drivers/pinctrl/pinctrl-lpc18xx.c

   1 /*
   2  * Pinctrl driver for NXP LPC18xx/LPC43xx System Control Unit (SCU)
   3  *
   4  * Copyright (C) 2015 Joachim Eastwood <manabian@gmail.com>
   5  *
   6  * This file is licensed under the terms of the GNU General Public
   7  * License version 2. This program is licensed "as is" without any
   8  * warranty of any kind, whether express or implied.
   9  */
  10
  11 #include <linux/bitops.h>
  12 #include <linux/clk.h>
  13 #include <linux/io.h>
  14 #include <linux/init.h>
  15 #include <linux/of.h>
  16 #include <linux/of_device.h>
  17 #include <linux/pinctrl/pinctrl.h>
  18 #include <linux/pinctrl/pinmux.h>
  19 #include <linux/pinctrl/pinconf-generic.h>
  20
  21 #include "core.h"
  22 #include "pinctrl-utils.h"
  23
  24 /* LPC18XX SCU analog function registers */
  25 #define LPC18XX_SCU_REG_ENAIO0          0xc88
  26 #define LPC18XX_SCU_REG_ENAIO1          0xc8c
  27 #define LPC18XX_SCU_REG_ENAIO2          0xc90
  28 #define LPC18XX_SCU_REG_ENAIO2_DAC      BIT(0)
  29
  30 /* LPC18XX SCU pin register definitions */
  31 #define LPC18XX_SCU_PIN_MODE_MASK       0x7
  32 #define LPC18XX_SCU_PIN_EPD             BIT(3)
  33 #define LPC18XX_SCU_PIN_EPUN            BIT(4)
  34 #define LPC18XX_SCU_PIN_EHS             BIT(5)
  35 #define LPC18XX_SCU_PIN_EZI             BIT(6)
  36 #define LPC18XX_SCU_PIN_ZIF             BIT(7)
  37 #define LPC18XX_SCU_PIN_EHD_MASK        0x300
  38 #define LPC18XX_SCU_PIN_EHD_POS         8
  39
  40 #define LPC18XX_SCU_USB1_EPD            BIT(2)
  41 #define LPC18XX_SCU_USB1_EPWR           BIT(4)
  42
  43 #define LPC18XX_SCU_I2C0_EFP            BIT(0)
  44 #define LPC18XX_SCU_I2C0_EHD            BIT(2)
  45 #define LPC18XX_SCU_I2C0_EZI            BIT(3)
  46 #define LPC18XX_SCU_I2C0_ZIF            BIT(7)
  47 #define LPC18XX_SCU_I2C0_SCL_SHIFT      0
  48 #define LPC18XX_SCU_I2C0_SDA_SHIFT      8
  49
  50 #define LPC18XX_SCU_FUNC_PER_PIN        8
  51
  52 /* LPC18XX SCU pin interrupt select registers */
  53 #define LPC18XX_SCU_PINTSEL0            0xe00
  54 #define LPC18XX_SCU_PINTSEL1            0xe04
  55 #define LPC18XX_SCU_PINTSEL_VAL_MASK    0xff
  56 #define LPC18XX_SCU_PINTSEL_PORT_SHIFT  5
  57 #define LPC18XX_SCU_IRQ_PER_PINTSEL     4
  58 #define LPC18XX_GPIO_PINS_PER_PORT      32
  59 #define LPC18XX_GPIO_PIN_INT_MAX        8
  60
  61 #define LPC18XX_SCU_PINTSEL_VAL(val, n) \
  62         ((val) << (((n) % LPC18XX_SCU_IRQ_PER_PINTSEL) * 8))
  63
  64 /* LPC18xx pin types */
  65 enum {
  66         TYPE_ND,        /* Normal-drive */
  67         TYPE_HD,        /* High-drive */
  68         TYPE_HS,        /* High-speed */
  69         TYPE_I2C0,
  70         TYPE_USB1,
  71 };
  72
  73 /* LPC18xx pin functions */
  74 enum {
  75         FUNC_R,         /* Reserved */
  76         FUNC_ADC,
  77         FUNC_ADCTRIG,
  78         FUNC_CAN0,
  79         FUNC_CAN1,
  80         FUNC_CGU_OUT,
  81         FUNC_CLKIN,
  82         FUNC_CLKOUT,
  83         FUNC_CTIN,
  84         FUNC_CTOUT,
  85         FUNC_DAC,
  86         FUNC_EMC,
  87         FUNC_EMC_ALT,
  88         FUNC_ENET,
  89         FUNC_ENET_ALT,
  90         FUNC_GPIO,
  91         FUNC_I2C0,
  92         FUNC_I2C1,
  93         FUNC_I2S0_RX_MCLK,
  94         FUNC_I2S0_RX_SCK,
  95         FUNC_I2S0_RX_SDA,
  96         FUNC_I2S0_RX_WS,
  97         FUNC_I2S0_TX_MCLK,
  98         FUNC_I2S0_TX_SCK,
  99         FUNC_I2S0_TX_SDA,
 100         FUNC_I2S0_TX_WS,
 101         FUNC_I2S1,
 102         FUNC_LCD,
 103         FUNC_LCD_ALT,
 104         FUNC_MCTRL,
 105         FUNC_NMI,
 106         FUNC_QEI,
 107         FUNC_SDMMC,
 108         FUNC_SGPIO,
 109         FUNC_SPI,
 110         FUNC_SPIFI,
 111         FUNC_SSP0,
 112         FUNC_SSP0_ALT,
 113         FUNC_SSP1,
 114         FUNC_TIMER0,
 115         FUNC_TIMER1,
 116         FUNC_TIMER2,
 117         FUNC_TIMER3,
 118         FUNC_TRACE,
 119         FUNC_UART0,
 120         FUNC_UART1,
 121         FUNC_UART2,
 122         FUNC_UART3,
 123         FUNC_USB0,
 124         FUNC_USB1,
 125         FUNC_MAX
 126 };
 127
 128 static const char *const lpc18xx_function_names[] = {
 129         [FUNC_R]                = "reserved",
 130         [FUNC_ADC]              = "adc",
 131         [FUNC_ADCTRIG]          = "adctrig",
 132         [FUNC_CAN0]             = "can0",
 133         [FUNC_CAN1]             = "can1",
 134         [FUNC_CGU_OUT]          = "cgu_out",
 135         [FUNC_CLKIN]            = "clkin",
 136         [FUNC_CLKOUT]           = "clkout",
 137         [FUNC_CTIN]             = "ctin",
 138         [FUNC_CTOUT]            = "ctout",
 139         [FUNC_DAC]              = "dac",
 140         [FUNC_EMC]              = "emc",
 141         [FUNC_EMC_ALT]          = "emc_alt",
 142         [FUNC_ENET]             = "enet",
 143         [FUNC_ENET_ALT]         = "enet_alt",
 144         [FUNC_GPIO]             = "gpio",
 145         [FUNC_I2C0]             = "i2c0",
 146         [FUNC_I2C1]             = "i2c1",
 147         [FUNC_I2S0_RX_MCLK]     = "i2s0_rx_mclk",
 148         [FUNC_I2S0_RX_SCK]      = "i2s0_rx_sck",
 149         [FUNC_I2S0_RX_SDA]      = "i2s0_rx_sda",
 150         [FUNC_I2S0_RX_WS]       = "i2s0_rx_ws",
 151         [FUNC_I2S0_TX_MCLK]     = "i2s0_tx_mclk",
 152         [FUNC_I2S0_TX_SCK]      = "i2s0_tx_sck",
 153         [FUNC_I2S0_TX_SDA]      = "i2s0_tx_sda",
 154         [FUNC_I2S0_TX_WS]       = "i2s0_tx_ws",
 155         [FUNC_I2S1]             = "i2s1",
 156         [FUNC_LCD]              = "lcd",
 157         [FUNC_LCD_ALT]          = "lcd_alt",
 158         [FUNC_MCTRL]            = "mctrl",
 159         [FUNC_NMI]              = "nmi",
 160         [FUNC_QEI]              = "qei",
 161         [FUNC_SDMMC]            = "sdmmc",
 162         [FUNC_SGPIO]            = "sgpio",
 163         [FUNC_SPI]              = "spi",
 164         [FUNC_SPIFI]            = "spifi",
 165         [FUNC_SSP0]             = "ssp0",
 166         [FUNC_SSP0_ALT]         = "ssp0_alt",
 167         [FUNC_SSP1]             = "ssp1",
 168         [FUNC_TIMER0]           = "timer0",
 169         [FUNC_TIMER1]           = "timer1",
 170         [FUNC_TIMER2]           = "timer2",
 171         [FUNC_TIMER3]           = "timer3",
 172         [FUNC_TRACE]            = "trace",
 173         [FUNC_UART0]            = "uart0",
 174         [FUNC_UART1]            = "uart1",
 175         [FUNC_UART2]            = "uart2",
 176         [FUNC_UART3]            = "uart3",
 177         [FUNC_USB0]             = "usb0",
 178         [FUNC_USB1]             = "usb1",
 179 };
 180
 181 struct lpc18xx_pmx_func {
 182         const char **groups;
 183         unsigned ngroups;
 184 };
 185
 186 struct lpc18xx_scu_data {
 187         struct pinctrl_dev *pctl;
 188         void __iomem *base;
 189         struct clk *clk;
 190         struct lpc18xx_pmx_func func[FUNC_MAX];
 191 };
 192
 193 struct lpc18xx_pin_caps {
 194         unsigned int offset;
 195         unsigned char functions[LPC18XX_SCU_FUNC_PER_PIN];
 196         unsigned char analog;
 197         unsigned char type;
 198 };
 199
 200 /* Analog pins are required to have both bias and input disabled */
 201 #define LPC18XX_SCU_ANALOG_PIN_CFG      0x10
 202
 203 /* Macros to maniupluate analog member in lpc18xx_pin_caps */
 204 #define LPC18XX_ANALOG_PIN              BIT(7)
 205 #define LPC18XX_ANALOG_ADC(a)           ((a >> 5) & 0x3)
 206 #define LPC18XX_ANALOG_BIT_MASK         0x1f
 207 #define ADC0                            (LPC18XX_ANALOG_PIN | (0x00 << 5))
 208 #define ADC1                            (LPC18XX_ANALOG_PIN | (0x01 << 5))
 209 #define DAC                             LPC18XX_ANALOG_PIN
 210
 211 #define LPC_P(port, pin, f0, f1, f2, f3, f4, f5, f6, f7, a, t)  \
 212 static struct lpc18xx_pin_caps lpc18xx_pin_p##port##_##pin = {  \
 213         .offset = 0x##port * 32 * 4 + pin * 4,                  \
 214         .functions = {                                          \
 215                         FUNC_##f0, FUNC_##f1, FUNC_##f2,        \
 216                         FUNC_##f3, FUNC_##f4, FUNC_##f5,        \
 217                         FUNC_##f6, FUNC_##f7,                   \
 218         },                                                      \
 219         .analog = a,                                            \
 220         .type = TYPE_##t,                                       \
 221 }
 222
 223 #define LPC_N(pname, off, f0, f1, f2, f3, f4, f5, f6, f7, a, t) \
 224 static struct lpc18xx_pin_caps lpc18xx_pin_##pname = {          \
 225         .offset = off,                                          \
 226         .functions = {                                          \
 227                         FUNC_##f0, FUNC_##f1, FUNC_##f2,        \
 228                         FUNC_##f3, FUNC_##f4, FUNC_##f5,        \
 229                         FUNC_##f6, FUNC_##f7,                   \
 230         },                                                      \
 231         .analog = a,                                            \
 232         .type = TYPE_##t,                                       \
 233 }
 234
 235
 236 /* Pinmuxing table taken from data sheet */
 237 /*    Pin    FUNC0  FUNC1  FUNC2  FUNC3   FUNC4   FUNC5   FUNC6    FUNC7 ANALOG TYPE */
 238 LPC_P(0,0,   GPIO,  SSP1,  ENET,  SGPIO,      R,      R, I2S0_TX_WS,I2S1,     0, ND);
 239 LPC_P(0,1,   GPIO,  SSP1,ENET_ALT,SGPIO,      R,      R,   ENET,    I2S1,     0, ND);
 240 LPC_P(1,0,   GPIO,  CTIN,   EMC,      R,      R,   SSP0,  SGPIO,       R,     0, ND);
 241 LPC_P(1,1,   GPIO, CTOUT,   EMC,  SGPIO,      R,   SSP0,      R,       R,     0, ND);
 242 LPC_P(1,2,   GPIO, CTOUT,   EMC,  SGPIO,      R,   SSP0,      R,       R,     0, ND);
 243 LPC_P(1,3,   GPIO, CTOUT, SGPIO,    EMC,   USB0,   SSP1,      R,   SDMMC,     0, ND);
 244 LPC_P(1,4,   GPIO, CTOUT, SGPIO,    EMC,   USB0,   SSP1,      R,   SDMMC,     0, ND);
 245 LPC_P(1,5,   GPIO, CTOUT,     R,    EMC,   USB0,   SSP1,  SGPIO,   SDMMC,     0, ND);
 246 LPC_P(1,6,   GPIO,  CTIN,     R,    EMC,      R,      R,  SGPIO,   SDMMC,     0, ND);
 247 LPC_P(1,7,   GPIO, UART1, CTOUT,    EMC,   USB0,      R,      R,       R,     0, ND);
 248 LPC_P(1,8,   GPIO, UART1, CTOUT,    EMC,      R,      R,      R,   SDMMC,     0, ND);
 249 LPC_P(1,9,   GPIO, UART1, CTOUT,    EMC,      R,      R,      R,   SDMMC,     0, ND);
 250 LPC_P(1,10,  GPIO, UART1, CTOUT,    EMC,      R,      R,      R,   SDMMC,     0, ND);
 251 LPC_P(1,11,  GPIO, UART1, CTOUT,    EMC,      R,      R,      R,   SDMMC,     0, ND);
 252 LPC_P(1,12,  GPIO, UART1,     R,    EMC, TIMER0,      R,  SGPIO,   SDMMC,     0, ND);
 253 LPC_P(1,13,  GPIO, UART1,     R,    EMC, TIMER0,      R,  SGPIO,   SDMMC,     0, ND);
 254 LPC_P(1,14,  GPIO, UART1,     R,    EMC, TIMER0,      R,  SGPIO,       R,     0, ND);
 255 LPC_P(1,15,  GPIO, UART2, SGPIO,   ENET, TIMER0,      R,      R,       R,     0, ND);
 256 LPC_P(1,16,  GPIO, UART2, SGPIO,ENET_ALT,TIMER0,      R,      R,    ENET,     0, ND);
 257 LPC_P(1,17,  GPIO, UART2,     R,   ENET, TIMER0,   CAN1,  SGPIO,       R,     0, HD);
 258 LPC_P(1,18,  GPIO, UART2,     R,   ENET, TIMER0,   CAN1,  SGPIO,       R,     0, ND);
 259 LPC_P(1,19,  ENET,  SSP1,     R,      R, CLKOUT,      R, I2S0_RX_MCLK,I2S1,   0, ND);
 260 LPC_P(1,20,  GPIO,  SSP1,     R,   ENET, TIMER0,      R,  SGPIO,       R,     0, ND);
 261 LPC_P(2,0,  SGPIO, UART0,   EMC,   USB0,   GPIO,      R, TIMER3,    ENET,     0, ND);
 262 LPC_P(2,1,  SGPIO, UART0,   EMC,   USB0,   GPIO,      R, TIMER3,       R,     0, ND);
 263 LPC_P(2,2,  SGPIO, UART0,   EMC,   USB0,   GPIO,   CTIN, TIMER3,       R,     0, ND);
 264 LPC_P(2,3,  SGPIO,  I2C1, UART3,   CTIN,   GPIO,      R, TIMER3,    USB0,     0, HD);
 265 LPC_P(2,4,  SGPIO,  I2C1, UART3,   CTIN,   GPIO,      R, TIMER3,    USB0,     0, HD);
 266 LPC_P(2,5,  SGPIO,  CTIN,  USB1, ADCTRIG,  GPIO,      R, TIMER3,    USB0,     0, HD);
 267 LPC_P(2,6,  SGPIO, UART0,   EMC,   USB0,   GPIO,   CTIN, TIMER3,       R,     0, ND);
 268 LPC_P(2,7,   GPIO, CTOUT, UART3,    EMC,      R,      R, TIMER3,       R,     0, ND);
 269 LPC_P(2,8,  SGPIO, CTOUT, UART3,    EMC,   GPIO,      R,      R,       R,     0, ND);
 270 LPC_P(2,9,   GPIO, CTOUT, UART3,    EMC,      R,      R,      R,       R,     0, ND);
 271 LPC_P(2,10,  GPIO, CTOUT, UART2,    EMC,      R,      R,      R,       R,     0, ND);
 272 LPC_P(2,11,  GPIO, CTOUT, UART2,    EMC,      R,      R,      R,       R,     0, ND);
 273 LPC_P(2,12,  GPIO, CTOUT,     R,    EMC,      R,      R,      R,   UART2,     0, ND);
 274 LPC_P(2,13,  GPIO,  CTIN,     R,    EMC,      R,      R,      R,   UART2,     0, ND);
 275 LPC_P(3,0,  I2S0_RX_SCK, I2S0_RX_MCLK, I2S0_TX_SCK, I2S0_TX_MCLK,SSP0,R,R,R,  0, ND);
 276 LPC_P(3,1,  I2S0_TX_WS, I2S0_RX_WS,CAN0,USB1,GPIO,    R,    LCD,       R,     0, ND);
 277 LPC_P(3,2,  I2S0_TX_SDA, I2S0_RX_SDA,CAN0,USB1,GPIO,  R,    LCD,      R,      0, ND);
 278 LPC_P(3,3,      R,   SPI,  SSP0,  SPIFI, CGU_OUT,R, I2S0_TX_MCLK,  I2S1,      0, HS);
 279 LPC_P(3,4,   GPIO,     R,     R,  SPIFI,  UART1, I2S0_TX_WS, I2S1,  LCD,      0, ND);
 280 LPC_P(3,5,   GPIO,     R,     R,  SPIFI,  UART1, I2S0_TX_SDA,I2S1,  LCD,      0, ND);
 281 LPC_P(3,6,   GPIO,   SPI,  SSP0,  SPIFI,      R,  SSP0_ALT,   R,      R,      0, ND);
 282 LPC_P(3,7,      R,   SPI,  SSP0,  SPIFI,   GPIO,  SSP0_ALT,   R,      R,      0, ND);
 283 LPC_P(3,8,      R,   SPI,  SSP0,  SPIFI,   GPIO,  SSP0_ALT,   R,      R,      0, ND);
 284 LPC_P(4,0,   GPIO, MCTRL,   NMI,      R,      R,    LCD,  UART3,      R,      0, ND);
 285 LPC_P(4,1,   GPIO, CTOUT,   LCD,      R,      R, LCD_ALT, UART3,   ENET, ADC0|1, ND);
 286 LPC_P(4,2,   GPIO, CTOUT,   LCD,      R,      R, LCD_ALT, UART3,  SGPIO,      0, ND);
 287 LPC_P(4,3,   GPIO, CTOUT,   LCD,      R,      R, LCD_ALT, UART3,  SGPIO, ADC0|0, ND);
 288 LPC_P(4,4,   GPIO, CTOUT,   LCD,      R,      R, LCD_ALT, UART3,  SGPIO,    DAC, ND);
 289 LPC_P(4,5,   GPIO, CTOUT,   LCD,      R,      R,      R,      R,  SGPIO,      0, ND);
 290 LPC_P(4,6,   GPIO, CTOUT,   LCD,      R,      R,      R,      R,  SGPIO,      0, ND);
 291 LPC_P(4,7,    LCD, CLKIN,     R,      R,      R,      R,   I2S1,I2S0_TX_SCK,  0, ND);
 292 LPC_P(4,8,      R,  CTIN,   LCD,      R,   GPIO, LCD_ALT,  CAN1,  SGPIO,      0, ND);
 293 LPC_P(4,9,      R,  CTIN,   LCD,      R,   GPIO, LCD_ALT,  CAN1,  SGPIO,      0, ND);
 294 LPC_P(4,10,     R,  CTIN,   LCD,      R,   GPIO, LCD_ALT,     R,  SGPIO,      0, ND);
 295 LPC_P(5,0,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 296 LPC_P(5,1,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 297 LPC_P(5,2,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 298 LPC_P(5,3,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 299 LPC_P(5,4,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 300 LPC_P(5,5,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 301 LPC_P(5,6,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 302 LPC_P(5,7,   GPIO, MCTRL,   EMC,      R,  UART1, TIMER1,      R,      R,      0, ND);
 303 LPC_P(6,0,      R, I2S0_RX_MCLK,R,    R, I2S0_RX_SCK, R,      R,      R,      0, ND);
 304 LPC_P(6,1,   GPIO,   EMC, UART0, I2S0_RX_WS,  R, TIMER2,      R,      R,      0, ND);
 305 LPC_P(6,2,   GPIO,   EMC, UART0, I2S0_RX_SDA, R, TIMER2,      R,      R,      0, ND);
 306 LPC_P(6,3,   GPIO,  USB0, SGPIO,    EMC,      R, TIMER2,      R,      R,      0, ND);
 307 LPC_P(6,4,   GPIO,  CTIN, UART0,    EMC,      R,      R,      R,      R,      0, ND);
 308 LPC_P(6,5,   GPIO, CTOUT, UART0,    EMC,      R,      R,      R,      R,      0, ND);
 309 LPC_P(6,6,   GPIO,   EMC, SGPIO,   USB0,      R, TIMER2,      R,      R,      0, ND);
 310 LPC_P(6,7,      R,   EMC, SGPIO,   USB0,   GPIO, TIMER2,      R,      R,      0, ND);
 311 LPC_P(6,8,      R,   EMC, SGPIO,   USB0,   GPIO, TIMER2,      R,      R,      0, ND);
 312 LPC_P(6,9,   GPIO,     R,     R,    EMC,      R, TIMER2,      R,      R,      0, ND);
 313 LPC_P(6,10,  GPIO, MCTRL,     R,    EMC,      R,      R,      R,      R,      0, ND);
 314 LPC_P(6,11,  GPIO,     R,     R,    EMC,      R, TIMER2,      R,      R,      0, ND);
 315 LPC_P(6,12,  GPIO, CTOUT,     R,    EMC,      R,      R,      R,      R,      0, ND);
 316 LPC_P(7,0,   GPIO, CTOUT,     R,    LCD,      R,      R,      R,  SGPIO,      0, ND);
 317 LPC_P(7,1,   GPIO, CTOUT,I2S0_TX_WS,LCD,LCD_ALT,      R,  UART2,  SGPIO,      0, ND);
 318 LPC_P(7,2,   GPIO, CTIN,I2S0_TX_SDA,LCD,LCD_ALT,      R,  UART2,  SGPIO,      0, ND);
 319 LPC_P(7,3,   GPIO, CTIN,      R,    LCD,LCD_ALT,      R,      R,      R,      0, ND);
 320 LPC_P(7,4,   GPIO, CTOUT,     R,    LCD,LCD_ALT,  TRACE,      R,      R, ADC0|4, ND);
 321 LPC_P(7,5,   GPIO, CTOUT,     R,    LCD,LCD_ALT,  TRACE,      R,      R, ADC0|3, ND);
 322 LPC_P(7,6,   GPIO, CTOUT,     R,    LCD,      R,  TRACE,      R,      R,      0, ND);
 323 LPC_P(7,7,   GPIO, CTOUT,     R,    LCD,      R,  TRACE,   ENET,  SGPIO, ADC1|6, ND);
 324 LPC_P(8,0,   GPIO,  USB0,     R,  MCTRL,  SGPIO,      R,      R, TIMER0,      0, HD);
 325 LPC_P(8,1,   GPIO,  USB0,     R,  MCTRL,  SGPIO,      R,      R, TIMER0,      0, HD);
 326 LPC_P(8,2,   GPIO,  USB0,     R,  MCTRL,  SGPIO,      R,      R, TIMER0,      0, HD);
 327 LPC_P(8,3,   GPIO,  USB1,     R,    LCD, LCD_ALT,     R,      R, TIMER0,      0, ND);
 328 LPC_P(8,4,   GPIO,  USB1,     R,    LCD, LCD_ALT,     R,      R, TIMER0,      0, ND);
 329 LPC_P(8,5,   GPIO,  USB1,     R,    LCD, LCD_ALT,     R,      R, TIMER0,      0, ND);
 330 LPC_P(8,6,   GPIO,  USB1,     R,    LCD, LCD_ALT,     R,      R, TIMER0,      0, ND);
 331 LPC_P(8,7,   GPIO,  USB1,     R,    LCD, LCD_ALT,     R,      R, TIMER0,      0, ND);
 332 LPC_P(8,8,      R,  USB1,     R,      R,      R,      R,CGU_OUT,   I2S1,      0, ND);
 333 LPC_P(9,0,   GPIO, MCTRL,     R,      R,      R,   ENET,  SGPIO,   SSP0,      0, ND);
 334 LPC_P(9,1,   GPIO, MCTRL,     R,      R, I2S0_TX_WS,ENET, SGPIO,   SSP0,      0, ND);
 335 LPC_P(9,2,   GPIO, MCTRL,     R,      R, I2S0_TX_SDA,ENET,SGPIO,   SSP0,      0, ND);
 336 LPC_P(9,3,   GPIO, MCTRL,  USB1,      R,      R,   ENET,  SGPIO,  UART3,      0, ND);
 337 LPC_P(9,4,      R, MCTRL,  USB1,      R,   GPIO,   ENET,  SGPIO,  UART3,      0, ND);
 338 LPC_P(9,5,      R, MCTRL,  USB1,      R,   GPIO,   ENET,  SGPIO,  UART0,      0, ND);
 339 LPC_P(9,6,   GPIO, MCTRL,  USB1,      R,      R,   ENET,  SGPIO,  UART0,      0, ND);
 340 LPC_P(a,0,      R,     R,     R,      R,      R,   I2S1, CGU_OUT,     R,      0, ND);
 341 LPC_P(a,1,   GPIO,   QEI,     R,  UART2,      R,      R,      R,      R,      0, HD);
 342 LPC_P(a,2,   GPIO,   QEI,     R,  UART2,      R,      R,      R,      R,      0, HD);
 343 LPC_P(a,3,   GPIO,   QEI,     R,      R,      R,      R,      R,      R,      0, HD);
 344 LPC_P(a,4,      R, CTOUT,     R,    EMC,   GPIO,      R,      R,      R,      0, ND);
 345 LPC_P(b,0,      R, CTOUT,   LCD,      R,   GPIO,      R,      R,      R,      0, ND);
 346 LPC_P(b,1,      R,  USB1,   LCD,      R,   GPIO,  CTOUT,      R,      R,      0, ND);
 347 LPC_P(b,2,      R,  USB1,   LCD,      R,   GPIO,  CTOUT,      R,      R,      0, ND);
 348 LPC_P(b,3,      R,  USB1,   LCD,      R,   GPIO,  CTOUT,      R,      R,      0, ND);
 349 LPC_P(b,4,      R,  USB1,   LCD,      R,   GPIO,   CTIN,      R,      R,      0, ND);
 350 LPC_P(b,5,      R,  USB1,   LCD,      R,   GPIO,   CTIN, LCD_ALT,     R,      0, ND);
 351 LPC_P(b,6,      R,  USB1,   LCD,      R,   GPIO,   CTIN, LCD_ALT,     R, ADC0|6, ND);
 352 LPC_P(c,0,      R,  USB1,     R,   ENET,    LCD,      R,      R,  SDMMC, ADC1|1, ND);
 353 LPC_P(c,1,   USB1,     R, UART1,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 354 LPC_P(c,2,   USB1,     R, UART1,   ENET,   GPIO,      R,      R,  SDMMC,      0, ND);
 355 LPC_P(c,3,   USB1,     R, UART1,   ENET,   GPIO,      R,      R,  SDMMC, ADC1|0, ND);
 356 LPC_P(c,4,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 357 LPC_P(c,5,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 358 LPC_P(c,6,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 359 LPC_P(c,7,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 360 LPC_P(c,8,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 361 LPC_P(c,9,      R,  USB1,     R,   ENET,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 362 LPC_P(c,10,     R,  USB1, UART1,      R,   GPIO,      R, TIMER3,  SDMMC,      0, ND);
 363 LPC_P(c,11,     R,  USB1, UART1,      R,   GPIO,      R,      R,  SDMMC,      0, ND);
 364 LPC_P(c,12,     R,     R, UART1,      R,   GPIO,  SGPIO, I2S0_TX_SDA,SDMMC,   0, ND);
 365 LPC_P(c,13,     R,     R, UART1,      R,   GPIO,  SGPIO, I2S0_TX_WS, SDMMC,   0, ND);
 366 LPC_P(c,14,     R,     R, UART1,      R,   GPIO,  SGPIO,   ENET,  SDMMC,      0, ND);
 367 LPC_P(d,0,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 368 LPC_P(d,1,      R,     R,   EMC,      R,   GPIO,  SDMMC,      R,  SGPIO,      0, ND);
 369 LPC_P(d,2,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 370 LPC_P(d,3,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 371 LPC_P(d,4,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 372 LPC_P(d,5,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 373 LPC_P(d,6,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 374 LPC_P(d,7,      R,  CTIN,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 375 LPC_P(d,8,      R,  CTIN,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 376 LPC_P(d,9,      R, CTOUT,   EMC,      R,   GPIO,      R,      R,  SGPIO,      0, ND);
 377 LPC_P(d,10,     R,  CTIN,   EMC,      R,   GPIO,      R,      R,      R,      0, ND);
 378 LPC_P(d,11,     R,     R,   EMC,      R,   GPIO,   USB1,  CTOUT,      R,      0, ND);
 379 LPC_P(d,12,     R,     R,   EMC,      R,   GPIO,      R,  CTOUT,      R,      0, ND);
 380 LPC_P(d,13,     R,  CTIN,   EMC,      R,   GPIO,      R,  CTOUT,      R,      0, ND);
 381 LPC_P(d,14,     R,     R,   EMC,      R,   GPIO,      R,  CTOUT,      R,      0, ND);
 382 LPC_P(d,15,     R,     R,   EMC,      R,   GPIO,  SDMMC,  CTOUT,      R,      0, ND);
 383 LPC_P(d,16,     R,     R,   EMC,      R,   GPIO,  SDMMC,  CTOUT,      R,      0, ND);
 384 LPC_P(e,0,      R,     R,     R,    EMC,   GPIO,   CAN1,      R,      R,      0, ND);
 385 LPC_P(e,1,      R,     R,     R,    EMC,   GPIO,   CAN1,      R,      R,      0, ND);
 386 LPC_P(e,2,ADCTRIG,  CAN0,     R,    EMC,   GPIO,      R,      R,      R,      0, ND);
 387 LPC_P(e,3,      R,  CAN0,ADCTRIG,   EMC,   GPIO,      R,      R,      R,      0, ND);
 388 LPC_P(e,4,      R,   NMI,     R,    EMC,   GPIO,      R,      R,      R,      0, ND);
 389 LPC_P(e,5,      R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 390 LPC_P(e,6,      R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 391 LPC_P(e,7,      R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 392 LPC_P(e,8,      R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 393 LPC_P(e,9,      R,  CTIN, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 394 LPC_P(e,10,     R,  CTIN, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 395 LPC_P(e,11,     R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 396 LPC_P(e,12,     R, CTOUT, UART1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 397 LPC_P(e,13,     R, CTOUT,  I2C1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 398 LPC_P(e,14,     R,     R,     R,    EMC,   GPIO,      R,      R,      R,      0, ND);
 399 LPC_P(e,15,     R, CTOUT,  I2C1,    EMC,   GPIO,      R,      R,      R,      0, ND);
 400 LPC_P(f,0,   SSP0, CLKIN,     R,      R,      R,      R,      R,   I2S1,      0, ND);
 401 LPC_P(f,1,      R,     R,  SSP0,      R,   GPIO,      R,  SGPIO,      R,      0, ND);
 402 LPC_P(f,2,      R, UART3,  SSP0,      R,   GPIO,      R,  SGPIO,      R,      0, ND);
 403 LPC_P(f,3,      R, UART3,  SSP0,      R,   GPIO,      R,  SGPIO,      R,      0, ND);
 404 LPC_P(f,4,   SSP1, CLKIN, TRACE,      R,      R, R, I2S0_TX_MCLK,I2S0_RX_SCK, 0, ND);
 405 LPC_P(f,5,      R, UART3,  SSP1,  TRACE,   GPIO,      R,  SGPIO,      R, ADC1|4, ND);
 406 LPC_P(f,6,      R, UART3,  SSP1,  TRACE,   GPIO,      R,  SGPIO,   I2S1, ADC1|3, ND);
 407 LPC_P(f,7,      R, UART3,  SSP1,  TRACE,   GPIO,      R,  SGPIO,   I2S1, ADC1|7, ND);
 408 LPC_P(f,8,      R, UART0,  CTIN,  TRACE,   GPIO,      R,  SGPIO,      R, ADC0|2, ND);
 409 LPC_P(f,9,      R, UART0, CTOUT,      R,   GPIO,      R,  SGPIO,      R, ADC1|2, ND);
 410 LPC_P(f,10,     R, UART0,     R,      R,   GPIO,      R,  SDMMC,      R, ADC0|5, ND);
 411 LPC_P(f,11,     R, UART0,     R,      R,   GPIO,      R,  SDMMC,      R, ADC1|5, ND);
 412
 413 /*    Pin      Offset FUNC0  FUNC1  FUNC2  FUNC3  FUNC4    FUNC5   FUNC6      FUNC7 ANALOG TYPE */
 414 LPC_N(clk0,     0xc00, EMC, CLKOUT,   R,     R,  SDMMC,   EMC_ALT,  SSP1,      ENET,  0, HS);
 415 LPC_N(clk1,     0xc04, EMC, CLKOUT,   R,     R,      R,   CGU_OUT,   R,        I2S1,  0, HS);
 416 LPC_N(clk2,     0xc08, EMC, CLKOUT,   R,     R,  SDMMC,   EMC_ALT,I2S0_TX_MCLK,I2S1,  0, HS);
 417 LPC_N(clk3,     0xc0c, EMC, CLKOUT,   R,     R,      R,   CGU_OUT,   R,        I2S1,  0, HS);
 418 LPC_N(usb1_dm,  0xc80, R,      R,     R,     R,      R,      R,      R,          R,   0, USB1);
 419 LPC_N(usb1_dp,  0xc80, R,      R,     R,     R,      R,      R,      R,          R,   0, USB1);
 420 LPC_N(i2c0_scl, 0xc84, R,      R,     R,     R,      R,      R,      R,          R,   0, I2C0);
 421 LPC_N(i2c0_sda, 0xc84, R,      R,     R,     R,      R,      R,      R,          R,   0, I2C0);
 422
 423 #define LPC18XX_PIN_P(port, pin) {                      \
 424         .number = 0x##port * 32 + pin,                  \
 425         .name = "p"#port"_"#pin,                        \
 426         .drv_data = &lpc18xx_pin_p##port##_##pin        \
 427 }
 428
 429 /* Pin numbers for special pins */
 430 enum {
 431         PIN_CLK0 = 600,
 432         PIN_CLK1,
 433         PIN_CLK2,
 434         PIN_CLK3,
 435         PIN_USB1_DM,
 436         PIN_USB1_DP,
 437         PIN_I2C0_SCL,
 438         PIN_I2C0_SDA,
 439 };
 440
 441 #define LPC18XX_PIN(pname, n) {                         \
 442         .number = n,                                    \
 443         .name = #pname,                                 \
 444         .drv_data = &lpc18xx_pin_##pname                \
 445 }
 446
 447 static const struct pinctrl_pin_desc lpc18xx_pins[] = {
 448         LPC18XX_PIN_P(0,0),
 449         LPC18XX_PIN_P(0,1),
 450         LPC18XX_PIN_P(1,0),
 451         LPC18XX_PIN_P(1,1),
 452         LPC18XX_PIN_P(1,2),
 453         LPC18XX_PIN_P(1,3),
 454         LPC18XX_PIN_P(1,4),
 455         LPC18XX_PIN_P(1,5),
 456         LPC18XX_PIN_P(1,6),
 457         LPC18XX_PIN_P(1,7),
 458         LPC18XX_PIN_P(1,8),
 459         LPC18XX_PIN_P(1,9),
 460         LPC18XX_PIN_P(1,10),
 461         LPC18XX_PIN_P(1,11),
 462         LPC18XX_PIN_P(1,12),
 463         LPC18XX_PIN_P(1,13),
 464         LPC18XX_PIN_P(1,14),
 465         LPC18XX_PIN_P(1,15),
 466         LPC18XX_PIN_P(1,16),
 467         LPC18XX_PIN_P(1,17),
 468         LPC18XX_PIN_P(1,18),
 469         LPC18XX_PIN_P(1,19),
 470         LPC18XX_PIN_P(1,20),
 471         LPC18XX_PIN_P(2,0),
 472         LPC18XX_PIN_P(2,1),
 473         LPC18XX_PIN_P(2,2),
 474         LPC18XX_PIN_P(2,3),
 475         LPC18XX_PIN_P(2,4),
 476         LPC18XX_PIN_P(2,5),
 477         LPC18XX_PIN_P(2,6),
 478         LPC18XX_PIN_P(2,7),
 479         LPC18XX_PIN_P(2,8),
 480         LPC18XX_PIN_P(2,9),
 481         LPC18XX_PIN_P(2,10),
 482         LPC18XX_PIN_P(2,11),
 483         LPC18XX_PIN_P(2,12),
 484         LPC18XX_PIN_P(2,13),
 485         LPC18XX_PIN_P(3,0),
 486         LPC18XX_PIN_P(3,1),
 487         LPC18XX_PIN_P(3,2),
 488         LPC18XX_PIN_P(3,3),
 489         LPC18XX_PIN_P(3,4),
 490         LPC18XX_PIN_P(3,5),
 491         LPC18XX_PIN_P(3,6),
 492         LPC18XX_PIN_P(3,7),
 493         LPC18XX_PIN_P(3,8),
 494         LPC18XX_PIN_P(4,0),
 495         LPC18XX_PIN_P(4,1),
 496         LPC18XX_PIN_P(4,2),
 497         LPC18XX_PIN_P(4,3),
 498         LPC18XX_PIN_P(4,4),
 499         LPC18XX_PIN_P(4,5),
 500         LPC18XX_PIN_P(4,6),
 501         LPC18XX_PIN_P(4,7),
 502         LPC18XX_PIN_P(4,8),
 503         LPC18XX_PIN_P(4,9),
 504         LPC18XX_PIN_P(4,10),
 505         LPC18XX_PIN_P(5,0),
 506         LPC18XX_PIN_P(5,1),
 507         LPC18XX_PIN_P(5,2),
 508         LPC18XX_PIN_P(5,3),
 509         LPC18XX_PIN_P(5,4),
 510         LPC18XX_PIN_P(5,5),
 511         LPC18XX_PIN_P(5,6),
 512         LPC18XX_PIN_P(5,7),
 513         LPC18XX_PIN_P(6,0),
 514         LPC18XX_PIN_P(6,1),
 515         LPC18XX_PIN_P(6,2),
 516         LPC18XX_PIN_P(6,3),
 517         LPC18XX_PIN_P(6,4),
 518         LPC18XX_PIN_P(6,5),
 519         LPC18XX_PIN_P(6,6),
 520         LPC18XX_PIN_P(6,7),
 521         LPC18XX_PIN_P(6,8),
 522         LPC18XX_PIN_P(6,9),
 523         LPC18XX_PIN_P(6,10),
 524         LPC18XX_PIN_P(6,11),
 525         LPC18XX_PIN_P(6,12),
 526         LPC18XX_PIN_P(7,0),
 527         LPC18XX_PIN_P(7,1),
 528         LPC18XX_PIN_P(7,2),
 529         LPC18XX_PIN_P(7,3),
 530         LPC18XX_PIN_P(7,4),
 531         LPC18XX_PIN_P(7,5),
 532         LPC18XX_PIN_P(7,6),
 533         LPC18XX_PIN_P(7,7),
 534         LPC18XX_PIN_P(8,0),
 535         LPC18XX_PIN_P(8,1),
 536         LPC18XX_PIN_P(8,2),
 537         LPC18XX_PIN_P(8,3),
 538         LPC18XX_PIN_P(8,4),
 539         LPC18XX_PIN_P(8,5),
 540         LPC18XX_PIN_P(8,6),
 541         LPC18XX_PIN_P(8,7),
 542         LPC18XX_PIN_P(8,8),
 543         LPC18XX_PIN_P(9,0),
 544         LPC18XX_PIN_P(9,1),
 545         LPC18XX_PIN_P(9,2),
 546         LPC18XX_PIN_P(9,3),
 547         LPC18XX_PIN_P(9,4),
 548         LPC18XX_PIN_P(9,5),
 549         LPC18XX_PIN_P(9,6),
 550         LPC18XX_PIN_P(a,0),
 551         LPC18XX_PIN_P(a,1),
 552         LPC18XX_PIN_P(a,2),
 553         LPC18XX_PIN_P(a,3),
 554         LPC18XX_PIN_P(a,4),
 555         LPC18XX_PIN_P(b,0),
 556         LPC18XX_PIN_P(b,1),
 557         LPC18XX_PIN_P(b,2),
 558         LPC18XX_PIN_P(b,3),
 559         LPC18XX_PIN_P(b,4),
 560         LPC18XX_PIN_P(b,5),
 561         LPC18XX_PIN_P(b,6),
 562         LPC18XX_PIN_P(c,0),
 563         LPC18XX_PIN_P(c,1),
 564         LPC18XX_PIN_P(c,2),
 565         LPC18XX_PIN_P(c,3),
 566         LPC18XX_PIN_P(c,4),
 567         LPC18XX_PIN_P(c,5),
 568         LPC18XX_PIN_P(c,6),
 569         LPC18XX_PIN_P(c,7),
 570         LPC18XX_PIN_P(c,8),
 571         LPC18XX_PIN_P(c,9),
 572         LPC18XX_PIN_P(c,10),
 573         LPC18XX_PIN_P(c,11),
 574         LPC18XX_PIN_P(c,12),
 575         LPC18XX_PIN_P(c,13),
 576         LPC18XX_PIN_P(c,14),
 577         LPC18XX_PIN_P(d,0),
 578         LPC18XX_PIN_P(d,1),
 579         LPC18XX_PIN_P(d,2),
 580         LPC18XX_PIN_P(d,3),
 581         LPC18XX_PIN_P(d,4),
 582         LPC18XX_PIN_P(d,5),
 583         LPC18XX_PIN_P(d,6),
 584         LPC18XX_PIN_P(d,7),
 585         LPC18XX_PIN_P(d,8),
 586         LPC18XX_PIN_P(d,9),
 587         LPC18XX_PIN_P(d,10),
 588         LPC18XX_PIN_P(d,11),
 589         LPC18XX_PIN_P(d,12),
 590         LPC18XX_PIN_P(d,13),
 591         LPC18XX_PIN_P(d,14),
 592         LPC18XX_PIN_P(d,15),
 593         LPC18XX_PIN_P(d,16),
 594         LPC18XX_PIN_P(e,0),
 595         LPC18XX_PIN_P(e,1),
 596         LPC18XX_PIN_P(e,2),
 597         LPC18XX_PIN_P(e,3),
 598         LPC18XX_PIN_P(e,4),
 599         LPC18XX_PIN_P(e,5),
 600         LPC18XX_PIN_P(e,6),
 601         LPC18XX_PIN_P(e,7),
 602         LPC18XX_PIN_P(e,8),
 603         LPC18XX_PIN_P(e,9),
 604         LPC18XX_PIN_P(e,10),
 605         LPC18XX_PIN_P(e,11),
 606         LPC18XX_PIN_P(e,12),
 607         LPC18XX_PIN_P(e,13),
 608         LPC18XX_PIN_P(e,14),
 609         LPC18XX_PIN_P(e,15),
 610         LPC18XX_PIN_P(f,0),
 611         LPC18XX_PIN_P(f,1),
 612         LPC18XX_PIN_P(f,2),
 613         LPC18XX_PIN_P(f,3),
 614         LPC18XX_PIN_P(f,4),
 615         LPC18XX_PIN_P(f,5),
 616         LPC18XX_PIN_P(f,6),
 617         LPC18XX_PIN_P(f,7),
 618         LPC18XX_PIN_P(f,8),
 619         LPC18XX_PIN_P(f,9),
 620         LPC18XX_PIN_P(f,10),
 621         LPC18XX_PIN_P(f,11),
 622
 623         LPC18XX_PIN(clk0, PIN_CLK0),
 624         LPC18XX_PIN(clk1, PIN_CLK1),
 625         LPC18XX_PIN(clk2, PIN_CLK2),
 626         LPC18XX_PIN(clk3, PIN_CLK3),
 627         LPC18XX_PIN(usb1_dm,  PIN_USB1_DM),
 628         LPC18XX_PIN(usb1_dp,  PIN_USB1_DP),
 629         LPC18XX_PIN(i2c0_scl, PIN_I2C0_SCL),
 630         LPC18XX_PIN(i2c0_sda, PIN_I2C0_SDA),
 631 };
 632
 633 /**
 634  * enum lpc18xx_pin_config_param - possible pin configuration parameters
 635  * @PIN_CONFIG_GPIO_PIN_INT: route gpio to the gpio pin interrupt
 636  *      controller.
 637  */
 638 enum lpc18xx_pin_config_param {
 639         PIN_CONFIG_GPIO_PIN_INT = PIN_CONFIG_END + 1,
 640 };
 641
 642 static const struct pinconf_generic_params lpc18xx_params[] = {
 643         {"nxp,gpio-pin-interrupt", PIN_CONFIG_GPIO_PIN_INT, 0},
 644 };
 645
 646 #ifdef CONFIG_DEBUG_FS
 647 static const struct pin_config_item lpc18xx_conf_items[ARRAY_SIZE(lpc18xx_params)] = {
 648         PCONFDUMP(PIN_CONFIG_GPIO_PIN_INT, "gpio pin int", NULL, true),
 649 };
 650 #endif
 651
 652 static int lpc18xx_pconf_get_usb1(enum pin_config_param param, int *arg, u32 reg)
 653 {
 654         switch (param) {
 655         case PIN_CONFIG_LOW_POWER_MODE:
 656                 if (reg & LPC18XX_SCU_USB1_EPWR)
 657                         *arg = 0;
 658                 else
 659                         *arg = 1;
 660                 break;
 661
 662         case PIN_CONFIG_BIAS_DISABLE:
 663                 if (reg & LPC18XX_SCU_USB1_EPD)
 664                         return -EINVAL;
 665                 break;
 666
 667         case PIN_CONFIG_BIAS_PULL_DOWN:
 668                 if (reg & LPC18XX_SCU_USB1_EPD)
 669                         *arg = 1;
 670                 else
 671                         return -EINVAL;
 672                 break;
 673
 674         default:
 675                 return -ENOTSUPP;
 676         }
 677
 678         return 0;
 679 }
 680
 681 static int lpc18xx_pconf_get_i2c0(enum pin_config_param param, int *arg, u32 reg,
 682                                   unsigned pin)
 683 {
 684         u8 shift;
 685
 686         if (pin == PIN_I2C0_SCL)
 687                 shift = LPC18XX_SCU_I2C0_SCL_SHIFT;
 688         else
 689                 shift = LPC18XX_SCU_I2C0_SDA_SHIFT;
 690
 691         switch (param) {
 692         case PIN_CONFIG_INPUT_ENABLE:
 693                 if (reg & (LPC18XX_SCU_I2C0_EZI << shift))
 694                         *arg = 1;
 695                 else
 696                         return -EINVAL;
 697                 break;
 698
 699         case PIN_CONFIG_SLEW_RATE:
 700                 if (reg & (LPC18XX_SCU_I2C0_EHD << shift))
 701                         *arg = 1;
 702                 else
 703                         *arg = 0;
 704                 break;
 705
 706         case PIN_CONFIG_INPUT_SCHMITT:
 707                 if (reg & (LPC18XX_SCU_I2C0_EFP << shift))
 708                         *arg = 3;
 709                 else
 710                         *arg = 50;
 711                 break;
 712
 713         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 714                 if (reg & (LPC18XX_SCU_I2C0_ZIF << shift))
 715                         return -EINVAL;
 716                 else
 717                         *arg = 1;
 718                 break;
 719
 720         default:
 721                 return -ENOTSUPP;
 722         }
 723
 724         return 0;
 725 }
 726
 727 static int lpc18xx_pin_to_gpio(struct pinctrl_dev *pctldev, unsigned pin)
 728 {
 729         struct pinctrl_gpio_range *range;
 730
 731         range = pinctrl_find_gpio_range_from_pin_nolock(pctldev, pin);
 732         if (!range)
 733                 return -EINVAL;
 734
 735         return pin - range->pin_base + range->base;
 736 }
 737
 738 static int lpc18xx_get_pintsel(void __iomem *addr, u32 val, int *arg)
 739 {
 740         u32 reg_val;
 741         int i;
 742
 743         reg_val = readl(addr);
 744         for (i = 0; i < LPC18XX_SCU_IRQ_PER_PINTSEL; i++) {
 745                 if ((reg_val & LPC18XX_SCU_PINTSEL_VAL_MASK) == val)
 746                         return 0;
 747
 748                 reg_val >>= BITS_PER_BYTE;
 749                 *arg += 1;
 750         }
 751
 752         return -EINVAL;
 753 }
 754
 755 static u32 lpc18xx_gpio_to_pintsel_val(int gpio)
 756 {
 757         unsigned int gpio_port, gpio_pin;
 758
 759         gpio_port = gpio / LPC18XX_GPIO_PINS_PER_PORT;
 760         gpio_pin  = gpio % LPC18XX_GPIO_PINS_PER_PORT;
 761
 762         return gpio_pin | (gpio_port << LPC18XX_SCU_PINTSEL_PORT_SHIFT);
 763 }
 764
 765 static int lpc18xx_pconf_get_gpio_pin_int(struct pinctrl_dev *pctldev,
 766                                           int *arg, unsigned pin)
 767 {
 768         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
 769         int gpio, ret;
 770         u32 val;
 771
 772         gpio = lpc18xx_pin_to_gpio(pctldev, pin);
 773         if (gpio < 0)
 774                 return -ENOTSUPP;
 775
 776         val = lpc18xx_gpio_to_pintsel_val(gpio);
 777
 778         /*
 779          * Check if this pin has been enabled as a interrupt in any of the two
 780          * PINTSEL registers. *arg indicates which interrupt number (0-7).
 781          */
 782         *arg = 0;
 783         ret = lpc18xx_get_pintsel(scu->base + LPC18XX_SCU_PINTSEL0, val, arg);
 784         if (ret == 0)
 785                 return ret;
 786
 787         return lpc18xx_get_pintsel(scu->base + LPC18XX_SCU_PINTSEL1, val, arg);
 788 }
 789
 790 static int lpc18xx_pconf_get_pin(struct pinctrl_dev *pctldev, unsigned param,
 791                                  int *arg, u32 reg, unsigned pin,
 792                                  struct lpc18xx_pin_caps *pin_cap)
 793 {
 794         switch (param) {
 795         case PIN_CONFIG_BIAS_DISABLE:
 796                 if ((!(reg & LPC18XX_SCU_PIN_EPD)) && (reg & LPC18XX_SCU_PIN_EPUN))
 797                         ;
 798                 else
 799                         return -EINVAL;
 800                 break;
 801
 802         case PIN_CONFIG_BIAS_PULL_UP:
 803                 if (reg & LPC18XX_SCU_PIN_EPUN)
 804                         return -EINVAL;
 805                 else
 806                         *arg = 1;
 807                 break;
 808
 809         case PIN_CONFIG_BIAS_PULL_DOWN:
 810                 if (reg & LPC18XX_SCU_PIN_EPD)
 811                         *arg = 1;
 812                 else
 813                         return -EINVAL;
 814                 break;
 815
 816         case PIN_CONFIG_INPUT_ENABLE:
 817                 if (reg & LPC18XX_SCU_PIN_EZI)
 818                         *arg = 1;
 819                 else
 820                         return -EINVAL;
 821                 break;
 822
 823         case PIN_CONFIG_SLEW_RATE:
 824                 if (pin_cap->type == TYPE_HD)
 825                         return -ENOTSUPP;
 826
 827                 if (reg & LPC18XX_SCU_PIN_EHS)
 828                         *arg = 1;
 829                 else
 830                         *arg = 0;
 831                 break;
 832
 833         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 834                 if (reg & LPC18XX_SCU_PIN_ZIF)
 835                         return -EINVAL;
 836                 else
 837                         *arg = 1;
 838                 break;
 839
 840         case PIN_CONFIG_DRIVE_STRENGTH:
 841                 if (pin_cap->type != TYPE_HD)
 842                         return -ENOTSUPP;
 843
 844                 *arg = (reg & LPC18XX_SCU_PIN_EHD_MASK) >> LPC18XX_SCU_PIN_EHD_POS;
 845                 switch (*arg) {
 846                 case 3: *arg += 5;
 847                         /* fall through */
 848                 case 2: *arg += 5;
 849                         /* fall through */
 850                 case 1: *arg += 3;
 851                         /* fall through */
 852                 case 0: *arg += 4;
 853                 }
 854                 break;
 855
 856         case PIN_CONFIG_GPIO_PIN_INT:
 857                 return lpc18xx_pconf_get_gpio_pin_int(pctldev, arg, pin);
 858
 859         default:
 860                 return -ENOTSUPP;
 861         }
 862
 863         return 0;
 864 }
 865
 866 static struct lpc18xx_pin_caps *lpc18xx_get_pin_caps(unsigned pin)
 867 {
 868         int i;
 869
 870         for (i = 0; i < ARRAY_SIZE(lpc18xx_pins); i++) {
 871                 if (lpc18xx_pins[i].number == pin)
 872                         return lpc18xx_pins[i].drv_data;
 873         }
 874
 875         return NULL;
 876 }
 877
 878 static int lpc18xx_pconf_get(struct pinctrl_dev *pctldev, unsigned pin,
 879                              unsigned long *config)
 880 {
 881         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
 882         enum pin_config_param param = pinconf_to_config_param(*config);
 883         struct lpc18xx_pin_caps *pin_cap;
 884         int ret, arg = 0;
 885         u32 reg;
 886
 887         pin_cap = lpc18xx_get_pin_caps(pin);
 888         if (!pin_cap)
 889                 return -EINVAL;
 890
 891         reg = readl(scu->base + pin_cap->offset);
 892
 893         if (pin_cap->type == TYPE_I2C0)
 894                 ret = lpc18xx_pconf_get_i2c0(param, &arg, reg, pin);
 895         else if (pin_cap->type == TYPE_USB1)
 896                 ret = lpc18xx_pconf_get_usb1(param, &arg, reg);
 897         else
 898                 ret = lpc18xx_pconf_get_pin(pctldev, param, &arg, reg, pin, pin_cap);
 899
 900         if (ret < 0)
 901                 return ret;
 902
 903         *config = pinconf_to_config_packed(param, (u16)arg);
 904
 905         return 0;
 906 }
 907
 908 static int lpc18xx_pconf_set_usb1(struct pinctrl_dev *pctldev,
 909                                   enum pin_config_param param,
 910                                   u32 param_val, u32 *reg)
 911 {
 912         switch (param) {
 913         case PIN_CONFIG_LOW_POWER_MODE:
 914                 if (param_val)
 915                         *reg &= ~LPC18XX_SCU_USB1_EPWR;
 916                 else
 917                         *reg |= LPC18XX_SCU_USB1_EPWR;
 918                 break;
 919
 920         case PIN_CONFIG_BIAS_DISABLE:
 921                 *reg &= ~LPC18XX_SCU_USB1_EPD;
 922                 break;
 923
 924         case PIN_CONFIG_BIAS_PULL_DOWN:
 925                 *reg |= LPC18XX_SCU_USB1_EPD;
 926                 break;
 927
 928         default:
 929                 dev_err(pctldev->dev, "Property not supported\n");
 930                 return -ENOTSUPP;
 931         }
 932
 933         return 0;
 934 }
 935
 936 static int lpc18xx_pconf_set_i2c0(struct pinctrl_dev *pctldev,
 937                                   enum pin_config_param param,
 938                                   u32 param_val, u32 *reg,
 939                                   unsigned pin)
 940 {
 941         u8 shift;
 942
 943         if (pin == PIN_I2C0_SCL)
 944                 shift = LPC18XX_SCU_I2C0_SCL_SHIFT;
 945         else
 946                 shift = LPC18XX_SCU_I2C0_SDA_SHIFT;
 947
 948         switch (param) {
 949         case PIN_CONFIG_INPUT_ENABLE:
 950                 if (param_val)
 951                         *reg |= (LPC18XX_SCU_I2C0_EZI << shift);
 952                 else
 953                         *reg &= ~(LPC18XX_SCU_I2C0_EZI << shift);
 954                 break;
 955
 956         case PIN_CONFIG_SLEW_RATE:
 957                 if (param_val)
 958                         *reg |= (LPC18XX_SCU_I2C0_EHD << shift);
 959                 else
 960                         *reg &= ~(LPC18XX_SCU_I2C0_EHD << shift);
 961                 break;
 962
 963         case PIN_CONFIG_INPUT_SCHMITT:
 964                 if (param_val == 3)
 965                         *reg |= (LPC18XX_SCU_I2C0_EFP << shift);
 966                 else if (param_val == 50)
 967                         *reg &= ~(LPC18XX_SCU_I2C0_EFP << shift);
 968                 else
 969                         return -ENOTSUPP;
 970                 break;
 971
 972         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
 973                 if (param_val)
 974                         *reg &= ~(LPC18XX_SCU_I2C0_ZIF << shift);
 975                 else
 976                         *reg |= (LPC18XX_SCU_I2C0_ZIF << shift);
 977                 break;
 978
 979         default:
 980                 dev_err(pctldev->dev, "Property not supported\n");
 981                 return -ENOTSUPP;
 982         }
 983
 984         return 0;
 985 }
 986
 987 static int lpc18xx_pconf_set_gpio_pin_int(struct pinctrl_dev *pctldev,
 988                                           u32 param_val, unsigned pin)
 989 {
 990         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
 991         u32 val, reg_val, reg_offset = LPC18XX_SCU_PINTSEL0;
 992         int gpio;
 993
 994         if (param_val >= LPC18XX_GPIO_PIN_INT_MAX)
 995                 return -EINVAL;
 996
 997         gpio = lpc18xx_pin_to_gpio(pctldev, pin);
 998         if (gpio < 0)
 999                 return -ENOTSUPP;
1000
1001         val = lpc18xx_gpio_to_pintsel_val(gpio);
1002
1003         reg_offset += (param_val / LPC18XX_SCU_IRQ_PER_PINTSEL) * sizeof(u32);
1004
1005         reg_val = readl(scu->base + reg_offset);
1006         reg_val &= ~LPC18XX_SCU_PINTSEL_VAL(LPC18XX_SCU_PINTSEL_VAL_MASK, param_val);
1007         reg_val |= LPC18XX_SCU_PINTSEL_VAL(val, param_val);
1008         writel(reg_val, scu->base + reg_offset);
1009
1010         return 0;
1011 }
1012
1013 static int lpc18xx_pconf_set_pin(struct pinctrl_dev *pctldev, unsigned param,
1014                                  u32 param_val, u32 *reg, unsigned pin,
1015                                  struct lpc18xx_pin_caps *pin_cap)
1016 {
1017         switch (param) {
1018         case PIN_CONFIG_BIAS_DISABLE:
1019                 *reg &= ~LPC18XX_SCU_PIN_EPD;
1020                 *reg |= LPC18XX_SCU_PIN_EPUN;
1021                 break;
1022
1023         case PIN_CONFIG_BIAS_PULL_UP:
1024                 *reg &= ~LPC18XX_SCU_PIN_EPUN;
1025                 break;
1026
1027         case PIN_CONFIG_BIAS_PULL_DOWN:
1028                 *reg |= LPC18XX_SCU_PIN_EPD;
1029                 break;
1030
1031         case PIN_CONFIG_INPUT_ENABLE:
1032                 if (param_val)
1033                         *reg |= LPC18XX_SCU_PIN_EZI;
1034                 else
1035                         *reg &= ~LPC18XX_SCU_PIN_EZI;
1036                 break;
1037
1038         case PIN_CONFIG_SLEW_RATE:
1039                 if (pin_cap->type == TYPE_HD) {
1040                         dev_err(pctldev->dev, "Slew rate unsupported on high-drive pins\n");
1041                         return -ENOTSUPP;
1042                 }
1043
1044                 if (param_val == 0)
1045                         *reg &= ~LPC18XX_SCU_PIN_EHS;
1046                 else
1047                         *reg |= LPC18XX_SCU_PIN_EHS;
1048                 break;
1049
1050         case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
1051                 if (param_val)
1052                         *reg &= ~LPC18XX_SCU_PIN_ZIF;
1053                 else
1054                         *reg |= LPC18XX_SCU_PIN_ZIF;
1055                 break;
1056
1057         case PIN_CONFIG_DRIVE_STRENGTH:
1058                 if (pin_cap->type != TYPE_HD) {
1059                         dev_err(pctldev->dev, "Drive strength available only on high-drive pins\n");
1060                         return -ENOTSUPP;
1061                 }
1062                 *reg &= ~LPC18XX_SCU_PIN_EHD_MASK;
1063
1064                 switch (param_val) {
1065                 case 20: param_val -= 5;
1066                          /* fall through */
1067                 case 14: param_val -= 5;
1068                          /* fall through */
1069                 case  8: param_val -= 3;
1070                          /* fall through */
1071                 case  4: param_val -= 4;
1072                          break;
1073                 default:
1074                         dev_err(pctldev->dev, "Drive strength %u unsupported\n", param_val);
1075                         return -ENOTSUPP;
1076                 }
1077                 *reg |= param_val << LPC18XX_SCU_PIN_EHD_POS;
1078                 break;
1079
1080         case PIN_CONFIG_GPIO_PIN_INT:
1081                 return lpc18xx_pconf_set_gpio_pin_int(pctldev, param_val, pin);
1082
1083         default:
1084                 dev_err(pctldev->dev, "Property not supported\n");
1085                 return -ENOTSUPP;
1086         }
1087
1088         return 0;
1089 }
1090
1091 static int lpc18xx_pconf_set(struct pinctrl_dev *pctldev, unsigned pin,
1092                              unsigned long *configs, unsigned num_configs)
1093 {
1094         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
1095         struct lpc18xx_pin_caps *pin_cap;
1096         enum pin_config_param param;
1097         u32 param_val;
1098         u32 reg;
1099         int ret;
1100         int i;
1101
1102         pin_cap = lpc18xx_get_pin_caps(pin);
1103         if (!pin_cap)
1104                 return -EINVAL;
1105
1106         reg = readl(scu->base + pin_cap->offset);
1107
1108         for (i = 0; i < num_configs; i++) {
1109                 param = pinconf_to_config_param(configs[i]);
1110                 param_val = pinconf_to_config_argument(configs[i]);
1111
1112                 if (pin_cap->type == TYPE_I2C0)
1113                         ret = lpc18xx_pconf_set_i2c0(pctldev, param, param_val, &reg, pin);
1114                 else if (pin_cap->type == TYPE_USB1)
1115                         ret = lpc18xx_pconf_set_usb1(pctldev, param, param_val, &reg);
1116                 else
1117                         ret = lpc18xx_pconf_set_pin(pctldev, param, param_val, &reg, pin, pin_cap);
1118
1119                 if (ret)
1120                         return ret;
1121         }
1122
1123         writel(reg, scu->base + pin_cap->offset);
1124
1125         return 0;
1126 }
1127
1128 static const struct pinconf_ops lpc18xx_pconf_ops = {
1129         .is_generic     = true,
1130         .pin_config_get = lpc18xx_pconf_get,
1131         .pin_config_set = lpc18xx_pconf_set,
1132 };
1133
1134 static int lpc18xx_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
1135 {
1136         return ARRAY_SIZE(lpc18xx_function_names);
1137 }
1138
1139 static const char *lpc18xx_pmx_get_func_name(struct pinctrl_dev *pctldev,
1140                                              unsigned function)
1141 {
1142         return lpc18xx_function_names[function];
1143 }
1144
1145 static int lpc18xx_pmx_get_func_groups(struct pinctrl_dev *pctldev,
1146                                        unsigned function,
1147                                        const char *const **groups,
1148                                        unsigned *const num_groups)
1149 {
1150         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
1151
1152         *groups  = scu->func[function].groups;
1153         *num_groups = scu->func[function].ngroups;
1154
1155         return 0;
1156 }
1157
1158 static int lpc18xx_pmx_set(struct pinctrl_dev *pctldev, unsigned function,
1159                            unsigned group)
1160 {
1161         struct lpc18xx_scu_data *scu = pinctrl_dev_get_drvdata(pctldev);
1162         struct lpc18xx_pin_caps *pin = lpc18xx_pins[group].drv_data;
1163         int func;
1164         u32 reg;
1165
1166         /* Dedicated USB1 and I2C0 pins doesn't support muxing */
1167         if (pin->type == TYPE_USB1) {
1168                 if (function == FUNC_USB1)
1169                         return 0;
1170
1171                 goto fail;
1172         }
1173
1174         if (pin->type == TYPE_I2C0) {
1175                 if (function == FUNC_I2C0)
1176                         return 0;
1177
1178                 goto fail;
1179         }
1180
1181         if (function == FUNC_ADC && (pin->analog & LPC18XX_ANALOG_PIN)) {
1182                 u32 offset;
1183
1184                 writel(LPC18XX_SCU_ANALOG_PIN_CFG, scu->base + pin->offset);
1185
1186                 if (LPC18XX_ANALOG_ADC(pin->analog) == 0)
1187                         offset = LPC18XX_SCU_REG_ENAIO0;
1188                 else
1189                         offset = LPC18XX_SCU_REG_ENAIO1;
1190
1191                 reg = readl(scu->base + offset);
1192                 reg |= pin->analog & LPC18XX_ANALOG_BIT_MASK;
1193                 writel(reg, scu->base + offset);
1194
1195                 return 0;
1196         }
1197
1198         if (function == FUNC_DAC && (pin->analog & LPC18XX_ANALOG_PIN)) {
1199                 writel(LPC18XX_SCU_ANALOG_PIN_CFG, scu->base + pin->offset);
1200
1201                 reg = readl(scu->base + LPC18XX_SCU_REG_ENAIO2);
1202                 reg |= LPC18XX_SCU_REG_ENAIO2_DAC;
1203                 writel(reg, scu->base + LPC18XX_SCU_REG_ENAIO2);
1204
1205                 return 0;
1206         }
1207
1208         for (func = 0; func < LPC18XX_SCU_FUNC_PER_PIN; func++) {
1209                 if (function == pin->functions[func])
1210                         break;
1211         }
1212
1213         if (func >= LPC18XX_SCU_FUNC_PER_PIN)
1214                 goto fail;
1215
1216         reg = readl(scu->base + pin->offset);
1217         reg &= ~LPC18XX_SCU_PIN_MODE_MASK;
1218         writel(reg | func, scu->base + pin->offset);
1219
1220         return 0;
1221 fail:
1222         dev_err(pctldev->dev, "Pin %s can't be %s\n", lpc18xx_pins[group].name,
1223                                                       lpc18xx_function_names[function]);
1224         return -EINVAL;
1225 }
1226
1227 static const struct pinmux_ops lpc18xx_pmx_ops = {
1228         .get_functions_count    = lpc18xx_pmx_get_funcs_count,
1229         .get_function_name      = lpc18xx_pmx_get_func_name,
1230         .get_function_groups    = lpc18xx_pmx_get_func_groups,
1231         .set_mux                = lpc18xx_pmx_set,
1232 };
1233
1234 static int lpc18xx_pctl_get_groups_count(struct pinctrl_dev *pctldev)
1235 {
1236         return ARRAY_SIZE(lpc18xx_pins);
1237 }
1238
1239 static const char *lpc18xx_pctl_get_group_name(struct pinctrl_dev *pctldev,
1240                                                unsigned group)
1241 {
1242         return lpc18xx_pins[group].name;
1243 }
1244
1245 static int lpc18xx_pctl_get_group_pins(struct pinctrl_dev *pctldev,
1246                                        unsigned group,
1247                                        const unsigned **pins,
1248                                        unsigned *num_pins)
1249 {
1250         *pins = &lpc18xx_pins[group].number;
1251         *num_pins = 1;
1252
1253         return 0;
1254 }
1255
1256 static const struct pinctrl_ops lpc18xx_pctl_ops = {
1257         .get_groups_count       = lpc18xx_pctl_get_groups_count,
1258         .get_group_name         = lpc18xx_pctl_get_group_name,
1259         .get_group_pins         = lpc18xx_pctl_get_group_pins,
1260         .dt_node_to_map         = pinconf_generic_dt_node_to_map_pin,
1261         .dt_free_map            = pinctrl_utils_free_map,
1262 };
1263
1264 static struct pinctrl_desc lpc18xx_scu_desc = {
1265         .name = "lpc18xx/43xx-scu",
1266         .pins = lpc18xx_pins,
1267         .npins = ARRAY_SIZE(lpc18xx_pins),
1268         .pctlops = &lpc18xx_pctl_ops,
1269         .pmxops = &lpc18xx_pmx_ops,
1270         .confops = &lpc18xx_pconf_ops,
1271         .num_custom_params = ARRAY_SIZE(lpc18xx_params),
1272         .custom_params = lpc18xx_params,
1273 #ifdef CONFIG_DEBUG_FS
1274         .custom_conf_items = lpc18xx_conf_items,
1275 #endif
1276         .owner = THIS_MODULE,
1277 };
1278
1279 static bool lpc18xx_valid_pin_function(unsigned pin, unsigned function)
1280 {
1281         struct lpc18xx_pin_caps *p = lpc18xx_pins[pin].drv_data;
1282         int i;
1283
1284         if (function == FUNC_DAC && p->analog == DAC)
1285                 return true;
1286
1287         if (function == FUNC_ADC && p->analog)
1288                 return true;
1289
1290         if (function == FUNC_I2C0 && p->type == TYPE_I2C0)
1291                 return true;
1292
1293         if (function == FUNC_USB1 && p->type == TYPE_USB1)
1294                 return true;
1295
1296         for (i = 0; i < LPC18XX_SCU_FUNC_PER_PIN; i++) {
1297                 if (function == p->functions[i])
1298                         return true;
1299         }
1300
1301         return false;
1302 }
1303
1304 static int lpc18xx_create_group_func_map(struct device *dev,
1305                                          struct lpc18xx_scu_data *scu)
1306 {
1307         u16 pins[ARRAY_SIZE(lpc18xx_pins)];
1308         int func, ngroups, i;
1309
1310         for (func = 0; func < FUNC_MAX; func++) {
1311                 for (ngroups = 0, i = 0; i < ARRAY_SIZE(lpc18xx_pins); i++) {
1312                         if (lpc18xx_valid_pin_function(i, func))
1313                                 pins[ngroups++] = i;
1314                 }
1315
1316                 scu->func[func].ngroups = ngroups;
1317                 scu->func[func].groups = devm_kcalloc(dev,
1318                                                       ngroups, sizeof(char *),
1319                                                       GFP_KERNEL);
1320                 if (!scu->func[func].groups)
1321                         return -ENOMEM;
1322
1323                 for (i = 0; i < ngroups; i++)
1324                         scu->func[func].groups[i] = lpc18xx_pins[pins[i]].name;
1325         }
1326
1327         return 0;
1328 }
1329
1330 static int lpc18xx_scu_probe(struct platform_device *pdev)
1331 {
1332         struct lpc18xx_scu_data *scu;
1333         struct resource *res;
1334         int ret;
1335
1336         scu = devm_kzalloc(&pdev->dev, sizeof(*scu), GFP_KERNEL);
1337         if (!scu)
1338                 return -ENOMEM;
1339
1340         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1341         scu->base = devm_ioremap_resource(&pdev->dev, res);
1342         if (IS_ERR(scu->base))
1343                 return PTR_ERR(scu->base);
1344
1345         scu->clk = devm_clk_get(&pdev->dev, NULL);
1346         if (IS_ERR(scu->clk)) {
1347                 dev_err(&pdev->dev, "Input clock not found.\n");
1348                 return PTR_ERR(scu->clk);
1349         }
1350
1351         ret = lpc18xx_create_group_func_map(&pdev->dev, scu);
1352         if (ret) {
1353                 dev_err(&pdev->dev, "Unable to create group func map.\n");
1354                 return ret;
1355         }
1356
1357         ret = clk_prepare_enable(scu->clk);
1358         if (ret) {
1359                 dev_err(&pdev->dev, "Unable to enable clock.\n");
1360                 return ret;
1361         }
1362
1363         platform_set_drvdata(pdev, scu);
1364
1365         scu->pctl = devm_pinctrl_register(&pdev->dev, &lpc18xx_scu_desc, scu);
1366         if (IS_ERR(scu->pctl)) {
1367                 dev_err(&pdev->dev, "Could not register pinctrl driver\n");
1368                 clk_disable_unprepare(scu->clk);
1369                 return PTR_ERR(scu->pctl);
1370         }
1371
1372         return 0;
1373 }
1374
1375 static const struct of_device_id lpc18xx_scu_match[] = {
1376         { .compatible = "nxp,lpc1850-scu" },
1377         {},
1378 };
1379
1380 static struct platform_driver lpc18xx_scu_driver = {
1381         .probe          = lpc18xx_scu_probe,
1382         .driver = {
1383                 .name           = "lpc18xx-scu",
1384                 .of_match_table = lpc18xx_scu_match,
1385                 .suppress_bind_attrs = true,
1386         },
1387 };
1388 builtin_platform_driver(lpc18xx_scu_driver);