drivers/event/cnxk/cn9k_worker.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include "roc_api.h"
   6
   7 #include "cn9k_worker.h"
   8
   9 uint16_t __rte_hot
  10 cn9k_sso_hws_enq(void *port, const struct rte_event *ev)
  11 {
  12         struct cn9k_sso_hws *ws = port;
  13
  14         switch (ev->op) {
  15         case RTE_EVENT_OP_NEW:
  16                 return cn9k_sso_hws_new_event(ws, ev);
  17         case RTE_EVENT_OP_FORWARD:
  18                 cn9k_sso_hws_forward_event(ws, ev);
  19                 break;
  20         case RTE_EVENT_OP_RELEASE:
  21                 cnxk_sso_hws_swtag_flush(ws->tag_op, ws->swtag_flush_op);
  22                 break;
  23         default:
  24                 return 0;
  25         }
  26
  27         return 1;
  28 }
  29
  30 uint16_t __rte_hot
  31 cn9k_sso_hws_enq_burst(void *port, const struct rte_event ev[],
  32                        uint16_t nb_events)
  33 {
  34         RTE_SET_USED(nb_events);
  35         return cn9k_sso_hws_enq(port, ev);
  36 }
  37
  38 uint16_t __rte_hot
  39 cn9k_sso_hws_enq_new_burst(void *port, const struct rte_event ev[],
  40                            uint16_t nb_events)
  41 {
  42         struct cn9k_sso_hws *ws = port;
  43         uint16_t i, rc = 1;
  44
  45         for (i = 0; i < nb_events && rc; i++)
  46                 rc = cn9k_sso_hws_new_event(ws, &ev[i]);
  47
  48         return nb_events;
  49 }
  50
  51 uint16_t __rte_hot
  52 cn9k_sso_hws_enq_fwd_burst(void *port, const struct rte_event ev[],
  53                            uint16_t nb_events)
  54 {
  55         struct cn9k_sso_hws *ws = port;
  56
  57         RTE_SET_USED(nb_events);
  58         cn9k_sso_hws_forward_event(ws, ev);
  59
  60         return 1;
  61 }
  62
  63 uint16_t __rte_hot
  64 cn9k_sso_hws_deq(void *port, struct rte_event *ev, uint64_t timeout_ticks)
  65 {
  66         struct cn9k_sso_hws *ws = port;
  67
  68         RTE_SET_USED(timeout_ticks);
  69
  70         if (ws->swtag_req) {
  71                 ws->swtag_req = 0;
  72                 cnxk_sso_hws_swtag_wait(ws->tag_op);
  73                 return 1;
  74         }
  75
  76         return cn9k_sso_hws_get_work(ws, ev);
  77 }
  78
  79 uint16_t __rte_hot
  80 cn9k_sso_hws_deq_burst(void *port, struct rte_event ev[], uint16_t nb_events,
  81                        uint64_t timeout_ticks)
  82 {
  83         RTE_SET_USED(nb_events);
  84
  85         return cn9k_sso_hws_deq(port, ev, timeout_ticks);
  86 }
  87
  88 uint16_t __rte_hot
  89 cn9k_sso_hws_tmo_deq(void *port, struct rte_event *ev, uint64_t timeout_ticks)
  90 {
  91         struct cn9k_sso_hws *ws = port;
  92         uint16_t ret = 1;
  93         uint64_t iter;
  94
  95         if (ws->swtag_req) {
  96                 ws->swtag_req = 0;
  97                 cnxk_sso_hws_swtag_wait(ws->tag_op);
  98                 return ret;
  99         }
 100
 101         ret = cn9k_sso_hws_get_work(ws, ev);
 102         for (iter = 1; iter < timeout_ticks && (ret == 0); iter++)
 103                 ret = cn9k_sso_hws_get_work(ws, ev);
 104
 105         return ret;
 106 }
 107
 108 uint16_t __rte_hot
 109 cn9k_sso_hws_tmo_deq_burst(void *port, struct rte_event ev[],
 110                            uint16_t nb_events, uint64_t timeout_ticks)
 111 {
 112         RTE_SET_USED(nb_events);
 113
 114         return cn9k_sso_hws_tmo_deq(port, ev, timeout_ticks);
 115 }
 116
 117 /* Dual ws ops. */
 118
 119 uint16_t __rte_hot
 120 cn9k_sso_hws_dual_enq(void *port, const struct rte_event *ev)
 121 {
 122         struct cn9k_sso_hws_dual *dws = port;
 123         struct cn9k_sso_hws_state *vws;
 124
 125         vws = &dws->ws_state[!dws->vws];
 126         switch (ev->op) {
 127         case RTE_EVENT_OP_NEW:
 128                 return cn9k_sso_hws_dual_new_event(dws, ev);
 129         case RTE_EVENT_OP_FORWARD:
 130                 cn9k_sso_hws_dual_forward_event(dws, vws, ev);
 131                 break;
 132         case RTE_EVENT_OP_RELEASE:
 133                 cnxk_sso_hws_swtag_flush(vws->tag_op, vws->swtag_flush_op);
 134                 break;
 135         default:
 136                 return 0;
 137         }
 138
 139         return 1;
 140 }
 141
 142 uint16_t __rte_hot
 143 cn9k_sso_hws_dual_enq_burst(void *port, const struct rte_event ev[],
 144                             uint16_t nb_events)
 145 {
 146         RTE_SET_USED(nb_events);
 147         return cn9k_sso_hws_dual_enq(port, ev);
 148 }
 149
 150 uint16_t __rte_hot
 151 cn9k_sso_hws_dual_enq_new_burst(void *port, const struct rte_event ev[],
 152                                 uint16_t nb_events)
 153 {
 154         struct cn9k_sso_hws_dual *dws = port;
 155         uint16_t i, rc = 1;
 156
 157         for (i = 0; i < nb_events && rc; i++)
 158                 rc = cn9k_sso_hws_dual_new_event(dws, &ev[i]);
 159
 160         return nb_events;
 161 }
 162
 163 uint16_t __rte_hot
 164 cn9k_sso_hws_dual_enq_fwd_burst(void *port, const struct rte_event ev[],
 165                                 uint16_t nb_events)
 166 {
 167         struct cn9k_sso_hws_dual *dws = port;
 168
 169         RTE_SET_USED(nb_events);
 170         cn9k_sso_hws_dual_forward_event(dws, &dws->ws_state[!dws->vws], ev);
 171
 172         return 1;
 173 }
 174
 175 uint16_t __rte_hot
 176 cn9k_sso_hws_dual_deq(void *port, struct rte_event *ev, uint64_t timeout_ticks)
 177 {
 178         struct cn9k_sso_hws_dual *dws = port;
 179         uint16_t gw;
 180
 181         RTE_SET_USED(timeout_ticks);
 182         if (dws->swtag_req) {
 183                 dws->swtag_req = 0;
 184                 cnxk_sso_hws_swtag_wait(dws->ws_state[!dws->vws].tag_op);
 185                 return 1;
 186         }
 187
 188         gw = cn9k_sso_hws_dual_get_work(&dws->ws_state[dws->vws],
 189                                         &dws->ws_state[!dws->vws], ev);
 190         dws->vws = !dws->vws;
 191         return gw;
 192 }
 193
 194 uint16_t __rte_hot
 195 cn9k_sso_hws_dual_deq_burst(void *port, struct rte_event ev[],
 196                             uint16_t nb_events, uint64_t timeout_ticks)
 197 {
 198         RTE_SET_USED(nb_events);
 199
 200         return cn9k_sso_hws_dual_deq(port, ev, timeout_ticks);
 201 }
 202
 203 uint16_t __rte_hot
 204 cn9k_sso_hws_dual_tmo_deq(void *port, struct rte_event *ev,
 205                           uint64_t timeout_ticks)
 206 {
 207         struct cn9k_sso_hws_dual *dws = port;
 208         uint16_t ret = 1;
 209         uint64_t iter;
 210
 211         if (dws->swtag_req) {
 212                 dws->swtag_req = 0;
 213                 cnxk_sso_hws_swtag_wait(dws->ws_state[!dws->vws].tag_op);
 214                 return ret;
 215         }
 216
 217         ret = cn9k_sso_hws_dual_get_work(&dws->ws_state[dws->vws],
 218                                          &dws->ws_state[!dws->vws], ev);
 219         dws->vws = !dws->vws;
 220         for (iter = 1; iter < timeout_ticks && (ret == 0); iter++) {
 221                 ret = cn9k_sso_hws_dual_get_work(&dws->ws_state[dws->vws],
 222                                                  &dws->ws_state[!dws->vws], ev);
 223                 dws->vws = !dws->vws;
 224         }
 225
 226         return ret;
 227 }
 228
 229 uint16_t __rte_hot
 230 cn9k_sso_hws_dual_tmo_deq_burst(void *port, struct rte_event ev[],
 231                                 uint16_t nb_events, uint64_t timeout_ticks)
 232 {
 233         RTE_SET_USED(nb_events);
 234
 235         return cn9k_sso_hws_dual_tmo_deq(port, ev, timeout_ticks);
 236 }