Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / arch / sparc / kernel / irq.c
1 /*  $Id: irq.c,v 1.114 2001/12/11 04:55:51 davem Exp $
2  *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
3  *                            Sparc the IRQ's 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/config.h>
15 #include <linux/module.h>
16 #include <linux/sched.h>
17 #include <linux/ptrace.h>
18 #include <linux/errno.h>
19 #include <linux/linkage.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/signal.h>
22 #include <linux/sched.h>
23 #include <linux/interrupt.h>
24 #include <linux/slab.h>
25 #include <linux/random.h>
26 #include <linux/init.h>
27 #include <linux/smp.h>
28 #include <linux/smp_lock.h>
29 #include <linux/delay.h>
30 #include <linux/threads.h>
31 #include <linux/spinlock.h>
32 #include <linux/seq_file.h>
33
34 #include <asm/ptrace.h>
35 #include <asm/processor.h>
36 #include <asm/system.h>
37 #include <asm/psr.h>
38 #include <asm/smp.h>
39 #include <asm/vaddrs.h>
40 #include <asm/timer.h>
41 #include <asm/openprom.h>
42 #include <asm/oplib.h>
43 #include <asm/traps.h>
44 #include <asm/irq.h>
45 #include <asm/io.h>
46 #include <asm/pgalloc.h>
47 #include <asm/pgtable.h>
48 #include <asm/pcic.h>
49 #include <asm/cacheflush.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 __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 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 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(__local_irq_save);
108 EXPORT_SYMBOL(local_irq_enable);
109 EXPORT_SYMBOL(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)(irqreturn_t (*)(int, void *,struct pt_regs *)) =
138     (void (*)(irqreturn_t (*)(int, void *,struct pt_regs *))) 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 struct irqaction *irq_action[NR_IRQS] = {
158         [0 ... (NR_IRQS-1)] = NULL
159 };
160
161 /* Used to protect the IRQ action lists */
162 DEFINE_SPINLOCK(irq_action_lock);
163
164 int show_interrupts(struct seq_file *p, void *v)
165 {
166         int i = *(loff_t *) v;
167         struct irqaction * action;
168         unsigned long flags;
169 #ifdef CONFIG_SMP
170         int j;
171 #endif
172
173         if (sparc_cpu_model == sun4d) {
174                 extern int show_sun4d_interrupts(struct seq_file *, void *);
175                 
176                 return show_sun4d_interrupts(p, v);
177         }
178         spin_lock_irqsave(&irq_action_lock, flags);
179         if (i < NR_IRQS) {
180                 action = *(i + irq_action);
181                 if (!action) 
182                         goto out_unlock;
183                 seq_printf(p, "%3d: ", i);
184 #ifndef CONFIG_SMP
185                 seq_printf(p, "%10u ", kstat_irqs(i));
186 #else
187                 for (j = 0; j < NR_CPUS; j++) {
188                         if (cpu_online(j))
189                                 seq_printf(p, "%10u ",
190                                     kstat_cpu(cpu_logical_map(j)).irqs[i]);
191                 }
192 #endif
193                 seq_printf(p, " %c %s",
194                         (action->flags & SA_INTERRUPT) ? '+' : ' ',
195                         action->name);
196                 for (action=action->next; action; action = action->next) {
197                         seq_printf(p, ",%s %s",
198                                 (action->flags & SA_INTERRUPT) ? " +" : "",
199                                 action->name);
200                 }
201                 seq_putc(p, '\n');
202         }
203 out_unlock:
204         spin_unlock_irqrestore(&irq_action_lock, flags);
205         return 0;
206 }
207
208 void free_irq(unsigned int irq, void *dev_id)
209 {
210         struct irqaction * action;
211         struct irqaction * tmp = NULL;
212         unsigned long flags;
213         unsigned int cpu_irq;
214         
215         if (sparc_cpu_model == sun4d) {
216                 extern void sun4d_free_irq(unsigned int, void *);
217                 
218                 sun4d_free_irq(irq, dev_id);
219                 return;
220         }
221         cpu_irq = irq & (NR_IRQS - 1);
222         if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
223                 printk("Trying to free bogus IRQ %d\n", irq);
224                 return;
225         }
226
227         spin_lock_irqsave(&irq_action_lock, flags);
228
229         action = *(cpu_irq + irq_action);
230
231         if (!action->handler) {
232                 printk("Trying to free free IRQ%d\n",irq);
233                 goto out_unlock;
234         }
235         if (dev_id) {
236                 for (; action; action = action->next) {
237                         if (action->dev_id == dev_id)
238                                 break;
239                         tmp = action;
240                 }
241                 if (!action) {
242                         printk("Trying to free free shared IRQ%d\n",irq);
243                         goto out_unlock;
244                 }
245         } else if (action->flags & SA_SHIRQ) {
246                 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
247                 goto out_unlock;
248         }
249         if (action->flags & SA_STATIC_ALLOC)
250         {
251                 /* This interrupt is marked as specially allocated
252                  * so it is a bad idea to free it.
253                  */
254                 printk("Attempt to free statically allocated IRQ%d (%s)\n",
255                        irq, action->name);
256                 goto out_unlock;
257         }
258         
259         if (action && tmp)
260                 tmp->next = action->next;
261         else
262                 *(cpu_irq + irq_action) = action->next;
263
264         spin_unlock_irqrestore(&irq_action_lock, flags);
265
266         synchronize_irq(irq);
267
268         spin_lock_irqsave(&irq_action_lock, flags);
269
270         kfree(action);
271
272         if (!(*(cpu_irq + irq_action)))
273                 disable_irq(irq);
274
275 out_unlock:
276         spin_unlock_irqrestore(&irq_action_lock, flags);
277 }
278
279 EXPORT_SYMBOL(free_irq);
280
281 /*
282  * This is called when we want to synchronize with
283  * interrupts. We may for example tell a device to
284  * stop sending interrupts: but to make sure there
285  * are no interrupts that are executing on another
286  * CPU we need to call this function.
287  */
288 #ifdef CONFIG_SMP
289 void synchronize_irq(unsigned int irq)
290 {
291         printk("synchronize_irq says: implement me!\n");
292         BUG();
293 }
294 #endif /* SMP */
295
296 void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
297 {
298         int i;
299         struct irqaction * action;
300         unsigned int cpu_irq;
301         
302         cpu_irq = irq & (NR_IRQS - 1);
303         action = *(cpu_irq + irq_action);
304
305         printk("IO device interrupt, irq = %d\n", irq);
306         printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 
307                     regs->npc, regs->u_regs[14]);
308         if (action) {
309                 printk("Expecting: ");
310                 for (i = 0; i < 16; i++)
311                         if (action->handler)
312                                 printk("[%s:%d:0x%x] ", action->name,
313                                        (int) i, (unsigned int) action->handler);
314         }
315         printk("AIEEE\n");
316         panic("bogus interrupt received");
317 }
318
319 void handler_irq(int irq, struct pt_regs * regs)
320 {
321         struct irqaction * action;
322         int cpu = smp_processor_id();
323 #ifdef CONFIG_SMP
324         extern void smp4m_irq_rotate(int cpu);
325 #endif
326
327         irq_enter();
328         disable_pil_irq(irq);
329 #ifdef CONFIG_SMP
330         /* Only rotate on lower priority IRQ's (scsi, ethernet, etc.). */
331         if(irq < 10)
332                 smp4m_irq_rotate(cpu);
333 #endif
334         action = *(irq + irq_action);
335         kstat_cpu(cpu).irqs[irq]++;
336         do {
337                 if (!action || !action->handler)
338                         unexpected_irq(irq, NULL, regs);
339                 action->handler(irq, action->dev_id, regs);
340                 action = action->next;
341         } while (action);
342         enable_pil_irq(irq);
343         irq_exit();
344 }
345
346 #ifdef CONFIG_BLK_DEV_FD
347 extern void floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
348
349 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
350 {
351         int cpu = smp_processor_id();
352
353         disable_pil_irq(irq);
354         irq_enter();
355         kstat_cpu(cpu).irqs[irq]++;
356         floppy_interrupt(irq, dev_id, regs);
357         irq_exit();
358         enable_pil_irq(irq);
359         // XXX Eek, it's totally changed with preempt_count() and such
360         // if (softirq_pending(cpu))
361         //      do_softirq();
362 }
363 #endif
364
365 /* Fast IRQ's on the Sparc can only have one routine attached to them,
366  * thus no sharing possible.
367  */
368 int request_fast_irq(unsigned int irq,
369                      irqreturn_t (*handler)(int, void *, struct pt_regs *),
370                      unsigned long irqflags, const char *devname)
371 {
372         struct irqaction *action;
373         unsigned long flags;
374         unsigned int cpu_irq;
375         int ret;
376 #ifdef CONFIG_SMP
377         struct tt_entry *trap_table;
378         extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
379 #endif
380         
381         cpu_irq = irq & (NR_IRQS - 1);
382         if(cpu_irq > 14) {
383                 ret = -EINVAL;
384                 goto out;
385         }
386         if(!handler) {
387                 ret = -EINVAL;
388                 goto out;
389         }
390
391         spin_lock_irqsave(&irq_action_lock, flags);
392
393         action = *(cpu_irq + irq_action);
394         if(action) {
395                 if(action->flags & SA_SHIRQ)
396                         panic("Trying to register fast irq when already shared.\n");
397                 if(irqflags & SA_SHIRQ)
398                         panic("Trying to register fast irq as shared.\n");
399
400                 /* Anyway, someone already owns it so cannot be made fast. */
401                 printk("request_fast_irq: Trying to register yet already owned.\n");
402                 ret = -EBUSY;
403                 goto out_unlock;
404         }
405
406         /* If this is flagged as statically allocated then we use our
407          * private struct which is never freed.
408          */
409         if (irqflags & SA_STATIC_ALLOC) {
410             if (static_irq_count < MAX_STATIC_ALLOC)
411                 action = &static_irqaction[static_irq_count++];
412             else
413                 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
414                        irq, devname);
415         }
416         
417         if (action == NULL)
418             action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
419                                                  GFP_ATOMIC);
420         
421         if (!action) { 
422                 ret = -ENOMEM;
423                 goto out_unlock;
424         }
425
426         /* Dork with trap table if we get this far. */
427 #define INSTANTIATE(table) \
428         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
429         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
430                 SPARC_BRANCH((unsigned long) handler, \
431                              (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
432         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
433         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
434
435         INSTANTIATE(sparc_ttable)
436 #ifdef CONFIG_SMP
437         trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
438         trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
439         trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
440 #endif
441 #undef INSTANTIATE
442         /*
443          * XXX Correct thing whould be to flush only I- and D-cache lines
444          * which contain the handler in question. But as of time of the
445          * writing we have no CPU-neutral interface to fine-grained flushes.
446          */
447         flush_cache_all();
448
449         action->handler = handler;
450         action->flags = irqflags;
451         cpus_clear(action->mask);
452         action->name = devname;
453         action->dev_id = NULL;
454         action->next = NULL;
455
456         *(cpu_irq + irq_action) = action;
457
458         enable_irq(irq);
459
460         ret = 0;
461 out_unlock:
462         spin_unlock_irqrestore(&irq_action_lock, flags);
463 out:
464         return ret;
465 }
466
467 int request_irq(unsigned int irq,
468                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
469                 unsigned long irqflags, const char * devname, void *dev_id)
470 {
471         struct irqaction * action, *tmp = NULL;
472         unsigned long flags;
473         unsigned int cpu_irq;
474         int ret;
475         
476         if (sparc_cpu_model == sun4d) {
477                 extern int sun4d_request_irq(unsigned int, 
478                                              irqreturn_t (*)(int, void *, struct pt_regs *),
479                                              unsigned long, const char *, void *);
480                 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
481         }
482         cpu_irq = irq & (NR_IRQS - 1);
483         if(cpu_irq > 14) {
484                 ret = -EINVAL;
485                 goto out;
486         }
487         if (!handler) {
488                 ret = -EINVAL;
489                 goto out;
490         }
491             
492         spin_lock_irqsave(&irq_action_lock, flags);
493
494         action = *(cpu_irq + irq_action);
495         if (action) {
496                 if ((action->flags & SA_SHIRQ) && (irqflags & SA_SHIRQ)) {
497                         for (tmp = action; tmp->next; tmp = tmp->next);
498                 } else {
499                         ret = -EBUSY;
500                         goto out_unlock;
501                 }
502                 if ((action->flags & SA_INTERRUPT) ^ (irqflags & SA_INTERRUPT)) {
503                         printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
504                         ret = -EBUSY;
505                         goto out_unlock;
506                 }   
507                 action = NULL;          /* Or else! */
508         }
509
510         /* If this is flagged as statically allocated then we use our
511          * private struct which is never freed.
512          */
513         if (irqflags & SA_STATIC_ALLOC) {
514                 if (static_irq_count < MAX_STATIC_ALLOC)
515                         action = &static_irqaction[static_irq_count++];
516                 else
517                         printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
518         }
519         
520         if (action == NULL)
521                 action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
522                                                      GFP_ATOMIC);
523         
524         if (!action) { 
525                 ret = -ENOMEM;
526                 goto out_unlock;
527         }
528
529         action->handler = handler;
530         action->flags = irqflags;
531         cpus_clear(action->mask);
532         action->name = devname;
533         action->next = NULL;
534         action->dev_id = dev_id;
535
536         if (tmp)
537                 tmp->next = action;
538         else
539                 *(cpu_irq + irq_action) = action;
540
541         enable_irq(irq);
542
543         ret = 0;
544 out_unlock:
545         spin_unlock_irqrestore(&irq_action_lock, flags);
546 out:
547         return ret;
548 }
549
550 EXPORT_SYMBOL(request_irq);
551
552 /* We really don't need these at all on the Sparc.  We only have
553  * stubs here because they are exported to modules.
554  */
555 unsigned long probe_irq_on(void)
556 {
557         return 0;
558 }
559
560 EXPORT_SYMBOL(probe_irq_on);
561
562 int probe_irq_off(unsigned long mask)
563 {
564         return 0;
565 }
566
567 EXPORT_SYMBOL(probe_irq_off);
568
569 /* djhr
570  * This could probably be made indirect too and assigned in the CPU
571  * bits of the code. That would be much nicer I think and would also
572  * fit in with the idea of being able to tune your kernel for your machine
573  * by removing unrequired machine and device support.
574  *
575  */
576
577 void __init init_IRQ(void)
578 {
579         extern void sun4c_init_IRQ( void );
580         extern void sun4m_init_IRQ( void );
581         extern void sun4d_init_IRQ( void );
582
583         switch(sparc_cpu_model) {
584         case sun4c:
585         case sun4:
586                 sun4c_init_IRQ();
587                 break;
588
589         case sun4m:
590 #ifdef CONFIG_PCI
591                 pcic_probe();
592                 if (pcic_present()) {
593                         sun4m_pci_init_IRQ();
594                         break;
595                 }
596 #endif
597                 sun4m_init_IRQ();
598                 break;
599                 
600         case sun4d:
601                 sun4d_init_IRQ();
602                 break;
603
604         default:
605                 prom_printf("Cannot initialize IRQ's on this Sun machine...");
606                 break;
607         }
608         btfixup();
609 }
610
611 void init_irq_proc(void)
612 {
613         /* For now, nothing... */
614 }