Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
irq_xen.c
Go to the documentation of this file.
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;
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;
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
102 xen_dummy_handler(int irq, void *dev_id)
103 {
104  return IRQ_HANDLED;
105 }
106 
107 static irqreturn_t
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
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);
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);
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);
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);
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);
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);
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:
215  case IA64_PERFMON_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
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
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
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 
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 
334 {
335 #ifdef CONFIG_SMP
336  unsigned int cpu = smp_processor_id();
337  struct callback_register 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 */
353 #endif /* CONFIG_SMP */
354 }
355 
356 void __init
358 {
359  struct callback_register event = {
361  .address = { .ip = (unsigned long)&xen_event_callback },
362  };
363 
364  xen_init_IRQ();
366  late_time_init = xen_bind_early_percpu_irq;
367 }
368 
369 void
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  */
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:
391  break;
392  case IA64_IPI_RESCHEDULE:
394  break;
395  case IA64_CMCP_VECTOR:
397  break;
398  case IA64_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) {
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
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
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 __initconst = {
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 };