]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/gpio/gpio-samsung.c
gpio: samsung: remove s5p64x0 related gpio codes
[karo-tx-linux.git] / drivers / gpio / gpio-samsung.c
1 /*
2  * Copyright (c) 2009-2011 Samsung Electronics Co., Ltd.
3  *              http://www.samsung.com/
4  *
5  * Copyright 2008 Openmoko, Inc.
6  * Copyright 2008 Simtec Electronics
7  *      Ben Dooks <ben@simtec.co.uk>
8  *      http://armlinux.simtec.co.uk/
9  *
10  * SAMSUNG - GPIOlib support
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License version 2 as
14  * published by the Free Software Foundation.
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/irq.h>
19 #include <linux/io.h>
20 #include <linux/gpio.h>
21 #include <linux/init.h>
22 #include <linux/spinlock.h>
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/device.h>
26 #include <linux/ioport.h>
27 #include <linux/of.h>
28 #include <linux/slab.h>
29 #include <linux/of_address.h>
30
31 #include <asm/irq.h>
32
33 #include <mach/map.h>
34 #include <mach/regs-gpio.h>
35
36 #if defined(CONFIG_ARCH_S3C24XX) || defined(CONFIG_ARCH_S3C64XX)
37 #include <mach/gpio-samsung.h>
38 #endif
39
40 #include <plat/cpu.h>
41 #include <plat/gpio-core.h>
42 #include <plat/gpio-cfg.h>
43 #include <plat/gpio-cfg-helpers.h>
44 #include <plat/pm.h>
45
46 int samsung_gpio_setpull_updown(struct samsung_gpio_chip *chip,
47                                 unsigned int off, samsung_gpio_pull_t pull)
48 {
49         void __iomem *reg = chip->base + 0x08;
50         int shift = off * 2;
51         u32 pup;
52
53         pup = __raw_readl(reg);
54         pup &= ~(3 << shift);
55         pup |= pull << shift;
56         __raw_writel(pup, reg);
57
58         return 0;
59 }
60
61 samsung_gpio_pull_t samsung_gpio_getpull_updown(struct samsung_gpio_chip *chip,
62                                                 unsigned int off)
63 {
64         void __iomem *reg = chip->base + 0x08;
65         int shift = off * 2;
66         u32 pup = __raw_readl(reg);
67
68         pup >>= shift;
69         pup &= 0x3;
70
71         return (__force samsung_gpio_pull_t)pup;
72 }
73
74 int s3c2443_gpio_setpull(struct samsung_gpio_chip *chip,
75                          unsigned int off, samsung_gpio_pull_t pull)
76 {
77         switch (pull) {
78         case S3C_GPIO_PULL_NONE:
79                 pull = 0x01;
80                 break;
81         case S3C_GPIO_PULL_UP:
82                 pull = 0x00;
83                 break;
84         case S3C_GPIO_PULL_DOWN:
85                 pull = 0x02;
86                 break;
87         }
88         return samsung_gpio_setpull_updown(chip, off, pull);
89 }
90
91 samsung_gpio_pull_t s3c2443_gpio_getpull(struct samsung_gpio_chip *chip,
92                                          unsigned int off)
93 {
94         samsung_gpio_pull_t pull;
95
96         pull = samsung_gpio_getpull_updown(chip, off);
97
98         switch (pull) {
99         case 0x00:
100                 pull = S3C_GPIO_PULL_UP;
101                 break;
102         case 0x01:
103         case 0x03:
104                 pull = S3C_GPIO_PULL_NONE;
105                 break;
106         case 0x02:
107                 pull = S3C_GPIO_PULL_DOWN;
108                 break;
109         }
110
111         return pull;
112 }
113
114 static int s3c24xx_gpio_setpull_1(struct samsung_gpio_chip *chip,
115                                   unsigned int off, samsung_gpio_pull_t pull,
116                                   samsung_gpio_pull_t updown)
117 {
118         void __iomem *reg = chip->base + 0x08;
119         u32 pup = __raw_readl(reg);
120
121         if (pull == updown)
122                 pup &= ~(1 << off);
123         else if (pull == S3C_GPIO_PULL_NONE)
124                 pup |= (1 << off);
125         else
126                 return -EINVAL;
127
128         __raw_writel(pup, reg);
129         return 0;
130 }
131
132 static samsung_gpio_pull_t s3c24xx_gpio_getpull_1(struct samsung_gpio_chip *chip,
133                                                   unsigned int off,
134                                                   samsung_gpio_pull_t updown)
135 {
136         void __iomem *reg = chip->base + 0x08;
137         u32 pup = __raw_readl(reg);
138
139         pup &= (1 << off);
140         return pup ? S3C_GPIO_PULL_NONE : updown;
141 }
142
143 samsung_gpio_pull_t s3c24xx_gpio_getpull_1up(struct samsung_gpio_chip *chip,
144                                              unsigned int off)
145 {
146         return s3c24xx_gpio_getpull_1(chip, off, S3C_GPIO_PULL_UP);
147 }
148
149 int s3c24xx_gpio_setpull_1up(struct samsung_gpio_chip *chip,
150                              unsigned int off, samsung_gpio_pull_t pull)
151 {
152         return s3c24xx_gpio_setpull_1(chip, off, pull, S3C_GPIO_PULL_UP);
153 }
154
155 samsung_gpio_pull_t s3c24xx_gpio_getpull_1down(struct samsung_gpio_chip *chip,
156                                                unsigned int off)
157 {
158         return s3c24xx_gpio_getpull_1(chip, off, S3C_GPIO_PULL_DOWN);
159 }
160
161 int s3c24xx_gpio_setpull_1down(struct samsung_gpio_chip *chip,
162                                unsigned int off, samsung_gpio_pull_t pull)
163 {
164         return s3c24xx_gpio_setpull_1(chip, off, pull, S3C_GPIO_PULL_DOWN);
165 }
166
167 /*
168  * samsung_gpio_setcfg_2bit - Samsung 2bit style GPIO configuration.
169  * @chip: The gpio chip that is being configured.
170  * @off: The offset for the GPIO being configured.
171  * @cfg: The configuration value to set.
172  *
173  * This helper deal with the GPIO cases where the control register
174  * has two bits of configuration per gpio, which have the following
175  * functions:
176  *      00 = input
177  *      01 = output
178  *      1x = special function
179  */
180
181 static int samsung_gpio_setcfg_2bit(struct samsung_gpio_chip *chip,
182                                     unsigned int off, unsigned int cfg)
183 {
184         void __iomem *reg = chip->base;
185         unsigned int shift = off * 2;
186         u32 con;
187
188         if (samsung_gpio_is_cfg_special(cfg)) {
189                 cfg &= 0xf;
190                 if (cfg > 3)
191                         return -EINVAL;
192
193                 cfg <<= shift;
194         }
195
196         con = __raw_readl(reg);
197         con &= ~(0x3 << shift);
198         con |= cfg;
199         __raw_writel(con, reg);
200
201         return 0;
202 }
203
204 /*
205  * samsung_gpio_getcfg_2bit - Samsung 2bit style GPIO configuration read.
206  * @chip: The gpio chip that is being configured.
207  * @off: The offset for the GPIO being configured.
208  *
209  * The reverse of samsung_gpio_setcfg_2bit(). Will return a value which
210  * could be directly passed back to samsung_gpio_setcfg_2bit(), from the
211  * S3C_GPIO_SPECIAL() macro.
212  */
213
214 static unsigned int samsung_gpio_getcfg_2bit(struct samsung_gpio_chip *chip,
215                                              unsigned int off)
216 {
217         u32 con;
218
219         con = __raw_readl(chip->base);
220         con >>= off * 2;
221         con &= 3;
222
223         /* this conversion works for IN and OUT as well as special mode */
224         return S3C_GPIO_SPECIAL(con);
225 }
226
227 /*
228  * samsung_gpio_setcfg_4bit - Samsung 4bit single register GPIO config.
229  * @chip: The gpio chip that is being configured.
230  * @off: The offset for the GPIO being configured.
231  * @cfg: The configuration value to set.
232  *
233  * This helper deal with the GPIO cases where the control register has 4 bits
234  * of control per GPIO, generally in the form of:
235  *      0000 = Input
236  *      0001 = Output
237  *      others = Special functions (dependent on bank)
238  *
239  * Note, since the code to deal with the case where there are two control
240  * registers instead of one, we do not have a separate set of functions for
241  * each case.
242  */
243
244 static int samsung_gpio_setcfg_4bit(struct samsung_gpio_chip *chip,
245                                     unsigned int off, unsigned int cfg)
246 {
247         void __iomem *reg = chip->base;
248         unsigned int shift = (off & 7) * 4;
249         u32 con;
250
251         if (off < 8 && chip->chip.ngpio > 8)
252                 reg -= 4;
253
254         if (samsung_gpio_is_cfg_special(cfg)) {
255                 cfg &= 0xf;
256                 cfg <<= shift;
257         }
258
259         con = __raw_readl(reg);
260         con &= ~(0xf << shift);
261         con |= cfg;
262         __raw_writel(con, reg);
263
264         return 0;
265 }
266
267 /*
268  * samsung_gpio_getcfg_4bit - Samsung 4bit single register GPIO config read.
269  * @chip: The gpio chip that is being configured.
270  * @off: The offset for the GPIO being configured.
271  *
272  * The reverse of samsung_gpio_setcfg_4bit(), turning a gpio configuration
273  * register setting into a value the software can use, such as could be passed
274  * to samsung_gpio_setcfg_4bit().
275  *
276  * @sa samsung_gpio_getcfg_2bit
277  */
278
279 static unsigned samsung_gpio_getcfg_4bit(struct samsung_gpio_chip *chip,
280                                          unsigned int off)
281 {
282         void __iomem *reg = chip->base;
283         unsigned int shift = (off & 7) * 4;
284         u32 con;
285
286         if (off < 8 && chip->chip.ngpio > 8)
287                 reg -= 4;
288
289         con = __raw_readl(reg);
290         con >>= shift;
291         con &= 0xf;
292
293         /* this conversion works for IN and OUT as well as special mode */
294         return S3C_GPIO_SPECIAL(con);
295 }
296
297 #ifdef CONFIG_PLAT_S3C24XX
298 /*
299  * s3c24xx_gpio_setcfg_abank - S3C24XX style GPIO configuration (Bank A)
300  * @chip: The gpio chip that is being configured.
301  * @off: The offset for the GPIO being configured.
302  * @cfg: The configuration value to set.
303  *
304  * This helper deal with the GPIO cases where the control register
305  * has one bit of configuration for the gpio, where setting the bit
306  * means the pin is in special function mode and unset means output.
307  */
308
309 static int s3c24xx_gpio_setcfg_abank(struct samsung_gpio_chip *chip,
310                                      unsigned int off, unsigned int cfg)
311 {
312         void __iomem *reg = chip->base;
313         unsigned int shift = off;
314         u32 con;
315
316         if (samsung_gpio_is_cfg_special(cfg)) {
317                 cfg &= 0xf;
318
319                 /* Map output to 0, and SFN2 to 1 */
320                 cfg -= 1;
321                 if (cfg > 1)
322                         return -EINVAL;
323
324                 cfg <<= shift;
325         }
326
327         con = __raw_readl(reg);
328         con &= ~(0x1 << shift);
329         con |= cfg;
330         __raw_writel(con, reg);
331
332         return 0;
333 }
334
335 /*
336  * s3c24xx_gpio_getcfg_abank - S3C24XX style GPIO configuration read (Bank A)
337  * @chip: The gpio chip that is being configured.
338  * @off: The offset for the GPIO being configured.
339  *
340  * The reverse of s3c24xx_gpio_setcfg_abank() turning an GPIO into a usable
341  * GPIO configuration value.
342  *
343  * @sa samsung_gpio_getcfg_2bit
344  * @sa samsung_gpio_getcfg_4bit
345  */
346
347 static unsigned s3c24xx_gpio_getcfg_abank(struct samsung_gpio_chip *chip,
348                                           unsigned int off)
349 {
350         u32 con;
351
352         con = __raw_readl(chip->base);
353         con >>= off;
354         con &= 1;
355         con++;
356
357         return S3C_GPIO_SFN(con);
358 }
359 #endif
360
361 static void __init samsung_gpiolib_set_cfg(struct samsung_gpio_cfg *chipcfg,
362                                            int nr_chips)
363 {
364         for (; nr_chips > 0; nr_chips--, chipcfg++) {
365                 if (!chipcfg->set_config)
366                         chipcfg->set_config = samsung_gpio_setcfg_4bit;
367                 if (!chipcfg->get_config)
368                         chipcfg->get_config = samsung_gpio_getcfg_4bit;
369                 if (!chipcfg->set_pull)
370                         chipcfg->set_pull = samsung_gpio_setpull_updown;
371                 if (!chipcfg->get_pull)
372                         chipcfg->get_pull = samsung_gpio_getpull_updown;
373         }
374 }
375
376 struct samsung_gpio_cfg s3c24xx_gpiocfg_default = {
377         .set_config     = samsung_gpio_setcfg_2bit,
378         .get_config     = samsung_gpio_getcfg_2bit,
379 };
380
381 #ifdef CONFIG_PLAT_S3C24XX
382 static struct samsung_gpio_cfg s3c24xx_gpiocfg_banka = {
383         .set_config     = s3c24xx_gpio_setcfg_abank,
384         .get_config     = s3c24xx_gpio_getcfg_abank,
385 };
386 #endif
387
388 static struct samsung_gpio_cfg samsung_gpio_cfgs[] = {
389         [0] = {
390                 .cfg_eint       = 0x0,
391         },
392         [1] = {
393                 .cfg_eint       = 0x3,
394         },
395         [2] = {
396                 .cfg_eint       = 0x7,
397         },
398         [3] = {
399                 .cfg_eint       = 0xF,
400         },
401         [4] = {
402                 .cfg_eint       = 0x0,
403                 .set_config     = samsung_gpio_setcfg_2bit,
404                 .get_config     = samsung_gpio_getcfg_2bit,
405         },
406         [5] = {
407                 .cfg_eint       = 0x2,
408                 .set_config     = samsung_gpio_setcfg_2bit,
409                 .get_config     = samsung_gpio_getcfg_2bit,
410         },
411         [6] = {
412                 .cfg_eint       = 0x3,
413                 .set_config     = samsung_gpio_setcfg_2bit,
414                 .get_config     = samsung_gpio_getcfg_2bit,
415         },
416         [7] = {
417                 .set_config     = samsung_gpio_setcfg_2bit,
418                 .get_config     = samsung_gpio_getcfg_2bit,
419         },
420 };
421
422 /*
423  * Default routines for controlling GPIO, based on the original S3C24XX
424  * GPIO functions which deal with the case where each gpio bank of the
425  * chip is as following:
426  *
427  * base + 0x00: Control register, 2 bits per gpio
428  *              gpio n: 2 bits starting at (2*n)
429  *              00 = input, 01 = output, others mean special-function
430  * base + 0x04: Data register, 1 bit per gpio
431  *              bit n: data bit n
432 */
433
434 static int samsung_gpiolib_2bit_input(struct gpio_chip *chip, unsigned offset)
435 {
436         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
437         void __iomem *base = ourchip->base;
438         unsigned long flags;
439         unsigned long con;
440
441         samsung_gpio_lock(ourchip, flags);
442
443         con = __raw_readl(base + 0x00);
444         con &= ~(3 << (offset * 2));
445
446         __raw_writel(con, base + 0x00);
447
448         samsung_gpio_unlock(ourchip, flags);
449         return 0;
450 }
451
452 static int samsung_gpiolib_2bit_output(struct gpio_chip *chip,
453                                        unsigned offset, int value)
454 {
455         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
456         void __iomem *base = ourchip->base;
457         unsigned long flags;
458         unsigned long dat;
459         unsigned long con;
460
461         samsung_gpio_lock(ourchip, flags);
462
463         dat = __raw_readl(base + 0x04);
464         dat &= ~(1 << offset);
465         if (value)
466                 dat |= 1 << offset;
467         __raw_writel(dat, base + 0x04);
468
469         con = __raw_readl(base + 0x00);
470         con &= ~(3 << (offset * 2));
471         con |= 1 << (offset * 2);
472
473         __raw_writel(con, base + 0x00);
474         __raw_writel(dat, base + 0x04);
475
476         samsung_gpio_unlock(ourchip, flags);
477         return 0;
478 }
479
480 /*
481  * The samsung_gpiolib_4bit routines are to control the gpio banks where
482  * the gpio configuration register (GPxCON) has 4 bits per GPIO, as the
483  * following example:
484  *
485  * base + 0x00: Control register, 4 bits per gpio
486  *              gpio n: 4 bits starting at (4*n)
487  *              0000 = input, 0001 = output, others mean special-function
488  * base + 0x04: Data register, 1 bit per gpio
489  *              bit n: data bit n
490  *
491  * Note, since the data register is one bit per gpio and is at base + 0x4
492  * we can use samsung_gpiolib_get and samsung_gpiolib_set to change the
493  * state of the output.
494  */
495
496 static int samsung_gpiolib_4bit_input(struct gpio_chip *chip,
497                                       unsigned int offset)
498 {
499         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
500         void __iomem *base = ourchip->base;
501         unsigned long con;
502
503         con = __raw_readl(base + GPIOCON_OFF);
504         if (ourchip->bitmap_gpio_int & BIT(offset))
505                 con |= 0xf << con_4bit_shift(offset);
506         else
507                 con &= ~(0xf << con_4bit_shift(offset));
508         __raw_writel(con, base + GPIOCON_OFF);
509
510         pr_debug("%s: %p: CON now %08lx\n", __func__, base, con);
511
512         return 0;
513 }
514
515 static int samsung_gpiolib_4bit_output(struct gpio_chip *chip,
516                                        unsigned int offset, int value)
517 {
518         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
519         void __iomem *base = ourchip->base;
520         unsigned long con;
521         unsigned long dat;
522
523         con = __raw_readl(base + GPIOCON_OFF);
524         con &= ~(0xf << con_4bit_shift(offset));
525         con |= 0x1 << con_4bit_shift(offset);
526
527         dat = __raw_readl(base + GPIODAT_OFF);
528
529         if (value)
530                 dat |= 1 << offset;
531         else
532                 dat &= ~(1 << offset);
533
534         __raw_writel(dat, base + GPIODAT_OFF);
535         __raw_writel(con, base + GPIOCON_OFF);
536         __raw_writel(dat, base + GPIODAT_OFF);
537
538         pr_debug("%s: %p: CON %08lx, DAT %08lx\n", __func__, base, con, dat);
539
540         return 0;
541 }
542
543 /*
544  * The next set of routines are for the case where the GPIO configuration
545  * registers are 4 bits per GPIO but there is more than one register (the
546  * bank has more than 8 GPIOs.
547  *
548  * This case is the similar to the 4 bit case, but the registers are as
549  * follows:
550  *
551  * base + 0x00: Control register, 4 bits per gpio (lower 8 GPIOs)
552  *              gpio n: 4 bits starting at (4*n)
553  *              0000 = input, 0001 = output, others mean special-function
554  * base + 0x04: Control register, 4 bits per gpio (up to 8 additions GPIOs)
555  *              gpio n: 4 bits starting at (4*n)
556  *              0000 = input, 0001 = output, others mean special-function
557  * base + 0x08: Data register, 1 bit per gpio
558  *              bit n: data bit n
559  *
560  * To allow us to use the samsung_gpiolib_get and samsung_gpiolib_set
561  * routines we store the 'base + 0x4' address so that these routines see
562  * the data register at ourchip->base + 0x04.
563  */
564
565 static int samsung_gpiolib_4bit2_input(struct gpio_chip *chip,
566                                        unsigned int offset)
567 {
568         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
569         void __iomem *base = ourchip->base;
570         void __iomem *regcon = base;
571         unsigned long con;
572
573         if (offset > 7)
574                 offset -= 8;
575         else
576                 regcon -= 4;
577
578         con = __raw_readl(regcon);
579         con &= ~(0xf << con_4bit_shift(offset));
580         __raw_writel(con, regcon);
581
582         pr_debug("%s: %p: CON %08lx\n", __func__, base, con);
583
584         return 0;
585 }
586
587 static int samsung_gpiolib_4bit2_output(struct gpio_chip *chip,
588                                         unsigned int offset, int value)
589 {
590         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
591         void __iomem *base = ourchip->base;
592         void __iomem *regcon = base;
593         unsigned long con;
594         unsigned long dat;
595         unsigned con_offset = offset;
596
597         if (con_offset > 7)
598                 con_offset -= 8;
599         else
600                 regcon -= 4;
601
602         con = __raw_readl(regcon);
603         con &= ~(0xf << con_4bit_shift(con_offset));
604         con |= 0x1 << con_4bit_shift(con_offset);
605
606         dat = __raw_readl(base + GPIODAT_OFF);
607
608         if (value)
609                 dat |= 1 << offset;
610         else
611                 dat &= ~(1 << offset);
612
613         __raw_writel(dat, base + GPIODAT_OFF);
614         __raw_writel(con, regcon);
615         __raw_writel(dat, base + GPIODAT_OFF);
616
617         pr_debug("%s: %p: CON %08lx, DAT %08lx\n", __func__, base, con, dat);
618
619         return 0;
620 }
621
622 #ifdef CONFIG_PLAT_S3C24XX
623 /* The next set of routines are for the case of s3c24xx bank a */
624
625 static int s3c24xx_gpiolib_banka_input(struct gpio_chip *chip, unsigned offset)
626 {
627         return -EINVAL;
628 }
629
630 static int s3c24xx_gpiolib_banka_output(struct gpio_chip *chip,
631                                         unsigned offset, int value)
632 {
633         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
634         void __iomem *base = ourchip->base;
635         unsigned long flags;
636         unsigned long dat;
637         unsigned long con;
638
639         local_irq_save(flags);
640
641         con = __raw_readl(base + 0x00);
642         dat = __raw_readl(base + 0x04);
643
644         dat &= ~(1 << offset);
645         if (value)
646                 dat |= 1 << offset;
647
648         __raw_writel(dat, base + 0x04);
649
650         con &= ~(1 << offset);
651
652         __raw_writel(con, base + 0x00);
653         __raw_writel(dat, base + 0x04);
654
655         local_irq_restore(flags);
656         return 0;
657 }
658 #endif
659
660 static void samsung_gpiolib_set(struct gpio_chip *chip,
661                                 unsigned offset, int value)
662 {
663         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
664         void __iomem *base = ourchip->base;
665         unsigned long flags;
666         unsigned long dat;
667
668         samsung_gpio_lock(ourchip, flags);
669
670         dat = __raw_readl(base + 0x04);
671         dat &= ~(1 << offset);
672         if (value)
673                 dat |= 1 << offset;
674         __raw_writel(dat, base + 0x04);
675
676         samsung_gpio_unlock(ourchip, flags);
677 }
678
679 static int samsung_gpiolib_get(struct gpio_chip *chip, unsigned offset)
680 {
681         struct samsung_gpio_chip *ourchip = to_samsung_gpio(chip);
682         unsigned long val;
683
684         val = __raw_readl(ourchip->base + 0x04);
685         val >>= offset;
686         val &= 1;
687
688         return val;
689 }
690
691 /*
692  * CONFIG_S3C_GPIO_TRACK enables the tracking of the s3c specific gpios
693  * for use with the configuration calls, and other parts of the s3c gpiolib
694  * support code.
695  *
696  * Not all s3c support code will need this, as some configurations of cpu
697  * may only support one or two different configuration options and have an
698  * easy gpio to samsung_gpio_chip mapping function. If this is the case, then
699  * the machine support file should provide its own samsung_gpiolib_getchip()
700  * and any other necessary functions.
701  */
702
703 #ifdef CONFIG_S3C_GPIO_TRACK
704 struct samsung_gpio_chip *s3c_gpios[S3C_GPIO_END];
705
706 static __init void s3c_gpiolib_track(struct samsung_gpio_chip *chip)
707 {
708         unsigned int gpn;
709         int i;
710
711         gpn = chip->chip.base;
712         for (i = 0; i < chip->chip.ngpio; i++, gpn++) {
713                 BUG_ON(gpn >= ARRAY_SIZE(s3c_gpios));
714                 s3c_gpios[gpn] = chip;
715         }
716 }
717 #endif /* CONFIG_S3C_GPIO_TRACK */
718
719 /*
720  * samsung_gpiolib_add() - add the Samsung gpio_chip.
721  * @chip: The chip to register
722  *
723  * This is a wrapper to gpiochip_add() that takes our specific gpio chip
724  * information and makes the necessary alterations for the platform and
725  * notes the information for use with the configuration systems and any
726  * other parts of the system.
727  */
728
729 static void __init samsung_gpiolib_add(struct samsung_gpio_chip *chip)
730 {
731         struct gpio_chip *gc = &chip->chip;
732         int ret;
733
734         BUG_ON(!chip->base);
735         BUG_ON(!gc->label);
736         BUG_ON(!gc->ngpio);
737
738         spin_lock_init(&chip->lock);
739
740         if (!gc->direction_input)
741                 gc->direction_input = samsung_gpiolib_2bit_input;
742         if (!gc->direction_output)
743                 gc->direction_output = samsung_gpiolib_2bit_output;
744         if (!gc->set)
745                 gc->set = samsung_gpiolib_set;
746         if (!gc->get)
747                 gc->get = samsung_gpiolib_get;
748
749 #ifdef CONFIG_PM
750         if (chip->pm != NULL) {
751                 if (!chip->pm->save || !chip->pm->resume)
752                         pr_err("gpio: %s has missing PM functions\n",
753                                gc->label);
754         } else
755                 pr_err("gpio: %s has no PM function\n", gc->label);
756 #endif
757
758         /* gpiochip_add() prints own failure message on error. */
759         ret = gpiochip_add(gc);
760         if (ret >= 0)
761                 s3c_gpiolib_track(chip);
762 }
763
764 static void __init s3c24xx_gpiolib_add_chips(struct samsung_gpio_chip *chip,
765                                              int nr_chips, void __iomem *base)
766 {
767         int i;
768         struct gpio_chip *gc = &chip->chip;
769
770         for (i = 0 ; i < nr_chips; i++, chip++) {
771                 /* skip banks not present on SoC */
772                 if (chip->chip.base >= S3C_GPIO_END)
773                         continue;
774
775                 if (!chip->config)
776                         chip->config = &s3c24xx_gpiocfg_default;
777                 if (!chip->pm)
778                         chip->pm = __gpio_pm(&samsung_gpio_pm_2bit);
779                 if ((base != NULL) && (chip->base == NULL))
780                         chip->base = base + ((i) * 0x10);
781
782                 if (!gc->direction_input)
783                         gc->direction_input = samsung_gpiolib_2bit_input;
784                 if (!gc->direction_output)
785                         gc->direction_output = samsung_gpiolib_2bit_output;
786
787                 samsung_gpiolib_add(chip);
788         }
789 }
790
791 static void __init samsung_gpiolib_add_2bit_chips(struct samsung_gpio_chip *chip,
792                                                   int nr_chips, void __iomem *base,
793                                                   unsigned int offset)
794 {
795         int i;
796
797         for (i = 0 ; i < nr_chips; i++, chip++) {
798                 chip->chip.direction_input = samsung_gpiolib_2bit_input;
799                 chip->chip.direction_output = samsung_gpiolib_2bit_output;
800
801                 if (!chip->config)
802                         chip->config = &samsung_gpio_cfgs[7];
803                 if (!chip->pm)
804                         chip->pm = __gpio_pm(&samsung_gpio_pm_2bit);
805                 if ((base != NULL) && (chip->base == NULL))
806                         chip->base = base + ((i) * offset);
807
808                 samsung_gpiolib_add(chip);
809         }
810 }
811
812 /*
813  * samsung_gpiolib_add_4bit_chips - 4bit single register GPIO config.
814  * @chip: The gpio chip that is being configured.
815  * @nr_chips: The no of chips (gpio ports) for the GPIO being configured.
816  *
817  * This helper deal with the GPIO cases where the control register has 4 bits
818  * of control per GPIO, generally in the form of:
819  * 0000 = Input
820  * 0001 = Output
821  * others = Special functions (dependent on bank)
822  *
823  * Note, since the code to deal with the case where there are two control
824  * registers instead of one, we do not have a separate set of function
825  * (samsung_gpiolib_add_4bit2_chips)for each case.
826  */
827
828 static void __init samsung_gpiolib_add_4bit_chips(struct samsung_gpio_chip *chip,
829                                                   int nr_chips, void __iomem *base)
830 {
831         int i;
832
833         for (i = 0 ; i < nr_chips; i++, chip++) {
834                 chip->chip.direction_input = samsung_gpiolib_4bit_input;
835                 chip->chip.direction_output = samsung_gpiolib_4bit_output;
836
837                 if (!chip->config)
838                         chip->config = &samsung_gpio_cfgs[2];
839                 if (!chip->pm)
840                         chip->pm = __gpio_pm(&samsung_gpio_pm_4bit);
841                 if ((base != NULL) && (chip->base == NULL))
842                         chip->base = base + ((i) * 0x20);
843
844                 chip->bitmap_gpio_int = 0;
845
846                 samsung_gpiolib_add(chip);
847         }
848 }
849
850 static void __init samsung_gpiolib_add_4bit2_chips(struct samsung_gpio_chip *chip,
851                                                    int nr_chips)
852 {
853         for (; nr_chips > 0; nr_chips--, chip++) {
854                 chip->chip.direction_input = samsung_gpiolib_4bit2_input;
855                 chip->chip.direction_output = samsung_gpiolib_4bit2_output;
856
857                 if (!chip->config)
858                         chip->config = &samsung_gpio_cfgs[2];
859                 if (!chip->pm)
860                         chip->pm = __gpio_pm(&samsung_gpio_pm_4bit);
861
862                 samsung_gpiolib_add(chip);
863         }
864 }
865
866 int samsung_gpiolib_to_irq(struct gpio_chip *chip, unsigned int offset)
867 {
868         struct samsung_gpio_chip *samsung_chip = container_of(chip, struct samsung_gpio_chip, chip);
869
870         return samsung_chip->irq_base + offset;
871 }
872
873 #ifdef CONFIG_PLAT_S3C24XX
874 static int s3c24xx_gpiolib_fbank_to_irq(struct gpio_chip *chip, unsigned offset)
875 {
876         if (offset < 4) {
877                 if (soc_is_s3c2412())
878                         return IRQ_EINT0_2412 + offset;
879                 else
880                         return IRQ_EINT0 + offset;
881         }
882
883         if (offset < 8)
884                 return IRQ_EINT4 + offset - 4;
885
886         return -EINVAL;
887 }
888 #endif
889
890 #ifdef CONFIG_ARCH_S3C64XX
891 static int s3c64xx_gpiolib_mbank_to_irq(struct gpio_chip *chip, unsigned pin)
892 {
893         return pin < 5 ? IRQ_EINT(23) + pin : -ENXIO;
894 }
895
896 static int s3c64xx_gpiolib_lbank_to_irq(struct gpio_chip *chip, unsigned pin)
897 {
898         return pin >= 8 ? IRQ_EINT(16) + pin - 8 : -ENXIO;
899 }
900 #endif
901
902 struct samsung_gpio_chip s3c24xx_gpios[] = {
903 #ifdef CONFIG_PLAT_S3C24XX
904         {
905                 .config = &s3c24xx_gpiocfg_banka,
906                 .chip   = {
907                         .base                   = S3C2410_GPA(0),
908                         .owner                  = THIS_MODULE,
909                         .label                  = "GPIOA",
910                         .ngpio                  = 27,
911                         .direction_input        = s3c24xx_gpiolib_banka_input,
912                         .direction_output       = s3c24xx_gpiolib_banka_output,
913                 },
914         }, {
915                 .chip   = {
916                         .base   = S3C2410_GPB(0),
917                         .owner  = THIS_MODULE,
918                         .label  = "GPIOB",
919                         .ngpio  = 11,
920                 },
921         }, {
922                 .chip   = {
923                         .base   = S3C2410_GPC(0),
924                         .owner  = THIS_MODULE,
925                         .label  = "GPIOC",
926                         .ngpio  = 16,
927                 },
928         }, {
929                 .chip   = {
930                         .base   = S3C2410_GPD(0),
931                         .owner  = THIS_MODULE,
932                         .label  = "GPIOD",
933                         .ngpio  = 16,
934                 },
935         }, {
936                 .chip   = {
937                         .base   = S3C2410_GPE(0),
938                         .label  = "GPIOE",
939                         .owner  = THIS_MODULE,
940                         .ngpio  = 16,
941                 },
942         }, {
943                 .chip   = {
944                         .base   = S3C2410_GPF(0),
945                         .owner  = THIS_MODULE,
946                         .label  = "GPIOF",
947                         .ngpio  = 8,
948                         .to_irq = s3c24xx_gpiolib_fbank_to_irq,
949                 },
950         }, {
951                 .irq_base = IRQ_EINT8,
952                 .chip   = {
953                         .base   = S3C2410_GPG(0),
954                         .owner  = THIS_MODULE,
955                         .label  = "GPIOG",
956                         .ngpio  = 16,
957                         .to_irq = samsung_gpiolib_to_irq,
958                 },
959         }, {
960                 .chip   = {
961                         .base   = S3C2410_GPH(0),
962                         .owner  = THIS_MODULE,
963                         .label  = "GPIOH",
964                         .ngpio  = 15,
965                 },
966         },
967                 /* GPIOS for the S3C2443 and later devices. */
968         {
969                 .base   = S3C2440_GPJCON,
970                 .chip   = {
971                         .base   = S3C2410_GPJ(0),
972                         .owner  = THIS_MODULE,
973                         .label  = "GPIOJ",
974                         .ngpio  = 16,
975                 },
976         }, {
977                 .base   = S3C2443_GPKCON,
978                 .chip   = {
979                         .base   = S3C2410_GPK(0),
980                         .owner  = THIS_MODULE,
981                         .label  = "GPIOK",
982                         .ngpio  = 16,
983                 },
984         }, {
985                 .base   = S3C2443_GPLCON,
986                 .chip   = {
987                         .base   = S3C2410_GPL(0),
988                         .owner  = THIS_MODULE,
989                         .label  = "GPIOL",
990                         .ngpio  = 15,
991                 },
992         }, {
993                 .base   = S3C2443_GPMCON,
994                 .chip   = {
995                         .base   = S3C2410_GPM(0),
996                         .owner  = THIS_MODULE,
997                         .label  = "GPIOM",
998                         .ngpio  = 2,
999                 },
1000         },
1001 #endif
1002 };
1003
1004 /*
1005  * GPIO bank summary:
1006  *
1007  * Bank GPIOs   Style   SlpCon  ExtInt Group
1008  * A    8       4Bit    Yes     1
1009  * B    7       4Bit    Yes     1
1010  * C    8       4Bit    Yes     2
1011  * D    5       4Bit    Yes     3
1012  * E    5       4Bit    Yes     None
1013  * F    16      2Bit    Yes     4 [1]
1014  * G    7       4Bit    Yes     5
1015  * H    10      4Bit[2] Yes     6
1016  * I    16      2Bit    Yes     None
1017  * J    12      2Bit    Yes     None
1018  * K    16      4Bit[2] No      None
1019  * L    15      4Bit[2] No      None
1020  * M    6       4Bit    No      IRQ_EINT
1021  * N    16      2Bit    No      IRQ_EINT
1022  * O    16      2Bit    Yes     7
1023  * P    15      2Bit    Yes     8
1024  * Q    9       2Bit    Yes     9
1025  *
1026  * [1] BANKF pins 14,15 do not form part of the external interrupt sources
1027  * [2] BANK has two control registers, GPxCON0 and GPxCON1
1028  */
1029
1030 static struct samsung_gpio_chip s3c64xx_gpios_4bit[] = {
1031 #ifdef CONFIG_ARCH_S3C64XX
1032         {
1033                 .chip   = {
1034                         .base   = S3C64XX_GPA(0),
1035                         .ngpio  = S3C64XX_GPIO_A_NR,
1036                         .label  = "GPA",
1037                 },
1038         }, {
1039                 .chip   = {
1040                         .base   = S3C64XX_GPB(0),
1041                         .ngpio  = S3C64XX_GPIO_B_NR,
1042                         .label  = "GPB",
1043                 },
1044         }, {
1045                 .chip   = {
1046                         .base   = S3C64XX_GPC(0),
1047                         .ngpio  = S3C64XX_GPIO_C_NR,
1048                         .label  = "GPC",
1049                 },
1050         }, {
1051                 .chip   = {
1052                         .base   = S3C64XX_GPD(0),
1053                         .ngpio  = S3C64XX_GPIO_D_NR,
1054                         .label  = "GPD",
1055                 },
1056         }, {
1057                 .config = &samsung_gpio_cfgs[0],
1058                 .chip   = {
1059                         .base   = S3C64XX_GPE(0),
1060                         .ngpio  = S3C64XX_GPIO_E_NR,
1061                         .label  = "GPE",
1062                 },
1063         }, {
1064                 .base   = S3C64XX_GPG_BASE,
1065                 .chip   = {
1066                         .base   = S3C64XX_GPG(0),
1067                         .ngpio  = S3C64XX_GPIO_G_NR,
1068                         .label  = "GPG",
1069                 },
1070         }, {
1071                 .base   = S3C64XX_GPM_BASE,
1072                 .config = &samsung_gpio_cfgs[1],
1073                 .chip   = {
1074                         .base   = S3C64XX_GPM(0),
1075                         .ngpio  = S3C64XX_GPIO_M_NR,
1076                         .label  = "GPM",
1077                         .to_irq = s3c64xx_gpiolib_mbank_to_irq,
1078                 },
1079         },
1080 #endif
1081 };
1082
1083 static struct samsung_gpio_chip s3c64xx_gpios_4bit2[] = {
1084 #ifdef CONFIG_ARCH_S3C64XX
1085         {
1086                 .base   = S3C64XX_GPH_BASE + 0x4,
1087                 .chip   = {
1088                         .base   = S3C64XX_GPH(0),
1089                         .ngpio  = S3C64XX_GPIO_H_NR,
1090                         .label  = "GPH",
1091                 },
1092         }, {
1093                 .base   = S3C64XX_GPK_BASE + 0x4,
1094                 .config = &samsung_gpio_cfgs[0],
1095                 .chip   = {
1096                         .base   = S3C64XX_GPK(0),
1097                         .ngpio  = S3C64XX_GPIO_K_NR,
1098                         .label  = "GPK",
1099                 },
1100         }, {
1101                 .base   = S3C64XX_GPL_BASE + 0x4,
1102                 .config = &samsung_gpio_cfgs[1],
1103                 .chip   = {
1104                         .base   = S3C64XX_GPL(0),
1105                         .ngpio  = S3C64XX_GPIO_L_NR,
1106                         .label  = "GPL",
1107                         .to_irq = s3c64xx_gpiolib_lbank_to_irq,
1108                 },
1109         },
1110 #endif
1111 };
1112
1113 static struct samsung_gpio_chip s3c64xx_gpios_2bit[] = {
1114 #ifdef CONFIG_ARCH_S3C64XX
1115         {
1116                 .base   = S3C64XX_GPF_BASE,
1117                 .config = &samsung_gpio_cfgs[6],
1118                 .chip   = {
1119                         .base   = S3C64XX_GPF(0),
1120                         .ngpio  = S3C64XX_GPIO_F_NR,
1121                         .label  = "GPF",
1122                 },
1123         }, {
1124                 .config = &samsung_gpio_cfgs[7],
1125                 .chip   = {
1126                         .base   = S3C64XX_GPI(0),
1127                         .ngpio  = S3C64XX_GPIO_I_NR,
1128                         .label  = "GPI",
1129                 },
1130         }, {
1131                 .config = &samsung_gpio_cfgs[7],
1132                 .chip   = {
1133                         .base   = S3C64XX_GPJ(0),
1134                         .ngpio  = S3C64XX_GPIO_J_NR,
1135                         .label  = "GPJ",
1136                 },
1137         }, {
1138                 .config = &samsung_gpio_cfgs[6],
1139                 .chip   = {
1140                         .base   = S3C64XX_GPO(0),
1141                         .ngpio  = S3C64XX_GPIO_O_NR,
1142                         .label  = "GPO",
1143                 },
1144         }, {
1145                 .config = &samsung_gpio_cfgs[6],
1146                 .chip   = {
1147                         .base   = S3C64XX_GPP(0),
1148                         .ngpio  = S3C64XX_GPIO_P_NR,
1149                         .label  = "GPP",
1150                 },
1151         }, {
1152                 .config = &samsung_gpio_cfgs[6],
1153                 .chip   = {
1154                         .base   = S3C64XX_GPQ(0),
1155                         .ngpio  = S3C64XX_GPIO_Q_NR,
1156                         .label  = "GPQ",
1157                 },
1158         }, {
1159                 .base   = S3C64XX_GPN_BASE,
1160                 .irq_base = IRQ_EINT(0),
1161                 .config = &samsung_gpio_cfgs[5],
1162                 .chip   = {
1163                         .base   = S3C64XX_GPN(0),
1164                         .ngpio  = S3C64XX_GPIO_N_NR,
1165                         .label  = "GPN",
1166                         .to_irq = samsung_gpiolib_to_irq,
1167                 },
1168         },
1169 #endif
1170 };
1171
1172 /*
1173  * S5PC100 GPIO bank summary:
1174  *
1175  * Bank GPIOs   Style   INT Type
1176  * A0   8       4Bit    GPIO_INT0
1177  * A1   5       4Bit    GPIO_INT1
1178  * B    8       4Bit    GPIO_INT2
1179  * C    5       4Bit    GPIO_INT3
1180  * D    7       4Bit    GPIO_INT4
1181  * E0   8       4Bit    GPIO_INT5
1182  * E1   6       4Bit    GPIO_INT6
1183  * F0   8       4Bit    GPIO_INT7
1184  * F1   8       4Bit    GPIO_INT8
1185  * F2   8       4Bit    GPIO_INT9
1186  * F3   4       4Bit    GPIO_INT10
1187  * G0   8       4Bit    GPIO_INT11
1188  * G1   3       4Bit    GPIO_INT12
1189  * G2   7       4Bit    GPIO_INT13
1190  * G3   7       4Bit    GPIO_INT14
1191  * H0   8       4Bit    WKUP_INT
1192  * H1   8       4Bit    WKUP_INT
1193  * H2   8       4Bit    WKUP_INT
1194  * H3   8       4Bit    WKUP_INT
1195  * I    8       4Bit    GPIO_INT15
1196  * J0   8       4Bit    GPIO_INT16
1197  * J1   5       4Bit    GPIO_INT17
1198  * J2   8       4Bit    GPIO_INT18
1199  * J3   8       4Bit    GPIO_INT19
1200  * J4   4       4Bit    GPIO_INT20
1201  * K0   8       4Bit    None
1202  * K1   6       4Bit    None
1203  * K2   8       4Bit    None
1204  * K3   8       4Bit    None
1205  * L0   8       4Bit    None
1206  * L1   8       4Bit    None
1207  * L2   8       4Bit    None
1208  * L3   8       4Bit    None
1209  */
1210
1211 static struct samsung_gpio_chip s5pc100_gpios_4bit[] = {
1212 #ifdef CONFIG_CPU_S5PC100
1213         {
1214                 .chip   = {
1215                         .base   = S5PC100_GPA0(0),
1216                         .ngpio  = S5PC100_GPIO_A0_NR,
1217                         .label  = "GPA0",
1218                 },
1219         }, {
1220                 .chip   = {
1221                         .base   = S5PC100_GPA1(0),
1222                         .ngpio  = S5PC100_GPIO_A1_NR,
1223                         .label  = "GPA1",
1224                 },
1225         }, {
1226                 .chip   = {
1227                         .base   = S5PC100_GPB(0),
1228                         .ngpio  = S5PC100_GPIO_B_NR,
1229                         .label  = "GPB",
1230                 },
1231         }, {
1232                 .chip   = {
1233                         .base   = S5PC100_GPC(0),
1234                         .ngpio  = S5PC100_GPIO_C_NR,
1235                         .label  = "GPC",
1236                 },
1237         }, {
1238                 .chip   = {
1239                         .base   = S5PC100_GPD(0),
1240                         .ngpio  = S5PC100_GPIO_D_NR,
1241                         .label  = "GPD",
1242                 },
1243         }, {
1244                 .chip   = {
1245                         .base   = S5PC100_GPE0(0),
1246                         .ngpio  = S5PC100_GPIO_E0_NR,
1247                         .label  = "GPE0",
1248                 },
1249         }, {
1250                 .chip   = {
1251                         .base   = S5PC100_GPE1(0),
1252                         .ngpio  = S5PC100_GPIO_E1_NR,
1253                         .label  = "GPE1",
1254                 },
1255         }, {
1256                 .chip   = {
1257                         .base   = S5PC100_GPF0(0),
1258                         .ngpio  = S5PC100_GPIO_F0_NR,
1259                         .label  = "GPF0",
1260                 },
1261         }, {
1262                 .chip   = {
1263                         .base   = S5PC100_GPF1(0),
1264                         .ngpio  = S5PC100_GPIO_F1_NR,
1265                         .label  = "GPF1",
1266                 },
1267         }, {
1268                 .chip   = {
1269                         .base   = S5PC100_GPF2(0),
1270                         .ngpio  = S5PC100_GPIO_F2_NR,
1271                         .label  = "GPF2",
1272                 },
1273         }, {
1274                 .chip   = {
1275                         .base   = S5PC100_GPF3(0),
1276                         .ngpio  = S5PC100_GPIO_F3_NR,
1277                         .label  = "GPF3",
1278                 },
1279         }, {
1280                 .chip   = {
1281                         .base   = S5PC100_GPG0(0),
1282                         .ngpio  = S5PC100_GPIO_G0_NR,
1283                         .label  = "GPG0",
1284                 },
1285         }, {
1286                 .chip   = {
1287                         .base   = S5PC100_GPG1(0),
1288                         .ngpio  = S5PC100_GPIO_G1_NR,
1289                         .label  = "GPG1",
1290                 },
1291         }, {
1292                 .chip   = {
1293                         .base   = S5PC100_GPG2(0),
1294                         .ngpio  = S5PC100_GPIO_G2_NR,
1295                         .label  = "GPG2",
1296                 },
1297         }, {
1298                 .chip   = {
1299                         .base   = S5PC100_GPG3(0),
1300                         .ngpio  = S5PC100_GPIO_G3_NR,
1301                         .label  = "GPG3",
1302                 },
1303         }, {
1304                 .chip   = {
1305                         .base   = S5PC100_GPI(0),
1306                         .ngpio  = S5PC100_GPIO_I_NR,
1307                         .label  = "GPI",
1308                 },
1309         }, {
1310                 .chip   = {
1311                         .base   = S5PC100_GPJ0(0),
1312                         .ngpio  = S5PC100_GPIO_J0_NR,
1313                         .label  = "GPJ0",
1314                 },
1315         }, {
1316                 .chip   = {
1317                         .base   = S5PC100_GPJ1(0),
1318                         .ngpio  = S5PC100_GPIO_J1_NR,
1319                         .label  = "GPJ1",
1320                 },
1321         }, {
1322                 .chip   = {
1323                         .base   = S5PC100_GPJ2(0),
1324                         .ngpio  = S5PC100_GPIO_J2_NR,
1325                         .label  = "GPJ2",
1326                 },
1327         }, {
1328                 .chip   = {
1329                         .base   = S5PC100_GPJ3(0),
1330                         .ngpio  = S5PC100_GPIO_J3_NR,
1331                         .label  = "GPJ3",
1332                 },
1333         }, {
1334                 .chip   = {
1335                         .base   = S5PC100_GPJ4(0),
1336                         .ngpio  = S5PC100_GPIO_J4_NR,
1337                         .label  = "GPJ4",
1338                 },
1339         }, {
1340                 .chip   = {
1341                         .base   = S5PC100_GPK0(0),
1342                         .ngpio  = S5PC100_GPIO_K0_NR,
1343                         .label  = "GPK0",
1344                 },
1345         }, {
1346                 .chip   = {
1347                         .base   = S5PC100_GPK1(0),
1348                         .ngpio  = S5PC100_GPIO_K1_NR,
1349                         .label  = "GPK1",
1350                 },
1351         }, {
1352                 .chip   = {
1353                         .base   = S5PC100_GPK2(0),
1354                         .ngpio  = S5PC100_GPIO_K2_NR,
1355                         .label  = "GPK2",
1356                 },
1357         }, {
1358                 .chip   = {
1359                         .base   = S5PC100_GPK3(0),
1360                         .ngpio  = S5PC100_GPIO_K3_NR,
1361                         .label  = "GPK3",
1362                 },
1363         }, {
1364                 .chip   = {
1365                         .base   = S5PC100_GPL0(0),
1366                         .ngpio  = S5PC100_GPIO_L0_NR,
1367                         .label  = "GPL0",
1368                 },
1369         }, {
1370                 .chip   = {
1371                         .base   = S5PC100_GPL1(0),
1372                         .ngpio  = S5PC100_GPIO_L1_NR,
1373                         .label  = "GPL1",
1374                 },
1375         }, {
1376                 .chip   = {
1377                         .base   = S5PC100_GPL2(0),
1378                         .ngpio  = S5PC100_GPIO_L2_NR,
1379                         .label  = "GPL2",
1380                 },
1381         }, {
1382                 .chip   = {
1383                         .base   = S5PC100_GPL3(0),
1384                         .ngpio  = S5PC100_GPIO_L3_NR,
1385                         .label  = "GPL3",
1386                 },
1387         }, {
1388                 .chip   = {
1389                         .base   = S5PC100_GPL4(0),
1390                         .ngpio  = S5PC100_GPIO_L4_NR,
1391                         .label  = "GPL4",
1392                 },
1393         }, {
1394                 .base   = (S5P_VA_GPIO + 0xC00),
1395                 .irq_base = IRQ_EINT(0),
1396                 .chip   = {
1397                         .base   = S5PC100_GPH0(0),
1398                         .ngpio  = S5PC100_GPIO_H0_NR,
1399                         .label  = "GPH0",
1400                         .to_irq = samsung_gpiolib_to_irq,
1401                 },
1402         }, {
1403                 .base   = (S5P_VA_GPIO + 0xC20),
1404                 .irq_base = IRQ_EINT(8),
1405                 .chip   = {
1406                         .base   = S5PC100_GPH1(0),
1407                         .ngpio  = S5PC100_GPIO_H1_NR,
1408                         .label  = "GPH1",
1409                         .to_irq = samsung_gpiolib_to_irq,
1410                 },
1411         }, {
1412                 .base   = (S5P_VA_GPIO + 0xC40),
1413                 .irq_base = IRQ_EINT(16),
1414                 .chip   = {
1415                         .base   = S5PC100_GPH2(0),
1416                         .ngpio  = S5PC100_GPIO_H2_NR,
1417                         .label  = "GPH2",
1418                         .to_irq = samsung_gpiolib_to_irq,
1419                 },
1420         }, {
1421                 .base   = (S5P_VA_GPIO + 0xC60),
1422                 .irq_base = IRQ_EINT(24),
1423                 .chip   = {
1424                         .base   = S5PC100_GPH3(0),
1425                         .ngpio  = S5PC100_GPIO_H3_NR,
1426                         .label  = "GPH3",
1427                         .to_irq = samsung_gpiolib_to_irq,
1428                 },
1429         },
1430 #endif
1431 };
1432
1433 /*
1434  * Followings are the gpio banks in S5PV210/S5PC110
1435  *
1436  * The 'config' member when left to NULL, is initialized to the default
1437  * structure samsung_gpio_cfgs[3] in the init function below.
1438  *
1439  * The 'base' member is also initialized in the init function below.
1440  * Note: The initialization of 'base' member of samsung_gpio_chip structure
1441  * uses the above macro and depends on the banks being listed in order here.
1442  */
1443
1444 static struct samsung_gpio_chip s5pv210_gpios_4bit[] = {
1445 #ifdef CONFIG_CPU_S5PV210
1446         {
1447                 .chip   = {
1448                         .base   = S5PV210_GPA0(0),
1449                         .ngpio  = S5PV210_GPIO_A0_NR,
1450                         .label  = "GPA0",
1451                 },
1452         }, {
1453                 .chip   = {
1454                         .base   = S5PV210_GPA1(0),
1455                         .ngpio  = S5PV210_GPIO_A1_NR,
1456                         .label  = "GPA1",
1457                 },
1458         }, {
1459                 .chip   = {
1460                         .base   = S5PV210_GPB(0),
1461                         .ngpio  = S5PV210_GPIO_B_NR,
1462                         .label  = "GPB",
1463                 },
1464         }, {
1465                 .chip   = {
1466                         .base   = S5PV210_GPC0(0),
1467                         .ngpio  = S5PV210_GPIO_C0_NR,
1468                         .label  = "GPC0",
1469                 },
1470         }, {
1471                 .chip   = {
1472                         .base   = S5PV210_GPC1(0),
1473                         .ngpio  = S5PV210_GPIO_C1_NR,
1474                         .label  = "GPC1",
1475                 },
1476         }, {
1477                 .chip   = {
1478                         .base   = S5PV210_GPD0(0),
1479                         .ngpio  = S5PV210_GPIO_D0_NR,
1480                         .label  = "GPD0",
1481                 },
1482         }, {
1483                 .chip   = {
1484                         .base   = S5PV210_GPD1(0),
1485                         .ngpio  = S5PV210_GPIO_D1_NR,
1486                         .label  = "GPD1",
1487                 },
1488         }, {
1489                 .chip   = {
1490                         .base   = S5PV210_GPE0(0),
1491                         .ngpio  = S5PV210_GPIO_E0_NR,
1492                         .label  = "GPE0",
1493                 },
1494         }, {
1495                 .chip   = {
1496                         .base   = S5PV210_GPE1(0),
1497                         .ngpio  = S5PV210_GPIO_E1_NR,
1498                         .label  = "GPE1",
1499                 },
1500         }, {
1501                 .chip   = {
1502                         .base   = S5PV210_GPF0(0),
1503                         .ngpio  = S5PV210_GPIO_F0_NR,
1504                         .label  = "GPF0",
1505                 },
1506         }, {
1507                 .chip   = {
1508                         .base   = S5PV210_GPF1(0),
1509                         .ngpio  = S5PV210_GPIO_F1_NR,
1510                         .label  = "GPF1",
1511                 },
1512         }, {
1513                 .chip   = {
1514                         .base   = S5PV210_GPF2(0),
1515                         .ngpio  = S5PV210_GPIO_F2_NR,
1516                         .label  = "GPF2",
1517                 },
1518         }, {
1519                 .chip   = {
1520                         .base   = S5PV210_GPF3(0),
1521                         .ngpio  = S5PV210_GPIO_F3_NR,
1522                         .label  = "GPF3",
1523                 },
1524         }, {
1525                 .chip   = {
1526                         .base   = S5PV210_GPG0(0),
1527                         .ngpio  = S5PV210_GPIO_G0_NR,
1528                         .label  = "GPG0",
1529                 },
1530         }, {
1531                 .chip   = {
1532                         .base   = S5PV210_GPG1(0),
1533                         .ngpio  = S5PV210_GPIO_G1_NR,
1534                         .label  = "GPG1",
1535                 },
1536         }, {
1537                 .chip   = {
1538                         .base   = S5PV210_GPG2(0),
1539                         .ngpio  = S5PV210_GPIO_G2_NR,
1540                         .label  = "GPG2",
1541                 },
1542         }, {
1543                 .chip   = {
1544                         .base   = S5PV210_GPG3(0),
1545                         .ngpio  = S5PV210_GPIO_G3_NR,
1546                         .label  = "GPG3",
1547                 },
1548         }, {
1549                 .chip   = {
1550                         .base   = S5PV210_GPI(0),
1551                         .ngpio  = S5PV210_GPIO_I_NR,
1552                         .label  = "GPI",
1553                 },
1554         }, {
1555                 .chip   = {
1556                         .base   = S5PV210_GPJ0(0),
1557                         .ngpio  = S5PV210_GPIO_J0_NR,
1558                         .label  = "GPJ0",
1559                 },
1560         }, {
1561                 .chip   = {
1562                         .base   = S5PV210_GPJ1(0),
1563                         .ngpio  = S5PV210_GPIO_J1_NR,
1564                         .label  = "GPJ1",
1565                 },
1566         }, {
1567                 .chip   = {
1568                         .base   = S5PV210_GPJ2(0),
1569                         .ngpio  = S5PV210_GPIO_J2_NR,
1570                         .label  = "GPJ2",
1571                 },
1572         }, {
1573                 .chip   = {
1574                         .base   = S5PV210_GPJ3(0),
1575                         .ngpio  = S5PV210_GPIO_J3_NR,
1576                         .label  = "GPJ3",
1577                 },
1578         }, {
1579                 .chip   = {
1580                         .base   = S5PV210_GPJ4(0),
1581                         .ngpio  = S5PV210_GPIO_J4_NR,
1582                         .label  = "GPJ4",
1583                 },
1584         }, {
1585                 .chip   = {
1586                         .base   = S5PV210_MP01(0),
1587                         .ngpio  = S5PV210_GPIO_MP01_NR,
1588                         .label  = "MP01",
1589                 },
1590         }, {
1591                 .chip   = {
1592                         .base   = S5PV210_MP02(0),
1593                         .ngpio  = S5PV210_GPIO_MP02_NR,
1594                         .label  = "MP02",
1595                 },
1596         }, {
1597                 .chip   = {
1598                         .base   = S5PV210_MP03(0),
1599                         .ngpio  = S5PV210_GPIO_MP03_NR,
1600                         .label  = "MP03",
1601                 },
1602         }, {
1603                 .chip   = {
1604                         .base   = S5PV210_MP04(0),
1605                         .ngpio  = S5PV210_GPIO_MP04_NR,
1606                         .label  = "MP04",
1607                 },
1608         }, {
1609                 .chip   = {
1610                         .base   = S5PV210_MP05(0),
1611                         .ngpio  = S5PV210_GPIO_MP05_NR,
1612                         .label  = "MP05",
1613                 },
1614         }, {
1615                 .base   = (S5P_VA_GPIO + 0xC00),
1616                 .irq_base = IRQ_EINT(0),
1617                 .chip   = {
1618                         .base   = S5PV210_GPH0(0),
1619                         .ngpio  = S5PV210_GPIO_H0_NR,
1620                         .label  = "GPH0",
1621                         .to_irq = samsung_gpiolib_to_irq,
1622                 },
1623         }, {
1624                 .base   = (S5P_VA_GPIO + 0xC20),
1625                 .irq_base = IRQ_EINT(8),
1626                 .chip   = {
1627                         .base   = S5PV210_GPH1(0),
1628                         .ngpio  = S5PV210_GPIO_H1_NR,
1629                         .label  = "GPH1",
1630                         .to_irq = samsung_gpiolib_to_irq,
1631                 },
1632         }, {
1633                 .base   = (S5P_VA_GPIO + 0xC40),
1634                 .irq_base = IRQ_EINT(16),
1635                 .chip   = {
1636                         .base   = S5PV210_GPH2(0),
1637                         .ngpio  = S5PV210_GPIO_H2_NR,
1638                         .label  = "GPH2",
1639                         .to_irq = samsung_gpiolib_to_irq,
1640                 },
1641         }, {
1642                 .base   = (S5P_VA_GPIO + 0xC60),
1643                 .irq_base = IRQ_EINT(24),
1644                 .chip   = {
1645                         .base   = S5PV210_GPH3(0),
1646                         .ngpio  = S5PV210_GPIO_H3_NR,
1647                         .label  = "GPH3",
1648                         .to_irq = samsung_gpiolib_to_irq,
1649                 },
1650         },
1651 #endif
1652 };
1653
1654 /* TODO: cleanup soc_is_* */
1655 static __init int samsung_gpiolib_init(void)
1656 {
1657         struct samsung_gpio_chip *chip;
1658         int i, nr_chips;
1659         int group = 0;
1660
1661         /*
1662          * Currently there are two drivers that can provide GPIO support for
1663          * Samsung SoCs. For device tree enabled platforms, the new
1664          * pinctrl-samsung driver is used, providing both GPIO and pin control
1665          * interfaces. For legacy (non-DT) platforms this driver is used.
1666          */
1667         if (of_have_populated_dt())
1668                 return -ENODEV;
1669
1670         samsung_gpiolib_set_cfg(samsung_gpio_cfgs, ARRAY_SIZE(samsung_gpio_cfgs));
1671
1672         if (soc_is_s3c24xx()) {
1673                 s3c24xx_gpiolib_add_chips(s3c24xx_gpios,
1674                                 ARRAY_SIZE(s3c24xx_gpios), S3C24XX_VA_GPIO);
1675         } else if (soc_is_s3c64xx()) {
1676                 samsung_gpiolib_add_2bit_chips(s3c64xx_gpios_2bit,
1677                                 ARRAY_SIZE(s3c64xx_gpios_2bit),
1678                                 S3C64XX_VA_GPIO + 0xE0, 0x20);
1679                 samsung_gpiolib_add_4bit_chips(s3c64xx_gpios_4bit,
1680                                 ARRAY_SIZE(s3c64xx_gpios_4bit),
1681                                 S3C64XX_VA_GPIO);
1682                 samsung_gpiolib_add_4bit2_chips(s3c64xx_gpios_4bit2,
1683                                 ARRAY_SIZE(s3c64xx_gpios_4bit2));
1684         } else if (soc_is_s5pc100()) {
1685                 group = 0;
1686                 chip = s5pc100_gpios_4bit;
1687                 nr_chips = ARRAY_SIZE(s5pc100_gpios_4bit);
1688
1689                 for (i = 0; i < nr_chips; i++, chip++) {
1690                         if (!chip->config) {
1691                                 chip->config = &samsung_gpio_cfgs[3];
1692                                 chip->group = group++;
1693                         }
1694                 }
1695                 samsung_gpiolib_add_4bit_chips(s5pc100_gpios_4bit, nr_chips, S5P_VA_GPIO);
1696 #if defined(CONFIG_CPU_S5PC100) && defined(CONFIG_S5P_GPIO_INT)
1697                 s5p_register_gpioint_bank(IRQ_GPIOINT, 0, S5P_GPIOINT_GROUP_MAXNR);
1698 #endif
1699         } else if (soc_is_s5pv210()) {
1700                 group = 0;
1701                 chip = s5pv210_gpios_4bit;
1702                 nr_chips = ARRAY_SIZE(s5pv210_gpios_4bit);
1703
1704                 for (i = 0; i < nr_chips; i++, chip++) {
1705                         if (!chip->config) {
1706                                 chip->config = &samsung_gpio_cfgs[3];
1707                                 chip->group = group++;
1708                         }
1709                 }
1710                 samsung_gpiolib_add_4bit_chips(s5pv210_gpios_4bit, nr_chips, S5P_VA_GPIO);
1711 #if defined(CONFIG_CPU_S5PV210) && defined(CONFIG_S5P_GPIO_INT)
1712                 s5p_register_gpioint_bank(IRQ_GPIOINT, 0, S5P_GPIOINT_GROUP_MAXNR);
1713 #endif
1714         } else {
1715                 WARN(1, "Unknown SoC in gpio-samsung, no GPIOs added\n");
1716                 return -ENODEV;
1717         }
1718
1719         return 0;
1720 }
1721 core_initcall(samsung_gpiolib_init);
1722
1723 int s3c_gpio_cfgpin(unsigned int pin, unsigned int config)
1724 {
1725         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1726         unsigned long flags;
1727         int offset;
1728         int ret;
1729
1730         if (!chip)
1731                 return -EINVAL;
1732
1733         offset = pin - chip->chip.base;
1734
1735         samsung_gpio_lock(chip, flags);
1736         ret = samsung_gpio_do_setcfg(chip, offset, config);
1737         samsung_gpio_unlock(chip, flags);
1738
1739         return ret;
1740 }
1741 EXPORT_SYMBOL(s3c_gpio_cfgpin);
1742
1743 int s3c_gpio_cfgpin_range(unsigned int start, unsigned int nr,
1744                           unsigned int cfg)
1745 {
1746         int ret;
1747
1748         for (; nr > 0; nr--, start++) {
1749                 ret = s3c_gpio_cfgpin(start, cfg);
1750                 if (ret != 0)
1751                         return ret;
1752         }
1753
1754         return 0;
1755 }
1756 EXPORT_SYMBOL_GPL(s3c_gpio_cfgpin_range);
1757
1758 int s3c_gpio_cfgall_range(unsigned int start, unsigned int nr,
1759                           unsigned int cfg, samsung_gpio_pull_t pull)
1760 {
1761         int ret;
1762
1763         for (; nr > 0; nr--, start++) {
1764                 s3c_gpio_setpull(start, pull);
1765                 ret = s3c_gpio_cfgpin(start, cfg);
1766                 if (ret != 0)
1767                         return ret;
1768         }
1769
1770         return 0;
1771 }
1772 EXPORT_SYMBOL_GPL(s3c_gpio_cfgall_range);
1773
1774 unsigned s3c_gpio_getcfg(unsigned int pin)
1775 {
1776         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1777         unsigned long flags;
1778         unsigned ret = 0;
1779         int offset;
1780
1781         if (chip) {
1782                 offset = pin - chip->chip.base;
1783
1784                 samsung_gpio_lock(chip, flags);
1785                 ret = samsung_gpio_do_getcfg(chip, offset);
1786                 samsung_gpio_unlock(chip, flags);
1787         }
1788
1789         return ret;
1790 }
1791 EXPORT_SYMBOL(s3c_gpio_getcfg);
1792
1793 int s3c_gpio_setpull(unsigned int pin, samsung_gpio_pull_t pull)
1794 {
1795         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1796         unsigned long flags;
1797         int offset, ret;
1798
1799         if (!chip)
1800                 return -EINVAL;
1801
1802         offset = pin - chip->chip.base;
1803
1804         samsung_gpio_lock(chip, flags);
1805         ret = samsung_gpio_do_setpull(chip, offset, pull);
1806         samsung_gpio_unlock(chip, flags);
1807
1808         return ret;
1809 }
1810 EXPORT_SYMBOL(s3c_gpio_setpull);
1811
1812 samsung_gpio_pull_t s3c_gpio_getpull(unsigned int pin)
1813 {
1814         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1815         unsigned long flags;
1816         int offset;
1817         u32 pup = 0;
1818
1819         if (chip) {
1820                 offset = pin - chip->chip.base;
1821
1822                 samsung_gpio_lock(chip, flags);
1823                 pup = samsung_gpio_do_getpull(chip, offset);
1824                 samsung_gpio_unlock(chip, flags);
1825         }
1826
1827         return (__force samsung_gpio_pull_t)pup;
1828 }
1829 EXPORT_SYMBOL(s3c_gpio_getpull);
1830
1831 #ifdef CONFIG_S5P_GPIO_DRVSTR
1832 s5p_gpio_drvstr_t s5p_gpio_get_drvstr(unsigned int pin)
1833 {
1834         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1835         unsigned int off;
1836         void __iomem *reg;
1837         int shift;
1838         u32 drvstr;
1839
1840         if (!chip)
1841                 return -EINVAL;
1842
1843         off = pin - chip->chip.base;
1844         shift = off * 2;
1845         reg = chip->base + 0x0C;
1846
1847         drvstr = __raw_readl(reg);
1848         drvstr = drvstr >> shift;
1849         drvstr &= 0x3;
1850
1851         return (__force s5p_gpio_drvstr_t)drvstr;
1852 }
1853 EXPORT_SYMBOL(s5p_gpio_get_drvstr);
1854
1855 int s5p_gpio_set_drvstr(unsigned int pin, s5p_gpio_drvstr_t drvstr)
1856 {
1857         struct samsung_gpio_chip *chip = samsung_gpiolib_getchip(pin);
1858         unsigned int off;
1859         void __iomem *reg;
1860         int shift;
1861         u32 tmp;
1862
1863         if (!chip)
1864                 return -EINVAL;
1865
1866         off = pin - chip->chip.base;
1867         shift = off * 2;
1868         reg = chip->base + 0x0C;
1869
1870         tmp = __raw_readl(reg);
1871         tmp &= ~(0x3 << shift);
1872         tmp |= drvstr << shift;
1873
1874         __raw_writel(tmp, reg);
1875
1876         return 0;
1877 }
1878 EXPORT_SYMBOL(s5p_gpio_set_drvstr);
1879 #endif  /* CONFIG_S5P_GPIO_DRVSTR */
1880
1881 #ifdef CONFIG_PLAT_S3C24XX
1882 unsigned int s3c2410_modify_misccr(unsigned int clear, unsigned int change)
1883 {
1884         unsigned long flags;
1885         unsigned long misccr;
1886
1887         local_irq_save(flags);
1888         misccr = __raw_readl(S3C24XX_MISCCR);
1889         misccr &= ~clear;
1890         misccr ^= change;
1891         __raw_writel(misccr, S3C24XX_MISCCR);
1892         local_irq_restore(flags);
1893
1894         return misccr;
1895 }
1896 EXPORT_SYMBOL(s3c2410_modify_misccr);
1897 #endif