arm: exynos: Squash bogus warnings in pinmux
[karo-tx-uboot.git] / 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         struct exynos5_gpio_part1 *gpio1 =
17                 (struct exynos5_gpio_part1 *) samsung_get_base_gpio_part1();
18         struct s5p_gpio_bank *bank;
19         int i, start, count;
20
21         switch (peripheral) {
22         case PERIPH_ID_UART0:
23                 bank = &gpio1->a0;
24                 start = 0;
25                 count = 4;
26                 break;
27         case PERIPH_ID_UART1:
28                 bank = &gpio1->d0;
29                 start = 0;
30                 count = 4;
31                 break;
32         case PERIPH_ID_UART2:
33                 bank = &gpio1->a1;
34                 start = 0;
35                 count = 4;
36                 break;
37         case PERIPH_ID_UART3:
38                 bank = &gpio1->a1;
39                 start = 4;
40                 count = 2;
41                 break;
42         default:
43                 debug("%s: invalid peripheral %d", __func__, peripheral);
44                 return;
45         }
46         for (i = start; i < start + count; i++) {
47                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
48                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
49         }
50 }
51
52 static void exynos5420_uart_config(int peripheral)
53 {
54         struct exynos5420_gpio_part1 *gpio1 =
55                 (struct exynos5420_gpio_part1 *)samsung_get_base_gpio_part1();
56         struct s5p_gpio_bank *bank;
57         int i, start, count;
58
59         switch (peripheral) {
60         case PERIPH_ID_UART0:
61                 bank = &gpio1->a0;
62                 start = 0;
63                 count = 4;
64                 break;
65         case PERIPH_ID_UART1:
66                 bank = &gpio1->a0;
67                 start = 4;
68                 count = 4;
69                 break;
70         case PERIPH_ID_UART2:
71                 bank = &gpio1->a1;
72                 start = 0;
73                 count = 4;
74                 break;
75         case PERIPH_ID_UART3:
76                 bank = &gpio1->a1;
77                 start = 4;
78                 count = 2;
79                 break;
80         default:
81                 debug("%s: invalid peripheral %d", __func__, peripheral);
82                 return;
83         }
84
85         for (i = start; i < start + count; i++) {
86                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
87                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
88         }
89 }
90
91 static int exynos5_mmc_config(int peripheral, int flags)
92 {
93         struct exynos5_gpio_part1 *gpio1 =
94                 (struct exynos5_gpio_part1 *) samsung_get_base_gpio_part1();
95         struct s5p_gpio_bank *bank, *bank_ext;
96         int i, start = 0, gpio_func = 0;
97
98         switch (peripheral) {
99         case PERIPH_ID_SDMMC0:
100                 bank = &gpio1->c0;
101                 bank_ext = &gpio1->c1;
102                 start = 0;
103                 gpio_func = GPIO_FUNC(0x2);
104                 break;
105         case PERIPH_ID_SDMMC1:
106                 bank = &gpio1->c2;
107                 bank_ext = NULL;
108                 break;
109         case PERIPH_ID_SDMMC2:
110                 bank = &gpio1->c3;
111                 bank_ext = &gpio1->c4;
112                 start = 3;
113                 gpio_func = GPIO_FUNC(0x3);
114                 break;
115         case PERIPH_ID_SDMMC3:
116                 bank = &gpio1->c4;
117                 bank_ext = NULL;
118                 break;
119         default:
120                 debug("%s: invalid peripheral %d", __func__, peripheral);
121                 return -1;
122         }
123         if ((flags & PINMUX_FLAG_8BIT_MODE) && !bank_ext) {
124                 debug("SDMMC device %d does not support 8bit mode",
125                                 peripheral);
126                 return -1;
127         }
128         if (flags & PINMUX_FLAG_8BIT_MODE) {
129                 for (i = start; i <= (start + 3); i++) {
130                         s5p_gpio_cfg_pin(bank_ext, i, gpio_func);
131                         s5p_gpio_set_pull(bank_ext, i, GPIO_PULL_UP);
132                         s5p_gpio_set_drv(bank_ext, i, GPIO_DRV_4X);
133                 }
134         }
135         for (i = 0; i < 2; i++) {
136                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
137                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
138                 s5p_gpio_set_drv(bank, i, GPIO_DRV_4X);
139         }
140         for (i = 3; i <= 6; i++) {
141                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
142                 s5p_gpio_set_pull(bank, i, GPIO_PULL_UP);
143                 s5p_gpio_set_drv(bank, i, GPIO_DRV_4X);
144         }
145
146         return 0;
147 }
148
149 static int exynos5420_mmc_config(int peripheral, int flags)
150 {
151         struct exynos5420_gpio_part3 *gpio3 =
152                 (struct exynos5420_gpio_part3 *)samsung_get_base_gpio_part3();
153         struct s5p_gpio_bank *bank = NULL, *bank_ext = NULL;
154         int i, start;
155
156         switch (peripheral) {
157         case PERIPH_ID_SDMMC0:
158                 bank = &gpio3->c0;
159                 bank_ext = &gpio3->c3;
160                 start = 0;
161                 break;
162         case PERIPH_ID_SDMMC1:
163                 bank = &gpio3->c1;
164                 bank_ext = &gpio3->d1;
165                 start = 4;
166                 break;
167         case PERIPH_ID_SDMMC2:
168                 bank = &gpio3->c2;
169                 bank_ext = NULL;
170                 start = 0;
171                 break;
172         default:
173                 start = 0;
174                 debug("%s: invalid peripheral %d", __func__, peripheral);
175                 return -1;
176         }
177
178         if ((flags & PINMUX_FLAG_8BIT_MODE) && !bank_ext) {
179                 debug("SDMMC device %d does not support 8bit mode",
180                       peripheral);
181                 return -1;
182         }
183
184         if (flags & PINMUX_FLAG_8BIT_MODE) {
185                 for (i = start; i <= (start + 3); i++) {
186                         s5p_gpio_cfg_pin(bank_ext, i, GPIO_FUNC(0x2));
187                         s5p_gpio_set_pull(bank_ext, i, GPIO_PULL_UP);
188                         s5p_gpio_set_drv(bank_ext, i, GPIO_DRV_4X);
189                 }
190         }
191
192         for (i = 0; i < 3; i++) {
193                 /*
194                  * MMC0 is intended to be used for eMMC. The
195                  * card detect pin is used as a VDDEN signal to
196                  * power on the eMMC. The 5420 iROM makes
197                  * this same assumption.
198                  */
199                 if ((peripheral == PERIPH_ID_SDMMC0) && (i == 2)) {
200                         s5p_gpio_set_value(bank, i, 1);
201                         s5p_gpio_cfg_pin(bank, i, GPIO_OUTPUT);
202                 } else {
203                         s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
204                 }
205                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
206                 s5p_gpio_set_drv(bank, i, GPIO_DRV_4X);
207         }
208
209         for (i = 3; i <= 6; i++) {
210                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
211                 s5p_gpio_set_pull(bank, i, GPIO_PULL_UP);
212                 s5p_gpio_set_drv(bank, i, GPIO_DRV_4X);
213         }
214
215         return 0;
216 }
217
218 static void exynos5_sromc_config(int flags)
219 {
220         struct exynos5_gpio_part1 *gpio1 =
221                 (struct exynos5_gpio_part1 *) samsung_get_base_gpio_part1();
222         int i;
223
224         /*
225          * SROM:CS1 and EBI
226          *
227          * GPY0[0]      SROM_CSn[0]
228          * GPY0[1]      SROM_CSn[1](2)
229          * GPY0[2]      SROM_CSn[2]
230          * GPY0[3]      SROM_CSn[3]
231          * GPY0[4]      EBI_OEn(2)
232          * GPY0[5]      EBI_EEn(2)
233          *
234          * GPY1[0]      EBI_BEn[0](2)
235          * GPY1[1]      EBI_BEn[1](2)
236          * GPY1[2]      SROM_WAIT(2)
237          * GPY1[3]      EBI_DATA_RDn(2)
238          */
239         s5p_gpio_cfg_pin(&gpio1->y0, (flags & PINMUX_FLAG_BANK),
240                                 GPIO_FUNC(2));
241         s5p_gpio_cfg_pin(&gpio1->y0, 4, GPIO_FUNC(2));
242         s5p_gpio_cfg_pin(&gpio1->y0, 5, GPIO_FUNC(2));
243
244         for (i = 0; i < 4; i++)
245                 s5p_gpio_cfg_pin(&gpio1->y1, i, GPIO_FUNC(2));
246
247         /*
248          * EBI: 8 Addrss Lines
249          *
250          * GPY3[0]      EBI_ADDR[0](2)
251          * GPY3[1]      EBI_ADDR[1](2)
252          * GPY3[2]      EBI_ADDR[2](2)
253          * GPY3[3]      EBI_ADDR[3](2)
254          * GPY3[4]      EBI_ADDR[4](2)
255          * GPY3[5]      EBI_ADDR[5](2)
256          * GPY3[6]      EBI_ADDR[6](2)
257          * GPY3[7]      EBI_ADDR[7](2)
258          *
259          * EBI: 16 Data Lines
260          *
261          * GPY5[0]      EBI_DATA[0](2)
262          * GPY5[1]      EBI_DATA[1](2)
263          * GPY5[2]      EBI_DATA[2](2)
264          * GPY5[3]      EBI_DATA[3](2)
265          * GPY5[4]      EBI_DATA[4](2)
266          * GPY5[5]      EBI_DATA[5](2)
267          * GPY5[6]      EBI_DATA[6](2)
268          * GPY5[7]      EBI_DATA[7](2)
269          *
270          * GPY6[0]      EBI_DATA[8](2)
271          * GPY6[1]      EBI_DATA[9](2)
272          * GPY6[2]      EBI_DATA[10](2)
273          * GPY6[3]      EBI_DATA[11](2)
274          * GPY6[4]      EBI_DATA[12](2)
275          * GPY6[5]      EBI_DATA[13](2)
276          * GPY6[6]      EBI_DATA[14](2)
277          * GPY6[7]      EBI_DATA[15](2)
278          */
279         for (i = 0; i < 8; i++) {
280                 s5p_gpio_cfg_pin(&gpio1->y3, i, GPIO_FUNC(2));
281                 s5p_gpio_set_pull(&gpio1->y3, i, GPIO_PULL_UP);
282
283                 s5p_gpio_cfg_pin(&gpio1->y5, i, GPIO_FUNC(2));
284                 s5p_gpio_set_pull(&gpio1->y5, i, GPIO_PULL_UP);
285
286                 s5p_gpio_cfg_pin(&gpio1->y6, i, GPIO_FUNC(2));
287                 s5p_gpio_set_pull(&gpio1->y6, i, GPIO_PULL_UP);
288         }
289 }
290
291 static void exynos5_i2c_config(int peripheral, int flags)
292 {
293
294         struct exynos5_gpio_part1 *gpio1 =
295                 (struct exynos5_gpio_part1 *) samsung_get_base_gpio_part1();
296
297         switch (peripheral) {
298         case PERIPH_ID_I2C0:
299                 s5p_gpio_cfg_pin(&gpio1->b3, 0, GPIO_FUNC(0x2));
300                 s5p_gpio_cfg_pin(&gpio1->b3, 1, GPIO_FUNC(0x2));
301                 break;
302         case PERIPH_ID_I2C1:
303                 s5p_gpio_cfg_pin(&gpio1->b3, 2, GPIO_FUNC(0x2));
304                 s5p_gpio_cfg_pin(&gpio1->b3, 3, GPIO_FUNC(0x2));
305                 break;
306         case PERIPH_ID_I2C2:
307                 s5p_gpio_cfg_pin(&gpio1->a0, 6, GPIO_FUNC(0x3));
308                 s5p_gpio_cfg_pin(&gpio1->a0, 7, GPIO_FUNC(0x3));
309                 break;
310         case PERIPH_ID_I2C3:
311                 s5p_gpio_cfg_pin(&gpio1->a1, 2, GPIO_FUNC(0x3));
312                 s5p_gpio_cfg_pin(&gpio1->a1, 3, GPIO_FUNC(0x3));
313                 break;
314         case PERIPH_ID_I2C4:
315                 s5p_gpio_cfg_pin(&gpio1->a2, 0, GPIO_FUNC(0x3));
316                 s5p_gpio_cfg_pin(&gpio1->a2, 1, GPIO_FUNC(0x3));
317                 break;
318         case PERIPH_ID_I2C5:
319                 s5p_gpio_cfg_pin(&gpio1->a2, 2, GPIO_FUNC(0x3));
320                 s5p_gpio_cfg_pin(&gpio1->a2, 3, GPIO_FUNC(0x3));
321                 break;
322         case PERIPH_ID_I2C6:
323                 s5p_gpio_cfg_pin(&gpio1->b1, 3, GPIO_FUNC(0x4));
324                 s5p_gpio_cfg_pin(&gpio1->b1, 4, GPIO_FUNC(0x4));
325                 break;
326         case PERIPH_ID_I2C7:
327                 s5p_gpio_cfg_pin(&gpio1->b2, 2, GPIO_FUNC(0x3));
328                 s5p_gpio_cfg_pin(&gpio1->b2, 3, GPIO_FUNC(0x3));
329                 break;
330         }
331 }
332
333 static void exynos5420_i2c_config(int peripheral)
334 {
335         struct exynos5420_gpio_part1 *gpio1 =
336                 (struct exynos5420_gpio_part1 *)samsung_get_base_gpio_part1();
337
338         switch (peripheral) {
339         case PERIPH_ID_I2C0:
340                 s5p_gpio_cfg_pin(&gpio1->b3, 0, GPIO_FUNC(0x2));
341                 s5p_gpio_cfg_pin(&gpio1->b3, 1, GPIO_FUNC(0x2));
342                 break;
343         case PERIPH_ID_I2C1:
344                 s5p_gpio_cfg_pin(&gpio1->b3, 2, GPIO_FUNC(0x2));
345                 s5p_gpio_cfg_pin(&gpio1->b3, 3, GPIO_FUNC(0x2));
346                 break;
347         case PERIPH_ID_I2C2:
348                 s5p_gpio_cfg_pin(&gpio1->a0, 6, GPIO_FUNC(0x3));
349                 s5p_gpio_cfg_pin(&gpio1->a0, 7, GPIO_FUNC(0x3));
350                 break;
351         case PERIPH_ID_I2C3:
352                 s5p_gpio_cfg_pin(&gpio1->a1, 2, GPIO_FUNC(0x3));
353                 s5p_gpio_cfg_pin(&gpio1->a1, 3, GPIO_FUNC(0x3));
354                 break;
355         case PERIPH_ID_I2C4:
356                 s5p_gpio_cfg_pin(&gpio1->a2, 0, GPIO_FUNC(0x3));
357                 s5p_gpio_cfg_pin(&gpio1->a2, 1, GPIO_FUNC(0x3));
358                 break;
359         case PERIPH_ID_I2C5:
360                 s5p_gpio_cfg_pin(&gpio1->a2, 2, GPIO_FUNC(0x3));
361                 s5p_gpio_cfg_pin(&gpio1->a2, 3, GPIO_FUNC(0x3));
362                 break;
363         case PERIPH_ID_I2C6:
364                 s5p_gpio_cfg_pin(&gpio1->b1, 3, GPIO_FUNC(0x4));
365                 s5p_gpio_cfg_pin(&gpio1->b1, 4, GPIO_FUNC(0x4));
366                 break;
367         case PERIPH_ID_I2C7:
368                 s5p_gpio_cfg_pin(&gpio1->b2, 2, GPIO_FUNC(0x3));
369                 s5p_gpio_cfg_pin(&gpio1->b2, 3, GPIO_FUNC(0x3));
370                 break;
371         case PERIPH_ID_I2C8:
372                 s5p_gpio_cfg_pin(&gpio1->b3, 4, GPIO_FUNC(0x2));
373                 s5p_gpio_cfg_pin(&gpio1->b3, 5, GPIO_FUNC(0x2));
374                 break;
375         case PERIPH_ID_I2C9:
376                 s5p_gpio_cfg_pin(&gpio1->b3, 6, GPIO_FUNC(0x2));
377                 s5p_gpio_cfg_pin(&gpio1->b3, 7, GPIO_FUNC(0x2));
378                 break;
379         case PERIPH_ID_I2C10:
380                 s5p_gpio_cfg_pin(&gpio1->b4, 0, GPIO_FUNC(0x2));
381                 s5p_gpio_cfg_pin(&gpio1->b4, 1, GPIO_FUNC(0x2));
382                 break;
383         }
384 }
385
386 static void exynos5_i2s_config(int peripheral)
387 {
388         int i;
389         struct exynos5_gpio_part1 *gpio1 =
390                 (struct exynos5_gpio_part1 *)samsung_get_base_gpio_part1();
391         struct exynos5_gpio_part4 *gpio4 =
392                 (struct exynos5_gpio_part4 *)samsung_get_base_gpio_part4();
393
394         switch (peripheral) {
395         case PERIPH_ID_I2S0:
396                 for (i = 0; i < 5; i++)
397                         s5p_gpio_cfg_pin(&gpio4->z, i, GPIO_FUNC(0x02));
398                 break;
399         case PERIPH_ID_I2S1:
400                 for (i = 0; i < 5; i++)
401                         s5p_gpio_cfg_pin(&gpio1->b0, i, GPIO_FUNC(0x02));
402                 break;
403         }
404 }
405
406 void exynos5_spi_config(int peripheral)
407 {
408         int cfg = 0, pin = 0, i;
409         struct s5p_gpio_bank *bank = NULL;
410         struct exynos5_gpio_part1 *gpio1 =
411                 (struct exynos5_gpio_part1 *) samsung_get_base_gpio_part1();
412         struct exynos5_gpio_part2 *gpio2 =
413                 (struct exynos5_gpio_part2 *) samsung_get_base_gpio_part2();
414
415         switch (peripheral) {
416         case PERIPH_ID_SPI0:
417                 bank = &gpio1->a2;
418                 cfg = GPIO_FUNC(0x2);
419                 pin = 0;
420                 break;
421         case PERIPH_ID_SPI1:
422                 bank = &gpio1->a2;
423                 cfg = GPIO_FUNC(0x2);
424                 pin = 4;
425                 break;
426         case PERIPH_ID_SPI2:
427                 bank = &gpio1->b1;
428                 cfg = GPIO_FUNC(0x5);
429                 pin = 1;
430                 break;
431         case PERIPH_ID_SPI3:
432                 bank = &gpio2->f1;
433                 cfg = GPIO_FUNC(0x2);
434                 pin = 0;
435                 break;
436         case PERIPH_ID_SPI4:
437                 for (i = 0; i < 2; i++) {
438                         s5p_gpio_cfg_pin(&gpio2->f0, i + 2, GPIO_FUNC(0x4));
439                         s5p_gpio_cfg_pin(&gpio2->e0, i + 4, GPIO_FUNC(0x4));
440                 }
441                 break;
442         }
443         if (peripheral != PERIPH_ID_SPI4) {
444                 for (i = pin; i < pin + 4; i++)
445                         s5p_gpio_cfg_pin(bank, i, cfg);
446         }
447 }
448
449 void exynos5420_spi_config(int peripheral)
450 {
451         int cfg, pin, i;
452         struct s5p_gpio_bank *bank = NULL;
453         struct exynos5420_gpio_part1 *gpio1 =
454                 (struct exynos5420_gpio_part1 *)samsung_get_base_gpio_part1();
455         struct exynos5420_gpio_part4 *gpio4 =
456                 (struct exynos5420_gpio_part4 *)samsung_get_base_gpio_part4();
457
458         switch (peripheral) {
459         case PERIPH_ID_SPI0:
460                 bank = &gpio1->a2;
461                 cfg = GPIO_FUNC(0x2);
462                 pin = 0;
463                 break;
464         case PERIPH_ID_SPI1:
465                 bank = &gpio1->a2;
466                 cfg = GPIO_FUNC(0x2);
467                 pin = 4;
468                 break;
469         case PERIPH_ID_SPI2:
470                 bank = &gpio1->b1;
471                 cfg = GPIO_FUNC(0x5);
472                 pin = 1;
473                 break;
474         case PERIPH_ID_SPI3:
475                 bank = &gpio4->f1;
476                 cfg = GPIO_FUNC(0x2);
477                 pin = 0;
478                 break;
479         case PERIPH_ID_SPI4:
480                 cfg = 0;
481                 pin = 0;
482                 break;
483         default:
484                 cfg = 0;
485                 pin = 0;
486                 debug("%s: invalid peripheral %d", __func__, peripheral);
487                 return;
488         }
489
490         if (peripheral != PERIPH_ID_SPI4) {
491                 for (i = pin; i < pin + 4; i++)
492                         s5p_gpio_cfg_pin(bank, i, cfg);
493         } else {
494                 for (i = 0; i < 2; i++) {
495                         s5p_gpio_cfg_pin(&gpio4->f0, i + 2, GPIO_FUNC(0x4));
496                         s5p_gpio_cfg_pin(&gpio4->e0, i + 4, GPIO_FUNC(0x4));
497                 }
498         }
499 }
500
501 static int exynos5_pinmux_config(int peripheral, int flags)
502 {
503         switch (peripheral) {
504         case PERIPH_ID_UART0:
505         case PERIPH_ID_UART1:
506         case PERIPH_ID_UART2:
507         case PERIPH_ID_UART3:
508                 exynos5_uart_config(peripheral);
509                 break;
510         case PERIPH_ID_SDMMC0:
511         case PERIPH_ID_SDMMC1:
512         case PERIPH_ID_SDMMC2:
513         case PERIPH_ID_SDMMC3:
514                 return exynos5_mmc_config(peripheral, flags);
515         case PERIPH_ID_SROMC:
516                 exynos5_sromc_config(flags);
517                 break;
518         case PERIPH_ID_I2C0:
519         case PERIPH_ID_I2C1:
520         case PERIPH_ID_I2C2:
521         case PERIPH_ID_I2C3:
522         case PERIPH_ID_I2C4:
523         case PERIPH_ID_I2C5:
524         case PERIPH_ID_I2C6:
525         case PERIPH_ID_I2C7:
526                 exynos5_i2c_config(peripheral, flags);
527                 break;
528         case PERIPH_ID_I2S0:
529         case PERIPH_ID_I2S1:
530                 exynos5_i2s_config(peripheral);
531                 break;
532         case PERIPH_ID_SPI0:
533         case PERIPH_ID_SPI1:
534         case PERIPH_ID_SPI2:
535         case PERIPH_ID_SPI3:
536         case PERIPH_ID_SPI4:
537                 exynos5_spi_config(peripheral);
538                 break;
539         default:
540                 debug("%s: invalid peripheral %d", __func__, peripheral);
541                 return -1;
542         }
543
544         return 0;
545 }
546
547 static int exynos5420_pinmux_config(int peripheral, int flags)
548 {
549         switch (peripheral) {
550         case PERIPH_ID_UART0:
551         case PERIPH_ID_UART1:
552         case PERIPH_ID_UART2:
553         case PERIPH_ID_UART3:
554                 exynos5420_uart_config(peripheral);
555                 break;
556         case PERIPH_ID_SDMMC0:
557         case PERIPH_ID_SDMMC1:
558         case PERIPH_ID_SDMMC2:
559         case PERIPH_ID_SDMMC3:
560                 return exynos5420_mmc_config(peripheral, flags);
561         case PERIPH_ID_SPI0:
562         case PERIPH_ID_SPI1:
563         case PERIPH_ID_SPI2:
564         case PERIPH_ID_SPI3:
565         case PERIPH_ID_SPI4:
566                 exynos5420_spi_config(peripheral);
567                 break;
568         case PERIPH_ID_I2C0:
569         case PERIPH_ID_I2C1:
570         case PERIPH_ID_I2C2:
571         case PERIPH_ID_I2C3:
572         case PERIPH_ID_I2C4:
573         case PERIPH_ID_I2C5:
574         case PERIPH_ID_I2C6:
575         case PERIPH_ID_I2C7:
576         case PERIPH_ID_I2C8:
577         case PERIPH_ID_I2C9:
578         case PERIPH_ID_I2C10:
579                 exynos5420_i2c_config(peripheral);
580                 break;
581         default:
582                 debug("%s: invalid peripheral %d", __func__, peripheral);
583                 return -1;
584         }
585
586         return 0;
587 }
588
589 static void exynos4_i2c_config(int peripheral, int flags)
590 {
591         struct exynos4_gpio_part1 *gpio1 =
592                 (struct exynos4_gpio_part1 *) samsung_get_base_gpio_part1();
593
594         switch (peripheral) {
595         case PERIPH_ID_I2C0:
596                 s5p_gpio_cfg_pin(&gpio1->d1, 0, GPIO_FUNC(0x2));
597                 s5p_gpio_cfg_pin(&gpio1->d1, 1, GPIO_FUNC(0x2));
598                 break;
599         case PERIPH_ID_I2C1:
600                 s5p_gpio_cfg_pin(&gpio1->d1, 2, GPIO_FUNC(0x2));
601                 s5p_gpio_cfg_pin(&gpio1->d1, 3, GPIO_FUNC(0x2));
602                 break;
603         case PERIPH_ID_I2C2:
604                 s5p_gpio_cfg_pin(&gpio1->a0, 6, GPIO_FUNC(0x3));
605                 s5p_gpio_cfg_pin(&gpio1->a0, 7, GPIO_FUNC(0x3));
606                 break;
607         case PERIPH_ID_I2C3:
608                 s5p_gpio_cfg_pin(&gpio1->a1, 2, GPIO_FUNC(0x3));
609                 s5p_gpio_cfg_pin(&gpio1->a1, 3, GPIO_FUNC(0x3));
610                 break;
611         case PERIPH_ID_I2C4:
612                 s5p_gpio_cfg_pin(&gpio1->b, 2, GPIO_FUNC(0x3));
613                 s5p_gpio_cfg_pin(&gpio1->b, 3, GPIO_FUNC(0x3));
614                 break;
615         case PERIPH_ID_I2C5:
616                 s5p_gpio_cfg_pin(&gpio1->b, 6, GPIO_FUNC(0x3));
617                 s5p_gpio_cfg_pin(&gpio1->b, 7, GPIO_FUNC(0x3));
618                 break;
619         case PERIPH_ID_I2C6:
620                 s5p_gpio_cfg_pin(&gpio1->c1, 3, GPIO_FUNC(0x4));
621                 s5p_gpio_cfg_pin(&gpio1->c1, 4, GPIO_FUNC(0x4));
622                 break;
623         case PERIPH_ID_I2C7:
624                 s5p_gpio_cfg_pin(&gpio1->d0, 2, GPIO_FUNC(0x3));
625                 s5p_gpio_cfg_pin(&gpio1->d0, 3, GPIO_FUNC(0x3));
626                 break;
627         }
628 }
629
630 static int exynos4_mmc_config(int peripheral, int flags)
631 {
632         struct exynos4_gpio_part2 *gpio2 =
633                 (struct exynos4_gpio_part2 *)samsung_get_base_gpio_part2();
634         struct s5p_gpio_bank *bank, *bank_ext;
635         int i;
636
637         switch (peripheral) {
638         case PERIPH_ID_SDMMC0:
639                 bank = &gpio2->k0;
640                 bank_ext = &gpio2->k1;
641                 break;
642         case PERIPH_ID_SDMMC2:
643                 bank = &gpio2->k2;
644                 bank_ext = &gpio2->k3;
645                 break;
646         default:
647                 return -1;
648         }
649         for (i = 0; i < 7; i++) {
650                 if (i == 2)
651                         continue;
652                 s5p_gpio_cfg_pin(bank, i,  GPIO_FUNC(0x2));
653                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
654                 s5p_gpio_set_drv(bank, i, GPIO_DRV_4X);
655         }
656         if (flags & PINMUX_FLAG_8BIT_MODE) {
657                 for (i = 3; i < 7; i++) {
658                         s5p_gpio_cfg_pin(bank_ext, i,  GPIO_FUNC(0x3));
659                         s5p_gpio_set_pull(bank_ext, i, GPIO_PULL_NONE);
660                         s5p_gpio_set_drv(bank_ext, i, GPIO_DRV_4X);
661                 }
662         }
663
664         return 0;
665 }
666
667 static void exynos4_uart_config(int peripheral)
668 {
669         struct exynos4_gpio_part1 *gpio1 =
670                 (struct exynos4_gpio_part1 *)samsung_get_base_gpio_part1();
671         struct s5p_gpio_bank *bank;
672         int i, start, count;
673
674         switch (peripheral) {
675         case PERIPH_ID_UART0:
676                 bank = &gpio1->a0;
677                 start = 0;
678                 count = 4;
679                 break;
680         case PERIPH_ID_UART1:
681                 bank = &gpio1->a0;
682                 start = 4;
683                 count = 4;
684                 break;
685         case PERIPH_ID_UART2:
686                 bank = &gpio1->a1;
687                 start = 0;
688                 count = 4;
689                 break;
690         case PERIPH_ID_UART3:
691                 bank = &gpio1->a1;
692                 start = 4;
693                 count = 2;
694                 break;
695         default:
696                 debug("%s: invalid peripheral %d", __func__, peripheral);
697                 return;
698         }
699         for (i = start; i < start + count; i++) {
700                 s5p_gpio_set_pull(bank, i, GPIO_PULL_NONE);
701                 s5p_gpio_cfg_pin(bank, i, GPIO_FUNC(0x2));
702         }
703 }
704 static int exynos4_pinmux_config(int peripheral, int flags)
705 {
706         switch (peripheral) {
707         case PERIPH_ID_UART0:
708         case PERIPH_ID_UART1:
709         case PERIPH_ID_UART2:
710         case PERIPH_ID_UART3:
711                 exynos4_uart_config(peripheral);
712                 break;
713         case PERIPH_ID_I2C0:
714         case PERIPH_ID_I2C1:
715         case PERIPH_ID_I2C2:
716         case PERIPH_ID_I2C3:
717         case PERIPH_ID_I2C4:
718         case PERIPH_ID_I2C5:
719         case PERIPH_ID_I2C6:
720         case PERIPH_ID_I2C7:
721                 exynos4_i2c_config(peripheral, flags);
722                 break;
723         case PERIPH_ID_SDMMC0:
724         case PERIPH_ID_SDMMC2:
725                 return exynos4_mmc_config(peripheral, flags);
726         case PERIPH_ID_SDMMC1:
727         case PERIPH_ID_SDMMC3:
728         case PERIPH_ID_SDMMC4:
729                 debug("SDMMC device %d not implemented\n", peripheral);
730                 return -1;
731         default:
732                 debug("%s: invalid peripheral %d", __func__, peripheral);
733                 return -1;
734         }
735
736         return 0;
737 }
738
739 int exynos_pinmux_config(int peripheral, int flags)
740 {
741         if (cpu_is_exynos5()) {
742                 if (proid_is_exynos5420())
743                         return exynos5420_pinmux_config(peripheral, flags);
744                 else if (proid_is_exynos5250())
745                         return exynos5_pinmux_config(peripheral, flags);
746         } else if (cpu_is_exynos4()) {
747                 return exynos4_pinmux_config(peripheral, flags);
748         } else {
749                 debug("pinmux functionality not supported\n");
750         }
751
752         return -1;
753 }
754
755 #ifdef CONFIG_OF_CONTROL
756 static int exynos4_pinmux_decode_periph_id(const void *blob, int node)
757 {
758         int err;
759         u32 cell[3];
760
761         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
762                                         ARRAY_SIZE(cell));
763         if (err) {
764                 debug(" invalid peripheral id\n");
765                 return PERIPH_ID_NONE;
766         }
767
768         return cell[1];
769 }
770
771 static int exynos5_pinmux_decode_periph_id(const void *blob, int node)
772 {
773         int err;
774         u32 cell[3];
775
776         err = fdtdec_get_int_array(blob, node, "interrupts", cell,
777                                         ARRAY_SIZE(cell));
778         if (err)
779                 return PERIPH_ID_NONE;
780
781         return cell[1];
782 }
783
784 int pinmux_decode_periph_id(const void *blob, int node)
785 {
786         if (cpu_is_exynos5())
787                 return  exynos5_pinmux_decode_periph_id(blob, node);
788         else if (cpu_is_exynos4())
789                 return  exynos4_pinmux_decode_periph_id(blob, node);
790         else
791                 return PERIPH_ID_NONE;
792 }
793 #endif