]> Pileus Git - ~andy/linux/blob - arch/x86/pci/xen.c
pci/xen: When free-ing MSI-X/MSI irq->desc also use generic code.
[~andy/linux] / arch / x86 / pci / xen.c
1 /*
2  * Xen PCI Frontend Stub - puts some "dummy" functions in to the Linux
3  *                         x86 PCI core to support the Xen PCI Frontend
4  *
5  *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
6  */
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/pci.h>
10 #include <linux/acpi.h>
11
12 #include <linux/io.h>
13 #include <asm/io_apic.h>
14 #include <asm/pci_x86.h>
15
16 #include <asm/xen/hypervisor.h>
17
18 #include <xen/features.h>
19 #include <xen/events.h>
20 #include <asm/xen/pci.h>
21
22 #ifdef CONFIG_ACPI
23 static int xen_hvm_register_pirq(u32 gsi, int triggering)
24 {
25         int rc, irq;
26         struct physdev_map_pirq map_irq;
27         int shareable = 0;
28         char *name;
29
30         if (!xen_hvm_domain())
31                 return -1;
32
33         map_irq.domid = DOMID_SELF;
34         map_irq.type = MAP_PIRQ_TYPE_GSI;
35         map_irq.index = gsi;
36         map_irq.pirq = -1;
37
38         rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
39         if (rc) {
40                 printk(KERN_WARNING "xen map irq failed %d\n", rc);
41                 return -1;
42         }
43
44         if (triggering == ACPI_EDGE_SENSITIVE) {
45                 shareable = 0;
46                 name = "ioapic-edge";
47         } else {
48                 shareable = 1;
49                 name = "ioapic-level";
50         }
51
52         irq = xen_map_pirq_gsi(map_irq.pirq, gsi, shareable, name);
53
54         printk(KERN_DEBUG "xen: --> irq=%d, pirq=%d\n", irq, map_irq.pirq);
55
56         return irq;
57 }
58
59 static int acpi_register_gsi_xen_hvm(struct device *dev, u32 gsi,
60                                  int trigger, int polarity)
61 {
62         return xen_hvm_register_pirq(gsi, trigger);
63 }
64 #endif
65
66 #if defined(CONFIG_PCI_MSI)
67 #include <linux/msi.h>
68 #include <asm/msidef.h>
69
70 struct xen_pci_frontend_ops *xen_pci_frontend;
71 EXPORT_SYMBOL_GPL(xen_pci_frontend);
72
73 #define XEN_PIRQ_MSI_DATA  (MSI_DATA_TRIGGER_EDGE | \
74                 MSI_DATA_LEVEL_ASSERT | (3 << 8) | MSI_DATA_VECTOR(0))
75
76 static void xen_msi_compose_msg(struct pci_dev *pdev, unsigned int pirq,
77                 struct msi_msg *msg)
78 {
79         /* We set vector == 0 to tell the hypervisor we don't care about it,
80          * but we want a pirq setup instead.
81          * We use the dest_id field to pass the pirq that we want. */
82         msg->address_hi = MSI_ADDR_BASE_HI | MSI_ADDR_EXT_DEST_ID(pirq);
83         msg->address_lo =
84                 MSI_ADDR_BASE_LO |
85                 MSI_ADDR_DEST_MODE_PHYSICAL |
86                 MSI_ADDR_REDIRECTION_CPU |
87                 MSI_ADDR_DEST_ID(pirq);
88
89         msg->data = XEN_PIRQ_MSI_DATA;
90 }
91
92 static int xen_hvm_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
93 {
94         int irq, pirq, ret = 0;
95         struct msi_desc *msidesc;
96         struct msi_msg msg;
97
98         list_for_each_entry(msidesc, &dev->msi_list, list) {
99                 __read_msi_msg(msidesc, &msg);
100                 pirq = MSI_ADDR_EXT_DEST_ID(msg.address_hi) |
101                         ((msg.address_lo >> MSI_ADDR_DEST_ID_SHIFT) & 0xff);
102                 if (xen_irq_from_pirq(pirq) >= 0 && msg.data == XEN_PIRQ_MSI_DATA) {
103                         xen_allocate_pirq_msi((type == PCI_CAP_ID_MSIX) ?
104                                         "msi-x" : "msi", &irq, &pirq, XEN_ALLOC_IRQ);
105                         if (irq < 0)
106                                 goto error;
107                         ret = set_irq_msi(irq, msidesc);
108                         if (ret < 0)
109                                 goto error_while;
110                         printk(KERN_DEBUG "xen: msi already setup: msi --> irq=%d"
111                                         " pirq=%d\n", irq, pirq);
112                         return 0;
113                 }
114                 xen_allocate_pirq_msi((type == PCI_CAP_ID_MSIX) ?
115                                 "msi-x" : "msi", &irq, &pirq, (XEN_ALLOC_IRQ | XEN_ALLOC_PIRQ));
116                 if (irq < 0 || pirq < 0)
117                         goto error;
118                 printk(KERN_DEBUG "xen: msi --> irq=%d, pirq=%d\n", irq, pirq);
119                 xen_msi_compose_msg(dev, pirq, &msg);
120                 ret = set_irq_msi(irq, msidesc);
121                 if (ret < 0)
122                         goto error_while;
123                 write_msi_msg(irq, &msg);
124         }
125         return 0;
126
127 error_while:
128         unbind_from_irqhandler(irq, NULL);
129 error:
130         if (ret == -ENODEV)
131                 dev_err(&dev->dev, "Xen PCI frontend has not registered" \
132                                 " MSI/MSI-X support!\n");
133
134         return ret;
135 }
136
137 /*
138  * For MSI interrupts we have to use drivers/xen/event.s functions to
139  * allocate an irq_desc and setup the right */
140
141
142 static int xen_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
143 {
144         int irq, ret, i;
145         struct msi_desc *msidesc;
146         int *v;
147
148         v = kzalloc(sizeof(int) * max(1, nvec), GFP_KERNEL);
149         if (!v)
150                 return -ENOMEM;
151
152         if (type == PCI_CAP_ID_MSIX)
153                 ret = xen_pci_frontend_enable_msix(dev, v, nvec);
154         else
155                 ret = xen_pci_frontend_enable_msi(dev, v);
156         if (ret)
157                 goto error;
158         i = 0;
159         list_for_each_entry(msidesc, &dev->msi_list, list) {
160                 xen_allocate_pirq_msi(
161                         (type == PCI_CAP_ID_MSIX) ?
162                         "pcifront-msi-x" : "pcifront-msi",
163                         &irq, &v[i], XEN_ALLOC_IRQ);
164                 if (irq < 0) {
165                         ret = -1;
166                         goto free;
167                 }
168                 ret = set_irq_msi(irq, msidesc);
169                 if (ret)
170                         goto error_while;
171                 i++;
172         }
173         kfree(v);
174         return 0;
175
176 error_while:
177         unbind_from_irqhandler(irq, NULL);
178 error:
179         if (ret == -ENODEV)
180                 dev_err(&dev->dev, "Xen PCI frontend has not registered" \
181                         " MSI/MSI-X support!\n");
182 free:
183         kfree(v);
184         return ret;
185 }
186
187 static void xen_teardown_msi_irqs(struct pci_dev *dev)
188 {
189         struct msi_desc *msidesc;
190
191         msidesc = list_entry(dev->msi_list.next, struct msi_desc, list);
192         if (msidesc->msi_attrib.is_msix)
193                 xen_pci_frontend_disable_msix(dev);
194         else
195                 xen_pci_frontend_disable_msi(dev);
196
197         /* Free the IRQ's and the msidesc using the generic code. */
198         default_teardown_msi_irqs(dev);
199 }
200
201 static void xen_teardown_msi_irq(unsigned int irq)
202 {
203         xen_destroy_irq(irq);
204 }
205
206 static int xen_initdom_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
207 {
208         int irq, ret;
209         struct msi_desc *msidesc;
210
211         list_for_each_entry(msidesc, &dev->msi_list, list) {
212                 irq = xen_create_msi_irq(dev, msidesc, type);
213                 if (irq < 0)
214                         return -1;
215
216                 ret = set_irq_msi(irq, msidesc);
217                 if (ret)
218                         goto error;
219         }
220         return 0;
221
222 error:
223         xen_destroy_irq(irq);
224         return ret;
225 }
226 #endif
227
228 static int xen_pcifront_enable_irq(struct pci_dev *dev)
229 {
230         int rc;
231         int share = 1;
232
233         dev_info(&dev->dev, "Xen PCI enabling IRQ: %d\n", dev->irq);
234
235         if (dev->irq < 0)
236                 return -EINVAL;
237
238         if (dev->irq < NR_IRQS_LEGACY)
239                 share = 0;
240
241         rc = xen_allocate_pirq(dev->irq, share, "pcifront");
242         if (rc < 0) {
243                 dev_warn(&dev->dev, "Xen PCI IRQ: %d, failed to register:%d\n",
244                          dev->irq, rc);
245                 return rc;
246         }
247         return 0;
248 }
249
250 int __init pci_xen_init(void)
251 {
252         if (!xen_pv_domain() || xen_initial_domain())
253                 return -ENODEV;
254
255         printk(KERN_INFO "PCI: setting up Xen PCI frontend stub\n");
256
257         pcibios_set_cache_line_size();
258
259         pcibios_enable_irq = xen_pcifront_enable_irq;
260         pcibios_disable_irq = NULL;
261
262 #ifdef CONFIG_ACPI
263         /* Keep ACPI out of the picture */
264         acpi_noirq = 1;
265 #endif
266
267 #ifdef CONFIG_PCI_MSI
268         x86_msi.setup_msi_irqs = xen_setup_msi_irqs;
269         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
270         x86_msi.teardown_msi_irqs = xen_teardown_msi_irqs;
271 #endif
272         return 0;
273 }
274
275 int __init pci_xen_hvm_init(void)
276 {
277         if (!xen_feature(XENFEAT_hvm_pirqs))
278                 return 0;
279
280 #ifdef CONFIG_ACPI
281         /*
282          * We don't want to change the actual ACPI delivery model,
283          * just how GSIs get registered.
284          */
285         __acpi_register_gsi = acpi_register_gsi_xen_hvm;
286 #endif
287
288 #ifdef CONFIG_PCI_MSI
289         x86_msi.setup_msi_irqs = xen_hvm_setup_msi_irqs;
290         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
291 #endif
292         return 0;
293 }
294
295 #ifdef CONFIG_XEN_DOM0
296 static int xen_register_pirq(u32 gsi, int triggering)
297 {
298         int rc, irq;
299         struct physdev_map_pirq map_irq;
300         int shareable = 0;
301         char *name;
302
303         if (!xen_pv_domain())
304                 return -1;
305
306         if (triggering == ACPI_EDGE_SENSITIVE) {
307                 shareable = 0;
308                 name = "ioapic-edge";
309         } else {
310                 shareable = 1;
311                 name = "ioapic-level";
312         }
313
314         irq = xen_allocate_pirq(gsi, shareable, name);
315
316         printk(KERN_DEBUG "xen: --> irq=%d\n", irq);
317
318         if (irq < 0)
319                 goto out;
320
321         map_irq.domid = DOMID_SELF;
322         map_irq.type = MAP_PIRQ_TYPE_GSI;
323         map_irq.index = gsi;
324         map_irq.pirq = irq;
325
326         rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
327         if (rc) {
328                 printk(KERN_WARNING "xen map irq failed %d\n", rc);
329                 return -1;
330         }
331
332 out:
333         return irq;
334 }
335
336 static int xen_register_gsi(u32 gsi, int triggering, int polarity)
337 {
338         int rc, irq;
339         struct physdev_setup_gsi setup_gsi;
340
341         if (!xen_pv_domain())
342                 return -1;
343
344         printk(KERN_DEBUG "xen: registering gsi %u triggering %d polarity %d\n",
345                         gsi, triggering, polarity);
346
347         irq = xen_register_pirq(gsi, triggering);
348
349         setup_gsi.gsi = gsi;
350         setup_gsi.triggering = (triggering == ACPI_EDGE_SENSITIVE ? 0 : 1);
351         setup_gsi.polarity = (polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
352
353         rc = HYPERVISOR_physdev_op(PHYSDEVOP_setup_gsi, &setup_gsi);
354         if (rc == -EEXIST)
355                 printk(KERN_INFO "Already setup the GSI :%d\n", gsi);
356         else if (rc) {
357                 printk(KERN_ERR "Failed to setup GSI :%d, err_code:%d\n",
358                                 gsi, rc);
359         }
360
361         return irq;
362 }
363
364 static __init void xen_setup_acpi_sci(void)
365 {
366         int rc;
367         int trigger, polarity;
368         int gsi = acpi_sci_override_gsi;
369
370         if (!gsi)
371                 return;
372
373         rc = acpi_get_override_irq(gsi, &trigger, &polarity);
374         if (rc) {
375                 printk(KERN_WARNING "xen: acpi_get_override_irq failed for acpi"
376                                 " sci, rc=%d\n", rc);
377                 return;
378         }
379         trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
380         polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
381         
382         printk(KERN_INFO "xen: sci override: global_irq=%d trigger=%d "
383                         "polarity=%d\n", gsi, trigger, polarity);
384
385         gsi = xen_register_gsi(gsi, trigger, polarity);
386         printk(KERN_INFO "xen: acpi sci %d\n", gsi);
387
388         return;
389 }
390
391 static int acpi_register_gsi_xen(struct device *dev, u32 gsi,
392                                  int trigger, int polarity)
393 {
394         return xen_register_gsi(gsi, trigger, polarity);
395 }
396
397 static int __init pci_xen_initial_domain(void)
398 {
399 #ifdef CONFIG_PCI_MSI
400         x86_msi.setup_msi_irqs = xen_initdom_setup_msi_irqs;
401         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
402 #endif
403         xen_setup_acpi_sci();
404         __acpi_register_gsi = acpi_register_gsi_xen;
405
406         return 0;
407 }
408
409 void __init xen_setup_pirqs(void)
410 {
411         int irq;
412
413         pci_xen_initial_domain();
414
415         if (0 == nr_ioapics) {
416                 for (irq = 0; irq < NR_IRQS_LEGACY; irq++)
417                         xen_allocate_pirq(irq, 0, "xt-pic");
418                 return;
419         }
420
421         /* Pre-allocate legacy irqs */
422         for (irq = 0; irq < NR_IRQS_LEGACY; irq++) {
423                 int trigger, polarity;
424
425                 if (acpi_get_override_irq(irq, &trigger, &polarity) == -1)
426                         continue;
427
428                 xen_register_pirq(irq,
429                         trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE);
430         }
431 }
432 #endif