xref: /openbmc/linux/arch/alpha/kernel/irq.c (revision 4800cd83)
1 /*
2  *	linux/arch/alpha/kernel/irq.c
3  *
4  *	Copyright (C) 1995 Linus Torvalds
5  *
6  * This file contains the code used by various IRQ handling routines:
7  * asking for different IRQ's should be done through these routines
8  * instead of just grabbing them. Thus setups with different IRQ numbers
9  * shouldn't result in any weird surprises, and installing new handlers
10  * should be easier.
11  */
12 
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/kernel_stat.h>
17 #include <linux/signal.h>
18 #include <linux/sched.h>
19 #include <linux/ptrace.h>
20 #include <linux/interrupt.h>
21 #include <linux/random.h>
22 #include <linux/init.h>
23 #include <linux/irq.h>
24 #include <linux/proc_fs.h>
25 #include <linux/seq_file.h>
26 #include <linux/profile.h>
27 #include <linux/bitops.h>
28 
29 #include <asm/system.h>
30 #include <asm/io.h>
31 #include <asm/uaccess.h>
32 
33 volatile unsigned long irq_err_count;
34 DEFINE_PER_CPU(unsigned long, irq_pmi_count);
35 
36 void ack_bad_irq(unsigned int irq)
37 {
38 	irq_err_count++;
39 	printk(KERN_CRIT "Unexpected IRQ trap at vector %u\n", irq);
40 }
41 
42 #ifdef CONFIG_SMP
43 static char irq_user_affinity[NR_IRQS];
44 
45 int irq_select_affinity(unsigned int irq)
46 {
47 	struct irq_data *data = irq_get_irq_data(irq);
48 	struct irq_chip *chip;
49 	static int last_cpu;
50 	int cpu = last_cpu + 1;
51 
52 	if (!data)
53 		return 1;
54 	chip = irq_data_get_irq_chip(data);
55 
56 	if (!chip->irq_set_affinity || irq_user_affinity[irq])
57 		return 1;
58 
59 	while (!cpu_possible(cpu) ||
60 	       !cpumask_test_cpu(cpu, irq_default_affinity))
61 		cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
62 	last_cpu = cpu;
63 
64 	cpumask_copy(data->affinity, cpumask_of(cpu));
65 	chip->irq_set_affinity(data, cpumask_of(cpu), false);
66 	return 0;
67 }
68 #endif /* CONFIG_SMP */
69 
70 int
71 show_interrupts(struct seq_file *p, void *v)
72 {
73 	int j;
74 	int irq = *(loff_t *) v;
75 	struct irqaction * action;
76 	struct irq_desc *desc;
77 	unsigned long flags;
78 
79 #ifdef CONFIG_SMP
80 	if (irq == 0) {
81 		seq_puts(p, "           ");
82 		for_each_online_cpu(j)
83 			seq_printf(p, "CPU%d       ", j);
84 		seq_putc(p, '\n');
85 	}
86 #endif
87 
88 	if (irq < ACTUAL_NR_IRQS) {
89 		desc = irq_to_desc(irq);
90 
91 		if (!desc)
92 			return 0;
93 
94 		raw_spin_lock_irqsave(&desc->lock, flags);
95 		action = desc->action;
96 		if (!action)
97 			goto unlock;
98 		seq_printf(p, "%3d: ", irq);
99 #ifndef CONFIG_SMP
100 		seq_printf(p, "%10u ", kstat_irqs(irq));
101 #else
102 		for_each_online_cpu(j)
103 			seq_printf(p, "%10u ", kstat_irqs_cpu(irq, j));
104 #endif
105 		seq_printf(p, " %14s", get_irq_desc_chip(desc)->name);
106 		seq_printf(p, "  %c%s",
107 			(action->flags & IRQF_DISABLED)?'+':' ',
108 			action->name);
109 
110 		for (action=action->next; action; action = action->next) {
111 			seq_printf(p, ", %c%s",
112 				  (action->flags & IRQF_DISABLED)?'+':' ',
113 				   action->name);
114 		}
115 
116 		seq_putc(p, '\n');
117 unlock:
118 		raw_spin_unlock_irqrestore(&desc->lock, flags);
119 	} else if (irq == ACTUAL_NR_IRQS) {
120 #ifdef CONFIG_SMP
121 		seq_puts(p, "IPI: ");
122 		for_each_online_cpu(j)
123 			seq_printf(p, "%10lu ", cpu_data[j].ipi_count);
124 		seq_putc(p, '\n');
125 #endif
126 		seq_puts(p, "PMI: ");
127 		for_each_online_cpu(j)
128 			seq_printf(p, "%10lu ", per_cpu(irq_pmi_count, j));
129 		seq_puts(p, "          Performance Monitoring\n");
130 		seq_printf(p, "ERR: %10lu\n", irq_err_count);
131 	}
132 	return 0;
133 }
134 
135 /*
136  * handle_irq handles all normal device IRQ's (the special
137  * SMP cross-CPU interrupts have their own specific
138  * handlers).
139  */
140 
141 #define MAX_ILLEGAL_IRQS 16
142 
143 void
144 handle_irq(int irq)
145 {
146 	/*
147 	 * We ack quickly, we don't want the irq controller
148 	 * thinking we're snobs just because some other CPU has
149 	 * disabled global interrupts (we have already done the
150 	 * INT_ACK cycles, it's too late to try to pretend to the
151 	 * controller that we aren't taking the interrupt).
152 	 *
153 	 * 0 return value means that this irq is already being
154 	 * handled by some other CPU. (or is disabled)
155 	 */
156 	static unsigned int illegal_count=0;
157 	struct irq_desc *desc = irq_to_desc(irq);
158 
159 	if (!desc || ((unsigned) irq > ACTUAL_NR_IRQS &&
160 	    illegal_count < MAX_ILLEGAL_IRQS)) {
161 		irq_err_count++;
162 		illegal_count++;
163 		printk(KERN_CRIT "device_interrupt: invalid interrupt %d\n",
164 		       irq);
165 		return;
166 	}
167 
168 	/*
169 	 * From here we must proceed with IPL_MAX. Note that we do not
170 	 * explicitly enable interrupts afterwards - some MILO PALcode
171 	 * (namely LX164 one) seems to have severe problems with RTI
172 	 * at IPL 0.
173 	 */
174 	local_irq_disable();
175 	irq_enter();
176 	generic_handle_irq_desc(irq, desc);
177 	irq_exit();
178 }
179