Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(C) 2024 Marvell.
       3                 :            :  */
       4                 :            : 
       5                 :            : #ifndef __CNXK_COMMON_H__
       6                 :            : #define __CNXK_COMMON_H__
       7                 :            : 
       8                 :            : #include "cnxk_eventdev.h"
       9                 :            : #include "cnxk_worker.h"
      10                 :            : 
      11                 :            : struct cnxk_sso_hws_prf {
      12                 :            :         uint64_t base;
      13                 :            :         uint32_t gw_wdata;
      14                 :            :         void *lookup_mem;
      15                 :            :         uint64_t gw_rdata;
      16                 :            :         uint8_t swtag_req;
      17                 :            :         uint8_t hws_id;
      18                 :            : };
      19                 :            : 
      20                 :            : static uint32_t
      21                 :            : cnxk_sso_hws_prf_wdata(struct cnxk_sso_evdev *dev)
      22                 :            : {
      23                 :            :         uint32_t wdata = 1;
      24                 :            : 
      25   [ #  #  #  # ]:          0 :         if (dev->deq_tmo_ns)
      26                 :            :                 wdata |= BIT(16);
      27                 :            : 
      28   [ #  #  #  #  :          0 :         switch (dev->gw_mode) {
                   #  # ]
      29                 :            :         case CNXK_GW_MODE_NONE:
      30                 :            :         default:
      31                 :            :                 break;
      32                 :          0 :         case CNXK_GW_MODE_PREF:
      33                 :          0 :                 wdata |= BIT(19);
      34                 :          0 :                 break;
      35                 :          0 :         case CNXK_GW_MODE_PREF_WFE:
      36                 :          0 :                 wdata |= BIT(20) | BIT(19);
      37                 :          0 :                 break;
      38                 :            :         }
      39                 :            : 
      40                 :            :         return wdata;
      41                 :            : }
      42                 :            : 
      43                 :            : static uint8_t
      44                 :            : cnxk_sso_hws_preschedule_get(uint8_t preschedule_type)
      45                 :            : {
      46                 :            :         uint8_t gw_mode = 0;
      47                 :            : 
      48      [ #  #  # ]:          0 :         switch (preschedule_type) {
      49                 :            :         default:
      50                 :            :         case RTE_EVENT_PRESCHEDULE_NONE:
      51                 :            :                 gw_mode = CNXK_GW_MODE_NONE;
      52                 :            :                 break;
      53                 :          0 :         case RTE_EVENT_PRESCHEDULE:
      54                 :            :                 gw_mode = CNXK_GW_MODE_PREF;
      55                 :          0 :                 break;
      56                 :          0 :         case RTE_EVENT_PRESCHEDULE_ADAPTIVE:
      57                 :            :                 gw_mode = CNXK_GW_MODE_PREF_WFE;
      58                 :          0 :                 break;
      59                 :            :         }
      60                 :            : 
      61                 :            :         return gw_mode;
      62                 :            : }
      63                 :            : 
      64                 :            : static void
      65                 :          0 : cnxk_sso_hws_reset(void *arg, void *ws)
      66                 :            : {
      67                 :            :         struct cnxk_sso_evdev *dev = arg;
      68                 :            :         struct cnxk_sso_hws_prf *ws_prf;
      69                 :            :         uint64_t pend_state;
      70                 :            :         uint8_t swtag_req;
      71                 :            :         uintptr_t base;
      72                 :            :         uint8_t hws_id;
      73                 :            :         union {
      74                 :            :                 __uint128_t wdata;
      75                 :            :                 uint64_t u64[2];
      76                 :            :         } gw;
      77                 :            :         uint8_t pend_tt;
      78                 :            :         bool is_pend;
      79                 :            : 
      80                 :            :         ws_prf = ws;
      81                 :          0 :         base = ws_prf->base;
      82                 :          0 :         hws_id = ws_prf->hws_id;
      83                 :          0 :         swtag_req = ws_prf->swtag_req;
      84                 :            : 
      85                 :          0 :         roc_sso_hws_gwc_invalidate(&dev->sso, &hws_id, 1);
      86         [ #  # ]:          0 :         plt_write64(0, base + SSOW_LF_GWS_OP_GWC_INVAL);
      87                 :            :         /* Wait till getwork/swtp/waitw/desched completes. */
      88                 :            :         is_pend = false;
      89                 :            :         /* Work in WQE0 is always consumed, unless its a SWTAG. */
      90         [ #  # ]:          0 :         pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
      91   [ #  #  #  # ]:          0 :         if (pend_state & (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(54)) || swtag_req)
      92                 :            :                 is_pend = true;
      93                 :            : 
      94                 :            :         do {
      95                 :            :                 pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
      96         [ #  # ]:          0 :         } while (pend_state &
      97                 :            :                  (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(58) | BIT_ULL(56) | BIT_ULL(54)));
      98         [ #  # ]:          0 :         pend_tt = CNXK_TT_FROM_TAG(plt_read64(base + SSOW_LF_GWS_WQE0));
      99         [ #  # ]:          0 :         if (is_pend && pend_tt != SSO_TT_EMPTY) { /* Work was pending */
     100         [ #  # ]:          0 :                 if (pend_tt == SSO_TT_ATOMIC || pend_tt == SSO_TT_ORDERED)
     101                 :          0 :                         cnxk_sso_hws_swtag_untag(base + SSOW_LF_GWS_OP_SWTAG_UNTAG);
     102                 :          0 :                 plt_write64(0, base + SSOW_LF_GWS_OP_DESCHED);
     103         [ #  # ]:          0 :         } else if (pend_tt != SSO_TT_EMPTY) {
     104                 :          0 :                 plt_write64(0, base + SSOW_LF_GWS_OP_SWTAG_FLUSH);
     105                 :            :         }
     106                 :            : 
     107                 :            :         /* Wait for desched to complete. */
     108                 :            :         do {
     109                 :            :                 pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
     110         [ #  # ]:          0 :         } while (pend_state & (BIT_ULL(58) | BIT_ULL(56)));
     111                 :            : 
     112         [ #  # ]:          0 :         switch (dev->gw_mode) {
     113                 :            :         case CNXK_GW_MODE_PREF:
     114                 :            :         case CNXK_GW_MODE_PREF_WFE:
     115         [ #  # ]:          0 :                 while (plt_read64(base + SSOW_LF_GWS_PRF_WQE0) & BIT_ULL(63))
     116                 :            :                         ;
     117                 :            :                 break;
     118                 :            :         case CNXK_GW_MODE_NONE:
     119                 :            :         default:
     120                 :            :                 break;
     121                 :            :         }
     122                 :            : 
     123         [ #  # ]:          0 :         if (CNXK_TT_FROM_TAG(plt_read64(base + SSOW_LF_GWS_PRF_WQE0)) != SSO_TT_EMPTY) {
     124                 :          0 :                 plt_write64(BIT_ULL(16) | 1, base + SSOW_LF_GWS_OP_GET_WORK0);
     125                 :            :                 do {
     126                 :          0 :                         roc_load_pair(gw.u64[0], gw.u64[1], base + SSOW_LF_GWS_WQE0);
     127         [ #  # ]:          0 :                 } while (gw.u64[0] & BIT_ULL(63));
     128                 :          0 :                 pend_tt = CNXK_TT_FROM_TAG(plt_read64(base + SSOW_LF_GWS_WQE0));
     129         [ #  # ]:          0 :                 if (pend_tt != SSO_TT_EMPTY) { /* Work was pending */
     130         [ #  # ]:          0 :                         if (pend_tt == SSO_TT_ATOMIC || pend_tt == SSO_TT_ORDERED)
     131                 :          0 :                                 cnxk_sso_hws_swtag_untag(base + SSOW_LF_GWS_OP_SWTAG_UNTAG);
     132                 :          0 :                         plt_write64(0, base + SSOW_LF_GWS_OP_DESCHED);
     133                 :            :                 }
     134                 :            :         }
     135                 :            : 
     136                 :            :         plt_write64(0, base + SSOW_LF_GWS_OP_GWC_INVAL);
     137                 :          0 :         roc_sso_hws_gwc_invalidate(&dev->sso, &hws_id, 1);
     138                 :            :         rte_mb();
     139                 :          0 : }
     140                 :            : 
     141                 :            : static void
     142                 :          0 : cnxk_sso_configure_queue_stash(struct rte_eventdev *event_dev)
     143                 :          0 : {
     144                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     145                 :          0 :         struct roc_sso_hwgrp_stash stash[dev->stash_cnt];
     146                 :            :         int i, rc;
     147                 :            : 
     148                 :          0 :         plt_sso_dbg();
     149         [ #  # ]:          0 :         for (i = 0; i < dev->stash_cnt; i++) {
     150                 :          0 :                 stash[i].hwgrp = dev->stash_parse_data[i].queue;
     151                 :          0 :                 stash[i].stash_offset = dev->stash_parse_data[i].stash_offset;
     152                 :          0 :                 stash[i].stash_count = dev->stash_parse_data[i].stash_length;
     153                 :            :         }
     154                 :          0 :         rc = roc_sso_hwgrp_stash_config(&dev->sso, stash, dev->stash_cnt);
     155         [ #  # ]:          0 :         if (rc < 0)
     156                 :          0 :                 plt_warn("failed to configure HWGRP WQE stashing rc = %d", rc);
     157                 :          0 : }
     158                 :            : 
     159                 :            : #endif /* __CNXK_COMMON_H__ */