1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Huawei HiNIC PCI Express Linux driver
4  * Copyright(c) 2017 Huawei Technologies Co., Ltd
5  */
6 
7 #include <linux/types.h>
8 #include <linux/netdevice.h>
9 #include <linux/etherdevice.h>
10 #include <linux/if_vlan.h>
11 #include <linux/pci.h>
12 #include <linux/device.h>
13 #include <linux/errno.h>
14 
15 #include "hinic_hw_if.h"
16 #include "hinic_hw_dev.h"
17 #include "hinic_port.h"
18 #include "hinic_dev.h"
19 
20 #define HINIC_MIN_MTU_SIZE              256
21 #define HINIC_MAX_JUMBO_FRAME_SIZE      15872
22 
23 enum mac_op {
24 	MAC_DEL,
25 	MAC_SET,
26 };
27 
28 /**
29  * change_mac - change(add or delete) mac address
30  * @nic_dev: nic device
31  * @addr: mac address
32  * @vlan_id: vlan number to set with the mac
33  * @op: add or delete the mac
34  *
35  * Return 0 - Success, negative - Failure
36  **/
37 static int change_mac(struct hinic_dev *nic_dev, const u8 *addr,
38 		      u16 vlan_id, enum mac_op op)
39 {
40 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
41 	struct hinic_port_mac_cmd port_mac_cmd;
42 	struct hinic_hwif *hwif = hwdev->hwif;
43 	u16 out_size = sizeof(port_mac_cmd);
44 	struct pci_dev *pdev = hwif->pdev;
45 	enum hinic_port_cmd cmd;
46 	int err;
47 
48 	if (op == MAC_SET)
49 		cmd = HINIC_PORT_CMD_SET_MAC;
50 	else
51 		cmd = HINIC_PORT_CMD_DEL_MAC;
52 
53 	port_mac_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
54 	port_mac_cmd.vlan_id = vlan_id;
55 	memcpy(port_mac_cmd.mac, addr, ETH_ALEN);
56 
57 	err = hinic_port_msg_cmd(hwdev, cmd, &port_mac_cmd,
58 				 sizeof(port_mac_cmd),
59 				 &port_mac_cmd, &out_size);
60 	if (err || out_size != sizeof(port_mac_cmd) ||
61 	    (port_mac_cmd.status &&
62 	     (port_mac_cmd.status != HINIC_PF_SET_VF_ALREADY || !HINIC_IS_VF(hwif)) &&
63 	     port_mac_cmd.status != HINIC_MGMT_STATUS_EXIST)) {
64 		dev_err(&pdev->dev, "Failed to change MAC, err: %d, status: 0x%x, out size: 0x%x\n",
65 			err, port_mac_cmd.status, out_size);
66 		return -EFAULT;
67 	}
68 
69 	if (port_mac_cmd.status == HINIC_PF_SET_VF_ALREADY) {
70 		dev_warn(&pdev->dev, "PF has already set VF mac, ignore %s operation\n",
71 			 (op == MAC_SET) ? "set" : "del");
72 		return HINIC_PF_SET_VF_ALREADY;
73 	}
74 
75 	if (cmd == HINIC_PORT_CMD_SET_MAC && port_mac_cmd.status ==
76 	    HINIC_MGMT_STATUS_EXIST)
77 		dev_warn(&pdev->dev, "MAC is repeated, ignore set operation\n");
78 
79 	return 0;
80 }
81 
82 /**
83  * hinic_port_add_mac - add mac address
84  * @nic_dev: nic device
85  * @addr: mac address
86  * @vlan_id: vlan number to set with the mac
87  *
88  * Return 0 - Success, negative - Failure
89  **/
90 int hinic_port_add_mac(struct hinic_dev *nic_dev,
91 		       const u8 *addr, u16 vlan_id)
92 {
93 	return change_mac(nic_dev, addr, vlan_id, MAC_SET);
94 }
95 
96 /**
97  * hinic_port_del_mac - remove mac address
98  * @nic_dev: nic device
99  * @addr: mac address
100  * @vlan_id: vlan number that is connected to the mac
101  *
102  * Return 0 - Success, negative - Failure
103  **/
104 int hinic_port_del_mac(struct hinic_dev *nic_dev, const u8 *addr,
105 		       u16 vlan_id)
106 {
107 	return change_mac(nic_dev, addr, vlan_id, MAC_DEL);
108 }
109 
110 /**
111  * hinic_port_get_mac - get the mac address of the nic device
112  * @nic_dev: nic device
113  * @addr: returned mac address
114  *
115  * Return 0 - Success, negative - Failure
116  **/
117 int hinic_port_get_mac(struct hinic_dev *nic_dev, u8 *addr)
118 {
119 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
120 	struct hinic_port_mac_cmd port_mac_cmd;
121 	struct hinic_hwif *hwif = hwdev->hwif;
122 	u16 out_size = sizeof(port_mac_cmd);
123 	struct pci_dev *pdev = hwif->pdev;
124 	int err;
125 
126 	port_mac_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
127 
128 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_MAC,
129 				 &port_mac_cmd, sizeof(port_mac_cmd),
130 				 &port_mac_cmd, &out_size);
131 	if (err || (out_size != sizeof(port_mac_cmd)) || port_mac_cmd.status) {
132 		dev_err(&pdev->dev, "Failed to get mac, err: %d, status: 0x%x, out size: 0x%x\n",
133 			err, port_mac_cmd.status, out_size);
134 		return -EFAULT;
135 	}
136 
137 	memcpy(addr, port_mac_cmd.mac, ETH_ALEN);
138 	return 0;
139 }
140 
141 /**
142  * hinic_port_set_mtu - set mtu
143  * @nic_dev: nic device
144  * @new_mtu: new mtu
145  *
146  * Return 0 - Success, negative - Failure
147  **/
148 int hinic_port_set_mtu(struct hinic_dev *nic_dev, int new_mtu)
149 {
150 	struct net_device *netdev = nic_dev->netdev;
151 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
152 	struct hinic_port_mtu_cmd port_mtu_cmd;
153 	struct hinic_hwif *hwif = hwdev->hwif;
154 	u16 out_size = sizeof(port_mtu_cmd);
155 	struct pci_dev *pdev = hwif->pdev;
156 	int err, max_frame;
157 
158 	if (new_mtu < HINIC_MIN_MTU_SIZE) {
159 		netif_err(nic_dev, drv, netdev, "mtu < MIN MTU size");
160 		return -EINVAL;
161 	}
162 
163 	max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
164 	if (max_frame > HINIC_MAX_JUMBO_FRAME_SIZE) {
165 		netif_err(nic_dev, drv, netdev, "mtu > MAX MTU size");
166 		return -EINVAL;
167 	}
168 
169 	port_mtu_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
170 	port_mtu_cmd.mtu = new_mtu;
171 
172 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_CHANGE_MTU,
173 				 &port_mtu_cmd, sizeof(port_mtu_cmd),
174 				 &port_mtu_cmd, &out_size);
175 	if (err || out_size != sizeof(port_mtu_cmd) || port_mtu_cmd.status) {
176 		dev_err(&pdev->dev, "Failed to set mtu, err: %d, status: 0x%x, out size: 0x%x\n",
177 			err, port_mtu_cmd.status, out_size);
178 		return -EFAULT;
179 	}
180 
181 	return 0;
182 }
183 
184 /**
185  * hinic_port_add_vlan - add vlan to the nic device
186  * @nic_dev: nic device
187  * @vlan_id: the vlan number to add
188  *
189  * Return 0 - Success, negative - Failure
190  **/
191 int hinic_port_add_vlan(struct hinic_dev *nic_dev, u16 vlan_id)
192 {
193 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
194 	struct hinic_port_vlan_cmd port_vlan_cmd;
195 
196 	port_vlan_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
197 	port_vlan_cmd.vlan_id = vlan_id;
198 
199 	return hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_ADD_VLAN,
200 				  &port_vlan_cmd, sizeof(port_vlan_cmd),
201 				  NULL, NULL);
202 }
203 
204 /**
205  * hinic_port_del_vlan - delete vlan from the nic device
206  * @nic_dev: nic device
207  * @vlan_id: the vlan number to delete
208  *
209  * Return 0 - Success, negative - Failure
210  **/
211 int hinic_port_del_vlan(struct hinic_dev *nic_dev, u16 vlan_id)
212 {
213 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
214 	struct hinic_port_vlan_cmd port_vlan_cmd;
215 
216 	port_vlan_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
217 	port_vlan_cmd.vlan_id = vlan_id;
218 
219 	return hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_DEL_VLAN,
220 				 &port_vlan_cmd, sizeof(port_vlan_cmd),
221 				 NULL, NULL);
222 }
223 
224 /**
225  * hinic_port_set_rx_mode - set rx mode in the nic device
226  * @nic_dev: nic device
227  * @rx_mode: the rx mode to set
228  *
229  * Return 0 - Success, negative - Failure
230  **/
231 int hinic_port_set_rx_mode(struct hinic_dev *nic_dev, u32 rx_mode)
232 {
233 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
234 	struct hinic_port_rx_mode_cmd rx_mode_cmd;
235 
236 	rx_mode_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
237 	rx_mode_cmd.rx_mode = rx_mode;
238 
239 	return hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RX_MODE,
240 				  &rx_mode_cmd, sizeof(rx_mode_cmd),
241 				  NULL, NULL);
242 }
243 
244 /**
245  * hinic_port_link_state - get the link state
246  * @nic_dev: nic device
247  * @link_state: the returned link state
248  *
249  * Return 0 - Success, negative - Failure
250  **/
251 int hinic_port_link_state(struct hinic_dev *nic_dev,
252 			  enum hinic_port_link_state *link_state)
253 {
254 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
255 	struct hinic_hwif *hwif = hwdev->hwif;
256 	struct hinic_port_link_cmd link_cmd;
257 	struct pci_dev *pdev = hwif->pdev;
258 	u16 out_size = sizeof(link_cmd);
259 	int err;
260 
261 	link_cmd.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
262 
263 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_LINK_STATE,
264 				 &link_cmd, sizeof(link_cmd),
265 				 &link_cmd, &out_size);
266 	if (err || (out_size != sizeof(link_cmd)) || link_cmd.status) {
267 		dev_err(&pdev->dev, "Failed to get link state, err: %d, status: 0x%x, out size: 0x%x\n",
268 			err, link_cmd.status, out_size);
269 		return -EINVAL;
270 	}
271 
272 	*link_state = link_cmd.state;
273 	return 0;
274 }
275 
276 /**
277  * hinic_port_set_state - set port state
278  * @nic_dev: nic device
279  * @state: the state to set
280  *
281  * Return 0 - Success, negative - Failure
282  **/
283 int hinic_port_set_state(struct hinic_dev *nic_dev, enum hinic_port_state state)
284 {
285 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
286 	struct hinic_port_state_cmd port_state;
287 	struct hinic_hwif *hwif = hwdev->hwif;
288 	struct pci_dev *pdev = hwif->pdev;
289 	u16 out_size = sizeof(port_state);
290 	int err;
291 
292 	if (HINIC_IS_VF(hwdev->hwif))
293 		return 0;
294 
295 	port_state.state = state;
296 
297 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_PORT_STATE,
298 				 &port_state, sizeof(port_state),
299 				 &port_state, &out_size);
300 	if (err || (out_size != sizeof(port_state)) || port_state.status) {
301 		dev_err(&pdev->dev, "Failed to set port state, err: %d, status: 0x%x, out size: 0x%x\n",
302 			err, port_state.status, out_size);
303 		return -EFAULT;
304 	}
305 
306 	return 0;
307 }
308 
309 /**
310  * hinic_port_set_func_state- set func device state
311  * @nic_dev: nic device
312  * @state: the state to set
313  *
314  * Return 0 - Success, negative - Failure
315  **/
316 int hinic_port_set_func_state(struct hinic_dev *nic_dev,
317 			      enum hinic_func_port_state state)
318 {
319 	struct hinic_port_func_state_cmd func_state;
320 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
321 	struct hinic_hwif *hwif = hwdev->hwif;
322 	struct pci_dev *pdev = hwif->pdev;
323 	u16 out_size = sizeof(func_state);
324 	int err;
325 
326 	func_state.func_idx = HINIC_HWIF_FUNC_IDX(hwif);
327 	func_state.state = state;
328 
329 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_FUNC_STATE,
330 				 &func_state, sizeof(func_state),
331 				 &func_state, &out_size);
332 	if (err || (out_size != sizeof(func_state)) || func_state.status) {
333 		dev_err(&pdev->dev, "Failed to set port func state, err: %d, status: 0x%x, out size: 0x%x\n",
334 			err, func_state.status, out_size);
335 		return -EFAULT;
336 	}
337 
338 	return 0;
339 }
340 
341 /**
342  * hinic_port_get_cap - get port capabilities
343  * @nic_dev: nic device
344  * @port_cap: returned port capabilities
345  *
346  * Return 0 - Success, negative - Failure
347  **/
348 int hinic_port_get_cap(struct hinic_dev *nic_dev,
349 		       struct hinic_port_cap *port_cap)
350 {
351 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
352 	struct hinic_hwif *hwif = hwdev->hwif;
353 	struct pci_dev *pdev = hwif->pdev;
354 	u16 out_size = sizeof(*port_cap);
355 	int err;
356 
357 	port_cap->func_idx = HINIC_HWIF_FUNC_IDX(hwif);
358 
359 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_CAP,
360 				 port_cap, sizeof(*port_cap),
361 				 port_cap, &out_size);
362 	if (err || (out_size != sizeof(*port_cap)) || port_cap->status) {
363 		dev_err(&pdev->dev,
364 			"Failed to get port capabilities, err: %d, status: 0x%x, out size: 0x%x\n",
365 			err, port_cap->status, out_size);
366 		return -EIO;
367 	}
368 
369 	return 0;
370 }
371 
372 /**
373  * hinic_port_set_tso - set port tso configuration
374  * @nic_dev: nic device
375  * @state: the tso state to set
376  *
377  * Return 0 - Success, negative - Failure
378  **/
379 int hinic_port_set_tso(struct hinic_dev *nic_dev, enum hinic_tso_state state)
380 {
381 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
382 	struct hinic_hwif *hwif = hwdev->hwif;
383 	struct hinic_tso_config tso_cfg = {0};
384 	struct pci_dev *pdev = hwif->pdev;
385 	u16 out_size = sizeof(tso_cfg);
386 	int err;
387 
388 	tso_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
389 	tso_cfg.tso_en = state;
390 
391 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_TSO,
392 				 &tso_cfg, sizeof(tso_cfg),
393 				 &tso_cfg, &out_size);
394 	if (err || out_size != sizeof(tso_cfg) || tso_cfg.status) {
395 		dev_err(&pdev->dev,
396 			"Failed to set port tso, err: %d, status: 0x%x, out size: 0x%x\n",
397 			err, tso_cfg.status, out_size);
398 		return -EIO;
399 	}
400 
401 	return 0;
402 }
403 
404 int hinic_set_rx_csum_offload(struct hinic_dev *nic_dev, u32 en)
405 {
406 	struct hinic_checksum_offload rx_csum_cfg = {0};
407 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
408 	u16 out_size = sizeof(rx_csum_cfg);
409 	struct hinic_hwif *hwif;
410 	struct pci_dev *pdev;
411 	int err;
412 
413 	if (!hwdev)
414 		return -EINVAL;
415 
416 	hwif = hwdev->hwif;
417 	pdev = hwif->pdev;
418 	rx_csum_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
419 	rx_csum_cfg.rx_csum_offload = en;
420 
421 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RX_CSUM,
422 				 &rx_csum_cfg, sizeof(rx_csum_cfg),
423 				 &rx_csum_cfg, &out_size);
424 	if (err || !out_size || rx_csum_cfg.status) {
425 		dev_err(&pdev->dev,
426 			"Failed to set rx csum offload, err: %d, status: 0x%x, out size: 0x%x\n",
427 			err, rx_csum_cfg.status, out_size);
428 		return -EIO;
429 	}
430 
431 	return 0;
432 }
433 
434 int hinic_set_rx_vlan_offload(struct hinic_dev *nic_dev, u8 en)
435 {
436 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
437 	struct hinic_vlan_cfg vlan_cfg;
438 	struct hinic_hwif *hwif;
439 	struct pci_dev *pdev;
440 	u16 out_size;
441 	int err;
442 
443 	if (!hwdev)
444 		return -EINVAL;
445 
446 	out_size = sizeof(vlan_cfg);
447 	hwif = hwdev->hwif;
448 	pdev = hwif->pdev;
449 	vlan_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
450 	vlan_cfg.vlan_rx_offload = en;
451 
452 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RX_VLAN_OFFLOAD,
453 				 &vlan_cfg, sizeof(vlan_cfg),
454 				 &vlan_cfg, &out_size);
455 	if (err || !out_size || vlan_cfg.status) {
456 		dev_err(&pdev->dev,
457 			"Failed to set rx vlan offload, err: %d, status: 0x%x, out size: 0x%x\n",
458 			err, vlan_cfg.status, out_size);
459 		return -EINVAL;
460 	}
461 
462 	return 0;
463 }
464 
465 int hinic_set_max_qnum(struct hinic_dev *nic_dev, u8 num_rqs)
466 {
467 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
468 	struct hinic_hwif *hwif = hwdev->hwif;
469 	struct hinic_rq_num rq_num = { 0 };
470 	struct pci_dev *pdev = hwif->pdev;
471 	u16 out_size = sizeof(rq_num);
472 	int err;
473 
474 	rq_num.func_id = HINIC_HWIF_FUNC_IDX(hwif);
475 	rq_num.num_rqs = num_rqs;
476 	rq_num.rq_depth = ilog2(nic_dev->rq_depth);
477 
478 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RQ_IQ_MAP,
479 				 &rq_num, sizeof(rq_num),
480 				 &rq_num, &out_size);
481 	if (err || !out_size || rq_num.status) {
482 		dev_err(&pdev->dev,
483 			"Failed to set rxq number, err: %d, status: 0x%x, out size: 0x%x\n",
484 			err, rq_num.status, out_size);
485 		return -EIO;
486 	}
487 
488 	return 0;
489 }
490 
491 static int hinic_set_rx_lro(struct hinic_dev *nic_dev, u8 ipv4_en, u8 ipv6_en,
492 			    u8 max_wqe_num)
493 {
494 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
495 	struct hinic_lro_config lro_cfg = { 0 };
496 	struct hinic_hwif *hwif = hwdev->hwif;
497 	struct pci_dev *pdev = hwif->pdev;
498 	u16 out_size = sizeof(lro_cfg);
499 	int err;
500 
501 	lro_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
502 	lro_cfg.lro_ipv4_en = ipv4_en;
503 	lro_cfg.lro_ipv6_en = ipv6_en;
504 	lro_cfg.lro_max_wqe_num = max_wqe_num;
505 
506 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_LRO,
507 				 &lro_cfg, sizeof(lro_cfg),
508 				 &lro_cfg, &out_size);
509 	if (err || !out_size || lro_cfg.status) {
510 		dev_err(&pdev->dev,
511 			"Failed to set lro offload, err: %d, status: 0x%x, out size: 0x%x\n",
512 			err, lro_cfg.status, out_size);
513 		return -EIO;
514 	}
515 
516 	return 0;
517 }
518 
519 static int hinic_set_rx_lro_timer(struct hinic_dev *nic_dev, u32 timer_value)
520 {
521 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
522 	struct hinic_lro_timer lro_timer = { 0 };
523 	struct hinic_hwif *hwif = hwdev->hwif;
524 	struct pci_dev *pdev = hwif->pdev;
525 	u16 out_size = sizeof(lro_timer);
526 	int err;
527 
528 	lro_timer.status = 0;
529 	lro_timer.type = 0;
530 	lro_timer.enable = 1;
531 	lro_timer.timer = timer_value;
532 
533 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_LRO_TIMER,
534 				 &lro_timer, sizeof(lro_timer),
535 				 &lro_timer, &out_size);
536 	if (lro_timer.status == 0xFF) {
537 		/* For this case, we think status (0xFF) is OK */
538 		lro_timer.status = 0;
539 		dev_dbg(&pdev->dev,
540 			"Set lro timer not supported by the current FW version, it will be 1ms default\n");
541 	}
542 
543 	if (err || !out_size || lro_timer.status) {
544 		dev_err(&pdev->dev,
545 			"Failed to set lro timer, err: %d, status: 0x%x, out size: 0x%x\n",
546 			err, lro_timer.status, out_size);
547 
548 		return -EIO;
549 	}
550 
551 	return 0;
552 }
553 
554 int hinic_set_rx_lro_state(struct hinic_dev *nic_dev, u8 lro_en,
555 			   u32 lro_timer, u32 wqe_num)
556 {
557 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
558 	u8 ipv4_en;
559 	u8 ipv6_en;
560 	int err;
561 
562 	if (!hwdev)
563 		return -EINVAL;
564 
565 	ipv4_en = lro_en ? 1 : 0;
566 	ipv6_en = lro_en ? 1 : 0;
567 
568 	err = hinic_set_rx_lro(nic_dev, ipv4_en, ipv6_en, (u8)wqe_num);
569 	if (err)
570 		return err;
571 
572 	if (HINIC_IS_VF(nic_dev->hwdev->hwif))
573 		return 0;
574 
575 	err = hinic_set_rx_lro_timer(nic_dev, lro_timer);
576 	if (err)
577 		return err;
578 
579 	return 0;
580 }
581 
582 int hinic_rss_set_indir_tbl(struct hinic_dev *nic_dev, u32 tmpl_idx,
583 			    const u32 *indir_table)
584 {
585 	struct hinic_rss_indirect_tbl *indir_tbl;
586 	struct hinic_func_to_io *func_to_io;
587 	struct hinic_cmdq_buf cmd_buf;
588 	struct hinic_hwdev *hwdev;
589 	struct hinic_hwif *hwif;
590 	struct pci_dev *pdev;
591 	u32 indir_size;
592 	u64 out_param;
593 	int err, i;
594 	u32 *temp;
595 
596 	hwdev = nic_dev->hwdev;
597 	func_to_io = &hwdev->func_to_io;
598 	hwif = hwdev->hwif;
599 	pdev = hwif->pdev;
600 
601 	err = hinic_alloc_cmdq_buf(&func_to_io->cmdqs, &cmd_buf);
602 	if (err) {
603 		dev_err(&pdev->dev, "Failed to allocate cmdq buf\n");
604 		return err;
605 	}
606 
607 	cmd_buf.size = sizeof(*indir_tbl);
608 
609 	indir_tbl = cmd_buf.buf;
610 	indir_tbl->group_index = cpu_to_be32(tmpl_idx);
611 
612 	for (i = 0; i < HINIC_RSS_INDIR_SIZE; i++) {
613 		indir_tbl->entry[i] = indir_table[i];
614 
615 		if (0x3 == (i & 0x3)) {
616 			temp = (u32 *)&indir_tbl->entry[i - 3];
617 			*temp = cpu_to_be32(*temp);
618 		}
619 	}
620 
621 	/* cfg the rss indirect table by command queue */
622 	indir_size = HINIC_RSS_INDIR_SIZE / 2;
623 	indir_tbl->offset = 0;
624 	indir_tbl->size = cpu_to_be32(indir_size);
625 
626 	err = hinic_cmdq_direct_resp(&func_to_io->cmdqs, HINIC_MOD_L2NIC,
627 				     HINIC_UCODE_CMD_SET_RSS_INDIR_TABLE,
628 				     &cmd_buf, &out_param);
629 	if (err || out_param != 0) {
630 		dev_err(&pdev->dev, "Failed to set rss indir table\n");
631 		err = -EFAULT;
632 		goto free_buf;
633 	}
634 
635 	indir_tbl->offset = cpu_to_be32(indir_size);
636 	indir_tbl->size = cpu_to_be32(indir_size);
637 	memcpy(&indir_tbl->entry[0], &indir_tbl->entry[indir_size], indir_size);
638 
639 	err = hinic_cmdq_direct_resp(&func_to_io->cmdqs, HINIC_MOD_L2NIC,
640 				     HINIC_UCODE_CMD_SET_RSS_INDIR_TABLE,
641 				     &cmd_buf, &out_param);
642 	if (err || out_param != 0) {
643 		dev_err(&pdev->dev, "Failed to set rss indir table\n");
644 		err = -EFAULT;
645 	}
646 
647 free_buf:
648 	hinic_free_cmdq_buf(&func_to_io->cmdqs, &cmd_buf);
649 
650 	return err;
651 }
652 
653 int hinic_rss_get_indir_tbl(struct hinic_dev *nic_dev, u32 tmpl_idx,
654 			    u32 *indir_table)
655 {
656 	struct hinic_rss_indir_table rss_cfg = { 0 };
657 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
658 	struct hinic_hwif *hwif = hwdev->hwif;
659 	struct pci_dev *pdev = hwif->pdev;
660 	u16 out_size = sizeof(rss_cfg);
661 	int err = 0, i;
662 
663 	rss_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
664 	rss_cfg.template_id = tmpl_idx;
665 
666 	err = hinic_port_msg_cmd(hwdev,
667 				 HINIC_PORT_CMD_GET_RSS_TEMPLATE_INDIR_TBL,
668 				 &rss_cfg, sizeof(rss_cfg), &rss_cfg,
669 				 &out_size);
670 	if (err || !out_size || rss_cfg.status) {
671 		dev_err(&pdev->dev, "Failed to get indir table, err: %d, status: 0x%x, out size: 0x%x\n",
672 			err, rss_cfg.status, out_size);
673 		return -EINVAL;
674 	}
675 
676 	hinic_be32_to_cpu(rss_cfg.indir, HINIC_RSS_INDIR_SIZE);
677 	for (i = 0; i < HINIC_RSS_INDIR_SIZE; i++)
678 		indir_table[i] = rss_cfg.indir[i];
679 
680 	return 0;
681 }
682 
683 int hinic_set_rss_type(struct hinic_dev *nic_dev, u32 tmpl_idx,
684 		       struct hinic_rss_type rss_type)
685 {
686 	struct hinic_rss_context_tbl *ctx_tbl;
687 	struct hinic_func_to_io *func_to_io;
688 	struct hinic_cmdq_buf cmd_buf;
689 	struct hinic_hwdev *hwdev;
690 	struct hinic_hwif *hwif;
691 	struct pci_dev *pdev;
692 	u64 out_param;
693 	u32 ctx = 0;
694 	int err;
695 
696 	hwdev = nic_dev->hwdev;
697 	func_to_io = &hwdev->func_to_io;
698 	hwif = hwdev->hwif;
699 	pdev = hwif->pdev;
700 
701 	err = hinic_alloc_cmdq_buf(&func_to_io->cmdqs, &cmd_buf);
702 	if (err) {
703 		dev_err(&pdev->dev, "Failed to allocate cmd buf\n");
704 		return -ENOMEM;
705 	}
706 
707 	ctx |=  HINIC_RSS_TYPE_SET(1, VALID) |
708 		HINIC_RSS_TYPE_SET(rss_type.ipv4, IPV4) |
709 		HINIC_RSS_TYPE_SET(rss_type.ipv6, IPV6) |
710 		HINIC_RSS_TYPE_SET(rss_type.ipv6_ext, IPV6_EXT) |
711 		HINIC_RSS_TYPE_SET(rss_type.tcp_ipv4, TCP_IPV4) |
712 		HINIC_RSS_TYPE_SET(rss_type.tcp_ipv6, TCP_IPV6) |
713 		HINIC_RSS_TYPE_SET(rss_type.tcp_ipv6_ext, TCP_IPV6_EXT) |
714 		HINIC_RSS_TYPE_SET(rss_type.udp_ipv4, UDP_IPV4) |
715 		HINIC_RSS_TYPE_SET(rss_type.udp_ipv6, UDP_IPV6);
716 
717 	cmd_buf.size = sizeof(struct hinic_rss_context_tbl);
718 
719 	ctx_tbl = (struct hinic_rss_context_tbl *)cmd_buf.buf;
720 	ctx_tbl->group_index = cpu_to_be32(tmpl_idx);
721 	ctx_tbl->offset = 0;
722 	ctx_tbl->size = sizeof(u32);
723 	ctx_tbl->size = cpu_to_be32(ctx_tbl->size);
724 	ctx_tbl->rsvd = 0;
725 	ctx_tbl->ctx = cpu_to_be32(ctx);
726 
727 	/* cfg the rss context table by command queue */
728 	err = hinic_cmdq_direct_resp(&func_to_io->cmdqs, HINIC_MOD_L2NIC,
729 				     HINIC_UCODE_CMD_SET_RSS_CONTEXT_TABLE,
730 				     &cmd_buf, &out_param);
731 
732 	hinic_free_cmdq_buf(&func_to_io->cmdqs, &cmd_buf);
733 
734 	if (err || out_param != 0) {
735 		dev_err(&pdev->dev, "Failed to set rss context table, err: %d\n",
736 			err);
737 		return -EFAULT;
738 	}
739 
740 	return 0;
741 }
742 
743 int hinic_get_rss_type(struct hinic_dev *nic_dev, u32 tmpl_idx,
744 		       struct hinic_rss_type *rss_type)
745 {
746 	struct hinic_rss_context_table ctx_tbl = { 0 };
747 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
748 	u16 out_size = sizeof(ctx_tbl);
749 	struct hinic_hwif *hwif;
750 	struct pci_dev *pdev;
751 	int err;
752 
753 	if (!hwdev || !rss_type)
754 		return -EINVAL;
755 
756 	hwif = hwdev->hwif;
757 	pdev = hwif->pdev;
758 
759 	ctx_tbl.func_id = HINIC_HWIF_FUNC_IDX(hwif);
760 	ctx_tbl.template_id = tmpl_idx;
761 
762 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_RSS_CTX_TBL,
763 				 &ctx_tbl, sizeof(ctx_tbl),
764 				 &ctx_tbl, &out_size);
765 	if (err || !out_size || ctx_tbl.status) {
766 		dev_err(&pdev->dev, "Failed to get hash type, err: %d, status: 0x%x, out size: 0x%x\n",
767 			err, ctx_tbl.status, out_size);
768 		return -EINVAL;
769 	}
770 
771 	rss_type->ipv4          = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV4);
772 	rss_type->ipv6          = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV6);
773 	rss_type->ipv6_ext      = HINIC_RSS_TYPE_GET(ctx_tbl.context, IPV6_EXT);
774 	rss_type->tcp_ipv4      = HINIC_RSS_TYPE_GET(ctx_tbl.context, TCP_IPV4);
775 	rss_type->tcp_ipv6      = HINIC_RSS_TYPE_GET(ctx_tbl.context, TCP_IPV6);
776 	rss_type->tcp_ipv6_ext  = HINIC_RSS_TYPE_GET(ctx_tbl.context,
777 						     TCP_IPV6_EXT);
778 	rss_type->udp_ipv4      = HINIC_RSS_TYPE_GET(ctx_tbl.context, UDP_IPV4);
779 	rss_type->udp_ipv6      = HINIC_RSS_TYPE_GET(ctx_tbl.context, UDP_IPV6);
780 
781 	return 0;
782 }
783 
784 int hinic_rss_set_template_tbl(struct hinic_dev *nic_dev, u32 template_id,
785 			       const u8 *temp)
786 {
787 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
788 	struct hinic_hwif *hwif = hwdev->hwif;
789 	struct hinic_rss_key rss_key = { 0 };
790 	struct pci_dev *pdev = hwif->pdev;
791 	u16 out_size = sizeof(rss_key);
792 	int err;
793 
794 	rss_key.func_id = HINIC_HWIF_FUNC_IDX(hwif);
795 	rss_key.template_id = template_id;
796 	memcpy(rss_key.key, temp, HINIC_RSS_KEY_SIZE);
797 
798 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RSS_TEMPLATE_TBL,
799 				 &rss_key, sizeof(rss_key),
800 				 &rss_key, &out_size);
801 	if (err || !out_size || rss_key.status) {
802 		dev_err(&pdev->dev,
803 			"Failed to set rss hash key, err: %d, status: 0x%x, out size: 0x%x\n",
804 			err, rss_key.status, out_size);
805 		return -EINVAL;
806 	}
807 
808 	return 0;
809 }
810 
811 int hinic_rss_get_template_tbl(struct hinic_dev *nic_dev, u32 tmpl_idx,
812 			       u8 *temp)
813 {
814 	struct hinic_rss_template_key temp_key = { 0 };
815 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
816 	u16 out_size = sizeof(temp_key);
817 	struct hinic_hwif *hwif;
818 	struct pci_dev *pdev;
819 	int err;
820 
821 	if (!hwdev || !temp)
822 		return -EINVAL;
823 
824 	hwif = hwdev->hwif;
825 	pdev = hwif->pdev;
826 
827 	temp_key.func_id = HINIC_HWIF_FUNC_IDX(hwif);
828 	temp_key.template_id = tmpl_idx;
829 
830 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_RSS_TEMPLATE_TBL,
831 				 &temp_key, sizeof(temp_key),
832 				 &temp_key, &out_size);
833 	if (err || !out_size || temp_key.status) {
834 		dev_err(&pdev->dev, "Failed to set hash key, err: %d, status: 0x%x, out size: 0x%x\n",
835 			err, temp_key.status, out_size);
836 		return -EINVAL;
837 	}
838 
839 	memcpy(temp, temp_key.key, HINIC_RSS_KEY_SIZE);
840 
841 	return 0;
842 }
843 
844 int hinic_rss_set_hash_engine(struct hinic_dev *nic_dev, u8 template_id,
845 			      u8 type)
846 {
847 	struct hinic_rss_engine_type rss_engine = { 0 };
848 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
849 	struct hinic_hwif *hwif = hwdev->hwif;
850 	struct pci_dev *pdev = hwif->pdev;
851 	u16 out_size = sizeof(rss_engine);
852 	int err;
853 
854 	rss_engine.func_id = HINIC_HWIF_FUNC_IDX(hwif);
855 	rss_engine.hash_engine = type;
856 	rss_engine.template_id = template_id;
857 
858 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_RSS_HASH_ENGINE,
859 				 &rss_engine, sizeof(rss_engine),
860 				 &rss_engine, &out_size);
861 	if (err || !out_size || rss_engine.status) {
862 		dev_err(&pdev->dev,
863 			"Failed to set hash engine, err: %d, status: 0x%x, out size: 0x%x\n",
864 			err, rss_engine.status, out_size);
865 		return -EINVAL;
866 	}
867 
868 	return 0;
869 }
870 
871 int hinic_rss_get_hash_engine(struct hinic_dev *nic_dev, u8 tmpl_idx, u8 *type)
872 {
873 	struct hinic_rss_engine_type hash_type = { 0 };
874 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
875 	u16 out_size = sizeof(hash_type);
876 	struct hinic_hwif *hwif;
877 	struct pci_dev *pdev;
878 	int err;
879 
880 	if (!hwdev || !type)
881 		return -EINVAL;
882 
883 	hwif = hwdev->hwif;
884 	pdev = hwif->pdev;
885 
886 	hash_type.func_id = HINIC_HWIF_FUNC_IDX(hwif);
887 	hash_type.template_id = tmpl_idx;
888 
889 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_RSS_HASH_ENGINE,
890 				 &hash_type, sizeof(hash_type),
891 				 &hash_type, &out_size);
892 	if (err || !out_size || hash_type.status) {
893 		dev_err(&pdev->dev, "Failed to get hash engine, err: %d, status: 0x%x, out size: 0x%x\n",
894 			err, hash_type.status, out_size);
895 		return -EINVAL;
896 	}
897 
898 	*type = hash_type.hash_engine;
899 	return 0;
900 }
901 
902 int hinic_rss_cfg(struct hinic_dev *nic_dev, u8 rss_en, u8 template_id)
903 {
904 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
905 	struct hinic_rss_config rss_cfg = { 0 };
906 	struct hinic_hwif *hwif = hwdev->hwif;
907 	struct pci_dev *pdev = hwif->pdev;
908 	u16 out_size = sizeof(rss_cfg);
909 	int err;
910 
911 	rss_cfg.func_id = HINIC_HWIF_FUNC_IDX(hwif);
912 	rss_cfg.rss_en = rss_en;
913 	rss_cfg.template_id = template_id;
914 	rss_cfg.rq_priority_number = 0;
915 
916 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_RSS_CFG,
917 				 &rss_cfg, sizeof(rss_cfg),
918 				 &rss_cfg, &out_size);
919 	if (err || !out_size || rss_cfg.status) {
920 		dev_err(&pdev->dev,
921 			"Failed to set rss cfg, err: %d, status: 0x%x, out size: 0x%x\n",
922 			err, rss_cfg.status, out_size);
923 		return -EINVAL;
924 	}
925 
926 	return 0;
927 }
928 
929 int hinic_rss_template_alloc(struct hinic_dev *nic_dev, u8 *tmpl_idx)
930 {
931 	struct hinic_rss_template_mgmt template_mgmt = { 0 };
932 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
933 	struct hinic_hwif *hwif = hwdev->hwif;
934 	u16 out_size = sizeof(template_mgmt);
935 	struct pci_dev *pdev = hwif->pdev;
936 	int err;
937 
938 	template_mgmt.func_id = HINIC_HWIF_FUNC_IDX(hwif);
939 	template_mgmt.cmd = NIC_RSS_CMD_TEMP_ALLOC;
940 
941 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_RSS_TEMP_MGR,
942 				 &template_mgmt, sizeof(template_mgmt),
943 				 &template_mgmt, &out_size);
944 	if (err || !out_size || template_mgmt.status) {
945 		dev_err(&pdev->dev, "Failed to alloc rss template, err: %d, status: 0x%x, out size: 0x%x\n",
946 			err, template_mgmt.status, out_size);
947 		return -EINVAL;
948 	}
949 
950 	*tmpl_idx = template_mgmt.template_id;
951 
952 	return 0;
953 }
954 
955 int hinic_rss_template_free(struct hinic_dev *nic_dev, u8 tmpl_idx)
956 {
957 	struct hinic_rss_template_mgmt template_mgmt = { 0 };
958 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
959 	struct hinic_hwif *hwif = hwdev->hwif;
960 	u16 out_size = sizeof(template_mgmt);
961 	struct pci_dev *pdev = hwif->pdev;
962 	int err;
963 
964 	template_mgmt.func_id = HINIC_HWIF_FUNC_IDX(hwif);
965 	template_mgmt.template_id = tmpl_idx;
966 	template_mgmt.cmd = NIC_RSS_CMD_TEMP_FREE;
967 
968 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_RSS_TEMP_MGR,
969 				 &template_mgmt, sizeof(template_mgmt),
970 				 &template_mgmt, &out_size);
971 	if (err || !out_size || template_mgmt.status) {
972 		dev_err(&pdev->dev, "Failed to free rss template, err: %d, status: 0x%x, out size: 0x%x\n",
973 			err, template_mgmt.status, out_size);
974 		return -EINVAL;
975 	}
976 
977 	return 0;
978 }
979 
980 int hinic_get_vport_stats(struct hinic_dev *nic_dev,
981 			  struct hinic_vport_stats *stats)
982 {
983 	struct hinic_cmd_vport_stats vport_stats = { 0 };
984 	struct hinic_port_stats_info stats_info = { 0 };
985 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
986 	struct hinic_hwif *hwif = hwdev->hwif;
987 	u16 out_size = sizeof(vport_stats);
988 	struct pci_dev *pdev = hwif->pdev;
989 	int err;
990 
991 	stats_info.stats_version = HINIC_PORT_STATS_VERSION;
992 	stats_info.func_id = HINIC_HWIF_FUNC_IDX(hwif);
993 	stats_info.stats_size = sizeof(vport_stats);
994 
995 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_VPORT_STAT,
996 				 &stats_info, sizeof(stats_info),
997 				 &vport_stats, &out_size);
998 	if (err || !out_size || vport_stats.status) {
999 		dev_err(&pdev->dev,
1000 			"Failed to get function statistics, err: %d, status: 0x%x, out size: 0x%x\n",
1001 			err, vport_stats.status, out_size);
1002 		return -EFAULT;
1003 	}
1004 
1005 	memcpy(stats, &vport_stats.stats, sizeof(*stats));
1006 	return 0;
1007 }
1008 
1009 int hinic_get_phy_port_stats(struct hinic_dev *nic_dev,
1010 			     struct hinic_phy_port_stats *stats)
1011 {
1012 	struct hinic_port_stats_info stats_info = { 0 };
1013 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
1014 	struct hinic_hwif *hwif = hwdev->hwif;
1015 	struct hinic_port_stats *port_stats;
1016 	u16 out_size = sizeof(*port_stats);
1017 	struct pci_dev *pdev = hwif->pdev;
1018 	int err;
1019 
1020 	port_stats = kzalloc(sizeof(*port_stats), GFP_KERNEL);
1021 	if (!port_stats)
1022 		return -ENOMEM;
1023 
1024 	stats_info.stats_version = HINIC_PORT_STATS_VERSION;
1025 	stats_info.stats_size = sizeof(*port_stats);
1026 
1027 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_PORT_STATISTICS,
1028 				 &stats_info, sizeof(stats_info),
1029 				 port_stats, &out_size);
1030 	if (err || !out_size || port_stats->status) {
1031 		dev_err(&pdev->dev,
1032 			"Failed to get port statistics, err: %d, status: 0x%x, out size: 0x%x\n",
1033 			err, port_stats->status, out_size);
1034 		err = -EINVAL;
1035 		goto out;
1036 	}
1037 
1038 	memcpy(stats, &port_stats->stats, sizeof(*stats));
1039 
1040 out:
1041 	kfree(port_stats);
1042 
1043 	return err;
1044 }
1045 
1046 int hinic_get_mgmt_version(struct hinic_dev *nic_dev, u8 *mgmt_ver)
1047 {
1048 	struct hinic_hwdev *hwdev = nic_dev->hwdev;
1049 	struct hinic_version_info up_ver = {0};
1050 	u16 out_size = sizeof(up_ver);
1051 	struct hinic_hwif *hwif;
1052 	struct pci_dev *pdev;
1053 	int err;
1054 
1055 	if (!hwdev)
1056 		return -EINVAL;
1057 
1058 	hwif = hwdev->hwif;
1059 	pdev = hwif->pdev;
1060 
1061 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_MGMT_VERSION,
1062 				 &up_ver, sizeof(up_ver), &up_ver,
1063 				 &out_size);
1064 	if (err || !out_size || up_ver.status) {
1065 		dev_err(&pdev->dev,
1066 			"Failed to get mgmt version, err: %d, status: 0x%x, out size: 0x%x\n",
1067 			err, up_ver.status, out_size);
1068 		return -EINVAL;
1069 	}
1070 
1071 	snprintf(mgmt_ver, HINIC_MGMT_VERSION_MAX_LEN, "%s", up_ver.ver);
1072 
1073 	return 0;
1074 }
1075 
1076 int hinic_get_link_mode(struct hinic_hwdev *hwdev,
1077 			struct hinic_link_mode_cmd *link_mode)
1078 {
1079 	u16 out_size;
1080 	int err;
1081 
1082 	if (!hwdev || !link_mode)
1083 		return -EINVAL;
1084 
1085 	link_mode->func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1086 	out_size = sizeof(*link_mode);
1087 
1088 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_LINK_MODE,
1089 				 link_mode, sizeof(*link_mode),
1090 				 link_mode, &out_size);
1091 	if (err || !out_size || link_mode->status) {
1092 		dev_err(&hwdev->hwif->pdev->dev,
1093 			"Failed to get link mode, err: %d, status: 0x%x, out size: 0x%x\n",
1094 			err, link_mode->status, out_size);
1095 		return -EIO;
1096 	}
1097 
1098 	return 0;
1099 }
1100 
1101 int hinic_set_autoneg(struct hinic_hwdev *hwdev, bool enable)
1102 {
1103 	struct hinic_set_autoneg_cmd autoneg = {0};
1104 	u16 out_size = sizeof(autoneg);
1105 	int err;
1106 
1107 	if (!hwdev)
1108 		return -EINVAL;
1109 
1110 	autoneg.func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1111 	autoneg.enable = enable;
1112 
1113 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_AUTONEG,
1114 				 &autoneg, sizeof(autoneg),
1115 				 &autoneg, &out_size);
1116 	if (err || !out_size || autoneg.status) {
1117 		dev_err(&hwdev->hwif->pdev->dev, "Failed to %s autoneg, err: %d, status: 0x%x, out size: 0x%x\n",
1118 			enable ? "enable" : "disable", err, autoneg.status,
1119 			out_size);
1120 		return -EIO;
1121 	}
1122 
1123 	return 0;
1124 }
1125 
1126 int hinic_set_speed(struct hinic_hwdev *hwdev, enum nic_speed_level speed)
1127 {
1128 	struct hinic_speed_cmd speed_info = {0};
1129 	u16 out_size = sizeof(speed_info);
1130 	int err;
1131 
1132 	if (!hwdev)
1133 		return -EINVAL;
1134 
1135 	speed_info.func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1136 	speed_info.speed = speed;
1137 
1138 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_SPEED,
1139 				 &speed_info, sizeof(speed_info),
1140 				 &speed_info, &out_size);
1141 	if (err || !out_size || speed_info.status) {
1142 		dev_err(&hwdev->hwif->pdev->dev,
1143 			"Failed to set speed, err: %d, status: 0x%x, out size: 0x%x\n",
1144 			err, speed_info.status, out_size);
1145 		return -EIO;
1146 	}
1147 
1148 	return 0;
1149 }
1150 
1151 int hinic_set_link_settings(struct hinic_hwdev *hwdev,
1152 			    struct hinic_link_ksettings_info *info)
1153 {
1154 	u16 out_size = sizeof(*info);
1155 	int err;
1156 
1157 	err = hinic_hilink_msg_cmd(hwdev, HINIC_HILINK_CMD_SET_LINK_SETTINGS,
1158 				   info, sizeof(*info), info, &out_size);
1159 	if ((info->status != HINIC_MGMT_CMD_UNSUPPORTED &&
1160 	     info->status) || err || !out_size) {
1161 		dev_err(&hwdev->hwif->pdev->dev,
1162 			"Failed to set link settings, err: %d, status: 0x%x, out size: 0x%x\n",
1163 			err, info->status, out_size);
1164 		return -EFAULT;
1165 	}
1166 
1167 	return info->status;
1168 }
1169 
1170 int hinic_get_hw_pause_info(struct hinic_hwdev *hwdev,
1171 			    struct hinic_pause_config *pause_info)
1172 {
1173 	u16 out_size = sizeof(*pause_info);
1174 	int err;
1175 
1176 	pause_info->func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1177 
1178 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_PAUSE_INFO,
1179 				 pause_info, sizeof(*pause_info),
1180 				 pause_info, &out_size);
1181 	if (err || !out_size || pause_info->status) {
1182 		dev_err(&hwdev->hwif->pdev->dev, "Failed to get pause info, err: %d, status: 0x%x, out size: 0x%x\n",
1183 			err, pause_info->status, out_size);
1184 		return -EIO;
1185 	}
1186 
1187 	return 0;
1188 }
1189 
1190 int hinic_set_hw_pause_info(struct hinic_hwdev *hwdev,
1191 			    struct hinic_pause_config *pause_info)
1192 {
1193 	u16 out_size = sizeof(*pause_info);
1194 	int err;
1195 
1196 	pause_info->func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1197 
1198 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_PAUSE_INFO,
1199 				 pause_info, sizeof(*pause_info),
1200 				 pause_info, &out_size);
1201 	if (err || !out_size || pause_info->status) {
1202 		dev_err(&hwdev->hwif->pdev->dev, "Failed to set pause info, err: %d, status: 0x%x, out size: 0x%x\n",
1203 			err, pause_info->status, out_size);
1204 		return -EIO;
1205 	}
1206 
1207 	return 0;
1208 }
1209 
1210 int hinic_dcb_set_pfc(struct hinic_hwdev *hwdev, u8 pfc_en, u8 pfc_bitmap)
1211 {
1212 	struct hinic_nic_cfg *nic_cfg = &hwdev->func_to_io.nic_cfg;
1213 	struct hinic_set_pfc pfc = {0};
1214 	u16 out_size = sizeof(pfc);
1215 	int err;
1216 
1217 	if (HINIC_IS_VF(hwdev->hwif))
1218 		return 0;
1219 
1220 	mutex_lock(&nic_cfg->cfg_mutex);
1221 
1222 	pfc.func_id = HINIC_HWIF_FUNC_IDX(hwdev->hwif);
1223 	pfc.pfc_bitmap = pfc_bitmap;
1224 	pfc.pfc_en = pfc_en;
1225 
1226 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_PFC,
1227 				 &pfc, sizeof(pfc), &pfc, &out_size);
1228 	if (err || pfc.status || !out_size) {
1229 		dev_err(&hwdev->hwif->pdev->dev, "Failed to %s pfc, err: %d, status: 0x%x, out size: 0x%x\n",
1230 			pfc_en ? "enable" : "disable", err, pfc.status,
1231 			out_size);
1232 		mutex_unlock(&nic_cfg->cfg_mutex);
1233 		return -EIO;
1234 	}
1235 
1236 	/* pause settings is opposite from pfc */
1237 	nic_cfg->rx_pause = pfc_en ? 0 : 1;
1238 	nic_cfg->tx_pause = pfc_en ? 0 : 1;
1239 
1240 	mutex_unlock(&nic_cfg->cfg_mutex);
1241 
1242 	return 0;
1243 }
1244 
1245 int hinic_set_loopback_mode(struct hinic_hwdev *hwdev, u32 mode, u32 enable)
1246 {
1247 	struct hinic_port_loopback lb = {0};
1248 	u16 out_size = sizeof(lb);
1249 	int err;
1250 
1251 	lb.mode = mode;
1252 	lb.en = enable;
1253 
1254 	if (mode < LOOP_MODE_MIN || mode > LOOP_MODE_MAX) {
1255 		dev_err(&hwdev->hwif->pdev->dev,
1256 			"Invalid loopback mode %d to set\n", mode);
1257 		return -EINVAL;
1258 	}
1259 
1260 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_LOOPBACK_MODE,
1261 				 &lb, sizeof(lb), &lb, &out_size);
1262 	if (err || !out_size || lb.status) {
1263 		dev_err(&hwdev->hwif->pdev->dev,
1264 			"Failed to set loopback mode %d en %d, err: %d, status: 0x%x, out size: 0x%x\n",
1265 			mode, enable, err, lb.status, out_size);
1266 		return -EIO;
1267 	}
1268 
1269 	return 0;
1270 }
1271 
1272 static int _set_led_status(struct hinic_hwdev *hwdev, u8 port,
1273 			   enum hinic_led_type type,
1274 			   enum hinic_led_mode mode, u8 reset)
1275 {
1276 	struct hinic_led_info led_info = {0};
1277 	u16 out_size = sizeof(led_info);
1278 	struct hinic_pfhwdev *pfhwdev;
1279 	int err;
1280 
1281 	pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev);
1282 
1283 	led_info.port = port;
1284 	led_info.reset = reset;
1285 
1286 	led_info.type = type;
1287 	led_info.mode = mode;
1288 
1289 	err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM,
1290 				HINIC_COMM_CMD_SET_LED_STATUS,
1291 				&led_info, sizeof(led_info),
1292 				&led_info, &out_size, HINIC_MGMT_MSG_SYNC);
1293 	if (err || led_info.status || !out_size) {
1294 		dev_err(&hwdev->hwif->pdev->dev, "Failed to set led status, err: %d, status: 0x%x, out size: 0x%x\n",
1295 			err, led_info.status, out_size);
1296 		return -EIO;
1297 	}
1298 
1299 	return 0;
1300 }
1301 
1302 int hinic_set_led_status(struct hinic_hwdev *hwdev, u8 port,
1303 			 enum hinic_led_type type, enum hinic_led_mode mode)
1304 {
1305 	if (!hwdev)
1306 		return -EINVAL;
1307 
1308 	return _set_led_status(hwdev, port, type, mode, 0);
1309 }
1310 
1311 int hinic_reset_led_status(struct hinic_hwdev *hwdev, u8 port)
1312 {
1313 	int err;
1314 
1315 	if (!hwdev)
1316 		return -EINVAL;
1317 
1318 	err = _set_led_status(hwdev, port, HINIC_LED_TYPE_INVALID,
1319 			      HINIC_LED_MODE_INVALID, 1);
1320 	if (err)
1321 		dev_err(&hwdev->hwif->pdev->dev,
1322 			"Failed to reset led status\n");
1323 
1324 	return err;
1325 }
1326 
1327 static bool hinic_if_sfp_absent(struct hinic_hwdev *hwdev)
1328 {
1329 	struct hinic_cmd_get_light_module_abs sfp_abs = {0};
1330 	u16 out_size = sizeof(sfp_abs);
1331 	u8 port_id = hwdev->port_id;
1332 	int err;
1333 
1334 	sfp_abs.port_id = port_id;
1335 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_SFP_ABS,
1336 				 &sfp_abs, sizeof(sfp_abs), &sfp_abs,
1337 				 &out_size);
1338 	if (sfp_abs.status || err || !out_size) {
1339 		dev_err(&hwdev->hwif->pdev->dev,
1340 			"Failed to get port%d sfp absent status, err: %d, status: 0x%x, out size: 0x%x\n",
1341 			port_id, err, sfp_abs.status, out_size);
1342 		return true;
1343 	}
1344 
1345 	return ((sfp_abs.abs_status == 0) ? false : true);
1346 }
1347 
1348 int hinic_get_sfp_eeprom(struct hinic_hwdev *hwdev, u8 *data, u16 *len)
1349 {
1350 	struct hinic_cmd_get_std_sfp_info sfp_info = {0};
1351 	u16 out_size = sizeof(sfp_info);
1352 	u8 port_id;
1353 	int err;
1354 
1355 	if (!hwdev || !data || !len)
1356 		return -EINVAL;
1357 
1358 	port_id = hwdev->port_id;
1359 
1360 	if (hinic_if_sfp_absent(hwdev))
1361 		return -ENXIO;
1362 
1363 	sfp_info.port_id = port_id;
1364 	err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_GET_STD_SFP_INFO,
1365 				 &sfp_info, sizeof(sfp_info), &sfp_info,
1366 				 &out_size);
1367 	if (sfp_info.status || err || !out_size) {
1368 		dev_err(&hwdev->hwif->pdev->dev,
1369 			"Failed to get port%d sfp eeprom information, err: %d, status: 0x%x, out size: 0x%x\n",
1370 			port_id, err, sfp_info.status, out_size);
1371 		return -EIO;
1372 	}
1373 
1374 	*len = min_t(u16, sfp_info.eeprom_len, STD_SFP_INFO_MAX_SIZE);
1375 	memcpy(data, sfp_info.sfp_info, STD_SFP_INFO_MAX_SIZE);
1376 
1377 	return 0;
1378 }
1379 
1380 int hinic_get_sfp_type(struct hinic_hwdev *hwdev, u8 *data0, u8 *data1)
1381 {
1382 	u8 sfp_data[STD_SFP_INFO_MAX_SIZE];
1383 	u16 len;
1384 	int err;
1385 
1386 	if (hinic_if_sfp_absent(hwdev))
1387 		return -ENXIO;
1388 
1389 	err = hinic_get_sfp_eeprom(hwdev, sfp_data, &len);
1390 	if (err)
1391 		return err;
1392 
1393 	*data0 = sfp_data[0];
1394 	*data1 = sfp_data[1];
1395 
1396 	return 0;
1397 }
1398