drivers/net/bnxt/tf_ulp/ulp_flow_db.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <rte_malloc.h>
   7 #include "bnxt.h"
   8 #include "bnxt_tf_common.h"
   9 #include "ulp_utils.h"
  10 #include "ulp_template_struct.h"
  11 #include "ulp_mapper.h"
  12 #include "ulp_flow_db.h"
  13 #include "ulp_fc_mgr.h"
  14 #include "ulp_tun.h"
  15
  16 #define ULP_FLOW_DB_RES_DIR_BIT         31
  17 #define ULP_FLOW_DB_RES_DIR_MASK        0x80000000
  18 #define ULP_FLOW_DB_RES_FUNC_BITS       28
  19 #define ULP_FLOW_DB_RES_FUNC_MASK       0x70000000
  20 #define ULP_FLOW_DB_RES_NXT_MASK        0x0FFFFFFF
  21 #define ULP_FLOW_DB_RES_FUNC_UPPER      5
  22 #define ULP_FLOW_DB_RES_FUNC_NEED_LOWER 0x80
  23 #define ULP_FLOW_DB_RES_FUNC_LOWER_MASK 0x1F
  24
  25 /* Macro to copy the nxt_resource_idx */
  26 #define ULP_FLOW_DB_RES_NXT_SET(dst, src)       {(dst) |= ((src) &\
  27                                          ULP_FLOW_DB_RES_NXT_MASK); }
  28 #define ULP_FLOW_DB_RES_NXT_RESET(dst)  ((dst) &= ~(ULP_FLOW_DB_RES_NXT_MASK))
  29
  30 /*
  31  * Helper function to set the bit in the active flows
  32  * No validation is done in this function.
  33  *
  34  * flow_db [in] Ptr to flow database
  35  * flow_type [in] - specify default or regular
  36  * idx [in] The index to bit to be set or reset.
  37  * flag [in] 1 to set and 0 to reset.
  38  *
  39  * returns none
  40  */
  41 static void
  42 ulp_flow_db_active_flows_bit_set(struct bnxt_ulp_flow_db *flow_db,
  43                                  enum bnxt_ulp_fdb_type flow_type,
  44                                  uint32_t idx,
  45                                  uint32_t flag)
  46 {
  47         struct bnxt_ulp_flow_tbl *f_tbl = &flow_db->flow_tbl;
  48         uint32_t a_idx = idx / ULP_INDEX_BITMAP_SIZE;
  49
  50         if (flag) {
  51                 if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR || flow_type ==
  52                     BNXT_ULP_FDB_TYPE_RID)
  53                         ULP_INDEX_BITMAP_SET(f_tbl->active_reg_flows[a_idx],
  54                                              idx);
  55                 if (flow_type == BNXT_ULP_FDB_TYPE_DEFAULT || flow_type ==
  56                     BNXT_ULP_FDB_TYPE_RID)
  57                         ULP_INDEX_BITMAP_SET(f_tbl->active_dflt_flows[a_idx],
  58                                              idx);
  59         } else {
  60                 if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR || flow_type ==
  61                     BNXT_ULP_FDB_TYPE_RID)
  62                         ULP_INDEX_BITMAP_RESET(f_tbl->active_reg_flows[a_idx],
  63                                                idx);
  64                 if (flow_type == BNXT_ULP_FDB_TYPE_DEFAULT || flow_type ==
  65                     BNXT_ULP_FDB_TYPE_RID)
  66                         ULP_INDEX_BITMAP_RESET(f_tbl->active_dflt_flows[a_idx],
  67                                                idx);
  68         }
  69 }
  70
  71 /*
  72  * Helper function to check if given fid is active flow.
  73  * No validation being done in this function.
  74  *
  75  * flow_db [in] Ptr to flow database
  76  * flow_type [in] - specify default or regular
  77  * idx [in] The index to bit to be set or reset.
  78  *
  79  * returns 1 on set or 0 if not set.
  80  */
  81 static int32_t
  82 ulp_flow_db_active_flows_bit_is_set(struct bnxt_ulp_flow_db *flow_db,
  83                                     enum bnxt_ulp_fdb_type flow_type,
  84                                     uint32_t idx)
  85 {
  86         struct bnxt_ulp_flow_tbl *f_tbl = &flow_db->flow_tbl;
  87         uint32_t a_idx = idx / ULP_INDEX_BITMAP_SIZE;
  88         uint32_t reg, dflt;
  89
  90         reg = ULP_INDEX_BITMAP_GET(f_tbl->active_reg_flows[a_idx], idx);
  91         dflt = ULP_INDEX_BITMAP_GET(f_tbl->active_dflt_flows[a_idx], idx);
  92
  93         switch (flow_type) {
  94         case BNXT_ULP_FDB_TYPE_REGULAR:
  95                 return (reg && !dflt);
  96         case BNXT_ULP_FDB_TYPE_DEFAULT:
  97                 return (!reg && dflt);
  98         case BNXT_ULP_FDB_TYPE_RID:
  99                 return (reg && dflt);
 100         default:
 101                 return 0;
 102         }
 103 }
 104
 105 static inline enum tf_dir
 106 ulp_flow_db_resource_dir_get(struct ulp_fdb_resource_info *res_info)
 107 {
 108         return ((res_info->nxt_resource_idx & ULP_FLOW_DB_RES_DIR_MASK) >>
 109                 ULP_FLOW_DB_RES_DIR_BIT);
 110 }
 111
 112 static uint8_t
 113 ulp_flow_db_resource_func_get(struct ulp_fdb_resource_info *res_info)
 114 {
 115         uint8_t func;
 116
 117         func = (((res_info->nxt_resource_idx & ULP_FLOW_DB_RES_FUNC_MASK) >>
 118                  ULP_FLOW_DB_RES_FUNC_BITS) << ULP_FLOW_DB_RES_FUNC_UPPER);
 119         /* The resource func is split into upper and lower */
 120         if (func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER)
 121                 return (func | res_info->resource_func_lower);
 122         return func;
 123 }
 124
 125 /*
 126  * Helper function to copy the resource params to resource info
 127  *  No validation being done in this function.
 128  *
 129  * resource_info [out] Ptr to resource information
 130  * params [in] The input params from the caller
 131  * returns none
 132  */
 133 static void
 134 ulp_flow_db_res_params_to_info(struct ulp_fdb_resource_info *resource_info,
 135                                struct ulp_flow_db_res_params *params)
 136 {
 137         uint32_t resource_func;
 138
 139         resource_info->nxt_resource_idx |= ((params->direction <<
 140                                       ULP_FLOW_DB_RES_DIR_BIT) &
 141                                      ULP_FLOW_DB_RES_DIR_MASK);
 142         resource_func = (params->resource_func >> ULP_FLOW_DB_RES_FUNC_UPPER);
 143         resource_info->nxt_resource_idx |= ((resource_func <<
 144                                              ULP_FLOW_DB_RES_FUNC_BITS) &
 145                                             ULP_FLOW_DB_RES_FUNC_MASK);
 146
 147         if (params->resource_func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER) {
 148                 /* Break the resource func into two parts */
 149                 resource_func = (params->resource_func &
 150                                  ULP_FLOW_DB_RES_FUNC_LOWER_MASK);
 151                 resource_info->resource_func_lower = resource_func;
 152         }
 153
 154         /* Store the handle as 64bit only for EM table entries */
 155         if (params->resource_func != BNXT_ULP_RESOURCE_FUNC_EM_TABLE) {
 156                 resource_info->resource_hndl = (uint32_t)params->resource_hndl;
 157                 resource_info->resource_type = params->resource_type;
 158                 resource_info->resource_sub_type = params->resource_sub_type;
 159                 resource_info->fdb_flags = params->fdb_flags;
 160         } else {
 161                 resource_info->resource_em_handle = params->resource_hndl;
 162         }
 163 }
 164
 165 /*
 166  * Helper function to copy the resource params to resource info
 167  *  No validation being done in this function.
 168  *
 169  * resource_info [in] Ptr to resource information
 170  * params [out] The output params to the caller
 171  *
 172  * returns none
 173  */
 174 static void
 175 ulp_flow_db_res_info_to_params(struct ulp_fdb_resource_info *resource_info,
 176                                struct ulp_flow_db_res_params *params)
 177 {
 178         memset(params, 0, sizeof(struct ulp_flow_db_res_params));
 179
 180         /* use the helper function to get the resource func */
 181         params->direction = ulp_flow_db_resource_dir_get(resource_info);
 182         params->resource_func = ulp_flow_db_resource_func_get(resource_info);
 183
 184         if (params->resource_func == BNXT_ULP_RESOURCE_FUNC_EM_TABLE) {
 185                 params->resource_hndl = resource_info->resource_em_handle;
 186         } else if (params->resource_func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER) {
 187                 params->resource_hndl = resource_info->resource_hndl;
 188                 params->resource_type = resource_info->resource_type;
 189                 params->resource_sub_type = resource_info->resource_sub_type;
 190                 params->fdb_flags = resource_info->fdb_flags;
 191         }
 192 }
 193
 194 /*
 195  * Helper function to allocate the flow table and initialize
 196  * the stack for allocation operations.
 197  *
 198  * flow_db [in] Ptr to flow database structure
 199  *
 200  * Returns 0 on success or negative number on failure.
 201  */
 202 static int32_t
 203 ulp_flow_db_alloc_resource(struct bnxt_ulp_flow_db *flow_db)
 204 {
 205         uint32_t                        idx = 0;
 206         struct bnxt_ulp_flow_tbl        *flow_tbl;
 207         uint32_t                        size;
 208
 209         flow_tbl = &flow_db->flow_tbl;
 210
 211         size = sizeof(struct ulp_fdb_resource_info) * flow_tbl->num_resources;
 212         flow_tbl->flow_resources =
 213                         rte_zmalloc("ulp_fdb_resource_info", size, 0);
 214
 215         if (!flow_tbl->flow_resources) {
 216                 BNXT_TF_DBG(ERR, "Failed to alloc memory for flow table\n");
 217                 return -ENOMEM;
 218         }
 219         size = sizeof(uint32_t) * flow_tbl->num_resources;
 220         flow_tbl->flow_tbl_stack = rte_zmalloc("flow_tbl_stack", size, 0);
 221         if (!flow_tbl->flow_tbl_stack) {
 222                 BNXT_TF_DBG(ERR, "Failed to alloc memory flow tbl stack\n");
 223                 return -ENOMEM;
 224         }
 225         size = (flow_tbl->num_flows / sizeof(uint64_t)) + 1;
 226         size = ULP_BYTE_ROUND_OFF_8(size);
 227         flow_tbl->active_reg_flows = rte_zmalloc("active reg flows", size,
 228                                                  ULP_BUFFER_ALIGN_64_BYTE);
 229         if (!flow_tbl->active_reg_flows) {
 230                 BNXT_TF_DBG(ERR, "Failed to alloc memory active reg flows\n");
 231                 return -ENOMEM;
 232         }
 233
 234         flow_tbl->active_dflt_flows = rte_zmalloc("active dflt flows", size,
 235                                                   ULP_BUFFER_ALIGN_64_BYTE);
 236         if (!flow_tbl->active_dflt_flows) {
 237                 BNXT_TF_DBG(ERR, "Failed to alloc memory active dflt flows\n");
 238                 return -ENOMEM;
 239         }
 240
 241         /* Initialize the stack table. */
 242         for (idx = 0; idx < flow_tbl->num_resources; idx++)
 243                 flow_tbl->flow_tbl_stack[idx] = idx;
 244
 245         /* Ignore the first element in the list. */
 246         flow_tbl->head_index = 1;
 247         /* Tail points to the last entry in the list. */
 248         flow_tbl->tail_index = flow_tbl->num_resources - 1;
 249         return 0;
 250 }
 251
 252 /*
 253  * Helper function to deallocate the flow table.
 254  *
 255  * flow_db [in] Ptr to flow database structure
 256  *
 257  * Returns none.
 258  */
 259 static void
 260 ulp_flow_db_dealloc_resource(struct bnxt_ulp_flow_db *flow_db)
 261 {
 262         struct bnxt_ulp_flow_tbl *flow_tbl = &flow_db->flow_tbl;
 263
 264         /* Free all the allocated tables in the flow table. */
 265         if (flow_tbl->active_reg_flows) {
 266                 rte_free(flow_tbl->active_reg_flows);
 267                 flow_tbl->active_reg_flows = NULL;
 268         }
 269         if (flow_tbl->active_dflt_flows) {
 270                 rte_free(flow_tbl->active_dflt_flows);
 271                 flow_tbl->active_dflt_flows = NULL;
 272         }
 273
 274         if (flow_tbl->flow_tbl_stack) {
 275                 rte_free(flow_tbl->flow_tbl_stack);
 276                 flow_tbl->flow_tbl_stack = NULL;
 277         }
 278
 279         if (flow_tbl->flow_resources) {
 280                 rte_free(flow_tbl->flow_resources);
 281                 flow_tbl->flow_resources = NULL;
 282         }
 283 }
 284
 285 /*
 286  * Helper function to add function id to the flow table
 287  *
 288  * flow_db [in] Ptr to flow table
 289  * flow_id [in] The flow id of the flow
 290  * func_id [in] The func_id to be set, for reset pass zero
 291  *
 292  * returns none
 293  */
 294 static void
 295 ulp_flow_db_func_id_set(struct bnxt_ulp_flow_db *flow_db,
 296                         uint32_t flow_id,
 297                         uint32_t func_id)
 298 {
 299         /* set the function id in the function table */
 300         if (flow_id < flow_db->func_id_tbl_size)
 301                 flow_db->func_id_tbl[flow_id] = func_id;
 302         else /* This should never happen */
 303                 BNXT_TF_DBG(ERR, "Invalid flow id, flowdb corrupt\n");
 304 }
 305
 306 /*
 307  * Initialize the parent-child database. Memory is allocated in this
 308  * call and assigned to the database
 309  *
 310  * flow_db [in] Ptr to flow table
 311  * num_entries[in] - number of entries to allocate
 312  *
 313  * Returns 0 on success or negative number on failure.
 314  */
 315 static int32_t
 316 ulp_flow_db_parent_tbl_init(struct bnxt_ulp_flow_db *flow_db,
 317                             uint32_t num_entries)
 318 {
 319         struct ulp_fdb_parent_child_db *p_db;
 320         uint32_t size, idx;
 321
 322         if (!num_entries)
 323                 return 0;
 324
 325         /* update the sizes for the allocation */
 326         p_db = &flow_db->parent_child_db;
 327         p_db->child_bitset_size = (flow_db->flow_tbl.num_flows /
 328                                    sizeof(uint64_t)) + 1; /* size in bytes */
 329         p_db->child_bitset_size = ULP_BYTE_ROUND_OFF_8(p_db->child_bitset_size);
 330         p_db->entries_count = num_entries;
 331
 332         /* allocate the memory */
 333         p_db->parent_flow_tbl = rte_zmalloc("fdb parent flow tbl",
 334                                             sizeof(struct ulp_fdb_parent_info) *
 335                                             p_db->entries_count, 0);
 336         if (!p_db->parent_flow_tbl) {
 337                 BNXT_TF_DBG(ERR,
 338                             "Failed to allocate memory fdb parent flow tbl\n");
 339                 return -ENOMEM;
 340         }
 341         size = p_db->child_bitset_size * p_db->entries_count;
 342
 343         /*
 344          * allocate the big chunk of memory to be statically carved into
 345          * child_fid_bitset pointer.
 346          */
 347         p_db->parent_flow_tbl_mem = rte_zmalloc("fdb parent flow tbl mem",
 348                                                 size,
 349                                                 ULP_BUFFER_ALIGN_64_BYTE);
 350         if (!p_db->parent_flow_tbl_mem) {
 351                 BNXT_TF_DBG(ERR,
 352                             "Failed to allocate memory fdb parent flow mem\n");
 353                 return -ENOMEM;
 354         }
 355
 356         /* set the pointers in parent table to their offsets */
 357         for (idx = 0 ; idx < p_db->entries_count; idx++) {
 358                 p_db->parent_flow_tbl[idx].child_fid_bitset =
 359                         (uint64_t *)&p_db->parent_flow_tbl_mem[idx *
 360                         p_db->child_bitset_size];
 361         }
 362         /* success */
 363         return 0;
 364 }
 365
 366 /*
 367  * Deinitialize the parent-child database. Memory is deallocated in
 368  * this call and all flows should have been purged before this
 369  * call.
 370  *
 371  * flow_db [in] Ptr to flow table
 372  *
 373  * Returns none
 374  */
 375 static void
 376 ulp_flow_db_parent_tbl_deinit(struct bnxt_ulp_flow_db *flow_db)
 377 {
 378         /* free the memory related to parent child database */
 379         if (flow_db->parent_child_db.parent_flow_tbl_mem) {
 380                 rte_free(flow_db->parent_child_db.parent_flow_tbl_mem);
 381                 flow_db->parent_child_db.parent_flow_tbl_mem = NULL;
 382         }
 383         if (flow_db->parent_child_db.parent_flow_tbl) {
 384                 rte_free(flow_db->parent_child_db.parent_flow_tbl);
 385                 flow_db->parent_child_db.parent_flow_tbl = NULL;
 386         }
 387 }
 388
 389 /*
 390  * Initialize the flow database. Memory is allocated in this
 391  * call and assigned to the flow database.
 392  *
 393  * ulp_ctxt [in] Ptr to ulp context
 394  *
 395  * Returns 0 on success or negative number on failure.
 396  */
 397 int32_t
 398 ulp_flow_db_init(struct bnxt_ulp_context *ulp_ctxt)
 399 {
 400         struct bnxt_ulp_device_params *dparms;
 401         struct bnxt_ulp_flow_tbl *flow_tbl;
 402         struct bnxt_ulp_flow_db *flow_db;
 403         uint32_t dev_id, num_flows;
 404         enum bnxt_ulp_flow_mem_type mtype;
 405
 406         /* Get the dev specific number of flows that needed to be supported. */
 407         if (bnxt_ulp_cntxt_dev_id_get(ulp_ctxt, &dev_id)) {
 408                 BNXT_TF_DBG(ERR, "Invalid device id\n");
 409                 return -EINVAL;
 410         }
 411
 412         dparms = bnxt_ulp_device_params_get(dev_id);
 413         if (!dparms) {
 414                 BNXT_TF_DBG(ERR, "could not fetch the device params\n");
 415                 return -ENODEV;
 416         }
 417
 418         flow_db = rte_zmalloc("bnxt_ulp_flow_db",
 419                               sizeof(struct bnxt_ulp_flow_db), 0);
 420         if (!flow_db) {
 421                 BNXT_TF_DBG(ERR,
 422                             "Failed to allocate memory for flow table ptr\n");
 423                 return -ENOMEM;
 424         }
 425
 426         /* Attach the flow database to the ulp context. */
 427         bnxt_ulp_cntxt_ptr2_flow_db_set(ulp_ctxt, flow_db);
 428
 429         /* Determine the number of flows based on EM type */
 430         if (bnxt_ulp_cntxt_mem_type_get(ulp_ctxt, &mtype))
 431                 goto error_free;
 432
 433         if (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT)
 434                 num_flows = dparms->int_flow_db_num_entries;
 435         else
 436                 num_flows = dparms->ext_flow_db_num_entries;
 437
 438         /* Populate the regular flow table limits. */
 439         flow_tbl = &flow_db->flow_tbl;
 440         flow_tbl->num_flows = num_flows + 1;
 441         flow_tbl->num_resources = ((num_flows + 1) *
 442                                    dparms->num_resources_per_flow);
 443
 444         /* Include the default flow table limits. */
 445         flow_tbl->num_flows += (BNXT_FLOW_DB_DEFAULT_NUM_FLOWS + 1);
 446         flow_tbl->num_resources += ((BNXT_FLOW_DB_DEFAULT_NUM_FLOWS + 1) *
 447                                     BNXT_FLOW_DB_DEFAULT_NUM_RESOURCES);
 448
 449         /* Allocate the resource for the flow table. */
 450         if (ulp_flow_db_alloc_resource(flow_db))
 451                 goto error_free;
 452
 453         /* add 1 since we are not using index 0 for flow id */
 454         flow_db->func_id_tbl_size = flow_tbl->num_flows + 1;
 455         /* Allocate the function Id table */
 456         flow_db->func_id_tbl = rte_zmalloc("bnxt_ulp_flow_db_func_id_table",
 457                                            flow_db->func_id_tbl_size *
 458                                            sizeof(uint16_t), 0);
 459         if (!flow_db->func_id_tbl) {
 460                 BNXT_TF_DBG(ERR,
 461                             "Failed to allocate mem for flow table func id\n");
 462                 goto error_free;
 463         }
 464         /* initialize the parent child database */
 465         if (ulp_flow_db_parent_tbl_init(flow_db,
 466                                         dparms->fdb_parent_flow_entries)) {
 467                 BNXT_TF_DBG(ERR,
 468                             "Failed to allocate mem for parent child db\n");
 469                 goto error_free;
 470         }
 471
 472         /* All good so return. */
 473         BNXT_TF_DBG(INFO, "FlowDB initialized with %d flows.\n",
 474                     flow_tbl->num_flows);
 475         return 0;
 476 error_free:
 477         ulp_flow_db_deinit(ulp_ctxt);
 478         return -ENOMEM;
 479 }
 480
 481 /*
 482  * Deinitialize the flow database. Memory is deallocated in
 483  * this call and all flows should have been purged before this
 484  * call.
 485  *
 486  * ulp_ctxt [in] Ptr to ulp context
 487  *
 488  * Returns 0 on success.
 489  */
 490 int32_t
 491 ulp_flow_db_deinit(struct bnxt_ulp_context *ulp_ctxt)
 492 {
 493         struct bnxt_ulp_flow_db *flow_db;
 494
 495         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 496         if (!flow_db)
 497                 return -EINVAL;
 498
 499         /* Detach the flow database from the ulp context. */
 500         bnxt_ulp_cntxt_ptr2_flow_db_set(ulp_ctxt, NULL);
 501
 502         /* Free up all the memory. */
 503         ulp_flow_db_parent_tbl_deinit(flow_db);
 504         ulp_flow_db_dealloc_resource(flow_db);
 505         rte_free(flow_db->func_id_tbl);
 506         rte_free(flow_db);
 507
 508         return 0;
 509 }
 510
 511 /*
 512  * Allocate the flow database entry
 513  *
 514  * ulp_ctxt [in] Ptr to ulp_context
 515  * flow_type [in] - specify default or regular
 516  * func_id [in].function id of the ingress port
 517  * fid [out] The index to the flow entry
 518  *
 519  * returns 0 on success and negative on failure.
 520  */
 521 int32_t
 522 ulp_flow_db_fid_alloc(struct bnxt_ulp_context *ulp_ctxt,
 523                       enum bnxt_ulp_fdb_type flow_type,
 524                       uint16_t func_id,
 525                       uint32_t *fid)
 526 {
 527         struct bnxt_ulp_flow_db *flow_db;
 528         struct bnxt_ulp_flow_tbl *flow_tbl;
 529
 530         *fid = 0; /* Initialize fid to invalid value */
 531         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 532         if (!flow_db) {
 533                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 534                 return -EINVAL;
 535         }
 536
 537         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
 538                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
 539                 return -EINVAL;
 540         }
 541
 542         flow_tbl = &flow_db->flow_tbl;
 543         /* check for max flows */
 544         if (flow_tbl->num_flows <= flow_tbl->head_index) {
 545                 BNXT_TF_DBG(ERR, "Flow database has reached max flows\n");
 546                 return -ENOMEM;
 547         }
 548         if (flow_tbl->tail_index <= (flow_tbl->head_index + 1)) {
 549                 BNXT_TF_DBG(ERR, "Flow database has reached max resources\n");
 550                 return -ENOMEM;
 551         }
 552         *fid = flow_tbl->flow_tbl_stack[flow_tbl->head_index];
 553         flow_tbl->head_index++;
 554
 555         /* Set the flow type */
 556         ulp_flow_db_active_flows_bit_set(flow_db, flow_type, *fid, 1);
 557
 558         /* function id update is only valid for regular flow table */
 559         if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
 560                 ulp_flow_db_func_id_set(flow_db, *fid, func_id);
 561
 562         /* return success */
 563         return 0;
 564 }
 565
 566 /*
 567  * Allocate the flow database entry.
 568  * The params->critical_resource has to be set to 0 to allocate a new resource.
 569  *
 570  * ulp_ctxt [in] Ptr to ulp_context
 571  * flow_type [in] Specify it is regular or default flow
 572  * fid [in] The index to the flow entry
 573  * params [in] The contents to be copied into resource
 574  *
 575  * returns 0 on success and negative on failure.
 576  */
 577 int32_t
 578 ulp_flow_db_resource_add(struct bnxt_ulp_context *ulp_ctxt,
 579                          enum bnxt_ulp_fdb_type flow_type,
 580                          uint32_t fid,
 581                          struct ulp_flow_db_res_params *params)
 582 {
 583         struct bnxt_ulp_flow_db *flow_db;
 584         struct bnxt_ulp_flow_tbl *flow_tbl;
 585         struct ulp_fdb_resource_info *resource, *fid_resource;
 586         struct bnxt_ulp_fc_info *ulp_fc_info;
 587         uint32_t idx;
 588
 589         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 590         if (!flow_db) {
 591                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 592                 return -EINVAL;
 593         }
 594
 595         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
 596                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
 597                 return -EINVAL;
 598         }
 599
 600         flow_tbl = &flow_db->flow_tbl;
 601         /* check for max flows */
 602         if (fid >= flow_tbl->num_flows || !fid) {
 603                 BNXT_TF_DBG(ERR, "Invalid flow index\n");
 604                 return -EINVAL;
 605         }
 606
 607         /* check if the flow is active or not */
 608         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
 609                 BNXT_TF_DBG(ERR, "flow does not exist %x:%x\n", flow_type, fid);
 610                 return -EINVAL;
 611         }
 612
 613         /* check for max resource */
 614         if ((flow_tbl->head_index + 1) >= flow_tbl->tail_index) {
 615                 BNXT_TF_DBG(ERR, "Flow db has reached max resources\n");
 616                 return -ENOMEM;
 617         }
 618         fid_resource = &flow_tbl->flow_resources[fid];
 619
 620         if (params->critical_resource && fid_resource->resource_em_handle) {
 621                 BNXT_TF_DBG(DEBUG, "Ignore multiple critical resources\n");
 622                 /* Ignore the multiple critical resources */
 623                 params->critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
 624         }
 625
 626         if (!params->critical_resource) {
 627                 /* Not the critical_resource so allocate a resource */
 628                 idx = flow_tbl->flow_tbl_stack[flow_tbl->tail_index];
 629                 resource = &flow_tbl->flow_resources[idx];
 630                 flow_tbl->tail_index--;
 631
 632                 /* Update the chain list of resource*/
 633                 ULP_FLOW_DB_RES_NXT_SET(resource->nxt_resource_idx,
 634                                         fid_resource->nxt_resource_idx);
 635                 /* update the contents */
 636                 ulp_flow_db_res_params_to_info(resource, params);
 637                 ULP_FLOW_DB_RES_NXT_RESET(fid_resource->nxt_resource_idx);
 638                 ULP_FLOW_DB_RES_NXT_SET(fid_resource->nxt_resource_idx,
 639                                         idx);
 640         } else {
 641                 /* critical resource. Just update the fid resource */
 642                 ulp_flow_db_res_params_to_info(fid_resource, params);
 643         }
 644
 645         ulp_fc_info = bnxt_ulp_cntxt_ptr2_fc_info_get(ulp_ctxt);
 646         if (params->resource_type == TF_TBL_TYPE_ACT_STATS_64 &&
 647             params->resource_sub_type ==
 648             BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT &&
 649             ulp_fc_info && ulp_fc_info->num_counters) {
 650                 /* Store the first HW counter ID for this table */
 651                 if (!ulp_fc_mgr_start_idx_isset(ulp_ctxt, params->direction))
 652                         ulp_fc_mgr_start_idx_set(ulp_ctxt, params->direction,
 653                                                  params->resource_hndl);
 654
 655                 ulp_fc_mgr_cntr_set(ulp_ctxt, params->direction,
 656                                     params->resource_hndl);
 657
 658                 if (!ulp_fc_mgr_thread_isstarted(ulp_ctxt))
 659                         ulp_fc_mgr_thread_start(ulp_ctxt);
 660         }
 661
 662         /* all good, return success */
 663         return 0;
 664 }
 665
 666 /*
 667  * Free the flow database entry.
 668  * The params->critical_resource has to be set to 1 to free the first resource.
 669  *
 670  * ulp_ctxt [in] Ptr to ulp_context
 671  * flow_type [in] Specify it is regular or default flow
 672  * fid [in] The index to the flow entry
 673  * params [in/out] The contents to be copied into params.
 674  * Only the critical_resource needs to be set by the caller.
 675  *
 676  * Returns 0 on success and negative on failure.
 677  */
 678 int32_t
 679 ulp_flow_db_resource_del(struct bnxt_ulp_context *ulp_ctxt,
 680                          enum bnxt_ulp_fdb_type flow_type,
 681                          uint32_t fid,
 682                          struct ulp_flow_db_res_params *params)
 683 {
 684         struct bnxt_ulp_flow_db *flow_db;
 685         struct bnxt_ulp_flow_tbl *flow_tbl;
 686         struct ulp_fdb_resource_info *nxt_resource, *fid_resource;
 687         uint32_t nxt_idx = 0;
 688
 689         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 690         if (!flow_db) {
 691                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 692                 return -EINVAL;
 693         }
 694
 695         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
 696                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
 697                 return -EINVAL;
 698         }
 699
 700         flow_tbl = &flow_db->flow_tbl;
 701         /* check for max flows */
 702         if (fid >= flow_tbl->num_flows || !fid) {
 703                 BNXT_TF_DBG(ERR, "Invalid flow index %x\n", fid);
 704                 return -EINVAL;
 705         }
 706
 707         /* check if the flow is active or not */
 708         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
 709                 BNXT_TF_DBG(ERR, "flow does not exist %x:%x\n", flow_type, fid);
 710                 return -EINVAL;
 711         }
 712
 713         fid_resource = &flow_tbl->flow_resources[fid];
 714         if (!params->critical_resource) {
 715                 /* Not the critical resource so free the resource */
 716                 ULP_FLOW_DB_RES_NXT_SET(nxt_idx,
 717                                         fid_resource->nxt_resource_idx);
 718                 if (!nxt_idx) {
 719                         /* reached end of resources */
 720                         return -ENOENT;
 721                 }
 722                 nxt_resource = &flow_tbl->flow_resources[nxt_idx];
 723
 724                 /* connect the fid resource to the next resource */
 725                 ULP_FLOW_DB_RES_NXT_RESET(fid_resource->nxt_resource_idx);
 726                 ULP_FLOW_DB_RES_NXT_SET(fid_resource->nxt_resource_idx,
 727                                         nxt_resource->nxt_resource_idx);
 728
 729                 /* update the contents to be given to caller */
 730                 ulp_flow_db_res_info_to_params(nxt_resource, params);
 731
 732                 /* Delete the nxt_resource */
 733                 memset(nxt_resource, 0, sizeof(struct ulp_fdb_resource_info));
 734
 735                 /* add it to the free list */
 736                 flow_tbl->tail_index++;
 737                 if (flow_tbl->tail_index >= flow_tbl->num_resources) {
 738                         BNXT_TF_DBG(ERR, "FlowDB:Tail reached max\n");
 739                         return -ENOENT;
 740                 }
 741                 flow_tbl->flow_tbl_stack[flow_tbl->tail_index] = nxt_idx;
 742
 743         } else {
 744                 /* Critical resource. copy the contents and exit */
 745                 ulp_flow_db_res_info_to_params(fid_resource, params);
 746                 ULP_FLOW_DB_RES_NXT_SET(nxt_idx,
 747                                         fid_resource->nxt_resource_idx);
 748                 memset(fid_resource, 0, sizeof(struct ulp_fdb_resource_info));
 749                 ULP_FLOW_DB_RES_NXT_SET(fid_resource->nxt_resource_idx,
 750                                         nxt_idx);
 751         }
 752
 753         /* Now that the HW Flow counter resource is deleted, reset it's
 754          * corresponding slot in the SW accumulation table in the Flow Counter
 755          * manager
 756          */
 757         if (params->resource_type == TF_TBL_TYPE_ACT_STATS_64 &&
 758             params->resource_sub_type ==
 759             BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT) {
 760                 ulp_fc_mgr_cntr_reset(ulp_ctxt, params->direction,
 761                                       params->resource_hndl);
 762         }
 763
 764         /* all good, return success */
 765         return 0;
 766 }
 767
 768 /*
 769  * Free the flow database entry
 770  *
 771  * ulp_ctxt [in] Ptr to ulp_context
 772  * flow_type [in] - specify default or regular
 773  * fid [in] The index to the flow entry
 774  *
 775  * returns 0 on success and negative on failure.
 776  */
 777 int32_t
 778 ulp_flow_db_fid_free(struct bnxt_ulp_context *ulp_ctxt,
 779                      enum bnxt_ulp_fdb_type flow_type,
 780                      uint32_t fid)
 781 {
 782         struct bnxt_ulp_flow_tbl *flow_tbl;
 783         struct bnxt_ulp_flow_db *flow_db;
 784
 785         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 786         if (!flow_db) {
 787                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 788                 return -EINVAL;
 789         }
 790
 791         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
 792                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
 793                 return -EINVAL;
 794         }
 795
 796         flow_tbl = &flow_db->flow_tbl;
 797
 798         /* check for limits of fid */
 799         if (fid >= flow_tbl->num_flows || !fid) {
 800                 BNXT_TF_DBG(ERR, "Invalid flow index\n");
 801                 return -EINVAL;
 802         }
 803
 804         /* check if the flow is active or not */
 805         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
 806                 BNXT_TF_DBG(ERR, "flow does not exist %x:%x\n", flow_type, fid);
 807                 return -EINVAL;
 808         }
 809         flow_tbl->head_index--;
 810         if (!flow_tbl->head_index) {
 811                 BNXT_TF_DBG(ERR, "FlowDB: Head Ptr is zero\n");
 812                 return -ENOENT;
 813         }
 814
 815         flow_tbl->flow_tbl_stack[flow_tbl->head_index] = fid;
 816
 817         /* Clear the flows bitmap */
 818         ulp_flow_db_active_flows_bit_set(flow_db, flow_type, fid, 0);
 819
 820         if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
 821                 ulp_flow_db_func_id_set(flow_db, fid, 0);
 822
 823         /* all good, return success */
 824         return 0;
 825 }
 826
 827 /*
 828  *Get the flow database entry details
 829  *
 830  * ulp_ctxt [in] Ptr to ulp_context
 831  * flow_type [in] - specify default or regular
 832  * fid [in] The index to the flow entry
 833  * nxt_idx [in/out] the index to the next entry
 834  * params [out] The contents to be copied into params.
 835  *
 836  * returns 0 on success and negative on failure.
 837  */
 838 int32_t
 839 ulp_flow_db_resource_get(struct bnxt_ulp_context *ulp_ctxt,
 840                          enum bnxt_ulp_fdb_type flow_type,
 841                          uint32_t fid,
 842                          uint32_t *nxt_idx,
 843                          struct ulp_flow_db_res_params *params)
 844 {
 845         struct bnxt_ulp_flow_db *flow_db;
 846         struct bnxt_ulp_flow_tbl *flow_tbl;
 847         struct ulp_fdb_resource_info *nxt_resource, *fid_resource;
 848
 849         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 850         if (!flow_db) {
 851                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 852                 return -EINVAL;
 853         }
 854
 855         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
 856                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
 857                 return -EINVAL;
 858         }
 859
 860         flow_tbl = &flow_db->flow_tbl;
 861
 862         /* check for limits of fid */
 863         if (fid >= flow_tbl->num_flows || !fid) {
 864                 BNXT_TF_DBG(ERR, "Invalid flow index\n");
 865                 return -EINVAL;
 866         }
 867
 868         /* check if the flow is active or not */
 869         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
 870                 BNXT_TF_DBG(ERR, "flow does not exist\n");
 871                 return -EINVAL;
 872         }
 873
 874         if (!*nxt_idx) {
 875                 fid_resource = &flow_tbl->flow_resources[fid];
 876                 ulp_flow_db_res_info_to_params(fid_resource, params);
 877                 ULP_FLOW_DB_RES_NXT_SET(*nxt_idx,
 878                                         fid_resource->nxt_resource_idx);
 879         } else {
 880                 nxt_resource = &flow_tbl->flow_resources[*nxt_idx];
 881                 ulp_flow_db_res_info_to_params(nxt_resource, params);
 882                 *nxt_idx = 0;
 883                 ULP_FLOW_DB_RES_NXT_SET(*nxt_idx,
 884                                         nxt_resource->nxt_resource_idx);
 885         }
 886
 887         /* all good, return success */
 888         return 0;
 889 }
 890
 891 /*
 892  * Get the flow database entry iteratively
 893  *
 894  * flow_tbl [in] Ptr to flow table
 895  * flow_type [in] - specify default or regular
 896  * fid [in/out] The index to the flow entry
 897  *
 898  * returns 0 on success and negative on failure.
 899  */
 900 static int32_t
 901 ulp_flow_db_next_entry_get(struct bnxt_ulp_flow_db *flow_db,
 902                            enum bnxt_ulp_fdb_type flow_type,
 903                            uint32_t *fid)
 904 {
 905         uint32_t lfid = *fid;
 906         uint32_t idx, s_idx, mod_fid;
 907         uint64_t bs;
 908         uint64_t *active_flows;
 909         struct bnxt_ulp_flow_tbl *flowtbl = &flow_db->flow_tbl;
 910
 911         if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR) {
 912                 active_flows = flowtbl->active_reg_flows;
 913         } else if (flow_type == BNXT_ULP_FDB_TYPE_DEFAULT) {
 914                 active_flows = flowtbl->active_dflt_flows;
 915         } else {
 916                 BNXT_TF_DBG(ERR, "Invalid flow type %x\n", flow_type);
 917                         return -EINVAL;
 918         }
 919
 920         do {
 921                 /* increment the flow id to find the next valid flow id */
 922                 lfid++;
 923                 if (lfid >= flowtbl->num_flows)
 924                         return -ENOENT;
 925                 idx = lfid / ULP_INDEX_BITMAP_SIZE;
 926                 mod_fid = lfid % ULP_INDEX_BITMAP_SIZE;
 927                 s_idx = idx;
 928                 while (!(bs = active_flows[idx])) {
 929                         idx++;
 930                         if ((idx * ULP_INDEX_BITMAP_SIZE) >= flowtbl->num_flows)
 931                                 return -ENOENT;
 932                 }
 933                 /*
 934                  * remove the previous bits in the bitset bs to find the
 935                  * next non zero bit in the bitset. This needs to be done
 936                  * only if the idx is same as he one you started.
 937                  */
 938                 if (s_idx == idx)
 939                         bs &= (-1UL >> mod_fid);
 940                 lfid = (idx * ULP_INDEX_BITMAP_SIZE) + __builtin_clzl(bs);
 941                 if (*fid >= lfid) {
 942                         BNXT_TF_DBG(ERR, "Flow Database is corrupt\n");
 943                         return -ENOENT;
 944                 }
 945         } while (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type,
 946                                                       lfid));
 947
 948         /* all good, return success */
 949         *fid = lfid;
 950         return 0;
 951 }
 952
 953 /*
 954  * Flush all flows in the flow database.
 955  *
 956  * ulp_ctxt [in] Ptr to ulp context
 957  * flow_type [in] - specify default or regular
 958  *
 959  * returns 0 on success or negative number on failure
 960  */
 961 int32_t
 962 ulp_flow_db_flush_flows(struct bnxt_ulp_context *ulp_ctx,
 963                         enum bnxt_ulp_fdb_type flow_type)
 964 {
 965         uint32_t fid = 0;
 966         struct bnxt_ulp_flow_db *flow_db;
 967
 968         if (!ulp_ctx) {
 969                 BNXT_TF_DBG(ERR, "Invalid Argument\n");
 970                 return -EINVAL;
 971         }
 972
 973         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
 974         if (!flow_db) {
 975                 BNXT_TF_DBG(ERR, "Flow database not found\n");
 976                 return -EINVAL;
 977         }
 978         if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
 979                 BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
 980                 return -EINVAL;
 981         }
 982
 983         while (!ulp_flow_db_next_entry_get(flow_db, flow_type, &fid))
 984                 ulp_mapper_resources_free(ulp_ctx, flow_type, fid);
 985
 986         bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
 987
 988         return 0;
 989 }
 990
 991 /*
 992  * Flush all flows in the flow database that belong to a device function.
 993  *
 994  * ulp_ctxt [in] Ptr to ulp context
 995  * func_id [in] - The port function id
 996  *
 997  * returns 0 on success or negative number on failure
 998  */
 999 int32_t
