event/skeleton: advertise the burst mode capability

[dpdk.git] / drivers / event / skeleton / skeleton_eventdev.c

diff --git a/drivers/event/skeleton/skeleton_eventdev.c b/drivers/event/skeleton/skeleton_eventdev.c
index 085cb86..34cd79a 100644 (file)
--- a/drivers/event/skeleton/skeleton_eventdev.c
+++ b/drivers/event/skeleton/skeleton_eventdev.c
@@ -43,10 +43,9 @@
 #include <rte_dev.h>
 #include <rte_eal.h>
 #include <rte_log.h>
+#include <rte_malloc.h>
 #include <rte_memory.h>
 #include <rte_memzone.h>
-#include <rte_malloc.h>
-#include <rte_pci.h>
 #include <rte_lcore.h>
 #include <rte_vdev.h>
 
@@ -130,6 +129,7 @@ skeleton_eventdev_info_get(struct rte_eventdev *dev,
        dev_info->max_event_port_enqueue_depth = 16;
        dev_info->max_num_events = (1ULL << 20);
        dev_info->event_dev_cap = RTE_EVENT_DEV_CAP_QUEUE_QOS |
+                                       RTE_EVENT_DEV_CAP_BURST_MODE |
                                        RTE_EVENT_DEV_CAP_EVENT_QOS;
 }
 
@@ -196,7 +196,7 @@ skeleton_eventdev_queue_def_conf(struct rte_eventdev *dev, uint8_t queue_id,
 
        queue_conf->nb_atomic_flows = (1ULL << 20);
        queue_conf->nb_atomic_order_sequences = (1ULL << 20);
-       queue_conf->event_queue_cfg = RTE_EVENT_QUEUE_CFG_DEFAULT;
+       queue_conf->event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
        queue_conf->priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
 }
 
@@ -287,13 +287,14 @@ skeleton_eventdev_port_setup(struct rte_eventdev *dev, uint8_t port_id,
 }
 
 static int
