drivers/event/octeontx/ssovf_worker.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) Cavium networks Ltd. 2017.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Cavium networks nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "ssovf_worker.h"
  34
  35 static force_inline void
  36 ssows_new_event(struct ssows *ws, const struct rte_event *ev)
  37 {
  38         const uint64_t event_ptr = ev->u64;
  39         const uint32_t tag = (uint32_t)ev->event;
  40         const uint8_t new_tt = ev->sched_type;
  41         const uint8_t grp = ev->queue_id;
  42
  43         ssows_add_work(ws, event_ptr, tag, new_tt, grp);
  44 }
  45
  46 static force_inline void
  47 ssows_fwd_swtag(struct ssows *ws, const struct rte_event *ev, const uint8_t grp)
  48 {
  49         const uint8_t cur_tt = ws->cur_tt;
  50         const uint8_t new_tt = ev->sched_type;
  51         const uint32_t tag = (uint32_t)ev->event;
  52         /*
  53          * cur_tt/new_tt     SSO_SYNC_ORDERED SSO_SYNC_ATOMIC SSO_SYNC_UNTAGGED
  54          *
  55          * SSO_SYNC_ORDERED        norm           norm             untag
  56          * SSO_SYNC_ATOMIC         norm           norm             untag
  57          * SSO_SYNC_UNTAGGED       full           full             NOOP
  58          */
  59         if (unlikely(cur_tt == SSO_SYNC_UNTAGGED)) {
  60                 if (new_tt != SSO_SYNC_UNTAGGED) {
  61                         ssows_swtag_full(ws, ev->u64, tag,
  62                                 new_tt, grp);
  63                 }
  64         } else {
  65                 if (likely(new_tt != SSO_SYNC_UNTAGGED))
  66                         ssows_swtag_norm(ws, tag, new_tt);
  67                 else
  68                         ssows_swtag_untag(ws);
  69         }
  70         ws->swtag_req = 1;
  71 }
  72
  73 #define OCT_EVENT_TYPE_GRP_FWD (RTE_EVENT_TYPE_MAX - 1)
  74
  75 static force_inline void
  76 ssows_fwd_group(struct ssows *ws, const struct rte_event *ev, const uint8_t grp)
  77 {
  78         const uint64_t event_ptr = ev->u64;
  79         const uint32_t tag = (uint32_t)ev->event;
  80         const uint8_t cur_tt = ws->cur_tt;
  81         const uint8_t new_tt = ev->sched_type;
  82
  83         if (cur_tt == SSO_SYNC_ORDERED) {
  84                 /* Create unique tag based on custom event type and new grp */
  85                 uint32_t newtag = OCT_EVENT_TYPE_GRP_FWD << 28;
  86
  87                 newtag |= grp << 20;
  88                 newtag |= tag;
  89                 ssows_swtag_norm(ws, newtag, SSO_SYNC_ATOMIC);
  90                 rte_smp_wmb();
  91                 ssows_swtag_wait(ws);
  92         } else {
  93                 rte_smp_wmb();
  94         }
  95         ssows_add_work(ws, event_ptr, tag, new_tt, grp);
  96 }
  97
  98 static force_inline void
  99 ssows_forward_event(struct ssows *ws, const struct rte_event *ev)
 100 {
 101         const uint8_t grp = ev->queue_id;
 102
 103         /* Group hasn't changed, Use SWTAG to forward the event */
 104         if (ws->cur_grp == grp)
 105                 ssows_fwd_swtag(ws, ev, grp);
 106         else
 107         /*
 108          * Group has been changed for group based work pipelining,
 109          * Use deschedule/add_work operation to transfer the event to
 110          * new group/core
 111          */
 112                 ssows_fwd_group(ws, ev, grp);
 113 }
 114
 115 static force_inline void
 116 ssows_release_event(struct ssows *ws)
 117 {
 118         if (likely(ws->cur_tt != SSO_SYNC_UNTAGGED))
 119                 ssows_swtag_untag(ws);
 120 }
 121
 122 force_inline uint16_t __hot
 123 ssows_enq(void *port, const struct rte_event *ev)
 124 {
 125         struct ssows *ws = port;
 126         uint16_t ret = 1;
 127
 128         switch (ev->op) {
 129         case RTE_EVENT_OP_NEW:
 130                 ssows_new_event(ws, ev);
 131                 break;
 132         case RTE_EVENT_OP_FORWARD:
 133                 ssows_forward_event(ws, ev);
 134                 break;
 135         case RTE_EVENT_OP_RELEASE:
 136                 ssows_release_event(ws);
 137                 break;
 138         default:
 139                 ret = 0;
 140         }
 141         return ret;
 142 }
 143
 144 uint16_t __hot
 145 ssows_enq_burst(void *port, const struct rte_event ev[], uint16_t nb_events)
 146 {
 147         RTE_SET_USED(nb_events);
 148         return ssows_enq(port, ev);
 149 }