drivers/event/octeontx2/otx2_tim_worker.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include "otx2_tim_evdev.h"
   6 #include "otx2_tim_worker.h"
   7
   8 static inline int
   9 tim_arm_checks(const struct otx2_tim_ring * const tim_ring,
  10                struct rte_event_timer * const tim)
  11 {
  12         if (unlikely(tim->state)) {
  13                 tim->state = RTE_EVENT_TIMER_ERROR;
  14                 rte_errno = EALREADY;
  15                 goto fail;
  16         }
  17
  18         if (unlikely(!tim->timeout_ticks ||
  19                      tim->timeout_ticks >= tim_ring->nb_bkts)) {
  20                 tim->state = tim->timeout_ticks ? RTE_EVENT_TIMER_ERROR_TOOLATE
  21                         : RTE_EVENT_TIMER_ERROR_TOOEARLY;
  22                 rte_errno = EINVAL;
  23                 goto fail;
  24         }
  25
  26         return 0;
  27
  28 fail:
  29         return -EINVAL;
  30 }
  31
  32 static inline void
  33 tim_format_event(const struct rte_event_timer * const tim,
  34                  struct otx2_tim_ent * const entry)
  35 {
  36         entry->w0 = (tim->ev.event & 0xFFC000000000) >> 6 |
  37                 (tim->ev.event & 0xFFFFFFFFF);
  38         entry->wqe = tim->ev.u64;
  39 }
  40
  41 static __rte_always_inline uint16_t
  42 tim_timer_arm_burst(const struct rte_event_timer_adapter *adptr,
  43                     struct rte_event_timer **tim,
  44                     const uint16_t nb_timers,
  45                     const uint8_t flags)
  46 {
  47         struct otx2_tim_ring *tim_ring = adptr->data->adapter_priv;
  48         struct otx2_tim_ent entry;
  49         uint16_t index;
  50         int ret;
  51
  52         for (index = 0; index < nb_timers; index++) {
  53                 if (tim_arm_checks(tim_ring, tim[index]))
  54                         break;
  55
  56                 tim_format_event(tim[index], &entry);
  57                 if (flags & OTX2_TIM_SP)
  58                         ret = tim_add_entry_sp(tim_ring,
  59                                                tim[index]->timeout_ticks,
  60                                                tim[index], &entry, flags);
  61                 if (flags & OTX2_TIM_MP)
  62                         ret = tim_add_entry_mp(tim_ring,
  63                                                tim[index]->timeout_ticks,
  64                                                tim[index], &entry, flags);
  65
  66                 if (unlikely(ret)) {
  67                         rte_errno = -ret;
  68                         break;
  69                 }
  70         }
  71
  72         return index;
  73 }
  74
  75 #define FP(_name, _f3, _f2, _f1, _flags)                                  \
  76 uint16_t __rte_noinline                                                   \
  77 otx2_tim_arm_burst_ ## _name(const struct rte_event_timer_adapter *adptr, \
  78                              struct rte_event_timer **tim,                \
  79                              const uint16_t nb_timers)                    \
  80 {                                                                         \
  81         return tim_timer_arm_burst(adptr, tim, nb_timers, _flags);        \
  82 }
  83 TIM_ARM_FASTPATH_MODES
  84 #undef FP