-skeleton_eventdev_port_link(void *port,
+skeleton_eventdev_port_link(struct rte_eventdev *dev, void *port,
                        const uint8_t queues[], const uint8_t priorities[],
                        uint16_t nb_links)
 {
        struct skeleton_port *sp = port;
        PMD_DRV_FUNC_TRACE();
 
+       RTE_SET_USED(dev);
        RTE_SET_USED(sp);
        RTE_SET_USED(queues);
        RTE_SET_USED(priorities);
@@ -303,12 +304,13 @@ skeleton_eventdev_port_link(void *port,
 }
 
 static int
-skeleton_eventdev_port_unlink(void *port, uint8_t queues[],
-                                uint16_t nb_unlinks)
+skeleton_eventdev_port_unlink(struct rte_eventdev *dev, void *port,
+                                uint8_t queues[], uint16_t nb_unlinks)
 {
        struct skeleton_port *sp = port;
        PMD_DRV_FUNC_TRACE();
 
+       RTE_SET_USED(dev);
        RTE_SET_USED(sp);
        RTE_SET_USED(queues);
 
@@ -317,7 +319,7 @@ skeleton_eventdev_port_unlink(void *port, uint8_t queues[],
 
 }
 
-static void
+static int
 skeleton_eventdev_timeout_ticks(struct rte_eventdev *dev, uint64_t ns,
                                 uint64_t *timeout_ticks)
 {
@@ -328,6 +330,8 @@ skeleton_eventdev_timeout_ticks(struct rte_eventdev *dev, uint64_t ns,
 
        RTE_SET_USED(skel);
        *timeout_ticks = ns * scale;
+
+       return 0;
 }
 
 static void
@@ -381,7 +385,7 @@ skeleton_eventdev_init(struct rte_eventdev *eventdev)
        if (rte_eal_process_type() != RTE_PROC_PRIMARY)
                return 0;
 
-       pci_dev = eventdev->pci_dev;
+       pci_dev = RTE_DEV_TO_PCI(eventdev->dev);
 
        skel->reg_base = (uintptr_t)pci_dev->mem_resource[0].addr;
        if (!skel->reg_base) {
@@ -423,60 +427,41 @@ static const struct rte_pci_id pci_id_skeleton_map[] = {
        },
 };
 
-static struct rte_eventdev_driver pci_eventdev_skeleton_pmd = {
-       .pci_drv = {
-               .id_table = pci_id_skeleton_map,
-               .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
-               .probe = rte_event_pmd_pci_probe,
-               .remove = rte_event_pmd_pci_remove,
-       },
-       .eventdev_init = skeleton_eventdev_init,
-       .dev_private_size = sizeof(struct skeleton_eventdev),
+static int
+event_skeleton_pci_probe(struct rte_pci_driver *pci_drv,
+                        struct rte_pci_device *pci_dev)
+{
+       return rte_event_pmd_pci_probe(pci_drv, pci_dev,
+               sizeof(struct skeleton_eventdev), skeleton_eventdev_init);
+}
+
+static int
+event_skeleton_pci_remove(struct rte_pci_device *pci_dev)
+{
+       return rte_event_pmd_pci_remove(pci_dev, NULL);
+}
+
+static struct rte_pci_driver pci_eventdev_skeleton_pmd = {
+       .id_table = pci_id_skeleton_map,
+       .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
+       .probe = event_skeleton_pci_probe,
+       .remove = event_skeleton_pci_remove,
 };
 
-RTE_PMD_REGISTER_PCI(event_skeleton_pci, pci_eventdev_skeleton_pmd.pci_drv);
+RTE_PMD_REGISTER_PCI(event_skeleton_pci, pci_eventdev_skeleton_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(event_skeleton_pci, pci_id_skeleton_map);
 
 /* VDEV based event device */
 
-/**
- * Global static parameter used to create a unique name for each skeleton
- * event device.
- */
-static unsigned int skeleton_unique_id;
-
-static inline int
-skeleton_create_unique_device_name(char *name, size_t size)
-{
-       int ret;
-
-       if (name == NULL)
-               return -EINVAL;
-
-       ret = snprintf(name, size, "%s_%u", RTE_STR(EVENTDEV_NAME_SKELETON_PMD),
-                       skeleton_unique_id++);
-       if (ret < 0)
-               return ret;
-       return 0;
-}
-
 static int
-skeleton_eventdev_create(int socket_id)
+skeleton_eventdev_create(const char *name, int socket_id)
 {
        struct rte_eventdev *eventdev;
-       char eventdev_name[RTE_EVENTDEV_NAME_MAX_LEN];
 
-       /* Create a unique device name */
-       if (skeleton_create_unique_device_name(eventdev_name,
-                       RTE_EVENTDEV_NAME_MAX_LEN) != 0) {
-               PMD_DRV_ERR("Failed to create unique eventdev name");
-               return -EINVAL;
-       }
-
-       eventdev = rte_event_pmd_vdev_init(eventdev_name,
+       eventdev = rte_event_pmd_vdev_init(name,
                        sizeof(struct skeleton_eventdev), socket_id);
        if (eventdev == NULL) {
-               PMD_DRV_ERR("Failed to create eventdev vdev");
+               PMD_DRV_ERR("Failed to create eventdev vdev %s", name);
                goto fail;
        }
 
@@ -493,22 +478,25 @@ fail:
 }
 
 static int
-skeleton_eventdev_probe(const char *name, __rte_unused const char *input_args)
+skeleton_eventdev_probe(struct rte_vdev_device *vdev)
 {
+       const char *name;
+
+       name = rte_vdev_device_name(vdev);
        RTE_LOG(INFO, PMD, "Initializing %s on NUMA node %d\n", name,
                        rte_socket_id());
-       return skeleton_eventdev_create(rte_socket_id());
+       return skeleton_eventdev_create(name, rte_socket_id());
 }
 
 static int
-skeleton_eventdev_remove(const char *name)
+skeleton_eventdev_remove(struct rte_vdev_device *vdev)
 {
-       if (name == NULL)
-               return -EINVAL;
+       const char *name;
 
+       name = rte_vdev_device_name(vdev);
        PMD_DRV_LOG(INFO, "Closing %s on NUMA node %d", name, rte_socket_id());
 
-       return 0;
+       return rte_event_pmd_vdev_uninit(name);
 }
 
 static struct rte_vdev_driver vdev_eventdev_skeleton_pmd = {