drivers/pinctrl/spear/pinctrl-spear310.c

   1 /*
   2  * Driver for the ST Microelectronics SPEAr310 pinmux
   3  *
   4  * Copyright (C) 2012 ST Microelectronics
   5  * Viresh Kumar <vireshk@kernel.org>
   6  *
   7  * This file is licensed under the terms of the GNU General Public
   8  * License version 2. This program is licensed "as is" without any
   9  * warranty of any kind, whether express or implied.
  10  */
  11
  12 #include <linux/err.h>
  13 #include <linux/init.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include "pinctrl-spear3xx.h"
  17
  18 #define DRIVER_NAME "spear310-pinmux"
  19
  20 /* addresses */
  21 #define PMX_CONFIG_REG                  0x08
  22
  23 /* emi_cs_0_to_5_pins */
  24 static const unsigned emi_cs_0_to_5_pins[] = { 45, 46, 47, 48, 49, 50 };
  25 static struct spear_muxreg emi_cs_0_to_5_muxreg[] = {
  26         {
  27                 .reg = PMX_CONFIG_REG,
  28                 .mask = PMX_TIMER_0_1_MASK | PMX_TIMER_2_3_MASK,
  29                 .val = 0,
  30         },
  31 };
  32
  33 static struct spear_modemux emi_cs_0_to_5_modemux[] = {
  34         {
  35                 .muxregs = emi_cs_0_to_5_muxreg,
  36                 .nmuxregs = ARRAY_SIZE(emi_cs_0_to_5_muxreg),
  37         },
  38 };
  39
  40 static struct spear_pingroup emi_cs_0_to_5_pingroup = {
  41         .name = "emi_cs_0_to_5_grp",
  42         .pins = emi_cs_0_to_5_pins,
  43         .npins = ARRAY_SIZE(emi_cs_0_to_5_pins),
  44         .modemuxs = emi_cs_0_to_5_modemux,
  45         .nmodemuxs = ARRAY_SIZE(emi_cs_0_to_5_modemux),
  46 };
  47
  48 static const char *const emi_cs_0_to_5_grps[] = { "emi_cs_0_to_5_grp" };
  49 static struct spear_function emi_cs_0_to_5_function = {
  50         .name = "emi",
  51         .groups = emi_cs_0_to_5_grps,
  52         .ngroups = ARRAY_SIZE(emi_cs_0_to_5_grps),
  53 };
  54
  55 /* uart1_pins */
  56 static const unsigned uart1_pins[] = { 0, 1 };
  57 static struct spear_muxreg uart1_muxreg[] = {
  58         {
  59                 .reg = PMX_CONFIG_REG,
  60                 .mask = PMX_FIRDA_MASK,
  61                 .val = 0,
  62         },
  63 };
  64
  65 static struct spear_modemux uart1_modemux[] = {
  66         {
  67                 .muxregs = uart1_muxreg,
  68                 .nmuxregs = ARRAY_SIZE(uart1_muxreg),
  69         },
  70 };
  71
  72 static struct spear_pingroup uart1_pingroup = {
  73         .name = "uart1_grp",
  74         .pins = uart1_pins,
  75         .npins = ARRAY_SIZE(uart1_pins),
  76         .modemuxs = uart1_modemux,
  77         .nmodemuxs = ARRAY_SIZE(uart1_modemux),
  78 };
  79
  80 static const char *const uart1_grps[] = { "uart1_grp" };
  81 static struct spear_function uart1_function = {
  82         .name = "uart1",
  83         .groups = uart1_grps,
  84         .ngroups = ARRAY_SIZE(uart1_grps),
  85 };
  86
  87 /* uart2_pins */
  88 static const unsigned uart2_pins[] = { 43, 44 };
  89 static struct spear_muxreg uart2_muxreg[] = {
  90         {
  91                 .reg = PMX_CONFIG_REG,
  92                 .mask = PMX_TIMER_0_1_MASK,
  93                 .val = 0,
  94         },
  95 };
  96
  97 static struct spear_modemux uart2_modemux[] = {
  98         {
  99                 .muxregs = uart2_muxreg,
 100                 .nmuxregs = ARRAY_SIZE(uart2_muxreg),
 101         },
 102 };
 103
 104 static struct spear_pingroup uart2_pingroup = {
 105         .name = "uart2_grp",
 106         .pins = uart2_pins,
 107         .npins = ARRAY_SIZE(uart2_pins),
 108         .modemuxs = uart2_modemux,
 109         .nmodemuxs = ARRAY_SIZE(uart2_modemux),
 110 };
 111
 112 static const char *const uart2_grps[] = { "uart2_grp" };
 113 static struct spear_function uart2_function = {
 114         .name = "uart2",
 115         .groups = uart2_grps,
 116         .ngroups = ARRAY_SIZE(uart2_grps),
 117 };
 118
 119 /* uart3_pins */
 120 static const unsigned uart3_pins[] = { 37, 38 };
 121 static struct spear_muxreg uart3_muxreg[] = {
 122         {
 123                 .reg = PMX_CONFIG_REG,
 124                 .mask = PMX_UART0_MODEM_MASK,
 125                 .val = 0,
 126         },
 127 };
 128
 129 static struct spear_modemux uart3_modemux[] = {
 130         {
 131                 .muxregs = uart3_muxreg,
 132                 .nmuxregs = ARRAY_SIZE(uart3_muxreg),
 133         },
 134 };
 135
 136 static struct spear_pingroup uart3_pingroup = {
 137         .name = "uart3_grp",
 138         .pins = uart3_pins,
 139         .npins = ARRAY_SIZE(uart3_pins),
 140         .modemuxs = uart3_modemux,
 141         .nmodemuxs = ARRAY_SIZE(uart3_modemux),
 142 };
 143
 144 static const char *const uart3_grps[] = { "uart3_grp" };
 145 static struct spear_function uart3_function = {
 146         .name = "uart3",
 147         .groups = uart3_grps,
 148         .ngroups = ARRAY_SIZE(uart3_grps),
 149 };
 150
 151 /* uart4_pins */
 152 static const unsigned uart4_pins[] = { 39, 40 };
 153 static struct spear_muxreg uart4_muxreg[] = {
 154         {
 155                 .reg = PMX_CONFIG_REG,
 156                 .mask = PMX_UART0_MODEM_MASK,
 157                 .val = 0,
 158         },
 159 };
 160
 161 static struct spear_modemux uart4_modemux[] = {
 162         {
 163                 .muxregs = uart4_muxreg,
 164                 .nmuxregs = ARRAY_SIZE(uart4_muxreg),
 165         },
 166 };
 167
 168 static struct spear_pingroup uart4_pingroup = {
 169         .name = "uart4_grp",
 170         .pins = uart4_pins,
 171         .npins = ARRAY_SIZE(uart4_pins),
 172         .modemuxs = uart4_modemux,
 173         .nmodemuxs = ARRAY_SIZE(uart4_modemux),
 174 };
 175
 176 static const char *const uart4_grps[] = { "uart4_grp" };
 177 static struct spear_function uart4_function = {
 178         .name = "uart4",
 179         .groups = uart4_grps,
 180         .ngroups = ARRAY_SIZE(uart4_grps),
 181 };
 182
 183 /* uart5_pins */
 184 static const unsigned uart5_pins[] = { 41, 42 };
 185 static struct spear_muxreg uart5_muxreg[] = {
 186         {
 187                 .reg = PMX_CONFIG_REG,
 188                 .mask = PMX_UART0_MODEM_MASK,
 189                 .val = 0,
 190         },
 191 };
 192
 193 static struct spear_modemux uart5_modemux[] = {
 194         {
 195                 .muxregs = uart5_muxreg,
 196                 .nmuxregs = ARRAY_SIZE(uart5_muxreg),
 197         },
 198 };
 199
 200 static struct spear_pingroup uart5_pingroup = {
 201         .name = "uart5_grp",
 202         .pins = uart5_pins,
 203         .npins = ARRAY_SIZE(uart5_pins),
 204         .modemuxs = uart5_modemux,
 205         .nmodemuxs = ARRAY_SIZE(uart5_modemux),
 206 };
 207
 208 static const char *const uart5_grps[] = { "uart5_grp" };
 209 static struct spear_function uart5_function = {
 210         .name = "uart5",
 211         .groups = uart5_grps,
 212         .ngroups = ARRAY_SIZE(uart5_grps),
 213 };
 214
 215 /* fsmc_pins */
 216 static const unsigned fsmc_pins[] = { 34, 35, 36 };
 217 static struct spear_muxreg fsmc_muxreg[] = {
 218         {
 219                 .reg = PMX_CONFIG_REG,
 220                 .mask = PMX_SSP_CS_MASK,
 221                 .val = 0,
 222         },
 223 };
 224
 225 static struct spear_modemux fsmc_modemux[] = {
 226         {
 227                 .muxregs = fsmc_muxreg,
 228                 .nmuxregs = ARRAY_SIZE(fsmc_muxreg),
 229         },
 230 };
 231
 232 static struct spear_pingroup fsmc_pingroup = {
 233         .name = "fsmc_grp",
 234         .pins = fsmc_pins,
 235         .npins = ARRAY_SIZE(fsmc_pins),
 236         .modemuxs = fsmc_modemux,
 237         .nmodemuxs = ARRAY_SIZE(fsmc_modemux),
 238 };
 239
 240 static const char *const fsmc_grps[] = { "fsmc_grp" };
 241 static struct spear_function fsmc_function = {
 242         .name = "fsmc",
 243         .groups = fsmc_grps,
 244         .ngroups = ARRAY_SIZE(fsmc_grps),
 245 };
 246
 247 /* rs485_0_pins */
 248 static const unsigned rs485_0_pins[] = { 19, 20, 21, 22, 23 };
 249 static struct spear_muxreg rs485_0_muxreg[] = {
 250         {
 251                 .reg = PMX_CONFIG_REG,
 252                 .mask = PMX_MII_MASK,
 253                 .val = 0,
 254         },
 255 };
 256
 257 static struct spear_modemux rs485_0_modemux[] = {
 258         {
 259                 .muxregs = rs485_0_muxreg,
 260                 .nmuxregs = ARRAY_SIZE(rs485_0_muxreg),
 261         },
 262 };
 263
 264 static struct spear_pingroup rs485_0_pingroup = {
 265         .name = "rs485_0_grp",
 266         .pins = rs485_0_pins,
 267         .npins = ARRAY_SIZE(rs485_0_pins),
 268         .modemuxs = rs485_0_modemux,
 269         .nmodemuxs = ARRAY_SIZE(rs485_0_modemux),
 270 };
 271
 272 static const char *const rs485_0_grps[] = { "rs485_0" };
 273 static struct spear_function rs485_0_function = {
 274         .name = "rs485_0",
 275         .groups = rs485_0_grps,
 276         .ngroups = ARRAY_SIZE(rs485_0_grps),
 277 };
 278
 279 /* rs485_1_pins */
 280 static const unsigned rs485_1_pins[] = { 14, 15, 16, 17, 18 };
 281 static struct spear_muxreg rs485_1_muxreg[] = {
 282         {
 283                 .reg = PMX_CONFIG_REG,
 284                 .mask = PMX_MII_MASK,
 285                 .val = 0,
 286         },
 287 };
 288
 289 static struct spear_modemux rs485_1_modemux[] = {
 290         {
 291                 .muxregs = rs485_1_muxreg,
 292                 .nmuxregs = ARRAY_SIZE(rs485_1_muxreg),
 293         },
 294 };
 295
 296 static struct spear_pingroup rs485_1_pingroup = {
 297         .name = "rs485_1_grp",
 298         .pins = rs485_1_pins,
 299         .npins = ARRAY_SIZE(rs485_1_pins),
 300         .modemuxs = rs485_1_modemux,
 301         .nmodemuxs = ARRAY_SIZE(rs485_1_modemux),
 302 };
 303
 304 static const char *const rs485_1_grps[] = { "rs485_1" };
 305 static struct spear_function rs485_1_function = {
 306         .name = "rs485_1",
 307         .groups = rs485_1_grps,
 308         .ngroups = ARRAY_SIZE(rs485_1_grps),
 309 };
 310
 311 /* tdm_pins */
 312 static const unsigned tdm_pins[] = { 10, 11, 12, 13 };
 313 static struct spear_muxreg tdm_muxreg[] = {
 314         {
 315                 .reg = PMX_CONFIG_REG,
 316                 .mask = PMX_MII_MASK,
 317                 .val = 0,
 318         },
 319 };
 320
 321 static struct spear_modemux tdm_modemux[] = {
 322         {
 323                 .muxregs = tdm_muxreg,
 324                 .nmuxregs = ARRAY_SIZE(tdm_muxreg),
 325         },
 326 };
 327
 328 static struct spear_pingroup tdm_pingroup = {
 329         .name = "tdm_grp",
 330         .pins = tdm_pins,
 331         .npins = ARRAY_SIZE(tdm_pins),
 332         .modemuxs = tdm_modemux,
 333         .nmodemuxs = ARRAY_SIZE(tdm_modemux),
 334 };
 335
 336 static const char *const tdm_grps[] = { "tdm_grp" };
 337 static struct spear_function tdm_function = {
 338         .name = "tdm",
 339         .groups = tdm_grps,
 340         .ngroups = ARRAY_SIZE(tdm_grps),
 341 };
 342
 343 /* pingroups */
 344 static struct spear_pingroup *spear310_pingroups[] = {
 345         SPEAR3XX_COMMON_PINGROUPS,
 346         &emi_cs_0_to_5_pingroup,
 347         &uart1_pingroup,
 348         &uart2_pingroup,
 349         &uart3_pingroup,
 350         &uart4_pingroup,
 351         &uart5_pingroup,
 352         &fsmc_pingroup,
 353         &rs485_0_pingroup,
 354         &rs485_1_pingroup,
 355         &tdm_pingroup,
 356 };
 357
 358 /* functions */
 359 static struct spear_function *spear310_functions[] = {
 360         SPEAR3XX_COMMON_FUNCTIONS,
 361         &emi_cs_0_to_5_function,
 362         &uart1_function,
 363         &uart2_function,
 364         &uart3_function,
 365         &uart4_function,
 366         &uart5_function,
 367         &fsmc_function,
 368         &rs485_0_function,
 369         &rs485_1_function,
 370         &tdm_function,
 371 };
 372
 373 static const struct of_device_id spear310_pinctrl_of_match[] = {
 374         {
 375                 .compatible = "st,spear310-pinmux",
 376         },
 377         {},
 378 };
 379
 380 static int spear310_pinctrl_probe(struct platform_device *pdev)
 381 {
 382         int ret;
 383
 384         spear3xx_machdata.groups = spear310_pingroups;
 385         spear3xx_machdata.ngroups = ARRAY_SIZE(spear310_pingroups);
 386         spear3xx_machdata.functions = spear310_functions;
 387         spear3xx_machdata.nfunctions = ARRAY_SIZE(spear310_functions);
 388
 389         pmx_init_addr(&spear3xx_machdata, PMX_CONFIG_REG);
 390         pmx_init_gpio_pingroup_addr(spear3xx_machdata.gpio_pingroups,
 391                         spear3xx_machdata.ngpio_pingroups, PMX_CONFIG_REG);
 392
 393         spear3xx_machdata.modes_supported = false;
 394
 395         ret = spear_pinctrl_probe(pdev, &spear3xx_machdata);
 396         if (ret)
 397                 return ret;
 398
 399         return 0;
 400 }
 401
 402 static struct platform_driver spear310_pinctrl_driver = {
 403         .driver = {
 404                 .name = DRIVER_NAME,
 405                 .of_match_table = spear310_pinctrl_of_match,
 406         },
 407         .probe = spear310_pinctrl_probe,
 408 };
 409
 410 static int __init spear310_pinctrl_init(void)
 411 {
 412         return platform_driver_register(&spear310_pinctrl_driver);
 413 }
 414 arch_initcall(spear310_pinctrl_init);