rte_event_timer_adapter.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2017 Cavium, Inc.
 * Copyright(c) 2017-2018 Intel Corporation.
 * All rights reserved.
 */
 
#ifndef __RTE_EVENT_TIMER_ADAPTER_H__
#define __RTE_EVENT_TIMER_ADAPTER_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <rte_spinlock.h>
#include <rte_memory.h>
 
#include "rte_eventdev.h"
#include "rte_eventdev_trace_fp.h"
 
enum rte_event_timer_adapter_clk_src {
    RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
    RTE_EVENT_TIMER_ADAPTER_EXT_CLK0,
    RTE_EVENT_TIMER_ADAPTER_EXT_CLK1,
    RTE_EVENT_TIMER_ADAPTER_EXT_CLK2,
    RTE_EVENT_TIMER_ADAPTER_EXT_CLK3,
};
 
#define RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES    (1ULL << 0)
#define RTE_EVENT_TIMER_ADAPTER_F_SP_PUT    (1ULL << 1)
#define RTE_EVENT_TIMER_ADAPTER_F_PERIODIC  (1ULL << 2)
struct rte_event_timer_adapter_conf {
    uint8_t event_dev_id;
    uint16_t timer_adapter_id;
    uint32_t socket_id;
    enum rte_event_timer_adapter_clk_src clk_src;
    uint64_t timer_tick_ns;
    uint64_t max_tmo_ns;
    uint64_t nb_timers;
    uint64_t flags;
};
 
struct rte_event_timer_adapter_stats {
    uint64_t evtim_exp_count;
    uint64_t ev_enq_count;
    uint64_t ev_inv_count;
    uint64_t evtim_retry_count;
    uint64_t adapter_tick_count;
};
 
struct rte_event_timer_adapter;
 
typedef int (*rte_event_timer_adapter_port_conf_cb_t)(uint16_t id,
                              uint8_t event_dev_id,
                              uint8_t *event_port_id,
                              void *conf_arg);
 
struct rte_event_timer_adapter *
rte_event_timer_adapter_create(const struct rte_event_timer_adapter_conf *conf);
 
struct rte_event_timer_adapter *
rte_event_timer_adapter_create_ext(
        const struct rte_event_timer_adapter_conf *conf,
        rte_event_timer_adapter_port_conf_cb_t conf_cb,
        void *conf_arg);
 
struct rte_event_timer_adapter_info {
    uint64_t min_resolution_ns;
    uint64_t max_tmo_ns;
    struct rte_event_timer_adapter_conf conf;
    uint32_t caps;
    int16_t event_dev_port_id;
};
 
int
rte_event_timer_adapter_get_info(
        const struct rte_event_timer_adapter *adapter,
        struct rte_event_timer_adapter_info *adapter_info);
 
int
rte_event_timer_adapter_start(
        const struct rte_event_timer_adapter *adapter);
 
int
rte_event_timer_adapter_stop(const struct rte_event_timer_adapter *adapter);
 
struct rte_event_timer_adapter *
rte_event_timer_adapter_lookup(uint16_t adapter_id);
 
int
rte_event_timer_adapter_free(struct rte_event_timer_adapter *adapter);
 
int
rte_event_timer_adapter_service_id_get(struct rte_event_timer_adapter *adapter,
                       uint32_t *service_id);
 
int
rte_event_timer_adapter_stats_get(struct rte_event_timer_adapter *adapter,
        struct rte_event_timer_adapter_stats *stats);
 
int
rte_event_timer_adapter_stats_reset(struct rte_event_timer_adapter *adapter);
 
enum rte_event_timer_state {
    RTE_EVENT_TIMER_NOT_ARMED   = 0,
    RTE_EVENT_TIMER_ARMED       = 1,
    RTE_EVENT_TIMER_CANCELED    = 2,
    RTE_EVENT_TIMER_ERROR       = -1,
    RTE_EVENT_TIMER_ERROR_TOOEARLY  = -2,
    RTE_EVENT_TIMER_ERROR_TOOLATE   = -3,
};
 
RTE_STD_C11
struct rte_event_timer {
    struct rte_event ev;
    uint64_t timeout_ticks;
    uint64_t impl_opaque[2];
    enum rte_event_timer_state state;
    uint8_t user_meta[0];
} __rte_cache_aligned;
 
typedef uint16_t (*rte_event_timer_arm_burst_t)(
        const struct rte_event_timer_adapter *adapter,
        struct rte_event_timer **tims,
        uint16_t nb_tims);
typedef uint16_t (*rte_event_timer_arm_tmo_tick_burst_t)(
        const struct rte_event_timer_adapter *adapter,
        struct rte_event_timer **tims,
        uint64_t timeout_tick,
        uint16_t nb_tims);
typedef uint16_t (*rte_event_timer_cancel_burst_t)(
        const struct rte_event_timer_adapter *adapter,
        struct rte_event_timer **tims,
        uint16_t nb_tims);
struct rte_event_timer_adapter {
    rte_event_timer_arm_burst_t arm_burst;
    rte_event_timer_arm_tmo_tick_burst_t arm_tmo_tick_burst;
    rte_event_timer_cancel_burst_t cancel_burst;
    struct rte_event_timer_adapter_data *data;
    const struct event_timer_adapter_ops *ops;
    RTE_STD_C11
    uint8_t allocated : 1;
} __rte_cache_aligned;
 
#define ADAPTER_VALID_OR_ERR_RET(adapter, retval) do {      \
    if (adapter == NULL || !adapter->allocated)     \
        return retval;                  \
} while (0)
 
#define FUNC_PTR_OR_ERR_RET(func, errval) do {          \
    if ((func) == NULL)                 \
        return errval;                  \
} while (0)
 
#define FUNC_PTR_OR_NULL_RET_WITH_ERRNO(func, errval) do {  \
    if ((func) == NULL) {                   \
        rte_errno = errval;             \
        return NULL;                    \
    }                           \
} while (0)
 
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)
{
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
    ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
    FUNC_PTR_OR_ERR_RET(adapter->arm_burst, -EINVAL);
#endif
    rte_eventdev_trace_timer_arm_burst(adapter, (void **)evtims,
        nb_evtims);
    return adapter->arm_burst(adapter, evtims, nb_evtims);
}
 
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)
{
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
    ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
    FUNC_PTR_OR_ERR_RET(adapter->arm_tmo_tick_burst, -EINVAL);
#endif
    rte_eventdev_trace_timer_arm_tmo_tick_burst(adapter, timeout_ticks,
        (void **)evtims, nb_evtims);
    return adapter->arm_tmo_tick_burst(adapter, evtims, timeout_ticks,
                       nb_evtims);
}
 
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)
{
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
    ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
    FUNC_PTR_OR_ERR_RET(adapter->cancel_burst, -EINVAL);
#endif
    rte_eventdev_trace_timer_cancel_burst(adapter, (void **)evtims,
        nb_evtims);
    return adapter->cancel_burst(adapter, evtims, nb_evtims);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* __RTE_EVENT_TIMER_ADAPTER_H__ */