net/bnxt: aggregate ULP mapper create arguments
[dpdk.git] / drivers / net / bnxt / tf_ulp / bnxt_ulp_flow.c
index 35099a3..9326401 100644 (file)
@@ -67,19 +67,15 @@ bnxt_ulp_flow_create(struct rte_eth_dev                     *dev,
                     const struct rte_flow_action       actions[],
                     struct rte_flow_error              *error)
 {
-       struct ulp_rte_hdr_bitmap hdr_bitmap;
-       struct ulp_rte_hdr_field hdr_field[BNXT_ULP_PROTO_HDR_MAX];
-       struct ulp_rte_act_bitmap act_bitmap;
-       struct ulp_rte_act_prop act_prop;
-       enum ulp_direction_type dir = ULP_DIR_INGRESS;
-       uint32_t class_id, act_tmpl;
-       uint32_t app_priority;
-       int ret;
+       struct bnxt_ulp_mapper_create_parms mapper_cparms = { 0 };
+       struct ulp_rte_parser_params params;
        struct bnxt_ulp_context *ulp_ctx = NULL;
-       uint32_t vnic;
-       uint8_t svif;
+       uint32_t class_id, act_tmpl;
        struct rte_flow *flow_id;
        uint32_t fid;
+       uint8_t *buffer;
+       uint32_t vnic;
+       int ret;
 
        if (bnxt_ulp_flow_validate_args(attr,
                                        pattern, actions,
@@ -94,67 +90,52 @@ bnxt_ulp_flow_create(struct rte_eth_dev                     *dev,
                return NULL;
        }
 
-       /* clear the header bitmap and field structure */
-       memset(&hdr_bitmap, 0, sizeof(struct ulp_rte_hdr_bitmap));
-       memset(hdr_field, 0, sizeof(hdr_field));
-       memset(&act_bitmap, 0, sizeof(act_bitmap));
-       memset(&act_prop, 0, sizeof(act_prop));
-
-       svif = bnxt_get_svif(dev->data->port_id, false);
-       BNXT_TF_DBG(ERR, "SVIF for port[%d][port]=0x%08x\n",
-                   dev->data->port_id, svif);
-
-       hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].size = sizeof(svif);
-       hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec[0] = svif;
-       hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].mask[0] = -1;
-       ULP_BITMAP_SET(hdr_bitmap.bits, BNXT_ULP_HDR_BIT_SVIF);
-
-       /*
-        * VNIC is being pushed as 32bit and the pop will take care of
-        * proper size
-        */
+       /* Initialize the parser params */
+       memset(&params, 0, sizeof(struct ulp_rte_parser_params));
+
+       if (attr->egress)
+               params.dir = ULP_DIR_EGRESS;
+
+       /* copy the device port id and direction for further processing */
+       buffer = params.hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec;
+       rte_memcpy(buffer, &dev->data->port_id, sizeof(uint16_t));
+
+       /* Set the implicit vnic in the action property */
        vnic = (uint32_t)bnxt_get_vnic_id(dev->data->port_id);
        vnic = htonl(vnic);
-       rte_memcpy(&act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
+       rte_memcpy(&params.act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
                   &vnic, BNXT_ULP_ACT_PROP_SZ_VNIC);
 
        /* Parse the rte flow pattern */
-       ret = bnxt_ulp_rte_parser_hdr_parse(pattern,
-                                           &hdr_bitmap,
-                                           hdr_field);
+       ret = bnxt_ulp_rte_parser_hdr_parse(pattern, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
        /* Parse the rte flow action */
-       ret = bnxt_ulp_rte_parser_act_parse(actions,
-                                           &act_bitmap,
-                                           &act_prop);
+       ret = bnxt_ulp_rte_parser_act_parse(actions, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
-       if (attr->egress)
-               dir = ULP_DIR_EGRESS;
-
-       ret = ulp_matcher_pattern_match(dir, &hdr_bitmap, hdr_field,
-                                       &act_bitmap, &class_id);
+       ret = ulp_matcher_pattern_match(&params, &class_id);
 
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
-       ret = ulp_matcher_action_match(dir, &act_bitmap, &act_tmpl);
+       ret = ulp_matcher_action_match(&params, &act_tmpl);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
-       app_priority = attr->priority;
+       mapper_cparms.app_priority = attr->priority;
+       mapper_cparms.hdr_bitmap = &params.hdr_bitmap;
+       mapper_cparms.hdr_field = params.hdr_field;
+       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;
+
        /* call the ulp mapper to create the flow in the hardware */
        ret = ulp_mapper_flow_create(ulp_ctx,
-                                    app_priority,
-                                    &hdr_bitmap,
-                                    hdr_field,
-                                    &act_bitmap,
-                                    &act_prop,
-                                    class_id,
-                                    act_tmpl,
+                                    &mapper_cparms,
                                     &fid);
        if (!ret) {
                flow_id = (struct rte_flow *)((uintptr_t)fid);
@@ -175,11 +156,7 @@ bnxt_ulp_flow_validate(struct rte_eth_dev *dev __rte_unused,
                       const struct rte_flow_action actions[],
                       struct rte_flow_error *error)
 {
-       struct ulp_rte_hdr_bitmap hdr_bitmap;
-       struct ulp_rte_hdr_field hdr_field[BNXT_ULP_PROTO_HDR_MAX];
-       struct ulp_rte_act_bitmap act_bitmap;
-       struct ulp_rte_act_prop act_prop;
-       enum ulp_direction_type dir = ULP_DIR_INGRESS;
+       struct ulp_rte_parser_params            params;
        uint32_t class_id, act_tmpl;
        int ret;
 
@@ -190,36 +167,28 @@ bnxt_ulp_flow_validate(struct rte_eth_dev *dev __rte_unused,
                return -EINVAL;
        }
 
-       /* clear the header bitmap and field structure */
-       memset(&hdr_bitmap, 0, sizeof(struct ulp_rte_hdr_bitmap));
-       memset(hdr_field, 0, sizeof(hdr_field));
-       memset(&act_bitmap, 0, sizeof(act_bitmap));
-       memset(&act_prop, 0, sizeof(act_prop));
+       /* Initialize the parser params */
+       memset(&params, 0, sizeof(struct ulp_rte_parser_params));
+
+       if (attr->egress)
+               params.dir = ULP_DIR_EGRESS;
 
        /* Parse the rte flow pattern */
-       ret = bnxt_ulp_rte_parser_hdr_parse(pattern,
-                                           &hdr_bitmap,
-                                           hdr_field);
+       ret = bnxt_ulp_rte_parser_hdr_parse(pattern, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
        /* Parse the rte flow action */
-       ret = bnxt_ulp_rte_parser_act_parse(actions,
-                                           &act_bitmap,
-                                           &act_prop);
+       ret = bnxt_ulp_rte_parser_act_parse(actions, &params);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
-       if (attr->egress)
-               dir = ULP_DIR_EGRESS;
-
-       ret = ulp_matcher_pattern_match(dir, &hdr_bitmap, hdr_field,
-                                       &act_bitmap, &class_id);
+       ret = ulp_matcher_pattern_match(&params, &class_id);
 
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
-       ret = ulp_matcher_action_match(dir, &act_bitmap, &act_tmpl);
+       ret = ulp_matcher_action_match(&params, &act_tmpl);
        if (ret != BNXT_TF_RC_SUCCESS)
                goto parse_error;
 
@@ -262,11 +231,42 @@ bnxt_ulp_flow_destroy(struct rte_eth_dev *dev,
        return ret;
 }
 
+/* Function to destroy the rte flows. */
+static int32_t
+bnxt_ulp_flow_flush(struct rte_eth_dev *eth_dev,
+                   struct rte_flow_error *error)
+{
+       struct bnxt_ulp_context *ulp_ctx;
+       int32_t ret;
+       struct bnxt *bp;
+
+       ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(eth_dev);
+       if (!ulp_ctx) {
+               BNXT_TF_DBG(ERR, "ULP context is not initialized\n");
+               rte_flow_error_set(error, EINVAL,
+                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+                                  "Failed to flush flow.");
+               return -EINVAL;
+       }
+       bp = eth_dev->data->dev_private;
+
+       /* Free the resources for the last device */
+       if (!ulp_ctx_deinit_allowed(bp))
+               return 0;
+
+       ret = ulp_flow_db_flush_flows(ulp_ctx, BNXT_ULP_REGULAR_FLOW_TABLE);
+       if (ret)
+               rte_flow_error_set(error, ret,
+                                  RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
+                                  "Failed to flush flow.");
+       return ret;
+}
+
 const struct rte_flow_ops bnxt_ulp_rte_flow_ops = {
        .validate = bnxt_ulp_flow_validate,
        .create = bnxt_ulp_flow_create,
        .destroy = bnxt_ulp_flow_destroy,
-       .flush = NULL,
+       .flush = bnxt_ulp_flow_flush,
        .query = NULL,
        .isolate = NULL
 };