1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018-2019 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 340 /* If use max 400bit key, we can support tuples for ether type */ 341 if (pf->fdir.fd_cfg.max_key_length == MAX_KEY_LENGTH) { 342 key_cfg->tuple_active |= 343 BIT(INNER_DST_MAC) | BIT(INNER_SRC_MAC) | 344 BIT(OUTER_SRC_PORT) | BIT(INNER_SCTP_TAG) | 345 BIT(OUTER_DST_PORT) | BIT(INNER_VLAN_TAG2) | 346 BIT(OUTER_TUN_VNI) | BIT(OUTER_TUN_FLOW_ID) | 347 BIT(OUTER_ETH_TYPE) | BIT(OUTER_IP_PROTO); 348 } 349 350 /* roce_type is used to filter roce frames 351 * dst_vport is used to specify the rule 352 */ 353 key_cfg->meta_data_active = BIT(DST_VPORT) | BIT(TUNNEL_PACKET) | 354 BIT(VLAN_NUMBER); 355 356 ret = hns3_get_fd_allocation(hw, 357 &pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_1], 358 &pf->fdir.fd_cfg.rule_num[HNS3_FD_STAGE_2], 359 &pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_1], 360 &pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_2]); 361 if (ret) 362 return ret; 363 364 return hns3_set_fd_key_config(hns); 365 } 366 367 static int hns3_fd_tcam_config(struct hns3_hw *hw, bool sel_x, int loc, 368 uint8_t *key, bool is_add) 369 { 370 #define FD_TCAM_CMD_NUM 3 371 struct hns3_fd_tcam_config_1_cmd *req1; 372 struct hns3_fd_tcam_config_2_cmd *req2; 373 struct hns3_fd_tcam_config_3_cmd *req3; 374 struct hns3_cmd_desc desc[FD_TCAM_CMD_NUM]; 375 int len; 376 int ret; 377 378 hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_FD_TCAM_OP, false); 379 desc[0].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); 380 hns3_cmd_setup_basic_desc(&desc[1], HNS3_OPC_FD_TCAM_OP, false); 381 desc[1].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); 382 hns3_cmd_setup_basic_desc(&desc[2], HNS3_OPC_FD_TCAM_OP, false); 383 384 req1 = (struct hns3_fd_tcam_config_1_cmd *)desc[0].data; 385 req2 = (struct hns3_fd_tcam_config_2_cmd *)desc[1].data; 386 req3 = (struct hns3_fd_tcam_config_3_cmd *)desc[2].data; 387 388 req1->stage = HNS3_FD_STAGE_1; 389 req1->xy_sel = sel_x ? 1 : 0; 390 hns3_set_bit(req1->port_info, HNS3_FD_EPORT_SW_EN_B, 0); 391 req1->index = rte_cpu_to_le_32(loc); 392 req1->entry_vld = sel_x ? is_add : 0; 393 394 if (key) { 395 len = sizeof(req1->tcam_data); 396 memcpy(req1->tcam_data, key, len); 397 key += len; 398 399 len = sizeof(req2->tcam_data); 400 memcpy(req2->tcam_data, key, len); 401 key += len; 402 403 len = sizeof(req3->tcam_data); 404 memcpy(req3->tcam_data, key, len); 405 } 406 407 ret = hns3_cmd_send(hw, desc, FD_TCAM_CMD_NUM); 408 if (ret) 409 hns3_err(hw, "Config tcam key fail, ret=%d loc=%d add=%d", 410 ret, loc, is_add); 411 return ret; 412 } 413 414 static int hns3_fd_ad_config(struct hns3_hw *hw, int loc, 415 struct hns3_fd_ad_data *action) 416 { 417 struct hns3_fd_ad_config_cmd *req; 418 struct hns3_cmd_desc desc; 419 uint64_t ad_data = 0; 420 int ret; 421 422 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_AD_OP, false); 423 424 req = (struct hns3_fd_ad_config_cmd *)desc.data; 425 req->index = rte_cpu_to_le_32(loc); 426 req->stage = HNS3_FD_STAGE_1; 427 428 hns3_set_bit(ad_data, HNS3_FD_AD_WR_RULE_ID_B, 429 action->write_rule_id_to_bd); 430 hns3_set_field(ad_data, HNS3_FD_AD_RULE_ID_M, HNS3_FD_AD_RULE_ID_S, 431 action->rule_id); 432 if (action->nb_queues > 1) { 433 hns3_set_bit(ad_data, HNS3_FD_AD_QUEUE_REGION_EN_B, 1); 434 hns3_set_field(ad_data, HNS3_FD_AD_QUEUE_REGION_SIZE_M, 435 HNS3_FD_AD_QUEUE_REGION_SIZE_S, 436 rte_log2_u32(action->nb_queues)); 437 } 438 /* set extend bit if counter_id is in [128 ~ 255] */ 439 if (action->counter_id & BIT(HNS3_FD_AD_COUNTER_HIGH_BIT)) 440 hns3_set_bit(ad_data, HNS3_FD_AD_COUNTER_HIGH_BIT_B, 1); 441 /* set extend bit if queue id > 1024 */ 442 if (action->queue_id & BIT(HNS3_FD_AD_QUEUE_ID_HIGH_BIT)) 443 hns3_set_bit(ad_data, HNS3_FD_AD_QUEUE_ID_HIGH_BIT_B, 1); 444 ad_data <<= HNS3_FD_AD_DATA_S; 445 hns3_set_bit(ad_data, HNS3_FD_AD_DROP_B, action->drop_packet); 446 if (action->nb_queues == 1) 447 hns3_set_bit(ad_data, HNS3_FD_AD_DIRECT_QID_B, 1); 448 hns3_set_field(ad_data, HNS3_FD_AD_QID_M, HNS3_FD_AD_QID_S, 449 action->queue_id); 450 hns3_set_bit(ad_data, HNS3_FD_AD_USE_COUNTER_B, action->use_counter); 451 hns3_set_field(ad_data, HNS3_FD_AD_COUNTER_NUM_M, 452 HNS3_FD_AD_COUNTER_NUM_S, action->counter_id); 453 hns3_set_bit(ad_data, HNS3_FD_AD_NXT_STEP_B, action->use_next_stage); 454 hns3_set_field(ad_data, HNS3_FD_AD_NXT_KEY_M, HNS3_FD_AD_NXT_KEY_S, 455 action->next_input_key); 456 457 req->ad_data = rte_cpu_to_le_64(ad_data); 458 ret = hns3_cmd_send(hw, &desc, 1); 459 if (ret) 460 hns3_err(hw, "Config fd ad fail, ret=%d loc=%d", ret, loc); 461 462 return ret; 463 } 464 465 static inline void hns3_fd_convert_mac(uint8_t *key, uint8_t *mask, 466 uint8_t *mac_x, uint8_t *mac_y) 467 { 468 uint8_t tmp; 469 int i; 470 471 for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) { 472 tmp = RTE_ETHER_ADDR_LEN - 1 - i; 473 calc_x(mac_x[tmp], key[i], mask[i]); 474 calc_y(mac_y[tmp], key[i], mask[i]); 475 } 476 } 477 478 static void hns3_fd_convert_int16(uint32_t tuple, struct hns3_fdir_rule *rule, 479 uint8_t *val_x, uint8_t *val_y) 480 { 481 uint16_t tmp_x_s; 482 uint16_t tmp_y_s; 483 uint16_t mask; 484 uint16_t key; 485 486 switch (tuple) { 487 case OUTER_SRC_PORT: 488 key = rule->key_conf.spec.outer_src_port; 489 mask = rule->key_conf.mask.outer_src_port; 490 break; 491 case OUTER_DST_PORT: 492 key = rule->key_conf.spec.tunnel_type; 493 mask = rule->key_conf.mask.tunnel_type; 494 break; 495 case OUTER_ETH_TYPE: 496 key = rule->key_conf.spec.outer_ether_type; 497 mask = rule->key_conf.mask.outer_ether_type; 498 break; 499 case INNER_SRC_PORT: 500 key = rule->key_conf.spec.src_port; 501 mask = rule->key_conf.mask.src_port; 502 break; 503 case INNER_DST_PORT: 504 key = rule->key_conf.spec.dst_port; 505 mask = rule->key_conf.mask.dst_port; 506 break; 507 case INNER_VLAN_TAG1: 508 key = rule->key_conf.spec.vlan_tag1; 509 mask = rule->key_conf.mask.vlan_tag1; 510 break; 511 case INNER_VLAN_TAG2: 512 key = rule->key_conf.spec.vlan_tag2; 513 mask = rule->key_conf.mask.vlan_tag2; 514 break; 515 default: 516 /* INNER_ETH_TYPE: */ 517 key = rule->key_conf.spec.ether_type; 518 mask = rule->key_conf.mask.ether_type; 519 break; 520 } 521 calc_x(tmp_x_s, key, mask); 522 calc_y(tmp_y_s, key, mask); 523 val_x[0] = rte_cpu_to_le_16(tmp_x_s) & 0xFF; 524 val_x[1] = rte_cpu_to_le_16(tmp_x_s) >> HNS3_BITS_PER_BYTE; 525 val_y[0] = rte_cpu_to_le_16(tmp_y_s) & 0xFF; 526 val_y[1] = rte_cpu_to_le_16(tmp_y_s) >> HNS3_BITS_PER_BYTE; 527 } 528 529 static inline void hns3_fd_convert_int32(uint32_t key, uint32_t mask, 530 uint8_t *val_x, uint8_t *val_y) 531 { 532 uint32_t tmp_x_l; 533 uint32_t tmp_y_l; 534 535 calc_x(tmp_x_l, key, mask); 536 calc_y(tmp_y_l, key, mask); 537 memcpy(val_x, &tmp_x_l, sizeof(tmp_x_l)); 538 memcpy(val_y, &tmp_y_l, sizeof(tmp_y_l)); 539 } 540 541 static bool hns3_fd_convert_tuple(struct hns3_hw *hw, 542 uint32_t tuple, uint8_t *key_x, 543 uint8_t *key_y, struct hns3_fdir_rule *rule) 544 { 545 struct hns3_fdir_key_conf *key_conf; 546 int tmp; 547 int i; 548 549 if ((rule->input_set & BIT(tuple)) == 0) 550 return true; 551 552 key_conf = &rule->key_conf; 553 switch (tuple) { 554 case INNER_DST_MAC: 555 hns3_fd_convert_mac(key_conf->spec.dst_mac, 556 key_conf->mask.dst_mac, key_x, key_y); 557 break; 558 case INNER_SRC_MAC: 559 hns3_fd_convert_mac(key_conf->spec.src_mac, 560 key_conf->mask.src_mac, key_x, key_y); 561 break; 562 case OUTER_SRC_PORT: 563 case OUTER_DST_PORT: 564 case OUTER_ETH_TYPE: 565 case INNER_SRC_PORT: 566 case INNER_DST_PORT: 567 case INNER_VLAN_TAG1: 568 case INNER_VLAN_TAG2: 569 case INNER_ETH_TYPE: 570 hns3_fd_convert_int16(tuple, rule, key_x, key_y); 571 break; 572 case INNER_SRC_IP: 573 hns3_fd_convert_int32(key_conf->spec.src_ip[IP_ADDR_KEY_ID], 574 key_conf->mask.src_ip[IP_ADDR_KEY_ID], 575 key_x, key_y); 576 break; 577 case INNER_DST_IP: 578 hns3_fd_convert_int32(key_conf->spec.dst_ip[IP_ADDR_KEY_ID], 579 key_conf->mask.dst_ip[IP_ADDR_KEY_ID], 580 key_x, key_y); 581 break; 582 case INNER_SCTP_TAG: 583 hns3_fd_convert_int32(key_conf->spec.sctp_tag, 584 key_conf->mask.sctp_tag, key_x, key_y); 585 break; 586 case OUTER_TUN_VNI: 587 for (i = 0; i < VNI_OR_TNI_LEN; i++) { 588 tmp = VNI_OR_TNI_LEN - 1 - i; 589 calc_x(key_x[tmp], 590 key_conf->spec.outer_tun_vni[i], 591 key_conf->mask.outer_tun_vni[i]); 592 calc_y(key_y[tmp], 593 key_conf->spec.outer_tun_vni[i], 594 key_conf->mask.outer_tun_vni[i]); 595 } 596 break; 597 case OUTER_TUN_FLOW_ID: 598 calc_x(*key_x, key_conf->spec.outer_tun_flow_id, 599 key_conf->mask.outer_tun_flow_id); 600 calc_y(*key_y, key_conf->spec.outer_tun_flow_id, 601 key_conf->mask.outer_tun_flow_id); 602 break; 603 case INNER_IP_TOS: 604 calc_x(*key_x, key_conf->spec.ip_tos, key_conf->mask.ip_tos); 605 calc_y(*key_y, key_conf->spec.ip_tos, key_conf->mask.ip_tos); 606 break; 607 case OUTER_IP_PROTO: 608 calc_x(*key_x, key_conf->spec.outer_proto, 609 key_conf->mask.outer_proto); 610 calc_y(*key_y, key_conf->spec.outer_proto, 611 key_conf->mask.outer_proto); 612 break; 613 case INNER_IP_PROTO: 614 calc_x(*key_x, key_conf->spec.ip_proto, 615 key_conf->mask.ip_proto); 616 calc_y(*key_y, key_conf->spec.ip_proto, 617 key_conf->mask.ip_proto); 618 break; 619 default: 620 hns3_warn(hw, "not support tuple of (%u)", tuple); 621 break; 622 } 623 return true; 624 } 625 626 static uint32_t hns3_get_port_number(uint8_t pf_id, uint8_t vf_id) 627 { 628 uint32_t port_number = 0; 629 630 hns3_set_field(port_number, HNS3_PF_ID_M, HNS3_PF_ID_S, pf_id); 631 hns3_set_field(port_number, HNS3_VF_ID_M, HNS3_VF_ID_S, vf_id); 632 hns3_set_bit(port_number, HNS3_PORT_TYPE_B, HOST_PORT); 633 634 return port_number; 635 } 636 637 static void hns3_fd_convert_meta_data(struct hns3_fd_key_cfg *cfg, 638 uint8_t vf_id, 639 struct hns3_fdir_rule *rule, 640 uint8_t *key_x, uint8_t *key_y) 641 { 642 uint16_t meta_data = 0; 643 uint32_t port_number; 644 uint8_t cur_pos = 0; 645 uint8_t tuple_size; 646 uint8_t shift_bits; 647 uint32_t tmp_x; 648 uint32_t tmp_y; 649 uint8_t i; 650 651 for (i = 0; i < MAX_META_DATA; i++) { 652 if ((cfg->meta_data_active & BIT(i)) == 0) 653 continue; 654 655 tuple_size = meta_data_key_info[i].key_length; 656 if (i == TUNNEL_PACKET) { 657 hns3_set_bit(meta_data, cur_pos, 658 rule->key_conf.spec.tunnel_type ? 1 : 0); 659 cur_pos += tuple_size; 660 } else if (i == VLAN_NUMBER) { 661 uint32_t vlan_tag; 662 uint8_t vlan_num; 663 if (rule->key_conf.spec.tunnel_type == 0) 664 vlan_num = rule->key_conf.vlan_num; 665 else 666 vlan_num = rule->key_conf.outer_vlan_num; 667 if (vlan_num == 1) 668 vlan_tag = HNS3_VLAN_TAG_TYPE_TAG1; 669 else if (vlan_num == VLAN_TAG_NUM_MAX) 670 vlan_tag = HNS3_VLAN_TAG_TYPE_TAG1_2; 671 else 672 vlan_tag = HNS3_VLAN_TAG_TYPE_NONE; 673 hns3_set_field(meta_data, 674 GENMASK(cur_pos + tuple_size, 675 cur_pos), cur_pos, vlan_tag); 676 cur_pos += tuple_size; 677 } else if (i == DST_VPORT) { 678 port_number = hns3_get_port_number(0, vf_id); 679 hns3_set_field(meta_data, 680 GENMASK(cur_pos + tuple_size, cur_pos), 681 cur_pos, port_number); 682 cur_pos += tuple_size; 683 } 684 } 685 686 calc_x(tmp_x, meta_data, 0xFFFF); 687 calc_y(tmp_y, meta_data, 0xFFFF); 688 shift_bits = sizeof(meta_data) * HNS3_BITS_PER_BYTE - cur_pos; 689 690 tmp_x = rte_cpu_to_le_32(tmp_x << shift_bits); 691 tmp_y = rte_cpu_to_le_32(tmp_y << shift_bits); 692 key_x[0] = tmp_x & 0xFF; 693 key_x[1] = (tmp_x >> HNS3_BITS_PER_BYTE) & 0xFF; 694 key_y[0] = tmp_y & 0xFF; 695 key_y[1] = (tmp_y >> HNS3_BITS_PER_BYTE) & 0xFF; 696 } 697 698 /* A complete key is combined with meta data key and tuple key. 699 * Meta data key is stored at the MSB region, and tuple key is stored at 700 * the LSB region, unused bits will be filled 0. 701 */ 702 static int hns3_config_key(struct hns3_adapter *hns, 703 struct hns3_fdir_rule *rule) 704 { 705 struct hns3_pf *pf = &hns->pf; 706 struct hns3_hw *hw = &hns->hw; 707 struct hns3_fd_key_cfg *key_cfg; 708 uint8_t *cur_key_x; 709 uint8_t *cur_key_y; 710 uint8_t key_x[MAX_KEY_BYTES] __rte_aligned(4); 711 uint8_t key_y[MAX_KEY_BYTES] __rte_aligned(4); 712 uint8_t vf_id = rule->vf_id; 713 uint8_t meta_data_region; 714 uint8_t tuple_size; 715 uint8_t i; 716 int ret; 717 718 memset(key_x, 0, sizeof(key_x)); 719 memset(key_y, 0, sizeof(key_y)); 720 cur_key_x = key_x; 721 cur_key_y = key_y; 722 723 key_cfg = &pf->fdir.fd_cfg.key_cfg[HNS3_FD_STAGE_1]; 724 for (i = 0; i < MAX_TUPLE; i++) { 725 bool tuple_valid; 726 727 tuple_size = tuple_key_info[i].key_length / HNS3_BITS_PER_BYTE; 728 if (key_cfg->tuple_active & BIT(i)) { 729 tuple_valid = hns3_fd_convert_tuple(hw, i, cur_key_x, 730 cur_key_y, rule); 731 if (tuple_valid) { 732 cur_key_x += tuple_size; 733 cur_key_y += tuple_size; 734 } 735 } 736 } 737 738 meta_data_region = pf->fdir.fd_cfg.max_key_length / HNS3_BITS_PER_BYTE - 739 MAX_META_DATA_LENGTH / HNS3_BITS_PER_BYTE; 740 741 hns3_fd_convert_meta_data(key_cfg, vf_id, rule, 742 key_x + meta_data_region, 743 key_y + meta_data_region); 744 745 ret = hns3_fd_tcam_config(hw, false, rule->location, key_y, true); 746 if (ret) { 747 hns3_err(hw, "Config fd key_y fail, loc=%u, ret=%d", 748 rule->queue_id, ret); 749 return ret; 750 } 751 752 ret = hns3_fd_tcam_config(hw, true, rule->location, key_x, true); 753 if (ret) 754 hns3_err(hw, "Config fd key_x fail, loc=%u, ret=%d", 755 rule->queue_id, ret); 756 return ret; 757 } 758 759 static int hns3_config_action(struct hns3_hw *hw, struct hns3_fdir_rule *rule) 760 { 761 struct hns3_fd_ad_data ad_data; 762 763 ad_data.ad_id = rule->location; 764 765 if (rule->action == HNS3_FD_ACTION_DROP_PACKET) { 766 ad_data.drop_packet = true; 767 ad_data.queue_id = 0; 768 ad_data.nb_queues = 0; 769 } else { 770 ad_data.drop_packet = false; 771 ad_data.queue_id = rule->queue_id; 772 ad_data.nb_queues = rule->nb_queues; 773 } 774 775 if (unlikely(rule->flags & HNS3_RULE_FLAG_COUNTER)) { 776 ad_data.use_counter = true; 777 ad_data.counter_id = rule->act_cnt.id; 778 } else { 779 ad_data.use_counter = false; 780 ad_data.counter_id = 0; 781 } 782 783 if (unlikely(rule->flags & HNS3_RULE_FLAG_FDID)) 784 ad_data.rule_id = rule->fd_id; 785 else 786 ad_data.rule_id = rule->location; 787 788 ad_data.use_next_stage = false; 789 ad_data.next_input_key = 0; 790 791 ad_data.write_rule_id_to_bd = true; 792 793 return hns3_fd_ad_config(hw, ad_data.ad_id, &ad_data); 794 } 795 796 static int hns3_fd_clear_all_rules(struct hns3_hw *hw, uint32_t rule_num) 797 { 798 uint32_t i; 799 int ret; 800 801 for (i = 0; i < rule_num; i++) { 802 ret = hns3_fd_tcam_config(hw, true, i, NULL, false); 803 if (ret) 804 return ret; 805 } 806 807 return 0; 808 } 809 810 int hns3_fdir_filter_init(struct hns3_adapter *hns) 811 { 812 struct hns3_pf *pf = &hns->pf; 813 struct hns3_fdir_info *fdir_info = &pf->fdir; 814 uint32_t rule_num = fdir_info->fd_cfg.rule_num[HNS3_FD_STAGE_1]; 815 char fdir_hash_name[RTE_HASH_NAMESIZE]; 816 struct rte_hash_parameters fdir_hash_params = { 817 .name = fdir_hash_name, 818 .entries = rule_num, 819 .key_len = sizeof(struct hns3_fdir_key_conf), 820 .hash_func = rte_hash_crc, 821 .hash_func_init_val = 0, 822 }; 823 int ret; 824 825 ret = hns3_fd_clear_all_rules(&hns->hw, rule_num); 826 if (ret) { 827 PMD_INIT_LOG(ERR, "Clear all fd rules fail! ret = %d", ret); 828 return ret; 829 } 830 831 fdir_hash_params.socket_id = rte_socket_id(); 832 TAILQ_INIT(&fdir_info->fdir_list); 833 rte_spinlock_init(&fdir_info->flows_lock); 834 snprintf(fdir_hash_name, RTE_HASH_NAMESIZE, "%s", hns->hw.data->name); 835 fdir_info->hash_handle = rte_hash_create(&fdir_hash_params); 836 if (fdir_info->hash_handle == NULL) { 837 PMD_INIT_LOG(ERR, "Create FDIR hash handle fail!"); 838 return -EINVAL; 839 } 840 fdir_info->hash_map = rte_zmalloc("hns3 FDIR hash", 841 rule_num * 842 sizeof(struct hns3_fdir_rule_ele *), 843 0); 844 if (fdir_info->hash_map == NULL) { 845 PMD_INIT_LOG(ERR, "Allocate memory for FDIR hash map fail!"); 846 rte_hash_free(fdir_info->hash_handle); 847 return -ENOMEM; 848 } 849 850 return 0; 851 } 852 853 void hns3_fdir_filter_uninit(struct hns3_adapter *hns) 854 { 855 struct hns3_pf *pf = &hns->pf; 856 struct hns3_fdir_info *fdir_info = &pf->fdir; 857 struct hns3_fdir_rule_ele *fdir_filter; 858 859 rte_spinlock_lock(&fdir_info->flows_lock); 860 if (fdir_info->hash_map) { 861 rte_free(fdir_info->hash_map); 862 fdir_info->hash_map = NULL; 863 } 864 if (fdir_info->hash_handle) { 865 rte_hash_free(fdir_info->hash_handle); 866 fdir_info->hash_handle = NULL; 867 } 868 rte_spinlock_unlock(&fdir_info->flows_lock); 869 870 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list); 871 while (fdir_filter) { 872 TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries); 873 hns3_fd_tcam_config(&hns->hw, true, 874 fdir_filter->fdir_conf.location, NULL, 875 false); 876 rte_free(fdir_filter); 877 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list); 878 } 879 } 880 881 /* 882 * Find a key in the hash table. 883 * @return 884 * - Zero and positive values are key location. 885 * - -EINVAL if the parameters are invalid. 886 * - -ENOENT if the key is not found. 887 */ 888 static int hns3_fdir_filter_lookup(struct hns3_fdir_info *fdir_info, 889 struct hns3_fdir_key_conf *key) 890 { 891 hash_sig_t sig; 892 int ret; 893 894 rte_spinlock_lock(&fdir_info->flows_lock); 895 sig = rte_hash_crc(key, sizeof(*key), 0); 896 ret = rte_hash_lookup_with_hash(fdir_info->hash_handle, key, sig); 897 rte_spinlock_unlock(&fdir_info->flows_lock); 898 899 return ret; 900 } 901 902 static int hns3_insert_fdir_filter(struct hns3_hw *hw, 903 struct hns3_fdir_info *fdir_info, 904 struct hns3_fdir_rule_ele *fdir_filter) 905 { 906 struct hns3_fdir_key_conf *key; 907 hash_sig_t sig; 908 int ret; 909 910 key = &fdir_filter->fdir_conf.key_conf; 911 rte_spinlock_lock(&fdir_info->flows_lock); 912 sig = rte_hash_crc(key, sizeof(*key), 0); 913 ret = rte_hash_add_key_with_hash(fdir_info->hash_handle, key, sig); 914 if (ret < 0) { 915 rte_spinlock_unlock(&fdir_info->flows_lock); 916 hns3_err(hw, "Hash table full? err:%d(%s)!", ret, 917 strerror(-ret)); 918 return ret; 919 } 920 921 fdir_info->hash_map[ret] = fdir_filter; 922 TAILQ_INSERT_TAIL(&fdir_info->fdir_list, fdir_filter, entries); 923 rte_spinlock_unlock(&fdir_info->flows_lock); 924 925 return ret; 926 } 927 928 static int hns3_remove_fdir_filter(struct hns3_hw *hw, 929 struct hns3_fdir_info *fdir_info, 930 struct hns3_fdir_key_conf *key) 931 { 932 struct hns3_fdir_rule_ele *fdir_filter; 933 hash_sig_t sig; 934 int ret; 935 936 rte_spinlock_lock(&fdir_info->flows_lock); 937 sig = rte_hash_crc(key, sizeof(*key), 0); 938 ret = rte_hash_del_key_with_hash(fdir_info->hash_handle, key, sig); 939 if (ret < 0) { 940 rte_spinlock_unlock(&fdir_info->flows_lock); 941 hns3_err(hw, "Delete hash key fail ret=%d", ret); 942 return ret; 943 } 944 945 fdir_filter = fdir_info->hash_map[ret]; 946 fdir_info->hash_map[ret] = NULL; 947 TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries); 948 rte_spinlock_unlock(&fdir_info->flows_lock); 949 950 rte_free(fdir_filter); 951 952 return 0; 953 } 954 955 int hns3_fdir_filter_program(struct hns3_adapter *hns, 956 struct hns3_fdir_rule *rule, bool del) 957 { 958 struct hns3_pf *pf = &hns->pf; 959 struct hns3_fdir_info *fdir_info = &pf->fdir; 960 struct hns3_fdir_rule_ele *node; 961 struct hns3_hw *hw = &hns->hw; 962 int ret; 963 964 if (del) { 965 ret = hns3_fd_tcam_config(hw, true, rule->location, NULL, 966 false); 967 if (ret) 968 hns3_err(hw, "Failed to delete fdir: %u src_ip:%x " 969 "dst_ip:%x src_port:%u dst_port:%u ret = %d", 970 rule->location, 971 rule->key_conf.spec.src_ip[IP_ADDR_KEY_ID], 972 rule->key_conf.spec.dst_ip[IP_ADDR_KEY_ID], 973 rule->key_conf.spec.src_port, 974 rule->key_conf.spec.dst_port, ret); 975 else 976 hns3_remove_fdir_filter(hw, fdir_info, &rule->key_conf); 977 978 return ret; 979 } 980 981 ret = hns3_fdir_filter_lookup(fdir_info, &rule->key_conf); 982 if (ret >= 0) { 983 hns3_err(hw, "Conflict with existing fdir loc: %d", ret); 984 return -EINVAL; 985 } 986 987 node = rte_zmalloc("hns3 fdir rule", sizeof(struct hns3_fdir_rule_ele), 988 0); 989 if (node == NULL) { 990 hns3_err(hw, "Failed to allocate fdir_rule memory"); 991 return -ENOMEM; 992 } 993 994 rte_memcpy(&node->fdir_conf, rule, sizeof(struct hns3_fdir_rule)); 995 ret = hns3_insert_fdir_filter(hw, fdir_info, node); 996 if (ret < 0) { 997 rte_free(node); 998 return ret; 999 } 1000 rule->location = ret; 1001 node->fdir_conf.location = ret; 1002 1003 rte_spinlock_lock(&fdir_info->flows_lock); 1004 ret = hns3_config_action(hw, rule); 1005 if (!ret) 1006 ret = hns3_config_key(hns, rule); 1007 rte_spinlock_unlock(&fdir_info->flows_lock); 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 ret = 0; 1030 1031 /* flush flow director */ 1032 rte_spinlock_lock(&fdir_info->flows_lock); 1033 rte_hash_reset(fdir_info->hash_handle); 1034 rte_spinlock_unlock(&fdir_info->flows_lock); 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 rte_free(fdir_filter); 1043 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list); 1044 } 1045 1046 if (ret) { 1047 hns3_err(hw, "Fail to delete FDIR filter, ret = %d", ret); 1048 ret = -EIO; 1049 } 1050 return ret; 1051 } 1052 1053 int hns3_restore_all_fdir_filter(struct hns3_adapter *hns) 1054 { 1055 struct hns3_pf *pf = &hns->pf; 1056 struct hns3_fdir_info *fdir_info = &pf->fdir; 1057 struct hns3_fdir_rule_ele *fdir_filter; 1058 struct hns3_hw *hw = &hns->hw; 1059 bool err = false; 1060 int ret; 1061 1062 TAILQ_FOREACH(fdir_filter, &fdir_info->fdir_list, entries) { 1063 ret = hns3_config_action(hw, &fdir_filter->fdir_conf); 1064 if (!ret) 1065 ret = hns3_config_key(hns, &fdir_filter->fdir_conf); 1066 if (ret) { 1067 err = true; 1068 if (ret == -EBUSY) 1069 break; 1070 } 1071 } 1072 1073 if (err) { 1074 hns3_err(hw, "Fail to restore FDIR filter, ret = %d", ret); 1075 return -EIO; 1076 } 1077 return 0; 1078 } 1079 1080 int hns3_get_count(struct hns3_hw *hw, uint32_t id, uint64_t *value) 1081 { 1082 struct hns3_fd_get_cnt_cmd *req; 1083 struct hns3_cmd_desc desc; 1084 int ret; 1085 1086 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_COUNTER_OP, true); 1087 1088 req = (struct hns3_fd_get_cnt_cmd *)desc.data; 1089 req->stage = HNS3_FD_STAGE_1; 1090 req->index = rte_cpu_to_le_32(id); 1091 1092 ret = hns3_cmd_send(hw, &desc, 1); 1093 if (ret) { 1094 hns3_err(hw, "Read counter fail, ret=%d", ret); 1095 return ret; 1096 } 1097 1098 *value = req->value; 1099 1100 return ret; 1101 } 1102