1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Cavium, Inc.
3 * Copyright(c) 2017-2018 Intel Corporation.
4 * All rights reserved.
5 */
6
7 #ifndef __RTE_EVENT_TIMER_ADAPTER_H__
8 #define __RTE_EVENT_TIMER_ADAPTER_H__
9
10 /**
11 * @file
12 *
13 * RTE Event Timer Adapter
14 *
15 * An event timer adapter has the following abstract working model:
16 *
17 * timer_tick_ns
18 * +
19 * +-------+ |
20 * | | |
21 * +-------+ bkt 0 +----v---+
22 * | | | |
23 * | +-------+ |
24 * +---+---+ +---+---+ +---+---+---+---+
25 * | | | | | | | | |
26 * | bkt n | | bkt 1 |<-> t0| t1| t2| tn|
27 * | | | | | | | | |
28 * +---+---+ +---+---+ +---+---+---+---+
29 * | Timer adapter |
30 * +---+---+ +---+---+
31 * | | | |
32 * | bkt 4 | | bkt 2 |<--- Current bucket
33 * | | | |
34 * +---+---+ +---+---+
35 * | +-------+ |
36 * | | | |
37 * +------+ bkt 3 +-------+
38 * | |
39 * +-------+
40 *
41 * - It has a virtual monotonically increasing 64-bit timer adapter clock based
42 * on *enum rte_event_timer_adapter_clk_src* clock source. The clock source
43 * could be a CPU clock, or a platform dependent external clock.
44 *
45 * - The application creates a timer adapter instance with given the clock
46 * source, the total number of event timers, and a resolution(expressed in ns)
47 * to traverse between the buckets.
48 *
49 * - Each timer adapter may have 0 to n buckets based on the configured
50 * max timeout(max_tmo_ns) and resolution(timer_tick_ns). Upon starting the
51 * timer adapter, the adapter starts ticking at *timer_tick_ns* resolution.
52 *
53 * - The application arms an event timer that will expire *timer_tick_ns*
54 * from now.
55 *
56 * - The application can cancel an armed timer and no timer expiry event will be
57 * generated.
58 *
59 * - If a timer expires then the library injects the timer expiry event in
60 * the designated event queue.
61 *
62 * - The timer expiry event will be received through *rte_event_dequeue_burst*.
63 *
64 * - The application frees the timer adapter instance.
65 *
66 * Multiple timer adapters can be created with a varying level of resolution
67 * for various expiry use cases that run in parallel.
68 *
69 * Before using the timer adapter, the application has to create and configure
70 * an event device along with the event port. Based on the event device
71 * capability it might require creating an additional event port to be used
72 * by the timer adapter.
73 *
74 * The application creates the event timer adapter using the
75 * ``rte_event_timer_adapter_create()``. The event device id is passed to this
76 * function, inside this function the event device capability is checked,
77 * and if an in-built port is absent the application uses the default
78 * function to create a new producer port.
79 *
80 * The application may also use the function
81 * ``rte_event_timer_adapter_create_ext()`` to have granular control over
82 * producer port creation in a case where the in-built port is absent.
83 *
84 * After creating the timer adapter, the application has to start it
85 * using ``rte_event_timer_adapter_start()``. The buckets are traversed from
86 * 0 to n; when the adapter ticks, the next bucket is visited. Each time,
87 * the list per bucket is processed, and timer expiry events are sent to the
88 * designated event queue.
89 *
90 * The application can arm one or more event timers using the
91 * ``rte_event_timer_arm_burst()``. The *timeout_ticks* represents the number
92 * of *timer_tick_ns* after which the timer has to expire. The timeout at
93 * which the timers expire can be grouped or be independent of each
94 * event timer instance. ``rte_event_timer_arm_tmo_tick_burst()`` addresses the
95 * former case and ``rte_event_timer_arm_burst()`` addresses the latter case.
96 *
97 * The application can cancel the timers from expiring using the
98 * ``rte_event_timer_cancel_burst()``.
99 *
100 * On the secondary process, ``rte_event_timer_adapter_lookup()`` can be used
101 * to get the timer adapter pointer from its id and use it to invoke fastpath
102 * operations such as arm and cancel.
103 *
104 * Some of the use cases of event timer adapter are Beacon Timers,
105 * Generic SW Timeout, Wireless MAC Scheduling, 3G Frame Protocols,
106 * Packet Scheduling, Protocol Retransmission Timers, Supervision Timers.
107 * All these use cases require high resolution and low time drift.
108 */
109
110 #ifdef __cplusplus
111 extern "C" {
112 #endif
113
114
115 #include "rte_eventdev.h"
116 #include "rte_eventdev_trace_fp.h"
117
118 /**
119 * Timer adapter clock source
120 */
121 enum rte_event_timer_adapter_clk_src {
122 RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
123 /**< Use CPU clock as the clock source. */
124 RTE_EVENT_TIMER_ADAPTER_EXT_CLK0,
125 /**< Platform dependent external clock source 0. */
126 RTE_EVENT_TIMER_ADAPTER_EXT_CLK1,
127 /**< Platform dependent external clock source 1. */
128 RTE_EVENT_TIMER_ADAPTER_EXT_CLK2,
129 /**< Platform dependent external clock source 2. */
130 RTE_EVENT_TIMER_ADAPTER_EXT_CLK3,
131 /**< Platform dependent external clock source 3. */
132 };
133
134 #define RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES (1ULL << 0)
135 /**< The event timer adapter implementation may have constraints on the
136 * resolution (timer_tick_ns) and maximum timer expiry timeout(max_tmo_ns)
137 * based on the given timer adapter or system. If this flag is set, the
138 * implementation adjusts the resolution and maximum timeout to the best
139 * possible configuration. On successful timer adapter creation, the
140 * application can get the configured resolution and max timeout with
141 * ``rte_event_timer_adapter_get_info()``.
142 *
143 * @see struct rte_event_timer_adapter_info::min_resolution_ns
144 * @see struct rte_event_timer_adapter_info::max_tmo_ns
145 */
146 #define RTE_EVENT_TIMER_ADAPTER_F_SP_PUT (1ULL << 1)
147 /**< ``rte_event_timer_arm_burst()`` API to be used in single producer mode.
148 *
149 * @see struct rte_event_timer_adapter_conf::flags
150 */
151
152 #define RTE_EVENT_TIMER_ADAPTER_F_PERIODIC (1ULL << 2)
153 /**< Flag to configure an event timer adapter in periodic mode; non-periodic
154 * mode is the default. A timer will fire once or periodically until the timer
155 * is cancelled based on the adapter mode.
156 *
157 * @see struct rte_event_timer_adapter_conf::flags
158 */
159
160 /**
161 * Timer adapter configuration structure
162 */
163 struct rte_event_timer_adapter_conf {
164 uint8_t event_dev_id;
165 /**< Event device identifier */
166 uint16_t timer_adapter_id;
167 /**< Event timer adapter identifier */
168 uint32_t socket_id;
169 /**< Identifier of socket from which to allocate memory for adapter */
170 enum rte_event_timer_adapter_clk_src clk_src;
171 /**< Clock source for timer adapter */
172 uint64_t timer_tick_ns;
173 /**< Timer adapter resolution in ns */
174 uint64_t max_tmo_ns;
175 /**< Maximum timer timeout(expiry) in ns */
176 uint64_t nb_timers;
177 /**< Total number of timers per adapter */
178 uint64_t flags;
179 /**< Timer adapter config flags (RTE_EVENT_TIMER_ADAPTER_F_*) */
180 };
181
182 /**
183 * Event timer adapter stats structure
184 */
185 struct rte_event_timer_adapter_stats {
186 uint64_t evtim_exp_count;
187 /**< Number of event timers that have expired. */
188 uint64_t ev_enq_count;
189 /**< Eventdev enqueue count */
190 uint64_t ev_inv_count;
191 /**< Invalid expiry event count */
192 uint64_t evtim_retry_count;
193 /**< Event timer retry count */
194 uint64_t adapter_tick_count;
195 /**< Tick count for the adapter, at its resolution */
196 };
197
198 struct rte_event_timer_adapter;
199
200 /**
201 * Callback function type for producer port creation.
202 */
203 typedef int (*rte_event_timer_adapter_port_conf_cb_t)(uint16_t id,
204 uint8_t event_dev_id,
205 uint8_t *event_port_id,
206 void *conf_arg);
207
208 /**
209 * Create an event timer adapter.
210 *
211 * This function must be invoked first before any other function in the API.
212 *
213 * @param conf
214 * The event timer adapter configuration structure.
215 *
216 * @return
217 * A pointer to the new allocated event timer adapter on success.
218 * NULL on error with rte_errno set appropriately.
219 * Possible rte_errno values include:
220 * - ERANGE: timer_tick_ns is not in supported range.
221 * - ENOMEM: unable to allocate sufficient memory for adapter instances
222 * - EINVAL: invalid event device identifier specified in config
223 * - ENOSPC: maximum number of adapters already created
224 * - EIO: event device reconfiguration and restart error. The adapter
225 * reconfigures the event device with an additional port by default if it is
226 * required to use a service to manage timers. If the device had been started
227 * before this call, this error code indicates an error in restart following
228 * an error in reconfiguration, i.e., a combination of the two error codes.
229 */
230 struct rte_event_timer_adapter *
231 rte_event_timer_adapter_create(const struct rte_event_timer_adapter_conf *conf);
232
233 /**
234 * Create a timer adapter with the supplied callback.
235 *
236 * This function can be used to have a more granular control over the timer
237 * adapter creation. If a built-in port is absent, then the function uses the
238 * callback provided to create and get the port id to be used as a producer
239 * port.
240 *
241 * @param conf
242 * The timer adapter configuration structure
243 * @param conf_cb
244 * The port config callback function.
245 * @param conf_arg
246 * Opaque pointer to the argument for the callback function
247 *
248 * @return
249 * A pointer to the new allocated event timer adapter on success.
250 * NULL on error with rte_errno set appropriately.
251 * Possible rte_errno values include:
252 * - ERANGE: timer_tick_ns is not in supported range.
253 * - ENOMEM: unable to allocate sufficient memory for adapter instances
254 * - EINVAL: invalid event device identifier specified in config
255 * - ENOSPC: maximum number of adapters already created
256 */
257 struct rte_event_timer_adapter *
258 rte_event_timer_adapter_create_ext(
259 const struct rte_event_timer_adapter_conf *conf,
260 rte_event_timer_adapter_port_conf_cb_t conf_cb,
261 void *conf_arg);
262
263 /**
264 * Timer adapter info structure.
265 */
266 struct rte_event_timer_adapter_info {
267 uint64_t min_resolution_ns;
268 /**< Minimum timer adapter resolution in ns */
269 uint64_t max_tmo_ns;
270 /**< Maximum timer timeout(expire) in ns */
271 struct rte_event_timer_adapter_conf conf;
272 /**< Configured timer adapter attributes */
273 uint32_t caps;
274 /**< Event timer adapter capabilities */
275 int16_t event_dev_port_id;
276 /**< Event device port ID, if applicable */
277 };
278
279 /**
280 * Retrieve the contextual information of an event timer adapter.
281 *
282 * @param adapter
283 * A pointer to the event timer adapter structure.
284 *
285 * @param[out] adapter_info
286 * A pointer to a structure of type *rte_event_timer_adapter_info* to be
287 * filled with the contextual information of the adapter.
288 *
289 * @return
290 * - 0: Success, driver updates the contextual information of the
291 * timer adapter
292 * - <0: Error code returned by the driver info get function.
293 * - -EINVAL: adapter identifier invalid
294 *
295 * @see RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
296 * struct rte_event_timer_adapter_info
297 *
298 */
299 int
300 rte_event_timer_adapter_get_info(
301 const struct rte_event_timer_adapter *adapter,
302 struct rte_event_timer_adapter_info *adapter_info);
303
304 /**
305 * Start a timer adapter.
306 *
307 * The adapter start step is the last one and consists of setting the timer
308 * adapter to start accepting the timers and schedules to event queues.
309 *
310 * On success, all basic functions exported by the API (timer arm,
311 * timer cancel and so on) can be invoked.
312 *
313 * @param adapter
314 * A pointer to the event timer adapter structure.
315 *
316 * @return
317 * - 0: Success, adapter started.
318 * - <0: Error code returned by the driver start function.
319 * - -EINVAL if adapter identifier invalid
320 * - -ENOENT if software adapter but no service core mapped
321 * - -ENOTSUP if software adapter and more than one service core mapped
322 * - -EALREADY if adapter has already been started
323 *
324 * @note
325 * The eventdev to which the event_timer_adapter is connected needs to
326 * be started before calling rte_event_timer_adapter_start().
327 */
328 int
329 rte_event_timer_adapter_start(
330 const struct rte_event_timer_adapter *adapter);
331
332 /**
333 * Stop an event timer adapter.
334 *
335 * The adapter can be restarted with a call to
336 * ``rte_event_timer_adapter_start()``.
337 *
338 * @param adapter
339 * A pointer to the event timer adapter structure.
340 *
341 * @return
342 * - 0: Success, adapter stopped.
343 * - <0: Error code returned by the driver stop function.
344 * - -EINVAL if adapter identifier invalid
345 */
346 int
347 rte_event_timer_adapter_stop(const struct rte_event_timer_adapter *adapter);
348
349 /**
350 * Lookup an event timer adapter using its identifier.
351 *
352 * If an event timer adapter was created in another process with the same
353 * identifier, this function will locate its state and set up access to it
354 * so that it can be used in this process.
355 *
356 * @param adapter_id
357 * The event timer adapter identifier.
358 *
359 * @return
360 * A pointer to the event timer adapter matching the identifier on success.
361 * NULL on error with rte_errno set appropriately.
362 * Possible rte_errno values include:
363 * - ENOENT - requested entry not available to return.
364 */
365 struct rte_event_timer_adapter *
366 rte_event_timer_adapter_lookup(uint16_t adapter_id);
367
368 /**
369 * Free an event timer adapter.
370 *
371 * Destroy an event timer adapter, freeing all resources.
372 *
373 * Before invoking this function, the application must wait for all the
374 * armed timers to expire or cancel the outstanding armed timers.
375 *
376 * @param adapter
377 * A pointer to an event timer adapter structure.
378 *
379 * @return
380 * - 0: Successfully freed the event timer adapter resources.
381 * - <0: Failed to free the event timer adapter resources.
382 * - -EAGAIN: adapter is busy; timers outstanding
383 * - -EBUSY: stop hasn't been called for this adapter yet
384 * - -EINVAL: adapter id invalid, or adapter invalid
385 */
386 int
387 rte_event_timer_adapter_free(struct rte_event_timer_adapter *adapter);
388
389 /**
390 * Retrieve the service ID of the event timer adapter. If the adapter doesn't
391 * use an rte_service function, this function returns -ESRCH.
392 *
393 * @param adapter
394 * A pointer to an event timer adapter.
395 *
396 * @param [out] service_id
397 * A pointer to a uint32_t, to be filled in with the service id.
398 *
399 * @return
400 * - 0: Success
401 * - <0: Error code on failure
402 * - -ESRCH: the adapter does not require a service to operate
403 */
404 int
405 rte_event_timer_adapter_service_id_get(struct rte_event_timer_adapter *adapter,
406 uint32_t *service_id);
407
408 /**
409 * Retrieve statistics for an event timer adapter instance.
410 *
411 * @param adapter
412 * A pointer to an event timer adapter structure.
413 * @param[out] stats
414 * A pointer to a structure to fill with statistics.
415 *
416 * @return
417 * - 0: Successfully retrieved.
418 * - <0: Failure; error code returned.
419 */
420 int
421 rte_event_timer_adapter_stats_get(struct rte_event_timer_adapter *adapter,
422 struct rte_event_timer_adapter_stats *stats);
423
424 /**
425 * Reset statistics for an event timer adapter instance.
426 *
427 * @param adapter
428 * A pointer to an event timer adapter structure.
429 *
430 * @return
431 * - 0: Successfully reset;
432 * - <0: Failure; error code returned.
433 */
434 int
435 rte_event_timer_adapter_stats_reset(struct rte_event_timer_adapter *adapter);
436
437 /**
438 * Event timer state.
439 */
440 enum rte_event_timer_state {
441 RTE_EVENT_TIMER_NOT_ARMED = 0,
442 /**< Event timer not armed. */
443 RTE_EVENT_TIMER_ARMED = 1,
444 /**< Event timer successfully armed. */
445 RTE_EVENT_TIMER_CANCELED = 2,
446 /**< Event timer successfully canceled. */
447 RTE_EVENT_TIMER_ERROR = -1,
448 /**< Generic event timer error. */
449 RTE_EVENT_TIMER_ERROR_TOOEARLY = -2,
450 /**< Event timer timeout tick value is too small for the adapter to
451 * handle, given its configured resolution.
452 */
453 RTE_EVENT_TIMER_ERROR_TOOLATE = -3,
454 /**< Event timer timeout tick is greater than the maximum timeout.*/
455 };
456
457 /**
458 * The generic *rte_event_timer* structure to hold the event timer attributes
459 * for arm and cancel operations.
460 */
461 RTE_STD_C11
462 struct rte_event_timer {
463 struct rte_event ev;
464 /**<
465 * Expiry event attributes. On successful event timer timeout,
466 * the following attributes will be used to inject the expiry event to
467 * the eventdev:
468 * - event_queue_id: Targeted event queue id for expiry events.
469 * - event_priority: Event priority of the event expiry event in the
470 * event queue relative to other events.
471 * - sched_type: Scheduling type of the expiry event.
472 * - flow_id: Flow id of the expiry event.
473 * - op: RTE_EVENT_OP_NEW
474 * - event_type: RTE_EVENT_TYPE_TIMER
475 */
476 uint64_t timeout_ticks;
477 /**< Expiry timer ticks expressed in number of *timer_ticks_ns* from
478 * now.
479 * @see struct rte_event_timer_adapter_info::adapter_conf::timer_tick_ns
480 */
481 uint64_t impl_opaque[2];
482 /**< Implementation-specific opaque data.
483 * An event timer adapter implementation use this field to hold
484 * implementation specific values to share between the arm and cancel
485 * operations. The application should not modify this field.
486 */
487 enum rte_event_timer_state state;
488 /**< State of the event timer. */
489 uint8_t user_meta[0];
490 /**< Memory to store user specific metadata.
491 * The event timer adapter implementation should not modify this area.
492 */
493 } __rte_cache_aligned;
494
495 typedef uint16_t (*rte_event_timer_arm_burst_t)(
496 const struct rte_event_timer_adapter *adapter,
497 struct rte_event_timer **tims,
498 uint16_t nb_tims);
499 /**< @internal Enable event timers to enqueue timer events upon expiry */
500 typedef uint16_t (*rte_event_timer_arm_tmo_tick_burst_t)(
501 const struct rte_event_timer_adapter *adapter,
502 struct rte_event_timer **tims,
503 uint64_t timeout_tick,
504 uint16_t nb_tims);
505 /**< @internal Enable event timers with common expiration time */
506 typedef uint16_t (*rte_event_timer_cancel_burst_t)(
507 const struct rte_event_timer_adapter *adapter,
508 struct rte_event_timer **tims,
509 uint16_t nb_tims);
510 /**< @internal Prevent event timers from enqueuing timer events */
511
512 /**
513 * @internal Data structure associated with each event timer adapter.
514 */
515 struct rte_event_timer_adapter {
516 rte_event_timer_arm_burst_t arm_burst;
517 /**< Pointer to driver arm_burst function. */
518 rte_event_timer_arm_tmo_tick_burst_t arm_tmo_tick_burst;
519 /**< Pointer to driver arm_tmo_tick_burst function. */
520 rte_event_timer_cancel_burst_t cancel_burst;
521 /**< Pointer to driver cancel function. */
522 struct rte_event_timer_adapter_data *data;
523 /**< Pointer to shared adapter data */
524 const struct event_timer_adapter_ops *ops;
525 /**< Functions exported by adapter driver */
526
527 RTE_STD_C11
528 uint8_t allocated : 1;
529 /**< Flag to indicate that this adapter has been allocated */
530 } __rte_cache_aligned;
531
532 #define ADAPTER_VALID_OR_ERR_RET(adapter, retval) do { \
533 if (adapter == NULL || !adapter->allocated) \
534 return retval; \
535 } while (0)
536
537 #define FUNC_PTR_OR_ERR_RET(func, errval) do { \
538 if ((func) == NULL) \
539 return errval; \
540 } while (0)
541
542 #define FUNC_PTR_OR_NULL_RET_WITH_ERRNO(func, errval) do { \
543 if ((func) == NULL) { \
544 rte_errno = errval; \
545 return NULL; \
546 } \
547 } while (0)
548
549 /**
550 * Arm a burst of event timers with separate expiration timeout tick for each
551 * event timer.
552 *
553 * Before calling this function, the application allocates
554 * ``struct rte_event_timer`` objects from mempool or huge page backed
555 * application buffers of desired size. On successful allocation,
556 * application updates the `struct rte_event_timer`` attributes such as
557 * expiry event attributes, timeout ticks from now.
558 * This function submits the event timer arm requests to the event timer adapter
559 * and on expiry, the events will be injected to designated event queue.
560 * Timer expiry events will be generated once or periodically until cancellation
561 * based on the adapter mode.
562 *
563 * @param adapter
564 * A pointer to an event timer adapter structure.
565 * @param evtims
566 * Pointer to an array of objects of type *rte_event_timer* structure.
567 * @param nb_evtims
568 * Number of event timers in the supplied array.
569 *
570 * @return
571 * The number of successfully armed event timers. The return value can be less
572 * than the value of the *nb_evtims* parameter. If the return value is less
573 * than *nb_evtims*, the remaining event timers at the end of *evtims*
574 * are not consumed, and the caller has to take care of them, and rte_errno
575 * is set accordingly. Possible errno values include:
576 * - EINVAL Invalid timer adapter, expiry event queue ID is invalid, or an
577 * expiry event's sched type doesn't match the capabilities of the
578 * destination event queue.
579 * - EAGAIN Specified timer adapter is not running
580 * - EALREADY A timer was encountered that was already armed
581 *
582 * @see RTE_EVENT_TIMER_ADAPTER_F_PERIODIC
583 *
584 */
585 static inline uint16_t
rte_event_timer_arm_burst(const struct rte_event_timer_adapter * adapter,struct rte_event_timer ** evtims,uint16_t nb_evtims)586 rte_event_timer_arm_burst(const struct rte_event_timer_adapter *adapter,
587 struct rte_event_timer **evtims,
588 uint16_t nb_evtims)
589 {
590 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
591 ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
592 FUNC_PTR_OR_ERR_RET(adapter->arm_burst, -EINVAL);
593 #endif
594 rte_eventdev_trace_timer_arm_burst(adapter, (void **)evtims,
595 nb_evtims);
596 return adapter->arm_burst(adapter, evtims, nb_evtims);
597 }
598
599 /**
600 * Arm a burst of event timers with same expiration timeout tick.
601 *
602 * Provides the same functionality as ``rte_event_timer_arm_burst()``, except
603 * that application can use this API when all the event timers have the
604 * same timeout expiration tick. This specialized function can provide the
605 * additional hint to the adapter implementation and optimize if possible.
606 *
607 * @param adapter
608 * A pointer to an event timer adapter structure.
609 * @param evtims
610 * Points to an array of objects of type *rte_event_timer* structure.
611 * @param timeout_ticks
612 * The number of ticks in which the timers should expire.
613 * @param nb_evtims
614 * Number of event timers in the supplied array.
615 *
616 * @return
617 * The number of successfully armed event timers. The return value can be less
618 * than the value of the *nb_evtims* parameter. If the return value is less
619 * than *nb_evtims*, the remaining event timers at the end of *evtims*
620 * are not consumed, and the caller has to take care of them, and rte_errno
621 * is set accordingly. Possible errno values include:
622 * - EINVAL Invalid timer adapter, expiry event queue ID is invalid, or an
623 * expiry event's sched type doesn't match the capabilities of the
624 * destination event queue.
625 * - EAGAIN Specified event timer adapter is not running
626 * - EALREADY A timer was encountered that was already armed
627 */
628 static inline uint16_t
rte_event_timer_arm_tmo_tick_burst(const struct rte_event_timer_adapter * adapter,struct rte_event_timer ** evtims,const uint64_t timeout_ticks,const uint16_t nb_evtims)629 rte_event_timer_arm_tmo_tick_burst(
630 const struct rte_event_timer_adapter *adapter,
631 struct rte_event_timer **evtims,
632 const uint64_t timeout_ticks,
633 const uint16_t nb_evtims)
634 {
635 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
636 ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
637 FUNC_PTR_OR_ERR_RET(adapter->arm_tmo_tick_burst, -EINVAL);
638 #endif
639 rte_eventdev_trace_timer_arm_tmo_tick_burst(adapter, timeout_ticks,
640 (void **)evtims, nb_evtims);
641 return adapter->arm_tmo_tick_burst(adapter, evtims, timeout_ticks,
642 nb_evtims);
643 }
644
645 /**
646 * Cancel a burst of event timers from being scheduled to the event device.
647 *
648 * @param adapter
649 * A pointer to an event timer adapter structure.
650 * @param evtims
651 * Points to an array of objects of type *rte_event_timer* structure
652 * @param nb_evtims
653 * Number of event timer instances in the supplied array.
654 *
655 * @return
656 * The number of successfully canceled event timers. The return value can be
657 * less than the value of the *nb_evtims* parameter. If the return value is
658 * less than *nb_evtims*, the remaining event timers at the end of *evtims*
659 * are not consumed, and the caller has to take care of them, and rte_errno
660 * is set accordingly. Possible errno values include:
661 * - EINVAL Invalid timer adapter identifier
662 * - EAGAIN Specified timer adapter is not running
663 * - EALREADY A timer was encountered that was already canceled
664 */
665 static inline uint16_t
rte_event_timer_cancel_burst(const struct rte_event_timer_adapter * adapter,struct rte_event_timer ** evtims,uint16_t nb_evtims)666 rte_event_timer_cancel_burst(const struct rte_event_timer_adapter *adapter,
667 struct rte_event_timer **evtims,
668 uint16_t nb_evtims)
669 {
670 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
671 ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
672 FUNC_PTR_OR_ERR_RET(adapter->cancel_burst, -EINVAL);
673 #endif
674 rte_eventdev_trace_timer_cancel_burst(adapter, (void **)evtims,
675 nb_evtims);
676 return adapter->cancel_burst(adapter, evtims, nb_evtims);
677 }
678
679 #ifdef __cplusplus
680 }
681 #endif
682
683 #endif /* __RTE_EVENT_TIMER_ADAPTER_H__ */
684