9974d21048fd3c0aee10b5ade01d9d9e421cfc67
[pandora-kernel.git] / arch / x86 / kernel / irq_32.c
1 /*
2  *      Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
3  *
4  * This file contains the lowest level x86-specific interrupt
5  * entry, irq-stacks and irq statistics code. All the remaining
6  * irq logic is done by the generic kernel/irq/ code and
7  * by the x86-specific irq controller code. (e.g. i8259.c and
8  * io_apic.c.)
9  */
10
11 #include <linux/module.h>
12 #include <linux/seq_file.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel_stat.h>
15 #include <linux/notifier.h>
16 #include <linux/cpu.h>
17 #include <linux/delay.h>
18 #include <linux/uaccess.h>
19 #include <linux/percpu.h>
20 #include <linux/mm.h>
21
22 #include <asm/apic.h>
23
24 DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
25 EXPORT_PER_CPU_SYMBOL(irq_stat);
26
27 DEFINE_PER_CPU(struct pt_regs *, irq_regs);
28 EXPORT_PER_CPU_SYMBOL(irq_regs);
29
30 #ifdef CONFIG_DEBUG_STACKOVERFLOW
31 /* Debugging check for stack overflow: is there less than 1KB free? */
32 static int check_stack_overflow(void)
33 {
34         long sp;
35
36         __asm__ __volatile__("andl %%esp,%0" :
37                              "=r" (sp) : "0" (THREAD_SIZE - 1));
38
39         return sp < (sizeof(struct thread_info) + STACK_WARN);
40 }
41
42 static void print_stack_overflow(void)
43 {
44         printk(KERN_WARNING "low stack detected by irq handler\n");
45         dump_stack();
46 }
47
48 #else
49 static inline int check_stack_overflow(void) { return 0; }
50 static inline void print_stack_overflow(void) { }
51 #endif
52
53 /*
54  * per-CPU IRQ handling contexts (thread information and stack)
55  */
56 union irq_ctx {
57         struct thread_info      tinfo;
58         u32                     stack[THREAD_SIZE/sizeof(u32)];
59 } __attribute__((aligned(THREAD_SIZE)));
60
61 static DEFINE_PER_CPU(union irq_ctx *, hardirq_ctx);
62 static DEFINE_PER_CPU(union irq_ctx *, softirq_ctx);
63
64 static void call_on_stack(void *func, void *stack)
65 {
66         asm volatile("xchgl     %%ebx,%%esp     \n"
67                      "call      *%%edi          \n"
68                      "movl      %%ebx,%%esp     \n"
69                      : "=b" (stack)
70                      : "0" (stack),
71                        "D"(func)
72                      : "memory", "cc", "edx", "ecx", "eax");
73 }
74
75 static inline int
76 execute_on_irq_stack(int overflow, struct irq_desc *desc, int irq)
77 {
78         union irq_ctx *curctx, *irqctx;
79         u32 *isp, arg1, arg2;
80
81         curctx = (union irq_ctx *) current_thread_info();
82         irqctx = __this_cpu_read(hardirq_ctx);
83
84         /*
85          * this is where we switch to the IRQ stack. However, if we are
86          * already using the IRQ stack (because we interrupted a hardirq
87          * handler) we can't do that and just have to keep using the
88          * current stack (which is the irq stack already after all)
89          */
90         if (unlikely(curctx == irqctx))
91                 return 0;
92
93         /* build the stack frame on the IRQ stack */
94         isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
95         irqctx->tinfo.task = curctx->tinfo.task;
96         irqctx->tinfo.previous_esp = current_stack_pointer;
97
98         /*
99          * Copy the softirq bits in preempt_count so that the
100          * softirq checks work in the hardirq context.
101          */
102         irqctx->tinfo.preempt_count =
103                 (irqctx->tinfo.preempt_count & ~SOFTIRQ_MASK) |
104                 (curctx->tinfo.preempt_count & SOFTIRQ_MASK);
105
106         if (unlikely(overflow))
107                 call_on_stack(print_stack_overflow, isp);
108
109         asm volatile("xchgl     %%ebx,%%esp     \n"
110                      "call      *%%edi          \n"
111                      "movl      %%ebx,%%esp     \n"
112                      : "=a" (arg1), "=d" (arg2), "=b" (isp)
113                      :  "0" (irq),   "1" (desc),  "2" (isp),
114                         "D" (desc->handle_irq)
115                      : "memory", "cc", "ecx");
116         return 1;
117 }
118
119 /*
120  * allocate per-cpu stacks for hardirq and for softirq processing
121  */
122 void __cpuinit irq_ctx_init(int cpu)
123 {
124         union irq_ctx *irqctx;
125
126         if (per_cpu(hardirq_ctx, cpu))
127                 return;
128
129         irqctx = page_address(alloc_pages_node(cpu_to_node(cpu),
130                                                THREAD_FLAGS,
131                                                THREAD_ORDER));
132         memset(&irqctx->tinfo, 0, sizeof(struct thread_info));
133         irqctx->tinfo.cpu               = cpu;
134         irqctx->tinfo.preempt_count     = HARDIRQ_OFFSET;
135         irqctx->tinfo.addr_limit        = MAKE_MM_SEG(0);
136
137         per_cpu(hardirq_ctx, cpu) = irqctx;
138
139         irqctx = page_address(alloc_pages_node(cpu_to_node(cpu),
140                                                THREAD_FLAGS,
141                                                THREAD_ORDER));
142         memset(&irqctx->tinfo, 0, sizeof(struct thread_info));
143         irqctx->tinfo.cpu               = cpu;
144         irqctx->tinfo.addr_limit        = MAKE_MM_SEG(0);
145
146         per_cpu(softirq_ctx, cpu) = irqctx;
147
148         printk(KERN_DEBUG "CPU %u irqstacks, hard=%p soft=%p\n",
149                cpu, per_cpu(hardirq_ctx, cpu),  per_cpu(softirq_ctx, cpu));
150 }
151
152 asmlinkage void do_softirq(void)
153 {
154         unsigned long flags;
155         struct thread_info *curctx;
156         union irq_ctx *irqctx;
157         u32 *isp;
158
159         if (in_interrupt())
160                 return;
161
162         local_irq_save(flags);
163
164         if (local_softirq_pending()) {
165                 curctx = current_thread_info();
166                 irqctx = __this_cpu_read(softirq_ctx);
167                 irqctx->tinfo.task = curctx->task;
168                 irqctx->tinfo.previous_esp = current_stack_pointer;
169
170                 /* build the stack frame on the softirq stack */
171                 isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
172
173                 call_on_stack(__do_softirq, isp);
174                 /*
175                  * Shouldnt happen, we returned above if in_interrupt():
176                  */
177                 WARN_ON_ONCE(softirq_count());
178         }
179
180         local_irq_restore(flags);
181 }
182
183 bool handle_irq(unsigned irq, struct pt_regs *regs)
184 {
185         struct irq_desc *desc;
186         int overflow;
187
188         overflow = check_stack_overflow();
189
190         desc = irq_to_desc(irq);
191         if (unlikely(!desc))
192                 return false;
193
194         if (!execute_on_irq_stack(overflow, desc, irq)) {
195                 if (unlikely(overflow))
196                         print_stack_overflow();
197                 desc->handle_irq(irq, desc);
198         }
199
200         return true;
201 }