net/i40e: fix bitmap free
[dpdk.git] / 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-2019 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 #include <rte_eal_memconfig.h>
34
35 #include "rte_fslmc.h"
36 #include "fslmc_vfio.h"
37 #include "fslmc_logs.h"
38 #include <mc/fsl_dpmng.h>
39
40 #include "portal/dpaa2_hw_pvt.h"
41 #include "portal/dpaa2_hw_dpio.h"
42
43 #define FSLMC_CONTAINER_MAX_LEN 8 /**< Of the format dprc.XX */
44
45 /* Number of VFIO containers & groups with in */
46 static struct fslmc_vfio_group vfio_group;
47 static struct fslmc_vfio_container vfio_container;
48 static int container_device_fd;
49 char *fslmc_container;
50 static int fslmc_iommu_type;
51 static uint32_t *msi_intr_vaddr;
52 void *(*rte_mcp_ptr_list);
53
54 void *
55 dpaa2_get_mcp_ptr(int portal_idx)
56 {
57         if (rte_mcp_ptr_list)
58                 return rte_mcp_ptr_list[portal_idx];
59         else
60                 return NULL;
61 }
62
63 static struct rte_dpaa2_object_list dpaa2_obj_list =
64         TAILQ_HEAD_INITIALIZER(dpaa2_obj_list);
65
66 /*register a fslmc bus based dpaa2 driver */
67 void
68 rte_fslmc_object_register(struct rte_dpaa2_object *object)
69 {
70         RTE_VERIFY(object);
71
72         TAILQ_INSERT_TAIL(&dpaa2_obj_list, object, next);
73 }
74
75 int
76 fslmc_get_container_group(int *groupid)
77 {
78         int ret;
79         char *container;
80
81         if (!fslmc_container) {
82                 container = getenv("DPRC");
83                 if (container == NULL) {
84                         DPAA2_BUS_DEBUG("DPAA2: DPRC not available");
85                         return -EINVAL;
86                 }
87
88                 if (strlen(container) >= FSLMC_CONTAINER_MAX_LEN) {
89                         DPAA2_BUS_ERR("Invalid container name: %s", container);
90                         return -1;
91                 }
92
93                 fslmc_container = strdup(container);
94                 if (!fslmc_container) {
95                         DPAA2_BUS_ERR("Mem alloc failure; Container name");
96                         return -ENOMEM;
97                 }
98         }
99
100         fslmc_iommu_type = (rte_vfio_noiommu_is_enabled() == 1) ?
101                 RTE_VFIO_NOIOMMU : VFIO_TYPE1_IOMMU;
102
103         /* get group number */
104         ret = rte_vfio_get_group_num(SYSFS_FSL_MC_DEVICES,
105                                      fslmc_container, groupid);
106         if (ret <= 0) {
107                 DPAA2_BUS_ERR("Unable to find %s IOMMU group", fslmc_container);
108                 return -1;
109         }
110
111         DPAA2_BUS_DEBUG("Container: %s has VFIO iommu group id = %d",
112                         fslmc_container, *groupid);
113
114         return 0;
115 }
116
117 static int
118 vfio_connect_container(void)
119 {
120         int fd, ret;
121
122         if (vfio_container.used) {
123                 DPAA2_BUS_DEBUG("No container available");
124                 return -1;
125         }
126
127         /* Try connecting to vfio container if already created */
128         if (!ioctl(vfio_group.fd, VFIO_GROUP_SET_CONTAINER,
129                 &vfio_container.fd)) {
130                 DPAA2_BUS_DEBUG(
131                     "Container pre-exists with FD[0x%x] for this group",
132                     vfio_container.fd);
133                 vfio_group.container = &vfio_container;
134                 return 0;
135         }
136
137         /* Opens main vfio file descriptor which represents the "container" */
138         fd = rte_vfio_get_container_fd();
139         if (fd < 0) {
140                 DPAA2_BUS_ERR("Failed to open VFIO container");
141                 return -errno;
142         }
143
144         /* Check whether support for SMMU type IOMMU present or not */
145         if (ioctl(fd, VFIO_CHECK_EXTENSION, fslmc_iommu_type)) {
146                 /* Connect group to container */
147                 ret = ioctl(vfio_group.fd, VFIO_GROUP_SET_CONTAINER, &fd);
148                 if (ret) {
149                         DPAA2_BUS_ERR("Failed to setup group container");
150                         close(fd);
151                         return -errno;
152                 }
153
154                 ret = ioctl(fd, VFIO_SET_IOMMU, fslmc_iommu_type);
155                 if (ret) {
156                         DPAA2_BUS_ERR("Failed to setup VFIO iommu");
157                         close(fd);
158                         return -errno;
159                 }
160         } else {
161                 DPAA2_BUS_ERR("No supported IOMMU available");
162                 close(fd);
163                 return -EINVAL;
164         }
165
166         vfio_container.used = 1;
167         vfio_container.fd = fd;
168         vfio_container.group = &vfio_group;
169         vfio_group.container = &vfio_container;
170
171         return 0;
172 }
173
174 static int vfio_map_irq_region(struct fslmc_vfio_group *group)
175 {
176         int ret;
177         unsigned long *vaddr = NULL;
178         struct vfio_iommu_type1_dma_map map = {
179                 .argsz = sizeof(map),
180                 .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
181                 .vaddr = 0x6030000,
182                 .iova = 0x6030000,
183                 .size = 0x1000,
184         };
185
186         vaddr = (unsigned long *)mmap(NULL, 0x1000, PROT_WRITE |
187                 PROT_READ, MAP_SHARED, container_device_fd, 0x6030000);
188         if (vaddr == MAP_FAILED) {
189                 DPAA2_BUS_INFO("Unable to map region (errno = %d)", errno);
190                 return -errno;
191         }
192
193         msi_intr_vaddr = (uint32_t *)((char *)(vaddr) + 64);
194         map.vaddr = (unsigned long)vaddr;
195         ret = ioctl(group->container->fd, VFIO_IOMMU_MAP_DMA, &map);
196         if (ret == 0)
197                 return 0;
198
199         DPAA2_BUS_ERR("Unable to map DMA address (errno = %d)", errno);
200         return -errno;
201 }
202
203 static int fslmc_map_dma(uint64_t vaddr, rte_iova_t iovaddr, size_t len);
204 static int fslmc_unmap_dma(uint64_t vaddr, rte_iova_t iovaddr, size_t len);
205
206 static void
207 fslmc_memevent_cb(enum rte_mem_event type, const void *addr, size_t len,
208                 void *arg __rte_unused)
209 {
210         struct rte_memseg_list *msl;
211         struct rte_memseg *ms;
212         size_t cur_len = 0, map_len = 0;
213         uint64_t virt_addr;
214         rte_iova_t iova_addr;
215         int ret;
216
217         msl = rte_mem_virt2memseg_list(addr);
218
219         while (cur_len < len) {
220                 const void *va = RTE_PTR_ADD(addr, cur_len);
221
222                 ms = rte_mem_virt2memseg(va, msl);
223                 iova_addr = ms->iova;
224                 virt_addr = ms->addr_64;
225                 map_len = ms->len;
226
227                 DPAA2_BUS_DEBUG("Request for %s, va=%p, "
228                                 "virt_addr=0x%" PRIx64 ", "
229                                 "iova=0x%" PRIx64 ", map_len=%zu",
230                                 type == RTE_MEM_EVENT_ALLOC ?
231                                         "alloc" : "dealloc",
232                                 va, virt_addr, iova_addr, map_len);
233
234                 /* iova_addr may be set to RTE_BAD_IOVA */
235                 if (iova_addr == RTE_BAD_IOVA) {
236                         DPAA2_BUS_DEBUG("Segment has invalid iova, skipping\n");
237                         cur_len += map_len;
238                         continue;
239                 }
240
241                 if (type == RTE_MEM_EVENT_ALLOC)
242                         ret = fslmc_map_dma(virt_addr, iova_addr, map_len);
243                 else
244                         ret = fslmc_unmap_dma(virt_addr, iova_addr, map_len);
245
246                 if (ret != 0) {
247                         DPAA2_BUS_ERR("DMA Mapping/Unmapping failed. "
248                                         "Map=%d, addr=%p, len=%zu, err:(%d)",
249                                         type, va, map_len, ret);
250                         return;
251                 }
252
253                 cur_len += map_len;
254         }
255
256         if (type == RTE_MEM_EVENT_ALLOC)
257                 DPAA2_BUS_DEBUG("Total Mapped: addr=%p, len=%zu",
258                                 addr, len);
259         else
260                 DPAA2_BUS_DEBUG("Total Unmapped: addr=%p, len=%zu",
261                                 addr, len);
262 }
263
264 static int
265 fslmc_map_dma(uint64_t vaddr, rte_iova_t iovaddr __rte_unused, size_t len)
266 {
267         struct fslmc_vfio_group *group;
268         struct vfio_iommu_type1_dma_map dma_map = {
269                 .argsz = sizeof(struct vfio_iommu_type1_dma_map),
270                 .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
271         };
272         int ret;
273
274         if (fslmc_iommu_type == RTE_VFIO_NOIOMMU) {
275                 DPAA2_BUS_DEBUG("Running in NOIOMMU mode");
276                 return 0;
277         }
278
279         dma_map.size = len;
280         dma_map.vaddr = vaddr;
281
282 #ifdef RTE_LIBRTE_DPAA2_USE_PHYS_IOVA
283         dma_map.iova = iovaddr;
284 #else
285         dma_map.iova = dma_map.vaddr;
286 #endif
287
288         /* SET DMA MAP for IOMMU */
289         group = &vfio_group;
290
291         if (!group->container) {
292                 DPAA2_BUS_ERR("Container is not connected ");
293                 return -1;
294         }
295
296         DPAA2_BUS_DEBUG("--> Map address: 0x%"PRIx64", size: %"PRIu64"",
297                         (uint64_t)dma_map.vaddr, (uint64_t)dma_map.size);
298         ret = ioctl(group->container->fd, VFIO_IOMMU_MAP_DMA, &dma_map);
299         if (ret) {
300                 DPAA2_BUS_ERR("VFIO_IOMMU_MAP_DMA API(errno = %d)",
301                                 errno);
302                 return -1;
303         }
304
305         return 0;
306 }
307
308 static int
309 fslmc_unmap_dma(uint64_t vaddr, uint64_t iovaddr __rte_unused, size_t len)
310 {
311         struct fslmc_vfio_group *group;
312         struct vfio_iommu_type1_dma_unmap dma_unmap = {
313                 .argsz = sizeof(struct vfio_iommu_type1_dma_unmap),
314                 .flags = 0,
315         };
316         int ret;
317
318         if (fslmc_iommu_type == RTE_VFIO_NOIOMMU) {
319                 DPAA2_BUS_DEBUG("Running in NOIOMMU mode");
320                 return 0;
321         }
322
323         dma_unmap.size = len;
324         dma_unmap.iova = vaddr;
325
326         /* SET DMA MAP for IOMMU */
327         group = &vfio_group;
328
329         if (!group->container) {
330                 DPAA2_BUS_ERR("Container is not connected ");
331                 return -1;
332         }
333
334         DPAA2_BUS_DEBUG("--> Unmap address: 0x%"PRIx64", size: %"PRIu64"",
335                         (uint64_t)dma_unmap.iova, (uint64_t)dma_unmap.size);
336         ret = ioctl(group->container->fd, VFIO_IOMMU_UNMAP_DMA, &dma_unmap);
337         if (ret) {
338                 DPAA2_BUS_ERR("VFIO_IOMMU_UNMAP_DMA API(errno = %d)",
339                                 errno);
340                 return -1;
341         }
342
343         return 0;
344 }
345
346 static int
347 fslmc_dmamap_seg(const struct rte_memseg_list *msl __rte_unused,
348                 const struct rte_memseg *ms, void *arg)
349 {
350         int *n_segs = arg;
351         int ret;
352
353         /* if IOVA address is invalid, skip */
354         if (ms->iova == RTE_BAD_IOVA)
355                 return 0;
356
357         ret = fslmc_map_dma(ms->addr_64, ms->iova, ms->len);
358         if (ret)
359                 DPAA2_BUS_ERR("Unable to VFIO map (addr=%p, len=%zu)",
360                                 ms->addr, ms->len);
361         else
362                 (*n_segs)++;
363
364         return ret;
365 }
366
367 int
368 rte_fslmc_vfio_mem_dmamap(uint64_t vaddr, uint64_t iova, uint64_t size)
369 {
370         int ret;
371         struct fslmc_vfio_group *group;
372         struct vfio_iommu_type1_dma_map dma_map = {
373                 .argsz = sizeof(struct vfio_iommu_type1_dma_map),
374                 .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
375         };
376
377         if (fslmc_iommu_type == RTE_VFIO_NOIOMMU) {
378                 DPAA2_BUS_DEBUG("Running in NOIOMMU mode");
379                 return 0;
380         }
381
382         /* SET DMA MAP for IOMMU */
383         group = &vfio_group;
384         if (!group->container) {
385                 DPAA2_BUS_ERR("Container is not connected");
386                 return -1;
387         }
388
389         dma_map.size = size;
390         dma_map.vaddr = vaddr;
391         dma_map.iova = iova;
392
393         DPAA2_BUS_DEBUG("VFIOdmamap 0x%"PRIx64":0x%"PRIx64",size 0x%"PRIx64"\n",
394                         (uint64_t)dma_map.vaddr, (uint64_t)dma_map.iova,
395                         (uint64_t)dma_map.size);
396         ret = ioctl(group->container->fd, VFIO_IOMMU_MAP_DMA,
397                     &dma_map);
398         if (ret) {
399                 printf("Unable to map DMA address (errno = %d)\n",
400                         errno);
401                 return ret;
402         }
403
404         return 0;
405 }
406
407 int rte_fslmc_vfio_dmamap(void)
408 {
409         int i = 0, ret;
410
411         /* Lock before parsing and registering callback to memory subsystem */
412         rte_mcfg_mem_read_lock();
413
414         if (rte_memseg_walk(fslmc_dmamap_seg, &i) < 0) {
415                 rte_mcfg_mem_read_unlock();
416                 return -1;
417         }
418
419         ret = rte_mem_event_callback_register("fslmc_memevent_clb",
420                         fslmc_memevent_cb, NULL);
421         if (ret && rte_errno == ENOTSUP)
422                 DPAA2_BUS_DEBUG("Memory event callbacks not supported");
423         else if (ret)
424                 DPAA2_BUS_DEBUG("Unable to install memory handler");
425         else
426                 DPAA2_BUS_DEBUG("Installed memory callback handler");
427
428         DPAA2_BUS_DEBUG("Total %d segments found.", i);
429
430         /* TODO - This is a W.A. as VFIO currently does not add the mapping of
431          * the interrupt region to SMMU. This should be removed once the
432          * support is added in the Kernel.
433          */
434         vfio_map_irq_region(&vfio_group);
435
436         /* Existing segments have been mapped and memory callback for hotplug
437          * has been installed.
438          */
439         rte_mcfg_mem_read_unlock();
440
441         return 0;
442 }
443
444 static int
445 fslmc_vfio_setup_device(const char *sysfs_base, const char *dev_addr,
446                 int *vfio_dev_fd, struct vfio_device_info *device_info)
447 {
448         struct vfio_group_status group_status = {
449                         .argsz = sizeof(group_status)
450         };
451         int vfio_group_fd, vfio_container_fd, iommu_group_no, ret;
452
453         /* get group number */
454         ret = rte_vfio_get_group_num(sysfs_base, dev_addr, &iommu_group_no);
455         if (ret < 0)
456                 return -1;
457
458         /* get the actual group fd */
459         vfio_group_fd = rte_vfio_get_group_fd(iommu_group_no);
460         if (vfio_group_fd < 0)
461                 return -1;
462
463         /* if group_fd == 0, that means the device isn't managed by VFIO */
464         if (vfio_group_fd == 0) {
465                 RTE_LOG(WARNING, EAL, " %s not managed by VFIO driver, skipping\n",
466                                 dev_addr);
467                 return 1;
468         }
469
470         /* Opens main vfio file descriptor which represents the "container" */
471         vfio_container_fd = rte_vfio_get_container_fd();
472         if (vfio_container_fd < 0) {
473                 DPAA2_BUS_ERR("Failed to open VFIO container");
474                 return -errno;
475         }
476
477         /* check if the group is viable */
478         ret = ioctl(vfio_group_fd, VFIO_GROUP_GET_STATUS, &group_status);
479         if (ret) {
480                 DPAA2_BUS_ERR("  %s cannot get group status, "
481                                 "error %i (%s)\n", dev_addr,
482                                 errno, strerror(errno));
483                 close(vfio_group_fd);
484                 rte_vfio_clear_group(vfio_group_fd);
485                 return -1;
486         } else if (!(group_status.flags & VFIO_GROUP_FLAGS_VIABLE)) {
487                 DPAA2_BUS_ERR("  %s VFIO group is not viable!\n", dev_addr);
488                 close(vfio_group_fd);
489                 rte_vfio_clear_group(vfio_group_fd);
490                 return -1;
491         }
492         /* At this point, we know that this group is viable (meaning,
493          * all devices are either bound to VFIO or not bound to anything)
494          */
495
496         /* check if group does not have a container yet */
497         if (!(group_status.flags & VFIO_GROUP_FLAGS_CONTAINER_SET)) {
498
499                 /* add group to a container */
500                 ret = ioctl(vfio_group_fd, VFIO_GROUP_SET_CONTAINER,
501                                 &vfio_container_fd);
502                 if (ret) {
503                         DPAA2_BUS_ERR("  %s cannot add VFIO group to container, "
504                                         "error %i (%s)\n", dev_addr,
505                                         errno, strerror(errno));
506                         close(vfio_group_fd);
507                         close(vfio_container_fd);
508                         rte_vfio_clear_group(vfio_group_fd);
509                         return -1;
510                 }
511
512                 /*
513                  * set an IOMMU type for container
514                  *
515                  */
516                 if (ioctl(vfio_container_fd, VFIO_CHECK_EXTENSION,
517                           fslmc_iommu_type)) {
518                         ret = ioctl(vfio_container_fd, VFIO_SET_IOMMU,
519                                     fslmc_iommu_type);
520                         if (ret) {
521                                 DPAA2_BUS_ERR("Failed to setup VFIO iommu");
522                                 close(vfio_group_fd);
523                                 close(vfio_container_fd);
524                                 return -errno;
525                         }
526                 } else {
527                         DPAA2_BUS_ERR("No supported IOMMU available");
528                         close(vfio_group_fd);
529                         close(vfio_container_fd);
530                         return -EINVAL;
531                 }
532         }
533
534         /* get a file descriptor for the device */
535         *vfio_dev_fd = ioctl(vfio_group_fd, VFIO_GROUP_GET_DEVICE_FD, dev_addr);
536         if (*vfio_dev_fd < 0) {
537                 /* if we cannot get a device fd, this implies a problem with
538                  * the VFIO group or the container not having IOMMU configured.
539                  */
540
541                 DPAA2_BUS_WARN("Getting a vfio_dev_fd for %s failed", dev_addr);
542                 close(vfio_group_fd);
543                 close(vfio_container_fd);
544                 rte_vfio_clear_group(vfio_group_fd);
545                 return -1;
546         }
547
548         /* test and setup the device */
549         ret = ioctl(*vfio_dev_fd, VFIO_DEVICE_GET_INFO, device_info);
550         if (ret) {
551                 DPAA2_BUS_ERR("  %s cannot get device info, error %i (%s)",
552                                 dev_addr, errno, strerror(errno));
553                 close(*vfio_dev_fd);
554                 close(vfio_group_fd);
555                 close(vfio_container_fd);
556                 rte_vfio_clear_group(vfio_group_fd);
557                 return -1;
558         }
559
560         return 0;
561 }
562
563 static intptr_t vfio_map_mcp_obj(const char *mcp_obj)
564 {
565         intptr_t v_addr = (intptr_t)MAP_FAILED;
566         int32_t ret, mc_fd;
567         struct vfio_group_status status = { .argsz = sizeof(status) };
568
569         struct vfio_device_info d_info = { .argsz = sizeof(d_info) };
570         struct vfio_region_info reg_info = { .argsz = sizeof(reg_info) };
571
572         fslmc_vfio_setup_device(SYSFS_FSL_MC_DEVICES, mcp_obj,
573                         &mc_fd, &d_info);
574
575         /* getting device region info*/
576         ret = ioctl(mc_fd, VFIO_DEVICE_GET_REGION_INFO, &reg_info);
577         if (ret < 0) {
578                 DPAA2_BUS_ERR("Error in VFIO getting REGION_INFO");
579                 goto MC_FAILURE;
580         }
581
582         v_addr = (size_t)mmap(NULL, reg_info.size,
583                 PROT_WRITE | PROT_READ, MAP_SHARED,
584                 mc_fd, reg_info.offset);
585
586 MC_FAILURE:
587         close(mc_fd);
588
589         return v_addr;
590 }
591
592 #define IRQ_SET_BUF_LEN  (sizeof(struct vfio_irq_set) + sizeof(int))
593
594 int rte_dpaa2_intr_enable(struct rte_intr_handle *intr_handle, int index)
595 {
596         int len, ret;
597         char irq_set_buf[IRQ_SET_BUF_LEN];
598         struct vfio_irq_set *irq_set;
599         int *fd_ptr;
600
601         len = sizeof(irq_set_buf);
602
603         irq_set = (struct vfio_irq_set *)irq_set_buf;
604         irq_set->argsz = len;
605         irq_set->count = 1;
606         irq_set->flags =
607                 VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER;
608         irq_set->index = index;
609         irq_set->start = 0;
610         fd_ptr = (int *)&irq_set->data;
611         *fd_ptr = intr_handle->fd;
612
613         ret = ioctl(intr_handle->vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set);
614         if (ret) {
615                 DPAA2_BUS_ERR("Error:dpaa2 SET IRQs fd=%d, err = %d(%s)",
616                               intr_handle->fd, errno, strerror(errno));
617                 return ret;
618         }
619
620         return ret;
621 }
622
623 int rte_dpaa2_intr_disable(struct rte_intr_handle *intr_handle, int index)
624 {
625         struct vfio_irq_set *irq_set;
626         char irq_set_buf[IRQ_SET_BUF_LEN];
627         int len, ret;
628
629         len = sizeof(struct vfio_irq_set);
630
631         irq_set = (struct vfio_irq_set *)irq_set_buf;
632         irq_set->argsz = len;
633         irq_set->flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER;
634         irq_set->index = index;
635         irq_set->start = 0;
636         irq_set->count = 0;
637
638         ret = ioctl(intr_handle->vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set);
639         if (ret)
640                 DPAA2_BUS_ERR(
641                         "Error disabling dpaa2 interrupts for fd %d",
642                         intr_handle->fd);
643
644         return ret;
645 }
646
647 /* set up interrupt support (but not enable interrupts) */
648 int
649 rte_dpaa2_vfio_setup_intr(struct rte_intr_handle *intr_handle,
650                           int vfio_dev_fd,
651                           int num_irqs)
652 {
653         int i, ret;
654
655         /* start from MSI-X interrupt type */
656         for (i = 0; i < num_irqs; i++) {
657                 struct vfio_irq_info irq_info = { .argsz = sizeof(irq_info) };
658                 int fd = -1;
659
660                 irq_info.index = i;
661
662                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq_info);
663                 if (ret < 0) {
664                         DPAA2_BUS_ERR("Cannot get IRQ(%d) info, error %i (%s)",
665                                       i, errno, strerror(errno));
666                         return -1;
667                 }
668
669                 /* if this vector cannot be used with eventfd,
670                  * fail if we explicitly
671                  * specified interrupt type, otherwise continue
672                  */
673                 if ((irq_info.flags & VFIO_IRQ_INFO_EVENTFD) == 0)
674                         continue;
675
676                 /* set up an eventfd for interrupts */
677                 fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
678                 if (fd < 0) {
679                         DPAA2_BUS_ERR("Cannot set up eventfd, error %i (%s)",
680                                       errno, strerror(errno));
681                         return -1;
682                 }
683
684                 intr_handle->fd = fd;
685                 intr_handle->type = RTE_INTR_HANDLE_VFIO_MSI;
686                 intr_handle->vfio_dev_fd = vfio_dev_fd;
687
688                 return 0;
689         }
690
691         /* if we're here, we haven't found a suitable interrupt vector */
692         return -1;
693 }
694
695 /*
696  * fslmc_process_iodevices for processing only IO (ETH, CRYPTO, and possibly
697  * EVENT) devices.
698  */
699 static int
700 fslmc_process_iodevices(struct rte_dpaa2_device *dev)
701 {
702         int dev_fd;
703         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
704         struct rte_dpaa2_object *object = NULL;
705
706         fslmc_vfio_setup_device(SYSFS_FSL_MC_DEVICES, dev->device.name,
707                         &dev_fd, &device_info);
708
709         switch (dev->dev_type) {
710         case DPAA2_ETH:
711                 rte_dpaa2_vfio_setup_intr(&dev->intr_handle, dev_fd,
712                                           device_info.num_irqs);
713                 break;
714         case DPAA2_CON:
715         case DPAA2_IO:
716         case DPAA2_CI:
717         case DPAA2_BPOOL:
718         case DPAA2_DPRTC:
719         case DPAA2_MUX:
720                 TAILQ_FOREACH(object, &dpaa2_obj_list, next) {
721                         if (dev->dev_type == object->dev_type)
722                                 object->create(dev_fd, &device_info,
723                                                dev->object_id);
724                         else
725                                 continue;
726                 }
727                 break;
728         default:
729                 break;
730         }
731
732         DPAA2_BUS_LOG(DEBUG, "Device (%s) abstracted from VFIO",
733                       dev->device.name);
734         return 0;
735 }
736
737 static int
738 fslmc_process_mcp(struct rte_dpaa2_device *dev)
739 {
740         int ret;
741         intptr_t v_addr;
742         struct fsl_mc_io dpmng  = {0};
743         struct mc_version mc_ver_info = {0};
744
745         rte_mcp_ptr_list = malloc(sizeof(void *) * (MC_PORTAL_INDEX + 1));
746         if (!rte_mcp_ptr_list) {
747                 DPAA2_BUS_ERR("Unable to allocate MC portal memory");
748                 ret = -ENOMEM;
749                 goto cleanup;
750         }
751
752         v_addr = vfio_map_mcp_obj(dev->device.name);
753         if (v_addr == (intptr_t)MAP_FAILED) {
754                 DPAA2_BUS_ERR("Error mapping region (errno = %d)", errno);
755                 ret = -1;
756                 goto cleanup;
757         }
758
759         /* check the MC version compatibility */
760         dpmng.regs = (void *)v_addr;
761
762         /* In case of secondary processes, MC version check is no longer
763          * required.
764          */
765         if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
766                 rte_mcp_ptr_list[MC_PORTAL_INDEX] = (void *)v_addr;
767                 return 0;
768         }
769
770         if (mc_get_version(&dpmng, CMD_PRI_LOW, &mc_ver_info)) {
771                 DPAA2_BUS_ERR("Unable to obtain MC version");
772                 ret = -1;
773                 goto cleanup;
774         }
775
776         if ((mc_ver_info.major != MC_VER_MAJOR) ||
777             (mc_ver_info.minor < MC_VER_MINOR)) {
778                 DPAA2_BUS_ERR("DPAA2 MC version not compatible!"
779                               " Expected %d.%d.x, Detected %d.%d.%d",
780                               MC_VER_MAJOR, MC_VER_MINOR,
781                               mc_ver_info.major, mc_ver_info.minor,
782                               mc_ver_info.revision);
783                 ret = -1;
784                 goto cleanup;
785         }
786         rte_mcp_ptr_list[MC_PORTAL_INDEX] = (void *)v_addr;
787
788         return 0;
789
790 cleanup:
791         if (rte_mcp_ptr_list) {
792                 free(rte_mcp_ptr_list);
793                 rte_mcp_ptr_list = NULL;
794         }
795
796         return ret;
797 }
798
799 int
800 fslmc_vfio_process_group(void)
801 {
802         int ret;
803         int found_mportal = 0;
804         struct rte_dpaa2_device *dev, *dev_temp;
805
806         /* Search the MCP as that should be initialized first. */
807         TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
808                 if (dev->dev_type == DPAA2_MPORTAL) {
809                         if (dev->device.devargs &&
810                             dev->device.devargs->policy == RTE_DEV_BLACKLISTED) {
811                                 DPAA2_BUS_LOG(DEBUG, "%s Blacklisted, skipping",
812                                               dev->device.name);
813                                 TAILQ_REMOVE(&rte_fslmc_bus.device_list,
814                                                 dev, next);
815                                 continue;
816                         }
817
818                         ret = fslmc_process_mcp(dev);
819                         if (ret) {
820                                 DPAA2_BUS_ERR("Unable to map MC Portal");
821                                 return -1;
822                         }
823                         if (!found_mportal)
824                                 found_mportal = 1;
825
826                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
827                         free(dev);
828                         dev = NULL;
829                         /* Ideally there is only a single dpmcp, but in case
830                          * multiple exists, looping on remaining devices.
831                          */
832                 }
833         }
834
835         /* Cannot continue if there is not even a single mportal */
836         if (!found_mportal) {
837                 DPAA2_BUS_ERR("No MC Portal device found. Not continuing");
838                 return -1;
839         }
840
841         TAILQ_FOREACH_SAFE(dev, &rte_fslmc_bus.device_list, next, dev_temp) {
842                 if (dev->device.devargs &&
843                     dev->device.devargs->policy == RTE_DEV_BLACKLISTED) {
844                         DPAA2_BUS_LOG(DEBUG, "%s Blacklisted, skipping",
845                                       dev->device.name);
846                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
847                         continue;
848                 }
849                 switch (dev->dev_type) {
850                 case DPAA2_ETH:
851                 case DPAA2_CRYPTO:
852                 case DPAA2_QDMA:
853                         ret = fslmc_process_iodevices(dev);
854                         if (ret) {
855                                 DPAA2_BUS_DEBUG("Dev (%s) init failed",
856                                                 dev->device.name);
857                                 return ret;
858                         }
859                         break;
860                 case DPAA2_CON:
861                 case DPAA2_CI:
862                 case DPAA2_BPOOL:
863                 case DPAA2_DPRTC:
864                 case DPAA2_MUX:
865                         /* IN case of secondary processes, all control objects
866                          * like dpbp, dpcon, dpci are not initialized/required
867                          * - all of these are assumed to be initialized and made
868                          *   available by primary.
869                          */
870                         if (rte_eal_process_type() == RTE_PROC_SECONDARY)
871                                 continue;
872
873                         /* Call the object creation routine and remove the
874                          * device entry from device list
875                          */
876                         ret = fslmc_process_iodevices(dev);
877                         if (ret) {
878                                 DPAA2_BUS_DEBUG("Dev (%s) init failed",
879                                                 dev->device.name);
880                                 return -1;
881                         }
882
883                         break;
884                 case DPAA2_IO:
885                         ret = fslmc_process_iodevices(dev);
886                         if (ret) {
887                                 DPAA2_BUS_DEBUG("Dev (%s) init failed",
888                                                 dev->device.name);
889                                 return -1;
890                         }
891
892                         break;
893                 case DPAA2_UNKNOWN:
894                 default:
895                         /* Unknown - ignore */
896                         DPAA2_BUS_DEBUG("Found unknown device (%s)",
897                                         dev->device.name);
898                         TAILQ_REMOVE(&rte_fslmc_bus.device_list, dev, next);
899                         free(dev);
900                         dev = NULL;
901                 }
902         }
903
904         return 0;
905 }
906
907 int
908 fslmc_vfio_setup_group(void)
909 {
910         int groupid;
911         int ret;
912         struct vfio_group_status status = { .argsz = sizeof(status) };
913
914         /* if already done once */
915         if (container_device_fd)
916                 return 0;
917
918         ret = fslmc_get_container_group(&groupid);
919         if (ret)
920                 return ret;
921
922         /* In case this group was already opened, continue without any
923          * processing.
924          */
925         if (vfio_group.groupid == groupid) {
926                 DPAA2_BUS_ERR("groupid already exists %d", groupid);
927                 return 0;
928         }
929
930         /* Get the actual group fd */
931         ret = rte_vfio_get_group_fd(groupid);
932         if (ret < 0)
933                 return ret;
934         vfio_group.fd = ret;
935
936         /* Check group viability */
937         ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_STATUS, &status);
938         if (ret) {
939                 DPAA2_BUS_ERR("VFIO error getting group status");
940                 close(vfio_group.fd);
941                 rte_vfio_clear_group(vfio_group.fd);
942                 return ret;
943         }
944
945         if (!(status.flags & VFIO_GROUP_FLAGS_VIABLE)) {
946                 DPAA2_BUS_ERR("VFIO group not viable");
947                 close(vfio_group.fd);
948                 rte_vfio_clear_group(vfio_group.fd);
949                 return -EPERM;
950         }
951         /* Since Group is VIABLE, Store the groupid */
952         vfio_group.groupid = groupid;
953
954         /* check if group does not have a container yet */
955         if (!(status.flags & VFIO_GROUP_FLAGS_CONTAINER_SET)) {
956                 /* Now connect this IOMMU group to given container */
957                 ret = vfio_connect_container();
958                 if (ret) {
959                         DPAA2_BUS_ERR(
960                                 "Error connecting container with groupid %d",
961                                 groupid);
962                         close(vfio_group.fd);
963                         rte_vfio_clear_group(vfio_group.fd);
964                         return ret;
965                 }
966         }
967
968         /* Get Device information */
969         ret = ioctl(vfio_group.fd, VFIO_GROUP_GET_DEVICE_FD, fslmc_container);
970         if (ret < 0) {
971                 DPAA2_BUS_ERR("Error getting device %s fd from group %d",
972                               fslmc_container, vfio_group.groupid);
973                 close(vfio_group.fd);
974                 rte_vfio_clear_group(vfio_group.fd);
975                 return ret;
976         }
977         container_device_fd = ret;
978         DPAA2_BUS_DEBUG("VFIO Container FD is [0x%X]",
979                         container_device_fd);
980
981         return 0;
982 }