1
2
3
4
5
6
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
47
48
49struct 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
57static struct sun4d_timer_regs __iomem *sun4d_timers;
58
59#define TIMER_IRQ 10
60
61#define MAX_STATIC_ALLOC 4
62extern int static_irq_count;
63static unsigned char sbus_tid[32];
64
65static struct irqaction *irq_action[NR_IRQS];
66extern spinlock_t irq_action_lock;
67
68static struct sbus_action {
69 struct irqaction *action;
70
71} *sbus_actions;
72
73static int pil_to_sbus[] = {
74 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
75};
76
77static int sbus_to_pil[] = {
78 0, 2, 3, 5, 7, 9, 11, 13,
79};
80
81static int nsbi;
82
83
84DEFINE_SPINLOCK(sun4d_imsk_lock);
85
86int 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 }
110found_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 }
141out_unlock:
142 spin_unlock_irqrestore(&irq_action_lock, flags);
143 return 0;
144}
145
146void 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
179
180
181 printk("Attempt to free statically allocated IRQ%d (%s)\n",
182 irq, action->name);
183 goto out_unlock;
184 }
185
186 if (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
202out_unlock:
203 spin_unlock_irqrestore(&irq_action_lock, flags);
204}
205
206extern void unexpected_irq(int, void *, struct pt_regs *);
207
208void 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
214 int sbusl = pil_to_sbus[irq];
215
216
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
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
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
267int 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;
306 }
307
308
309
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;
341out_unlock:
342 spin_unlock_irqrestore(&irq_action_lock, flags);
343out:
344 return ret;
345}
346
347static 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
360static 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
374static void sun4d_set_cpu_int(int cpu, int level)
375{
376 sun4d_send_ipi(cpu, level);
377}
378
379static void sun4d_clear_ipi(int cpu, int level)
380{
381}
382
383static void sun4d_set_udt(int cpu)
384{
385}
386
387
388void __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
445static void sun4d_clear_clock_irq(void)
446{
447 sbus_readl(&sun4d_timers->l10_timer_limit);
448}
449
450static void sun4d_load_profile_irq(int cpu, unsigned int limit)
451{
452 bw_set_prof_limit(cpu, limit);
453}
454
455static 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
465static 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
475 lvl14_save[2] += smp4d_ticker - real_irq_entry;
476
477
478
479
480
481 local_irq_save(flags);
482 patchme_maybe_smp_msg[0] = 0x01000000;
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
492static 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
506
507
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
541void __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
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
575void __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
590}
591
