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
xen_assign_irq_vector(int irq)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
xen_free_irq_vector(int vector)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_vector fail vector=%d\n",
62 __func__, vector);
63 }
64
65
66 static DEFINE_PER_CPU(int, xen_timer_irq) = -1;
67 static DEFINE_PER_CPU(int, xen_ipi_irq) = -1;
68 static DEFINE_PER_CPU(int, xen_resched_irq) = -1;
69 static DEFINE_PER_CPU(int, xen_cmc_irq) = -1;
70 static DEFINE_PER_CPU(int, xen_cmcp_irq) = -1;
71 static DEFINE_PER_CPU(int, xen_cpep_irq) = -1;
72 #define NAME_SIZE 15
73 static DEFINE_PER_CPU(char[NAME_SIZE], xen_timer_name);
74 static DEFINE_PER_CPU(char[NAME_SIZE], xen_ipi_name);
75 static DEFINE_PER_CPU(char[NAME_SIZE], xen_resched_name);
76 static DEFINE_PER_CPU(char[NAME_SIZE], xen_cmc_name);
77 static DEFINE_PER_CPU(char[NAME_SIZE], xen_cmcp_name);
78 static DEFINE_PER_CPU(char[NAME_SIZE], xen_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 #include <linux/sched.h>
96
97 /* Dummy stub. Though we may check XEN_RESCHEDULE_VECTOR before __do_IRQ,
98 * it ends up to issue several memory accesses upon percpu data and
99 * thus adds unnecessary traffic to other paths.
100 */
101 static irqreturn_t
xen_dummy_handler(int irq,void * dev_id)102 xen_dummy_handler(int irq, void *dev_id)
103 {
104 return IRQ_HANDLED;
105 }
106
107 static irqreturn_t
xen_resched_handler(int irq,void * dev_id)108 xen_resched_handler(int irq, void *dev_id)
109 {
110 scheduler_ipi();
111 return IRQ_HANDLED;
112 }
113
114 static struct irqaction xen_ipi_irqaction = {
115 .handler = handle_IPI,
116 .flags = IRQF_DISABLED,
117 .name = "IPI"
118 };
119
120 static struct irqaction xen_resched_irqaction = {
121 .handler = xen_resched_handler,
122 .flags = IRQF_DISABLED,
123 .name = "resched"
124 };
125
126 static struct irqaction xen_tlb_irqaction = {
127 .handler = xen_dummy_handler,
128 .flags = IRQF_DISABLED,
129 .name = "tlb_flush"
130 };
131 #endif
132
133 /*
134 * This is xen version percpu irq registration, which needs bind
135 * to xen specific evtchn sub-system. One trick here is that xen
136 * evtchn binding interface depends on kmalloc because related
137 * port needs to be freed at device/cpu down. So we cache the
138 * registration on BSP before slab is ready and then deal them
139 * at later point. For rest instances happening after slab ready,
140 * we hook them to xen evtchn immediately.
141 *
142 * FIXME: MCA is not supported by far, and thus "nomca" boot param is
143 * required.
144 */
145 static void
__xen_register_percpu_irq(unsigned int cpu,unsigned int vec,struct irqaction * action,int save)146 __xen_register_percpu_irq(unsigned int cpu, unsigned int vec,
147 struct irqaction *action, int save)
148 {
149 int irq = 0;
150
151 if (xen_slab_ready) {
152 switch (vec) {
153 case IA64_TIMER_VECTOR:
154 snprintf(per_cpu(xen_timer_name, cpu),
155 sizeof(per_cpu(xen_timer_name, cpu)),
156 "%s%d", action->name, cpu);
157 irq = bind_virq_to_irqhandler(VIRQ_ITC, cpu,
158 action->handler, action->flags,
159 per_cpu(xen_timer_name, cpu), action->dev_id);
160 per_cpu(xen_timer_irq, cpu) = irq;
161 break;
162 case IA64_IPI_RESCHEDULE:
163 snprintf(per_cpu(xen_resched_name, cpu),
164 sizeof(per_cpu(xen_resched_name, cpu)),
165 "%s%d", action->name, cpu);
166 irq = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR, cpu,
167 action->handler, action->flags,
168 per_cpu(xen_resched_name, cpu), action->dev_id);
169 per_cpu(xen_resched_irq, cpu) = irq;
170 break;
171 case IA64_IPI_VECTOR:
172 snprintf(per_cpu(xen_ipi_name, cpu),
173 sizeof(per_cpu(xen_ipi_name, cpu)),
174 "%s%d", action->name, cpu);
175 irq = bind_ipi_to_irqhandler(XEN_IPI_VECTOR, cpu,
176 action->handler, action->flags,
177 per_cpu(xen_ipi_name, cpu), action->dev_id);
178 per_cpu(xen_ipi_irq, cpu) = irq;
179 break;
180 case IA64_CMC_VECTOR:
181 snprintf(per_cpu(xen_cmc_name, cpu),
182 sizeof(per_cpu(xen_cmc_name, cpu)),
183 "%s%d", action->name, cpu);
184 irq = bind_virq_to_irqhandler(VIRQ_MCA_CMC, cpu,
185 action->handler,
186 action->flags,
187 per_cpu(xen_cmc_name, cpu),
188 action->dev_id);
189 per_cpu(xen_cmc_irq, cpu) = irq;
190 break;
191 case IA64_CMCP_VECTOR:
192 snprintf(per_cpu(xen_cmcp_name, cpu),
193 sizeof(per_cpu(xen_cmcp_name, cpu)),
194 "%s%d", action->name, cpu);
195 irq = bind_ipi_to_irqhandler(XEN_CMCP_VECTOR, cpu,
196 action->handler,
197 action->flags,
198 per_cpu(xen_cmcp_name, cpu),
199 action->dev_id);
200 per_cpu(xen_cmcp_irq, cpu) = irq;
201 break;
202 case IA64_CPEP_VECTOR:
203 snprintf(per_cpu(xen_cpep_name, cpu),
204 sizeof(per_cpu(xen_cpep_name, cpu)),
205 "%s%d", action->name, cpu);
206 irq = bind_ipi_to_irqhandler(XEN_CPEP_VECTOR, cpu,
207 action->handler,
208 action->flags,
209 per_cpu(xen_cpep_name, cpu),
210 action->dev_id);
211 per_cpu(xen_cpep_irq, cpu) = irq;
212 break;
213 case IA64_CPE_VECTOR:
214 case IA64_MCA_RENDEZ_VECTOR:
215 case IA64_PERFMON_VECTOR:
216 case IA64_MCA_WAKEUP_VECTOR:
217 case IA64_SPURIOUS_INT_VECTOR:
218 /* No need to complain, these aren't supported. */
219 break;
220 default:
221 printk(KERN_WARNING "Percpu irq %d is unsupported "
222 "by xen!\n", vec);
223 break;
224 }
225 BUG_ON(irq < 0);
226
227 if (irq > 0) {
228 /*
229 * Mark percpu. Without this, migrate_irqs() will
230 * mark the interrupt for migrations and trigger it
231 * on cpu hotplug.
232 */
233 irq_set_status_flags(irq, IRQ_PER_CPU);
234 }
235 }
236
237 /* For BSP, we cache registered percpu irqs, and then re-walk
238 * them when initializing APs
239 */
240 if (!cpu && save) {
241 BUG_ON(saved_irq_cnt == MAX_LATE_IRQ);
242 saved_percpu_irqs[saved_irq_cnt].irq = vec;
243 saved_percpu_irqs[saved_irq_cnt].action = action;
244 saved_irq_cnt++;
245 if (!xen_slab_ready)
246 late_irq_cnt++;
247 }
248 }
249
250 static void
xen_register_percpu_irq(ia64_vector vec,struct irqaction * action)251 xen_register_percpu_irq(ia64_vector vec, struct irqaction *action)
252 {
253 __xen_register_percpu_irq(smp_processor_id(), vec, action, 1);
254 }
255
256 static void
xen_bind_early_percpu_irq(void)257 xen_bind_early_percpu_irq(void)
258 {
259 int i;
260
261 xen_slab_ready = 1;
262 /* There's no race when accessing this cached array, since only
263 * BSP will face with such step shortly
264 */
265 for (i = 0; i < late_irq_cnt; i++)
266 __xen_register_percpu_irq(smp_processor_id(),
267 saved_percpu_irqs[i].irq,
268 saved_percpu_irqs[i].action, 0);
269 }
270
271 /* FIXME: There's no obvious point to check whether slab is ready. So
272 * a hack is used here by utilizing a late time hook.
273 */
274
275 #ifdef CONFIG_HOTPLUG_CPU
276 static int __devinit
unbind_evtchn_callback(struct notifier_block * nfb,unsigned long action,void * hcpu)277 unbind_evtchn_callback(struct notifier_block *nfb,
278 unsigned long action, void *hcpu)
279 {
280 unsigned int cpu = (unsigned long)hcpu;
281
282 if (action == CPU_DEAD) {
283 /* Unregister evtchn. */
284 if (per_cpu(xen_cpep_irq, cpu) >= 0) {
285 unbind_from_irqhandler(per_cpu(xen_cpep_irq, cpu),
286 NULL);
287 per_cpu(xen_cpep_irq, cpu) = -1;
288 }
289 if (per_cpu(xen_cmcp_irq, cpu) >= 0) {
290 unbind_from_irqhandler(per_cpu(xen_cmcp_irq, cpu),
291 NULL);
292 per_cpu(xen_cmcp_irq, cpu) = -1;
293 }
294 if (per_cpu(xen_cmc_irq, cpu) >= 0) {
295 unbind_from_irqhandler(per_cpu(xen_cmc_irq, cpu), NULL);
296 per_cpu(xen_cmc_irq, cpu) = -1;
297 }
298 if (per_cpu(xen_ipi_irq, cpu) >= 0) {
299 unbind_from_irqhandler(per_cpu(xen_ipi_irq, cpu), NULL);
300 per_cpu(xen_ipi_irq, cpu) = -1;
301 }
302 if (per_cpu(xen_resched_irq, cpu) >= 0) {
303 unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu),
304 NULL);
305 per_cpu(xen_resched_irq, cpu) = -1;
306 }
307 if (per_cpu(xen_timer_irq, cpu) >= 0) {
308 unbind_from_irqhandler(per_cpu(xen_timer_irq, cpu),
309 NULL);
310 per_cpu(xen_timer_irq, cpu) = -1;
311 }
312 }
313 return NOTIFY_OK;
314 }
315
316 static struct notifier_block unbind_evtchn_notifier = {
317 .notifier_call = unbind_evtchn_callback,
318 .priority = 0
319 };
320 #endif
321
xen_smp_intr_init_early(unsigned int cpu)322 void xen_smp_intr_init_early(unsigned int cpu)
323 {
324 #ifdef CONFIG_SMP
325 unsigned int i;
326
327 for (i = 0; i < saved_irq_cnt; i++)
328 __xen_register_percpu_irq(cpu, saved_percpu_irqs[i].irq,
329 saved_percpu_irqs[i].action, 0);
330 #endif
331 }
332
xen_smp_intr_init(void)333 void xen_smp_intr_init(void)
334 {
335 #ifdef CONFIG_SMP
336 unsigned int cpu = smp_processor_id();
337 struct callback_register event = {
338 .type = CALLBACKTYPE_event,
339 .address = { .ip = (unsigned long)&xen_event_callback },
340 };
341
342 if (cpu == 0) {
343 /* Initialization was already done for boot cpu. */
344 #ifdef CONFIG_HOTPLUG_CPU
345 /* Register the notifier only once. */
346 register_cpu_notifier(&unbind_evtchn_notifier);
347 #endif
348 return;
349 }
350
351 /* This should be piggyback when setup vcpu guest context */
352 BUG_ON(HYPERVISOR_callback_op(CALLBACKOP_register, &event));
353 #endif /* CONFIG_SMP */
354 }
355
356 void __init
xen_irq_init(void)357 xen_irq_init(void)
358 {
359 struct callback_register event = {
360 .type = CALLBACKTYPE_event,
361 .address = { .ip = (unsigned long)&xen_event_callback },
362 };
363
364 xen_init_IRQ();
365 BUG_ON(HYPERVISOR_callback_op(CALLBACKOP_register, &event));
366 late_time_init = xen_bind_early_percpu_irq;
367 }
368
369 void
xen_platform_send_ipi(int cpu,int vector,int delivery_mode,int redirect)370 xen_platform_send_ipi(int cpu, int vector, int delivery_mode, int redirect)
371 {
372 #ifdef CONFIG_SMP
373 /* TODO: we need to call vcpu_up here */
374 if (unlikely(vector == ap_wakeup_vector)) {
375 /* XXX
376 * This should be in __cpu_up(cpu) in ia64 smpboot.c
377 * like x86. But don't want to modify it,
378 * keep it untouched.
379 */
380 xen_smp_intr_init_early(cpu);
381
382 xen_send_ipi(cpu, vector);
383 /* vcpu_prepare_and_up(cpu); */
384 return;
385 }
386 #endif
387
388 switch (vector) {
389 case IA64_IPI_VECTOR:
390 xen_send_IPI_one(cpu, XEN_IPI_VECTOR);
391 break;
392 case IA64_IPI_RESCHEDULE:
393 xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
394 break;
395 case IA64_CMCP_VECTOR:
396 xen_send_IPI_one(cpu, XEN_CMCP_VECTOR);
397 break;
398 case IA64_CPEP_VECTOR:
399 xen_send_IPI_one(cpu, XEN_CPEP_VECTOR);
400 break;
401 case IA64_TIMER_VECTOR: {
402 /* this is used only once by check_sal_cache_flush()
403 at boot time */
404 static int used = 0;
405 if (!used) {
406 xen_send_ipi(cpu, IA64_TIMER_VECTOR);
407 used = 1;
408 break;
409 }
410 /* fallthrough */
411 }
412 default:
413 printk(KERN_WARNING "Unsupported IPI type 0x%x\n",
414 vector);
415 notify_remote_via_irq(0); /* defaults to 0 irq */
416 break;
417 }
418 }
419
420 static void __init
xen_register_ipi(void)421 xen_register_ipi(void)
422 {
423 #ifdef CONFIG_SMP
424 register_percpu_irq(IA64_IPI_VECTOR, &xen_ipi_irqaction);
425 register_percpu_irq(IA64_IPI_RESCHEDULE, &xen_resched_irqaction);
426 register_percpu_irq(IA64_IPI_LOCAL_TLB_FLUSH, &xen_tlb_irqaction);
427 #endif
428 }
429
430 static void
xen_resend_irq(unsigned int vector)431 xen_resend_irq(unsigned int vector)
432 {
433 (void)resend_irq_on_evtchn(vector);
434 }
435
436 const struct pv_irq_ops xen_irq_ops __initdata = {
437 .register_ipi = xen_register_ipi,
438
439 .assign_irq_vector = xen_assign_irq_vector,
440 .free_irq_vector = xen_free_irq_vector,
441 .register_percpu_irq = xen_register_percpu_irq,
442
443 .resend_irq = xen_resend_irq,
444 };
445