LCOV - code coverage report
Current view: top level - drivers/event/octeontx - ssovf_worker.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 145 0.0 %
Date: 2024-01-22 16:26:08 Functions: 0 58 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 102 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2017 Cavium, Inc
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "ssovf_worker.h"
       6                 :            : 
       7                 :            : static __rte_always_inline void
       8                 :            : ssows_new_event(struct ssows *ws, const struct rte_event *ev)
       9                 :            : {
      10                 :          0 :         const uint64_t event_ptr = ev->u64;
      11                 :          0 :         const uint32_t tag = (uint32_t)ev->event;
      12                 :          0 :         const uint8_t new_tt = ev->sched_type;
      13                 :          0 :         const uint8_t grp = ev->queue_id;
      14                 :            : 
      15                 :          0 :         ssows_add_work(ws, event_ptr, tag, new_tt, grp);
      16                 :          0 : }
      17                 :            : 
      18                 :            : static __rte_always_inline void
      19                 :            : ssows_fwd_swtag(struct ssows *ws, const struct rte_event *ev, const uint8_t grp)
      20                 :            : {
      21                 :          0 :         const uint8_t cur_tt = ws->cur_tt;
      22                 :          0 :         const uint8_t new_tt = ev->sched_type;
      23                 :          0 :         const uint32_t tag = (uint32_t)ev->event;
      24                 :            :         /*
      25                 :            :          * cur_tt/new_tt     SSO_SYNC_ORDERED SSO_SYNC_ATOMIC SSO_SYNC_UNTAGGED
      26                 :            :          *
      27                 :            :          * SSO_SYNC_ORDERED        norm           norm             untag
      28                 :            :          * SSO_SYNC_ATOMIC         norm           norm             untag
      29                 :            :          * SSO_SYNC_UNTAGGED       full           full             NOOP
      30                 :            :          */
      31   [ #  #  #  #  :          0 :         if (unlikely(cur_tt == SSO_SYNC_UNTAGGED)) {
                   #  # ]
      32   [ #  #  #  #  :          0 :                 if (new_tt != SSO_SYNC_UNTAGGED) {
                   #  # ]
      33                 :          0 :                         ssows_swtag_full(ws, ev->u64, tag,
      34                 :            :                                 new_tt, grp);
      35                 :            :                 }
      36                 :            :         } else {
      37   [ #  #  #  #  :          0 :                 if (likely(new_tt != SSO_SYNC_UNTAGGED))
                   #  # ]
      38                 :            :                         ssows_swtag_norm(ws, tag, new_tt);
      39                 :            :                 else
      40                 :            :                         ssows_swtag_untag(ws);
      41                 :            :         }
      42                 :          0 :         ws->swtag_req = 1;
      43                 :          0 : }
      44                 :            : 
      45                 :            : #define OCT_EVENT_TYPE_GRP_FWD (RTE_EVENT_TYPE_MAX - 1)
      46                 :            : 
      47                 :            : static __rte_always_inline void
      48                 :            : ssows_fwd_group(struct ssows *ws, const struct rte_event *ev, const uint8_t grp)
      49                 :            : {
      50                 :          0 :         const uint64_t event_ptr = ev->u64;
      51                 :          0 :         const uint32_t tag = (uint32_t)ev->event;
      52                 :          0 :         const uint8_t cur_tt = ws->cur_tt;
      53                 :          0 :         const uint8_t new_tt = ev->sched_type;
      54                 :            : 
      55                 :          0 :         if (cur_tt == SSO_SYNC_ORDERED) {
      56                 :            :                 /* Create unique tag based on custom event type and new grp */
      57                 :            :                 uint32_t newtag = OCT_EVENT_TYPE_GRP_FWD << 28;
      58                 :            : 
      59                 :          0 :                 newtag |= grp << 20;
      60                 :          0 :                 newtag |= tag;
      61                 :            :                 ssows_swtag_norm(ws, newtag, SSO_SYNC_ATOMIC);
      62                 :          0 :                 rte_smp_wmb();
      63                 :            :                 ssows_swtag_wait(ws);
      64                 :            :         } else {
      65                 :          0 :                 rte_smp_wmb();
      66                 :            :         }
      67                 :            :         ssows_add_work(ws, event_ptr, tag, new_tt, grp);
      68                 :          0 : }
      69                 :            : 
      70                 :            : static __rte_always_inline void
      71                 :            : ssows_forward_event(struct ssows *ws, const struct rte_event *ev)
      72                 :            : {
      73                 :          0 :         const uint8_t grp = ev->queue_id;
      74                 :            : 
      75                 :            :         /* Group hasn't changed, Use SWTAG to forward the event */
      76   [ #  #  #  # ]:          0 :         if (ws->cur_grp == grp)
      77                 :            :                 ssows_fwd_swtag(ws, ev, grp);
      78                 :            :         else
      79                 :            :         /*
      80                 :            :          * Group has been changed for group based work pipelining,
      81                 :            :          * Use deschedule/add_work operation to transfer the event to
      82                 :            :          * new group/core
      83                 :            :          */
      84   [ #  #  #  #  :          0 :                 ssows_fwd_group(ws, ev, grp);
                   #  # ]
      85                 :            : }
      86                 :            : 
      87                 :            : static __rte_always_inline void
      88                 :            : ssows_release_event(struct ssows *ws)
      89                 :            : {
      90   [ #  #  #  # ]:          0 :         if (likely(ws->cur_tt != SSO_SYNC_UNTAGGED))
      91                 :            :                 ssows_swtag_untag(ws);
      92                 :            : }
      93                 :            : 
      94                 :            : #define R(name, f2, f1, f0, flags)                                           \
      95                 :            : static uint16_t __rte_noinline  __rte_hot                                    \
      96                 :            : ssows_deq_ ##name(void *port, struct rte_event *ev, uint64_t timeout_ticks)  \
      97                 :            : {                                                                            \
      98                 :            :         struct ssows *ws = port;                                             \
      99                 :            :                                                                              \
     100                 :            :         RTE_SET_USED(timeout_ticks);                                         \
     101                 :            :                                                                              \
     102                 :            :         if (ws->swtag_req) {                                              \
     103                 :            :                 ws->swtag_req = 0;                                        \
     104                 :            :                 ssows_swtag_wait(ws);                                        \
     105                 :            :                 return 1;                                                    \
     106                 :            :         } else {                                                             \
     107                 :            :                 return ssows_get_work(ws, ev, flags);                        \
     108                 :            :         }                                                                    \
     109                 :            : }                                                                            \
     110                 :            :                                                                              \
     111                 :            : static uint16_t __rte_hot                                                    \
     112                 :            : ssows_deq_burst_ ##name(void *port, struct rte_event ev[],                   \
     113                 :            :                          uint16_t nb_events, uint64_t timeout_ticks)         \
     114                 :            : {                                                                            \
     115                 :            :         RTE_SET_USED(nb_events);                                             \
     116                 :            :                                                                              \
     117                 :            :         return ssows_deq_ ##name(port, ev, timeout_ticks);                   \
     118                 :            : }                                                                            \
     119                 :            :                                                                              \
     120                 :            : static uint16_t __rte_hot                                                    \
     121                 :            : ssows_deq_timeout_ ##name(void *port, struct rte_event *ev,                  \
     122                 :            :                           uint64_t timeout_ticks)                            \
     123                 :            : {                                                                            \
     124                 :            :         struct ssows *ws = port;                                             \
     125                 :            :         uint64_t iter;                                                       \
     126                 :            :         uint16_t ret = 1;                                                    \
     127                 :            :                                                                              \
     128                 :            :         if (ws->swtag_req) {                                              \
     129                 :            :                 ws->swtag_req = 0;                                        \
     130                 :            :                 ssows_swtag_wait(ws);                                        \
     131                 :            :         } else {                                                             \
     132                 :            :                 ret = ssows_get_work(ws, ev, flags);                         \
     133                 :            :                 for (iter = 1; iter < timeout_ticks && (ret == 0); iter++)   \
     134                 :            :                         ret = ssows_get_work(ws, ev, flags);                 \
     135                 :            :         }                                                                    \
     136                 :            :         return ret;                                                          \
     137                 :            : }                                                                            \
     138                 :            :                                                                              \
     139                 :            : static uint16_t __rte_hot                                                    \
     140                 :            : ssows_deq_timeout_burst_ ##name(void *port, struct rte_event ev[],           \
     141                 :            :                                 uint16_t nb_events, uint64_t timeout_ticks)  \
     142                 :            : {                                                                            \
     143                 :            :         RTE_SET_USED(nb_events);                                             \
     144                 :            :                                                                              \
     145                 :            :         return ssows_deq_timeout_ ##name(port, ev, timeout_ticks);           \
     146                 :            : }
     147                 :            : 
     148   [ #  #  #  # ]:          0 : SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
     149                 :            : #undef R
     150                 :            : 
     151                 :            : __rte_always_inline uint16_t __rte_hot
     152                 :          0 : ssows_enq(void *port, const struct rte_event *ev)
     153                 :            : {
     154                 :            :         struct ssows *ws = port;
     155                 :            :         uint16_t ret = 1;
     156                 :            : 
     157   [ #  #  #  # ]:          0 :         switch (ev->op) {
     158                 :          0 :         case RTE_EVENT_OP_NEW:
     159                 :          0 :                 rte_smp_wmb();
     160                 :            :                 ssows_new_event(ws, ev);
     161                 :            :                 break;
     162                 :            :         case RTE_EVENT_OP_FORWARD:
     163                 :            :                 ssows_forward_event(ws, ev);
     164                 :            :                 break;
     165                 :            :         case RTE_EVENT_OP_RELEASE:
     166                 :            :                 ssows_release_event(ws);
     167                 :            :                 break;
     168                 :            :         default:
     169                 :            :                 ret = 0;
     170                 :            :         }
     171                 :          0 :         return ret;
     172                 :            : }
     173                 :            : 
     174                 :            : uint16_t __rte_hot
     175   [ #  #  #  # ]:          0 : ssows_enq_burst(void *port, const struct rte_event ev[], uint16_t nb_events)
     176                 :            : {
     177                 :            :         RTE_SET_USED(nb_events);
     178                 :          0 :         return ssows_enq(port, ev);
     179                 :            : }
     180                 :            : 
     181                 :            : uint16_t __rte_hot
     182                 :          0 : ssows_enq_new_burst(void *port, const struct rte_event ev[], uint16_t nb_events)
     183                 :            : {
     184                 :            :         uint16_t i;
     185                 :            :         struct ssows *ws = port;
     186                 :            : 
     187                 :          0 :         rte_smp_wmb();
     188         [ #  # ]:          0 :         for (i = 0; i < nb_events; i++)
     189                 :          0 :                 ssows_new_event(ws,  &ev[i]);
     190                 :            : 
     191                 :          0 :         return nb_events;
     192                 :            : }
     193                 :            : 
     194                 :            : uint16_t __rte_hot
     195         [ #  # ]:          0 : ssows_enq_fwd_burst(void *port, const struct rte_event ev[], uint16_t nb_events)
     196                 :            : {
     197                 :            :         struct ssows *ws = port;
     198                 :            :         RTE_SET_USED(nb_events);
     199                 :            : 
     200                 :            :         ssows_forward_event(ws,  ev);
     201                 :            : 
     202                 :          0 :         return 1;
     203                 :            : }
     204                 :            : 
     205                 :            : void
     206                 :          0 : ssows_flush_events(struct ssows *ws, uint8_t queue_id,
     207                 :            :                                 ssows_handle_event_t fn, void *arg)
     208                 :            : {
     209                 :            :         uint32_t reg_off;
     210                 :            :         struct rte_event ev;
     211                 :            :         uint64_t enable, aq_cnt = 1, cq_ds_cnt = 1;
     212                 :            :         uint64_t get_work0, get_work1;
     213                 :            :         uint64_t sched_type_queue;
     214                 :          0 :         uint8_t *base = ssovf_bar(OCTEONTX_SSO_GROUP, queue_id, 0);
     215                 :            : 
     216                 :            :         enable = ssovf_read64(base + SSO_VHGRP_QCTL);
     217         [ #  # ]:          0 :         if (!enable)
     218                 :            :                 return;
     219                 :            : 
     220                 :            :         reg_off = SSOW_VHWS_OP_GET_WORK0;
     221                 :            :         reg_off |= 1 << 17; /* Grouped */
     222                 :            :         reg_off |= 1 << 16; /* WAIT */
     223                 :          0 :         reg_off |= queue_id << 4; /* INDEX_GGRP_MASK(group number) */
     224         [ #  # ]:          0 :         while (aq_cnt || cq_ds_cnt) {
     225                 :            :                 aq_cnt = ssovf_read64(base + SSO_VHGRP_AQ_CNT);
     226                 :            :                 cq_ds_cnt = ssovf_read64(base + SSO_VHGRP_INT_CNT);
     227                 :            :                 /* Extract cq and ds count */
     228                 :          0 :                 cq_ds_cnt &= 0x1FFF1FFF0000;
     229                 :            : 
     230                 :          0 :                 ssovf_load_pair(get_work0, get_work1, ws->base + reg_off);
     231                 :            : 
     232                 :          0 :                 sched_type_queue = (get_work0 >> 32) & 0xfff;
     233                 :          0 :                 ws->cur_tt = sched_type_queue & 0x3;
     234                 :          0 :                 ws->cur_grp = sched_type_queue >> 2;
     235                 :          0 :                 sched_type_queue = sched_type_queue << 38;
     236                 :          0 :                 ev.event = sched_type_queue | (get_work0 & 0xffffffff);
     237   [ #  #  #  # ]:          0 :                 if (get_work1 && ev.event_type == RTE_EVENT_TYPE_ETHDEV)
     238                 :          0 :                         ev.mbuf = ssovf_octeontx_wqe_to_pkt(get_work1,
     239                 :          0 :                                         (ev.event >> 20) & 0x7F,
     240                 :            :                                         OCCTX_RX_OFFLOAD_NONE |
     241                 :            :                                         OCCTX_RX_MULTI_SEG_F,
     242                 :            :                                         ws->lookup_mem);
     243                 :            :                 else
     244                 :            :                         ev.u64 = get_work1;
     245                 :            : 
     246   [ #  #  #  # ]:          0 :                 if (fn != NULL && ev.u64 != 0)
     247                 :          0 :                         fn(arg, ev);
     248                 :            :         }
     249                 :            : }
     250                 :            : 
     251                 :            : void
     252                 :          0 : ssows_reset(struct ssows *ws)
     253                 :            : {
     254                 :            :         uint64_t tag;
     255                 :            :         uint64_t pend_tag;
     256                 :            :         uint8_t pend_tt;
     257                 :            :         uint8_t tt;
     258                 :            : 
     259         [ #  # ]:          0 :         tag = ssovf_read64(ws->base + SSOW_VHWS_TAG);
     260                 :            :         pend_tag = ssovf_read64(ws->base + SSOW_VHWS_PENDTAG);
     261                 :            : 
     262         [ #  # ]:          0 :         if (pend_tag & (1ULL << 63)) { /* Tagswitch pending */
     263                 :          0 :                 pend_tt = (pend_tag >> 32) & 0x3;
     264         [ #  # ]:          0 :                 if (pend_tt == SSO_SYNC_ORDERED || pend_tt == SSO_SYNC_ATOMIC)
     265                 :            :                         ssows_desched(ws);
     266                 :            :         } else {
     267                 :          0 :                 tt = (tag >> 32) & 0x3;
     268         [ #  # ]:          0 :                 if (tt == SSO_SYNC_ORDERED || tt == SSO_SYNC_ATOMIC)
     269                 :            :                         ssows_swtag_untag(ws);
     270                 :            :         }
     271                 :          0 : }
     272                 :            : 
     273                 :            : static __rte_always_inline uint16_t
     274                 :            : __sso_event_tx_adapter_enqueue(void *port, struct rte_event ev[],
     275                 :            :                                uint16_t nb_events, uint64_t *cmd,
     276                 :            :                                const uint16_t flag)
     277                 :            : {
     278                 :            :         uint16_t port_id;
     279                 :            :         uint16_t queue_id;
     280                 :            :         struct rte_mbuf *m;
     281                 :            :         struct rte_eth_dev *ethdev;
     282                 :            :         struct ssows *ws = port;
     283                 :            :         struct octeontx_txq *txq;
     284                 :            : 
     285                 :            :         RTE_SET_USED(nb_events);
     286                 :          0 :         switch (ev->sched_type) {
     287                 :          0 :         case SSO_SYNC_ORDERED:
     288                 :          0 :                 ssows_swtag_norm(ws, ev->event, SSO_SYNC_ATOMIC);
     289                 :          0 :                 rte_io_wmb();
     290                 :            :                 ssows_swtag_wait(ws);
     291                 :            :                 break;
     292                 :          0 :         case SSO_SYNC_UNTAGGED:
     293                 :          0 :                 ssows_swtag_full(ws, ev->u64, ev->event, SSO_SYNC_ATOMIC,
     294                 :          0 :                                 ev->queue_id);
     295                 :          0 :                 rte_io_wmb();
     296                 :            :                 ssows_swtag_wait(ws);
     297                 :            :                 break;
     298                 :          0 :         case SSO_SYNC_ATOMIC:
     299                 :          0 :                 rte_io_wmb();
     300                 :          0 :                 break;
     301                 :            :         }
     302                 :            : 
     303                 :          0 :         m = ev[0].mbuf;
     304                 :          0 :         port_id = m->port;
     305                 :            :         queue_id = rte_event_eth_tx_adapter_txq_get(m);
     306                 :          0 :         ethdev = &rte_eth_devices[port_id];
     307                 :          0 :         txq = ethdev->data->tx_queues[queue_id];
     308                 :            : 
     309                 :            :         return __octeontx_xmit_pkts(txq, &m, 1, cmd, flag);
     310                 :            : }
     311                 :            : 
     312                 :            : #define T(name, f3, f2, f1, f0, sz, flags)                                   \
     313                 :            : static uint16_t __rte_noinline  __rte_hot                                    \
     314                 :            : sso_event_tx_adapter_enqueue_ ## name(void *port, struct rte_event ev[],     \
     315                 :            :                                   uint16_t nb_events)                        \
     316                 :            : {                                                                            \
     317                 :            :         uint64_t cmd[sz];                                                    \
     318                 :            :         return __sso_event_tx_adapter_enqueue(port, ev, nb_events, cmd,      \
     319                 :            :                                               flags);                        \
     320                 :            : }
     321                 :            : 
     322   [ #  #  #  # ]:          0 : SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
     323                 :            : #undef T
     324                 :            : 
     325                 :            : static uint16_t __rte_hot
     326                 :          0 : ssow_crypto_adapter_enqueue(void *port, struct rte_event ev[],
     327                 :            :                             uint16_t nb_events)
     328                 :            : {
     329                 :            :         RTE_SET_USED(nb_events);
     330                 :            : 
     331                 :          0 :         return otx_crypto_adapter_enqueue(port, ev->event_ptr);
     332                 :            : }
     333                 :            : 
     334                 :            : void
     335         [ #  # ]:          0 : ssovf_fastpath_fns_set(struct rte_eventdev *dev)
     336                 :            : {
     337                 :            :         struct ssovf_evdev *edev = ssovf_pmd_priv(dev);
     338                 :            : 
     339                 :          0 :         dev->enqueue       = ssows_enq;
     340                 :          0 :         dev->enqueue_burst = ssows_enq_burst;
     341                 :          0 :         dev->enqueue_new_burst = ssows_enq_new_burst;
     342                 :          0 :         dev->enqueue_forward_burst = ssows_enq_fwd_burst;
     343                 :            : 
     344                 :          0 :         dev->ca_enqueue = ssow_crypto_adapter_enqueue;
     345                 :            : 
     346                 :          0 :         const event_tx_adapter_enqueue_t ssow_txa_enqueue[2][2][2][2] = {
     347                 :            : #define T(name, f3, f2, f1, f0, sz, flags)                              \
     348                 :            :         [f3][f2][f1][f0] =  sso_event_tx_adapter_enqueue_ ##name,
     349                 :            : 
     350                 :            :                 SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
     351                 :            : #undef T
     352                 :            :         };
     353                 :            : 
     354                 :          0 :         dev->txa_enqueue = ssow_txa_enqueue
     355                 :          0 :                 [!!(edev->tx_offload_flags & OCCTX_TX_OFFLOAD_MBUF_NOFF_F)]
     356                 :          0 :                 [!!(edev->tx_offload_flags & OCCTX_TX_OFFLOAD_OL3_OL4_CSUM_F)]
     357                 :          0 :                 [!!(edev->tx_offload_flags & OCCTX_TX_OFFLOAD_L3_L4_CSUM_F)]
     358                 :          0 :                 [!!(edev->tx_offload_flags & OCCTX_TX_MULTI_SEG_F)];
     359                 :            : 
     360                 :          0 :         dev->txa_enqueue_same_dest = dev->txa_enqueue;
     361                 :            : 
     362                 :            :         /* Assigning dequeue func pointers */
     363                 :          0 :         const event_dequeue_t ssow_deq[2][2][2] = {
     364                 :            : #define R(name, f2, f1, f0, flags)                                      \
     365                 :            :         [f2][f1][f0] =  ssows_deq_ ##name,
     366                 :            : 
     367                 :            : SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
     368                 :            : #undef R
     369                 :            :         };
     370                 :            : 
     371                 :          0 :         dev->dequeue = ssow_deq
     372                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_VLAN_FLTR_F)]
     373                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_OFFLOAD_CSUM_F)]
     374                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_MULTI_SEG_F)];
     375                 :            : 
     376                 :          0 :         const event_dequeue_burst_t ssow_deq_burst[2][2][2] = {
     377                 :            : #define R(name, f2, f1, f0, flags)                                      \
     378                 :            :         [f2][f1][f0] =  ssows_deq_burst_ ##name,
     379                 :            : 
     380                 :            : SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
     381                 :            : #undef R
     382                 :            :         };
     383                 :            : 
     384                 :          0 :         dev->dequeue_burst = ssow_deq_burst
     385                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_VLAN_FLTR_F)]
     386                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_OFFLOAD_CSUM_F)]
     387                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_MULTI_SEG_F)];
     388                 :            : 
     389         [ #  # ]:          0 :         if (edev->is_timeout_deq) {
     390                 :          0 :                 const event_dequeue_t ssow_deq_timeout[2][2][2] = {
     391                 :            : #define R(name, f2, f1, f0, flags)                                      \
     392                 :            :         [f2][f1][f0] =  ssows_deq_timeout_ ##name,
     393                 :            : 
     394                 :            : SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
     395                 :            : #undef R
     396                 :            :                 };
     397                 :            : 
     398                 :          0 :         dev->dequeue = ssow_deq_timeout
     399                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_VLAN_FLTR_F)]
     400                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_OFFLOAD_CSUM_F)]
     401                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_MULTI_SEG_F)];
     402                 :            : 
     403                 :          0 :         const event_dequeue_burst_t ssow_deq_timeout_burst[2][2][2] = {
     404                 :            : #define R(name, f2, f1, f0, flags)                                      \
     405                 :            :         [f2][f1][f0] =  ssows_deq_timeout_burst_ ##name,
     406                 :            : 
     407                 :            : SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
     408                 :            : #undef R
     409                 :            :                 };
     410                 :            : 
     411                 :          0 :         dev->dequeue_burst = ssow_deq_timeout_burst
     412                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_VLAN_FLTR_F)]
     413                 :            :                 [!!(edev->rx_offload_flags & OCCTX_RX_OFFLOAD_CSUM_F)]
     414                 :          0 :                 [!!(edev->rx_offload_flags & OCCTX_RX_MULTI_SEG_F)];
     415                 :            :         }
     416                 :          0 : }
     417                 :            : 
     418                 :            : static void
     419                 :          0 : octeontx_create_rx_ol_flags_array(void *mem)
     420                 :            : {
     421                 :            :         uint16_t idx, errcode, errlev;
     422                 :            :         uint32_t val, *ol_flags;
     423                 :            : 
     424                 :            :         /* Skip ptype array memory */
     425                 :            :         ol_flags = (uint32_t *)mem;
     426                 :            : 
     427         [ #  # ]:          0 :         for (idx = 0; idx < BIT(ERRCODE_ERRLEN_WIDTH); idx++) {
     428                 :          0 :                 errcode = idx & 0xff;
     429                 :          0 :                 errlev = (idx & 0x700) >> 8;
     430                 :            : 
     431                 :            :                 val = RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN;
     432                 :            :                 val |= RTE_MBUF_F_RX_L4_CKSUM_UNKNOWN;
     433                 :            :                 val |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_UNKNOWN;
     434                 :            : 
     435   [ #  #  #  #  :          0 :                 switch (errlev) {
                   #  # ]
     436                 :          0 :                 case OCCTX_ERRLEV_RE:
     437         [ #  # ]:          0 :                         if (errcode) {
     438                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     439                 :            :                                 val |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
     440                 :            :                         } else {
     441                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     442                 :            :                                 val |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     443                 :            :                         }
     444                 :            :                         break;
     445                 :          0 :                 case OCCTX_ERRLEV_LC:
     446         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_IP4_CSUM) {
     447                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     448                 :            :                                 val |= RTE_MBUF_F_RX_OUTER_IP_CKSUM_BAD;
     449                 :            :                         } else {
     450                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     451                 :            :                         }
     452                 :            :                         break;
     453                 :          0 :                 case OCCTX_ERRLEV_LD:
     454                 :            :                         /* Check if parsed packet is neither IPv4 or IPV6 */
     455         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_IP4_NOT)
     456                 :            :                                 break;
     457                 :            :                         val |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     458         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_L4_CSUM)
     459                 :            :                                 val |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_BAD;
     460                 :            :                         else
     461                 :            :                                 val |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     462                 :            :                         break;
     463                 :          0 :                 case OCCTX_ERRLEV_LE:
     464         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_IP4_CSUM)
     465                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     466                 :            :                         else
     467                 :            :                                 val |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     468                 :            :                         break;
     469                 :          0 :                 case OCCTX_ERRLEV_LF:
     470                 :            :                         /* Check if parsed packet is neither IPv4 or IPV6 */
     471         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_IP4_NOT)
     472                 :            :                                 break;
     473                 :            :                         val |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     474         [ #  # ]:          0 :                         if (errcode == OCCTX_EC_L4_CSUM)
     475                 :            :                                 val |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
     476                 :            :                         else
     477                 :            :                                 val |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     478                 :            :                         break;
     479                 :            :                 }
     480                 :            : 
     481                 :          0 :                 ol_flags[idx] = val;
     482                 :            :         }
     483                 :          0 : }
     484                 :            : 
     485                 :            : void *
     486                 :          0 : octeontx_fastpath_lookup_mem_get(void)
     487                 :            : {
     488                 :          0 :         const char name[] = OCCTX_FASTPATH_LOOKUP_MEM;
     489                 :            :         const struct rte_memzone *mz;
     490                 :            :         void *mem;
     491                 :            : 
     492                 :          0 :         mz = rte_memzone_lookup(name);
     493         [ #  # ]:          0 :         if (mz != NULL)
     494                 :          0 :                 return mz->addr;
     495                 :            : 
     496                 :            :         /* Request for the first time */
     497                 :          0 :         mz = rte_memzone_reserve_aligned(name, LOOKUP_ARRAY_SZ,
     498                 :            :                                          SOCKET_ID_ANY, 0, OCCTX_ALIGN);
     499         [ #  # ]:          0 :         if (mz != NULL) {
     500                 :          0 :                 mem = mz->addr;
     501                 :            :                 /* Form the rx ol_flags based on errcode */
     502                 :          0 :                 octeontx_create_rx_ol_flags_array(mem);
     503                 :          0 :                 return mem;
     504                 :            :         }
     505                 :            :         return NULL;
     506                 :            : }

Generated by: LCOV version 1.14