[IA64] remove duplicate include iommu.h
[linux-2.6.git] / arch / ia64 / xen / irq_xen.c
1 /******************************************************************************
2  * arch/ia64/xen/irq_xen.c
3  *
4  * Copyright (c) 2008 Isaku Yamahata <yamahata at valinux co jp>
5  *                    VA Linux Systems Japan K.K.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  */
22
23 #include <linux/cpu.h>
24
25 #include <xen/interface/xen.h>
26 #include <xen/interface/callback.h>
27 #include <xen/events.h>
28
29 #include <asm/xen/privop.h>
30
31 #include "irq_xen.h"
32
33 /***************************************************************************
34  * pv_irq_ops
35  * irq operations
36  */
37
38 static int
39 xen_assign_irq_vector(int irq)
40 {
41         struct physdev_irq irq_op;
42
43         irq_op.irq = irq;
44         if (HYPERVISOR_physdev_op(PHYSDEVOP_alloc_irq_vector, &irq_op))
45                 return -ENOSPC;
46
47         return irq_op.vector;
48 }
49
50 static void
51 xen_free_irq_vector(int vector)
52 {
53         struct physdev_irq irq_op;
54
55         if (vector < IA64_FIRST_DEVICE_VECTOR ||
56             vector > IA64_LAST_DEVICE_VECTOR)
57                 return;
58
59         irq_op.vector = vector;
60         if (HYPERVISOR_physdev_op(PHYSDEVOP_free_irq_vector, &irq_op))
61                 printk(KERN_WARNING "%s: xen_free_irq_vecotr fail vector=%d\n",
62                        __func__, vector);
63 }
64
65
66 static DEFINE_PER_CPU(int, timer_irq) = -1;
67 static DEFINE_PER_CPU(int, ipi_irq) = -1;
68 static DEFINE_PER_CPU(int, resched_irq) = -1;
69 static DEFINE_PER_CPU(int, cmc_irq) = -1;
70 static DEFINE_PER_CPU(int, cmcp_irq) = -1;
71 static DEFINE_PER_CPU(int, cpep_irq) = -1;
72 #define NAME_SIZE       15
73 static DEFINE_PER_CPU(char[NAME_SIZE], timer_name);
74 static DEFINE_PER_CPU(char[NAME_SIZE], ipi_name);
75 static DEFINE_PER_CPU(char[NAME_SIZE], resched_name);
76 static DEFINE_PER_CPU(char[NAME_SIZE], cmc_name);
77 static DEFINE_PER_CPU(char[NAME_SIZE], cmcp_name);
78 static DEFINE_PER_CPU(char[NAME_SIZE], cpep_name);
79 #undef NAME_SIZE
80
81 struct saved_irq {
82         unsigned int irq;
83         struct irqaction *action;
84 };
85 /* 16 should be far optimistic value, since only several percpu irqs
86  * are registered early.
87  */
88 #define MAX_LATE_IRQ    16
89 static struct saved_irq saved_percpu_irqs[MAX_LATE_IRQ];
90 static unsigned short late_irq_cnt;
91 static unsigned short saved_irq_cnt;
92 static int xen_slab_ready;
93
94 #ifdef CONFIG_SMP
95 /* Dummy stub. Though we may check XEN_RESCHEDULE_VECTOR before __do_IRQ,
96  * it ends up to issue several memory accesses upon percpu data and
97  * thus adds unnecessary traffic to other paths.
98  */
99 static irqreturn_t
100 xen_dummy_handler(int irq, void *dev_id)
101 {
102
103         return IRQ_HANDLED;
104 }
105
106 static struct irqaction xen_ipi_irqaction = {
107         .handler =      handle_IPI,
108         .flags =        IRQF_DISABLED,
109         .name =         "IPI"
110 };
111
112 static struct irqaction xen_resched_irqaction = {
113         .handler =      xen_dummy_handler,
114         .flags =        IRQF_DISABLED,
115         .name =         "resched"
116 };
117
118 static struct irqaction xen_tlb_irqaction = {
119         .handler =      xen_dummy_handler,
120         .flags =        IRQF_DISABLED,
121         .name =         "tlb_flush"
122 };
123 #endif
124
125 /*
126  * This is xen version percpu irq registration, which needs bind
127  * to xen specific evtchn sub-system. One trick here is that xen
128  * evtchn binding interface depends on kmalloc because related
129  * port needs to be freed at device/cpu down. So we cache the
130  * registration on BSP before slab is ready and then deal them
131  * at later point. For rest instances happening after slab ready,
132  * we hook them to xen evtchn immediately.
133  *
134  * FIXME: MCA is not supported by far, and thus "nomca" boot param is
135  * required.
136  */
137 static void
138 __xen_register_percpu_irq(unsigned int cpu, unsigned int vec,
139                         struct irqaction *action, int save)
140 {
141         irq_desc_t *desc;
142         int irq = 0;
143
144         if (xen_slab_ready) {
145                 switch (vec) {
146                 case IA64_TIMER_VECTOR:
147                         snprintf(per_cpu(timer_name, cpu),
148                                  sizeof(per_cpu(timer_name, cpu)),
149                                  "%s%d", action->name, cpu);
150                         irq = bind_virq_to_irqhandler(VIRQ_ITC, cpu,
151                                 action->handler, action->flags,
152                                 per_cpu(timer_name, cpu), action->dev_id);
153                         per_cpu(timer_irq, cpu) = irq;
154                         break;
155                 case IA64_IPI_RESCHEDULE:
156                         snprintf(per_cpu(resched_name, cpu),
157                                  sizeof(per_cpu(resched_name, cpu)),
158                                  "%s%d", action->name, cpu);
159                         irq = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR, cpu,
160                                 action->handler, action->flags,
161                                 per_cpu(resched_name, cpu), action->dev_id);
162                         per_cpu(resched_irq, cpu) = irq;
163                         break;
164                 case IA64_IPI_VECTOR:
165                         snprintf(per_cpu(ipi_name, cpu),
166                                  sizeof(per_cpu(ipi_name, cpu)),
167                                  "%s%d", action->name, cpu);
168                         irq = bind_ipi_to_irqhandler(XEN_IPI_VECTOR, cpu,
169                                 action->handler, action->flags,
170                                 per_cpu(ipi_name, cpu), action->dev_id);
171                         per_cpu(ipi_irq, cpu) = irq;
172                         break;
173                 case IA64_CMC_VECTOR:
174                         snprintf(per_cpu(cmc_name, cpu),
175                                  sizeof(per_cpu(cmc_name, cpu)),
176                                  "%s%d", action->name, cpu);
177                         irq = bind_virq_to_irqhandler(VIRQ_MCA_CMC, cpu,
178                                                       action->handler,
179                                                       action->flags,
180                                                       per_cpu(cmc_name, cpu),
181                                                       action->dev_id);
182                         per_cpu(cmc_irq, cpu) = irq;
183                         break;
184                 case IA64_CMCP_VECTOR:
185                         snprintf(per_cpu(cmcp_name, cpu),
186                                  sizeof(per_cpu(cmcp_name, cpu)),
187                                  "%s%d", action->name, cpu);
188                         irq = bind_ipi_to_irqhandler(XEN_CMCP_VECTOR, cpu,
189                                                      action->handler,
190                                                      action->flags,
191                                                      per_cpu(cmcp_name, cpu),
192                                                      action->dev_id);
193                         per_cpu(cmcp_irq, cpu) = irq;
194                         break;
195                 case IA64_CPEP_VECTOR:
196                         snprintf(per_cpu(cpep_name, cpu),
197                                  sizeof(per_cpu(cpep_name, cpu)),
198                                  "%s%d", action->name, cpu);
199                         irq = bind_ipi_to_irqhandler(XEN_CPEP_VECTOR, cpu,
200                                                      action->handler,
201                                                      action->flags,
202                                                      per_cpu(cpep_name, cpu),
203                                                      action->dev_id);
204                         per_cpu(cpep_irq, cpu) = irq;
205                         break;
206                 case IA64_CPE_VECTOR:
207                 case IA64_MCA_RENDEZ_VECTOR:
208                 case IA64_PERFMON_VECTOR:
209                 case IA64_MCA_WAKEUP_VECTOR:
210                 case IA64_SPURIOUS_INT_VECTOR:
211                         /* No need to complain, these aren't supported. */
212                         break;
213                 default:
214                         printk(KERN_WARNING "Percpu irq %d is unsupported "
215                                "by xen!\n", vec);
216                         break;
217                 }
218                 BUG_ON(irq < 0);
219
220                 if (irq > 0) {
221                         /*
222                          * Mark percpu.  Without this, migrate_irqs() will
223                          * mark the interrupt for migrations and trigger it
224                          * on cpu hotplug.
225                          */
226                         desc = irq_desc + irq;
227                         desc->status |= IRQ_PER_CPU;
228                 }
229         }
230
231         /* For BSP, we cache registered percpu irqs, and then re-walk
232          * them when initializing APs
233          */
234         if (!cpu && save) {
235                 BUG_ON(saved_irq_cnt == MAX_LATE_IRQ);
236                 saved_percpu_irqs[saved_irq_cnt].irq = vec;
237                 saved_percpu_irqs[saved_irq_cnt].action = action;
238                 saved_irq_cnt++;
239                 if (!xen_slab_ready)
240                         late_irq_cnt++;
241         }
242 }
243
244 static void
245 xen_register_percpu_irq(ia64_vector vec, struct irqaction *action)
246 {
247         __xen_register_percpu_irq(smp_processor_id(), vec, action, 1);
248 }
249
250 static void
251 xen_bind_early_percpu_irq(void)
252 {
253         int i;
254
255         xen_slab_ready = 1;
256         /* There's no race when accessing this cached array, since only
257          * BSP will face with such step shortly
258          */
259         for (i = 0; i < late_irq_cnt; i++)
260                 __xen_register_percpu_irq(smp_processor_id(),
261                                           saved_percpu_irqs[i].irq,
262                                           saved_percpu_irqs[i].action, 0);
263 }
264
265 /* FIXME: There's no obvious point to check whether slab is ready. So
266  * a hack is used here by utilizing a late time hook.
267  */
268
269 #ifdef CONFIG_HOTPLUG_CPU
270 static int __devinit
271 unbind_evtchn_callback(struct notifier_block *nfb,
272                        unsigned long action, void *hcpu)
273 {
274         unsigned int cpu = (unsigned long)hcpu;
275
276         if (action == CPU_DEAD) {
277                 /* Unregister evtchn.  */
278                 if (per_cpu(cpep_irq, cpu) >= 0) {
279                         unbind_from_irqhandler(per_cpu(cpep_irq, cpu), NULL);
280                         per_cpu(cpep_irq, cpu) = -1;
281                 }
282                 if (per_cpu(cmcp_irq, cpu) >= 0) {
283                         unbind_from_irqhandler(per_cpu(cmcp_irq, cpu), NULL);
284                         per_cpu(cmcp_irq, cpu) = -1;
285                 }
286                 if (per_cpu(cmc_irq, cpu) >= 0) {
287                         unbind_from_irqhandler(per_cpu(cmc_irq, cpu), NULL);
288                         per_cpu(cmc_irq, cpu) = -1;
289                 }
290                 if (per_cpu(ipi_irq, cpu) >= 0) {
291                         unbind_from_irqhandler(per_cpu(ipi_irq, cpu), NULL);
292                         per_cpu(ipi_irq, cpu) = -1;
293                 }
294                 if (per_cpu(resched_irq, cpu) >= 0) {
295                         unbind_from_irqhandler(per_cpu(resched_irq, cpu),
296                                                 NULL);
297                         per_cpu(resched_irq, cpu) = -1;
298                 }
299                 if (per_cpu(timer_irq, cpu) >= 0) {
300                         unbind_from_irqhandler(per_cpu(timer_irq, cpu), NULL);
301                         per_cpu(timer_irq, cpu) = -1;
302                 }
303         }
304         return NOTIFY_OK;
305 }
306
307 static struct notifier_block unbind_evtchn_notifier = {
308         .notifier_call = unbind_evtchn_callback,
309         .priority = 0
310 };
311 #endif
312
313 void xen_smp_intr_init_early(unsigned int cpu)
314 {
315 #ifdef CONFIG_SMP
316         unsigned int i;
317
318         for (i = 0; i < saved_irq_cnt; i++)
319                 __xen_register_percpu_irq(cpu, saved_percpu_irqs[i].irq,
320                                           saved_percpu_irqs[i].action, 0);
321 #endif
322 }
323
324 void xen_smp_intr_init(void)
325 {
326 #ifdef CONFIG_SMP
327         unsigned int cpu = smp_processor_id();
328         struct callback_register event = {
329                 .type = CALLBACKTYPE_event,
330                 .address = { .ip = (unsigned long)&xen_event_callback },
331         };
332
333         if (cpu == 0) {
334                 /* Initialization was already done for boot cpu.  */
335 #ifdef CONFIG_HOTPLUG_CPU
336                 /* Register the notifier only once.  */
337                 register_cpu_notifier(&unbind_evtchn_notifier);
338 #endif
339                 return;
340         }
341
342         /* This should be piggyback when setup vcpu guest context */
343         BUG_ON(HYPERVISOR_callback_op(CALLBACKOP_register, &event));
344 #endif /* CONFIG_SMP */
345 }
346
347 void __init
348 xen_irq_init(void)
349 {
350         struct callback_register event = {
351                 .type = CALLBACKTYPE_event,
352                 .address = { .ip = (unsigned long)&xen_event_callback },
353         };
354
355         xen_init_IRQ();
356         BUG_ON(HYPERVISOR_callback_op(CALLBACKOP_register, &event));
357         late_time_init = xen_bind_early_percpu_irq;
358 }
359
360 void
361 xen_platform_send_ipi(int cpu, int vector, int delivery_mode, int redirect)
362 {
363 #ifdef CONFIG_SMP
364         /* TODO: we need to call vcpu_up here */
365         if (unlikely(vector == ap_wakeup_vector)) {
366                 /* XXX
367                  * This should be in __cpu_up(cpu) in ia64 smpboot.c
368                  * like x86. But don't want to modify it,
369                  * keep it untouched.
370                  */
371                 xen_smp_intr_init_early(cpu);
372
373                 xen_send_ipi(cpu, vector);
374                 /* vcpu_prepare_and_up(cpu); */
375                 return;
376         }
377 #endif
378
379         switch (vector) {
380         case IA64_IPI_VECTOR:
381                 xen_send_IPI_one(cpu, XEN_IPI_VECTOR);
382                 break;
383         case IA64_IPI_RESCHEDULE:
384                 xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
385                 break;
386         case IA64_CMCP_VECTOR:
387                 xen_send_IPI_one(cpu, XEN_CMCP_VECTOR);
388                 break;
389         case IA64_CPEP_VECTOR:
390                 xen_send_IPI_one(cpu, XEN_CPEP_VECTOR);
391                 break;
392         case IA64_TIMER_VECTOR: {
393                 /* this is used only once by check_sal_cache_flush()
394                    at boot time */
395                 static int used = 0;
396                 if (!used) {
397                         xen_send_ipi(cpu, IA64_TIMER_VECTOR);
398                         used = 1;
399                         break;
400                 }
401                 /* fallthrough */
402         }
403         default:
404                 printk(KERN_WARNING "Unsupported IPI type 0x%x\n",
405                        vector);
406                 notify_remote_via_irq(0); /* defaults to 0 irq */
407                 break;
408         }
409 }
410
411 static void __init
412 xen_register_ipi(void)
413 {
414 #ifdef CONFIG_SMP
415         register_percpu_irq(IA64_IPI_VECTOR, &xen_ipi_irqaction);
416         register_percpu_irq(IA64_IPI_RESCHEDULE, &xen_resched_irqaction);
417         register_percpu_irq(IA64_IPI_LOCAL_TLB_FLUSH, &xen_tlb_irqaction);
418 #endif
419 }
420
421 static void
422 xen_resend_irq(unsigned int vector)
423 {
424         (void)resend_irq_on_evtchn(vector);
425 }
426
427 const struct pv_irq_ops xen_irq_ops __initdata = {
428         .register_ipi = xen_register_ipi,
429
430         .assign_irq_vector = xen_assign_irq_vector,
431         .free_irq_vector = xen_free_irq_vector,
432         .register_percpu_irq = xen_register_percpu_irq,
433
434         .resend_irq = xen_resend_irq,
435 };