1 // SPDX-License-Identifier: GPL-2.0
5 * Author: Ryan Wilson <hap9@epoch.ncsc.mil>
7 #include <linux/module.h>
8 #include <linux/init.h>
10 #include <xen/xenbus.h>
11 #include <xen/events.h>
12 #include <xen/grant_table.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>
28 #include <asm/xen/swiotlb-xen.h>
30 #define INVALID_EVTCHN (-1)
32 struct pci_bus_entry
{
33 struct list_head list
;
37 #define _PDEVB_op_active (0)
38 #define PDEVB_op_active (1 << (_PDEVB_op_active))
40 struct pcifront_device
{
41 struct xenbus_device
*xdev
;
42 struct list_head root_buses
;
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
;
58 struct pci_sysdata sd
;
59 struct pcifront_device
*pdev
;
62 static inline struct pcifront_device
*
63 pcifront_get_pdev(struct pcifront_sd
*sd
)
68 static inline void pcifront_init_sd(struct pcifront_sd
*sd
,
69 unsigned int domain
, unsigned int bus
,
70 struct pcifront_device
*pdev
)
72 /* Because we do not expose that information via XenBus. */
73 sd
->sd
.node
= first_online_node
;
74 sd
->sd
.domain
= domain
;
78 static DEFINE_SPINLOCK(pcifront_dev_lock
);
79 static struct pcifront_device
*pcifront_dev
;
81 static int errno_to_pcibios_err(int errno
)
84 case XEN_PCI_ERR_success
:
85 return PCIBIOS_SUCCESSFUL
;
87 case XEN_PCI_ERR_dev_not_found
:
88 return PCIBIOS_DEVICE_NOT_FOUND
;
90 case XEN_PCI_ERR_invalid_offset
:
91 case XEN_PCI_ERR_op_failed
:
92 return PCIBIOS_BAD_REGISTER_NUMBER
;
94 case XEN_PCI_ERR_not_implemented
:
95 return PCIBIOS_FUNC_NOT_SUPPORTED
;
97 case XEN_PCI_ERR_access_denied
:
98 return PCIBIOS_SET_FAILED
;
103 static inline void schedule_pcifront_aer_op(struct pcifront_device
*pdev
)
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
);
112 static int do_pci_op(struct pcifront_device
*pdev
, struct xen_pci_op
*op
)
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
;
121 spin_lock_irqsave(&pdev
->sh_info_lock
, irq_flags
);
123 memcpy(active_op
, op
, sizeof(struct xen_pci_op
));
127 set_bit(_XEN_PCIF_active
, (unsigned long *)&pdev
->sh_info
->flags
);
128 notify_remote_via_evtchn(port
);
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.
136 ns_timeout
= ktime_get_ns() + 2 * (s64
)NSEC_PER_SEC
;
138 xen_clear_irq_pending(irq
);
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
);
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
;
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.
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
);
167 memcpy(op
, active_op
, sizeof(struct xen_pci_op
));
171 spin_unlock_irqrestore(&pdev
->sh_info_lock
, irq_flags
);
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
)
180 struct xen_pci_op op
= {
181 .cmd
= XEN_PCI_OP_conf_read
,
182 .domain
= pci_domain_nr(bus
),
188 struct pcifront_sd
*sd
= bus
->sysdata
;
189 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
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
);
196 err
= do_pci_op(pdev
, &op
);
199 dev_dbg(&pdev
->xdev
->dev
, "read got back value %x\n",
203 } else if (err
== -ENODEV
) {
204 /* No device here, pretend that it just returned 0 */
209 return errno_to_pcibios_err(err
);
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
)
216 struct xen_pci_op op
= {
217 .cmd
= XEN_PCI_OP_conf_write
,
218 .domain
= pci_domain_nr(bus
),
225 struct pcifront_sd
*sd
= bus
->sysdata
;
226 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
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
);
233 return errno_to_pcibios_err(do_pci_op(pdev
, &op
));
236 static struct pci_ops pcifront_bus_ops
= {
237 .read
= pcifront_bus_read
,
238 .write
= pcifront_bus_write
,
241 #ifdef CONFIG_PCI_MSI
242 static int pci_frontend_enable_msix(struct pci_dev
*dev
,
243 int vector
[], int nvec
)
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
,
254 struct pcifront_sd
*sd
= dev
->bus
->sysdata
;
255 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
256 struct msi_desc
*entry
;
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
);
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;
272 err
= do_pci_op(pdev
, &op
);
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
);
285 vector
[i
] = op
.msix_entries
[i
].vector
;
288 pr_info("enable msix get value %x\n", op
.value
);
292 pci_err(dev
, "enable msix get err %x\n", err
);
297 static void pci_frontend_disable_msix(struct pci_dev
*dev
)
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
,
306 struct pcifront_sd
*sd
= dev
->bus
->sysdata
;
307 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
309 err
= do_pci_op(pdev
, &op
);
311 /* What should do for error ? */
313 pci_err(dev
, "pci_disable_msix get err %x\n", err
);
316 static int pci_frontend_enable_msi(struct pci_dev
*dev
, int vector
[])
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
,
325 struct pcifront_sd
*sd
= dev
->bus
->sysdata
;
326 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
328 err
= do_pci_op(pdev
, &op
);
330 vector
[0] = op
.value
;
332 pci_warn(dev
, "MSI entry is invalid: %d!\n",
338 pci_err(dev
, "pci frontend enable msi failed for dev "
339 "%x:%x\n", op
.bus
, op
.devfn
);
345 static void pci_frontend_disable_msi(struct pci_dev
*dev
)
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
,
354 struct pcifront_sd
*sd
= dev
->bus
->sysdata
;
355 struct pcifront_device
*pdev
= pcifront_get_pdev(sd
);
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");
364 /* how can pciback notify us fail? */
365 pr_info("get fake response from backend\n");
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
,
375 static void pci_frontend_registrar(int enable
)
378 xen_pci_frontend
= &pci_frontend_ops
;
380 xen_pci_frontend
= NULL
;
383 static inline void pci_frontend_registrar(int enable
) { };
384 #endif /* CONFIG_PCI_MSI */
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
)
389 struct pcifront_device
*pdev
= data
;
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",
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",
408 static int pcifront_scan_bus(struct pcifront_device
*pdev
,
409 unsigned int domain
, unsigned int bus
,
416 * Scan the bus for functions and add.
417 * We omit handling of PCI bridge attachment because pciback prevents
418 * bridges from being exported.
420 for (devfn
= 0; devfn
< 0x100; devfn
++) {
421 d
= pci_get_slot(b
, devfn
);
423 /* Device is already known. */
428 d
= pci_scan_single_device(b
, devfn
);
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
));
438 static int pcifront_scan_root(struct pcifront_device
*pdev
,
439 unsigned int domain
, unsigned int bus
)
442 LIST_HEAD(resources
);
443 struct pcifront_sd
*sd
= NULL
;
444 struct pci_bus_entry
*bus_entry
= NULL
;
446 static struct resource busn_res
= {
449 .flags
= IORESOURCE_BUS
,
452 #ifndef CONFIG_PCI_DOMAINS
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");
463 dev_info(&pdev
->xdev
->dev
, "Creating PCI Frontend Bus %04x:%02x\n",
466 bus_entry
= kzalloc(sizeof(*bus_entry
), GFP_KERNEL
);
467 sd
= kzalloc(sizeof(*sd
), GFP_KERNEL
);
468 if (!bus_entry
|| !sd
) {
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
);
477 pci_lock_rescan_remove();
479 b
= pci_scan_root_bus(&pdev
->xdev
->dev
, bus
,
480 &pcifront_bus_ops
, sd
, &resources
);
482 dev_err(&pdev
->xdev
->dev
,
483 "Error creating PCI Frontend Bus!\n");
485 pci_unlock_rescan_remove();
486 pci_free_resource_list(&resources
);
492 list_add(&bus_entry
->list
, &pdev
->root_buses
);
495 * pci_scan_root_bus skips devices which do not have a
496 * devfn==0. The pcifront_scan_bus enumerates all devfn.
498 err
= pcifront_scan_bus(pdev
, domain
, bus
, b
);
500 /* Claim resources before going "live" with our devices */
501 pci_walk_bus(b
, pcifront_claim_resource
, pdev
);
503 /* Create SysFS and notify udev of the devices. Aka: "going live" */
504 pci_bus_add_devices(b
);
506 pci_unlock_rescan_remove();
516 static int pcifront_rescan_root(struct pcifront_device
*pdev
,
517 unsigned int domain
, unsigned int bus
)
522 b
= pci_find_bus(domain
, bus
);
524 /* If the bus is unknown, create it. */
525 return pcifront_scan_root(pdev
, domain
, bus
);
527 dev_info(&pdev
->xdev
->dev
, "Rescanning PCI Frontend Bus %04x:%02x\n",
530 err
= pcifront_scan_bus(pdev
, domain
, bus
, b
);
532 /* Claim resources before going "live" with our devices */
533 pci_walk_bus(b
, pcifront_claim_resource
, pdev
);
535 /* Create SysFS and notify udev of the devices. Aka: "going live" */
536 pci_bus_add_devices(b
);
541 static void free_root_bus_devs(struct pci_bus
*bus
)
545 while (!list_empty(&bus
->devices
)) {
546 dev
= container_of(bus
->devices
.next
, struct pci_dev
,
548 pci_dbg(dev
, "removing device\n");
549 pci_stop_and_remove_bus_device(dev
);
553 static void pcifront_free_roots(struct pcifront_device
*pdev
)
555 struct pci_bus_entry
*bus_entry
, *t
;
557 dev_dbg(&pdev
->xdev
->dev
, "cleaning up root buses\n");
559 pci_lock_rescan_remove();
560 list_for_each_entry_safe(bus_entry
, t
, &pdev
->root_buses
, list
) {
561 list_del(&bus_entry
->list
);
563 free_root_bus_devs(bus_entry
->bus
);
565 kfree(bus_entry
->bus
->sysdata
);
567 device_unregister(bus_entry
->bus
->bridge
);
568 pci_remove_bus(bus_entry
->bus
);
572 pci_unlock_rescan_remove();
575 static pci_ers_result_t
pcifront_common_process(int cmd
,
576 struct pcifront_device
*pdev
,
577 pci_channel_state_t state
)
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
;
585 dev_dbg(&pdev
->xdev
->dev
,
586 "pcifront AER process: cmd %x (bus:%x, devfn%x)",
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");
593 return PCI_ERS_RESULT_NONE
;
595 pdrv
= to_pci_driver(pcidev
->dev
.driver
);
597 if (pdrv
->err_handler
&& pdrv
->err_handler
->error_detected
) {
598 pci_dbg(pcidev
, "trying to call AER service\n");
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
;
610 dev_err(&pdev
->xdev
->dev
,
611 "bad request in aer recovery operation!\n");
615 return PCI_ERS_RESULT_NONE
;
619 static void pcifront_do_aer(struct work_struct
*data
)
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
;
628 * If a pci_conf op is in progress, we have to wait until it is done
629 * before service aer op
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
);
635 pdev
->sh_info
->aer_op
.err
= pcifront_common_process(cmd
, pdev
, state
);
637 /* Post the operation to the guest. */
639 clear_bit(_XEN_PCIB_active
, (unsigned long *)&pdev
->sh_info
->flags
);
640 notify_remote_via_evtchn(pdev
->evtchn
);
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();
647 schedule_pcifront_aer_op(pdev
);
651 static irqreturn_t
pcifront_handler_aer(int irq
, void *dev
)
653 struct pcifront_device
*pdev
= dev
;
655 schedule_pcifront_aer_op(pdev
);
658 static int pcifront_connect_and_init_dma(struct pcifront_device
*pdev
)
662 spin_lock(&pcifront_dev_lock
);
665 dev_info(&pdev
->xdev
->dev
, "Installing PCI frontend\n");
670 spin_unlock(&pcifront_dev_lock
);
672 if (!err
&& !is_swiotlb_active(&pdev
->xdev
->dev
)) {
673 err
= pci_xen_swiotlb_init_late();
675 dev_err(&pdev
->xdev
->dev
, "Could not setup SWIOTLB!\n");
680 static void pcifront_disconnect(struct pcifront_device
*pdev
)
682 spin_lock(&pcifront_dev_lock
);
684 if (pdev
== pcifront_dev
) {
685 dev_info(&pdev
->xdev
->dev
,
686 "Disconnecting PCI Frontend Buses\n");
690 spin_unlock(&pcifront_dev_lock
);
692 static struct pcifront_device
*alloc_pdev(struct xenbus_device
*xdev
)
694 struct pcifront_device
*pdev
;
696 pdev
= kzalloc(sizeof(struct pcifront_device
), GFP_KERNEL
);
700 if (xenbus_setup_ring(xdev
, GFP_KERNEL
, (void **)&pdev
->sh_info
, 1,
706 pdev
->sh_info
->flags
= 0;
708 /*Flag for registering PV AER handler*/
709 set_bit(_XEN_PCIB_AERHANDLER
, (void *)&pdev
->sh_info
->flags
);
711 dev_set_drvdata(&xdev
->dev
, pdev
);
714 INIT_LIST_HEAD(&pdev
->root_buses
);
716 spin_lock_init(&pdev
->sh_info_lock
);
718 pdev
->evtchn
= INVALID_EVTCHN
;
721 INIT_WORK(&pdev
->op_work
, pcifront_do_aer
);
723 dev_dbg(&xdev
->dev
, "Allocated pdev @ 0x%p pdev->sh_info @ 0x%p\n",
724 pdev
, pdev
->sh_info
);
729 static void free_pdev(struct pcifront_device
*pdev
)
731 dev_dbg(&pdev
->xdev
->dev
, "freeing pdev @ 0x%p\n", pdev
);
733 pcifront_free_roots(pdev
);
735 cancel_work_sync(&pdev
->op_work
);
738 unbind_from_irqhandler(pdev
->irq
, pdev
);
740 if (pdev
->evtchn
!= INVALID_EVTCHN
)
741 xenbus_free_evtchn(pdev
->xdev
, pdev
->evtchn
);
743 xenbus_teardown_ring((void **)&pdev
->sh_info
, 1, &pdev
->gnt_ref
);
745 dev_set_drvdata(&pdev
->xdev
->dev
, NULL
);
750 static int pcifront_publish_info(struct pcifront_device
*pdev
)
753 struct xenbus_transaction trans
;
755 err
= xenbus_alloc_evtchn(pdev
->xdev
, &pdev
->evtchn
);
759 err
= bind_evtchn_to_irqhandler(pdev
->evtchn
, pcifront_handler_aer
,
760 0, "pcifront", pdev
);
768 err
= xenbus_transaction_start(&trans
);
770 xenbus_dev_fatal(pdev
->xdev
, err
,
771 "Error writing configuration for backend "
772 "(start transaction)");
776 err
= xenbus_printf(trans
, pdev
->xdev
->nodename
,
777 "pci-op-ref", "%u", pdev
->gnt_ref
);
779 err
= xenbus_printf(trans
, pdev
->xdev
->nodename
,
780 "event-channel", "%u", pdev
->evtchn
);
782 err
= xenbus_printf(trans
, pdev
->xdev
->nodename
,
783 "magic", XEN_PCI_MAGIC
);
786 xenbus_transaction_end(trans
, 1);
787 xenbus_dev_fatal(pdev
->xdev
, err
,
788 "Error writing configuration for backend");
791 err
= xenbus_transaction_end(trans
, 0);
795 xenbus_dev_fatal(pdev
->xdev
, err
,
796 "Error completing transaction "
802 xenbus_switch_state(pdev
->xdev
, XenbusStateInitialised
);
804 dev_dbg(&pdev
->xdev
->dev
, "publishing successful!\n");
810 static void pcifront_connect(struct pcifront_device
*pdev
)
813 int i
, num_roots
, len
;
815 unsigned int domain
, bus
;
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);
824 xenbus_dev_fatal(pdev
->xdev
, err
,
825 "Error scanning PCI root 0000:00");
829 } else if (err
!= 1) {
830 xenbus_dev_fatal(pdev
->xdev
, err
>= 0 ? -EINVAL
: err
,
831 "Error reading number of PCI roots");
835 for (i
= 0; i
< num_roots
; i
++) {
836 len
= snprintf(str
, sizeof(str
), "root-%d", i
);
837 if (unlikely(len
>= (sizeof(str
) - 1)))
840 err
= xenbus_scanf(XBT_NIL
, pdev
->xdev
->otherend
, str
,
841 "%x:%x", &domain
, &bus
);
843 xenbus_dev_fatal(pdev
->xdev
, err
>= 0 ? -EINVAL
: err
,
844 "Error reading PCI root %d", i
);
848 err
= pcifront_rescan_root(pdev
, domain
, bus
);
850 xenbus_dev_fatal(pdev
->xdev
, err
,
851 "Error scanning PCI root %04x:%02x",
857 xenbus_switch_state(pdev
->xdev
, XenbusStateConnected
);
860 static void pcifront_try_connect(struct pcifront_device
*pdev
)
864 /* Only connect once */
865 if (xenbus_read_driver_state(pdev
->xdev
->nodename
) !=
866 XenbusStateInitialised
)
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");
876 pcifront_connect(pdev
);
879 static int pcifront_try_disconnect(struct pcifront_device
*pdev
)
882 enum xenbus_state prev_state
;
885 prev_state
= xenbus_read_driver_state(pdev
->xdev
->nodename
);
887 if (prev_state
>= XenbusStateClosing
)
890 if (prev_state
== XenbusStateConnected
) {
891 pcifront_free_roots(pdev
);
892 pcifront_disconnect(pdev
);
895 err
= xenbus_switch_state(pdev
->xdev
, XenbusStateClosed
);
902 static void pcifront_attach_devices(struct pcifront_device
*pdev
)
904 if (xenbus_read_driver_state(pdev
->xdev
->nodename
) ==
905 XenbusStateReconfiguring
)
906 pcifront_connect(pdev
);
909 static int pcifront_detach_devices(struct pcifront_device
*pdev
)
913 enum xenbus_state state
;
914 unsigned int domain
, bus
, slot
, func
;
915 struct pci_dev
*pci_dev
;
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");
929 goto out_switch_state
;
930 } else if (state
!= XenbusStateConnected
) {
934 err
= xenbus_scanf(XBT_NIL
, pdev
->xdev
->otherend
, "num_devs", "%d",
939 xenbus_dev_fatal(pdev
->xdev
, err
,
940 "Error reading number of PCI devices");
944 /* Find devices being detached and remove them. */
945 for (i
= 0; i
< num_devs
; i
++) {
948 l
= snprintf(str
, sizeof(str
), "state-%d", i
);
949 if (unlikely(l
>= (sizeof(str
) - 1))) {
953 state
= xenbus_read_unsigned(pdev
->xdev
->otherend
, str
,
956 if (state
!= XenbusStateClosing
)
960 l
= snprintf(str
, sizeof(str
), "vdev-%d", i
);
961 if (unlikely(l
>= (sizeof(str
) - 1))) {
965 err
= xenbus_scanf(XBT_NIL
, pdev
->xdev
->otherend
, str
,
966 "%x:%x:%x.%x", &domain
, &bus
, &slot
, &func
);
970 xenbus_dev_fatal(pdev
->xdev
, err
,
971 "Error reading PCI device %d", i
);
975 pci_dev
= pci_get_domain_bus_and_slot(domain
, bus
,
976 PCI_DEVFN(slot
, func
));
978 dev_dbg(&pdev
->xdev
->dev
,
979 "Cannot get PCI device %04x:%02x:%02x.%d\n",
980 domain
, bus
, slot
, func
);
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();
988 dev_dbg(&pdev
->xdev
->dev
,
989 "PCI device %04x:%02x:%02x.%d removed.\n",
990 domain
, bus
, slot
, func
);
994 err
= xenbus_switch_state(pdev
->xdev
, XenbusStateReconfiguring
);
1000 static void pcifront_backend_changed(struct xenbus_device
*xdev
,
1001 enum xenbus_state be_state
)
1003 struct pcifront_device
*pdev
= dev_get_drvdata(&xdev
->dev
);
1006 case XenbusStateUnknown
:
1007 case XenbusStateInitialising
:
1008 case XenbusStateInitWait
:
1009 case XenbusStateInitialised
:
1012 case XenbusStateConnected
:
1013 pcifront_try_connect(pdev
);
1016 case XenbusStateClosed
:
1017 if (xdev
->state
== XenbusStateClosed
)
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
);
1025 case XenbusStateReconfiguring
:
1026 pcifront_detach_devices(pdev
);
1029 case XenbusStateReconfigured
:
1030 pcifront_attach_devices(pdev
);
1035 static int pcifront_xenbus_probe(struct xenbus_device
*xdev
,
1036 const struct xenbus_device_id
*id
)
1039 struct pcifront_device
*pdev
= alloc_pdev(xdev
);
1043 xenbus_dev_fatal(xdev
, err
,
1044 "Error allocating pcifront_device struct");
1048 err
= pcifront_publish_info(pdev
);
1056 static void pcifront_xenbus_remove(struct xenbus_device
*xdev
)
1058 struct pcifront_device
*pdev
= dev_get_drvdata(&xdev
->dev
);
1064 static const struct xenbus_device_id xenpci_ids
[] = {
1069 static struct xenbus_driver xenpci_driver
= {
1072 .probe
= pcifront_xenbus_probe
,
1073 .remove
= pcifront_xenbus_remove
,
1074 .otherend_changed
= pcifront_backend_changed
,
1077 static int __init
pcifront_init(void)
1079 if (!xen_pv_domain() || xen_initial_domain())
1082 if (!xen_has_pv_devices())
1085 pci_frontend_registrar(1 /* enable */);
1087 return xenbus_register_frontend(&xenpci_driver
);
1090 static void __exit
pcifront_cleanup(void)
1092 xenbus_unregister_driver(&xenpci_driver
);
1093 pci_frontend_registrar(0 /* disable */);
1095 module_init(pcifront_init
);
1096 module_exit(pcifront_cleanup
);
1098 MODULE_DESCRIPTION("Xen PCI passthrough frontend.");
1099 MODULE_LICENSE("GPL");
1100 MODULE_ALIAS("xen:pci");