DPDK patches and discussions
 help / color / mirror / Atom feed
From: Pallavi Kadam <pallavi.kadam@intel.com>
To: dev@dpdk.org, thomas@monjalon.net
Cc: ranjit.menon@intel.com, dmitry.kozliuk@gmail.com,
	Narcisa.Vasile@microsoft.com, talshn@nvidia.com,
	pallavi.kadam@intel.com
Subject: [dpdk-dev] [PATCH] bus/pci: netuio interface for windows
Date: Thu, 10 Sep 2020 18:59:47 -0700
Message-ID: <20200911015947.20044-1-pallavi.kadam@intel.com> (raw)

This patch adds implementations to probe PCI devices bound to netuio
with the help of "netuio" class device changes.
Now Windows will support both "netuio" and "net" device class and
can set kernel driver type based on the device class selection.

Note: Few definitions and structures have been copied from
netuio_interface.h file from
("[v3] windows/netuio: add Windows NetUIO kernel driver") series
and this will be fixed once the exact path for netuio source code is known.

Signed-off-by: Pallavi Kadam <pallavi.kadam@intel.com>
Reviewed-by: Ranjit Menon <ranjit.menon@intel.com>
---
 drivers/bus/pci/windows/pci.c | 293 +++++++++++++++++++++++++++++-----
 1 file changed, 257 insertions(+), 36 deletions(-)

diff --git a/drivers/bus/pci/windows/pci.c b/drivers/bus/pci/windows/pci.c
index c80bd5571..38db87a2a 100644
--- a/drivers/bus/pci/windows/pci.c
+++ b/drivers/bus/pci/windows/pci.c
@@ -17,6 +17,42 @@ DEFINE_DEVPROPKEY(DEVPKEY_Device_Numa_Node, 0x540b947e, 0x8b40, 0x45bc,
 	0xa8, 0xa2, 0x6a, 0x0b, 0x89, 0x4c, 0xbd, 0xa2, 3);
 #endif
 
