1
2
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
51enum HNS3_PORT_TYPE {
52 HOST_PORT,
53 NETWORK_PORT
54};
55
56enum 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
63enum HNS3_FD_KEY_TYPE {
64 HNS3_FD_KEY_BASE_ON_PTYPE,
65 HNS3_FD_KEY_BASE_ON_TUPLE,
66};
67
68enum 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
80struct key_info {
81 uint8_t key_type;
82 uint8_t key_length;
83};
84
85static 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
96static 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
135enum HNS3_FD_PACKET_TYPE {
136 NIC_PACKET,
137 ROCE_PACKET,
138};
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158#define calc_x(x, k, v) ((x) = (~(k) & (v)))
159#define calc_y(y, k, v) ((y) = ((k) & (v)))
160
161struct 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
172struct hns3_fd_tcam_config_2_cmd {
173 uint8_t tcam_data[24];
174};
175
176struct hns3_fd_tcam_config_3_cmd {
177 uint8_t tcam_data[20];
178 uint8_t rsv[4];
179};
180
181struct hns3_get_fd_mode_cmd {
182 uint8_t mode;
183 uint8_t enable;
184 uint8_t rsv[22];
185};
186
187struct 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
195struct 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
208struct 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
216struct 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
225static 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
246static 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
274static 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
303int 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
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
356
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
380static 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
427static 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
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
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
478static 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
491static 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
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
542static 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
554static 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
639static 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
650static 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
712
713
714
715static 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
772static 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
809static 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
823int 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
865void 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
893
894
895
896
897
898static 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
910static 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
933static 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
957int 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
1023int 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
1034 rte_hash_reset(fdir_info->hash_handle);
1035
1036 memset(fdir_info->hash_map, 0,
1037 sizeof(struct hns3_fdir_rule_ele *) *
1038 fdir_info->fd_cfg.rule_num[HNS3_FD_STAGE_1]);
1039
1040 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
1041 while (fdir_filter) {
1042 TAILQ_REMOVE(&fdir_info->fdir_list, fdir_filter, entries);
1043 ret = hns3_fd_tcam_config(hw, true,
1044 fdir_filter->fdir_conf.location,
1045 NULL, false);
1046 if (ret == 0)
1047 succ_cnt++;
1048 else
1049 fail_cnt++;
1050 rte_free(fdir_filter);
1051 fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list);
1052 }
1053
1054 if (fail_cnt > 0) {
1055 hns3_err(hw, "fail to delete all FDIR filter, success num = %d "
1056 "fail num = %d", succ_cnt, fail_cnt);
1057 ret = -EIO;
1058 }
1059
1060 return ret;
1061}
1062
1063int hns3_restore_all_fdir_filter(struct hns3_adapter *hns)
1064{
1065 struct hns3_pf *pf = &hns->pf;
1066 struct hns3_fdir_info *fdir_info = &pf->fdir;
1067 struct hns3_fdir_rule_ele *fdir_filter;
1068 struct hns3_hw *hw = &hns->hw;
1069 bool err = false;
1070 int ret;
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081 rte_spinlock_unlock(&hw->lock);
1082 pthread_mutex_lock(&hw->flows_lock);
1083 TAILQ_FOREACH(fdir_filter, &fdir_info->fdir_list, entries) {
1084 ret = hns3_config_action(hw, &fdir_filter->fdir_conf);
1085 if (!ret)
1086 ret = hns3_config_key(hns, &fdir_filter->fdir_conf);
1087 if (ret) {
1088 err = true;
1089 if (ret == -EBUSY)
1090 break;
1091 }
1092 }
1093 pthread_mutex_unlock(&hw->flows_lock);
1094 rte_spinlock_lock(&hw->lock);
1095
1096 if (err) {
1097 hns3_err(hw, "Fail to restore FDIR filter, ret = %d", ret);
1098 return -EIO;
1099 }
1100 return 0;
1101}
1102
1103int hns3_get_count(struct hns3_hw *hw, uint32_t id, uint64_t *value)
1104{
1105 struct hns3_fd_get_cnt_cmd *req;
1106 struct hns3_cmd_desc desc;
1107 int ret;
1108
1109 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_FD_COUNTER_OP, true);
1110
1111 req = (struct hns3_fd_get_cnt_cmd *)desc.data;
1112 req->stage = HNS3_FD_STAGE_1;
1113 req->index = rte_cpu_to_le_32(id);
1114
1115 ret = hns3_cmd_send(hw, &desc, 1);
1116 if (ret) {
1117 hns3_err(hw, "Read counter fail, ret=%d", ret);
1118 return ret;
1119 }
1120
1121 *value = req->value;
1122
1123 return ret;
1124}
1125
