MAINTAINERS: firewire git URL update
[pandora-kernel.git] / kernel / irq / generic-chip.c
1 /*
2  * Library implementing the most common irq chip callback functions
3  *
4  * Copyright (C) 2011, Thomas Gleixner
5  */
6 #include <linux/io.h>
7 #include <linux/irq.h>
8 #include <linux/slab.h>
9 #include <linux/interrupt.h>
10 #include <linux/kernel_stat.h>
11 #include <linux/syscore_ops.h>
12
13 #include "internals.h"
14
15 static LIST_HEAD(gc_list);
16 static DEFINE_RAW_SPINLOCK(gc_lock);
17
18 static inline struct irq_chip_regs *cur_regs(struct irq_data *d)
19 {
20         return &container_of(d->chip, struct irq_chip_type, chip)->regs;
21 }
22
23 /**
24  * irq_gc_noop - NOOP function
25  * @d: irq_data
26  */
27 void irq_gc_noop(struct irq_data *d)
28 {
29 }
30
31 /**
32  * irq_gc_mask_disable_reg - Mask chip via disable register
33  * @d: irq_data
34  *
35  * Chip has separate enable/disable registers instead of a single mask
36  * register.
37  */
38 void irq_gc_mask_disable_reg(struct irq_data *d)
39 {
40         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
41         u32 mask = 1 << (d->irq - gc->irq_base);
42
43         irq_gc_lock(gc);
44         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->disable);
45         gc->mask_cache &= ~mask;
46         irq_gc_unlock(gc);
47 }
48
49 /**
50  * irq_gc_mask_set_mask_bit - Mask chip via setting bit in mask register
51  * @d: irq_data
52  *
53  * Chip has a single mask register. Values of this register are cached
54  * and protected by gc->lock
55  */
56 void irq_gc_mask_set_bit(struct irq_data *d)
57 {
58         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
59         u32 mask = 1 << (d->irq - gc->irq_base);
60
61         irq_gc_lock(gc);
62         gc->mask_cache |= mask;
63         irq_reg_writel(gc->mask_cache, gc->reg_base + cur_regs(d)->mask);
64         irq_gc_unlock(gc);
65 }
66
67 /**
68  * irq_gc_mask_set_mask_bit - Mask chip via clearing bit in mask register
69  * @d: irq_data
70  *
71  * Chip has a single mask register. Values of this register are cached
72  * and protected by gc->lock
73  */
74 void irq_gc_mask_clr_bit(struct irq_data *d)
75 {
76         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
77         u32 mask = 1 << (d->irq - gc->irq_base);
78
79         irq_gc_lock(gc);
80         gc->mask_cache &= ~mask;
81         irq_reg_writel(gc->mask_cache, gc->reg_base + cur_regs(d)->mask);
82         irq_gc_unlock(gc);
83 }
84
85 /**
86  * irq_gc_unmask_enable_reg - Unmask chip via enable register
87  * @d: irq_data
88  *
89  * Chip has separate enable/disable registers instead of a single mask
90  * register.
91  */
92 void irq_gc_unmask_enable_reg(struct irq_data *d)
93 {
94         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
95         u32 mask = 1 << (d->irq - gc->irq_base);
96
97         irq_gc_lock(gc);
98         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->enable);
99         gc->mask_cache |= mask;
100         irq_gc_unlock(gc);
101 }
102
103 /**
104  * irq_gc_ack_set_bit - Ack pending interrupt via setting bit
105  * @d: irq_data
106  */
107 void irq_gc_ack_set_bit(struct irq_data *d)
108 {
109         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
110         u32 mask = 1 << (d->irq - gc->irq_base);
111
112         irq_gc_lock(gc);
113         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->ack);
114         irq_gc_unlock(gc);
115 }
116
117 /**
118  * irq_gc_ack_clr_bit - Ack pending interrupt via clearing bit
119  * @d: irq_data
120  */
121 void irq_gc_ack_clr_bit(struct irq_data *d)
122 {
123         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
124         u32 mask = ~(1 << (d->irq - gc->irq_base));
125
126         irq_gc_lock(gc);
127         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->ack);
128         irq_gc_unlock(gc);
129 }
130
131 /**
132  * irq_gc_mask_disable_reg_and_ack- Mask and ack pending interrupt
133  * @d: irq_data
134  */
135 void irq_gc_mask_disable_reg_and_ack(struct irq_data *d)
136 {
137         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
138         u32 mask = 1 << (d->irq - gc->irq_base);
139
140         irq_gc_lock(gc);
141         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->mask);
142         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->ack);
143         irq_gc_unlock(gc);
144 }
145
146 /**
147  * irq_gc_eoi - EOI interrupt
148  * @d: irq_data
149  */
150 void irq_gc_eoi(struct irq_data *d)
151 {
152         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
153         u32 mask = 1 << (d->irq - gc->irq_base);
154
155         irq_gc_lock(gc);
156         irq_reg_writel(mask, gc->reg_base + cur_regs(d)->eoi);
157         irq_gc_unlock(gc);
158 }
159
160 /**
161  * irq_gc_set_wake - Set/clr wake bit for an interrupt
162  * @d: irq_data
163  *
164  * For chips where the wake from suspend functionality is not
165  * configured in a separate register and the wakeup active state is
166  * just stored in a bitmask.
167  */
168 int irq_gc_set_wake(struct irq_data *d, unsigned int on)
169 {
170         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
171         u32 mask = 1 << (d->irq - gc->irq_base);
172
173         if (!(mask & gc->wake_enabled))
174                 return -EINVAL;
175
176         irq_gc_lock(gc);
177         if (on)
178                 gc->wake_active |= mask;
179         else
180                 gc->wake_active &= ~mask;
181         irq_gc_unlock(gc);
182         return 0;
183 }
184
185 /**
186  * irq_alloc_generic_chip - Allocate a generic chip and initialize it
187  * @name:       Name of the irq chip
188  * @num_ct:     Number of irq_chip_type instances associated with this
189  * @irq_base:   Interrupt base nr for this chip
190  * @reg_base:   Register base address (virtual)
191  * @handler:    Default flow handler associated with this chip
192  *
193  * Returns an initialized irq_chip_generic structure. The chip defaults
194  * to the primary (index 0) irq_chip_type and @handler
195  */
196 struct irq_chip_generic *
197 irq_alloc_generic_chip(const char *name, int num_ct, unsigned int irq_base,
198                        void __iomem *reg_base, irq_flow_handler_t handler)
199 {
200         struct irq_chip_generic *gc;
201         unsigned long sz = sizeof(*gc) + num_ct * sizeof(struct irq_chip_type);
202
203         gc = kzalloc(sz, GFP_KERNEL);
204         if (gc) {
205                 raw_spin_lock_init(&gc->lock);
206                 gc->num_ct = num_ct;
207                 gc->irq_base = irq_base;
208                 gc->reg_base = reg_base;
209                 gc->chip_types->chip.name = name;
210                 gc->chip_types->handler = handler;
211         }
212         return gc;
213 }
214
215 /*
216  * Separate lockdep class for interrupt chip which can nest irq_desc
217  * lock.
218  */
219 static struct lock_class_key irq_nested_lock_class;
220
221 /**
222  * irq_setup_generic_chip - Setup a range of interrupts with a generic chip
223  * @gc:         Generic irq chip holding all data
224  * @msk:        Bitmask holding the irqs to initialize relative to gc->irq_base
225  * @flags:      Flags for initialization
226  * @clr:        IRQ_* bits to clear
227  * @set:        IRQ_* bits to set
228  *
229  * Set up max. 32 interrupts starting from gc->irq_base. Note, this
230  * initializes all interrupts to the primary irq_chip_type and its
231  * associated handler.
232  */
233 void irq_setup_generic_chip(struct irq_chip_generic *gc, u32 msk,
234                             enum irq_gc_flags flags, unsigned int clr,
235                             unsigned int set)
236 {
237         struct irq_chip_type *ct = gc->chip_types;
238         unsigned int i;
239
240         raw_spin_lock(&gc_lock);
241         list_add_tail(&gc->list, &gc_list);
242         raw_spin_unlock(&gc_lock);
243
244         /* Init mask cache ? */
245         if (flags & IRQ_GC_INIT_MASK_CACHE)
246                 gc->mask_cache = irq_reg_readl(gc->reg_base + ct->regs.mask);
247
248         for (i = gc->irq_base; msk; msk >>= 1, i++) {
249                 if (!(msk & 0x01))
250                         continue;
251
252                 if (flags & IRQ_GC_INIT_NESTED_LOCK)
253                         irq_set_lockdep_class(i, &irq_nested_lock_class);
254
255                 irq_set_chip_and_handler(i, &ct->chip, ct->handler);
256                 irq_set_chip_data(i, gc);
257                 irq_modify_status(i, clr, set);
258         }
259         gc->irq_cnt = i - gc->irq_base;
260 }
261
262 /**
263  * irq_setup_alt_chip - Switch to alternative chip
264  * @d:          irq_data for this interrupt
265  * @type        Flow type to be initialized
266  *
267  * Only to be called from chip->irq_set_type() callbacks.
268  */
269 int irq_setup_alt_chip(struct irq_data *d, unsigned int type)
270 {
271         struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
272         struct irq_chip_type *ct = gc->chip_types;
273         unsigned int i;
274
275         for (i = 0; i < gc->num_ct; i++, ct++) {
276                 if (ct->type & type) {
277                         d->chip = &ct->chip;
278                         irq_data_to_desc(d)->handle_irq = ct->handler;
279                         return 0;
280                 }
281         }
282         return -EINVAL;
283 }
284
285 /**
286  * irq_remove_generic_chip - Remove a chip
287  * @gc:         Generic irq chip holding all data
288  * @msk:        Bitmask holding the irqs to initialize relative to gc->irq_base
289  * @clr:        IRQ_* bits to clear
290  * @set:        IRQ_* bits to set
291  *
292  * Remove up to 32 interrupts starting from gc->irq_base.
293  */
294 void irq_remove_generic_chip(struct irq_chip_generic *gc, u32 msk,
295                              unsigned int clr, unsigned int set)
296 {
297         unsigned int i = gc->irq_base;
298
299         raw_spin_lock(&gc_lock);
300         list_del(&gc->list);
301         raw_spin_unlock(&gc_lock);
302
303         for (; msk; msk >>= 1, i++) {
304                 if (!(msk & 0x01))
305                         continue;
306
307                 /* Remove handler first. That will mask the irq line */
308                 irq_set_handler(i, NULL);
309                 irq_set_chip(i, &no_irq_chip);
310                 irq_set_chip_data(i, NULL);
311                 irq_modify_status(i, clr, set);
312         }
313 }
314
315 #ifdef CONFIG_PM
316 static int irq_gc_suspend(void)
317 {
318         struct irq_chip_generic *gc;
319
320         list_for_each_entry(gc, &gc_list, list) {
321                 struct irq_chip_type *ct = gc->chip_types;
322
323                 if (ct->chip.irq_suspend)
324                         ct->chip.irq_suspend(irq_get_irq_data(gc->irq_base));
325         }
326         return 0;
327 }
328
329 static void irq_gc_resume(void)
330 {
331         struct irq_chip_generic *gc;
332
333         list_for_each_entry(gc, &gc_list, list) {
334                 struct irq_chip_type *ct = gc->chip_types;
335
336                 if (ct->chip.irq_resume)
337                         ct->chip.irq_resume(irq_get_irq_data(gc->irq_base));
338         }
339 }
340 #else
341 #define irq_gc_suspend NULL
342 #define irq_gc_resume NULL
343 #endif
344
345 static void irq_gc_shutdown(void)
346 {
347         struct irq_chip_generic *gc;
348
349         list_for_each_entry(gc, &gc_list, list) {
350                 struct irq_chip_type *ct = gc->chip_types;
351
352                 if (ct->chip.irq_pm_shutdown)
353                         ct->chip.irq_pm_shutdown(irq_get_irq_data(gc->irq_base));
354         }
355 }
356
357 static struct syscore_ops irq_gc_syscore_ops = {
358         .suspend = irq_gc_suspend,
359         .resume = irq_gc_resume,
360         .shutdown = irq_gc_shutdown,
361 };
362
363 static int __init irq_gc_init_ops(void)
364 {
365         register_syscore_ops(&irq_gc_syscore_ops);
366         return 0;
367 }
368 device_initcall(irq_gc_init_ops);