1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 Cavium, Inc
12 #include <rte_byteorder.h>
13 #include <rte_common.h>
14 #include <rte_debug.h>
18 #include <rte_malloc.h>
19 #include <rte_memory.h>
20 #include <rte_lcore.h>
21 #include <rte_bus_vdev.h>
23 #include "skeleton_eventdev.h"
25 #define EVENTDEV_NAME_SKELETON_PMD event_skeleton
26 /**< Skeleton event device PMD name */
29 skeleton_eventdev_enqueue(void *port, const struct rte_event *ev)
31 struct skeleton_port *sp = port;
41 skeleton_eventdev_enqueue_burst(void *port, const struct rte_event ev[],
44 struct skeleton_port *sp = port;
49 RTE_SET_USED(nb_events);
55 skeleton_eventdev_dequeue(void *port, struct rte_event *ev,
56 uint64_t timeout_ticks)
58 struct skeleton_port *sp = port;
62 RTE_SET_USED(timeout_ticks);
68 skeleton_eventdev_dequeue_burst(void *port, struct rte_event ev[],
69 uint16_t nb_events, uint64_t timeout_ticks)
71 struct skeleton_port *sp = port;
75 RTE_SET_USED(nb_events);
76 RTE_SET_USED(timeout_ticks);
82 skeleton_eventdev_info_get(struct rte_eventdev *dev,
83 struct rte_event_dev_info *dev_info)
85 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
91 dev_info->min_dequeue_timeout_ns = 1;
92 dev_info->max_dequeue_timeout_ns = 10000;
93 dev_info->dequeue_timeout_ns = 25;
94 dev_info->max_event_queues = 64;
95 dev_info->max_event_queue_flows = (1ULL << 20);
96 dev_info->max_event_queue_priority_levels = 8;
97 dev_info->max_event_priority_levels = 8;
98 dev_info->max_event_ports = 32;
99 dev_info->max_event_port_dequeue_depth = 16;
100 dev_info->max_event_port_enqueue_depth = 16;
101 dev_info->max_num_events = (1ULL << 20);
102 dev_info->event_dev_cap = RTE_EVENT_DEV_CAP_QUEUE_QOS |
103 RTE_EVENT_DEV_CAP_BURST_MODE |
104 RTE_EVENT_DEV_CAP_EVENT_QOS;
108 skeleton_eventdev_configure(const struct rte_eventdev *dev)
110 struct rte_eventdev_data *data = dev->data;
111 struct rte_event_dev_config *conf = &data->dev_conf;
112 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
114 PMD_DRV_FUNC_TRACE();
119 PMD_DRV_LOG(DEBUG, "Configured eventdev devid=%d", dev->data->dev_id);
124 skeleton_eventdev_start(struct rte_eventdev *dev)
126 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
128 PMD_DRV_FUNC_TRACE();
136 skeleton_eventdev_stop(struct rte_eventdev *dev)
138 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
140 PMD_DRV_FUNC_TRACE();
146 skeleton_eventdev_close(struct rte_eventdev *dev)
148 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
150 PMD_DRV_FUNC_TRACE();
158 skeleton_eventdev_queue_def_conf(struct rte_eventdev *dev, uint8_t queue_id,
159 struct rte_event_queue_conf *queue_conf)
161 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
163 PMD_DRV_FUNC_TRACE();
166 RTE_SET_USED(queue_id);
168 queue_conf->nb_atomic_flows = (1ULL << 20);
169 queue_conf->nb_atomic_order_sequences = (1ULL << 20);
170 queue_conf->event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
171 queue_conf->priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
175 skeleton_eventdev_queue_release(struct rte_eventdev *dev, uint8_t queue_id)
177 PMD_DRV_FUNC_TRACE();
180 RTE_SET_USED(queue_id);
184 skeleton_eventdev_queue_setup(struct rte_eventdev *dev, uint8_t queue_id,
185 const struct rte_event_queue_conf *queue_conf)
187 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
189 PMD_DRV_FUNC_TRACE();
192 RTE_SET_USED(queue_conf);
193 RTE_SET_USED(queue_id);
199 skeleton_eventdev_port_def_conf(struct rte_eventdev *dev, uint8_t port_id,
200 struct rte_event_port_conf *port_conf)
202 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
204 PMD_DRV_FUNC_TRACE();
207 RTE_SET_USED(port_id);
209 port_conf->new_event_threshold = 32 * 1024;
210 port_conf->dequeue_depth = 16;
211 port_conf->enqueue_depth = 16;
215 skeleton_eventdev_port_release(void *port)
217 struct skeleton_port *sp = port;
218 PMD_DRV_FUNC_TRACE();
224 skeleton_eventdev_port_setup(struct rte_eventdev *dev, uint8_t port_id,
225 const struct rte_event_port_conf *port_conf)
227 struct skeleton_port *sp;
228 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
230 PMD_DRV_FUNC_TRACE();
233 RTE_SET_USED(port_conf);
235 /* Free memory prior to re-allocation if needed */
236 if (dev->data->ports[port_id] != NULL) {
237 PMD_DRV_LOG(DEBUG, "Freeing memory prior to re-allocation %d",
239 skeleton_eventdev_port_release(dev->data->ports[port_id]);
240 dev->data->ports[port_id] = NULL;
243 /* Allocate event port memory */
244 sp = rte_zmalloc_socket("eventdev port",
245 sizeof(struct skeleton_port), RTE_CACHE_LINE_SIZE,
246 dev->data->socket_id);
248 PMD_DRV_ERR("Failed to allocate sp port_id=%d", port_id);
252 sp->port_id = port_id;
254 PMD_DRV_LOG(DEBUG, "[%d] sp=%p", port_id, sp);
256 dev->data->ports[port_id] = sp;
261 skeleton_eventdev_port_link(struct rte_eventdev *dev, void *port,
262 const uint8_t queues[], const uint8_t priorities[],
265 struct skeleton_port *sp = port;
266 PMD_DRV_FUNC_TRACE();
270 RTE_SET_USED(queues);
271 RTE_SET_USED(priorities);
273 /* Linked all the queues */
274 return (int)nb_links;
278 skeleton_eventdev_port_unlink(struct rte_eventdev *dev, void *port,
279 uint8_t queues[], uint16_t nb_unlinks)
281 struct skeleton_port *sp = port;
282 PMD_DRV_FUNC_TRACE();
286 RTE_SET_USED(queues);
288 /* Unlinked all the queues */
289 return (int)nb_unlinks;
294 skeleton_eventdev_timeout_ticks(struct rte_eventdev *dev, uint64_t ns,
295 uint64_t *timeout_ticks)
297 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
300 PMD_DRV_FUNC_TRACE();
303 *timeout_ticks = ns * scale;
309 skeleton_eventdev_dump(struct rte_eventdev *dev, FILE *f)
311 struct skeleton_eventdev *skel = skeleton_pmd_priv(dev);
313 PMD_DRV_FUNC_TRACE();
320 /* Initialize and register event driver with DPDK Application */
321 static const struct rte_eventdev_ops skeleton_eventdev_ops = {
322 .dev_infos_get = skeleton_eventdev_info_get,
323 .dev_configure = skeleton_eventdev_configure,
324 .dev_start = skeleton_eventdev_start,
325 .dev_stop = skeleton_eventdev_stop,
326 .dev_close = skeleton_eventdev_close,
327 .queue_def_conf = skeleton_eventdev_queue_def_conf,
328 .queue_setup = skeleton_eventdev_queue_setup,
329 .queue_release = skeleton_eventdev_queue_release,
330 .port_def_conf = skeleton_eventdev_port_def_conf,
331 .port_setup = skeleton_eventdev_port_setup,
332 .port_release = skeleton_eventdev_port_release,
333 .port_link = skeleton_eventdev_port_link,
334 .port_unlink = skeleton_eventdev_port_unlink,
335 .timeout_ticks = skeleton_eventdev_timeout_ticks,
336 .dump = skeleton_eventdev_dump
340 skeleton_eventdev_init(struct rte_eventdev *eventdev)
342 struct rte_pci_device *pci_dev;
343 struct skeleton_eventdev *skel = skeleton_pmd_priv(eventdev);
346 PMD_DRV_FUNC_TRACE();
348 eventdev->dev_ops = &skeleton_eventdev_ops;
349 eventdev->enqueue = skeleton_eventdev_enqueue;
350 eventdev->enqueue_burst = skeleton_eventdev_enqueue_burst;
351 eventdev->dequeue = skeleton_eventdev_dequeue;
352 eventdev->dequeue_burst = skeleton_eventdev_dequeue_burst;
354 /* For secondary processes, the primary has done all the work */
355 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
358 pci_dev = RTE_DEV_TO_PCI(eventdev->dev);
360 skel->reg_base = (uintptr_t)pci_dev->mem_resource[0].addr;
361 if (!skel->reg_base) {
362 PMD_DRV_ERR("Failed to map BAR0");
367 skel->device_id = pci_dev->id.device_id;
368 skel->vendor_id = pci_dev->id.vendor_id;
369 skel->subsystem_device_id = pci_dev->id.subsystem_device_id;
370 skel->subsystem_vendor_id = pci_dev->id.subsystem_vendor_id;
372 PMD_DRV_LOG(DEBUG, "pci device (%x:%x) %u:%u:%u:%u",
373 pci_dev->id.vendor_id, pci_dev->id.device_id,
374 pci_dev->addr.domain, pci_dev->addr.bus,
375 pci_dev->addr.devid, pci_dev->addr.function);
377 PMD_DRV_LOG(INFO, "dev_id=%d socket_id=%d (%x:%x)",
378 eventdev->data->dev_id, eventdev->data->socket_id,
379 skel->vendor_id, skel->device_id);
385 /* PCI based event device */
387 #define EVENTDEV_SKEL_VENDOR_ID 0x177d
388 #define EVENTDEV_SKEL_PRODUCT_ID 0x0001
390 static const struct rte_pci_id pci_id_skeleton_map[] = {
392 RTE_PCI_DEVICE(EVENTDEV_SKEL_VENDOR_ID,
393 EVENTDEV_SKEL_PRODUCT_ID)
401 event_skeleton_pci_probe(struct rte_pci_driver *pci_drv,
402 struct rte_pci_device *pci_dev)
404 return rte_event_pmd_pci_probe(pci_drv, pci_dev,
405 sizeof(struct skeleton_eventdev), skeleton_eventdev_init);
409 event_skeleton_pci_remove(struct rte_pci_device *pci_dev)
411 return rte_event_pmd_pci_remove(pci_dev, NULL);
414 static struct rte_pci_driver pci_eventdev_skeleton_pmd = {
415 .id_table = pci_id_skeleton_map,
416 .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
417 .probe = event_skeleton_pci_probe,
418 .remove = event_skeleton_pci_remove,
421 RTE_PMD_REGISTER_PCI(event_skeleton_pci, pci_eventdev_skeleton_pmd);
422 RTE_PMD_REGISTER_PCI_TABLE(event_skeleton_pci, pci_id_skeleton_map);
424 /* VDEV based event device */
427 skeleton_eventdev_create(const char *name, int socket_id)
429 struct rte_eventdev *eventdev;
431 eventdev = rte_event_pmd_vdev_init(name,
432 sizeof(struct skeleton_eventdev), socket_id);
433 if (eventdev == NULL) {
434 PMD_DRV_ERR("Failed to create eventdev vdev %s", name);
438 eventdev->dev_ops = &skeleton_eventdev_ops;
439 eventdev->enqueue = skeleton_eventdev_enqueue;
440 eventdev->enqueue_burst = skeleton_eventdev_enqueue_burst;
441 eventdev->dequeue = skeleton_eventdev_dequeue;
442 eventdev->dequeue_burst = skeleton_eventdev_dequeue_burst;
450 skeleton_eventdev_probe(struct rte_vdev_device *vdev)
454 name = rte_vdev_device_name(vdev);
455 RTE_LOG(INFO, PMD, "Initializing %s on NUMA node %d\n", name,
457 return skeleton_eventdev_create(name, rte_socket_id());
461 skeleton_eventdev_remove(struct rte_vdev_device *vdev)
465 name = rte_vdev_device_name(vdev);
466 PMD_DRV_LOG(INFO, "Closing %s on NUMA node %d", name, rte_socket_id());
468 return rte_event_pmd_vdev_uninit(name);
471 static struct rte_vdev_driver vdev_eventdev_skeleton_pmd = {
472 .probe = skeleton_eventdev_probe,
473 .remove = skeleton_eventdev_remove
476 RTE_PMD_REGISTER_VDEV(EVENTDEV_NAME_SKELETON_PMD, vdev_eventdev_skeleton_pmd);