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 pci_dev_for_each_resource(dev, r, i) { 394 if (!r->parent && r->start && r->flags) { 395 dev_info(&pdev->xdev->dev, "claiming resource %s/%d\n", 396 pci_name(dev), i); 397 if (pci_claim_resource(dev, i)) { 398 dev_err(&pdev->xdev->dev, "Could not claim resource %s/%d! " 399 "Device offline. Try using e820_host=1 in the guest config.\n", 400 pci_name(dev), i); 401 } 402 } 403 } 404 405 return 0; 406 } 407 408 static int pcifront_scan_bus(struct pcifront_device *pdev, 409 unsigned int domain, unsigned int bus, 410 struct pci_bus *b) 411 { 412 struct pci_dev *d; 413 unsigned int devfn; 414 415 /* 416 * Scan the bus for functions and add. 417 * We omit handling of PCI bridge attachment because pciback prevents 418 * bridges from being exported. 419 */ 420 for (devfn = 0; devfn < 0x100; devfn++) { 421 d = pci_get_slot(b, devfn); 422 if (d) { 423 /* Device is already known. */ 424 pci_dev_put(d); 425 continue; 426 } 427 428 d = pci_scan_single_device(b, devfn); 429 if (d) 430 dev_info(&pdev->xdev->dev, "New device on " 431 "%04x:%02x:%02x.%d found.\n", domain, bus, 432 PCI_SLOT(devfn), PCI_FUNC(devfn)); 433 } 434 435 return 0; 436 } 437 438 static int pcifront_scan_root(struct pcifront_device *pdev, 439 unsigned int domain, unsigned int bus) 440 { 441 struct pci_bus *b; 442 LIST_HEAD(resources); 443 struct pcifront_sd *sd = NULL; 444 struct pci_bus_entry *bus_entry = NULL; 445 int err = 0; 446 static struct resource busn_res = { 447 .start = 0, 448 .end = 255, 449 .flags = IORESOURCE_BUS, 450 }; 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 = kzalloc(sizeof(*bus_entry), GFP_KERNEL); 467 sd = kzalloc(sizeof(*sd), GFP_KERNEL); 468 if (!bus_entry || !sd) { 469 err = -ENOMEM; 470 goto err_out; 471 } 472 pci_add_resource(&resources, &ioport_resource); 473 pci_add_resource(&resources, &iomem_resource); 474 pci_add_resource(&resources, &busn_res); 475 pcifront_init_sd(sd, domain, bus, pdev); 476 477 pci_lock_rescan_remove(); 478 479 b = pci_scan_root_bus(&pdev->xdev->dev, bus, 480 &pcifront_bus_ops, sd, &resources); 481 if (!b) { 482 dev_err(&pdev->xdev->dev, 483 "Error creating PCI Frontend Bus!\n"); 484 err = -ENOMEM; 485 pci_unlock_rescan_remove(); 486 pci_free_resource_list(&resources); 487 goto err_out; 488 } 489 490 bus_entry->bus = b; 491 492 list_add(&bus_entry->list, &pdev->root_buses); 493 494 /* 495 * pci_scan_root_bus skips devices which do not have a 496 * devfn==0. The pcifront_scan_bus enumerates all devfn. 497 */ 498 err = pcifront_scan_bus(pdev, domain, bus, b); 499 500 /* Claim resources before going "live" with our devices */ 501 pci_walk_bus(b, pcifront_claim_resource, pdev); 502 503 /* Create SysFS and notify udev of the devices. Aka: "going live" */ 504 pci_bus_add_devices(b); 505 506 pci_unlock_rescan_remove(); 507 return err; 508 509 err_out: 510 kfree(bus_entry); 511 kfree(sd); 512 513 return err; 514 } 515 516 static int pcifront_rescan_root(struct pcifront_device *pdev, 517 unsigned int domain, unsigned int bus) 518 { 519 int err; 520 struct pci_bus *b; 521 522 b = pci_find_bus(domain, bus); 523 if (!b) 524 /* If the bus is unknown, create it. */ 525 return pcifront_scan_root(pdev, domain, bus); 526 527 dev_info(&pdev->xdev->dev, "Rescanning PCI Frontend Bus %04x:%02x\n", 528 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 pci_dbg(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 pci_lock_rescan_remove(); 560 list_for_each_entry_safe(bus_entry, t, &pdev->root_buses, list) { 561 list_del(&bus_entry->list); 562 563 free_root_bus_devs(bus_entry->bus); 564 565 kfree(bus_entry->bus->sysdata); 566 567 device_unregister(bus_entry->bus->bridge); 568 pci_remove_bus(bus_entry->bus); 569 570 kfree(bus_entry); 571 } 572 pci_unlock_rescan_remove(); 573 } 574 575 static pci_ers_result_t pcifront_common_process(int cmd, 576 struct pcifront_device *pdev, 577 pci_channel_state_t state) 578 { 579 struct pci_driver *pdrv; 580 int bus = pdev->sh_info->aer_op.bus; 581 int devfn = pdev->sh_info->aer_op.devfn; 582 int domain = pdev->sh_info->aer_op.domain; 583 struct pci_dev *pcidev; 584 585 dev_dbg(&pdev->xdev->dev, 586 "pcifront AER process: cmd %x (bus:%x, devfn%x)", 587 cmd, bus, devfn); 588 589 pcidev = pci_get_domain_bus_and_slot(domain, bus, devfn); 590 if (!pcidev || !pcidev->dev.driver) { 591 dev_err(&pdev->xdev->dev, "device or AER driver is NULL\n"); 592 pci_dev_put(pcidev); 593 return PCI_ERS_RESULT_NONE; 594 } 595 pdrv = to_pci_driver(pcidev->dev.driver); 596 597 if (pdrv->err_handler && pdrv->err_handler->error_detected) { 598 pci_dbg(pcidev, "trying to call AER service\n"); 599 switch (cmd) { 600 case XEN_PCI_OP_aer_detected: 601 return pdrv->err_handler->error_detected(pcidev, state); 602 case XEN_PCI_OP_aer_mmio: 603 return pdrv->err_handler->mmio_enabled(pcidev); 604 case XEN_PCI_OP_aer_slotreset: 605 return pdrv->err_handler->slot_reset(pcidev); 606 case XEN_PCI_OP_aer_resume: 607 pdrv->err_handler->resume(pcidev); 608 return PCI_ERS_RESULT_NONE; 609 default: 610 dev_err(&pdev->xdev->dev, 611 "bad request in aer recovery operation!\n"); 612 } 613 } 614 615 return PCI_ERS_RESULT_NONE; 616 } 617 618 619 static void pcifront_do_aer(struct work_struct *data) 620 { 621 struct pcifront_device *pdev = 622 container_of(data, struct pcifront_device, op_work); 623 int cmd = pdev->sh_info->aer_op.cmd; 624 pci_channel_state_t state = 625 (pci_channel_state_t)pdev->sh_info->aer_op.err; 626 627 /* 628 * If a pci_conf op is in progress, we have to wait until it is done 629 * before service aer op 630 */ 631 dev_dbg(&pdev->xdev->dev, 632 "pcifront service aer bus %x devfn %x\n", 633 pdev->sh_info->aer_op.bus, pdev->sh_info->aer_op.devfn); 634 635 pdev->sh_info->aer_op.err = pcifront_common_process(cmd, pdev, state); 636 637 /* Post the operation to the guest. */ 638 wmb(); 639 clear_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags); 640 notify_remote_via_evtchn(pdev->evtchn); 641 642 /*in case of we lost an aer request in four lines time_window*/ 643 smp_mb__before_atomic(); 644 clear_bit(_PDEVB_op_active, &pdev->flags); 645 smp_mb__after_atomic(); 646 647 schedule_pcifront_aer_op(pdev); 648 649 } 650 651 static irqreturn_t pcifront_handler_aer(int irq, void *dev) 652 { 653 struct pcifront_device *pdev = dev; 654 655 schedule_pcifront_aer_op(pdev); 656 return IRQ_HANDLED; 657 } 658 static int pcifront_connect_and_init_dma(struct pcifront_device *pdev) 659 { 660 int err = 0; 661 662 spin_lock(&pcifront_dev_lock); 663 664 if (!pcifront_dev) { 665 dev_info(&pdev->xdev->dev, "Installing PCI frontend\n"); 666 pcifront_dev = pdev; 667 } else 668 err = -EEXIST; 669 670 spin_unlock(&pcifront_dev_lock); 671 672 if (!err && !is_swiotlb_active(&pdev->xdev->dev)) { 673 err = pci_xen_swiotlb_init_late(); 674 if (err) 675 dev_err(&pdev->xdev->dev, "Could not setup SWIOTLB!\n"); 676 } 677 return err; 678 } 679 680 static void pcifront_disconnect(struct pcifront_device *pdev) 681 { 682 spin_lock(&pcifront_dev_lock); 683 684 if (pdev == pcifront_dev) { 685 dev_info(&pdev->xdev->dev, 686 "Disconnecting PCI Frontend Buses\n"); 687 pcifront_dev = NULL; 688 } 689 690 spin_unlock(&pcifront_dev_lock); 691 } 692 static struct pcifront_device *alloc_pdev(struct xenbus_device *xdev) 693 { 694 struct pcifront_device *pdev; 695 696 pdev = kzalloc(sizeof(struct pcifront_device), GFP_KERNEL); 697 if (pdev == NULL) 698 goto out; 699 700 if (xenbus_setup_ring(xdev, GFP_KERNEL, (void **)&pdev->sh_info, 1, 701 &pdev->gnt_ref)) { 702 kfree(pdev); 703 pdev = NULL; 704 goto out; 705 } 706 pdev->sh_info->flags = 0; 707 708 /*Flag for registering PV AER handler*/ 709 set_bit(_XEN_PCIB_AERHANDLER, (void *)&pdev->sh_info->flags); 710 711 dev_set_drvdata(&xdev->dev, pdev); 712 pdev->xdev = xdev; 713 714 INIT_LIST_HEAD(&pdev->root_buses); 715 716 spin_lock_init(&pdev->sh_info_lock); 717 718 pdev->evtchn = INVALID_EVTCHN; 719 pdev->irq = -1; 720 721 INIT_WORK(&pdev->op_work, pcifront_do_aer); 722 723 dev_dbg(&xdev->dev, "Allocated pdev @ 0x%p pdev->sh_info @ 0x%p\n", 724 pdev, pdev->sh_info); 725 out: 726 return pdev; 727 } 728 729 static void free_pdev(struct pcifront_device *pdev) 730 { 731 dev_dbg(&pdev->xdev->dev, "freeing pdev @ 0x%p\n", pdev); 732 733 pcifront_free_roots(pdev); 734 735 cancel_work_sync(&pdev->op_work); 736 737 if (pdev->irq >= 0) 738 unbind_from_irqhandler(pdev->irq, pdev); 739 740 if (pdev->evtchn != INVALID_EVTCHN) 741 xenbus_free_evtchn(pdev->xdev, pdev->evtchn); 742 743 xenbus_teardown_ring((void **)&pdev->sh_info, 1, &pdev->gnt_ref); 744 745 dev_set_drvdata(&pdev->xdev->dev, NULL); 746 747 kfree(pdev); 748 } 749 750 static int pcifront_publish_info(struct pcifront_device *pdev) 751 { 752 int err = 0; 753 struct xenbus_transaction trans; 754 755 err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn); 756 if (err) 757 goto out; 758 759 err = bind_evtchn_to_irqhandler(pdev->evtchn, pcifront_handler_aer, 760 0, "pcifront", pdev); 761 762 if (err < 0) 763 return err; 764 765 pdev->irq = err; 766 767 do_publish: 768 err = xenbus_transaction_start(&trans); 769 if (err) { 770 xenbus_dev_fatal(pdev->xdev, err, 771 "Error writing configuration for backend " 772 "(start transaction)"); 773 goto out; 774 } 775 776 err = xenbus_printf(trans, pdev->xdev->nodename, 777 "pci-op-ref", "%u", pdev->gnt_ref); 778 if (!err) 779 err = xenbus_printf(trans, pdev->xdev->nodename, 780 "event-channel", "%u", pdev->evtchn); 781 if (!err) 782 err = xenbus_printf(trans, pdev->xdev->nodename, 783 "magic", XEN_PCI_MAGIC); 784 785 if (err) { 786 xenbus_transaction_end(trans, 1); 787 xenbus_dev_fatal(pdev->xdev, err, 788 "Error writing configuration for backend"); 789 goto out; 790 } else { 791 err = xenbus_transaction_end(trans, 0); 792 if (err == -EAGAIN) 793 goto do_publish; 794 else if (err) { 795 xenbus_dev_fatal(pdev->xdev, err, 796 "Error completing transaction " 797 "for backend"); 798 goto out; 799 } 800 } 801 802 xenbus_switch_state(pdev->xdev, XenbusStateInitialised); 803 804 dev_dbg(&pdev->xdev->dev, "publishing successful!\n"); 805 806 out: 807 return err; 808 } 809 810 static void pcifront_connect(struct pcifront_device *pdev) 811 { 812 int err; 813 int i, num_roots, len; 814 char str[64]; 815 unsigned int domain, bus; 816 817 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, 818 "root_num", "%d", &num_roots); 819 if (err == -ENOENT) { 820 xenbus_dev_error(pdev->xdev, err, 821 "No PCI Roots found, trying 0000:00"); 822 err = pcifront_rescan_root(pdev, 0, 0); 823 if (err) { 824 xenbus_dev_fatal(pdev->xdev, err, 825 "Error scanning PCI root 0000:00"); 826 return; 827 } 828 num_roots = 0; 829 } else if (err != 1) { 830 xenbus_dev_fatal(pdev->xdev, err >= 0 ? -EINVAL : err, 831 "Error reading number of PCI roots"); 832 return; 833 } 834 835 for (i = 0; i < num_roots; i++) { 836 len = snprintf(str, sizeof(str), "root-%d", i); 837 if (unlikely(len >= (sizeof(str) - 1))) 838 return; 839 840 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, 841 "%x:%x", &domain, &bus); 842 if (err != 2) { 843 xenbus_dev_fatal(pdev->xdev, err >= 0 ? -EINVAL : err, 844 "Error reading PCI root %d", i); 845 return; 846 } 847 848 err = pcifront_rescan_root(pdev, domain, bus); 849 if (err) { 850 xenbus_dev_fatal(pdev->xdev, err, 851 "Error scanning PCI root %04x:%02x", 852 domain, bus); 853 return; 854 } 855 } 856 857 xenbus_switch_state(pdev->xdev, XenbusStateConnected); 858 } 859 860 static void pcifront_try_connect(struct pcifront_device *pdev) 861 { 862 int err; 863 864 /* Only connect once */ 865 if (xenbus_read_driver_state(pdev->xdev->nodename) != 866 XenbusStateInitialised) 867 return; 868 869 err = pcifront_connect_and_init_dma(pdev); 870 if (err && err != -EEXIST) { 871 xenbus_dev_fatal(pdev->xdev, err, 872 "Error setting up PCI Frontend"); 873 return; 874 } 875 876 pcifront_connect(pdev); 877 } 878 879 static int pcifront_try_disconnect(struct pcifront_device *pdev) 880 { 881 int err = 0; 882 enum xenbus_state prev_state; 883 884 885 prev_state = xenbus_read_driver_state(pdev->xdev->nodename); 886 887 if (prev_state >= XenbusStateClosing) 888 goto out; 889 890 if (prev_state == XenbusStateConnected) { 891 pcifront_free_roots(pdev); 892 pcifront_disconnect(pdev); 893 } 894 895 err = xenbus_switch_state(pdev->xdev, XenbusStateClosed); 896 897 out: 898 899 return err; 900 } 901 902 static void pcifront_attach_devices(struct pcifront_device *pdev) 903 { 904 if (xenbus_read_driver_state(pdev->xdev->nodename) == 905 XenbusStateReconfiguring) 906 pcifront_connect(pdev); 907 } 908 909 static int pcifront_detach_devices(struct pcifront_device *pdev) 910 { 911 int err = 0; 912 int i, num_devs; 913 enum xenbus_state state; 914 unsigned int domain, bus, slot, func; 915 struct pci_dev *pci_dev; 916 char str[64]; 917 918 state = xenbus_read_driver_state(pdev->xdev->nodename); 919 if (state == XenbusStateInitialised) { 920 dev_dbg(&pdev->xdev->dev, "Handle skipped connect.\n"); 921 /* We missed Connected and need to initialize. */ 922 err = pcifront_connect_and_init_dma(pdev); 923 if (err && err != -EEXIST) { 924 xenbus_dev_fatal(pdev->xdev, err, 925 "Error setting up PCI Frontend"); 926 goto out; 927 } 928 929 goto out_switch_state; 930 } else if (state != XenbusStateConnected) { 931 goto out; 932 } 933 934 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, "num_devs", "%d", 935 &num_devs); 936 if (err != 1) { 937 if (err >= 0) 938 err = -EINVAL; 939 xenbus_dev_fatal(pdev->xdev, err, 940 "Error reading number of PCI devices"); 941 goto out; 942 } 943 944 /* Find devices being detached and remove them. */ 945 for (i = 0; i < num_devs; i++) { 946 int l, state; 947 948 l = snprintf(str, sizeof(str), "state-%d", i); 949 if (unlikely(l >= (sizeof(str) - 1))) { 950 err = -ENOMEM; 951 goto out; 952 } 953 state = xenbus_read_unsigned(pdev->xdev->otherend, str, 954 XenbusStateUnknown); 955 956 if (state != XenbusStateClosing) 957 continue; 958 959 /* Remove device. */ 960 l = snprintf(str, sizeof(str), "vdev-%d", i); 961 if (unlikely(l >= (sizeof(str) - 1))) { 962 err = -ENOMEM; 963 goto out; 964 } 965 err = xenbus_scanf(XBT_NIL, pdev->xdev->otherend, str, 966 "%x:%x:%x.%x", &domain, &bus, &slot, &func); 967 if (err != 4) { 968 if (err >= 0) 969 err = -EINVAL; 970 xenbus_dev_fatal(pdev->xdev, err, 971 "Error reading PCI device %d", i); 972 goto out; 973 } 974 975 pci_dev = pci_get_domain_bus_and_slot(domain, bus, 976 PCI_DEVFN(slot, func)); 977 if (!pci_dev) { 978 dev_dbg(&pdev->xdev->dev, 979 "Cannot get PCI device %04x:%02x:%02x.%d\n", 980 domain, bus, slot, func); 981 continue; 982 } 983 pci_lock_rescan_remove(); 984 pci_stop_and_remove_bus_device(pci_dev); 985 pci_dev_put(pci_dev); 986 pci_unlock_rescan_remove(); 987 988 dev_dbg(&pdev->xdev->dev, 989 "PCI device %04x:%02x:%02x.%d removed.\n", 990 domain, bus, slot, func); 991 } 992 993 out_switch_state: 994 err = xenbus_switch_state(pdev->xdev, XenbusStateReconfiguring); 995 996 out: 997 return err; 998 } 999 1000 static void pcifront_backend_changed(struct xenbus_device *xdev, 1001 enum xenbus_state be_state) 1002 { 1003 struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev); 1004 1005 switch (be_state) { 1006 case XenbusStateUnknown: 1007 case XenbusStateInitialising: 1008 case XenbusStateInitWait: 1009 case XenbusStateInitialised: 1010 break; 1011 1012 case XenbusStateConnected: 1013 pcifront_try_connect(pdev); 1014 break; 1015 1016 case XenbusStateClosed: 1017 if (xdev->state == XenbusStateClosed) 1018 break; 1019 fallthrough; /* Missed the backend's CLOSING state */ 1020 case XenbusStateClosing: 1021 dev_warn(&xdev->dev, "backend going away!\n"); 1022 pcifront_try_disconnect(pdev); 1023 break; 1024 1025 case XenbusStateReconfiguring: 1026 pcifront_detach_devices(pdev); 1027 break; 1028 1029 case XenbusStateReconfigured: 1030 pcifront_attach_devices(pdev); 1031 break; 1032 } 1033 } 1034 1035 static int pcifront_xenbus_probe(struct xenbus_device *xdev, 1036 const struct xenbus_device_id *id) 1037 { 1038 int err = 0; 1039 struct pcifront_device *pdev = alloc_pdev(xdev); 1040 1041 if (pdev == NULL) { 1042 err = -ENOMEM; 1043 xenbus_dev_fatal(xdev, err, 1044 "Error allocating pcifront_device struct"); 1045 goto out; 1046 } 1047 1048 err = pcifront_publish_info(pdev); 1049 if (err) 1050 free_pdev(pdev); 1051 1052 out: 1053 return err; 1054 } 1055 1056 static void pcifront_xenbus_remove(struct xenbus_device *xdev) 1057 { 1058 struct pcifront_device *pdev = dev_get_drvdata(&xdev->dev); 1059 1060 if (pdev) 1061 free_pdev(pdev); 1062 } 1063 1064 static const struct xenbus_device_id xenpci_ids[] = { 1065 {"pci"}, 1066 {""}, 1067 }; 1068 1069 static struct xenbus_driver xenpci_driver = { 1070 .name = "pcifront", 1071 .ids = xenpci_ids, 1072 .probe = pcifront_xenbus_probe, 1073 .remove = pcifront_xenbus_remove, 1074 .otherend_changed = pcifront_backend_changed, 1075 }; 1076 1077 static int __init pcifront_init(void) 1078 { 1079 if (!xen_pv_domain() || xen_initial_domain()) 1080 return -ENODEV; 1081 1082 if (!xen_has_pv_devices()) 1083 return -ENODEV; 1084 1085 pci_frontend_registrar(1 /* enable */); 1086 1087 return xenbus_register_frontend(&xenpci_driver); 1088 } 1089 1090 static void __exit pcifront_cleanup(void) 1091 { 1092 xenbus_unregister_driver(&xenpci_driver); 1093 pci_frontend_registrar(0 /* disable */); 1094 } 1095 module_init(pcifront_init); 1096 module_exit(pcifront_cleanup); 1097 1098 MODULE_DESCRIPTION("Xen PCI passthrough frontend."); 1099 MODULE_LICENSE("GPL"); 1100 MODULE_ALIAS("xen:pci"); 1101