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/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 #ifndef CONFIG_SPL_BUILD
 176                         gpio_request(i, "sdmmc0_vdden");
 177 #endif
 178                         gpio_set_value(i, 1);
 179                         gpio_cfg_pin(i, S5P_GPIO_OUTPUT);
 180                 } else {
 181                         gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 182                 }
 183                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 184                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 185         }
 186
 187         for (i = (start + 3); i <= (start + 6); i++) {
 188                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 189                 gpio_set_pull(i, S5P_GPIO_PULL_UP);
 190                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 191         }
 192
 193         return 0;
 194 }
 195
 196 static void exynos5_sromc_config(int flags)
 197 {
 198         int i;
 199
 200         /*
 201          * SROM:CS1 and EBI
 202          *
 203          * GPY0[0]      SROM_CSn[0]
 204          * GPY0[1]      SROM_CSn[1](2)
 205          * GPY0[2]      SROM_CSn[2]
 206          * GPY0[3]      SROM_CSn[3]
 207          * GPY0[4]      EBI_OEn(2)
 208          * GPY0[5]      EBI_EEn(2)
 209          *
 210          * GPY1[0]      EBI_BEn[0](2)
 211          * GPY1[1]      EBI_BEn[1](2)
 212          * GPY1[2]      SROM_WAIT(2)
 213          * GPY1[3]      EBI_DATA_RDn(2)
 214          */
 215         gpio_cfg_pin(EXYNOS5_GPIO_Y00 + (flags & PINMUX_FLAG_BANK),
 216                      S5P_GPIO_FUNC(2));
 217         gpio_cfg_pin(EXYNOS5_GPIO_Y04, S5P_GPIO_FUNC(2));
 218         gpio_cfg_pin(EXYNOS5_GPIO_Y05, S5P_GPIO_FUNC(2));
 219
 220         for (i = 0; i < 4; i++)
 221                 gpio_cfg_pin(EXYNOS5_GPIO_Y10 + i, S5P_GPIO_FUNC(2));
 222
 223         /*
 224          * EBI: 8 Addrss Lines
 225          *
 226          * GPY3[0]      EBI_ADDR[0](2)
 227          * GPY3[1]      EBI_ADDR[1](2)
 228          * GPY3[2]      EBI_ADDR[2](2)
 229          * GPY3[3]      EBI_ADDR[3](2)
 230          * GPY3[4]      EBI_ADDR[4](2)
 231          * GPY3[5]      EBI_ADDR[5](2)
 232          * GPY3[6]      EBI_ADDR[6](2)
 233          * GPY3[7]      EBI_ADDR[7](2)
 234          *
 235          * EBI: 16 Data Lines
 236          *
 237          * GPY5[0]      EBI_DATA[0](2)
 238          * GPY5[1]      EBI_DATA[1](2)
 239          * GPY5[2]      EBI_DATA[2](2)
 240          * GPY5[3]      EBI_DATA[3](2)
 241          * GPY5[4]      EBI_DATA[4](2)
 242          * GPY5[5]      EBI_DATA[5](2)
 243          * GPY5[6]      EBI_DATA[6](2)
 244          * GPY5[7]      EBI_DATA[7](2)
 245          *
 246          * GPY6[0]      EBI_DATA[8](2)
 247          * GPY6[1]      EBI_DATA[9](2)
 248          * GPY6[2]      EBI_DATA[10](2)
 249          * GPY6[3]      EBI_DATA[11](2)
 250          * GPY6[4]      EBI_DATA[12](2)
 251          * GPY6[5]      EBI_DATA[13](2)
 252          * GPY6[6]      EBI_DATA[14](2)
 253          * GPY6[7]      EBI_DATA[15](2)
 254          */
 255         for (i = 0; i < 8; i++) {
 256                 gpio_cfg_pin(EXYNOS5_GPIO_Y30 + i, S5P_GPIO_FUNC(2));
 257                 gpio_set_pull(EXYNOS5_GPIO_Y30 + i, S5P_GPIO_PULL_UP);
 258
 259                 gpio_cfg_pin(EXYNOS5_GPIO_Y50 + i, S5P_GPIO_FUNC(2));
 260                 gpio_set_pull(EXYNOS5_GPIO_Y50 + i, S5P_GPIO_PULL_UP);
 261
 262                 gpio_cfg_pin(EXYNOS5_GPIO_Y60 + i, S5P_GPIO_FUNC(2));
 263                 gpio_set_pull(EXYNOS5_GPIO_Y60 + i, S5P_GPIO_PULL_UP);
 264         }
 265 }
 266
 267 static void exynos5_i2c_config(int peripheral, int flags)
 268 {
 269         switch (peripheral) {
 270         case PERIPH_ID_I2C0:
 271                 gpio_cfg_pin(EXYNOS5_GPIO_B30, S5P_GPIO_FUNC(0x2));
 272                 gpio_cfg_pin(EXYNOS5_GPIO_B31, S5P_GPIO_FUNC(0x2));
 273                 break;
 274         case PERIPH_ID_I2C1:
 275                 gpio_cfg_pin(EXYNOS5_GPIO_B32, S5P_GPIO_FUNC(0x2));
 276                 gpio_cfg_pin(EXYNOS5_GPIO_B33, S5P_GPIO_FUNC(0x2));
 277                 break;
 278         case PERIPH_ID_I2C2:
 279                 gpio_cfg_pin(EXYNOS5_GPIO_A06, S5P_GPIO_FUNC(0x3));
 280                 gpio_cfg_pin(EXYNOS5_GPIO_A07, S5P_GPIO_FUNC(0x3));
 281                 break;
 282         case PERIPH_ID_I2C3:
 283                 gpio_cfg_pin(EXYNOS5_GPIO_A12, S5P_GPIO_FUNC(0x3));
 284                 gpio_cfg_pin(EXYNOS5_GPIO_A13, S5P_GPIO_FUNC(0x3));
 285                 break;
 286         case PERIPH_ID_I2C4:
 287                 gpio_cfg_pin(EXYNOS5_GPIO_A20, S5P_GPIO_FUNC(0x3));
 288                 gpio_cfg_pin(EXYNOS5_GPIO_A21, S5P_GPIO_FUNC(0x3));
 289                 break;
 290         case PERIPH_ID_I2C5:
 291                 gpio_cfg_pin(EXYNOS5_GPIO_A22, S5P_GPIO_FUNC(0x3));
 292                 gpio_cfg_pin(EXYNOS5_GPIO_A23, S5P_GPIO_FUNC(0x3));
 293                 break;
 294         case PERIPH_ID_I2C6:
 295                 gpio_cfg_pin(EXYNOS5_GPIO_B13, S5P_GPIO_FUNC(0x4));
 296                 gpio_cfg_pin(EXYNOS5_GPIO_B14, S5P_GPIO_FUNC(0x4));
 297                 break;
 298         case PERIPH_ID_I2C7:
 299                 gpio_cfg_pin(EXYNOS5_GPIO_B22, S5P_GPIO_FUNC(0x3));
 300                 gpio_cfg_pin(EXYNOS5_GPIO_B23, S5P_GPIO_FUNC(0x3));
 301                 break;
 302         }
 303 }
 304
 305 static void exynos5420_i2c_config(int peripheral)
 306 {
 307         switch (peripheral) {
 308         case PERIPH_ID_I2C0:
 309                 gpio_cfg_pin(EXYNOS5420_GPIO_B30, S5P_GPIO_FUNC(0x2));
 310                 gpio_cfg_pin(EXYNOS5420_GPIO_B31, S5P_GPIO_FUNC(0x2));
 311                 break;
 312         case PERIPH_ID_I2C1:
 313                 gpio_cfg_pin(EXYNOS5420_GPIO_B32, S5P_GPIO_FUNC(0x2));
 314                 gpio_cfg_pin(EXYNOS5420_GPIO_B33, S5P_GPIO_FUNC(0x2));
 315                 break;
 316         case PERIPH_ID_I2C2:
 317                 gpio_cfg_pin(EXYNOS5420_GPIO_A06, S5P_GPIO_FUNC(0x3));
 318                 gpio_cfg_pin(EXYNOS5420_GPIO_A07, S5P_GPIO_FUNC(0x3));
 319                 break;
 320         case PERIPH_ID_I2C3:
 321                 gpio_cfg_pin(EXYNOS5420_GPIO_A12, S5P_GPIO_FUNC(0x3));
 322                 gpio_cfg_pin(EXYNOS5420_GPIO_A13, S5P_GPIO_FUNC(0x3));
 323                 break;
 324         case PERIPH_ID_I2C4:
 325                 gpio_cfg_pin(EXYNOS5420_GPIO_A20, S5P_GPIO_FUNC(0x3));
 326                 gpio_cfg_pin(EXYNOS5420_GPIO_A21, S5P_GPIO_FUNC(0x3));
 327                 break;
 328         case PERIPH_ID_I2C5:
 329                 gpio_cfg_pin(EXYNOS5420_GPIO_A22, S5P_GPIO_FUNC(0x3));
 330                 gpio_cfg_pin(EXYNOS5420_GPIO_A23, S5P_GPIO_FUNC(0x3));
 331                 break;
 332         case PERIPH_ID_I2C6:
 333                 gpio_cfg_pin(EXYNOS5420_GPIO_B13, S5P_GPIO_FUNC(0x4));
 334                 gpio_cfg_pin(EXYNOS5420_GPIO_B14, S5P_GPIO_FUNC(0x4));
 335                 break;
 336         case PERIPH_ID_I2C7:
 337                 gpio_cfg_pin(EXYNOS5420_GPIO_B22, S5P_GPIO_FUNC(0x3));
 338                 gpio_cfg_pin(EXYNOS5420_GPIO_B23, S5P_GPIO_FUNC(0x3));
 339                 break;
 340         case PERIPH_ID_I2C8:
 341                 gpio_cfg_pin(EXYNOS5420_GPIO_B34, S5P_GPIO_FUNC(0x2));
 342                 gpio_cfg_pin(EXYNOS5420_GPIO_B35, S5P_GPIO_FUNC(0x2));
 343                 break;
 344         case PERIPH_ID_I2C9:
 345                 gpio_cfg_pin(EXYNOS5420_GPIO_B36, S5P_GPIO_FUNC(0x2));
 346                 gpio_cfg_pin(EXYNOS5420_GPIO_B37, S5P_GPIO_FUNC(0x2));
 347                 break;
 348         case PERIPH_ID_I2C10:
 349                 gpio_cfg_pin(EXYNOS5420_GPIO_B40, S5P_GPIO_FUNC(0x2));
 350                 gpio_cfg_pin(EXYNOS5420_GPIO_B41, S5P_GPIO_FUNC(0x2));
 351                 break;
 352         }
 353 }
 354
 355 static void exynos5_i2s_config(int peripheral)
 356 {
 357         int i;
 358
 359         switch (peripheral) {
 360         case PERIPH_ID_I2S0:
 361                 for (i = 0; i < 5; i++)
 362                         gpio_cfg_pin(EXYNOS5_GPIO_Z0 + i, S5P_GPIO_FUNC(0x02));
 363                 break;
 364         case PERIPH_ID_I2S1:
 365                 for (i = 0; i < 5; i++)
 366                         gpio_cfg_pin(EXYNOS5_GPIO_B00 + i, S5P_GPIO_FUNC(0x02));
 367                 break;
 368         }
 369 }
 370
 371 void exynos5_spi_config(int peripheral)
 372 {
 373         int cfg = 0, pin = 0, i;
 374
 375         switch (peripheral) {
 376         case PERIPH_ID_SPI0:
 377                 cfg = S5P_GPIO_FUNC(0x2);
 378                 pin = EXYNOS5_GPIO_A20;
 379                 break;
 380         case PERIPH_ID_SPI1:
 381                 cfg = S5P_GPIO_FUNC(0x2);
 382                 pin = EXYNOS5_GPIO_A24;
 383                 break;
 384         case PERIPH_ID_SPI2:
 385                 cfg = S5P_GPIO_FUNC(0x5);
 386                 pin = EXYNOS5_GPIO_B11;
 387                 break;
 388         case PERIPH_ID_SPI3:
 389                 cfg = S5P_GPIO_FUNC(0x2);
 390                 pin = EXYNOS5_GPIO_F10;
 391                 break;
 392         case PERIPH_ID_SPI4:
 393                 for (i = 0; i < 2; i++) {
 394                         gpio_cfg_pin(EXYNOS5_GPIO_F02 + i, S5P_GPIO_FUNC(0x4));
 395                         gpio_cfg_pin(EXYNOS5_GPIO_E04 + i, S5P_GPIO_FUNC(0x4));
 396                 }
 397                 break;
 398         }
 399         if (peripheral != PERIPH_ID_SPI4) {
 400                 for (i = pin; i < pin + 4; i++)
 401                         gpio_cfg_pin(i, cfg);
 402         }
 403 }
 404
 405 void exynos5420_spi_config(int peripheral)
 406 {
 407         int cfg, pin, i;
 408
 409         switch (peripheral) {
 410         case PERIPH_ID_SPI0:
 411                 pin = EXYNOS5420_GPIO_A20;
 412                 cfg = S5P_GPIO_FUNC(0x2);
 413                 break;
 414         case PERIPH_ID_SPI1:
 415                 pin = EXYNOS5420_GPIO_A24;
 416                 cfg = S5P_GPIO_FUNC(0x2);
 417                 break;
 418         case PERIPH_ID_SPI2:
 419                 pin = EXYNOS5420_GPIO_B11;
 420                 cfg = S5P_GPIO_FUNC(0x5);
 421                 break;
 422         case PERIPH_ID_SPI3:
 423                 pin = EXYNOS5420_GPIO_F10;
 424                 cfg = S5P_GPIO_FUNC(0x2);
 425                 break;
 426         case PERIPH_ID_SPI4:
 427                 cfg = 0;
 428                 pin = 0;
 429                 break;
 430         default:
 431                 cfg = 0;
 432                 pin = 0;
 433                 debug("%s: invalid peripheral %d", __func__, peripheral);
 434                 return;
 435         }
 436
 437         if (peripheral != PERIPH_ID_SPI4) {
 438                 for (i = pin; i < pin + 4; i++)
 439                         gpio_cfg_pin(i, cfg);
 440         } else {
 441                 for (i = 0; i < 2; i++) {
 442                         gpio_cfg_pin(EXYNOS5420_GPIO_F02 + i,
 443                                      S5P_GPIO_FUNC(0x4));
 444                         gpio_cfg_pin(EXYNOS5420_GPIO_E04 + i,
 445                                      S5P_GPIO_FUNC(0x4));
 446                 }
 447         }
 448 }
 449
 450 static int exynos5_pinmux_config(int peripheral, int flags)
 451 {
 452         switch (peripheral) {
 453         case PERIPH_ID_UART0:
 454         case PERIPH_ID_UART1:
 455         case PERIPH_ID_UART2:
 456         case PERIPH_ID_UART3:
 457                 exynos5_uart_config(peripheral);
 458                 break;
 459         case PERIPH_ID_SDMMC0:
 460         case PERIPH_ID_SDMMC1:
 461         case PERIPH_ID_SDMMC2:
 462         case PERIPH_ID_SDMMC3:
 463                 return exynos5_mmc_config(peripheral, flags);
 464         case PERIPH_ID_SROMC:
 465                 exynos5_sromc_config(flags);
 466                 break;
 467         case PERIPH_ID_I2C0:
 468         case PERIPH_ID_I2C1:
 469         case PERIPH_ID_I2C2:
 470         case PERIPH_ID_I2C3:
 471         case PERIPH_ID_I2C4:
 472         case PERIPH_ID_I2C5:
 473         case PERIPH_ID_I2C6:
 474         case PERIPH_ID_I2C7:
 475                 exynos5_i2c_config(peripheral, flags);
 476                 break;
 477         case PERIPH_ID_I2S0:
 478         case PERIPH_ID_I2S1:
 479                 exynos5_i2s_config(peripheral);
 480                 break;
 481         case PERIPH_ID_SPI0:
 482         case PERIPH_ID_SPI1:
 483         case PERIPH_ID_SPI2:
 484         case PERIPH_ID_SPI3:
 485         case PERIPH_ID_SPI4:
 486                 exynos5_spi_config(peripheral);
 487                 break;
 488         default:
 489                 debug("%s: invalid peripheral %d", __func__, peripheral);
 490                 return -1;
 491         }
 492
 493         return 0;
 494 }
 495
 496 static int exynos5420_pinmux_config(int peripheral, int flags)
 497 {
 498         switch (peripheral) {
 499         case PERIPH_ID_UART0:
 500         case PERIPH_ID_UART1:
 501         case PERIPH_ID_UART2:
 502         case PERIPH_ID_UART3:
 503                 exynos5420_uart_config(peripheral);
 504                 break;
 505         case PERIPH_ID_SDMMC0:
 506         case PERIPH_ID_SDMMC1:
 507         case PERIPH_ID_SDMMC2:
 508         case PERIPH_ID_SDMMC3:
 509                 return exynos5420_mmc_config(peripheral, flags);
 510         case PERIPH_ID_SPI0:
 511         case PERIPH_ID_SPI1:
 512         case PERIPH_ID_SPI2:
 513         case PERIPH_ID_SPI3:
 514         case PERIPH_ID_SPI4:
 515                 exynos5420_spi_config(peripheral);
 516                 break;
 517         case PERIPH_ID_I2C0:
 518         case PERIPH_ID_I2C1:
 519         case PERIPH_ID_I2C2:
 520         case PERIPH_ID_I2C3:
 521         case PERIPH_ID_I2C4:
 522         case PERIPH_ID_I2C5:
 523         case PERIPH_ID_I2C6:
 524         case PERIPH_ID_I2C7:
 525         case PERIPH_ID_I2C8:
 526         case PERIPH_ID_I2C9:
 527         case PERIPH_ID_I2C10:
 528                 exynos5420_i2c_config(peripheral);
 529                 break;
 530         default:
 531                 debug("%s: invalid peripheral %d", __func__, peripheral);
 532                 return -1;
 533         }
 534
 535         return 0;
 536 }
 537
 538 static void exynos4_i2c_config(int peripheral, int flags)
 539 {
 540         switch (peripheral) {
 541         case PERIPH_ID_I2C0:
 542                 gpio_cfg_pin(EXYNOS4_GPIO_D10, S5P_GPIO_FUNC(0x2));
 543                 gpio_cfg_pin(EXYNOS4_GPIO_D11, S5P_GPIO_FUNC(0x2));
 544                 break;
 545         case PERIPH_ID_I2C1:
 546                 gpio_cfg_pin(EXYNOS4_GPIO_D12, S5P_GPIO_FUNC(0x2));
 547                 gpio_cfg_pin(EXYNOS4_GPIO_D13, S5P_GPIO_FUNC(0x2));
 548                 break;
 549         case PERIPH_ID_I2C2:
 550                 gpio_cfg_pin(EXYNOS4_GPIO_A06, S5P_GPIO_FUNC(0x3));
 551                 gpio_cfg_pin(EXYNOS4_GPIO_A07, S5P_GPIO_FUNC(0x3));
 552                 break;
 553         case PERIPH_ID_I2C3:
 554                 gpio_cfg_pin(EXYNOS4_GPIO_A12, S5P_GPIO_FUNC(0x3));
 555                 gpio_cfg_pin(EXYNOS4_GPIO_A13, S5P_GPIO_FUNC(0x3));
 556                 break;
 557         case PERIPH_ID_I2C4:
 558                 gpio_cfg_pin(EXYNOS4_GPIO_B2, S5P_GPIO_FUNC(0x3));
 559                 gpio_cfg_pin(EXYNOS4_GPIO_B3, S5P_GPIO_FUNC(0x3));
 560                 break;
 561         case PERIPH_ID_I2C5:
 562                 gpio_cfg_pin(EXYNOS4_GPIO_B6, S5P_GPIO_FUNC(0x3));
 563                 gpio_cfg_pin(EXYNOS4_GPIO_B7, S5P_GPIO_FUNC(0x3));
 564                 break;
 565         case PERIPH_ID_I2C6:
 566                 gpio_cfg_pin(EXYNOS4_GPIO_C13, S5P_GPIO_FUNC(0x4));
 567                 gpio_cfg_pin(EXYNOS4_GPIO_C14, S5P_GPIO_FUNC(0x4));
 568                 break;
 569         case PERIPH_ID_I2C7:
 570                 gpio_cfg_pin(EXYNOS4_GPIO_D02, S5P_GPIO_FUNC(0x3));
 571                 gpio_cfg_pin(EXYNOS4_GPIO_D03, S5P_GPIO_FUNC(0x3));
 572                 break;
 573         }
 574 }
 575
 576 static int exynos4_mmc_config(int peripheral, int flags)
 577 {
 578         int i, start = 0, start_ext = 0;
 579         unsigned int func, ext_func;
 580
 581         switch (peripheral) {
 582         case PERIPH_ID_SDMMC0:
 583                 start = EXYNOS4_GPIO_K00;
 584                 start_ext = EXYNOS4_GPIO_K13;
 585                 func = S5P_GPIO_FUNC(0x2);
 586                 ext_func = S5P_GPIO_FUNC(0x3);
 587                 break;
 588         case PERIPH_ID_SDMMC2:
 589                 start = EXYNOS4_GPIO_K20;
 590                 start_ext = EXYNOS4_GPIO_K33;
 591                 func = S5P_GPIO_FUNC(0x2);
 592                 ext_func = S5P_GPIO_FUNC(0x3);
 593                 break;
 594         case PERIPH_ID_SDMMC4:
 595                 start = EXYNOS4_GPIO_K00;
 596                 start_ext = EXYNOS4_GPIO_K13;
 597                 func = S5P_GPIO_FUNC(0x3);
 598                 ext_func = S5P_GPIO_FUNC(0x4);
 599                 break;
 600         default:
 601                 return -1;
 602         }
 603         for (i = start; i < (start + 7); i++) {
 604                 if (i == (start + 2))
 605                         continue;
 606                 gpio_cfg_pin(i,  func);
 607                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 608                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 609         }
 610         /* SDMMC2 do not use 8bit mode at exynos4 */
 611         if (flags & PINMUX_FLAG_8BIT_MODE) {
 612                 for (i = start_ext; i < (start_ext + 4); i++) {
 613                         gpio_cfg_pin(i,  ext_func);
 614                         gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 615                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 616                 }
 617         }
 618
 619         return 0;
 620 }
 621
 622 static void exynos4_uart_config(int peripheral)
 623 {
 624         int i, start, count;
 625
 626         switch (peripheral) {
 627         case PERIPH_ID_UART0:
 628                 start = EXYNOS4_GPIO_A00;
 629                 count = 4;
 630                 break;
 631         case PERIPH_ID_UART1:
 632                 start = EXYNOS4_GPIO_A04;
 633                 count = 4;
 634                 break;
 635         case PERIPH_ID_UART2:
 636                 start = EXYNOS4_GPIO_A10;
 637                 count = 4;
 638                 break;
 639         case PERIPH_ID_UART3:
 640                 start = EXYNOS4_GPIO_A14;
 641                 count = 2;
 642                 break;
 643         default:
 644                 debug("%s: invalid peripheral %d", __func__, peripheral);
 645                 return;
 646         }
 647         for (i = start; i < (start + count); i++) {
 648                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 649                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 650         }
 651 }
 652
 653 static void exynos4x12_i2c_config(int peripheral, int flags)
 654 {
 655         switch (peripheral) {
 656         case PERIPH_ID_I2C0:
 657                 gpio_cfg_pin(EXYNOS4X12_GPIO_D10, S5P_GPIO_FUNC(0x2));
 658                 gpio_cfg_pin(EXYNOS4X12_GPIO_D11, S5P_GPIO_FUNC(0x2));
 659                 break;
 660         case PERIPH_ID_I2C1:
 661                 gpio_cfg_pin(EXYNOS4X12_GPIO_D12, S5P_GPIO_FUNC(0x2));
 662                 gpio_cfg_pin(EXYNOS4X12_GPIO_D13, S5P_GPIO_FUNC(0x2));
 663                 break;
 664         case PERIPH_ID_I2C2:
 665                 gpio_cfg_pin(EXYNOS4X12_GPIO_A06, S5P_GPIO_FUNC(0x3));
 666                 gpio_cfg_pin(EXYNOS4X12_GPIO_A07, S5P_GPIO_FUNC(0x3));
 667                 break;
 668         case PERIPH_ID_I2C3:
 669                 gpio_cfg_pin(EXYNOS4X12_GPIO_A12, S5P_GPIO_FUNC(0x3));
 670                 gpio_cfg_pin(EXYNOS4X12_GPIO_A13, S5P_GPIO_FUNC(0x3));
 671                 break;
 672         case PERIPH_ID_I2C4:
 673                 gpio_cfg_pin(EXYNOS4X12_GPIO_B2, S5P_GPIO_FUNC(0x3));
 674                 gpio_cfg_pin(EXYNOS4X12_GPIO_B3, S5P_GPIO_FUNC(0x3));
 675                 break;
 676         case PERIPH_ID_I2C5:
 677                 gpio_cfg_pin(EXYNOS4X12_GPIO_B6, S5P_GPIO_FUNC(0x3));
 678                 gpio_cfg_pin(EXYNOS4X12_GPIO_B7, S5P_GPIO_FUNC(0x3));
 679                 break;
 680         case PERIPH_ID_I2C6:
 681                 gpio_cfg_pin(EXYNOS4X12_GPIO_C13, S5P_GPIO_FUNC(0x4));
 682                 gpio_cfg_pin(EXYNOS4X12_GPIO_C14, S5P_GPIO_FUNC(0x4));
 683                 break;
 684         case PERIPH_ID_I2C7:
 685                 gpio_cfg_pin(EXYNOS4X12_GPIO_D02, S5P_GPIO_FUNC(0x3));
 686                 gpio_cfg_pin(EXYNOS4X12_GPIO_D03, S5P_GPIO_FUNC(0x3));
 687                 break;
 688         }
 689 }
 690
 691 static int exynos4x12_mmc_config(int peripheral, int flags)
 692 {
 693         int i, start = 0, start_ext = 0;
 694         unsigned int func, ext_func;
 695
 696         switch (peripheral) {
 697         case PERIPH_ID_SDMMC0:
 698                 start = EXYNOS4X12_GPIO_K00;
 699                 start_ext = EXYNOS4X12_GPIO_K13;
 700                 func = S5P_GPIO_FUNC(0x2);
 701                 ext_func = S5P_GPIO_FUNC(0x3);
 702                 break;
 703         case PERIPH_ID_SDMMC2:
 704                 start = EXYNOS4X12_GPIO_K20;
 705                 start_ext = EXYNOS4X12_GPIO_K33;
 706                 func = S5P_GPIO_FUNC(0x2);
 707                 ext_func = S5P_GPIO_FUNC(0x3);
 708                 break;
 709         case PERIPH_ID_SDMMC4:
 710                 start = EXYNOS4X12_GPIO_K00;
 711                 start_ext = EXYNOS4X12_GPIO_K13;
 712                 func = S5P_GPIO_FUNC(0x3);
 713                 ext_func = S5P_GPIO_FUNC(0x4);
 714                 break;
 715         default:
 716                 return -1;
 717         }
 718         for (i = start; i < (start + 7); i++) {
 719                 if (i == (start + 2))
 720                         continue;
 721                 gpio_cfg_pin(i,  func);
 722                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 723                 gpio_set_drv(i, S5P_GPIO_DRV_4X);
 724         }
 725         if (flags & PINMUX_FLAG_8BIT_MODE) {
 726                 for (i = start_ext; i < (start_ext + 4); i++) {
 727                         gpio_cfg_pin(i,  ext_func);
 728                         gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 729                         gpio_set_drv(i, S5P_GPIO_DRV_4X);
 730                 }
 731         }
 732
 733         return 0;
 734 }
 735
 736 static void exynos4x12_uart_config(int peripheral)
 737 {
 738         int i, start, count;
 739
 740         switch (peripheral) {
 741         case PERIPH_ID_UART0:
 742                 start = EXYNOS4X12_GPIO_A00;
 743                 count = 4;
 744                 break;
 745         case PERIPH_ID_UART1:
 746                 start = EXYNOS4X12_GPIO_A04;
 747                 count = 4;
 748                 break;
 749         case PERIPH_ID_UART2:
 750                 start = EXYNOS4X12_GPIO_A10;
 751                 count = 4;
 752                 break;
 753         case PERIPH_ID_UART3:
 754                 start = EXYNOS4X12_GPIO_A14;
 755                 count = 2;
 756                 break;
 757         default:
 758                 debug("%s: invalid peripheral %d", __func__, peripheral);
 759                 return;
 760         }
 761         for (i = start; i < (start + count); i++) {
 762                 gpio_set_pull(i, S5P_GPIO_PULL_NONE);
 763                 gpio_cfg_pin(i, S5P_GPIO_FUNC(0x2));
 764         }
 765 }
 766
 767 static int exynos4_pinmux_config(int peripheral, int flags)
 768 {
 769         switch (peripheral) {
 770         case PERIPH_ID_UART0:
 771         case PERIPH_ID_UART1:
 772         case PERIPH_ID_UART2:
 773         case PERIPH_ID_UART3:
 774                 exynos4_uart_config(peripheral);
 775                 break;
 776         case PERIPH_ID_I2C0:
 777         case PERIPH_ID_I2C1:
 778         case PERIPH_ID_I2C2:
 779         case PERIPH_ID_I2C3:
 780         case PERIPH_ID_I2C4:
 781         case PERIPH_ID_I2C5:
 782         case PERIPH_ID_I2C6:
 783         case PERIPH_ID_I2C7:
 784                 exynos4_i2c_config(peripheral, flags);
 785                 break;
 786         case PERIPH_ID_SDMMC0:
 787         case PERIPH_ID_SDMMC2:
 788         case PERIPH_ID_SDMMC4:
 789                 return exynos4_mmc_config(peripheral, flags);
 790         case PERIPH_ID_SDMMC1:
 791         case PERIPH_ID_SDMMC3:
 792                 debug("SDMMC device %d not implemented\n", peripheral);
 793                 return -1;
 794         default:
 795                 debug("%s: invalid peripheral %d", __func__, peripheral);
 796                 return -1;
 797         }
 798
 799         return 0;
 800 }
 801
 802 static int exynos4x12_pinmux_config(int peripheral, int flags)
 803 {
 804         switch (peripheral) {
 805         case PERIPH_ID_UART0:
 806         case PERIPH_ID_UART1:
 807         case PERIPH_ID_UART2:
 808         case PERIPH_ID_UART3:
 809                 exynos4x12_uart_config(peripheral);
 810                 break;
 811         case PERIPH_ID_I2C0:
 812         case PERIPH_ID_I2C1:
 813         case PERIPH_ID_I2C2:
 814         case PERIPH_ID_I2C3:
 815         case PERIPH_ID_I2C4:
 816         case PERIPH_ID_I2C5:
 817         case PERIPH_ID_I2C6:
 818         case PERIPH_ID_I2C7:
 819                 exynos4x12_i2c_config(peripheral, flags);
 820                 break;
 821         case PERIPH_ID_SDMMC0:
 822         case PERIPH_ID_SDMMC2:
 823         case PERIPH_ID_SDMMC4:
 824                 return exynos4x12_mmc_config(peripheral, flags);
 825         case PERIPH_ID_SDMMC1:
 826         case PERIPH_ID_SDMMC3:
 827                 debug("SDMMC device %d not implemented\n", peripheral);
 828                 return -1;
 829         default:
 830                 debug("%s: invalid peripheral %d", __func__, peripheral);
 831                 return -1;
 832         }
 833
 834         return 0;
 835 }
 836
 837 int exynos_pinmux_config(int peripheral, int flags)
 838 {
 839         if (cpu_is_exynos5()) {
 840                 if (proid_is_exynos5420())
 841                         return exynos5420_pinmux_config(peripheral, flags);
 842                 else if (proid_is_exynos5250())
 843                         return exynos5_pinmux_config(peripheral, flags);
 844         } else if (cpu_is_exynos4()) {
 845                 if (proid_is_exynos4412())
 846                         return exynos4x12_pinmux_config(peripheral, flags);
 847                 else
 848                         return exynos4_pinmux_config(peripheral, flags);
 849         }
 850
 851         debug("pinmux functionality not supported\n");
 852
 853         return -1;
 854 }
 855
 856 #ifdef CONFIG_OF_CONTROL
 857 static int exynos4_pinmux_decode_periph_id(const void *blob, int node)
 858 {
 859         int err;
 860         u32 cell[3];
 861
 862         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
 863                                         ARRAY_SIZE(cell));
 864         if (err) {
 865                 debug(" invalid peripheral id\n");
 866                 return PERIPH_ID_NONE;
 867         }
 868
 869         return cell[1];
 870 }
 871
 872 static int exynos5_pinmux_decode_periph_id(const void *blob, int node)
 873 {
 874         int err;
 875         u32 cell[3];
 876
 877         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
 878                                         ARRAY_SIZE(cell));
 879         if (err)
 880                 return PERIPH_ID_NONE;
 881
 882         return cell[1];
 883 }
 884
 885 int pinmux_decode_periph_id(const void *blob, int node)
 886 {
 887         if (cpu_is_exynos5())
 888                 return  exynos5_pinmux_decode_periph_id(blob, node);
 889         else if (cpu_is_exynos4())
 890                 return  exynos4_pinmux_decode_periph_id(blob, node);
 891
 892         return PERIPH_ID_NONE;
 893 }
 894 #endif