sparc,sparc64: unify lib/
[linux-2.6.git] / arch / sparc / kernel / irq.c
1 /*
2  *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
3  *                            Sparc the IRQs are basically 'cast in stone'
4  *                            and you are supposed to probe the prom's device
5  *                            node trees to find out who's got which IRQ.
6  *
7  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
8  *  Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
9  *  Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com)
10  *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
11  *  Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
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
49 #include "irq.h"
50
51 #ifdef CONFIG_SMP
52 #define SMP_NOP2 "nop; nop;\n\t"
53 #define SMP_NOP3 "nop; nop; nop;\n\t"
54 #else
55 #define SMP_NOP2
56 #define SMP_NOP3
57 #endif /* SMP */
58 unsigned long __raw_local_irq_save(void)
59 {
60         unsigned long retval;
61         unsigned long tmp;
62
63         __asm__ __volatile__(
64                 "rd     %%psr, %0\n\t"
65                 SMP_NOP3        /* Sun4m + Cypress + SMP bug */
66                 "or     %0, %2, %1\n\t"
67                 "wr     %1, 0, %%psr\n\t"
68                 "nop; nop; nop\n"
69                 : "=&r" (retval), "=r" (tmp)
70                 : "i" (PSR_PIL)
71                 : "memory");
72
73         return retval;
74 }
75
76 void raw_local_irq_enable(void)
77 {
78         unsigned long tmp;
79
80         __asm__ __volatile__(
81                 "rd     %%psr, %0\n\t"
82                 SMP_NOP3        /* Sun4m + Cypress + SMP bug */
83                 "andn   %0, %1, %0\n\t"
84                 "wr     %0, 0, %%psr\n\t"
85                 "nop; nop; nop\n"
86                 : "=&r" (tmp)
87                 : "i" (PSR_PIL)
88                 : "memory");
89 }
90
91 void raw_local_irq_restore(unsigned long old_psr)
92 {
93         unsigned long tmp;
94
95         __asm__ __volatile__(
96                 "rd     %%psr, %0\n\t"
97                 "and    %2, %1, %2\n\t"
98                 SMP_NOP2        /* Sun4m + Cypress + SMP bug */
99                 "andn   %0, %1, %0\n\t"
100                 "wr     %0, %2, %%psr\n\t"
101                 "nop; nop; nop\n"
102                 : "=&r" (tmp)
103                 : "i" (PSR_PIL), "r" (old_psr)
104                 : "memory");
105 }
106
107 EXPORT_SYMBOL(__raw_local_irq_save);
108 EXPORT_SYMBOL(raw_local_irq_enable);
109 EXPORT_SYMBOL(raw_local_irq_restore);
110
111 /*
112  * Dave Redman (djhr@tadpole.co.uk)
113  *
114  * IRQ numbers.. These are no longer restricted to 15..
115  *
116  * this is done to enable SBUS cards and onboard IO to be masked
117  * correctly. using the interrupt level isn't good enough.
118  *
119  * For example:
120  *   A device interrupting at sbus level6 and the Floppy both come in
121  *   at IRQ11, but enabling and disabling them requires writing to
122  *   different bits in the SLAVIO/SEC.
123  *
124  * As a result of these changes sun4m machines could now support
125  * directed CPU interrupts using the existing enable/disable irq code
126  * with tweaks.
127  *
128  */
129
130 static void irq_panic(void)
131 {
132     extern char *cputypval;
133     prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
134     prom_halt();
135 }
136
137 void (*sparc_init_timers)(irq_handler_t ) =
138     (void (*)(irq_handler_t )) irq_panic;
139
140 /*
141  * Dave Redman (djhr@tadpole.co.uk)
142  *
143  * There used to be extern calls and hard coded values here.. very sucky!
144  * instead, because some of the devices attach very early, I do something
145  * equally sucky but at least we'll never try to free statically allocated
146  * space or call kmalloc before kmalloc_init :(.
147  * 
148  * In fact it's the timer10 that attaches first.. then timer14
149  * then kmalloc_init is called.. then the tty interrupts attach.
150  * hmmm....
151  *
152  */
153 #define MAX_STATIC_ALLOC        4
154 struct irqaction static_irqaction[MAX_STATIC_ALLOC];
155 int static_irq_count;
156
157 static struct {
158         struct irqaction *action;
159         int flags;
160 } sparc_irq[NR_IRQS];
161 #define SPARC_IRQ_INPROGRESS 1
162
163 /* Used to protect the IRQ action lists */
164 DEFINE_SPINLOCK(irq_action_lock);
165
166 int show_interrupts(struct seq_file *p, void *v)
167 {
168         int i = *(loff_t *) v;
169         struct irqaction * action;
170         unsigned long flags;
171 #ifdef CONFIG_SMP
172         int j;
173 #endif
174
175         if (sparc_cpu_model == sun4d) {
176                 extern int show_sun4d_interrupts(struct seq_file *, void *);
177                 
178                 return show_sun4d_interrupts(p, v);
179         }
180         spin_lock_irqsave(&irq_action_lock, flags);
181         if (i < NR_IRQS) {
182                 action = sparc_irq[i].action;
183                 if (!action) 
184                         goto out_unlock;
185                 seq_printf(p, "%3d: ", i);
186 #ifndef CONFIG_SMP
187                 seq_printf(p, "%10u ", kstat_irqs(i));
188 #else
189                 for_each_online_cpu(j) {
190                         seq_printf(p, "%10u ",
191                                     kstat_cpu(j).irqs[i]);
192                 }
193 #endif
194                 seq_printf(p, " %c %s",
195                         (action->flags & IRQF_DISABLED) ? '+' : ' ',
196                         action->name);
197                 for (action=action->next; action; action = action->next) {
198                         seq_printf(p, ",%s %s",
199                                 (action->flags & IRQF_DISABLED) ? " +" : "",
200                                 action->name);
201                 }
202                 seq_putc(p, '\n');
203         }
204 out_unlock:
205         spin_unlock_irqrestore(&irq_action_lock, flags);
206         return 0;
207 }
208
209 void free_irq(unsigned int irq, void *dev_id)
210 {
211         struct irqaction * action;
212         struct irqaction **actionp;
213         unsigned long flags;
214         unsigned int cpu_irq;
215         
216         if (sparc_cpu_model == sun4d) {
217                 extern void sun4d_free_irq(unsigned int, void *);
218                 
219                 sun4d_free_irq(irq, dev_id);
220                 return;
221         }
222         cpu_irq = irq & (NR_IRQS - 1);
223         if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
224                 printk("Trying to free bogus IRQ %d\n", irq);
225                 return;
226         }
227
228         spin_lock_irqsave(&irq_action_lock, flags);
229
230         actionp = &sparc_irq[cpu_irq].action;
231         action = *actionp;
232
233         if (!action->handler) {
234                 printk("Trying to free free IRQ%d\n",irq);
235                 goto out_unlock;
236         }
237         if (dev_id) {
238                 for (; action; action = action->next) {
239                         if (action->dev_id == dev_id)
240                                 break;
241                         actionp = &action->next;
242                 }
243                 if (!action) {
244                         printk("Trying to free free shared IRQ%d\n",irq);
245                         goto out_unlock;
246                 }
247         } else if (action->flags & IRQF_SHARED) {
248                 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
249                 goto out_unlock;
250         }
251         if (action->flags & SA_STATIC_ALLOC)
252         {
253                 /* This interrupt is marked as specially allocated
254                  * so it is a bad idea to free it.
255                  */
256                 printk("Attempt to free statically allocated IRQ%d (%s)\n",
257                        irq, action->name);
258                 goto out_unlock;
259         }
260
261         *actionp = action->next;
262
263         spin_unlock_irqrestore(&irq_action_lock, flags);
264
265         synchronize_irq(irq);
266
267         spin_lock_irqsave(&irq_action_lock, flags);
268
269         kfree(action);
270
271         if (!sparc_irq[cpu_irq].action)
272                 __disable_irq(irq);
273
274 out_unlock:
275         spin_unlock_irqrestore(&irq_action_lock, flags);
276 }
277
278 EXPORT_SYMBOL(free_irq);
279
280 /*
281  * This is called when we want to synchronize with
282  * interrupts. We may for example tell a device to
283  * stop sending interrupts: but to make sure there
284  * are no interrupts that are executing on another
285  * CPU we need to call this function.
286  */
287 #ifdef CONFIG_SMP
288 void synchronize_irq(unsigned int irq)
289 {
290         unsigned int cpu_irq;
291
292         cpu_irq = irq & (NR_IRQS - 1);
293         while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
294                 cpu_relax();
295 }
296 #endif /* SMP */
297
298 void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
299 {
300         int i;
301         struct irqaction * action;
302         unsigned int cpu_irq;
303         
304         cpu_irq = irq & (NR_IRQS - 1);
305         action = sparc_irq[cpu_irq].action;
306
307         printk("IO device interrupt, irq = %d\n", irq);
308         printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 
309                     regs->npc, regs->u_regs[14]);
310         if (action) {
311                 printk("Expecting: ");
312                 for (i = 0; i < 16; i++)
313                         if (action->handler)
314                                 printk("[%s:%d:0x%x] ", action->name,
315                                        (int) i, (unsigned int) action->handler);
316         }
317         printk("AIEEE\n");
318         panic("bogus interrupt received");
319 }
320
321 void handler_irq(int irq, struct pt_regs * regs)
322 {
323         struct pt_regs *old_regs;
324         struct irqaction * action;
325         int cpu = smp_processor_id();
326 #ifdef CONFIG_SMP
327         extern void smp4m_irq_rotate(int cpu);
328 #endif
329
330         old_regs = set_irq_regs(regs);
331         irq_enter();
332         disable_pil_irq(irq);
333 #ifdef CONFIG_SMP
334         /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
335         if((sparc_cpu_model==sun4m) && (irq < 10))
336                 smp4m_irq_rotate(cpu);
337 #endif
338         action = sparc_irq[irq].action;
339         sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
340         kstat_cpu(cpu).irqs[irq]++;
341         do {
342                 if (!action || !action->handler)
343                         unexpected_irq(irq, NULL, regs);
344                 action->handler(irq, action->dev_id);
345                 action = action->next;
346         } while (action);
347         sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
348         enable_pil_irq(irq);
349         irq_exit();
350         set_irq_regs(old_regs);
351 }
352
353 #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)
354
355 /* Fast IRQs on the Sparc can only have one routine attached to them,
356  * thus no sharing possible.
357  */
358 static int request_fast_irq(unsigned int irq,
359                             void (*handler)(void),
360                             unsigned long irqflags, const char *devname)
361 {
362         struct irqaction *action;
363         unsigned long flags;
364         unsigned int cpu_irq;
365         int ret;
366 #ifdef CONFIG_SMP
367         struct tt_entry *trap_table;
368         extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
369 #endif
370         
371         cpu_irq = irq & (NR_IRQS - 1);
372         if(cpu_irq > 14) {
373                 ret = -EINVAL;
374                 goto out;
375         }
376         if(!handler) {
377                 ret = -EINVAL;
378                 goto out;
379         }
380
381         spin_lock_irqsave(&irq_action_lock, flags);
382
383         action = sparc_irq[cpu_irq].action;
384         if(action) {
385                 if(action->flags & IRQF_SHARED)
386                         panic("Trying to register fast irq when already shared.\n");
387                 if(irqflags & IRQF_SHARED)
388                         panic("Trying to register fast irq as shared.\n");
389
390                 /* Anyway, someone already owns it so cannot be made fast. */
391                 printk("request_fast_irq: Trying to register yet already owned.\n");
392                 ret = -EBUSY;
393                 goto out_unlock;
394         }
395
396         /* If this is flagged as statically allocated then we use our
397          * private struct which is never freed.
398          */
399         if (irqflags & SA_STATIC_ALLOC) {
400             if (static_irq_count < MAX_STATIC_ALLOC)
401                 action = &static_irqaction[static_irq_count++];
402             else
403                 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
404                        irq, devname);
405         }
406         
407         if (action == NULL)
408             action = kmalloc(sizeof(struct irqaction),
409                                                  GFP_ATOMIC);
410         
411         if (!action) { 
412                 ret = -ENOMEM;
413                 goto out_unlock;
414         }
415
416         /* Dork with trap table if we get this far. */
417 #define INSTANTIATE(table) \
418         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
419         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
420                 SPARC_BRANCH((unsigned long) handler, \
421                              (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
422         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
423         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
424
425         INSTANTIATE(sparc_ttable)
426 #ifdef CONFIG_SMP
427         trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
428         trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
429         trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
430 #endif
431 #undef INSTANTIATE
432         /*
433          * XXX Correct thing whould be to flush only I- and D-cache lines
434          * which contain the handler in question. But as of time of the
435          * writing we have no CPU-neutral interface to fine-grained flushes.
436          */
437         flush_cache_all();
438
439         action->flags = irqflags;
440         cpus_clear(action->mask);
441         action->name = devname;
442         action->dev_id = NULL;
443         action->next = NULL;
444
445         sparc_irq[cpu_irq].action = action;
446
447         __enable_irq(irq);
448
449         ret = 0;
450 out_unlock:
451         spin_unlock_irqrestore(&irq_action_lock, flags);
452 out:
453         return ret;
454 }
455
456 /* These variables are used to access state from the assembler
457  * interrupt handler, floppy_hardint, so we cannot put these in
458  * the floppy driver image because that would not work in the
459  * modular case.
460  */
461 volatile unsigned char *fdc_status;
462 EXPORT_SYMBOL(fdc_status);
463
464 char *pdma_vaddr;
465 EXPORT_SYMBOL(pdma_vaddr);
466
467 unsigned long pdma_size;
468 EXPORT_SYMBOL(pdma_size);
469
470 volatile int doing_pdma;
471 EXPORT_SYMBOL(doing_pdma);
472
473 char *pdma_base;
474 EXPORT_SYMBOL(pdma_base);
475
476 unsigned long pdma_areasize;
477 EXPORT_SYMBOL(pdma_areasize);
478
479 extern void floppy_hardint(void);
480
481 static irq_handler_t floppy_irq_handler;
482
483 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
484 {
485         struct pt_regs *old_regs;
486         int cpu = smp_processor_id();
487
488         old_regs = set_irq_regs(regs);
489         disable_pil_irq(irq);
490         irq_enter();
491         kstat_cpu(cpu).irqs[irq]++;
492         floppy_irq_handler(irq, dev_id);
493         irq_exit();
494         enable_pil_irq(irq);
495         set_irq_regs(old_regs);
496         // XXX Eek, it's totally changed with preempt_count() and such
497         // if (softirq_pending(cpu))
498         //      do_softirq();
499 }
500
501 int sparc_floppy_request_irq(int irq, unsigned long flags,
502                              irq_handler_t irq_handler)
503 {
504         floppy_irq_handler = irq_handler;
505         return request_fast_irq(irq, floppy_hardint, flags, "floppy");
506 }
507 EXPORT_SYMBOL(sparc_floppy_request_irq);
508
509 #endif
510
511 int request_irq(unsigned int irq,
512                 irq_handler_t handler,
513                 unsigned long irqflags, const char * devname, void *dev_id)
514 {
515         struct irqaction * action, **actionp;
516         unsigned long flags;
517         unsigned int cpu_irq;
518         int ret;
519         
520         if (sparc_cpu_model == sun4d) {
521                 extern int sun4d_request_irq(unsigned int, 
522                                              irq_handler_t ,
523                                              unsigned long, const char *, void *);
524                 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
525         }
526         cpu_irq = irq & (NR_IRQS - 1);
527         if(cpu_irq > 14) {
528                 ret = -EINVAL;
529                 goto out;
530         }
531         if (!handler) {
532                 ret = -EINVAL;
533                 goto out;
534         }
535             
536         spin_lock_irqsave(&irq_action_lock, flags);
537
538         actionp = &sparc_irq[cpu_irq].action;
539         action = *actionp;
540         if (action) {
541                 if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
542                         ret = -EBUSY;
543                         goto out_unlock;
544                 }
545                 if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
546                         printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
547                         ret = -EBUSY;
548                         goto out_unlock;
549                 }
550                 for ( ; action; action = *actionp)
551                         actionp = &action->next;
552         }
553
554         /* If this is flagged as statically allocated then we use our
555          * private struct which is never freed.
556          */
557         if (irqflags & SA_STATIC_ALLOC) {
558                 if (static_irq_count < MAX_STATIC_ALLOC)
559                         action = &static_irqaction[static_irq_count++];
560                 else
561                         printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
562         }
563         
564         if (action == NULL)
565                 action = kmalloc(sizeof(struct irqaction),
566                                                      GFP_ATOMIC);
567         
568         if (!action) { 
569                 ret = -ENOMEM;
570                 goto out_unlock;
571         }
572
573         action->handler = handler;
574         action->flags = irqflags;
575         cpus_clear(action->mask);
576         action->name = devname;
577         action->next = NULL;
578         action->dev_id = dev_id;
579
580         *actionp = action;
581
582         __enable_irq(irq);
583
584         ret = 0;
585 out_unlock:
586         spin_unlock_irqrestore(&irq_action_lock, flags);
587 out:
588         return ret;
589 }
590
591 EXPORT_SYMBOL(request_irq);
592
593 void disable_irq_nosync(unsigned int irq)
594 {
595         return __disable_irq(irq);
596 }
597 EXPORT_SYMBOL(disable_irq_nosync);
598
599 void disable_irq(unsigned int irq)
600 {
601         return __disable_irq(irq);
602 }
603 EXPORT_SYMBOL(disable_irq);
604
605 void enable_irq(unsigned int irq)
606 {
607         return __enable_irq(irq);
608 }
609
610 EXPORT_SYMBOL(enable_irq);
611
612 /* We really don't need these at all on the Sparc.  We only have
613  * stubs here because they are exported to modules.
614  */
615 unsigned long probe_irq_on(void)
616 {
617         return 0;
618 }
619
620 EXPORT_SYMBOL(probe_irq_on);
621
622 int probe_irq_off(unsigned long mask)
623 {
624         return 0;
625 }
626
627 EXPORT_SYMBOL(probe_irq_off);
628
629 /* djhr
630  * This could probably be made indirect too and assigned in the CPU
631  * bits of the code. That would be much nicer I think and would also
632  * fit in with the idea of being able to tune your kernel for your machine
633  * by removing unrequired machine and device support.
634  *
635  */
636
637 void __init init_IRQ(void)
638 {
639         extern void sun4c_init_IRQ( void );
640         extern void sun4m_init_IRQ( void );
641         extern void sun4d_init_IRQ( void );
642
643         switch(sparc_cpu_model) {
644         case sun4c:
645         case sun4:
646                 sun4c_init_IRQ();
647                 break;
648
649         case sun4m:
650 #ifdef CONFIG_PCI
651                 pcic_probe();
652                 if (pcic_present()) {
653                         sun4m_pci_init_IRQ();
654                         break;
655                 }
656 #endif
657                 sun4m_init_IRQ();
658                 break;
659                 
660         case sun4d:
661                 sun4d_init_IRQ();
662                 break;
663
664         default:
665                 prom_printf("Cannot initialize IRQs on this Sun machine...");
666                 break;
667         }
668         btfixup();
669 }
670
671 void init_irq_proc(void)
672 {
673         /* For now, nothing... */
674 }