git.sur5r.net Git - u-boot/blob - arch/arm/mach-exynos/pinmux.c

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