Re: [PATCH] vfio: selftests: Add driver for IGB QEMU device

[David Matlack <dmatlack@google.com>]

On 2026-05-11 09:18 PM, Josh Hilke wrote:
> Add a VFIO selftest driver for the Intel Gigabit Ethernet controller
> (IGB). IGB is fully virtualized in QEMU [1] which makes it easy to run
> VFIO selftests without needing any specific hardware.
> 
> IGB does not have a default memcpy operation, and memcpy is required for
> all VFIO selftest drivers. However, IGB has a "loopback" mode which is
> used in this driver to implement memcpy. When IGB is in loopback mode,
> it doesn't send data out to the network. Instead, it sends data from the
> Tx queue directly to the Rx queue which points to the memcpy
> destination, instead of sending the data out to the network.
> 
> This driver passes all of the VFIO selftests in
> tools/testing/selftests/vfio/ when running in QEMU. The driver has not
> been tested using a real IGB device since the main goal of writing this
> driver is to run VFIO selftests in QEMU without requiring any hardware.
> 
> This command is used to test the driver. It runs
> ./tools/testing/selftests/vfio/vfio_pci_driver_test using virtme-ng [2],
> which runs a kernel in a virtualized environment using QEMU that has a
> copy-on-write snapshot the host filesystem.
> 
> vng \
>   --run arch/x86/boot/bzImage \
>   --user root \
>   --disable-microvm \
>   --memory 32G \
>   --cpus 8 \
>   --qemu-opts="-M q35,accel=kvm,kernel-irqchip=split" \
>   --qemu-opts="-device intel-iommu,intremap=on,caching-mode=on,device-iotlb=on" \
>   --qemu-opts="-netdev user,id=net0 -device igb,netdev=net0,addr=09.0" \
>   --append "console=ttyS0 earlyprintk=ttyS0 intel_iommu=on iommu=pt" \
>   --exec "modprobe vfio-pci && \
>           ./tools/testing/selftests/vfio/scripts/setup.sh 0000:00:09.0 && \
>           ./tools/testing/selftests/vfio/scripts/run.sh ./tools/testing/selftests/vfio/vfio_pci_driver_test"
> 
> Code was written entirely by AI (Gemini) by feeding it the Intel IGB
> specification, the code for the real IGB driver, and the QEMU
> implementation of the IGB device. It took many iterations of prompting
> to get the driver to pass all of the tests, and lot's of de-slopping to
> remove unnecessary code and make the code readable.
> 
> Code comments are also written by Gemini through iterative
> prompting.
> 
> This patch is based on the kvm/queue branch.
> 
> [1] https://www.qemu.org/docs/master/system/devices/igb.html
> [2] https://github.com/arighi/virtme-ng
> 
> Assisted-by: Gemini:gemini-3-pro-preview
> Signed-off-by: Josh Hilke <jrhilke@google.com>

I just did a quick first pass and left some feedback. Overall I'm very
excited to have a driver for a device supported by QEMU!

> ---
>  .../selftests/vfio/lib/drivers/igb/igb.c      | 381 ++++++++++++++++++
>  .../vfio/lib/drivers/igb/registers.h          | 103 +++++
>  tools/testing/selftests/vfio/lib/libvfio.mk   |   1 +
>  .../selftests/vfio/lib/vfio_pci_driver.c      |   2 +
>  4 files changed, 487 insertions(+)
>  create mode 100644 tools/testing/selftests/vfio/lib/drivers/igb/igb.c
>  create mode 100644 tools/testing/selftests/vfio/lib/drivers/igb/registers.h
> 
> diff --git a/tools/testing/selftests/vfio/lib/drivers/igb/igb.c b/tools/testing/selftests/vfio/lib/drivers/igb/igb.c
> new file mode 100644
> index 000000000000..13c8429784ac
> --- /dev/null
> +++ b/tools/testing/selftests/vfio/lib/drivers/igb/igb.c
> @@ -0,0 +1,381 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +#include <unistd.h>
> +#include <errno.h>
> +#include <stdint.h>
> +#include <linux/io.h>
> +#include <linux/pci_regs.h>
> +#include <libvfio/vfio_pci_device.h>
> +
> +#include "registers.h"
> +
> +#define PCI_VENDOR_ID_INTEL 0x8086
> +#define PCI_DEVICE_ID_INTEL_IGB 0x10C9