+/* GUID definition for device class netUIO */
+DEFINE_GUID(GUID_DEVCLASS_NETUIO, 0x78912bc1, 0xcb8e, 0x4b28,
+	0xa3, 0x29, 0xf3, 0x22, 0xeb, 0xad, 0xbe, 0x0f);
+
+/* GUID definition for the netuio device interface */
+DEFINE_GUID(GUID_DEVINTERFACE_NETUIO, 0x08336f60, 0x0679, 0x4c6c,
+	0x85, 0xd2, 0xae, 0x7c, 0xed, 0x65, 0xff, 0xf7);
+
+/* IOCTL code definitions */
+#define IOCTL_NETUIO_MAP_HW_INTO_USERMODE \
+	CTL_CODE(FILE_DEVICE_NETWORK, 51, METHOD_BUFFERED, \
+	    FILE_READ_ACCESS | FILE_WRITE_ACCESS)
+
+#define  MAX_DEVICENAME_SZ 255
+
+static const char netuio_class[] = "netuio class";
+static const char net_class[] = "net class";
+
+#pragma pack(push)
+#pragma pack(8)
+struct mem_region {
+	UINT64 size;  /* memory region size */
+	LARGE_INTEGER phys_addr;  /* physical address of the memory region */
+	PVOID virt_addr;  /* virtual address of the memory region */
+	PVOID user_mapped_virt_addr;  /* virtual address of the region mapped */
+					/* into user process context */
+};
+
+#define PCI_MAX_BAR 6
+
+struct device_info {
+	struct mem_region hw[PCI_MAX_BAR];
+	USHORT reserved;
+};
+#pragma pack(pop)
+
 /*
  * This code is used to simulate a PCI probe by parsing information in
  * the registry hive for PCI devices.
@@ -172,34 +208,148 @@ pci_uio_remap_resource(struct rte_pci_device *dev __rte_unused)
 }
 
 static int
-get_device_pci_address(HDEVINFO dev_info,
-	PSP_DEVINFO_DATA device_info_data, struct rte_pci_addr *addr)
+send_ioctl(HANDLE f, DWORD ioctl,
+	void *in_buf, DWORD in_buf_size, void *out_buf, DWORD out_buf_size)
 {
-	BOOL  res;
-	ULONG bus_num, dev_and_func;
+	BOOL res;
+	DWORD bytes_ret = 0;
 
-	res = SetupDiGetDeviceRegistryProperty(dev_info, device_info_data,
-		SPDRP_BUSNUMBER, NULL, (PBYTE)&bus_num, sizeof(bus_num), NULL);
+	res = DeviceIoControl(f, ioctl, in_buf, in_buf_size,
+		out_buf, out_buf_size, &bytes_ret, NULL);
 	if (!res) {
-		RTE_LOG_WIN32_ERR(
-			"SetupDiGetDeviceRegistryProperty(SPDRP_BUSNUMBER)");
+		RTE_LOG_WIN32_ERR("DeviceIoControl:IOCTL query failed");
 		return -1;
 	}
 
-	res = SetupDiGetDeviceRegistryProperty(dev_info, device_info_data,
-		SPDRP_ADDRESS, NULL, (PBYTE)&dev_and_func, sizeof(dev_and_func),
+	return ERROR_SUCCESS;
+}
+
+/*
+ * get device resource information by sending ioctl to netuio driver
+ */
+static int
+get_netuio_device_info(HDEVINFO dev_info, PSP_DEVINFO_DATA dev_info_data,
+	struct rte_pci_device *dev)
+{
+	int ret = -1;
+	BOOL res;
+	DWORD required_size = 0;
+	TCHAR dev_instance_id[MAX_DEVICENAME_SZ];
+	HANDLE netuio = INVALID_HANDLE_VALUE;
+	HDEVINFO di_set = INVALID_HANDLE_VALUE;
+	SP_DEVICE_INTERFACE_DATA  dev_ifx_data = { 0 };
+	PSP_DEVICE_INTERFACE_DETAIL_DATA dev_ifx_detail = NULL;
+	struct device_info hw_info = { 0 };
+	unsigned int idx;
+	DEVPROPTYPE property_type;
+	DWORD numa_node;
+
+	/* obtain the driver interface for this device */
+	res = SetupDiGetDeviceInstanceId(dev_info, dev_info_data,
+		dev_instance_id, sizeof(dev_instance_id), &required_size);
+	if (!res) {
+		RTE_LOG_WIN32_ERR("SetupDiGetDeviceInstanceId");
+		return -1;
+	}
+
+	/* obtain the device information set */
+	di_set = SetupDiGetClassDevs(&GUID_DEVINTERFACE_NETUIO, dev_instance_id,
+		NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+	if (di_set == INVALID_HANDLE_VALUE) {
+		RTE_LOG_WIN32_ERR("SetupDiGetClassDevs(device information set)");
+		return -1;
+	}
+
+	dev_ifx_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+
+	/* enumerate the netUIO interfaces for this device information set */
+	res = SetupDiEnumDeviceInterfaces(di_set, 0, &GUID_DEVINTERFACE_NETUIO,
+		0, &dev_ifx_data);
+	if (!res) {
+		RTE_LOG_WIN32_ERR("SetupDiEnumDeviceInterfaces: no device interface");
+		goto end;
+	}
+
+	/* request and allocate required size for the device interface detail */
+	required_size = 0;
+	res = SetupDiGetDeviceInterfaceDetail(di_set, &dev_ifx_data, NULL, 0,
+		&required_size, NULL);
+	if (!res) {
+		/* ERROR_INSUFFICIENT_BUFFER is expected */
+		if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+			RTE_LOG_WIN32_ERR("SetupDiGetDeviceInterfaceDetail");
+			goto end;
+		}
+	}
+
+	dev_ifx_detail = malloc(required_size);
+	if (!dev_ifx_detail) {
+		RTE_LOG(ERR, EAL, "Could not allocate memory for dev interface.\n");
+		goto end;
+	}
+	dev_ifx_detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+
+	res = SetupDiGetDeviceInterfaceDetail(di_set, &dev_ifx_data,
+		dev_ifx_detail, required_size, NULL, NULL);
+	if (!res) {
+		RTE_LOG_WIN32_ERR("SetupDiGetDeviceInterfaceDetail");
+		goto end;
+	}
+
+	/* open the kernel driver */
+	netuio = CreateFile(dev_ifx_detail->DevicePath,
+		GENERIC_READ | GENERIC_WRITE,
+		FILE_SHARE_READ | FILE_SHARE_WRITE,
+		NULL,
+		OPEN_EXISTING,
+		FILE_ATTRIBUTE_NORMAL,
 		NULL);
+	if (netuio == INVALID_HANDLE_VALUE) {
+		RTE_LOG_WIN32_ERR("CreateFile");
+		RTE_LOG(ERR, EAL, "Unable to open driver file \"%s\".\n",
+			dev_ifx_detail->DevicePath);
+		goto end;
+	}
+
+	/* send ioctl to retrieve device information */
+	if (send_ioctl(netuio, IOCTL_NETUIO_MAP_HW_INTO_USERMODE, NULL, 0,
+		&hw_info, sizeof(hw_info)) != ERROR_SUCCESS) {
+		RTE_LOG(ERR, EAL, "Unable to send ioctl to driver.\n");
+		goto end;
+	}
+
+	/* set relevant values into the dev structure */
+	for (idx = 0; idx < PCI_MAX_RESOURCE; idx++) {
+		dev->mem_resource[idx].phys_addr =
+		    hw_info.hw[idx].phys_addr.QuadPart;
+		dev->mem_resource[idx].addr =
+		    hw_info.hw[idx].user_mapped_virt_addr;
+		dev->mem_resource[idx].len = hw_info.hw[idx].size;
+	}
+
+	/* get NUMA node using DEVPKEY_Device_Numa_Node */
+	res = SetupDiGetDevicePropertyW(dev_info, dev_info_data,
+		&DEVPKEY_Device_Numa_Node, &property_type,
+		(BYTE *)&numa_node, sizeof(numa_node), NULL, 0);
 	if (!res) {
 		RTE_LOG_WIN32_ERR(
-			"SetupDiGetDeviceRegistryProperty(SPDRP_ADDRESS)");
-		return -1;
+			"SetupDiGetDevicePropertyW(DEVPKEY_Device_Numa_Node)");
+		goto end;
 	}
