]>
Commit | Line | Data |
---|---|---|
1f629b7a HS |
1 | /* |
2 | * S3C24XX IRQ handling | |
a21765a7 | 3 | * |
e02f8664 | 4 | * Copyright (c) 2003-2004 Simtec Electronics |
a21765a7 | 5 | * Ben Dooks <ben@simtec.co.uk> |
1f629b7a | 6 | * Copyright (c) 2012 Heiko Stuebner <heiko@sntech.de> |
a21765a7 BD |
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 as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
a21765a7 BD |
17 | */ |
18 | ||
19 | #include <linux/init.h> | |
1f629b7a | 20 | #include <linux/slab.h> |
a21765a7 | 21 | #include <linux/module.h> |
1f629b7a HS |
22 | #include <linux/io.h> |
23 | #include <linux/err.h> | |
a21765a7 BD |
24 | #include <linux/interrupt.h> |
25 | #include <linux/ioport.h> | |
edbaa603 | 26 | #include <linux/device.h> |
1f629b7a | 27 | #include <linux/irqdomain.h> |
a21765a7 | 28 | |
a21765a7 BD |
29 | #include <asm/mach/irq.h> |
30 | ||
1f629b7a HS |
31 | #include <mach/regs-irq.h> |
32 | #include <mach/regs-gpio.h> | |
a21765a7 | 33 | |
a2b7ba9c | 34 | #include <plat/cpu.h> |
1f629b7a | 35 | #include <plat/regs-irqtype.h> |
a2b7ba9c | 36 | #include <plat/pm.h> |
a21765a7 | 37 | |
1f629b7a HS |
38 | #define S3C_IRQTYPE_NONE 0 |
39 | #define S3C_IRQTYPE_EINT 1 | |
40 | #define S3C_IRQTYPE_EDGE 2 | |
41 | #define S3C_IRQTYPE_LEVEL 3 | |
a21765a7 | 42 | |
1f629b7a HS |
43 | struct s3c_irq_data { |
44 | unsigned int type; | |
45 | unsigned long parent_irq; | |
a21765a7 | 46 | |
1f629b7a HS |
47 | /* data gets filled during init */ |
48 | struct s3c_irq_intc *intc; | |
49 | unsigned long sub_bits; | |
50 | struct s3c_irq_intc *sub_intc; | |
a21765a7 BD |
51 | }; |
52 | ||
1f629b7a HS |
53 | /* |
54 | * Sructure holding the controller data | |
55 | * @reg_pending register holding pending irqs | |
56 | * @reg_intpnd special register intpnd in main intc | |
57 | * @reg_mask mask register | |
58 | * @domain irq_domain of the controller | |
59 | * @parent parent controller for ext and sub irqs | |
60 | * @irqs irq-data, always s3c_irq_data[32] | |
61 | */ | |
62 | struct s3c_irq_intc { | |
63 | void __iomem *reg_pending; | |
64 | void __iomem *reg_intpnd; | |
65 | void __iomem *reg_mask; | |
66 | struct irq_domain *domain; | |
67 | struct s3c_irq_intc *parent; | |
68 | struct s3c_irq_data *irqs; | |
a21765a7 BD |
69 | }; |
70 | ||
1f629b7a | 71 | static void s3c_irq_mask(struct irq_data *data) |
a21765a7 | 72 | { |
1f629b7a HS |
73 | struct s3c_irq_intc *intc = data->domain->host_data; |
74 | struct s3c_irq_intc *parent_intc = intc->parent; | |
75 | struct s3c_irq_data *irq_data = &intc->irqs[data->hwirq]; | |
76 | struct s3c_irq_data *parent_data; | |
a21765a7 | 77 | unsigned long mask; |
1f629b7a HS |
78 | unsigned int irqno; |
79 | ||
80 | mask = __raw_readl(intc->reg_mask); | |
81 | mask |= (1UL << data->hwirq); | |
82 | __raw_writel(mask, intc->reg_mask); | |
83 | ||
84 | if (parent_intc && irq_data->parent_irq) { | |
85 | parent_data = &parent_intc->irqs[irq_data->parent_irq]; | |
a21765a7 | 86 | |
1f629b7a HS |
87 | /* check to see if we need to mask the parent IRQ */ |
88 | if ((mask & parent_data->sub_bits) == parent_data->sub_bits) { | |
89 | irqno = irq_find_mapping(parent_intc->domain, | |
90 | irq_data->parent_irq); | |
91 | s3c_irq_mask(irq_get_irq_data(irqno)); | |
92 | } | |
93 | } | |
a21765a7 BD |
94 | } |
95 | ||
1f629b7a | 96 | static void s3c_irq_unmask(struct irq_data *data) |
a21765a7 | 97 | { |
1f629b7a HS |
98 | struct s3c_irq_intc *intc = data->domain->host_data; |
99 | struct s3c_irq_intc *parent_intc = intc->parent; | |
100 | struct s3c_irq_data *irq_data = &intc->irqs[data->hwirq]; | |
a21765a7 | 101 | unsigned long mask; |
1f629b7a | 102 | unsigned int irqno; |
a21765a7 | 103 | |
1f629b7a HS |
104 | mask = __raw_readl(intc->reg_mask); |
105 | mask &= ~(1UL << data->hwirq); | |
106 | __raw_writel(mask, intc->reg_mask); | |
a21765a7 | 107 | |
1f629b7a HS |
108 | if (parent_intc && irq_data->parent_irq) { |
109 | irqno = irq_find_mapping(parent_intc->domain, | |
110 | irq_data->parent_irq); | |
111 | s3c_irq_unmask(irq_get_irq_data(irqno)); | |
a21765a7 BD |
112 | } |
113 | } | |
114 | ||
1f629b7a | 115 | static inline void s3c_irq_ack(struct irq_data *data) |
a21765a7 | 116 | { |
1f629b7a HS |
117 | struct s3c_irq_intc *intc = data->domain->host_data; |
118 | unsigned long bitval = 1UL << data->hwirq; | |
a21765a7 | 119 | |
1f629b7a HS |
120 | __raw_writel(bitval, intc->reg_pending); |
121 | if (intc->reg_intpnd) | |
122 | __raw_writel(bitval, intc->reg_intpnd); | |
a21765a7 BD |
123 | } |
124 | ||
1f629b7a HS |
125 | static int s3c_irqext_type_set(void __iomem *gpcon_reg, |
126 | void __iomem *extint_reg, | |
127 | unsigned long gpcon_offset, | |
128 | unsigned long extint_offset, | |
129 | unsigned int type) | |
a21765a7 | 130 | { |
a21765a7 BD |
131 | unsigned long newvalue = 0, value; |
132 | ||
a21765a7 BD |
133 | /* Set the GPIO to external interrupt mode */ |
134 | value = __raw_readl(gpcon_reg); | |
135 | value = (value & ~(3 << gpcon_offset)) | (0x02 << gpcon_offset); | |
136 | __raw_writel(value, gpcon_reg); | |
137 | ||
138 | /* Set the external interrupt to pointed trigger type */ | |
139 | switch (type) | |
140 | { | |
6cab4860 | 141 | case IRQ_TYPE_NONE: |
1f629b7a | 142 | pr_warn("No edge setting!\n"); |
a21765a7 BD |
143 | break; |
144 | ||
6cab4860 | 145 | case IRQ_TYPE_EDGE_RISING: |
a21765a7 BD |
146 | newvalue = S3C2410_EXTINT_RISEEDGE; |
147 | break; | |
148 | ||
6cab4860 | 149 | case IRQ_TYPE_EDGE_FALLING: |
a21765a7 BD |
150 | newvalue = S3C2410_EXTINT_FALLEDGE; |
151 | break; | |
152 | ||
6cab4860 | 153 | case IRQ_TYPE_EDGE_BOTH: |
a21765a7 BD |
154 | newvalue = S3C2410_EXTINT_BOTHEDGE; |
155 | break; | |
156 | ||
6cab4860 | 157 | case IRQ_TYPE_LEVEL_LOW: |
a21765a7 BD |
158 | newvalue = S3C2410_EXTINT_LOWLEV; |
159 | break; | |
160 | ||
6cab4860 | 161 | case IRQ_TYPE_LEVEL_HIGH: |
a21765a7 BD |
162 | newvalue = S3C2410_EXTINT_HILEV; |
163 | break; | |
164 | ||
165 | default: | |
1f629b7a HS |
166 | pr_err("No such irq type %d", type); |
167 | return -EINVAL; | |
a21765a7 BD |
168 | } |
169 | ||
170 | value = __raw_readl(extint_reg); | |
171 | value = (value & ~(7 << extint_offset)) | (newvalue << extint_offset); | |
172 | __raw_writel(value, extint_reg); | |
173 | ||
174 | return 0; | |
175 | } | |
176 | ||
dc1a3538 | 177 | static int s3c_irqext_type(struct irq_data *data, unsigned int type) |
a21765a7 | 178 | { |
1f629b7a HS |
179 | void __iomem *extint_reg; |
180 | void __iomem *gpcon_reg; | |
181 | unsigned long gpcon_offset, extint_offset; | |
a21765a7 | 182 | |
1f629b7a HS |
183 | if ((data->hwirq >= 4) && (data->hwirq <= 7)) { |
184 | gpcon_reg = S3C2410_GPFCON; | |
185 | extint_reg = S3C24XX_EXTINT0; | |
186 | gpcon_offset = (data->hwirq) * 2; | |
187 | extint_offset = (data->hwirq) * 4; | |
188 | } else if ((data->hwirq >= 8) && (data->hwirq <= 15)) { | |
189 | gpcon_reg = S3C2410_GPGCON; | |
190 | extint_reg = S3C24XX_EXTINT1; | |
191 | gpcon_offset = (data->hwirq - 8) * 2; | |
192 | extint_offset = (data->hwirq - 8) * 4; | |
193 | } else if ((data->hwirq >= 16) && (data->hwirq <= 23)) { | |
194 | gpcon_reg = S3C2410_GPGCON; | |
195 | extint_reg = S3C24XX_EXTINT2; | |
196 | gpcon_offset = (data->hwirq - 8) * 2; | |
197 | extint_offset = (data->hwirq - 16) * 4; | |
198 | } else { | |
199 | return -EINVAL; | |
200 | } | |
a21765a7 | 201 | |
1f629b7a HS |
202 | return s3c_irqext_type_set(gpcon_reg, extint_reg, gpcon_offset, |
203 | extint_offset, type); | |
a21765a7 BD |
204 | } |
205 | ||
1f629b7a | 206 | static int s3c_irqext0_type(struct irq_data *data, unsigned int type) |
a21765a7 | 207 | { |
1f629b7a HS |
208 | void __iomem *extint_reg; |
209 | void __iomem *gpcon_reg; | |
210 | unsigned long gpcon_offset, extint_offset; | |
a21765a7 | 211 | |
1f629b7a HS |
212 | if ((data->hwirq >= 0) && (data->hwirq <= 3)) { |
213 | gpcon_reg = S3C2410_GPFCON; | |
214 | extint_reg = S3C24XX_EXTINT0; | |
215 | gpcon_offset = (data->hwirq) * 2; | |
216 | extint_offset = (data->hwirq) * 4; | |
217 | } else { | |
218 | return -EINVAL; | |
219 | } | |
a21765a7 | 220 | |
1f629b7a HS |
221 | return s3c_irqext_type_set(gpcon_reg, extint_reg, gpcon_offset, |
222 | extint_offset, type); | |
a21765a7 BD |
223 | } |
224 | ||
dc1a3538 | 225 | static struct irq_chip s3c_irq_chip = { |
1f629b7a HS |
226 | .name = "s3c", |
227 | .irq_ack = s3c_irq_ack, | |
228 | .irq_mask = s3c_irq_mask, | |
229 | .irq_unmask = s3c_irq_unmask, | |
230 | .irq_set_wake = s3c_irq_wake | |
a21765a7 BD |
231 | }; |
232 | ||
dc1a3538 | 233 | static struct irq_chip s3c_irq_level_chip = { |
1f629b7a HS |
234 | .name = "s3c-level", |
235 | .irq_mask = s3c_irq_mask, | |
236 | .irq_unmask = s3c_irq_unmask, | |
237 | .irq_ack = s3c_irq_ack, | |
a21765a7 BD |
238 | }; |
239 | ||
1f629b7a HS |
240 | static struct irq_chip s3c_irqext_chip = { |
241 | .name = "s3c-ext", | |
242 | .irq_mask = s3c_irq_mask, | |
243 | .irq_unmask = s3c_irq_unmask, | |
244 | .irq_ack = s3c_irq_ack, | |
245 | .irq_set_type = s3c_irqext_type, | |
246 | .irq_set_wake = s3c_irqext_wake | |
a21765a7 BD |
247 | }; |
248 | ||
1f629b7a HS |
249 | static struct irq_chip s3c_irq_eint0t4 = { |
250 | .name = "s3c-ext0", | |
251 | .irq_ack = s3c_irq_ack, | |
252 | .irq_mask = s3c_irq_mask, | |
253 | .irq_unmask = s3c_irq_unmask, | |
254 | .irq_set_wake = s3c_irq_wake, | |
255 | .irq_set_type = s3c_irqext0_type, | |
256 | }; | |
a21765a7 | 257 | |
1f629b7a | 258 | static void s3c_irq_demux(unsigned int irq, struct irq_desc *desc) |
a21765a7 | 259 | { |
1f629b7a HS |
260 | struct irq_chip *chip = irq_desc_get_chip(desc); |
261 | struct s3c_irq_intc *intc = desc->irq_data.domain->host_data; | |
262 | struct s3c_irq_data *irq_data = &intc->irqs[desc->irq_data.hwirq]; | |
263 | struct s3c_irq_intc *sub_intc = irq_data->sub_intc; | |
264 | unsigned long src; | |
265 | unsigned long msk; | |
266 | unsigned int n; | |
267 | ||
268 | chained_irq_enter(chip, desc); | |
269 | ||
270 | src = __raw_readl(sub_intc->reg_pending); | |
271 | msk = __raw_readl(sub_intc->reg_mask); | |
272 | ||
273 | src &= ~msk; | |
274 | src &= irq_data->sub_bits; | |
275 | ||
276 | while (src) { | |
277 | n = __ffs(src); | |
278 | src &= ~(1 << n); | |
279 | generic_handle_irq(irq_find_mapping(sub_intc->domain, n)); | |
a21765a7 BD |
280 | } |
281 | ||
1f629b7a | 282 | chained_irq_exit(chip, desc); |
a21765a7 BD |
283 | } |
284 | ||
229fd8ff BD |
285 | #ifdef CONFIG_FIQ |
286 | /** | |
287 | * s3c24xx_set_fiq - set the FIQ routing | |
288 | * @irq: IRQ number to route to FIQ on processor. | |
289 | * @on: Whether to route @irq to the FIQ, or to remove the FIQ routing. | |
290 | * | |
291 | * Change the state of the IRQ to FIQ routing depending on @irq and @on. If | |
292 | * @on is true, the @irq is checked to see if it can be routed and the | |
293 | * interrupt controller updated to route the IRQ. If @on is false, the FIQ | |
294 | * routing is cleared, regardless of which @irq is specified. | |
295 | */ | |
296 | int s3c24xx_set_fiq(unsigned int irq, bool on) | |
297 | { | |
298 | u32 intmod; | |
299 | unsigned offs; | |
300 | ||
301 | if (on) { | |
302 | offs = irq - FIQ_START; | |
303 | if (offs > 31) | |
304 | return -EINVAL; | |
305 | ||
306 | intmod = 1 << offs; | |
307 | } else { | |
308 | intmod = 0; | |
309 | } | |
310 | ||
311 | __raw_writel(intmod, S3C2410_INTMOD); | |
312 | return 0; | |
313 | } | |
0f13c824 BD |
314 | |
315 | EXPORT_SYMBOL_GPL(s3c24xx_set_fiq); | |
229fd8ff BD |
316 | #endif |
317 | ||
1f629b7a HS |
318 | static int s3c24xx_irq_map(struct irq_domain *h, unsigned int virq, |
319 | irq_hw_number_t hw) | |
a21765a7 | 320 | { |
1f629b7a HS |
321 | struct s3c_irq_intc *intc = h->host_data; |
322 | struct s3c_irq_data *irq_data = &intc->irqs[hw]; | |
323 | struct s3c_irq_intc *parent_intc; | |
324 | struct s3c_irq_data *parent_irq_data; | |
325 | unsigned int irqno; | |
326 | ||
327 | if (!intc) { | |
328 | pr_err("irq-s3c24xx: no controller found for hwirq %lu\n", hw); | |
329 | return -EINVAL; | |
330 | } | |
a21765a7 | 331 | |
1f629b7a HS |
332 | if (!irq_data) { |
333 | pr_err("irq-s3c24xx: no irq data found for hwirq %lu\n", hw); | |
334 | return -EINVAL; | |
335 | } | |
a21765a7 | 336 | |
1f629b7a HS |
337 | /* attach controller pointer to irq_data */ |
338 | irq_data->intc = intc; | |
a21765a7 | 339 | |
1f629b7a HS |
340 | /* set handler and flags */ |
341 | switch (irq_data->type) { | |
342 | case S3C_IRQTYPE_NONE: | |
343 | return 0; | |
344 | case S3C_IRQTYPE_EINT: | |
345 | if (irq_data->parent_irq) | |
346 | irq_set_chip_and_handler(virq, &s3c_irqext_chip, | |
347 | handle_edge_irq); | |
348 | else | |
349 | irq_set_chip_and_handler(virq, &s3c_irq_eint0t4, | |
350 | handle_edge_irq); | |
351 | break; | |
352 | case S3C_IRQTYPE_EDGE: | |
20f6c781 HS |
353 | if (irq_data->parent_irq || |
354 | intc->reg_pending == S3C2416_SRCPND2) | |
1f629b7a HS |
355 | irq_set_chip_and_handler(virq, &s3c_irq_level_chip, |
356 | handle_edge_irq); | |
357 | else | |
358 | irq_set_chip_and_handler(virq, &s3c_irq_chip, | |
359 | handle_edge_irq); | |
360 | break; | |
361 | case S3C_IRQTYPE_LEVEL: | |
362 | if (irq_data->parent_irq) | |
363 | irq_set_chip_and_handler(virq, &s3c_irq_level_chip, | |
364 | handle_level_irq); | |
365 | else | |
366 | irq_set_chip_and_handler(virq, &s3c_irq_chip, | |
367 | handle_level_irq); | |
368 | break; | |
369 | default: | |
370 | pr_err("irq-s3c24xx: unsupported irqtype %d\n", irq_data->type); | |
371 | return -EINVAL; | |
a21765a7 | 372 | } |
1f629b7a HS |
373 | set_irq_flags(virq, IRQF_VALID); |
374 | ||
375 | if (irq_data->parent_irq) { | |
376 | parent_intc = intc->parent; | |
377 | if (!parent_intc) { | |
378 | pr_err("irq-s3c24xx: no parent controller found for hwirq %lu\n", | |
379 | hw); | |
380 | goto err; | |
381 | } | |
a21765a7 | 382 | |
1f629b7a HS |
383 | parent_irq_data = &parent_intc->irqs[irq_data->parent_irq]; |
384 | if (!irq_data) { | |
385 | pr_err("irq-s3c24xx: no irq data found for hwirq %lu\n", | |
386 | hw); | |
387 | goto err; | |
388 | } | |
a21765a7 | 389 | |
1f629b7a HS |
390 | parent_irq_data->sub_intc = intc; |
391 | parent_irq_data->sub_bits |= (1UL << hw); | |
a21765a7 | 392 | |
1f629b7a HS |
393 | /* attach the demuxer to the parent irq */ |
394 | irqno = irq_find_mapping(parent_intc->domain, | |
395 | irq_data->parent_irq); | |
396 | if (!irqno) { | |
397 | pr_err("irq-s3c24xx: could not find mapping for parent irq %lu\n", | |
398 | irq_data->parent_irq); | |
399 | goto err; | |
400 | } | |
401 | irq_set_chained_handler(irqno, s3c_irq_demux); | |
a21765a7 BD |
402 | } |
403 | ||
1f629b7a | 404 | return 0; |
a21765a7 | 405 | |
1f629b7a HS |
406 | err: |
407 | set_irq_flags(virq, 0); | |
a21765a7 | 408 | |
1f629b7a HS |
409 | /* the only error can result from bad mapping data*/ |
410 | return -EINVAL; | |
411 | } | |
a21765a7 | 412 | |
1f629b7a HS |
413 | static struct irq_domain_ops s3c24xx_irq_ops = { |
414 | .map = s3c24xx_irq_map, | |
415 | .xlate = irq_domain_xlate_twocell, | |
416 | }; | |
a21765a7 | 417 | |
1f629b7a HS |
418 | static void s3c24xx_clear_intc(struct s3c_irq_intc *intc) |
419 | { | |
420 | void __iomem *reg_source; | |
421 | unsigned long pend; | |
422 | unsigned long last; | |
423 | int i; | |
a21765a7 | 424 | |
1f629b7a HS |
425 | /* if intpnd is set, read the next pending irq from there */ |
426 | reg_source = intc->reg_intpnd ? intc->reg_intpnd : intc->reg_pending; | |
a21765a7 | 427 | |
1f629b7a HS |
428 | last = 0; |
429 | for (i = 0; i < 4; i++) { | |
430 | pend = __raw_readl(reg_source); | |
a21765a7 | 431 | |
1f629b7a | 432 | if (pend == 0 || pend == last) |
a21765a7 BD |
433 | break; |
434 | ||
1f629b7a HS |
435 | __raw_writel(pend, intc->reg_pending); |
436 | if (intc->reg_intpnd) | |
437 | __raw_writel(pend, intc->reg_intpnd); | |
a21765a7 | 438 | |
1f629b7a HS |
439 | pr_info("irq: clearing pending status %08x\n", (int)pend); |
440 | last = pend; | |
a21765a7 | 441 | } |
1f629b7a | 442 | } |
a21765a7 | 443 | |
1f629b7a HS |
444 | struct s3c_irq_intc *s3c24xx_init_intc(struct device_node *np, |
445 | struct s3c_irq_data *irq_data, | |
446 | struct s3c_irq_intc *parent, | |
447 | unsigned long address) | |
448 | { | |
449 | struct s3c_irq_intc *intc; | |
450 | void __iomem *base = (void *)0xf6000000; /* static mapping */ | |
451 | int irq_num; | |
452 | int irq_start; | |
453 | int irq_offset; | |
454 | int ret; | |
455 | ||
456 | intc = kzalloc(sizeof(struct s3c_irq_intc), GFP_KERNEL); | |
457 | if (!intc) | |
458 | return ERR_PTR(-ENOMEM); | |
459 | ||
460 | intc->irqs = irq_data; | |
461 | ||
462 | if (parent) | |
463 | intc->parent = parent; | |
464 | ||
465 | /* select the correct data for the controller. | |
466 | * Need to hard code the irq num start and offset | |
467 | * to preserve the static mapping for now | |
468 | */ | |
469 | switch (address) { | |
470 | case 0x4a000000: | |
471 | pr_debug("irq: found main intc\n"); | |
472 | intc->reg_pending = base; | |
473 | intc->reg_mask = base + 0x08; | |
474 | intc->reg_intpnd = base + 0x10; | |
475 | irq_num = 32; | |
476 | irq_start = S3C2410_IRQ(0); | |
477 | irq_offset = 0; | |
478 | break; | |
479 | case 0x4a000018: | |
480 | pr_debug("irq: found subintc\n"); | |
481 | intc->reg_pending = base + 0x18; | |
482 | intc->reg_mask = base + 0x1c; | |
483 | irq_num = 29; | |
484 | irq_start = S3C2410_IRQSUB(0); | |
485 | irq_offset = 0; | |
486 | break; | |
487 | case 0x4a000040: | |
488 | pr_debug("irq: found intc2\n"); | |
489 | intc->reg_pending = base + 0x40; | |
490 | intc->reg_mask = base + 0x48; | |
491 | intc->reg_intpnd = base + 0x50; | |
492 | irq_num = 8; | |
493 | irq_start = S3C2416_IRQ(0); | |
494 | irq_offset = 0; | |
495 | break; | |
496 | case 0x560000a4: | |
497 | pr_debug("irq: found eintc\n"); | |
498 | base = (void *)0xfd000000; | |
499 | ||
500 | intc->reg_mask = base + 0xa4; | |
501 | intc->reg_pending = base + 0x08; | |
502 | irq_num = 20; | |
503 | irq_start = S3C2410_IRQ(32); | |
504 | irq_offset = 4; | |
505 | break; | |
506 | default: | |
507 | pr_err("irq: unsupported controller address\n"); | |
508 | ret = -EINVAL; | |
509 | goto err; | |
510 | } | |
a21765a7 | 511 | |
1f629b7a HS |
512 | /* now that all the data is complete, init the irq-domain */ |
513 | s3c24xx_clear_intc(intc); | |
514 | intc->domain = irq_domain_add_legacy(np, irq_num, irq_start, | |
515 | irq_offset, &s3c24xx_irq_ops, | |
516 | intc); | |
517 | if (!intc->domain) { | |
518 | pr_err("irq: could not create irq-domain\n"); | |
519 | ret = -EINVAL; | |
520 | goto err; | |
521 | } | |
a21765a7 | 522 | |
1f629b7a | 523 | return intc; |
a21765a7 | 524 | |
1f629b7a HS |
525 | err: |
526 | kfree(intc); | |
527 | return ERR_PTR(ret); | |
528 | } | |
a21765a7 | 529 | |
1f629b7a HS |
530 | /* s3c24xx_init_irq |
531 | * | |
532 | * Initialise S3C2410 IRQ system | |
533 | */ | |
a21765a7 | 534 | |
1f629b7a HS |
535 | static struct s3c_irq_data init_base[32] = { |
536 | { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */ | |
537 | { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */ | |
538 | { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */ | |
539 | { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */ | |
540 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */ | |
541 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */ | |
542 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
543 | { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */ | |
544 | { .type = S3C_IRQTYPE_EDGE, }, /* TICK */ | |
545 | { .type = S3C_IRQTYPE_EDGE, }, /* WDT */ | |
546 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */ | |
547 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */ | |
548 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */ | |
549 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */ | |
550 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */ | |
551 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */ | |
552 | { .type = S3C_IRQTYPE_EDGE, }, /* LCD */ | |
553 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */ | |
554 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */ | |
555 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */ | |
556 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */ | |
557 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI */ | |
558 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */ | |
559 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */ | |
560 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
561 | { .type = S3C_IRQTYPE_EDGE, }, /* USBD */ | |
562 | { .type = S3C_IRQTYPE_EDGE, }, /* USBH */ | |
563 | { .type = S3C_IRQTYPE_EDGE, }, /* IIC */ | |
564 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */ | |
565 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */ | |
566 | { .type = S3C_IRQTYPE_EDGE, }, /* RTC */ | |
567 | { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */ | |
568 | }; | |
a21765a7 | 569 | |
1f629b7a HS |
570 | static struct s3c_irq_data init_eint[32] = { |
571 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
572 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
573 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
574 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
575 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT4 */ | |
576 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT5 */ | |
577 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT6 */ | |
578 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT7 */ | |
579 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT8 */ | |
580 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT9 */ | |
581 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT10 */ | |
582 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT11 */ | |
583 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT12 */ | |
584 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT13 */ | |
585 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT14 */ | |
586 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT15 */ | |
587 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT16 */ | |
588 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT17 */ | |
589 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT18 */ | |
590 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT19 */ | |
591 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT20 */ | |
592 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT21 */ | |
593 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT22 */ | |
594 | { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT23 */ | |
595 | }; | |
a21765a7 | 596 | |
1f629b7a HS |
597 | static struct s3c_irq_data init_subint[32] = { |
598 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */ | |
599 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */ | |
600 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */ | |
601 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */ | |
602 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */ | |
603 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */ | |
604 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */ | |
605 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */ | |
606 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */ | |
607 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */ | |
608 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */ | |
609 | }; | |
a21765a7 | 610 | |
1f629b7a HS |
611 | void __init s3c24xx_init_irq(void) |
612 | { | |
613 | struct s3c_irq_intc *main_intc; | |
a21765a7 | 614 | |
1f629b7a HS |
615 | #ifdef CONFIG_FIQ |
616 | init_FIQ(FIQ_START); | |
617 | #endif | |
a21765a7 | 618 | |
1f629b7a HS |
619 | main_intc = s3c24xx_init_intc(NULL, &init_base[0], NULL, 0x4a000000); |
620 | if (IS_ERR(main_intc)) { | |
621 | pr_err("irq: could not create main interrupt controller\n"); | |
622 | return; | |
a21765a7 BD |
623 | } |
624 | ||
1f629b7a HS |
625 | s3c24xx_init_intc(NULL, &init_subint[0], main_intc, 0x4a000018); |
626 | s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4); | |
a21765a7 | 627 | } |
ef602eb5 HS |
628 | |
629 | #ifdef CONFIG_CPU_S3C2416 | |
20f6c781 HS |
630 | static struct s3c_irq_data init_s3c2416base[32] = { |
631 | { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */ | |
632 | { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */ | |
633 | { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */ | |
634 | { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */ | |
635 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */ | |
636 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */ | |
637 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
638 | { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */ | |
639 | { .type = S3C_IRQTYPE_EDGE, }, /* TICK */ | |
640 | { .type = S3C_IRQTYPE_LEVEL, }, /* WDT/AC97 */ | |
641 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */ | |
642 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */ | |
643 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */ | |
644 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */ | |
645 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */ | |
646 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */ | |
647 | { .type = S3C_IRQTYPE_LEVEL, }, /* LCD */ | |
648 | { .type = S3C_IRQTYPE_LEVEL, }, /* DMA */ | |
649 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART3 */ | |
650 | { .type = S3C_IRQTYPE_NONE, }, /* reserved */ | |
651 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI1 */ | |
652 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI0 */ | |
653 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */ | |
654 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */ | |
655 | { .type = S3C_IRQTYPE_EDGE, }, /* NAND */ | |
656 | { .type = S3C_IRQTYPE_EDGE, }, /* USBD */ | |
657 | { .type = S3C_IRQTYPE_EDGE, }, /* USBH */ | |
658 | { .type = S3C_IRQTYPE_EDGE, }, /* IIC */ | |
659 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */ | |
660 | { .type = S3C_IRQTYPE_NONE, }, | |
661 | { .type = S3C_IRQTYPE_EDGE, }, /* RTC */ | |
662 | { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */ | |
ef602eb5 HS |
663 | }; |
664 | ||
20f6c781 HS |
665 | static struct s3c_irq_data init_s3c2416subint[32] = { |
666 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */ | |
667 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */ | |
668 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */ | |
669 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */ | |
670 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */ | |
671 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */ | |
672 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */ | |
673 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */ | |
674 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */ | |
675 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */ | |
676 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */ | |
677 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
678 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
679 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
680 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
681 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD2 */ | |
682 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD3 */ | |
683 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD4 */ | |
684 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA0 */ | |
685 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA1 */ | |
686 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA2 */ | |
687 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA3 */ | |
688 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA4 */ | |
689 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA5 */ | |
690 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-RX */ | |
691 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-TX */ | |
692 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-ERR */ | |
693 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* WDT */ | |
694 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* AC97 */ | |
ef602eb5 HS |
695 | }; |
696 | ||
20f6c781 HS |
697 | static struct s3c_irq_data init_s3c2416_second[32] = { |
698 | { .type = S3C_IRQTYPE_EDGE }, /* 2D */ | |
699 | { .type = S3C_IRQTYPE_EDGE }, /* IIC1 */ | |
700 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
701 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
702 | { .type = S3C_IRQTYPE_EDGE }, /* PCM0 */ | |
703 | { .type = S3C_IRQTYPE_EDGE }, /* PCM1 */ | |
704 | { .type = S3C_IRQTYPE_EDGE }, /* I2S0 */ | |
705 | { .type = S3C_IRQTYPE_EDGE }, /* I2S1 */ | |
ef602eb5 HS |
706 | }; |
707 | ||
4a282dd3 | 708 | void __init s3c2416_init_irq(void) |
ef602eb5 | 709 | { |
20f6c781 | 710 | struct s3c_irq_intc *main_intc; |
ef602eb5 | 711 | |
20f6c781 | 712 | pr_info("S3C2416: IRQ Support\n"); |
ef602eb5 | 713 | |
20f6c781 HS |
714 | #ifdef CONFIG_FIQ |
715 | init_FIQ(FIQ_START); | |
716 | #endif | |
ef602eb5 | 717 | |
20f6c781 HS |
718 | main_intc = s3c24xx_init_intc(NULL, &init_s3c2416base[0], NULL, 0x4a000000); |
719 | if (IS_ERR(main_intc)) { | |
720 | pr_err("irq: could not create main interrupt controller\n"); | |
721 | return; | |
722 | } | |
ef602eb5 | 723 | |
20f6c781 HS |
724 | s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4); |
725 | s3c24xx_init_intc(NULL, &init_s3c2416subint[0], main_intc, 0x4a000018); | |
ef602eb5 | 726 | |
20f6c781 | 727 | s3c24xx_init_intc(NULL, &init_s3c2416_second[0], NULL, 0x4a000040); |
ef602eb5 HS |
728 | } |
729 | ||
ef602eb5 | 730 | #endif |
6b628917 | 731 | |
6f8d7ea2 HS |
732 | #ifdef CONFIG_CPU_S3C244X |
733 | /* camera irq */ | |
734 | ||
735 | static void s3c_irq_demux_cam(unsigned int irq, | |
736 | struct irq_desc *desc) | |
737 | { | |
738 | unsigned int subsrc, submsk; | |
739 | ||
740 | /* read the current pending interrupts, and the mask | |
741 | * for what it is available */ | |
742 | ||
743 | subsrc = __raw_readl(S3C2410_SUBSRCPND); | |
744 | submsk = __raw_readl(S3C2410_INTSUBMSK); | |
745 | ||
746 | subsrc &= ~submsk; | |
747 | subsrc >>= 11; | |
748 | subsrc &= 3; | |
749 | ||
750 | if (subsrc != 0) { | |
751 | if (subsrc & 1) { | |
752 | generic_handle_irq(IRQ_S3C2440_CAM_C); | |
753 | } | |
754 | if (subsrc & 2) { | |
755 | generic_handle_irq(IRQ_S3C2440_CAM_P); | |
756 | } | |
757 | } | |
758 | } | |
759 | ||
760 | #define INTMSK_CAM (1UL << (IRQ_CAM - IRQ_EINT0)) | |
761 | ||
762 | static void | |
763 | s3c_irq_cam_mask(struct irq_data *data) | |
764 | { | |
765 | s3c_irqsub_mask(data->irq, INTMSK_CAM, 3 << 11); | |
766 | } | |
767 | ||
768 | static void | |
769 | s3c_irq_cam_unmask(struct irq_data *data) | |
770 | { | |
771 | s3c_irqsub_unmask(data->irq, INTMSK_CAM); | |
772 | } | |
773 | ||
774 | static void | |
775 | s3c_irq_cam_ack(struct irq_data *data) | |
776 | { | |
777 | s3c_irqsub_maskack(data->irq, INTMSK_CAM, 3 << 11); | |
778 | } | |
779 | ||
780 | static struct irq_chip s3c_irq_cam = { | |
781 | .irq_mask = s3c_irq_cam_mask, | |
782 | .irq_unmask = s3c_irq_cam_unmask, | |
783 | .irq_ack = s3c_irq_cam_ack, | |
784 | }; | |
785 | ||
ce6c164b | 786 | #ifdef CONFIG_CPU_S3C2440 |
2286cf46 HS |
787 | /* WDT/AC97 */ |
788 | ||
789 | static void s3c_irq_demux_wdtac97(unsigned int irq, | |
790 | struct irq_desc *desc) | |
791 | { | |
792 | unsigned int subsrc, submsk; | |
793 | ||
794 | /* read the current pending interrupts, and the mask | |
795 | * for what it is available */ | |
796 | ||
797 | subsrc = __raw_readl(S3C2410_SUBSRCPND); | |
798 | submsk = __raw_readl(S3C2410_INTSUBMSK); | |
799 | ||
800 | subsrc &= ~submsk; | |
801 | subsrc >>= 13; | |
802 | subsrc &= 3; | |
803 | ||
804 | if (subsrc != 0) { | |
805 | if (subsrc & 1) { | |
806 | generic_handle_irq(IRQ_S3C2440_WDT); | |
807 | } | |
808 | if (subsrc & 2) { | |
809 | generic_handle_irq(IRQ_S3C2440_AC97); | |
810 | } | |
811 | } | |
812 | } | |
813 | ||
814 | ||
815 | #define INTMSK_WDT (1UL << (IRQ_WDT - IRQ_EINT0)) | |
816 | ||
817 | static void | |
818 | s3c_irq_wdtac97_mask(struct irq_data *data) | |
819 | { | |
820 | s3c_irqsub_mask(data->irq, INTMSK_WDT, 3 << 13); | |
821 | } | |
822 | ||
823 | static void | |
824 | s3c_irq_wdtac97_unmask(struct irq_data *data) | |
825 | { | |
826 | s3c_irqsub_unmask(data->irq, INTMSK_WDT); | |
827 | } | |
828 | ||
829 | static void | |
830 | s3c_irq_wdtac97_ack(struct irq_data *data) | |
831 | { | |
832 | s3c_irqsub_maskack(data->irq, INTMSK_WDT, 3 << 13); | |
833 | } | |
834 | ||
835 | static struct irq_chip s3c_irq_wdtac97 = { | |
836 | .irq_mask = s3c_irq_wdtac97_mask, | |
837 | .irq_unmask = s3c_irq_wdtac97_unmask, | |
838 | .irq_ack = s3c_irq_wdtac97_ack, | |
839 | }; | |
840 | ||
7cefed5e | 841 | void __init s3c2440_init_irq(void) |
2286cf46 HS |
842 | { |
843 | unsigned int irqno; | |
844 | ||
845 | printk("S3C2440: IRQ Support\n"); | |
846 | ||
ce6c164b HS |
847 | s3c24xx_init_irq(); |
848 | ||
6f8d7ea2 HS |
849 | irq_set_chip_and_handler(IRQ_NFCON, &s3c_irq_level_chip, |
850 | handle_level_irq); | |
851 | set_irq_flags(IRQ_NFCON, IRQF_VALID); | |
852 | ||
853 | /* add chained handler for camera */ | |
854 | ||
855 | irq_set_chip_and_handler(IRQ_CAM, &s3c_irq_level_chip, | |
856 | handle_level_irq); | |
857 | irq_set_chained_handler(IRQ_CAM, s3c_irq_demux_cam); | |
858 | ||
859 | for (irqno = IRQ_S3C2440_CAM_C; irqno <= IRQ_S3C2440_CAM_P; irqno++) { | |
860 | irq_set_chip_and_handler(irqno, &s3c_irq_cam, | |
861 | handle_level_irq); | |
862 | set_irq_flags(irqno, IRQF_VALID); | |
863 | } | |
7cefed5e HS |
864 | |
865 | /* add new chained handler for wdt, ac7 */ | |
866 | ||
867 | irq_set_chip_and_handler(IRQ_WDT, &s3c_irq_level_chip, | |
868 | handle_level_irq); | |
869 | irq_set_chained_handler(IRQ_WDT, s3c_irq_demux_wdtac97); | |
870 | ||
871 | for (irqno = IRQ_S3C2440_WDT; irqno <= IRQ_S3C2440_AC97; irqno++) { | |
872 | irq_set_chip_and_handler(irqno, &s3c_irq_wdtac97, | |
873 | handle_level_irq); | |
874 | set_irq_flags(irqno, IRQF_VALID); | |
875 | } | |
6f8d7ea2 | 876 | } |
ce6c164b | 877 | #endif |
6f8d7ea2 | 878 | |
ce6c164b | 879 | #ifdef CONFIG_CPU_S3C2442 |
70644ade HS |
880 | static struct s3c_irq_data init_s3c2442base[32] = { |
881 | { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */ | |
882 | { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */ | |
883 | { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */ | |
884 | { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */ | |
885 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */ | |
886 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */ | |
887 | { .type = S3C_IRQTYPE_LEVEL, }, /* CAM */ | |
888 | { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */ | |
889 | { .type = S3C_IRQTYPE_EDGE, }, /* TICK */ | |
890 | { .type = S3C_IRQTYPE_EDGE, }, /* WDT */ | |
891 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */ | |
892 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */ | |
893 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */ | |
894 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */ | |
895 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */ | |
896 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */ | |
897 | { .type = S3C_IRQTYPE_EDGE, }, /* LCD */ | |
898 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */ | |
899 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */ | |
900 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */ | |
901 | { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */ | |
902 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI */ | |
903 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */ | |
904 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */ | |
905 | { .type = S3C_IRQTYPE_LEVEL, }, /* NFCON */ | |
906 | { .type = S3C_IRQTYPE_EDGE, }, /* USBD */ | |
907 | { .type = S3C_IRQTYPE_EDGE, }, /* USBH */ | |
908 | { .type = S3C_IRQTYPE_EDGE, }, /* IIC */ | |
909 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */ | |
910 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */ | |
911 | { .type = S3C_IRQTYPE_EDGE, }, /* RTC */ | |
912 | { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */ | |
913 | }; | |
6f8d7ea2 | 914 | |
70644ade HS |
915 | static struct s3c_irq_data init_s3c2442subint[32] = { |
916 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */ | |
917 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */ | |
918 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */ | |
919 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */ | |
920 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */ | |
921 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */ | |
922 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */ | |
923 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */ | |
924 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */ | |
925 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */ | |
926 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */ | |
927 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* TC */ | |
928 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* ADC */ | |
929 | }; | |
6f8d7ea2 | 930 | |
70644ade HS |
931 | void __init s3c2442_init_irq(void) |
932 | { | |
933 | struct s3c_irq_intc *main_intc; | |
6f8d7ea2 | 934 | |
70644ade | 935 | pr_info("S3C2442: IRQ Support\n"); |
6f8d7ea2 | 936 | |
70644ade HS |
937 | #ifdef CONFIG_FIQ |
938 | init_FIQ(FIQ_START); | |
939 | #endif | |
ce6c164b | 940 | |
70644ade HS |
941 | main_intc = s3c24xx_init_intc(NULL, &init_s3c2442base[0], NULL, 0x4a000000); |
942 | if (IS_ERR(main_intc)) { | |
943 | pr_err("irq: could not create main interrupt controller\n"); | |
944 | return; | |
ce6c164b | 945 | } |
70644ade HS |
946 | |
947 | s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4); | |
948 | s3c24xx_init_intc(NULL, &init_s3c2442subint[0], main_intc, 0x4a000018); | |
6f8d7ea2 | 949 | } |
ce6c164b | 950 | #endif |
6f8d7ea2 | 951 | |
6f8d7ea2 HS |
952 | #endif |
953 | ||
6b628917 | 954 | #ifdef CONFIG_CPU_S3C2443 |
f44ddba3 HS |
955 | static struct s3c_irq_data init_s3c2443base[32] = { |
956 | { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */ | |
957 | { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */ | |
958 | { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */ | |
959 | { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */ | |
960 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */ | |
961 | { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */ | |
962 | { .type = S3C_IRQTYPE_LEVEL, }, /* CAM */ | |
963 | { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */ | |
964 | { .type = S3C_IRQTYPE_EDGE, }, /* TICK */ | |
965 | { .type = S3C_IRQTYPE_LEVEL, }, /* WDT/AC97 */ | |
966 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */ | |
967 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */ | |
968 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */ | |
969 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */ | |
970 | { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */ | |
971 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */ | |
972 | { .type = S3C_IRQTYPE_LEVEL, }, /* LCD */ | |
973 | { .type = S3C_IRQTYPE_LEVEL, }, /* DMA */ | |
974 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART3 */ | |
975 | { .type = S3C_IRQTYPE_EDGE, }, /* CFON */ | |
976 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI1 */ | |
977 | { .type = S3C_IRQTYPE_EDGE, }, /* SDI0 */ | |
978 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */ | |
979 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */ | |
980 | { .type = S3C_IRQTYPE_EDGE, }, /* NAND */ | |
981 | { .type = S3C_IRQTYPE_EDGE, }, /* USBD */ | |
982 | { .type = S3C_IRQTYPE_EDGE, }, /* USBH */ | |
983 | { .type = S3C_IRQTYPE_EDGE, }, /* IIC */ | |
984 | { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */ | |
985 | { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */ | |
986 | { .type = S3C_IRQTYPE_EDGE, }, /* RTC */ | |
987 | { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */ | |
6b628917 HS |
988 | }; |
989 | ||
6b628917 | 990 | |
f44ddba3 HS |
991 | static struct s3c_irq_data init_s3c2443subint[32] = { |
992 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */ | |
993 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */ | |
994 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */ | |
995 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */ | |
996 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */ | |
997 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */ | |
998 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */ | |
999 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */ | |
1000 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */ | |
1001 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */ | |
1002 | { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */ | |
1003 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* CAM_C */ | |
1004 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* CAM_P */ | |
1005 | { .type = S3C_IRQTYPE_NONE }, /* reserved */ | |
1006 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD1 */ | |
1007 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD2 */ | |
1008 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD3 */ | |
1009 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD4 */ | |
1010 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA0 */ | |
1011 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA1 */ | |
1012 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA2 */ | |
1013 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA3 */ | |
1014 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA4 */ | |
1015 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA5 */ | |
1016 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-RX */ | |
1017 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-TX */ | |
1018 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-ERR */ | |
1019 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* WDT */ | |
1020 | { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* AC97 */ | |
6b628917 HS |
1021 | }; |
1022 | ||
b499b7a8 | 1023 | void __init s3c2443_init_irq(void) |
6b628917 | 1024 | { |
f44ddba3 | 1025 | struct s3c_irq_intc *main_intc; |
6b628917 | 1026 | |
f44ddba3 | 1027 | pr_info("S3C2443: IRQ Support\n"); |
6b628917 | 1028 | |
f44ddba3 HS |
1029 | #ifdef CONFIG_FIQ |
1030 | init_FIQ(FIQ_START); | |
1031 | #endif | |
6b628917 | 1032 | |
f44ddba3 HS |
1033 | main_intc = s3c24xx_init_intc(NULL, &init_s3c2443base[0], NULL, 0x4a000000); |
1034 | if (IS_ERR(main_intc)) { | |
1035 | pr_err("irq: could not create main interrupt controller\n"); | |
1036 | return; | |
1037 | } | |
6b628917 | 1038 | |
f44ddba3 HS |
1039 | s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4); |
1040 | s3c24xx_init_intc(NULL, &init_s3c2443subint[0], main_intc, 0x4a000018); | |
6b628917 | 1041 | } |
6b628917 | 1042 | #endif |