4 * Xen models interrupts with abstract event channels. Because each
5 * domain gets 1024 event channels, but NR_IRQ is not that large, we
6 * must dynamically map irqs<->event channels. The event channels
7 * interface with the rest of the kernel by defining a xen interrupt
8 * chip. When an event is recieved, it is mapped to an irq and sent
9 * through the normal interrupt processing path.
11 * There are four kinds of events which can be mapped to an event
14 * 1. Inter-domain notifications. This includes all the virtual
15 * device events, since they're driven by front-ends in another domain
17 * 2. VIRQs, typically used for timers. These are per-cpu events.
19 * 4. Hardware interrupts. Not supported at present.
21 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
24 #include <linux/linkage.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/module.h>
28 #include <linux/string.h>
29 #include <linux/bootmem.h>
30 #include <linux/slab.h>
33 #include <asm/ptrace.h>
36 #include <asm/sync_bitops.h>
37 #include <asm/xen/hypercall.h>
38 #include <asm/xen/hypervisor.h>
42 #include <xen/xen-ops.h>
43 #include <xen/events.h>
44 #include <xen/interface/xen.h>
45 #include <xen/interface/event_channel.h>
46 #include <xen/interface/hvm/hvm_op.h>
47 #include <xen/interface/hvm/params.h>
50 * This lock protects updates to the following mapping and reference-count
51 * arrays. The lock does not need to be acquired to read the mapping tables.
53 static DEFINE_SPINLOCK(irq_mapping_update_lock
);
55 /* IRQ <-> VIRQ mapping. */
56 static DEFINE_PER_CPU(int [NR_VIRQS
], virq_to_irq
) = {[0 ... NR_VIRQS
-1] = -1};
58 /* IRQ <-> IPI mapping */
59 static DEFINE_PER_CPU(int [XEN_NR_IPIS
], ipi_to_irq
) = {[0 ... XEN_NR_IPIS
-1] = -1};
61 /* Interrupt types. */
71 * Packed IRQ information:
72 * type - enum xen_irq_type
73 * event channel - irq->event channel mapping
74 * cpu - cpu this event channel is bound to
75 * index - type-specific information:
76 * PIRQ - vector, with MSB being "needs EIO"
83 enum xen_irq_type type
; /* type */
84 unsigned short evtchn
; /* event channel */
85 unsigned short cpu
; /* cpu bound */
92 unsigned short vector
;
97 static struct irq_info irq_info
[NR_IRQS
];
99 static int evtchn_to_irq
[NR_EVENT_CHANNELS
] = {
100 [0 ... NR_EVENT_CHANNELS
-1] = -1
102 struct cpu_evtchn_s
{
103 unsigned long bits
[NR_EVENT_CHANNELS
/BITS_PER_LONG
];
105 static struct cpu_evtchn_s
*cpu_evtchn_mask_p
;
106 static inline unsigned long *cpu_evtchn_mask(int cpu
)
108 return cpu_evtchn_mask_p
[cpu
].bits
;
111 /* Xen will never allocate port zero for any purpose. */
112 #define VALID_EVTCHN(chn) ((chn) != 0)
114 static struct irq_chip xen_dynamic_chip
;
115 static struct irq_chip xen_percpu_chip
;
117 /* Constructor for packed IRQ information. */
118 static struct irq_info
mk_unbound_info(void)
120 return (struct irq_info
) { .type
= IRQT_UNBOUND
};
123 static struct irq_info
mk_evtchn_info(unsigned short evtchn
)
125 return (struct irq_info
) { .type
= IRQT_EVTCHN
, .evtchn
= evtchn
,
129 static struct irq_info
mk_ipi_info(unsigned short evtchn
, enum ipi_vector ipi
)
131 return (struct irq_info
) { .type
= IRQT_IPI
, .evtchn
= evtchn
,
132 .cpu
= 0, .u
.ipi
= ipi
};
135 static struct irq_info
mk_virq_info(unsigned short evtchn
, unsigned short virq
)
137 return (struct irq_info
) { .type
= IRQT_VIRQ
, .evtchn
= evtchn
,
138 .cpu
= 0, .u
.virq
= virq
};
141 static struct irq_info
mk_pirq_info(unsigned short evtchn
,
142 unsigned short gsi
, unsigned short vector
)
144 return (struct irq_info
) { .type
= IRQT_PIRQ
, .evtchn
= evtchn
,
145 .cpu
= 0, .u
.pirq
= { .gsi
= gsi
, .vector
= vector
} };
149 * Accessors for packed IRQ information.
151 static struct irq_info
*info_for_irq(unsigned irq
)
153 return &irq_info
[irq
];
156 static unsigned int evtchn_from_irq(unsigned irq
)
158 return info_for_irq(irq
)->evtchn
;
161 unsigned irq_from_evtchn(unsigned int evtchn
)
163 return evtchn_to_irq
[evtchn
];
165 EXPORT_SYMBOL_GPL(irq_from_evtchn
);
167 static enum ipi_vector
ipi_from_irq(unsigned irq
)
169 struct irq_info
*info
= info_for_irq(irq
);
171 BUG_ON(info
== NULL
);
172 BUG_ON(info
->type
!= IRQT_IPI
);
177 static unsigned virq_from_irq(unsigned irq
)
179 struct irq_info
*info
= info_for_irq(irq
);
181 BUG_ON(info
== NULL
);
182 BUG_ON(info
->type
!= IRQT_VIRQ
);
187 static unsigned gsi_from_irq(unsigned irq
)
189 struct irq_info
*info
= info_for_irq(irq
);
191 BUG_ON(info
== NULL
);
192 BUG_ON(info
->type
!= IRQT_PIRQ
);
194 return info
->u
.pirq
.gsi
;
197 static unsigned vector_from_irq(unsigned irq
)
199 struct irq_info
*info
= info_for_irq(irq
);
201 BUG_ON(info
== NULL
);
202 BUG_ON(info
->type
!= IRQT_PIRQ
);
204 return info
->u
.pirq
.vector
;
207 static enum xen_irq_type
type_from_irq(unsigned irq
)
209 return info_for_irq(irq
)->type
;
212 static unsigned cpu_from_irq(unsigned irq
)
214 return info_for_irq(irq
)->cpu
;
217 static unsigned int cpu_from_evtchn(unsigned int evtchn
)
219 int irq
= evtchn_to_irq
[evtchn
];
223 ret
= cpu_from_irq(irq
);
228 static inline unsigned long active_evtchns(unsigned int cpu
,
229 struct shared_info
*sh
,
232 return (sh
->evtchn_pending
[idx
] &
233 cpu_evtchn_mask(cpu
)[idx
] &
234 ~sh
->evtchn_mask
[idx
]);
237 static void bind_evtchn_to_cpu(unsigned int chn
, unsigned int cpu
)
239 int irq
= evtchn_to_irq
[chn
];
243 cpumask_copy(irq_to_desc(irq
)->affinity
, cpumask_of(cpu
));
246 __clear_bit(chn
, cpu_evtchn_mask(cpu_from_irq(irq
)));
247 __set_bit(chn
, cpu_evtchn_mask(cpu
));
249 irq_info
[irq
].cpu
= cpu
;
252 static void init_evtchn_cpu_bindings(void)
255 struct irq_desc
*desc
;
258 /* By default all event channels notify CPU#0. */
259 for_each_irq_desc(i
, desc
) {
260 cpumask_copy(desc
->affinity
, cpumask_of(0));
264 memset(cpu_evtchn_mask(0), ~0, sizeof(cpu_evtchn_mask(0)));
267 static inline void clear_evtchn(int port
)
269 struct shared_info
*s
= HYPERVISOR_shared_info
;
270 sync_clear_bit(port
, &s
->evtchn_pending
[0]);
273 static inline void set_evtchn(int port
)
275 struct shared_info
*s
= HYPERVISOR_shared_info
;
276 sync_set_bit(port
, &s
->evtchn_pending
[0]);
279 static inline int test_evtchn(int port
)
281 struct shared_info
*s
= HYPERVISOR_shared_info
;
282 return sync_test_bit(port
, &s
->evtchn_pending
[0]);
287 * notify_remote_via_irq - send event to remote end of event channel via irq
288 * @irq: irq of event channel to send event to
290 * Unlike notify_remote_via_evtchn(), this is safe to use across
291 * save/restore. Notifications on a broken connection are silently
294 void notify_remote_via_irq(int irq
)
296 int evtchn
= evtchn_from_irq(irq
);
298 if (VALID_EVTCHN(evtchn
))
299 notify_remote_via_evtchn(evtchn
);
301 EXPORT_SYMBOL_GPL(notify_remote_via_irq
);
303 static void mask_evtchn(int port
)
305 struct shared_info
*s
= HYPERVISOR_shared_info
;
306 sync_set_bit(port
, &s
->evtchn_mask
[0]);
309 static void unmask_evtchn(int port
)
311 struct shared_info
*s
= HYPERVISOR_shared_info
;
312 unsigned int cpu
= get_cpu();
314 BUG_ON(!irqs_disabled());
316 /* Slow path (hypercall) if this is a non-local port. */
317 if (unlikely(cpu
!= cpu_from_evtchn(port
))) {
318 struct evtchn_unmask unmask
= { .port
= port
};
319 (void)HYPERVISOR_event_channel_op(EVTCHNOP_unmask
, &unmask
);
321 struct vcpu_info
*vcpu_info
= __get_cpu_var(xen_vcpu
);
323 sync_clear_bit(port
, &s
->evtchn_mask
[0]);
326 * The following is basically the equivalent of
327 * 'hw_resend_irq'. Just like a real IO-APIC we 'lose
328 * the interrupt edge' if the channel is masked.
330 if (sync_test_bit(port
, &s
->evtchn_pending
[0]) &&
331 !sync_test_and_set_bit(port
/ BITS_PER_LONG
,
332 &vcpu_info
->evtchn_pending_sel
))
333 vcpu_info
->evtchn_upcall_pending
= 1;
339 static int find_unbound_irq(void)
341 struct irq_data
*data
;
344 for (irq
= 0; irq
< nr_irqs
; irq
++) {
345 data
= irq_get_irq_data(irq
);
346 /* only 0->15 have init'd desc; handle irq > 16 */
349 if (data
->chip
== &no_irq_chip
)
351 if (data
->chip
!= &xen_dynamic_chip
)
353 if (irq_info
[irq
].type
== IRQT_UNBOUND
)
358 panic("No available IRQ to bind to: increase nr_irqs!\n");
360 res
= irq_alloc_desc_at(irq
, 0);
362 if (WARN_ON(res
!= irq
))
368 int bind_evtchn_to_irq(unsigned int evtchn
)
372 spin_lock(&irq_mapping_update_lock
);
374 irq
= evtchn_to_irq
[evtchn
];
377 irq
= find_unbound_irq();
379 set_irq_chip_and_handler_name(irq
, &xen_dynamic_chip
,
380 handle_edge_irq
, "event");
382 evtchn_to_irq
[evtchn
] = irq
;
383 irq_info
[irq
] = mk_evtchn_info(evtchn
);
386 spin_unlock(&irq_mapping_update_lock
);
390 EXPORT_SYMBOL_GPL(bind_evtchn_to_irq
);
392 static int bind_ipi_to_irq(unsigned int ipi
, unsigned int cpu
)
394 struct evtchn_bind_ipi bind_ipi
;
397 spin_lock(&irq_mapping_update_lock
);
399 irq
= per_cpu(ipi_to_irq
, cpu
)[ipi
];
402 irq
= find_unbound_irq();
406 set_irq_chip_and_handler_name(irq
, &xen_percpu_chip
,
407 handle_percpu_irq
, "ipi");
410 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_ipi
,
413 evtchn
= bind_ipi
.port
;
415 evtchn_to_irq
[evtchn
] = irq
;
416 irq_info
[irq
] = mk_ipi_info(evtchn
, ipi
);
417 per_cpu(ipi_to_irq
, cpu
)[ipi
] = irq
;
419 bind_evtchn_to_cpu(evtchn
, cpu
);
423 spin_unlock(&irq_mapping_update_lock
);
428 static int bind_virq_to_irq(unsigned int virq
, unsigned int cpu
)
430 struct evtchn_bind_virq bind_virq
;
433 spin_lock(&irq_mapping_update_lock
);
435 irq
= per_cpu(virq_to_irq
, cpu
)[virq
];
438 bind_virq
.virq
= virq
;
439 bind_virq
.vcpu
= cpu
;
440 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq
,
443 evtchn
= bind_virq
.port
;
445 irq
= find_unbound_irq();
447 set_irq_chip_and_handler_name(irq
, &xen_percpu_chip
,
448 handle_percpu_irq
, "virq");
450 evtchn_to_irq
[evtchn
] = irq
;
451 irq_info
[irq
] = mk_virq_info(evtchn
, virq
);
453 per_cpu(virq_to_irq
, cpu
)[virq
] = irq
;
455 bind_evtchn_to_cpu(evtchn
, cpu
);
458 spin_unlock(&irq_mapping_update_lock
);
463 static void unbind_from_irq(unsigned int irq
)
465 struct evtchn_close close
;
466 int evtchn
= evtchn_from_irq(irq
);
468 spin_lock(&irq_mapping_update_lock
);
470 if (VALID_EVTCHN(evtchn
)) {
472 if (HYPERVISOR_event_channel_op(EVTCHNOP_close
, &close
) != 0)
475 switch (type_from_irq(irq
)) {
477 per_cpu(virq_to_irq
, cpu_from_evtchn(evtchn
))
478 [virq_from_irq(irq
)] = -1;
481 per_cpu(ipi_to_irq
, cpu_from_evtchn(evtchn
))
482 [ipi_from_irq(irq
)] = -1;
488 /* Closed ports are implicitly re-bound to VCPU0. */
489 bind_evtchn_to_cpu(evtchn
, 0);
491 evtchn_to_irq
[evtchn
] = -1;
494 if (irq_info
[irq
].type
!= IRQT_UNBOUND
) {
495 irq_info
[irq
] = mk_unbound_info();
500 spin_unlock(&irq_mapping_update_lock
);
503 int bind_evtchn_to_irqhandler(unsigned int evtchn
,
504 irq_handler_t handler
,
505 unsigned long irqflags
,
506 const char *devname
, void *dev_id
)
511 irq
= bind_evtchn_to_irq(evtchn
);
512 retval
= request_irq(irq
, handler
, irqflags
, devname
, dev_id
);
514 unbind_from_irq(irq
);
520 EXPORT_SYMBOL_GPL(bind_evtchn_to_irqhandler
);
522 int bind_virq_to_irqhandler(unsigned int virq
, unsigned int cpu
,
523 irq_handler_t handler
,
524 unsigned long irqflags
, const char *devname
, void *dev_id
)
529 irq
= bind_virq_to_irq(virq
, cpu
);
530 retval
= request_irq(irq
, handler
, irqflags
, devname
, dev_id
);
532 unbind_from_irq(irq
);
538 EXPORT_SYMBOL_GPL(bind_virq_to_irqhandler
);
540 int bind_ipi_to_irqhandler(enum ipi_vector ipi
,
542 irq_handler_t handler
,
543 unsigned long irqflags
,
549 irq
= bind_ipi_to_irq(ipi
, cpu
);
553 irqflags
|= IRQF_NO_SUSPEND
;
554 retval
= request_irq(irq
, handler
, irqflags
, devname
, dev_id
);
556 unbind_from_irq(irq
);
563 void unbind_from_irqhandler(unsigned int irq
, void *dev_id
)
565 free_irq(irq
, dev_id
);
566 unbind_from_irq(irq
);
568 EXPORT_SYMBOL_GPL(unbind_from_irqhandler
);
570 void xen_send_IPI_one(unsigned int cpu
, enum ipi_vector vector
)
572 int irq
= per_cpu(ipi_to_irq
, cpu
)[vector
];
574 notify_remote_via_irq(irq
);
577 irqreturn_t
xen_debug_interrupt(int irq
, void *dev_id
)
579 struct shared_info
*sh
= HYPERVISOR_shared_info
;
580 int cpu
= smp_processor_id();
583 static DEFINE_SPINLOCK(debug_lock
);
585 spin_lock_irqsave(&debug_lock
, flags
);
587 printk("vcpu %d\n ", cpu
);
589 for_each_online_cpu(i
) {
590 struct vcpu_info
*v
= per_cpu(xen_vcpu
, i
);
591 printk("%d: masked=%d pending=%d event_sel %08lx\n ", i
,
592 (get_irq_regs() && i
== cpu
) ? xen_irqs_disabled(get_irq_regs()) : v
->evtchn_upcall_mask
,
593 v
->evtchn_upcall_pending
,
594 v
->evtchn_pending_sel
);
596 printk("pending:\n ");
597 for(i
= ARRAY_SIZE(sh
->evtchn_pending
)-1; i
>= 0; i
--)
598 printk("%08lx%s", sh
->evtchn_pending
[i
],
599 i
% 8 == 0 ? "\n " : " ");
600 printk("\nmasks:\n ");
601 for(i
= ARRAY_SIZE(sh
->evtchn_mask
)-1; i
>= 0; i
--)
602 printk("%08lx%s", sh
->evtchn_mask
[i
],
603 i
% 8 == 0 ? "\n " : " ");
605 printk("\nunmasked:\n ");
606 for(i
= ARRAY_SIZE(sh
->evtchn_mask
)-1; i
>= 0; i
--)
607 printk("%08lx%s", sh
->evtchn_pending
[i
] & ~sh
->evtchn_mask
[i
],
608 i
% 8 == 0 ? "\n " : " ");
610 printk("\npending list:\n");
611 for(i
= 0; i
< NR_EVENT_CHANNELS
; i
++) {
612 if (sync_test_bit(i
, sh
->evtchn_pending
)) {
613 printk(" %d: event %d -> irq %d\n",
614 cpu_from_evtchn(i
), i
,
619 spin_unlock_irqrestore(&debug_lock
, flags
);
624 static DEFINE_PER_CPU(unsigned, xed_nesting_count
);
627 * Search the CPUs pending events bitmasks. For each one found, map
628 * the event number to an irq, and feed it into do_IRQ() for
631 * Xen uses a two-level bitmap to speed searching. The first level is
632 * a bitset of words which contain pending event bits. The second
633 * level is a bitset of pending events themselves.
635 static void __xen_evtchn_do_upcall(void)
638 struct shared_info
*s
= HYPERVISOR_shared_info
;
639 struct vcpu_info
*vcpu_info
= __get_cpu_var(xen_vcpu
);
643 unsigned long pending_words
;
645 vcpu_info
->evtchn_upcall_pending
= 0;
647 if (__get_cpu_var(xed_nesting_count
)++)
650 #ifndef CONFIG_X86 /* No need for a barrier -- XCHG is a barrier on x86. */
651 /* Clear master flag /before/ clearing selector flag. */
654 pending_words
= xchg(&vcpu_info
->evtchn_pending_sel
, 0);
655 while (pending_words
!= 0) {
656 unsigned long pending_bits
;
657 int word_idx
= __ffs(pending_words
);
658 pending_words
&= ~(1UL << word_idx
);
660 while ((pending_bits
= active_evtchns(cpu
, s
, word_idx
)) != 0) {
661 int bit_idx
= __ffs(pending_bits
);
662 int port
= (word_idx
* BITS_PER_LONG
) + bit_idx
;
663 int irq
= evtchn_to_irq
[port
];
664 struct irq_desc
*desc
;
667 desc
= irq_to_desc(irq
);
669 generic_handle_irq_desc(irq
, desc
);
674 BUG_ON(!irqs_disabled());
676 count
= __get_cpu_var(xed_nesting_count
);
677 __get_cpu_var(xed_nesting_count
) = 0;
678 } while (count
!= 1 || vcpu_info
->evtchn_upcall_pending
);
685 void xen_evtchn_do_upcall(struct pt_regs
*regs
)
687 struct pt_regs
*old_regs
= set_irq_regs(regs
);
692 __xen_evtchn_do_upcall();
695 set_irq_regs(old_regs
);
698 void xen_hvm_evtchn_do_upcall(void)
700 __xen_evtchn_do_upcall();
702 EXPORT_SYMBOL_GPL(xen_hvm_evtchn_do_upcall
);
704 /* Rebind a new event channel to an existing irq. */
705 void rebind_evtchn_irq(int evtchn
, int irq
)
707 struct irq_info
*info
= info_for_irq(irq
);
709 /* Make sure the irq is masked, since the new event channel
710 will also be masked. */
713 spin_lock(&irq_mapping_update_lock
);
715 /* After resume the irq<->evtchn mappings are all cleared out */
716 BUG_ON(evtchn_to_irq
[evtchn
] != -1);
717 /* Expect irq to have been bound before,
718 so there should be a proper type */
719 BUG_ON(info
->type
== IRQT_UNBOUND
);
721 evtchn_to_irq
[evtchn
] = irq
;
722 irq_info
[irq
] = mk_evtchn_info(evtchn
);
724 spin_unlock(&irq_mapping_update_lock
);
726 /* new event channels are always bound to cpu 0 */
727 irq_set_affinity(irq
, cpumask_of(0));
729 /* Unmask the event channel. */
733 /* Rebind an evtchn so that it gets delivered to a specific cpu */
734 static int rebind_irq_to_cpu(unsigned irq
, unsigned tcpu
)
736 struct evtchn_bind_vcpu bind_vcpu
;
737 int evtchn
= evtchn_from_irq(irq
);
739 /* events delivered via platform PCI interrupts are always
740 * routed to vcpu 0 */
741 if (!VALID_EVTCHN(evtchn
) ||
742 (xen_hvm_domain() && !xen_have_vector_callback
))
745 /* Send future instances of this interrupt to other vcpu. */
746 bind_vcpu
.port
= evtchn
;
747 bind_vcpu
.vcpu
= tcpu
;
750 * If this fails, it usually just indicates that we're dealing with a
751 * virq or IPI channel, which don't actually need to be rebound. Ignore
752 * it, but don't do the xenlinux-level rebind in that case.
754 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_vcpu
, &bind_vcpu
) >= 0)
755 bind_evtchn_to_cpu(evtchn
, tcpu
);
760 static int set_affinity_irq(unsigned irq
, const struct cpumask
*dest
)
762 unsigned tcpu
= cpumask_first(dest
);
764 return rebind_irq_to_cpu(irq
, tcpu
);
767 int resend_irq_on_evtchn(unsigned int irq
)
769 int masked
, evtchn
= evtchn_from_irq(irq
);
770 struct shared_info
*s
= HYPERVISOR_shared_info
;
772 if (!VALID_EVTCHN(evtchn
))
775 masked
= sync_test_and_set_bit(evtchn
, s
->evtchn_mask
);
776 sync_set_bit(evtchn
, s
->evtchn_pending
);
778 unmask_evtchn(evtchn
);
783 static void enable_dynirq(unsigned int irq
)
785 int evtchn
= evtchn_from_irq(irq
);
787 if (VALID_EVTCHN(evtchn
))
788 unmask_evtchn(evtchn
);
791 static void disable_dynirq(unsigned int irq
)
793 int evtchn
= evtchn_from_irq(irq
);
795 if (VALID_EVTCHN(evtchn
))
799 static void ack_dynirq(unsigned int irq
)
801 int evtchn
= evtchn_from_irq(irq
);
803 move_native_irq(irq
);
805 if (VALID_EVTCHN(evtchn
))
806 clear_evtchn(evtchn
);
809 static int retrigger_dynirq(unsigned int irq
)
811 int evtchn
= evtchn_from_irq(irq
);
812 struct shared_info
*sh
= HYPERVISOR_shared_info
;
815 if (VALID_EVTCHN(evtchn
)) {
818 masked
= sync_test_and_set_bit(evtchn
, sh
->evtchn_mask
);
819 sync_set_bit(evtchn
, sh
->evtchn_pending
);
821 unmask_evtchn(evtchn
);
828 static void restore_cpu_virqs(unsigned int cpu
)
830 struct evtchn_bind_virq bind_virq
;
831 int virq
, irq
, evtchn
;
833 for (virq
= 0; virq
< NR_VIRQS
; virq
++) {
834 if ((irq
= per_cpu(virq_to_irq
, cpu
)[virq
]) == -1)
837 BUG_ON(virq_from_irq(irq
) != virq
);
839 /* Get a new binding from Xen. */
840 bind_virq
.virq
= virq
;
841 bind_virq
.vcpu
= cpu
;
842 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq
,
845 evtchn
= bind_virq
.port
;
847 /* Record the new mapping. */
848 evtchn_to_irq
[evtchn
] = irq
;
849 irq_info
[irq
] = mk_virq_info(evtchn
, virq
);
850 bind_evtchn_to_cpu(evtchn
, cpu
);
853 unmask_evtchn(evtchn
);
857 static void restore_cpu_ipis(unsigned int cpu
)
859 struct evtchn_bind_ipi bind_ipi
;
860 int ipi
, irq
, evtchn
;
862 for (ipi
= 0; ipi
< XEN_NR_IPIS
; ipi
++) {
863 if ((irq
= per_cpu(ipi_to_irq
, cpu
)[ipi
]) == -1)
866 BUG_ON(ipi_from_irq(irq
) != ipi
);
868 /* Get a new binding from Xen. */
870 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_ipi
,
873 evtchn
= bind_ipi
.port
;
875 /* Record the new mapping. */
876 evtchn_to_irq
[evtchn
] = irq
;
877 irq_info
[irq
] = mk_ipi_info(evtchn
, ipi
);
878 bind_evtchn_to_cpu(evtchn
, cpu
);
881 unmask_evtchn(evtchn
);
886 /* Clear an irq's pending state, in preparation for polling on it */
887 void xen_clear_irq_pending(int irq
)
889 int evtchn
= evtchn_from_irq(irq
);
891 if (VALID_EVTCHN(evtchn
))
892 clear_evtchn(evtchn
);
895 void xen_set_irq_pending(int irq
)
897 int evtchn
= evtchn_from_irq(irq
);
899 if (VALID_EVTCHN(evtchn
))
903 bool xen_test_irq_pending(int irq
)
905 int evtchn
= evtchn_from_irq(irq
);
908 if (VALID_EVTCHN(evtchn
))
909 ret
= test_evtchn(evtchn
);
914 /* Poll waiting for an irq to become pending. In the usual case, the
915 irq will be disabled so it won't deliver an interrupt. */
916 void xen_poll_irq(int irq
)
918 evtchn_port_t evtchn
= evtchn_from_irq(irq
);
920 if (VALID_EVTCHN(evtchn
)) {
921 struct sched_poll poll
;
925 set_xen_guest_handle(poll
.ports
, &evtchn
);
927 if (HYPERVISOR_sched_op(SCHEDOP_poll
, &poll
) != 0)
932 void xen_irq_resume(void)
934 unsigned int cpu
, irq
, evtchn
;
936 init_evtchn_cpu_bindings();
938 /* New event-channel space is not 'live' yet. */
939 for (evtchn
= 0; evtchn
< NR_EVENT_CHANNELS
; evtchn
++)
942 /* No IRQ <-> event-channel mappings. */
943 for (irq
= 0; irq
< nr_irqs
; irq
++)
944 irq_info
[irq
].evtchn
= 0; /* zap event-channel binding */
946 for (evtchn
= 0; evtchn
< NR_EVENT_CHANNELS
; evtchn
++)
947 evtchn_to_irq
[evtchn
] = -1;
949 for_each_possible_cpu(cpu
) {
950 restore_cpu_virqs(cpu
);
951 restore_cpu_ipis(cpu
);
955 static struct irq_chip xen_dynamic_chip __read_mostly
= {
958 .disable
= disable_dynirq
,
959 .mask
= disable_dynirq
,
960 .unmask
= enable_dynirq
,
963 .set_affinity
= set_affinity_irq
,
964 .retrigger
= retrigger_dynirq
,
967 static struct irq_chip xen_percpu_chip __read_mostly
= {
968 .name
= "xen-percpu",
970 .disable
= disable_dynirq
,
971 .mask
= disable_dynirq
,
972 .unmask
= enable_dynirq
,
977 int xen_set_callback_via(uint64_t via
)
979 struct xen_hvm_param a
;
980 a
.domid
= DOMID_SELF
;
981 a
.index
= HVM_PARAM_CALLBACK_IRQ
;
983 return HYPERVISOR_hvm_op(HVMOP_set_param
, &a
);
985 EXPORT_SYMBOL_GPL(xen_set_callback_via
);
987 #ifdef CONFIG_XEN_PVHVM
988 /* Vector callbacks are better than PCI interrupts to receive event
989 * channel notifications because we can receive vector callbacks on any
990 * vcpu and we don't need PCI support or APIC interactions. */
991 void xen_callback_vector(void)
994 uint64_t callback_via
;
995 if (xen_have_vector_callback
) {
996 callback_via
= HVM_CALLBACK_VECTOR(XEN_HVM_EVTCHN_CALLBACK
);
997 rc
= xen_set_callback_via(callback_via
);
999 printk(KERN_ERR
"Request for Xen HVM callback vector"
1001 xen_have_vector_callback
= 0;
1004 printk(KERN_INFO
"Xen HVM callback vector for event delivery is "
1006 /* in the restore case the vector has already been allocated */
1007 if (!test_bit(XEN_HVM_EVTCHN_CALLBACK
, used_vectors
))
1008 alloc_intr_gate(XEN_HVM_EVTCHN_CALLBACK
, xen_hvm_callback_vector
);
1012 void xen_callback_vector(void) {}
1015 void __init
xen_init_IRQ(void)
1019 cpu_evtchn_mask_p
= kcalloc(nr_cpu_ids
, sizeof(struct cpu_evtchn_s
),
1021 BUG_ON(cpu_evtchn_mask_p
== NULL
);
1023 init_evtchn_cpu_bindings();
1025 /* No event channels are 'live' right now. */
1026 for (i
= 0; i
< NR_EVENT_CHANNELS
; i
++)
1029 if (xen_hvm_domain()) {
1030 xen_callback_vector();
1033 irq_ctx_init(smp_processor_id());