PPC fixes for SMP; also fix the stack overflow detection, remove
[opensuse:kernel.git] / arch / ppc / kernel / irq.c
1 /*
2  * BK Id: %F% %I% %G% %U% %#%
3  */
4 /*
5  *  arch/ppc/kernel/irq.c
6  *
7  *  Derived from arch/i386/kernel/irq.c
8  *    Copyright (C) 1992 Linus Torvalds
9  *  Adapted from arch/i386 by Gary Thomas
10  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
11  *  Updated and modified by Cort Dougan <cort@fsmlabs.com>
12  *    Copyright (C) 1996-2001 Cort Dougan
13  *  Adapted for Power Macintosh by Paul Mackerras
14  *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
15  *  Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
16  *  
17  * This file contains the code used by various IRQ handling routines:
18  * asking for different IRQ's should be done through these routines
19  * instead of just grabbing them. Thus setups with different IRQ numbers
20  * shouldn't result in any weird surprises, and installing new handlers
21  * should be easier.
22  *
23  * The MPC8xx has an interrupt mask in the SIU.  If a bit is set, the
24  * interrupt is _enabled_.  As expected, IRQ0 is bit 0 in the 32-bit
25  * mask register (of which only 16 are defined), hence the weird shifting
26  * and compliment of the cached_irq_mask.  I want to be able to stuff
27  * this right into the SIU SMASK register.
28  * Many of the prep/chrp functions are conditional compiled on CONFIG_8xx
29  * to reduce code space and undefined function references.
30  */
31
32
33 #include <linux/ptrace.h>
34 #include <linux/errno.h>
35 #include <linux/threads.h>
36 #include <linux/kernel_stat.h>
37 #include <linux/signal.h>
38 #include <linux/sched.h>
39 #include <linux/ioport.h>
40 #include <linux/interrupt.h>
41 #include <linux/timex.h>
42 #include <linux/config.h>
43 #include <linux/init.h>
44 #include <linux/slab.h>
45 #include <linux/pci.h>
46 #include <linux/delay.h>
47 #include <linux/irq.h>
48 #include <linux/proc_fs.h>
49 #include <linux/random.h>
50 #include <linux/seq_file.h>
51
52 #include <asm/uaccess.h>
53 #include <asm/bitops.h>
54 #include <asm/system.h>
55 #include <asm/io.h>
56 #include <asm/pgtable.h>
57 #include <asm/irq.h>
58 #include <asm/cache.h>
59 #include <asm/prom.h>
60 #include <asm/ptrace.h>
61
62 #define NR_MASK_WORDS   ((NR_IRQS + 31) / 32)
63
64 extern atomic_t ipi_recv;
65 extern atomic_t ipi_sent;
66 void enable_irq(unsigned int irq_nr);
67 void disable_irq(unsigned int irq_nr);
68
69 static void register_irq_proc (unsigned int irq);
70
71 #define MAXCOUNT 10000000
72
73 irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned =
74         { [0 ... NR_IRQS-1] = { 0, NULL, NULL, 0, SPIN_LOCK_UNLOCKED}};
75         
76 int ppc_spurious_interrupts = 0;
77 struct irqaction *ppc_irq_action[NR_IRQS];
78 unsigned long ppc_cached_irq_mask[NR_MASK_WORDS];
79 unsigned long ppc_lost_interrupts[NR_MASK_WORDS];
80 atomic_t ppc_n_lost_interrupts;
81
82 /* nasty hack for shared irq's since we need to do kmalloc calls but
83  * can't very early in the boot when we need to do a request irq.
84  * this needs to be removed.
85  * -- Cort
86  */
87 #define IRQ_KMALLOC_ENTRIES 8
88 static int cache_bitmask = 0;
89 static struct irqaction malloc_cache[IRQ_KMALLOC_ENTRIES];
90 extern int mem_init_done;
91
92 #if defined(CONFIG_TAU_INT)
93 extern int tau_interrupts(unsigned long cpu);
94 extern int tau_initialized;
95 #endif
96
97 void *irq_kmalloc(size_t size, int pri)
98 {
99         unsigned int i;
100         if ( mem_init_done )
101                 return kmalloc(size,pri);
102         for ( i = 0; i < IRQ_KMALLOC_ENTRIES ; i++ )
103                 if ( ! ( cache_bitmask & (1<<i) ) )
104                 {
105                         cache_bitmask |= (1<<i);
106                         return (void *)(&malloc_cache[i]);
107                 }
108         return 0;
109 }
110
111 void irq_kfree(void *ptr)
112 {
113         unsigned int i;
114         for ( i = 0 ; i < IRQ_KMALLOC_ENTRIES ; i++ )
115                 if ( ptr == &malloc_cache[i] )
116                 {
117                         cache_bitmask &= ~(1<<i);
118                         return;
119                 }
120         kfree(ptr);
121 }
122
123 int
124 setup_irq(unsigned int irq, struct irqaction * new)
125 {
126         int shared = 0;
127         unsigned long flags;
128         struct irqaction *old, **p;
129         irq_desc_t *desc = irq_desc + irq;
130
131         /*
132          * Some drivers like serial.c use request_irq() heavily,
133          * so we have to be careful not to interfere with a
134          * running system.
135          */
136         if (new->flags & SA_SAMPLE_RANDOM) {
137                 /*
138                  * This function might sleep, we want to call it first,
139                  * outside of the atomic block.
140                  * Yes, this might clear the entropy pool if the wrong
141                  * driver is attempted to be loaded, without actually
142                  * installing a new handler, but is this really a problem,
143                  * only the sysadmin is able to do this.
144                  */
145                 rand_initialize_irq(irq);
146         }
147
148         /*
149          * The following block of code has to be executed atomically
150          */
151         spin_lock_irqsave(&desc->lock,flags);
152         p = &desc->action;
153         if ((old = *p) != NULL) {
154                 /* Can't share interrupts unless both agree to */
155                 if (!(old->flags & new->flags & SA_SHIRQ)) {
156                         spin_unlock_irqrestore(&desc->lock,flags);
157                         return -EBUSY;
158                 }
159
160                 /* add new interrupt at end of irq queue */
161                 do {
162                         p = &old->next;
163                         old = *p;
164                 } while (old);
165                 shared = 1;
166         }
167
168         *p = new;
169
170         if (!shared) {
171                 desc->depth = 0;
172                 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
173                 unmask_irq(irq);
174         }
175         spin_unlock_irqrestore(&desc->lock,flags);
176
177         register_irq_proc(irq);
178         return 0;
179 }
180
181 #if (defined(CONFIG_8xx) || defined(CONFIG_8260))
182 /* Name change so we can catch standard drivers that potentially mess up
183  * the internal interrupt controller on 8xx and 8260.  Just bear with me,
184  * I don't like this either and I am searching a better solution.  For
185  * now, this is what I need. -- Dan
186  */
187 #define request_irq     request_8xxirq
188 #endif
189
190 void free_irq(unsigned int irq, void* dev_id)
191 {
192         irq_desc_t *desc;
193         struct irqaction **p;
194         unsigned long flags;
195
196         desc = irq_desc + irq;
197         spin_lock_irqsave(&desc->lock,flags);
198         p = &desc->action;
199         for (;;) {
200                 struct irqaction * action = *p;
201                 if (action) {
202                         struct irqaction **pp = p;
203                         p = &action->next;
204                         if (action->dev_id != dev_id)
205                                 continue;
206
207                         /* Found it - now remove it from the list of entries */
208                         *pp = action->next;
209                         if (!desc->action) {
210                                 desc->status |= IRQ_DISABLED;
211                                 mask_irq(irq);
212                         }
213                         spin_unlock_irqrestore(&desc->lock,flags);
214
215 #ifdef CONFIG_SMP
216                         /* Wait to make sure it's not being used on another CPU */
217                         while (desc->status & IRQ_INPROGRESS)
218                                 barrier();
219 #endif
220                         irq_kfree(action);
221                         return;
222                 }
223                 printk("Trying to free free IRQ%d\n",irq);
224                 spin_unlock_irqrestore(&desc->lock,flags);
225                 break;
226         }
227         return;
228 }
229
230 int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *),
231         unsigned long irqflags, const char * devname, void *dev_id)
232 {
233         struct irqaction *action;
234         int retval;
235
236         if (irq >= NR_IRQS)
237                 return -EINVAL;
238         if (!handler)
239         {
240                 /*
241                  * free_irq() used to be implemented as a call to
242                  * request_irq() with handler being NULL.  Now we have
243                  * a real free_irq() but need to allow the old behavior
244                  * for old code that hasn't caught up yet.
245                  *  -- Cort <cort@fsmlabs.com>
246                  */
247                 free_irq(irq, dev_id);
248                 return 0;
249         }
250         
251         action = (struct irqaction *)
252                 irq_kmalloc(sizeof(struct irqaction), GFP_KERNEL);
253         if (!action) {
254                 printk(KERN_ERR "irq_kmalloc() failed for irq %d !\n", irq);
255                 return -ENOMEM;
256         }
257         
258         action->handler = handler;
259         action->flags = irqflags;                                       
260         action->mask = 0;
261         action->name = devname;
262         action->dev_id = dev_id;
263         action->next = NULL;
264         
265         retval = setup_irq(irq, action);
266         if (retval)
267         {
268                 kfree(action);
269                 return retval;
270         }
271                 
272         return 0;
273 }
274
275 /*
276  * Generic enable/disable code: this just calls
277  * down into the PIC-specific version for the actual
278  * hardware disable after having gotten the irq
279  * controller lock. 
280  */
281  
282 /**
283  *      disable_irq_nosync - disable an irq without waiting
284  *      @irq: Interrupt to disable
285  *
286  *      Disable the selected interrupt line. Disables of an interrupt
287  *      stack. Unlike disable_irq(), this function does not ensure existing
288  *      instances of the IRQ handler have completed before returning.
289  *
290  *      This function may be called from IRQ context.
291  */
292  
293  void disable_irq_nosync(unsigned int irq)
294 {
295         irq_desc_t *desc = irq_desc + irq;
296         unsigned long flags;
297
298         spin_lock_irqsave(&desc->lock, flags);
299         if (!desc->depth++) {
300                 if (!(desc->status & IRQ_PER_CPU))
301                         desc->status |= IRQ_DISABLED;
302                 mask_irq(irq);
303         }
304         spin_unlock_irqrestore(&desc->lock, flags);
305 }
306
307 /**
308  *      disable_irq - disable an irq and wait for completion
309  *      @irq: Interrupt to disable
310  *
311  *      Disable the selected interrupt line. Disables of an interrupt
312  *      stack. That is for two disables you need two enables. This
313  *      function waits for any pending IRQ handlers for this interrupt
314  *      to complete before returning. If you use this function while
315  *      holding a resource the IRQ handler may need you will deadlock.
316  *
317  *      This function may be called - with care - from IRQ context.
318  */
319  
320 void disable_irq(unsigned int irq)
321 {
322         disable_irq_nosync(irq);
323
324         if (!local_irq_count(smp_processor_id())) {
325                 do {
326                         barrier();
327                 } while (irq_desc[irq].status & IRQ_INPROGRESS);
328         }
329 }
330
331 /**
332  *      enable_irq - enable interrupt handling on an irq
333  *      @irq: Interrupt to enable
334  *
335  *      Re-enables the processing of interrupts on this IRQ line
336  *      providing no disable_irq calls are now in effect.
337  *
338  *      This function may be called from IRQ context.
339  */
340  
341 void enable_irq(unsigned int irq)
342 {
343         irq_desc_t *desc = irq_desc + irq;
344         unsigned long flags;
345
346         spin_lock_irqsave(&desc->lock, flags);
347         switch (desc->depth) {
348         case 1: {
349                 unsigned int status = desc->status & ~IRQ_DISABLED;
350                 desc->status = status;
351                 if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
352                         desc->status = status | IRQ_REPLAY;
353                         hw_resend_irq(desc->handler,irq);
354                 }
355                 unmask_irq(irq);
356                 /* fall-through */
357         }
358         default:
359                 desc->depth--;
360                 break;
361         case 0:
362                 printk("enable_irq(%u) unbalanced\n", irq);
363         }
364         spin_unlock_irqrestore(&desc->lock, flags);
365 }
366
367 int show_interrupts(struct seq_file *p, void *v)
368 {
369         int i, j;
370         struct irqaction * action;
371
372         seq_puts(p, "           ");
373         for (j=0; j<smp_num_cpus; j++)
374                 seq_printf(p, "CPU%d       ", j);
375         seq_putc(p, '\n');
376
377         for (i = 0 ; i < NR_IRQS ; i++) {
378                 action = irq_desc[i].action;
379                 if ( !action || !action->handler )
380                         continue;
381                 seq_printf(p, "%3d: ", i);              
382 #ifdef CONFIG_SMP
383                 for (j = 0; j < smp_num_cpus; j++)
384                         seq_printf(p, "%10u ",
385                                    kstat.irqs[cpu_logical_map(j)][i]);
386 #else           
387                 seq_printf(p, "%10u ", kstat_irqs(i));
388 #endif /* CONFIG_SMP */
389                 if (irq_desc[i].handler)                
390                         seq_printf(p, " %s ", irq_desc[i].handler->typename);
391                 else
392                         seq_puts(p, "  None      ");
393                 seq_printf(p, "%s", (irq_desc[i].status & IRQ_LEVEL) ? "Level " : "Edge  ");
394                 seq_printf(p, "    %s", action->name);
395                 for (action = action->next; action; action = action->next)
396                         seq_printf(p, ", %s", action->name);
397                 seq_putc(p, '\n');
398         }
399 #ifdef CONFIG_TAU_INT
400         if (tau_initialized){
401                 seq_puts(p, "TAU: ");
402                 for (j = 0; j < smp_num_cpus; j++)
403                         seq_printf(p, "%10u ", tau_interrupts(j));
404                 seq_puts(p, "  PowerPC             Thermal Assist (cpu temp)\n");
405         }
406 #endif
407 #ifdef CONFIG_SMP
408         /* should this be per processor send/receive? */
409         seq_printf(p, "IPI (recv/sent): %10u/%u\n",
410                    atomic_read(&ipi_recv), atomic_read(&ipi_sent));
411 #endif          
412         seq_printf(p, "BAD: %10u\n", ppc_spurious_interrupts);
413         return 0;
414 }
415
416 static inline void
417 handle_irq_event(int irq, struct pt_regs *regs, struct irqaction *action)
418 {
419         int status = 0;
420
421         if (!(action->flags & SA_INTERRUPT))
422                 __sti();
423
424         do {
425                 status |= action->flags;
426                 action->handler(irq, action->dev_id, regs);
427                 action = action->next;
428         } while (action);
429         if (status & SA_SAMPLE_RANDOM)
430                 add_interrupt_randomness(irq);
431         __cli();
432 }
433
434 /*
435  * Eventually, this should take an array of interrupts and an array size
436  * so it can dispatch multiple interrupts.
437  */
438 void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
439 {
440         int status;
441         struct irqaction *action;
442         int cpu = smp_processor_id();
443         irq_desc_t *desc = irq_desc + irq;
444
445         kstat.irqs[cpu][irq]++;
446         spin_lock(&desc->lock);
447         ack_irq(irq);   
448         /*
449            REPLAY is when Linux resends an IRQ that was dropped earlier
450            WAITING is used by probe to mark irqs that are being tested
451            */
452         status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
453         if (!(status & IRQ_PER_CPU))
454                 status |= IRQ_PENDING; /* we _want_ to handle it */
455
456         /*
457          * If the IRQ is disabled for whatever reason, we cannot
458          * use the action we have.
459          */
460         action = NULL;
461         if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {
462                 action = desc->action;
463                 if (!action || !action->handler) {
464                         ppc_spurious_interrupts++;
465                         printk(KERN_DEBUG "Unhandled interrupt %x, disabled\n", irq);
466                         /* We can't call disable_irq here, it would deadlock */
467                         ++desc->depth;
468                         desc->status |= IRQ_DISABLED;
469                         mask_irq(irq);
470                         /* This is a real interrupt, we have to eoi it,
471                            so we jump to out */
472                         goto out;
473                 }
474                 status &= ~IRQ_PENDING; /* we commit to handling */
475                 if (!(status & IRQ_PER_CPU))
476                         status |= IRQ_INPROGRESS; /* we are handling it */
477         }
478         desc->status = status;
479
480         /*
481          * If there is no IRQ handler or it was disabled, exit early.
482            Since we set PENDING, if another processor is handling
483            a different instance of this same irq, the other processor
484            will take care of it.
485          */
486         if (!action)
487                 goto out;
488
489
490         /*
491          * Edge triggered interrupts need to remember
492          * pending events.
493          * This applies to any hw interrupts that allow a second
494          * instance of the same irq to arrive while we are in do_IRQ
495          * or in the handler. But the code here only handles the _second_
496          * instance of the irq, not the third or fourth. So it is mostly
497          * useful for irq hardware that does not mask cleanly in an
498          * SMP environment.
499          */
500         for (;;) {
501                 spin_unlock(&desc->lock);
502                 handle_irq_event(irq, regs, action);
503                 spin_lock(&desc->lock);
504                 
505                 if (!(desc->status & IRQ_PENDING))
506                         break;
507                 desc->status &= ~IRQ_PENDING;
508         }
509         desc->status &= ~IRQ_INPROGRESS;
510 out:
511         /*
512          * The ->end() handler has to deal with interrupts which got
513          * disabled while the handler was running.
514          */
515         if (irq_desc[irq].handler) {
516                 if (irq_desc[irq].handler->end)
517                         irq_desc[irq].handler->end(irq);
518                 else if (irq_desc[irq].handler->enable)
519                         irq_desc[irq].handler->enable(irq);
520         }
521         spin_unlock(&desc->lock);
522 }
523
524 #ifndef CONFIG_PPC_ISERIES      /* iSeries version is in iSeries_pic.c */
525 int do_IRQ(struct pt_regs *regs)
526 {
527         int cpu = smp_processor_id();
528         int irq, first = 1;
529         hardirq_enter( cpu );
530
531         /*
532          * Every platform is required to implement ppc_md.get_irq.
533          * This function will either return an irq number or -1 to
534          * indicate there are no more pending.  But the first time
535          * through the loop this means there wasn't and IRQ pending.
536          * The value -2 is for buggy hardware and means that this IRQ
537          * has already been handled. -- Tom
538          */
539         while ((irq = ppc_md.get_irq(regs)) >= 0) {
540                 ppc_irq_dispatch_handler(regs, irq);
541                 first = 0;
542         }
543         if (irq != -2 && first)
544                 /* That's not SMP safe ... but who cares ? */
545                 ppc_spurious_interrupts++;
546         hardirq_exit( cpu );
547
548         if (softirq_pending(cpu))
549                 do_softirq();
550         return 1; /* lets ret_from_int know we can do checks */
551 }
552 #endif /* CONFIG_PPC_ISERIES */
553
554 unsigned long probe_irq_on (void)
555 {
556         return 0;
557 }
558
559 int probe_irq_off (unsigned long irqs)
560 {
561         return 0;
562 }
563
564 unsigned int probe_irq_mask(unsigned long irqs)
565 {
566         return 0;
567 }
568
569 void __init init_IRQ(void)
570 {
571         static int once = 0;
572
573         if ( once )
574                 return;
575         else
576                 once++;
577         
578         ppc_md.init_IRQ();
579 }
580
581 #ifdef CONFIG_SMP
582 unsigned char global_irq_holder = NO_PROC_ID;
583 unsigned volatile long global_irq_lock; /* pendantic :long for set_bit--RR*/
584
585 atomic_t global_bh_count;
586
587 static void show(char * str)
588 {
589         int cpu = smp_processor_id();
590
591         printk("\n%s, CPU %d:\n", str, cpu);
592         printk("irq:  [%d %d]\n",
593                local_irq_count(0),
594                local_irq_count(1));
595         printk("bh:   %d [%d %d]\n",
596                atomic_read(&global_bh_count),
597                local_bh_count(0),
598                local_bh_count(1));
599 }
600
601 static inline void wait_on_bh(void)
602 {
603         int count = MAXCOUNT;
604         do {
605                 if (!--count) {
606                         show("wait_on_bh");
607                         count = ~0;
608                 }
609                 /* nothing .. wait for the other bh's to go away */
610         } while (atomic_read(&global_bh_count) != 0);
611 }
612
613
614 static inline void wait_on_irq(int cpu)
615 {
616         int count = MAXCOUNT;
617
618         for (;;) {
619
620                 /*
621                  * Wait until all interrupts are gone. Wait
622                  * for bottom half handlers unless we're
623                  * already executing in one..
624                  */
625                 if (!irqs_running())
626                         if (local_bh_count(cpu) || !spin_is_locked(&global_bh_lock))
627                                         break;
628
629                 /* Duh, we have to loop. Release the lock to avoid deadlocks */
630                 clear_bit(0,&global_irq_lock);
631
632                 for (;;) {
633                         if (!--count) {
634                                 show("wait_on_irq");
635                                 count = ~0;
636                         }
637                         __sti();
638                         /* 
639                          * We have to allow irqs to arrive between __sti and __cli
640                          * Some cpus apparently won't cause the interrupt
641                          * for several instructions. We hope that isync will
642                          * catch this --Troy
643                          */
644                         __asm__ __volatile__ ("isync");
645                         __cli();
646                         if (irqs_running())
647                                 continue;
648                         if (global_irq_lock)
649                                 continue;
650                         if (!local_bh_count(cpu) && spin_is_locked(&global_bh_lock))
651                                 continue;
652                         if (!test_and_set_bit(0,&global_irq_lock))
653                                 break;
654                 }
655         }
656 }
657
658 /*
659  * This is called when we want to synchronize with
660  * bottom half handlers. We need to wait until
661  * no other CPU is executing any bottom half handler.
662  *
663  * Don't wait if we're already running in an interrupt
664  * context or are inside a bh handler.
665  */
666 void synchronize_bh(void)
667 {
668         if (atomic_read(&global_bh_count) && !in_interrupt())
669                 wait_on_bh();
670 }
671
672 /*
673  * This is called when we want to synchronize with
674  * interrupts. We may for example tell a device to
675  * stop sending interrupts: but to make sure there
676  * are no interrupts that are executing on another
677  * CPU we need to call this function.
678  */
679 void synchronize_irq(void)
680 {
681         if (irqs_running()) {
682                 /* Stupid approach */
683                 cli();
684                 sti();
685         }
686 }
687
688 static inline void get_irqlock(int cpu)
689 {
690         unsigned int loops = MAXCOUNT;
691
692         if (test_and_set_bit(0,&global_irq_lock)) {
693                 /* do we already hold the lock? */
694                 if ((unsigned char) cpu == global_irq_holder)
695                         return;
696                 /* Uhhuh.. Somebody else got it. Wait.. */
697                 do {
698                         do {
699                                 if (loops-- == 0) {
700                                         printk("get_irqlock(%d) waiting, global_irq_holder=%d\n", cpu, global_irq_holder);
701 #ifdef CONFIG_XMON
702                                         xmon(0);
703 #endif
704                                 }
705                         } while (test_bit(0,&global_irq_lock));
706                 } while (test_and_set_bit(0,&global_irq_lock));         
707         }
708         /* 
709          * We also need to make sure that nobody else is running
710          * in an interrupt context. 
711          */
712         wait_on_irq(cpu);
713
714         /*
715          * Ok, finally..
716          */
717         global_irq_holder = cpu;
718 }
719
720 /*
721  * A global "cli()" while in an interrupt context
722  * turns into just a local cli(). Interrupts
723  * should use spinlocks for the (very unlikely)
724  * case that they ever want to protect against
725  * each other.
726  *
727  * If we already have local interrupts disabled,
728  * this will not turn a local disable into a
729  * global one (problems with spinlocks: this makes
730  * save_flags+cli+sti usable inside a spinlock).
731  */
732 void __global_cli(void)
733 {
734         unsigned long flags;
735         
736         __save_flags(flags);
737         if (flags & (1 << 15)) {
738                 int cpu = smp_processor_id();
739                 __cli();
740                 if (!local_irq_count(cpu))
741                         get_irqlock(cpu);
742         }
743 }
744
745 void __global_sti(void)
746 {
747         int cpu = smp_processor_id();
748
749         if (!local_irq_count(cpu))
750                 release_irqlock(cpu);
751         __sti();
752 }
753
754 /*
755  * SMP flags value to restore to:
756  * 0 - global cli
757  * 1 - global sti
758  * 2 - local cli
759  * 3 - local sti
760  */
761 unsigned long __global_save_flags(void)
762 {
763         int retval;
764         int local_enabled;
765         unsigned long flags;
766
767         __save_flags(flags);
768         local_enabled = (flags >> 15) & 1;
769         /* default to local */
770         retval = 2 + local_enabled;
771
772         /* check for global flags if we're not in an interrupt */
773         if (!local_irq_count(smp_processor_id())) {
774                 if (local_enabled)
775                         retval = 1;
776                 if (global_irq_holder == (unsigned char) smp_processor_id())
777                         retval = 0;
778         }
779         return retval;
780 }
781
782 int
783 tb(long vals[],
784    int  max_size)
785 {
786    register unsigned long *orig_sp __asm__ ("r1");
787    register unsigned long lr __asm__ ("r3");
788    unsigned long *sp;
789    int i;
790
791    asm volatile ("mflr 3");
792    vals[0] = lr;
793    sp = (unsigned long *) *orig_sp;
794    sp = (unsigned long *) *sp;
795    for (i=1; i<max_size; i++) {
796       if (sp == 0) {
797          break;
798       }
799
800       vals[i] = *(sp+1);
801       sp = (unsigned long *) *sp;
802    }
803
804    return i;
805 }
806
807 void __global_restore_flags(unsigned long flags)
808 {
809         switch (flags) {
810         case 0:
811                 __global_cli();
812                 break;
813         case 1:
814                 __global_sti();
815                 break;
816         case 2:
817                 __cli();
818                 break;
819         case 3:
820                 __sti();
821                 break;
822         default:
823         {
824                 unsigned long trace[5];
825                 int           count;
826                 int           i;
827
828                 printk("global_restore_flags: %08lx (%08lx)\n",
829                         flags, (&flags)[-1]);
830                 count = tb(trace, 5);
831                 printk("tb:");
832                 for(i=0; i<count; i++) {
833                         printk(" %8.8lx", trace[i]);
834                 }
835                 printk("\n");
836         }
837         }
838 }
839 #endif /* CONFIG_SMP */
840
841 static struct proc_dir_entry *root_irq_dir;
842 static struct proc_dir_entry *irq_dir[NR_IRQS];
843 static struct proc_dir_entry *smp_affinity_entry[NR_IRQS];
844
845 #ifdef CONFIG_IRQ_ALL_CPUS
846 #define DEFAULT_CPU_AFFINITY 0xffffffff
847 #else
848 #define DEFAULT_CPU_AFFINITY 0x00000001
849 #endif
850
851 unsigned int irq_affinity [NR_IRQS] =
852         { [0 ... NR_IRQS-1] = DEFAULT_CPU_AFFINITY };
853
854 #define HEX_DIGITS 8
855
856 static int irq_affinity_read_proc (char *page, char **start, off_t off,
857                         int count, int *eof, void *data)
858 {
859         if (count < HEX_DIGITS+1)
860                 return -EINVAL;
861         return sprintf (page, "%08x\n", irq_affinity[(int)data]);
862 }
863
864 static unsigned int parse_hex_value (const char *buffer,
865                 unsigned long count, unsigned long *ret)
866 {
867         unsigned char hexnum [HEX_DIGITS];
868         unsigned long value;
869         int i;
870
871         if (!count)
872                 return -EINVAL;
873         if (count > HEX_DIGITS)
874                 count = HEX_DIGITS;
875         if (copy_from_user(hexnum, buffer, count))
876                 return -EFAULT;
877
878         /*
879          * Parse the first 8 characters as a hex string, any non-hex char
880          * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
881          */
882         value = 0;
883
884         for (i = 0; i < count; i++) {
885                 unsigned int c = hexnum[i];
886
887                 switch (c) {
888                         case '0' ... '9': c -= '0'; break;
889                         case 'a' ... 'f': c -= 'a'-10; break;
890                         case 'A' ... 'F': c -= 'A'-10; break;
891                 default:
892                         goto out;
893                 }
894                 value = (value << 4) | c;
895         }
896 out:
897         *ret = value;
898         return 0;
899 }
900
901 static int irq_affinity_write_proc (struct file *file, const char *buffer,
902                                         unsigned long count, void *data)
903 {
904         int irq = (int) data, full_count = count, err;
905         unsigned long new_value;
906
907         if (!irq_desc[irq].handler->set_affinity)
908                 return -EIO;
909
910         err = parse_hex_value(buffer, count, &new_value);
911
912         /*
913          * Do not allow disabling IRQs completely - it's a too easy
914          * way to make the system unusable accidentally :-) At least
915          * one online CPU still has to be targeted.
916          *
917          * We assume a 1-1 logical<->physical cpu mapping here.  If
918          * we assume that the cpu indices in /proc/irq/../smp_affinity
919          * are actually logical cpu #'s then we have no problem.
920          *  -- Cort <cort@fsmlabs.com>
921          */
922         if (!(new_value & cpu_online_map))
923                 return -EINVAL;
924
925         irq_affinity[irq] = new_value;
926         irq_desc[irq].handler->set_affinity(irq, new_value);
927
928         return full_count;
929 }
930
931 static int prof_cpu_mask_read_proc (char *page, char **start, off_t off,
932                         int count, int *eof, void *data)
933 {
934         unsigned long *mask = (unsigned long *) data;
935         if (count < HEX_DIGITS+1)
936                 return -EINVAL;
937         return sprintf (page, "%08lx\n", *mask);
938 }
939
940 static int prof_cpu_mask_write_proc (struct file *file, const char *buffer,
941                                         unsigned long count, void *data)
942 {
943         unsigned long *mask = (unsigned long *) data, full_count = count, err;
944         unsigned long new_value;
945
946         err = parse_hex_value(buffer, count, &new_value);
947         if (err)
948                 return err;
949
950         *mask = new_value;
951         return full_count;
952 }
953
954 #define MAX_NAMELEN 10
955
956 static void register_irq_proc (unsigned int irq)
957 {
958         struct proc_dir_entry *entry;
959         char name [MAX_NAMELEN];
960
961         if (!root_irq_dir || (irq_desc[irq].handler == NULL))
962                 return;
963
964         memset(name, 0, MAX_NAMELEN);
965         sprintf(name, "%d", irq);
966
967         /* create /proc/irq/1234 */
968         irq_dir[irq] = proc_mkdir(name, root_irq_dir);
969
970         /* create /proc/irq/1234/smp_affinity */
971         entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]);
972
973         entry->nlink = 1;
974         entry->data = (void *)irq;
975         entry->read_proc = irq_affinity_read_proc;
976         entry->write_proc = irq_affinity_write_proc;
977
978         smp_affinity_entry[irq] = entry;
979 }
980
981 unsigned long prof_cpu_mask = -1;
982
983 void init_irq_proc (void)
984 {
985         struct proc_dir_entry *entry;
986         int i;
987
988         /* create /proc/irq */
989         root_irq_dir = proc_mkdir("irq", 0);
990
991         /* create /proc/irq/prof_cpu_mask */
992         entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
993
994         entry->nlink = 1;
995         entry->data = (void *)&prof_cpu_mask;
996         entry->read_proc = prof_cpu_mask_read_proc;
997         entry->write_proc = prof_cpu_mask_write_proc;
998
999         /*
1000          * Create entries for all existing IRQs.
1001          */
1002         for (i = 0; i < NR_IRQS; i++) {
1003                 if (irq_desc[i].handler == NULL)
1004                         continue;
1005                 register_irq_proc(i);
1006         }
1007 }
1008
1009 void no_action(int irq, void *dev, struct pt_regs *regs)
1010 {
1011 }