2 * linux/arch/arm/common/gic.c
4 * Copyright (C) 2002 ARM Limited, All Rights Reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * Interrupt architecture for the GIC:
12 * o There is one Interrupt Distributor, which receives interrupts
13 * from system devices and sends them to the Interrupt Controllers.
15 * o There is one CPU Interface per CPU, which sends interrupts sent
16 * by the Distributor, and interrupts generated locally, to the
19 * Note that IRQs 0-31 are special - they are local to each CPU.
20 * As such, the enable set/clear, pending set/clear and active bit
21 * registers are banked per-cpu for these sources.
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/list.h>
26 #include <linux/smp.h>
30 #include <asm/mach/irq.h>
31 #include <asm/hardware/gic.h>
33 static void __iomem
*gic_dist_base
;
34 static void __iomem
*gic_cpu_base
;
37 * Routines to acknowledge, disable and enable interrupts
39 * Linux assumes that when we're done with an interrupt we need to
40 * unmask it, in the same way we need to unmask an interrupt when
43 * The GIC has a seperate notion of "end of interrupt" to re-enable
44 * an interrupt after handling, in order to support hardware
47 * We can make the GIC behave in the way that Linux expects by making
48 * our "acknowledge" routine disable the interrupt, then mark it as
51 static void gic_ack_irq(unsigned int irq
)
53 u32 mask
= 1 << (irq
% 32);
54 writel(mask
, gic_dist_base
+ GIC_DIST_ENABLE_CLEAR
+ (irq
/ 32) * 4);
55 writel(irq
, gic_cpu_base
+ GIC_CPU_EOI
);
58 static void gic_mask_irq(unsigned int irq
)
60 u32 mask
= 1 << (irq
% 32);
61 writel(mask
, gic_dist_base
+ GIC_DIST_ENABLE_CLEAR
+ (irq
/ 32) * 4);
64 static void gic_unmask_irq(unsigned int irq
)
66 u32 mask
= 1 << (irq
% 32);
67 writel(mask
, gic_dist_base
+ GIC_DIST_ENABLE_SET
+ (irq
/ 32) * 4);
70 static void gic_set_cpu(struct irqdesc
*desc
, unsigned int irq
, unsigned int cpu
)
72 void __iomem
*reg
= gic_dist_base
+ GIC_DIST_TARGET
+ (irq
& ~3);
73 unsigned int shift
= (irq
% 4) * 8;
76 val
= readl(reg
) & ~(0xff << shift
);
77 val
|= 1 << (cpu
+ shift
);
81 static struct irqchip gic_chip
= {
84 .unmask
= gic_unmask_irq
,
86 .set_cpu
= gic_set_cpu
,
90 void __init
gic_dist_init(void __iomem
*base
)
92 unsigned int max_irq
, i
;
93 u32 cpumask
= 1 << smp_processor_id();
95 cpumask
|= cpumask
<< 8;
96 cpumask
|= cpumask
<< 16;
100 writel(0, base
+ GIC_DIST_CTRL
);
103 * Find out how many interrupts are supported.
105 max_irq
= readl(base
+ GIC_DIST_CTR
) & 0x1f;
106 max_irq
= (max_irq
+ 1) * 32;
109 * The GIC only supports up to 1020 interrupt sources.
110 * Limit this to either the architected maximum, or the
113 if (max_irq
> max(1020, NR_IRQS
))
114 max_irq
= max(1020, NR_IRQS
);
117 * Set all global interrupts to be level triggered, active low.
119 for (i
= 32; i
< max_irq
; i
+= 16)
120 writel(0, base
+ GIC_DIST_CONFIG
+ i
* 4 / 16);
123 * Set all global interrupts to this CPU only.
125 for (i
= 32; i
< max_irq
; i
+= 4)
126 writel(cpumask
, base
+ GIC_DIST_TARGET
+ i
* 4 / 4);
129 * Set priority on all interrupts.
131 for (i
= 0; i
< max_irq
; i
+= 4)
132 writel(0xa0a0a0a0, base
+ GIC_DIST_PRI
+ i
* 4 / 4);
135 * Disable all interrupts.
137 for (i
= 0; i
< max_irq
; i
+= 32)
138 writel(0xffffffff, base
+ GIC_DIST_ENABLE_CLEAR
+ i
* 4 / 32);
141 * Setup the Linux IRQ subsystem.
143 for (i
= 29; i
< max_irq
; i
++) {
144 set_irq_chip(i
, &gic_chip
);
145 set_irq_handler(i
, do_level_IRQ
);
146 set_irq_flags(i
, IRQF_VALID
| IRQF_PROBE
);
149 writel(1, base
+ GIC_DIST_CTRL
);
152 void __cpuinit
gic_cpu_init(void __iomem
*base
)
155 writel(0xf0, base
+ GIC_CPU_PRIMASK
);
156 writel(1, base
+ GIC_CPU_CTRL
);
160 void gic_raise_softirq(cpumask_t cpumask
, unsigned int irq
)
162 unsigned long map
= *cpus_addr(cpumask
);
164 writel(map
<< 16 | irq
, gic_dist_base
+ GIC_DIST_SOFTINT
);