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