2 * arch/mips/emma2rh/markeins/irq.c
3 * This file defines the irq handler for EMMA2RH.
5 * Copyright (C) NEC Electronics Corporation 2004-2006
7 * This file is based on the arch/mips/ddb5xxx/ddb5477/irq.c
9 * Copyright 2001 MontaVista Software Inc.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/types.h>
29 #include <linux/ptrace.h>
30 #include <linux/delay.h>
32 #include <asm/irq_cpu.h>
33 #include <asm/system.h>
34 #include <asm/mipsregs.h>
35 #include <asm/debug.h>
36 #include <asm/addrspace.h>
37 #include <asm/bootinfo.h>
39 #include <asm/emma/emma2rh.h>
41 /* number of total irqs supported by EMMA2RH */
42 #define NUM_EMMA2RH_IRQ 96
47 * 0-7: 8 CPU interrupts
48 * 0 - software interrupt 0
49 * 1 - software interrupt 1
50 * 2 - most Vrc5477 interrupts are routed to this pin
51 * 3 - (optional) some other interrupts routed to this pin for debugg
55 * 7 - cpu timer (used by default)
59 void ll_emma2rh_irq_enable(int emma2rh_irq)
65 reg_index = EMMA2RH_BHIF_INT_EN_0 +
66 (EMMA2RH_BHIF_INT_EN_1 - EMMA2RH_BHIF_INT_EN_0) *
68 reg_value = emma2rh_in32(reg_index);
69 reg_bitmask = 0x1 << (emma2rh_irq % 32);
70 db_assert((reg_value & reg_bitmask) == 0);
71 emma2rh_out32(reg_index, reg_value | reg_bitmask);
74 void ll_emma2rh_irq_disable(int emma2rh_irq)
80 reg_index = EMMA2RH_BHIF_INT_EN_0 +
81 (EMMA2RH_BHIF_INT_EN_1 - EMMA2RH_BHIF_INT_EN_0) *
83 reg_value = emma2rh_in32(reg_index);
84 reg_bitmask = 0x1 << (emma2rh_irq % 32);
85 db_assert((reg_value & reg_bitmask) != 0);
86 emma2rh_out32(reg_index, reg_value & ~reg_bitmask);
89 static void emma2rh_irq_enable(unsigned int irq)
91 ll_emma2rh_irq_enable(irq - EMMA2RH_IRQ_BASE);
94 static void emma2rh_irq_disable(unsigned int irq)
96 ll_emma2rh_irq_disable(irq - EMMA2RH_IRQ_BASE);
99 struct irq_chip emma2rh_irq_controller = {
100 .name = "emma2rh_irq",
101 .ack = emma2rh_irq_disable,
102 .mask = emma2rh_irq_disable,
103 .mask_ack = emma2rh_irq_disable,
104 .unmask = emma2rh_irq_enable,
107 void emma2rh_irq_init(void)
111 for (i = 0; i < NUM_EMMA2RH_IRQ; i++)
112 set_irq_chip_and_handler(EMMA2RH_IRQ_BASE + i,
113 &emma2rh_irq_controller,
117 void ll_emma2rh_sw_irq_enable(int irq)
122 db_assert(irq < NUM_EMMA2RH_IRQ_SW);
124 reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
126 emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
129 void ll_emma2rh_sw_irq_disable(int irq)
136 reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
138 emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
141 static void emma2rh_sw_irq_enable(unsigned int irq)
143 ll_emma2rh_sw_irq_enable(irq - EMMA2RH_SW_IRQ_BASE);
146 static void emma2rh_sw_irq_disable(unsigned int irq)
148 ll_emma2rh_sw_irq_disable(irq - EMMA2RH_SW_IRQ_BASE);
151 struct irq_chip emma2rh_sw_irq_controller = {
152 .name = "emma2rh_sw_irq",
153 .ack = emma2rh_sw_irq_disable,
154 .mask = emma2rh_sw_irq_disable,
155 .mask_ack = emma2rh_sw_irq_disable,
156 .unmask = emma2rh_sw_irq_enable,
159 void emma2rh_sw_irq_init(void)
163 for (i = 0; i < NUM_EMMA2RH_IRQ_SW; i++)
164 set_irq_chip_and_handler(EMMA2RH_SW_IRQ_BASE + i,
165 &emma2rh_sw_irq_controller,
169 void ll_emma2rh_gpio_irq_enable(int irq)
174 db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
176 reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
178 emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
181 void ll_emma2rh_gpio_irq_disable(int irq)
186 db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
188 reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
190 emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
193 static void emma2rh_gpio_irq_enable(unsigned int irq)
195 ll_emma2rh_gpio_irq_enable(irq - EMMA2RH_GPIO_IRQ_BASE);
198 static void emma2rh_gpio_irq_disable(unsigned int irq)
200 ll_emma2rh_gpio_irq_disable(irq - EMMA2RH_GPIO_IRQ_BASE);
203 static void emma2rh_gpio_irq_ack(unsigned int irq)
205 irq -= EMMA2RH_GPIO_IRQ_BASE;
206 emma2rh_out32(EMMA2RH_GPIO_INT_ST, ~(1 << irq));
207 ll_emma2rh_gpio_irq_disable(irq);
210 static void emma2rh_gpio_irq_end(unsigned int irq)
212 if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
213 ll_emma2rh_gpio_irq_enable(irq - EMMA2RH_GPIO_IRQ_BASE);
216 struct irq_chip emma2rh_gpio_irq_controller = {
217 .name = "emma2rh_gpio_irq",
218 .ack = emma2rh_gpio_irq_ack,
219 .mask = emma2rh_gpio_irq_disable,
220 .mask_ack = emma2rh_gpio_irq_ack,
221 .unmask = emma2rh_gpio_irq_enable,
222 .end = emma2rh_gpio_irq_end,
225 void emma2rh_gpio_irq_init(void)
229 for (i = 0; i < NUM_EMMA2RH_IRQ_GPIO; i++)
230 set_irq_chip(EMMA2RH_GPIO_IRQ_BASE + i,
231 &emma2rh_gpio_irq_controller);
234 static struct irqaction irq_cascade = {
235 .handler = no_action,
237 .mask = CPU_MASK_NONE,
244 * the first level int-handler will jump here if it is a emma2rh irq
246 void emma2rh_irq_dispatch(void)
252 intStatus = emma2rh_in32(EMMA2RH_BHIF_INT_ST_0) &
253 emma2rh_in32(EMMA2RH_BHIF_INT_EN_0);
255 #ifdef EMMA2RH_SW_CASCADE
257 (1 << ((EMMA2RH_SW_CASCADE - EMMA2RH_IRQ_INT0) & (32 - 1)))) {
259 swIntStatus = emma2rh_in32(EMMA2RH_BHIF_SW_INT)
260 & emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
261 for (i = 0, bitmask = 1; i < 32; i++, bitmask <<= 1) {
262 if (swIntStatus & bitmask) {
263 do_IRQ(EMMA2RH_SW_IRQ_BASE + i);
270 for (i = 0, bitmask = 1; i < 32; i++, bitmask <<= 1) {
271 if (intStatus & bitmask) {
272 do_IRQ(EMMA2RH_IRQ_BASE + i);
277 intStatus = emma2rh_in32(EMMA2RH_BHIF_INT_ST_1) &
278 emma2rh_in32(EMMA2RH_BHIF_INT_EN_1);
280 #ifdef EMMA2RH_GPIO_CASCADE
282 (1 << ((EMMA2RH_GPIO_CASCADE - EMMA2RH_IRQ_INT0) & (32 - 1)))) {
284 gpioIntStatus = emma2rh_in32(EMMA2RH_GPIO_INT_ST)
285 & emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
286 for (i = 0, bitmask = 1; i < 32; i++, bitmask <<= 1) {
287 if (gpioIntStatus & bitmask) {
288 do_IRQ(EMMA2RH_GPIO_IRQ_BASE + i);
295 for (i = 32, bitmask = 1; i < 64; i++, bitmask <<= 1) {
296 if (intStatus & bitmask) {
297 do_IRQ(EMMA2RH_IRQ_BASE + i);
302 intStatus = emma2rh_in32(EMMA2RH_BHIF_INT_ST_2) &
303 emma2rh_in32(EMMA2RH_BHIF_INT_EN_2);
305 for (i = 64, bitmask = 1; i < 96; i++, bitmask <<= 1) {
306 if (intStatus & bitmask) {
307 do_IRQ(EMMA2RH_IRQ_BASE + i);
313 void __init arch_init_irq(void)
317 db_run(printk("markeins_irq_setup invoked.\n"));
319 /* by default, interrupts are disabled. */
320 emma2rh_out32(EMMA2RH_BHIF_INT_EN_0, 0);
321 emma2rh_out32(EMMA2RH_BHIF_INT_EN_1, 0);
322 emma2rh_out32(EMMA2RH_BHIF_INT_EN_2, 0);
323 emma2rh_out32(EMMA2RH_BHIF_INT1_EN_0, 0);
324 emma2rh_out32(EMMA2RH_BHIF_INT1_EN_1, 0);
325 emma2rh_out32(EMMA2RH_BHIF_INT1_EN_2, 0);
326 emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, 0);
328 clear_c0_status(0xff00);
329 set_c0_status(0x0400);
331 #define GPIO_PCI (0xf<<15)
332 /* setup GPIO interrupt for PCI interface */
333 /* direction input */
334 reg = emma2rh_in32(EMMA2RH_GPIO_DIR);
335 emma2rh_out32(EMMA2RH_GPIO_DIR, reg & ~GPIO_PCI);
336 /* disable interrupt */
337 reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
338 emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg & ~GPIO_PCI);
340 reg = emma2rh_in32(EMMA2RH_GPIO_INT_MODE);
341 emma2rh_out32(EMMA2RH_GPIO_INT_MODE, reg | GPIO_PCI);
342 reg = emma2rh_in32(EMMA2RH_GPIO_INT_CND_A);
343 emma2rh_out32(EMMA2RH_GPIO_INT_CND_A, reg & (~GPIO_PCI));
344 /* interrupt clear */
345 emma2rh_out32(EMMA2RH_GPIO_INT_ST, ~GPIO_PCI);
347 /* init all controllers */
349 emma2rh_sw_irq_init();
350 emma2rh_gpio_irq_init();
353 /* setup cascade interrupts */
354 setup_irq(EMMA2RH_IRQ_BASE + EMMA2RH_SW_CASCADE, &irq_cascade);
355 setup_irq(EMMA2RH_IRQ_BASE + EMMA2RH_GPIO_CASCADE, &irq_cascade);
356 setup_irq(CPU_IRQ_BASE + CPU_EMMA2RH_CASCADE, &irq_cascade);
359 asmlinkage void plat_irq_dispatch(void)
361 unsigned int pending = read_c0_status() & read_c0_cause() & ST0_IM;
363 if (pending & STATUSF_IP7)
364 do_IRQ(CPU_IRQ_BASE + 7);
365 else if (pending & STATUSF_IP2)
366 emma2rh_irq_dispatch();
367 else if (pending & STATUSF_IP1)
368 do_IRQ(CPU_IRQ_BASE + 1);
369 else if (pending & STATUSF_IP0)
370 do_IRQ(CPU_IRQ_BASE + 0);
372 spurious_interrupt();