ARM: S3C24XX: move s3c24xx_init_irq to s3c2410_init_irq
[sfrench/cifs-2.6.git] / arch / arm / mach-s3c24xx / irq.c
1 /*
2  * S3C24XX IRQ handling
3  *
4  * Copyright (c) 2003-2004 Simtec Electronics
5  *      Ben Dooks <ben@simtec.co.uk>
6  * Copyright (c) 2012 Heiko Stuebner <heiko@sntech.de>
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.
17 */
18
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/module.h>
22 #include <linux/io.h>
23 #include <linux/err.h>
24 #include <linux/interrupt.h>
25 #include <linux/ioport.h>
26 #include <linux/device.h>
27 #include <linux/irqdomain.h>
28
29 #include <asm/mach/irq.h>
30
31 #include <mach/regs-irq.h>
32 #include <mach/regs-gpio.h>
33
34 #include <plat/cpu.h>
35 #include <plat/regs-irqtype.h>
36 #include <plat/pm.h>
37
38 #define S3C_IRQTYPE_NONE        0
39 #define S3C_IRQTYPE_EINT        1
40 #define S3C_IRQTYPE_EDGE        2
41 #define S3C_IRQTYPE_LEVEL       3
42
43 struct s3c_irq_data {
44         unsigned int type;
45         unsigned long parent_irq;
46
47         /* data gets filled during init */
48         struct s3c_irq_intc *intc;
49         unsigned long sub_bits;
50         struct s3c_irq_intc *sub_intc;
51 };
52
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;
69 };
70
71 static void s3c_irq_mask(struct irq_data *data)
72 {
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;
77         unsigned long mask;
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) {
85                 parent_data = &parent_intc->irqs[irq_data->parent_irq];
86
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         }
94 }
95
96 static void s3c_irq_unmask(struct irq_data *data)
97 {
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];
101         unsigned long mask;
102         unsigned int irqno;
103
104         mask = __raw_readl(intc->reg_mask);
105         mask &= ~(1UL << data->hwirq);
106         __raw_writel(mask, intc->reg_mask);
107
108         if (parent_intc) {
109                 irqno = irq_find_mapping(parent_intc->domain,
110                                          irq_data->parent_irq);
111                 s3c_irq_unmask(irq_get_irq_data(irqno));
112         }
113 }
114
115 static inline void s3c_irq_ack(struct irq_data *data)
116 {
117         struct s3c_irq_intc *intc = data->domain->host_data;
118         unsigned long bitval = 1UL << data->hwirq;
119
120         __raw_writel(bitval, intc->reg_pending);
121         if (intc->reg_intpnd)
122                 __raw_writel(bitval, intc->reg_intpnd);
123 }
124
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)
130 {
131         unsigned long newvalue = 0, value;
132
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         {
141                 case IRQ_TYPE_NONE:
142                         pr_warn("No edge setting!\n");
143                         break;
144
145                 case IRQ_TYPE_EDGE_RISING:
146                         newvalue = S3C2410_EXTINT_RISEEDGE;
147                         break;
148
149                 case IRQ_TYPE_EDGE_FALLING:
150                         newvalue = S3C2410_EXTINT_FALLEDGE;
151                         break;
152
153                 case IRQ_TYPE_EDGE_BOTH:
154                         newvalue = S3C2410_EXTINT_BOTHEDGE;
155                         break;
156
157                 case IRQ_TYPE_LEVEL_LOW:
158                         newvalue = S3C2410_EXTINT_LOWLEV;
159                         break;
160
161                 case IRQ_TYPE_LEVEL_HIGH:
162                         newvalue = S3C2410_EXTINT_HILEV;
163                         break;
164
165                 default:
166                         pr_err("No such irq type %d", type);
167                         return -EINVAL;
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
177 static int s3c_irqext_type(struct irq_data *data, unsigned int type)
178 {
179         void __iomem *extint_reg;
180         void __iomem *gpcon_reg;
181         unsigned long gpcon_offset, extint_offset;
182
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         }
201
202         return s3c_irqext_type_set(gpcon_reg, extint_reg, gpcon_offset,
203                                    extint_offset, type);
204 }
205
206 static int s3c_irqext0_type(struct irq_data *data, unsigned int type)
207 {
208         void __iomem *extint_reg;
209         void __iomem *gpcon_reg;
210         unsigned long gpcon_offset, extint_offset;
211
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         }
220
221         return s3c_irqext_type_set(gpcon_reg, extint_reg, gpcon_offset,
222                                    extint_offset, type);
223 }
224
225 static struct irq_chip s3c_irq_chip = {
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
231 };
232
233 static struct irq_chip s3c_irq_level_chip = {
234         .name           = "s3c-level",
235         .irq_mask       = s3c_irq_mask,
236         .irq_unmask     = s3c_irq_unmask,
237         .irq_ack        = s3c_irq_ack,
238 };
239
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
247 };
248
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 };
257
258 static void s3c_irq_demux(unsigned int irq, struct irq_desc *desc)
259 {
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));
280         }
281
282         chained_irq_exit(chip, desc);
283 }
284
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 }
314
315 EXPORT_SYMBOL_GPL(s3c24xx_set_fiq);
316 #endif
317
318 static int s3c24xx_irq_map(struct irq_domain *h, unsigned int virq,
319                                                         irq_hw_number_t hw)
320 {
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         /* attach controller pointer to irq_data */
328         irq_data->intc = intc;
329
330         parent_intc = intc->parent;
331
332         /* set handler and flags */
333         switch (irq_data->type) {
334         case S3C_IRQTYPE_NONE:
335                 return 0;
336         case S3C_IRQTYPE_EINT:
337                 /* On the S3C2412, the EINT0to3 have a parent irq
338                  * but need the s3c_irq_eint0t4 chip
339                  */
340                 if (parent_intc && (!soc_is_s3c2412() || hw >= 4))
341                         irq_set_chip_and_handler(virq, &s3c_irqext_chip,
342                                                  handle_edge_irq);
343                 else
344                         irq_set_chip_and_handler(virq, &s3c_irq_eint0t4,
345                                                  handle_edge_irq);
346                 break;
347         case S3C_IRQTYPE_EDGE:
348                 if (parent_intc || intc->reg_pending == S3C2416_SRCPND2)
349                         irq_set_chip_and_handler(virq, &s3c_irq_level_chip,
350                                                  handle_edge_irq);
351                 else
352                         irq_set_chip_and_handler(virq, &s3c_irq_chip,
353                                                  handle_edge_irq);
354                 break;
355         case S3C_IRQTYPE_LEVEL:
356                 if (parent_intc)
357                         irq_set_chip_and_handler(virq, &s3c_irq_level_chip,
358                                                  handle_level_irq);
359                 else
360                         irq_set_chip_and_handler(virq, &s3c_irq_chip,
361                                                  handle_level_irq);
362                 break;
363         default:
364                 pr_err("irq-s3c24xx: unsupported irqtype %d\n", irq_data->type);
365                 return -EINVAL;
366         }
367         set_irq_flags(virq, IRQF_VALID);
368
369         if (parent_intc && irq_data->type != S3C_IRQTYPE_NONE) {
370                 if (irq_data->parent_irq > 31) {
371                         pr_err("irq-s3c24xx: parent irq %lu is out of range\n",
372                                irq_data->parent_irq);
373                         goto err;
374                 }
375
376                 parent_irq_data = &parent_intc->irqs[irq_data->parent_irq];
377                 parent_irq_data->sub_intc = intc;
378                 parent_irq_data->sub_bits |= (1UL << hw);
379
380                 /* attach the demuxer to the parent irq */
381                 irqno = irq_find_mapping(parent_intc->domain,
382                                          irq_data->parent_irq);
383                 if (!irqno) {
384                         pr_err("irq-s3c24xx: could not find mapping for parent irq %lu\n",
385                                irq_data->parent_irq);
386                         goto err;
387                 }
388                 irq_set_chained_handler(irqno, s3c_irq_demux);
389         }
390
391         return 0;
392
393 err:
394         set_irq_flags(virq, 0);
395
396         /* the only error can result from bad mapping data*/
397         return -EINVAL;
398 }
399
400 static struct irq_domain_ops s3c24xx_irq_ops = {
401         .map = s3c24xx_irq_map,
402         .xlate = irq_domain_xlate_twocell,
403 };
404
405 static void s3c24xx_clear_intc(struct s3c_irq_intc *intc)
406 {
407         void __iomem *reg_source;
408         unsigned long pend;
409         unsigned long last;
410         int i;
411
412         /* if intpnd is set, read the next pending irq from there */
413         reg_source = intc->reg_intpnd ? intc->reg_intpnd : intc->reg_pending;
414
415         last = 0;
416         for (i = 0; i < 4; i++) {
417                 pend = __raw_readl(reg_source);
418
419                 if (pend == 0 || pend == last)
420                         break;
421
422                 __raw_writel(pend, intc->reg_pending);
423                 if (intc->reg_intpnd)
424                         __raw_writel(pend, intc->reg_intpnd);
425
426                 pr_info("irq: clearing pending status %08x\n", (int)pend);
427                 last = pend;
428         }
429 }
430
431 struct s3c_irq_intc *s3c24xx_init_intc(struct device_node *np,
432                                        struct s3c_irq_data *irq_data,
433                                        struct s3c_irq_intc *parent,
434                                        unsigned long address)
435 {
436         struct s3c_irq_intc *intc;
437         void __iomem *base = (void *)0xf6000000; /* static mapping */
438         int irq_num;
439         int irq_start;
440         int ret;
441
442         intc = kzalloc(sizeof(struct s3c_irq_intc), GFP_KERNEL);
443         if (!intc)
444                 return ERR_PTR(-ENOMEM);
445
446         intc->irqs = irq_data;
447
448         if (parent)
449                 intc->parent = parent;
450
451         /* select the correct data for the controller.
452          * Need to hard code the irq num start and offset
453          * to preserve the static mapping for now
454          */
455         switch (address) {
456         case 0x4a000000:
457                 pr_debug("irq: found main intc\n");
458                 intc->reg_pending = base;
459                 intc->reg_mask = base + 0x08;
460                 intc->reg_intpnd = base + 0x10;
461                 irq_num = 32;
462                 irq_start = S3C2410_IRQ(0);
463                 break;
464         case 0x4a000018:
465                 pr_debug("irq: found subintc\n");
466                 intc->reg_pending = base + 0x18;
467                 intc->reg_mask = base + 0x1c;
468                 irq_num = 29;
469                 irq_start = S3C2410_IRQSUB(0);
470                 break;
471         case 0x4a000040:
472                 pr_debug("irq: found intc2\n");
473                 intc->reg_pending = base + 0x40;
474                 intc->reg_mask = base + 0x48;
475                 intc->reg_intpnd = base + 0x50;
476                 irq_num = 8;
477                 irq_start = S3C2416_IRQ(0);
478                 break;
479         case 0x560000a4:
480                 pr_debug("irq: found eintc\n");
481                 base = (void *)0xfd000000;
482
483                 intc->reg_mask = base + 0xa4;
484                 intc->reg_pending = base + 0x08;
485                 irq_num = 24;
486                 irq_start = S3C2410_IRQ(32);
487                 break;
488         default:
489                 pr_err("irq: unsupported controller address\n");
490                 ret = -EINVAL;
491                 goto err;
492         }
493
494         /* now that all the data is complete, init the irq-domain */
495         s3c24xx_clear_intc(intc);
496         intc->domain = irq_domain_add_legacy(np, irq_num, irq_start,
497                                              0, &s3c24xx_irq_ops,
498                                              intc);
499         if (!intc->domain) {
500                 pr_err("irq: could not create irq-domain\n");
501                 ret = -EINVAL;
502                 goto err;
503         }
504
505         return intc;
506
507 err:
508         kfree(intc);
509         return ERR_PTR(ret);
510 }
511
512 static struct s3c_irq_data init_eint[32] = {
513         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
514         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
515         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
516         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
517         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT4 */
518         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT5 */
519         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT6 */
520         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT7 */
521         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT8 */
522         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT9 */
523         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT10 */
524         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT11 */
525         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT12 */
526         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT13 */
527         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT14 */
528         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT15 */
529         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT16 */
530         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT17 */
531         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT18 */
532         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT19 */
533         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT20 */
534         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT21 */
535         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT22 */
536         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT23 */
537 };
538
539 #ifdef CONFIG_CPU_S3C2410
540 static struct s3c_irq_data init_s3c2410base[32] = {
541         { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */
542         { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */
543         { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */
544         { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */
545         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
546         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
547         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
548         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
549         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
550         { .type = S3C_IRQTYPE_EDGE, }, /* WDT */
551         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
552         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
553         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
554         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
555         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
556         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
557         { .type = S3C_IRQTYPE_EDGE, }, /* LCD */
558         { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */
559         { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */
560         { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */
561         { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */
562         { .type = S3C_IRQTYPE_EDGE, }, /* SDI */
563         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
564         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
565         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
566         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
567         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
568         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
569         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
570         { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */
571         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
572         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
573 };
574
575 static struct s3c_irq_data init_s3c2410subint[32] = {
576         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
577         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
578         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
579         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
580         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
581         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
582         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
583         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
584         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
585         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
586         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
587 };
588
589 void __init s3c2410_init_irq(void)
590 {
591         struct s3c_irq_intc *main_intc;
592
593 #ifdef CONFIG_FIQ
594         init_FIQ(FIQ_START);
595 #endif
596
597         main_intc = s3c24xx_init_intc(NULL, &init_s3c2410base[0], NULL, 0x4a000000);
598         if (IS_ERR(main_intc)) {
599                 pr_err("irq: could not create main interrupt controller\n");
600                 return;
601         }
602
603         s3c24xx_init_intc(NULL, &init_s3c2410subint[0], main_intc, 0x4a000018);
604         s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4);
605 }
606 #endif
607
608 #ifdef CONFIG_CPU_S3C2412
609 static struct s3c_irq_data init_s3c2412base[32] = {
610         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT0 */
611         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT1 */
612         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT2 */
613         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT3 */
614         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
615         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
616         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
617         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
618         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
619         { .type = S3C_IRQTYPE_EDGE, }, /* WDT */
620         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
621         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
622         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
623         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
624         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
625         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
626         { .type = S3C_IRQTYPE_EDGE, }, /* LCD */
627         { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */
628         { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */
629         { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */
630         { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */
631         { .type = S3C_IRQTYPE_LEVEL, }, /* SDI/CF */
632         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
633         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
634         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
635         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
636         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
637         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
638         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
639         { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */
640         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
641         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
642 };
643
644 static struct s3c_irq_data init_s3c2412eint[32] = {
645         { .type = S3C_IRQTYPE_EINT, .parent_irq = 0 }, /* EINT0 */
646         { .type = S3C_IRQTYPE_EINT, .parent_irq = 1 }, /* EINT1 */
647         { .type = S3C_IRQTYPE_EINT, .parent_irq = 2 }, /* EINT2 */
648         { .type = S3C_IRQTYPE_EINT, .parent_irq = 3 }, /* EINT3 */
649         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT4 */
650         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT5 */
651         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT6 */
652         { .type = S3C_IRQTYPE_EINT, .parent_irq = 4 }, /* EINT7 */
653         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT8 */
654         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT9 */
655         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT10 */
656         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT11 */
657         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT12 */
658         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT13 */
659         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT14 */
660         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT15 */
661         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT16 */
662         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT17 */
663         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT18 */
664         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT19 */
665         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT20 */
666         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT21 */
667         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT22 */
668         { .type = S3C_IRQTYPE_EINT, .parent_irq = 5 }, /* EINT23 */
669 };
670
671 static struct s3c_irq_data init_s3c2412subint[32] = {
672         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
673         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
674         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
675         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
676         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
677         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
678         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
679         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
680         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
681         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
682         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
683         { .type = S3C_IRQTYPE_NONE, },
684         { .type = S3C_IRQTYPE_NONE, },
685         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 21 }, /* SDI */
686         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 21 }, /* CF */
687 };
688
689 void s3c2412_init_irq(void)
690 {
691         struct s3c_irq_intc *main_intc;
692
693         pr_info("S3C2412: IRQ Support\n");
694
695 #ifdef CONFIG_FIQ
696         init_FIQ(FIQ_START);
697 #endif
698
699         main_intc = s3c24xx_init_intc(NULL, &init_s3c2412base[0], NULL, 0x4a000000);
700         if (IS_ERR(main_intc)) {
701                 pr_err("irq: could not create main interrupt controller\n");
702                 return;
703         }
704
705         s3c24xx_init_intc(NULL, &init_s3c2412eint[0], main_intc, 0x560000a4);
706         s3c24xx_init_intc(NULL, &init_s3c2412subint[0], main_intc, 0x4a000018);
707 }
708 #endif
709
710 #ifdef CONFIG_CPU_S3C2416
711 static struct s3c_irq_data init_s3c2416base[32] = {
712         { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */
713         { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */
714         { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */
715         { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */
716         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
717         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
718         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
719         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
720         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
721         { .type = S3C_IRQTYPE_LEVEL, }, /* WDT/AC97 */
722         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
723         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
724         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
725         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
726         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
727         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
728         { .type = S3C_IRQTYPE_LEVEL, }, /* LCD */
729         { .type = S3C_IRQTYPE_LEVEL, }, /* DMA */
730         { .type = S3C_IRQTYPE_LEVEL, }, /* UART3 */
731         { .type = S3C_IRQTYPE_NONE, }, /* reserved */
732         { .type = S3C_IRQTYPE_EDGE, }, /* SDI1 */
733         { .type = S3C_IRQTYPE_EDGE, }, /* SDI0 */
734         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
735         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
736         { .type = S3C_IRQTYPE_EDGE, }, /* NAND */
737         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
738         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
739         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
740         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
741         { .type = S3C_IRQTYPE_NONE, },
742         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
743         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
744 };
745
746 static struct s3c_irq_data init_s3c2416subint[32] = {
747         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
748         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
749         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
750         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
751         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
752         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
753         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
754         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
755         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
756         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
757         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
758         { .type = S3C_IRQTYPE_NONE }, /* reserved */
759         { .type = S3C_IRQTYPE_NONE }, /* reserved */
760         { .type = S3C_IRQTYPE_NONE }, /* reserved */
761         { .type = S3C_IRQTYPE_NONE }, /* reserved */
762         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD2 */
763         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD3 */
764         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD4 */
765         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA0 */
766         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA1 */
767         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA2 */
768         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA3 */
769         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA4 */
770         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA5 */
771         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-RX */
772         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-TX */
773         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-ERR */
774         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* WDT */
775         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* AC97 */
776 };
777
778 static struct s3c_irq_data init_s3c2416_second[32] = {
779         { .type = S3C_IRQTYPE_EDGE }, /* 2D */
780         { .type = S3C_IRQTYPE_EDGE }, /* IIC1 */
781         { .type = S3C_IRQTYPE_NONE }, /* reserved */
782         { .type = S3C_IRQTYPE_NONE }, /* reserved */
783         { .type = S3C_IRQTYPE_EDGE }, /* PCM0 */
784         { .type = S3C_IRQTYPE_EDGE }, /* PCM1 */
785         { .type = S3C_IRQTYPE_EDGE }, /* I2S0 */
786         { .type = S3C_IRQTYPE_EDGE }, /* I2S1 */
787 };
788
789 void __init s3c2416_init_irq(void)
790 {
791         struct s3c_irq_intc *main_intc;
792
793         pr_info("S3C2416: IRQ Support\n");
794
795 #ifdef CONFIG_FIQ
796         init_FIQ(FIQ_START);
797 #endif
798
799         main_intc = s3c24xx_init_intc(NULL, &init_s3c2416base[0], NULL, 0x4a000000);
800         if (IS_ERR(main_intc)) {
801                 pr_err("irq: could not create main interrupt controller\n");
802                 return;
803         }
804
805         s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4);
806         s3c24xx_init_intc(NULL, &init_s3c2416subint[0], main_intc, 0x4a000018);
807
808         s3c24xx_init_intc(NULL, &init_s3c2416_second[0], NULL, 0x4a000040);
809 }
810
811 #endif
812
813 #ifdef CONFIG_CPU_S3C2440
814 static struct s3c_irq_data init_s3c2440base[32] = {
815         { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */
816         { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */
817         { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */
818         { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */
819         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
820         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
821         { .type = S3C_IRQTYPE_LEVEL, }, /* CAM */
822         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
823         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
824         { .type = S3C_IRQTYPE_LEVEL, }, /* WDT/AC97 */
825         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
826         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
827         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
828         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
829         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
830         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
831         { .type = S3C_IRQTYPE_EDGE, }, /* LCD */
832         { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */
833         { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */
834         { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */
835         { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */
836         { .type = S3C_IRQTYPE_EDGE, }, /* SDI */
837         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
838         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
839         { .type = S3C_IRQTYPE_LEVEL, }, /* NFCON */
840         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
841         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
842         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
843         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
844         { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */
845         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
846         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
847 };
848
849 static struct s3c_irq_data init_s3c2440subint[32] = {
850         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
851         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
852         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
853         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
854         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
855         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
856         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
857         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
858         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
859         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
860         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
861         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* TC */
862         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* ADC */
863         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* WDT */
864         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* AC97 */
865 };
866
867 void __init s3c2440_init_irq(void)
868 {
869         struct s3c_irq_intc *main_intc;
870
871         pr_info("S3C2440: IRQ Support\n");
872
873 #ifdef CONFIG_FIQ
874         init_FIQ(FIQ_START);
875 #endif
876
877         main_intc = s3c24xx_init_intc(NULL, &init_s3c2440base[0], NULL, 0x4a000000);
878         if (IS_ERR(main_intc)) {
879                 pr_err("irq: could not create main interrupt controller\n");
880                 return;
881         }
882
883         s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4);
884         s3c24xx_init_intc(NULL, &init_s3c2440subint[0], main_intc, 0x4a000018);
885 }
886 #endif
887
888 #ifdef CONFIG_CPU_S3C2442
889 static struct s3c_irq_data init_s3c2442base[32] = {
890         { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */
891         { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */
892         { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */
893         { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */
894         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
895         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
896         { .type = S3C_IRQTYPE_LEVEL, }, /* CAM */
897         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
898         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
899         { .type = S3C_IRQTYPE_EDGE, }, /* WDT */
900         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
901         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
902         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
903         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
904         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
905         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
906         { .type = S3C_IRQTYPE_EDGE, }, /* LCD */
907         { .type = S3C_IRQTYPE_EDGE, }, /* DMA0 */
908         { .type = S3C_IRQTYPE_EDGE, }, /* DMA1 */
909         { .type = S3C_IRQTYPE_EDGE, }, /* DMA2 */
910         { .type = S3C_IRQTYPE_EDGE, }, /* DMA3 */
911         { .type = S3C_IRQTYPE_EDGE, }, /* SDI */
912         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
913         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
914         { .type = S3C_IRQTYPE_LEVEL, }, /* NFCON */
915         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
916         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
917         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
918         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
919         { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */
920         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
921         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
922 };
923
924 static struct s3c_irq_data init_s3c2442subint[32] = {
925         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
926         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
927         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
928         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
929         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
930         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
931         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
932         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
933         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
934         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
935         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
936         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* TC */
937         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* ADC */
938 };
939
940 void __init s3c2442_init_irq(void)
941 {
942         struct s3c_irq_intc *main_intc;
943
944         pr_info("S3C2442: IRQ Support\n");
945
946 #ifdef CONFIG_FIQ
947         init_FIQ(FIQ_START);
948 #endif
949
950         main_intc = s3c24xx_init_intc(NULL, &init_s3c2442base[0], NULL, 0x4a000000);
951         if (IS_ERR(main_intc)) {
952                 pr_err("irq: could not create main interrupt controller\n");
953                 return;
954         }
955
956         s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4);
957         s3c24xx_init_intc(NULL, &init_s3c2442subint[0], main_intc, 0x4a000018);
958 }
959 #endif
960
961 #ifdef CONFIG_CPU_S3C2443
962 static struct s3c_irq_data init_s3c2443base[32] = {
963         { .type = S3C_IRQTYPE_EINT, }, /* EINT0 */
964         { .type = S3C_IRQTYPE_EINT, }, /* EINT1 */
965         { .type = S3C_IRQTYPE_EINT, }, /* EINT2 */
966         { .type = S3C_IRQTYPE_EINT, }, /* EINT3 */
967         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT4to7 */
968         { .type = S3C_IRQTYPE_LEVEL, }, /* EINT8to23 */
969         { .type = S3C_IRQTYPE_LEVEL, }, /* CAM */
970         { .type = S3C_IRQTYPE_EDGE, }, /* nBATT_FLT */
971         { .type = S3C_IRQTYPE_EDGE, }, /* TICK */
972         { .type = S3C_IRQTYPE_LEVEL, }, /* WDT/AC97 */
973         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER0 */
974         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER1 */
975         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER2 */
976         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER3 */
977         { .type = S3C_IRQTYPE_EDGE, }, /* TIMER4 */
978         { .type = S3C_IRQTYPE_LEVEL, }, /* UART2 */
979         { .type = S3C_IRQTYPE_LEVEL, }, /* LCD */
980         { .type = S3C_IRQTYPE_LEVEL, }, /* DMA */
981         { .type = S3C_IRQTYPE_LEVEL, }, /* UART3 */
982         { .type = S3C_IRQTYPE_EDGE, }, /* CFON */
983         { .type = S3C_IRQTYPE_EDGE, }, /* SDI1 */
984         { .type = S3C_IRQTYPE_EDGE, }, /* SDI0 */
985         { .type = S3C_IRQTYPE_EDGE, }, /* SPI0 */
986         { .type = S3C_IRQTYPE_LEVEL, }, /* UART1 */
987         { .type = S3C_IRQTYPE_EDGE, }, /* NAND */
988         { .type = S3C_IRQTYPE_EDGE, }, /* USBD */
989         { .type = S3C_IRQTYPE_EDGE, }, /* USBH */
990         { .type = S3C_IRQTYPE_EDGE, }, /* IIC */
991         { .type = S3C_IRQTYPE_LEVEL, }, /* UART0 */
992         { .type = S3C_IRQTYPE_EDGE, }, /* SPI1 */
993         { .type = S3C_IRQTYPE_EDGE, }, /* RTC */
994         { .type = S3C_IRQTYPE_LEVEL, }, /* ADCPARENT */
995 };
996
997
998 static struct s3c_irq_data init_s3c2443subint[32] = {
999         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-RX */
1000         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-TX */
1001         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 28 }, /* UART0-ERR */
1002         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-RX */
1003         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-TX */
1004         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 23 }, /* UART1-ERR */
1005         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-RX */
1006         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-TX */
1007         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 15 }, /* UART2-ERR */
1008         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* TC */
1009         { .type = S3C_IRQTYPE_EDGE, .parent_irq = 31 }, /* ADC */
1010         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* CAM_C */
1011         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 6 }, /* CAM_P */
1012         { .type = S3C_IRQTYPE_NONE }, /* reserved */
1013         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD1 */
1014         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD2 */
1015         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD3 */
1016         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 16 }, /* LCD4 */
1017         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA0 */
1018         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA1 */
1019         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA2 */
1020         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA3 */
1021         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA4 */
1022         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 17 }, /* DMA5 */
1023         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-RX */
1024         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-TX */
1025         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 18 }, /* UART3-ERR */
1026         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* WDT */
1027         { .type = S3C_IRQTYPE_LEVEL, .parent_irq = 9 }, /* AC97 */
1028 };
1029
1030 void __init s3c2443_init_irq(void)
1031 {
1032         struct s3c_irq_intc *main_intc;
1033
1034         pr_info("S3C2443: IRQ Support\n");
1035
1036 #ifdef CONFIG_FIQ
1037         init_FIQ(FIQ_START);
1038 #endif
1039
1040         main_intc = s3c24xx_init_intc(NULL, &init_s3c2443base[0], NULL, 0x4a000000);
1041         if (IS_ERR(main_intc)) {
1042                 pr_err("irq: could not create main interrupt controller\n");
1043                 return;
1044         }
1045
1046         s3c24xx_init_intc(NULL, &init_eint[0], main_intc, 0x560000a4);
1047         s3c24xx_init_intc(NULL, &init_s3c2443subint[0], main_intc, 0x4a000018);
1048 }
1049 #endif