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