pciback.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * PCI Backend Common Data Structures & Function Declarations
  4 *
  5 *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
  6 */
  7#ifndef __XEN_PCIBACK_H__
  8#define __XEN_PCIBACK_H__
  9
 10#include <linux/pci.h>
 11#include <linux/interrupt.h>
 12#include <xen/xenbus.h>
 13#include <linux/list.h>
 14#include <linux/spinlock.h>
 15#include <linux/workqueue.h>
 16#include <linux/atomic.h>
 17#include <xen/events.h>
 18#include <xen/interface/io/pciif.h>
 19
 20#define DRV_NAME	"xen-pciback"
 21
 22struct pci_dev_entry {
 23	struct list_head list;
 24	struct pci_dev *dev;
 25};
 26
 27#define _PDEVF_op_active	(0)
 28#define PDEVF_op_active		(1<<(_PDEVF_op_active))
 29#define _PCIB_op_pending	(1)
 30#define PCIB_op_pending		(1<<(_PCIB_op_pending))
 31#define _EOI_pending		(2)
 32#define EOI_pending		(1<<(_EOI_pending))
 33
 34struct xen_pcibk_device {
 35	void *pci_dev_data;
 36	struct mutex dev_lock;
 37	struct xenbus_device *xdev;
 38	struct xenbus_watch be_watch;
 39	u8 be_watching;
 40	int evtchn_irq;
 41	struct xen_pci_sharedinfo *sh_info;
 42	unsigned long flags;
 43	struct work_struct op_work;
 44	struct xen_pci_op op;
 45};
 46
 47struct xen_pcibk_dev_data {
 48	struct list_head config_fields;
 49	struct pci_saved_state *pci_saved_state;
 50	unsigned int permissive:1;
 51	unsigned int allow_interrupt_control:1;
 52	unsigned int warned_on_write:1;
 53	unsigned int enable_intx:1;
 54	unsigned int isr_on:1; /* Whether the IRQ handler is installed. */
 55	unsigned int ack_intr:1; /* .. and ACK-ing */
 56	unsigned long handled;
 57	unsigned int irq; /* Saved in case device transitions to MSI/MSI-X */
 58	char irq_name[]; /* xen-pcibk[000:04:00.0] */
 59};
 60
 61/* Used by XenBus and xen_pcibk_ops.c */
 62extern wait_queue_head_t xen_pcibk_aer_wait_queue;
 63/* Used by pcistub.c and conf_space_quirks.c */
 64extern struct list_head xen_pcibk_quirks;
 65
 66/* Get/Put PCI Devices that are hidden from the PCI Backend Domain */
 67struct pci_dev *pcistub_get_pci_dev_by_slot(struct xen_pcibk_device *pdev,
 68					    int domain, int bus,
 69					    int slot, int func);
 70void pcistub_put_pci_dev(struct pci_dev *dev);
 71
 72static inline bool xen_pcibk_pv_support(void)
 73{
 74	return IS_ENABLED(CONFIG_XEN_PCIDEV_BACKEND);
 75}
 76
 77/* Ensure a device is turned off or reset */
 78void xen_pcibk_reset_device(struct pci_dev *pdev);
 79
 80/* Access a virtual configuration space for a PCI device */
 81int xen_pcibk_config_init(void);
 82int xen_pcibk_config_init_dev(struct pci_dev *dev);
 83void xen_pcibk_config_free_dyn_fields(struct pci_dev *dev);
 84void xen_pcibk_config_reset_dev(struct pci_dev *dev);
 85void xen_pcibk_config_free_dev(struct pci_dev *dev);
 86int xen_pcibk_config_read(struct pci_dev *dev, int offset, int size,
 87			  u32 *ret_val);
 88int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size,
 89			   u32 value);
 90
 91/* Handle requests for specific devices from the frontend */
 92typedef int (*publish_pci_dev_cb) (struct xen_pcibk_device *pdev,
 93				   unsigned int domain, unsigned int bus,
 94				   unsigned int devfn, unsigned int devid);
 95typedef int (*publish_pci_root_cb) (struct xen_pcibk_device *pdev,
 96				    unsigned int domain, unsigned int bus);
 97
 98/* Backend registration for the two types of BDF representation:
 99 *  vpci - BDFs start at 00
100 *  passthrough - BDFs are exactly like in the host.
101 */
102struct xen_pcibk_backend {
103	const char *name;
104	int (*init)(struct xen_pcibk_device *pdev);
105	void (*free)(struct xen_pcibk_device *pdev);
106	int (*find)(struct pci_dev *pcidev, struct xen_pcibk_device *pdev,
107		    unsigned int *domain, unsigned int *bus,
108		    unsigned int *devfn);
109	int (*publish)(struct xen_pcibk_device *pdev, publish_pci_root_cb cb);
110	void (*release)(struct xen_pcibk_device *pdev, struct pci_dev *dev,
111                        bool lock);
112	int (*add)(struct xen_pcibk_device *pdev, struct pci_dev *dev,
113		   int devid, publish_pci_dev_cb publish_cb);
114	struct pci_dev *(*get)(struct xen_pcibk_device *pdev,
115			       unsigned int domain, unsigned int bus,
116			       unsigned int devfn);
117};
118
119extern const struct xen_pcibk_backend xen_pcibk_vpci_backend;
120extern const struct xen_pcibk_backend xen_pcibk_passthrough_backend;
121extern const struct xen_pcibk_backend *xen_pcibk_backend;
122
123static inline int xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
124					struct pci_dev *dev,
125					int devid,
126					publish_pci_dev_cb publish_cb)
127{
128	if (xen_pcibk_backend && xen_pcibk_backend->add)
129		return xen_pcibk_backend->add(pdev, dev, devid, publish_cb);
130	return -1;
131}
132
133static inline void xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
134					     struct pci_dev *dev, bool lock)
135{
136	if (xen_pcibk_backend && xen_pcibk_backend->release)
137		return xen_pcibk_backend->release(pdev, dev, lock);
138}
139
140static inline struct pci_dev *
141xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev, unsigned int domain,
142		      unsigned int bus, unsigned int devfn)
143{
144	if (xen_pcibk_backend && xen_pcibk_backend->get)
145		return xen_pcibk_backend->get(pdev, domain, bus, devfn);
146	return NULL;
147}
148
149/**
150* Add for domain0 PCIE-AER handling. Get guest domain/bus/devfn in xen_pcibk
151* before sending aer request to pcifront, so that guest could identify
152* device, coopearte with xen_pcibk to finish aer recovery job if device driver
153* has the capability
154*/
155static inline int xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
156					     struct xen_pcibk_device *pdev,
157					     unsigned int *domain,
158					     unsigned int *bus,
159					     unsigned int *devfn)
160{
161	if (xen_pcibk_backend && xen_pcibk_backend->find)
162		return xen_pcibk_backend->find(pcidev, pdev, domain, bus,
163					       devfn);
164	return -1;
165}
166
167static inline int xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
168{
169	if (xen_pcibk_backend && xen_pcibk_backend->init)
170		return xen_pcibk_backend->init(pdev);
171	return -1;
172}
173
174static inline int xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
175					      publish_pci_root_cb cb)
176{
177	if (xen_pcibk_backend && xen_pcibk_backend->publish)
178		return xen_pcibk_backend->publish(pdev, cb);
179	return -1;
180}
181
182static inline void xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
183{
184	if (xen_pcibk_backend && xen_pcibk_backend->free)
185		return xen_pcibk_backend->free(pdev);
186}
187
188/* Handles events from front-end */
189irqreturn_t xen_pcibk_handle_event(int irq, void *dev_id);
190void xen_pcibk_do_op(struct work_struct *data);
191
192static inline void xen_pcibk_lateeoi(struct xen_pcibk_device *pdev,
193				     unsigned int eoi_flag)
194{
195	if (test_and_clear_bit(_EOI_pending, &pdev->flags))
196		xen_irq_lateeoi(pdev->evtchn_irq, eoi_flag);
197}
198
199int xen_pcibk_xenbus_register(void);
200void xen_pcibk_xenbus_unregister(void);
201#endif