drivers/pinctrl/pinctrl-thunderbay.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Intel Thunder Bay SOC pinctrl/GPIO driver
   4  *
   5  * Copyright (C) 2021 Intel Corporation
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/err.h>
  10 #include <linux/gpio/driver.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/irq.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_irq.h>
  18
  19 #include <linux/pinctrl/pinconf.h>
  20 #include <linux/pinctrl/pinconf-generic.h>
  21 #include <linux/pinctrl/pinctrl.h>
  22 #include <linux/pinctrl/pinmux.h>
  23
  24 #include <linux/platform_device.h>
  25 #include <linux/slab.h>
  26 #include <linux/spinlock.h>
  27
  28 #include "core.h"
  29 #include "pinconf.h"
  30 #include "pinctrl-utils.h"
  31 #include "pinmux.h"
  32
  33 /* Bit 0:2 and 4:6 should be used for mode selection */
  34 #define THB_GPIO_PINMUX_MODE_0                  0x00
  35 #define THB_GPIO_PINMUX_MODE_1                  0x11
  36 #define THB_GPIO_PINMUX_MODE_2                  0x22
  37 #define THB_GPIO_PINMUX_MODE_3                  0x33
  38 #define THB_GPIO_PINMUX_MODE_4                  0x44
  39
  40 #define THB_GPIO_PORT_SELECT_MASK               BIT(8)
  41 #define THB_GPIO_PAD_DIRECTION_MASK             BIT(10)
  42 #define THB_GPIO_SPU_MASK                       BIT(11)
  43 #define THB_GPIO_PULL_ENABLE_MASK               BIT(12)
  44 #define THB_GPIO_PULL_UP_MASK                   BIT(13)
  45 #define THB_GPIO_PULL_DOWN_MASK                 BIT(14)
  46 #define THB_GPIO_ENAQ_MASK                      BIT(15)
  47 /* bit 16-19: Drive Strength for the Pad */
  48 #define THB_GPIO_DRIVE_STRENGTH_MASK            (0xF0000)
  49 #define THB_GPIO_SLEW_RATE_MASK                 BIT(20)
  50 #define THB_GPIO_SCHMITT_TRIGGER_MASK           BIT(21)
  51
  52 #define THB_GPIO_REG_OFFSET(pin_num)                    ((pin_num) * (0x4))
  53 #define THB_MAX_MODE_SUPPORTED                          (5u)
  54 #define THB_MAX_NPINS_SUPPORTED                         (67u)
  55
  56 /* store Pin status */
  57 static u32 thb_pinx_status[THB_MAX_NPINS_SUPPORTED];
  58
  59 struct thunderbay_mux_desc {
  60         u8 mode;
  61         const char *name;
  62 };
  63
  64 #define THUNDERBAY_PIN_DESC(pin_number, pin_name, ...) {        \
  65         .number = pin_number,                           \
  66         .name = pin_name,                               \
  67         .drv_data = &(struct thunderbay_mux_desc[]) {   \
  68                         __VA_ARGS__, { } },             \
  69 }
  70
  71 #define THUNDERBAY_MUX(pin_mode, pin_function) {                \
  72         .mode = pin_mode,                               \
  73         .name = pin_function,                           \
  74 }
  75
  76 struct thunderbay_pin_soc {
  77         const struct pinctrl_pin_desc           *pins;
  78         unsigned int                            npins;
  79 };
  80
  81 /**
  82  * struct thunderbay_pinctrl - Intel Thunderbay pinctrl structure
  83  * @pctrl: Pointer to the pin controller device
  84  * @base0: First register base address
  85  * @dev: Pointer to the device structure
  86  * @chip: GPIO chip used by this pin controller
  87  * @soc: Pin control configuration data based on SoC
  88  * @ngroups: Number of pin groups available
  89  * @nfuncs: Number of pin functions available
  90  */
  91 struct thunderbay_pinctrl {
  92         struct pinctrl_dev              *pctrl;
  93         void __iomem                    *base0;
  94         struct device                   *dev;
  95         struct gpio_chip                chip;
  96         const struct thunderbay_pin_soc *soc;
  97         unsigned int                    ngroups;
  98         unsigned int                    nfuncs;
  99 };
 100
 101 static const struct pinctrl_pin_desc thunderbay_pins[] = {
 102         THUNDERBAY_PIN_DESC(0, "GPIO0",
 103                             THUNDERBAY_MUX(0X0, "I2C0_M0"),
 104                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 105                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 106                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 107                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 108         THUNDERBAY_PIN_DESC(1, "GPIO1",
 109                             THUNDERBAY_MUX(0X0, "I2C0_M0"),
 110                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 111                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 112                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 113                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 114         THUNDERBAY_PIN_DESC(2, "GPIO2",
 115                             THUNDERBAY_MUX(0X0, "I2C1_M0"),
 116                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 117                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 118                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 119                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 120         THUNDERBAY_PIN_DESC(3, "GPIO3",
 121                             THUNDERBAY_MUX(0X0, "I2C1_M0"),
 122                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 123                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 124                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 125                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 126         THUNDERBAY_PIN_DESC(4, "GPIO4",
 127                             THUNDERBAY_MUX(0X0, "I2C2_M0"),
 128                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 129                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 130                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 131                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 132         THUNDERBAY_PIN_DESC(5, "GPIO5",
 133                             THUNDERBAY_MUX(0X0, "I2C2_M0"),
 134                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 135                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 136                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 137                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 138         THUNDERBAY_PIN_DESC(6, "GPIO6",
 139                             THUNDERBAY_MUX(0X0, "I2C3_M0"),
 140                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 141                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 142                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 143                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 144         THUNDERBAY_PIN_DESC(7, "GPIO7",
 145                             THUNDERBAY_MUX(0X0, "I2C3_M0"),
 146                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 147                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 148                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 149                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 150         THUNDERBAY_PIN_DESC(8, "GPIO8",
 151                             THUNDERBAY_MUX(0X0, "I2C4_M0"),
 152                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 153                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 154                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 155                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 156         THUNDERBAY_PIN_DESC(9, "GPIO9",
 157                             THUNDERBAY_MUX(0X0, "I2C4_M0"),
 158                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 159                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 160                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 161                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 162         THUNDERBAY_PIN_DESC(10, "GPIO10",
 163                             THUNDERBAY_MUX(0X0, "UART0_M0"),
 164                             THUNDERBAY_MUX(0X1, "RT0_DSU_M1"),
 165                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 166                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 167                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 168         THUNDERBAY_PIN_DESC(11, "GPIO11",
 169                             THUNDERBAY_MUX(0X0, "UART0_M0"),
 170                             THUNDERBAY_MUX(0X1, "RT0_DSU_M1"),
 171                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 172                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 173                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 174         THUNDERBAY_PIN_DESC(12, "GPIO12",
 175                             THUNDERBAY_MUX(0X0, "UART0_M0"),
 176                             THUNDERBAY_MUX(0X1, "RT1_DSU_M1"),
 177                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 178                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 179                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 180         THUNDERBAY_PIN_DESC(13, "GPIO13",
 181                             THUNDERBAY_MUX(0X0, "UART0_M0"),
 182                             THUNDERBAY_MUX(0X1, "RT1_DSU_M1"),
 183                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 184                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 185                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 186         THUNDERBAY_PIN_DESC(14, "GPIO14",
 187                             THUNDERBAY_MUX(0X0, "UART1_M0"),
 188                             THUNDERBAY_MUX(0X1, "RT2_DSU_M1"),
 189                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 190                             THUNDERBAY_MUX(0X3, "TRIGGER_M3"),
 191                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 192         THUNDERBAY_PIN_DESC(15, "GPIO15",
 193                             THUNDERBAY_MUX(0X0, "UART1_M0"),
 194                             THUNDERBAY_MUX(0X1, "RT2_DSU_M1"),
 195                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 196                             THUNDERBAY_MUX(0X3, "TRIGGER_M3"),
 197                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 198         THUNDERBAY_PIN_DESC(16, "GPIO16",
 199                             THUNDERBAY_MUX(0X0, "UART1_M0"),
 200                             THUNDERBAY_MUX(0X1, "RT3_DSU_M1"),
 201                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 202                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 203                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 204         THUNDERBAY_PIN_DESC(17, "GPIO17",
 205                             THUNDERBAY_MUX(0X0, "UART1_M0"),
 206                             THUNDERBAY_MUX(0X1, "RT3_DSU_M1"),
 207                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 208                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 209                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 210         THUNDERBAY_PIN_DESC(18, "GPIO18",
 211                             THUNDERBAY_MUX(0X0, "SPI0_M0"),
 212                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 213                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 214                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 215                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 216         THUNDERBAY_PIN_DESC(19, "GPIO19",
 217                             THUNDERBAY_MUX(0X0, "SPI0_M0"),
 218                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 219                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 220                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 221                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 222         THUNDERBAY_PIN_DESC(20, "GPIO20",
 223                             THUNDERBAY_MUX(0X0, "SPI0_M0"),
 224                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 225                             THUNDERBAY_MUX(0X2, "TPIU_TRACE_M2"),
 226                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 227                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 228         THUNDERBAY_PIN_DESC(21, "GPIO21",
 229                             THUNDERBAY_MUX(0X0, "SPI0_M0"),
 230                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 231                             THUNDERBAY_MUX(0X2, "TPIU_TRACE_M2"),
 232                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 233                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 234         THUNDERBAY_PIN_DESC(22, "GPIO22",
 235                             THUNDERBAY_MUX(0X0, "SPI1_M0"),
 236                             THUNDERBAY_MUX(0X1, "EMPTY_M0"),
 237                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 238                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 239                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 240         THUNDERBAY_PIN_DESC(23, "GPIO23",
 241                             THUNDERBAY_MUX(0X0, "SPI1_M0"),
 242                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 243                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 244                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 245                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 246         THUNDERBAY_PIN_DESC(24, "GPIO24",
 247                             THUNDERBAY_MUX(0X0, "SPI1_M0"),
 248                             THUNDERBAY_MUX(0X1, "TPIU_TRACE_M1"),
 249                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 250                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 251                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 252         THUNDERBAY_PIN_DESC(25, "GPIO25",
 253                             THUNDERBAY_MUX(0X0, "SPI1_M0"),
 254                             THUNDERBAY_MUX(0X1, "TPIU_TRACE_M1"),
 255                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 256                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 257                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 258         THUNDERBAY_PIN_DESC(26, "GPIO26",
 259                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 260                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 261                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 262                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 263                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 264         THUNDERBAY_PIN_DESC(27, "GPIO27",
 265                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 266                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 267                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 268                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 269                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 270         THUNDERBAY_PIN_DESC(28, "GPIO28",
 271                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 272                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 273                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 274                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 275                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 276         THUNDERBAY_PIN_DESC(29, "GPIO29",
 277                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 278                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 279                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 280                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 281                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 282         THUNDERBAY_PIN_DESC(30, "GPIO30",
 283                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 284                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 285                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 286                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 287                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 288         THUNDERBAY_PIN_DESC(31, "GPIO31",
 289                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 290                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 291                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 292                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 293                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 294         THUNDERBAY_PIN_DESC(32, "GPIO32",
 295                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 296                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 297                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 298                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 299                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 300         THUNDERBAY_PIN_DESC(33, "GPIO33",
 301                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 302                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 303                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 304                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 305                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 306         THUNDERBAY_PIN_DESC(34, "GPIO34",
 307                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 308                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 309                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 310                             THUNDERBAY_MUX(0X3, "DIG_VIEW_0"),
 311                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 312         THUNDERBAY_PIN_DESC(35, "GPIO35",
 313                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 314                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 315                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 316                             THUNDERBAY_MUX(0X3, "DIG_VIEW_1"),
 317                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 318         THUNDERBAY_PIN_DESC(36, "GPIO36",
 319                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 320                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 321                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 322                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_0"),
 323                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 324         THUNDERBAY_PIN_DESC(37, "GPIO37",
 325                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 326                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 327                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 328                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_1"),
 329                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 330         THUNDERBAY_PIN_DESC(38, "GPIO38",
 331                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 332                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 333                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 334                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_2"),
 335                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 336         THUNDERBAY_PIN_DESC(39, "GPIO39",
 337                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 338                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 339                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 340                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_3"),
 341                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 342         THUNDERBAY_PIN_DESC(40, "GPIO40",
 343                             THUNDERBAY_MUX(0X0, "ETHER0_M0"),
 344                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 345                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 346                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 347                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 348         THUNDERBAY_PIN_DESC(41, "GPIO41",
 349                             THUNDERBAY_MUX(0X0, "POWER_INTERRUPT_MAX_PLATFORM_POWER_M0"),
 350                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 351                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 352                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 353                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 354         THUNDERBAY_PIN_DESC(42, "GPIO42",
 355                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 356                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 357                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 358                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 359                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 360         THUNDERBAY_PIN_DESC(43, "GPIO43",
 361                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 362                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 363                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 364                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 365                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 366         THUNDERBAY_PIN_DESC(44, "GPIO44",
 367                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 368                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 369                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 370                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 371                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 372         THUNDERBAY_PIN_DESC(45, "GPIO45",
 373                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 374                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 375                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 376                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 377                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 378         THUNDERBAY_PIN_DESC(46, "GPIO46",
 379                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 380                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 381                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 382                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 383                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 384         THUNDERBAY_PIN_DESC(47, "GPIO47",
 385                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 386                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 387                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 388                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 389                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 390         THUNDERBAY_PIN_DESC(48, "GPIO48",
 391                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 392                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 393                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 394                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 395                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 396         THUNDERBAY_PIN_DESC(49, "GPIO49",
 397                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 398                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 399                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 400                             THUNDERBAY_MUX(0X3, "DEBUG_M3"),
 401                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 402         THUNDERBAY_PIN_DESC(50, "GPIO50",
 403                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 404                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 405                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 406                             THUNDERBAY_MUX(0X3, "DIG_VIEW_0"),
 407                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 408         THUNDERBAY_PIN_DESC(51, "GPIO51",
 409                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 410                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 411                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 412                             THUNDERBAY_MUX(0X3, "DIG_VIEW_1"),
 413                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 414         THUNDERBAY_PIN_DESC(52, "GPIO52",
 415                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 416                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 417                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 418                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_0"),
 419                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 420         THUNDERBAY_PIN_DESC(53, "GPIO53",
 421                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 422                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 423                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 424                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_1"),
 425                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 426         THUNDERBAY_PIN_DESC(54, "GPIO54",
 427                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 428                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 429                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 430                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_2"),
 431                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 432         THUNDERBAY_PIN_DESC(55, "GPIO55",
 433                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 434                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 435                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 436                             THUNDERBAY_MUX(0X3, "CPR_IO_OUT_CLK_3"),
 437                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 438         THUNDERBAY_PIN_DESC(56, "GPIO56",
 439                             THUNDERBAY_MUX(0X0, "ETHER1_M0"),
 440                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 441                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 442                             THUNDERBAY_MUX(0X3, "POWER_INTERRUPT_ICCMAX_VDDD_M3"),
 443                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 444         THUNDERBAY_PIN_DESC(57, "GPIO57",
 445                             THUNDERBAY_MUX(0X0, "POWER_INTERRUPT_ICCMAX_VPU_M0"),
 446                             THUNDERBAY_MUX(0X1, "TPIU_DATA_M1"),
 447                             THUNDERBAY_MUX(0X2, "TPIU_DATA_M2"),
 448                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 449                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 450         THUNDERBAY_PIN_DESC(58, "GPIO58",
 451                             THUNDERBAY_MUX(0X0, "THERMTRIP_M0"),
 452                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 453                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 454                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 455                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 456         THUNDERBAY_PIN_DESC(59, "GPIO59",
 457                             THUNDERBAY_MUX(0X0, "THERMTRIP_M0"),
 458                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 459                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 460                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 461                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 462         THUNDERBAY_PIN_DESC(60, "GPIO60",
 463                             THUNDERBAY_MUX(0X0, "SMBUS_M0"),
 464                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 465                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 466                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 467                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 468         THUNDERBAY_PIN_DESC(61, "GPIO61",
 469                             THUNDERBAY_MUX(0X0, "SMBUS_M0"),
 470                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 471                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 472                             THUNDERBAY_MUX(0X3, "POWER_INTERRUPT_ICCMAX_VDDD_M3"),
 473                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 474         THUNDERBAY_PIN_DESC(62, "GPIO62",
 475                             THUNDERBAY_MUX(0X0, "PLATFORM_RESET_M0"),
 476                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 477                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 478                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 479                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 480         THUNDERBAY_PIN_DESC(63, "GPIO63",
 481                             THUNDERBAY_MUX(0X0, "PLATFORM_RESET_M0"),
 482                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 483                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 484                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 485                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 486         THUNDERBAY_PIN_DESC(64, "GPIO64",
 487                             THUNDERBAY_MUX(0X0, "PLATFORM_SHUTDOWN_M0"),
 488                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 489                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 490                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 491                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 492         THUNDERBAY_PIN_DESC(65, "GPIO65",
 493                             THUNDERBAY_MUX(0X0, "PLATFORM_SHUTDOWN_M0"),
 494                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 495                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 496                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 497                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 498         THUNDERBAY_PIN_DESC(66, "GPIO66",
 499                             THUNDERBAY_MUX(0X0, "POWER_INTERRUPT_ICCMAX_MEDIA_M0"),
 500                             THUNDERBAY_MUX(0X1, "EMPTY_M1"),
 501                             THUNDERBAY_MUX(0X2, "EMPTY_M2"),
 502                             THUNDERBAY_MUX(0X3, "EMPTY_M3"),
 503                             THUNDERBAY_MUX(0X4, "GPIO_M4")),
 504 };
 505
 506 static const struct thunderbay_pin_soc thunderbay_data = {
 507         .pins   = thunderbay_pins,
 508         .npins  = ARRAY_SIZE(thunderbay_pins),
 509 };
 510
 511 static u32 thb_gpio_read_reg(struct gpio_chip *chip, unsigned int pinnr)
 512 {
 513         struct thunderbay_pinctrl *tpc = gpiochip_get_data(chip);
 514
 515         return readl(tpc->base0 + THB_GPIO_REG_OFFSET(pinnr));
 516 }
 517
 518 static u32 thb_gpio_write_reg(struct gpio_chip *chip, unsigned int pinnr, u32 value)
 519 {
 520         struct thunderbay_pinctrl *tpc = gpiochip_get_data(chip);
 521
 522         writel(value, (tpc->base0 + THB_GPIO_REG_OFFSET(pinnr)));
 523         return 0;
 524 }
 525
 526 static int thb_read_gpio_data(struct gpio_chip *chip, unsigned int offset, unsigned int pad_dir)
 527 {
 528         int data_offset;
 529         u32 data_reg;
 530
 531         /* as per GPIO Spec = pad_dir 0:input, 1:output */
 532         data_offset = 0x2000u + (offset / 32);
 533         if (!pad_dir)
 534                 data_offset += 4;
 535         data_reg = thb_gpio_read_reg(chip, data_offset);
 536
 537         return data_reg & BIT(offset % 32);
 538 }
 539
 540 static int thb_write_gpio_data(struct gpio_chip *chip, unsigned int offset, unsigned int value)
 541 {
 542         int data_offset;
 543         u32 data_reg;
 544
 545         data_offset = 0x2000u + (offset / 32);
 546
 547         data_reg = thb_gpio_read_reg(chip, data_offset);
 548
 549         if (value > 0)
 550                 data_reg |= BIT(offset % 32);
 551         else
 552                 data_reg &= ~BIT(offset % 32);
 553
 554         return thb_gpio_write_reg(chip, data_offset, data_reg);
 555 }
 556
 557 static int thunderbay_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
 558 {
 559         u32 reg = thb_gpio_read_reg(chip, offset);
 560
 561         /* Return direction only if configured as GPIO else negative error */
 562         if (reg & THB_GPIO_PORT_SELECT_MASK)
 563                 return !(reg & THB_GPIO_PAD_DIRECTION_MASK);
 564         return -EINVAL;
 565 }
 566
 567 static int thunderbay_gpio_set_direction_input(struct gpio_chip *chip, unsigned int offset)
 568 {
 569         u32 reg = thb_gpio_read_reg(chip, offset);
 570
 571         /* set pin as input only if it is GPIO else error */
 572         if (reg & THB_GPIO_PORT_SELECT_MASK) {
 573                 reg &= (~THB_GPIO_PAD_DIRECTION_MASK);
 574                 thb_gpio_write_reg(chip, offset, reg);
 575                 return 0;
 576         }
 577         return -EINVAL;
 578 }
 579
 580 static void thunderbay_gpio_set_value(struct gpio_chip *chip, unsigned int offset, int value)
 581 {
 582         u32 reg = thb_gpio_read_reg(chip, offset);
 583
 584         /* update pin value only if it is GPIO-output else error */
 585         if ((reg & THB_GPIO_PORT_SELECT_MASK) && (reg & THB_GPIO_PAD_DIRECTION_MASK))
 586                 thb_write_gpio_data(chip, offset, value);
 587 }
 588
 589 static int thunderbay_gpio_set_direction_output(struct gpio_chip *chip,
 590                                                 unsigned int offset, int value)
 591 {
 592         u32 reg = thb_gpio_read_reg(chip, offset);
 593
 594         /* set pin as output only if it is GPIO else error */
 595         if (reg & THB_GPIO_PORT_SELECT_MASK) {
 596                 reg |= THB_GPIO_PAD_DIRECTION_MASK;
 597                 thb_gpio_write_reg(chip, offset, reg);
 598                 thunderbay_gpio_set_value(chip, offset, value);
 599                 return 0;
 600         }
 601         return -EINVAL;
 602 }
 603
 604 static int thunderbay_gpio_get_value(struct gpio_chip *chip, unsigned int offset)
 605 {
 606         u32 reg = thb_gpio_read_reg(chip, offset);
 607         int gpio_dir = 0;
 608
 609         /* Read pin value only if it is GPIO else error */
 610         if (reg & THB_GPIO_PORT_SELECT_MASK) {
 611                 /* 0=in, 1=out */
 612                 gpio_dir = (reg & THB_GPIO_PAD_DIRECTION_MASK) > 0;
 613
 614                 /* Returns negative value when pin is configured as PORT */
 615                 return thb_read_gpio_data(chip, offset, gpio_dir);
 616         }
 617         return -EINVAL;
 618 }
 619
 620 static int thunderbay_gpiochip_probe(struct thunderbay_pinctrl *tpc)
 621 {
 622         struct gpio_chip *chip = &tpc->chip;
 623         int ret;
 624
 625         chip->label             = dev_name(tpc->dev);
 626         chip->parent            = tpc->dev;
 627         chip->request           = gpiochip_generic_request;
 628         chip->free              = gpiochip_generic_free;
 629         chip->get_direction     = thunderbay_gpio_get_direction;
 630         chip->direction_input   = thunderbay_gpio_set_direction_input;
 631         chip->direction_output  = thunderbay_gpio_set_direction_output;
 632         chip->get               = thunderbay_gpio_get_value;
 633         chip->set               = thunderbay_gpio_set_value;
 634         chip->set_config        = gpiochip_generic_config;
 635         /* identifies the first GPIO number handled by this chip; or,
 636          * if negative during registration, requests dynamic ID allocation.
 637          * Please pass -1 as base to let gpiolib select the chip base in all possible cases.
 638          * We want to get rid of the static GPIO number space in the long run.
 639          */
 640         chip->base              = -1;
 641         /* Number of GPIOs handled by this controller; the last GPIO handled is (base + ngpio - 1)*/
 642         chip->ngpio             = THB_MAX_NPINS_SUPPORTED;
 643
 644         /* Register/add Thunder Bay GPIO chip with Linux framework */
 645         ret = gpiochip_add_data(chip, tpc);
 646         if (ret)
 647                 dev_err(tpc->dev, "Failed to add gpiochip\n");
 648         return ret;
 649 }
 650
 651 static int thunderbay_request_gpio(struct pinctrl_dev *pctldev,
 652                                    struct pinctrl_gpio_range *range,
 653                                    unsigned int pin)
 654 {
 655         struct thunderbay_pinctrl *tpc = pinctrl_dev_get_drvdata(pctldev);
 656         struct gpio_chip *chip = &tpc->chip;
 657         u32 reg = 0;
 658
 659         if (thb_pinx_status[pin] == 0u) {
 660                 reg = thb_gpio_read_reg(chip, pin);
 661                 /* Updates PIN configuration as GPIO and sets GPIO to MODE-4*/
 662                 reg |= (THB_GPIO_PORT_SELECT_MASK | THB_GPIO_PINMUX_MODE_4);
 663                 thb_gpio_write_reg(chip, pin, reg);
 664
 665                 /* update pin status as busy */
 666                 thb_pinx_status[pin] = 1u;
 667
 668                 return 0;
 669         }
 670         return -EINVAL;
 671 }
 672
 673 static void thunderbay_free_gpio(struct pinctrl_dev *pctldev,
 674                                  struct pinctrl_gpio_range *range,
 675                                  unsigned int pin)
 676 {
 677         struct thunderbay_pinctrl *tpc = pinctrl_dev_get_drvdata(pctldev);
 678         struct gpio_chip *chip = &tpc->chip;
 679         u32 reg = 0;
 680
 681         if (thb_pinx_status[pin] == 1u) {
 682                 reg = thb_gpio_read_reg(chip, pin);
 683
 684                 /* Updates PIN configuration from GPIO to PORT */
 685                 reg &= (~THB_GPIO_PORT_SELECT_MASK);
 686
 687                 /* Change Port/gpio mode to default mode-0 */
 688                 reg &= (~THB_GPIO_PINMUX_MODE_4);
 689
 690                 thb_gpio_write_reg(chip, pin, reg);
 691
 692                 /* update pin status as free */
 693                 thb_pinx_status[pin] = 0u;
 694         }
 695 }
 696
 697 static int thb_pinctrl_set_mux(struct pinctrl_dev *pctldev,
 698                                unsigned int func_select, unsigned int group_select)
 699 {
 700         struct thunderbay_pinctrl *tpc = pinctrl_dev_get_drvdata(pctldev);
 701         struct gpio_chip *chip = &tpc->chip;
 702         struct function_desc *function;
 703         unsigned int i, pin_mode;
 704         struct group_desc *group;
 705         int ret = -EINVAL;
 706         u32 reg = 0u;
 707
 708         group = pinctrl_generic_get_group(pctldev, group_select);
 709         if (!group)
 710                 return -EINVAL;
 711
 712         function = pinmux_generic_get_function(pctldev, func_select);
 713         if (!function)
 714                 return -EINVAL;
 715
 716         pin_mode = *(unsigned int *)(function->data);
 717
 718         /* Change modes for pins in the selected group */
 719         for (i = 0; i < group->num_pins; i++) {
 720                 reg = thb_gpio_read_reg(chip, group->pins[i]);
 721
 722                 switch (pin_mode) {
 723                 case 0u:
 724                         reg |= THB_GPIO_PINMUX_MODE_0;
 725                         break;
 726                 case 1u:
 727                         reg |= THB_GPIO_PINMUX_MODE_1;
 728                         break;
 729                 case 2u:
 730                         reg |= THB_GPIO_PINMUX_MODE_2;
 731                         break;
 732                 case 3u:
 733                         reg |= THB_GPIO_PINMUX_MODE_3;
 734                         break;
 735                 case 4u:
 736                         reg |= THB_GPIO_PINMUX_MODE_4;
 737                         break;
 738                 default:
 739                         return -EINVAL;
 740                 }
 741
 742                 ret = thb_gpio_write_reg(chip, group->pins[i], reg);
 743                 if (~ret) {
 744                         /* update pin status as busy */
 745                         thb_pinx_status[group->pins[i]] = 1u;
 746                 }
 747         }
 748         return ret;
 749 }
 750
 751 static int thunderbay_build_groups(struct thunderbay_pinctrl *tpc)
 752 {
 753         struct group_desc *thunderbay_groups;
 754         int i;
 755
 756         tpc->ngroups = tpc->soc->npins;
 757         thunderbay_groups = devm_kcalloc(tpc->dev, tpc->ngroups,
 758                                          sizeof(*thunderbay_groups), GFP_KERNEL);
 759         if (!thunderbay_groups)
 760                 return -ENOMEM;
 761
 762         for (i = 0; i < tpc->ngroups; i++) {
 763                 struct group_desc *group = thunderbay_groups + i;
 764                 const struct pinctrl_pin_desc *pin_info = thunderbay_pins + i;
 765
 766                 group->name = pin_info->name;
 767                 group->pins = (int *)&pin_info->number;
 768                 pinctrl_generic_add_group(tpc->pctrl, group->name,
 769                                           group->pins, 1, NULL);
 770         }
 771         return 0;
 772 }
 773
 774 static int thunderbay_add_functions(struct thunderbay_pinctrl *tpc, struct function_desc *funcs)
 775 {
 776         int i;
 777
 778         /* Assign the groups for each function */
 779         for (i = 0; i < tpc->nfuncs; i++) {
 780                 struct function_desc *func = &funcs[i];
 781                 const char **group_names;
 782                 unsigned int grp_idx = 0;
 783                 int j;
 784
 785                 group_names = devm_kcalloc(tpc->dev, func->num_group_names,
 786                                            sizeof(*group_names), GFP_KERNEL);
 787                 if (!group_names)
 788                         return -ENOMEM;
 789
 790                 for (j = 0; j < tpc->soc->npins; j++) {
 791                         const struct pinctrl_pin_desc *pin_info = &thunderbay_pins[j];
 792                         struct thunderbay_mux_desc *pin_mux;
 793
 794                         for (pin_mux = pin_info->drv_data; pin_mux->name; pin_mux++) {
 795                                 if (!strcmp(pin_mux->name, func->name))
 796                                         group_names[grp_idx++] = pin_info->name;
 797                         }
 798                 }
 799
 800                 func->group_names = group_names;
 801         }
 802
 803         /* Add all functions */
 804         for (i = 0; i < tpc->nfuncs; i++) {
 805                 pinmux_generic_add_function(tpc->pctrl,
 806                                             funcs[i].name,
 807                                             funcs[i].group_names,
 808                                             funcs[i].num_group_names,
 809                                             funcs[i].data);
 810         }
 811
 812         return 0;
 813 }
 814
 815 static int thunderbay_build_functions(struct thunderbay_pinctrl *tpc)
 816 {
 817         struct function_desc *thunderbay_funcs;
 818         void *ptr;
 819         int pin;
 820         int ret;
 821
 822         /*
 823          * Allocate maximum possible number of functions. Assume every pin
 824          * being part of 8 (hw maximum) globally unique muxes.
 825          */
 826         tpc->nfuncs = 0;
 827         thunderbay_funcs = kcalloc(tpc->soc->npins * 8,
 828                                    sizeof(*thunderbay_funcs), GFP_KERNEL);
 829         if (!thunderbay_funcs)
 830                 return -ENOMEM;
 831
 832         /* Setup 1 function for each unique mux */
 833         for (pin = 0; pin < tpc->soc->npins; pin++) {
 834                 const struct pinctrl_pin_desc *pin_info = thunderbay_pins + pin;
 835                 struct thunderbay_mux_desc *pin_mux;
 836
 837                 for (pin_mux = pin_info->drv_data; pin_mux->name; pin_mux++) {
 838                         struct function_desc *func;
 839
 840                         /* Check if we already have function for this mux */
 841                         for (func = thunderbay_funcs; func->name; func++) {
 842                                 if (!strcmp(pin_mux->name, func->name)) {
 843                                         func->num_group_names++;
 844                                         break;
 845                                 }
 846                         }
 847
 848                         if (!func->name) {
 849                                 func->name = pin_mux->name;
 850                                 func->num_group_names = 1;
 851                                 func->data = (int *)&pin_mux->mode;
 852                                 tpc->nfuncs++;
 853                         }
 854                 }
 855         }
 856
 857         /* Reallocate memory based on actual number of functions */
 858         ptr = krealloc(thunderbay_funcs,
 859                        tpc->nfuncs * sizeof(*thunderbay_funcs), GFP_KERNEL);
 860         if (!ptr)
 861                 return -ENOMEM;
 862
 863         thunderbay_funcs = ptr;
 864         ret = thunderbay_add_functions(tpc, thunderbay_funcs);
 865
 866         kfree(thunderbay_funcs);
 867         return ret;
 868 }
 869
 870 static int thunderbay_pinconf_set_tristate(struct thunderbay_pinctrl *tpc,
 871                                            unsigned int pin, u32 config)
 872 {
 873         struct gpio_chip *chip = &tpc->chip;
 874         u32 reg;
 875
 876         reg = thb_gpio_read_reg(chip, pin);
 877         if (config > 0)
 878                 reg |= THB_GPIO_ENAQ_MASK;
 879         else
 880                 reg &= ~THB_GPIO_ENAQ_MASK;
 881
 882         return thb_gpio_write_reg(chip, pin, reg);
 883 }
 884
 885 static int thunderbay_pinconf_get_tristate(struct thunderbay_pinctrl *tpc,
 886                                            unsigned int pin, u32 *config)
 887 {
 888         struct gpio_chip *chip = &tpc->chip;
 889         u32 reg;
 890
 891         reg = thb_gpio_read_reg(chip, pin);
 892         *config = (reg & THB_GPIO_ENAQ_MASK) > 0;
 893
 894         return 0;
 895 }
 896
 897 static int thunderbay_pinconf_set_pulldown(struct thunderbay_pinctrl *tpc,
 898                                            unsigned int pin, u32 config)
 899 {
 900         struct gpio_chip *chip = &tpc->chip;
 901         u32 reg;
 902
 903         reg = thb_gpio_read_reg(chip, pin);
 904         if (config > 0)
 905                 reg |= THB_GPIO_PULL_DOWN_MASK;
 906         else
 907                 reg &= ~THB_GPIO_PULL_DOWN_MASK;
 908
 909         return thb_gpio_write_reg(chip, pin, reg);
 910 }
 911
 912 static int thunderbay_pinconf_get_pulldown(struct thunderbay_pinctrl *tpc,
 913                                            unsigned int pin, u32 *config)
 914 {
 915         struct gpio_chip *chip = &tpc->chip;
 916         u32 reg = 0;
 917
 918         reg = thb_gpio_read_reg(chip, pin);
 919         *config = ((reg & THB_GPIO_PULL_DOWN_MASK) > 0) ? 1 : 0;
 920
 921         return 0;
 922 }
 923
 924 static int thunderbay_pinconf_set_pullup(struct thunderbay_pinctrl *tpc,
 925                                          unsigned int pin, u32 config)
 926 {
 927         struct gpio_chip *chip = &tpc->chip;
 928         u32 reg;
 929
 930         reg = thb_gpio_read_reg(chip, pin);
 931         if (config > 0)
 932                 reg &= ~THB_GPIO_PULL_UP_MASK;
 933         else
 934                 reg |= THB_GPIO_PULL_UP_MASK;
 935
 936         return thb_gpio_write_reg(chip, pin, reg);
 937 }
 938
 939 static int thunderbay_pinconf_get_pullup(struct thunderbay_pinctrl *tpc,
 940                                          unsigned int pin, u32 *config)
 941 {
 942         struct gpio_chip *chip = &tpc->chip;
 943         u32 reg;
 944
 945         reg = thb_gpio_read_reg(chip, pin);
 946         *config = ((reg & THB_GPIO_PULL_UP_MASK) == 0) ? 1 : 0;
 947
 948         return 0;
 949 }
 950
 951 static int thunderbay_pinconf_set_opendrain(struct thunderbay_pinctrl *tpc,
 952                                             unsigned int pin, u32 config)
 953 {
 954         struct gpio_chip *chip = &tpc->chip;
 955         u32 reg;
 956
 957         reg = thb_gpio_read_reg(chip, pin);
 958         if (config > 0)
 959                 reg &= ~THB_GPIO_PULL_ENABLE_MASK;
 960         else
 961                 reg |= THB_GPIO_PULL_ENABLE_MASK;
 962
 963         return thb_gpio_write_reg(chip, pin, reg);
 964 }
 965
 966 static int thunderbay_pinconf_get_opendrain(struct thunderbay_pinctrl *tpc,
 967                                             unsigned int pin, u32 *config)
 968 {
 969         struct gpio_chip *chip = &tpc->chip;
 970         u32 reg;
 971
 972         reg = thb_gpio_read_reg(chip, pin);
 973         *config = ((reg & THB_GPIO_PULL_ENABLE_MASK) == 0) ? 1 : 0;
 974
 975         return 0;
 976 }
 977
 978 static int thunderbay_pinconf_set_pushpull(struct thunderbay_pinctrl *tpc,
 979                                            unsigned int pin, u32 config)
 980 {
 981         struct gpio_chip *chip = &tpc->chip;
 982         u32 reg;
 983
 984         reg = thb_gpio_read_reg(chip, pin);
 985         if (config > 0)
 986                 reg |= THB_GPIO_PULL_ENABLE_MASK;
 987         else
 988                 reg &= ~THB_GPIO_PULL_ENABLE_MASK;
 989
 990         return thb_gpio_write_reg(chip, pin, reg);
 991 }
 992
 993 static int thunderbay_pinconf_get_pushpull(struct thunderbay_pinctrl *tpc,
 994                                            unsigned int pin, u32 *config)
 995 {
 996         struct gpio_chip *chip = &tpc->chip;
 997         u32 reg;
 998
 999         reg = thb_gpio_read_reg(chip, pin);
1000         *config = ((reg & THB_GPIO_PULL_ENABLE_MASK) > 0) ? 1 : 0;
1001
1002         return 0;
1003 }
1004
1005 static int thunderbay_pinconf_set_drivestrength(struct thunderbay_pinctrl *tpc,
1006                                                 unsigned int pin, u32 config)
1007 {
1008         struct gpio_chip *chip = &tpc->chip;
1009         u32 reg;
1010
1011         reg = thb_gpio_read_reg(chip, pin);
1012
1013         /* Drive Strength: 0x0 to 0xF */
1014         if (config <= 0xF) {
1015                 reg = (reg | config);
1016                 return thb_gpio_write_reg(chip, pin, reg);
1017         }
1018
1019         return -EINVAL;
1020 }
1021
1022 static int thunderbay_pinconf_get_drivestrength(struct thunderbay_pinctrl *tpc,
1023                                                 unsigned int pin, u32 *config)
1024 {
1025         struct gpio_chip *chip = &tpc->chip;
1026         u32 reg;
1027
1028         reg = thb_gpio_read_reg(chip, pin);
1029         reg = (reg & THB_GPIO_DRIVE_STRENGTH_MASK) >> 16;
1030         *config = (reg > 0) ? reg : 0;
1031
1032         return 0;
1033 }
1034
1035 static int thunderbay_pinconf_set_schmitt(struct thunderbay_pinctrl *tpc,
1036                                           unsigned int pin, u32 config)
1037 {
1038         struct gpio_chip *chip = &tpc->chip;
1039         u32 reg;
1040
1041         reg = thb_gpio_read_reg(chip, pin);
1042         if (config > 0)
1043                 reg |= THB_GPIO_SCHMITT_TRIGGER_MASK;
1044         else
1045                 reg &= ~THB_GPIO_SCHMITT_TRIGGER_MASK;
1046
1047         return thb_gpio_write_reg(chip, pin, reg);
1048 }
1049
1050 static int thunderbay_pinconf_get_schmitt(struct thunderbay_pinctrl *tpc,
1051                                           unsigned int pin, u32 *config)
1052 {
1053         struct gpio_chip *chip = &tpc->chip;
1054         u32 reg;
1055
1056         reg = thb_gpio_read_reg(chip, pin);
1057         *config = ((reg & THB_GPIO_SCHMITT_TRIGGER_MASK) > 0) ? 1 : 0;
1058
1059         return 0;
1060 }
1061
1062 static int thunderbay_pinconf_set_slew_rate(struct thunderbay_pinctrl *tpc,
1063                                             unsigned int pin, u32 config)
1064 {
1065         struct gpio_chip *chip = &tpc->chip;
1066         u32 reg = 0;
1067
1068         reg = thb_gpio_read_reg(chip, pin);
1069         if (config > 0)
1070                 reg |= THB_GPIO_SLEW_RATE_MASK;
1071         else
1072                 reg &= ~THB_GPIO_SLEW_RATE_MASK;
1073
1074         return thb_gpio_write_reg(chip, pin, reg);
1075 }
1076
1077 static int thunderbay_pinconf_get_slew_rate(struct thunderbay_pinctrl *tpc,
1078                                             unsigned int pin, u32 *config)
1079 {
1080         struct gpio_chip *chip = &tpc->chip;
1081         u32 reg;
1082
1083         reg = thb_gpio_read_reg(chip, pin);
1084         *config = ((reg & THB_GPIO_SLEW_RATE_MASK) > 0) ? 1 : 0;
1085
1086         return 0;
1087 }
1088
1089 static int thunderbay_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
1090                                   unsigned long *config)
1091 {
1092         struct thunderbay_pinctrl *tpc = pinctrl_dev_get_drvdata(pctldev);
1093         enum pin_config_param param = pinconf_to_config_param(*config);
1094         u32 arg;
1095         int ret;
1096
1097         switch (param) {
1098         case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1099                 ret = thunderbay_pinconf_get_tristate(tpc, pin, &arg);
1100                 break;
1101
1102         case PIN_CONFIG_BIAS_PULL_DOWN:
1103                 ret = thunderbay_pinconf_get_pulldown(tpc, pin, &arg);
1104                 break;
1105
1106         case PIN_CONFIG_BIAS_PULL_UP:
1107                 ret = thunderbay_pinconf_get_pullup(tpc, pin, &arg);
1108                 break;
1109
1110         case PIN_CONFIG_DRIVE_OPEN_DRAIN:
1111                 ret = thunderbay_pinconf_get_opendrain(tpc, pin, &arg);
1112                 break;
1113
1114         case PIN_CONFIG_DRIVE_PUSH_PULL:
1115                 ret = thunderbay_pinconf_get_pushpull(tpc, pin, &arg);
1116                 break;
1117
1118         case PIN_CONFIG_DRIVE_STRENGTH:
1119                 ret = thunderbay_pinconf_get_drivestrength(tpc, pin, &arg);
1120                 break;
1121
1122         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1123                 ret = thunderbay_pinconf_get_schmitt(tpc, pin, &arg);
1124                 break;
1125
1126         case PIN_CONFIG_SLEW_RATE:
1127                 ret = thunderbay_pinconf_get_slew_rate(tpc, pin, &arg);
1128                 break;
1129
1130         default:
1131                 return -ENOTSUPP;
1132         }
1133
1134         *config = pinconf_to_config_packed(param, arg);
1135
1136         return ret;
1137 }
1138
1139 static int thunderbay_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
1140                                   unsigned long *configs, unsigned int num_configs)
1141 {
1142         struct thunderbay_pinctrl *tpc = pinctrl_dev_get_drvdata(pctldev);
1143         enum pin_config_param param;
1144         unsigned int pinconf;
1145         int ret = 0;
1146         u32 arg;
1147
1148         for (pinconf = 0; pinconf < num_configs; pinconf++) {
1149                 param = pinconf_to_config_param(configs[pinconf]);
1150                 arg = pinconf_to_config_argument(configs[pinconf]);
1151
1152                 switch (param) {
1153                 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1154                         ret = thunderbay_pinconf_set_tristate(tpc, pin, arg);
1155                         break;
1156
1157                 case PIN_CONFIG_BIAS_PULL_DOWN:
1158                         ret = thunderbay_pinconf_set_pulldown(tpc, pin, arg);
1159                         break;
1160
1161                 case PIN_CONFIG_BIAS_PULL_UP:
1162                         ret = thunderbay_pinconf_set_pullup(tpc, pin, arg);
1163                         break;
1164
1165                 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
1166                         ret = thunderbay_pinconf_set_opendrain(tpc, pin, arg);
1167                         break;
1168
1169                 case PIN_CONFIG_DRIVE_PUSH_PULL:
1170                         ret = thunderbay_pinconf_set_pushpull(tpc, pin, arg);
1171                         break;
1172
1173                 case PIN_CONFIG_DRIVE_STRENGTH:
1174                         ret = thunderbay_pinconf_set_drivestrength(tpc, pin, arg);
1175                         break;
1176
1177                 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1178                         ret = thunderbay_pinconf_set_schmitt(tpc, pin, arg);
1179                         break;
1180
1181                 case PIN_CONFIG_SLEW_RATE:
1182                         ret = thunderbay_pinconf_set_slew_rate(tpc, pin, arg);
1183                         break;
1184
1185                 default:
1186                         return -ENOTSUPP;
1187                 }
1188         }
1189         return ret;
1190 }
1191
1192 static const struct pinctrl_ops thunderbay_pctlops = {
1193         .get_groups_count = pinctrl_generic_get_group_count,
1194         .get_group_name   = pinctrl_generic_get_group_name,
1195         .get_group_pins   = pinctrl_generic_get_group_pins,
1196         .dt_node_to_map   = pinconf_generic_dt_node_to_map_all,
1197         .dt_free_map      = pinconf_generic_dt_free_map,
1198 };
1199
1200 static const struct pinmux_ops thunderbay_pmxops = {
1201         .get_functions_count    = pinmux_generic_get_function_count,
1202         .get_function_name      = pinmux_generic_get_function_name,
1203         .get_function_groups    = pinmux_generic_get_function_groups,
1204         .set_mux                = thb_pinctrl_set_mux,
1205         .gpio_request_enable    = thunderbay_request_gpio,
1206         .gpio_disable_free      = thunderbay_free_gpio,
1207 };
1208
1209 static const struct pinconf_ops thunderbay_confops = {
1210         .is_generic             = true,
1211         .pin_config_get         = thunderbay_pinconf_get,
1212         .pin_config_set         = thunderbay_pinconf_set,
1213 };
1214
1215 static struct pinctrl_desc thunderbay_pinctrl_desc = {
1216         .name           = "thunderbay-pinmux",
1217         .pctlops        = &thunderbay_pctlops,
1218         .pmxops         = &thunderbay_pmxops,
1219         .confops        = &thunderbay_confops,
1220         .owner          = THIS_MODULE,
1221 };
1222
1223 static const struct of_device_id thunderbay_pinctrl_match[] = {
1224         {
1225                 .compatible = "intel,thunderbay-pinctrl",
1226                 .data = &thunderbay_data
1227         },
1228         {}
1229 };
1230
1231 static int thunderbay_pinctrl_probe(struct platform_device *pdev)
1232 {
1233         const struct of_device_id *of_id;
1234         struct device *dev = &pdev->dev;
1235         struct thunderbay_pinctrl *tpc;
1236         int ret;
1237
1238         of_id = of_match_node(thunderbay_pinctrl_match, pdev->dev.of_node);
1239         if (!of_id)
1240                 return -ENODEV;
1241
1242         tpc = devm_kzalloc(dev, sizeof(*tpc), GFP_KERNEL);
1243         if (!tpc)
1244                 return -ENOMEM;
1245
1246         tpc->dev = dev;
1247         tpc->soc = of_id->data;
1248
1249         tpc->base0 = devm_platform_ioremap_resource(pdev, 0);
1250         if (IS_ERR(tpc->base0))
1251                 return PTR_ERR(tpc->base0);
1252
1253         thunderbay_pinctrl_desc.pins = tpc->soc->pins;
1254         thunderbay_pinctrl_desc.npins = tpc->soc->npins;
1255
1256         /* Register pinctrl */
1257         tpc->pctrl = devm_pinctrl_register(dev, &thunderbay_pinctrl_desc, tpc);
1258         if (IS_ERR(tpc->pctrl))
1259                 return PTR_ERR(tpc->pctrl);
1260
1261         /* Setup pinmux groups */
1262         ret = thunderbay_build_groups(tpc);
1263         if (ret)
1264                 return ret;
1265
1266         /* Setup pinmux functions */
1267         ret = thunderbay_build_functions(tpc);
1268         if (ret)
1269                 return ret;
1270
1271         /* Setup GPIO */
1272         ret = thunderbay_gpiochip_probe(tpc);
1273         if (ret < 0)
1274                 return ret;
1275
1276         platform_set_drvdata(pdev, tpc);
1277
1278         return 0;
1279 }
1280
1281 static int thunderbay_pinctrl_remove(struct platform_device *pdev)
1282 {
1283         /* thunderbay_pinctrl_remove function to clear the assigned memory */
1284         return 0;
1285 }
1286
1287 static struct platform_driver thunderbay_pinctrl_driver = {
1288         .driver = {
1289                 .name = "thunderbay-pinctrl",
1290                 .of_match_table = thunderbay_pinctrl_match,
1291         },
1292         .probe = thunderbay_pinctrl_probe,
1293         .remove = thunderbay_pinctrl_remove,
1294 };
1295
1296 builtin_platform_driver(thunderbay_pinctrl_driver);
1297
1298 MODULE_AUTHOR("Lakshmi Sowjanya D <lakshmi.sowjanya.d@intel.com>");
1299 MODULE_AUTHOR("Kiran Kumar S <kiran.kumar1.s@intel.com>");
1300 MODULE_DESCRIPTION("Intel Thunder Bay Pinctrl/GPIO Driver");
1301 MODULE_LICENSE("GPL v2");