From: Shreyansh Jain <shreyansh.jain@nxp.com>
Date: Fri, 25 Aug 2017 10:19:54 +0000 (+0530)
Subject: bus/fslmc: refactor scan and probe functions
X-Git-Tag: spdx-start~2122
X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=828d51d8fc3e;p=dpdk.git

bus/fslmc: refactor scan and probe functions

Scan now searches for devices through sysfs interface and adds them
to a list for later initialization. During probe, each device is
initialized accroding to its property.

Signed-off-by: Shreyansh Jain <shreyansh.jain@nxp.com>
Reviewed-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
---

diff --git a/drivers/bus/fslmc/fslmc_bus.c b/drivers/bus/fslmc/fslmc_bus.c
index f71598d579..d50c303ba7 100644
--- a/drivers/bus/fslmc/fslmc_bus.c
+++ b/drivers/bus/fslmc/fslmc_bus.c
@@ -42,32 +42,170 @@
 #include <rte_memcpy.h>
 #include <rte_ethdev.h>
 
-#include "rte_fslmc.h"
-#include "fslmc_vfio.h"
+#include <rte_fslmc.h>
+#include <fslmc_vfio.h>
 
 #define FSLMC_BUS_LOG(level, fmt, args...) \
-	RTE_LOG(level, EAL, "%s(): " fmt "\n", __func__, ##args)
+	RTE_LOG(level, EAL, fmt "\n", ##args)
+
+#define VFIO_IOMMU_GROUP_PATH "/sys/kernel/iommu_groups"
 
 struct rte_fslmc_bus rte_fslmc_bus;
 
+static void
+cleanup_fslmc_device_list(void)
+{
+	struct rte_dpaa2_device *dev;
+	struct rte_dpaa2_device *t_dev;
+
+	TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, t_dev) {
+		TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
+		free(dev);
+		dev = NULL;
+	}
+}
+
+static int
+scan_one_fslmc_device(char *dev_name)
+{
+	char *dup_dev_name, *t_ptr;
+	struct rte_dpaa2_device *dev;
+
+	if (!dev_name)
+		return -1;
+
+	/* Ignore the Container name itself */
+	if (!strncmp("dprc", dev_name, 4))
+		return 0;
+
+	/* Creating a temporary copy to perform cut-parse over string */
+	dup_dev_name = strdup(dev_name);
+	if (!dup_dev_name) {
+		FSLMC_BUS_LOG(ERR, "Out of memory.");
+		return -ENOMEM;
+	}
+
+	/* For all other devices, we allocate rte_dpaa2_device.
+	 * For those devices where there is no driver, probe would release
+	 * the memory associated with the rte_dpaa2_device after necessary
+	 * initialization.
+	 */
+	dev = calloc(1, sizeof(struct rte_dpaa2_device));
+	if (!dev) {
+		FSLMC_BUS_LOG(ERR, "Out of memory.");
+		free(dup_dev_name);
+		return -ENOMEM;
+	}
+
+	/* Parse the device name and ID */
+	t_ptr = strtok(dup_dev_name, ".");
+	if (!t_ptr) {
+		FSLMC_BUS_LOG(ERR, "Incorrect device string observed.");
+		goto cleanup;
+	}
+	if (!strncmp("dpni", t_ptr, 4))
+		dev->dev_type = DPAA2_ETH;
+	else if (!strncmp("dpseci", t_ptr, 6))
+		dev->dev_type = DPAA2_CRYPTO;
+	else if (!strncmp("dpcon", t_ptr, 5))
+		dev->dev_type = DPAA2_CON;
+	else if (!strncmp("dpbp", t_ptr, 4))
+		dev->dev_type = DPAA2_BPOOL;
+	else if (!strncmp("dpio", t_ptr, 4))
+		dev->dev_type = DPAA2_IO;
+	else if (!strncmp("dpci", t_ptr, 5))
+		dev->dev_type = DPAA2_CI;
+	else if (!strncmp("dpmcp", t_ptr, 5))
+		dev->dev_type = DPAA2_MPORTAL;
+	else
+		dev->dev_type = DPAA2_UNKNOWN;
+
+	t_ptr = strtok(NULL, ".");
+	if (!t_ptr) {
+		FSLMC_BUS_LOG(ERR, "Incorrect device string observed (%s).",
+			      t_ptr);
+		goto cleanup;
+	}
+
+	sscanf(t_ptr, "%hu", &dev->object_id);
+	dev->device.name = strdup(dev_name);
+	if (!dev->device.name) {
+		FSLMC_BUS_LOG(ERR, "Out of memory.");
+		goto cleanup;
+	}
+
+	/* Add device in the fslmc device list */
+	TAILQ_INSERT_TAIL(&rte_fslmc_bus.device_list, dev, next);
+
+	/* Don't need the duplicated device filesystem entry anymore */
+	if (dup_dev_name)
+		free(dup_dev_name);
+
+	return 0;
+cleanup:
+	if (dup_dev_name)
+		free(dup_dev_name);
+	if (dev)
+		free(dev);
+	return -1;
+}
+
 static int
 rte_fslmc_scan(void)
 {
 	int ret;
+	int device_count = 0;
+	char fslmc_dirpath[PATH_MAX];
+	DIR *dir;
+	struct dirent *entry;
+	static int process_once;
+	int groupid;
 
-	ret = fslmc_vfio_setup_group();
-	if (ret) {
-		FSLMC_BUS_LOG(ERR, "fslmc: Unable to setup VFIO");
-		return ret;
+	if (process_once) {
+		FSLMC_BUS_LOG(DEBUG,
+			      "Fslmc bus already scanned. Not rescanning");
+		return 0;
 	}
+	process_once = 1;
 
-	ret = fslmc_vfio_process_group();
-	if (ret) {
-		FSLMC_BUS_LOG(ERR, "fslmc: Unable to setup devices");
-		return -1;
+	ret = fslmc_get_container_group(&groupid);
+	if (ret != 0)
+		goto scan_fail;
+
+	/* Scan devices on the group */
+	sprintf(fslmc_dirpath, "%s/%d/devices", VFIO_IOMMU_GROUP_PATH,
+		groupid);
+	dir = opendir(fslmc_dirpath);
+	if (!dir) {
+		FSLMC_BUS_LOG(ERR, "Unable to open VFIO group dir.");
+		goto scan_fail;
 	}
 
-	RTE_LOG(INFO, EAL, "fslmc: Bus scan completed\n");
+	while ((entry = readdir(dir)) != NULL) {
+		if (entry->d_name[0] == '.' || entry->d_type != DT_LNK)
+			continue;
+
+		ret = scan_one_fslmc_device(entry->d_name);
+		if (ret != 0) {
+			/* Error in parsing directory - exit gracefully */
+			goto scan_fail_cleanup;
+		}
+		device_count += 1;
+	}
+
+	FSLMC_BUS_LOG(INFO, "fslmc: Bus scan completed");
+
+	closedir(dir);
+	return 0;
+
+scan_fail_cleanup:
+	closedir(dir);
+
+	/* Remove all devices in the list */
+	cleanup_fslmc_device_list();
+scan_fail:
+	FSLMC_BUS_LOG(DEBUG, "FSLMC Bus Not Available. Skipping.");
+	/* Irrespective of failure, scan only return success */
 	return 0;
 }
 
@@ -88,6 +226,21 @@ rte_fslmc_probe(void)
 	struct rte_dpaa2_device *dev;
 	struct rte_dpaa2_driver *drv;
 
+	if (TAILQ_EMPTY(&rte_fslmc_bus.device_list))
+		return 0;
+
+	ret = fslmc_vfio_setup_group();
+	if (ret) {
+		FSLMC_BUS_LOG(ERR, "Unable to setup VFIO %d", ret);
+		return 0;
+	}
+
+	ret = fslmc_vfio_process_group();
+	if (ret) {
+		FSLMC_BUS_LOG(ERR, "Unable to setup devices %d", ret);
+		return 0;
+	}
+
 	TAILQ_FOREACH(dev, &rte_fslmc_bus.device_list, next) {
 		TAILQ_FOREACH(drv, &rte_fslmc_bus.driver_list, next) {
 			ret = rte_fslmc_match(drv, dev);
@@ -103,7 +256,8 @@ rte_fslmc_probe(void)
 			break;
 		}
 	}
-	return ret;
+
+	return 0;
 }
 
 static struct rte_device *
diff --git a/drivers/bus/fslmc/fslmc_vfio.c b/drivers/bus/fslmc/fslmc_vfio.c
index f0d69a9dc8..a1309b3a4f 100644
--- a/drivers/bus/fslmc/fslmc_vfio.c
+++ b/drivers/bus/fslmc/fslmc_vfio.c
@@ -63,18 +63,20 @@
 #include "portal/dpaa2_hw_dpio.h"
 
 #define FSLMC_VFIO_LOG(level, fmt, args...) \
-	RTE_LOG(level, EAL, "%s(): " fmt "\n", __func__, ##args)
+	RTE_LOG(level, EAL, fmt "\n", ##args)
 
 /** Pathname of FSL-MC devices directory. */
 #define SYSFS_FSL_MC_DEVICES "/sys/bus/fsl-mc/devices"
 
+#define FSLMC_CONTAINER_MAX_LEN 8 /**< Of the format dprc.XX */
+
 /* Number of VFIO containers & groups with in */
 static struct fslmc_vfio_group vfio_group;
 static struct fslmc_vfio_container vfio_container;
 static int container_device_fd;
+static char *g_container;
 static uint32_t *msi_intr_vaddr;
 void *(*rte_mcp_ptr_list);
-static uint32_t mcp_id;
 static int is_dma_done;
 
 static struct rte_dpaa2_object_list dpaa2_obj_list =
@@ -89,10 +91,56 @@ rte_fslmc_object_register(struct rte_dpaa2_object *object)
 	TAILQ_INSERT_TAIL(&dpaa2_obj_list, object, next);
 }
 
-static int vfio_connect_container(void)
+int
+fslmc_get_container_group(int *groupid)
+{
+	int ret;
+	char *container;
+
+	if (!g_container) {
+		container = getenv("DPRC");
+		if (container == NULL) {
+			RTE_LOG(WARNING, EAL, "DPAA2: DPRC not available\n");
+			return -EINVAL;
+		}
+
+		if (strlen(container) >= FSLMC_CONTAINER_MAX_LEN) {
+			FSLMC_VFIO_LOG(ERR, "Invalid container name: %s\n",
+				       container);
+			return -1;
+		}
+
+		g_container = strdup(container);
+		if (!g_container) {
+			FSLMC_VFIO_LOG(ERR, "Out of memory.");
+			return -ENOMEM;
+		}
+	}
+
+	/* get group number */
+	ret = vfio_get_group_no(SYSFS_FSL_MC_DEVICES, g_container, groupid);
+	if (ret <= 0) {
+		FSLMC_VFIO_LOG(ERR, "Unable to find %s IOMMU group",
+			       g_container);
+		return -1;
+	}
+
+	FSLMC_VFIO_LOG(DEBUG, "Container: %s has VFIO iommu group id = %d",
+		       g_container, *groupid);
+
+	return 0;
+}
+
+static int
+vfio_connect_container(void)
 {
 	int fd, ret;
 
+	if (vfio_container.used) {
+		FSLMC_VFIO_LOG(DEBUG, "No container available.");
+		return -1;
+	}
+
 	/* Try connecting to vfio container if already created */
 	if (!ioctl(vfio_group.fd, VFIO_GROUP_SET_CONTAINER,
 		&vfio_container.fd)) {
@@ -284,48 +332,6 @@ MC_FAILURE:
 	return v_addr;
 }
 
-static inline int
-dpaa2_compare_dpaa2_dev(const struct rte_dpaa2_device *dev,
-			 const struct rte_dpaa2_device *dev2)
-{
-	/*not the same family device */
-	if (dev->dev_type != DPAA2_ETH ||
-			dev->dev_type != DPAA2_CRYPTO)
-		return -1;
-
-	if (dev->object_id == dev2->object_id)
-		return 0;
-	else
-		return 1;
-}
-
-static void
-fslmc_bus_add_device(struct rte_dpaa2_device *dev)
-{
-	struct rte_fslmc_device_list *dev_l;
-
-	dev_l = &rte_fslmc_bus.device_list;
-
-	/* device is valid, add in list (sorted) */
-	if (TAILQ_EMPTY(dev_l)) {
-		TAILQ_INSERT_TAIL(dev_l, dev, next);
-	} else {
-		struct rte_dpaa2_device *dev2;
-		int ret;
-
-		TAILQ_FOREACH(dev2, dev_l, next) {
-			ret = dpaa2_compare_dpaa2_dev(dev, dev2);
-			if (ret <= 0)
-				continue;
-
-			TAILQ_INSERT_BEFORE(dev2, dev, next);
-			return;
-		}
-
-		TAILQ_INSERT_TAIL(dev_l, dev, next);
-	}
-}
-
 #define IRQ_SET_BUF_LEN  (sizeof(struct vfio_irq_set) + sizeof(int))
 
 int rte_dpaa2_intr_enable(struct rte_intr_handle *intr_handle,
@@ -360,283 +366,240 @@ int rte_dpaa2_intr_enable(struct rte_intr_handle *intr_handle,
 	return 0;
 }
 
-/* Following function shall fetch total available list of MC devices
- * from VFIO container & populate private list of devices and other
- * data structures
+/*
+ * fslmc_process_iodevices for processing only IO (ETH, CRYPTO, and possibly
+ * EVENT) devices.
  */
-int fslmc_vfio_process_group(void)
+static int
+fslmc_process_iodevices(struct rte_dpaa2_device *dev)
 {
-	struct fslmc_vfio_device *vdev;
+	int dev_fd;
 	struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
-	char *temp_obj, *object_type, *mcp_obj, *dev_name;
-	int32_t object_id, i, dev_fd, ret;
-	DIR *d;
-	struct dirent *dir;
-	char path[PATH_MAX];
-	int64_t v_addr;
-	int ndev_count;
-	struct fslmc_vfio_group *group = &vfio_group;
-	static int process_once;
+	struct rte_dpaa2_object *object = NULL;
 
-	/* if already done once */
-	if (process_once) {
-		FSLMC_VFIO_LOG(DEBUG,
-			       "Already scanned once - re-scan not supported");
-		return 0;
+	dev_fd = ioctl(vfio_group.fd, VFIO_GROUP_GET_DEVICE_FD,
+		       dev->device.name);
+	if (dev_fd <= 0) {
+		FSLMC_VFIO_LOG(ERR, "Unable to obtain device FD for device:%s",
+			       dev->device.name);
+		return -1;
 	}
-	process_once = 0;
-
-	sprintf(path, "/sys/kernel/iommu_groups/%d/devices", group->groupid);
 
-	d = opendir(path);
-	if (!d) {
-		FSLMC_VFIO_LOG(ERR, "Unable to open directory %s", path);
+	if (ioctl(dev_fd, VFIO_DEVICE_GET_INFO, &device_info)) {
+		FSLMC_VFIO_LOG(ERR, "DPAA2 VFIO_DEVICE_GET_INFO fail");
 		return -1;
 	}
 
-	/*Counting the number of devices in a group and getting the mcp ID*/
-	ndev_count = 0;
-	mcp_obj = NULL;
-	while ((dir = readdir(d)) != NULL) {
-		if (dir->d_type == DT_LNK) {
-			ndev_count++;
-			if (!strncmp("dpmcp", dir->d_name, 5)) {
-				if (mcp_obj)
-					free(mcp_obj);
-				mcp_obj = malloc(sizeof(dir->d_name));
-				if (!mcp_obj) {
-					FSLMC_VFIO_LOG(ERR,
-						       "mcp obj:alloc failed");
-					closedir(d);
-					return -ENOMEM;
-				}
-				strcpy(mcp_obj, dir->d_name);
-				temp_obj = strtok(dir->d_name, ".");
-				temp_obj = strtok(NULL, ".");
-				sscanf(temp_obj, "%d", &mcp_id);
-			}
+	switch (dev->dev_type) {
+	case DPAA2_CON:
+	case DPAA2_IO:
+	case DPAA2_CI:
+	case DPAA2_BPOOL:
+		TAILQ_FOREACH(object, &dpaa2_obj_list, next) {
+			if (dev->dev_type == object->dev_type)
+				object->create(dev_fd, &device_info,
+					       dev->object_id);
+			else
+				continue;
 		}
-	}
-	closedir(d);
-	d = NULL;
-	if (!mcp_obj) {
-		FSLMC_VFIO_LOG(ERR, "DPAA2 MCP Object not Found");
-		return -ENODEV;
-	}
-	RTE_LOG(INFO, EAL, "fslmc: DPRC contains = %d devices\n", ndev_count);
-
-	/* Allocate the memory depends upon number of objects in a group*/
-	group->vfio_device = (struct fslmc_vfio_device *)malloc(ndev_count *
-			     sizeof(struct fslmc_vfio_device));
-	if (!(group->vfio_device)) {
-		FSLMC_VFIO_LOG(ERR, "vfio device: Unable to allocate memory\n");
-		free(mcp_obj);
-		return -ENOMEM;
+		break;
+	default:
+		break;
 	}
 
-	/* Allocate memory for MC Portal list */
+	FSLMC_VFIO_LOG(DEBUG, "Device (%s) abstracted from VFIO",
+		       dev->device.name);
+	return 0;
+}
+
+static int
+fslmc_process_mcp(struct rte_dpaa2_device *dev)
+{
+	int64_t v_addr;
+	char *dev_name;
+
 	rte_mcp_ptr_list = malloc(sizeof(void *) * 1);
 	if (!rte_mcp_ptr_list) {
-		FSLMC_VFIO_LOG(ERR, "portal list: Unable to allocate memory!");
-		free(mcp_obj);
-		goto FAILURE;
+		FSLMC_VFIO_LOG(ERR, "Out of memory");
+		return -ENOMEM;
 	}
 
-	v_addr = vfio_map_mcp_obj(group, mcp_obj);
-	free(mcp_obj);
-	if (v_addr == (int64_t)MAP_FAILED) {
-		FSLMC_VFIO_LOG(ERR, "Error mapping region (errno = %d)", errno);
-		goto FAILURE;
+	dev_name = strdup(dev->device.name);
+	if (!dev_name) {
+		FSLMC_VFIO_LOG(ERR, "Out of memory.");
+		free(rte_mcp_ptr_list);
+		rte_mcp_ptr_list = NULL;
+		return -ENOMEM;
 	}
 
-	rte_mcp_ptr_list[0] = (void *)v_addr;
-
-	d = opendir(path);
-	if (!d) {
-		FSLMC_VFIO_LOG(ERR, "Unable to open %s Directory", path);
-		goto FAILURE;
+	v_addr = vfio_map_mcp_obj(&vfio_group, dev_name);
+	if (v_addr == (int64_t)MAP_FAILED) {
+		FSLMC_VFIO_LOG(ERR, "Error mapping region  (errno = %d)",
+			       errno);
+		free(rte_mcp_ptr_list);
+		rte_mcp_ptr_list = NULL;
+		return -1;
 	}
 
-	i = 0;
-	/* Parsing each object and initiating them*/
-	while ((dir = readdir(d)) != NULL) {
-		if (dir->d_type != DT_LNK)
-			continue;
-		if (!strncmp("dprc", dir->d_name, 4) ||
-		    !strncmp("dpmcp", dir->d_name, 5))
-			continue;
-		dev_name = malloc(sizeof(dir->d_name));
-		if (!dev_name) {
-			FSLMC_VFIO_LOG(ERR, "name: Unable to allocate memory");
-			goto FAILURE;
-		}
-		strcpy(dev_name, dir->d_name);
-		object_type = strtok(dir->d_name, ".");
-		temp_obj = strtok(NULL, ".");
-		sscanf(temp_obj, "%d", &object_id);
-
-		/* getting the device fd*/
-		dev_fd = ioctl(group->fd, VFIO_GROUP_GET_DEVICE_FD, dev_name);
-		if (dev_fd < 0) {
-			FSLMC_VFIO_LOG(ERR,
-				       "GET_DEVICE_FD error fd: %s, Group: %d",
-				       dev_name, group->fd);
-			free(dev_name);
-			goto FAILURE;
-		}
+	rte_mcp_ptr_list[0] = (void *)v_addr;
 
-		free(dev_name);
-		vdev = &group->vfio_device[group->object_index++];
-		vdev->fd = dev_fd;
-		vdev->index = i;
-		i++;
-		/* Get Device inofrmation */
-		if (ioctl(vdev->fd, VFIO_DEVICE_GET_INFO, &device_info)) {
-			FSLMC_VFIO_LOG(ERR, "DPAA2 VFIO_DEVICE_GET_INFO fail");
-			goto FAILURE;
-		}
-		if (!strcmp(object_type, "dpni") ||
-		    !strcmp(object_type, "dpseci")) {
-			struct rte_dpaa2_device *dev;
+	return 0;
+}
 
-			dev = malloc(sizeof(struct rte_dpaa2_device));
-			if (dev == NULL)
+int
+fslmc_vfio_process_group(void)
+{
+	int ret;
+	int found_mportal = 0;
+	struct rte_dpaa2_device *dev, *dev_temp;
+
+	/* Search the MCP as that should be initialized first. */
+	TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
+		if (dev->dev_type == DPAA2_MPORTAL) {
+			ret = fslmc_process_mcp(dev);
+			if (ret) {
+				FSLMC_VFIO_LOG(DEBUG, "Unable to map Portal.");
 				return -1;
-
-			memset(dev, 0, sizeof(*dev));
-			/* store hw_id of dpni/dpseci device */
-			dev->object_id = object_id;
-			dev->dev_type = (strcmp(object_type, "dpseci")) ?
-				DPAA2_ETH : DPAA2_CRYPTO;
-
-			sprintf(dev->name, "%s.%d", object_type, object_id);
-			dev->device.name = dev->name;
-
-			fslmc_bus_add_device(dev);
-			FSLMC_VFIO_LOG(DEBUG, "DPAA2: Added %s", dev->name);
-		} else {
-			/* Parse all other objects */
-			struct rte_dpaa2_object *object;
-
-			TAILQ_FOREACH(object, &dpaa2_obj_list, next) {
-				if (!strcmp(object_type, object->name))
-					object->create(dev_fd, &device_info,
-						       object_id);
-				else
-					continue;
 			}
+			if (!found_mportal)
+				found_mportal = 1;
+
+			TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
+			free(dev);
+			dev = NULL;
+			/* Ideally there is only a single dpmcp, but in case
+			 * multiple exists, looping on remaining devices.
+			 */
 		}
 	}
-	closedir(d);
 
-	ret = dpaa2_affine_qbman_swp();
-	if (ret)
-		FSLMC_VFIO_LOG(DEBUG, "Error in affining qbman swp %d", ret);
+	/* Cannot continue if there is not even a single mportal */
+	if (!found_mportal) {
+		FSLMC_VFIO_LOG(DEBUG,
+			       "No MC Portal device found. Not continuing.");
+		return -1;
+	}
 
-	return 0;
+	TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
+		if (!dev)
+			break;
 
-FAILURE:
-	if (d)
-		closedir(d);
-	if (rte_mcp_ptr_list) {
-		free(rte_mcp_ptr_list);
-		rte_mcp_ptr_list = NULL;
+		switch (dev->dev_type) {
+		case DPAA2_ETH:
+		case DPAA2_CRYPTO:
+			ret = fslmc_process_iodevices(dev);
+			if (ret) {
+				FSLMC_VFIO_LOG(DEBUG,
+					       "Dev (%s) init failed.",
+					       dev->device.name);
+				return ret;
+			}
+			break;
+		case DPAA2_CON:
+		case DPAA2_IO:
+		case DPAA2_CI:
+		case DPAA2_BPOOL:
+			/* Call the object creation routine and remove the
+			 * device entry from device list
+			 */
+			ret = fslmc_process_iodevices(dev);
+			if (ret) {
+				FSLMC_VFIO_LOG(DEBUG,
+					       "Dev (%s) init failed.",
+					       dev->device.name);
+				return -1;
+			}
+
+			/* This device is not required to be in the DPDK
+			 * exposed device list.
+			 */
+			TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
+			free(dev);
+			dev = NULL;
+			break;
+		case DPAA2_UNKNOWN:
+		default:
+			/* Unknown - ignore */
+			FSLMC_VFIO_LOG(DEBUG, "Found unknown device (%s).",
+				       dev->device.name);
+			TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
+			free(dev);
+			dev = NULL;
+		}
 	}
 
-	free(group->vfio_device);
-	group->vfio_device = NULL;
-	return -1;
+	return 0;
 }
 
-int fslmc_vfio_setup_group(void)
+int
+fslmc_vfio_setup_group(void)
 {
-	struct fslmc_vfio_group *group = NULL;
 	int groupid;
 	int ret;
-	char *container;
 	struct vfio_group_status status = { .argsz = sizeof(status) };
 
 	/* if already done once */
 	if (container_device_fd)
 		return 0;
 
-	container = getenv("DPRC");
-
-	if (container == NULL) {
-		FSLMC_VFIO_LOG(ERR, "VFIO container not set in env DPRC");
-		return -EOPNOTSUPP;
-	}
-
-	/* get group number */
-	ret = vfio_get_group_no(SYSFS_FSL_MC_DEVICES, container, &groupid);
-	if (ret == 0) {
-		RTE_LOG(WARNING, EAL, "%s not managed by VFIO, skipping\n",
-			container);
-		return -EOPNOTSUPP;
-	}
-
-	/* if negative, something failed */
-	if (ret < 0)
+	ret = fslmc_get_container_group(&groupid);
+	if (ret)
 		return ret;
 
-	FSLMC_VFIO_LOG(DEBUG, "VFIO iommu group id = %d", groupid);
-
-	/* Check if group already exists */
-	group = &vfio_group;
-	if (group->groupid == groupid) {
-		FSLMC_VFIO_LOG(ERR, "groupid already exists %d",
-			       groupid);
+	/* In case this group was already opened, continue without any
+	 * processing.
+	 */
+	if (vfio_group.groupid == groupid) {
+		FSLMC_VFIO_LOG(ERR, "groupid already exists %d", groupid);
 		return 0;
 	}
 
-	/* get the actual group fd */
+	/* Get the actual group fd */
 	ret = vfio_get_group_fd(groupid);
 	if (ret < 0)
 		return ret;
-	group->fd = ret;
+	vfio_group.fd = ret;
 
-	/*
-	 * at this point, we know that this group is viable (meaning,
-	 * all devices are either bound to VFIO or not bound to anything)
-	 */
-
-	ret = ioctl(group->fd, VFIO_GROUP_GET_STATUS, &status);
+	/* Check group viability */
+	ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_STATUS, &status);
 	if (ret) {
-		FSLMC_VFIO_LOG(ERR, " VFIO error getting group status");
-		close(group->fd);
+		FSLMC_VFIO_LOG(ERR, "VFIO error getting group status");
+		close(vfio_group.fd);
 		return ret;
 	}
 
 	if (!(status.flags & VFIO_GROUP_FLAGS_VIABLE)) {
 		FSLMC_VFIO_LOG(ERR, "VFIO group not viable");
-		close(group->fd);
+		close(vfio_group.fd);
 		return -EPERM;
 	}
 	/* Since Group is VIABLE, Store the groupid */
-	group->groupid = groupid;
+	vfio_group.groupid = groupid;
 
 	/* check if group does not have a container yet */
 	if (!(status.flags & VFIO_GROUP_FLAGS_CONTAINER_SET)) {
 		/* Now connect this IOMMU group to given container */
 		ret = vfio_connect_container();
 		if (ret) {
-			FSLMC_VFIO_LOG(ERR, "VFIO error connecting container"
-				       " with groupid %d", groupid);
-			close(group->fd);
+			FSLMC_VFIO_LOG(ERR,
+				"Error connecting container with groupid %d",
+				groupid);
+			close(vfio_group.fd);
 			return ret;
 		}
 	}
 
 	/* Get Device information */
-	ret = ioctl(group->fd, VFIO_GROUP_GET_DEVICE_FD, container);
+	ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_DEVICE_FD, g_container);
 	if (ret < 0) {
-		FSLMC_VFIO_LOG(ERR, "VFIO error getting device %s fd from"
-			       " group  %d", container, group->groupid);
+		FSLMC_VFIO_LOG(ERR, "Error getting device %s fd from group %d",
+			       g_container, vfio_group.groupid);
+		close(vfio_group.fd);
 		return ret;
 	}
 	container_device_fd = ret;
 	FSLMC_VFIO_LOG(DEBUG, "VFIO Container FD is [0x%X]",
-		     container_device_fd);
+		       container_device_fd);
 
 	return 0;
 }
diff --git a/drivers/bus/fslmc/fslmc_vfio.h b/drivers/bus/fslmc/fslmc_vfio.h
index 60a57434f0..edb86d04da 100644
--- a/drivers/bus/fslmc/fslmc_vfio.h
+++ b/drivers/bus/fslmc/fslmc_vfio.h
@@ -36,7 +36,6 @@
 
 #include "eal_vfio.h"
 
-#define DPAA2_VENDOR_ID		0x1957
 #define DPAA2_MC_DPNI_DEVID	7
 #define DPAA2_MC_DPSECI_DEVID	3
 #define DPAA2_MC_DPCON_DEVID	5
@@ -44,7 +43,6 @@
 #define DPAA2_MC_DPBP_DEVID	10
 #define DPAA2_MC_DPCI_DEVID	11
 
-
 typedef struct fslmc_vfio_device {
 	int fd; /* fslmc root container device ?? */
 	int index; /*index of child object */
@@ -71,6 +69,8 @@ int rte_dpaa2_intr_enable(struct rte_intr_handle *intr_handle,
 
 int fslmc_vfio_setup_group(void);
 int fslmc_vfio_process_group(void);
+char *fslmc_get_container(void);
+int fslmc_get_container_group(int *gropuid);
 int rte_fslmc_vfio_dmamap(void);
 
 #endif /* _FSLMC_VFIO_H_ */
diff --git a/drivers/bus/fslmc/portal/dpaa2_hw_dpio.c b/drivers/bus/fslmc/portal/dpaa2_hw_dpio.c
index da4184913d..7315555169 100644
--- a/drivers/bus/fslmc/portal/dpaa2_hw_dpio.c
+++ b/drivers/bus/fslmc/portal/dpaa2_hw_dpio.c
@@ -59,7 +59,6 @@
 #include <rte_dev.h>
 
 #include <fslmc_logs.h>
-#include <fslmc_vfio.h>
 #include <rte_fslmc.h>
 #include "dpaa2_hw_pvt.h"
 #include "dpaa2_hw_dpio.h"
diff --git a/drivers/bus/fslmc/rte_fslmc.h b/drivers/bus/fslmc/rte_fslmc.h
index 2f684d9ce4..4c32db6270 100644
--- a/drivers/bus/fslmc/rte_fslmc.h
+++ b/drivers/bus/fslmc/rte_fslmc.h
@@ -56,6 +56,9 @@ extern "C" {
 #include <rte_interrupts.h>
 #include <rte_dev.h>
 #include <rte_bus.h>
+#include <rte_tailq.h>
+
+#include <fslmc_vfio.h>
 
 #define FSLMC_OBJECT_MAX_LEN 32   /**< Length of each device on bus */