+	dev->device.numa_node = numa_node;
 
-	addr->domain = 0;
-	addr->bus = bus_num;
-	addr->devid = dev_and_func >> 16;
-	addr->function = dev_and_func & 0xffff;
-	return 0;
+	ret = ERROR_SUCCESS;
+end:
+	if (netuio != INVALID_HANDLE_VALUE)
+		CloseHandle(netuio);
+
+	if (dev_ifx_detail)
+		free(dev_ifx_detail);
+
+	if (di_set != INVALID_HANDLE_VALUE)
+		SetupDiDestroyDeviceInfoList(di_set);
+
+	return ret;
 }
 
 static int
@@ -209,6 +359,7 @@ get_device_resource_info(HDEVINFO dev_info,
 	DEVPROPTYPE property_type;
 	DWORD numa_node;
 	BOOL  res;
+	int ret;
 
 	switch (dev->kdrv) {
 	case RTE_KDRV_NONE:
@@ -228,6 +379,18 @@ get_device_resource_info(HDEVINFO dev_info,
 		dev->mem_resource[0].len = 0;
 		dev->mem_resource[0].addr = NULL;
 		break;
+	case RTE_KDRV_NIC_UIO:
+		/* get device info from netuio kernel driver */
+		ret = get_netuio_device_info(dev_info, dev_info_data, dev);
+		if (ret != 0) {
+			RTE_LOG(DEBUG, EAL,
+				"Could not retrieve device info for PCI device "
+				PCI_PRI_FMT,
+				dev->addr.domain, dev->addr.bus,
+				dev->addr.devid, dev->addr.function);
+			return ret;
+		}
+		break;
 	default:
 		/* kernel driver type is unsupported */
 		RTE_LOG(DEBUG, EAL,
@@ -274,7 +437,7 @@ parse_pci_hardware_id(const char *buf, struct rte_pci_id *pci_id)
 	uint32_t subvendor_id = 0;
 
 	ids = sscanf_s(buf, "PCI\\VEN_%" PRIx16 "&DEV_%" PRIx16 "&SUBSYS_%"
-		PRIx32, &vendor_id, &device_id, &subvendor_id);
+	    PRIx32, &vendor_id, &device_id, &subvendor_id);
 	if (ids != 3)
 		return -1;
 
@@ -286,13 +449,46 @@ parse_pci_hardware_id(const char *buf, struct rte_pci_id *pci_id)
 }
 
 static void
-get_kernel_driver_type(struct rte_pci_device *dev)
+set_kernel_driver_type(PSP_DEVINFO_DATA device_info_data,
+	struct rte_pci_device *dev)
 {
-	/*
-	 * If another kernel driver is supported the relevant checking
-	 * functions should be here
-	 */
-	dev->kdrv = RTE_KDRV_NONE;
+	/* set kernel driver type based on device class */
+	if (IsEqualGUID((const void *)&(device_info_data->ClassGuid),
+		(const void *)&GUID_DEVCLASS_NETUIO))
+		dev->kdrv = RTE_KDRV_NIC_UIO;
+	else
+		dev->kdrv = RTE_KDRV_NONE;
+}
+
+static int
+get_device_pci_address(HDEVINFO dev_info,
+	PSP_DEVINFO_DATA device_info_data, struct rte_pci_addr *addr)
+{
+	BOOL  res;
+	ULONG bus_num, dev_and_func;
+
+	res = SetupDiGetDeviceRegistryProperty(dev_info, device_info_data,
+		SPDRP_BUSNUMBER, NULL, (PBYTE)&bus_num, sizeof(bus_num), NULL);
+	if (!res) {
+		RTE_LOG_WIN32_ERR(
+			"SetupDiGetDeviceRegistryProperty(SPDRP_BUSNUMBER)");
+		return -1;
+	}
+
+	res = SetupDiGetDeviceRegistryProperty(dev_info, device_info_data,
+		SPDRP_ADDRESS, NULL, (PBYTE)&dev_and_func, sizeof(dev_and_func),
+		NULL);
+	if (!res) {
+		RTE_LOG_WIN32_ERR(
+			"SetupDiGetDeviceRegistryProperty(SPDRP_ADDRESS)");
+		return -1;
+	}
+
+	addr->domain = 0;
+	addr->bus = bus_num;
+	addr->devid = dev_and_func >> 16;
+	addr->function = dev_and_func & 0xffff;
+	return 0;
 }
 
 static int
@@ -335,7 +531,7 @@ pci_scan_one(HDEVINFO dev_info, PSP_DEVINFO_DATA device_info_data)
 
 	pci_name_set(dev);
 
-	get_kernel_driver_type(dev);
+	set_kernel_driver_type(device_info_data, dev);
 
 	/* get resources */
 	if (get_device_resource_info(dev_info, device_info_data, dev)
@@ -376,26 +572,29 @@ pci_scan_one(HDEVINFO dev_info, PSP_DEVINFO_DATA device_info_data)
 }
 
 /*
- * Scan the contents of the PCI bus
- * and add all network class devices into the devices list.
+ * Scan for devices in specified device class
+ * and add them into the devices list.
  */
-int
-rte_pci_scan(void)
+static int
+pci_scan_device_class(const GUID *guid)
 {
 	int   ret = -1;
 	DWORD device_index = 0, found_device = 0;
 	HDEVINFO dev_info;
 	SP_DEVINFO_DATA device_info_data;
+	const char *class;
 
-	/* for debug purposes, PCI can be disabled */
-	if (!rte_eal_has_pci())
-		return 0;
+	if (IsEqualGUID((const void *)guid,
+	    (const void *)&GUID_DEVCLASS_NETUIO))
+		class = netuio_class;
+	else
+		class = net_class;
 
-	dev_info = SetupDiGetClassDevs(&GUID_DEVCLASS_NET, TEXT("PCI"), NULL,
-				DIGCF_PRESENT);
+	dev_info = SetupDiGetClassDevs(guid, TEXT("PCI"), NULL,	DIGCF_PRESENT);
 	if (dev_info == INVALID_HANDLE_VALUE) {
 		RTE_LOG_WIN32_ERR("SetupDiGetClassDevs(pci_scan)");
-		RTE_LOG(ERR, EAL, "Unable to enumerate PCI devices.\n");
+		RTE_LOG(ERR, EAL, "Unable to enumerate %s PCI devices.\n",
+			    class);
 		goto end;
 	}
 
@@ -415,7 +614,8 @@ rte_pci_scan(void)
 		device_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
 	}
 
-	RTE_LOG(DEBUG, EAL, "PCI scan found %lu devices\n", found_device);
+	RTE_LOG(DEBUG, EAL, "PCI scan found %lu %s devices\n",
+		found_device, class);
 	ret = 0;
 end:
 	if (dev_info != INVALID_HANDLE_VALUE)
@@ -423,3 +623,24 @@ rte_pci_scan(void)
 
 	return ret;
 }
+
+/*
+ * Scan the contents of the PCI bus looking for devices
+ */
+int
+rte_pci_scan(void)
+{
+	int   ret = -1;
+
+	/* for debug purposes, PCI can be disabled */
+	if (!rte_eal_has_pci())
+		return 0;
+
+	/* first, scan for netUIO class devices */
+	ret = pci_scan_device_class(&GUID_DEVCLASS_NETUIO);
+
+	/* then, scan for the standard net class devices */
+	ret = pci_scan_device_class(&GUID_DEVCLASS_NET);
+
+	return ret;
+}
-- 
2.18.0.windows.1


             reply	other threads:[~2020-09-11  2:04 UTC|newest]

Thread overview: 20+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-09-11  1:59 Pallavi Kadam [this message]
2020-09-13 18:42 ` Tal Shnaiderman
2020-09-15 20:13   ` Ranjit Menon
2020-09-15 23:28 ` [dpdk-dev] [PATCH v2] " Pallavi Kadam
2020-09-16  1:54   ` Stephen Hemminger
2020-09-17  0:48     ` Ranjit Menon
2020-09-17  1:20       ` Ranjit Menon
2020-09-21 21:08   ` [dpdk-dev] [PATCH v3] " Pallavi Kadam
2020-09-22  3:05     ` [dpdk-dev] [PATCH v4] " Pallavi Kadam
2020-09-25  1:53       ` [dpdk-dev] [PATCH v5] " Pallavi Kadam
2020-09-29  8:28         ` Tal Shnaiderman
2020-09-29 17:29           ` Ranjit Menon
2020-09-30  7:58             ` Tal Shnaiderman
2020-10-06 23:31           ` Kadam, Pallavi
2020-10-06 21:57         ` [dpdk-dev] [PATCH v6] " Pallavi Kadam
2020-10-08 17:46           ` Tal Shnaiderman
2020-10-08 18:56           ` [dpdk-dev] [PATCH v7] " Pallavi Kadam
2020-10-08 21:50             ` Tal Shnaiderman
2020-10-09  2:12             ` Narcisa Ana Maria Vasile
2020-10-14 20:27               ` Thomas Monjalon

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20200911015947.20044-1-pallavi.kadam@intel.com \
    --to=pallavi.kadam@intel.com \
    --cc=Narcisa.Vasile@microsoft.com \
    --cc=dev@dpdk.org \
    --cc=dmitry.kozliuk@gmail.com \
    --cc=ranjit.menon@intel.com \
    --cc=talshn@nvidia.com \
    --cc=thomas@monjalon.net \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ https://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git