drivers/net/hns3/hns3_fdir.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018-2021 HiSilicon Limited.
   3  */
   4
   5 #include <ethdev_driver.h>
   6 #include <rte_hash.h>
   7 #include <rte_hash_crc.h>
   8 #include <rte_io.h>
   9 #include <rte_malloc.h>
  10
  11 #include "hns3_ethdev.h"
  12 #include "hns3_logs.h"
  13
  14 #define HNS3_VLAN_TAG_TYPE_NONE         0
  15 #define HNS3_VLAN_TAG_TYPE_TAG2         1
  16 #define HNS3_VLAN_TAG_TYPE_TAG1         2
  17 #define HNS3_VLAN_TAG_TYPE_TAG1_2       3
  18
  19 #define HNS3_PF_ID_S                    0
  20 #define HNS3_PF_ID_M                    GENMASK(2, 0)
  21 #define HNS3_VF_ID_S                    3
  22 #define HNS3_VF_ID_M                    GENMASK(10, 3)
  23 #define HNS3_PORT_TYPE_B                11
  24 #define HNS3_NETWORK_PORT_ID_S          0
  25 #define HNS3_NETWORK_PORT_ID_M          GENMASK(3, 0)
  26
  27 #define HNS3_FD_EPORT_SW_EN_B           0
  28
  29 #define HNS3_FD_AD_DATA_S               32
  30 #define HNS3_FD_AD_DROP_B               0
  31 #define HNS3_FD_AD_DIRECT_QID_B         1
  32 #define HNS3_FD_AD_QID_S                2
  33 #define HNS3_FD_AD_QID_M                GENMASK(11, 2)
  34 #define HNS3_FD_AD_USE_COUNTER_B        12
  35 #define HNS3_FD_AD_COUNTER_NUM_S        13
  36 #define HNS3_FD_AD_COUNTER_NUM_M        GENMASK(19, 13)
  37 #define HNS3_FD_AD_NXT_STEP_B           20
  38 #define HNS3_FD_AD_NXT_KEY_S            21
  39 #define HNS3_FD_AD_NXT_KEY_M            GENMASK(25, 21)
  40 #define HNS3_FD_AD_WR_RULE_ID_B         0
  41 #define HNS3_FD_AD_RULE_ID_S            1
  42 #define HNS3_FD_AD_RULE_ID_M            GENMASK(12, 1)
  43 #define HNS3_FD_AD_QUEUE_REGION_EN_B    16
  44 #define HNS3_FD_AD_QUEUE_REGION_SIZE_S  17
  45 #define HNS3_FD_AD_QUEUE_REGION_SIZE_M  GENMASK(20, 17)
  46 #define HNS3_FD_AD_COUNTER_HIGH_BIT     7
  47 #define HNS3_FD_AD_COUNTER_HIGH_BIT_B   26
  48 #define HNS3_FD_AD_QUEUE_ID_HIGH_BIT    10
  49 #define HNS3_FD_AD_QUEUE_ID_HIGH_BIT_B  21
  50
  51 enum HNS3_PORT_TYPE {
  52         HOST_PORT,
  53         NETWORK_PORT
  54 };
  55
  56 enum HNS3_FD_MODE {
  57         HNS3_FD_MODE_DEPTH_2K_WIDTH_400B_STAGE_1,
  58         HNS3_FD_MODE_DEPTH_1K_WIDTH_400B_STAGE_2,
  59         HNS3_FD_MODE_DEPTH_4K_WIDTH_200B_STAGE_1,
  60         HNS3_FD_MODE_DEPTH_2K_WIDTH_200B_STAGE_2,
  61 };
  62
  63 enum HNS3_FD_KEY_TYPE {
  64         HNS3_FD_KEY_BASE_ON_PTYPE,
  65         HNS3_FD_KEY_BASE_ON_TUPLE,
  66 };
  67
  68 enum HNS3_FD_META_DATA {
  69         PACKET_TYPE_ID,
  70         IP_FRAGEMENT,
  71         ROCE_TYPE,
  72         NEXT_KEY,
  73         VLAN_NUMBER,
  74         SRC_VPORT,
  75         DST_VPORT,
  76         TUNNEL_PACKET,
  77         MAX_META_DATA,
  78 };
  79
  80 struct key_info {
  81         uint8_t key_type;
  82         uint8_t key_length;
  83 };
  84
  85 static const struct key_info meta_data_key_info[] = {
  86         {PACKET_TYPE_ID, 6},
  87         {IP_FRAGEMENT, 1},
  88         {ROCE_TYPE, 1},
  89         {NEXT_KEY, 5},
  90         {VLAN_NUMBER, 2},
  91         {SRC_VPORT, 12},
  92         {DST_VPORT, 12},
  93         {TUNNEL_PACKET, 1},
  94 };
  95
  96 static const struct key_info tuple_key_info[] = {
  97         {OUTER_DST_MAC, 48},
  98         {OUTER_SRC_MAC, 48},
  99         {OUTER_VLAN_TAG_FST, 16},
 100         {OUTER_VLAN_TAG_SEC, 16},
 101         {OUTER_ETH_TYPE, 16},
 102         {OUTER_L2_RSV, 16},
 103         {OUTER_IP_TOS, 8},
 104         {OUTER_IP_PROTO, 8},
 105         {OUTER_SRC_IP, 32},
 106         {OUTER_DST_IP, 32},
 107         {OUTER_L3_RSV, 16},
 108         {OUTER_SRC_PORT, 16},
 109         {OUTER_DST_PORT, 16},
 110         {OUTER_L4_RSV, 32},
 111         {OUTER_TUN_VNI, 24},
 112         {OUTER_TUN_FLOW_ID, 8},
 113         {INNER_DST_MAC, 48},
 114         {INNER_SRC_MAC, 48},
 115         {INNER_VLAN_TAG1, 16},
 116         {INNER_VLAN_TAG2, 16},
 117         {INNER_ETH_TYPE, 16},
 118         {INNER_L2_RSV, 16},
 119         {INNER_IP_TOS, 8},
 120         {INNER_IP_PROTO, 8},
 121         {INNER_SRC_IP, 32},
 122         {INNER_DST_IP, 32},
 123         {INNER_L3_RSV, 16},
 124         {INNER_SRC_PORT, 16},
 125         {INNER_DST_PORT, 16},
 126         {INNER_SCTP_TAG, 32},
 127 };
 128
 129 #define MAX_KEY_LENGTH          400
 130 #define MAX_200B_KEY_LENGTH     200
 131 #define MAX_META_DATA_LENGTH    16
 132 #define MAX_KEY_DWORDS  DIV_ROUND_UP(MAX_KEY_LENGTH / HNS3_BITS_PER_BYTE, 4)
 133 #define MAX_KEY_BYTES   (MAX_KEY_DWORDS * 4)
 134
 135 enum HNS3_FD_PACKET_TYPE {
 136         NIC_PACKET,
 137         ROCE_PACKET,
 138 };
 139
 140 /* For each bit of TCAM entry, it uses a pair of 'x' and
 141  * 'y' to indicate which value to match, like below:
 142  * ----------------------------------
 143  * | bit x | bit y |  search value  |
 144  * ----------------------------------
 145  * |   0   |   0   |   always hit   |
 146  * ----------------------------------
 147  * |   1   |   0   |   match '0'    |
 148  * ----------------------------------
 149  * |   0   |   1   |   match '1'    |
 150  * ----------------------------------
 151  * |   1   |   1   |   invalid      |
 152  * ----------------------------------
 153  * Then for input key(k) and mask(v), we can calculate the value by
 154  * the formulae:
 155  *      x = (~k) & v
 156  *      y = k & v
 157  */
 158 #define calc_x(x, k, v) ((x) = (~(k) & (v)))
 159 #define calc_y(y, k, v) ((y) = ((k) & (v)))
 160
 161 struct hns3_fd_tcam_config_1_cmd {
 162         uint8_t stage;
 163         uint8_t xy_sel;
 164         uint8_t port_info;
 165         uint8_t rsv1[1];
 166         rte_le32_t index;
 167         uint8_t entry_vld;
 168         uint8_t rsv2[7];
 169         uint8_t tcam_data[8];
 170 };
 171
 172 struct hns3_fd_tcam_config_2_cmd {
 173         uint8_t tcam_data[24];
 174 };
 175
 176 struct hns3_fd_tcam_config_3_cmd {
 177         uint8_t tcam_data[20];
 178         uint8_t rsv[4];
 179 };
 180
 181 struct hns3_get_fd_mode_cmd {
 182         uint8_t mode;
 183         uint8_t enable;
 184         uint8_t rsv[22];
 185 };
 186
 187 struct hns3_get_fd_allocation_cmd {
 188         rte_le32_t stage1_entry_num;
 189         rte_le32_t stage2_entry_num;
 190         rte_le16_t stage1_counter_num;
 191         rte_le16_t stage2_counter_num;
 192         uint8_t rsv[12];
 193 };
 194
 195 struct hns3_set_fd_key_config_cmd {
 196         uint8_t stage;
 197         uint8_t key_select;
 198         uint8_t inner_sipv6_word_en;
 199         uint8_t inner_dipv6_word_en;
 200         uint8_t outer_sipv6_word_en;
 201         uint8_t outer_dipv6_word_en;
 202         uint8_t rsv1[2];
 203         rte_le32_t tuple_mask;
 204         rte_le32_t meta_data_mask;
 205         uint8_t rsv2[8];
 206 };
 207
 208 struct hns3_fd_ad_config_cmd {
 209         uint8_t stage;
 210         uint8_t rsv1[3];
 211         rte_le32_t index;
 212         rte_le64_t ad_data;
 213         uint8_t rsv2[8];
 214 };
 215
 216 struct hns3_fd_get_cnt_cmd {
 217         uint8_t stage;
 218         uint8_t rsv1[3];
 219         rte_le16_t index;
 220         uint8_t rsv2[2];
 221         rte_le64_t value;
 222         uint8_t rsv3[8];
 223 };
 224
 225 static int hns3_get_fd_mode(struct hns3_hw *hw, uint8_t *fd_mode)
 226 {
 227         struct hns3_get_fd_mode_cmd *req;
 228         struct hns3_cmd_desc desc;
 229         int ret;
 230
 231         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_MODE_CTRL, true);
 232
 233         req = (struct hns3_get_fd_mode_cmd *)desc.data;
 234
 235         ret = hns3_cmd_send(hw, &desc, 1);
 236         if (ret) {
 237                 hns3_err(hw, "Get fd mode fail, ret=%d", ret);
 238                 return ret;
 239         }
 240
 241         *fd_mode = req->mode;
 242
 243         return ret;
 244 }
 245
 246 static int hns3_get_fd_allocation(struct hns3_hw *hw,
 247                                   uint32_t *stage1_entry_num,
 248                                   uint32_t *stage2_entry_num,
 249                                   uint16_t *stage1_counter_num,
 250                                   uint16_t *stage2_counter_num)
 251 {
 252         struct hns3_get_fd_allocation_cmd *req;
 253         struct hns3_cmd_desc desc;
 254         int ret;
 255
 256         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_GET_ALLOCATION, true);
 257
 258         req = (struct hns3_get_fd_allocation_cmd *)desc.data;
 259
 260         ret = hns3_cmd_send(hw, &desc, 1);
 261         if (ret) {
 262                 hns3_err(hw, "Query fd allocation fail, ret=%d", ret);
 263                 return ret;
 264         }
 265
 266         *stage1_entry_num = rte_le_to_cpu_32(req->stage1_entry_num);
 267         *stage2_entry_num = rte_le_to_cpu_32(req->stage2_entry_num);
 268         *stage1_counter_num = rte_le_to_cpu_16(req->stage1_counter_num);
 269         *stage2_counter_num = rte_le_to_cpu_16(req->stage2_counter_num);
 270
 271         return ret;
 272 }
 273
 274 static int hns3_set_fd_key_config(struct hns3_adapter *hns)
 275 {
 276         struct hns3_set_fd_key_config_cmd *req;
 277         struct hns3_fd_key_cfg *key_cfg;
 278         struct hns3_pf *pf = &hns->pf;
 279         struct hns3_hw *hw = &hns->hw;
 280         struct hns3_cmd_desc desc;
 281         int ret;
 282
 283         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_KEY_CONFIG, false);
 284
 285         req = (struct hns3_set_fd_key_config_cmd *)desc.data;
 286         key_cfg = &pf->fdir.fd_cfg.key_cfg[HNS3_FD_STAGE_1];
 287         req->stage = HNS3_FD_STAGE_1;
 288         req->key_select = key_cfg->key_sel;
 289         req->inner_sipv6_word_en = key_cfg->inner_sipv6_word_en;
 290         req->inner_dipv6_word_en = key_cfg->inner_dipv6_word_en;
 291         req->outer_sipv6_word_en = key_cfg->outer_sipv6_word_en;
 292         req->outer_dipv6_word_en = key_cfg->outer_dipv6_word_en;
 293         req->tuple_mask = rte_cpu_to_le_32(~key_cfg->tuple_active);
 294         req->meta_data_mask = rte_cpu_to_le_32(~key_cfg->meta_data_active);
 295
 296         ret = hns3_cmd_send(hw, &desc, 1);
 297         if (ret)
 298                 hns3_err(hw, "Set fd key fail, ret=%d", ret);
 299
 300         return ret;
 301 }
 302
 303 int hns3_init_fd_config(struct hns3_adapter *hns)
 304 {
 305         struct hns3_pf *pf = &hns->pf;
 306         struct hns3_hw *hw = &hns->hw;
 307         struct hns3_fd_key_cfg *key_cfg;
 308         int ret;
 309
 310         ret = hns3_get_fd_mode(hw, &pf->fdir.fd_cfg.fd_mode);
 311         if (ret)
 312                 return ret;
 313
 314         switch (pf->fdir.fd_cfg.fd_mode) {
 315         case HNS3_FD_MODE_DEPTH_2K_WIDTH_400B_STAGE_1:
 316                 pf->fdir.fd_cfg.max_key_length = MAX_KEY_LENGTH;
 317                 break;
 318         case HNS3_FD_MODE_DEPTH_4K_WIDTH_200B_STAGE_1:
 319                 pf->fdir.fd_cfg.max_key_length = MAX_200B_KEY_LENGTH;
 320                 hns3_warn(hw, "Unsupported tunnel filter in 4K*200Bit");
 321                 break;
 322         default:
 323                 hns3_err(hw, "Unsupported flow director mode %u",
 324                             pf->fdir.fd_cfg.fd_mode);
 325                 return -EOPNOTSUPP;
 326         }
 327
 328         key_cfg = &pf->fdir.fd_cfg.key_cfg[HNS3_FD_STAGE_1];
 329         key_cfg->key_sel = HNS3_FD_KEY_BASE_ON_TUPLE;
 330         key_cfg->inner_sipv6_word_en = IPV6_ADDR_WORD_MASK;
 331         key_cfg->inner_dipv6_word_en = IPV6_ADDR_WORD_MASK;
 332         key_cfg->outer_sipv6_word_en = 0;
 333         key_cfg->outer_dipv6_word_en = 0;
 334
 335         key_cfg->tuple_active = BIT(INNER_VLAN_TAG1) | BIT(INNER_ETH_TYPE) |
 336             BIT(INNER_IP_PROTO) | BIT(INNER_IP_TOS) |
 337             BIT(INNER_SRC_IP) | BIT(INNER_DST_IP) |
 338             BIT(INNER_SRC_PORT) | BIT(INNER_DST_PORT);
 339         hns3_dbg(hw, "fdir tuple: inner<vlan_tag1 eth_type ip_src ip_dst "
 340                   "ip_proto ip_tos l4_src_port l4_dst_port>");
 341
 342         /* If use max 400bit key, we can support tuples for ether type */
 343         if (pf->fdir.fd_cfg.max_key_length == MAX_KEY_LENGTH) {
 344                 key_cfg->tuple_active |=
 345                     BIT(INNER_DST_MAC) | BIT(INNER_SRC_MAC) |
 346                     BIT(OUTER_SRC_PORT) | BIT(INNER_SCTP_TAG) |
 347                     BIT(OUTER_DST_PORT) | BIT(INNER_VLAN_TAG2) |
 348                     BIT(OUTER_TUN_VNI) | BIT(OUTER_TUN_FLOW_ID) |
 349                     BIT(OUTER_ETH_TYPE) | BIT(OUTER_IP_PROTO);
 350                 hns3_dbg(hw, "fdir tuple more: inner<dst_mac src_mac "
 351                           "vlan_tag2 sctp_tag> outer<eth_type ip_proto "
 352                           "l4_src_port l4_dst_port tun_vni tun_flow_id>");
 353         }
 354
 355         /* roce_type is used to filter roce frames
 356          * dst_vport is used to specify the rule
 357          */
 358         key_cfg->meta_data_active = BIT(DST_VPORT) | BIT(TUNNEL_PACKET) |
 359             BIT(VLAN_NUMBER);
 360         hns3_dbg(hw, "fdir meta data: dst_vport tunnel_packet vlan_number");
 361
 362         ret = hns3_get_fd_allocation(hw,
 363                                      &pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_1],
 364                                      &pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_2],
 365                                      &pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_1],
 366                                      &pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_2]);
 367         if (ret)
 368                 return ret;
 369
 370         hns3_dbg(hw, "fdir: stage1<rules-%u counters-%u> stage2<rules-%u "
 371                   "counters=%u>",
 372                   pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_1],
 373                   pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_1],
 374                   pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_2],
 375                   pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_2]);
 376
 377         return hns3_set_fd_key_config(hns);
 378 }
 379
 380 static int hns3_fd_tcam_config(struct hns3_hw *hw, bool sel_x, int loc,
 381                                uint8_t *key, bool is_add)
 382 {
 383 #define FD_TCAM_CMD_NUM 3
 384         struct hns3_fd_tcam_config_1_cmd *req1;
 385         struct hns3_fd_tcam_config_2_cmd *req2;
 386         struct hns3_fd_tcam_config_3_cmd *req3;
 387         struct hns3_cmd_desc desc[FD_TCAM_CMD_NUM];
 388         int len;
 389         int ret;
 390
 391         hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_FD_TCAM_OP, false);
 392         desc[0].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT);
 393         hns3_cmd_setup_basic_desc(&desc[1], HNS3_OPC_FD_TCAM_OP, false);
 394         desc[1].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT);
 395         hns3_cmd_setup_basic_desc(&desc[2], HNS3_OPC_FD_TCAM_OP, false);
 396
 397         req1 = (struct hns3_fd_tcam_config_1_cmd *)desc[0].data;
 398         req2 = (struct hns3_fd_tcam_config_2_cmd *)desc[1].data;
 399         req3 = (struct hns3_fd_tcam_config_3_cmd *)desc[2].data;
 400
 401         req1->stage = HNS3_FD_STAGE_1;
 402         req1->xy_sel = sel_x ? 1 : 0;
 403         hns3_set_bit(req1->port_info, HNS3_FD_EPORT_SW_EN_B, 0);
 404         req1->index = rte_cpu_to_le_32(loc);
 405         req1->entry_vld = sel_x ? is_add : 0;
 406
 407         if (key) {
 408                 len = sizeof(req1->tcam_data);
 409                 memcpy(req1->tcam_data, key, len);
 410                 key += len;
 411
 412                 len = sizeof(req2->tcam_data);
 413                 memcpy(req2->tcam_data, key, len);
 414                 key += len;
 415
 416                 len = sizeof(req3->tcam_data);
 417                 memcpy(req3->tcam_data, key, len);
 418         }
 419
 420         ret = hns3_cmd_send(hw, desc, FD_TCAM_CMD_NUM);
 421         if (ret)
 422                 hns3_err(hw, "Config tcam key fail, ret=%d loc=%d add=%d",
 423                             ret, loc, is_add);
 424         return ret;
 425 }
 426
 427 static int hns3_fd_ad_config(struct hns3_hw *hw, int loc,
 428                              struct hns3_fd_ad_data *action)
 429 {
 430         struct hns3_fd_ad_config_cmd *req;
 431         struct hns3_cmd_desc desc;
 432         uint64_t ad_data = 0;
 433         int ret;
 434
 435         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_AD_OP, false);
 436
 437         req = (struct hns3_fd_ad_config_cmd *)desc.data;
 438         req->index = rte_cpu_to_le_32(loc);
 439         req->stage = HNS3_FD_STAGE_1;
 440
 441         hns3_set_bit(ad_data, HNS3_FD_AD_WR_RULE_ID_B,
 442                      action->write_rule_id_to_bd);
 443         hns3_set_field(ad_data, HNS3_FD_AD_RULE_ID_M, HNS3_FD_AD_RULE_ID_S,
 444                        action->rule_id);
 445         if (action->nb_queues > 1) {
 446                 hns3_set_bit(ad_data, HNS3_FD_AD_QUEUE_REGION_EN_B, 1);
 447                 hns3_set_field(ad_data, HNS3_FD_AD_QUEUE_REGION_SIZE_M,
 448                                HNS3_FD_AD_QUEUE_REGION_SIZE_S,
 449                                rte_log2_u32(action->nb_queues));
 450         }
 451         /* set extend bit if counter_id is in [128 ~ 255] */
 452         if (action->counter_id & BIT(HNS3_FD_AD_COUNTER_HIGH_BIT))
 453                 hns3_set_bit(ad_data, HNS3_FD_AD_COUNTER_HIGH_BIT_B, 1);
 454         /* set extend bit if queue id > 1024 */
 455         if (action->queue_id & BIT(HNS3_FD_AD_QUEUE_ID_HIGH_BIT))
 456                 hns3_set_bit(ad_data, HNS3_FD_AD_QUEUE_ID_HIGH_BIT_B, 1);
 457         ad_data <<= HNS3_FD_AD_DATA_S;
 458         hns3_set_bit(ad_data, HNS3_FD_AD_DROP_B, action->drop_packet);
 459         if (action->nb_queues == 1)
 460                 hns3_set_bit(ad_data, HNS3_FD_AD_DIRECT_QID_B, 1);
 461         hns3_set_field(ad_data, HNS3_FD_AD_QID_M, HNS3_FD_AD_QID_S,
 462                        action->queue_id);
 463         hns3_set_bit(ad_data, HNS3_FD_AD_USE_COUNTER_B, action->use_counter);
 464         hns3_set_field(ad_data, HNS3_FD_AD_COUNTER_NUM_M,
 465                        HNS3_FD_AD_COUNTER_NUM_S, action->counter_id);
 466         hns3_set_bit(ad_data, HNS3_FD_AD_NXT_STEP_B, action->use_next_stage);
 467         hns3_set_field(ad_data, HNS3_FD_AD_NXT_KEY_M, HNS3_FD_AD_NXT_KEY_S,
 468                        action->next_input_key);
 469
 470         req->ad_data = rte_cpu_to_le_64(ad_data);
 471         ret = hns3_cmd_send(hw, &desc, 1);
 472         if (ret)
 473                 hns3_err(hw, "Config fd ad fail, ret=%d loc=%d", ret, loc);
 474
 475         return ret;
 476 }
 477
 478 static inline void hns3_fd_convert_mac(uint8_t *key, uint8_t *mask,
 479                                        uint8_t *mac_x, uint8_t *mac_y)
 480 {
 481         uint8_t tmp;
 482         int i;
 483
 484         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) {
 485                 tmp = RTE_ETHER_ADDR_LEN - 1 - i;
 486                 calc_x(mac_x[tmp], key[i], mask[i]);
 487                 calc_y(mac_y[tmp], key[i], mask[i]);
 488         }
 489 }
 490
 491 static void hns3_fd_convert_int16(uint32_t tuple, struct hns3_fdir_rule *rule,
 492                                   uint8_t *val_x, uint8_t *val_y)
 493 {
 494         uint16_t tmp_x_s;
 495         uint16_t tmp_y_s;
 496         uint16_t mask;
 497         uint16_t key;
 498
 499         switch (tuple) {
 500         case OUTER_SRC_PORT:
 501                 key = rule->key_conf.spec.outer_src_port;
 502                 mask = rule->key_conf.mask.outer_src_port;
 503                 break;
 504         case OUTER_DST_PORT:
 505                 key = rule->key_conf.spec.tunnel_type;
 506                 mask = rule->key_conf.mask.tunnel_type;
 507                 break;
 508         case OUTER_ETH_TYPE:
 509                 key = rule->key_conf.spec.outer_ether_type;
 510                 mask = rule->key_conf.mask.outer_ether_type;
 511                 break;
 512         case INNER_SRC_PORT:
 513                 key = rule->key_conf.spec.src_port;
 514                 mask = rule->key_conf.mask.src_port;
 515                 break;
 516         case INNER_DST_PORT:
 517                 key = rule->key_conf.spec.dst_port;
 518                 mask = rule->key_conf.mask.dst_port;
 519                 break;
 520         case INNER_VLAN_TAG1:
 521                 key = rule->key_conf.spec.vlan_tag1;
 522                 mask = rule->key_conf.mask.vlan_tag1;
 523                 break;
 524         case INNER_VLAN_TAG2:
 525                 key = rule->key_conf.spec.vlan_tag2;
 526                 mask = rule->key_conf.mask.vlan_tag2;
 527                 break;
 528         default:
 529                 /*  INNER_ETH_TYPE: */
 530                 key = rule->key_conf.spec.ether_type;
 531                 mask = rule->key_conf.mask.ether_type;
 532                 break;
 533         }
 534         calc_x(tmp_x_s, key, mask);
 535         calc_y(tmp_y_s, key, mask);
 536         val_x[0] = rte_cpu_to_le_16(tmp_x_s) & 0xFF;
 537         val_x[1] = rte_cpu_to_le_16(tmp_x_s) >> HNS3_BITS_PER_BYTE;
 538         val_y[0] = rte_cpu_to_le_16(tmp_y_s) & 0xFF;
 539         val_y[1] = rte_cpu_to_le_16(tmp_y_s) >> HNS3_BITS_PER_BYTE;
 540 }
 541
 542 static inline void hns3_fd_convert_int32(uint32_t key, uint32_t mask,
 543                                          uint8_t *val_x, uint8_t *val_y)
 544 {
 545         uint32_t tmp_x_l;
 546         uint32_t tmp_y_l;
 547
 548         calc_x(tmp_x_l, key, mask);
 549         calc_y(tmp_y_l, key, mask);
 550         memcpy(val_x, &tmp_x_l, sizeof(tmp_x_l));
 551         memcpy(val_y, &tmp_y_l, sizeof(tmp_y_l));
 552 }
 553
 554 static bool hns3_fd_convert_tuple(struct hns3_hw *hw,
 555                                   uint32_t tuple, uint8_t *key_x,
 556                                   uint8_t *key_y, struct hns3_fdir_rule *rule)
 557 {
 558         struct hns3_fdir_key_conf *key_conf;
 559         int tmp;
 560         int i;
 561
 562         if ((rule->input_set & BIT(tuple)) == 0)
 563                 return true;
 564
 565         key_conf = &rule->key_conf;
 566         switch (tuple) {
 567         case INNER_DST_MAC:
 568                 hns3_fd_convert_mac(key_conf->spec.dst_mac,
 569                                     key_conf->mask.dst_mac, key_x, key_y);
 570                 break;
 571         case INNER_SRC_MAC:
 572                 hns3_fd_convert_mac(key_conf->spec.src_mac,
 573                                     key_conf->mask.src_mac, key_x, key_y);
 574                 break;
 575         case OUTER_SRC_PORT:
 576         case OUTER_DST_PORT:
 577         case OUTER_ETH_TYPE:
 578         case INNER_SRC_PORT:
 579         case INNER_DST_PORT:
 580         case INNER_VLAN_TAG1:
 581         case INNER_VLAN_TAG2:
 582         case INNER_ETH_TYPE:
 583                 hns3_fd_convert_int16(tuple, rule, key_x, key_y);
 584                 break;
 585         case INNER_SRC_IP:
 586                 hns3_fd_convert_int32(key_conf->spec.src_ip[IP_ADDR_KEY_ID],
 587                                       key_conf->mask.src_ip[IP_ADDR_KEY_ID],
 588                                       key_x, key_y);
 589                 break;
 590         case INNER_DST_IP:
 591                 hns3_fd_convert_int32(key_conf->spec.dst_ip[IP_ADDR_KEY_ID],
 592                                       key_conf->mask.dst_ip[IP_ADDR_KEY_ID],
 593                                       key_x, key_y);
 594                 break;
 595         case INNER_SCTP_TAG:
 596                 hns3_fd_convert_int32(key_conf->spec.sctp_tag,
 597                                       key_conf->mask.sctp_tag, key_x, key_y);
 598                 break;
 599         case OUTER_TUN_VNI:
 600                 for (i = 0; i < VNI_OR_TNI_LEN; i++) {
 601                         tmp = VNI_OR_TNI_LEN - 1 - i;
 602                         calc_x(key_x[tmp],
 603                                key_conf->spec.outer_tun_vni[i],
 604                                key_conf->mask.outer_tun_vni[i]);
 605                         calc_y(key_y[tmp],
 606                                key_conf->spec.outer_tun_vni[i],
 607                                key_conf->mask.outer_tun_vni[i]);
 608                 }
 609                 break;
 610         case OUTER_TUN_FLOW_ID:
 611                 calc_x(*key_x, key_conf->spec.outer_tun_flow_id,
 612                        key_conf->mask.outer_tun_flow_id);
 613                 calc_y(*key_y, key_conf->spec.outer_tun_flow_id,
 614                        key_conf->mask.outer_tun_flow_id);
 615                 break;
 616         case INNER_IP_TOS:
 617                 calc_x(*key_x, key_conf->spec.ip_tos, key_conf->mask.ip_tos);
 618                 calc_y(*key_y, key_conf->spec.ip_tos, key_conf->mask.ip_tos);
 619                 break;
 620         case OUTER_IP_PROTO:
 621                 calc_x(*key_x, key_conf->spec.outer_proto,
 622                        key_conf->mask.outer_proto);
 623                 calc_y(*key_y, key_conf->spec.outer_proto,
 624                        key_conf->mask.outer_proto);
 625                 break;
 626         case INNER_IP_PROTO:
 627                 calc_x(*key_x, key_conf->spec.ip_proto,
 628                        key_conf->mask.ip_proto);
 629                 calc_y(*key_y, key_conf->spec.ip_proto,
 630                        key_conf->mask.ip_proto);
 631                 break;
 632         default:
 633                 hns3_warn(hw, "not support tuple of (%u)", tuple);
 634                 break;
 635         }
 636         return true;
 637 }
 638
 639 static uint32_t hns3_get_port_number(uint8_t pf_id, uint8_t vf_id)
 640 {
 641         uint32_t port_number = 0;
 642
 643         hns3_set_field(port_number, HNS3_PF_ID_M, HNS3_PF_ID_S, pf_id);
 644         hns3_set_field(port_number, HNS3_VF_ID_M, HNS3_VF_ID_S, vf_id);
 645         hns3_set_bit(port_number, HNS3_PORT_TYPE_B, HOST_PORT);
 646
 647         return port_number;
 648 }
 649
 650 static void hns3_fd_convert_meta_data(struct hns3_fd_key_cfg *cfg,
 651                                       uint8_t vf_id,
 652                                       struct hns3_fdir_rule *rule,
 653                                       uint8_t *key_x, uint8_t *key_y)
 654 {
 655         uint16_t meta_data = 0;
 656         uint32_t port_number;
 657         uint8_t cur_pos = 0;
 658         uint8_t tuple_size;
 659         uint8_t shift_bits;
 660         uint32_t tmp_x;
 661         uint32_t tmp_y;
 662         uint8_t i;
 663
 664         for (i = 0; i < MAX_META_DATA; i++) {
 665                 if ((cfg->meta_data_active & BIT(i)) == 0)
 666                         continue;
 667
 668                 tuple_size = meta_data_key_info[i].key_length;
 669                 if (i == TUNNEL_PACKET) {
 670                         hns3_set_bit(meta_data, cur_pos,
 671                                      rule->key_conf.spec.tunnel_type ? 1 : 0);
 672                         cur_pos += tuple_size;
 673                 } else if (i == VLAN_NUMBER) {
 674                         uint32_t vlan_tag;
 675                         uint8_t vlan_num;
 676                         if (rule->key_conf.spec.tunnel_type == 0)
 677                                 vlan_num = rule->key_conf.vlan_num;
 678                         else
 679                                 vlan_num = rule->key_conf.outer_vlan_num;
 680                         if (vlan_num == 1)
 681                                 vlan_tag = HNS3_VLAN_TAG_TYPE_TAG1;
 682                         else if (vlan_num == VLAN_TAG_NUM_MAX)
 683                                 vlan_tag = HNS3_VLAN_TAG_TYPE_TAG1_2;
 684                         else
 685                                 vlan_tag = HNS3_VLAN_TAG_TYPE_NONE;
 686                         hns3_set_field(meta_data,
 687                                        GENMASK(cur_pos + tuple_size,
 688                                                cur_pos), cur_pos, vlan_tag);
 689                         cur_pos += tuple_size;
 690                 } else if (i == DST_VPORT) {
 691                         port_number = hns3_get_port_number(0, vf_id);
 692                         hns3_set_field(meta_data,
 693                                        GENMASK(cur_pos + tuple_size, cur_pos),
 694                                        cur_pos, port_number);
 695                         cur_pos += tuple_size;
 696                 }
 697         }
 698
 699         calc_x(tmp_x, meta_data, 0xFFFF);
 700         calc_y(tmp_y, meta_data, 0xFFFF);
 701         shift_bits = sizeof(meta_data) * HNS3_BITS_PER_BYTE - cur_pos;
 702
 703         tmp_x = rte_cpu_to_le_32(tmp_x << shift_bits);
 704         tmp_y = rte_cpu_to_le_32(tmp_y << shift_bits);
 705         key_x[0] = tmp_x & 0xFF;
 706         key_x[1] = (tmp_x >> HNS3_BITS_PER_BYTE) & 0xFF;
 707         key_y[0] = tmp_y & 0xFF;
 708         key_y[1] = (tmp_y >> HNS3_BITS_PER_BYTE) & 0xFF;
 709 }
 710
 711 /* A complete key is combined with meta data key and tuple key.
 712  * Meta data key is stored at the MSB region, and tuple key is stored at
 713  * the LSB region, unused bits will be filled 0.
 714  */
 715 static int hns3_config_key(struct hns3_adapter *hns,
 716                            struct hns3_fdir_rule *rule)
 717 {
 718         struct hns3_pf *pf = &hns->pf;
 719         struct hns3_hw *hw = &hns->hw;
 720         struct hns3_fd_key_cfg *key_cfg;
 721         uint8_t *cur_key_x;
 722         uint8_t *cur_key_y;
 723         uint8_t key_x[MAX_KEY_BYTES] __rte_aligned(4);
 724         uint8_t key_y[MAX_KEY_BYTES] __rte_aligned(4);
 725         uint8_t vf_id = rule->vf_id;
 726         uint8_t meta_data_region;
 727         uint8_t tuple_size;
 728         uint8_t i;
 729         int ret;
 730
 731         memset(key_x, 0, sizeof(key_x));
 732         memset(key_y, 0, sizeof(key_y));
 733         cur_key_x = key_x;
 734         cur_key_y = key_y;
 735
 736         key_cfg = &pf->fdir.fd_cfg.key_cfg[HNS3_FD_STAGE_1];
 737         for (i = 0; i < MAX_TUPLE; i++) {
 738                 bool tuple_valid;
 739
 740                 tuple_size = tuple_key_info[i].key_length / HNS3_BITS_PER_BYTE;
 741                 if (key_cfg->tuple_active & BIT(i)) {
 742                         tuple_valid = hns3_fd_convert_tuple(hw, i, cur_key_x,
 743                                                             cur_key_y, rule);
 744                         if (tuple_valid) {
 745                                 cur_key_x += tuple_size;
 746                                 cur_key_y += tuple_size;
 747                         }
 748                 }
 749         }
 750
 751         meta_data_region = pf->fdir.fd_cfg.max_key_length / HNS3_BITS_PER_BYTE -
 752             MAX_META_DATA_LENGTH / HNS3_BITS_PER_BYTE;
 753
 754         hns3_fd_convert_meta_data(key_cfg, vf_id, rule,
 755                                   key_x + meta_data_region,
 756                                   key_y + meta_data_region);
 757
 758         ret = hns3_fd_tcam_config(hw, false, rule->location, key_y, true);
 759         if (ret) {
 760                 hns3_err(hw, "Config fd key_y fail, loc=%u, ret=%d",
 761                             rule->queue_id, ret);
 762                 return ret;
 763         }
 764
 765         ret = hns3_fd_tcam_config(hw, true, rule->location, key_x, true);
 766         if (ret)
 767                 hns3_err(hw, "Config fd key_x fail, loc=%u, ret=%d",
 768                             rule->queue_id, ret);
 769         return ret;
 770 }
 771
 772 static int hns3_config_action(struct hns3_hw *hw, struct hns3_fdir_rule *rule)
 773 {
 774         struct hns3_fd_ad_data ad_data;
 775
 776         ad_data.ad_id = rule->location;
 777
 778         if (rule->action == HNS3_FD_ACTION_DROP_PACKET) {
 779                 ad_data.drop_packet = true;
 780                 ad_data.queue_id = 0;
 781                 ad_data.nb_queues = 0;
 782         } else {
 783                 ad_data.drop_packet = false;
 784                 ad_data.queue_id = rule->queue_id;
 785                 ad_data.nb_queues = rule->nb_queues;
 786         }
 787
 788         if (unlikely(rule->flags & HNS3_RULE_FLAG_COUNTER)) {
 789                 ad_data.use_counter = true;
 790                 ad_data.counter_id = rule->act_cnt.id;
 791         } else {
 792                 ad_data.use_counter = false;
 793                 ad_data.counter_id = 0;
 794         }
 795
 796         if (unlikely(rule->flags & HNS3_RULE_FLAG_FDID))
 797                 ad_data.rule_id = rule->fd_id;
 798         else
 799                 ad_data.rule_id = rule->location;
 800
 801         ad_data.use_next_stage = false;
 802         ad_data.next_input_key = 0;
 803
 804         ad_data.write_rule_id_to_bd = true;
 805
 806         return hns3_fd_ad_config(hw, ad_data.ad_id, &ad_data);
 807 }
 808
 809 static int hns3_fd_clear_all_rules(struct hns3_hw *hw, uint32_t rule_num)
 810 {
 811         uint32_t i;
 812         int ret;
 813
 814         for (i = 0; i < rule_num; i++) {
 815                 ret = hns3_fd_tcam_config(hw, true, i, NULL, false);
 816                 if (ret)
 817                         return ret;
 818         }
 819
 820         return 0;
 821 }
 822
 823 int hns3_fdir_filter_init(struct hns3_adapter *hns)
 824 {
 825         struct hns3_pf *pf = &hns->pf;
 826         struct hns3_fdir_info *fdir_info = &pf->fdir;
 827         uint32_t rule_num = fdir_info->fd_cfg.rule_num[HNS3_FD_STAGE_1];
 828         char fdir_hash_name[RTE_HASH_NAMESIZE];
 829         struct rte_hash_parameters fdir_hash_params = {
 830                 .name = fdir_hash_name,
 831                 .entries = rule_num,
 832                 .key_len = sizeof(struct hns3_fdir_key_conf),
 833                 .hash_func = rte_hash_crc,
 834                 .hash_func_init_val = 0,
 835         };
 836         int ret;
 837
 838         ret = hns3_fd_clear_all_rules(&hns->hw, rule_num);
 839         if (ret) {
 840                 PMD_INIT_LOG(ERR, "Clear all fd rules fail! ret = %d", ret);
 841                 return ret;
 842         }
 843
 844         fdir_hash_params.socket_id = rte_socket_id();
 845         TAILQ_INIT(&fdir_info->fdir_list);
 846         snprintf(fdir_hash_name, RTE_HASH_NAMESIZE, "%s", hns->hw.data->name);
 847         fdir_info->hash_handle = rte_hash_create(&fdir_hash_params);
 848         if (fdir_info->hash_handle == NULL) {
 849                 PMD_INIT_LOG(ERR, "Create FDIR hash handle fail!");
 850                 return -EINVAL;
 851         }
 852         fdir_info->hash_map = rte_zmalloc("hns3 FDIR hash",
 853                                           rule_num *
 854                                           sizeof(struct hns3_fdir_rule_ele *),
 855                                           0);
 856         if (fdir_info->hash_map == NULL) {
 857                 PMD_INIT_LOG(ERR, "Allocate memory for FDIR hash map fail!");
 858                 rte_hash_free(fdir_info->hash_handle);
 859                 return -ENOMEM;
 860         }
 861
 862         return 0;
 863 }
 864
 865 void hns3_fdir_filter_uninit(struct hns3_adapter *hns)
 866 {
 867         struct hns3_pf *pf = &hns->pf;
 868         struct hns3_fdir_info *fdir_info = &pf->fdir;
 869         struct hns3_fdir_rule_ele *fdir_filter;
 870
 871         if (fdir_info->hash_map) {
 872                 rte_free(fdir_info->hash_map);
 873                 fdir_info->hash_map = NULL;
 874         }
 875         if (fdir_info->hash_handle) {
 876                 rte_hash_free(fdir_info->hash_handle);
 877                 fdir_info->hash_handle = NULL;
 878         }
 879
 880         fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
 881         while (fdir_filter) {
 882                 TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries);
 883                 hns3_fd_tcam_config(&hns->hw, true,
 884                                     fdir_filter->fdir_conf.location, NULL,
 885                                     false);
 886                 rte_free(fdir_filter);
 887                 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
 888         }
 889 }
 890
 891 /*
 892  * Find a key in the hash table.
 893  * @return
 894  *   - Zero and positive values are key location.
 895  *   - -EINVAL if the parameters are invalid.
 896  *   - -ENOENT if the key is not found.
 897  */
 898 static int hns3_fdir_filter_lookup(struct hns3_fdir_info *fdir_info,
 899                                     struct hns3_fdir_key_conf *key)
 900 {
 901         hash_sig_t sig;
 902         int ret;
 903
 904         sig = rte_hash_crc(key, sizeof(*key), 0);
 905         ret = rte_hash_lookup_with_hash(fdir_info->hash_handle, key, sig);
 906
 907         return ret;
 908 }
 909
 910 static int hns3_insert_fdir_filter(struct hns3_hw *hw,
 911                                    struct hns3_fdir_info *fdir_info,
 912                                    struct hns3_fdir_rule_ele *fdir_filter)
 913 {
 914         struct hns3_fdir_key_conf *key;
 915         hash_sig_t sig;
 916         int ret;
 917
 918         key = &fdir_filter->fdir_conf.key_conf;
 919         sig = rte_hash_crc(key, sizeof(*key), 0);
 920         ret = rte_hash_add_key_with_hash(fdir_info->hash_handle, key, sig);
 921         if (ret < 0) {
 922                 hns3_err(hw, "Hash table full? err:%d(%s)!", ret,
 923                          strerror(-ret));
 924                 return ret;
 925         }
 926
 927         fdir_info->hash_map[ret] = fdir_filter;
 928         TAILQ_INSERT_TAIL(&fdir_info->fdir_list, fdir_filter, entries);
 929
 930         return ret;
 931 }
 932
 933 static int hns3_remove_fdir_filter(struct hns3_hw *hw,
 934                                    struct hns3_fdir_info *fdir_info,
 935                                    struct hns3_fdir_key_conf *key)
 936 {
 937         struct hns3_fdir_rule_ele *fdir_filter;
 938         hash_sig_t sig;
 939         int ret;
 940
 941         sig = rte_hash_crc(key, sizeof(*key), 0);
 942         ret = rte_hash_del_key_with_hash(fdir_info->hash_handle, key, sig);
 943         if (ret < 0) {
 944                 hns3_err(hw, "Delete hash key fail ret=%d", ret);
 945                 return ret;
 946         }
 947
 948         fdir_filter = fdir_info->hash_map[ret];
 949         fdir_info->hash_map[ret] = NULL;
 950         TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries);
 951
 952         rte_free(fdir_filter);
 953
 954         return 0;
 955 }
 956
 957 int hns3_fdir_filter_program(struct hns3_adapter *hns,
 958                              struct hns3_fdir_rule *rule, bool del)
 959 {
 960         struct hns3_pf *pf = &hns->pf;
 961         struct hns3_fdir_info *fdir_info = &pf->fdir;
 962         struct hns3_fdir_rule_ele *node;
 963         struct hns3_hw *hw = &hns->hw;
 964         int ret;
 965
 966         if (del) {
 967                 ret = hns3_fd_tcam_config(hw, true, rule->location, NULL,
 968                                           false);
 969                 if (ret)
 970                         hns3_err(hw, "Failed to delete fdir: %u src_ip:%x "
 971                                  "dst_ip:%x src_port:%u dst_port:%u ret = %d",
 972                                  rule->location,
 973                                  rule->key_conf.spec.src_ip[IP_ADDR_KEY_ID],
 974                                  rule->key_conf.spec.dst_ip[IP_ADDR_KEY_ID],
 975                                  rule->key_conf.spec.src_port,
 976                                  rule->key_conf.spec.dst_port, ret);
 977                 else
 978                         hns3_remove_fdir_filter(hw, fdir_info, &rule->key_conf);
 979
 980                 return ret;
 981         }
 982
 983         ret = hns3_fdir_filter_lookup(fdir_info, &rule->key_conf);
 984         if (ret >= 0) {
 985                 hns3_err(hw, "Conflict with existing fdir loc: %d", ret);
 986                 return -EINVAL;
 987         }
 988
 989         node = rte_zmalloc("hns3 fdir rule", sizeof(struct hns3_fdir_rule_ele),
 990                            0);
 991         if (node == NULL) {
 992                 hns3_err(hw, "Failed to allocate fdir_rule memory");
 993                 return -ENOMEM;
 994         }
 995
 996         rte_memcpy(&node->fdir_conf, rule, sizeof(struct hns3_fdir_rule));
 997         ret = hns3_insert_fdir_filter(hw, fdir_info, node);
 998         if (ret < 0) {
 999                 rte_free(node);
1000                 return ret;
1001         }
1002         rule->location = ret;
1003         node->fdir_conf.location = ret;
1004
1005         ret = hns3_config_action(hw, rule);
1006         if (!ret)
1007                 ret = hns3_config_key(hns, rule);
1008         if (ret) {
1009                 hns3_err(hw, "Failed to config fdir: %u src_ip:%x dst_ip:%x "
1010                          "src_port:%u dst_port:%u ret = %d",
1011                          rule->location,
1012                          rule->key_conf.spec.src_ip[IP_ADDR_KEY_ID],
1013                          rule->key_conf.spec.dst_ip[IP_ADDR_KEY_ID],
1014                          rule->key_conf.spec.src_port,
1015                          rule->key_conf.spec.dst_port, ret);
1016                 (void)hns3_remove_fdir_filter(hw, fdir_info, &rule->key_conf);
1017         }
1018
1019         return ret;
1020 }
1021
1022 /* remove all the flow director filters */
1023 int hns3_clear_all_fdir_filter(struct hns3_adapter *hns)
1024 {
1025         struct hns3_pf *pf = &hns->pf;
1026         struct hns3_fdir_info *fdir_info = &pf->fdir;
1027         struct hns3_fdir_rule_ele *fdir_filter;
1028         struct hns3_hw *hw = &hns->hw;
1029         int succ_cnt = 0;
1030         int fail_cnt = 0;
1031         int ret = 0;
1032
1033         /* flush flow director */
1034         rte_hash_reset(fdir_info->hash_handle);
1035
1036         fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
1037         while (fdir_filter) {
1038                 TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries);
1039                 ret = hns3_fd_tcam_config(hw, true,
1040                                           fdir_filter->fdir_conf.location,
1041                                           NULL, false);
1042                 if (ret == 0)
1043                         succ_cnt++;
1044                 else
1045                         fail_cnt++;
1046                 rte_free(fdir_filter);
1047                 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
1048         }
1049
1050         if (fail_cnt > 0) {
1051                 hns3_err(hw, "fail to delete all FDIR filter, success num = %d "
1052                          "fail num = %d", succ_cnt, fail_cnt);
1053                 ret = -EIO;
1054         }
1055
1056         return ret;
1057 }
1058
1059 int hns3_restore_all_fdir_filter(struct hns3_adapter *hns)
1060 {
1061         struct hns3_pf *pf = &hns->pf;
1062         struct hns3_fdir_info *fdir_info = &pf->fdir;
1063         struct hns3_fdir_rule_ele *fdir_filter;
1064         struct hns3_hw *hw = &hns->hw;
1065         bool err = false;
1066         int ret;
1067
1068         /*
1069          * This API is called in the reset recovery process, the parent function
1070          * must hold hw->lock.
1071          * There maybe deadlock if acquire hw->flows_lock directly because rte
1072          * flow driver ops first acquire hw->flows_lock and then may acquire
1073          * hw->lock.
1074          * So here first release the hw->lock and then acquire the
1075          * hw->flows_lock to avoid deadlock.
1076          */
1077         rte_spinlock_unlock(&hw->lock);
1078         pthread_mutex_lock(&hw->flows_lock);
1079         TAILQ_FOREACH(fdir_filter, &fdir_info->fdir_list, entries) {
1080                 ret = hns3_config_action(hw, &fdir_filter->fdir_conf);
1081                 if (!ret)
1082                         ret = hns3_config_key(hns, &fdir_filter->fdir_conf);
1083                 if (ret) {
1084                         err = true;
1085                         if (ret == -EBUSY)
1086                                 break;
1087                 }
1088         }
1089         pthread_mutex_unlock(&hw->flows_lock);
1090         rte_spinlock_lock(&hw->lock);
1091
1092         if (err) {
1093                 hns3_err(hw, "Fail to restore FDIR filter, ret = %d", ret);
1094                 return -EIO;
1095         }
1096         return 0;
1097 }
1098
1099 int hns3_get_count(struct hns3_hw *hw, uint32_t id, uint64_t *value)
1100 {
1101         struct hns3_fd_get_cnt_cmd *req;
1102         struct hns3_cmd_desc desc;
1103         int ret;
1104
1105         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_COUNTER_OP, true);
1106
1107         req = (struct hns3_fd_get_cnt_cmd *)desc.data;
1108         req->stage = HNS3_FD_STAGE_1;
1109         req->index = rte_cpu_to_le_32(id);
1110
1111         ret = hns3_cmd_send(hw, &desc, 1);
1112         if (ret) {
1113                 hns3_err(hw, "Read counter fail, ret=%d", ret);
1114                 return ret;
1115         }
1116
1117         *value = req->value;
1118
1119         return ret;
1120 }