You should be able to include <linux/pci_id.h> for these.

> +#define IGB_MAX_CHUNK_SIZE 1024
> +#define MSIX_VECTOR 0
> +#define RING_SIZE 4096 /* Number of descriptors in ring */

What's the maximum ring size that IGB can support? The max chunk size is
quite small so using a larger ring will be helpful toward getting the
device to do a lot of memcpys for Live Update testing.

> +
> +struct igb_tx_desc {
> +	union {
> +		struct {
> +			uint64_t buffer_addr; /* Address of descriptor's data buffer */
> +			uint32_t cmd_type_len; /* Command/Type/Length */
> +			uint32_t olinfo_status; /* Context/Buffer info */

Use kernel-style fixed width types (u64, u32, etc.).

> +		} read;
> +
> +		struct {
> +			uint64_t rsvd;        /* Reserved */
> +			uint32_t nxtseq_seed; /* Next sequence seed */
> +			uint32_t status;      /* Descriptor status */
> +		} wb;
> +	};
> +};
> +
> +struct igb_rx_desc {
> +	union {
> +		struct {
> +			uint64_t pkt_addr; /* Packet buffer address */
> +			uint64_t hdr_addr; /* Header buffer address */
> +		} read;
> +		struct {
> +			uint16_t pkt_info;     /* RSS type, Packet type */
> +			uint16_t hdr_info;     /* Split Head, buf len */
> +			uint32_t rss;          /* RSS Hash */
> +			uint32_t status_error; /* ext status/error */
> +			uint16_t length;       /* Packet length */
> +			uint16_t vlan;         /* VLAN tag */
> +		} wb; /* writeback */
> +	};
> +};
> +
> +struct igb {
> +	void *bar0;
> +	struct igb_tx_desc *tx_ring;
> +	struct igb_rx_desc *rx_ring;
> +	uint32_t tx_tail;
> +	uint32_t rx_tail;
> +};
> +
> +static inline struct igb *to_igb_state(struct vfio_pci_device *device)
> +{
> +	return (struct igb *)device->driver.region.vaddr;
> +}
> +
> +static inline void igb_write32(struct igb *igb, uint32_t reg, uint32_t val)
> +{
> +	writel(val, igb->bar0 + reg);
> +}
> +
> +static inline uint32_t igb_read32(struct igb *igb, uint32_t reg)
> +{
> +	return readl(igb->bar0 + reg);
> +}
> +
> +static int igb_write_phy(struct igb *igb, uint32_t offset, uint16_t data)
> +{
> +	uint32_t mdic;
> +	int i;
> +
> +	mdic = (((uint32_t)data) |
> +		(offset << IGB_MDIC_REG_SHIFT) |
> +		(1 << IGB_MDIC_PHY_SHIFT) |
> +		IGB_MDIC_OP_WRITE);
> +
> +	igb_write32(igb, IGB_MDIC, mdic);
> +
> +	for (i = 0; i < 1000; i++) {
> +		usleep(50);
> +		mdic = igb_read32(igb, IGB_MDIC);
> +		if (mdic & IGB_MDIC_READY)
> +			break;
> +	}
> +
> +	if (!(mdic & IGB_MDIC_READY))
> +		return -1;
> +
> +	if (mdic & IGB_MDIC_ERROR)
> +		return -1;
> +
> +	return 0;
> +}
> +
> +static int igb_read_phy(struct igb *igb, uint32_t offset, uint16_t *data)
> +{
> +	uint32_t mdic;
> +	int i;
> +
> +	mdic = ((offset << IGB_MDIC_REG_SHIFT) |
> +		(1 << IGB_MDIC_PHY_SHIFT) |
> +		IGB_MDIC_OP_READ);
> +
> +	igb_write32(igb, IGB_MDIC, mdic);
> +
> +	for (i = 0; i < 1000; i++) {
> +		usleep(50);
> +		mdic = igb_read32(igb, IGB_MDIC);
> +		if (mdic & IGB_MDIC_READY)
> +			break;
> +	}
> +
> +	if (!(mdic & IGB_MDIC_READY))
> +		return -1;
> +
> +	if (mdic & IGB_MDIC_ERROR)
> +		return -1;
> +
> +	*data = (uint16_t)mdic;
> +	return 0;
> +}
> +
> +static int igb_phy_setup_autoneg(struct igb *igb)
> +{
> +	int timeout_ms = 1000;
> +	bool success = false;
> +	uint16_t phy_status;
> +	int ret;
> +	int i;
> +
> +	/* Trigger auto-negotiation */
> +	ret = igb_write_phy(igb, IGB_PHY_CTRL_REG_OFFSET,
> +			    IGB_PHY_CTRL_AN_ENABLE | IGB_PHY_CTRL_RESTART_AN);
> +	if (ret)
> +		return ret;
> +
> +	for (i = 0; i < timeout_ms; i++) {
> +		if (igb_read_phy(igb, IGB_PHY_STATUS_REG_OFFSET, &phy_status) == 0) {
> +			success = !!(phy_status & IGB_PHY_STATUS_AN_COMP);
> +			if (success)
> +				break;
> +		}
> +		usleep(1000);
> +	}
> +
> +	if (!success) {
> +		printf("igb: Auto-negotiation did not complete in time\n");
> +		return -ETIMEDOUT;
> +	}
> +
> +	return 0;
> +}
> +
> +static int igb_probe(struct vfio_pci_device *device)
> +{
> +	if (!vfio_pci_device_match(device, PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IGB))
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static void igb_init(struct vfio_pci_device *device)
> +{
> +	struct igb *igb = to_igb_state(device);
> +	uint64_t iova_tx, iova_rx;
> +	uint32_t ctrl, rctl;
> +	uint16_t cmd_reg;
> +	int retries;
> +
> +	VFIO_ASSERT_GE(device->driver.region.size,
> +		       sizeof(struct igb) + 2 * RING_SIZE * sizeof(struct igb_tx_desc));

Please put these rings into struct igb directly rather than doing raw
pointer arithmetic and size calculations. e.g.

struct igb {
	void *bar0;
	u32 tx_tail;
	u32 rx_tail;
	struct igb_tx_desc tx_ring[RING_SIZE];
	struct igb_rx_desc rx_ring[RING_SIZE];
};

> +
> +	/* Set up rings and calculate IOVAs */
> +	igb->bar0 = device->bars[0].vaddr;
> +
> +	igb->tx_ring = (struct igb_tx_desc *)(igb + 1);
> +	igb->rx_ring = (struct igb_rx_desc *)(igb->tx_ring + RING_SIZE);
> +
> +	iova_tx = to_iova(device, igb->tx_ring);
> +	iova_rx = to_iova(device, igb->rx_ring);
> +
> +	/* Reset device and disable all interrupts */
> +	igb_write32(igb, IGB_CTRL, igb_read32(igb, IGB_CTRL) | IGB_CTRL_RST);
> +	usleep(20000);
> +	igb_write32(igb, IGB_IMC, 0xFFFFFFFF);
> +
> +	/* Signal that the driver is loaded */
> +	ctrl = igb_read32(igb, IGB_CTRL_EXT);
> +	ctrl |= IGB_CTRL_EXT_DRV_LOAD;
> +	ctrl &= ~IGB_CTRL_EXT_LINK_MODE_MASK;
> +	igb_write32(igb, IGB_CTRL_EXT, ctrl);
> +
> +	/* Enable PCI Bus Master. */
> +	cmd_reg = vfio_pci_config_readw(device, PCI_COMMAND);
> +	if (!(cmd_reg & PCI_COMMAND_MASTER)) {
> +		cmd_reg |= (PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY);
> +		vfio_pci_config_writew(device, PCI_COMMAND, cmd_reg);
> +	}
> +
> +	/* Trigger autonegotiation. This enables IGB to transmit data. */
> +	if (igb_phy_setup_autoneg(igb))
> +		return;
> +
> +	/* Configure TX and RX descriptor rings */
> +	igb_write32(igb, IGB_TDBAL0, (uint32_t)iova_tx);
> +	igb_write32(igb, IGB_TDBAH0, (uint32_t)(iova_tx >> 32));
> +	igb_write32(igb, IGB_TDLEN0, RING_SIZE * sizeof(struct igb_tx_desc));
> +	igb_write32(igb, IGB_TDH0, 0);
> +	igb_write32(igb, IGB_TDT0, 0);
> +	igb_write32(igb, IGB_TXDCTL0, IGB_TXDCTL0_Q_EN);
> +
> +	igb_write32(igb, IGB_RDBAL0, (uint32_t)iova_rx);
> +	igb_write32(igb, IGB_RDBAH0, (uint32_t)(iova_rx >> 32));
> +	igb_write32(igb, IGB_RDLEN0, RING_SIZE * sizeof(struct igb_rx_desc));
> +	igb_write32(igb, IGB_RDH0, 0);
> +	igb_write32(igb, IGB_RDT0, 0);
> +	igb_write32(igb, IGB_RXDCTL0, IGB_RXDCTL0_Q_EN);
> +
> +	/* Wait for TX and RX queues to be enabled */
> +	retries = 2000;
> +	while (retries-- > 0) {
> +		if ((igb_read32(igb, IGB_TXDCTL0) & IGB_TXDCTL0_Q_EN) &&
> +		    (igb_read32(igb, IGB_RXDCTL0) & IGB_RXDCTL0_Q_EN))
> +			break;
> +		usleep(10);
> +	}
> +
> +	/* Enable Receiver and Transmitter */
> +	rctl = IGB_RCTL_EN |       /* Receiver Enable */
> +	       IGB_RCTL_UPE |      /* Unicast Promiscuous (for dummy MAC) */
> +	       IGB_RCTL_LBM_MAC |  /* MAC Loopback Mode */
> +	       IGB_RCTL_SECRC;     /* Strip CRC (needed for memcmp) */
> +	igb_write32(igb, IGB_RCTL, rctl);
> +	igb_write32(igb, IGB_TCTL, IGB_TCTL_EN);
> +
> +	/* Enable MSI-X with 1 vector for the test */
> +	vfio_pci_msix_enable(device, MSIX_VECTOR, 1);
> +
> +	/* Enable auto-masking of interrupts to avoid storms without a real ISR */
> +	igb_write32(igb, IGB_GPIE, IGB_GPIE_EIAME);
> +
> +	/* Enable interrupts on vector 0 */
> +	igb_write32(igb, IGB_EIMS, 1);
> +
> +	/* Map vector 0 to interrupt cause 0 and mark it valid */
> +	igb_write32(igb, IGB_IVAR0, IGB_IVAR_VALID);
> +
> +	/* Initialize driver state and capability limits */
> +	igb->tx_tail = 0;
> +	igb->rx_tail = 0;

This comment seems wrong.

> +
> +	device->driver.max_memcpy_size = (RING_SIZE - 1) * IGB_MAX_CHUNK_SIZE;
> +	device->driver.max_memcpy_count = RING_SIZE - 1;

The device must be able to do max_memcpy_count copies of
max_memcpy_size, so max_memcpy_size should be IGB_MAX_CHUNK_SIZE.

Once you do this you can also get rid of the chunking loop in
memcpy_start().

> +	device->driver.msi = MSIX_VECTOR;
> +}
> +
> +static void igb_remove(struct vfio_pci_device *device)
> +{
> +	struct igb *igb = to_igb_state(device);
> +
> +	vfio_pci_msix_disable(device);
> +	igb_write32(igb, IGB_RCTL, 0);
> +	igb_write32(igb, IGB_TCTL, 0);
> +	igb_write32(igb, IGB_CTRL, igb_read32(igb, IGB_CTRL) | IGB_CTRL_RST);
> +}
> +
> +static void igb_irq_disable(struct igb *igb)
> +{
> +	igb_write32(igb, IGB_EIMC, 1);
> +}
> +
> +static void igb_irq_enable(struct igb *igb)
> +{
> +	igb_write32(igb, IGB_EIMS, 1);
> +}
> +
> +static void igb_irq_clear(struct igb *igb)
> +{
> +	igb_read32(igb, IGB_EICR);
> +}
> +
> +static void igb_memcpy_start(struct vfio_pci_device *device, iova_t src,
> +			     iova_t dst, u64 size, u64 count)
> +{
> +	struct igb *igb = to_igb_state(device);
> +	iova_t curr_src, curr_dst;
> +	struct igb_rx_desc *rx;
> +	struct igb_tx_desc *tx;
> +	u64 chunk_size;
> +	u64 remaining;
> +	uint32_t i;
> +
> +	igb_irq_disable(igb);
> +
> +	for (i = 0; i < count; i++) {
> +		curr_src = src;
> +		curr_dst = dst;
> +		remaining = size;
> +
> +		while (remaining > 0) {
> +			chunk_size = min_t(u64, remaining, IGB_MAX_CHUNK_SIZE);
> +
> +			tx = &igb->tx_ring[igb->tx_tail];
> +			rx = &igb->rx_ring[igb->rx_tail];
> +
> +			memset(tx, 0, sizeof(struct igb_tx_desc));
> +			memset(rx, 0, sizeof(struct igb_rx_desc));
> +
> +			rx->read.pkt_addr = curr_dst;
> +			rx->read.hdr_addr = 0;
> +			rx->wb.status_error = 0;

Don't rx->read.hdr_addr and rx->wb.status_error overlap the same u64?
It's not a bug since both write 0 but it is weird.

> +
> +			tx->read.buffer_addr = curr_src;
> +			tx->read.cmd_type_len = (uint32_t)chunk_size;
> +			tx->read.cmd_type_len |= (uint32_t)(IGB_TXD_CMD_EOP) << IGB_TXD_CMD_SHIFT;
> +
> +			/* Set to 0 to disable offloads and avoid needing a context descriptor */
> +			tx->read.olinfo_status = 0;
> +
> +			curr_src += chunk_size;
> +			curr_dst += chunk_size;
> +			remaining -= chunk_size;
> +
> +			igb->tx_tail = (igb->tx_tail + 1) % RING_SIZE;
> +			igb->rx_tail = (igb->rx_tail + 1) % RING_SIZE;
> +		}
> +	}
> +
> +	igb_write32(igb, IGB_RDT0, igb->rx_tail);
> +	igb_write32(igb, IGB_TDT0, igb->tx_tail);
> +}
> +
> +static int igb_memcpy_wait(struct vfio_pci_device *device)
> +{
> +	struct igb *igb = to_igb_state(device);
> +	struct igb_rx_desc *rx;
> +	uint32_t prev_tail;
> +	int retries;
> +
> +	prev_tail = (igb->rx_tail + RING_SIZE - 1) % RING_SIZE;
> +	rx = &igb->rx_ring[prev_tail];
> +
> +	retries = 100;
> +	while (retries-- > 0) {
> +		if (rx->wb.status_error & 1)
> +			break;
> +		usleep(10);
> +	}

Why bail after a certain timeout? The test may have kicked off a large
count of memcpys. Is this for error detection?

> +
> +	igb_irq_clear(igb);
> +
> +	igb_irq_enable(igb);
> +
> +	if (rx->wb.status_error & 1)
> +		return 0;
> +
> +	return -ETIMEDOUT;

Is there any other way to the device signals errors other than failing
to set bit 0 of status_error? I'm especially curious how it handles
memcpy_from_unmapped_iova in vfio_pci_driver_test.c.

> +}
> +
> +static void igb_send_msi(struct vfio_pci_device *device)
> +{
> +	struct igb *igb = to_igb_state(device);
> +
> +	igb_write32(igb, IGB_EICS, 1);
> +}
> +
> +const struct vfio_pci_driver_ops igb_ops = {
> +	.name = "igb",
> +	.probe = igb_probe,
> +	.init = igb_init,
> +	.remove = igb_remove,
> +	.memcpy_start = igb_memcpy_start,
> +	.memcpy_wait = igb_memcpy_wait,
> +	.send_msi = igb_send_msi,
> +};
> diff --git a/tools/testing/selftests/vfio/lib/drivers/igb/registers.h b/tools/testing/selftests/vfio/lib/drivers/igb/registers.h
> new file mode 100644
> index 000000000000..e2756be2e9c0
> --- /dev/null
> +++ b/tools/testing/selftests/vfio/lib/drivers/igb/registers.h
> @@ -0,0 +1,103 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +
> +#ifndef _IGB_REGISTERS_H_
> +#define _IGB_REGISTERS_H_
> +
> +/* Register Offsets (Intel 82576EB Datasheet) */
> +#define IGB_CTRL 0x00000 /* Device Control */
> +#define IGB_STATUS 0x00008 /* Device Status */
> +#define IGB_CTRL_EXT 0x00018 /* Extended Device Control */
> +#define IGB_MDIC 0x00020 /* MDI Control */
> +#define IGB_RCTL 0x00100 /* Receive Control */
> +#define IGB_TCTL 0x00400 /* Transmit Control */
> +#define IGB_SCTL 0x00420 /* SerDes Control */
> +
> +/* Interrupt Registers */
> +#define IGB_IMC 0x0150C /* Interrupt Mask Clear */
> +#define IGB_IVAR0 0x01700 /* Interrupt Vector Allocation Register 0 */
> +
> +/* Rx Ring 0 Registers */
> +#define IGB_RDBAL0 0x0C000 /* Rx Desc Base Address Low */
> +#define IGB_RDBAH0 0x0C004 /* Rx Desc Base Address High */
> +#define IGB_RDLEN0 0x0C008 /* Rx Desc Length */
> +#define IGB_RDH0 0x0C010 /* Rx Desc Head */
> +#define IGB_RDT0 0x0C018 /* Rx Desc Tail */
> +#define IGB_RXDCTL0 0x0C028 /* Rx Desc Control */
> +
> +/* Tx Ring 0 Registers */
> +#define IGB_TDBAL0 0x0E000 /* Tx Desc Base Address Low */
> +#define IGB_TDBAH0 0x0E004 /* Tx Desc Base Address High */
> +#define IGB_TDLEN0 0x0E008 /* Tx Desc Length */
> +#define IGB_TDH0 0x0E010 /* Tx Desc Head */
> +#define IGB_TDT0 0x0E018 /* Tx Desc Tail */
> +#define IGB_TXDCTL0 0x0E028 /* Tx Desc Control */
> +
> +/* Control Bit Definitions */
> +/* CTRL */
> +#define IGB_CTRL_RST (1 << 26) /* Device Reset */
> +#define IGB_CTRL_EXT_LINK_MODE_MASK (3 << 22)
> +
> +/* CTRL_EXT */
> +#define IGB_CTRL_EXT_DRV_LOAD (1 << 28) /* Driver Loaded */
> +
> +/* RCTL */
> +#define IGB_RCTL_EN (1 << 1) /* Receiver Enable */
> +#define IGB_RCTL_UPE (1 << 3) /* Unicast Promiscuous Enabled */
> +#define IGB_RCTL_LPE (1 << 5) /* Long Packet Reception Enable */
> +#define IGB_RCTL_LBM_MAC (1 << 6) /* Loopback Mode - MAC */
> +#define IGB_RCTL_SECRC (1 << 26) /* Strip Ethernet CRC */
> +
> +/* TCTL */
> +#define IGB_TCTL_EN (1 << 1) /* Transmit Enable */
> +
> +/* SCTL */
> +#define IGB_SCTL_DISABLE_SERDES_LOOPBACK (1 << 6)
> +
> +/* MDIC */
> +#define IGB_MDIC_OP_WRITE (1 << 26)
> +#define IGB_MDIC_OP_READ  (2 << 26)
> +
> +#define IGB_EICR 0x01580 /* Extended Interrupt Cause Read */
> +
> +#define IGB_RAH0 0x05404 /* Receive Address High 0 */
> +#define IGB_VMOLR0 0x05AD0 /* VM Offload Layout Register 0 */
> +
> +#define IGB_VMOLR_LPE 0x00010000 /* Long Packet Enable */
> +#define IGB_VMOLR_BAM 0x08000000 /* Broadcast Accept Mode */
> +#define IGB_RAH_POOL_1 0x00040000 /* Pool 1 assignment */
> +
> +#define IGB_EIMS 0x01524 /* Extended Interrupt Mask Set */
> +#define IGB_EICS 0x01520 /* Extended Interrupt Cause Set */
> +#define IGB_EIMC 0x01528 /* Extended Interrupt Mask Clear */
> +#define IGB_CTRL_GIO_MASTER_DISABLE (1 << 2) /* GIO Master Disable */
> +#define IGB_STATUS_GIO_MASTER_ENABLE (1 << 19) /* GIO Master Enable */
> +#define IGB_GPIE 0x01514 /* General Purpose Interrupt Enable */
> +#define IGB_TXDCTL0_Q_EN (1 << 25) /* Transmit Queue Enable */
> +#define IGB_RXDCTL0_Q_EN (1 << 25) /* Receive Queue Enable */
> +#define IGB_MRQC 0x05818 /* Multiple Receive Queues Command */
> +
> +#define IGB_MDIC_PHY_SHIFT 21 /* PHY Address Shift */
> +#define IGB_MDIC_REG_SHIFT 16 /* Register Address Shift */
> +#define IGB_MDIC_READY (1 << 28) /* MDI Data Ready */
> +#define IGB_MDIC_ERROR (1 << 29) /* MDI Error */
> +
> +#define IGB_PHY_CTRL_REG_OFFSET 0
> +#define IGB_PHY_STATUS_REG_OFFSET 1
> +#define IGB_PHY_STATUS_AN_COMP 0x0020 /* Auto-negotiation complete */
> +#define IGB_PHY_CTRL_AN_ENABLE 0x1000 /* Auto-Negotiation Enable */
> +#define IGB_PHY_CTRL_RESTART_AN 0x0200 /* Restart Auto-Negotiation */
> +
> +#define IGB_PHY_AUTONEG_ADV_REG_OFFSET 4 /* Auto-Negotiation Advertisement */
> +#define IGB_PHY_1000T_CTRL_REG_OFFSET 9 /* 1000Base-T Control */
> +#define IGB_CR_1000T_FD_CAPS 0x0200 /* Advertise 1000 Mbps Full Duplex */
> +
> +#define IGB_GPIE_EIAME 0x10 /* Extended Interrupt Auto Mask Enable */
> +#define IGB_IVAR_VALID 0x80 /* Valid bit for IVAR register */
> +
> +#define IGB_TXD_CMD_EOP 0x01 /* End of Packet */
> +#define IGB_TXD_CMD_IFCS 0x02 /* Insert FCS */
> +#define IGB_TXD_CMD_RS 0x08 /* Report Status */
> +#define IGB_TXD_CMD_SHIFT 24 /* Shift for command bits in cmd_type_len */
> +#define IGB_TXD_CMD_LEGACY_FORMAT (1 << 20) /* Forces legacy descriptor format in QEMU */

IGB_TXD_CMD_LEGACY_FORMAT appears to be unused. I didn't check the rest.
Can you prune out the unused macros?

Related: Are these macros and/or the descriptor struct available in any
kernel headers that we could symlink into the VFIO selftests like we do
for DSA?

> +
> +#endif /* _IGB_REGISTERS_H_ */
> diff --git a/tools/testing/selftests/vfio/lib/libvfio.mk b/tools/testing/selftests/vfio/lib/libvfio.mk
> index 9f47bceed16f..1f13cca04348 100644
> --- a/tools/testing/selftests/vfio/lib/libvfio.mk
> +++ b/tools/testing/selftests/vfio/lib/libvfio.mk
> @@ -12,6 +12,7 @@ LIBVFIO_C += vfio_pci_driver.c
>  ifeq ($(ARCH:x86_64=x86),x86)
>  LIBVFIO_C += drivers/ioat/ioat.c
>  LIBVFIO_C += drivers/dsa/dsa.c
> +LIBVFIO_C += drivers/igb/igb.c
>  endif
>  
>  LIBVFIO_OUTPUT := $(OUTPUT)/libvfio
> diff --git a/tools/testing/selftests/vfio/lib/vfio_pci_driver.c b/tools/testing/selftests/vfio/lib/vfio_pci_driver.c
> index 6827f4a6febe..a5d0547132c4 100644
> --- a/tools/testing/selftests/vfio/lib/vfio_pci_driver.c
> +++ b/tools/testing/selftests/vfio/lib/vfio_pci_driver.c
> @@ -5,12 +5,14 @@
>  #ifdef __x86_64__
>  extern struct vfio_pci_driver_ops dsa_ops;
>  extern struct vfio_pci_driver_ops ioat_ops;
> +extern struct vfio_pci_driver_ops igb_ops;
>  #endif
>  
>  static struct vfio_pci_driver_ops *driver_ops[] = {
>  #ifdef __x86_64__
>  	&dsa_ops,
>  	&ioat_ops,
> +	&igb_ops,
>  #endif
>  };
>  
> -- 
> 2.54.0.563.g4f69b47b94-goog
>