d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

virtio: Reduce boilerplate for device driver module definitions

Browse Source 
Rather than have every device register itself for both virtio_pci and
virtio_mmio, provide a VIRTIO_DRIVER_MODULE wrapper to declare both,
merge VIRTIO_SIMPLE_PNPTABLE with VIRTIO_SIMPLE_PNPINFO and make the
latter register for both buses. This also has the benefit of abstracting
away the available transports and their names.

Reviewed by:	bryanv
Differential Revision:	https://reviews.freebsd.org/D28073
This commit is contained in:
Jessica Clarke 2021-01-21 01:07:23 +00:00
parent be79a2c60f
commit 633218ee46
7 changed files with 21 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
sys/dev/virtio/balloon/virtio_balloon.c
View File

@ -158,17 +158,13 @@ static driver_t vtballoon_driver = {
};
static devclass_t vtballoon_devclass;
DRIVER_MODULE(virtio_balloon, virtio_mmio, vtballoon_driver,
vtballoon_devclass, 0, 0);
DRIVER_MODULE(virtio_balloon, virtio_pci, vtballoon_driver,
VIRTIO_DRIVER_MODULE(virtio_balloon, vtballoon_driver,
vtballoon_devclass, 0, 0);
MODULE_VERSION(virtio_balloon, 1);
MODULE_DEPEND(virtio_balloon, virtio, 1, 1, 1);
VIRTIO_SIMPLE_PNPTABLE(virtio_balloon, VIRTIO_ID_BALLOON,
VIRTIO_SIMPLE_PNPINFO(virtio_balloon, VIRTIO_ID_BALLOON,
"VirtIO Balloon Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, virtio_balloon);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, virtio_balloon);
static int
vtballoon_probe(device_t dev)

8
sys/dev/virtio/block/virtio_blk.c
View File

@ -267,16 +267,12 @@ static driver_t vtblk_driver = {
};
static devclass_t vtblk_devclass;
DRIVER_MODULE(virtio_blk, virtio_mmio, vtblk_driver, vtblk_devclass,
vtblk_modevent, 0);
DRIVER_MODULE(virtio_blk, virtio_pci, vtblk_driver, vtblk_devclass,
VIRTIO_DRIVER_MODULE(virtio_blk, vtblk_driver, vtblk_devclass,
vtblk_modevent, 0);
MODULE_VERSION(virtio_blk, 1);
MODULE_DEPEND(virtio_blk, virtio, 1, 1, 1);
VIRTIO_SIMPLE_PNPTABLE(virtio_blk, VIRTIO_ID_BLOCK, "VirtIO Block Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, virtio_blk);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, virtio_blk);
VIRTIO_SIMPLE_PNPINFO(virtio_blk, VIRTIO_ID_BLOCK, "VirtIO Block Adapter");
static int
vtblk_modevent(module_t mod, int type, void *unused)

8
sys/dev/virtio/console/virtio_console.c
View File

@ -263,17 +263,13 @@ static driver_t vtcon_driver = {
};
static devclass_t vtcon_devclass;
DRIVER_MODULE(virtio_console, virtio_mmio, vtcon_driver, vtcon_devclass,
vtcon_modevent, 0);
DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass,
VIRTIO_DRIVER_MODULE(virtio_console, vtcon_driver, vtcon_devclass,
vtcon_modevent, 0);
MODULE_VERSION(virtio_console, 1);
MODULE_DEPEND(virtio_console, virtio, 1, 1, 1);
VIRTIO_SIMPLE_PNPTABLE(virtio_console, VIRTIO_ID_CONSOLE,
VIRTIO_SIMPLE_PNPINFO(virtio_console, VIRTIO_ID_CONSOLE,
"VirtIO Console Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, virtio_console);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, virtio_console);
static int
vtcon_modevent(module_t mod, int type, void *unused)

8
sys/dev/virtio/network/if_vtnet.c
View File

@ -362,9 +362,7 @@ static driver_t vtnet_driver = {
};
static devclass_t vtnet_devclass;
DRIVER_MODULE(vtnet, virtio_mmio, vtnet_driver, vtnet_devclass,
vtnet_modevent, 0);
DRIVER_MODULE(vtnet, virtio_pci, vtnet_driver, vtnet_devclass,
VIRTIO_DRIVER_MODULE(vtnet, vtnet_driver, vtnet_devclass,
vtnet_modevent, 0);
MODULE_VERSION(vtnet, 1);
MODULE_DEPEND(vtnet, virtio, 1, 1, 1);
@ -372,9 +370,7 @@ MODULE_DEPEND(vtnet, virtio, 1, 1, 1);
MODULE_DEPEND(vtnet, netmap, 1, 1, 1);
#endif
VIRTIO_SIMPLE_PNPTABLE(vtnet, VIRTIO_ID_NETWORK, "VirtIO Networking Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, vtnet);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, vtnet);
VIRTIO_SIMPLE_PNPINFO(vtnet, VIRTIO_ID_NETWORK, "VirtIO Networking Adapter");
static int
vtnet_modevent(module_t mod, int type, void *unused)

8
sys/dev/virtio/random/virtio_random.c
View File

@ -97,18 +97,14 @@ static driver_t vtrnd_driver = {
};
static devclass_t vtrnd_devclass;
DRIVER_MODULE(virtio_random, virtio_mmio, vtrnd_driver, vtrnd_devclass,
vtrnd_modevent, 0);
DRIVER_MODULE(virtio_random, virtio_pci, vtrnd_driver, vtrnd_devclass,
VIRTIO_DRIVER_MODULE(virtio_random, vtrnd_driver, vtrnd_devclass,
vtrnd_modevent, 0);
MODULE_VERSION(virtio_random, 1);
MODULE_DEPEND(virtio_random, virtio, 1, 1, 1);
MODULE_DEPEND(virtio_random, random_device, 1, 1, 1);
VIRTIO_SIMPLE_PNPTABLE(virtio_random, VIRTIO_ID_ENTROPY,
VIRTIO_SIMPLE_PNPINFO(virtio_random, VIRTIO_ID_ENTROPY,
"VirtIO Entropy Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, virtio_random);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, virtio_random);
static int
vtrnd_modevent(module_t mod, int type, void *unused)

8
sys/dev/virtio/scsi/virtio_scsi.c
View File

@ -239,17 +239,13 @@ static driver_t vtscsi_driver = {
};
static devclass_t vtscsi_devclass;
DRIVER_MODULE(virtio_scsi, virtio_mmio, vtscsi_driver, vtscsi_devclass,
vtscsi_modevent, 0);
DRIVER_MODULE(virtio_scsi, virtio_pci, vtscsi_driver, vtscsi_devclass,
VIRTIO_DRIVER_MODULE(virtio_scsi, vtscsi_driver, vtscsi_devclass,
vtscsi_modevent, 0);
MODULE_VERSION(virtio_scsi, 1);
MODULE_DEPEND(virtio_scsi, virtio, 1, 1, 1);
MODULE_DEPEND(virtio_scsi, cam, 1, 1, 1);
VIRTIO_SIMPLE_PNPTABLE(virtio_scsi, VIRTIO_ID_SCSI, "VirtIO SCSI Adapter");
VIRTIO_SIMPLE_PNPINFO(virtio_mmio, virtio_scsi);
VIRTIO_SIMPLE_PNPINFO(virtio_pci, virtio_scsi);
VIRTIO_SIMPLE_PNPINFO(virtio_scsi, VIRTIO_ID_SCSI, "VirtIO SCSI Adapter");
static int
vtscsi_modevent(module_t mod, int type, void *unused)

13
sys/dev/virtio/virtio.h
View File

@ -66,17 +66,22 @@ struct virtio_feature_desc {
const char *vfd_str;
};
#define VIRTIO_DRIVER_MODULE(name, driver, devclass, evh, arg) \
DRIVER_MODULE(name, virtio_mmio, driver, devclass, evh, arg); \
DRIVER_MODULE(name, virtio_pci, driver, devclass, evh, arg)
struct virtio_pnp_match {
uint32_t device_type;
const char *description;
};
#define VIRTIO_SIMPLE_PNPTABLE(driver, devtype, desc) \
#define VIRTIO_SIMPLE_PNPINFO(driver, devtype, desc) \
static const struct virtio_pnp_match driver ## _match = { \
.device_type = devtype, \
.description = desc, \
}
#define VIRTIO_SIMPLE_PNPINFO(bus, driver) \
MODULE_PNP_INFO("U32:device_type;D:#", bus, driver, \
}; \
MODULE_PNP_INFO("U32:device_type;D:#", virtio_mmio, driver, \
&driver ## _match, 1); \
MODULE_PNP_INFO("U32:device_type;D:#", virtio_pci, driver, \
&driver ## _match, 1)
#define VIRTIO_SIMPLE_PROBE(dev, driver) \
(virtio_simple_probe(dev, &driver ## _match))