irq_comm.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. /*
  2. * irq_comm.c: Common API for in kernel interrupt controller
  3. * Copyright (c) 2007, Intel Corporation.
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms and conditions of the GNU General Public License,
  7. * version 2, as published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope it will be useful, but WITHOUT
  10. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12. * more details.
  13. *
  14. * You should have received a copy of the GNU General Public License along with
  15. * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  16. * Place - Suite 330, Boston, MA 02111-1307 USA.
  17. * Authors:
  18. * Yaozu (Eddie) Dong <Eddie.dong@intel.com>
  19. *
  20. */
  21. #include <linux/kvm_host.h>
  22. #include <asm/msidef.h>
  23. #include "irq.h"
  24. #include "ioapic.h"
  25. static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
  26. struct kvm *kvm, int level)
  27. {
  28. #ifdef CONFIG_X86
  29. return kvm_pic_set_irq(pic_irqchip(kvm), e->irqchip.pin, level);
  30. #else
  31. return -1;
  32. #endif
  33. }
  34. static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
  35. struct kvm *kvm, int level)
  36. {
  37. return kvm_ioapic_set_irq(kvm->arch.vioapic, e->irqchip.pin, level);
  38. }
  39. void kvm_get_intr_delivery_bitmask(struct kvm_ioapic *ioapic,
  40. union kvm_ioapic_redirect_entry *entry,
  41. unsigned long *deliver_bitmask)
  42. {
  43. struct kvm_vcpu *vcpu;
  44. kvm_ioapic_get_delivery_bitmask(ioapic, entry->fields.dest_id,
  45. entry->fields.dest_mode,
  46. deliver_bitmask);
  47. switch (entry->fields.delivery_mode) {
  48. case IOAPIC_LOWEST_PRIORITY:
  49. vcpu = kvm_get_lowest_prio_vcpu(ioapic->kvm,
  50. entry->fields.vector, deliver_bitmask);
  51. *deliver_bitmask = 1 << vcpu->vcpu_id;
  52. break;
  53. case IOAPIC_FIXED:
  54. case IOAPIC_NMI:
  55. break;
  56. default:
  57. if (printk_ratelimit())
  58. printk(KERN_INFO "kvm: unsupported delivery mode %d\n",
  59. entry->fields.delivery_mode);
  60. *deliver_bitmask = 0;
  61. }
  62. }
  63. static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
  64. struct kvm *kvm, int level)
  65. {
  66. int vcpu_id, r = -1;
  67. struct kvm_vcpu *vcpu;
  68. struct kvm_ioapic *ioapic = ioapic_irqchip(kvm);
  69. union kvm_ioapic_redirect_entry entry;
  70. unsigned long deliver_bitmask;
  71. BUG_ON(!ioapic);
  72. entry.bits = 0;
  73. entry.fields.dest_id = (e->msi.address_lo &
  74. MSI_ADDR_DEST_ID_MASK) >> MSI_ADDR_DEST_ID_SHIFT;
  75. entry.fields.vector = (e->msi.data &
  76. MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT;
  77. entry.fields.dest_mode = test_bit(MSI_ADDR_DEST_MODE_SHIFT,
  78. (unsigned long *)&e->msi.address_lo);
  79. entry.fields.trig_mode = test_bit(MSI_DATA_TRIGGER_SHIFT,
  80. (unsigned long *)&e->msi.data);
  81. entry.fields.delivery_mode = test_bit(
  82. MSI_DATA_DELIVERY_MODE_SHIFT,
  83. (unsigned long *)&e->msi.data);
  84. /* TODO Deal with RH bit of MSI message address */
  85. kvm_get_intr_delivery_bitmask(ioapic, &entry, &deliver_bitmask);
  86. if (!deliver_bitmask) {
  87. printk(KERN_WARNING "kvm: no destination for MSI delivery!");
  88. return -1;
  89. }
  90. for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
  91. if (!(deliver_bitmask & (1 << vcpu_id)))
  92. continue;
  93. deliver_bitmask &= ~(1 << vcpu_id);
  94. vcpu = ioapic->kvm->vcpus[vcpu_id];
  95. if (vcpu) {
  96. if (r < 0)
  97. r = 0;
  98. r += kvm_apic_set_irq(vcpu, entry.fields.vector,
  99. entry.fields.trig_mode);
  100. }
  101. }
  102. return r;
  103. }
  104. /* This should be called with the kvm->lock mutex held
  105. * Return value:
  106. * < 0 Interrupt was ignored (masked or not delivered for other reasons)
  107. * = 0 Interrupt was coalesced (previous irq is still pending)
  108. * > 0 Number of CPUs interrupt was delivered to
  109. */
  110. int kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level)
  111. {
  112. struct kvm_kernel_irq_routing_entry *e;
  113. unsigned long *irq_state, sig_level;
  114. int ret = -1;
  115. if (irq < KVM_IOAPIC_NUM_PINS) {
  116. irq_state = (unsigned long *)&kvm->arch.irq_states[irq];
  117. /* Logical OR for level trig interrupt */
  118. if (level)
  119. set_bit(irq_source_id, irq_state);
  120. else
  121. clear_bit(irq_source_id, irq_state);
  122. sig_level = !!(*irq_state);
  123. } else /* Deal with MSI/MSI-X */
  124. sig_level = 1;
  125. /* Not possible to detect if the guest uses the PIC or the
  126. * IOAPIC. So set the bit in both. The guest will ignore
  127. * writes to the unused one.
  128. */
  129. list_for_each_entry(e, &kvm->irq_routing, link)
  130. if (e->gsi == irq) {
  131. int r = e->set(e, kvm, sig_level);
  132. if (r < 0)
  133. continue;
  134. ret = r + ((ret < 0) ? 0 : ret);
  135. }
  136. return ret;
  137. }
  138. void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
  139. {
  140. struct kvm_kernel_irq_routing_entry *e;
  141. struct kvm_irq_ack_notifier *kian;
  142. struct hlist_node *n;
  143. unsigned gsi = pin;
  144. list_for_each_entry(e, &kvm->irq_routing, link)
  145. if (e->irqchip.irqchip == irqchip &&
  146. e->irqchip.pin == pin) {
  147. gsi = e->gsi;
  148. break;
  149. }
  150. hlist_for_each_entry(kian, n, &kvm->arch.irq_ack_notifier_list, link)
  151. if (kian->gsi == gsi)
  152. kian->irq_acked(kian);
  153. }
  154. void kvm_register_irq_ack_notifier(struct kvm *kvm,
  155. struct kvm_irq_ack_notifier *kian)
  156. {
  157. hlist_add_head(&kian->link, &kvm->arch.irq_ack_notifier_list);
  158. }
  159. void kvm_unregister_irq_ack_notifier(struct kvm_irq_ack_notifier *kian)
  160. {
  161. hlist_del_init(&kian->link);
  162. }
  163. /* The caller must hold kvm->lock mutex */
  164. int kvm_request_irq_source_id(struct kvm *kvm)
  165. {
  166. unsigned long *bitmap = &kvm->arch.irq_sources_bitmap;
  167. int irq_source_id = find_first_zero_bit(bitmap,
  168. sizeof(kvm->arch.irq_sources_bitmap));
  169. if (irq_source_id >= sizeof(kvm->arch.irq_sources_bitmap)) {
  170. printk(KERN_WARNING "kvm: exhaust allocatable IRQ sources!\n");
  171. return -EFAULT;
  172. }
  173. ASSERT(irq_source_id != KVM_USERSPACE_IRQ_SOURCE_ID);
  174. set_bit(irq_source_id, bitmap);
  175. return irq_source_id;
  176. }
  177. void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id)
  178. {
  179. int i;
  180. ASSERT(irq_source_id != KVM_USERSPACE_IRQ_SOURCE_ID);
  181. if (irq_source_id < 0 ||
  182. irq_source_id >= sizeof(kvm->arch.irq_sources_bitmap)) {
  183. printk(KERN_ERR "kvm: IRQ source ID out of range!\n");
  184. return;
  185. }
  186. for (i = 0; i < KVM_IOAPIC_NUM_PINS; i++)
  187. clear_bit(irq_source_id, &kvm->arch.irq_states[i]);
  188. clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap);
  189. }
  190. void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
  191. struct kvm_irq_mask_notifier *kimn)
  192. {
  193. kimn->irq = irq;
  194. hlist_add_head(&kimn->link, &kvm->mask_notifier_list);
  195. }
  196. void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
  197. struct kvm_irq_mask_notifier *kimn)
  198. {
  199. hlist_del(&kimn->link);
  200. }
  201. void kvm_fire_mask_notifiers(struct kvm *kvm, int irq, bool mask)
  202. {
  203. struct kvm_irq_mask_notifier *kimn;
  204. struct hlist_node *n;
  205. hlist_for_each_entry(kimn, n, &kvm->mask_notifier_list, link)
  206. if (kimn->irq == irq)
  207. kimn->func(kimn, mask);
  208. }
  209. static void __kvm_free_irq_routing(struct list_head *irq_routing)
  210. {
  211. struct kvm_kernel_irq_routing_entry *e, *n;
  212. list_for_each_entry_safe(e, n, irq_routing, link)
  213. kfree(e);
  214. }
  215. void kvm_free_irq_routing(struct kvm *kvm)
  216. {
  217. __kvm_free_irq_routing(&kvm->irq_routing);
  218. }
  219. static int setup_routing_entry(struct kvm_kernel_irq_routing_entry *e,
  220. const struct kvm_irq_routing_entry *ue)
  221. {
  222. int r = -EINVAL;
  223. int delta;
  224. e->gsi = ue->gsi;
  225. switch (ue->type) {
  226. case KVM_IRQ_ROUTING_IRQCHIP:
  227. delta = 0;
  228. switch (ue->u.irqchip.irqchip) {
  229. case KVM_IRQCHIP_PIC_MASTER:
  230. e->set = kvm_set_pic_irq;
  231. break;
  232. case KVM_IRQCHIP_PIC_SLAVE:
  233. e->set = kvm_set_pic_irq;
  234. delta = 8;
  235. break;
  236. case KVM_IRQCHIP_IOAPIC:
  237. e->set = kvm_set_ioapic_irq;
  238. break;
  239. default:
  240. goto out;
  241. }
  242. e->irqchip.irqchip = ue->u.irqchip.irqchip;
  243. e->irqchip.pin = ue->u.irqchip.pin + delta;
  244. break;
  245. case KVM_IRQ_ROUTING_MSI:
  246. e->set = kvm_set_msi;
  247. e->msi.address_lo = ue->u.msi.address_lo;
  248. e->msi.address_hi = ue->u.msi.address_hi;
  249. e->msi.data = ue->u.msi.data;
  250. break;
  251. default:
  252. goto out;
  253. }
  254. r = 0;
  255. out:
  256. return r;
  257. }
  258. int kvm_set_irq_routing(struct kvm *kvm,
  259. const struct kvm_irq_routing_entry *ue,
  260. unsigned nr,
  261. unsigned flags)
  262. {
  263. struct list_head irq_list = LIST_HEAD_INIT(irq_list);
  264. struct list_head tmp = LIST_HEAD_INIT(tmp);
  265. struct kvm_kernel_irq_routing_entry *e = NULL;
  266. unsigned i;
  267. int r;
  268. for (i = 0; i < nr; ++i) {
  269. r = -EINVAL;
  270. if (ue->gsi >= KVM_MAX_IRQ_ROUTES)
  271. goto out;
  272. if (ue->flags)
  273. goto out;
  274. r = -ENOMEM;
  275. e = kzalloc(sizeof(*e), GFP_KERNEL);
  276. if (!e)
  277. goto out;
  278. r = setup_routing_entry(e, ue);
  279. if (r)
  280. goto out;
  281. ++ue;
  282. list_add(&e->link, &irq_list);
  283. e = NULL;
  284. }
  285. mutex_lock(&kvm->lock);
  286. list_splice(&kvm->irq_routing, &tmp);
  287. INIT_LIST_HEAD(&kvm->irq_routing);
  288. list_splice(&irq_list, &kvm->irq_routing);
  289. INIT_LIST_HEAD(&irq_list);
  290. list_splice(&tmp, &irq_list);
  291. mutex_unlock(&kvm->lock);
  292. r = 0;
  293. out:
  294. kfree(e);
  295. __kvm_free_irq_routing(&irq_list);
  296. return r;
  297. }
  298. #define IOAPIC_ROUTING_ENTRY(irq) \
  299. { .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP, \
  300. .u.irqchip.irqchip = KVM_IRQCHIP_IOAPIC, .u.irqchip.pin = (irq) }
  301. #define ROUTING_ENTRY1(irq) IOAPIC_ROUTING_ENTRY(irq)
  302. #ifdef CONFIG_X86
  303. # define PIC_ROUTING_ENTRY(irq) \
  304. { .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP, \
  305. .u.irqchip.irqchip = SELECT_PIC(irq), .u.irqchip.pin = (irq) % 8 }
  306. # define ROUTING_ENTRY2(irq) \
  307. IOAPIC_ROUTING_ENTRY(irq), PIC_ROUTING_ENTRY(irq)
  308. #else
  309. # define ROUTING_ENTRY2(irq) \
  310. IOAPIC_ROUTING_ENTRY(irq)
  311. #endif
  312. static const struct kvm_irq_routing_entry default_routing[] = {
  313. ROUTING_ENTRY2(0), ROUTING_ENTRY2(1),
  314. ROUTING_ENTRY2(2), ROUTING_ENTRY2(3),
  315. ROUTING_ENTRY2(4), ROUTING_ENTRY2(5),
  316. ROUTING_ENTRY2(6), ROUTING_ENTRY2(7),
  317. ROUTING_ENTRY2(8), ROUTING_ENTRY2(9),
  318. ROUTING_ENTRY2(10), ROUTING_ENTRY2(11),
  319. ROUTING_ENTRY2(12), ROUTING_ENTRY2(13),
  320. ROUTING_ENTRY2(14), ROUTING_ENTRY2(15),
  321. ROUTING_ENTRY1(16), ROUTING_ENTRY1(17),
  322. ROUTING_ENTRY1(18), ROUTING_ENTRY1(19),
  323. ROUTING_ENTRY1(20), ROUTING_ENTRY1(21),
  324. ROUTING_ENTRY1(22), ROUTING_ENTRY1(23),
  325. #ifdef CONFIG_IA64
  326. ROUTING_ENTRY1(24), ROUTING_ENTRY1(25),
  327. ROUTING_ENTRY1(26), ROUTING_ENTRY1(27),
  328. ROUTING_ENTRY1(28), ROUTING_ENTRY1(29),
  329. ROUTING_ENTRY1(30), ROUTING_ENTRY1(31),
  330. ROUTING_ENTRY1(32), ROUTING_ENTRY1(33),
  331. ROUTING_ENTRY1(34), ROUTING_ENTRY1(35),
  332. ROUTING_ENTRY1(36), ROUTING_ENTRY1(37),
  333. ROUTING_ENTRY1(38), ROUTING_ENTRY1(39),
  334. ROUTING_ENTRY1(40), ROUTING_ENTRY1(41),
  335. ROUTING_ENTRY1(42), ROUTING_ENTRY1(43),
  336. ROUTING_ENTRY1(44), ROUTING_ENTRY1(45),
  337. ROUTING_ENTRY1(46), ROUTING_ENTRY1(47),
  338. #endif
  339. };
  340. int kvm_setup_default_irq_routing(struct kvm *kvm)
  341. {
  342. return kvm_set_irq_routing(kvm, default_routing,
  343. ARRAY_SIZE(default_routing), 0);
  344. }