v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / arch / arm / mach-sa1100 / irq.c
1 /*
2  * linux/arch/arm/mach-sa1100/irq.c
3  *
4  * Copyright (C) 1999-2001 Nicolas Pitre
5  *
6  * Generic IRQ handling for the SA11x0, GPIO 11-27 IRQ demultiplexing.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <linux/config.h>
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/sched.h>
17 #include <linux/interrupt.h>
18 #include <linux/ptrace.h>
19
20 #include <asm/hardware.h>
21 #include <asm/irq.h>
22 #include <asm/mach/irq.h>
23 #include <asm/arch/irq.h>
24
25 #include "generic.h"
26
27
28 /*
29  * SA1100 GPIO edge detection for IRQs:
30  * IRQs are generated on Falling-Edge, Rising-Edge, or both.
31  * This must be called *before* the appropriate IRQ is registered.
32  * Use this instead of directly setting GRER/GFER.
33  */
34
35 static int GPIO_IRQ_rising_edge;
36 static int GPIO_IRQ_falling_edge;
37
38 void set_GPIO_IRQ_edge( int gpio_mask, int edge )
39 {
40         if (edge & GPIO_FALLING_EDGE)
41                 GPIO_IRQ_falling_edge |= gpio_mask;
42         else
43                 GPIO_IRQ_falling_edge &= ~gpio_mask;
44         if (edge & GPIO_RISING_EDGE)
45                 GPIO_IRQ_rising_edge |= gpio_mask;
46         else
47                 GPIO_IRQ_rising_edge &= ~gpio_mask;
48 }
49
50 EXPORT_SYMBOL(set_GPIO_IRQ_edge);
51
52
53 /*
54  * We don't need to ACK IRQs on the SA1100 unless they're GPIOs
55  * this is for internal IRQs i.e. from 11 to 31.
56  */
57
58 static void sa1100_mask_irq(unsigned int irq)
59 {
60         ICMR &= ~(1 << irq);
61 }
62
63 static void sa1100_unmask_irq(unsigned int irq)
64 {
65         ICMR |= (1 << irq);
66 }
67
68 /*
69  * GPIO IRQs must be acknoledged.  This is for IRQs from 0 to 10.
70  */
71
72 static void sa1100_mask_and_ack_GPIO0_10_irq(unsigned int irq)
73 {
74         ICMR &= ~(1 << irq);
75         GEDR = (1 << irq);
76 }
77
78 static void sa1100_mask_GPIO0_10_irq(unsigned int irq)
79 {
80         ICMR &= ~(1 << irq);
81 }
82
83 static void sa1100_unmask_GPIO0_10_irq(unsigned int irq)
84 {
85         GRER = (GRER & ~(1 << irq)) | (GPIO_IRQ_rising_edge & (1 << irq));
86         GFER = (GFER & ~(1 << irq)) | (GPIO_IRQ_falling_edge & (1 << irq));
87         ICMR |= (1 << irq);
88 }
89
90 /*
91  * Install handler for GPIO 11-27 edge detect interrupts
92  */
93
94 static int GPIO_11_27_enabled;          /* enabled i.e. unmasked GPIO IRQs */
95 static int GPIO_11_27_spurious;         /* GPIOs that triggered when masked */
96
97 static void sa1100_GPIO11_27_demux(int irq, void *dev_id,
98                                    struct pt_regs *regs)
99 {
100         int i, spurious;
101
102         while ((irq = (GEDR & 0xfffff800))) {
103                 /*
104                  * We don't want to clear GRER/GFER when the corresponding
105                  * IRQ is masked because we could miss a level transition
106                  * i.e. an IRQ which need servicing as soon as it is
107                  * unmasked.  However, such situation should happen only
108                  * during the loop below.  Thus all IRQs which aren't
109                  * enabled at this point are considered spurious.  Those
110                  * are cleared but only de-activated if they happen twice.
111                  */
112                 spurious = irq & ~GPIO_11_27_enabled;
113                 if (spurious) {
114                         GEDR = spurious;
115                         GRER &= ~(spurious & GPIO_11_27_spurious);
116                         GFER &= ~(spurious & GPIO_11_27_spurious);
117                         GPIO_11_27_spurious |= spurious;
118                         irq ^= spurious;
119                         if (!irq) continue;
120                 }
121
122                 for (i = 11; i <= 27; ++i) {
123                         if (irq & (1<<i)) {
124                                 do_IRQ (IRQ_GPIO_11_27(i), regs);
125                         }
126                 }
127         }
128 }
129
130 static struct irqaction GPIO11_27_irq = {
131         name:           "GPIO 11-27",
132         handler:        sa1100_GPIO11_27_demux,
133         flags:          SA_INTERRUPT
134 };
135
136 static void sa1100_mask_and_ack_GPIO11_27_irq(unsigned int irq)
137 {
138         int mask = (1 << GPIO_11_27_IRQ(irq));
139         GPIO_11_27_spurious &= ~mask;
140         GPIO_11_27_enabled &= ~mask;
141         GEDR = mask;
142 }
143
144 static void sa1100_mask_GPIO11_27_irq(unsigned int irq)
145 {
146         int mask = (1 << GPIO_11_27_IRQ(irq));
147         GPIO_11_27_spurious &= ~mask;
148         GPIO_11_27_enabled &= ~mask;
149 }
150
151 static void sa1100_unmask_GPIO11_27_irq(unsigned int irq)
152 {
153         int mask = (1 << GPIO_11_27_IRQ(irq));
154         if (GPIO_11_27_spurious & mask) {
155                 /*
156                  * We don't want to miss an interrupt that would have occurred
157                  * while it was masked.  Simulate it if it is the case.
158                  */
159                 int state = GPLR;
160                 if (((state & GPIO_IRQ_rising_edge) |
161                      (~state & GPIO_IRQ_falling_edge)) & mask)
162                 {
163                         /* just in case it gets referenced: */
164                         struct pt_regs dummy;
165
166                         memzero(&dummy, sizeof(dummy));
167                         do_IRQ(irq, &dummy);
168
169                         /* we are being called recursively from do_IRQ() */
170                         return;
171                 }
172         }
173         GPIO_11_27_enabled |= mask;
174         GRER = (GRER & ~mask) | (GPIO_IRQ_rising_edge & mask);
175         GFER = (GFER & ~mask) | (GPIO_IRQ_falling_edge & mask);
176 }
177
178
179 void __init sa1100_init_irq(void)
180 {
181         int irq;
182
183         /* disable all IRQs */
184         ICMR = 0;
185
186         /* all IRQs are IRQ, not FIQ */
187         ICLR = 0;
188
189         /* clear all GPIO edge detects */
190         GFER = 0;
191         GRER = 0;
192         GEDR = -1;
193
194         /*
195          * Whatever the doc says, this has to be set for the wait-on-irq
196          * instruction to work... on a SA1100 rev 9 at least.
197          */
198         ICCR = 1;
199
200         for (irq = 0; irq <= 10; irq++) {
201                 irq_desc[irq].valid     = 1;
202                 irq_desc[irq].probe_ok  = 1;
203                 irq_desc[irq].mask_ack  = sa1100_mask_and_ack_GPIO0_10_irq;
204                 irq_desc[irq].mask      = sa1100_mask_GPIO0_10_irq;
205                 irq_desc[irq].unmask    = sa1100_unmask_GPIO0_10_irq;
206         }
207
208         for (irq = 11; irq <= 31; irq++) {
209                 irq_desc[irq].valid     = 1;
210                 irq_desc[irq].probe_ok  = 0;
211                 irq_desc[irq].mask_ack  = sa1100_mask_irq;
212                 irq_desc[irq].mask      = sa1100_mask_irq;
213                 irq_desc[irq].unmask    = sa1100_unmask_irq;
214         }
215
216         for (irq = 32; irq <= 48; irq++) {
217                 irq_desc[irq].valid     = 1;
218                 irq_desc[irq].probe_ok  = 1;
219                 irq_desc[irq].mask_ack  = sa1100_mask_and_ack_GPIO11_27_irq;
220                 irq_desc[irq].mask      = sa1100_mask_GPIO11_27_irq;
221                 irq_desc[irq].unmask    = sa1100_unmask_GPIO11_27_irq;
222         }
223         setup_arm_irq( IRQ_GPIO11_27, &GPIO11_27_irq );
224
225         /*
226          * We generally don't want the LCD IRQ being
227          * enabled as soon as we request it.
228          */
229         irq_desc[IRQ_LCD].noautoenable = 1;
230 }