?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.31.6
[linux/fpc-iii.git] / arch / sparc / kernel / sun4d_irq.c
blobab036a72de5a16460cdb8b548dbcf15bb2e04db6
1 /*
2 * arch/sparc/kernel/sun4d_irq.c:
3 * SS1000/SC2000 interrupt handling.
4 *
5 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
6 * Heavily based on arch/sparc/kernel/irq.c.
7 */
8
9 #include <linux/errno.h>
10 #include <linux/linkage.h>
11 #include <linux/kernel_stat.h>
12 #include <linux/signal.h>
13 #include <linux/sched.h>
14 #include <linux/ptrace.h>
15 #include <linux/interrupt.h>
16 #include <linux/slab.h>
17 #include <linux/random.h>
18 #include <linux/init.h>
19 #include <linux/smp.h>
20 #include <linux/spinlock.h>
21 #include <linux/seq_file.h>
22 #include <linux/of.h>
23 #include <linux/of_device.h>
24
25 #include <asm/ptrace.h>
26 #include <asm/processor.h>
27 #include <asm/system.h>
28 #include <asm/psr.h>
29 #include <asm/smp.h>
30 #include <asm/vaddrs.h>
31 #include <asm/timer.h>
32 #include <asm/openprom.h>
33 #include <asm/oplib.h>
34 #include <asm/traps.h>
35 #include <asm/irq.h>
36 #include <asm/io.h>
37 #include <asm/pgalloc.h>
38 #include <asm/pgtable.h>
39 #include <asm/sbi.h>
40 #include <asm/cacheflush.h>
41 #include <asm/irq_regs.h>
42
43 #include "kernel.h"
44 #include "irq.h"
45
46 /* If you trust current SCSI layer to handle different SCSI IRQs, enable this. I don't trust it... -jj */
47 /* #define DISTRIBUTE_IRQS */
48
49 struct sun4d_timer_regs {
50 u32 l10_timer_limit;
51 u32 l10_cur_countx;
52 u32 l10_limit_noclear;
53 u32 ctrl;
54 u32 l10_cur_count;
55 };
56
57 static struct sun4d_timer_regs __iomem *sun4d_timers;
58
59 #define TIMER_IRQ 10
60
61 #define MAX_STATIC_ALLOC 4
62 extern int static_irq_count;
63 static unsigned char sbus_tid[32];
64
65 static struct irqaction *irq_action[NR_IRQS];
66 extern spinlock_t irq_action_lock;
67
68 static struct sbus_action {
69 struct irqaction *action;
70 /* For SMP this needs to be extended */
71 } *sbus_actions;
72
73 static int pil_to_sbus[] = {
74 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
75 };
76
77 static int sbus_to_pil[] = {
78 0, 2, 3, 5, 7, 9, 11, 13,
79 };
80
81 static int nsbi;
82
83 /* Exported for sun4d_smp.c */
84 DEFINE_SPINLOCK(sun4d_imsk_lock);
85
86 int show_sun4d_interrupts(struct seq_file *p, void *v)
87 {
88 int i = *(loff_t *) v, j = 0, k = 0, sbusl;
89 struct irqaction * action;
90 unsigned long flags;
91 #ifdef CONFIG_SMP
92 int x;
93 #endif
94
95 spin_lock_irqsave(&irq_action_lock, flags);
96 if (i < NR_IRQS) {
97 sbusl = pil_to_sbus[i];
98 if (!sbusl) {
99 action = *(i + irq_action);
100 if (!action)
101 goto out_unlock;
102 } else {
103 for (j = 0; j < nsbi; j++) {
104 for (k = 0; k < 4; k++)
105 if ((action = sbus_actions [(j << 5) + (sbusl << 2) + k].action))
106 goto found_it;
107 }
108 goto out_unlock;
109 }
110 found_it: seq_printf(p, "%3d: ", i);
111 #ifndef CONFIG_SMP
112 seq_printf(p, "%10u ", kstat_irqs(i));
113 #else
114 for_each_online_cpu(x)
115 seq_printf(p, "%10u ",
116 kstat_cpu(cpu_logical_map(x)).irqs[i]);
117 #endif
118 seq_printf(p, "%c %s",
119 (action->flags & IRQF_DISABLED) ? '+' : ' ',
120 action->name);
121 action = action->next;
122 for (;;) {
123 for (; action; action = action->next) {
124 seq_printf(p, ",%s %s",
125 (action->flags & IRQF_DISABLED) ? " +" : "",
126 action->name);
127 }
128 if (!sbusl) break;
129 k++;
130 if (k < 4)
131 action = sbus_actions [(j << 5) + (sbusl << 2) + k].action;
132 else {
133 j++;
134 if (j == nsbi) break;
135 k = 0;
136 action = sbus_actions [(j << 5) + (sbusl << 2)].action;
137 }
138 }
139 seq_putc(p, '\n');
140 }
141 out_unlock:
142 spin_unlock_irqrestore(&irq_action_lock, flags);
143 return 0;
144 }
145
146 void sun4d_free_irq(unsigned int irq, void *dev_id)
147 {
148 struct irqaction *action, **actionp;
149 struct irqaction *tmp = NULL;
150 unsigned long flags;
151
152 spin_lock_irqsave(&irq_action_lock, flags);
153 if (irq < 15)
154 actionp = irq + irq_action;
155 else
156 actionp = &(sbus_actions[irq - (1 << 5)].action);
157 action = *actionp;
158 if (!action) {
159 printk("Trying to free free IRQ%d\n",irq);
160 goto out_unlock;
161 }
162 if (dev_id) {
163 for (; action; action = action->next) {
164 if (action->dev_id == dev_id)
165 break;
166 tmp = action;
167 }
168 if (!action) {
169 printk("Trying to free free shared IRQ%d\n",irq);
170 goto out_unlock;
171 }
172 } else if (action->flags & IRQF_SHARED) {
173 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
174 goto out_unlock;
175 }
176 if (action->flags & SA_STATIC_ALLOC)
177 {
178 /* This interrupt is marked as specially allocated
179 * so it is a bad idea to free it.
180 */
181 printk("Attempt to free statically allocated IRQ%d (%s)\n",
182 irq, action->name);
183 goto out_unlock;
184 }
185
186 if (action && tmp)
187 tmp->next = action->next;
188 else
189 *actionp = action->next;
190
191 spin_unlock_irqrestore(&irq_action_lock, flags);
192
193 synchronize_irq(irq);
194
195 spin_lock_irqsave(&irq_action_lock, flags);
196
197 kfree(action);
198
199 if (!(*actionp))
200 __disable_irq(irq);
201
202 out_unlock:
203 spin_unlock_irqrestore(&irq_action_lock, flags);
204 }
205
206 extern void unexpected_irq(int, void *, struct pt_regs *);
207
208 void sun4d_handler_irq(int irq, struct pt_regs * regs)
209 {
210 struct pt_regs *old_regs;
211 struct irqaction * action;
212 int cpu = smp_processor_id();
213 /* SBUS IRQ level (1 - 7) */
214 int sbusl = pil_to_sbus[irq];
215
216 /* FIXME: Is this necessary?? */
217 cc_get_ipen();
218
219 cc_set_iclr(1 << irq);
220
221 old_regs = set_irq_regs(regs);
222 irq_enter();
223 kstat_cpu(cpu).irqs[irq]++;
224 if (!sbusl) {
225 action = *(irq + irq_action);
226 if (!action)
227 unexpected_irq(irq, NULL, regs);
228 do {
229 action->handler(irq, action->dev_id);
230 action = action->next;
231 } while (action);
232 } else {
233 int bus_mask = bw_get_intr_mask(sbusl) & 0x3ffff;
234 int sbino;
235 struct sbus_action *actionp;
236 unsigned mask, slot;
237 int sbil = (sbusl << 2);
238
239 bw_clear_intr_mask(sbusl, bus_mask);
240
241 /* Loop for each pending SBI */
242 for (sbino = 0; bus_mask; sbino++, bus_mask >>= 1)
243 if (bus_mask & 1) {
244 mask = acquire_sbi(SBI2DEVID(sbino), 0xf << sbil);
245 mask &= (0xf << sbil);
246 actionp = sbus_actions + (sbino << 5) + (sbil);
247 /* Loop for each pending SBI slot */
248 for (slot = (1 << sbil); mask; slot <<= 1, actionp++)
249 if (mask & slot) {
250 mask &= ~slot;
251 action = actionp->action;
252
253 if (!action)
254 unexpected_irq(irq, NULL, regs);
255 do {
256 action->handler(irq, action->dev_id);
257 action = action->next;
258 } while (action);
259 release_sbi(SBI2DEVID(sbino), slot);
260 }
261 }
262 }
263 irq_exit();
264 set_irq_regs(old_regs);
265 }
266
267 int sun4d_request_irq(unsigned int irq,
268 irq_handler_t handler,
269 unsigned long irqflags, const char * devname, void *dev_id)
270 {
271 struct irqaction *action, *tmp = NULL, **actionp;
272 unsigned long flags;
273 int ret;
274
275 if(irq > 14 && irq < (1 << 5)) {
276 ret = -EINVAL;
277 goto out;
278 }
279
280 if (!handler) {
281 ret = -EINVAL;
282 goto out;
283 }
284
285 spin_lock_irqsave(&irq_action_lock, flags);
286
287 if (irq >= (1 << 5))
288 actionp = &(sbus_actions[irq - (1 << 5)].action);
289 else
290 actionp = irq + irq_action;
291 action = *actionp;
292
293 if (action) {
294 if ((action->flags & IRQF_SHARED) && (irqflags & IRQF_SHARED)) {
295 for (tmp = action; tmp->next; tmp = tmp->next);
296 } else {
297 ret = -EBUSY;
298 goto out_unlock;
299 }
300 if ((action->flags & IRQF_DISABLED) ^ (irqflags & IRQF_DISABLED)) {
301 printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
302 ret = -EBUSY;
303 goto out_unlock;
304 }
305 action = NULL; /* Or else! */
306 }
307
308 /* If this is flagged as statically allocated then we use our
309 * private struct which is never freed.
310 */
311 if (irqflags & SA_STATIC_ALLOC) {
312 if (static_irq_count < MAX_STATIC_ALLOC)
313 action = &static_irqaction[static_irq_count++];
314 else
315 printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
316 }
317
318 if (action == NULL)
319 action = kmalloc(sizeof(struct irqaction),
320 GFP_ATOMIC);
321
322 if (!action) {
323 ret = -ENOMEM;
324 goto out_unlock;
325 }
326
327 action->handler = handler;
328 action->flags = irqflags;
329 action->name = devname;
330 action->next = NULL;
331 action->dev_id = dev_id;
332
333 if (tmp)
334 tmp->next = action;
335 else
336 *actionp = action;
337
338 __enable_irq(irq);
339
340 ret = 0;
341 out_unlock:
342 spin_unlock_irqrestore(&irq_action_lock, flags);
343 out:
344 return ret;
345 }
346
347 static void sun4d_disable_irq(unsigned int irq)
348 {
349 int tid = sbus_tid[(irq >> 5) - 1];
350 unsigned long flags;
351
352 if (irq < NR_IRQS)
353 return;
354
355 spin_lock_irqsave(&sun4d_imsk_lock, flags);
356 cc_set_imsk_other(tid, cc_get_imsk_other(tid) | (1 << sbus_to_pil[(irq >> 2) & 7]));
357 spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
358 }
359
360 static void sun4d_enable_irq(unsigned int irq)
361 {
362 int tid = sbus_tid[(irq >> 5) - 1];
363 unsigned long flags;
364
365 if (irq < NR_IRQS)
366 return;
367
368 spin_lock_irqsave(&sun4d_imsk_lock, flags);
369 cc_set_imsk_other(tid, cc_get_imsk_other(tid) & ~(1 << sbus_to_pil[(irq >> 2) & 7]));
370 spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
371 }
372
373 #ifdef CONFIG_SMP
374 static void sun4d_set_cpu_int(int cpu, int level)
375 {
376 sun4d_send_ipi(cpu, level);
377 }
378
379 static void sun4d_clear_ipi(int cpu, int level)
380 {
381 }
382
383 static void sun4d_set_udt(int cpu)
384 {
385 }
386
387 /* Setup IRQ distribution scheme. */
388 void __init sun4d_distribute_irqs(void)
389 {
390 struct device_node *dp;
391
392 #ifdef DISTRIBUTE_IRQS
393 cpumask_t sbus_serving_map;
394
395 sbus_serving_map = cpu_present_map;
396 for_each_node_by_name(dp, "sbi") {
397 int board = of_getintprop_default(dp, "board#", 0);
398
399 if ((board * 2) == boot_cpu_id && cpu_isset(board * 2 + 1, cpu_present_map))
400 sbus_tid[board] = (board * 2 + 1);
401 else if (cpu_isset(board * 2, cpu_present_map))
402 sbus_tid[board] = (board * 2);
403 else if (cpu_isset(board * 2 + 1, cpu_present_map))
404 sbus_tid[board] = (board * 2 + 1);
405 else
406 sbus_tid[board] = 0xff;
407 if (sbus_tid[board] != 0xff)
408 cpu_clear(sbus_tid[board], sbus_serving_map);
409 }
410 for_each_node_by_name(dp, "sbi") {
411 int board = of_getintprop_default(dp, "board#", 0);
412 if (sbus_tid[board] == 0xff) {
413 int i = 31;
414
415 if (cpus_empty(sbus_serving_map))
416 sbus_serving_map = cpu_present_map;
417 while (cpu_isset(i, sbus_serving_map))
418 i--;
419 sbus_tid[board] = i;
420 cpu_clear(i, sbus_serving_map);
421 }
422 }
423 for_each_node_by_name(dp, "sbi") {
424 int devid = of_getintprop_default(dp, "device-id", 0);
425 int board = of_getintprop_default(dp, "board#", 0);
426 printk("sbus%d IRQs directed to CPU%d\n", board, sbus_tid[board]);
427 set_sbi_tid(devid, sbus_tid[board] << 3);
428 }
429 #else
430 int cpuid = cpu_logical_map(1);
431
432 if (cpuid == -1)
433 cpuid = cpu_logical_map(0);
434 for_each_node_by_name(dp, "sbi") {
435 int devid = of_getintprop_default(dp, "device-id", 0);
436 int board = of_getintprop_default(dp, "board#", 0);
437 sbus_tid[board] = cpuid;
438 set_sbi_tid(devid, cpuid << 3);
439 }
440 printk("All sbus IRQs directed to CPU%d\n", cpuid);
441 #endif
442 }
443 #endif
444
445 static void sun4d_clear_clock_irq(void)
446 {
447 sbus_readl(&sun4d_timers->l10_timer_limit);
448 }
449
450 static void sun4d_load_profile_irq(int cpu, unsigned int limit)
451 {
452 bw_set_prof_limit(cpu, limit);
453 }
454
455 static void __init sun4d_load_profile_irqs(void)
456 {
457 int cpu = 0, mid;
458
459 while (!cpu_find_by_instance(cpu, NULL, &mid)) {
460 sun4d_load_profile_irq(mid >> 3, 0);
461 cpu++;
462 }
463 }
464
465 static void __init sun4d_fixup_trap_table(void)
466 {
467 #ifdef CONFIG_SMP
468 unsigned long flags;
469 extern unsigned long lvl14_save[4];
470 struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (14 - 1)];
471 extern unsigned int real_irq_entry[], smp4d_ticker[];
472 extern unsigned int patchme_maybe_smp_msg[];
473
474 /* Adjust so that we jump directly to smp4d_ticker */
475 lvl14_save[2] += smp4d_ticker - real_irq_entry;
476
477 /* For SMP we use the level 14 ticker, however the bootup code
478 * has copied the firmware's level 14 vector into the boot cpu's
479 * trap table, we must fix this now or we get squashed.
480 */
481 local_irq_save(flags);
482 patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
483 trap_table->inst_one = lvl14_save[0];
484 trap_table->inst_two = lvl14_save[1];
485 trap_table->inst_three = lvl14_save[2];
486 trap_table->inst_four = lvl14_save[3];
487 local_flush_cache_all();
488 local_irq_restore(flags);
489 #endif
490 }
491
492 static void __init sun4d_init_timers(irq_handler_t counter_fn)
493 {
494 struct device_node *dp;
495 struct resource res;
496 const u32 *reg;
497 int err;
498
499 dp = of_find_node_by_name(NULL, "cpu-unit");
500 if (!dp) {
501 prom_printf("sun4d_init_timers: Unable to find cpu-unit\n");
502 prom_halt();
503 }
504
505 /* Which cpu-unit we use is arbitrary, we can view the bootbus timer
506 * registers via any cpu's mapping. The first 'reg' property is the
507 * bootbus.
508 */
509 reg = of_get_property(dp, "reg", NULL);
510 of_node_put(dp);
511 if (!reg) {
512 prom_printf("sun4d_init_timers: No reg property\n");
513 prom_halt();
514 }
515
516 res.start = reg[1];
517 res.end = reg[2] - 1;
518 res.flags = reg[0] & 0xff;
519 sun4d_timers = of_ioremap(&res, BW_TIMER_LIMIT,
520 sizeof(struct sun4d_timer_regs), "user timer");
521 if (!sun4d_timers) {
522 prom_printf("sun4d_init_timers: Can't map timer regs\n");
523 prom_halt();
524 }
525
526 sbus_writel((((1000000/HZ) + 1) << 10), &sun4d_timers->l10_timer_limit);
527
528 master_l10_counter = &sun4d_timers->l10_cur_count;
529
530 err = request_irq(TIMER_IRQ, counter_fn,
531 (IRQF_DISABLED | SA_STATIC_ALLOC),
532 "timer", NULL);
533 if (err) {
534 prom_printf("sun4d_init_timers: request_irq() failed with %d\n", err);
535 prom_halt();
536 }
537 sun4d_load_profile_irqs();
538 sun4d_fixup_trap_table();
539 }
540
541 void __init sun4d_init_sbi_irq(void)
542 {
543 struct device_node *dp;
544 int target_cpu = 0;
545
546 #ifdef CONFIG_SMP
547 target_cpu = boot_cpu_id;
548 #endif
549
550 nsbi = 0;
551 for_each_node_by_name(dp, "sbi")
552 nsbi++;
553 sbus_actions = kzalloc (nsbi * 8 * 4 * sizeof(struct sbus_action), GFP_ATOMIC);
554 if (!sbus_actions) {
555 prom_printf("SUN4D: Cannot allocate sbus_actions, halting.\n");
556 prom_halt();
557 }
558 for_each_node_by_name(dp, "sbi") {
559 int devid = of_getintprop_default(dp, "device-id", 0);
560 int board = of_getintprop_default(dp, "board#", 0);
561 unsigned int mask;
562
563 set_sbi_tid(devid, target_cpu << 3);
564 sbus_tid[board] = target_cpu;
565
566 /* Get rid of pending irqs from PROM */
567 mask = acquire_sbi(devid, 0xffffffff);
568 if (mask) {
569 printk ("Clearing pending IRQs %08x on SBI %d\n", mask, board);
570 release_sbi(devid, mask);
571 }
572 }
573 }
574
575 void __init sun4d_init_IRQ(void)
576 {
577 local_irq_disable();
578
579 BTFIXUPSET_CALL(enable_irq, sun4d_enable_irq, BTFIXUPCALL_NORM);
580 BTFIXUPSET_CALL(disable_irq, sun4d_disable_irq, BTFIXUPCALL_NORM);
581 BTFIXUPSET_CALL(clear_clock_irq, sun4d_clear_clock_irq, BTFIXUPCALL_NORM);
582 BTFIXUPSET_CALL(load_profile_irq, sun4d_load_profile_irq, BTFIXUPCALL_NORM);
583 sparc_init_timers = sun4d_init_timers;
584 #ifdef CONFIG_SMP
585 BTFIXUPSET_CALL(set_cpu_int, sun4d_set_cpu_int, BTFIXUPCALL_NORM);
586 BTFIXUPSET_CALL(clear_cpu_int, sun4d_clear_ipi, BTFIXUPCALL_NOP);
587 BTFIXUPSET_CALL(set_irq_udt, sun4d_set_udt, BTFIXUPCALL_NOP);
588 #endif
589 /* Cannot enable interrupts until OBP ticker is disabled. */
590 }
Linux with added FPC-III support