1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Huawei Technologies Co., Ltd
5 #include "hinic_compat.h"
6 #include "hinic_pmd_hwdev.h"
7 #include "hinic_pmd_hwif.h"
8 #include "hinic_pmd_eqs.h"
9 #include "hinic_pmd_wq.h"
10 #include "hinic_pmd_mgmt.h"
11 #include "hinic_pmd_cmdq.h"
12 #include "hinic_pmd_niccfg.h"
13 #include "hinic_pmd_mbox.h"
15 #define l2nic_msg_to_mgmt_sync(hwdev, cmd, buf_in, \
16 in_size, buf_out, out_size) \
17 hinic_msg_to_mgmt_sync(hwdev, HINIC_MOD_L2NIC, cmd, \
23 * hinic_init_function_table - Initialize function table.
26 * The hardware interface of a nic device.
28 * Receive buffer size.
32 * negative error value otherwise.
34 int hinic_init_function_table(void *hwdev, u16 rx_buf_sz)
36 struct hinic_function_table function_table;
37 u16 out_size = sizeof(function_table);
41 PMD_DRV_LOG(ERR, "Hwdev is NULL");
45 memset(&function_table, 0, sizeof(function_table));
46 function_table.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
47 function_table.func_id = hinic_global_func_id(hwdev);
48 function_table.mtu = 0x3FFF; /* default, max mtu */
49 function_table.rx_wqe_buf_size = rx_buf_sz;
51 err = hinic_msg_to_mgmt_sync(hwdev, HINIC_MOD_L2NIC,
52 HINIC_PORT_CMD_INIT_FUNC,
53 &function_table, sizeof(function_table),
54 &function_table, &out_size, 0);
55 if (err || function_table.mgmt_msg_head.status || !out_size) {
57 "Failed to init func table, err: %d, status: 0x%x, out size: 0x%x",
58 err, function_table.mgmt_msg_head.status, out_size);
66 * hinic_get_base_qpn - Get global queue number.
69 * The hardware interface of a nic device.
71 * Global queue number.
75 * negative error value otherwise.
77 int hinic_get_base_qpn(void *hwdev, u16 *global_qpn)
79 struct hinic_cmd_qpn cmd_qpn;
80 u16 out_size = sizeof(cmd_qpn);
83 if (!hwdev || !global_qpn) {
84 PMD_DRV_LOG(ERR, "Hwdev or global_qpn is NULL");
88 memset(&cmd_qpn, 0, sizeof(cmd_qpn));
89 cmd_qpn.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
90 cmd_qpn.func_id = hinic_global_func_id(hwdev);
92 err = hinic_msg_to_mgmt_sync(hwdev, HINIC_MOD_L2NIC,
93 HINIC_PORT_CMD_GET_GLOBAL_QPN,
94 &cmd_qpn, sizeof(cmd_qpn), &cmd_qpn,
96 if (err || !out_size || cmd_qpn.mgmt_msg_head.status) {
98 "Failed to get base qpn, err: %d, status: 0x%x, out size: 0x%x",
99 err, cmd_qpn.mgmt_msg_head.status, out_size);
103 *global_qpn = cmd_qpn.base_qpn;
109 * hinic_set_mac - Init mac_vlan table in NIC.
112 * The hardware interface of a nic device.
116 * Set 0 for mac_vlan table initialization.
118 * Global function id of NIC.
122 * negative error value otherwise.
124 int hinic_set_mac(void *hwdev, u8 *mac_addr, u16 vlan_id, u16 func_id)
126 struct hinic_port_mac_set mac_info;
127 u16 out_size = sizeof(mac_info);
130 if (!hwdev || !mac_addr) {
131 PMD_DRV_LOG(ERR, "Hwdev or mac_addr is NULL");
135 memset(&mac_info, 0, sizeof(mac_info));
136 mac_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
137 mac_info.func_id = func_id;
138 mac_info.vlan_id = vlan_id;
139 memmove(mac_info.mac, mac_addr, ETH_ALEN);
141 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_MAC, &mac_info,
142 sizeof(mac_info), &mac_info, &out_size);
143 if (err || !out_size || (mac_info.mgmt_msg_head.status &&
144 mac_info.mgmt_msg_head.status != HINIC_PF_SET_VF_ALREADY)) {
145 PMD_DRV_LOG(ERR, "Failed to set MAC, err: %d, status: 0x%x, out size: 0x%x",
146 err, mac_info.mgmt_msg_head.status, out_size);
150 if (mac_info.mgmt_msg_head.status == HINIC_PF_SET_VF_ALREADY) {
151 PMD_DRV_LOG(WARNING, "PF has already set vf mac, Ignore set operation.");
152 return HINIC_PF_SET_VF_ALREADY;
159 * hinic_del_mac - Uninit mac_vlan table in NIC.
162 * The hardware interface of a nic device.
166 * Set 0 for mac_vlan table initialization.
168 * Global function id of NIC.
172 * negative error value otherwise.
174 int hinic_del_mac(void *hwdev, u8 *mac_addr, u16 vlan_id, u16 func_id)
176 struct hinic_port_mac_set mac_info;
177 u16 out_size = sizeof(mac_info);
180 if (!hwdev || !mac_addr) {
181 PMD_DRV_LOG(ERR, "Hwdev or mac_addr is NULL");
185 if (vlan_id >= VLAN_N_VID) {
186 PMD_DRV_LOG(ERR, "Invalid VLAN number");
190 memset(&mac_info, 0, sizeof(mac_info));
191 mac_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
192 mac_info.func_id = func_id;
193 mac_info.vlan_id = vlan_id;
194 memmove(mac_info.mac, mac_addr, ETH_ALEN);
196 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_DEL_MAC, &mac_info,
197 sizeof(mac_info), &mac_info, &out_size);
198 if (err || !out_size || (mac_info.mgmt_msg_head.status &&
199 mac_info.mgmt_msg_head.status != HINIC_PF_SET_VF_ALREADY)) {
200 PMD_DRV_LOG(ERR, "Failed to delete MAC, err: %d, status: 0x%x, out size: 0x%x",
201 err, mac_info.mgmt_msg_head.status, out_size);
204 if (mac_info.mgmt_msg_head.status == HINIC_PF_SET_VF_ALREADY) {
205 PMD_DRV_LOG(WARNING, "PF has already set vf mac, Ignore delete operation.");
206 return HINIC_PF_SET_VF_ALREADY;
213 * hinic_get_default_mac - Get default mac address from hardware.
216 * The hardware interface of a nic device.
222 * negative error value otherwise.
224 int hinic_get_default_mac(void *hwdev, u8 *mac_addr)
226 struct hinic_port_mac_set mac_info;
227 u16 out_size = sizeof(mac_info);
230 if (!hwdev || !mac_addr) {
231 PMD_DRV_LOG(ERR, "Hwdev or mac_addr is NULL");
235 memset(&mac_info, 0, sizeof(mac_info));
236 mac_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
237 mac_info.func_id = hinic_global_func_id(hwdev);
239 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_MAC,
240 &mac_info, sizeof(mac_info),
241 &mac_info, &out_size);
242 if (err || !out_size || mac_info.mgmt_msg_head.status) {
243 PMD_DRV_LOG(ERR, "Failed to get mac, err: %d, status: 0x%x, out size: 0x%x",
244 err, mac_info.mgmt_msg_head.status, out_size);
248 memmove(mac_addr, mac_info.mac, ETH_ALEN);
254 * hinic_update_mac - Update mac address to hardware.
257 * The hardware interface of a nic device.
263 * Set 0 for mac_vlan table initialization.
265 * Global function id of NIC.
269 * negative error value otherwise.
271 int hinic_update_mac(void *hwdev, u8 *old_mac, u8 *new_mac, u16 vlan_id,
274 struct hinic_port_mac_update mac_info;
275 u16 out_size = sizeof(mac_info);
278 if (!hwdev || !old_mac || !new_mac) {
279 PMD_DRV_LOG(ERR, "Hwdev, old_mac or new_mac is NULL");
283 memset(&mac_info, 0, sizeof(mac_info));
284 mac_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
285 mac_info.func_id = func_id;
286 mac_info.vlan_id = vlan_id;
287 memcpy(mac_info.old_mac, old_mac, ETH_ALEN);
288 memcpy(mac_info.new_mac, new_mac, ETH_ALEN);
290 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_UPDATE_MAC,
291 &mac_info, sizeof(mac_info),
292 &mac_info, &out_size);
293 if (err || !out_size ||
294 (mac_info.mgmt_msg_head.status &&
295 mac_info.mgmt_msg_head.status != HINIC_PF_SET_VF_ALREADY)) {
296 PMD_DRV_LOG(ERR, "Failed to update MAC, err: %d, status: 0x%x, out size: 0x%x",
297 err, mac_info.mgmt_msg_head.status, out_size);
300 if (mac_info.mgmt_msg_head.status == HINIC_PF_SET_VF_ALREADY) {
301 PMD_DRV_LOG(WARNING, "PF has already set vf mac, Ignore update operation");
302 return HINIC_PF_SET_VF_ALREADY;
309 * hinic_set_port_mtu - Set MTU to port.
312 * The hardware interface of a nic device.
318 * negative error value otherwise.
320 int hinic_set_port_mtu(void *hwdev, u32 new_mtu)
322 struct hinic_mtu mtu_info;
323 u16 out_size = sizeof(mtu_info);
327 PMD_DRV_LOG(ERR, "Hwdev is NULL");
331 memset(&mtu_info, 0, sizeof(mtu_info));
332 mtu_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
333 mtu_info.func_id = hinic_global_func_id(hwdev);
334 mtu_info.mtu = new_mtu;
336 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_CHANGE_MTU,
337 &mtu_info, sizeof(mtu_info),
338 &mtu_info, &out_size);
339 if (err || !out_size || mtu_info.mgmt_msg_head.status) {
340 PMD_DRV_LOG(ERR, "Failed to set mtu, err: %d, status: 0x%x, out size: 0x%x",
341 err, mtu_info.mgmt_msg_head.status, out_size);
349 * hinic_add_remove_vlan - Add or remove vlan id to vlan elb table.
352 * The hardware interface of a nic device.
356 * Global function id of NIC.
358 * Add or remove operation.
362 * negative error value otherwise.
364 int hinic_add_remove_vlan(void *hwdev, u16 vlan_id, u16 func_id, bool add)
366 struct hinic_vlan_config vlan_info;
367 u16 out_size = sizeof(vlan_info);
372 PMD_DRV_LOG(ERR, "Hwdev is NULL");
376 cmd = add ? HINIC_PORT_CMD_ADD_VLAN : HINIC_PORT_CMD_DEL_VLAN;
378 memset(&vlan_info, 0, sizeof(vlan_info));
379 vlan_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
380 vlan_info.func_id = func_id;
381 vlan_info.vlan_id = vlan_id;
383 err = l2nic_msg_to_mgmt_sync(hwdev, cmd, &vlan_info,
384 sizeof(vlan_info), &vlan_info,
386 if (err || !out_size || vlan_info.mgmt_msg_head.status) {
388 "Failed to %s vlan, err: %d, status: 0x%x, out size: 0x%x",
389 add ? "add" : "remove", err,
390 vlan_info.mgmt_msg_head.status, out_size);
398 * hinic_config_vlan_filter - Enable or Disable vlan filter.
401 * The hardware interface of a nic device.
402 * @param vlan_filter_ctrl
407 * negative error value otherwise.
409 int hinic_config_vlan_filter(void *hwdev, u32 vlan_filter_ctrl)
411 struct hinic_hwdev *nic_hwdev = (struct hinic_hwdev *)hwdev;
412 struct hinic_vlan_filter vlan_filter;
413 u16 out_size = sizeof(vlan_filter);
419 memset(&vlan_filter, 0, sizeof(vlan_filter));
420 vlan_filter.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
421 vlan_filter.func_id = hinic_global_func_id(nic_hwdev);
422 vlan_filter.vlan_filter_ctrl = vlan_filter_ctrl;
424 err = l2nic_msg_to_mgmt_sync(nic_hwdev, HINIC_PORT_CMD_SET_VLAN_FILTER,
425 &vlan_filter, sizeof(vlan_filter),
426 &vlan_filter, &out_size);
427 if (vlan_filter.mgmt_msg_head.status == HINIC_MGMT_CMD_UNSUPPORTED) {
428 err = HINIC_MGMT_CMD_UNSUPPORTED;
429 } else if ((err == HINIC_MBOX_VF_CMD_ERROR) &&
430 (HINIC_IS_VF(nic_hwdev))) {
431 err = HINIC_MGMT_CMD_UNSUPPORTED;
432 } else if (err || !out_size || vlan_filter.mgmt_msg_head.status) {
434 "Failed to config vlan filter, vlan_filter_ctrl: 0x%x, err: %d, status: 0x%x, out size: 0x%x",
435 vlan_filter_ctrl, err,
436 vlan_filter.mgmt_msg_head.status, out_size);
444 * hinic_set_rx_vlan_offload - Enable or Disable vlan offload.
447 * The hardware interface of a nic device.
453 * negative error value otherwise.
455 int hinic_set_rx_vlan_offload(void *hwdev, u8 en)
457 struct hinic_vlan_offload vlan_cfg;
458 u16 out_size = sizeof(vlan_cfg);
462 PMD_DRV_LOG(ERR, "Hwdev is NULL");
466 memset(&vlan_cfg, 0, sizeof(vlan_cfg));
467 vlan_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
468 vlan_cfg.func_id = hinic_global_func_id(hwdev);
469 vlan_cfg.vlan_rx_offload = en;
471 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_RX_VLAN_OFFLOAD,
472 &vlan_cfg, sizeof(vlan_cfg),
473 &vlan_cfg, &out_size);
474 if (err || !out_size || vlan_cfg.mgmt_msg_head.status) {
476 "Failed to set rx vlan offload, err: %d, status: 0x%x, out size: 0x%x",
477 err, vlan_cfg.mgmt_msg_head.status, out_size);
485 * hinic_get_link_status - Get link status from hardware.
488 * The hardware interface of a nic device.
494 * negative error value otherwise.
496 int hinic_get_link_status(void *hwdev, u8 *link_state)
498 struct hinic_get_link get_link;
499 u16 out_size = sizeof(get_link);
502 if (!hwdev || !link_state) {
503 PMD_DRV_LOG(ERR, "Hwdev or link_state is NULL");
507 memset(&get_link, 0, sizeof(get_link));
508 get_link.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
509 get_link.func_id = hinic_global_func_id(hwdev);
511 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_LINK_STATE,
512 &get_link, sizeof(get_link),
513 &get_link, &out_size);
514 if (err || !out_size || get_link.mgmt_msg_head.status) {
515 PMD_DRV_LOG(ERR, "Failed to get link state, err: %d, status: 0x%x, out size: 0x%x",
516 err, get_link.mgmt_msg_head.status, out_size);
520 *link_state = get_link.link_status;
526 * hinic_set_vport_enable - Notify firmware that driver is ready or not.
529 * The hardware interface of a nic device.
531 * 1: driver is ready; 0: driver is not ok.
535 * negative error value otherwise.
537 int hinic_set_vport_enable(void *hwdev, bool enable)
539 struct hinic_vport_state en_state;
540 u16 out_size = sizeof(en_state);
544 PMD_DRV_LOG(ERR, "Hwdev is NULL");
548 memset(&en_state, 0, sizeof(en_state));
549 en_state.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
550 en_state.func_id = hinic_global_func_id(hwdev);
551 en_state.state = (enable ? 1 : 0);
553 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_VPORT_ENABLE,
554 &en_state, sizeof(en_state),
555 &en_state, &out_size);
556 if (err || !out_size || en_state.mgmt_msg_head.status) {
557 PMD_DRV_LOG(ERR, "Failed to set vport state, err: %d, status: 0x%x, out size: 0x%x",
558 err, en_state.mgmt_msg_head.status, out_size);
566 * hinic_set_port_enable - Open MAG to receive packets.
569 * The hardware interface of a nic device.
571 * 1: open MAG; 0: close MAG.
575 * negative error value otherwise.
577 int hinic_set_port_enable(void *hwdev, bool enable)
579 struct hinic_port_state en_state;
580 u16 out_size = sizeof(en_state);
584 PMD_DRV_LOG(ERR, "Hwdev is NULL");
588 if (HINIC_IS_VF((struct hinic_hwdev *)hwdev))
591 memset(&en_state, 0, sizeof(en_state));
592 en_state.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
593 en_state.state = (enable ? HINIC_PORT_ENABLE : HINIC_PORT_DISABLE);
595 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_PORT_ENABLE,
596 &en_state, sizeof(en_state),
597 &en_state, &out_size);
598 if (err || !out_size || en_state.mgmt_msg_head.status) {
599 PMD_DRV_LOG(ERR, "Failed to set phy port state, err: %d, status: 0x%x, out size: 0x%x",
600 err, en_state.mgmt_msg_head.status, out_size);
607 int hinic_get_port_info(void *hwdev, struct nic_port_info *port_info)
609 struct hinic_port_info port_msg;
610 u16 out_size = sizeof(port_msg);
613 if (!hwdev || !port_info) {
614 PMD_DRV_LOG(ERR, "Hwdev or port_info is NULL");
618 memset(&port_msg, 0, sizeof(port_msg));
619 port_msg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
620 port_msg.func_id = hinic_global_func_id(hwdev);
622 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_PORT_INFO,
623 &port_msg, sizeof(port_msg),
624 &port_msg, &out_size);
625 if (err || !out_size || port_msg.mgmt_msg_head.status) {
627 "Failed to get port info, err: %d, status: 0x%x, out size: 0x%x",
628 err, port_msg.mgmt_msg_head.status, out_size);
632 port_info->autoneg_cap = port_msg.autoneg_cap;
633 port_info->autoneg_state = port_msg.autoneg_state;
634 port_info->duplex = port_msg.duplex;
635 port_info->port_type = port_msg.port_type;
636 port_info->speed = port_msg.speed;
641 int hinic_set_pause_config(void *hwdev, struct nic_pause_config nic_pause)
643 struct hinic_pause_config pause_info;
644 u16 out_size = sizeof(pause_info);
648 PMD_DRV_LOG(ERR, "Hwdev is NULL");
652 memset(&pause_info, 0, sizeof(pause_info));
653 pause_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
654 pause_info.func_id = hinic_global_func_id(hwdev);
655 pause_info.auto_neg = nic_pause.auto_neg;
656 pause_info.rx_pause = nic_pause.rx_pause;
657 pause_info.tx_pause = nic_pause.tx_pause;
659 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_PAUSE_INFO,
660 &pause_info, sizeof(pause_info),
661 &pause_info, &out_size);
662 if (err || !out_size || pause_info.mgmt_msg_head.status) {
663 PMD_DRV_LOG(ERR, "Failed to set pause info, err: %d, status: 0x%x, out size: 0x%x",
664 err, pause_info.mgmt_msg_head.status, out_size);
671 int hinic_get_pause_info(void *hwdev, struct nic_pause_config *nic_pause)
673 struct hinic_pause_config pause_info;
674 u16 out_size = sizeof(pause_info);
677 if (!hwdev || !nic_pause)
680 memset(&pause_info, 0, sizeof(pause_info));
681 pause_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
682 pause_info.func_id = hinic_global_func_id(hwdev);
684 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_PAUSE_INFO,
685 &pause_info, sizeof(pause_info),
686 &pause_info, &out_size);
687 if (err || !out_size || pause_info.mgmt_msg_head.status) {
688 PMD_DRV_LOG(ERR, "Failed to get pause info, err: %d, status: 0x%x, out size: 0x%x\n",
689 err, pause_info.mgmt_msg_head.status, out_size);
693 nic_pause->auto_neg = pause_info.auto_neg;
694 nic_pause->rx_pause = pause_info.rx_pause;
695 nic_pause->tx_pause = pause_info.tx_pause;
700 int hinic_dcb_set_ets(void *hwdev, u8 *up_tc, u8 *pg_bw,
701 u8 *pgid, u8 *up_bw, u8 *prio)
703 struct hinic_up_ets_cfg ets;
704 u16 out_size = sizeof(ets);
709 if (!hwdev || !up_tc || !pg_bw || !pgid || !up_bw || !prio) {
710 PMD_DRV_LOG(ERR, "Hwdev, up_tc, pg_bw, pgid, up_bw or prio is NULL");
714 for (i = 0; i < HINIC_DCB_TC_MAX; i++) {
715 up_bw_t += *(up_bw + i);
716 pg_bw_t += *(pg_bw + i);
718 if (*(up_tc + i) > HINIC_DCB_TC_MAX) {
719 PMD_DRV_LOG(ERR, "Invalid up %d mapping tc: %d", i,
725 if (pg_bw_t != 100 || (up_bw_t % 100) != 0) {
727 "Invalid pg_bw: %d or up_bw: %d", pg_bw_t, up_bw_t);
731 memset(&ets, 0, sizeof(ets));
732 ets.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
733 ets.port_id = 0; /* reserved */
734 memcpy(ets.up_tc, up_tc, HINIC_DCB_TC_MAX);
735 memcpy(ets.pg_bw, pg_bw, HINIC_DCB_UP_MAX);
736 memcpy(ets.pgid, pgid, HINIC_DCB_UP_MAX);
737 memcpy(ets.up_bw, up_bw, HINIC_DCB_UP_MAX);
738 memcpy(ets.prio, prio, HINIC_DCB_UP_MAX);
740 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_ETS,
741 &ets, sizeof(ets), &ets, &out_size);
742 if (err || ets.mgmt_msg_head.status || !out_size) {
744 "Failed to set ets, err: %d, status: 0x%x, out size: 0x%x",
745 err, ets.mgmt_msg_head.status, out_size);
752 int hinic_get_vport_stats(void *hwdev, struct hinic_vport_stats *stats)
754 struct hinic_port_stats_info vport_stats_cmd;
755 struct hinic_cmd_vport_stats vport_stats_rsp;
756 u16 out_size = sizeof(vport_stats_rsp);
759 if (!hwdev || !stats) {
760 PMD_DRV_LOG(ERR, "Hwdev or stats is NULL");
764 memset(&vport_stats_rsp, 0, sizeof(vport_stats_rsp));
765 memset(&vport_stats_cmd, 0, sizeof(vport_stats_cmd));
766 vport_stats_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
767 vport_stats_cmd.stats_version = HINIC_PORT_STATS_VERSION;
768 vport_stats_cmd.func_id = hinic_global_func_id(hwdev);
769 vport_stats_cmd.stats_size = sizeof(vport_stats_rsp);
771 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_VPORT_STAT,
772 &vport_stats_cmd, sizeof(vport_stats_cmd),
773 &vport_stats_rsp, &out_size);
774 if (err || !out_size || vport_stats_rsp.mgmt_msg_head.status) {
776 "Get vport stats from fw failed, err: %d, status: 0x%x, out size: 0x%x",
777 err, vport_stats_rsp.mgmt_msg_head.status, out_size);
781 memcpy(stats, &vport_stats_rsp.stats, sizeof(*stats));
786 int hinic_get_phy_port_stats(void *hwdev, struct hinic_phy_port_stats *stats)
788 struct hinic_port_stats_info port_stats_cmd;
789 struct hinic_port_stats port_stats_rsp;
790 u16 out_size = sizeof(port_stats_rsp);
793 if (!hwdev || !stats) {
794 PMD_DRV_LOG(ERR, "Hwdev or stats is NULL");
798 memset(&port_stats_rsp, 0, sizeof(port_stats_rsp));
799 memset(&port_stats_cmd, 0, sizeof(port_stats_cmd));
800 port_stats_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
801 port_stats_cmd.stats_version = HINIC_PORT_STATS_VERSION;
802 port_stats_cmd.stats_size = sizeof(port_stats_rsp);
804 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_PORT_STATISTICS,
805 &port_stats_cmd, sizeof(port_stats_cmd),
806 &port_stats_rsp, &out_size);
807 if (err || !out_size || port_stats_rsp.mgmt_msg_head.status) {
809 "Failed to get port statistics, err: %d, status: 0x%x, out size: 0x%x",
810 err, port_stats_rsp.mgmt_msg_head.status, out_size);
814 memcpy(stats, &port_stats_rsp.stats, sizeof(*stats));
819 int hinic_set_rss_type(void *hwdev, u32 tmpl_idx, struct nic_rss_type rss_type)
821 struct nic_rss_context_tbl *ctx_tbl;
822 struct hinic_cmd_buf *cmd_buf;
828 PMD_DRV_LOG(ERR, "Hwdev is NULL");
832 cmd_buf = hinic_alloc_cmd_buf(hwdev);
834 PMD_DRV_LOG(ERR, "Failed to allocate cmd buf");
838 ctx |= HINIC_RSS_TYPE_SET(1, VALID) |
839 HINIC_RSS_TYPE_SET(rss_type.ipv4, IPV4) |
840 HINIC_RSS_TYPE_SET(rss_type.ipv6, IPV6) |
841 HINIC_RSS_TYPE_SET(rss_type.ipv6_ext, IPV6_EXT) |
842 HINIC_RSS_TYPE_SET(rss_type.tcp_ipv4, TCP_IPV4) |
843 HINIC_RSS_TYPE_SET(rss_type.tcp_ipv6, TCP_IPV6) |
844 HINIC_RSS_TYPE_SET(rss_type.tcp_ipv6_ext, TCP_IPV6_EXT) |
845 HINIC_RSS_TYPE_SET(rss_type.udp_ipv4, UDP_IPV4) |
846 HINIC_RSS_TYPE_SET(rss_type.udp_ipv6, UDP_IPV6);
848 cmd_buf->size = sizeof(struct nic_rss_context_tbl);
850 ctx_tbl = (struct nic_rss_context_tbl *)cmd_buf->buf;
851 ctx_tbl->group_index = cpu_to_be32(tmpl_idx);
853 ctx_tbl->size = sizeof(u32);
854 ctx_tbl->size = cpu_to_be32(ctx_tbl->size);
856 ctx_tbl->ctx = cpu_to_be32(ctx);
858 /* cfg the rss context table by command queue */
859 err = hinic_cmdq_direct_resp(hwdev, HINIC_ACK_TYPE_CMDQ,
861 HINIC_UCODE_CMD_SET_RSS_CONTEXT_TABLE,
862 cmd_buf, &out_param, 0);
864 hinic_free_cmd_buf(hwdev, cmd_buf);
866 if (err || out_param != 0) {
867 PMD_DRV_LOG(ERR, "Failed to set rss context table");
874 int hinic_get_rss_type(void *hwdev, u32 tmpl_idx, struct nic_rss_type *rss_type)
876 struct hinic_rss_context_table ctx_tbl;
877 u16 out_size = sizeof(ctx_tbl);
880 if (!hwdev || !rss_type) {
881 PMD_DRV_LOG(ERR, "Hwdev or rss_type is NULL");
885 ctx_tbl.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
886 ctx_tbl.func_id = hinic_global_func_id(hwdev);
887 ctx_tbl.template_id = (u8)tmpl_idx;
889 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_RSS_CTX_TBL,
890 &ctx_tbl, sizeof(ctx_tbl),
891 &ctx_tbl, &out_size);
892 if (err || !out_size || ctx_tbl.mgmt_msg_head.status) {
894 "Failed to get hash type, err: %d, status: 0x%x, out size: 0x%x",
895 err, ctx_tbl.mgmt_msg_head.status, out_size);
899 rss_type->ipv4 = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV4);
900 rss_type->ipv6 = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV6);
901 rss_type->ipv6_ext = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV6_EXT);
902 rss_type->tcp_ipv4 = HINIC_RSS_TYPE_GET(ctx_tbl.context, TCP_IPV4);
903 rss_type->tcp_ipv6 = HINIC_RSS_TYPE_GET(ctx_tbl.context, TCP_IPV6);
904 rss_type->tcp_ipv6_ext =
905 HINIC_RSS_TYPE_GET(ctx_tbl.context, TCP_IPV6_EXT);
906 rss_type->udp_ipv4 = HINIC_RSS_TYPE_GET(ctx_tbl.context, UDP_IPV4);
907 rss_type->udp_ipv6 = HINIC_RSS_TYPE_GET(ctx_tbl.context, UDP_IPV6);
912 int hinic_rss_set_template_tbl(void *hwdev, u32 tmpl_idx, u8 *temp)
914 struct hinic_rss_template_key temp_key;
915 u16 out_size = sizeof(temp_key);
918 if (!hwdev || !temp) {
919 PMD_DRV_LOG(ERR, "Hwdev or temp is NULL");
923 memset(&temp_key, 0, sizeof(temp_key));
924 temp_key.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
925 temp_key.func_id = hinic_global_func_id(hwdev);
926 temp_key.template_id = (u8)tmpl_idx;
927 memcpy(temp_key.key, temp, HINIC_RSS_KEY_SIZE);
929 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_RSS_TEMPLATE_TBL,
930 &temp_key, sizeof(temp_key),
931 &temp_key, &out_size);
932 if (err || !out_size || temp_key.mgmt_msg_head.status) {
934 "Failed to set hash key, err: %d, status: 0x%x, out size: 0x%x",
935 err, temp_key.mgmt_msg_head.status, out_size);
942 int hinic_rss_get_template_tbl(void *hwdev, u32 tmpl_idx, u8 *temp)
944 struct hinic_rss_template_key temp_key;
945 u16 out_size = sizeof(temp_key);
948 if (!hwdev || !temp) {
949 PMD_DRV_LOG(ERR, "Hwdev or temp is NULL");
953 memset(&temp_key, 0, sizeof(temp_key));
954 temp_key.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
955 temp_key.func_id = hinic_global_func_id(hwdev);
956 temp_key.template_id = (u8)tmpl_idx;
958 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_RSS_TEMPLATE_TBL,
959 &temp_key, sizeof(temp_key),
960 &temp_key, &out_size);
961 if (err || !out_size || temp_key.mgmt_msg_head.status) {
962 PMD_DRV_LOG(ERR, "Failed to get hash key, err: %d, status: 0x%x, out size: 0x%x",
963 err, temp_key.mgmt_msg_head.status, out_size);
967 memcpy(temp, temp_key.key, HINIC_RSS_KEY_SIZE);
973 * hinic_rss_set_hash_engine - Init rss hash function.
976 * The hardware interface of a nic device.
978 * Index of rss template from NIC.
980 * Hash function, such as Toeplitz or XOR.
984 * negative error value otherwise.
986 int hinic_rss_set_hash_engine(void *hwdev, u8 tmpl_idx, u8 type)
988 struct hinic_rss_engine_type hash_type;
989 u16 out_size = sizeof(hash_type);
993 PMD_DRV_LOG(ERR, "Hwdev is NULL");
997 memset(&hash_type, 0, sizeof(hash_type));
998 hash_type.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
999 hash_type.func_id = hinic_global_func_id(hwdev);
1000 hash_type.hash_engine = type;
1001 hash_type.template_id = tmpl_idx;
1003 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_RSS_HASH_ENGINE,
1004 &hash_type, sizeof(hash_type),
1005 &hash_type, &out_size);
1006 if (err || !out_size || hash_type.mgmt_msg_head.status) {
1007 PMD_DRV_LOG(ERR, "Failed to get hash engine, err: %d, status: 0x%x, out size: 0x%x",
1008 err, hash_type.mgmt_msg_head.status, out_size);
1015 int hinic_rss_set_indir_tbl(void *hwdev, u32 tmpl_idx, u32 *indir_table)
1017 struct nic_rss_indirect_tbl *indir_tbl;
1018 struct hinic_cmd_buf *cmd_buf;
1025 if (!hwdev || !indir_table) {
1026 PMD_DRV_LOG(ERR, "Hwdev or indir_table is NULL");
1030 cmd_buf = hinic_alloc_cmd_buf(hwdev);
1032 PMD_DRV_LOG(ERR, "Failed to allocate cmd buf");
1036 cmd_buf->size = sizeof(struct nic_rss_indirect_tbl);
1037 indir_tbl = cmd_buf->buf;
1038 indir_tbl->group_index = cpu_to_be32(tmpl_idx);
1040 for (i = 0; i < HINIC_RSS_INDIR_SIZE; i++) {
1041 indir_tbl->entry[i] = (u8)(*(indir_table + i));
1043 if (0x3 == (i & 0x3)) {
1044 temp = (u32 *)&indir_tbl->entry[i - 3];
1045 *temp = cpu_to_be32(*temp);
1049 /* configure the rss indirect table by command queue */
1050 indir_size = HINIC_RSS_INDIR_SIZE / 2;
1051 indir_tbl->offset = 0;
1052 indir_tbl->size = cpu_to_be32(indir_size);
1054 err = hinic_cmdq_direct_resp(hwdev, HINIC_ACK_TYPE_CMDQ,
1056 HINIC_UCODE_CMD_SET_RSS_INDIR_TABLE,
1057 cmd_buf, &out_param, 0);
1058 if (err || out_param != 0) {
1059 PMD_DRV_LOG(ERR, "Failed to set rss indir table");
1064 indir_tbl->offset = cpu_to_be32(indir_size);
1065 indir_tbl->size = cpu_to_be32(indir_size);
1066 memcpy(indir_tbl->entry, &indir_tbl->entry[indir_size], indir_size);
1068 err = hinic_cmdq_direct_resp(hwdev, HINIC_ACK_TYPE_CMDQ,
1070 HINIC_UCODE_CMD_SET_RSS_INDIR_TABLE,
1071 cmd_buf, &out_param, 0);
1072 if (err || out_param != 0) {
1073 PMD_DRV_LOG(ERR, "Failed to set rss indir table");
1078 hinic_free_cmd_buf(hwdev, cmd_buf);
1083 int hinic_rss_get_indir_tbl(void *hwdev, u32 tmpl_idx, u32 *indir_table)
1085 struct hinic_rss_indir_table rss_cfg;
1086 u16 out_size = sizeof(rss_cfg);
1089 if (!hwdev || !indir_table) {
1090 PMD_DRV_LOG(ERR, "Hwdev or indir_table is NULL");
1094 memset(&rss_cfg, 0, sizeof(rss_cfg));
1095 rss_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1096 rss_cfg.func_id = hinic_global_func_id(hwdev);
1097 rss_cfg.template_id = (u8)tmpl_idx;
1099 err = l2nic_msg_to_mgmt_sync(hwdev,
1100 HINIC_PORT_CMD_GET_RSS_TEMPLATE_INDIR_TBL,
1101 &rss_cfg, sizeof(rss_cfg), &rss_cfg,
1103 if (err || !out_size || rss_cfg.mgmt_msg_head.status) {
1104 PMD_DRV_LOG(ERR, "Failed to get indir table, err: %d, status: 0x%x, out size: 0x%x",
1105 err, rss_cfg.mgmt_msg_head.status, out_size);
1109 hinic_be32_to_cpu(rss_cfg.indir, HINIC_RSS_INDIR_SIZE);
1110 for (i = 0; i < HINIC_RSS_INDIR_SIZE; i++)
1111 indir_table[i] = rss_cfg.indir[i];
1116 int hinic_rss_cfg(void *hwdev, u8 rss_en, u8 tmpl_idx, u8 tc_num, u8 *prio_tc)
1118 struct hinic_rss_config rss_cfg;
1119 u16 out_size = sizeof(rss_cfg);
1122 /* micro code required: number of TC should be power of 2 */
1123 if (!hwdev || !prio_tc || (tc_num & (tc_num - 1))) {
1124 PMD_DRV_LOG(ERR, "Hwdev or prio_tc is NULL, or tc_num: %u Not power of 2",
1129 memset(&rss_cfg, 0, sizeof(rss_cfg));
1130 rss_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1131 rss_cfg.func_id = hinic_global_func_id(hwdev);
1132 rss_cfg.rss_en = rss_en;
1133 rss_cfg.template_id = tmpl_idx;
1134 rss_cfg.rq_priority_number = tc_num ? (u8)ilog2(tc_num) : 0;
1136 memcpy(rss_cfg.prio_tc, prio_tc, HINIC_DCB_UP_MAX);
1138 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_RSS_CFG,
1139 &rss_cfg, sizeof(rss_cfg), &rss_cfg,
1141 if (err || !out_size || rss_cfg.mgmt_msg_head.status) {
1142 PMD_DRV_LOG(ERR, "Failed to set rss cfg, err: %d, status: 0x%x, out size: 0x%x",
1143 err, rss_cfg.mgmt_msg_head.status, out_size);
1151 * hinic_rss_template_alloc - Get rss template id from the chip,
1152 * all functions share 96 templates.
1155 * The hardware interface of a nic device.
1157 * Index of rss template from chip.
1161 * negative error value otherwise.
1163 int hinic_rss_template_alloc(void *hwdev, u8 *tmpl_idx)
1165 struct hinic_rss_template_mgmt template_mgmt;
1166 u16 out_size = sizeof(template_mgmt);
1169 if (!hwdev || !tmpl_idx) {
1170 PMD_DRV_LOG(ERR, "Hwdev or tmpl_idx is NULL");
1174 memset(&template_mgmt, 0, sizeof(template_mgmt));
1175 template_mgmt.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1176 template_mgmt.func_id = hinic_global_func_id(hwdev);
1177 template_mgmt.cmd = NIC_RSS_CMD_TEMP_ALLOC;
1179 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_RSS_TEMP_MGR,
1180 &template_mgmt, sizeof(template_mgmt),
1181 &template_mgmt, &out_size);
1182 if (err || !out_size || template_mgmt.mgmt_msg_head.status) {
1183 PMD_DRV_LOG(ERR, "Failed to alloc rss template, err: %d, status: 0x%x, out size: 0x%x",
1184 err, template_mgmt.mgmt_msg_head.status, out_size);
1188 *tmpl_idx = template_mgmt.template_id;
1194 * hinic_rss_template_free - Free rss template id to the chip.
1197 * The hardware interface of a nic device.
1199 * Index of rss template from chip.
1203 * negative error value otherwise.
1205 int hinic_rss_template_free(void *hwdev, u8 tmpl_idx)
1207 struct hinic_rss_template_mgmt template_mgmt;
1208 u16 out_size = sizeof(template_mgmt);
1212 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1216 memset(&template_mgmt, 0, sizeof(template_mgmt));
1217 template_mgmt.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1218 template_mgmt.func_id = hinic_global_func_id(hwdev);
1219 template_mgmt.template_id = tmpl_idx;
1220 template_mgmt.cmd = NIC_RSS_CMD_TEMP_FREE;
1222 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_RSS_TEMP_MGR,
1223 &template_mgmt, sizeof(template_mgmt),
1224 &template_mgmt, &out_size);
1225 if (err || !out_size || template_mgmt.mgmt_msg_head.status) {
1226 PMD_DRV_LOG(ERR, "Failed to free rss template, err: %d, status: 0x%x, out size: 0x%x",
1227 err, template_mgmt.mgmt_msg_head.status, out_size);
1235 * hinic_set_rx_vhd_mode - Change rx buffer size after initialization.
1238 * The hardware interface of a nic device.
1242 * receive buffer size.
1246 * negative error value otherwise.
1248 int hinic_set_rx_vhd_mode(void *hwdev, u16 vhd_mode, u16 rx_buf_sz)
1250 struct hinic_set_vhd_mode vhd_mode_cfg;
1251 u16 out_size = sizeof(vhd_mode_cfg);
1255 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1259 memset(&vhd_mode_cfg, 0, sizeof(vhd_mode_cfg));
1261 vhd_mode_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1262 vhd_mode_cfg.func_id = hinic_global_func_id(hwdev);
1263 vhd_mode_cfg.vhd_type = vhd_mode;
1264 vhd_mode_cfg.rx_wqe_buffer_size = rx_buf_sz;
1266 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_VHD_CFG,
1267 &vhd_mode_cfg, sizeof(vhd_mode_cfg),
1268 &vhd_mode_cfg, &out_size);
1269 if (err || !out_size || vhd_mode_cfg.mgmt_msg_head.status) {
1271 "Failed to set vhd mode, err: %d, status: 0x%x, out size: 0x%x",
1272 err, vhd_mode_cfg.mgmt_msg_head.status, out_size);
1280 int hinic_set_rx_mode(void *hwdev, u32 enable)
1282 struct hinic_rx_mode_config rx_mode_cfg;
1283 u16 out_size = sizeof(rx_mode_cfg);
1287 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1291 memset(&rx_mode_cfg, 0, sizeof(rx_mode_cfg));
1292 rx_mode_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1293 rx_mode_cfg.func_id = hinic_global_func_id(hwdev);
1294 rx_mode_cfg.rx_mode = enable;
1296 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_RX_MODE,
1297 &rx_mode_cfg, sizeof(rx_mode_cfg),
1298 &rx_mode_cfg, &out_size);
1299 if (err || !out_size || rx_mode_cfg.mgmt_msg_head.status) {
1300 PMD_DRV_LOG(ERR, "Failed to set rx mode, err: %d, status: 0x%x, out size: 0x%x",
1301 err, rx_mode_cfg.mgmt_msg_head.status, out_size);
1309 * hinic_get_mgmt_version - Get mgmt module version from chip.
1312 * The hardware interface of a nic device.
1318 * negative error value otherwise.
1320 int hinic_get_mgmt_version(void *hwdev, char *fw)
1322 struct hinic_version_info fw_ver;
1323 u16 out_size = sizeof(fw_ver);
1326 if (!hwdev || !fw) {
1327 PMD_DRV_LOG(ERR, "Hwdev or fw is NULL");
1331 memset(&fw_ver, 0, sizeof(fw_ver));
1332 fw_ver.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1334 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_MGMT_VERSION,
1335 &fw_ver, sizeof(fw_ver), &fw_ver,
1337 if (err || !out_size || fw_ver.mgmt_msg_head.status) {
1338 PMD_DRV_LOG(ERR, "Failed to get mgmt version, err: %d, status: 0x%x, out size: 0x%x\n",
1339 err, fw_ver.mgmt_msg_head.status, out_size);
1343 snprintf(fw, HINIC_MGMT_VERSION_MAX_LEN, "%s", fw_ver.ver);
1348 int hinic_set_rx_csum_offload(void *hwdev, u32 en)
1350 struct hinic_checksum_offload rx_csum_cfg;
1351 u16 out_size = sizeof(rx_csum_cfg);
1355 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1359 memset(&rx_csum_cfg, 0, sizeof(rx_csum_cfg));
1360 rx_csum_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1361 rx_csum_cfg.func_id = hinic_global_func_id(hwdev);
1362 rx_csum_cfg.rx_csum_offload = en;
1364 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_RX_CSUM,
1365 &rx_csum_cfg, sizeof(rx_csum_cfg),
1366 &rx_csum_cfg, &out_size);
1367 if (err || !out_size || rx_csum_cfg.mgmt_msg_head.status) {
1369 "Failed to set rx csum offload, err: %d, status: 0x%x, out size: 0x%x",
1370 err, rx_csum_cfg.mgmt_msg_head.status, out_size);
1377 int hinic_set_rx_lro(void *hwdev, u8 ipv4_en, u8 ipv6_en, u8 max_wqe_num)
1379 struct hinic_lro_config lro_cfg;
1380 u16 out_size = sizeof(lro_cfg);
1384 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1388 memset(&lro_cfg, 0, sizeof(lro_cfg));
1389 lro_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1390 lro_cfg.func_id = hinic_global_func_id(hwdev);
1391 lro_cfg.lro_ipv4_en = ipv4_en;
1392 lro_cfg.lro_ipv6_en = ipv6_en;
1393 lro_cfg.lro_max_wqe_num = max_wqe_num;
1395 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_LRO,
1396 &lro_cfg, sizeof(lro_cfg), &lro_cfg,
1398 if (err || !out_size || lro_cfg.mgmt_msg_head.status) {
1399 PMD_DRV_LOG(ERR, "Failed to set lro offload, err: %d, status: 0x%x, out size: 0x%x",
1400 err, lro_cfg.mgmt_msg_head.status, out_size);
1407 int hinic_set_anti_attack(void *hwdev, bool enable)
1409 struct hinic_port_anti_attack_rate rate;
1410 u16 out_size = sizeof(rate);
1414 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1418 memset(&rate, 0, sizeof(rate));
1419 rate.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1420 rate.func_id = hinic_global_func_id(hwdev);
1421 rate.enable = enable;
1422 rate.cir = ANTI_ATTACK_DEFAULT_CIR;
1423 rate.xir = ANTI_ATTACK_DEFAULT_XIR;
1424 rate.cbs = ANTI_ATTACK_DEFAULT_CBS;
1425 rate.xbs = ANTI_ATTACK_DEFAULT_XBS;
1427 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_ANTI_ATTACK_RATE,
1428 &rate, sizeof(rate), &rate,
1430 if (err || !out_size || rate.mgmt_msg_head.status) {
1431 PMD_DRV_LOG(ERR, "Can't %s port Anti-Attack rate limit, err: %d, status: 0x%x, out size: 0x%x",
1432 (enable ? "enable" : "disable"), err,
1433 rate.mgmt_msg_head.status, out_size);
1440 /* Set autoneg status and restart port link status */
1441 int hinic_reset_port_link_cfg(void *hwdev)
1443 struct hinic_reset_link_cfg reset_cfg;
1444 u16 out_size = sizeof(reset_cfg);
1447 memset(&reset_cfg, 0, sizeof(reset_cfg));
1448 reset_cfg.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1449 reset_cfg.func_id = hinic_global_func_id(hwdev);
1451 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_RESET_LINK_CFG,
1452 &reset_cfg, sizeof(reset_cfg),
1453 &reset_cfg, &out_size);
1454 if (err || !out_size || reset_cfg.mgmt_msg_head.status) {
1455 PMD_DRV_LOG(ERR, "Reset port link configure failed, err: %d, status: 0x%x, out size: 0x%x",
1456 err, reset_cfg.mgmt_msg_head.status, out_size);
1464 * hinic_vf_func_init - Register VF to PF.
1467 * The hardware interface of a nic device.
1471 * negative error value otherwise.
1473 int hinic_vf_func_init(struct hinic_hwdev *hwdev)
1477 if (!HINIC_IS_VF(hwdev))
1480 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC,
1481 HINIC_PORT_CMD_VF_REGISTER, &state, sizeof(state),
1484 PMD_DRV_LOG(ERR, "Fail to register vf");
1492 * hinic_vf_func_free - Unregister VF from PF.
1495 * The hardware interface of a nic device.
1497 void hinic_vf_func_free(struct hinic_hwdev *hwdev)
1501 if (hinic_func_type(hwdev) != TYPE_VF)
1504 err = hinic_mbox_to_pf(hwdev, HINIC_MOD_L2NIC,
1505 HINIC_PORT_CMD_VF_UNREGISTER, &err, sizeof(err),
1508 PMD_DRV_LOG(ERR, "Fail to unregister VF, err: %d", err);
1511 int hinic_set_fast_recycle_mode(void *hwdev, u8 mode)
1513 struct hinic_fast_recycled_mode fast_recycled_mode;
1514 u16 out_size = sizeof(fast_recycled_mode);
1518 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1522 memset(&fast_recycled_mode, 0, sizeof(fast_recycled_mode));
1523 fast_recycled_mode.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1524 fast_recycled_mode.func_id = hinic_global_func_id(hwdev);
1525 fast_recycled_mode.fast_recycled_mode = mode;
1527 err = hinic_msg_to_mgmt_sync(hwdev, HINIC_MOD_COMM,
1528 HINIC_MGMT_CMD_FAST_RECYCLE_MODE_SET,
1529 &fast_recycled_mode,
1530 sizeof(fast_recycled_mode),
1531 &fast_recycled_mode, &out_size, 0);
1532 if (err || fast_recycled_mode.mgmt_msg_head.status || !out_size) {
1533 PMD_DRV_LOG(ERR, "Failed to set recycle mode, ret: %d",
1534 fast_recycled_mode.mgmt_msg_head.status);
1541 int hinic_clear_vport_stats(struct hinic_hwdev *hwdev)
1543 struct hinic_clear_vport_stats clear_vport_stats;
1544 u16 out_size = sizeof(clear_vport_stats);
1548 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1552 memset(&clear_vport_stats, 0, sizeof(clear_vport_stats));
1553 clear_vport_stats.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1554 clear_vport_stats.func_id = hinic_global_func_id(hwdev);
1556 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_CLEAN_VPORT_STAT,
1558 sizeof(clear_vport_stats),
1559 &clear_vport_stats, &out_size);
1560 if (err || !out_size || clear_vport_stats.mgmt_msg_head.status) {
1561 PMD_DRV_LOG(ERR, "Failed to clear vport statistics, err: %d, status: 0x%x, out size: 0x%x",
1562 err, clear_vport_stats.mgmt_msg_head.status, out_size);
1569 int hinic_clear_phy_port_stats(struct hinic_hwdev *hwdev)
1571 struct hinic_clear_port_stats clear_phy_port_stats;
1572 u16 out_size = sizeof(clear_phy_port_stats);
1576 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1580 memset(&clear_phy_port_stats, 0, sizeof(clear_phy_port_stats));
1581 clear_phy_port_stats.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1582 clear_phy_port_stats.func_id = hinic_global_func_id(hwdev);
1584 err = l2nic_msg_to_mgmt_sync(hwdev,
1585 HINIC_PORT_CMD_CLEAR_PORT_STATISTICS,
1586 &clear_phy_port_stats,
1587 sizeof(clear_phy_port_stats),
1588 &clear_phy_port_stats, &out_size);
1589 if (err || !out_size || clear_phy_port_stats.mgmt_msg_head.status) {
1590 PMD_DRV_LOG(ERR, "Failed to clear phy port statistics, err: %d, status: 0x%x, out size: 0x%x",
1591 err, clear_phy_port_stats.mgmt_msg_head.status,
1599 int hinic_set_link_status_follow(void *hwdev,
1600 enum hinic_link_follow_status status)
1602 struct hinic_set_link_follow follow;
1603 u16 out_size = sizeof(follow);
1609 if (HINIC_IS_VF((struct hinic_hwdev *)hwdev))
1612 if (status >= HINIC_LINK_FOLLOW_STATUS_MAX) {
1613 PMD_DRV_LOG(ERR, "Invalid link follow status: %d", status);
1617 memset(&follow, 0, sizeof(follow));
1618 follow.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1619 follow.func_id = hinic_global_func_id(hwdev);
1620 follow.follow_status = status;
1622 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_LINK_FOLLOW,
1623 &follow, sizeof(follow),
1624 &follow, &out_size);
1625 if ((follow.mgmt_msg_head.status != HINIC_MGMT_CMD_UNSUPPORTED &&
1626 follow.mgmt_msg_head.status) || err || !out_size) {
1628 "Failed to set link status follow phy port status, err: %d, status: 0x%x, out size: 0x%x",
1629 err, follow.mgmt_msg_head.status, out_size);
1633 return follow.mgmt_msg_head.status;
1636 int hinic_get_link_mode(void *hwdev, u32 *supported, u32 *advertised)
1638 struct hinic_link_mode_cmd link_mode;
1639 u16 out_size = sizeof(link_mode);
1642 if (!hwdev || !supported || !advertised)
1645 memset(&link_mode, 0, sizeof(link_mode));
1646 link_mode.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1647 link_mode.func_id = hinic_global_func_id(hwdev);
1649 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_GET_LINK_MODE,
1650 &link_mode, sizeof(link_mode),
1651 &link_mode, &out_size);
1652 if (err || !out_size || link_mode.mgmt_msg_head.status) {
1654 "Failed to get link mode, err: %d, status: 0x%x, out size: 0x%x",
1655 err, link_mode.mgmt_msg_head.status, out_size);
1659 *supported = link_mode.supported;
1660 *advertised = link_mode.advertised;
1666 * hinic_set_xsfp_tx_status - Enable or disable the fiber in
1667 * tx direction when set link up or down.
1670 * The hardware interface of a nic device.
1672 * Enable or Disable.
1676 * negative error value otherwise.
1678 int hinic_set_xsfp_tx_status(void *hwdev, bool enable)
1680 struct hinic_set_xsfp_status xsfp_status;
1681 u16 out_size = sizeof(struct hinic_set_xsfp_status);
1684 memset(&xsfp_status, 0, sizeof(xsfp_status));
1685 xsfp_status.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1686 xsfp_status.port_id = hinic_global_func_id(hwdev);
1687 xsfp_status.xsfp_tx_dis = ((enable == 0) ? 1 : 0);
1689 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_SET_XSFP_STATUS,
1690 &xsfp_status, sizeof(struct hinic_set_xsfp_status),
1691 &xsfp_status, &out_size);
1692 if (err || !out_size || xsfp_status.mgmt_msg_head.status) {
1694 "Failed to %s port xsfp status, err: %d, status: 0x%x, out size: 0x%x\n",
1695 enable ? "Disable" : "Enable", err,
1696 xsfp_status.mgmt_msg_head.status, out_size);
1704 * hinic_flush_qp_res - Flush tx && rx chip resources in case of set vport
1705 * fake failed when device start.
1708 * The hardware interface of a nic device.
1712 * negative error value otherwise.
1714 int hinic_flush_qp_res(void *hwdev)
1716 struct hinic_clear_qp_resource qp_res;
1717 u16 out_size = sizeof(qp_res);
1720 memset(&qp_res, 0, sizeof(qp_res));
1721 qp_res.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1722 qp_res.func_id = hinic_global_func_id(hwdev);
1724 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_CLEAR_QP_RES,
1725 &qp_res, sizeof(qp_res), &qp_res,
1727 if (err || !out_size || qp_res.mgmt_msg_head.status) {
1728 PMD_DRV_LOG(ERR, "Failed to clear sq resources, err: %d, status: 0x%x, out size: 0x%x",
1729 err, qp_res.mgmt_msg_head.status, out_size);
1737 * hinic_vf_get_default_cos - Get default cos of VF.
1740 * The hardware interface of a nic device.
1746 * negative error value otherwise.
1748 int hinic_vf_get_default_cos(struct hinic_hwdev *hwdev, u8 *cos_id)
1750 struct hinic_vf_default_cos vf_cos;
1751 u16 out_size = sizeof(vf_cos);
1754 memset(&vf_cos, 0, sizeof(vf_cos));
1755 vf_cos.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1757 err = hinic_msg_to_mgmt_sync(hwdev, HINIC_MOD_L2NIC,
1758 HINIC_PORT_CMD_GET_VF_COS, &vf_cos,
1759 sizeof(vf_cos), &vf_cos,
1761 if (err || !out_size || vf_cos.mgmt_msg_head.status) {
1762 PMD_DRV_LOG(ERR, "Get VF default cos failed, err: %d, status: 0x%x, out size: 0x%x",
1763 err, vf_cos.mgmt_msg_head.status, out_size);
1766 *cos_id = vf_cos.state.default_cos;
1772 * hinic_set_fdir_filter - Set fdir filter for control path
1773 * packet to notify firmware.
1776 * The hardware interface of a nic device.
1777 * @param filter_type
1778 * Packet type to filter.
1781 * @param type_enable
1782 * The status of pkt type filter.
1784 * Fdir function Enable or Disable.
1787 * negative error value otherwise.
1789 int hinic_set_fdir_filter(void *hwdev, u8 filter_type, u8 qid, u8 type_enable,
1792 struct hinic_port_qfilter_info port_filer_cmd;
1793 u16 out_size = sizeof(port_filer_cmd);
1799 memset(&port_filer_cmd, 0, sizeof(port_filer_cmd));
1800 port_filer_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1801 port_filer_cmd.func_id = hinic_global_func_id(hwdev);
1802 port_filer_cmd.filter_enable = (u8)enable;
1803 port_filer_cmd.filter_type = filter_type;
1804 port_filer_cmd.qid = qid;
1805 port_filer_cmd.filter_type_enable = type_enable;
1806 port_filer_cmd.fdir_flag = 0;
1808 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_Q_FILTER,
1809 &port_filer_cmd, sizeof(port_filer_cmd),
1810 &port_filer_cmd, &out_size);
1811 if (err || !out_size || port_filer_cmd.mgmt_msg_head.status) {
1812 PMD_DRV_LOG(ERR, "Set port Q filter failed, err: %d, status: 0x%x, out size: 0x%x, type: 0x%x,"
1813 " enable: 0x%x, qid: 0x%x, filter_type_enable: 0x%x\n",
1814 err, port_filer_cmd.mgmt_msg_head.status, out_size,
1815 filter_type, enable, qid, type_enable);
1823 * hinic_set_normal_filter - Set fdir filter for IO path packet.
1826 * The hardware interface of a nic device.
1829 * @param normal_type_enable
1830 * IO path packet function Enable or Disable
1832 * IO path packet filter key value, such as DIP from pkt.
1834 * Fdir function Enable or Disable.
1836 * Filter flag, such as dip or others.
1839 * negative error value otherwise.
1841 int hinic_set_normal_filter(void *hwdev, u8 qid, u8 normal_type_enable,
1842 u32 key, bool enable, u8 flag)
1844 struct hinic_port_qfilter_info port_filer_cmd;
1845 u16 out_size = sizeof(port_filer_cmd);
1851 memset(&port_filer_cmd, 0, sizeof(port_filer_cmd));
1852 port_filer_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1853 port_filer_cmd.func_id = hinic_global_func_id(hwdev);
1854 port_filer_cmd.filter_enable = (u8)enable;
1855 port_filer_cmd.qid = qid;
1856 port_filer_cmd.normal_type_enable = normal_type_enable;
1857 port_filer_cmd.fdir_flag = flag; /* fdir flag: support dip */
1858 port_filer_cmd.key = key;
1860 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_Q_FILTER,
1861 &port_filer_cmd, sizeof(port_filer_cmd),
1862 &port_filer_cmd, &out_size);
1863 if (err || !out_size || port_filer_cmd.mgmt_msg_head.status) {
1864 PMD_DRV_LOG(ERR, "Set normal filter failed, err: %d, status: 0x%x, out size: 0x%x, fdir_flag: 0x%x,"
1865 " enable: 0x%x, qid: 0x%x, normal_type_enable: 0x%x, key:0x%x\n",
1866 err, port_filer_cmd.mgmt_msg_head.status, out_size,
1867 flag, enable, qid, normal_type_enable, key);
1875 * hinic_set_fdir_tcam - Set fdir filter for control packet
1876 * by tcam table to notify hardware.
1879 * The hardware interface of a nic device.
1882 * @param filter_rule
1883 * TCAM rule for control packet, such as lacp or bgp.
1884 * @param filter_action
1885 * TCAM action for control packet, such as accept or drop.
1888 * negative error value otherwise.
1890 int hinic_set_fdir_tcam(void *hwdev, u16 type_mask,
1891 struct tag_pa_rule *filter_rule,
1892 struct tag_pa_action *filter_action)
1894 struct hinic_fdir_tcam_info port_tcam_cmd;
1895 u16 out_size = sizeof(port_tcam_cmd);
1901 memset(&port_tcam_cmd, 0, sizeof(port_tcam_cmd));
1902 port_tcam_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1903 port_tcam_cmd.tcam_index = type_mask;
1904 port_tcam_cmd.flag = TCAM_SET;
1905 memcpy((void *)&port_tcam_cmd.filter_rule,
1906 (void *)filter_rule, sizeof(struct tag_pa_rule));
1907 memcpy((void *)&port_tcam_cmd.filter_action,
1908 (void *)filter_action, sizeof(struct tag_pa_action));
1910 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_TCAM_FILTER,
1911 &port_tcam_cmd, sizeof(port_tcam_cmd),
1912 &port_tcam_cmd, &out_size);
1913 if (err || !out_size || port_tcam_cmd.mgmt_msg_head.status) {
1914 PMD_DRV_LOG(ERR, "Set tcam table failed, err: %d, status: 0x%x, out size: 0x%x",
1915 err, port_tcam_cmd.mgmt_msg_head.status, out_size);
1923 * hinic_clear_fdir_tcam - Clear fdir filter TCAM table for control packet.
1926 * The hardware interface of a nic device.
1931 * negative error value otherwise.
1933 int hinic_clear_fdir_tcam(void *hwdev, u16 type_mask)
1935 struct hinic_fdir_tcam_info port_tcam_cmd;
1936 u16 out_size = sizeof(port_tcam_cmd);
1942 memset(&port_tcam_cmd, 0, sizeof(port_tcam_cmd));
1943 port_tcam_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1944 port_tcam_cmd.tcam_index = type_mask;
1945 port_tcam_cmd.flag = TCAM_CLEAR;
1947 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_TCAM_FILTER,
1948 &port_tcam_cmd, sizeof(port_tcam_cmd),
1949 &port_tcam_cmd, &out_size);
1950 if (err || !out_size || port_tcam_cmd.mgmt_msg_head.status) {
1951 PMD_DRV_LOG(ERR, "Clear tcam table failed, err: %d, status: 0x%x, out size: 0x%x",
1952 err, port_tcam_cmd.mgmt_msg_head.status, out_size);
1959 int hinic_add_tcam_rule(void *hwdev, struct tag_tcam_cfg_rule *tcam_rule)
1961 u16 out_size = sizeof(struct tag_fdir_add_rule_cmd);
1962 struct tag_fdir_add_rule_cmd tcam_cmd;
1966 PMD_DRV_LOG(ERR, "Hwdev is NULL");
1970 if (tcam_rule->index >= HINIC_MAX_TCAM_RULES_NUM) {
1971 PMD_DRV_LOG(ERR, "Tcam rules num to add is invalid");
1975 memset(&tcam_cmd, 0, sizeof(struct tag_fdir_add_rule_cmd));
1976 tcam_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
1977 memcpy((void *)&tcam_cmd.rule, (void *)tcam_rule,
1978 sizeof(struct tag_tcam_cfg_rule));
1980 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_UP_TC_ADD_FLOW,
1981 &tcam_cmd, sizeof(tcam_cmd),
1982 &tcam_cmd, &out_size);
1983 if (err || tcam_cmd.mgmt_msg_head.status || !out_size) {
1985 "Add tcam rule failed, err: %d, status: 0x%x, out size: 0x%x",
1986 err, tcam_cmd.mgmt_msg_head.status, out_size);
1993 int hinic_del_tcam_rule(void *hwdev, u32 index)
1995 u16 out_size = sizeof(struct tag_fdir_del_rule_cmd);
1996 struct tag_fdir_del_rule_cmd tcam_cmd;
2000 PMD_DRV_LOG(ERR, "Hwdev is NULL");
2004 if (index >= HINIC_MAX_TCAM_RULES_NUM) {
2005 PMD_DRV_LOG(ERR, "Tcam rules num to del is invalid");
2009 memset(&tcam_cmd, 0, sizeof(struct tag_fdir_del_rule_cmd));
2010 tcam_cmd.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
2011 tcam_cmd.index_start = index;
2012 tcam_cmd.index_num = 1;
2014 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_UP_TC_DEL_FLOW,
2015 &tcam_cmd, sizeof(tcam_cmd),
2016 &tcam_cmd, &out_size);
2017 if (err || tcam_cmd.mgmt_msg_head.status || !out_size) {
2019 "Del tcam rule failed, err: %d, status: 0x%x, out size: 0x%x",
2020 err, tcam_cmd.mgmt_msg_head.status, out_size);
2027 static int hinic_mgmt_tcam_block(void *hwdev, u8 alloc_en,
2028 u8 block_type, u16 *index)
2030 struct hinic_cmd_ctrl_tcam_block tcam_block_info;
2031 u16 out_size = sizeof(struct hinic_cmd_ctrl_tcam_block);
2032 struct hinic_hwdev *nic_hwdev = (struct hinic_hwdev *)hwdev;
2036 PMD_DRV_LOG(ERR, "Hwdev is NULL");
2040 memset(&tcam_block_info, 0, sizeof(struct hinic_cmd_ctrl_tcam_block));
2041 tcam_block_info.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
2042 tcam_block_info.func_id = hinic_global_func_id(hwdev);
2043 tcam_block_info.alloc_en = alloc_en;
2044 tcam_block_info.tcam_type = block_type;
2045 tcam_block_info.tcam_block_index = *index;
2047 err = l2nic_msg_to_mgmt_sync(hwdev,
2048 HINIC_PORT_CMD_UP_TC_CTRL_TCAM_BLOCK,
2049 &tcam_block_info, sizeof(tcam_block_info),
2050 &tcam_block_info, &out_size);
2051 if (tcam_block_info.mgmt_msg_head.status ==
2052 HINIC_MGMT_CMD_UNSUPPORTED) {
2053 err = HINIC_MGMT_CMD_UNSUPPORTED;
2054 PMD_DRV_LOG(INFO, "Firmware/uP doesn't support alloc or del tcam block");
2056 } else if ((err == HINIC_MBOX_VF_CMD_ERROR) &&
2057 (HINIC_IS_VF(nic_hwdev))) {
2058 err = HINIC_MGMT_CMD_UNSUPPORTED;
2059 PMD_DRV_LOG(INFO, "VF doesn't support alloc and del tcam block.");
2061 } else if (err || (!out_size) || tcam_block_info.mgmt_msg_head.status) {
2063 "Set tcam block failed, err: %d, status: 0x%x, out size: 0x%x",
2064 err, tcam_block_info.mgmt_msg_head.status, out_size);
2069 *index = tcam_block_info.tcam_block_index;
2074 int hinic_alloc_tcam_block(void *hwdev, u8 block_type, u16 *index)
2076 return hinic_mgmt_tcam_block(hwdev, HINIC_TCAM_BLOCK_ENABLE,
2080 int hinic_free_tcam_block(void *hwdev, u8 block_type, u16 *index)
2082 return hinic_mgmt_tcam_block(hwdev, HINIC_TCAM_BLOCK_DISABLE,
2086 int hinic_flush_tcam_rule(void *hwdev)
2088 struct hinic_cmd_flush_tcam_rules tcam_flush;
2089 u16 out_size = sizeof(struct hinic_cmd_flush_tcam_rules);
2090 struct hinic_hwdev *nic_hwdev = (struct hinic_hwdev *)hwdev;
2094 PMD_DRV_LOG(ERR, "Hwdev is NULL");
2098 memset(&tcam_flush, 0, sizeof(struct hinic_cmd_flush_tcam_rules));
2099 tcam_flush.mgmt_msg_head.resp_aeq_num = HINIC_AEQ1;
2100 tcam_flush.func_id = hinic_global_func_id(hwdev);
2102 err = l2nic_msg_to_mgmt_sync(hwdev, HINIC_PORT_CMD_UP_TC_FLUSH_TCAM,
2103 &tcam_flush, sizeof(struct hinic_cmd_flush_tcam_rules),
2104 &tcam_flush, &out_size);
2105 if (tcam_flush.mgmt_msg_head.status == HINIC_MGMT_CMD_UNSUPPORTED) {
2106 err = HINIC_MGMT_CMD_UNSUPPORTED;
2107 PMD_DRV_LOG(INFO, "Firmware/uP doesn't support flush tcam fdir");
2108 } else if ((err == HINIC_MBOX_VF_CMD_ERROR) &&
2109 (HINIC_IS_VF(nic_hwdev))) {
2110 err = HINIC_MGMT_CMD_UNSUPPORTED;
2111 PMD_DRV_LOG(INFO, "VF doesn't support flush tcam fdir");
2112 } else if (err || (!out_size) || tcam_flush.mgmt_msg_head.status) {
2114 "Flush tcam fdir rules failed, err: %d, status: 0x%x, out size: 0x%x",
2115 err, tcam_flush.mgmt_msg_head.status, out_size);