drivers/net/bnxt/tf_ulp/bnxt_ulp_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2020 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include "bnxt.h"
   7 #include "bnxt_tf_common.h"
   8 #include "ulp_rte_parser.h"
   9 #include "ulp_matcher.h"
  10 #include "ulp_flow_db.h"
  11 #include "ulp_mapper.h"
  12 #include <rte_malloc.h>
  13
  14 static int32_t
  15 bnxt_ulp_flow_validate_args(const struct rte_flow_attr *attr,
  16                             const struct rte_flow_item pattern[],
  17                             const struct rte_flow_action actions[],
  18                             struct rte_flow_error *error)
  19 {
  20         /* Perform the validation of the arguments for null */
  21         if (!error)
  22                 return BNXT_TF_RC_ERROR;
  23
  24         if (!pattern) {
  25                 rte_flow_error_set(error,
  26                                    EINVAL,
  27                                    RTE_FLOW_ERROR_TYPE_ITEM_NUM,
  28                                    NULL,
  29                                    "NULL pattern.");
  30                 return BNXT_TF_RC_ERROR;
  31         }
  32
  33         if (!actions) {
  34                 rte_flow_error_set(error,
  35                                    EINVAL,
  36                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
  37                                    NULL,
  38                                    "NULL action.");
  39                 return BNXT_TF_RC_ERROR;
  40         }
  41
  42         if (!attr) {
  43                 rte_flow_error_set(error,
  44                                    EINVAL,
  45                                    RTE_FLOW_ERROR_TYPE_ATTR,
  46                                    NULL,
  47                                    "NULL attribute.");
  48                 return BNXT_TF_RC_ERROR;
  49         }
  50
  51         if (attr->egress && attr->ingress) {
  52                 rte_flow_error_set(error,
  53                                    EINVAL,
  54                                    RTE_FLOW_ERROR_TYPE_ATTR,
  55                                    attr,
  56                                    "EGRESS AND INGRESS UNSUPPORTED");
  57                 return BNXT_TF_RC_ERROR;
  58         }
  59         return BNXT_TF_RC_SUCCESS;
  60 }
  61
  62 /* Function to create the rte flow. */
  63 static struct rte_flow *
  64 bnxt_ulp_flow_create(struct rte_eth_dev                 *dev,
  65                      const struct rte_flow_attr         *attr,
  66                      const struct rte_flow_item         pattern[],
  67                      const struct rte_flow_action       actions[],
  68                      struct rte_flow_error              *error)
  69 {
  70         struct ulp_rte_hdr_bitmap hdr_bitmap;
  71         struct ulp_rte_hdr_field hdr_field[BNXT_ULP_PROTO_HDR_MAX];
  72         struct ulp_rte_act_bitmap act_bitmap;
  73         struct ulp_rte_act_prop act_prop;
  74         enum ulp_direction_type dir = ULP_DIR_INGRESS;
  75         uint32_t class_id, act_tmpl;
  76         uint32_t app_priority;
  77         int ret;
  78         struct bnxt_ulp_context *ulp_ctx = NULL;
  79         uint32_t vnic;
  80         uint8_t svif;
  81         struct rte_flow *flow_id;
  82         uint32_t fid;
  83
  84         if (bnxt_ulp_flow_validate_args(attr,
  85                                         pattern, actions,
  86                                         error) == BNXT_TF_RC_ERROR) {
  87                 BNXT_TF_DBG(ERR, "Invalid arguments being passed\n");
  88                 return NULL;
  89         }
  90
  91         ulp_ctx = bnxt_ulp_eth_dev_ptr2_cntxt_get(dev);
  92         if (!ulp_ctx) {
  93                 BNXT_TF_DBG(ERR, "ULP context is not initialized\n");
  94                 return NULL;
  95         }
  96
  97         /* clear the header bitmap and field structure */
  98         memset(&hdr_bitmap, 0, sizeof(struct ulp_rte_hdr_bitmap));
  99         memset(hdr_field, 0, sizeof(hdr_field));
 100         memset(&act_bitmap, 0, sizeof(act_bitmap));
 101         memset(&act_prop, 0, sizeof(act_prop));
 102
 103         svif = bnxt_get_svif(dev->data->port_id, false);
 104         BNXT_TF_DBG(ERR, "SVIF for port[%d][port]=0x%08x\n",
 105                     dev->data->port_id, svif);
 106
 107         hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].size = sizeof(svif);
 108         hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].spec[0] = svif;
 109         hdr_field[BNXT_ULP_HDR_FIELD_SVIF_INDEX].mask[0] = -1;
 110         ULP_BITMAP_SET(hdr_bitmap.bits, BNXT_ULP_HDR_BIT_SVIF);
 111
 112         /*
 113          * VNIC is being pushed as 32bit and the pop will take care of
 114          * proper size
 115          */
 116         vnic = (uint32_t)bnxt_get_vnic_id(dev->data->port_id);
 117         vnic = htonl(vnic);
 118         rte_memcpy(&act_prop.act_details[BNXT_ULP_ACT_PROP_IDX_VNIC],
 119                    &vnic, BNXT_ULP_ACT_PROP_SZ_VNIC);
 120
 121         /* Parse the rte flow pattern */
 122         ret = bnxt_ulp_rte_parser_hdr_parse(pattern,
 123                                             &hdr_bitmap,
 124                                             hdr_field);
 125         if (ret != BNXT_TF_RC_SUCCESS)
 126                 goto parse_error;
 127
 128         /* Parse the rte flow action */
 129         ret = bnxt_ulp_rte_parser_act_parse(actions,
 130                                             &act_bitmap,
 131                                             &act_prop);
 132         if (ret != BNXT_TF_RC_SUCCESS)
 133                 goto parse_error;
 134
 135         if (attr->egress)
 136                 dir = ULP_DIR_EGRESS;
 137
 138         ret = ulp_matcher_pattern_match(dir, &hdr_bitmap, hdr_field,
 139                                         &act_bitmap, &class_id);
 140
 141         if (ret != BNXT_TF_RC_SUCCESS)
 142                 goto parse_error;
 143
 144         ret = ulp_matcher_action_match(dir, &act_bitmap, &act_tmpl);
 145         if (ret != BNXT_TF_RC_SUCCESS)
 146                 goto parse_error;
 147
 148         app_priority = attr->priority;
 149         /* call the ulp mapper to create the flow in the hardware */
 150         ret = ulp_mapper_flow_create(ulp_ctx,
 151                                      app_priority,
 152                                      &hdr_bitmap,
 153                                      hdr_field,
 154                                      &act_bitmap,
 155                                      &act_prop,
 156                                      class_id,
 157                                      act_tmpl,
 158                                      &fid);
 159         if (!ret) {
 160                 flow_id = (struct rte_flow *)((uintptr_t)fid);
 161                 return flow_id;
 162         }
 163
 164 parse_error:
 165         rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 166                            "Failed to create flow.");
 167         return NULL;
 168 }
 169
 170 /* Function to validate the rte flow. */
 171 static int
 172 bnxt_ulp_flow_validate(struct rte_eth_dev *dev __rte_unused,
 173                        const struct rte_flow_attr *attr,
 174                        const struct rte_flow_item pattern[],
 175                        const struct rte_flow_action actions[],
 176                        struct rte_flow_error *error)
 177 {
 178         struct ulp_rte_hdr_bitmap hdr_bitmap;
 179         struct ulp_rte_hdr_field hdr_field[BNXT_ULP_PROTO_HDR_MAX];
 180         struct ulp_rte_act_bitmap act_bitmap;
 181         struct ulp_rte_act_prop act_prop;
 182         enum ulp_direction_type dir = ULP_DIR_INGRESS;
 183         uint32_t class_id, act_tmpl;
 184         int ret;
 185
 186         if (bnxt_ulp_flow_validate_args(attr,
 187                                         pattern, actions,
 188                                         error) == BNXT_TF_RC_ERROR) {
 189                 BNXT_TF_DBG(ERR, "Invalid arguments being passed\n");
 190                 return -EINVAL;
 191         }
 192
 193         /* clear the header bitmap and field structure */
 194         memset(&hdr_bitmap, 0, sizeof(struct ulp_rte_hdr_bitmap));
 195         memset(hdr_field, 0, sizeof(hdr_field));
 196         memset(&act_bitmap, 0, sizeof(act_bitmap));
 197         memset(&act_prop, 0, sizeof(act_prop));
 198
 199         /* Parse the rte flow pattern */
 200         ret = bnxt_ulp_rte_parser_hdr_parse(pattern,
 201                                             &hdr_bitmap,
 202                                             hdr_field);
 203         if (ret != BNXT_TF_RC_SUCCESS)
 204                 goto parse_error;
 205
 206         /* Parse the rte flow action */
 207         ret = bnxt_ulp_rte_parser_act_parse(actions,
 208                                             &act_bitmap,
 209                                             &act_prop);
 210         if (ret != BNXT_TF_RC_SUCCESS)
 211                 goto parse_error;
 212
 213         if (attr->egress)
 214                 dir = ULP_DIR_EGRESS;
 215
 216         ret = ulp_matcher_pattern_match(dir, &hdr_bitmap, hdr_field,
 217                                         &act_bitmap, &class_id);
 218
 219         if (ret != BNXT_TF_RC_SUCCESS)
 220                 goto parse_error;
 221
 222         ret = ulp_matcher_action_match(dir, &act_bitmap, &act_tmpl);
 223         if (ret != BNXT_TF_RC_SUCCESS)
 224                 goto parse_error;
 225
 226         /* all good return success */
 227         return ret;
 228
 229 parse_error:
 230         rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 231                            "Failed to validate flow.");
 232         return -EINVAL;
 233 }
 234
 235 const struct rte_flow_ops bnxt_ulp_rte_flow_ops = {
 236         .validate = bnxt_ulp_flow_validate,
 237         .create = bnxt_ulp_flow_create,
 238         .destroy = NULL,
 239         .flush = NULL,
 240         .query = NULL,
 241         .isolate = NULL
 242 };