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 static void xen_msi_compose_msg(struct pci_dev *pdev, unsigned int pirq,
  74                 struct msi_msg *msg)
  75 {
  76         /* We set vector == 0 to tell the hypervisor we don't care about it,
  77          * but we want a pirq setup instead.
  78          * We use the dest_id field to pass the pirq that we want. */
  79         msg->address_hi = MSI_ADDR_BASE_HI | MSI_ADDR_EXT_DEST_ID(pirq);
  80         msg->address_lo =
  81                 MSI_ADDR_BASE_LO |
  82                 MSI_ADDR_DEST_MODE_PHYSICAL |
  83                 MSI_ADDR_REDIRECTION_CPU |
  84                 MSI_ADDR_DEST_ID(pirq);
  85
  86         msg->data =
  87                 MSI_DATA_TRIGGER_EDGE |
  88                 MSI_DATA_LEVEL_ASSERT |
  89                 /* delivery mode reserved */
  90                 (3 << 8) |
  91                 MSI_DATA_VECTOR(0);
  92 }
  93
  94 static int xen_hvm_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
  95 {
  96         int irq, pirq, ret = 0;
  97         struct msi_desc *msidesc;
  98         struct msi_msg msg;
  99
 100         list_for_each_entry(msidesc, &dev->msi_list, list) {
 101                 xen_allocate_pirq_msi((type == PCI_CAP_ID_MSIX) ?
 102                                 "msi-x" : "msi", &irq, &pirq);
 103                 if (irq < 0 || pirq < 0)
 104                         goto error;
 105                 printk(KERN_DEBUG "xen: msi --> irq=%d, pirq=%d\n", irq, pirq);
 106                 xen_msi_compose_msg(dev, pirq, &msg);
 107                 ret = set_irq_msi(irq, msidesc);
 108                 if (ret < 0)
 109                         goto error_while;
 110                 write_msi_msg(irq, &msg);
 111         }
 112         return 0;
 113
 114 error_while:
 115         unbind_from_irqhandler(irq, NULL);
 116 error:
 117         if (ret == -ENODEV)
 118                 dev_err(&dev->dev, "Xen PCI frontend has not registered" \
 119                                 " MSI/MSI-X support!\n");
 120
 121         return ret;
 122 }
 123
 124 /*
 125  * For MSI interrupts we have to use drivers/xen/event.s functions to
 126  * allocate an irq_desc and setup the right */
 127
 128
 129 static int xen_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
 130 {
 131         int irq, ret, i;
 132         struct msi_desc *msidesc;
 133         int *v;
 134
 135         v = kzalloc(sizeof(int) * max(1, nvec), GFP_KERNEL);
 136         if (!v)
 137                 return -ENOMEM;
 138
 139         if (type == PCI_CAP_ID_MSIX)
 140                 ret = xen_pci_frontend_enable_msix(dev, &v, nvec);
 141         else
 142                 ret = xen_pci_frontend_enable_msi(dev, &v);
 143         if (ret)
 144                 goto error;
 145         i = 0;
 146         list_for_each_entry(msidesc, &dev->msi_list, list) {
 147                 irq = xen_allocate_pirq(v[i], 0, /* not sharable */
 148                         (type == PCI_CAP_ID_MSIX) ?
 149                         "pcifront-msi-x" : "pcifront-msi");
 150                 if (irq < 0) {
 151                         ret = -1;
 152                         goto free;
 153                 }
 154
 155                 ret = set_irq_msi(irq, msidesc);
 156                 if (ret)
 157                         goto error_while;
 158                 i++;
 159         }
 160         kfree(v);
 161         return 0;
 162
 163 error_while:
 164         unbind_from_irqhandler(irq, NULL);
 165 error:
 166         if (ret == -ENODEV)
 167                 dev_err(&dev->dev, "Xen PCI frontend has not registered" \
 168                         " MSI/MSI-X support!\n");
 169 free:
 170         kfree(v);
 171         return ret;
 172 }
 173
 174 static void xen_teardown_msi_irqs(struct pci_dev *dev)
 175 {
 176         struct msi_desc *msidesc;
 177
 178         msidesc = list_entry(dev->msi_list.next, struct msi_desc, list);
 179         if (msidesc->msi_attrib.is_msix)
 180                 xen_pci_frontend_disable_msix(dev);
 181         else
 182                 xen_pci_frontend_disable_msi(dev);
 183 }
 184
 185 static void xen_teardown_msi_irq(unsigned int irq)
 186 {
 187         xen_destroy_irq(irq);
 188 }
 189
 190 static int xen_initdom_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
 191 {
 192         int irq, ret;
 193         struct msi_desc *msidesc;
 194
 195         list_for_each_entry(msidesc, &dev->msi_list, list) {
 196                 irq = xen_create_msi_irq(dev, msidesc, type);
 197                 if (irq < 0)
 198                         return -1;
 199
 200                 ret = set_irq_msi(irq, msidesc);
 201                 if (ret)
 202                         goto error;
 203         }
 204         return 0;
 205
 206 error:
 207         xen_destroy_irq(irq);
 208         return ret;
 209 }
 210 #endif
 211
 212 static int xen_pcifront_enable_irq(struct pci_dev *dev)
 213 {
 214         int rc;
 215         int share = 1;
 216
 217         dev_info(&dev->dev, "Xen PCI enabling IRQ: %d\n", dev->irq);
 218
 219         if (dev->irq < 0)
 220                 return -EINVAL;
 221
 222         if (dev->irq < NR_IRQS_LEGACY)
 223                 share = 0;
 224
 225         rc = xen_allocate_pirq(dev->irq, share, "pcifront");
 226         if (rc < 0) {
 227                 dev_warn(&dev->dev, "Xen PCI IRQ: %d, failed to register:%d\n",
 228                          dev->irq, rc);
 229                 return rc;
 230         }
 231         return 0;
 232 }
 233
 234 int __init pci_xen_init(void)
 235 {
 236         if (!xen_pv_domain() || xen_initial_domain())
 237                 return -ENODEV;
 238
 239         printk(KERN_INFO "PCI: setting up Xen PCI frontend stub\n");
 240
 241         pcibios_set_cache_line_size();
 242
 243         pcibios_enable_irq = xen_pcifront_enable_irq;
 244         pcibios_disable_irq = NULL;
 245
 246 #ifdef CONFIG_ACPI
 247         /* Keep ACPI out of the picture */
 248         acpi_noirq = 1;
 249 #endif
 250
 251 #ifdef CONFIG_PCI_MSI
 252         x86_msi.setup_msi_irqs = xen_setup_msi_irqs;
 253         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
 254         x86_msi.teardown_msi_irqs = xen_teardown_msi_irqs;
 255 #endif
 256         return 0;
 257 }
 258
 259 int __init pci_xen_hvm_init(void)
 260 {
 261         if (!xen_feature(XENFEAT_hvm_pirqs))
 262                 return 0;
 263
 264 #ifdef CONFIG_ACPI
 265         /*
 266          * We don't want to change the actual ACPI delivery model,
 267          * just how GSIs get registered.
 268          */
 269         __acpi_register_gsi = acpi_register_gsi_xen_hvm;
 270 #endif
 271
 272 #ifdef CONFIG_PCI_MSI
 273         x86_msi.setup_msi_irqs = xen_hvm_setup_msi_irqs;
 274         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
 275 #endif
 276         return 0;
 277 }
 278
 279 #ifdef CONFIG_XEN_DOM0
 280 static int xen_register_pirq(u32 gsi, int triggering)
 281 {
 282         int rc, irq;
 283         struct physdev_map_pirq map_irq;
 284         int shareable = 0;
 285         char *name;
 286
 287         if (!xen_pv_domain())
 288                 return -1;
 289
 290         if (triggering == ACPI_EDGE_SENSITIVE) {
 291                 shareable = 0;
 292                 name = "ioapic-edge";
 293         } else {
 294                 shareable = 1;
 295                 name = "ioapic-level";
 296         }
 297
 298         irq = xen_allocate_pirq(gsi, shareable, name);
 299
 300         printk(KERN_DEBUG "xen: --> irq=%d\n", irq);
 301
 302         if (irq < 0)
 303                 goto out;
 304
 305         map_irq.domid = DOMID_SELF;
 306         map_irq.type = MAP_PIRQ_TYPE_GSI;
 307         map_irq.index = gsi;
 308         map_irq.pirq = irq;
 309
 310         rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
 311         if (rc) {
 312                 printk(KERN_WARNING "xen map irq failed %d\n", rc);
 313                 return -1;
 314         }
 315
 316 out:
 317         return irq;
 318 }
 319
 320 static int xen_register_gsi(u32 gsi, int triggering, int polarity)
 321 {
 322         int rc, irq;
 323         struct physdev_setup_gsi setup_gsi;
 324
 325         if (!xen_pv_domain())
 326                 return -1;
 327
 328         printk(KERN_DEBUG "xen: registering gsi %u triggering %d polarity %d\n",
 329                         gsi, triggering, polarity);
 330
 331         irq = xen_register_pirq(gsi, triggering);
 332
 333         setup_gsi.gsi = gsi;
 334         setup_gsi.triggering = (triggering == ACPI_EDGE_SENSITIVE ? 0 : 1);
 335         setup_gsi.polarity = (polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
 336
 337         rc = HYPERVISOR_physdev_op(PHYSDEVOP_setup_gsi, &setup_gsi);
 338         if (rc == -EEXIST)
 339                 printk(KERN_INFO "Already setup the GSI :%d\n", gsi);
 340         else if (rc) {
 341                 printk(KERN_ERR "Failed to setup GSI :%d, err_code:%d\n",
 342                                 gsi, rc);
 343         }
 344
 345         return irq;
 346 }
 347
 348 static __init void xen_setup_acpi_sci(void)
 349 {
 350         int rc;
 351         int trigger, polarity;
 352         int gsi = acpi_sci_override_gsi;
 353
 354         if (!gsi)
 355                 return;
 356
 357         rc = acpi_get_override_irq(gsi, &trigger, &polarity);
 358         if (rc) {
 359                 printk(KERN_WARNING "xen: acpi_get_override_irq failed for acpi"
 360                                 " sci, rc=%d\n", rc);
 361                 return;
 362         }
 363         trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
 364         polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
 365
 366         printk(KERN_INFO "xen: sci override: global_irq=%d trigger=%d "
 367                         "polarity=%d\n", gsi, trigger, polarity);
 368
 369         gsi = xen_register_gsi(gsi, trigger, polarity);
 370         printk(KERN_INFO "xen: acpi sci %d\n", gsi);
 371
 372         return;
 373 }
 374
 375 static int acpi_register_gsi_xen(struct device *dev, u32 gsi,
 376                                  int trigger, int polarity)
 377 {
 378         return xen_register_gsi(gsi, trigger, polarity);
 379 }
 380
 381 static int __init pci_xen_initial_domain(void)
 382 {
 383 #ifdef CONFIG_PCI_MSI
 384         x86_msi.setup_msi_irqs = xen_initdom_setup_msi_irqs;
 385         x86_msi.teardown_msi_irq = xen_teardown_msi_irq;
 386 #endif
 387         xen_setup_acpi_sci();
 388         __acpi_register_gsi = acpi_register_gsi_xen;
 389
 390         return 0;
 391 }
 392
 393 void __init xen_setup_pirqs(void)
 394 {
 395         int irq;
 396
 397         pci_xen_initial_domain();
 398
 399         if (0 == nr_ioapics) {
 400                 for (irq = 0; irq < NR_IRQS_LEGACY; irq++)
 401                         xen_allocate_pirq(irq, 0, "xt-pic");
 402                 return;
 403         }
 404
 405         /* Pre-allocate legacy irqs */
 406         for (irq = 0; irq < NR_IRQS_LEGACY; irq++) {
 407                 int trigger, polarity;
 408
 409                 if (acpi_get_override_irq(irq, &trigger, &polarity) == -1)
 410                         continue;
 411
 412                 xen_register_pirq(irq,
 413                         trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE);
 414         }
 415 }
 416 #endif