drivers/bus/fslmc/fslmc_vfio.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  *   Copyright (c) 2015-2016 Freescale Semiconductor, Inc. All rights reserved.
   4  *   Copyright 2016 NXP
   5  *
   6  */
   7
   8 #include <unistd.h>
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <fcntl.h>
  14 #include <errno.h>
  15 #include <sys/ioctl.h>
  16 #include <sys/stat.h>
  17 #include <sys/mman.h>
  18 #include <sys/vfs.h>
  19 #include <libgen.h>
  20 #include <dirent.h>
  21 #include <sys/eventfd.h>
  22
  23 #include <eal_filesystem.h>
  24 #include <rte_mbuf.h>
  25 #include <rte_ethdev_driver.h>
  26 #include <rte_malloc.h>
  27 #include <rte_memcpy.h>
  28 #include <rte_string_fns.h>
  29 #include <rte_cycles.h>
  30 #include <rte_kvargs.h>
  31 #include <rte_dev.h>
  32 #include <rte_bus.h>
  33
  34 #include "rte_fslmc.h"
  35 #include "fslmc_vfio.h"
  36 #include <mc/fsl_dpmng.h>
  37
  38 #include "portal/dpaa2_hw_pvt.h"
  39 #include "portal/dpaa2_hw_dpio.h"
  40
  41 #define FSLMC_VFIO_LOG(level, fmt, args...) \
  42         RTE_LOG(level, EAL, fmt "\n", ##args)
  43
  44 /** Pathname of FSL-MC devices directory. */
  45 #define SYSFS_FSL_MC_DEVICES "/sys/bus/fsl-mc/devices"
  46
  47 #define FSLMC_CONTAINER_MAX_LEN 8 /**< Of the format dprc.XX */
  48
  49 /* Number of VFIO containers & groups with in */
  50 static struct fslmc_vfio_group vfio_group;
  51 static struct fslmc_vfio_container vfio_container;
  52 static int container_device_fd;
  53 static char *g_container;
  54 static uint32_t *msi_intr_vaddr;
  55 void *(*rte_mcp_ptr_list);
  56 static int is_dma_done;
  57
  58 static struct rte_dpaa2_object_list dpaa2_obj_list =
  59         TAILQ_HEAD_INITIALIZER(dpaa2_obj_list);
  60
  61 /*register a fslmc bus based dpaa2 driver */
  62 void
  63 rte_fslmc_object_register(struct rte_dpaa2_object *object)
  64 {
  65         RTE_VERIFY(object);
  66
  67         TAILQ_INSERT_TAIL(&dpaa2_obj_list, object, next);
  68 }
  69
  70 int
  71 fslmc_get_container_group(int *groupid)
  72 {
  73         int ret;
  74         char *container;
  75
  76         if (!g_container) {
  77                 container = getenv("DPRC");
  78                 if (container == NULL) {
  79                         RTE_LOG(WARNING, EAL, "DPAA2: DPRC not available\n");
  80                         return -EINVAL;
  81                 }
  82
  83                 if (strlen(container) >= FSLMC_CONTAINER_MAX_LEN) {
  84                         FSLMC_VFIO_LOG(ERR, "Invalid container name: %s\n",
  85                                        container);
  86                         return -1;
  87                 }
  88
  89                 g_container = strdup(container);
  90                 if (!g_container) {
  91                         FSLMC_VFIO_LOG(ERR, "Out of memory.");
  92                         return -ENOMEM;
  93                 }
  94         }
  95
  96         /* get group number */
  97         ret = vfio_get_group_no(SYSFS_FSL_MC_DEVICES, g_container, groupid);
  98         if (ret <= 0) {
  99                 FSLMC_VFIO_LOG(ERR, "Unable to find %s IOMMU group",
 100                                g_container);
 101                 return -1;
 102         }
 103
 104         FSLMC_VFIO_LOG(DEBUG, "Container: %s has VFIO iommu group id = %d",
 105                        g_container, *groupid);
 106
 107         return 0;
 108 }
 109
 110 static int
 111 vfio_connect_container(void)
 112 {
 113         int fd, ret;
 114
 115         if (vfio_container.used) {
 116                 FSLMC_VFIO_LOG(DEBUG, "No container available.");
 117                 return -1;
 118         }
 119
 120         /* Try connecting to vfio container if already created */
 121         if (!ioctl(vfio_group.fd, VFIO_GROUP_SET_CONTAINER,
 122                 &vfio_container.fd)) {
 123                 FSLMC_VFIO_LOG(INFO,
 124                     "Container pre-exists with FD[0x%x] for this group",
 125                     vfio_container.fd);
 126                 vfio_group.container = &vfio_container;
 127                 return 0;
 128         }
 129
 130         /* Opens main vfio file descriptor which represents the "container" */
 131         fd = vfio_get_container_fd();
 132         if (fd < 0) {
 133                 FSLMC_VFIO_LOG(ERR, "Failed to open VFIO container");
 134                 return -errno;
 135         }
 136
 137         /* Check whether support for SMMU type IOMMU present or not */
 138         if (ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1_IOMMU)) {
 139                 /* Connect group to container */
 140                 ret = ioctl(vfio_group.fd, VFIO_GROUP_SET_CONTAINER, &fd);
 141                 if (ret) {
 142                         FSLMC_VFIO_LOG(ERR, "Failed to setup group container");
 143                         close(fd);
 144                         return -errno;
 145                 }
 146
 147                 ret = ioctl(fd, VFIO_SET_IOMMU, VFIO_TYPE1_IOMMU);
 148                 if (ret) {
 149                         FSLMC_VFIO_LOG(ERR, "Failed to setup VFIO iommu");
 150                         close(fd);
 151                         return -errno;
 152                 }
 153         } else {
 154                 FSLMC_VFIO_LOG(ERR, "No supported IOMMU available");
 155                 close(fd);
 156                 return -EINVAL;
 157         }
 158
 159         vfio_container.used = 1;
 160         vfio_container.fd = fd;
 161         vfio_container.group = &vfio_group;
 162         vfio_group.container = &vfio_container;
 163
 164         return 0;
 165 }
 166
 167 static int vfio_map_irq_region(struct fslmc_vfio_group *group)
 168 {
 169         int ret;
 170         unsigned long *vaddr = NULL;
 171         struct vfio_iommu_type1_dma_map map = {
 172                 .argsz = sizeof(map),
 173                 .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
 174                 .vaddr = 0x6030000,
 175                 .iova = 0x6030000,
 176                 .size = 0x1000,
 177         };
 178
 179         vaddr = (unsigned long *)mmap(NULL, 0x1000, PROT_WRITE |
 180                 PROT_READ, MAP_SHARED, container_device_fd, 0x6030000);
 181         if (vaddr == MAP_FAILED) {
 182                 FSLMC_VFIO_LOG(ERR, "Unable to map region (errno = %d)", errno);
 183                 return -errno;
 184         }
 185
 186         msi_intr_vaddr = (uint32_t *)((char *)(vaddr) + 64);
 187         map.vaddr = (unsigned long)vaddr;
 188         ret = ioctl(group->container->fd, VFIO_IOMMU_MAP_DMA, &map);
 189         if (ret == 0)
 190                 return 0;
 191
 192         FSLMC_VFIO_LOG(ERR, "VFIO_IOMMU_MAP_DMA fails (errno = %d)", errno);
 193         return -errno;
 194 }
 195
 196 int rte_fslmc_vfio_dmamap(void)
 197 {
 198         int ret;
 199         struct fslmc_vfio_group *group;
 200         struct vfio_iommu_type1_dma_map dma_map = {
 201                 .argsz = sizeof(struct vfio_iommu_type1_dma_map),
 202                 .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
 203         };
 204
 205         int i;
 206         const struct rte_memseg *memseg;
 207
 208         if (is_dma_done)
 209                 return 0;
 210
 211         memseg = rte_eal_get_physmem_layout();
 212         if (memseg == NULL) {
 213                 FSLMC_VFIO_LOG(ERR, "Cannot get physical layout.");
 214                 return -ENODEV;
 215         }
 216
 217         for (i = 0; i < RTE_MAX_MEMSEG; i++) {
 218                 if (memseg[i].addr == NULL && memseg[i].len == 0) {
 219                         FSLMC_VFIO_LOG(DEBUG, "Total %d segments found.", i);
 220                         break;
 221                 }
 222
 223                 dma_map.size = memseg[i].len;
 224                 dma_map.vaddr = memseg[i].addr_64;
 225 #ifdef RTE_LIBRTE_DPAA2_USE_PHYS_IOVA
 226                 if (rte_eal_iova_mode() == RTE_IOVA_VA)
 227                         dma_map.iova = dma_map.vaddr;
 228                 else
 229                         dma_map.iova = memseg[i].iova;
 230 #else
 231                 dma_map.iova = dma_map.vaddr;
 232 #endif
 233
 234                 /* SET DMA MAP for IOMMU */
 235                 group = &vfio_group;
 236
 237                 if (!group->container) {
 238                         FSLMC_VFIO_LOG(ERR, "Container is not connected ");
 239                         return -1;
 240                 }
 241
 242                 FSLMC_VFIO_LOG(DEBUG, "-->Initial SHM Virtual ADDR %llX",
 243                              dma_map.vaddr);
 244                 FSLMC_VFIO_LOG(DEBUG, "-----> DMA size 0x%llX", dma_map.size);
 245                 ret = ioctl(group->container->fd, VFIO_IOMMU_MAP_DMA,
 246                             &dma_map);
 247                 if (ret) {
 248                         FSLMC_VFIO_LOG(ERR, "VFIO_IOMMU_MAP_DMA API(errno = %d)",
 249                                        errno);
 250                         return ret;
 251                 }
 252         }
 253
 254         /* Verifying that at least single segment is available */
 255         if (i <= 0) {
 256                 FSLMC_VFIO_LOG(ERR, "No Segments found for VFIO Mapping");
 257                 return -1;
 258         }
 259
 260         /* TODO - This is a W.A. as VFIO currently does not add the mapping of
 261          * the interrupt region to SMMU. This should be removed once the
 262          * support is added in the Kernel.
 263          */
 264         vfio_map_irq_region(group);
 265
 266         is_dma_done = 1;
 267
 268         return 0;
 269 }
 270
 271 static int64_t vfio_map_mcp_obj(struct fslmc_vfio_group *group, char *mcp_obj)
 272 {
 273         int64_t v_addr = (int64_t)MAP_FAILED;
 274         int32_t ret, mc_fd;
 275
 276         struct vfio_device_info d_info = { .argsz = sizeof(d_info) };
 277         struct vfio_region_info reg_info = { .argsz = sizeof(reg_info) };
 278
 279         /* getting the mcp object's fd*/
 280         mc_fd = ioctl(group->fd, VFIO_GROUP_GET_DEVICE_FD, mcp_obj);
 281         if (mc_fd < 0) {
 282                 FSLMC_VFIO_LOG(ERR, "error in VFIO get dev %s fd from group %d",
 283                                mcp_obj, group->fd);
 284                 return v_addr;
 285         }
 286
 287         /* getting device info*/
 288         ret = ioctl(mc_fd, VFIO_DEVICE_GET_INFO, &d_info);
 289         if (ret < 0) {
 290                 FSLMC_VFIO_LOG(ERR, "error in VFIO getting DEVICE_INFO");
 291                 goto MC_FAILURE;
 292         }
 293
 294         /* getting device region info*/
 295         ret = ioctl(mc_fd, VFIO_DEVICE_GET_REGION_INFO, &reg_info);
 296         if (ret < 0) {
 297                 FSLMC_VFIO_LOG(ERR, "error in VFIO getting REGION_INFO");
 298                 goto MC_FAILURE;
 299         }
 300
 301         FSLMC_VFIO_LOG(DEBUG, "region offset = %llx  , region size = %llx",
 302                        reg_info.offset, reg_info.size);
 303
 304         v_addr = (uint64_t)mmap(NULL, reg_info.size,
 305                 PROT_WRITE | PROT_READ, MAP_SHARED,
 306                 mc_fd, reg_info.offset);
 307
 308 MC_FAILURE:
 309         close(mc_fd);
 310
 311         return v_addr;
 312 }
 313
 314 #define IRQ_SET_BUF_LEN  (sizeof(struct vfio_irq_set) + sizeof(int))
 315
 316 int rte_dpaa2_intr_enable(struct rte_intr_handle *intr_handle, int index)
 317 {
 318         int len, ret;
 319         char irq_set_buf[IRQ_SET_BUF_LEN];
 320         struct vfio_irq_set *irq_set;
 321         int *fd_ptr;
 322
 323         len = sizeof(irq_set_buf);
 324
 325         irq_set = (struct vfio_irq_set *)irq_set_buf;
 326         irq_set->argsz = len;
 327         irq_set->count = 1;
 328         irq_set->flags =
 329                 VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER;
 330         irq_set->index = index;
 331         irq_set->start = 0;
 332         fd_ptr = (int *)&irq_set->data;
 333         *fd_ptr = intr_handle->fd;
 334
 335         ret = ioctl(intr_handle->vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set);
 336         if (ret) {
 337                 RTE_LOG(ERR, EAL, "Error:dpaa2 SET IRQs fd=%d, err = %d(%s)\n",
 338                         intr_handle->fd, errno, strerror(errno));
 339                 return ret;
 340         }
 341
 342         return ret;
 343 }
 344
 345 int rte_dpaa2_intr_disable(struct rte_intr_handle *intr_handle, int index)
 346 {
 347         struct vfio_irq_set *irq_set;
 348         char irq_set_buf[IRQ_SET_BUF_LEN];
 349         int len, ret;
 350
 351         len = sizeof(struct vfio_irq_set);
 352
 353         irq_set = (struct vfio_irq_set *)irq_set_buf;
 354         irq_set->argsz = len;
 355         irq_set->flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER;
 356         irq_set->index = index;
 357         irq_set->start = 0;
 358         irq_set->count = 0;
 359
 360         ret = ioctl(intr_handle->vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set);
 361         if (ret)
 362                 RTE_LOG(ERR, EAL,
 363                         "Error disabling dpaa2 interrupts for fd %d\n",
 364                         intr_handle->fd);
 365
 366         return ret;
 367 }
 368
 369 /* set up interrupt support (but not enable interrupts) */
 370 int
 371 rte_dpaa2_vfio_setup_intr(struct rte_intr_handle *intr_handle,
 372                           int vfio_dev_fd,
 373                           int num_irqs)
 374 {
 375         int i, ret;
 376
 377         /* start from MSI-X interrupt type */
 378         for (i = 0; i < num_irqs; i++) {
 379                 struct vfio_irq_info irq_info = { .argsz = sizeof(irq_info) };
 380                 int fd = -1;
 381
 382                 irq_info.index = i;
 383
 384                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq_info);
 385                 if (ret < 0) {
 386                         FSLMC_VFIO_LOG(ERR,
 387                                        "cannot get IRQ(%d) info, error %i (%s)",
 388                                        i, errno, strerror(errno));
 389                         return -1;
 390                 }
 391
 392                 /* if this vector cannot be used with eventfd,
 393                  * fail if we explicitly
 394                  * specified interrupt type, otherwise continue
 395                  */
 396                 if ((irq_info.flags & VFIO_IRQ_INFO_EVENTFD) == 0)
 397                         continue;
 398
 399                 /* set up an eventfd for interrupts */
 400                 fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
 401                 if (fd < 0) {
 402                         FSLMC_VFIO_LOG(ERR,
 403                                        "cannot set up eventfd, error %i (%s)\n",
 404                                        errno, strerror(errno));
 405                         return -1;
 406                 }
 407
 408                 intr_handle->fd = fd;
 409                 intr_handle->type = RTE_INTR_HANDLE_VFIO_MSI;
 410                 intr_handle->vfio_dev_fd = vfio_dev_fd;
 411
 412                 return 0;
 413         }
 414
 415         /* if we're here, we haven't found a suitable interrupt vector */
 416         return -1;
 417 }
 418
 419 /*
 420  * fslmc_process_iodevices for processing only IO (ETH, CRYPTO, and possibly
 421  * EVENT) devices.
 422  */
 423 static int
 424 fslmc_process_iodevices(struct rte_dpaa2_device *dev)
 425 {
 426         int dev_fd;
 427         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
 428         struct rte_dpaa2_object *object = NULL;
 429
 430         dev_fd = ioctl(vfio_group.fd, VFIO_GROUP_GET_DEVICE_FD,
 431                        dev->device.name);
 432         if (dev_fd <= 0) {
 433                 FSLMC_VFIO_LOG(ERR, "Unable to obtain device FD for device:%s",
 434                                dev->device.name);
 435                 return -1;
 436         }
 437
 438         if (ioctl(dev_fd, VFIO_DEVICE_GET_INFO, &device_info)) {
 439                 FSLMC_VFIO_LOG(ERR, "DPAA2 VFIO_DEVICE_GET_INFO fail");
 440                 return -1;
 441         }
 442
 443         switch (dev->dev_type) {
 444         case DPAA2_ETH:
 445                 rte_dpaa2_vfio_setup_intr(&dev->intr_handle, dev_fd,
 446                                           device_info.num_irqs);
 447                 break;
 448         case DPAA2_CON:
 449         case DPAA2_IO:
 450         case DPAA2_CI:
 451         case DPAA2_BPOOL:
 452                 TAILQ_FOREACH(object, &dpaa2_obj_list, next) {
 453                         if (dev->dev_type == object->dev_type)
 454                                 object->create(dev_fd, &device_info,
 455                                                dev->object_id);
 456                         else
 457                                 continue;
 458                 }
 459                 break;
 460         default:
 461                 break;
 462         }
 463
 464         FSLMC_VFIO_LOG(DEBUG, "Device (%s) abstracted from VFIO",
 465                        dev->device.name);
 466         return 0;
 467 }
 468
 469 static int
 470 fslmc_process_mcp(struct rte_dpaa2_device *dev)
 471 {
 472         int64_t v_addr;
 473         char *dev_name;
 474         struct fsl_mc_io dpmng  = {0};
 475         struct mc_version mc_ver_info = {0};
 476
 477         rte_mcp_ptr_list = malloc(sizeof(void *) * 1);
 478         if (!rte_mcp_ptr_list) {
 479                 FSLMC_VFIO_LOG(ERR, "Out of memory");
 480                 return -ENOMEM;
 481         }
 482
 483         dev_name = strdup(dev->device.name);
 484         if (!dev_name) {
 485                 FSLMC_VFIO_LOG(ERR, "Out of memory.");
 486                 free(rte_mcp_ptr_list);
 487                 rte_mcp_ptr_list = NULL;
 488                 return -ENOMEM;
 489         }
 490
 491         v_addr = vfio_map_mcp_obj(&vfio_group, dev_name);
 492         if (v_addr == (int64_t)MAP_FAILED) {
 493                 FSLMC_VFIO_LOG(ERR, "Error mapping region  (errno = %d)",
 494                                errno);
 495                 free(rte_mcp_ptr_list);
 496                 rte_mcp_ptr_list = NULL;
 497                 return -1;
 498         }
 499
 500         /* check the MC version compatibility */
 501         dpmng.regs = (void *)v_addr;
 502         if (mc_get_version(&dpmng, CMD_PRI_LOW, &mc_ver_info))
 503                 RTE_LOG(WARNING, PMD, "\tmc_get_version failed\n");
 504
 505         if ((mc_ver_info.major != MC_VER_MAJOR) ||
 506             (mc_ver_info.minor < MC_VER_MINOR)) {
 507                 RTE_LOG(ERR, PMD, "DPAA2 MC version not compatible!"
 508                         " Expected %d.%d.x, Detected %d.%d.%d\n",
 509                         MC_VER_MAJOR, MC_VER_MINOR,
 510                         mc_ver_info.major, mc_ver_info.minor,
 511                         mc_ver_info.revision);
 512                 free(rte_mcp_ptr_list);
 513                 rte_mcp_ptr_list = NULL;
 514                 return -1;
 515         }
 516         rte_mcp_ptr_list[0] = (void *)v_addr;
 517
 518         return 0;
 519 }
 520
 521 int
 522 fslmc_vfio_process_group(void)
 523 {
 524         int ret;
 525         int found_mportal = 0;
 526         struct rte_dpaa2_device *dev, *dev_temp;
 527
 528         /* Search the MCP as that should be initialized first. */
 529         TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
 530                 if (dev->dev_type == DPAA2_MPORTAL) {
 531                         ret = fslmc_process_mcp(dev);
 532                         if (ret) {
 533                                 FSLMC_VFIO_LOG(DEBUG, "Unable to map Portal.");
 534                                 return -1;
 535                         }
 536                         if (!found_mportal)
 537                                 found_mportal = 1;
 538
 539                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
 540                         free(dev);
 541                         dev = NULL;
 542                         /* Ideally there is only a single dpmcp, but in case
 543                          * multiple exists, looping on remaining devices.
 544                          */
 545                 }
 546         }
 547
 548         /* Cannot continue if there is not even a single mportal */
 549         if (!found_mportal) {
 550                 FSLMC_VFIO_LOG(DEBUG,
 551                                "No MC Portal device found. Not continuing.");
 552                 return -1;
 553         }
 554
 555         TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
 556                 if (!dev)
 557                         break;
 558
 559                 switch (dev->dev_type) {
 560                 case DPAA2_ETH:
 561                 case DPAA2_CRYPTO:
 562                         ret = fslmc_process_iodevices(dev);
 563                         if (ret) {
 564                                 FSLMC_VFIO_LOG(DEBUG,
 565                                                "Dev (%s) init failed.",
 566                                                dev->device.name);
 567                                 return ret;
 568                         }
 569                         break;
 570                 case DPAA2_CON:
 571                 case DPAA2_IO:
 572                 case DPAA2_CI:
 573                 case DPAA2_BPOOL:
 574                         /* Call the object creation routine and remove the
 575                          * device entry from device list
 576                          */
 577                         ret = fslmc_process_iodevices(dev);
 578                         if (ret) {
 579                                 FSLMC_VFIO_LOG(DEBUG,
 580                                                "Dev (%s) init failed.",
 581                                                dev->device.name);
 582                                 return -1;
 583                         }
 584
 585                         /* This device is not required to be in the DPDK
 586                          * exposed device list.
 587                          */
 588                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
 589                         free(dev);
 590                         dev = NULL;
 591                         break;
 592                 case DPAA2_UNKNOWN:
 593                 default:
 594                         /* Unknown - ignore */
 595                         FSLMC_VFIO_LOG(DEBUG, "Found unknown device (%s).",
 596                                        dev->device.name);
 597                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
 598                         free(dev);
 599                         dev = NULL;
 600                 }
 601         }
 602
 603         return 0;
 604 }
 605
 606 int
 607 fslmc_vfio_setup_group(void)
 608 {
 609         int groupid;
 610         int ret;
 611         struct vfio_group_status status = { .argsz = sizeof(status) };
 612
 613         /* if already done once */
 614         if (container_device_fd)
 615                 return 0;
 616
 617         ret = fslmc_get_container_group(&groupid);
 618         if (ret)
 619                 return ret;
 620
 621         /* In case this group was already opened, continue without any
 622          * processing.
 623          */
 624         if (vfio_group.groupid == groupid) {
 625                 FSLMC_VFIO_LOG(ERR, "groupid already exists %d", groupid);
 626                 return 0;
 627         }
 628
 629         /* Get the actual group fd */
 630         ret = vfio_get_group_fd(groupid);
 631         if (ret < 0)
 632                 return ret;
 633         vfio_group.fd = ret;
 634
 635         /* Check group viability */
 636         ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_STATUS, &status);
 637         if (ret) {
 638                 FSLMC_VFIO_LOG(ERR, "VFIO error getting group status");
 639                 close(vfio_group.fd);
 640                 rte_vfio_clear_group(vfio_group.fd);
 641                 return ret;
 642         }
 643
 644         if (!(status.flags & VFIO_GROUP_FLAGS_VIABLE)) {
 645                 FSLMC_VFIO_LOG(ERR, "VFIO group not viable");
 646                 close(vfio_group.fd);
 647                 rte_vfio_clear_group(vfio_group.fd);
 648                 return -EPERM;
 649         }
 650         /* Since Group is VIABLE, Store the groupid */
 651         vfio_group.groupid = groupid;
 652
 653         /* check if group does not have a container yet */
 654         if (!(status.flags & VFIO_GROUP_FLAGS_CONTAINER_SET)) {
 655                 /* Now connect this IOMMU group to given container */
 656                 ret = vfio_connect_container();
 657                 if (ret) {
 658                         FSLMC_VFIO_LOG(ERR,
 659                                 "Error connecting container with groupid %d",
 660                                 groupid);
 661                         close(vfio_group.fd);
 662                         rte_vfio_clear_group(vfio_group.fd);
 663                         return ret;
 664                 }
 665         }
 666
 667         /* Get Device information */
 668         ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_DEVICE_FD, g_container);
 669         if (ret < 0) {
 670                 FSLMC_VFIO_LOG(ERR, "Error getting device %s fd from group %d",
 671                                g_container, vfio_group.groupid);
 672                 close(vfio_group.fd);
 673                 rte_vfio_clear_group(vfio_group.fd);
 674                 return ret;
 675         }
 676         container_device_fd = ret;
 677         FSLMC_VFIO_LOG(DEBUG, "VFIO Container FD is [0x%X]",
 678                        container_device_fd);
 679
 680         return 0;
 681 }