1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/sched.h>
16#include <linux/ptrace.h>
17#include <linux/errno.h>
18#include <linux/linkage.h>
19#include <linux/kernel_stat.h>
20#include <linux/signal.h>
21#include <linux/interrupt.h>
22#include <linux/slab.h>
23#include <linux/random.h>
24#include <linux/init.h>
25#include <linux/smp.h>
26#include <linux/delay.h>
27#include <linux/threads.h>
28#include <linux/spinlock.h>
29#include <linux/seq_file.h>
30
31#include <asm/ptrace.h>
32#include <asm/processor.h>
33#include <asm/system.h>
34#include <asm/psr.h>
35#include <asm/smp.h>
36#include <asm/vaddrs.h>
37#include <asm/timer.h>
38#include <asm/openprom.h>
39#include <asm/oplib.h>
40#include <asm/traps.h>
41#include <asm/irq.h>
42#include <asm/io.h>
43#include <asm/pgalloc.h>
44#include <asm/pgtable.h>
45#include <asm/pcic.h>
46#include <asm/cacheflush.h>
47#include <asm/irq_regs.h>
48#include <asm/leon.h>
49
50#include "kernel.h"
51#include "irq.h"
52
53#ifdef CONFIG_SMP
54#define SMP_NOP2 "nop; nop;\n\t"
55#define SMP_NOP3 "nop; nop; nop;\n\t"
56#else
57#define SMP_NOP2
58#define SMP_NOP3
59#endif
60unsigned long __raw_local_irq_save(void)
61{
62 unsigned long retval;
63 unsigned long tmp;
64
65 __asm__ __volatile__(
66 "rd %%psr, %0\n\t"
67 SMP_NOP3
68 "or %0, %2, %1\n\t"
69 "wr %1, 0, %%psr\n\t"
70 "nop; nop; nop\n"
71 : "=&r" (retval), "=r" (tmp)
72 : "i" (PSR_PIL)
73 : "memory");
74
75 return retval;
76}
77
78void raw_local_irq_enable(void)
79{
80 unsigned long tmp;
81
82 __asm__ __volatile__(
83 "rd %%psr, %0\n\t"
84 SMP_NOP3
85 "andn %0, %1, %0\n\t"
86 "wr %0, 0, %%psr\n\t"
87 "nop; nop; nop\n"
88 : "=&r" (tmp)
89 : "i" (PSR_PIL)
90 : "memory");
91}
92
93void raw_local_irq_restore(unsigned long old_psr)
94{
95 unsigned long tmp;
96
97 __asm__ __volatile__(
98 "rd %%psr, %0\n\t"
99 "and %2, %1, %2\n\t"
100 SMP_NOP2
101 "andn %0, %1, %0\n\t"
102 "wr %0, %2, %%psr\n\t"
103 "nop; nop; nop\n"
104 : "=&r" (tmp)
105 : "i" (PSR_PIL), "r" (old_psr)
106 : "memory");
107}
108
109EXPORT_SYMBOL(__raw_local_irq_save);
110EXPORT_SYMBOL(raw_local_irq_enable);
111EXPORT_SYMBOL(raw_local_irq_restore);
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132static void irq_panic(void)
133{
134 extern char *cputypval;
135 prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
136 prom_halt();
137}
138
139void (*sparc_init_timers)(irq_handler_t ) =
140 (void (*)(irq_handler_t )) irq_panic;
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155#define MAX_STATIC_ALLOC 4
156struct irqaction static_irqaction[MAX_STATIC_ALLOC];
157int static_irq_count;
158
159static struct {
160 struct irqaction *action;
161 int flags;
162} sparc_irq[NR_IRQS];
163#define SPARC_IRQ_INPROGRESS 1
164
165
166DEFINE_SPINLOCK(irq_action_lock);
167
168int show_interrupts(struct seq_file *p, void *v)
169{
170 int i = *(loff_t *) v;
171 struct irqaction * action;
172 unsigned long flags;
173#ifdef CONFIG_SMP
174 int j;
175#endif
176
177 if (sparc_cpu_model == sun4d) {
178 extern int show_sun4d_interrupts(struct seq_file *, void *);
179
180 return show_sun4d_interrupts(p, v);
181 }
182 spin_lock_irqsave(&irq_action_lock, flags);
183 if (i < NR_IRQS) {
184 action = sparc_irq[i].action;
185 if (!action)
186 goto out_unlock;
187 seq_printf(p, "%3d: ", i);
188#ifndef CONFIG_SMP
189 seq_printf(p, "%10u ", kstat_irqs(i));
190#else
191 for_each_online_cpu(j) {
192 seq_printf(p, "%10u ",
193 kstat_cpu(j).irqs[i]);
194 }
195#endif
196 seq_printf(p, " %c %s",
197 (action->flags & IRQF_DISABLED) ? '+' : ' ',
198 action->name);
199 for (action=action->next; action; action = action->next) {
200 seq_printf(p, ",%s %s",
201 (action->flags & IRQF_DISABLED) ? " +" : "",
202 action->name);
203 }
204 seq_putc(p, '\n');
205 }
206out_unlock:
207 spin_unlock_irqrestore(&irq_action_lock, flags);
208 return 0;
209}
210
211void free_irq(unsigned int irq, void *dev_id)
212{
213 struct irqaction * action;
214 struct irqaction **actionp;
215 unsigned long flags;
216 unsigned int cpu_irq;
217
218 if (sparc_cpu_model == sun4d) {
219 extern void sun4d_free_irq(unsigned int, void *);
220
221 sun4d_free_irq(irq, dev_id);
222 return;
223 }
224 cpu_irq = irq & (NR_IRQS - 1);
225 if (cpu_irq > 14) {
226 printk("Trying to free bogus IRQ %d\n", irq);
227 return;
228 }
229
230 spin_lock_irqsave(&irq_action_lock, flags);
231
232 actionp = &sparc_irq[cpu_irq].action;
233 action = *actionp;
234
235 if (!action->handler) {
236 printk("Trying to free free IRQ%d\n",irq);
237 goto out_unlock;
238 }
239 if (dev_id) {
240 for (; action; action = action->next) {
241 if (action->dev_id == dev_id)
242 break;
243 actionp = &action->next;
244 }
245 if (!action) {
246 printk("Trying to free free shared IRQ%d\n",irq);
247 goto out_unlock;
248 }
249 } else if (action->flags & IRQF_SHARED) {
250 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
251 goto out_unlock;
252 }
253 if (action->flags & SA_STATIC_ALLOC)
254 {
255
256
257
258 printk("Attempt to free statically allocated IRQ%d (%s)\n",
259 irq, action->name);
260 goto out_unlock;
261 }
262
263 *actionp = action->next;
264
265 spin_unlock_irqrestore(&irq_action_lock, flags);
266
267 synchronize_irq(irq);
268
269 spin_lock_irqsave(&irq_action_lock, flags);
270
271 kfree(action);
272
273 if (!sparc_irq[cpu_irq].action)
274 __disable_irq(irq);
275
276out_unlock:
277 spin_unlock_irqrestore(&irq_action_lock, flags);
278}
279
280EXPORT_SYMBOL(free_irq);
281
282
283
284
285
286
287
288
289#ifdef CONFIG_SMP
290void synchronize_irq(unsigned int irq)
291{
292 unsigned int cpu_irq;
293
294 cpu_irq = irq & (NR_IRQS - 1);
295 while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
296 cpu_relax();
297}
298EXPORT_SYMBOL(synchronize_irq);
299#endif
300
301void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
302{
303 int i;
304 struct irqaction * action;
305 unsigned int cpu_irq;
306
307 cpu_irq = irq & (NR_IRQS - 1);
308 action = sparc_irq[cpu_irq].action;
309
310 printk("IO device interrupt, irq = %d\n", irq);
311 printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc,
312 regs->npc, regs->u_regs[14]);
313 if (action) {
314 printk("Expecting: ");
315 for (i = 0; i < 16; i++)
316 if (action->handler)
317 printk("[%s:%d:0x%x] ", action->name,
318 (int) i, (unsigned int) action->handler);
319 }
320 printk("AIEEE\n");
321 panic("bogus interrupt received");
322}
323
324void handler_irq(int irq, struct pt_regs * regs)
325{
326 struct pt_regs *old_regs;
327 struct irqaction * action;
328 int cpu = smp_processor_id();
329#ifdef CONFIG_SMP
330 extern void smp4m_irq_rotate(int cpu);
331#endif
332
333 old_regs = set_irq_regs(regs);
334 irq_enter();
335 disable_pil_irq(irq);
336#ifdef CONFIG_SMP
337
338 if((sparc_cpu_model==sun4m) && (irq < 10))
339 smp4m_irq_rotate(cpu);
340#endif
341 action = sparc_irq[irq].action;
342 sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
343 kstat_cpu(cpu).irqs[irq]++;
344 do {
345 if (!action || !action->handler)
346 unexpected_irq(irq, NULL, regs);
347 action->handler(irq, action->dev_id);
348 action = action->next;
349 } while (action);
350 sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
351 enable_pil_irq(irq);
352 irq_exit();
353 set_irq_regs(old_regs);
354}
355
356#if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)
357
358
359
360
361static int request_fast_irq(unsigned int irq,
362 void (*handler)(void),
363 unsigned long irqflags, const char *devname)
364{
365 struct irqaction *action;
366 unsigned long flags;
367 unsigned int cpu_irq;
368 int ret;
369#ifdef CONFIG_SMP
370 struct tt_entry *trap_table;
371 extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
372#endif
373
374 cpu_irq = irq & (NR_IRQS - 1);
375 if(cpu_irq > 14) {
376 ret = -EINVAL;
377 goto out;
378 }
379 if(!handler) {
380 ret = -EINVAL;
381 goto out;
382 }
383
384 spin_lock_irqsave(&irq_action_lock, flags);
385
386 action = sparc_irq[cpu_irq].action;
387 if(action) {
388 if(action->flags & IRQF_SHARED)
389 panic("Trying to register fast irq when already shared.\n");
390 if(irqflags & IRQF_SHARED)
391 panic("Trying to register fast irq as shared.\n");
392
393
394 printk("request_fast_irq: Trying to register yet already owned.\n");
395 ret = -EBUSY;
396 goto out_unlock;
397 }
398
399
400
401
402 if (irqflags & SA_STATIC_ALLOC) {
403 if (static_irq_count < MAX_STATIC_ALLOC)
404 action = &static_irqaction[static_irq_count++];
405 else
406 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
407 irq, devname);
408 }
409
410 if (action == NULL)
411 action = kmalloc(sizeof(struct irqaction),
412 GFP_ATOMIC);
413
414 if (!action) {
415 ret = -ENOMEM;
416 goto out_unlock;
417 }
418
419
420#define INSTANTIATE(table) \
421 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
422 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
423 SPARC_BRANCH((unsigned long) handler, \
424 (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
425 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
426 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
427
428 INSTANTIATE(sparc_ttable)
429#ifdef CONFIG_SMP
430 trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
431 trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
432 trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
433#endif
434#undef INSTANTIATE
435
436
437
438
439
440 flush_cache_all();
441
442 action->flags = irqflags;
443 action->name = devname;
444 action->dev_id = NULL;
445 action->next = NULL;
446
447 sparc_irq[cpu_irq].action = action;
448
449 __enable_irq(irq);
450
451 ret = 0;
452out_unlock:
453 spin_unlock_irqrestore(&irq_action_lock, flags);
454out:
455 return ret;
456}
457
458
459
460
461
462
463volatile unsigned char *fdc_status;
464EXPORT_SYMBOL(fdc_status);
465
466char *pdma_vaddr;
467EXPORT_SYMBOL(pdma_vaddr);
468
469unsigned long pdma_size;
470EXPORT_SYMBOL(pdma_size);
471
472volatile int doing_pdma;
473EXPORT_SYMBOL(doing_pdma);
474
475char *pdma_base;
476EXPORT_SYMBOL(pdma_base);
477
478unsigned long pdma_areasize;
479EXPORT_SYMBOL(pdma_areasize);
480
481extern void floppy_hardint(void);
482
483static irq_handler_t floppy_irq_handler;
484
485void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
486{
487 struct pt_regs *old_regs;
488 int cpu = smp_processor_id();
489
490 old_regs = set_irq_regs(regs);
491 disable_pil_irq(irq);
492 irq_enter();
493 kstat_cpu(cpu).irqs[irq]++;
494 floppy_irq_handler(irq, dev_id);
495 irq_exit();
496 enable_pil_irq(irq);
497 set_irq_regs(old_regs);
498
499
500
501}
502
503int sparc_floppy_request_irq(int irq, unsigned long flags,
504 irq_handler_t irq_handler)
505{
506 floppy_irq_handler = irq_handler;
507 return request_fast_irq(irq, floppy_hardint, flags, "floppy");
508}
509EXPORT_SYMBOL(sparc_floppy_request_irq);
510
511#endif
512
513int request_irq(unsigned int irq,
514 irq_handler_t handler,
515 unsigned long irqflags, const char * devname, void *dev_id)
516{
517 struct irqaction * action, **actionp;
518 unsigned long flags;
519 unsigned int cpu_irq;
520 int ret;
521
522 if (sparc_cpu_model == sun4d) {
523 extern int sun4d_request_irq(unsigned int,
524 irq_handler_t ,
525 unsigned long, const char *, void *);
526 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
527 }
528 cpu_irq = irq & (NR_IRQS - 1);
529 if(cpu_irq > 14) {
530 ret = -EINVAL;
531 goto out;
532 }
533 if (!handler) {
534 ret = -EINVAL;
535 goto out;
536 }
537
538 spin_lock_irqsave(&irq_action_lock, flags);
539
540 actionp = &sparc_irq[cpu_irq].action;
541 action = *actionp;
542 if (action) {
543 if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
544 ret = -EBUSY;
545 goto out_unlock;
546 }
547 if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
548 printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
549 ret = -EBUSY;
550 goto out_unlock;
551 }
552 for ( ; action; action = *actionp)
553 actionp = &action->next;
554 }
555
556
557
558
559 if (irqflags & SA_STATIC_ALLOC) {
560 if (static_irq_count < MAX_STATIC_ALLOC)
561 action = &static_irqaction[static_irq_count++];
562 else
563 printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
564 }
565
566 if (action == NULL)
567 action = kmalloc(sizeof(struct irqaction),
568 GFP_ATOMIC);
569
570 if (!action) {
571 ret = -ENOMEM;
572 goto out_unlock;
573 }
574
575 action->handler = handler;
576 action->flags = irqflags;
577 action->name = devname;
578 action->next = NULL;
579 action->dev_id = dev_id;
580
581 *actionp = action;
582
583 __enable_irq(irq);
584
585 ret = 0;
586out_unlock:
587 spin_unlock_irqrestore(&irq_action_lock, flags);
588out:
589 return ret;
590}
591
592EXPORT_SYMBOL(request_irq);
593
594void disable_irq_nosync(unsigned int irq)
595{
596 __disable_irq(irq);
597}
598EXPORT_SYMBOL(disable_irq_nosync);
599
600void disable_irq(unsigned int irq)
601{
602 __disable_irq(irq);
603}
604EXPORT_SYMBOL(disable_irq);
605
606void enable_irq(unsigned int irq)
607{
608 __enable_irq(irq);
609}
610
611EXPORT_SYMBOL(enable_irq);
612
613
614
615
616unsigned long probe_irq_on(void)
617{
618 return 0;
619}
620
621EXPORT_SYMBOL(probe_irq_on);
622
623int probe_irq_off(unsigned long mask)
624{
625 return 0;
626}
627
628EXPORT_SYMBOL(probe_irq_off);
629
630
631
632
633
634
635
636
637
638void __init init_IRQ(void)
639{
640 extern void sun4c_init_IRQ( void );
641 extern void sun4m_init_IRQ( void );
642 extern void sun4d_init_IRQ( void );
643
644 switch(sparc_cpu_model) {
645 case sun4c:
646 case sun4:
647 sun4c_init_IRQ();
648 break;
649
650 case sun4m:
651#ifdef CONFIG_PCI
652 pcic_probe();
653 if (pcic_present()) {
654 sun4m_pci_init_IRQ();
655 break;
656 }
657#endif
658 sun4m_init_IRQ();
659 break;
660
661 case sun4d:
662 sun4d_init_IRQ();
663 break;
664
665 case sparc_leon:
666 leon_init_IRQ();
667 break;
668
669 default:
670 prom_printf("Cannot initialize IRQs on this Sun machine...");
671 break;
672 }
673 btfixup();
674}
675
676#ifdef CONFIG_PROC_FS
677void init_irq_proc(void)
678{
679
680}
681#endif
682