drivers/net/bnxt/tf_ulp/ulp_gen_tbl.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <rte_log.h>
   7 #include <rte_malloc.h>
   8 #include "tf_core.h"
   9 #include "tfp.h"
  10 #include "ulp_mapper.h"
  11 #include "ulp_flow_db.h"
  12
  13 /* Retrieve the generic table  initialization parameters for the tbl_idx */
  14 static struct bnxt_ulp_generic_tbl_params*
  15 ulp_mapper_gen_tbl_params_get(uint32_t tbl_idx)
  16 {
  17         if (tbl_idx >= BNXT_ULP_GEN_TBL_MAX_SZ)
  18                 return NULL;
  19
  20         return &ulp_generic_tbl_params[tbl_idx];
  21 }
  22
  23 /*
  24  * Initialize the generic table list
  25  *
  26  * mapper_data [in] Pointer to the mapper data and the generic table is
  27  * part of it
  28  *
  29  * returns 0 on success
  30  */
  31 int32_t
  32 ulp_mapper_generic_tbl_list_init(struct bnxt_ulp_mapper_data *mapper_data)
  33 {
  34         struct bnxt_ulp_generic_tbl_params *tbl;
  35         struct ulp_mapper_gen_tbl_list *entry;
  36         struct ulp_hash_create_params cparams;
  37         uint32_t idx, size;
  38
  39         /* Allocate the generic tables. */
  40         for (idx = 0; idx < BNXT_ULP_GEN_TBL_MAX_SZ; idx++) {
  41                 tbl = ulp_mapper_gen_tbl_params_get(idx);
  42                 if (!tbl) {
  43                         BNXT_TF_DBG(ERR, "Failed to get gen table parms %d\n",
  44                                     idx);
  45                         return -EINVAL;
  46                 }
  47                 entry = &mapper_data->gen_tbl_list[idx];
  48                 if (tbl->result_num_entries != 0) {
  49                         /* assign the name */
  50                         entry->gen_tbl_name = tbl->name;
  51                         /* add 4 bytes for reference count */
  52                         entry->mem_data_size = (tbl->result_num_entries + 1) *
  53                                 (tbl->result_num_bytes + sizeof(uint32_t));
  54
  55                         /* allocate the big chunk of memory */
  56                         entry->mem_data = rte_zmalloc("ulp mapper gen tbl",
  57                                                       entry->mem_data_size, 0);
  58                         if (!entry->mem_data) {
  59                                 BNXT_TF_DBG(ERR,
  60                                             "%s:Failed to alloc gen table %d\n",
  61                                             tbl->name, idx);
  62                                 return -ENOMEM;
  63                         }
  64                         /* Populate the generic table container */
  65                         entry->container.num_elem = tbl->result_num_entries;
  66                         entry->container.byte_data_size = tbl->result_num_bytes;
  67                         entry->container.ref_count =
  68                                 (uint32_t *)entry->mem_data;
  69                         size = sizeof(uint32_t) * (tbl->result_num_entries + 1);
  70                         entry->container.byte_data = &entry->mem_data[size];
  71                         entry->container.byte_order = tbl->result_byte_order;
  72                 } else {
  73                         BNXT_TF_DBG(ERR, "%s:Invalid gen table num of ent %d\n",
  74                                     tbl->name, idx);
  75                         return -EINVAL;
  76                 }
  77                 if (tbl->hash_tbl_entries) {
  78                         cparams.key_size = tbl->key_num_bytes;
  79                         cparams.num_buckets = tbl->num_buckets;
  80                         cparams.num_hash_tbl_entries = tbl->hash_tbl_entries;
  81                         cparams.num_key_entries = tbl->result_num_entries;
  82                         if (ulp_gen_hash_tbl_list_init(&cparams,
  83                                                        &entry->hash_tbl)) {
  84                                 BNXT_TF_DBG(ERR,
  85                                             "%s: Failed to alloc hash tbl %d\n",
  86                                             tbl->name, idx);
  87                                 return -ENOMEM;
  88                         }
  89                 }
  90         }
  91         /* success */
  92         return 0;
  93 }
  94
  95 /*
  96  * Free the generic table list
  97  *
  98  * mapper_data [in] Pointer to the mapper data and the generic table is
  99  * part of it
 100  *
 101  * returns 0 on success
 102  */
 103 int32_t
 104 ulp_mapper_generic_tbl_list_deinit(struct bnxt_ulp_mapper_data *mapper_data)
 105 {
 106         struct ulp_mapper_gen_tbl_list *tbl_list;
 107         uint32_t idx;
 108
 109         /* iterate the generic table. */
 110         for (idx = 0; idx < BNXT_ULP_GEN_TBL_MAX_SZ; idx++) {
 111                 tbl_list = &mapper_data->gen_tbl_list[idx];
 112                 if (tbl_list->mem_data) {
 113                         rte_free(tbl_list->mem_data);
 114                         tbl_list->mem_data = NULL;
 115                 }
 116                 if (tbl_list->hash_tbl) {
 117                         ulp_gen_hash_tbl_list_deinit(tbl_list->hash_tbl);
 118                         tbl_list->hash_tbl = NULL;
 119                 }
 120         }
 121         /* success */
 122         return 0;
 123 }
 124
 125 /*
 126  * Get the generic table list entry
 127  *
 128  * tbl_list [in] - Ptr to generic table
 129  * key [in] - Key index to the table
 130  * entry [out] - output will include the entry if found
 131  *
 132  * returns 0 on success.
 133  */
 134 int32_t
 135 ulp_mapper_gen_tbl_entry_get(struct ulp_mapper_gen_tbl_list *tbl_list,
 136                              uint32_t key,
 137                              struct ulp_mapper_gen_tbl_entry *entry)
 138 {
 139         /* populate the output and return the values */
 140         if (key > tbl_list->container.num_elem) {
 141                 BNXT_TF_DBG(ERR, "%s: invalid key %x:%x\n",
 142                             tbl_list->gen_tbl_name, key,
 143                             tbl_list->container.num_elem);
 144                 return -EINVAL;
 145         }
 146         entry->ref_count = &tbl_list->container.ref_count[key];
 147         entry->byte_data_size = tbl_list->container.byte_data_size;
 148         entry->byte_data = &tbl_list->container.byte_data[key *
 149                 entry->byte_data_size];
 150         entry->byte_order = tbl_list->container.byte_order;
 151         return 0;
 152 }
 153
 154 /*
 155  * utility function to calculate the table idx
 156  *
 157  * res_sub_type [in] - Resource sub type
 158  * dir [in] - Direction
 159  *
 160  * returns None
 161  */
 162 int32_t
 163 ulp_mapper_gen_tbl_idx_calculate(uint32_t res_sub_type, uint32_t dir)
 164 {
 165         int32_t tbl_idx;
 166
 167         /* Validate for direction */
 168         if (dir >= TF_DIR_MAX) {
 169                 BNXT_TF_DBG(ERR, "invalid argument %x\n", dir);
 170                 return -EINVAL;
 171         }
 172         tbl_idx = (res_sub_type << 1) | (dir & 0x1);
 173         if (tbl_idx >= BNXT_ULP_GEN_TBL_MAX_SZ) {
 174                 BNXT_TF_DBG(ERR, "invalid table index %x\n", tbl_idx);
 175                 return -EINVAL;
 176         }
 177         return tbl_idx;
 178 }
 179
 180 /*
 181  * Set the data in the generic table entry, Data is in Big endian format
 182  *
 183  * entry [in] - generic table entry
 184  * len [in] - The length of the data in bits to be set
 185  * data [in] - pointer to the data to be used for setting the value.
 186  * data_size [in] - length of the data pointer in bytes.
 187  *
 188  * returns 0 on success
 189  */
 190 int32_t
 191 ulp_mapper_gen_tbl_entry_data_set(struct ulp_mapper_gen_tbl_entry *entry,
 192                                   uint32_t len, uint8_t *data,
 193                                   uint32_t data_size)
 194 {
 195         /* validate the null arguments */
 196         if (!entry || !data) {
 197                 BNXT_TF_DBG(ERR, "invalid argument\n");
 198                 return -EINVAL;
 199         }
 200
 201         /* check the size of the buffer for validation */
 202         if (len > ULP_BYTE_2_BITS(entry->byte_data_size) ||
 203             data_size < ULP_BITS_2_BYTE(len)) {
 204                 BNXT_TF_DBG(ERR, "invalid offset or length %x:%x\n",
 205                             len, entry->byte_data_size);
 206                 return -EINVAL;
 207         }
 208         memcpy(entry->byte_data, data, ULP_BITS_2_BYTE(len));
 209         return 0;
 210 }
 211
 212 /*
 213  * Get the data in the generic table entry, Data is in Big endian format
 214  *
 215  * entry [in] - generic table entry
 216  * offset [in] - The offset in bits where the data has to get
 217  * len [in] - The length of the data in bits to be get
 218  * data [out] - pointer to the data to be used for setting the value.
 219  * data_size [in] - The size of data in bytes
 220  *
 221  * returns 0 on success
 222  */
 223 int32_t
 224 ulp_mapper_gen_tbl_entry_data_get(struct ulp_mapper_gen_tbl_entry *entry,
 225                                   uint32_t offset, uint32_t len, uint8_t *data,
 226                                   uint32_t data_size)
 227 {
 228         /* validate the null arguments */
 229         if (!entry || !data) {
 230                 BNXT_TF_DBG(ERR, "invalid argument\n");
 231                 return -EINVAL;
 232         }
 233
 234         /* check the size of the buffer for validation */
 235         if ((offset + len) > ULP_BYTE_2_BITS(entry->byte_data_size) ||
 236             len > ULP_BYTE_2_BITS(data_size)) {
 237                 BNXT_TF_DBG(ERR, "invalid offset or length %x:%x:%x\n",
 238                             offset, len, entry->byte_data_size);
 239                 return -EINVAL;
 240         }
 241         if (entry->byte_order == BNXT_ULP_BYTE_ORDER_LE)
 242                 ulp_bs_pull_lsb(entry->byte_data, data, data_size, offset, len);
 243         else
 244                 ulp_bs_pull_msb(entry->byte_data, data, offset, len);
 245
 246         return 0;
 247 }
 248
 249 /* Free the generic table list entry
 250  *
 251  * ulp_ctx [in] - Pointer to the ulp context
 252  * tbl_idx [in] - Index of the generic table
 253  * ckey [in] - Key for the entry in the table
 254  *
 255  * returns 0 on success
 256  */
 257 int32_t
 258 ulp_mapper_gen_tbl_entry_free(struct bnxt_ulp_context *ulp_ctx,
 259                               uint32_t tbl_idx, uint32_t ckey)
 260 {
 261         struct ulp_flow_db_res_params res;
 262
 263         res.direction = tbl_idx & 0x1;
 264         res.resource_sub_type = tbl_idx >> 1;
 265         res.resource_hndl = ckey;
 266
 267         return ulp_mapper_gen_tbl_res_free(ulp_ctx, &res);
 268 }
 269
 270 /* Free the generic table list resource
 271  *
 272  * ulp_ctx [in] - Pointer to the ulp context
 273  * res [in] - Pointer to flow db resource entry
 274  *
 275  * returns 0 on success
 276  */
 277 int32_t
 278 ulp_mapper_gen_tbl_res_free(struct bnxt_ulp_context *ulp_ctx,
 279                             struct ulp_flow_db_res_params *res)
 280 {
 281         struct bnxt_ulp_mapper_data *mapper_data;
 282         struct ulp_mapper_gen_tbl_list *gen_tbl_list;
 283         struct ulp_mapper_gen_tbl_entry entry;
 284         struct ulp_gen_hash_entry_params hash_entry;
 285         int32_t tbl_idx;
 286         uint32_t fid = 0;
 287         uint32_t key_idx;
 288
 289         /* Extract the resource sub type and direction */
 290         tbl_idx = ulp_mapper_gen_tbl_idx_calculate(res->resource_sub_type,
 291                                                    res->direction);
 292         if (tbl_idx < 0) {
 293                 BNXT_TF_DBG(ERR, "invalid argument %x:%x\n",
 294                             res->resource_sub_type, res->direction);
 295                 return -EINVAL;
 296         }
 297
 298         mapper_data = bnxt_ulp_cntxt_ptr2_mapper_data_get(ulp_ctx);
 299         if (!mapper_data) {
 300                 BNXT_TF_DBG(ERR, "invalid ulp context %x\n", tbl_idx);
 301                 return -EINVAL;
 302         }
 303         /* get the generic table  */
 304         gen_tbl_list = &mapper_data->gen_tbl_list[tbl_idx];
 305
 306         /* Get the generic table entry*/
 307         if (gen_tbl_list->hash_tbl) {
 308                 /* use the hash index to get the value */
 309                 hash_entry.hash_index = (uint32_t)res->resource_hndl;
 310                 if (ulp_gen_hash_tbl_list_index_search(gen_tbl_list->hash_tbl,
 311                                                        &hash_entry)) {
 312                         BNXT_TF_DBG(ERR, "Unable to find has entry %x:%x\n",
 313                                     tbl_idx, hash_entry.hash_index);
 314                         return -EINVAL;
 315                 }
 316                 key_idx = hash_entry.key_idx;
 317
 318         } else {
 319                 key_idx =  (uint32_t)res->resource_hndl;
 320         }
 321         if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list, key_idx, &entry)) {
 322                 BNXT_TF_DBG(ERR, "Gen tbl entry get failed %x:%" PRIX64 "\n",
 323                             tbl_idx, res->resource_hndl);
 324                 return -EINVAL;
 325         }
 326
 327         /* Decrement the reference count */
 328         if (!ULP_GEN_TBL_REF_CNT(&entry)) {
 329                 BNXT_TF_DBG(ERR, "generic table corrupt %x:%" PRIX64 "\n",
 330                             tbl_idx, res->resource_hndl);
 331                 return -EINVAL;
 332         }
 333         ULP_GEN_TBL_REF_CNT_DEC(&entry);
 334
 335         /* retain the details since there are other users */
 336         if (ULP_GEN_TBL_REF_CNT(&entry))
 337                 return 0;
 338
 339         /* Delete the generic table entry. First extract the fid */
 340         if (ulp_mapper_gen_tbl_entry_data_get(&entry, ULP_GEN_TBL_FID_OFFSET,
 341                                               ULP_GEN_TBL_FID_SIZE_BITS,
 342                                               (uint8_t *)&fid,
 343                                               sizeof(fid))) {
 344                 BNXT_TF_DBG(ERR, "Unable to get fid %x:%" PRIX64 "\n",
 345                             tbl_idx, res->resource_hndl);
 346                 return -EINVAL;
 347         }
 348         fid = tfp_be_to_cpu_32(fid);
 349
 350         /* Destroy the flow associated with the shared flow id */
 351         if (ulp_mapper_flow_destroy(ulp_ctx, BNXT_ULP_FDB_TYPE_RID,
 352                                     fid))
 353                 BNXT_TF_DBG(ERR, "Error in deleting shared flow id %x\n", fid);
 354
 355         /* Delete the entry from the hash table */
 356         if (gen_tbl_list->hash_tbl)
 357                 ulp_gen_hash_tbl_list_del(gen_tbl_list->hash_tbl, &hash_entry);
 358
 359         /* clear the byte data of the generic table entry */
 360         memset(entry.byte_data, 0, entry.byte_data_size);
 361
 362         return 0;
 363 }
 364
 365 /*
 366  * Write the generic table list hash entry
 367  *
 368  * tbl_list [in] - pointer to the generic table list
 369  * hash_entry [in] -  Hash table entry
 370  * gen_tbl_ent [out] - generic table entry
 371  *
 372  * returns 0 on success.
 373  */
 374 int32_t
 375 ulp_mapper_gen_tbl_hash_entry_add(struct ulp_mapper_gen_tbl_list *tbl_list,
 376                                   struct ulp_gen_hash_entry_params *hash_entry,
 377                                   struct ulp_mapper_gen_tbl_entry *gen_tbl_ent)
 378 {
 379         uint32_t key;
 380         int32_t rc = 0;
 381
 382         switch (hash_entry->search_flag) {
 383         case ULP_GEN_HASH_SEARCH_FOUND:
 384                 BNXT_TF_DBG(ERR, "%s: gen hash entry already present\n",
 385                             tbl_list->gen_tbl_name);
 386                 return -EINVAL;
 387         case ULP_GEN_HASH_SEARCH_FULL:
 388                 BNXT_TF_DBG(ERR, "%s: gen hash table is full\n",
 389                             tbl_list->gen_tbl_name);
 390                 return -EINVAL;
 391         case ULP_GEN_HASH_SEARCH_MISSED:
 392                 rc = ulp_gen_hash_tbl_list_add(tbl_list->hash_tbl, hash_entry);
 393                 if (rc) {
 394                         BNXT_TF_DBG(ERR, "%s: gen hash table add failed\n",
 395                                     tbl_list->gen_tbl_name);
 396                         return -EINVAL;
 397                 }
 398                 key = hash_entry->key_idx;
 399                 gen_tbl_ent->ref_count = &tbl_list->container.ref_count[key];
 400                 gen_tbl_ent->byte_data_size =
 401                         tbl_list->container.byte_data_size;
 402                 gen_tbl_ent->byte_data = &tbl_list->container.byte_data[key *
 403                         gen_tbl_ent->byte_data_size];
 404                 gen_tbl_ent->byte_order = tbl_list->container.byte_order;
 405                 break;
 406         default:
 407                 BNXT_TF_DBG(ERR, "%s: invalid search flag\n",
 408                             tbl_list->gen_tbl_name);
 409                 return -EINVAL;
 410         }
 411
 412         return rc;
 413 }