?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / net / ethernet / huawei / hinic / hinic_port.c
blobeb97f2d6b1adae8a51dbd3ccde23ad65f0e08a91
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 }
Linux with added FPC-III support