net/hns3: increase VF reset retry maximum
[dpdk.git] / drivers / net / bnxt / tf_ulp / bnxt_ulp_flow.c
index c7b2982..777a6ba 100644 (file)
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2014-2020 Broadcom
+ * Copyright(c) 2014-2021 Broadcom
  * All rights reserved.
  */
 
@@ -74,6 +74,27 @@ bnxt_ulp_set_dir_attributes(struct ulp_rte_parser_params *params,
                params->dir_attr |= BNXT_ULP_FLOW_ATTR_TRANSFER;
 }
 
+void
+bnxt_ulp_init_mapper_params(struct bnxt_ulp_mapper_create_parms *mapper_cparms,
+                           struct ulp_rte_parser_params *params,
+                           enum bnxt_ulp_fdb_type flow_type)
+{
+       mapper_cparms->flow_type        = flow_type;
+       mapper_cparms->app_priority     = params->priority;
+       mapper_cparms->dir_attr         = params->dir_attr;
+       mapper_cparms->class_tid        = params->class_id;
+       mapper_cparms->act_tid          = params->act_tmpl;
+       mapper_cparms->func_id          = params->func_id;
+       mapper_cparms->hdr_bitmap       = &params->hdr_bitmap;
+       mapper_cparms->hdr_field        = params->hdr_field;
+       mapper_cparms->comp_fld         = params->comp_fld;
+       mapper_cparms->act              = &params->act_bitmap;
+       mapper_cparms->act_prop         = &params->act_prop;
+       mapper_cparms->flow_id          = params->fid;
+       mapper_cparms->parent_flow      = params->parent_flow;
+       mapper_cparms->parent_fid       = params->parent_fid;
+}
+
 /* Function to create the rte flow. */
 static struct rte_flow *
 bnxt_ulp_flow_create(struct rte_eth_dev *dev,
@@ -85,22 +106,22 @@ bnxt_ulp_flow_create(struct rte_eth_dev *dev,
        struct bnxt_ulp_mapper_create_parms mapper_cparms = { 0 };
        struct ulp_rte_parser_params params;
        struct bnxt_ulp_context *ulp_ctx;
-       uint32_t class_id, act_tmpl;
+       int rc, ret = BNXT_TF_RC_ERROR;
        struct rte_flow *flow_id;
+       uint16_t func_id;
        uint32_t fid;
-       int ret = BNXT_TF_RC_ERROR;
 
        if (bnxt_ulp_flow_validate_args(attr,
                                        pattern, actions,
                                        error) == BNXT_TF_RC_ERROR) {
                BNXT_TF_DBG(ERR, "Invalid arguments being passed\n");
-               goto parse_error;
+               goto flow_error;
        }
 
        ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(dev);
        if (!ulp_ctx) {
                BNXT_TF_DBG(ERR, "ULP context is not initialized\n");
-               goto parse_error;
+               goto flow_error;
        }
 
        /* Initialize the parser params */
@@ -116,56 +137,78 @@ bnxt_ulp_flow_create(struct rte_eth_dev *dev,
        ULP_COMP_FLD_IDX_WR(&params, BNXT_ULP_CF_IDX_SVIF_FLAG,
                            BNXT_ULP_INVALID_SVIF_VAL);
 
+       /* Get the function id */
+       if (ulp_port_db_port_func_id_get(ulp_ctx,
+                                        dev->data->port_id,
+                                        &func_id)) {
+               BNXT_TF_DBG(ERR, "conversion of port to func id failed\n");
+               goto flow_error;
+       }
+
+       /* Protect flow creation */
+       if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
+               BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
+               goto flow_error;
+       }
+
+       /* Allocate a Flow ID for attaching all resources for the flow to.
+        * Once allocated, all errors have to walk the list of resources and
+        * free each of them.
+        */
+       rc = ulp_flow_db_fid_alloc(ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR,
+                                  func_id, &fid);
+       if (rc) {
+               BNXT_TF_DBG(ERR, "Unable to allocate flow table entry\n");
+               goto release_lock;
+       }
+
        /* Parse the rte flow pattern */
        ret = bnxt_ulp_rte_parser_hdr_parse(pattern, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
-               goto parse_error;
+               goto free_fid;
 
        /* Parse the rte flow action */
        ret = bnxt_ulp_rte_parser_act_parse(actions, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
-               goto parse_error;
+               goto free_fid;
 
+       params.fid = fid;
+       params.func_id = func_id;
+       params.priority = attr->priority;
+       params.port_id = bnxt_get_phy_port_id(dev->data->port_id);
        /* Perform the rte flow post process */
        ret = bnxt_ulp_rte_parser_post_process(&params);
-       if (ret != BNXT_TF_RC_SUCCESS)
-               goto parse_error;
+       if (ret == BNXT_TF_RC_ERROR)
+               goto free_fid;
+       else if (ret == BNXT_TF_RC_FID)
+               goto return_fid;
 
-       ret = ulp_matcher_pattern_match(&params, &class_id);
+       ret = ulp_matcher_pattern_match(&params, &params.class_id);
        if (ret != BNXT_TF_RC_SUCCESS)
-               goto parse_error;
+               goto free_fid;
 
-       ret = ulp_matcher_action_match(&params, &act_tmpl);
+       ret = ulp_matcher_action_match(&params, &params.act_tmpl);
        if (ret != BNXT_TF_RC_SUCCESS)
-               goto parse_error;
+               goto free_fid;
 
-       mapper_cparms.app_priority = attr->priority;
-       mapper_cparms.hdr_bitmap = &params.hdr_bitmap;
-       mapper_cparms.hdr_field = params.hdr_field;
-       mapper_cparms.comp_fld = params.comp_fld;
-       mapper_cparms.act = &params.act_bitmap;
-       mapper_cparms.act_prop = &params.act_prop;
-       mapper_cparms.class_tid = class_id;
-       mapper_cparms.act_tid = act_tmpl;
-       mapper_cparms.flow_type = BNXT_ULP_FDB_TYPE_REGULAR;
+       bnxt_ulp_init_mapper_params(&mapper_cparms, &params,
+                                   BNXT_ULP_FDB_TYPE_REGULAR);
+       /* Call the ulp mapper to create the flow in the hardware. */
+       ret = ulp_mapper_flow_create(ulp_ctx, &mapper_cparms);
+       if (ret)
+               goto free_fid;
 
-       /* Get the function id */
-       if (ulp_port_db_port_func_id_get(ulp_ctx,
-                                        dev->data->port_id,
-                                        &mapper_cparms.func_id)) {
-               BNXT_TF_DBG(ERR, "conversion of port to func id failed\n");
-               goto parse_error;
-       }
-       mapper_cparms.dir_attr = params.dir_attr;
+return_fid:
+       bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
 
-       /* Call the ulp mapper to create the flow in the hardware. */
-       ret = ulp_mapper_flow_create(ulp_ctx, &mapper_cparms, &fid);
-       if (!ret) {
-               flow_id = (struct rte_flow *)((uintptr_t)fid);
-               return flow_id;
-       }
+       flow_id = (struct rte_flow *)((uintptr_t)fid);
+       return flow_id;
 
-parse_error:
+free_fid:
+       ulp_flow_db_fid_free(ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR, fid);
+release_lock:
+       bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
+flow_error:
        rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                           "Failed to create flow.");
        return NULL;
@@ -179,10 +222,10 @@ bnxt_ulp_flow_validate(struct rte_eth_dev *dev,
                       const struct rte_flow_action actions[],
                       struct rte_flow_error *error)
 {
-       struct ulp_rte_parser_params            params;
+       struct ulp_rte_parser_params params;
+       struct bnxt_ulp_context *ulp_ctx;
        uint32_t class_id, act_tmpl;
        int ret = BNXT_TF_RC_ERROR;
-       struct bnxt_ulp_context *ulp_ctx;
 
        if (bnxt_ulp_flow_validate_args(attr,
                                        pattern, actions,
@@ -216,8 +259,10 @@ bnxt_ulp_flow_validate(struct rte_eth_dev *dev,
 
        /* Perform the rte flow post process */
        ret = bnxt_ulp_rte_parser_post_process(&params);
-       if (ret != BNXT_TF_RC_SUCCESS)
+       if (ret == BNXT_TF_RC_ERROR)
                goto parse_error;
+       else if (ret == BNXT_TF_RC_FID)
+               return 0;
 
        ret = ulp_matcher_pattern_match(&params, &class_id);
 
@@ -243,10 +288,10 @@ bnxt_ulp_flow_destroy(struct rte_eth_dev *dev,
                      struct rte_flow *flow,
                      struct rte_flow_error *error)
 {
-       int ret = 0;
        struct bnxt_ulp_context *ulp_ctx;
        uint32_t flow_id;
        uint16_t func_id;
+       int ret;
 
        ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(dev);
        if (!ulp_ctx) {
@@ -281,6 +326,10 @@ bnxt_ulp_flow_destroy(struct rte_eth_dev *dev,
                return -EINVAL;
        }
 
+       if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
+               BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
+               return -EINVAL;
+       }
        ret = ulp_mapper_flow_destroy(ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR,
                                      flow_id);
        if (ret) {
@@ -290,6 +339,7 @@ bnxt_ulp_flow_destroy(struct rte_eth_dev *dev,
                                           RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                                           "Failed to destroy flow.");
        }
+       bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
 
        return ret;
 }