aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/gpio
diff options
context:
space:
mode:
authorSascha Hauer <s.hauer@pengutronix.de>2011-07-07 04:00:49 -0400
committerSascha Hauer <s.hauer@pengutronix.de>2011-07-07 04:00:49 -0400
commite59a7943f2f72a1dc218447f4f285c8b67b3a98e (patch)
tree278b164568087fd6c92bb31572238ecf9ab4674f /drivers/gpio
parentfad107086d5a869c1c07e5bb35b7b57a10ecf578 (diff)
parent2ce420da39078a6135d1c004a0e4436fdc1458b4 (diff)
Merge remote-tracking branch 'grant/gpio/next-mx' into devel-features
Conflicts: arch/arm/mach-imx/mach-mx31_3ds.c arch/arm/mach-imx/mach-scb9328.c Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
Diffstat (limited to 'drivers/gpio')
-rw-r--r--drivers/gpio/Kconfig9
-rw-r--r--drivers/gpio/Makefile2
-rw-r--r--drivers/gpio/gpio-mxc.c379
-rw-r--r--drivers/gpio/gpio-mxs.c370
4 files changed, 760 insertions, 0 deletions
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 2967002a9f82..5e6fc222bb23 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -90,6 +90,15 @@ config GPIO_EXYNOS4
90 def_bool y 90 def_bool y
91 depends on CPU_EXYNOS4210 91 depends on CPU_EXYNOS4210
92 92
93config GPIO_MXS
94 def_bool y
95 depends on ARCH_MXS
96
97config GPIO_MXC
98 def_bool y
99 depends on ARCH_MXC
100 select GPIO_BASIC_MMIO_CORE
101
93config GPIO_PLAT_SAMSUNG 102config GPIO_PLAT_SAMSUNG
94 def_bool y 103 def_bool y
95 depends on SAMSUNG_GPIOLIB_4BIT 104 depends on SAMSUNG_GPIOLIB_4BIT
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index b605f8ec6fbe..9c37339a57a7 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -9,6 +9,8 @@ obj-$(CONFIG_GPIO_ADP5588) += adp5588-gpio.o
9obj-$(CONFIG_GPIO_BASIC_MMIO_CORE) += basic_mmio_gpio.o 9obj-$(CONFIG_GPIO_BASIC_MMIO_CORE) += basic_mmio_gpio.o
10obj-$(CONFIG_GPIO_BASIC_MMIO) += basic_mmio_gpio.o 10obj-$(CONFIG_GPIO_BASIC_MMIO) += basic_mmio_gpio.o
11obj-$(CONFIG_GPIO_EXYNOS4) += gpio-exynos4.o 11obj-$(CONFIG_GPIO_EXYNOS4) += gpio-exynos4.o
12obj-$(CONFIG_GPIO_MXC) += gpio-mxc.o
13obj-$(CONFIG_GPIO_MXS) += gpio-mxs.o
12obj-$(CONFIG_GPIO_PLAT_SAMSUNG) += gpio-plat-samsung.o 14obj-$(CONFIG_GPIO_PLAT_SAMSUNG) += gpio-plat-samsung.o
13obj-$(CONFIG_GPIO_S5PC100) += gpio-s5pc100.o 15obj-$(CONFIG_GPIO_S5PC100) += gpio-s5pc100.o
14obj-$(CONFIG_GPIO_S5PV210) += gpio-s5pv210.o 16obj-$(CONFIG_GPIO_S5PV210) += gpio-s5pv210.o
diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c
new file mode 100644
index 000000000000..b351952893bb
--- /dev/null
+++ b/drivers/gpio/gpio-mxc.c
@@ -0,0 +1,379 @@
1/*
2 * MXC GPIO support. (c) 2008 Daniel Mack <daniel@caiaq.de>
3 * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
4 *
5 * Based on code from Freescale,
6 * Copyright (C) 2004-2010 Freescale Semiconductor, Inc. All Rights Reserved.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 */
21
22#include <linux/init.h>
23#include <linux/interrupt.h>
24#include <linux/io.h>
25#include <linux/irq.h>
26#include <linux/gpio.h>
27#include <linux/platform_device.h>
28#include <linux/slab.h>
29#include <linux/basic_mmio_gpio.h>
30#include <mach/hardware.h>
31#include <asm-generic/bug.h>
32
33struct mxc_gpio_port {
34 struct list_head node;
35 void __iomem *base;
36 int irq;
37 int irq_high;
38 int virtual_irq_start;
39 struct bgpio_chip bgc;
40 u32 both_edges;
41};
42
43/*
44 * MX2 has one interrupt *for all* gpio ports. The list is used
45 * to save the references to all ports, so that mx2_gpio_irq_handler
46 * can walk through all interrupt status registers.
47 */
48static LIST_HEAD(mxc_gpio_ports);
49
50#define cpu_is_mx1_mx2() (cpu_is_mx1() || cpu_is_mx2())
51
52#define GPIO_DR (cpu_is_mx1_mx2() ? 0x1c : 0x00)
53#define GPIO_GDIR (cpu_is_mx1_mx2() ? 0x00 : 0x04)
54#define GPIO_PSR (cpu_is_mx1_mx2() ? 0x24 : 0x08)
55#define GPIO_ICR1 (cpu_is_mx1_mx2() ? 0x28 : 0x0C)
56#define GPIO_ICR2 (cpu_is_mx1_mx2() ? 0x2C : 0x10)
57#define GPIO_IMR (cpu_is_mx1_mx2() ? 0x30 : 0x14)
58#define GPIO_ISR (cpu_is_mx1_mx2() ? 0x34 : 0x18)
59
60#define GPIO_INT_LOW_LEV (cpu_is_mx1_mx2() ? 0x3 : 0x0)
61#define GPIO_INT_HIGH_LEV (cpu_is_mx1_mx2() ? 0x2 : 0x1)
62#define GPIO_INT_RISE_EDGE (cpu_is_mx1_mx2() ? 0x0 : 0x2)
63#define GPIO_INT_FALL_EDGE (cpu_is_mx1_mx2() ? 0x1 : 0x3)
64#define GPIO_INT_NONE 0x4
65
66/* Note: This driver assumes 32 GPIOs are handled in one register */
67
68static void _clear_gpio_irqstatus(struct mxc_gpio_port *port, u32 index)
69{
70 writel(1 << index, port->base + GPIO_ISR);
71}
72
73static void _set_gpio_irqenable(struct mxc_gpio_port *port, u32 index,
74 int enable)
75{
76 u32 l;
77
78 l = readl(port->base + GPIO_IMR);
79 l = (l & (~(1 << index))) | (!!enable << index);
80 writel(l, port->base + GPIO_IMR);
81}
82
83static void gpio_ack_irq(struct irq_data *d)
84{
85 struct mxc_gpio_port *port = irq_data_get_irq_chip_data(d);
86 u32 gpio = irq_to_gpio(d->irq);
87 _clear_gpio_irqstatus(port, gpio & 0x1f);
88}
89
90static void gpio_mask_irq(struct irq_data *d)
91{
92 struct mxc_gpio_port *port = irq_data_get_irq_chip_data(d);
93 u32 gpio = irq_to_gpio(d->irq);
94 _set_gpio_irqenable(port, gpio & 0x1f, 0);
95}
96
97static void gpio_unmask_irq(struct irq_data *d)
98{
99 struct mxc_gpio_port *port = irq_data_get_irq_chip_data(d);
100 u32 gpio = irq_to_gpio(d->irq);
101 _set_gpio_irqenable(port, gpio & 0x1f, 1);
102}
103
104static int gpio_set_irq_type(struct irq_data *d, u32 type)
105{
106 u32 gpio = irq_to_gpio(d->irq);
107 struct mxc_gpio_port *port = irq_data_get_irq_chip_data(d);
108 u32 bit, val;
109 int edge;
110 void __iomem *reg = port->base;
111
112 port->both_edges &= ~(1 << (gpio & 31));
113 switch (type) {
114 case IRQ_TYPE_EDGE_RISING:
115 edge = GPIO_INT_RISE_EDGE;
116 break;
117 case IRQ_TYPE_EDGE_FALLING:
118 edge = GPIO_INT_FALL_EDGE;
119 break;
120 case IRQ_TYPE_EDGE_BOTH:
121 val = gpio_get_value(gpio & 31);
122 if (val) {
123 edge = GPIO_INT_LOW_LEV;
124 pr_debug("mxc: set GPIO %d to low trigger\n", gpio);
125 } else {
126 edge = GPIO_INT_HIGH_LEV;
127 pr_debug("mxc: set GPIO %d to high trigger\n", gpio);
128 }
129 port->both_edges |= 1 << (gpio & 31);
130 break;
131 case IRQ_TYPE_LEVEL_LOW:
132 edge = GPIO_INT_LOW_LEV;
133 break;
134 case IRQ_TYPE_LEVEL_HIGH:
135 edge = GPIO_INT_HIGH_LEV;
136 break;
137 default:
138 return -EINVAL;
139 }
140
141 reg += GPIO_ICR1 + ((gpio & 0x10) >> 2); /* lower or upper register */
142 bit = gpio & 0xf;
143 val = readl(reg) & ~(0x3 << (bit << 1));
144 writel(val | (edge << (bit << 1)), reg);
145 _clear_gpio_irqstatus(port, gpio & 0x1f);
146
147 return 0;
148}
149
150static void mxc_flip_edge(struct mxc_gpio_port *port, u32 gpio)
151{
152 void __iomem *reg = port->base;
153 u32 bit, val;
154 int edge;
155
156 reg += GPIO_ICR1 + ((gpio & 0x10) >> 2); /* lower or upper register */
157 bit = gpio & 0xf;
158 val = readl(reg);
159 edge = (val >> (bit << 1)) & 3;
160 val &= ~(0x3 << (bit << 1));
161 if (edge == GPIO_INT_HIGH_LEV) {
162 edge = GPIO_INT_LOW_LEV;
163 pr_debug("mxc: switch GPIO %d to low trigger\n", gpio);
164 } else if (edge == GPIO_INT_LOW_LEV) {
165 edge = GPIO_INT_HIGH_LEV;
166 pr_debug("mxc: switch GPIO %d to high trigger\n", gpio);
167 } else {
168 pr_err("mxc: invalid configuration for GPIO %d: %x\n",
169 gpio, edge);
170 return;
171 }
172 writel(val | (edge << (bit << 1)), reg);
173}
174
175/* handle 32 interrupts in one status register */
176static void mxc_gpio_irq_handler(struct mxc_gpio_port *port, u32 irq_stat)
177{
178 u32 gpio_irq_no_base = port->virtual_irq_start;
179
180 while (irq_stat != 0) {
181 int irqoffset = fls(irq_stat) - 1;
182
183 if (port->both_edges & (1 << irqoffset))
184 mxc_flip_edge(port, irqoffset);
185
186 generic_handle_irq(gpio_irq_no_base + irqoffset);
187
188 irq_stat &= ~(1 << irqoffset);
189 }
190}
191
192/* MX1 and MX3 has one interrupt *per* gpio port */
193static void mx3_gpio_irq_handler(u32 irq, struct irq_desc *desc)
194{
195 u32 irq_stat;
196 struct mxc_gpio_port *port = irq_get_handler_data(irq);
197
198 irq_stat = readl(port->base + GPIO_ISR) & readl(port->base + GPIO_IMR);
199
200 mxc_gpio_irq_handler(port, irq_stat);
201}
202
203/* MX2 has one interrupt *for all* gpio ports */
204static void mx2_gpio_irq_handler(u32 irq, struct irq_desc *desc)
205{
206 u32 irq_msk, irq_stat;
207 struct mxc_gpio_port *port;
208
209 /* walk through all interrupt status registers */
210 list_for_each_entry(port, &mxc_gpio_ports, node) {
211 irq_msk = readl(port->base + GPIO_IMR);
212 if (!irq_msk)
213 continue;
214
215 irq_stat = readl(port->base + GPIO_ISR) & irq_msk;
216 if (irq_stat)
217 mxc_gpio_irq_handler(port, irq_stat);
218 }
219}
220
221/*
222 * Set interrupt number "irq" in the GPIO as a wake-up source.
223 * While system is running, all registered GPIO interrupts need to have
224 * wake-up enabled. When system is suspended, only selected GPIO interrupts
225 * need to have wake-up enabled.
226 * @param irq interrupt source number
227 * @param enable enable as wake-up if equal to non-zero
228 * @return This function returns 0 on success.
229 */
230static int gpio_set_wake_irq(struct irq_data *d, u32 enable)
231{
232 u32 gpio = irq_to_gpio(d->irq);
233 u32 gpio_idx = gpio & 0x1F;
234 struct mxc_gpio_port *port = irq_data_get_irq_chip_data(d);
235
236 if (enable) {
237 if (port->irq_high && (gpio_idx >= 16))
238 enable_irq_wake(port->irq_high);
239 else
240 enable_irq_wake(port->irq);
241 } else {
242 if (port->irq_high && (gpio_idx >= 16))
243 disable_irq_wake(port->irq_high);
244 else
245 disable_irq_wake(port->irq);
246 }
247
248 return 0;
249}
250
251static struct irq_chip gpio_irq_chip = {
252 .name = "GPIO",
253 .irq_ack = gpio_ack_irq,
254 .irq_mask = gpio_mask_irq,
255 .irq_unmask = gpio_unmask_irq,
256 .irq_set_type = gpio_set_irq_type,
257 .irq_set_wake = gpio_set_wake_irq,
258};
259
260/*
261 * This lock class tells lockdep that GPIO irqs are in a different
262 * category than their parents, so it won't report false recursion.
263 */
264static struct lock_class_key gpio_lock_class;
265
266static int __devinit mxc_gpio_probe(struct platform_device *pdev)
267{
268 struct mxc_gpio_port *port;
269 struct resource *iores;
270 int err, i;
271
272 port = kzalloc(sizeof(struct mxc_gpio_port), GFP_KERNEL);
273 if (!port)
274 return -ENOMEM;
275
276 port->virtual_irq_start = MXC_GPIO_IRQ_START + pdev->id * 32;
277
278 iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
279 if (!iores) {
280 err = -ENODEV;
281 goto out_kfree;
282 }
283
284 if (!request_mem_region(iores->start, resource_size(iores),
285 pdev->name)) {
286 err = -EBUSY;
287 goto out_kfree;
288 }
289
290 port->base = ioremap(iores->start, resource_size(iores));
291 if (!port->base) {
292 err = -ENOMEM;
293 goto out_release_mem;
294 }
295
296 port->irq_high = platform_get_irq(pdev, 1);
297 port->irq = platform_get_irq(pdev, 0);
298 if (port->irq < 0) {
299 err = -EINVAL;
300 goto out_iounmap;
301 }
302
303 /* disable the interrupt and clear the status */
304 writel(0, port->base + GPIO_IMR);
305 writel(~0, port->base + GPIO_ISR);
306
307 for (i = port->virtual_irq_start;
308 i < port->virtual_irq_start + 32; i++) {
309 irq_set_lockdep_class(i, &gpio_lock_class);
310 irq_set_chip_and_handler(i, &gpio_irq_chip, handle_level_irq);
311 set_irq_flags(i, IRQF_VALID);
312 irq_set_chip_data(i, port);
313 }
314
315 if (cpu_is_mx2()) {
316 /* setup one handler for all GPIO interrupts */
317 if (pdev->id == 0)
318 irq_set_chained_handler(port->irq,
319 mx2_gpio_irq_handler);
320 } else {
321 /* setup one handler for each entry */
322 irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
323 irq_set_handler_data(port->irq, port);
324 if (port->irq_high > 0) {
325 /* setup handler for GPIO 16 to 31 */
326 irq_set_chained_handler(port->irq_high,
327 mx3_gpio_irq_handler);
328 irq_set_handler_data(port->irq_high, port);
329 }
330 }
331
332 err = bgpio_init(&port->bgc, &pdev->dev, 4,
333 port->base + GPIO_PSR,
334 port->base + GPIO_DR, NULL,
335 port->base + GPIO_GDIR, NULL, false);
336 if (err)
337 goto out_iounmap;
338
339 port->bgc.gc.base = pdev->id * 32;
340
341 err = gpiochip_add(&port->bgc.gc);
342 if (err)
343 goto out_bgpio_remove;
344
345 list_add_tail(&port->node, &mxc_gpio_ports);
346
347 return 0;
348
349out_bgpio_remove:
350 bgpio_remove(&port->bgc);
351out_iounmap:
352 iounmap(port->base);
353out_release_mem:
354 release_mem_region(iores->start, resource_size(iores));
355out_kfree:
356 kfree(port);
357 dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
358 return err;
359}
360
361static struct platform_driver mxc_gpio_driver = {
362 .driver = {
363 .name = "gpio-mxc",
364 .owner = THIS_MODULE,
365 },
366 .probe = mxc_gpio_probe,
367};
368
369static int __init gpio_mxc_init(void)
370{
371 return platform_driver_register(&mxc_gpio_driver);
372}
373postcore_initcall(gpio_mxc_init);
374
375MODULE_AUTHOR("Freescale Semiconductor, "
376 "Daniel Mack <danielncaiaq.de>, "
377 "Juergen Beisert <kernel@pengutronix.de>");
378MODULE_DESCRIPTION("Freescale MXC GPIO");
379MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/gpio-mxs.c b/drivers/gpio/gpio-mxs.c
new file mode 100644
index 000000000000..a28761428bb0
--- /dev/null
+++ b/drivers/gpio/gpio-mxs.c
@@ -0,0 +1,370 @@
1/*
2 * MXC GPIO support. (c) 2008 Daniel Mack <daniel@caiaq.de>
3 * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
4 *
5 * Based on code from Freescale,
6 * Copyright (C) 2004-2010 Freescale Semiconductor, Inc. All Rights Reserved.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
20 * MA 02110-1301, USA.
21 */
22
23#include <linux/init.h>
24#include <linux/interrupt.h>
25#include <linux/io.h>
26#include <linux/irq.h>
27#include <linux/gpio.h>
28#include <linux/platform_device.h>
29#include <linux/slab.h>
30#include <mach/mxs.h>
31
32#define MXS_SET 0x4
33#define MXS_CLR 0x8
34
35#define PINCTRL_DOUT(n) ((cpu_is_mx23() ? 0x0500 : 0x0700) + (n) * 0x10)
36#define PINCTRL_DIN(n) ((cpu_is_mx23() ? 0x0600 : 0x0900) + (n) * 0x10)
37#define PINCTRL_DOE(n) ((cpu_is_mx23() ? 0x0700 : 0x0b00) + (n) * 0x10)
38#define PINCTRL_PIN2IRQ(n) ((cpu_is_mx23() ? 0x0800 : 0x1000) + (n) * 0x10)
39#define PINCTRL_IRQEN(n) ((cpu_is_mx23() ? 0x0900 : 0x1100) + (n) * 0x10)
40#define PINCTRL_IRQLEV(n) ((cpu_is_mx23() ? 0x0a00 : 0x1200) + (n) * 0x10)
41#define PINCTRL_IRQPOL(n) ((cpu_is_mx23() ? 0x0b00 : 0x1300) + (n) * 0x10)
42#define PINCTRL_IRQSTAT(n) ((cpu_is_mx23() ? 0x0c00 : 0x1400) + (n) * 0x10)
43
44#define GPIO_INT_FALL_EDGE 0x0
45#define GPIO_INT_LOW_LEV 0x1
46#define GPIO_INT_RISE_EDGE 0x2
47#define GPIO_INT_HIGH_LEV 0x3
48#define GPIO_INT_LEV_MASK (1 << 0)
49#define GPIO_INT_POL_MASK (1 << 1)
50
51struct mxs_gpio_port {
52 void __iomem *base;
53 int id;
54 int irq;
55 int irq_high;
56 int virtual_irq_start;
57 struct gpio_chip chip;
58};
59
60/* Note: This driver assumes 32 GPIOs are handled in one register */
61
62static void clear_gpio_irqstatus(struct mxs_gpio_port *port, u32 index)
63{
64 writel(1 << index, port->base + PINCTRL_IRQSTAT(port->id) + MXS_CLR);
65}
66
67static void set_gpio_irqenable(struct mxs_gpio_port *port, u32 index,
68 int enable)
69{
70 if (enable) {
71 writel(1 << index,
72 port->base + PINCTRL_IRQEN(port->id) + MXS_SET);
73 writel(1 << index,
74 port->base + PINCTRL_PIN2IRQ(port->id) + MXS_SET);
75 } else {
76 writel(1 << index,
77 port->base + PINCTRL_IRQEN(port->id) + MXS_CLR);
78 }
79}
80
81static void mxs_gpio_ack_irq(struct irq_data *d)
82{
83 struct mxs_gpio_port *port = irq_data_get_irq_chip_data(d);
84 u32 gpio = irq_to_gpio(d->irq);
85 clear_gpio_irqstatus(port, gpio & 0x1f);
86}
87
88static void mxs_gpio_mask_irq(struct irq_data *d)
89{
90 struct mxs_gpio_port *port = irq_data_get_irq_chip_data(d);
91 u32 gpio = irq_to_gpio(d->irq);
92 set_gpio_irqenable(port, gpio & 0x1f, 0);
93}
94
95static void mxs_gpio_unmask_irq(struct irq_data *d)
96{
97 struct mxs_gpio_port *port = irq_data_get_irq_chip_data(d);
98 u32 gpio = irq_to_gpio(d->irq);
99 set_gpio_irqenable(port, gpio & 0x1f, 1);
100}
101
102static int mxs_gpio_get(struct gpio_chip *chip, unsigned offset);
103
104static int mxs_gpio_set_irq_type(struct irq_data *d, unsigned int type)
105{
106 u32 gpio = irq_to_gpio(d->irq);
107 u32 pin_mask = 1 << (gpio & 31);
108 struct mxs_gpio_port *port = irq_data_get_irq_chip_data(d);
109 void __iomem *pin_addr;
110 int edge;
111
112 switch (type) {
113 case IRQ_TYPE_EDGE_RISING:
114 edge = GPIO_INT_RISE_EDGE;
115 break;
116 case IRQ_TYPE_EDGE_FALLING:
117 edge = GPIO_INT_FALL_EDGE;
118 break;
119 case IRQ_TYPE_LEVEL_LOW:
120 edge = GPIO_INT_LOW_LEV;
121 break;
122 case IRQ_TYPE_LEVEL_HIGH:
123 edge = GPIO_INT_HIGH_LEV;
124 break;
125 default:
126 return -EINVAL;
127 }
128
129 /* set level or edge */
130 pin_addr = port->base + PINCTRL_IRQLEV(port->id);
131 if (edge & GPIO_INT_LEV_MASK)
132 writel(pin_mask, pin_addr + MXS_SET);
133 else
134 writel(pin_mask, pin_addr + MXS_CLR);
135
136 /* set polarity */
137 pin_addr = port->base + PINCTRL_IRQPOL(port->id);
138 if (edge & GPIO_INT_POL_MASK)
139 writel(pin_mask, pin_addr + MXS_SET);
140 else
141 writel(pin_mask, pin_addr + MXS_CLR);
142
143 clear_gpio_irqstatus(port, gpio & 0x1f);
144
145 return 0;
146}
147
148/* MXS has one interrupt *per* gpio port */
149static void mxs_gpio_irq_handler(u32 irq, struct irq_desc *desc)
150{
151 u32 irq_stat;
152 struct mxs_gpio_port *port = irq_get_handler_data(irq);
153 u32 gpio_irq_no_base = port->virtual_irq_start;
154
155 desc->irq_data.chip->irq_ack(&desc->irq_data);
156
157 irq_stat = readl(port->base + PINCTRL_IRQSTAT(port->id)) &
158 readl(port->base + PINCTRL_IRQEN(port->id));
159
160 while (irq_stat != 0) {
161 int irqoffset = fls(irq_stat) - 1;
162 generic_handle_irq(gpio_irq_no_base + irqoffset);
163 irq_stat &= ~(1 << irqoffset);
164 }
165}
166
167/*
168 * Set interrupt number "irq" in the GPIO as a wake-up source.
169 * While system is running, all registered GPIO interrupts need to have
170 * wake-up enabled. When system is suspended, only selected GPIO interrupts
171 * need to have wake-up enabled.
172 * @param irq interrupt source number
173 * @param enable enable as wake-up if equal to non-zero
174 * @return This function returns 0 on success.
175 */
176static int mxs_gpio_set_wake_irq(struct irq_data *d, unsigned int enable)
177{
178 u32 gpio = irq_to_gpio(d->irq);
179 u32 gpio_idx = gpio & 0x1f;
180 struct mxs_gpio_port *port = irq_data_get_irq_chip_data(d);
181
182 if (enable) {
183 if (port->irq_high && (gpio_idx >= 16))
184 enable_irq_wake(port->irq_high);
185 else
186 enable_irq_wake(port->irq);
187 } else {
188 if (port->irq_high && (gpio_idx >= 16))
189 disable_irq_wake(port->irq_high);
190 else
191 disable_irq_wake(port->irq);
192 }
193
194 return 0;
195}
196
197static struct irq_chip gpio_irq_chip = {
198 .name = "mxs gpio",
199 .irq_ack = mxs_gpio_ack_irq,
200 .irq_mask = mxs_gpio_mask_irq,
201 .irq_unmask = mxs_gpio_unmask_irq,
202 .irq_set_type = mxs_gpio_set_irq_type,
203 .irq_set_wake = mxs_gpio_set_wake_irq,
204};
205
206static void mxs_set_gpio_direction(struct gpio_chip *chip, unsigned offset,
207 int dir)
208{
209 struct mxs_gpio_port *port =
210 container_of(chip, struct mxs_gpio_port, chip);
211 void __iomem *pin_addr = port->base + PINCTRL_DOE(port->id);
212
213 if (dir)
214 writel(1 << offset, pin_addr + MXS_SET);
215 else
216 writel(1 << offset, pin_addr + MXS_CLR);
217}
218
219static int mxs_gpio_get(struct gpio_chip *chip, unsigned offset)
220{
221 struct mxs_gpio_port *port =
222 container_of(chip, struct mxs_gpio_port, chip);
223
224 return (readl(port->base + PINCTRL_DIN(port->id)) >> offset) & 1;
225}
226
227static void mxs_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
228{
229 struct mxs_gpio_port *port =
230 container_of(chip, struct mxs_gpio_port, chip);
231 void __iomem *pin_addr = port->base + PINCTRL_DOUT(port->id);
232
233 if (value)
234 writel(1 << offset, pin_addr + MXS_SET);
235 else
236 writel(1 << offset, pin_addr + MXS_CLR);
237}
238
239static int mxs_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
240{
241 struct mxs_gpio_port *port =
242 container_of(chip, struct mxs_gpio_port, chip);
243
244 return port->virtual_irq_start + offset;
245}
246
247static int mxs_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
248{
249 mxs_set_gpio_direction(chip, offset, 0);
250 return 0;
251}
252
253static int mxs_gpio_direction_output(struct gpio_chip *chip,
254 unsigned offset, int value)
255{
256 mxs_gpio_set(chip, offset, value);
257 mxs_set_gpio_direction(chip, offset, 1);
258 return 0;
259}
260
261static int __devinit mxs_gpio_probe(struct platform_device *pdev)
262{
263 static void __iomem *base;
264 struct mxs_gpio_port *port;
265 struct resource *iores = NULL;
266 int err, i;
267
268 port = kzalloc(sizeof(struct mxs_gpio_port), GFP_KERNEL);
269 if (!port)
270 return -ENOMEM;
271
272 port->id = pdev->id;
273 port->virtual_irq_start = MXS_GPIO_IRQ_START + port->id * 32;
274
275 /*
276 * map memory region only once, as all the gpio ports
277 * share the same one
278 */
279 if (!base) {
280 iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
281 if (!iores) {
282 err = -ENODEV;
283 goto out_kfree;
284 }
285
286 if (!request_mem_region(iores->start, resource_size(iores),
287 pdev->name)) {
288 err = -EBUSY;
289 goto out_kfree;
290 }
291
292 base = ioremap(iores->start, resource_size(iores));
293 if (!base) {
294 err = -ENOMEM;
295 goto out_release_mem;
296 }
297 }
298 port->base = base;
299
300 port->irq = platform_get_irq(pdev, 0);
301 if (port->irq < 0) {
302 err = -EINVAL;
303 goto out_iounmap;
304 }
305
306 /* disable the interrupt and clear the status */
307 writel(0, port->base + PINCTRL_PIN2IRQ(port->id));
308 writel(0, port->base + PINCTRL_IRQEN(port->id));
309
310 /* clear address has to be used to clear IRQSTAT bits */
311 writel(~0U, port->base + PINCTRL_IRQSTAT(port->id) + MXS_CLR);
312
313 for (i = port->virtual_irq_start;
314 i < port->virtual_irq_start + 32; i++) {
315 irq_set_chip_and_handler(i, &gpio_irq_chip,
316 handle_level_irq);
317 set_irq_flags(i, IRQF_VALID);
318 irq_set_chip_data(i, port);
319 }
320
321 /* setup one handler for each entry */
322 irq_set_chained_handler(port->irq, mxs_gpio_irq_handler);
323 irq_set_handler_data(port->irq, port);
324
325 /* register gpio chip */
326 port->chip.direction_input = mxs_gpio_direction_input;
327 port->chip.direction_output = mxs_gpio_direction_output;
328 port->chip.get = mxs_gpio_get;
329 port->chip.set = mxs_gpio_set;
330 port->chip.to_irq = mxs_gpio_to_irq;
331 port->chip.base = port->id * 32;
332 port->chip.ngpio = 32;
333
334 err = gpiochip_add(&port->chip);
335 if (err)
336 goto out_iounmap;
337
338 return 0;
339
340out_iounmap:
341 if (iores)
342 iounmap(port->base);
343out_release_mem:
344 if (iores)
345 release_mem_region(iores->start, resource_size(iores));
346out_kfree:
347 kfree(port);
348 dev_info(&pdev->dev, "%s failed with errno %d\n", __func__, err);
349 return err;
350}
351
352static struct platform_driver mxs_gpio_driver = {
353 .driver = {
354 .name = "gpio-mxs",
355 .owner = THIS_MODULE,
356 },
357 .probe = mxs_gpio_probe,
358};
359
360static int __init mxs_gpio_init(void)
361{
362 return platform_driver_register(&mxs_gpio_driver);
363}
364postcore_initcall(mxs_gpio_init);
365
366MODULE_AUTHOR("Freescale Semiconductor, "
367 "Daniel Mack <danielncaiaq.de>, "
368 "Juergen Beisert <kernel@pengutronix.de>");
369MODULE_DESCRIPTION("Freescale MXS GPIO");
370MODULE_LICENSE("GPL");