net/bnxt: delete and flush L2 filters cleanly

[dpdk.git] / drivers / net / bnxt / bnxt_flow.c

diff --git a/drivers/net/bnxt/bnxt_flow.c b/drivers/net/bnxt/bnxt_flow.c
index 9a3f7ab..33f4b07 100644 (file)
--- a/drivers/net/bnxt/bnxt_flow.c
+++ b/drivers/net/bnxt/bnxt_flow.c
@@ -227,6 +227,9 @@ bnxt_validate_and_parse_flow_type(struct bnxt *bp,
                                valid_flags |= inner ?
                                        BNXT_FLOW_L2_INNER_DST_VALID_FLAG :
                                        BNXT_FLOW_L2_DST_VALID_FLAG;
+                               filter->priority = attr->priority;
+                               PMD_DRV_LOG(DEBUG,
+                                           "Creating a priority flow\n");
                        }
 
                        if (rte_is_broadcast_ether_addr(&eth_mask->src)) {
@@ -712,15 +715,6 @@ bnxt_flow_parse_attr(const struct rte_flow_attr *attr,
                return -rte_errno;
        }
 
-       /* Not supported */
-       if (attr->priority) {
-               rte_flow_error_set(error,
-                                  EINVAL,
-                                  RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
-                                  attr,
-                                  "No support for priority.");
-               return -rte_errno;
-       }
        return 0;
 }
 
@@ -802,13 +796,16 @@ bnxt_create_l2_filter(struct bnxt *bp, struct bnxt_filter_info *nf,
                memcpy(filter1->l2_addr, nf->dst_macaddr, RTE_ETHER_ADDR_LEN);
        }
 
-       if (nf->valid_flags & BNXT_FLOW_L2_DST_VALID_FLAG ||
-           nf->valid_flags & BNXT_FLOW_L2_INNER_DST_VALID_FLAG) {
+       if (nf->priority &&
+           (nf->valid_flags & BNXT_FLOW_L2_DST_VALID_FLAG ||
+            nf->valid_flags & BNXT_FLOW_L2_INNER_DST_VALID_FLAG)) {
                /* Tell the FW where to place the filter in the table. */
-               filter1->pri_hint =
+               if (nf->priority > 65535) {
+                       filter1->pri_hint =
                        HWRM_CFA_L2_FILTER_ALLOC_INPUT_PRI_HINT_BELOW_FILTER;
-               /* This will place the filter in TCAM */
-               filter1->l2_filter_id_hint = (uint64_t)-1;
+                       /* This will place the filter in TCAM */
+                       filter1->l2_filter_id_hint = (uint64_t)-1;
+               }
        }
 
        filter1->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
@@ -1639,7 +1636,7 @@ free_flow:
                rte_flow_error_set(error, 0,
                                   RTE_FLOW_ERROR_TYPE_NONE, NULL,
                                   "Flow with pattern exists, updating destination queue");
-       else if (!rte_errno)
+       else
                rte_flow_error_set(error, -ret,
                                   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
                                   "Failed to create flow.");
@@ -1718,6 +1715,7 @@ bnxt_flow_destroy(struct rte_eth_dev *dev,
        ret = bnxt_match_filter(bp, filter);
        if (ret == 0)
                PMD_DRV_LOG(ERR, "Could not find matching flow\n");
+
        if (filter->filter_type == HWRM_CFA_EM_FILTER)
                ret = bnxt_hwrm_clear_em_filter(bp, filter);
        if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
@@ -1726,9 +1724,40 @@ bnxt_flow_destroy(struct rte_eth_dev *dev,
 
 done:
        if (!ret) {
+               STAILQ_REMOVE(&vnic->filter, filter, bnxt_filter_info, next);
                bnxt_free_filter(bp, filter);
                STAILQ_REMOVE(&vnic->flow_list, flow, rte_flow, next);
                rte_free(flow);
+
+               /* If this was the last flow associated with this vnic,
+                * switch the queue back to RSS pool.
+                */
+               if (vnic && STAILQ_EMPTY(&vnic->flow_list)) {
+                       rte_free(vnic->fw_grp_ids);
+                       if (vnic->rx_queue_cnt > 1) {
+                               if (BNXT_CHIP_THOR(bp)) {
+                                       int j;
+
+                                       for (j = 0; j < vnic->num_lb_ctxts;
+                                            j++) {
+                                               bnxt_hwrm_vnic_ctx_free(bp,
+                                                                        vnic,
+                                                                        vnic->fw_grp_ids[j]);
+                                               vnic->fw_grp_ids[j] =
+                                                       INVALID_HW_RING_ID;
+                                       }
+                                       vnic->num_lb_ctxts = 0;
+                               } else {
+                                       bnxt_hwrm_vnic_ctx_free(bp,
+                                                               vnic,
+                                                               vnic->rss_rule);
+                                       vnic->rss_rule = INVALID_HW_RING_ID;
+                               }
+                       }
+                       bnxt_hwrm_vnic_free(bp, vnic);
+                       vnic->rx_queue_cnt = 0;
+                       bp->nr_vnics--;
+               }
        } else {
                rte_flow_error_set(error, -ret,
                                   RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
@@ -1747,8 +1776,11 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
        unsigned int i;
        int ret = 0;
 
-       for (i = 0; i < bp->nr_vnics; i++) {
+       for (i = 0; i < bp->max_vnics; i++) {
                vnic = &bp->vnic_info[i];
+               if (vnic->fw_vnic_id == INVALID_VNIC_ID)
+                       continue;
+
                STAILQ_FOREACH(flow, &vnic->flow_list, next) {
                        struct bnxt_filter_info *filter = flow->filter;
 
@@ -1769,6 +1801,8 @@ bnxt_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
                                ret = bnxt_hwrm_clear_em_filter(bp, filter);
                        if (filter->filter_type == HWRM_CFA_NTUPLE_FILTER)
                                ret = bnxt_hwrm_clear_ntuple_filter(bp, filter);
+                       else if (!i)
+                               ret = bnxt_hwrm_clear_l2_filter(bp, filter);
 
                        if (ret) {
                                rte_flow_error_set