config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / mfd / twl6040-irq.c
1 /*
2  * Interrupt controller support for TWL6040
3  *
4  * Author:     Misael Lopez Cruz <misael.lopez@ti.com>
5  *
6  * Copyright:   (C) 2011 Texas Instruments, Inc.
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  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * 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 St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/irq.h>
27 #include <linux/interrupt.h>
28 #include <linux/mfd/core.h>
29 #include <linux/mfd/twl6040.h>
30
31 struct twl6040_irq_data {
32         int mask;
33         int status;
34 };
35
36 static struct twl6040_irq_data twl6040_irqs[] = {
37         {
38                 .mask = TWL6040_THMSK,
39                 .status = TWL6040_THINT,
40         },
41         {
42                 .mask = TWL6040_PLUGMSK,
43                 .status = TWL6040_PLUGINT | TWL6040_UNPLUGINT,
44         },
45         {
46                 .mask = TWL6040_HOOKMSK,
47                 .status = TWL6040_HOOKINT,
48         },
49         {
50                 .mask = TWL6040_HFMSK,
51                 .status = TWL6040_HFINT,
52         },
53         {
54                 .mask = TWL6040_VIBMSK,
55                 .status = TWL6040_VIBINT,
56         },
57         {
58                 .mask = TWL6040_READYMSK,
59                 .status = TWL6040_READYINT,
60         },
61 };
62
63 static inline
64 struct twl6040_irq_data *irq_to_twl6040_irq(struct twl6040 *twl6040,
65                                             int irq)
66 {
67         return &twl6040_irqs[irq - twl6040->irq_base];
68 }
69
70 static void twl6040_irq_lock(struct irq_data *data)
71 {
72         struct twl6040 *twl6040 = irq_data_get_irq_chip_data(data);
73
74         mutex_lock(&twl6040->irq_mutex);
75 }
76
77 static void twl6040_irq_sync_unlock(struct irq_data *data)
78 {
79         struct twl6040 *twl6040 = irq_data_get_irq_chip_data(data);
80
81         /* write back to hardware any change in irq mask */
82         if (twl6040->irq_masks_cur != twl6040->irq_masks_cache) {
83                 twl6040->irq_masks_cache = twl6040->irq_masks_cur;
84                 twl6040_reg_write(twl6040, TWL6040_REG_INTMR,
85                                   twl6040->irq_masks_cur);
86         }
87
88         mutex_unlock(&twl6040->irq_mutex);
89 }
90
91 static void twl6040_irq_enable(struct irq_data *data)
92 {
93         struct twl6040 *twl6040 = irq_data_get_irq_chip_data(data);
94         struct twl6040_irq_data *irq_data = irq_to_twl6040_irq(twl6040,
95                                                                data->irq);
96
97         twl6040->irq_masks_cur &= ~irq_data->mask;
98 }
99
100 static void twl6040_irq_disable(struct irq_data *data)
101 {
102         struct twl6040 *twl6040 = irq_data_get_irq_chip_data(data);
103         struct twl6040_irq_data *irq_data = irq_to_twl6040_irq(twl6040,
104                                                                data->irq);
105
106         twl6040->irq_masks_cur |= irq_data->mask;
107 }
108
109 static struct irq_chip twl6040_irq_chip = {
110         .name                   = "twl6040",
111         .irq_bus_lock           = twl6040_irq_lock,
112         .irq_bus_sync_unlock    = twl6040_irq_sync_unlock,
113         .irq_enable             = twl6040_irq_enable,
114         .irq_disable            = twl6040_irq_disable,
115 };
116
117 static irqreturn_t twl6040_irq_thread(int irq, void *data)
118 {
119         struct twl6040 *twl6040 = data;
120         u8 intid;
121         int i;
122
123         intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
124
125         /* apply masking and report (backwards to handle READYINT first) */
126         for (i = ARRAY_SIZE(twl6040_irqs) - 1; i >= 0; i--) {
127                 if (twl6040->irq_masks_cur & twl6040_irqs[i].mask)
128                         intid &= ~twl6040_irqs[i].status;
129                 if (intid & twl6040_irqs[i].status)
130                         handle_nested_irq(twl6040->irq_base + i);
131         }
132
133         /* ack unmasked irqs */
134         twl6040_reg_write(twl6040, TWL6040_REG_INTID, intid);
135
136         return IRQ_HANDLED;
137 }
138
139 int twl6040_irq_init(struct twl6040 *twl6040)
140 {
141         int cur_irq, ret;
142         u8 val;
143
144         mutex_init(&twl6040->irq_mutex);
145
146         /* mask the individual interrupt sources */
147         twl6040->irq_masks_cur = TWL6040_ALLINT_MSK;
148         twl6040->irq_masks_cache = TWL6040_ALLINT_MSK;
149         twl6040_reg_write(twl6040, TWL6040_REG_INTMR, TWL6040_ALLINT_MSK);
150
151         /* Register them with genirq */
152         for (cur_irq = twl6040->irq_base;
153              cur_irq < twl6040->irq_base + ARRAY_SIZE(twl6040_irqs);
154              cur_irq++) {
155                 irq_set_chip_data(cur_irq, twl6040);
156                 irq_set_chip_and_handler(cur_irq, &twl6040_irq_chip,
157                                          handle_level_irq);
158                 irq_set_nested_thread(cur_irq, 1);
159
160                 /* ARM needs us to explicitly flag the IRQ as valid
161                  * and will set them noprobe when we do so. */
162 #ifdef CONFIG_ARM
163                 set_irq_flags(cur_irq, IRQF_VALID);
164 #else
165                 irq_set_noprobe(cur_irq);
166 #endif
167         }
168
169         ret = request_threaded_irq(twl6040->irq, NULL, twl6040_irq_thread,
170                                    IRQF_ONESHOT, "twl6040", twl6040);
171         if (ret) {
172                 dev_err(twl6040->dev, "failed to request IRQ %d: %d\n",
173                         twl6040->irq, ret);
174                 return ret;
175         }
176
177         /* reset interrupts */
178         val = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
179
180         /* interrupts cleared on write */
181         twl6040_clear_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_INTCLRMODE);
182
183         return 0;
184 }
185 EXPORT_SYMBOL(twl6040_irq_init);
186
187 void twl6040_irq_exit(struct twl6040 *twl6040)
188 {
189         free_irq(twl6040->irq, twl6040);
190 }
191 EXPORT_SYMBOL(twl6040_irq_exit);