arch/arm/cpu/armv7/exynos/pinmux.c

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics.
   3  * Abhilash Kesavan <a.kesavan@samsung.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <fdtdec.h>
  10 #include <asm/arch/gpio.h>
  11 #include <asm/arch/pinmux.h>
  12 #include <asm/arch/sromc.h>
  13
  14 static void exynos5_uart_config(int peripheral)
  15 {
  16         int i, start, count;
  17
  18         switch (peripheral) {
  19         case PERIPH_ID_UART0:
  20                 start = EXYNOS5_GPIO_A00;
  21                 count = 4;
  22                 break;
  23         case PERIPH_ID_UART1:
  24                 start = EXYNOS5_GPIO_D00;
  25                 count = 4;
  26                 break;
  27         case PERIPH_ID_UART2:
  28                 start = EXYNOS5_GPIO_A10;
  29                 count = 4;
  30                 break;
  31         case PERIPH_ID_UART3:
  32                 start = EXYNOS5_GPIO_A14;
  33                 count = 2;
  34                 break;
  35         default:
  36                 debug("%s: invalid peripheral %d", __func__, peripheral);
  37                 return;
  38         }
  39         for (i = start; i < start + count; i++) {
  40                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
  41                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
  42         }
  43 }
  44
  45 static void exynos5420_uart_config(int peripheral)
  46 {
  47         int i, start, count;
  48
  49         switch (peripheral) {
  50         case PERIPH_ID_UART0:
  51                 start = EXYNOS5420_GPIO_A00;
  52                 count = 4;
  53                 break;
  54         case PERIPH_ID_UART1:
  55                 start = EXYNOS5420_GPIO_A04;
  56                 count = 4;
  57                 break;
  58         case PERIPH_ID_UART2:
  59                 start = EXYNOS5420_GPIO_A10;
  60                 count = 4;
  61                 break;
  62         case PERIPH_ID_UART3:
  63                 start = EXYNOS5420_GPIO_A14;
  64                 count = 2;
  65                 break;
  66         default:
  67                 debug("%s: invalid peripheral %d", __func__, peripheral);
  68                 return;
  69         }
  70
  71         for (i = start; i < start + count; i++) {
  72                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
  73                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
  74         }
  75 }
  76
  77 static int exynos5_mmc_config(int peripheral, int flags)
  78 {
  79         int i, start, start_ext, gpio_func = 0;
  80
  81         switch (peripheral) {
  82         case PERIPH_ID_SDMMC0:
  83                 start = EXYNOS5_GPIO_C00;
  84                 start_ext = EXYNOS5_GPIO_C10;
  85                 gpio_func = S5P_GPIO_FUNC(0x2);
  86                 break;
  87         case PERIPH_ID_SDMMC1:
  88                 start = EXYNOS5_GPIO_C20;
  89                 start_ext = 0;
  90                 break;
  91         case PERIPH_ID_SDMMC2:
  92                 start = EXYNOS5_GPIO_C30;
  93                 start_ext = EXYNOS5_GPIO_C43;
  94                 gpio_func = S5P_GPIO_FUNC(0x3);
  95                 break;
  96         case PERIPH_ID_SDMMC3:
  97                 start = EXYNOS5_GPIO_C40;
  98                 start_ext = 0;
  99                 break;
 100         default:
 101                 debug("%s: invalid peripheral %d", __func__, peripheral);
 102                 return -1;
 103         }
 104         if ((flags & PINMUX_FLAG_8BIT_MODE) && !start_ext) {
 105                 debug("SDMMC device %d does not support 8bit mode",
 106                                 peripheral);
 107                 return -1;
 108         }
 109         if (flags & PINMUX_FLAG_8BIT_MODE) {
 110                 for (i = start_ext; i <= (start_ext + 3); i++) {
 111                         gpio_cfg_pin(i, gpio_func);
 112                         gpio_set_pull(i, S5P_GPIO_PULL_UP);
 113                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 114                 }
 115         }
 116         for (i = start; i < (start + 2); i++) {
 117                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 118                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 119                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 120         }
 121         for (i = (start + 3); i <= (start + 6); i++) {
 122                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 123                 gpio_set_pull(i, S5P_GPIO_PULL_UP);
 124                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 125         }
 126
 127         return 0;
 128 }
 129
 130 static int exynos5420_mmc_config(int peripheral, int flags)
 131 {
 132         int i, start = 0, start_ext = 0;
 133
 134         switch (peripheral) {
 135         case PERIPH_ID_SDMMC0:
 136                 start = EXYNOS5420_GPIO_C00;
 137                 start_ext = EXYNOS5420_GPIO_C30;
 138                 break;
 139         case PERIPH_ID_SDMMC1:
 140                 start = EXYNOS5420_GPIO_C10;
 141                 start_ext = EXYNOS5420_GPIO_D14;
 142                 break;
 143         case PERIPH_ID_SDMMC2:
 144                 start = EXYNOS5420_GPIO_C20;
 145                 start_ext = 0;
 146                 break;
 147         default:
 148                 start = 0;
 149                 debug("%s: invalid peripheral %d", __func__, peripheral);
 150                 return -1;
 151         }
 152
 153         if ((flags & PINMUX_FLAG_8BIT_MODE) && !start_ext) {
 154                 debug("SDMMC device %d does not support 8bit mode",
 155                       peripheral);
 156                 return -1;
 157         }
 158
 159         if (flags & PINMUX_FLAG_8BIT_MODE) {
 160                 for (i = start_ext; i <= (start_ext + 3); i++) {
 161                         gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 162                         gpio_set_pull(i, S5P_GPIO_PULL_UP);
 163                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 164                 }
 165         }
 166
 167         for (i = start; i < (start + 3); i++) {
 168                 /*
 169                  * MMC0 is intended to be used for eMMC. The
 170                  * card detect pin is used as a VDDEN signal to
 171                  * power on the eMMC. The 5420 iROM makes
 172                  * this same assumption.
 173                  */
 174                 if ((peripheral == PERIPH_ID_SDMMC0) && (i == (start + 2))) {
 175                         gpio_set_value(i, 1);
 176                         gpio_cfg_pin(i, S5P_GPIO_OUTPUT);
 177                 } else {
 178                         gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 179                 }
 180                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 181                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 182         }
 183
 184         for (i = (start + 3); i <= (start + 6); i++) {
 185                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 186                 gpio_set_pull(i, S5P_GPIO_PULL_UP);
 187                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 188         }
 189
 190         return 0;
 191 }
 192
 193 static void exynos5_sromc_config(int flags)
 194 {
 195         int i;
 196
 197         /*
 198          * SROM:CS1 and EBI
 199          *
 200          * GPY0[0]      SROM_CSn[0]
 201          * GPY0[1]      SROM_CSn[1](2)
 202          * GPY0[2]      SROM_CSn[2]
 203          * GPY0[3]      SROM_CSn[3]
 204          * GPY0[4]      EBI_OEn(2)
 205          * GPY0[5]      EBI_EEn(2)
 206          *
 207          * GPY1[0]      EBI_BEn[0](2)
 208          * GPY1[1]      EBI_BEn[1](2)
 209          * GPY1[2]      SROM_WAIT(2)
 210          * GPY1[3]      EBI_DATA_RDn(2)
 211          */
 212         gpio_cfg_pin(EXYNOS5_GPIO_Y00 + (flags & PINMUX_FLAG_BANK),
 213                      S5P_GPIO_FUNC(2));
 214         gpio_cfg_pin(EXYNOS5_GPIO_Y04, S5P_GPIO_FUNC(2));
 215         gpio_cfg_pin(EXYNOS5_GPIO_Y05, S5P_GPIO_FUNC(2));
 216
 217         for (i = 0; i < 4; i++)
 218                 gpio_cfg_pin(EXYNOS5_GPIO_Y10 + i, S5P_GPIO_FUNC(2));
 219
 220         /*
 221          * EBI: 8 Addrss Lines
 222          *
 223          * GPY3[0]      EBI_ADDR[0](2)
 224          * GPY3[1]      EBI_ADDR[1](2)
 225          * GPY3[2]      EBI_ADDR[2](2)
 226          * GPY3[3]      EBI_ADDR[3](2)
 227          * GPY3[4]      EBI_ADDR[4](2)
 228          * GPY3[5]      EBI_ADDR[5](2)
 229          * GPY3[6]      EBI_ADDR[6](2)
 230          * GPY3[7]      EBI_ADDR[7](2)
 231          *
 232          * EBI: 16 Data Lines
 233          *
 234          * GPY5[0]      EBI_DATA[0](2)
 235          * GPY5[1]      EBI_DATA[1](2)
 236          * GPY5[2]      EBI_DATA[2](2)
 237          * GPY5[3]      EBI_DATA[3](2)
 238          * GPY5[4]      EBI_DATA[4](2)
 239          * GPY5[5]      EBI_DATA[5](2)
 240          * GPY5[6]      EBI_DATA[6](2)
 241          * GPY5[7]      EBI_DATA[7](2)
 242          *
 243          * GPY6[0]      EBI_DATA[8](2)
 244          * GPY6[1]      EBI_DATA[9](2)
 245          * GPY6[2]      EBI_DATA[10](2)
 246          * GPY6[3]      EBI_DATA[11](2)
 247          * GPY6[4]      EBI_DATA[12](2)
 248          * GPY6[5]      EBI_DATA[13](2)
 249          * GPY6[6]      EBI_DATA[14](2)
 250          * GPY6[7]      EBI_DATA[15](2)
 251          */
 252         for (i = 0; i < 8; i++) {
 253                 gpio_cfg_pin(EXYNOS5_GPIO_Y30 + i, S5P_GPIO_FUNC(2));
 254                 gpio_set_pull(EXYNOS5_GPIO_Y30 + i, S5P_GPIO_PULL_UP);
 255
 256                 gpio_cfg_pin(EXYNOS5_GPIO_Y50 + i, S5P_GPIO_FUNC(2));
 257                 gpio_set_pull(EXYNOS5_GPIO_Y50 + i, S5P_GPIO_PULL_UP);
 258
 259                 gpio_cfg_pin(EXYNOS5_GPIO_Y60 + i, S5P_GPIO_FUNC(2));
 260                 gpio_set_pull(EXYNOS5_GPIO_Y60 + i, S5P_GPIO_PULL_UP);
 261         }
 262 }
 263
 264 static void exynos5_i2c_config(int peripheral, int flags)
 265 {
 266         switch (peripheral) {
 267         case PERIPH_ID_I2C0:
 268                 gpio_cfg_pin(EXYNOS5_GPIO_B30, S5P_GPIO_FUNC(0x2));
 269                 gpio_cfg_pin(EXYNOS5_GPIO_B31, S5P_GPIO_FUNC(0x2));
 270                 break;
 271         case PERIPH_ID_I2C1:
 272                 gpio_cfg_pin(EXYNOS5_GPIO_B32, S5P_GPIO_FUNC(0x2));
 273                 gpio_cfg_pin(EXYNOS5_GPIO_B33, S5P_GPIO_FUNC(0x2));
 274                 break;
 275         case PERIPH_ID_I2C2:
 276                 gpio_cfg_pin(EXYNOS5_GPIO_A06, S5P_GPIO_FUNC(0x3));
 277                 gpio_cfg_pin(EXYNOS5_GPIO_A07, S5P_GPIO_FUNC(0x3));
 278                 break;
 279         case PERIPH_ID_I2C3:
 280                 gpio_cfg_pin(EXYNOS5_GPIO_A12, S5P_GPIO_FUNC(0x3));
 281                 gpio_cfg_pin(EXYNOS5_GPIO_A13, S5P_GPIO_FUNC(0x3));
 282                 break;
 283         case PERIPH_ID_I2C4:
 284                 gpio_cfg_pin(EXYNOS5_GPIO_A20, S5P_GPIO_FUNC(0x3));
 285                 gpio_cfg_pin(EXYNOS5_GPIO_A21, S5P_GPIO_FUNC(0x3));
 286                 break;
 287         case PERIPH_ID_I2C5:
 288                 gpio_cfg_pin(EXYNOS5_GPIO_A22, S5P_GPIO_FUNC(0x3));
 289                 gpio_cfg_pin(EXYNOS5_GPIO_A23, S5P_GPIO_FUNC(0x3));
 290                 break;
 291         case PERIPH_ID_I2C6:
 292                 gpio_cfg_pin(EXYNOS5_GPIO_B13, S5P_GPIO_FUNC(0x4));
 293                 gpio_cfg_pin(EXYNOS5_GPIO_B14, S5P_GPIO_FUNC(0x4));
 294                 break;
 295         case PERIPH_ID_I2C7:
 296                 gpio_cfg_pin(EXYNOS5_GPIO_B22, S5P_GPIO_FUNC(0x3));
 297                 gpio_cfg_pin(EXYNOS5_GPIO_B23, S5P_GPIO_FUNC(0x3));
 298                 break;
 299         }
 300 }
 301
 302 static void exynos5420_i2c_config(int peripheral)
 303 {
 304         switch (peripheral) {
 305         case PERIPH_ID_I2C0:
 306                 gpio_cfg_pin(EXYNOS5420_GPIO_B30, S5P_GPIO_FUNC(0x2));
 307                 gpio_cfg_pin(EXYNOS5420_GPIO_B31, S5P_GPIO_FUNC(0x2));
 308                 break;
 309         case PERIPH_ID_I2C1:
 310                 gpio_cfg_pin(EXYNOS5420_GPIO_B32, S5P_GPIO_FUNC(0x2));
 311                 gpio_cfg_pin(EXYNOS5420_GPIO_B33, S5P_GPIO_FUNC(0x2));
 312                 break;
 313         case PERIPH_ID_I2C2:
 314                 gpio_cfg_pin(EXYNOS5420_GPIO_A06, S5P_GPIO_FUNC(0x3));
 315                 gpio_cfg_pin(EXYNOS5420_GPIO_A07, S5P_GPIO_FUNC(0x3));
 316                 break;
 317         case PERIPH_ID_I2C3:
 318                 gpio_cfg_pin(EXYNOS5420_GPIO_A12, S5P_GPIO_FUNC(0x3));
 319                 gpio_cfg_pin(EXYNOS5420_GPIO_A13, S5P_GPIO_FUNC(0x3));
 320                 break;
 321         case PERIPH_ID_I2C4:
 322                 gpio_cfg_pin(EXYNOS5420_GPIO_A20, S5P_GPIO_FUNC(0x3));
 323                 gpio_cfg_pin(EXYNOS5420_GPIO_A21, S5P_GPIO_FUNC(0x3));
 324                 break;
 325         case PERIPH_ID_I2C5:
 326                 gpio_cfg_pin(EXYNOS5420_GPIO_A22, S5P_GPIO_FUNC(0x3));
 327                 gpio_cfg_pin(EXYNOS5420_GPIO_A23, S5P_GPIO_FUNC(0x3));
 328                 break;
 329         case PERIPH_ID_I2C6:
 330                 gpio_cfg_pin(EXYNOS5420_GPIO_B13, S5P_GPIO_FUNC(0x4));
 331                 gpio_cfg_pin(EXYNOS5420_GPIO_B14, S5P_GPIO_FUNC(0x4));
 332                 break;
 333         case PERIPH_ID_I2C7:
 334                 gpio_cfg_pin(EXYNOS5420_GPIO_B22, S5P_GPIO_FUNC(0x3));
 335                 gpio_cfg_pin(EXYNOS5420_GPIO_B23, S5P_GPIO_FUNC(0x3));
 336                 break;
 337         case PERIPH_ID_I2C8:
 338                 gpio_cfg_pin(EXYNOS5420_GPIO_B34, S5P_GPIO_FUNC(0x2));
 339                 gpio_cfg_pin(EXYNOS5420_GPIO_B35, S5P_GPIO_FUNC(0x2));
 340                 break;
 341         case PERIPH_ID_I2C9:
 342                 gpio_cfg_pin(EXYNOS5420_GPIO_B36, S5P_GPIO_FUNC(0x2));
 343                 gpio_cfg_pin(EXYNOS5420_GPIO_B37, S5P_GPIO_FUNC(0x2));
 344                 break;
 345         case PERIPH_ID_I2C10:
 346                 gpio_cfg_pin(EXYNOS5420_GPIO_B40, S5P_GPIO_FUNC(0x2));
 347                 gpio_cfg_pin(EXYNOS5420_GPIO_B41, S5P_GPIO_FUNC(0x2));
 348                 break;
 349         }
 350 }
 351
 352 static void exynos5_i2s_config(int peripheral)
 353 {
 354         int i;
 355
 356         switch (peripheral) {
 357         case PERIPH_ID_I2S0:
 358                 for (i = 0; i < 5; i++)
 359                         gpio_cfg_pin(EXYNOS5_GPIO_Z0 + i, S5P_GPIO_FUNC(0x02));
 360                 break;
 361         case PERIPH_ID_I2S1:
 362                 for (i = 0; i < 5; i++)
 363                         gpio_cfg_pin(EXYNOS5_GPIO_B00 + i, S5P_GPIO_FUNC(0x02));
 364                 break;
 365         }
 366 }
 367
 368 void exynos5_spi_config(int peripheral)
 369 {
 370         int cfg = 0, pin = 0, i;
 371
 372         switch (peripheral) {
 373         case PERIPH_ID_SPI0:
 374                 cfg = S5P_GPIO_FUNC(0x2);
 375                 pin = EXYNOS5_GPIO_A20;
 376                 break;
 377         case PERIPH_ID_SPI1:
 378                 cfg = S5P_GPIO_FUNC(0x2);
 379                 pin = EXYNOS5_GPIO_A24;
 380                 break;
 381         case PERIPH_ID_SPI2:
 382                 cfg = S5P_GPIO_FUNC(0x5);
 383                 pin = EXYNOS5_GPIO_B11;
 384                 break;
 385         case PERIPH_ID_SPI3:
 386                 cfg = S5P_GPIO_FUNC(0x2);
 387                 pin = EXYNOS5_GPIO_F10;
 388                 break;
 389         case PERIPH_ID_SPI4:
 390                 for (i = 0; i < 2; i++) {
 391                         gpio_cfg_pin(EXYNOS5_GPIO_F02 + i, S5P_GPIO_FUNC(0x4));
 392                         gpio_cfg_pin(EXYNOS5_GPIO_E04 + i, S5P_GPIO_FUNC(0x4));
 393                 }
 394                 break;
 395         }
 396         if (peripheral != PERIPH_ID_SPI4) {
 397                 for (i = pin; i < pin + 4; i++)
 398                         gpio_cfg_pin(i, cfg);
 399         }
 400 }
 401
 402 void exynos5420_spi_config(int peripheral)
 403 {
 404         int cfg, pin, i;
 405
 406         switch (peripheral) {
 407         case PERIPH_ID_SPI0:
 408                 pin = EXYNOS5420_GPIO_A20;
 409                 cfg = S5P_GPIO_FUNC(0x2);
 410                 break;
 411         case PERIPH_ID_SPI1:
 412                 pin = EXYNOS5420_GPIO_A24;
 413                 cfg = S5P_GPIO_FUNC(0x2);
 414                 break;
 415         case PERIPH_ID_SPI2:
 416                 pin = EXYNOS5420_GPIO_B11;
 417                 cfg = S5P_GPIO_FUNC(0x5);
 418                 break;
 419         case PERIPH_ID_SPI3:
 420                 pin = EXYNOS5420_GPIO_F10;
 421                 cfg = S5P_GPIO_FUNC(0x2);
 422                 break;
 423         case PERIPH_ID_SPI4:
 424                 cfg = 0;
 425                 pin = 0;
 426                 break;
 427         default:
 428                 cfg = 0;
 429                 pin = 0;
 430                 debug("%s: invalid peripheral %d", __func__, peripheral);
 431                 return;
 432         }
 433
 434         if (peripheral != PERIPH_ID_SPI4) {
 435                 for (i = pin; i < pin + 4; i++)
 436                         gpio_cfg_pin(i, cfg);
 437         } else {
 438                 for (i = 0; i < 2; i++) {
 439                         gpio_cfg_pin(EXYNOS5420_GPIO_F02 + i,
 440                                      S5P_GPIO_FUNC(0x4));
 441                         gpio_cfg_pin(EXYNOS5420_GPIO_E04 + i,
 442                                      S5P_GPIO_FUNC(0x4));
 443                 }
 444         }
 445 }
 446
 447 static int exynos5_pinmux_config(int peripheral, int flags)
 448 {
 449         switch (peripheral) {
 450         case PERIPH_ID_UART0:
 451         case PERIPH_ID_UART1:
 452         case PERIPH_ID_UART2:
 453         case PERIPH_ID_UART3:
 454                 exynos5_uart_config(peripheral);
 455                 break;
 456         case PERIPH_ID_SDMMC0:
 457         case PERIPH_ID_SDMMC1:
 458         case PERIPH_ID_SDMMC2:
 459         case PERIPH_ID_SDMMC3:
 460                 return exynos5_mmc_config(peripheral, flags);
 461         case PERIPH_ID_SROMC:
 462                 exynos5_sromc_config(flags);
 463                 break;
 464         case PERIPH_ID_I2C0:
 465         case PERIPH_ID_I2C1:
 466         case PERIPH_ID_I2C2:
 467         case PERIPH_ID_I2C3:
 468         case PERIPH_ID_I2C4:
 469         case PERIPH_ID_I2C5:
 470         case PERIPH_ID_I2C6:
 471         case PERIPH_ID_I2C7:
 472                 exynos5_i2c_config(peripheral, flags);
 473                 break;
 474         case PERIPH_ID_I2S0:
 475         case PERIPH_ID_I2S1:
 476                 exynos5_i2s_config(peripheral);
 477                 break;
 478         case PERIPH_ID_SPI0:
 479         case PERIPH_ID_SPI1:
 480         case PERIPH_ID_SPI2:
 481         case PERIPH_ID_SPI3:
 482         case PERIPH_ID_SPI4:
 483                 exynos5_spi_config(peripheral);
 484                 break;
 485         default:
 486                 debug("%s: invalid peripheral %d", __func__, peripheral);
 487                 return -1;
 488         }
 489
 490         return 0;
 491 }
 492
 493 static int exynos5420_pinmux_config(int peripheral, int flags)
 494 {
 495         switch (peripheral) {
 496         case PERIPH_ID_UART0:
 497         case PERIPH_ID_UART1:
 498         case PERIPH_ID_UART2:
 499         case PERIPH_ID_UART3:
 500                 exynos5420_uart_config(peripheral);
 501                 break;
 502         case PERIPH_ID_SDMMC0:
 503         case PERIPH_ID_SDMMC1:
 504         case PERIPH_ID_SDMMC2:
 505         case PERIPH_ID_SDMMC3:
 506                 return exynos5420_mmc_config(peripheral, flags);
 507         case PERIPH_ID_SPI0:
 508         case PERIPH_ID_SPI1:
 509         case PERIPH_ID_SPI2:
 510         case PERIPH_ID_SPI3:
 511         case PERIPH_ID_SPI4:
 512                 exynos5420_spi_config(peripheral);
 513                 break;
 514         case PERIPH_ID_I2C0:
 515         case PERIPH_ID_I2C1:
 516         case PERIPH_ID_I2C2:
 517         case PERIPH_ID_I2C3:
 518         case PERIPH_ID_I2C4:
 519         case PERIPH_ID_I2C5:
 520         case PERIPH_ID_I2C6:
 521         case PERIPH_ID_I2C7:
 522         case PERIPH_ID_I2C8:
 523         case PERIPH_ID_I2C9:
 524         case PERIPH_ID_I2C10:
 525                 exynos5420_i2c_config(peripheral);
 526                 break;
 527         default:
 528                 debug("%s: invalid peripheral %d", __func__, peripheral);
 529                 return -1;
 530         }
 531
 532         return 0;
 533 }
 534
 535 static void exynos4_i2c_config(int peripheral, int flags)
 536 {
 537         switch (peripheral) {
 538         case PERIPH_ID_I2C0:
 539                 gpio_cfg_pin(EXYNOS4_GPIO_D10, S5P_GPIO_FUNC(0x2));
 540                 gpio_cfg_pin(EXYNOS4_GPIO_D11, S5P_GPIO_FUNC(0x2));
 541                 break;
 542         case PERIPH_ID_I2C1:
 543                 gpio_cfg_pin(EXYNOS4_GPIO_D12, S5P_GPIO_FUNC(0x2));
 544                 gpio_cfg_pin(EXYNOS4_GPIO_D13, S5P_GPIO_FUNC(0x2));
 545                 break;
 546         case PERIPH_ID_I2C2:
 547                 gpio_cfg_pin(EXYNOS4_GPIO_A06, S5P_GPIO_FUNC(0x3));
 548                 gpio_cfg_pin(EXYNOS4_GPIO_A07, S5P_GPIO_FUNC(0x3));
 549                 break;
 550         case PERIPH_ID_I2C3:
 551                 gpio_cfg_pin(EXYNOS4_GPIO_A12, S5P_GPIO_FUNC(0x3));
 552                 gpio_cfg_pin(EXYNOS4_GPIO_A13, S5P_GPIO_FUNC(0x3));
 553                 break;
 554         case PERIPH_ID_I2C4:
 555                 gpio_cfg_pin(EXYNOS4_GPIO_B2, S5P_GPIO_FUNC(0x3));
 556                 gpio_cfg_pin(EXYNOS4_GPIO_B3, S5P_GPIO_FUNC(0x3));
 557                 break;
 558         case PERIPH_ID_I2C5:
 559                 gpio_cfg_pin(EXYNOS4_GPIO_B6, S5P_GPIO_FUNC(0x3));
 560                 gpio_cfg_pin(EXYNOS4_GPIO_B7, S5P_GPIO_FUNC(0x3));
 561                 break;
 562         case PERIPH_ID_I2C6:
 563                 gpio_cfg_pin(EXYNOS4_GPIO_C13, S5P_GPIO_FUNC(0x4));
 564                 gpio_cfg_pin(EXYNOS4_GPIO_C14, S5P_GPIO_FUNC(0x4));
 565                 break;
 566         case PERIPH_ID_I2C7:
 567                 gpio_cfg_pin(EXYNOS4_GPIO_D02, S5P_GPIO_FUNC(0x3));
 568                 gpio_cfg_pin(EXYNOS4_GPIO_D03, S5P_GPIO_FUNC(0x3));
 569                 break;
 570         }
 571 }
 572
 573 static int exynos4_mmc_config(int peripheral, int flags)
 574 {
 575         int i, start = 0, start_ext = 0;
 576
 577         switch (peripheral) {
 578         case PERIPH_ID_SDMMC0:
 579                 start = EXYNOS4_GPIO_K00;
 580                 start_ext = EXYNOS4_GPIO_K13;
 581                 break;
 582         case PERIPH_ID_SDMMC2:
 583                 start = EXYNOS4_GPIO_K20;
 584                 start_ext = EXYNOS4_GPIO_K33;
 585                 break;
 586         default:
 587                 return -1;
 588         }
 589         for (i = start; i < (start + 7); i++) {
 590                 if (i == (start + 2))
 591                         continue;
 592                 gpio_cfg_pin(i,  S5P_GPIO_FUNC(0x2));
 593                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 594                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 595         }
 596         if (flags & PINMUX_FLAG_8BIT_MODE) {
 597                 for (i = start_ext; i < (start_ext + 4); i++) {
 598                         gpio_cfg_pin(i,  S5P_GPIO_FUNC(0x3));
 599                         gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 600                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 601                 }
 602         }
 603
 604         return 0;
 605 }
 606
 607 static void exynos4_uart_config(int peripheral)
 608 {
 609         int i, start, count;
 610
 611         switch (peripheral) {
 612         case PERIPH_ID_UART0:
 613                 start = EXYNOS4_GPIO_A00;
 614                 count = 4;
 615                 break;
 616         case PERIPH_ID_UART1:
 617                 start = EXYNOS4_GPIO_A04;
 618                 count = 4;
 619                 break;
 620         case PERIPH_ID_UART2:
 621                 start = EXYNOS4_GPIO_A10;
 622                 count = 4;
 623                 break;
 624         case PERIPH_ID_UART3:
 625                 start = EXYNOS4_GPIO_A14;
 626                 count = 2;
 627                 break;
 628         default:
 629                 debug("%s: invalid peripheral %d", __func__, peripheral);
 630                 return;
 631         }
 632         for (i = start; i < (start + count); i++) {
 633                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 634                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 635         }
 636 }
 637
 638 static void exynos4x12_i2c_config(int peripheral, int flags)
 639 {
 640         switch (peripheral) {
 641         case PERIPH_ID_I2C0:
 642                 gpio_cfg_pin(EXYNOS4X12_GPIO_D10, S5P_GPIO_FUNC(0x2));
 643                 gpio_cfg_pin(EXYNOS4X12_GPIO_D11, S5P_GPIO_FUNC(0x2));
 644                 break;
 645         case PERIPH_ID_I2C1:
 646                 gpio_cfg_pin(EXYNOS4X12_GPIO_D12, S5P_GPIO_FUNC(0x2));
 647                 gpio_cfg_pin(EXYNOS4X12_GPIO_D13, S5P_GPIO_FUNC(0x2));
 648                 break;
 649         case PERIPH_ID_I2C2:
 650                 gpio_cfg_pin(EXYNOS4X12_GPIO_A06, S5P_GPIO_FUNC(0x3));
 651                 gpio_cfg_pin(EXYNOS4X12_GPIO_A07, S5P_GPIO_FUNC(0x3));
 652                 break;
 653         case PERIPH_ID_I2C3:
 654                 gpio_cfg_pin(EXYNOS4X12_GPIO_A12, S5P_GPIO_FUNC(0x3));
 655                 gpio_cfg_pin(EXYNOS4X12_GPIO_A13, S5P_GPIO_FUNC(0x3));
 656                 break;
 657         case PERIPH_ID_I2C4:
 658                 gpio_cfg_pin(EXYNOS4X12_GPIO_B2, S5P_GPIO_FUNC(0x3));
 659                 gpio_cfg_pin(EXYNOS4X12_GPIO_B3, S5P_GPIO_FUNC(0x3));
 660                 break;
 661         case PERIPH_ID_I2C5:
 662                 gpio_cfg_pin(EXYNOS4X12_GPIO_B6, S5P_GPIO_FUNC(0x3));
 663                 gpio_cfg_pin(EXYNOS4X12_GPIO_B7, S5P_GPIO_FUNC(0x3));
 664                 break;
 665         case PERIPH_ID_I2C6:
 666                 gpio_cfg_pin(EXYNOS4X12_GPIO_C13, S5P_GPIO_FUNC(0x4));
 667                 gpio_cfg_pin(EXYNOS4X12_GPIO_C14, S5P_GPIO_FUNC(0x4));
 668                 break;
 669         case PERIPH_ID_I2C7:
 670                 gpio_cfg_pin(EXYNOS4X12_GPIO_D02, S5P_GPIO_FUNC(0x3));
 671                 gpio_cfg_pin(EXYNOS4X12_GPIO_D03, S5P_GPIO_FUNC(0x3));
 672                 break;
 673         }
 674 }
 675
 676 static int exynos4x12_mmc_config(int peripheral, int flags)
 677 {
 678         int i, start = 0, start_ext = 0;
 679
 680         switch (peripheral) {
 681         case PERIPH_ID_SDMMC0:
 682                 start = EXYNOS4X12_GPIO_K00;
 683                 start_ext = EXYNOS4X12_GPIO_K13;
 684                 break;
 685         case PERIPH_ID_SDMMC2:
 686                 start = EXYNOS4X12_GPIO_K20;
 687                 start_ext = EXYNOS4X12_GPIO_K33;
 688                 break;
 689         default:
 690                 return -1;
 691         }
 692         for (i = start; i < (start + 7); i++) {
 693                 if (i == (start + 2))
 694                         continue;
 695                 gpio_cfg_pin(i,  S5P_GPIO_FUNC(0x2));
 696                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 697                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 698         }
 699         if (flags & PINMUX_FLAG_8BIT_MODE) {
 700                 for (i = start_ext; i < (start_ext + 4); i++) {
 701                         gpio_cfg_pin(i,  S5P_GPIO_FUNC(0x3));
 702                         gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 703                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 704                 }
 705         }
 706
 707         return 0;
 708 }
 709
 710 static void exynos4x12_uart_config(int peripheral)
 711 {
 712         int i, start, count;
 713
 714         switch (peripheral) {
 715         case PERIPH_ID_UART0:
 716                 start = EXYNOS4X12_GPIO_A00;
 717                 count = 4;
 718                 break;
 719         case PERIPH_ID_UART1:
 720                 start = EXYNOS4X12_GPIO_A04;
 721                 count = 4;
 722                 break;
 723         case PERIPH_ID_UART2:
 724                 start = EXYNOS4X12_GPIO_A10;
 725                 count = 4;
 726                 break;
 727         case PERIPH_ID_UART3:
 728                 start = EXYNOS4X12_GPIO_A14;
 729                 count = 2;
 730                 break;
 731         default:
 732                 debug("%s: invalid peripheral %d", __func__, peripheral);
 733                 return;
 734         }
 735         for (i = start; i < (start + count); i++) {
 736                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 737                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 738         }
 739 }
 740
 741 static int exynos4_pinmux_config(int peripheral, int flags)
 742 {
 743         switch (peripheral) {
 744         case PERIPH_ID_UART0:
 745         case PERIPH_ID_UART1:
 746         case PERIPH_ID_UART2:
 747         case PERIPH_ID_UART3:
 748                 exynos4_uart_config(peripheral);
 749                 break;
 750         case PERIPH_ID_I2C0:
 751         case PERIPH_ID_I2C1:
 752         case PERIPH_ID_I2C2:
 753         case PERIPH_ID_I2C3:
 754         case PERIPH_ID_I2C4:
 755         case PERIPH_ID_I2C5:
 756         case PERIPH_ID_I2C6:
 757         case PERIPH_ID_I2C7:
 758                 exynos4_i2c_config(peripheral, flags);
 759                 break;
 760         case PERIPH_ID_SDMMC0:
 761         case PERIPH_ID_SDMMC2:
 762                 return exynos4_mmc_config(peripheral, flags);
 763         case PERIPH_ID_SDMMC1:
 764         case PERIPH_ID_SDMMC3:
 765         case PERIPH_ID_SDMMC4:
 766                 debug("SDMMC device %d not implemented\n", peripheral);
 767                 return -1;
 768         default:
 769                 debug("%s: invalid peripheral %d", __func__, peripheral);
 770                 return -1;
 771         }
 772
 773         return 0;
 774 }
 775
 776 static int exynos4x12_pinmux_config(int peripheral, int flags)
 777 {
 778         switch (peripheral) {
 779         case PERIPH_ID_UART0:
 780         case PERIPH_ID_UART1:
 781         case PERIPH_ID_UART2:
 782         case PERIPH_ID_UART3:
 783                 exynos4x12_uart_config(peripheral);
 784                 break;
 785         case PERIPH_ID_I2C0:
 786         case PERIPH_ID_I2C1:
 787         case PERIPH_ID_I2C2:
 788         case PERIPH_ID_I2C3:
 789         case PERIPH_ID_I2C4:
 790         case PERIPH_ID_I2C5:
 791         case PERIPH_ID_I2C6:
 792         case PERIPH_ID_I2C7:
 793                 exynos4x12_i2c_config(peripheral, flags);
 794                 break;
 795         case PERIPH_ID_SDMMC0:
 796         case PERIPH_ID_SDMMC2:
 797                 return exynos4x12_mmc_config(peripheral, flags);
 798         case PERIPH_ID_SDMMC1:
 799         case PERIPH_ID_SDMMC3:
 800         case PERIPH_ID_SDMMC4:
 801                 debug("SDMMC device %d not implemented\n", peripheral);
 802                 return -1;
 803         default:
 804                 debug("%s: invalid peripheral %d", __func__, peripheral);
 805                 return -1;
 806         }
 807
 808         return 0;
 809 }
 810
 811 int exynos_pinmux_config(int peripheral, int flags)
 812 {
 813         if (cpu_is_exynos5()) {
 814                 if (proid_is_exynos5420())
 815                         return exynos5420_pinmux_config(peripheral, flags);
 816                 else if (proid_is_exynos5250())
 817                         return exynos5_pinmux_config(peripheral, flags);
 818         } else if (cpu_is_exynos4()) {
 819                 if (proid_is_exynos4412())
 820                         return exynos4x12_pinmux_config(peripheral, flags);
 821                 else
 822                         return exynos4_pinmux_config(peripheral, flags);
 823         }
 824
 825         debug("pinmux functionality not supported\n");
 826
 827         return -1;
 828 }
 829
 830 #ifdef CONFIG_OF_CONTROL
 831 static int exynos4_pinmux_decode_periph_id(const void *blob, int node)
 832 {
 833         int err;
 834         u32 cell[3];
 835
 836         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
 837                                         ARRAY_SIZE(cell));
 838         if (err) {
 839                 debug(" invalid peripheral id\n");
 840                 return PERIPH_ID_NONE;
 841         }
 842
 843         return cell[1];
 844 }
 845
 846 static int exynos5_pinmux_decode_periph_id(const void *blob, int node)
 847 {
 848         int err;
 849         u32 cell[3];
 850
 851         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
 852                                         ARRAY_SIZE(cell));
 853         if (err)
 854                 return PERIPH_ID_NONE;
 855
 856         return cell[1];
 857 }
 858
 859 int pinmux_decode_periph_id(const void *blob, int node)
 860 {
 861         if (cpu_is_exynos5())
 862                 return  exynos5_pinmux_decode_periph_id(blob, node);
 863         else if (cpu_is_exynos4())
 864                 return  exynos4_pinmux_decode_periph_id(blob, node);
 865
 866         return PERIPH_ID_NONE;
 867 }
 868 #endif