drivers/common/cnxk/roc_nix_rss.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include "roc_api.h"
   6 #include "roc_priv.h"
   7
   8 void
   9 roc_nix_rss_key_default_fill(struct roc_nix *roc_nix,
  10                              uint8_t key[ROC_NIX_RSS_KEY_LEN])
  11 {
  12         PLT_SET_USED(roc_nix);
  13         const uint8_t default_key[ROC_NIX_RSS_KEY_LEN] = {
  14                 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED,
  15                 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD,
  16                 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED,
  17                 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD,
  18                 0xFE, 0xED, 0x0B, 0xAD, 0xFE, 0xED, 0x0B, 0xAD};
  19
  20         memcpy(key, default_key, ROC_NIX_RSS_KEY_LEN);
  21 }
  22
  23 void
  24 roc_nix_rss_key_set(struct roc_nix *roc_nix,
  25                     const uint8_t key[ROC_NIX_RSS_KEY_LEN])
  26 {
  27         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
  28         const uint64_t *keyptr;
  29         uint64_t val;
  30         uint32_t idx;
  31
  32         keyptr = (const uint64_t *)key;
  33         for (idx = 0; idx < (ROC_NIX_RSS_KEY_LEN >> 3); idx++) {
  34                 val = plt_cpu_to_be_64(keyptr[idx]);
  35                 plt_write64(val, nix->base + NIX_LF_RX_SECRETX(idx));
  36         }
  37 }
  38
  39 void
  40 roc_nix_rss_key_get(struct roc_nix *roc_nix, uint8_t key[ROC_NIX_RSS_KEY_LEN])
  41 {
  42         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
  43         uint64_t *keyptr = (uint64_t *)key;
  44         uint64_t val;
  45         uint32_t idx;
  46
  47         for (idx = 0; idx < (ROC_NIX_RSS_KEY_LEN >> 3); idx++) {
  48                 val = plt_read64(nix->base + NIX_LF_RX_SECRETX(idx));
  49                 keyptr[idx] = plt_be_to_cpu_64(val);
  50         }
  51 }
  52
  53 static int
  54 nix_cn9k_rss_reta_set(struct nix *nix, uint8_t group,
  55                       uint16_t reta[ROC_NIX_RSS_RETA_MAX])
  56 {
  57         struct mbox *mbox = (&nix->dev)->mbox;
  58         struct nix_aq_enq_req *req;
  59         uint16_t idx;
  60         int rc;
  61
  62         for (idx = 0; idx < nix->reta_sz; idx++) {
  63                 req = mbox_alloc_msg_nix_aq_enq(mbox);
  64                 if (!req) {
  65                         /* The shared memory buffer can be full.
  66                          * Flush it and retry
  67                          */
  68                         rc = mbox_process(mbox);
  69                         if (rc < 0)
  70                                 return rc;
  71                         req = mbox_alloc_msg_nix_aq_enq(mbox);
  72                         if (!req)
  73                                 return NIX_ERR_NO_MEM;
  74                 }
  75                 req->rss.rq = reta[idx];
  76                 /* Fill AQ info */
  77                 req->qidx = (group * nix->reta_sz) + idx;
  78                 req->ctype = NIX_AQ_CTYPE_RSS;
  79                 req->op = NIX_AQ_INSTOP_INIT;
  80         }
  81
  82         rc = mbox_process(mbox);
  83         if (rc < 0)
  84                 return rc;
  85
  86         return 0;
  87 }
  88
  89 static int
  90 nix_rss_reta_set(struct nix *nix, uint8_t group,
  91                  uint16_t reta[ROC_NIX_RSS_RETA_MAX])
  92 {
  93         struct mbox *mbox = (&nix->dev)->mbox;
  94         struct nix_cn10k_aq_enq_req *req;
  95         uint16_t idx;
  96         int rc;
  97
  98         for (idx = 0; idx < nix->reta_sz; idx++) {
  99                 req = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
 100                 if (!req) {
 101                         /* The shared memory buffer can be full.
 102                          * Flush it and retry
 103                          */
 104                         rc = mbox_process(mbox);
 105                         if (rc < 0)
 106                                 return rc;
 107                         req = mbox_alloc_msg_nix_cn10k_aq_enq(mbox);
 108                         if (!req)
 109                                 return NIX_ERR_NO_MEM;
 110                 }
 111                 req->rss.rq = reta[idx];
 112                 /* Fill AQ info */
 113                 req->qidx = (group * nix->reta_sz) + idx;
 114                 req->ctype = NIX_AQ_CTYPE_RSS;
 115                 req->op = NIX_AQ_INSTOP_INIT;
 116         }
 117
 118         rc = mbox_process(mbox);
 119         if (rc < 0)
 120                 return rc;
 121
 122         return 0;
 123 }
 124
 125 int
 126 roc_nix_rss_reta_set(struct roc_nix *roc_nix, uint8_t group,
 127                      uint16_t reta[ROC_NIX_RSS_RETA_MAX])
 128 {
 129         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 130         int rc;
 131
 132         if (group >= ROC_NIX_RSS_GRPS)
 133                 return NIX_ERR_PARAM;
 134
 135         if (roc_model_is_cn9k())
 136                 rc = nix_cn9k_rss_reta_set(nix, group, reta);
 137         else
 138                 rc = nix_rss_reta_set(nix, group, reta);
 139         if (rc)
 140                 return rc;
 141
 142         memcpy(&nix->reta[group], reta, ROC_NIX_RSS_RETA_MAX);
 143         return 0;
 144 }
 145
 146 int
 147 roc_nix_rss_reta_get(struct roc_nix *roc_nix, uint8_t group,
 148                      uint16_t reta[ROC_NIX_RSS_RETA_MAX])
 149 {
 150         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 151
 152         if (group >= ROC_NIX_RSS_GRPS)
 153                 return NIX_ERR_PARAM;
 154
 155         memcpy(reta, &nix->reta[group], ROC_NIX_RSS_RETA_MAX);
 156         return 0;
 157 }
 158
 159 int
 160 roc_nix_rss_flowkey_set(struct roc_nix *roc_nix, uint8_t *alg_idx,
 161                         uint32_t flowkey, uint8_t group, int mcam_index)
 162 {
 163         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 164         struct nix_rss_flowkey_cfg_rsp *rss_rsp;
 165         struct mbox *mbox = (&nix->dev)->mbox;
 166         struct nix_rss_flowkey_cfg *cfg;
 167         int rc = -ENOSPC;
 168
 169         if (group >= ROC_NIX_RSS_GRPS)
 170                 return NIX_ERR_PARAM;
 171
 172         cfg = mbox_alloc_msg_nix_rss_flowkey_cfg(mbox);
 173         if (cfg == NULL)
 174                 return rc;
 175         cfg->flowkey_cfg = flowkey;
 176         cfg->mcam_index = mcam_index; /* -1 indicates default group */
 177         cfg->group = group;           /* 0 is default group */
 178         rc = mbox_process_msg(mbox, (void *)&rss_rsp);
 179         if (rc)
 180                 return rc;
 181         if (alg_idx)
 182                 *alg_idx = rss_rsp->alg_idx;
 183
 184         return rc;
 185 }
 186
 187 int
 188 roc_nix_rss_default_setup(struct roc_nix *roc_nix, uint32_t flowkey)
 189 {
 190         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 191         uint16_t idx, qcnt = nix->nb_rx_queues;
 192         uint16_t reta[ROC_NIX_RSS_RETA_MAX];
 193         uint8_t key[ROC_NIX_RSS_KEY_LEN];
 194         uint8_t alg_idx;
 195         int rc;
 196
 197         roc_nix_rss_key_default_fill(roc_nix, key);
 198         roc_nix_rss_key_set(roc_nix, key);
 199
 200         /* Update default RSS RETA */
 201         for (idx = 0; idx < nix->reta_sz; idx++)
 202                 reta[idx] = idx % qcnt;
 203         rc = roc_nix_rss_reta_set(roc_nix, 0, reta);
 204         if (rc) {
 205                 plt_err("Failed to set RSS reta table rc=%d", rc);
 206                 goto fail;
 207         }
 208
 209         /* Update the default flowkey */
 210         rc = roc_nix_rss_flowkey_set(roc_nix, &alg_idx, flowkey,
 211                                      ROC_NIX_RSS_GROUP_DEFAULT, -1);
 212         if (rc) {
 213                 plt_err("Failed to set RSS flowkey rc=%d", rc);
 214                 goto fail;
 215         }
 216
 217         nix->rss_alg_idx = alg_idx;
 218 fail:
 219         return rc;
 220 }