Commit e6decf68 authored by Darek Stojaczyk's avatar Darek Stojaczyk Committed by Tomasz Zawadzki
Browse files

env_dpdk: add DPDK-independent driver information to spdk_pci_driver 



We want to make struct spdk_pci_driver public, so add env-agnostic
fields that define a driver directly to that struct.
PCI driver registration (potentially in upper layers) will only use
spdk_pci_id-s and spdk pci drv_flags, then those will be translated
to DPDK equivalents inside env_dpdk.

Change-Id: Ia24ecfc99ebf0f54f096eaf27bca5ed9c0dfe01d
Signed-off-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Signed-off-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/3183


Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Community-CI: Mellanox Build Bot
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
parent acee02ac

lib/env_dpdk/env_internal.h

+19 −1
Original line number Diff line number Diff line
@@ -59,14 +59,32 @@ 
#define SHIFT_1GB	30 /* (1 << 30) == 1 GB */

#define MASK_1GB	((1ULL << SHIFT_1GB) - 1)



#define SPDK_PMD_REGISTER_PCI(pci_drv)									\

#define SPDK_PCI_DRIVER_REGISTER(pci_drv)								\

__attribute__((constructor)) static void pci_drv ## _register(void)					\

{													\

	pci_driver_register(&pci_drv);									\

}



/** Device needs PCI BAR mapping (done with either IGB_UIO or VFIO) */

#define SPDK_PCI_DRIVER_NEED_MAPPING 0x0001

/** Device needs PCI BAR mapping with enabled write combining (wc) */

#define SPDK_PCI_DRIVER_WC_ACTIVATE 0x0002



#define SPDK_PCI_DEVICE(vend, dev)	        \

	.class_id = SPDK_PCI_CLASS_ANY_ID,      \

	.vendor_id = (vend),                    \

	.device_id = (dev),                     \

	.subvendor_id = SPDK_PCI_ANY_ID,        \

	.subdevice_id = SPDK_PCI_ANY_ID



#define SPDK_PCI_DRIVER_MAX_NAME_LEN 32

struct spdk_pci_driver {

	struct rte_pci_driver		driver;



	const char                      *name;

	const struct spdk_pci_id	*id_table;

	uint32_t			drv_flags;



	spdk_pci_enum_cb		cb_fn;

	void				*cb_arg;

	TAILQ_ENTRY(spdk_pci_driver)	tailq;

lib/env_dpdk/pci.c

+62 −1
Original line number Diff line number Diff line
@@ -239,6 +239,67 @@ cleanup_pci_devices(void) 


static int scan_pci_bus(bool delay_init);



/* translate spdk_pci_driver to an rte_pci_driver and register it to dpdk */

static int

register_rte_driver(struct spdk_pci_driver *driver)

{

	unsigned pci_id_count = 0;

	struct rte_pci_id *rte_id_table;

	char *rte_name;

	size_t rte_name_len;

	uint32_t rte_flags;



	assert(driver->id_table);

	while (driver->id_table[pci_id_count].vendor_id) {

		pci_id_count++;

	}

	assert(pci_id_count > 0);



	rte_id_table = calloc(pci_id_count + 1, sizeof(*rte_id_table));

	if (!rte_id_table) {

		return -ENOMEM;

	}



	while (pci_id_count > 0) {

		struct rte_pci_id *rte_id = &rte_id_table[pci_id_count - 1];

		const struct spdk_pci_id *spdk_id = &driver->id_table[pci_id_count - 1];



		rte_id->class_id = spdk_id->class_id;

		rte_id->vendor_id = spdk_id->vendor_id;

		rte_id->device_id = spdk_id->device_id;

		rte_id->subsystem_vendor_id = spdk_id->subvendor_id;

		rte_id->subsystem_device_id = spdk_id->subdevice_id;

		pci_id_count--;

	}



	assert(driver->name);

	rte_name_len = strlen(driver->name) + strlen("spdk_") + 1;

	rte_name = calloc(rte_name_len, 1);

	if (!rte_name) {

		free(rte_id_table);

		return -ENOMEM;

	}



	snprintf(rte_name, rte_name_len, "spdk_%s", driver->name);

	driver->driver.driver.name = rte_name;

	driver->driver.id_table = rte_id_table;



	rte_flags = 0;

	if (driver->drv_flags & SPDK_PCI_DRIVER_NEED_MAPPING) {

		rte_flags |= RTE_PCI_DRV_NEED_MAPPING;

	}

	if (driver->drv_flags & SPDK_PCI_DRIVER_WC_ACTIVATE) {

		rte_flags |= RTE_PCI_DRV_WC_ACTIVATE;

	}

	driver->driver.drv_flags = rte_flags;



	driver->driver.probe = pci_device_init;

	driver->driver.remove = pci_device_fini;



	rte_pci_register(&driver->driver);

	return 0;

}



static inline void

_pci_env_init(void)

{
@@ -260,7 +321,7 @@ pci_env_init(void) 
	struct spdk_pci_driver *driver;



	TAILQ_FOREACH(driver, &g_pci_drivers, tailq) {

		rte_pci_register(&driver->driver);

		register_rte_driver(driver);

	}



	_pci_env_init();

lib/env_dpdk/pci_idxd.c

+6 −13
Original line number Diff line number Diff line
@@ -35,23 +35,16 @@ 


#include "spdk/pci_ids.h"



#define SPDK_IDXD_PCI_DEVICE(DEVICE_ID) RTE_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)

static struct rte_pci_id idxd_driver_id[] = {

#define SPDK_IDXD_PCI_DEVICE(DEVICE_ID) SPDK_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)

static struct spdk_pci_id idxd_driver_id[] = {

	{SPDK_IDXD_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IDXD)},

	{ .vendor_id = 0, /* sentinel */ },

};



static struct spdk_pci_driver g_idxd_pci_drv = {

	.driver = {

		.drv_flags	= RTE_PCI_DRV_NEED_MAPPING,

	.name = "idxd",

	.id_table = idxd_driver_id,

		.probe		= pci_device_init,

		.remove		= pci_device_fini,

		.driver.name	= "spdk_idxd",

	},



	.cb_fn = NULL,

	.cb_arg = NULL,

	.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING

};



struct spdk_pci_driver *
@@ -60,4 +53,4 @@ spdk_pci_idxd_get_driver(void) 
	return &g_idxd_pci_drv;

}



SPDK_PMD_REGISTER_PCI(g_idxd_pci_drv);
 
SPDK_PCI_DRIVER_REGISTER(g_idxd_pci_drv);

lib/env_dpdk/pci_ioat.c

+6 −13
Original line number Diff line number Diff line
@@ -35,8 +35,8 @@ 


#include "spdk/pci_ids.h"



#define SPDK_IOAT_PCI_DEVICE(DEVICE_ID) RTE_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)

static struct rte_pci_id ioat_driver_id[] = {

#define SPDK_IOAT_PCI_DEVICE(DEVICE_ID) SPDK_PCI_DEVICE(SPDK_PCI_VID_INTEL, DEVICE_ID)

static struct spdk_pci_id ioat_driver_id[] = {