1000 ulp_flow_db_function_flow_flush(struct bnxt_ulp_context *ulp_ctx,
1001                                 uint16_t func_id)
1002 {
1003         uint32_t flow_id = 0;
1004         struct bnxt_ulp_flow_db *flow_db;
1005
1006         if (!ulp_ctx || !func_id) {
1007                 BNXT_TF_DBG(ERR, "Invalid Argument\n");
1008                 return -EINVAL;
1009         }
1010
1011         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
1012         if (!flow_db) {
1013                 BNXT_TF_DBG(ERR, "Flow database not found\n");
1014                 return -EINVAL;
1015         }
1016         if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
1017                 BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
1018                 return -EINVAL;
1019         }
1020
1021         while (!ulp_flow_db_next_entry_get(flow_db, BNXT_ULP_FDB_TYPE_REGULAR,
1022                                            &flow_id)) {
1023                 if (flow_db->func_id_tbl[flow_id] == func_id)
1024                         ulp_mapper_resources_free(ulp_ctx,
1025                                                   BNXT_ULP_FDB_TYPE_REGULAR,
1026                                                   flow_id);
1027         }
1028         bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
1029         return 0;
1030 }
1031
1032 /*
1033  * Flush all flows in the flow database that are associated with the session.
1034  *
1035  * ulp_ctxt [in] Ptr to ulp context
1036  *
1037  * returns 0 on success or negative number on failure
1038  */
1039 int32_t
1040 ulp_flow_db_session_flow_flush(struct bnxt_ulp_context *ulp_ctx)
1041 {
1042         /*
1043          * TBD: Tf core implementation of FW session flush shall change this
1044          * implementation.
1045          */
1046         return ulp_flow_db_flush_flows(ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR);
1047 }
1048
1049 /*
1050  * Check that flow id matches the function id or not
1051  *
1052  * ulp_ctxt [in] Ptr to ulp context
1053  * flow_db [in] Ptr to flow table
1054  * func_id [in] The func_id to be set, for reset pass zero.
1055  *
1056  * returns true on success or false on failure
1057  */
1058 bool
1059 ulp_flow_db_validate_flow_func(struct bnxt_ulp_context *ulp_ctx,
1060                                uint32_t flow_id,
1061                                uint32_t func_id)
1062 {
1063         struct bnxt_ulp_flow_db *flow_db;
1064
1065         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
1066         if (!flow_db) {
1067                 BNXT_TF_DBG(ERR, "Flow database not found\n");
1068                 return false;
1069         }
1070
1071         /* set the function id in the function table */
1072         if (flow_id < flow_db->func_id_tbl_size && func_id &&
1073             flow_db->func_id_tbl[flow_id] == func_id)
1074                 return true;
1075
1076         return false;
1077 }
1078
1079 /*
1080  * Internal api to traverse the resource list within a flow
1081  * and match a resource based on resource func and resource
1082  * sub type. This api should be used only for resources that
1083  * are unique and do not have multiple instances of resource
1084  * func and sub type combination since it will return only
1085  * the first match.
1086  */
1087 static int32_t
1088 ulp_flow_db_resource_params_get(struct bnxt_ulp_context *ulp_ctx,
1089                                 enum bnxt_ulp_fdb_type flow_type,
1090                                 uint32_t flow_id,
1091                                 uint32_t resource_func,
1092                                 uint32_t res_subtype,
1093                                 struct ulp_flow_db_res_params *params)
1094 {
1095         struct bnxt_ulp_flow_db *flow_db;
1096         struct bnxt_ulp_flow_tbl *flow_tbl;
1097         struct ulp_fdb_resource_info *fid_res;
1098         uint32_t res_id;
1099
1100         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
1101         if (!flow_db) {
1102                 BNXT_TF_DBG(ERR, "Flow database not found\n");
1103                 return -EINVAL;
1104         }
1105
1106         if (!params) {
1107                 BNXT_TF_DBG(ERR, "invalid argument\n");
1108                 return -EINVAL;
1109         }
1110
1111         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
1112                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
1113                 return -EINVAL;
1114         }
1115
1116         flow_tbl = &flow_db->flow_tbl;
1117
1118         /* check for limits of fid */
1119         if (flow_id >= flow_tbl->num_flows || !flow_id) {
1120                 BNXT_TF_DBG(ERR, "Invalid flow index\n");
1121                 return -EINVAL;
1122         }
1123
1124         /* check if the flow is active or not */
1125         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, flow_id)) {
1126                 BNXT_TF_DBG(ERR, "flow does not exist\n");
1127                 return -EINVAL;
1128         }
1129         /* Iterate the resource to get the resource handle */
1130         res_id =  flow_id;
1131         memset(params, 0, sizeof(struct ulp_flow_db_res_params));
1132         while (res_id) {
1133                 fid_res = &flow_tbl->flow_resources[res_id];
1134                 if (ulp_flow_db_resource_func_get(fid_res) == resource_func) {
1135                         if (resource_func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER) {
1136                                 if (res_subtype == fid_res->resource_sub_type) {
1137                                         ulp_flow_db_res_info_to_params(fid_res,
1138                                                                        params);
1139                                         return 0;
1140                                 }
1141
1142                         } else if (resource_func ==
1143                                    BNXT_ULP_RESOURCE_FUNC_EM_TABLE) {
1144                                 ulp_flow_db_res_info_to_params(fid_res,
1145                                                                params);
1146                                 return 0;
1147                         }
1148                 }
1149                 res_id = 0;
1150                 ULP_FLOW_DB_RES_NXT_SET(res_id, fid_res->nxt_resource_idx);
1151         }
1152         return -ENOENT;
1153 }
1154
1155 /*
1156  * Api to get the cfa action pointer from a flow.
1157  *
1158  * ulp_ctxt [in] Ptr to ulp context
1159  * flow_id [in] flow id
1160  * cfa_action [out] The resource handle stored in the flow database
1161  *
1162  * returns 0 on success
1163  */
1164 int32_t
1165 ulp_default_flow_db_cfa_action_get(struct bnxt_ulp_context *ulp_ctx,
1166                                    uint32_t flow_id,
1167                                    uint16_t *cfa_action)
1168 {
1169         uint8_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_VFR_CFA_ACTION;
1170         struct ulp_flow_db_res_params params;
1171         int32_t rc;
1172
1173         rc = ulp_flow_db_resource_params_get(ulp_ctx,
1174                                              BNXT_ULP_FDB_TYPE_DEFAULT,
1175                                              flow_id,
1176                                              BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE,
1177                                              sub_typ, &params);
1178         if (rc) {
1179                 BNXT_TF_DBG(INFO, "CFA Action ptr not found for flow id %u\n",
1180                             flow_id);
1181                 return -ENOENT;
1182         }
1183         *cfa_action = params.resource_hndl;
1184         return 0;
1185 }
1186
1187 /* internal validation function for parent flow tbl */
1188 static struct ulp_fdb_parent_info *
1189 ulp_flow_db_pc_db_entry_get(struct bnxt_ulp_context *ulp_ctxt,
1190                             uint32_t pc_idx)
1191 {
1192         struct bnxt_ulp_flow_db *flow_db;
1193
1194         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1195         if (!flow_db) {
1196                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
1197                 return NULL;
1198         }
1199
1200         /* check for max flows */
1201         if (pc_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
1202                 BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
1203                 return NULL;
1204         }
1205
1206         /* No support for parent child db then just exit */
1207         if (!flow_db->parent_child_db.entries_count) {
1208                 BNXT_TF_DBG(ERR, "parent child db not supported\n");
1209                 return NULL;
1210         }
1211         if (!flow_db->parent_child_db.parent_flow_tbl[pc_idx].valid) {
1212                 BNXT_TF_DBG(ERR, "Not a valid tunnel index\n");
1213                 return NULL;
1214         }
1215
1216         return &flow_db->parent_child_db.parent_flow_tbl[pc_idx];
1217 }
1218
1219 /* internal validation function for parent flow tbl */
1220 static struct bnxt_ulp_flow_db *
1221 ulp_flow_db_parent_arg_validation(struct bnxt_ulp_context *ulp_ctxt,
1222                                   uint32_t tun_idx)
1223 {
1224         struct bnxt_ulp_flow_db *flow_db;
1225
1226         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1227         if (!flow_db) {
1228                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
1229                 return NULL;
1230         }
1231
1232         /* check for max flows */
1233         if (tun_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
1234                 BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
1235                 return NULL;
1236         }
1237
1238         /* No support for parent child db then just exit */
1239         if (!flow_db->parent_child_db.entries_count) {
1240                 BNXT_TF_DBG(ERR, "parent child db not supported\n");
1241                 return NULL;
1242         }
1243
1244         return flow_db;
1245 }
1246
1247 /*
1248  * Allocate the entry in the parent-child database
1249  *
1250  * ulp_ctxt [in] Ptr to ulp_context
1251  * tun_idx [in] The tunnel index of the flow entry
1252  *
1253  * returns index on success and negative on failure.
1254  */
1255 static int32_t
1256 ulp_flow_db_pc_db_idx_alloc(struct bnxt_ulp_context *ulp_ctxt,
1257                             uint32_t tun_idx)
1258 {
1259         struct bnxt_ulp_flow_db *flow_db;
1260         struct ulp_fdb_parent_child_db *p_pdb;
1261         uint32_t idx, free_idx = 0;
1262
1263         /* validate the arguments */
1264         flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, tun_idx);
1265         if (!flow_db) {
1266                 BNXT_TF_DBG(ERR, "parent child db validation failed\n");
1267                 return -EINVAL;
1268         }
1269
1270         p_pdb = &flow_db->parent_child_db;
1271         for (idx = 0; idx < p_pdb->entries_count; idx++) {
1272                 if (p_pdb->parent_flow_tbl[idx].valid &&
1273                     p_pdb->parent_flow_tbl[idx].tun_idx == tun_idx) {
1274                         return idx;
1275                 }
1276                 if (!p_pdb->parent_flow_tbl[idx].valid && !free_idx)
1277                         free_idx = idx + 1;
1278         }
1279         /* no free slots */
1280         if (!free_idx) {
1281                 BNXT_TF_DBG(ERR, "parent child db is full\n");
1282                 return -ENOMEM;
1283         }
1284
1285         free_idx -= 1;
1286         /* set the Fid in the parent child */
1287         p_pdb->parent_flow_tbl[free_idx].tun_idx = tun_idx;
1288         p_pdb->parent_flow_tbl[free_idx].valid = 1;
1289         return free_idx;
1290 }
1291
1292 /*
1293  * Free the entry in the parent-child database
1294  *
1295  * pc_entry [in] Ptr to parent child db entry
1296  *
1297  * returns none.
1298  */
1299 static void
1300 ulp_flow_db_pc_db_entry_free(struct bnxt_ulp_context *ulp_ctxt,
1301                              struct ulp_fdb_parent_info *pc_entry)
1302 {
1303         struct bnxt_tun_cache_entry *tun_tbl;
1304         struct bnxt_ulp_flow_db *flow_db;
1305         uint64_t *tmp_bitset;
1306
1307         /* free the tunnel entry */
1308         tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
1309         if (tun_tbl)
1310                 ulp_tunnel_offload_entry_clear(tun_tbl, pc_entry->tun_idx);
1311
1312         /* free the child bitset*/
1313         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1314         if (flow_db)
1315                 memset(pc_entry->child_fid_bitset, 0,
1316                        flow_db->parent_child_db.child_bitset_size);
1317
1318         /* free the contents */
1319         tmp_bitset = pc_entry->child_fid_bitset;
1320         memset(pc_entry, 0, sizeof(struct ulp_fdb_parent_info));
1321         pc_entry->child_fid_bitset = tmp_bitset;
1322 }
1323
1324 /*
1325  * Set or reset the parent flow in the parent-child database
1326  *
1327  * ulp_ctxt [in] Ptr to ulp_context
1328  * pc_idx [in] The index to parent child db
1329  * parent_fid [in] The flow id of the parent flow entry
1330  * set_flag [in] Use 1 for setting child, 0 to reset
1331  *
1332  * returns zero on success and negative on failure.
1333  */
1334 int32_t
1335 ulp_flow_db_pc_db_parent_flow_set(struct bnxt_ulp_context *ulp_ctxt,
1336                                   uint32_t pc_idx,
1337                                   uint32_t parent_fid,
1338                                   uint32_t set_flag)
1339 {
1340         struct ulp_fdb_parent_info *pc_entry;
1341         struct bnxt_ulp_flow_db *flow_db;
1342
1343         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1344         if (!flow_db) {
1345                 BNXT_TF_DBG(ERR, "parent child db validation failed\n");
1346                 return -EINVAL;
1347         }
1348
1349         /* check for fid validity */
1350         if (parent_fid >= flow_db->flow_tbl.num_flows || !parent_fid) {
1351                 BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_fid);
1352                 return -EINVAL;
1353         }
1354
1355         /* validate the arguments and parent child entry */
1356         pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
1357         if (!pc_entry) {
1358                 BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
1359                 return -EINVAL;
1360         }
1361
1362         if (set_flag) {
1363                 pc_entry->parent_fid = parent_fid;
1364         } else {
1365                 if (pc_entry->parent_fid != parent_fid)
1366                         BNXT_TF_DBG(ERR, "Panic: invalid parent id\n");
1367                 pc_entry->parent_fid = 0;
1368
1369                 /* Free the parent child db entry if no user present */
1370                 if (!pc_entry->f2_cnt)
1371                         ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
1372         }
1373         return 0;
1374 }
1375
1376 /*
1377  * Set or reset the child flow in the parent-child database
1378  *
1379  * ulp_ctxt [in] Ptr to ulp_context
1380  * pc_idx [in] The index to parent child db
1381  * child_fid [in] The flow id of the child flow entry
1382  * set_flag [in] Use 1 for setting child, 0 to reset
1383  *
1384  * returns zero on success and negative on failure.
1385  */
1386 int32_t
1387 ulp_flow_db_pc_db_child_flow_set(struct bnxt_ulp_context *ulp_ctxt,
1388                                  uint32_t pc_idx,
1389                                  uint32_t child_fid,
1390                                  uint32_t set_flag)
1391 {
1392         struct ulp_fdb_parent_info *pc_entry;
1393         struct bnxt_ulp_flow_db *flow_db;
1394         uint32_t a_idx;
1395         uint64_t *t;
1396
1397         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1398         if (!flow_db) {
1399                 BNXT_TF_DBG(ERR, "parent child db validation failed\n");
1400                 return -EINVAL;
1401         }
1402
1403         /* check for fid validity */
1404         if (child_fid >= flow_db->flow_tbl.num_flows || !child_fid) {
1405                 BNXT_TF_DBG(ERR, "Invalid child flow index %x\n", child_fid);
1406                 return -EINVAL;
1407         }
1408
1409         /* validate the arguments and parent child entry */
1410         pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
1411         if (!pc_entry) {
1412                 BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
1413                 return -EINVAL;
1414         }
1415
1416         a_idx = child_fid / ULP_INDEX_BITMAP_SIZE;
1417         t = pc_entry->child_fid_bitset;
1418         if (set_flag) {
1419                 ULP_INDEX_BITMAP_SET(t[a_idx], child_fid);
1420                 pc_entry->f2_cnt++;
1421         } else {
1422                 ULP_INDEX_BITMAP_RESET(t[a_idx], child_fid);
1423                 if (pc_entry->f2_cnt)
1424                         pc_entry->f2_cnt--;
1425                 if (!pc_entry->f2_cnt && !pc_entry->parent_fid)
1426                         ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
1427         }
1428         return 0;
1429 }
1430
1431 /*
1432  * Get the next child flow in the parent-child database
1433  *
1434  * ulp_ctxt [in] Ptr to ulp_context
1435  * parent_fid [in] The flow id of the parent flow entry
1436  * child_fid [in/out] The flow id of the child flow entry
1437  *
1438  * returns zero on success and negative on failure.
1439  * Pass child_fid as zero for first entry.
1440  */
1441 int32_t
1442 ulp_flow_db_parent_child_flow_next_entry_get(struct bnxt_ulp_flow_db *flow_db,
1443                                              uint32_t parent_idx,
1444                                              uint32_t *child_fid)
1445 {
1446         struct ulp_fdb_parent_child_db *p_pdb;
1447         uint32_t idx, s_idx, mod_fid;
1448         uint32_t next_fid = *child_fid;
1449         uint64_t *child_bitset;
1450         uint64_t bs;
1451
1452         /* check for fid validity */
1453         p_pdb = &flow_db->parent_child_db;
1454         if (parent_idx >= p_pdb->entries_count ||
1455             !p_pdb->parent_flow_tbl[parent_idx].parent_fid) {
1456                 BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_idx);
1457                 return -EINVAL;
1458         }
1459
1460         child_bitset = p_pdb->parent_flow_tbl[parent_idx].child_fid_bitset;
1461         do {
1462                 /* increment the flow id to find the next valid flow id */
1463                 next_fid++;
1464                 if (next_fid >= flow_db->flow_tbl.num_flows)
1465                         return -ENOENT;
1466                 idx = next_fid / ULP_INDEX_BITMAP_SIZE;
1467                 mod_fid = next_fid % ULP_INDEX_BITMAP_SIZE;
1468                 s_idx = idx;
1469                 while (!(bs = child_bitset[idx])) {
1470                         idx++;
1471                         if ((idx * ULP_INDEX_BITMAP_SIZE) >=
1472                             flow_db->flow_tbl.num_flows)
1473                                 return -ENOENT;
1474                 }
1475                 /*
1476                  * remove the previous bits in the bitset bs to find the
1477                  * next non zero bit in the bitset. This needs to be done
1478                  * only if the idx is same as he one you started.
1479                  */
1480                 if (s_idx == idx)
1481                         bs &= (-1UL >> mod_fid);
1482                 next_fid = (idx * ULP_INDEX_BITMAP_SIZE) + __builtin_clzl(bs);
1483                 if (*child_fid >= next_fid) {
1484                         BNXT_TF_DBG(ERR, "Parent Child Database is corrupt\n");
1485                         return -ENOENT;
1486                 }
1487                 idx = next_fid / ULP_INDEX_BITMAP_SIZE;
1488         } while (!ULP_INDEX_BITMAP_GET(child_bitset[idx], next_fid));
1489         *child_fid = next_fid;
1490         return 0;
1491 }
1492
1493 /*
1494  * Set the counter accumulation in the parent flow
1495  *
1496  * ulp_ctxt [in] Ptr to ulp_context
1497  * pc_idx [in] The parent child index of the parent flow entry
1498  *
1499  * returns index on success and negative on failure.
1500  */
1501 static int32_t
1502 ulp_flow_db_parent_flow_count_accum_set(struct bnxt_ulp_context *ulp_ctxt,
1503                                         uint32_t pc_idx)
1504 {
1505         struct bnxt_ulp_flow_db *flow_db;
1506         struct ulp_fdb_parent_child_db *p_pdb;
1507
1508         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1509         if (!flow_db) {
1510                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
1511                 return -EINVAL;
1512         }
1513
1514         /* check for parent idx validity */
1515         p_pdb = &flow_db->parent_child_db;
1516         if (pc_idx >= p_pdb->entries_count ||
1517             !p_pdb->parent_flow_tbl[pc_idx].parent_fid) {
1518                 BNXT_TF_DBG(ERR, "Invalid parent child index %x\n", pc_idx);
1519                 return -EINVAL;
1520         }
1521
1522         p_pdb->parent_flow_tbl[pc_idx].counter_acc = 1;
1523         return 0;
1524 }
1525
1526 /*
1527  * Orphan the child flow entry
1528  * This is called only for child flows that have
1529  * BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW resource
1530  *
1531  * ulp_ctxt [in] Ptr to ulp_context
1532  * flow_type [in] Specify it is regular or default flow
1533  * fid [in] The index to the flow entry
1534  *
1535  * Returns 0 on success and negative on failure.
1536  */
1537 int32_t
1538 ulp_flow_db_child_flow_reset(struct bnxt_ulp_context *ulp_ctxt,
1539                              enum bnxt_ulp_fdb_type flow_type,
1540                              uint32_t fid)
1541 {
1542         struct bnxt_ulp_flow_db *flow_db;
1543         struct bnxt_ulp_flow_tbl *flow_tbl;
1544         struct ulp_fdb_resource_info *fid_res;
1545         uint32_t res_id = 0;
1546
1547         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1548         if (!flow_db) {
1549                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
1550                 return -EINVAL;
1551         }
1552
1553         if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
1554                 BNXT_TF_DBG(ERR, "Invalid flow type\n");
1555                 return -EINVAL;
1556         }
1557
1558         flow_tbl = &flow_db->flow_tbl;
1559         /* check for max flows */
1560         if (fid >= flow_tbl->num_flows || !fid) {
1561                 BNXT_TF_DBG(ERR, "Invalid flow index %x\n", fid);
1562                 return -EINVAL;
1563         }
1564
1565         /* check if the flow is active or not */
1566         if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
1567                 BNXT_TF_DBG(ERR, "flow does not exist\n");
1568                 return -EINVAL;
1569         }
1570
1571         /* Iterate the resource to get the resource handle */
1572         res_id =  fid;
1573         while (res_id) {
1574                 fid_res = &flow_tbl->flow_resources[res_id];
1575                 if (ulp_flow_db_resource_func_get(fid_res) ==
1576                     BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW) {
1577                         /* invalidate the resource details */
1578                         fid_res->resource_hndl = 0;
1579                         return 0;
1580                 }
1581                 res_id = 0;
1582                 ULP_FLOW_DB_RES_NXT_SET(res_id, fid_res->nxt_resource_idx);
1583         }
1584         /* failed */
1585         return -1;
1586 }
1587
1588 /*
1589  * Create parent flow in the parent flow tbl
1590  *
1591  * parms [in] Ptr to mapper params
1592  *
1593  * Returns 0 on success and negative on failure.
1594  */
1595 int32_t
1596 ulp_flow_db_parent_flow_create(struct bnxt_ulp_mapper_parms *parms)
1597 {
1598         struct ulp_flow_db_res_params fid_parms;
1599         uint32_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
1600         struct ulp_flow_db_res_params res_params;
1601         int32_t pc_idx;
1602
1603         /* create or get the parent child database */
1604         pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
1605         if (pc_idx < 0) {
1606                 BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
1607                             parms->tun_idx);
1608                 return -EINVAL;
1609         }
1610
1611         /* Update the parent fid */
1612         if (ulp_flow_db_pc_db_parent_flow_set(parms->ulp_ctx, pc_idx,
1613                                               parms->fid, 1)) {
1614                 BNXT_TF_DBG(ERR, "Error in setting parent fid %x\n",
1615                             parms->tun_idx);
1616                 return -EINVAL;
1617         }
1618
1619         /* Add the parent details in the resource list of the flow */
1620         memset(&fid_parms, 0, sizeof(fid_parms));
1621         fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW;
1622         fid_parms.resource_hndl = pc_idx;
1623         fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
1624         if (ulp_flow_db_resource_add(parms->ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR,
1625                                      parms->fid, &fid_parms)) {
1626                 BNXT_TF_DBG(ERR, "Error in adding flow res for fid %x\n",
1627                             parms->fid);
1628                 return -1;
1629         }
1630
1631         /* check of the flow has internal counter accumulation enabled */
1632         if (!ulp_flow_db_resource_params_get(parms->ulp_ctx,
1633                                              BNXT_ULP_FDB_TYPE_REGULAR,
1634                                              parms->fid,
1635                                              BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE,
1636                                              sub_typ,
1637                                              &res_params)) {
1638                 /* Enable the counter accumulation in parent entry */
1639                 if (ulp_flow_db_parent_flow_count_accum_set(parms->ulp_ctx,
1640                                                             pc_idx)) {
1641                         BNXT_TF_DBG(ERR, "Error in setting counter acc %x\n",
1642                                     parms->fid);
1643                         return -1;
1644                 }
1645         }
1646
1647         return 0;
1648 }
1649
1650 /*
1651  * Create child flow in the parent flow tbl
1652  *
1653  * parms [in] Ptr to mapper params
1654  *
1655  * Returns 0 on success and negative on failure.
1656  */
1657 int32_t
1658 ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
1659 {
1660         struct ulp_flow_db_res_params fid_parms;
1661         uint32_t sub_type = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
1662         enum bnxt_ulp_resource_func res_fun;
1663         struct ulp_flow_db_res_params res_p;
1664         int32_t rc, pc_idx;
1665
1666         /* create or get the parent child database */
1667         pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
1668         if (pc_idx < 0) {
1669                 BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
1670                             parms->tun_idx);
1671                 return -1;
1672         }
1673
1674         /* create the parent flow entry in parent flow table */
1675         rc = ulp_flow_db_pc_db_child_flow_set(parms->ulp_ctx, pc_idx,
1676                                               parms->fid, 1);
1677         if (rc) {
1678                 BNXT_TF_DBG(ERR, "Error in setting child fid %x\n", parms->fid);
1679                 return rc;
1680         }
1681
1682         /* Add the parent details in the resource list of the flow */
1683         memset(&fid_parms, 0, sizeof(fid_parms));
1684         fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW;
1685         fid_parms.resource_hndl = pc_idx;
1686         fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
1687         rc  = ulp_flow_db_resource_add(parms->ulp_ctx,
1688                                        BNXT_ULP_FDB_TYPE_REGULAR,
1689                                        parms->fid, &fid_parms);
1690         if (rc) {
1691                 BNXT_TF_DBG(ERR, "Error in adding flow res for fid %x\n",
1692                             parms->fid);
1693                 return rc;
1694         }
1695
1696         /* check if internal count action included for this flow.*/
1697         res_fun = BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE;
1698         rc = ulp_flow_db_resource_params_get(parms->ulp_ctx,
1699                                              BNXT_ULP_FDB_TYPE_REGULAR,
1700                                              parms->fid,
1701                                              res_fun,
1702                                              sub_type,
1703                                              &res_p);
1704         if (!rc) {
1705                 /* update the counter manager to include parent fid */
1706                 if (ulp_fc_mgr_cntr_parent_flow_set(parms->ulp_ctx,
1707                                                     res_p.direction,
1708                                                     res_p.resource_hndl,
1709                                                     pc_idx)) {
1710                         BNXT_TF_DBG(ERR, "Error in setting child %x\n",
1711                                     parms->fid);
1712                         return -1;
1713                 }
1714         }
1715
1716         /* return success */
1717         return 0;
1718 }
1719
1720 /*
1721  * Update the parent counters
1722  *
1723  * ulp_ctxt [in] Ptr to ulp_context
1724  * pc_idx [in] The parent flow entry idx
1725  * packet_count [in] - packet count
1726  * byte_count [in] - byte count
1727  *
1728  * returns 0 on success
1729  */
1730 int32_t
1731 ulp_flow_db_parent_flow_count_update(struct bnxt_ulp_context *ulp_ctxt,
1732                                      uint32_t pc_idx,
1733                                      uint64_t packet_count,
1734                                      uint64_t byte_count)
1735 {
1736         struct ulp_fdb_parent_info *pc_entry;
1737
1738         /* validate the arguments and get parent child entry */
1739         pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
1740         if (!pc_entry) {
1741                 BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
1742                 return -EINVAL;
1743         }
1744
1745         if (pc_entry->counter_acc) {
1746                 pc_entry->pkt_count += packet_count;
1747                 pc_entry->byte_count += byte_count;
1748         }
1749         return 0;
1750 }
1751
1752 /*
1753  * Get the parent accumulation counters
1754  *
1755  * ulp_ctxt [in] Ptr to ulp_context
1756  * pc_idx [in] The parent flow entry idx
1757  * packet_count [out] - packet count
1758  * byte_count [out] - byte count
1759  *
1760  * returns 0 on success
1761  */
1762 int32_t
1763 ulp_flow_db_parent_flow_count_get(struct bnxt_ulp_context *ulp_ctxt,
1764                                   uint32_t pc_idx, uint64_t *packet_count,
1765                                   uint64_t *byte_count, uint8_t count_reset)
1766 {
1767         struct ulp_fdb_parent_info *pc_entry;
1768
1769         /* validate the arguments and get parent child entry */
1770         pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
1771         if (!pc_entry) {
1772                 BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
1773                 return -EINVAL;
1774         }
1775
1776         if (pc_entry->counter_acc) {
1777                 *packet_count = pc_entry->pkt_count;
1778                 *byte_count = pc_entry->byte_count;
1779                 if (count_reset) {
1780                         pc_entry->pkt_count = 0;
1781                         pc_entry->byte_count = 0;
1782                 }
1783         }
1784         return 0;
1785 }
1786
1787 /*
1788  * reset the parent accumulation counters
1789  *
1790  * ulp_ctxt [in] Ptr to ulp_context
1791  *
1792  * returns none
1793  */
1794 void
1795 ulp_flow_db_parent_flow_count_reset(struct bnxt_ulp_context *ulp_ctxt)
1796 {
1797         struct bnxt_ulp_flow_db *flow_db;
1798         struct ulp_fdb_parent_child_db *p_pdb;
1799         uint32_t idx;
1800
1801         /* validate the arguments */
1802         flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
1803         if (!flow_db) {
1804                 BNXT_TF_DBG(ERR, "parent child db validation failed\n");
1805                 return;
1806         }
1807
1808         p_pdb = &flow_db->parent_child_db;
1809         for (idx = 0; idx < p_pdb->entries_count; idx++) {
1810                 if (p_pdb->parent_flow_tbl[idx].valid &&
1811                     p_pdb->parent_flow_tbl[idx].counter_acc) {
1812                         p_pdb->parent_flow_tbl[idx].pkt_count = 0;
1813                         p_pdb->parent_flow_tbl[idx].byte_count = 0;
1814                 }
1815         }
1816 }
1817
1818 /*
1819  * Set the shared bit for the flow db entry
1820  *
1821  * res [in] Ptr to fdb entry
1822  * shared [in] shared flag
1823  *
1824  * returns none
1825  */
1826 void ulp_flow_db_shared_session_set(struct ulp_flow_db_res_params *res,
1827                                     enum bnxt_ulp_shared_session shared)
1828 {
1829         if (res && (shared & BNXT_ULP_SHARED_SESSION_YES))
1830                 res->fdb_flags |= ULP_FDB_FLAG_SHARED_SESSION;
1831 }