net/sfc: support TSO in EF10 Tx datapath
[dpdk.git] / drivers / event / opdl / opdl_evdev.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Intel Corporation
3  */
4
5 #include <inttypes.h>
6 #include <string.h>
7
8 #include <rte_bus_vdev.h>
9 #include <rte_lcore.h>
10 #include <rte_memzone.h>
11 #include <rte_kvargs.h>
12 #include <rte_errno.h>
13 #include <rte_cycles.h>
14
15 #include "opdl_evdev.h"
16 #include "opdl_ring.h"
17 #include "opdl_log.h"
18
19 #define EVENTDEV_NAME_OPDL_PMD event_opdl
20 #define NUMA_NODE_ARG "numa_node"
21 #define DO_VALIDATION_ARG "do_validation"
22 #define DO_TEST_ARG "self_test"
23
24
25 static void
26 opdl_info_get(struct rte_eventdev *dev, struct rte_event_dev_info *info);
27
28 uint16_t
29 opdl_event_enqueue_burst(void *port,
30                          const struct rte_event ev[],
31                          uint16_t num)
32 {
33         struct opdl_port *p = port;
34
35         if (unlikely(!p->opdl->data->dev_started))
36                 return 0;
37
38
39         /* either rx_enqueue or disclaim*/
40         return p->enq(p, ev, num);
41 }
42
43 uint16_t
44 opdl_event_enqueue(void *port, const struct rte_event *ev)
45 {
46         struct opdl_port *p = port;
47
48         if (unlikely(!p->opdl->data->dev_started))
49                 return 0;
50
51
52         return p->enq(p, ev, 1);
53 }
54
55 uint16_t
56 opdl_event_dequeue_burst(void *port,
57                          struct rte_event *ev,
58                          uint16_t num,
59                          uint64_t wait)
60 {
61         struct opdl_port *p = (void *)port;
62
63         RTE_SET_USED(wait);
64
65         if (unlikely(!p->opdl->data->dev_started))
66                 return 0;
67
68         /* This function pointer can point to tx_dequeue or claim*/
69         return p->deq(p, ev, num);
70 }
71
72 uint16_t
73 opdl_event_dequeue(void *port,
74                    struct rte_event *ev,
75                    uint64_t wait)
76 {
77         struct opdl_port *p = (void *)port;
78
79         if (unlikely(!p->opdl->data->dev_started))
80                 return 0;
81
82         RTE_SET_USED(wait);
83
84         return p->deq(p, ev, 1);
85 }
86
87 static int
88 opdl_port_link(struct rte_eventdev *dev,
89                void *port,
90                const uint8_t queues[],
91                const uint8_t priorities[],
92                uint16_t num)
93 {
94         struct opdl_port *p = port;
95
96         RTE_SET_USED(priorities);
97         RTE_SET_USED(dev);
98
99         if (unlikely(dev->data->dev_started)) {
100                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
101                              "Attempt to link queue (%u) to port %d while device started\n",
102                              dev->data->dev_id,
103                                 queues[0],
104                                 p->id);
105                 rte_errno = -EINVAL;
106                 return 0;
107         }
108
109         /* Max of 1 queue per port */
110         if (num > 1) {
111                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
112                              "Attempt to link more than one queue (%u) to port %d requested\n",
113                              dev->data->dev_id,
114                                 num,
115                                 p->id);
116                 rte_errno = -EDQUOT;
117                 return 0;
118         }
119
120         if (!p->configured) {
121                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
122                              "port %d not configured, cannot link to %u\n",
123                              dev->data->dev_id,
124                                 p->id,
125                                 queues[0]);
126                 rte_errno = -EINVAL;
127                 return 0;
128         }
129
130         if (p->external_qid != OPDL_INVALID_QID) {
131                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
132                              "port %d already linked to queue %u, cannot link to %u\n",
133                              dev->data->dev_id,
134                                 p->id,
135                                 p->external_qid,
136                                 queues[0]);
137                 rte_errno = -EINVAL;
138                 return 0;
139         }
140
141         p->external_qid = queues[0];
142
143         return 1;
144 }
145
146 static int
147 opdl_port_unlink(struct rte_eventdev *dev,
148                  void *port,
149                  uint8_t queues[],
150                  uint16_t nb_unlinks)
151 {
152         struct opdl_port *p = port;
153
154         RTE_SET_USED(queues);
155         RTE_SET_USED(nb_unlinks);
156
157         if (unlikely(dev->data->dev_started)) {
158                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
159                              "Attempt to unlink queue (%u) to port %d while device started\n",
160                              dev->data->dev_id,
161                              queues[0],
162                              p->id);
163                 rte_errno = -EINVAL;
164                 return 0;
165         }
166         RTE_SET_USED(nb_unlinks);
167
168         /* Port Stuff */
169         p->queue_id = OPDL_INVALID_QID;
170         p->p_type = OPDL_INVALID_PORT;
171         p->external_qid = OPDL_INVALID_QID;
172
173         /* always unlink 0 queue due to statice pipeline */
174         return 0;
175 }
176
177 static int
178 opdl_port_setup(struct rte_eventdev *dev,
179                 uint8_t port_id,
180                 const struct rte_event_port_conf *conf)
181 {
182         struct opdl_evdev *device = opdl_pmd_priv(dev);
183         struct opdl_port *p = &device->ports[port_id];
184
185         RTE_SET_USED(conf);
186
187         /* Check if port already configured */
188         if (p->configured) {
189                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
190                              "Attempt to setup port %d which is already setup\n",
191                              dev->data->dev_id,
192                              p->id);
193                 return -EDQUOT;
194         }
195
196         *p = (struct opdl_port){0}; /* zero entire structure */
197         p->id = port_id;
198         p->opdl = device;
199         p->queue_id = OPDL_INVALID_QID;
200         p->external_qid = OPDL_INVALID_QID;
201         dev->data->ports[port_id] = p;
202         rte_smp_wmb();
203         p->configured = 1;
204         device->nb_ports++;
205         return 0;
206 }
207
208 static void
209 opdl_port_release(void *port)
210 {
211         struct opdl_port *p = (void *)port;
212
213         if (p == NULL ||
214             p->opdl->data->dev_started) {
215                 return;
216         }
217
218         p->configured = 0;
219         p->initialized = 0;
220 }
221
222 static void
223 opdl_port_def_conf(struct rte_eventdev *dev, uint8_t port_id,
224                 struct rte_event_port_conf *port_conf)
225 {
226         RTE_SET_USED(dev);
227         RTE_SET_USED(port_id);
228
229         port_conf->new_event_threshold = MAX_OPDL_CONS_Q_DEPTH;
230         port_conf->dequeue_depth = MAX_OPDL_CONS_Q_DEPTH;
231         port_conf->enqueue_depth = MAX_OPDL_CONS_Q_DEPTH;
232 }
233
234 static int
235 opdl_queue_setup(struct rte_eventdev *dev,
236                  uint8_t queue_id,
237                  const struct rte_event_queue_conf *conf)
238 {
239         enum queue_type type;
240
241         struct opdl_evdev *device = opdl_pmd_priv(dev);
242
243         /* Extra sanity check, probably not needed */
244         if (queue_id == OPDL_INVALID_QID) {
245                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
246                              "Invalid queue id %u requested\n",
247                              dev->data->dev_id,
248                              queue_id);
249                 return -EINVAL;
250         }
251
252         if (device->nb_q_md > device->max_queue_nb) {
253                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
254                              "Max number of queues %u exceeded by request %u\n",
255                              dev->data->dev_id,
256                              device->max_queue_nb,
257                              device->nb_q_md);
258                 return -EINVAL;
259         }
260
261         if (RTE_EVENT_QUEUE_CFG_ALL_TYPES
262             & conf->event_queue_cfg) {
263                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
264                              "QUEUE_CFG_ALL_TYPES not supported\n",
265                              dev->data->dev_id);
266                 return -ENOTSUP;
267         } else if (RTE_EVENT_QUEUE_CFG_SINGLE_LINK
268                    & conf->event_queue_cfg) {
269                 type = OPDL_Q_TYPE_SINGLE_LINK;
270         } else {
271                 switch (conf->schedule_type) {
272                 case RTE_SCHED_TYPE_ORDERED:
273                         type = OPDL_Q_TYPE_ORDERED;
274                         break;
275                 case RTE_SCHED_TYPE_ATOMIC:
276                         type = OPDL_Q_TYPE_ATOMIC;
277                         break;
278                 case RTE_SCHED_TYPE_PARALLEL:
279                         type = OPDL_Q_TYPE_ORDERED;
280                         break;
281                 default:
282                         PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
283                                      "Unknown queue type %d requested\n",
284                                      dev->data->dev_id,
285                                      conf->event_queue_cfg);
286                         return -EINVAL;
287                 }
288         }
289         /* Check if queue id has been setup already */
290         uint32_t i;
291         for (i = 0; i < device->nb_q_md; i++) {
292                 if (device->q_md[i].ext_id == queue_id) {
293                         PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
294                                      "queue id %u already setup\n",
295                                      dev->data->dev_id,
296                                      queue_id);
297                         return -EINVAL;
298                 }
299         }
300
301         device->q_md[device->nb_q_md].ext_id = queue_id;
302         device->q_md[device->nb_q_md].type = type;
303         device->q_md[device->nb_q_md].setup = 1;
304         device->nb_q_md++;
305
306         return 1;
307 }
308
309 static void
310 opdl_queue_release(struct rte_eventdev *dev, uint8_t queue_id)
311 {
312         struct opdl_evdev *device = opdl_pmd_priv(dev);
313
314         RTE_SET_USED(queue_id);
315
316         if (device->data->dev_started)
317                 return;
318
319 }
320
321 static void
322 opdl_queue_def_conf(struct rte_eventdev *dev,
323                     uint8_t queue_id,
324                     struct rte_event_queue_conf *conf)
325 {
326         RTE_SET_USED(dev);
327         RTE_SET_USED(queue_id);
328
329         static const struct rte_event_queue_conf default_conf = {
330                 .nb_atomic_flows = 1024,
331                 .nb_atomic_order_sequences = 1,
332                 .event_queue_cfg = 0,
333                 .schedule_type = RTE_SCHED_TYPE_ORDERED,
334                 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
335         };
336
337         *conf = default_conf;
338 }
339
340
341 static int
342 opdl_dev_configure(const struct rte_eventdev *dev)
343 {
344         struct opdl_evdev *opdl = opdl_pmd_priv(dev);
345         const struct rte_eventdev_data *data = dev->data;
346         const struct rte_event_dev_config *conf = &data->dev_conf;
347
348         opdl->max_queue_nb = conf->nb_event_queues;
349         opdl->max_port_nb = conf->nb_event_ports;
350         opdl->nb_events_limit = conf->nb_events_limit;
351
352         if (conf->event_dev_cfg & RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT) {
353                 PMD_DRV_LOG(ERR, "DEV_ID:[%02d] : "
354                              "DEQUEUE_TIMEOUT not supported\n",
355                              dev->data->dev_id);
356                 return -ENOTSUP;
357         }
358
359         return 0;
360 }
361
362 static void
363 opdl_info_get(struct rte_eventdev *dev, struct rte_event_dev_info *info)
364 {
365         RTE_SET_USED(dev);
366
367         static const struct rte_event_dev_info evdev_opdl_info = {
368                 .driver_name = OPDL_PMD_NAME,
369                 .max_event_queues = RTE_EVENT_MAX_QUEUES_PER_DEV,
370                 .max_event_queue_flows = OPDL_QID_NUM_FIDS,
371                 .max_event_queue_priority_levels = OPDL_Q_PRIORITY_MAX,
372                 .max_event_priority_levels = OPDL_IQS_MAX,
373                 .max_event_ports = OPDL_PORTS_MAX,
374                 .max_event_port_dequeue_depth = MAX_OPDL_CONS_Q_DEPTH,
375                 .max_event_port_enqueue_depth = MAX_OPDL_CONS_Q_DEPTH,
376                 .max_num_events = OPDL_INFLIGHT_EVENTS_TOTAL,
377                 .event_dev_cap = RTE_EVENT_DEV_CAP_BURST_MODE,
378         };
379
380         *info = evdev_opdl_info;
381 }
382
383 static void
384 opdl_dump(struct rte_eventdev *dev, FILE *f)
385 {
386         struct opdl_evdev *device = opdl_pmd_priv(dev);
387
388         if (!device->do_validation)
389                 return;
390
391         fprintf(f,
392                 "\n\n -- RING STATISTICS --\n");
393         uint32_t i;
394         for (i = 0; i < device->nb_opdls; i++)
395                 opdl_ring_dump(device->opdl[i], f);
396
397         fprintf(f,
398                 "\n\n -- PORT STATISTICS --\n"
399                 "Type Port Index  Port Id  Queue Id     Av. Req Size  "
400                 "Av. Grant Size     Av. Cycles PP"
401                 "      Empty DEQs   Non Empty DEQs   Pkts Processed\n");
402
403         for (i = 0; i < device->max_port_nb; i++) {
404                 char queue_id[64];
405                 char total_cyc[64];
406                 const char *p_type;
407
408                 uint64_t cne, cpg;
409                 struct opdl_port *port = &device->ports[i];
410
411                 if (port->initialized) {
412                         cne = port->port_stat[claim_non_empty];
413                         cpg = port->port_stat[claim_pkts_granted];
414                         if (port->p_type == OPDL_REGULAR_PORT)
415                                 p_type = "REG";
416                         else if (port->p_type == OPDL_PURE_RX_PORT)
417                                 p_type = "  RX";
418                         else if (port->p_type == OPDL_PURE_TX_PORT)
419                                 p_type = "  TX";
420                         else if (port->p_type == OPDL_ASYNC_PORT)
421                                 p_type = "SYNC";
422                         else
423                                 p_type = "????";
424
425                         sprintf(queue_id, "%02u", port->external_qid);
426                         if (port->p_type == OPDL_REGULAR_PORT ||
427                                         port->p_type == OPDL_ASYNC_PORT)
428                                 sprintf(total_cyc,
429                                         " %'16"PRIu64"",
430                                         (cpg != 0 ?
431                                          port->port_stat[total_cycles] / cpg
432                                          : 0));
433                         else
434                                 sprintf(total_cyc,
435                                         "             ----");
436                         fprintf(f,
437                                 "%4s %10u %8u %9s %'16"PRIu64" %'16"PRIu64" %s "
438                                 "%'16"PRIu64" %'16"PRIu64" %'16"PRIu64"\n",
439                                 p_type,
440                                 i,
441                                 port->id,
442                                 (port->external_qid == OPDL_INVALID_QID ? "---"
443                                  : queue_id),
444                                 (cne != 0 ?
445                                  port->port_stat[claim_pkts_requested] / cne
446                                  : 0),
447                                 (cne != 0 ?
448                                  port->port_stat[claim_pkts_granted] / cne
449                                  : 0),
450                                 total_cyc,
451                                 port->port_stat[claim_empty],
452                                 port->port_stat[claim_non_empty],
453                                 port->port_stat[claim_pkts_granted]);
454                 }
455         }
456         fprintf(f, "\n");
457 }
458
459
460 static void
461 opdl_stop(struct rte_eventdev *dev)
462 {
463         struct opdl_evdev *device = opdl_pmd_priv(dev);
464
465         opdl_xstats_uninit(dev);
466
467         destroy_queues_and_rings(dev);
468
469
470         device->started = 0;
471
472         rte_smp_wmb();
473 }
474
475 static int
476 opdl_start(struct rte_eventdev *dev)
477 {
478         int err = 0;
479
480         if (!err)
481                 err = create_queues_and_rings(dev);
482
483
484         if (!err)
485                 err = assign_internal_queue_ids(dev);
486
487
488         if (!err)
489                 err = initialise_queue_zero_ports(dev);
490
491
492         if (!err)
493                 err = initialise_all_other_ports(dev);
494
495
496         if (!err)
497                 err = check_queues_linked(dev);
498
499
500         if (!err)
501                 err = opdl_add_event_handlers(dev);
502
503
504         if (!err)
505                 err = build_all_dependencies(dev);
506
507         if (!err) {
508                 opdl_xstats_init(dev);
509
510                 struct opdl_evdev *device = opdl_pmd_priv(dev);
511
512                 PMD_DRV_LOG(INFO, "DEV_ID:[%02d] : "
513                               "SUCCESS : Created %u total queues (%u ex, %u in),"
514                               " %u opdls, %u event_dev ports, %u input ports",
515                               opdl_pmd_dev_id(device),
516                               device->nb_queues,
517                               (device->nb_queues - device->nb_opdls),
518                               device->nb_opdls,
519                               device->nb_opdls,
520                               device->nb_ports,
521                               device->queue[0].nb_ports);
522         } else
523                 opdl_stop(dev);
524
525         return err;
526 }
527
528 static int
529 opdl_close(struct rte_eventdev *dev)
530 {
531         struct opdl_evdev *device = opdl_pmd_priv(dev);
532         uint32_t i;
533
534         for (i = 0; i < device->max_port_nb; i++) {
535                 memset(&device->ports[i],
536                        0,
537                        sizeof(struct opdl_port));
538         }
539
540         memset(&device->s_md,
541                         0x0,
542                         sizeof(struct opdl_stage_meta_data)*OPDL_PORTS_MAX);
543
544         memset(&device->q_md,
545                         0xFF,
546                         sizeof(struct opdl_queue_meta_data)*OPDL_MAX_QUEUES);
547
548
549         memset(device->q_map_ex_to_in,
550                         0,
551                         sizeof(uint8_t)*OPDL_INVALID_QID);
552
553         opdl_xstats_uninit(dev);
554
555         device->max_port_nb = 0;
556
557         device->max_queue_nb = 0;
558
559         device->nb_opdls = 0;
560
561         device->nb_queues   = 0;
562
563         device->nb_ports    = 0;
564
565         device->nb_q_md     = 0;
566
567         dev->data->nb_queues = 0;
568
569         dev->data->nb_ports = 0;
570
571
572         return 0;
573 }
574
575 static int
576 assign_numa_node(const char *key __rte_unused, const char *value, void *opaque)
577 {
578         int *socket_id = opaque;
579         *socket_id = atoi(value);
580         if (*socket_id >= RTE_MAX_NUMA_NODES)
581                 return -1;
582         return 0;
583 }
584
585 static int
586 set_do_validation(const char *key __rte_unused, const char *value, void *opaque)
587 {
588         int *do_val = opaque;
589         *do_val = atoi(value);
590         if (*do_val != 0)
591                 *do_val = 1;
592
593         return 0;
594 }
595 static int
596 set_do_test(const char *key __rte_unused, const char *value, void *opaque)
597 {
598         int *do_test = opaque;
599
600         *do_test = atoi(value);
601
602         if (*do_test != 0)
603                 *do_test = 1;
604         return 0;
605 }
606
607 static int
608 opdl_probe(struct rte_vdev_device *vdev)
609 {
610         static struct rte_eventdev_ops evdev_opdl_ops = {
611                 .dev_configure = opdl_dev_configure,
612                 .dev_infos_get = opdl_info_get,
613                 .dev_close = opdl_close,
614                 .dev_start = opdl_start,
615                 .dev_stop = opdl_stop,
616                 .dump = opdl_dump,
617
618                 .queue_def_conf = opdl_queue_def_conf,
619                 .queue_setup = opdl_queue_setup,
620                 .queue_release = opdl_queue_release,
621                 .port_def_conf = opdl_port_def_conf,
622                 .port_setup = opdl_port_setup,
623                 .port_release = opdl_port_release,
624                 .port_link = opdl_port_link,
625                 .port_unlink = opdl_port_unlink,
626
627
628                 .xstats_get = opdl_xstats_get,
629                 .xstats_get_names = opdl_xstats_get_names,
630                 .xstats_get_by_name = opdl_xstats_get_by_name,
631                 .xstats_reset = opdl_xstats_reset,
632         };
633
634         static const char *const args[] = {
635                 NUMA_NODE_ARG,
636                 DO_VALIDATION_ARG,
637                 DO_TEST_ARG,
638                 NULL
639         };
640         const char *name;
641         const char *params;
642         struct rte_eventdev *dev;
643         struct opdl_evdev *opdl;
644         int socket_id = rte_socket_id();
645         int do_validation = 0;
646         int do_test = 0;
647         int str_len;
648         int test_result = 0;
649
650         name = rte_vdev_device_name(vdev);
651         params = rte_vdev_device_args(vdev);
652         if (params != NULL && params[0] != '\0') {
653                 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
654
655                 if (!kvlist) {
656                         PMD_DRV_LOG(INFO,
657                                         "Ignoring unsupported parameters when creating device '%s'\n",
658                                         name);
659                 } else {
660                         int ret = rte_kvargs_process(kvlist, NUMA_NODE_ARG,
661                                         assign_numa_node, &socket_id);
662                         if (ret != 0) {
663                                 PMD_DRV_LOG(ERR,
664                                                 "%s: Error parsing numa node parameter",
665                                                 name);
666
667                                 rte_kvargs_free(kvlist);
668                                 return ret;
669                         }
670
671                         ret = rte_kvargs_process(kvlist, DO_VALIDATION_ARG,
672                                         set_do_validation, &do_validation);
673                         if (ret != 0) {
674                                 PMD_DRV_LOG(ERR,
675                                         "%s: Error parsing do validation parameter",
676                                         name);
677                                 rte_kvargs_free(kvlist);
678                                 return ret;
679                         }
680
681                         ret = rte_kvargs_process(kvlist, DO_TEST_ARG,
682                                         set_do_test, &do_test);
683                         if (ret != 0) {
684                                 PMD_DRV_LOG(ERR,
685                                         "%s: Error parsing do test parameter",
686                                         name);
687                                 rte_kvargs_free(kvlist);
688                                 return ret;
689                         }
690
691                         rte_kvargs_free(kvlist);
692                 }
693         }
694         dev = rte_event_pmd_vdev_init(name,
695                         sizeof(struct opdl_evdev), socket_id);
696
697         if (dev == NULL) {
698                 PMD_DRV_LOG(ERR, "eventdev vdev init() failed");
699                 return -EFAULT;
700         }
701
702         PMD_DRV_LOG(INFO, "DEV_ID:[%02d] : "
703                       "Success - creating eventdev device %s, numa_node:[%d], do_valdation:[%s]"
704                           " , self_test:[%s]\n",
705                       dev->data->dev_id,
706                       name,
707                       socket_id,
708                       (do_validation ? "true" : "false"),
709                           (do_test ? "true" : "false"));
710
711         dev->dev_ops = &evdev_opdl_ops;
712
713         dev->enqueue = opdl_event_enqueue;
714         dev->enqueue_burst = opdl_event_enqueue_burst;
715         dev->enqueue_new_burst = opdl_event_enqueue_burst;
716         dev->enqueue_forward_burst = opdl_event_enqueue_burst;
717         dev->dequeue = opdl_event_dequeue;
718         dev->dequeue_burst = opdl_event_dequeue_burst;
719
720         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
721                 return 0;
722
723         opdl = dev->data->dev_private;
724         opdl->data = dev->data;
725         opdl->socket = socket_id;
726         opdl->do_validation = do_validation;
727         opdl->do_test = do_test;
728         str_len = strlen(name);
729         memcpy(opdl->service_name, name, str_len);
730
731         if (do_test == 1)
732                 test_result =  opdl_selftest();
733
734         return test_result;
735 }
736
737 static int
738 opdl_remove(struct rte_vdev_device *vdev)
739 {
740         const char *name;
741
742         name = rte_vdev_device_name(vdev);
743         if (name == NULL)
744                 return -EINVAL;
745
746         PMD_DRV_LOG(INFO, "Closing eventdev opdl device %s\n", name);
747
748         return rte_event_pmd_vdev_uninit(name);
749 }
750
751 static struct rte_vdev_driver evdev_opdl_pmd_drv = {
752         .probe = opdl_probe,
753         .remove = opdl_remove
754 };
755
756 RTE_INIT(opdl_init_log)
757 {
758         opdl_logtype_driver = rte_log_register("pmd.event.opdl.driver");
759         if (opdl_logtype_driver >= 0)
760                 rte_log_set_level(opdl_logtype_driver, RTE_LOG_INFO);
761 }
762
763
764 RTE_PMD_REGISTER_VDEV(EVENTDEV_NAME_OPDL_PMD, evdev_opdl_pmd_drv);
765 RTE_PMD_REGISTER_PARAM_STRING(event_opdl, NUMA_NODE_ARG "=<int>"
766                               DO_VALIDATION_ARG "=<int>" DO_TEST_ARG "=<int>");