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