]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * ip27-irq.c: Highlevel interrupt handling for IP27 architecture. | |
3 | * | |
4 | * Copyright (C) 1999, 2000 Ralf Baechle (ralf@gnu.org) | |
5 | * Copyright (C) 1999, 2000 Silicon Graphics, Inc. | |
6 | * Copyright (C) 1999 - 2001 Kanoj Sarcar | |
7 | */ | |
8 | #include <linux/config.h> | |
9 | #include <linux/init.h> | |
10 | #include <linux/irq.h> | |
11 | #include <linux/errno.h> | |
12 | #include <linux/signal.h> | |
13 | #include <linux/sched.h> | |
14 | #include <linux/types.h> | |
15 | #include <linux/interrupt.h> | |
16 | #include <linux/ioport.h> | |
1da177e4 LT |
17 | #include <linux/timex.h> |
18 | #include <linux/slab.h> | |
19 | #include <linux/random.h> | |
20 | #include <linux/smp_lock.h> | |
21 | #include <linux/kernel_stat.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/bitops.h> | |
24 | ||
25 | #include <asm/bootinfo.h> | |
26 | #include <asm/io.h> | |
27 | #include <asm/mipsregs.h> | |
28 | #include <asm/system.h> | |
29 | ||
30 | #include <asm/ptrace.h> | |
31 | #include <asm/processor.h> | |
32 | #include <asm/pci/bridge.h> | |
33 | #include <asm/sn/addrs.h> | |
34 | #include <asm/sn/agent.h> | |
35 | #include <asm/sn/arch.h> | |
36 | #include <asm/sn/hub.h> | |
37 | #include <asm/sn/intr.h> | |
38 | ||
39 | #undef DEBUG_IRQ | |
40 | #ifdef DEBUG_IRQ | |
41 | #define DBG(x...) printk(x) | |
42 | #else | |
43 | #define DBG(x...) | |
44 | #endif | |
45 | ||
46 | /* | |
47 | * Linux has a controller-independent x86 interrupt architecture. | |
48 | * every controller has a 'controller-template', that is used | |
49 | * by the main code to do the right thing. Each driver-visible | |
50 | * interrupt source is transparently wired to the apropriate | |
51 | * controller. Thus drivers need not be aware of the | |
52 | * interrupt-controller. | |
53 | * | |
54 | * Various interrupt controllers we handle: 8259 PIC, SMP IO-APIC, | |
55 | * PIIX4's internal 8259 PIC and SGI's Visual Workstation Cobalt (IO-)APIC. | |
56 | * (IO-APICs assumed to be messaging to Pentium local-APICs) | |
57 | * | |
58 | * the code is designed to be easily extended with new/different | |
59 | * interrupt controllers, without having to do assembly magic. | |
60 | */ | |
61 | ||
62 | extern asmlinkage void ip27_irq(void); | |
63 | ||
64 | extern struct bridge_controller *irq_to_bridge[]; | |
65 | extern int irq_to_slot[]; | |
66 | ||
67 | /* | |
68 | * use these macros to get the encoded nasid and widget id | |
69 | * from the irq value | |
70 | */ | |
71 | #define IRQ_TO_BRIDGE(i) irq_to_bridge[(i)] | |
72 | #define SLOT_FROM_PCI_IRQ(i) irq_to_slot[i] | |
73 | ||
74 | static inline int alloc_level(int cpu, int irq) | |
75 | { | |
4f12bfe5 | 76 | struct hub_data *hub = hub_data(cpu_to_node(cpu)); |
1da177e4 | 77 | struct slice_data *si = cpu_data[cpu].data; |
4f12bfe5 | 78 | int level; |
1da177e4 | 79 | |
4f12bfe5 | 80 | level = find_first_zero_bit(hub->irq_alloc_mask, LEVELS_PER_SLICE); |
1da177e4 LT |
81 | if (level >= LEVELS_PER_SLICE) |
82 | panic("Cpu %d flooded with devices\n", cpu); | |
83 | ||
4f12bfe5 | 84 | __set_bit(level, hub->irq_alloc_mask); |
1da177e4 LT |
85 | si->level_to_irq[level] = irq; |
86 | ||
87 | return level; | |
88 | } | |
89 | ||
90 | static inline int find_level(cpuid_t *cpunum, int irq) | |
91 | { | |
92 | int cpu, i; | |
93 | ||
94 | for (cpu = 0; cpu <= NR_CPUS; cpu++) { | |
95 | struct slice_data *si = cpu_data[cpu].data; | |
96 | ||
97 | if (!cpu_online(cpu)) | |
98 | continue; | |
99 | ||
100 | for (i = BASE_PCI_IRQ; i < LEVELS_PER_SLICE; i++) | |
101 | if (si->level_to_irq[i] == irq) { | |
102 | *cpunum = cpu; | |
103 | ||
104 | return i; | |
105 | } | |
106 | } | |
107 | ||
108 | panic("Could not identify cpu/level for irq %d\n", irq); | |
109 | } | |
110 | ||
111 | /* | |
112 | * Find first bit set | |
113 | */ | |
114 | static int ms1bit(unsigned long x) | |
115 | { | |
116 | int b = 0, s; | |
117 | ||
118 | s = 16; if (x >> 16 == 0) s = 0; b += s; x >>= s; | |
119 | s = 8; if (x >> 8 == 0) s = 0; b += s; x >>= s; | |
120 | s = 4; if (x >> 4 == 0) s = 0; b += s; x >>= s; | |
121 | s = 2; if (x >> 2 == 0) s = 0; b += s; x >>= s; | |
122 | s = 1; if (x >> 1 == 0) s = 0; b += s; | |
123 | ||
124 | return b; | |
125 | } | |
126 | ||
127 | /* | |
128 | * This code is unnecessarily complex, because we do SA_INTERRUPT | |
129 | * intr enabling. Basically, once we grab the set of intrs we need | |
130 | * to service, we must mask _all_ these interrupts; firstly, to make | |
131 | * sure the same intr does not intr again, causing recursion that | |
132 | * can lead to stack overflow. Secondly, we can not just mask the | |
133 | * one intr we are do_IRQing, because the non-masked intrs in the | |
134 | * first set might intr again, causing multiple servicings of the | |
135 | * same intr. This effect is mostly seen for intercpu intrs. | |
136 | * Kanoj 05.13.00 | |
137 | */ | |
138 | ||
139 | void ip27_do_irq_mask0(struct pt_regs *regs) | |
140 | { | |
141 | int irq, swlevel; | |
142 | hubreg_t pend0, mask0; | |
143 | cpuid_t cpu = smp_processor_id(); | |
144 | int pi_int_mask0 = | |
145 | (cputoslice(cpu) == 0) ? PI_INT_MASK0_A : PI_INT_MASK0_B; | |
146 | ||
147 | /* copied from Irix intpend0() */ | |
148 | pend0 = LOCAL_HUB_L(PI_INT_PEND0); | |
149 | mask0 = LOCAL_HUB_L(pi_int_mask0); | |
150 | ||
151 | pend0 &= mask0; /* Pick intrs we should look at */ | |
152 | if (!pend0) | |
153 | return; | |
154 | ||
155 | swlevel = ms1bit(pend0); | |
156 | #ifdef CONFIG_SMP | |
157 | if (pend0 & (1UL << CPU_RESCHED_A_IRQ)) { | |
158 | LOCAL_HUB_CLR_INTR(CPU_RESCHED_A_IRQ); | |
159 | } else if (pend0 & (1UL << CPU_RESCHED_B_IRQ)) { | |
160 | LOCAL_HUB_CLR_INTR(CPU_RESCHED_B_IRQ); | |
161 | } else if (pend0 & (1UL << CPU_CALL_A_IRQ)) { | |
162 | LOCAL_HUB_CLR_INTR(CPU_CALL_A_IRQ); | |
163 | smp_call_function_interrupt(); | |
164 | } else if (pend0 & (1UL << CPU_CALL_B_IRQ)) { | |
165 | LOCAL_HUB_CLR_INTR(CPU_CALL_B_IRQ); | |
166 | smp_call_function_interrupt(); | |
167 | } else | |
168 | #endif | |
169 | { | |
170 | /* "map" swlevel to irq */ | |
171 | struct slice_data *si = cpu_data[cpu].data; | |
172 | ||
173 | irq = si->level_to_irq[swlevel]; | |
174 | do_IRQ(irq, regs); | |
175 | } | |
176 | ||
177 | LOCAL_HUB_L(PI_INT_PEND0); | |
178 | } | |
179 | ||
180 | void ip27_do_irq_mask1(struct pt_regs *regs) | |
181 | { | |
182 | int irq, swlevel; | |
183 | hubreg_t pend1, mask1; | |
184 | cpuid_t cpu = smp_processor_id(); | |
185 | int pi_int_mask1 = (cputoslice(cpu) == 0) ? PI_INT_MASK1_A : PI_INT_MASK1_B; | |
186 | struct slice_data *si = cpu_data[cpu].data; | |
187 | ||
188 | /* copied from Irix intpend0() */ | |
189 | pend1 = LOCAL_HUB_L(PI_INT_PEND1); | |
190 | mask1 = LOCAL_HUB_L(pi_int_mask1); | |
191 | ||
192 | pend1 &= mask1; /* Pick intrs we should look at */ | |
193 | if (!pend1) | |
194 | return; | |
195 | ||
196 | swlevel = ms1bit(pend1); | |
197 | /* "map" swlevel to irq */ | |
198 | irq = si->level_to_irq[swlevel]; | |
199 | LOCAL_HUB_CLR_INTR(swlevel); | |
200 | do_IRQ(irq, regs); | |
201 | ||
202 | LOCAL_HUB_L(PI_INT_PEND1); | |
203 | } | |
204 | ||
205 | void ip27_prof_timer(struct pt_regs *regs) | |
206 | { | |
207 | panic("CPU %d got a profiling interrupt", smp_processor_id()); | |
208 | } | |
209 | ||
210 | void ip27_hub_error(struct pt_regs *regs) | |
211 | { | |
212 | panic("CPU %d got a hub error interrupt", smp_processor_id()); | |
213 | } | |
214 | ||
215 | static int intr_connect_level(int cpu, int bit) | |
216 | { | |
217 | nasid_t nasid = COMPACT_TO_NASID_NODEID(cpu_to_node(cpu)); | |
218 | struct slice_data *si = cpu_data[cpu].data; | |
4f12bfe5 | 219 | unsigned long flags; |
1da177e4 | 220 | |
4f12bfe5 | 221 | set_bit(bit, si->irq_enable_mask); |
1da177e4 | 222 | |
4f12bfe5 | 223 | local_irq_save(flags); |
1da177e4 LT |
224 | if (!cputoslice(cpu)) { |
225 | REMOTE_HUB_S(nasid, PI_INT_MASK0_A, si->irq_enable_mask[0]); | |
226 | REMOTE_HUB_S(nasid, PI_INT_MASK1_A, si->irq_enable_mask[1]); | |
227 | } else { | |
228 | REMOTE_HUB_S(nasid, PI_INT_MASK0_B, si->irq_enable_mask[0]); | |
229 | REMOTE_HUB_S(nasid, PI_INT_MASK1_B, si->irq_enable_mask[1]); | |
230 | } | |
4f12bfe5 | 231 | local_irq_restore(flags); |
1da177e4 LT |
232 | |
233 | return 0; | |
234 | } | |
235 | ||
236 | static int intr_disconnect_level(int cpu, int bit) | |
237 | { | |
238 | nasid_t nasid = COMPACT_TO_NASID_NODEID(cpu_to_node(cpu)); | |
239 | struct slice_data *si = cpu_data[cpu].data; | |
240 | ||
4f12bfe5 | 241 | clear_bit(bit, si->irq_enable_mask); |
1da177e4 LT |
242 | |
243 | if (!cputoslice(cpu)) { | |
244 | REMOTE_HUB_S(nasid, PI_INT_MASK0_A, si->irq_enable_mask[0]); | |
245 | REMOTE_HUB_S(nasid, PI_INT_MASK1_A, si->irq_enable_mask[1]); | |
246 | } else { | |
247 | REMOTE_HUB_S(nasid, PI_INT_MASK0_B, si->irq_enable_mask[0]); | |
248 | REMOTE_HUB_S(nasid, PI_INT_MASK1_B, si->irq_enable_mask[1]); | |
249 | } | |
250 | ||
251 | return 0; | |
252 | } | |
253 | ||
254 | /* Startup one of the (PCI ...) IRQs routes over a bridge. */ | |
255 | static unsigned int startup_bridge_irq(unsigned int irq) | |
256 | { | |
257 | struct bridge_controller *bc; | |
258 | bridgereg_t device; | |
259 | bridge_t *bridge; | |
260 | int pin, swlevel; | |
261 | cpuid_t cpu; | |
262 | ||
263 | pin = SLOT_FROM_PCI_IRQ(irq); | |
264 | bc = IRQ_TO_BRIDGE(irq); | |
265 | bridge = bc->base; | |
266 | ||
267 | DBG("bridge_startup(): irq= 0x%x pin=%d\n", irq, pin); | |
268 | /* | |
269 | * "map" irq to a swlevel greater than 6 since the first 6 bits | |
270 | * of INT_PEND0 are taken | |
271 | */ | |
272 | swlevel = find_level(&cpu, irq); | |
273 | bridge->b_int_addr[pin].addr = (0x20000 | swlevel | (bc->nasid << 8)); | |
274 | bridge->b_int_enable |= (1 << pin); | |
275 | bridge->b_int_enable |= 0x7ffffe00; /* more stuff in int_enable */ | |
276 | ||
277 | /* | |
278 | * Enable sending of an interrupt clear packt to the hub on a high to | |
279 | * low transition of the interrupt pin. | |
280 | * | |
281 | * IRIX sets additional bits in the address which are documented as | |
282 | * reserved in the bridge docs. | |
283 | */ | |
284 | bridge->b_int_mode |= (1UL << pin); | |
285 | ||
286 | /* | |
287 | * We assume the bridge to have a 1:1 mapping between devices | |
288 | * (slots) and intr pins. | |
289 | */ | |
290 | device = bridge->b_int_device; | |
291 | device &= ~(7 << (pin*3)); | |
292 | device |= (pin << (pin*3)); | |
293 | bridge->b_int_device = device; | |
294 | ||
295 | bridge->b_wid_tflush; | |
296 | ||
297 | return 0; /* Never anything pending. */ | |
298 | } | |
299 | ||
300 | /* Shutdown one of the (PCI ...) IRQs routes over a bridge. */ | |
301 | static void shutdown_bridge_irq(unsigned int irq) | |
302 | { | |
303 | struct bridge_controller *bc = IRQ_TO_BRIDGE(irq); | |
4f12bfe5 | 304 | struct hub_data *hub = hub_data(cpu_to_node(bc->irq_cpu)); |
1da177e4 LT |
305 | bridge_t *bridge = bc->base; |
306 | struct slice_data *si = cpu_data[bc->irq_cpu].data; | |
307 | int pin, swlevel; | |
308 | cpuid_t cpu; | |
309 | ||
310 | DBG("bridge_shutdown: irq 0x%x\n", irq); | |
311 | pin = SLOT_FROM_PCI_IRQ(irq); | |
312 | ||
313 | /* | |
314 | * map irq to a swlevel greater than 6 since the first 6 bits | |
315 | * of INT_PEND0 are taken | |
316 | */ | |
317 | swlevel = find_level(&cpu, irq); | |
318 | intr_disconnect_level(cpu, swlevel); | |
319 | ||
4f12bfe5 | 320 | __clear_bit(swlevel, hub->irq_alloc_mask); |
1da177e4 LT |
321 | si->level_to_irq[swlevel] = -1; |
322 | ||
323 | bridge->b_int_enable &= ~(1 << pin); | |
324 | bridge->b_wid_tflush; | |
325 | } | |
326 | ||
327 | static inline void enable_bridge_irq(unsigned int irq) | |
328 | { | |
329 | cpuid_t cpu; | |
330 | int swlevel; | |
331 | ||
332 | swlevel = find_level(&cpu, irq); /* Criminal offence */ | |
333 | intr_connect_level(cpu, swlevel); | |
334 | } | |
335 | ||
336 | static inline void disable_bridge_irq(unsigned int irq) | |
337 | { | |
338 | cpuid_t cpu; | |
339 | int swlevel; | |
340 | ||
341 | swlevel = find_level(&cpu, irq); /* Criminal offence */ | |
342 | intr_disconnect_level(cpu, swlevel); | |
343 | } | |
344 | ||
345 | static void mask_and_ack_bridge_irq(unsigned int irq) | |
346 | { | |
347 | disable_bridge_irq(irq); | |
348 | } | |
349 | ||
350 | static void end_bridge_irq(unsigned int irq) | |
351 | { | |
352 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)) && | |
353 | irq_desc[irq].action) | |
354 | enable_bridge_irq(irq); | |
355 | } | |
356 | ||
357 | static struct hw_interrupt_type bridge_irq_type = { | |
358 | .typename = "bridge", | |
359 | .startup = startup_bridge_irq, | |
360 | .shutdown = shutdown_bridge_irq, | |
361 | .enable = enable_bridge_irq, | |
362 | .disable = disable_bridge_irq, | |
363 | .ack = mask_and_ack_bridge_irq, | |
364 | .end = end_bridge_irq, | |
365 | }; | |
366 | ||
367 | static unsigned long irq_map[NR_IRQS / BITS_PER_LONG]; | |
368 | ||
369 | static int allocate_irqno(void) | |
370 | { | |
371 | int irq; | |
372 | ||
373 | again: | |
374 | irq = find_first_zero_bit(irq_map, NR_IRQS); | |
375 | ||
376 | if (irq >= NR_IRQS) | |
377 | return -ENOSPC; | |
378 | ||
379 | if (test_and_set_bit(irq, irq_map)) | |
380 | goto again; | |
381 | ||
382 | return irq; | |
383 | } | |
384 | ||
385 | void free_irqno(unsigned int irq) | |
386 | { | |
387 | clear_bit(irq, irq_map); | |
388 | } | |
389 | ||
390 | void __devinit register_bridge_irq(unsigned int irq) | |
391 | { | |
392 | irq_desc[irq].status = IRQ_DISABLED; | |
393 | irq_desc[irq].action = 0; | |
394 | irq_desc[irq].depth = 1; | |
395 | irq_desc[irq].handler = &bridge_irq_type; | |
396 | } | |
397 | ||
398 | int __devinit request_bridge_irq(struct bridge_controller *bc) | |
399 | { | |
400 | int irq = allocate_irqno(); | |
401 | int swlevel, cpu; | |
402 | nasid_t nasid; | |
403 | ||
404 | if (irq < 0) | |
405 | return irq; | |
406 | ||
407 | /* | |
408 | * "map" irq to a swlevel greater than 6 since the first 6 bits | |
409 | * of INT_PEND0 are taken | |
410 | */ | |
411 | cpu = bc->irq_cpu; | |
412 | swlevel = alloc_level(cpu, irq); | |
413 | if (unlikely(swlevel < 0)) { | |
414 | free_irqno(irq); | |
415 | ||
416 | return -EAGAIN; | |
417 | } | |
418 | ||
419 | /* Make sure it's not already pending when we connect it. */ | |
420 | nasid = COMPACT_TO_NASID_NODEID(cpu_to_node(cpu)); | |
421 | REMOTE_HUB_CLR_INTR(nasid, swlevel); | |
422 | ||
423 | intr_connect_level(cpu, swlevel); | |
424 | ||
425 | register_bridge_irq(irq); | |
426 | ||
427 | return irq; | |
428 | } | |
429 | ||
430 | void __init arch_init_irq(void) | |
431 | { | |
432 | set_except_vector(0, ip27_irq); | |
433 | } | |
434 | ||
435 | void install_ipi(void) | |
436 | { | |
437 | int slice = LOCAL_HUB_L(PI_CPU_NUM); | |
438 | int cpu = smp_processor_id(); | |
439 | struct slice_data *si = cpu_data[cpu].data; | |
4f12bfe5 RB |
440 | struct hub_data *hub = hub_data(cpu_to_node(cpu)); |
441 | int resched, call; | |
442 | ||
443 | resched = CPU_RESCHED_A_IRQ + slice; | |
444 | __set_bit(resched, hub->irq_alloc_mask); | |
445 | __set_bit(resched, si->irq_enable_mask); | |
446 | LOCAL_HUB_CLR_INTR(resched); | |
447 | ||
448 | call = CPU_CALL_A_IRQ + slice; | |
449 | __set_bit(call, hub->irq_alloc_mask); | |
450 | __set_bit(call, si->irq_enable_mask); | |
451 | LOCAL_HUB_CLR_INTR(call); | |
1da177e4 LT |
452 | |
453 | if (slice == 0) { | |
4f12bfe5 RB |
454 | LOCAL_HUB_S(PI_INT_MASK0_A, si->irq_enable_mask[0]); |
455 | LOCAL_HUB_S(PI_INT_MASK1_A, si->irq_enable_mask[1]); | |
1da177e4 | 456 | } else { |
4f12bfe5 RB |
457 | LOCAL_HUB_S(PI_INT_MASK0_B, si->irq_enable_mask[0]); |
458 | LOCAL_HUB_S(PI_INT_MASK1_B, si->irq_enable_mask[1]); | |
1da177e4 LT |
459 | } |
460 | } |