2 * Derived from arch/i386/kernel/irq.c
3 * Copyright (C) 1992 Linus Torvalds
4 * Adapted from arch/i386 by Gary Thomas
5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6 * Updated and modified by Cort Dougan <cort@fsmlabs.com>
7 * Copyright (C) 1996-2001 Cort Dougan
8 * Adapted for Power Macintosh by Paul Mackerras
9 * Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
10 * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
17 * This file contains the code used by various IRQ handling routines:
18 * asking for different IRQ's should be done through these routines
19 * instead of just grabbing them. Thus setups with different IRQ numbers
20 * shouldn't result in any weird surprises, and installing new handlers
23 * The MPC8xx has an interrupt mask in the SIU. If a bit is set, the
24 * interrupt is _enabled_. As expected, IRQ0 is bit 0 in the 32-bit
25 * mask register (of which only 16 are defined), hence the weird shifting
26 * and complement of the cached_irq_mask. I want to be able to stuff
27 * this right into the SIU SMASK register.
28 * Many of the prep/chrp functions are conditional compiled on CONFIG_8xx
29 * to reduce code space and undefined function references.
32 #include <linux/module.h>
33 #include <linux/threads.h>
34 #include <linux/kernel_stat.h>
35 #include <linux/signal.h>
36 #include <linux/sched.h>
37 #include <linux/ptrace.h>
38 #include <linux/ioport.h>
39 #include <linux/interrupt.h>
40 #include <linux/timex.h>
41 #include <linux/config.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/delay.h>
45 #include <linux/irq.h>
46 #include <linux/seq_file.h>
47 #include <linux/cpumask.h>
48 #include <linux/profile.h>
49 #include <linux/bitops.h>
51 #include <asm/uaccess.h>
52 #include <asm/system.h>
54 #include <asm/pgtable.h>
56 #include <asm/cache.h>
58 #include <asm/ptrace.h>
59 #include <asm/machdep.h>
60 #ifdef CONFIG_PPC_ISERIES
64 int __irq_offset_value
;
66 EXPORT_SYMBOL(__irq_offset_value
);
69 static int ppc_spurious_interrupts
;
72 #define NR_MASK_WORDS ((NR_IRQS + 31) / 32)
74 unsigned long ppc_cached_irq_mask
[NR_MASK_WORDS
];
75 atomic_t ppc_n_lost_interrupts
;
78 extern int tau_initialized
;
79 extern int tau_interrupts(int);
82 #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_MERGE)
83 extern atomic_t ipi_recv
;
84 extern atomic_t ipi_sent
;
86 #endif /* CONFIG_PPC32 */
89 EXPORT_SYMBOL(irq_desc
);
91 int distribute_irqs
= 1;
92 u64 ppc64_interrupt_controller
;
93 #endif /* CONFIG_PPC64 */
95 int show_interrupts(struct seq_file
*p
, void *v
)
97 int i
= *(loff_t
*)v
, j
;
98 struct irqaction
*action
;
104 for_each_online_cpu(j
)
105 seq_printf(p
, "CPU%d ", j
);
110 desc
= get_irq_desc(i
);
111 spin_lock_irqsave(&desc
->lock
, flags
);
112 action
= desc
->action
;
113 if (!action
|| !action
->handler
)
115 seq_printf(p
, "%3d: ", i
);
117 for_each_online_cpu(j
)
118 seq_printf(p
, "%10u ", kstat_cpu(j
).irqs
[i
]);
120 seq_printf(p
, "%10u ", kstat_irqs(i
));
121 #endif /* CONFIG_SMP */
123 seq_printf(p
, " %s ", desc
->handler
->typename
);
125 seq_puts(p
, " None ");
126 seq_printf(p
, "%s", (desc
->status
& IRQ_LEVEL
) ? "Level " : "Edge ");
127 seq_printf(p
, " %s", action
->name
);
128 for (action
= action
->next
; action
; action
= action
->next
)
129 seq_printf(p
, ", %s", action
->name
);
132 spin_unlock_irqrestore(&desc
->lock
, flags
);
133 } else if (i
== NR_IRQS
) {
135 #ifdef CONFIG_TAU_INT
136 if (tau_initialized
){
137 seq_puts(p
, "TAU: ");
138 for (j
= 0; j
< NR_CPUS
; j
++)
140 seq_printf(p
, "%10u ", tau_interrupts(j
));
141 seq_puts(p
, " PowerPC Thermal Assist (cpu temp)\n");
144 #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_MERGE)
145 /* should this be per processor send/receive? */
146 seq_printf(p
, "IPI (recv/sent): %10u/%u\n",
147 atomic_read(&ipi_recv
), atomic_read(&ipi_sent
));
149 #endif /* CONFIG_PPC32 */
150 seq_printf(p
, "BAD: %10u\n", ppc_spurious_interrupts
);
155 #ifdef CONFIG_HOTPLUG_CPU
156 void fixup_irqs(cpumask_t map
)
164 if (irq_desc
[irq
].status
& IRQ_PER_CPU
)
167 cpus_and(mask
, irq_affinity
[irq
], map
);
168 if (any_online_cpu(mask
) == NR_CPUS
) {
169 printk("Breaking affinity for irq %i\n", irq
);
172 if (irq_desc
[irq
].handler
->set_affinity
)
173 irq_desc
[irq
].handler
->set_affinity(irq
, mask
);
174 else if (irq_desc
[irq
].action
&& !(warned
++))
175 printk("Cannot set affinity for irq %i\n", irq
);
184 void do_IRQ(struct pt_regs
*regs
)
187 #ifdef CONFIG_IRQSTACKS
188 struct thread_info
*curtp
, *irqtp
;
193 #ifdef CONFIG_DEBUG_STACKOVERFLOW
194 /* Debugging check for stack overflow: is there less than 2KB free? */
198 sp
= __get_SP() & (THREAD_SIZE
-1);
200 if (unlikely(sp
< (sizeof(struct thread_info
) + 2048))) {
201 printk("do_IRQ: stack overflow: %ld\n",
202 sp
- sizeof(struct thread_info
));
209 * Every platform is required to implement ppc_md.get_irq.
210 * This function will either return an irq number or -1 to
211 * indicate there are no more pending.
212 * The value -2 is for buggy hardware and means that this IRQ
213 * has already been handled. -- Tom
215 irq
= ppc_md
.get_irq(regs
);
218 #ifdef CONFIG_IRQSTACKS
219 /* Switch to the irq stack to handle this */
220 curtp
= current_thread_info();
221 irqtp
= hardirq_ctx
[smp_processor_id()];
222 if (curtp
!= irqtp
) {
223 irqtp
->task
= curtp
->task
;
225 call___do_IRQ(irq
, regs
, irqtp
);
228 set_bits(irqtp
->flags
, &curtp
->flags
);
232 } else if (irq
!= -2)
233 /* That's not SMP safe ... but who cares ? */
234 ppc_spurious_interrupts
++;
238 #ifdef CONFIG_PPC_ISERIES
239 if (get_lppaca()->int_dword
.fields
.decr_int
) {
240 get_lppaca()->int_dword
.fields
.decr_int
= 0;
241 /* Signal a fake decrementer interrupt */
242 timer_interrupt(regs
);
247 void __init
init_IRQ(void)
266 * Virtual IRQ mapping code, used on systems with XICS interrupt controllers.
269 #define UNDEFINED_IRQ 0xffffffff
270 unsigned int virt_irq_to_real_map
[NR_IRQS
];
273 * Don't use virtual irqs 0, 1, 2 for devices.
274 * The pcnet32 driver considers interrupt numbers < 2 to be invalid,
275 * and 2 is the XICS IPI interrupt.
276 * We limit virtual irqs to 17 less than NR_IRQS so that when we
277 * offset them by 16 (to reserve the first 16 for ISA interrupts)
278 * we don't end up with an interrupt number >= NR_IRQS.
280 #define MIN_VIRT_IRQ 3
281 #define MAX_VIRT_IRQ (NR_IRQS - NUM_ISA_INTERRUPTS - 1)
282 #define NR_VIRT_IRQS (MAX_VIRT_IRQ - MIN_VIRT_IRQ + 1)
288 for (i
= 0; i
< NR_IRQS
; i
++)
289 virt_irq_to_real_map
[i
] = UNDEFINED_IRQ
;
292 /* Create a mapping for a real_irq if it doesn't already exist.
293 * Return the virtual irq as a convenience.
295 int virt_irq_create_mapping(unsigned int real_irq
)
297 unsigned int virq
, first_virq
;
300 if (ppc64_interrupt_controller
== IC_OPEN_PIC
)
301 return real_irq
; /* no mapping for openpic (for now) */
303 if (ppc64_interrupt_controller
== IC_CELL_PIC
)
304 return real_irq
; /* no mapping for iic either */
306 /* don't map interrupts < MIN_VIRT_IRQ */
307 if (real_irq
< MIN_VIRT_IRQ
) {
308 virt_irq_to_real_map
[real_irq
] = real_irq
;
312 /* map to a number between MIN_VIRT_IRQ and MAX_VIRT_IRQ */
314 if (virq
> MAX_VIRT_IRQ
)
315 virq
= (virq
% NR_VIRT_IRQS
) + MIN_VIRT_IRQ
;
317 /* search for this number or a free slot */
319 while (virt_irq_to_real_map
[virq
] != UNDEFINED_IRQ
) {
320 if (virt_irq_to_real_map
[virq
] == real_irq
)
322 if (++virq
> MAX_VIRT_IRQ
)
324 if (virq
== first_virq
)
325 goto nospace
; /* oops, no free slots */
328 virt_irq_to_real_map
[virq
] = real_irq
;
333 printk(KERN_CRIT
"Interrupt table is full\n");
334 printk(KERN_CRIT
"Increase NR_IRQS (currently %d) "
335 "in your kernel sources and rebuild.\n", NR_IRQS
);
342 * In most cases will get a hit on the very first slot checked in the
343 * virt_irq_to_real_map. Only when there are a large number of
344 * IRQs will this be expensive.
346 unsigned int real_irq_to_virt_slowpath(unsigned int real_irq
)
349 unsigned int first_virq
;
353 if (virq
> MAX_VIRT_IRQ
)
354 virq
= (virq
% NR_VIRT_IRQS
) + MIN_VIRT_IRQ
;
359 if (virt_irq_to_real_map
[virq
] == real_irq
)
364 if (virq
>= MAX_VIRT_IRQ
)
367 } while (first_virq
!= virq
);
373 #ifdef CONFIG_IRQSTACKS
374 struct thread_info
*softirq_ctx
[NR_CPUS
];
375 struct thread_info
*hardirq_ctx
[NR_CPUS
];
377 void irq_ctx_init(void)
379 struct thread_info
*tp
;
383 memset((void *)softirq_ctx
[i
], 0, THREAD_SIZE
);
386 tp
->preempt_count
= SOFTIRQ_OFFSET
;
388 memset((void *)hardirq_ctx
[i
], 0, THREAD_SIZE
);
391 tp
->preempt_count
= HARDIRQ_OFFSET
;
395 void do_softirq(void)
398 struct thread_info
*curtp
, *irqtp
;
403 local_irq_save(flags
);
405 if (local_softirq_pending()) {
406 curtp
= current_thread_info();
407 irqtp
= softirq_ctx
[smp_processor_id()];
408 irqtp
->task
= curtp
->task
;
409 call_do_softirq(irqtp
);
413 local_irq_restore(flags
);
415 EXPORT_SYMBOL(do_softirq
);
417 #endif /* CONFIG_IRQSTACKS */
419 static int __init
setup_noirqdistrib(char *str
)
425 __setup("noirqdistrib", setup_noirqdistrib
);
426 #endif /* CONFIG_PPC64 */