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;
+}
