1 /* 2 * Xen PCI Frontend. 3 * 4 * Author: Ryan Wilson <hap9@epoch.ncsc.mil> 5 */ 6 #include <linux/module.h> 7 #include <linux/init.h> 8 #include <linux/mm.h> 9 #include <xen/xenbus.h> 10 #include <xen/events.h> 11 #include <xen/grant_table.h> 12 #include <xen/page.h> 13 #include <linux/spinlock.h> 14 #include <linux/pci.h> 15 #include <linux/msi.h> 16 #include <xen/interface/io/pciif.h> 17 #include <asm/xen/pci.h> 18 #include <linux/interrupt.h> 19 #include <linux/atomic.h> 20 #include <linux/workqueue.h> 21 #include <linux/bitops.h> 22 #include <linux/time.h> 23 24 #include <asm/xen/swiotlb-xen.h> 25 #define INVALID_GRANT_REF (0) 26 #define INVALID_EVTCHN (-1) 27 28 struct pci_bus_entry { 29 struct list_head list; 30 struct pci_bus *bus; 31 }; 32 33 #define _PDEVB_op_active (0) 34 #define PDEVB_op_active (1 << (_PDEVB_op_active)) 35 36 struct pcifront_device { 37 struct xenbus_device *xdev; 38 struct list_head root_buses; 39 40 int evtchn; 41 int gnt_ref; 42 43 int irq; 44 45 /* Lock this when doing any operations in sh_info */ 46 spinlock_t sh_info_lock; 47 struct xen_pci_sharedinfo *sh_info; 48 struct work_struct op_work; 49 unsigned long flags; 50 51 }; 52 53 struct pcifront_sd { 54 int domain; 55 struct pcifront_device *pdev; 56 }; 57 58 static inline struct pcifront_device * 59 pcifront_get_pdev(struct pcifront_sd *sd) 60 { 61 return sd->pdev; 62 } 63 64 static inline void pcifront_init_sd(struct pcifront_sd *sd, 65 unsigned int domain, unsigned int bus, 66 struct pcifront_device *pdev) 67 { 68 sd->domain = domain; 69 sd->pdev = pdev; 70 } 71 72 static DEFINE_SPINLOCK(pcifront_dev_lock); 73 static struct pcifront_device *pcifront_dev; 74 75 static int verbose_request; 76 module_param(verbose_request, int, 0644); 77 78 static int errno_to_pcibios_err(int errno) 79 { 80 switch (errno) { 81 case XEN_PCI_ERR_success: 82 return PCIBIOS_SUCCESSFUL; 83 84 case XEN_PCI_ERR_dev_not_found: 85 return PCIBIOS_DEVICE_NOT_FOUND; 86 87 case XEN_PCI_ERR_invalid_offset: 88 case XEN_PCI_ERR_op_failed: 89 return PCIBIOS_BAD_REGISTER_NUMBER; 90 91 case XEN_PCI_ERR_not_implemented: 92 return PCIBIOS_FUNC_NOT_SUPPORTED; 93 94 case XEN_PCI_ERR_access_denied: 95 return PCIBIOS_SET_FAILED; 96 } 97 return errno; 98 } 99 100 static inline void schedule_pcifront_aer_op(struct pcifront_device *pdev) 101 { 102 if (test_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags) 103 && !test_and_set_bit(_PDEVB_op_active, &pdev->flags)) { 104 dev_dbg(&pdev->xdev->dev, "schedule aer frontend job\n"); 105 schedule_work(&pdev->op_work); 106 } 107 } 108 109 static int do_pci_op(struct pcifront_device *pdev, struct xen_pci_op *op) 110 { 111 int err = 0; 112 struct xen_pci_op *active_op = &pdev->sh_info->op; 113 unsigned long irq_flags; 114 evtchn_port_t port = pdev->evtchn; 115 unsigned irq = pdev->irq; 116 s64 ns, ns_timeout; 117 struct timeval tv; 118 119 spin_lock_irqsave(&pdev->sh_info_lock, irq_flags); 120 121 memcpy(active_op, op, sizeof(struct xen_pci_op)); 122 123 /* Go */ 124 wmb(); 125 set_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags); 126 notify_remote_via_evtchn(port); 127 128 /* 129 * We set a poll timeout of 3 seconds but give up on return after 130 * 2 seconds. It is better to time out too late rather than too early 131 * (in the latter case we end up continually re-executing poll() with a 132 * timeout in the past). 1s difference gives plenty of slack for error. 133 */ 134 do_gettimeofday(&tv); 135 ns_timeout = timeval_to_ns(&tv) + 2 * (s64)NSEC_PER_SEC; 136 137 xen_clear_irq_pending(irq); 138 139 while (test_bit(_XEN_PCIF_active, 140 (unsigned long *)&pdev->sh_info->flags)) { 141 xen_poll_irq_timeout(irq, jiffies + 3*HZ); 142 xen_clear_irq_pending(irq); 143 do_gettimeofday(&tv); 144 ns = timeval_to_ns(&tv); 145 if (ns > ns_timeout) { 146 dev_err(&pdev->xdev->dev, 147 "pciback not responding!!!\n"); 148 clear_bit(_XEN_PCIF_active, 149 (unsigned long *)&pdev->sh_info->flags); 150 err = XEN_PCI_ERR_dev_not_found; 151 goto out; 152 } 153 } 154 155 /* 156 * We might lose backend service request since we 157 * reuse same evtchn with pci_conf backend response. So re-schedule 158 * aer pcifront service. 159 */ 160 if (test_bit(_XEN_PCIB_active, 161 (unsigned long *)&pdev->sh_info->flags)) { 162 dev_err(&pdev->xdev->dev, 163 "schedule aer pcifront service\n"); 164 schedule_pcifront_aer_op(pdev); 165 } 166 167 memcpy(op, active_op, sizeof(struct xen_pci_op)); 168 169 err = op->err; 170 out: 171 spin_unlock_irqrestore(&pdev->sh_info_lock, irq_flags); 172 return err; 173 } 174 175 /* Access to this function is spinlocked in drivers/pci/access.c */ 176 static int pcifront_bus_read(struct pci_bus *bus, unsigned int devfn, 177 int where, int size, u32 *val) 178 { 179 int err = 0; 180 struct xen_pci_op op = { 181 .cmd = XEN_PCI_OP_conf_read, 182 .domain = pci_domain_nr(bus), 183 .bus = bus->number, 184 .devfn = devfn, 185 .offset = where, 186 .size = size, 187 }; 188 struct pcifront_sd *sd = bus->sysdata; 189 struct pcifront_device *pdev = pcifront_get_pdev(sd); 190 191 if (verbose_request) 192 dev_info(&pdev->xdev->dev, 193 "read dev=%04x:%02x:%02x.%d - offset %x size %d\n", 194 pci_domain_nr(bus), bus->number, PCI_SLOT(devfn), 195 PCI_FUNC(devfn), where, size); 196 197 err = do_pci_op(pdev, &op); 198 199 if (likely(!err)) { 200 if (verbose_request) 201 dev_info(&pdev->xdev->dev, "read got back value %x\n", 202 op.value); 203 204 *val = op.value; 205 } else if (err == -ENODEV) { 206 /* No device here, pretend that it just returned 0 */ 207 err = 0; 208 *val = 0; 209 } 210 211 return errno_to_pcibios_err(err); 212 } 213 214 /* Access to this function is spinlocked in drivers/pci/access.c */ 215 static int pcifront_bus_write(struct pci_bus *bus, unsigned int devfn, 216 int where, int size, u32 val) 217 { 218 struct xen_pci_op op = { 219 .cmd = XEN_PCI_OP_conf_write, 220 .domain = pci_domain_nr(bus), 221 .bus = bus->number, 222 .devfn = devfn, 223 .offset = where, 224 .size = size, 225 .value = val, 226 }; 227 struct pcifront_sd *sd = bus->sysdata; 228 struct pcifront_device *pdev = pcifront_get_pdev(sd); 229 230 if (verbose_request) 231 dev_info(&pdev->xdev->dev, 232 "write dev=%04x:%02x:%02x.%d - " 233 "offset %x size %d val %x\n", 234 pci_domain_nr(bus), bus->number, 235 PCI_SLOT(devfn), PCI_FUNC(devfn), where, size, val); 236 237 return errno_to_pcibios_err(do_pci_op(pdev, &op)); 238 } 239 240 static struct pci_ops pcifront_bus_ops = { 241 .read = pcifront_bus_read, 242 .write = pcifront_bus_write, 243 }; 244 245 #ifdef CONFIG_PCI_MSI 246 static int pci_frontend_enable_msix(struct pci_dev *dev, 247 int vector[], int nvec) 248 { 249 int err; 250 int i; 251 struct xen_pci_op op = { 252 .cmd = XEN_PCI_OP_enable_msix, 253 .domain = pci_domain_nr(dev->bus), 254 .bus = dev->bus->number, 255 .devfn = dev->devfn, 256 .value = nvec, 257 }; 258 struct pcifront_sd *sd = dev->bus->sysdata; 259 struct pcifront_device *pdev = pcifront_get_pdev(sd); 260 struct msi_desc *entry; 261 262 if (nvec > SH_INFO_MAX_VEC) { 263 dev_err(&dev->dev, "too much vector for pci frontend: %x." 264 " Increase SH_INFO_MAX_VEC.\n", nvec); 265 return -EINVAL; 266 } 267 268 i = 0; 269 list_for_each_entry(entry, &dev->msi_list, list) { 270 op.msix_entries[i].entry = entry->msi_attrib.entry_nr; 271 /* Vector is useless at this point. */ 272 op.msix_entries[i].vector = -1; 273 i++; 274 } 275 276 err = do_pci_op(pdev, &op); 277 278 if (likely(!err)) { 279 if (likely(!op.value)) { 280 /* we get the result */ 281 for (i = 0; i < nvec; i++) { 282 if (op.msix_entries[i].vector <= 0) { 283 dev_warn(&dev->dev, "MSI-X entry %d is invalid: %d!\n", 284 i, op.msix_entries[i].vector); 285 err = -EINVAL; 286 vector[i] = -1; 287 continue; 288 } 289 vector[i] = op.msix_entries[i].vector; 290 } 291 } else { 292 printk(KERN_DEBUG "enable msix get value %x\n", 293 op.value); 294 err = op.value; 295 } 296 } else { 297 dev_err(&dev->dev, "enable msix get err %x\n", err); 298 } 299 return err; 300 } 301 302 static void pci_frontend_disable_msix(struct pci_dev *dev) 303 { 304 int err; 305 struct xen_pci_op op = { 306 .cmd = XEN_PCI_OP_disable_msix, 307 .domain = pci_domain_nr(dev->bus), 308 .bus = dev->bus->number, 309 .devfn = dev->devfn, 310 }; 311 struct pcifront_sd *sd = dev->bus->sysdata; 312 struct pcifront_device *pdev = pcifront_get_pdev(sd); 313 314 err = do_pci_op(pdev, &op); 315 316 /* What should do for error ? */ 317 if (err) 318 dev_err(&dev->dev, "pci_disable_msix get err %x\n", err); 319 } 320 321 static int pci_frontend_enable_msi(struct pci_dev *dev, int vector[]) 322 { 323 int err; 324 struct xen_pci_op op = { 325 .cmd = XEN_PCI_OP_enable_msi, 326 .domain = pci_domain_nr(dev->bus), 327 .bus = dev->bus->number, 328 .devfn = dev->devfn, 329 }; 330 struct pcifront_sd *sd = dev->bus->sysdata; 331 struct pcifront_device *pdev = pcifront_get_pdev(sd); 332 333 err = do_pci_op(pdev, &op); 334 if (likely(!err)) { 335 vector[0] = op.value; 336 if (op.value <= 0) { 337 dev_warn(&dev->dev, "MSI entry is invalid: %d!\n", 338 op.value); 339 err = -EINVAL; 340 vector[0] = -1; 341 } 342 } else { 343 dev_err(&dev->dev, "pci frontend enable msi failed for dev " 344 "%x:%x\n", op.bus, op.devfn); 345 err = -EINVAL; 346 } 347 return err; 348 } 349 350 static void pci_frontend_disable_msi(struct pci_dev *dev) 351 { 352 int err; 353 struct xen_pci_op op = { 354 .cmd = XEN_PCI_OP_disable_msi, 355 .domain = pci_domain_nr(dev->bus), 356 .bus = dev->bus->number, 357 .devfn = dev->devfn, 358 }; 359 struct pcifront_sd *sd = dev->bus->sysdata; 360 struct pcifront_device *pdev = pcifront_get_pdev(sd); 361 362 err = do_pci_op(pdev, &op); 363 if (err == XEN_PCI_ERR_dev_not_found) { 364 /* XXX No response from backend, what shall we do? */ 365 printk(KERN_DEBUG "get no response from backend for disable MSI\n"); 366 return; 367 } 368 if (err) 369 /* how can pciback notify us fail? */ 370 printk(KERN_DEBUG "get fake response frombackend\n"); 371 } 372 373 static struct xen_pci_frontend_ops pci_frontend_ops = { 374 .enable_msi = pci_frontend_enable_msi, 375 .disable_msi = pci_frontend_disable_msi, 376 .enable_msix = pci_frontend_enable_msix, 377 .disable_msix = pci_frontend_disable_msix, 378 }; 379 380 static void pci_frontend_registrar(int enable) 381 { 382 if (enable) 383 xen_pci_frontend = &pci_frontend_ops; 384 else 385 xen_pci_frontend = NULL; 386 }; 387 #else 388 static inline void pci_frontend_registrar(int enable) { }; 389 #endif /* CONFIG_PCI_MSI */ 390 391 /* Claim resources for the PCI frontend as-is, backend won't allow changes */ 392 static int pcifront_claim_resource(struct pci_dev *dev, void *data) 393 { 394 struct pcifront_device *pdev = data; 395 int i; 396 struct resource *r; 397 398 for (i = 0; i < PCI_NUM_RESOURCES; i++) { 399 r = &dev->resource[i]; 400 401 if (!r->parent && r->start && r->flags) { 402 dev_info(&pdev->xdev->dev, "claiming resource %s/%d\n", 403 pci_name(dev), i); 404 if (pci_claim_resource(dev, i)) { 405 dev_err(&pdev->xdev->dev, "Could not claim resource %s/%d! " 406 "Device offline. Try using e820_host=1 in the guest config.\n", 407 pci_name(dev), i); 408 } 409 } 410 } 411 412 return 0; 413 } 414 415 static int pcifront_scan_bus(struct pcifront_device *pdev, 416 unsigned int domain, unsigned int bus, 417 struct pci_bus *b) 418 { 419 struct pci_dev *d; 420 unsigned int devfn; 421 422 /* Scan the bus for functions and add. 423 * We omit handling of PCI bridge attachment because pciback prevents 424 * bridges from being exported. 425 */ 426 for (devfn = 0; devfn < 0x100; devfn++) { 427 d = pci_get_slot(b, devfn); 428 if (d) { 429 /* Device is already known. */ 430 pci_dev_put(d); 431 continue; 432 } 433 434 d = pci_scan_single_device(b, devfn); 435 if (d) 436 dev_info(&pdev->xdev->dev, "New device on " 437 "%04x:%02x:%02x.%d found.\n", domain, bus, 438 PCI_SLOT(devfn), PCI_FUNC(devfn)); 439 } 440 441 return 0; 442 } 443 444 static int pcifront_scan_root(struct pcifront_device *pdev, 445 unsigned int domain, unsigned int bus) 446 { 447 struct pci_bus *b; 448 struct pcifront_sd *sd = NULL; 449 struct pci_bus_entry *bus_entry = NULL; 450 int err = 0; 451 452 #ifndef CONFIG_PCI_DOMAINS 453 if (domain != 0) { 454 dev_err(&pdev->xdev->dev, 455 "PCI Root in non-zero PCI Domain! domain=%d\n", domain); 456 dev_err(&pdev->xdev->dev, 457 "Please compile with CONFIG_PCI_DOMAINS\n"); 458 err = -EINVAL; 459 goto err_out; 460 } 461 #endif 462 463 dev_info(&pdev->xdev->dev, "Creating PCI Frontend Bus %04x:%02x\n", 464 domain, bus); 465 466 bus_entry = kmalloc(sizeof(*bus_entry), GFP_KERNEL); 467 sd = kmalloc(sizeof(*sd), GFP_KERNEL); 468 if (!bus_entry || !sd) { 469 err = -ENOMEM; 470 goto err_out; 471 } 472 pcifront_init_sd(sd, domain, bus, pdev); 473 474 b = pci_scan_bus_parented(&pdev->xdev->dev, bus, 475 &pcifront_bus_ops, sd); 476 if (!b) { 477 dev_err(&pdev->xdev->dev, 478 "Error creating PCI Frontend Bus!\n"); 479 err = -ENOMEM; 480 goto err_out; 481 } 482 483 bus_entry->bus = b; 484 485 list_add(&bus_entry->list, &pdev->root_buses); 486 487 /* pci_scan_bus_parented skips devices which do not have a have 488 * devfn==0. The pcifront_scan_bus enumerates all devfn. */ 489 err = pcifront_scan_bus(pdev, domain, bus, b); 490 491 /* Claim resources before going "live" with our devices */ 492 pci_walk_bus(b, pcifront_claim_resource, pdev); 493 494 /* Create SysFS and notify udev of the devices. Aka: "going live" */ 495 pci_bus_add_devices(b); 496 497 return err; 498 499 err_out: 500 kfree(bus_entry); 501 kfree(sd); 502 503 return err; 504 } 505 506 static int pcifront_rescan_root(struct pcifront_device *pdev, 507 unsigned int domain, unsigned int bus) 508 { 509 int err; 510 struct pci_bus *b; 511 512 #ifndef CONFIG_PCI_DOMAINS 513 if (domain != 0) { 514 dev_err(&pdev->xdev->dev, 515 "PCI Root in non-zero PCI Domain! domain=%d\n", domain); 516 dev_err(&pdev->xdev->dev, 517 "Please compile with CONFIG_PCI_DOMAINS\n"); 518 return -EINVAL; 519 } 520 #endif 521 522 dev_info(&pdev->xdev->dev, "Rescanning PCI Frontend Bus %04x:%02x\n", 523 domain, bus); 524 525 b = pci_find_bus(domain, bus); 526 if (!b) 527 /* If the bus is unknown, create it. */ 528 return pcifront_scan_root(pdev, domain, bus); 529 530 err = pcifront_scan_bus(pdev, domain, bus, b); 531 532 /* Claim resources before going "live" with our devices */ 533 pci_walk_bus(b, pcifront_claim_resource, pdev); 534 535 /* Create SysFS and notify udev of the devices. Aka: "going live" */ 536 pci_bus_add_devices(b); 537 538 return err; 539 } 540 541 static void free_root_bus_devs(struct pci_bus *bus) 542 { 543 struct pci_dev *dev; 544 545 while (!list_empty(&bus->devices)) { 546 dev = container_of(bus->devices.next, struct pci_dev, 547 bus_list); 548 dev_dbg(&dev->dev, "removing device\n"); 549 pci_stop_and_remove_bus_device(dev); 550 } 551 } 552 553 static void pcifront_free_roots(struct pcifront_device *pdev) 554 { 555 struct pci_bus_entry *bus_entry, *t; 556 557 dev_dbg(&pdev->xdev->dev, "cleaning up root buses\n"); 558 559 list_for_each_entry_safe(bus_entry, t, &pdev->root_buses, list) { 560 list_del(&bus_entry->list); 561 562 free_root_bus_devs(bus_entry->bus); 563 564 kfree(bus_entry->bus->sysdata); 565 566 device_unregister(bus_entry->bus->bridge); 567 pci_remove_bus(bus_entry->bus); 568 569 kfree(bus_entry); 570 } 571 } 572 573 static pci_ers_result_t pcifront_common_process(int cmd, 574 struct pcifront_device *pdev, 575 pci_channel_state_t state) 576 { 577 pci_ers_result_t result; 578 struct pci_driver *pdrv; 579 int bus = pdev->sh_info->aer_op.bus; 580 int devfn = pdev->sh_info->aer_op.devfn; 581 struct pci_dev *pcidev; 582 int flag = 0; 583 584 dev_dbg(&pdev->xdev->dev, 585 "pcifront AER process: cmd %x (bus:%x, devfn%x)", 586 cmd, bus, devfn); 587 result = PCI_ERS_RESULT_NONE; 588 589 pcidev = pci_get_bus_and_slot(bus, devfn); 590 if (!pcidev || !pcidev->driver) { 591 dev_err(&pdev->xdev->dev, "device or AER driver is NULL\n"); 592 if (pcidev) 593 pci_dev_put(pcidev); 594 return result; 595 } 596 pdrv = pcidev->driver; 597 598 if (pdrv) { 599 if (pdrv->err_handler && pdrv->err_handler->error_detected) { 600 dev_dbg(&pcidev->dev, 601 "trying to call AER service\n"); 602 if (pcidev) { 603 flag = 1; 604 switch (cmd) { 605 case XEN_PCI_OP_aer_detected: 606 result = pdrv->err_handler-> 607 error_detected(pcidev, state); 608 break; 609 case XEN_PCI_OP_aer_mmio: 610 result = pdrv->err_handler-> 611 mmio_enabled(pcidev); 612 break; 613 case XEN_PCI_OP_aer_slotreset: 614 result = pdrv->err_handler-> 615 slot_reset(pcidev); 616 break; 617 case XEN_PCI_OP_aer_resume: 618 pdrv->err_handler->resume(pcidev); 619 break; 620 default: 621 dev_err(&pdev->xdev->dev, 622 "bad request in aer recovery " 623 "operation!\n"); 624 625 } 626 } 627 } 628 } 629 if (!flag) 630 result = PCI_ERS_RESULT_NONE; 631 632 return result; 633 } 634 635 636 static void pcifront_do_aer(struct work_struct *data) 637 { 638 struct pcifront_device *pdev = 639 container_of(data, struct pcifront_device, op_work); 640 int cmd = pdev->sh_info->aer_op.cmd; 641 pci_channel_state_t state = 642 (pci_channel_state_t)pdev->sh_info->aer_op.err; 643 644 /*If a pci_conf op is in progress, 645 we have to wait until it is done before service aer op*/ 646 dev_dbg(&pdev->xdev->dev, 647 "pcifront service aer bus %x devfn %x\n", 648 pdev->sh_info->aer_op.bus, pdev->sh_info->aer_op.devfn); 649 650 pdev->sh_info->aer_op.err = pcifront_common_process(cmd, pdev, state); 651 652 /* Post the operation to the guest. */ 653 wmb(); 654 clear_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags); 655 notify_remote_via_evtchn(pdev->evtchn); 656 657 /*in case of we lost an aer request in four lines time_window*/ 658 smp_mb__before_clear_bit(); 659 clear_bit(_PDEVB_op_active, &pdev->flags); 660 smp_mb__after_clear_bit(); 661 662 schedule_pcifront_aer_op(pdev); 663 664 } 665 666 static irqreturn_t pcifront_handler_aer(int irq, void *dev) 667 { 668 struct pcifront_device *pdev = dev; 669 schedule_pcifront_aer_op(pdev); 670 return IRQ_HANDLED; 671 } 672 static int pcifront_connect_and_init_dma(struct pcifront_device *pdev) 673 { 674 int err = 0; 675 676 spin_lock(&pcifront_dev_lock); 677 678 if (!pcifront_dev) { 679 dev_info(&pdev->xdev->dev, "Installing PCI frontend\n"); 680 pcifront_dev = pdev; 681 } else 682 err = -EEXIST; 683 684 spin_unlock(&pcifront_dev_lock); 685 686 if (!err && !swiotlb_nr_tbl()) { 687 err = pci_xen_swiotlb_init_late(); 688 if (err) 689 dev_err(&pdev->xdev->dev, "Could not setup SWIOTLB!\n"); 690 } 691 return err; 692 } 693 694 static void pcifront_disconnect(struct pcifront_device *pdev) 695 { 696 spin_lock(&pcifront_dev_lock); 697 698 if (pdev == pcifront_dev) { 699 dev_info(&pdev->xdev->dev, 700 "Disconnecting PCI Frontend Buses\n"); 701 pcifront_dev = NULL; 702 } 703 704 spin_unlock(&pcifront_dev_lock); 705 } 706 static struct pcifront_device *alloc_pdev(struct xenbus_device *xdev) 707 { 708 struct pcifront_device *pdev; 709 710 pdev = kzalloc(sizeof(struct pcifront_device), GFP_KERNEL); 711 if (pdev == NULL) 712 goto out; 713 714 pdev->sh_info = 715 (struct xen_pci_sharedinfo *)__get_free_page(GFP_KERNEL); 716 if (pdev->sh_info == NULL) { 717 kfree(pdev); 718 pdev = NULL; 719 goto out; 720 } 721 pdev->sh_info->flags = 0; 722 723 /*Flag for registering PV AER handler*/ 724 set_bit(_XEN_PCIB_AERHANDLER, (void *)&pdev->sh_info->flags); 725 726 dev_set_drvdata(&xdev->dev, pdev); 727 pdev->xdev = xdev; 728 729 INIT_LIST_HEAD(&pdev->root_buses); 730 731 spin_lock_init(&pdev->sh_info_lock); 732 733 pdev->evtchn = INVALID_EVTCHN; 734 pdev->gnt_ref = INVALID_GRANT_REF; 735 pdev->irq = -1; 736 737 INIT_WORK(&pdev->op_work, pcifront_do_aer); 738 739 dev_dbg(&xdev->dev, "Allocated pdev @ 0x%p pdev->sh_info @ 0x%p\n", 740 pdev, pdev->sh_info); 741 out: 742 return pdev; 743 } 744 745 static void free_pdev(struct pcifront_device *pdev) 746 { 747 dev_dbg(&pdev->xdev->dev, "freeing pdev @ 0x%p\n", pdev); 748 749 pcifront_free_roots(pdev); 750 751 cancel_work_sync(&pdev->op_work); 752 753 if (pdev->irq >= 0) 754 unbind_from_irqhandler(pdev->irq, pdev); 755 756 if (pdev->evtchn != INVALID_EVTCHN) 757 xenbus_free_evtchn(pdev->xdev, pdev->evtchn); 758 759 if (pdev->gnt_ref != INVALID_GRANT_REF) 760 gnttab_end_foreign_access(pdev->gnt_ref, 0 /* r/w page */, 761 (unsigned long)pdev->sh_info); 762 else 763 free_page((unsigned long)pdev->sh_info); 764 765 dev_set_drvdata(&pdev->xdev->dev, NULL); 766 767 kfree(pdev); 768 } 769 770 static int pcifront_publish_info(struct pcifront_device *pdev) 771 { 772 int err = 0; 773 struct xenbus_transaction trans; 774 775 err = xenbus_grant_ring(pdev->xdev, virt_to_mfn(pdev->sh_info)); 776 if (err < 0) 777 goto out; 778 779 pdev->gnt_ref = err; 780 781 err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn); 782 if (err) 783 goto out; 784 785 err = bind_evtchn_to_irqhandler(pdev->evtchn, pcifront_handler_aer, 786 0, "pcifront", pdev); 787 788 if (err < 0) 789 return err; 790 791 pdev->irq = err; 792 793 do_publish: 794 err = xenbus_transaction_start(&trans); 795 if (err) { 796 xenbus_dev_fatal(pdev->xdev, err, 797 "Error writing configuration for backend " 798 "(start transaction)"); 799 goto out; 800 } 801 802 err = xenbus_printf(trans, pdev->xdev->nodename, 803 "pci-op-ref", "%u", pdev->gnt_ref); 804 if (!err) 805 err = xenbus_printf(trans, pdev->xdev->nodename, 806 "event-channel", "%u", pdev->evtchn); 807 if (!err) 808 err = xenbus_printf(trans, pdev->xdev->nodename, 809 "magic", XEN_PCI_MAGIC); 810 811 if (err) { 812 xenbus_transaction_end(trans, 1); 813 xenbus_dev_fatal(pdev->xdev, err, 814 "Error writing configuration for backend"); 815 goto out; 816 } else { 817 err = xenbus_transaction_end(trans, 0); 818 if (err == -EAGAIN) 819 goto do_publish; 820 else if (err) { 821 xenbus_dev_fatal(pdev->xdev, err, 822 "Error completing transaction " 823 "for backend"); 824 goto out; 825 } 826 } 827 828 xenbus_switch_state(pdev->xdev, XenbusStateInitialised); 829 830 dev_dbg(&pdev->xdev->dev, "publishing successful!\n"); 831 832 out: 833 return err; 834 } 835 836 static int pcifront_try_connect(struct pcifront_device *pdev) 837 { 838 int err = -EFAULT; 839 int i, num_roots, len; 840 char str[64]; 841 unsigned int domain, bus; 842 843 844 /* Only connect once */ 845 if (xenbus_read_driver_state(pdev->xdev->nodename) != 846 XenbusStateInitialised) 847 goto out; 848 849 err = pcifront_connect_and_init_dma(pdev); 850 if (err && err != -EEXIST) { 851 xenbus_dev_fatal(pdev->xdev, err, 852 "Error setting up PCI Frontend"); 853 goto out; 854 } 855 856 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, 857 "root_num", "%d", &num_roots); 858 if (err == -ENOENT) { 859 xenbus_dev_error(pdev->xdev, err, 860 "No PCI Roots found, trying 0000:00"); 861 err = pcifront_scan_root(pdev, 0, 0); 862 num_roots = 0; 863 } else if (err != 1) { 864 if (err == 0) 865 err = -EINVAL; 866 xenbus_dev_fatal(pdev->xdev, err, 867 "Error reading number of PCI roots"); 868 goto out; 869 } 870 871 for (i = 0; i < num_roots; i++) { 872 len = snprintf(str, sizeof(str), "root-%d", i); 873 if (unlikely(len >= (sizeof(str) - 1))) { 874 err = -ENOMEM; 875 goto out; 876 } 877 878 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, 879 "%x:%x", &domain, &bus); 880 if (err != 2) { 881 if (err >= 0) 882 err = -EINVAL; 883 xenbus_dev_fatal(pdev->xdev, err, 884 "Error reading PCI root %d", i); 885 goto out; 886 } 887 888 err = pcifront_scan_root(pdev, domain, bus); 889 if (err) { 890 xenbus_dev_fatal(pdev->xdev, err, 891 "Error scanning PCI root %04x:%02x", 892 domain, bus); 893 goto out; 894 } 895 } 896 897 err = xenbus_switch_state(pdev->xdev, XenbusStateConnected); 898 899 out: 900 return err; 901 } 902 903 static int pcifront_try_disconnect(struct pcifront_device *pdev) 904 { 905 int err = 0; 906 enum xenbus_state prev_state; 907 908 909 prev_state = xenbus_read_driver_state(pdev->xdev->nodename); 910 911 if (prev_state >= XenbusStateClosing) 912 goto out; 913 914 if (prev_state == XenbusStateConnected) { 915 pcifront_free_roots(pdev); 916 pcifront_disconnect(pdev); 917 } 918 919 err = xenbus_switch_state(pdev->xdev, XenbusStateClosed); 920 921 out: 922 923 return err; 924 } 925 926 static int pcifront_attach_devices(struct pcifront_device *pdev) 927 { 928 int err = -EFAULT; 929 int i, num_roots, len; 930 unsigned int domain, bus; 931 char str[64]; 932 933 if (xenbus_read_driver_state(pdev->xdev->nodename) != 934 XenbusStateReconfiguring) 935 goto out; 936 937 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, 938 "root_num", "%d", &num_roots); 939 if (err == -ENOENT) { 940 xenbus_dev_error(pdev->xdev, err, 941 "No PCI Roots found, trying 0000:00"); 942 err = pcifront_rescan_root(pdev, 0, 0); 943 num_roots = 0; 944 } else if (err != 1) { 945 if (err == 0) 946 err = -EINVAL; 947 xenbus_dev_fatal(pdev->xdev, err, 948 "Error reading number of PCI roots"); 949 goto out; 950 } 951 952 for (i = 0; i < num_roots; i++) { 953 len = snprintf(str, sizeof(str), "root-%d", i); 954 if (unlikely(len >= (sizeof(str) - 1))) { 955 err = -ENOMEM; 956 goto out; 957 } 958 959 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, 960 "%x:%x", &domain, &bus); 961 if (err != 2) { 962 if (err >= 0) 963 err = -EINVAL; 964 xenbus_dev_fatal(pdev->xdev, err, 965 "Error reading PCI root %d", i); 966 goto out; 967 } 968 969 err = pcifront_rescan_root(pdev, domain, bus); 970 if (err) { 971 xenbus_dev_fatal(pdev->xdev, err, 972 "Error scanning PCI root %04x:%02x", 973 domain, bus); 974 goto out; 975 } 976 } 977 978 xenbus_switch_state(pdev->xdev, XenbusStateConnected); 979 980 out: 981 return err; 982 } 983 984 static int pcifront_detach_devices(struct pcifront_device *pdev) 985 { 986 int err = 0; 987 int i, num_devs; 988 unsigned int domain, bus, slot, func; 989 struct pci_dev *pci_dev; 990 char str[64]; 991 992 if (xenbus_read_driver_state(pdev->xdev->nodename) != 993 XenbusStateConnected) 994 goto out; 995 996 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, "num_devs", "%d", 997 &num_devs); 998 if (err != 1) { 999 if (err >= 0) 1000 err = -EINVAL; 1001 xenbus_dev_fatal(pdev->xdev, err, 1002 "Error reading number of PCI devices"); 1003 goto out; 1004 } 1005 1006 /* Find devices being detached and remove them. */ 1007 for (i = 0; i < num_devs; i++) { 1008 int l, state; 1009 l = snprintf(str, sizeof(str), "state-%d", i); 1010 if (unlikely(l >= (sizeof(str) - 1))) { 1011 err = -ENOMEM; 1012 goto out; 1013 } 1014 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, "%d", 1015 &state); 1016 if (err != 1) 1017 state = XenbusStateUnknown; 1018 1019 if (state != XenbusStateClosing) 1020 continue; 1021 1022 /* Remove device. */ 1023 l = snprintf(str, sizeof(str), "vdev-%d", i); 1024 if (unlikely(l >= (sizeof(str) - 1))) { 1025 err = -ENOMEM; 1026 goto out; 1027 } 1028 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, 1029 "%x:%x:%x.%x", &domain, &bus, &slot, &func); 1030 if (err != 4) { 1031 if (err >= 0) 1032 err = -EINVAL; 1033 xenbus_dev_fatal(pdev->xdev, err, 1034 "Error reading PCI device %d", i); 1035 goto out; 1036 } 1037 1038 pci_dev = pci_get_domain_bus_and_slot(domain, bus, 1039 PCI_DEVFN(slot, func)); 1040 if (!pci_dev) { 1041 dev_dbg(&pdev->xdev->dev, 1042 "Cannot get PCI device %04x:%02x:%02x.%d\n", 1043 domain, bus, slot, func); 1044 continue; 1045 } 1046 pci_stop_and_remove_bus_device(pci_dev); 1047 pci_dev_put(pci_dev); 1048 1049 dev_dbg(&pdev->xdev->dev, 1050 "PCI device %04x:%02x:%02x.%d removed.\n", 1051 domain, bus, slot, func); 1052 } 1053 1054 err = xenbus_switch_state(pdev->xdev, XenbusStateReconfiguring); 1055 1056 out: 1057 return err; 1058 } 1059 1060 static void __init_refok pcifront_backend_changed(struct xenbus_device *xdev, 1061 enum xenbus_state be_state) 1062 { 1063 struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev); 1064 1065 switch (be_state) { 1066 case XenbusStateUnknown: 1067 case XenbusStateInitialising: 1068 case XenbusStateInitWait: 1069 case XenbusStateInitialised: 1070 break; 1071 1072 case XenbusStateConnected: 1073 pcifront_try_connect(pdev); 1074 break; 1075 1076 case XenbusStateClosed: 1077 if (xdev->state == XenbusStateClosed) 1078 break; 1079 /* Missed the backend's CLOSING state -- fallthrough */ 1080 case XenbusStateClosing: 1081 dev_warn(&xdev->dev, "backend going away!\n"); 1082 pcifront_try_disconnect(pdev); 1083 break; 1084 1085 case XenbusStateReconfiguring: 1086 pcifront_detach_devices(pdev); 1087 break; 1088 1089 case XenbusStateReconfigured: 1090 pcifront_attach_devices(pdev); 1091 break; 1092 } 1093 } 1094 1095 static int pcifront_xenbus_probe(struct xenbus_device *xdev, 1096 const struct xenbus_device_id *id) 1097 { 1098 int err = 0; 1099 struct pcifront_device *pdev = alloc_pdev(xdev); 1100 1101 if (pdev == NULL) { 1102 err = -ENOMEM; 1103 xenbus_dev_fatal(xdev, err, 1104 "Error allocating pcifront_device struct"); 1105 goto out; 1106 } 1107 1108 err = pcifront_publish_info(pdev); 1109 if (err) 1110 free_pdev(pdev); 1111 1112 out: 1113 return err; 1114 } 1115 1116 static int pcifront_xenbus_remove(struct xenbus_device *xdev) 1117 { 1118 struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev); 1119 if (pdev) 1120 free_pdev(pdev); 1121 1122 return 0; 1123 } 1124 1125 static const struct xenbus_device_id xenpci_ids[] = { 1126 {"pci"}, 1127 {""}, 1128 }; 1129 1130 static DEFINE_XENBUS_DRIVER(xenpci, "pcifront", 1131 .probe = pcifront_xenbus_probe, 1132 .remove = pcifront_xenbus_remove, 1133 .otherend_changed = pcifront_backend_changed, 1134 ); 1135 1136 static int __init pcifront_init(void) 1137 { 1138 if (!xen_pv_domain() || xen_initial_domain()) 1139 return -ENODEV; 1140 1141 pci_frontend_registrar(1 /* enable */); 1142 1143 return xenbus_register_frontend(&xenpci_driver); 1144 } 1145 1146 static void __exit pcifront_cleanup(void) 1147 { 1148 xenbus_unregister_driver(&xenpci_driver); 1149 pci_frontend_registrar(0 /* disable */); 1150 } 1151 module_init(pcifront_init); 1152 module_exit(pcifront_cleanup); 1153 1154 MODULE_DESCRIPTION("Xen PCI passthrough frontend."); 1155 MODULE_LICENSE("GPL"); 1156 MODULE_ALIAS("xen:pci"); 1157