2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 QLogic Corporation
5 * See LICENSE.qlcnic for copyright and licensing details.
8 #include "qlcnic_sriov.h"
10 #include <linux/types.h>
12 #define QLCNIC_SRIOV_VF_MAX_MAC 7
13 #define QLC_VF_MIN_TX_RATE 100
14 #define QLC_VF_MAX_TX_RATE 9999
15 #define QLC_MAC_OPCODE_MASK 0x7
16 #define QLC_VF_FLOOD_BIT BIT_16
17 #define QLC_FLOOD_MODE 0x5
19 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter
*, u8
);
21 struct qlcnic_sriov_cmd_handler
{
22 int (*fn
) (struct qlcnic_bc_trans
*, struct qlcnic_cmd_args
*);
25 struct qlcnic_sriov_fw_cmd_handler
{
27 int (*fn
) (struct qlcnic_bc_trans
*, struct qlcnic_cmd_args
*);
30 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter
*adapter
,
31 struct qlcnic_info
*npar_info
,
34 struct qlcnic_cmd_args cmd
;
37 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_SET_NIC_INFO
))
40 cmd
.req
.arg
[1] = (vport_id
<< 16) | 0x1;
41 cmd
.req
.arg
[2] = npar_info
->bit_offsets
;
42 cmd
.req
.arg
[2] |= npar_info
->min_tx_bw
<< 16;
43 cmd
.req
.arg
[3] = npar_info
->max_tx_bw
| (npar_info
->max_tx_ques
<< 16);
44 cmd
.req
.arg
[4] = npar_info
->max_tx_mac_filters
;
45 cmd
.req
.arg
[4] |= npar_info
->max_rx_mcast_mac_filters
<< 16;
46 cmd
.req
.arg
[5] = npar_info
->max_rx_ucast_mac_filters
|
47 (npar_info
->max_rx_ip_addr
<< 16);
48 cmd
.req
.arg
[6] = npar_info
->max_rx_lro_flow
|
49 (npar_info
->max_rx_status_rings
<< 16);
50 cmd
.req
.arg
[7] = npar_info
->max_rx_buf_rings
|
51 (npar_info
->max_rx_ques
<< 16);
52 cmd
.req
.arg
[8] = npar_info
->max_tx_vlan_keys
;
53 cmd
.req
.arg
[8] |= npar_info
->max_local_ipv6_addrs
<< 16;
54 cmd
.req
.arg
[9] = npar_info
->max_remote_ipv6_addrs
;
56 err
= qlcnic_issue_cmd(adapter
, &cmd
);
58 dev_err(&adapter
->pdev
->dev
,
59 "Failed to set vport info, err=%d\n", err
);
61 qlcnic_free_mbx_args(&cmd
);
65 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter
*adapter
,
66 struct qlcnic_info
*info
, u16 func
)
68 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
69 struct qlcnic_resources
*res
= &sriov
->ff_max
;
70 u16 num_macs
= sriov
->num_allowed_vlans
+ 1;
71 int ret
= -EIO
, vpid
, id
;
72 struct qlcnic_vport
*vp
;
73 u32 num_vfs
, max
, temp
;
75 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
, func
);
79 num_vfs
= sriov
->num_vfs
;
81 info
->bit_offsets
= 0xffff;
82 info
->max_tx_ques
= res
->num_tx_queues
/ max
;
84 if (qlcnic_83xx_pf_check(adapter
))
87 info
->max_rx_mcast_mac_filters
= res
->num_rx_mcast_mac_filters
;
89 if (adapter
->ahw
->pci_func
== func
) {
91 info
->max_tx_bw
= MAX_BW
;
93 temp
= res
->num_rx_ucast_mac_filters
- num_macs
* num_vfs
;
94 info
->max_rx_ucast_mac_filters
= temp
;
95 temp
= res
->num_tx_mac_filters
- num_macs
* num_vfs
;
96 info
->max_tx_mac_filters
= temp
;
97 temp
= num_macs
* num_vfs
* QLCNIC_SRIOV_VF_MAX_MAC
;
98 temp
= res
->num_rx_mcast_mac_filters
- temp
;
99 info
->max_rx_mcast_mac_filters
= temp
;
101 info
->max_tx_ques
= res
->num_tx_queues
- sriov
->num_vfs
;
103 id
= qlcnic_sriov_func_to_index(adapter
, func
);
106 vp
= sriov
->vf_info
[id
].vp
;
107 info
->min_tx_bw
= vp
->min_tx_bw
;
108 info
->max_tx_bw
= vp
->max_tx_bw
;
110 info
->max_rx_ucast_mac_filters
= num_macs
;
111 info
->max_tx_mac_filters
= num_macs
;
112 temp
= num_macs
* QLCNIC_SRIOV_VF_MAX_MAC
;
113 info
->max_rx_mcast_mac_filters
= temp
;
115 info
->max_tx_ques
= QLCNIC_SINGLE_RING
;
118 info
->max_rx_ip_addr
= res
->num_destip
/ max
;
119 info
->max_rx_status_rings
= res
->num_rx_status_rings
/ max
;
120 info
->max_rx_buf_rings
= res
->num_rx_buf_rings
/ max
;
121 info
->max_rx_ques
= res
->num_rx_queues
/ max
;
122 info
->max_rx_lro_flow
= res
->num_lro_flows_supported
/ max
;
123 info
->max_tx_vlan_keys
= res
->num_txvlan_keys
;
124 info
->max_local_ipv6_addrs
= res
->max_local_ipv6_addrs
;
125 info
->max_remote_ipv6_addrs
= res
->max_remote_ipv6_addrs
;
127 ret
= qlcnic_sriov_pf_set_vport_info(adapter
, info
, vpid
);
134 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter
*adapter
,
135 struct qlcnic_info
*info
)
137 struct qlcnic_resources
*ff_max
= &adapter
->ahw
->sriov
->ff_max
;
139 ff_max
->num_tx_mac_filters
= info
->max_tx_mac_filters
;
140 ff_max
->num_rx_ucast_mac_filters
= info
->max_rx_ucast_mac_filters
;
141 ff_max
->num_rx_mcast_mac_filters
= info
->max_rx_mcast_mac_filters
;
142 ff_max
->num_txvlan_keys
= info
->max_tx_vlan_keys
;
143 ff_max
->num_rx_queues
= info
->max_rx_ques
;
144 ff_max
->num_tx_queues
= info
->max_tx_ques
;
145 ff_max
->num_lro_flows_supported
= info
->max_rx_lro_flow
;
146 ff_max
->num_destip
= info
->max_rx_ip_addr
;
147 ff_max
->num_rx_buf_rings
= info
->max_rx_buf_rings
;
148 ff_max
->num_rx_status_rings
= info
->max_rx_status_rings
;
149 ff_max
->max_remote_ipv6_addrs
= info
->max_remote_ipv6_addrs
;
150 ff_max
->max_local_ipv6_addrs
= info
->max_local_ipv6_addrs
;
153 static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter
*adapter
,
154 struct qlcnic_info
*npar_info
)
156 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
159 temp
= npar_info
->max_rx_mcast_mac_filters
;
160 total_fn
= sriov
->num_vfs
+ 1;
162 temp
= temp
/ (QLCNIC_SRIOV_VF_MAX_MAC
* total_fn
);
163 sriov
->num_allowed_vlans
= temp
- 1;
165 if (qlcnic_83xx_pf_check(adapter
))
166 sriov
->num_allowed_vlans
= 1;
168 netdev_info(adapter
->netdev
, "Max Guest VLANs supported per VF = %d\n",
169 sriov
->num_allowed_vlans
);
172 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter
*adapter
,
173 struct qlcnic_info
*npar_info
)
176 struct qlcnic_cmd_args cmd
;
178 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_GET_NIC_INFO
))
181 cmd
.req
.arg
[1] = 0x2;
182 err
= qlcnic_issue_cmd(adapter
, &cmd
);
184 dev_err(&adapter
->pdev
->dev
,
185 "Failed to get PF info, err=%d\n", err
);
189 npar_info
->total_pf
= cmd
.rsp
.arg
[2] & 0xff;
190 npar_info
->total_rss_engines
= (cmd
.rsp
.arg
[2] >> 8) & 0xff;
191 npar_info
->max_vports
= MSW(cmd
.rsp
.arg
[2]);
192 npar_info
->max_tx_ques
= LSW(cmd
.rsp
.arg
[3]);
193 npar_info
->max_tx_mac_filters
= MSW(cmd
.rsp
.arg
[3]);
194 npar_info
->max_rx_mcast_mac_filters
= LSW(cmd
.rsp
.arg
[4]);
195 npar_info
->max_rx_ucast_mac_filters
= MSW(cmd
.rsp
.arg
[4]);
196 npar_info
->max_rx_ip_addr
= LSW(cmd
.rsp
.arg
[5]);
197 npar_info
->max_rx_lro_flow
= MSW(cmd
.rsp
.arg
[5]);
198 npar_info
->max_rx_status_rings
= LSW(cmd
.rsp
.arg
[6]);
199 npar_info
->max_rx_buf_rings
= MSW(cmd
.rsp
.arg
[6]);
200 npar_info
->max_rx_ques
= LSW(cmd
.rsp
.arg
[7]);
201 npar_info
->max_tx_vlan_keys
= MSW(cmd
.rsp
.arg
[7]);
202 npar_info
->max_local_ipv6_addrs
= LSW(cmd
.rsp
.arg
[8]);
203 npar_info
->max_remote_ipv6_addrs
= MSW(cmd
.rsp
.arg
[8]);
205 qlcnic_sriov_set_vf_max_vlan(adapter
, npar_info
);
206 qlcnic_sriov_pf_set_ff_max_res(adapter
, npar_info
);
207 dev_info(&adapter
->pdev
->dev
,
208 "\n\ttotal_pf: %d,\n"
209 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
210 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
211 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
212 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
213 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
214 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
215 npar_info
->total_pf
, npar_info
->total_rss_engines
,
216 npar_info
->max_vports
, npar_info
->max_tx_ques
,
217 npar_info
->max_tx_mac_filters
,
218 npar_info
->max_rx_mcast_mac_filters
,
219 npar_info
->max_rx_ucast_mac_filters
, npar_info
->max_rx_ip_addr
,
220 npar_info
->max_rx_lro_flow
, npar_info
->max_rx_status_rings
,
221 npar_info
->max_rx_buf_rings
, npar_info
->max_rx_ques
,
222 npar_info
->max_tx_vlan_keys
, npar_info
->max_local_ipv6_addrs
,
223 npar_info
->max_remote_ipv6_addrs
);
226 qlcnic_free_mbx_args(&cmd
);
230 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter
*adapter
,
233 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
234 struct qlcnic_vport
*vp
;
237 if (adapter
->ahw
->pci_func
== func
) {
238 sriov
->vp_handle
= 0;
240 index
= qlcnic_sriov_func_to_index(adapter
, func
);
243 vp
= sriov
->vf_info
[index
].vp
;
248 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter
*adapter
,
249 u16 vport_handle
, u8 func
)
251 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
252 struct qlcnic_vport
*vp
;
255 if (adapter
->ahw
->pci_func
== func
) {
256 sriov
->vp_handle
= vport_handle
;
258 index
= qlcnic_sriov_func_to_index(adapter
, func
);
261 vp
= sriov
->vf_info
[index
].vp
;
262 vp
->handle
= vport_handle
;
266 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter
*adapter
,
269 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
270 struct qlcnic_vf_info
*vf_info
;
273 if (adapter
->ahw
->pci_func
== func
) {
274 return sriov
->vp_handle
;
276 index
= qlcnic_sriov_func_to_index(adapter
, func
);
278 vf_info
= &sriov
->vf_info
[index
];
279 return vf_info
->vp
->handle
;
286 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter
*adapter
,
289 struct qlcnic_cmd_args cmd
;
293 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_CONFIG_VPORT
))
297 cmd
.req
.arg
[3] = func
<< 8;
299 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
, func
);
304 cmd
.req
.arg
[3] = ((vpid
& 0xffff) << 8) | 1;
307 ret
= qlcnic_issue_cmd(adapter
, &cmd
);
309 dev_err(&adapter
->pdev
->dev
,
310 "Failed %s vport, err %d for func 0x%x\n",
311 (flag
? "enable" : "disable"), ret
, func
);
316 vpid
= cmd
.rsp
.arg
[2] & 0xffff;
317 qlcnic_sriov_pf_set_vport_handle(adapter
, vpid
, func
);
319 qlcnic_sriov_pf_reset_vport_handle(adapter
, func
);
323 qlcnic_free_mbx_args(&cmd
);
327 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter
*adapter
,
330 struct qlcnic_cmd_args cmd
;
333 err
= qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_SET_NIC_INFO
);
337 cmd
.req
.arg
[1] = 0x4;
339 cmd
.req
.arg
[1] |= BIT_16
;
341 err
= qlcnic_issue_cmd(adapter
, &cmd
);
343 dev_err(&adapter
->pdev
->dev
,
344 "Failed to configure VLAN filtering, err=%d\n", err
);
346 qlcnic_free_mbx_args(&cmd
);
350 /* On configuring VF flood bit, PFD will receive traffic from all VFs */
351 static int qlcnic_sriov_pf_cfg_flood(struct qlcnic_adapter
*adapter
)
353 struct qlcnic_cmd_args cmd
;
356 err
= qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_SET_NIC_INFO
);
360 cmd
.req
.arg
[1] = QLC_FLOOD_MODE
| QLC_VF_FLOOD_BIT
;
362 err
= qlcnic_issue_cmd(adapter
, &cmd
);
364 dev_err(&adapter
->pdev
->dev
,
365 "Failed to configure VF Flood bit on PF, err=%d\n",
368 qlcnic_free_mbx_args(&cmd
);
372 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter
*adapter
,
375 struct qlcnic_cmd_args cmd
;
378 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_TOGGLE_ESWITCH
))
381 cmd
.req
.arg
[0] |= (3 << 29);
382 cmd
.req
.arg
[1] = ((func
& 0xf) << 2) | BIT_6
| BIT_1
;
384 cmd
.req
.arg
[1] |= BIT_0
;
386 err
= qlcnic_issue_cmd(adapter
, &cmd
);
388 if (err
!= QLCNIC_RCODE_SUCCESS
) {
389 dev_err(&adapter
->pdev
->dev
,
390 "Failed to enable sriov eswitch%d\n", err
);
394 qlcnic_free_mbx_args(&cmd
);
398 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter
*adapter
)
400 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
401 struct qlcnic_back_channel
*bc
= &sriov
->bc
;
404 for (i
= 0; i
< sriov
->num_vfs
; i
++)
405 cancel_work_sync(&sriov
->vf_info
[i
].flr_work
);
407 destroy_workqueue(bc
->bc_flr_wq
);
410 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter
*adapter
)
412 struct qlcnic_back_channel
*bc
= &adapter
->ahw
->sriov
->bc
;
413 struct workqueue_struct
*wq
;
415 wq
= create_singlethread_workqueue("qlcnic-flr");
417 dev_err(&adapter
->pdev
->dev
, "Cannot create FLR workqueue\n");
425 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter
*adapter
)
427 u8 func
= adapter
->ahw
->pci_func
;
429 if (!qlcnic_sriov_enable_check(adapter
))
432 qlcnic_sriov_pf_del_flr_queue(adapter
);
433 qlcnic_sriov_cfg_bc_intr(adapter
, 0);
434 qlcnic_sriov_pf_config_vport(adapter
, 0, func
);
435 qlcnic_sriov_pf_cfg_eswitch(adapter
, func
, 0);
436 qlcnic_sriov_pf_cfg_vlan_filtering(adapter
, 0);
437 __qlcnic_sriov_cleanup(adapter
);
438 adapter
->ahw
->op_mode
= QLCNIC_MGMT_FUNC
;
439 clear_bit(__QLCNIC_SRIOV_ENABLE
, &adapter
->state
);
442 void qlcnic_sriov_pf_disable(struct qlcnic_adapter
*adapter
)
444 if (!qlcnic_sriov_pf_check(adapter
))
447 if (!qlcnic_sriov_enable_check(adapter
))
450 pci_disable_sriov(adapter
->pdev
);
451 netdev_info(adapter
->netdev
,
452 "SR-IOV is disabled successfully on port %d\n",
456 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter
*adapter
)
458 struct net_device
*netdev
= adapter
->netdev
;
461 if (netif_running(netdev
))
462 __qlcnic_down(adapter
, netdev
);
464 qlcnic_sriov_pf_disable(adapter
);
466 qlcnic_sriov_free_vlans(adapter
);
468 qlcnic_sriov_pf_cleanup(adapter
);
470 /* After disabling SRIOV re-init the driver in default mode
471 configure opmode based on op_mode of function
473 if (qlcnic_83xx_configure_opmode(adapter
)) {
478 if (netif_running(netdev
))
479 __qlcnic_up(adapter
, netdev
);
485 static int qlcnic_sriov_pf_init(struct qlcnic_adapter
*adapter
)
487 struct qlcnic_hardware_context
*ahw
= adapter
->ahw
;
488 struct qlcnic_info nic_info
, pf_info
, vp_info
;
490 u8 func
= ahw
->pci_func
;
492 if (!qlcnic_sriov_enable_check(adapter
))
495 err
= qlcnic_sriov_pf_cfg_vlan_filtering(adapter
, 1);
499 if (qlcnic_84xx_check(adapter
)) {
500 err
= qlcnic_sriov_pf_cfg_flood(adapter
);
502 goto disable_vlan_filtering
;
505 err
= qlcnic_sriov_pf_cfg_eswitch(adapter
, func
, 1);
507 goto disable_vlan_filtering
;
509 err
= qlcnic_sriov_pf_config_vport(adapter
, 1, func
);
511 goto disable_eswitch
;
513 err
= qlcnic_sriov_get_pf_info(adapter
, &pf_info
);
517 err
= qlcnic_get_nic_info(adapter
, &nic_info
, func
);
521 err
= qlcnic_sriov_pf_cal_res_limit(adapter
, &vp_info
, func
);
525 err
= qlcnic_sriov_cfg_bc_intr(adapter
, 1);
529 ahw
->physical_port
= (u8
) nic_info
.phys_port
;
530 ahw
->switch_mode
= nic_info
.switch_mode
;
531 ahw
->max_mtu
= nic_info
.max_mtu
;
532 ahw
->capabilities
= nic_info
.capabilities
;
533 ahw
->nic_mode
= QLC_83XX_SRIOV_MODE
;
537 qlcnic_sriov_pf_config_vport(adapter
, 0, func
);
540 qlcnic_sriov_pf_cfg_eswitch(adapter
, func
, 0);
542 disable_vlan_filtering
:
543 qlcnic_sriov_pf_cfg_vlan_filtering(adapter
, 0);
548 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter
*adapter
, int num_vfs
)
552 if (!qlcnic_sriov_enable_check(adapter
))
555 err
= pci_enable_sriov(adapter
->pdev
, num_vfs
);
557 qlcnic_sriov_pf_cleanup(adapter
);
562 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter
*adapter
,
567 set_bit(__QLCNIC_SRIOV_ENABLE
, &adapter
->state
);
568 adapter
->ahw
->op_mode
= QLCNIC_SRIOV_PF_FUNC
;
570 err
= qlcnic_sriov_init(adapter
, num_vfs
);
574 err
= qlcnic_sriov_pf_create_flr_queue(adapter
);
578 err
= qlcnic_sriov_pf_init(adapter
);
582 qlcnic_sriov_alloc_vlans(adapter
);
584 err
= qlcnic_sriov_pf_enable(adapter
, num_vfs
);
588 qlcnic_sriov_pf_del_flr_queue(adapter
);
591 __qlcnic_sriov_cleanup(adapter
);
594 clear_bit(__QLCNIC_SRIOV_ENABLE
, &adapter
->state
);
595 adapter
->ahw
->op_mode
= QLCNIC_MGMT_FUNC
;
599 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter
*adapter
, int num_vfs
)
601 struct net_device
*netdev
= adapter
->netdev
;
604 if (!(adapter
->flags
& QLCNIC_MSIX_ENABLED
)) {
606 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
611 if (netif_running(netdev
))
612 __qlcnic_down(adapter
, netdev
);
614 err
= __qlcnic_pci_sriov_enable(adapter
, num_vfs
);
616 netdev_info(netdev
, "Failed to enable SR-IOV on port %d\n",
620 if (qlcnic_83xx_configure_opmode(adapter
))
624 "SR-IOV is enabled successfully on port %d\n",
626 /* Return number of vfs enabled */
629 if (netif_running(netdev
))
630 __qlcnic_up(adapter
, netdev
);
637 int qlcnic_pci_sriov_configure(struct pci_dev
*dev
, int num_vfs
)
639 struct qlcnic_adapter
*adapter
= pci_get_drvdata(dev
);
642 if (test_and_set_bit(__QLCNIC_RESETTING
, &adapter
->state
))
646 err
= qlcnic_pci_sriov_disable(adapter
);
648 err
= qlcnic_pci_sriov_enable(adapter
, num_vfs
);
650 clear_bit(__QLCNIC_RESETTING
, &adapter
->state
);
654 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter
*adapter
, u8 func
)
656 struct qlcnic_cmd_args cmd
;
657 struct qlcnic_vport
*vp
;
661 id
= qlcnic_sriov_func_to_index(adapter
, func
);
665 vp
= adapter
->ahw
->sriov
->vf_info
[id
].vp
;
666 err
= qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_SET_NIC_INFO
);
670 cmd
.req
.arg
[1] = 0x3 | func
<< 16;
671 if (vp
->spoofchk
== true) {
673 cmd
.req
.arg
[2] |= BIT_1
| BIT_3
| BIT_8
;
674 cmd
.req
.arg
[4] = mac
[5] | mac
[4] << 8 | mac
[3] << 16 |
676 cmd
.req
.arg
[5] = mac
[1] | mac
[0] << 8;
679 if (vp
->vlan_mode
== QLC_PVID_MODE
) {
680 cmd
.req
.arg
[2] |= BIT_6
;
681 cmd
.req
.arg
[3] |= vp
->pvid
<< 8;
684 err
= qlcnic_issue_cmd(adapter
, &cmd
);
686 dev_err(&adapter
->pdev
->dev
, "Failed to set ACL, err=%d\n",
689 qlcnic_free_mbx_args(&cmd
);
693 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter
*adapter
,
696 struct qlcnic_info defvp_info
;
699 err
= qlcnic_sriov_pf_cal_res_limit(adapter
, &defvp_info
, func
);
703 err
= qlcnic_sriov_set_vf_acl(adapter
, func
);
710 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans
*trans
,
711 struct qlcnic_cmd_args
*cmd
)
713 struct qlcnic_vf_info
*vf
= trans
->vf
;
714 struct qlcnic_vport
*vp
= vf
->vp
;
715 struct qlcnic_adapter
*adapter
;
716 struct qlcnic_sriov
*sriov
;
717 u16 func
= vf
->pci_func
;
721 adapter
= vf
->adapter
;
722 sriov
= adapter
->ahw
->sriov
;
724 if (trans
->req_hdr
->cmd_op
== QLCNIC_BC_CMD_CHANNEL_INIT
) {
725 err
= qlcnic_sriov_pf_config_vport(adapter
, 1, func
);
727 err
= qlcnic_sriov_set_vf_vport_info(adapter
, func
);
729 qlcnic_sriov_pf_config_vport(adapter
, 0, func
);
732 if (vp
->vlan_mode
== QLC_GUEST_VLAN_MODE
) {
733 size
= sizeof(*vf
->sriov_vlans
);
734 size
= size
* sriov
->num_allowed_vlans
;
735 memset(vf
->sriov_vlans
, 0, size
);
738 err
= qlcnic_sriov_pf_config_vport(adapter
, 0, func
);
744 cmd
->rsp
.arg
[0] |= (1 << 25);
746 if (trans
->req_hdr
->cmd_op
== QLCNIC_BC_CMD_CHANNEL_INIT
)
747 set_bit(QLC_BC_VF_STATE
, &vf
->state
);
749 clear_bit(QLC_BC_VF_STATE
, &vf
->state
);
754 cmd
->rsp
.arg
[0] |= (2 << 25);
758 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter
*adapter
,
759 struct qlcnic_vf_info
*vf
,
762 struct qlcnic_cmd_args cmd
;
763 struct qlcnic_macvlan_mbx mv
;
764 struct qlcnic_vport
*vp
;
772 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_CONFIG_MAC_VLAN
))
775 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
, vf
->pci_func
);
782 op
= ((op
== QLCNIC_MAC_ADD
|| op
== QLCNIC_MAC_VLAN_ADD
) ?
783 QLCNIC_MAC_VLAN_ADD
: QLCNIC_MAC_VLAN_DEL
);
785 cmd
.req
.arg
[1] = op
| (1 << 8) | (3 << 6);
786 cmd
.req
.arg
[1] |= ((vpid
& 0xffff) << 16) | BIT_31
;
790 mv
.mac_addr0
= addr
[0];
791 mv
.mac_addr1
= addr
[1];
792 mv
.mac_addr2
= addr
[2];
793 mv
.mac_addr3
= addr
[3];
794 mv
.mac_addr4
= addr
[4];
795 mv
.mac_addr5
= addr
[5];
796 buf
= &cmd
.req
.arg
[2];
797 memcpy(buf
, &mv
, sizeof(struct qlcnic_macvlan_mbx
));
799 err
= qlcnic_issue_cmd(adapter
, &cmd
);
802 dev_err(&adapter
->pdev
->dev
,
803 "MAC-VLAN %s to CAM failed, err=%d.\n",
804 ((op
== 1) ? "add " : "delete "), err
);
807 qlcnic_free_mbx_args(&cmd
);
811 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args
*cmd
)
813 if ((cmd
->req
.arg
[0] >> 29) != 0x3)
819 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter
*adapter
,
820 struct qlcnic_vf_info
*vf
,
823 struct qlcnic_sriov
*sriov
;
827 sriov
= adapter
->ahw
->sriov
;
829 mutex_lock(&vf
->vlan_list_lock
);
831 for (i
= 0; i
< sriov
->num_allowed_vlans
; i
++) {
832 vlan
= vf
->sriov_vlans
[i
];
834 qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, vlan
,
838 mutex_unlock(&vf
->vlan_list_lock
);
840 if (vf
->vp
->vlan_mode
!= QLC_PVID_MODE
) {
841 if (qlcnic_83xx_pf_check(adapter
) &&
842 qlcnic_sriov_check_any_vlan(vf
))
844 qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, 0, opcode
);
848 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans
*tran
,
849 struct qlcnic_cmd_args
*cmd
)
851 struct qlcnic_vf_info
*vf
= tran
->vf
;
852 struct qlcnic_adapter
*adapter
= vf
->adapter
;
853 struct qlcnic_rcv_mbx_out
*mbx_out
;
856 err
= qlcnic_sriov_validate_create_rx_ctx(cmd
);
858 cmd
->rsp
.arg
[0] |= (0x6 << 25);
862 cmd
->req
.arg
[6] = vf
->vp
->handle
;
863 err
= qlcnic_issue_cmd(adapter
, cmd
);
866 mbx_out
= (struct qlcnic_rcv_mbx_out
*)&cmd
->rsp
.arg
[1];
867 vf
->rx_ctx_id
= mbx_out
->ctx_id
;
868 qlcnic_83xx_cfg_default_mac_vlan(adapter
, vf
, QLCNIC_MAC_ADD
);
876 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans
*trans
,
877 struct qlcnic_cmd_args
*cmd
)
879 struct qlcnic_vf_info
*vf
= trans
->vf
;
882 type
= cmd
->req
.arg
[1];
884 case QLCNIC_SET_STATION_MAC
:
885 case QLCNIC_SET_FAC_DEF_MAC
:
886 cmd
->rsp
.arg
[0] = (2 << 25);
888 case QLCNIC_GET_CURRENT_MAC
:
889 cmd
->rsp
.arg
[0] = (1 << 25);
891 cmd
->rsp
.arg
[2] = mac
[1] | ((mac
[0] << 8) & 0xff00);
892 cmd
->rsp
.arg
[1] = mac
[5] | ((mac
[4] << 8) & 0xff00) |
893 ((mac
[3]) << 16 & 0xff0000) |
894 ((mac
[2]) << 24 & 0xff000000);
900 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args
*cmd
)
902 if ((cmd
->req
.arg
[0] >> 29) != 0x3)
908 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans
*trans
,
909 struct qlcnic_cmd_args
*cmd
)
911 struct qlcnic_vf_info
*vf
= trans
->vf
;
912 struct qlcnic_adapter
*adapter
= vf
->adapter
;
913 struct qlcnic_tx_mbx_out
*mbx_out
;
916 err
= qlcnic_sriov_validate_create_tx_ctx(cmd
);
918 cmd
->rsp
.arg
[0] |= (0x6 << 25);
922 cmd
->req
.arg
[5] |= vf
->vp
->handle
<< 16;
923 err
= qlcnic_issue_cmd(adapter
, cmd
);
925 mbx_out
= (struct qlcnic_tx_mbx_out
*)&cmd
->rsp
.arg
[2];
926 vf
->tx_ctx_id
= mbx_out
->ctx_id
;
934 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info
*vf
,
935 struct qlcnic_cmd_args
*cmd
)
937 if ((cmd
->req
.arg
[0] >> 29) != 0x3)
940 if ((cmd
->req
.arg
[1] & 0xffff) != vf
->rx_ctx_id
)
946 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans
*trans
,
947 struct qlcnic_cmd_args
*cmd
)
949 struct qlcnic_vf_info
*vf
= trans
->vf
;
950 struct qlcnic_adapter
*adapter
= vf
->adapter
;
953 err
= qlcnic_sriov_validate_del_rx_ctx(vf
, cmd
);
955 cmd
->rsp
.arg
[0] |= (0x6 << 25);
959 qlcnic_83xx_cfg_default_mac_vlan(adapter
, vf
, QLCNIC_MAC_DEL
);
960 cmd
->req
.arg
[1] |= vf
->vp
->handle
<< 16;
961 err
= qlcnic_issue_cmd(adapter
, cmd
);
969 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info
*vf
,
970 struct qlcnic_cmd_args
*cmd
)
972 if ((cmd
->req
.arg
[0] >> 29) != 0x3)
975 if ((cmd
->req
.arg
[1] & 0xffff) != vf
->tx_ctx_id
)
981 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans
*trans
,
982 struct qlcnic_cmd_args
*cmd
)
984 struct qlcnic_vf_info
*vf
= trans
->vf
;
985 struct qlcnic_adapter
*adapter
= vf
->adapter
;
988 err
= qlcnic_sriov_validate_del_tx_ctx(vf
, cmd
);
990 cmd
->rsp
.arg
[0] |= (0x6 << 25);
994 cmd
->req
.arg
[1] |= vf
->vp
->handle
<< 16;
995 err
= qlcnic_issue_cmd(adapter
, cmd
);
1003 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info
*vf
,
1004 struct qlcnic_cmd_args
*cmd
)
1006 if ((cmd
->req
.arg
[1] >> 16) != vf
->rx_ctx_id
)
1012 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans
*trans
,
1013 struct qlcnic_cmd_args
*cmd
)
1015 struct qlcnic_vf_info
*vf
= trans
->vf
;
1016 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1019 err
= qlcnic_sriov_validate_cfg_lro(vf
, cmd
);
1021 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1025 err
= qlcnic_issue_cmd(adapter
, cmd
);
1029 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans
*trans
,
1030 struct qlcnic_cmd_args
*cmd
)
1032 struct qlcnic_vf_info
*vf
= trans
->vf
;
1033 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1037 op
= cmd
->req
.arg
[1] & 0xff;
1039 cmd
->req
.arg
[1] |= vf
->vp
->handle
<< 16;
1040 cmd
->req
.arg
[1] |= BIT_31
;
1042 err
= qlcnic_issue_cmd(adapter
, cmd
);
1046 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info
*vf
,
1047 struct qlcnic_cmd_args
*cmd
)
1049 if (((cmd
->req
.arg
[1] >> 8) & 0xff) != vf
->pci_func
)
1052 if (!(cmd
->req
.arg
[1] & BIT_16
))
1055 if ((cmd
->req
.arg
[1] & 0xff) != 0x1)
1061 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans
*trans
,
1062 struct qlcnic_cmd_args
*cmd
)
1064 struct qlcnic_vf_info
*vf
= trans
->vf
;
1065 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1068 err
= qlcnic_sriov_validate_cfg_intrpt(vf
, cmd
);
1070 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1072 err
= qlcnic_issue_cmd(adapter
, cmd
);
1077 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter
*adapter
,
1078 struct qlcnic_vf_info
*vf
,
1079 struct qlcnic_cmd_args
*cmd
)
1081 if (cmd
->req
.arg
[1] != vf
->rx_ctx_id
)
1084 if (cmd
->req
.arg
[2] > adapter
->ahw
->max_mtu
)
1090 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans
*trans
,
1091 struct qlcnic_cmd_args
*cmd
)
1093 struct qlcnic_vf_info
*vf
= trans
->vf
;
1094 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1097 err
= qlcnic_sriov_validate_mtu(adapter
, vf
, cmd
);
1099 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1101 err
= qlcnic_issue_cmd(adapter
, cmd
);
1106 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info
*vf
,
1107 struct qlcnic_cmd_args
*cmd
)
1109 if (cmd
->req
.arg
[1] & BIT_31
) {
1110 if (((cmd
->req
.arg
[1] >> 16) & 0x7fff) != vf
->pci_func
)
1113 cmd
->req
.arg
[1] |= vf
->vp
->handle
<< 16;
1119 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans
*trans
,
1120 struct qlcnic_cmd_args
*cmd
)
1122 struct qlcnic_vf_info
*vf
= trans
->vf
;
1123 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1126 err
= qlcnic_sriov_validate_get_nic_info(vf
, cmd
);
1128 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1132 err
= qlcnic_issue_cmd(adapter
, cmd
);
1136 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info
*vf
,
1137 struct qlcnic_cmd_args
*cmd
)
1139 if (cmd
->req
.arg
[1] != vf
->rx_ctx_id
)
1145 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans
*trans
,
1146 struct qlcnic_cmd_args
*cmd
)
1148 struct qlcnic_vf_info
*vf
= trans
->vf
;
1149 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1152 err
= qlcnic_sriov_validate_cfg_rss(vf
, cmd
);
1154 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1156 err
= qlcnic_issue_cmd(adapter
, cmd
);
1161 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter
*adapter
,
1162 struct qlcnic_vf_info
*vf
,
1163 struct qlcnic_cmd_args
*cmd
)
1165 struct qlcnic_nic_intr_coalesce
*coal
= &adapter
->ahw
->coal
;
1166 u16 ctx_id
, pkts
, time
;
1168 ctx_id
= cmd
->req
.arg
[1] >> 16;
1169 pkts
= cmd
->req
.arg
[2] & 0xffff;
1170 time
= cmd
->req
.arg
[2] >> 16;
1172 if (ctx_id
!= vf
->rx_ctx_id
)
1174 if (pkts
> coal
->rx_packets
)
1176 if (time
< coal
->rx_time_us
)
1182 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans
*tran
,
1183 struct qlcnic_cmd_args
*cmd
)
1185 struct qlcnic_vf_info
*vf
= tran
->vf
;
1186 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1189 err
= qlcnic_sriov_validate_cfg_intrcoal(adapter
, vf
, cmd
);
1191 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1195 err
= qlcnic_issue_cmd(adapter
, cmd
);
1199 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter
*adapter
,
1200 struct qlcnic_vf_info
*vf
,
1201 struct qlcnic_cmd_args
*cmd
)
1203 struct qlcnic_macvlan_mbx
*macvlan
;
1204 struct qlcnic_vport
*vp
= vf
->vp
;
1207 if (!(cmd
->req
.arg
[1] & BIT_8
))
1210 cmd
->req
.arg
[1] |= (vf
->vp
->handle
<< 16);
1211 cmd
->req
.arg
[1] |= BIT_31
;
1213 macvlan
= (struct qlcnic_macvlan_mbx
*)&cmd
->req
.arg
[2];
1214 if (!(macvlan
->mac_addr0
& BIT_0
)) {
1215 dev_err(&adapter
->pdev
->dev
,
1216 "MAC address change is not allowed from VF %d",
1221 if (vp
->vlan_mode
== QLC_PVID_MODE
) {
1222 op
= cmd
->req
.arg
[1] & 0x7;
1223 cmd
->req
.arg
[1] &= ~0x7;
1224 new_op
= (op
== QLCNIC_MAC_ADD
|| op
== QLCNIC_MAC_VLAN_ADD
) ?
1225 QLCNIC_MAC_VLAN_ADD
: QLCNIC_MAC_VLAN_DEL
;
1226 cmd
->req
.arg
[3] |= vp
->pvid
<< 16;
1227 cmd
->req
.arg
[1] |= new_op
;
1233 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans
*trans
,
1234 struct qlcnic_cmd_args
*cmd
)
1236 struct qlcnic_vf_info
*vf
= trans
->vf
;
1237 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1240 err
= qlcnic_sriov_validate_cfg_macvlan(adapter
, vf
, cmd
);
1242 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1246 err
= qlcnic_issue_cmd(adapter
, cmd
);
1250 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info
*vf
,
1251 struct qlcnic_cmd_args
*cmd
)
1253 if ((cmd
->req
.arg
[1] >> 16) != vf
->rx_ctx_id
)
1259 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans
*trans
,
1260 struct qlcnic_cmd_args
*cmd
)
1262 struct qlcnic_vf_info
*vf
= trans
->vf
;
1263 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1266 err
= qlcnic_sriov_validate_linkevent(vf
, cmd
);
1268 cmd
->rsp
.arg
[0] |= (0x6 << 25);
1272 err
= qlcnic_issue_cmd(adapter
, cmd
);
1276 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans
*trans
,
1277 struct qlcnic_cmd_args
*cmd
)
1279 struct qlcnic_vf_info
*vf
= trans
->vf
;
1280 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1283 cmd
->req
.arg
[1] |= vf
->vp
->handle
<< 16;
1284 cmd
->req
.arg
[1] |= BIT_31
;
1285 err
= qlcnic_issue_cmd(adapter
, cmd
);
1289 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans
*trans
,
1290 struct qlcnic_cmd_args
*cmd
)
1292 struct qlcnic_vf_info
*vf
= trans
->vf
;
1293 struct qlcnic_vport
*vp
= vf
->vp
;
1294 u8 cmd_op
, mode
= vp
->vlan_mode
;
1295 struct qlcnic_adapter
*adapter
;
1296 struct qlcnic_sriov
*sriov
;
1298 adapter
= vf
->adapter
;
1299 sriov
= adapter
->ahw
->sriov
;
1301 cmd_op
= trans
->req_hdr
->cmd_op
;
1302 cmd
->rsp
.arg
[0] |= 1 << 25;
1304 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1305 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1307 if (qlcnic_84xx_check(adapter
) && mode
== QLC_PVID_MODE
)
1311 case QLC_GUEST_VLAN_MODE
:
1312 cmd
->rsp
.arg
[1] = mode
| 1 << 8;
1313 cmd
->rsp
.arg
[2] = sriov
->num_allowed_vlans
<< 16;
1316 cmd
->rsp
.arg
[1] = mode
| 1 << 8 | vp
->pvid
<< 16;
1323 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter
*adapter
,
1324 struct qlcnic_vf_info
*vf
,
1325 struct qlcnic_cmd_args
*cmd
)
1327 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1330 if (!qlcnic_sriov_check_any_vlan(vf
))
1333 vlan
= cmd
->req
.arg
[1] >> 16;
1334 if (!vf
->rx_ctx_id
) {
1335 qlcnic_sriov_del_vlan_id(sriov
, vf
, vlan
);
1339 qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, vlan
, QLCNIC_MAC_DEL
);
1340 qlcnic_sriov_del_vlan_id(sriov
, vf
, vlan
);
1342 if (qlcnic_83xx_pf_check(adapter
))
1343 qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
,
1348 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter
*adapter
,
1349 struct qlcnic_vf_info
*vf
,
1350 struct qlcnic_cmd_args
*cmd
)
1352 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1356 if (qlcnic_83xx_pf_check(adapter
) && qlcnic_sriov_check_any_vlan(vf
))
1359 vlan
= cmd
->req
.arg
[1] >> 16;
1361 if (!vf
->rx_ctx_id
) {
1362 qlcnic_sriov_add_vlan_id(sriov
, vf
, vlan
);
1366 if (qlcnic_83xx_pf_check(adapter
)) {
1367 err
= qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, 0,
1373 err
= qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, vlan
, QLCNIC_MAC_ADD
);
1376 if (qlcnic_83xx_pf_check(adapter
))
1377 qlcnic_sriov_cfg_vf_def_mac(adapter
, vf
, 0,
1382 qlcnic_sriov_add_vlan_id(sriov
, vf
, vlan
);
1386 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans
*tran
,
1387 struct qlcnic_cmd_args
*cmd
)
1389 struct qlcnic_vf_info
*vf
= tran
->vf
;
1390 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1391 struct qlcnic_vport
*vp
= vf
->vp
;
1395 if (vp
->vlan_mode
!= QLC_GUEST_VLAN_MODE
) {
1396 cmd
->rsp
.arg
[0] |= 2 << 25;
1400 op
= cmd
->req
.arg
[1] & 0xf;
1403 err
= qlcnic_sriov_pf_add_guest_vlan(adapter
, vf
, cmd
);
1405 err
= qlcnic_sriov_pf_del_guest_vlan(adapter
, vf
, cmd
);
1407 cmd
->rsp
.arg
[0] |= err
? 2 << 25 : 1 << 25;
1411 static const int qlcnic_pf_passthru_supp_cmds
[] = {
1412 QLCNIC_CMD_GET_STATISTICS
,
1413 QLCNIC_CMD_GET_PORT_CONFIG
,
1414 QLCNIC_CMD_GET_LINK_STATUS
,
1415 QLCNIC_CMD_INIT_NIC_FUNC
,
1416 QLCNIC_CMD_STOP_NIC_FUNC
,
1419 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr
[] = {
1420 [QLCNIC_BC_CMD_CHANNEL_INIT
] = {&qlcnic_sriov_pf_channel_cfg_cmd
},
1421 [QLCNIC_BC_CMD_CHANNEL_TERM
] = {&qlcnic_sriov_pf_channel_cfg_cmd
},
1422 [QLCNIC_BC_CMD_GET_ACL
] = {&qlcnic_sriov_pf_get_acl_cmd
},
1423 [QLCNIC_BC_CMD_CFG_GUEST_VLAN
] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd
},
1426 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr
[] = {
1427 {QLCNIC_CMD_CREATE_RX_CTX
, qlcnic_sriov_pf_create_rx_ctx_cmd
},
1428 {QLCNIC_CMD_CREATE_TX_CTX
, qlcnic_sriov_pf_create_tx_ctx_cmd
},
1429 {QLCNIC_CMD_MAC_ADDRESS
, qlcnic_sriov_pf_mac_address_cmd
},
1430 {QLCNIC_CMD_DESTROY_RX_CTX
, qlcnic_sriov_pf_del_rx_ctx_cmd
},
1431 {QLCNIC_CMD_DESTROY_TX_CTX
, qlcnic_sriov_pf_del_tx_ctx_cmd
},
1432 {QLCNIC_CMD_CONFIGURE_HW_LRO
, qlcnic_sriov_pf_cfg_lro_cmd
},
1433 {QLCNIC_CMD_CONFIGURE_IP_ADDR
, qlcnic_sriov_pf_cfg_ip_cmd
},
1434 {QLCNIC_CMD_CONFIG_INTRPT
, qlcnic_sriov_pf_cfg_intrpt_cmd
},
1435 {QLCNIC_CMD_SET_MTU
, qlcnic_sriov_pf_set_mtu_cmd
},
1436 {QLCNIC_CMD_GET_NIC_INFO
, qlcnic_sriov_pf_get_nic_info_cmd
},
1437 {QLCNIC_CMD_CONFIGURE_RSS
, qlcnic_sriov_pf_cfg_rss_cmd
},
1438 {QLCNIC_CMD_CONFIG_INTR_COAL
, qlcnic_sriov_pf_cfg_intrcoal_cmd
},
1439 {QLCNIC_CMD_CONFIG_MAC_VLAN
, qlcnic_sriov_pf_cfg_macvlan_cmd
},
1440 {QLCNIC_CMD_GET_LINK_EVENT
, qlcnic_sriov_pf_linkevent_cmd
},
1441 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE
, qlcnic_sriov_pf_cfg_promisc_cmd
},
1444 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter
*adapter
,
1445 struct qlcnic_bc_trans
*trans
,
1446 struct qlcnic_cmd_args
*cmd
)
1450 cmd_op
= trans
->req_hdr
->cmd_op
;
1452 if (trans
->req_hdr
->op_type
== QLC_BC_CMD
) {
1453 size
= ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr
);
1454 if (cmd_op
< size
) {
1455 qlcnic_pf_bc_cmd_hdlr
[cmd_op
].fn(trans
, cmd
);
1460 size
= ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr
);
1461 for (i
= 0; i
< size
; i
++) {
1462 if (cmd_op
== qlcnic_pf_fw_cmd_hdlr
[i
].cmd
) {
1463 qlcnic_pf_fw_cmd_hdlr
[i
].fn(trans
, cmd
);
1468 size
= ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds
);
1469 for (i
= 0; i
< size
; i
++) {
1470 if (cmd_op
== qlcnic_pf_passthru_supp_cmds
[i
]) {
1471 qlcnic_issue_cmd(adapter
, cmd
);
1477 cmd
->rsp
.arg
[0] |= (0x9 << 25);
1480 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter
*adapter
,
1485 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1486 adapter
->ahw
->pci_func
);
1490 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter
*adapter
,
1495 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1496 adapter
->ahw
->pci_func
);
1497 *int_id
|= vpid
<< 16;
1500 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter
*adapter
,
1505 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1506 adapter
->ahw
->pci_func
);
1507 *int_id
|= vpid
<< 16;
1510 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter
*adapter
,
1515 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1516 adapter
->ahw
->pci_func
);
1517 *int_id
|= vpid
<< 16;
1520 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter
*adapter
,
1525 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1526 adapter
->ahw
->pci_func
);
1527 *int_id
|= (vpid
<< 16) | BIT_31
;
1530 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter
*adapter
,
1535 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1536 adapter
->ahw
->pci_func
);
1537 *int_id
|= (vpid
<< 16) | BIT_31
;
1540 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter
*adapter
,
1545 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
,
1546 adapter
->ahw
->pci_func
);
1547 *int_id
|= (vpid
<< 16) | BIT_31
;
1550 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter
*adapter
,
1551 struct qlcnic_vf_info
*vf
)
1553 struct qlcnic_cmd_args cmd
;
1559 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_DESTROY_RX_CTX
))
1562 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
, vf
->pci_func
);
1564 cmd
.req
.arg
[1] = vf
->rx_ctx_id
| (vpid
& 0xffff) << 16;
1565 if (qlcnic_issue_cmd(adapter
, &cmd
))
1566 dev_err(&adapter
->pdev
->dev
,
1567 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1573 qlcnic_free_mbx_args(&cmd
);
1576 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter
*adapter
,
1577 struct qlcnic_vf_info
*vf
)
1579 struct qlcnic_cmd_args cmd
;
1585 if (qlcnic_alloc_mbx_args(&cmd
, adapter
, QLCNIC_CMD_DESTROY_TX_CTX
))
1588 vpid
= qlcnic_sriov_pf_get_vport_handle(adapter
, vf
->pci_func
);
1590 cmd
.req
.arg
[1] |= vf
->tx_ctx_id
| (vpid
& 0xffff) << 16;
1591 if (qlcnic_issue_cmd(adapter
, &cmd
))
1592 dev_err(&adapter
->pdev
->dev
,
1593 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1599 qlcnic_free_mbx_args(&cmd
);
1602 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov
*sriov
,
1603 struct qlcnic_vf_info
*vf
,
1604 struct qlcnic_bc_trans
*trans
)
1606 struct qlcnic_trans_list
*t_list
= &vf
->rcv_act
;
1609 spin_lock_irqsave(&t_list
->lock
, flag
);
1611 __qlcnic_sriov_add_act_list(sriov
, vf
, trans
);
1613 spin_unlock_irqrestore(&t_list
->lock
, flag
);
1617 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info
*vf
)
1619 struct qlcnic_adapter
*adapter
= vf
->adapter
;
1621 qlcnic_sriov_cleanup_list(&vf
->rcv_pend
);
1622 cancel_work_sync(&vf
->trans_work
);
1623 qlcnic_sriov_cleanup_list(&vf
->rcv_act
);
1625 if (test_bit(QLC_BC_VF_SOFT_FLR
, &vf
->state
)) {
1626 qlcnic_sriov_del_tx_ctx(adapter
, vf
);
1627 qlcnic_sriov_del_rx_ctx(adapter
, vf
);
1630 qlcnic_sriov_pf_config_vport(adapter
, 0, vf
->pci_func
);
1632 clear_bit(QLC_BC_VF_FLR
, &vf
->state
);
1633 if (test_bit(QLC_BC_VF_SOFT_FLR
, &vf
->state
)) {
1634 qlcnic_sriov_add_act_list_irqsave(adapter
->ahw
->sriov
, vf
,
1636 clear_bit(QLC_BC_VF_SOFT_FLR
, &vf
->state
);
1637 vf
->flr_trans
= NULL
;
1641 static void qlcnic_sriov_pf_process_flr(struct work_struct
*work
)
1643 struct qlcnic_vf_info
*vf
;
1645 vf
= container_of(work
, struct qlcnic_vf_info
, flr_work
);
1646 __qlcnic_sriov_process_flr(vf
);
1650 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov
*sriov
,
1651 struct qlcnic_vf_info
*vf
,
1654 if (test_bit(__QLCNIC_RESETTING
, &vf
->adapter
->state
))
1657 INIT_WORK(&vf
->flr_work
, func
);
1658 queue_work(sriov
->bc
.bc_flr_wq
, &vf
->flr_work
);
1661 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter
*adapter
,
1662 struct qlcnic_bc_trans
*trans
,
1663 struct qlcnic_vf_info
*vf
)
1665 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1667 set_bit(QLC_BC_VF_FLR
, &vf
->state
);
1668 clear_bit(QLC_BC_VF_STATE
, &vf
->state
);
1669 set_bit(QLC_BC_VF_SOFT_FLR
, &vf
->state
);
1670 vf
->flr_trans
= trans
;
1671 qlcnic_sriov_schedule_flr(sriov
, vf
, qlcnic_sriov_pf_process_flr
);
1672 netdev_info(adapter
->netdev
, "Software FLR for PCI func %d\n",
1676 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter
*adapter
,
1677 struct qlcnic_bc_trans
*trans
,
1678 struct qlcnic_vf_info
*vf
)
1680 struct qlcnic_bc_hdr
*hdr
= trans
->req_hdr
;
1682 if ((hdr
->cmd_op
== QLCNIC_BC_CMD_CHANNEL_INIT
) &&
1683 (hdr
->op_type
== QLC_BC_CMD
) &&
1684 test_bit(QLC_BC_VF_STATE
, &vf
->state
)) {
1685 qlcnic_sriov_handle_soft_flr(adapter
, trans
, vf
);
1692 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov
*sriov
,
1693 struct qlcnic_vf_info
*vf
)
1695 struct net_device
*dev
= vf
->adapter
->netdev
;
1696 struct qlcnic_vport
*vp
= vf
->vp
;
1698 if (!test_and_clear_bit(QLC_BC_VF_STATE
, &vf
->state
)) {
1699 clear_bit(QLC_BC_VF_FLR
, &vf
->state
);
1703 if (test_and_set_bit(QLC_BC_VF_FLR
, &vf
->state
)) {
1704 netdev_info(dev
, "FLR for PCI func %d in progress\n",
1709 if (vp
->vlan_mode
== QLC_GUEST_VLAN_MODE
)
1710 memset(vf
->sriov_vlans
, 0,
1711 sizeof(*vf
->sriov_vlans
) * sriov
->num_allowed_vlans
);
1713 qlcnic_sriov_schedule_flr(sriov
, vf
, qlcnic_sriov_pf_process_flr
);
1714 netdev_info(dev
, "FLR received for PCI func %d\n", vf
->pci_func
);
1717 void qlcnic_sriov_pf_reset(struct qlcnic_adapter
*adapter
)
1719 struct qlcnic_hardware_context
*ahw
= adapter
->ahw
;
1720 struct qlcnic_sriov
*sriov
= ahw
->sriov
;
1721 struct qlcnic_vf_info
*vf
;
1722 u16 num_vfs
= sriov
->num_vfs
;
1725 for (i
= 0; i
< num_vfs
; i
++) {
1726 vf
= &sriov
->vf_info
[i
];
1729 cancel_work_sync(&vf
->flr_work
);
1730 __qlcnic_sriov_process_flr(vf
);
1731 clear_bit(QLC_BC_VF_STATE
, &vf
->state
);
1734 qlcnic_sriov_pf_reset_vport_handle(adapter
, ahw
->pci_func
);
1735 QLCWRX(ahw
, QLCNIC_MBX_INTR_ENBL
, (ahw
->num_msix
- 1) << 8);
1738 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter
*adapter
)
1740 struct qlcnic_hardware_context
*ahw
= adapter
->ahw
;
1743 if (!qlcnic_sriov_enable_check(adapter
))
1746 ahw
->op_mode
= QLCNIC_SRIOV_PF_FUNC
;
1748 err
= qlcnic_sriov_pf_init(adapter
);
1752 dev_info(&adapter
->pdev
->dev
, "%s: op_mode %d\n",
1753 __func__
, ahw
->op_mode
);
1757 int qlcnic_sriov_set_vf_mac(struct net_device
*netdev
, int vf
, u8
*mac
)
1759 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
1760 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1762 struct qlcnic_vf_info
*vf_info
;
1765 if (!qlcnic_sriov_pf_check(adapter
))
1768 num_vfs
= sriov
->num_vfs
;
1770 if (!is_valid_ether_addr(mac
) || vf
>= num_vfs
)
1773 if (ether_addr_equal(adapter
->mac_addr
, mac
)) {
1774 netdev_err(netdev
, "MAC address is already in use by the PF\n");
1778 for (i
= 0; i
< num_vfs
; i
++) {
1779 vf_info
= &sriov
->vf_info
[i
];
1780 if (ether_addr_equal(vf_info
->vp
->mac
, mac
)) {
1782 "MAC address is already in use by VF %d\n",
1788 vf_info
= &sriov
->vf_info
[vf
];
1789 curr_mac
= vf_info
->vp
->mac
;
1791 if (test_bit(QLC_BC_VF_STATE
, &vf_info
->state
)) {
1793 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1798 memcpy(curr_mac
, mac
, netdev
->addr_len
);
1799 netdev_info(netdev
, "MAC Address %pM is configured for VF %d\n",
1804 int qlcnic_sriov_set_vf_tx_rate(struct net_device
*netdev
, int vf
, int tx_rate
)
1806 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
1807 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1808 struct qlcnic_vf_info
*vf_info
;
1809 struct qlcnic_info nic_info
;
1810 struct qlcnic_vport
*vp
;
1813 if (!qlcnic_sriov_pf_check(adapter
))
1816 if (vf
>= sriov
->num_vfs
)
1819 if (tx_rate
>= 10000 || tx_rate
< 100) {
1821 "Invalid Tx rate, allowed range is [%d - %d]",
1822 QLC_VF_MIN_TX_RATE
, QLC_VF_MAX_TX_RATE
);
1829 vf_info
= &sriov
->vf_info
[vf
];
1833 if (test_bit(QLC_BC_VF_STATE
, &vf_info
->state
)) {
1834 if (qlcnic_sriov_get_vf_vport_info(adapter
, &nic_info
, vpid
))
1837 nic_info
.max_tx_bw
= tx_rate
/ 100;
1838 nic_info
.bit_offsets
= BIT_0
;
1840 if (qlcnic_sriov_pf_set_vport_info(adapter
, &nic_info
, vpid
))
1844 vp
->max_tx_bw
= tx_rate
/ 100;
1846 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1847 tx_rate
, vp
->max_tx_bw
, vf
);
1851 int qlcnic_sriov_set_vf_vlan(struct net_device
*netdev
, int vf
,
1854 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
1855 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1856 struct qlcnic_vf_info
*vf_info
;
1857 struct qlcnic_vport
*vp
;
1859 if (!qlcnic_sriov_pf_check(adapter
))
1862 if (vf
>= sriov
->num_vfs
|| qos
> 7)
1865 if (vlan
> MAX_VLAN_ID
) {
1867 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1872 vf_info
= &sriov
->vf_info
[vf
];
1874 if (test_bit(QLC_BC_VF_STATE
, &vf_info
->state
)) {
1876 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1881 memset(vf_info
->sriov_vlans
, 0,
1882 sizeof(*vf_info
->sriov_vlans
) * sriov
->num_allowed_vlans
);
1886 vp
->vlan_mode
= QLC_GUEST_VLAN_MODE
;
1889 vp
->vlan_mode
= QLC_NO_VLAN_MODE
;
1893 vp
->vlan_mode
= QLC_PVID_MODE
;
1894 qlcnic_sriov_add_vlan_id(sriov
, vf_info
, vlan
);
1899 netdev_info(netdev
, "Setting VLAN %d, QoS %d, for VF %d\n",
1904 static __u32
qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter
*adapter
,
1905 struct qlcnic_vport
*vp
, int vf
)
1909 switch (vp
->vlan_mode
) {
1913 case QLC_GUEST_VLAN_MODE
:
1916 case QLC_NO_VLAN_MODE
:
1920 netdev_info(adapter
->netdev
, "Invalid VLAN mode = %d for VF %d\n",
1927 int qlcnic_sriov_get_vf_config(struct net_device
*netdev
,
1928 int vf
, struct ifla_vf_info
*ivi
)
1930 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
1931 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1932 struct qlcnic_vport
*vp
;
1934 if (!qlcnic_sriov_pf_check(adapter
))
1937 if (vf
>= sriov
->num_vfs
)
1940 vp
= sriov
->vf_info
[vf
].vp
;
1941 memcpy(&ivi
->mac
, vp
->mac
, ETH_ALEN
);
1942 ivi
->vlan
= qlcnic_sriov_get_vf_vlan(adapter
, vp
, vf
);
1944 ivi
->spoofchk
= vp
->spoofchk
;
1945 if (vp
->max_tx_bw
== MAX_BW
)
1948 ivi
->tx_rate
= vp
->max_tx_bw
* 100;
1954 int qlcnic_sriov_set_vf_spoofchk(struct net_device
*netdev
, int vf
, bool chk
)
1956 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
1957 struct qlcnic_sriov
*sriov
= adapter
->ahw
->sriov
;
1958 struct qlcnic_vf_info
*vf_info
;
1959 struct qlcnic_vport
*vp
;
1961 if (!qlcnic_sriov_pf_check(adapter
))
1964 if (vf
>= sriov
->num_vfs
)
1967 vf_info
= &sriov
->vf_info
[vf
];
1969 if (test_bit(QLC_BC_VF_STATE
, &vf_info
->state
)) {
1971 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",