	{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB0)},

	{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB1)},

	{SPDK_IOAT_PCI_DEVICE(PCI_DEVICE_ID_INTEL_IOAT_SNB2)},
@@ -90,16 +90,9 @@ static struct rte_pci_id ioat_driver_id[] = { 
};



static struct spdk_pci_driver g_ioat_pci_drv = {

	.driver = {

		.drv_flags	= RTE_PCI_DRV_NEED_MAPPING,

	.name = "ioat",

	.id_table = ioat_driver_id,

		.probe		= pci_device_init,

		.remove		= pci_device_fini,

		.driver.name	= "spdk_ioat",

	},



	.cb_fn = NULL,

	.cb_arg = NULL,

	.drv_flags = SPDK_PCI_DRIVER_NEED_MAPPING

};



struct spdk_pci_driver *
@@ -108,4 +101,4 @@ spdk_pci_ioat_get_driver(void) 
	return &g_ioat_pci_drv;

}



SPDK_PMD_REGISTER_PCI(g_ioat_pci_drv);
 
SPDK_PCI_DRIVER_REGISTER(g_ioat_pci_drv);

lib/env_dpdk/pci_nvme.c

+10 −18
Original line number Diff line number Diff line
@@ -35,30 +35,22 @@ 


#include "spdk/pci_ids.h"



static struct rte_pci_id nvme_pci_driver_id[] = {

static struct spdk_pci_id nvme_pci_driver_id[] = {

	{

		.class_id = SPDK_PCI_CLASS_NVME,

		.vendor_id = PCI_ANY_ID,

		.device_id = PCI_ANY_ID,

		.subsystem_vendor_id = PCI_ANY_ID,

		.subsystem_device_id = PCI_ANY_ID,

		.vendor_id = SPDK_PCI_ANY_ID,

		.device_id = SPDK_PCI_ANY_ID,

		.subvendor_id = SPDK_PCI_ANY_ID,

		.subdevice_id = SPDK_PCI_ANY_ID,

	},

	{ .vendor_id = 0, /* sentinel */ },

};



static struct spdk_pci_driver g_nvme_pci_drv = {

	.driver = {

		.drv_flags	= RTE_PCI_DRV_NEED_MAPPING

		| RTE_PCI_DRV_WC_ACTIVATE

		,

	.name = "nvme",

	.id_table = nvme_pci_driver_id,

		.probe		= pci_device_init,

		.remove		= pci_device_fini,

		.driver.name	= "spdk_nvme",

	},



	.cb_fn = NULL,

	.cb_arg = NULL,

	.drv_flags	= SPDK_PCI_DRIVER_NEED_MAPPING |

	SPDK_PCI_DRIVER_WC_ACTIVATE

};



struct spdk_pci_driver *
@@ -67,4 +59,4 @@ spdk_pci_nvme_get_driver(void) 
	return &g_nvme_pci_drv;

}



SPDK_PMD_REGISTER_PCI(g_nvme_pci_drv);
 
SPDK_PCI_DRIVER_REGISTER(g_nvme_pci_drv);