2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 QLogic Corporation
5 * See LICENSE.qlcnic for copyright and licensing details.
8 #include <linux/types.h>
10 #include "qlcnic_sriov.h"
13 #define QLCNIC_SRIOV_VF_MAX_MAC 7
14 #define QLC_VF_MIN_TX_RATE 100
15 #define QLC_VF_MAX_TX_RATE 9999
16 #define QLC_MAC_OPCODE_MASK 0x7
17 #define QLC_VF_FLOOD_BIT BIT_16
18 #define QLC_FLOOD_MODE 0x5
19 #define QLC_SRIOV_ALLOW_VLAN0 BIT_19
20 #define QLC_INTR_COAL_TYPE_MASK 0x7
22 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
24 struct qlcnic_sriov_cmd_handler {
25 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
28 struct qlcnic_sriov_fw_cmd_handler {
30 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
33 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
34 struct qlcnic_info *npar_info,
37 struct qlcnic_cmd_args cmd;
40 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
43 cmd.req.arg[1] = (vport_id << 16) | 0x1;
44 cmd.req.arg[2] = npar_info->bit_offsets;
45 cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
46 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
47 cmd.req.arg[4] = npar_info->max_tx_mac_filters;
48 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
49 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
50 (npar_info->max_rx_ip_addr << 16);
51 cmd.req.arg[6] = npar_info->max_rx_lro_flow |
52 (npar_info->max_rx_status_rings << 16);
53 cmd.req.arg[7] = npar_info->max_rx_buf_rings |
54 (npar_info->max_rx_ques << 16);
55 cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
56 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
57 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
59 err = qlcnic_issue_cmd(adapter, &cmd);
61 dev_err(&adapter->pdev->dev,
62 "Failed to set vport info, err=%d\n", err);
64 qlcnic_free_mbx_args(&cmd);
68 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
69 struct qlcnic_info *info, u16 func)
71 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
72 struct qlcnic_resources *res = &sriov->ff_max;
73 u16 num_macs = sriov->num_allowed_vlans + 1;
74 int ret = -EIO, vpid, id;
75 struct qlcnic_vport *vp;
76 u32 num_vfs, max, temp;
78 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
82 num_vfs = sriov->num_vfs;
84 info->bit_offsets = 0xffff;
85 info->max_tx_ques = res->num_tx_queues / max;
87 if (qlcnic_83xx_pf_check(adapter))
88 num_macs = QLCNIC_83XX_SRIOV_VF_MAX_MAC;
90 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
92 if (adapter->ahw->pci_func == func) {
94 info->max_tx_bw = MAX_BW;
96 temp = res->num_rx_ucast_mac_filters - num_macs * num_vfs;
97 info->max_rx_ucast_mac_filters = temp;
98 temp = res->num_tx_mac_filters - num_macs * num_vfs;
99 info->max_tx_mac_filters = temp;
100 temp = num_macs * num_vfs * QLCNIC_SRIOV_VF_MAX_MAC;
101 temp = res->num_rx_mcast_mac_filters - temp;
102 info->max_rx_mcast_mac_filters = temp;
104 info->max_tx_ques = res->num_tx_queues - sriov->num_vfs;
106 id = qlcnic_sriov_func_to_index(adapter, func);
109 vp = sriov->vf_info[id].vp;
110 info->min_tx_bw = vp->min_tx_bw;
111 info->max_tx_bw = vp->max_tx_bw;
113 info->max_rx_ucast_mac_filters = num_macs;
114 info->max_tx_mac_filters = num_macs;
115 temp = num_macs * QLCNIC_SRIOV_VF_MAX_MAC;
116 info->max_rx_mcast_mac_filters = temp;
118 info->max_tx_ques = QLCNIC_SINGLE_RING;
121 info->max_rx_ip_addr = res->num_destip / max;
122 info->max_rx_status_rings = res->num_rx_status_rings / max;
123 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
124 info->max_rx_ques = res->num_rx_queues / max;
125 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
126 info->max_tx_vlan_keys = res->num_txvlan_keys;
127 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
128 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
130 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
137 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
138 struct qlcnic_info *info)
140 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
142 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
143 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
144 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
145 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
146 ff_max->num_rx_queues = info->max_rx_ques;
147 ff_max->num_tx_queues = info->max_tx_ques;
148 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
149 ff_max->num_destip = info->max_rx_ip_addr;
150 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
151 ff_max->num_rx_status_rings = info->max_rx_status_rings;
152 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
153 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
156 static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter *adapter,
157 struct qlcnic_info *npar_info)
159 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
162 temp = npar_info->max_rx_mcast_mac_filters;
163 total_fn = sriov->num_vfs + 1;
165 temp = temp / (QLCNIC_SRIOV_VF_MAX_MAC * total_fn);
166 sriov->num_allowed_vlans = temp - 1;
168 if (qlcnic_83xx_pf_check(adapter))
169 sriov->num_allowed_vlans = 1;
171 netdev_info(adapter->netdev, "Max Guest VLANs supported per VF = %d\n",
172 sriov->num_allowed_vlans);
175 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
176 struct qlcnic_info *npar_info)
179 struct qlcnic_cmd_args cmd;
181 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
184 cmd.req.arg[1] = 0x2;
185 err = qlcnic_issue_cmd(adapter, &cmd);
187 dev_err(&adapter->pdev->dev,
188 "Failed to get PF info, err=%d\n", err);
192 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
193 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
194 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
195 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
196 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
197 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
198 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
199 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
200 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
201 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
202 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
203 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
204 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
205 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
206 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
208 qlcnic_sriov_set_vf_max_vlan(adapter, npar_info);
209 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
210 dev_info(&adapter->pdev->dev,
211 "\n\ttotal_pf: %d,\n"
212 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
213 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
214 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
215 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
216 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
217 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
218 npar_info->total_pf, npar_info->total_rss_engines,
219 npar_info->max_vports, npar_info->max_tx_ques,
220 npar_info->max_tx_mac_filters,
221 npar_info->max_rx_mcast_mac_filters,
222 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
223 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
224 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
225 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
226 npar_info->max_remote_ipv6_addrs);
229 qlcnic_free_mbx_args(&cmd);
233 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
236 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
237 struct qlcnic_vport *vp;
240 if (adapter->ahw->pci_func == func) {
241 sriov->vp_handle = 0;
243 index = qlcnic_sriov_func_to_index(adapter, func);
246 vp = sriov->vf_info[index].vp;
251 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
252 u16 vport_handle, u8 func)
254 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
255 struct qlcnic_vport *vp;
258 if (adapter->ahw->pci_func == func) {
259 sriov->vp_handle = vport_handle;
261 index = qlcnic_sriov_func_to_index(adapter, func);
264 vp = sriov->vf_info[index].vp;
265 vp->handle = vport_handle;
269 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
272 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
273 struct qlcnic_vf_info *vf_info;
276 if (adapter->ahw->pci_func == func) {
277 return sriov->vp_handle;
279 index = qlcnic_sriov_func_to_index(adapter, func);
281 vf_info = &sriov->vf_info[index];
282 return vf_info->vp->handle;
289 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
292 struct qlcnic_cmd_args cmd;
296 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
300 cmd.req.arg[3] = func << 8;
302 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
307 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
310 ret = qlcnic_issue_cmd(adapter, &cmd);
312 dev_err(&adapter->pdev->dev,
313 "Failed %s vport, err %d for func 0x%x\n",
314 (flag ? "enable" : "disable"), ret, func);
319 vpid = cmd.rsp.arg[2] & 0xffff;
320 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
322 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
326 qlcnic_free_mbx_args(&cmd);
330 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
333 struct qlcnic_cmd_args cmd;
336 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
340 cmd.req.arg[1] = 0x4;
342 adapter->flags |= QLCNIC_VLAN_FILTERING;
343 cmd.req.arg[1] |= BIT_16;
344 if (qlcnic_84xx_check(adapter))
345 cmd.req.arg[1] |= QLC_SRIOV_ALLOW_VLAN0;
347 adapter->flags &= ~QLCNIC_VLAN_FILTERING;
350 err = qlcnic_issue_cmd(adapter, &cmd);
352 dev_err(&adapter->pdev->dev,
353 "Failed to configure VLAN filtering, err=%d\n", err);
355 qlcnic_free_mbx_args(&cmd);
359 /* On configuring VF flood bit, PFD will receive traffic from all VFs */
360 static int qlcnic_sriov_pf_cfg_flood(struct qlcnic_adapter *adapter)
362 struct qlcnic_cmd_args cmd;
365 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
369 cmd.req.arg[1] = QLC_FLOOD_MODE | QLC_VF_FLOOD_BIT;
371 err = qlcnic_issue_cmd(adapter, &cmd);
373 dev_err(&adapter->pdev->dev,
374 "Failed to configure VF Flood bit on PF, err=%d\n",
377 qlcnic_free_mbx_args(&cmd);
381 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
384 struct qlcnic_cmd_args cmd;
387 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
390 cmd.req.arg[0] |= (3 << 29);
391 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
393 cmd.req.arg[1] |= BIT_0;
395 err = qlcnic_issue_cmd(adapter, &cmd);
397 if (err != QLCNIC_RCODE_SUCCESS) {
398 dev_err(&adapter->pdev->dev,
399 "Failed to enable sriov eswitch%d\n", err);
403 qlcnic_free_mbx_args(&cmd);
407 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
409 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
410 struct qlcnic_back_channel *bc = &sriov->bc;
413 for (i = 0; i < sriov->num_vfs; i++)
414 cancel_work_sync(&sriov->vf_info[i].flr_work);
416 destroy_workqueue(bc->bc_flr_wq);
419 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
421 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
422 struct workqueue_struct *wq;
424 wq = create_singlethread_workqueue("qlcnic-flr");
426 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
434 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
436 u8 func = adapter->ahw->pci_func;
438 if (!qlcnic_sriov_enable_check(adapter))
441 qlcnic_sriov_pf_del_flr_queue(adapter);
442 qlcnic_sriov_cfg_bc_intr(adapter, 0);
443 qlcnic_sriov_pf_config_vport(adapter, 0, func);
444 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
445 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
446 __qlcnic_sriov_cleanup(adapter);
447 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
448 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
451 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
453 if (!qlcnic_sriov_pf_check(adapter))
456 if (!qlcnic_sriov_enable_check(adapter))
459 pci_disable_sriov(adapter->pdev);
460 netdev_info(adapter->netdev,
461 "SR-IOV is disabled successfully on port %d\n",
465 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
467 struct net_device *netdev = adapter->netdev;
469 if (pci_vfs_assigned(adapter->pdev)) {
470 netdev_err(adapter->netdev,
471 "SR-IOV VFs belonging to port %d are assigned to VMs. SR-IOV can not be disabled on this port\n",
473 netdev_info(adapter->netdev,
474 "Please detach SR-IOV VFs belonging to port %d from VMs, and then try to disable SR-IOV on this port\n",
479 qlcnic_sriov_pf_disable(adapter);
482 if (netif_running(netdev))
483 __qlcnic_down(adapter, netdev);
485 qlcnic_sriov_free_vlans(adapter);
487 qlcnic_sriov_pf_cleanup(adapter);
489 /* After disabling SRIOV re-init the driver in default mode
490 configure opmode based on op_mode of function
492 if (qlcnic_83xx_configure_opmode(adapter)) {
497 if (netif_running(netdev))
498 __qlcnic_up(adapter, netdev);
504 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
506 struct qlcnic_hardware_context *ahw = adapter->ahw;
507 struct qlcnic_info nic_info, pf_info, vp_info;
509 u8 func = ahw->pci_func;
511 if (!qlcnic_sriov_enable_check(adapter))
514 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
518 if (qlcnic_84xx_check(adapter)) {
519 err = qlcnic_sriov_pf_cfg_flood(adapter);
521 goto disable_vlan_filtering;
524 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
526 goto disable_vlan_filtering;
528 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
530 goto disable_eswitch;
532 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
536 err = qlcnic_get_nic_info(adapter, &nic_info, func);
540 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
544 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
548 ahw->physical_port = (u8) nic_info.phys_port;
549 ahw->switch_mode = nic_info.switch_mode;
550 ahw->max_mtu = nic_info.max_mtu;
551 ahw->capabilities = nic_info.capabilities;
552 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
556 qlcnic_sriov_pf_config_vport(adapter, 0, func);
559 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
561 disable_vlan_filtering:
562 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
567 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
571 if (!qlcnic_sriov_enable_check(adapter))
574 err = pci_enable_sriov(adapter->pdev, num_vfs);
576 qlcnic_sriov_pf_cleanup(adapter);
581 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
586 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
587 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
589 err = qlcnic_sriov_init(adapter, num_vfs);
593 err = qlcnic_sriov_pf_create_flr_queue(adapter);
597 err = qlcnic_sriov_pf_init(adapter);
601 err = qlcnic_sriov_alloc_vlans(adapter);
608 qlcnic_sriov_pf_del_flr_queue(adapter);
611 __qlcnic_sriov_cleanup(adapter);
614 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
615 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
619 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
621 struct net_device *netdev = adapter->netdev;
624 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
626 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
631 if (netif_running(netdev))
632 __qlcnic_down(adapter, netdev);
634 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
638 if (netif_running(netdev))
639 __qlcnic_up(adapter, netdev);
642 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
645 "SR-IOV is enabled successfully on port %d\n",
647 /* Return number of vfs enabled */
652 if (netif_running(netdev))
653 __qlcnic_down(adapter, netdev);
656 if (!qlcnic_83xx_configure_opmode(adapter)) {
657 if (netif_running(netdev))
658 __qlcnic_up(adapter, netdev);
662 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
668 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
670 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
673 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
677 err = qlcnic_pci_sriov_disable(adapter);
679 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
681 clear_bit(__QLCNIC_RESETTING, &adapter->state);
685 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
687 struct qlcnic_cmd_args cmd;
688 struct qlcnic_vport *vp;
692 id = qlcnic_sriov_func_to_index(adapter, func);
696 vp = adapter->ahw->sriov->vf_info[id].vp;
697 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
701 cmd.req.arg[1] = 0x3 | func << 16;
702 if (vp->spoofchk == true) {
704 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
705 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
707 cmd.req.arg[5] = mac[1] | mac[0] << 8;
710 if (vp->vlan_mode == QLC_PVID_MODE) {
711 cmd.req.arg[2] |= BIT_6;
712 cmd.req.arg[3] |= vp->pvid << 8;
715 err = qlcnic_issue_cmd(adapter, &cmd);
717 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
720 qlcnic_free_mbx_args(&cmd);
724 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
727 struct qlcnic_info defvp_info;
730 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
734 err = qlcnic_sriov_set_vf_acl(adapter, func);
741 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
742 struct qlcnic_cmd_args *cmd)
744 struct qlcnic_vf_info *vf = trans->vf;
745 struct qlcnic_vport *vp = vf->vp;
746 struct qlcnic_adapter *adapter;
747 struct qlcnic_sriov *sriov;
748 u16 func = vf->pci_func;
752 adapter = vf->adapter;
753 sriov = adapter->ahw->sriov;
755 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
756 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
758 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
760 qlcnic_sriov_pf_config_vport(adapter, 0, func);
763 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {
764 size = sizeof(*vf->sriov_vlans);
765 size = size * sriov->num_allowed_vlans;
766 memset(vf->sriov_vlans, 0, size);
769 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
775 cmd->rsp.arg[0] |= (1 << 25);
777 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
778 set_bit(QLC_BC_VF_STATE, &vf->state);
780 clear_bit(QLC_BC_VF_STATE, &vf->state);
785 cmd->rsp.arg[0] |= (2 << 25);
789 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
790 struct qlcnic_vf_info *vf,
793 struct qlcnic_cmd_args *cmd;
794 struct qlcnic_macvlan_mbx mv;
795 struct qlcnic_vport *vp;
803 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
807 err = qlcnic_alloc_mbx_args(cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN);
811 cmd->type = QLC_83XX_MBX_CMD_NO_WAIT;
812 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
819 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
820 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
822 cmd->req.arg[1] = op | (1 << 8) | (3 << 6);
823 cmd->req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
827 mv.mac_addr0 = addr[0];
828 mv.mac_addr1 = addr[1];
829 mv.mac_addr2 = addr[2];
830 mv.mac_addr3 = addr[3];
831 mv.mac_addr4 = addr[4];
832 mv.mac_addr5 = addr[5];
833 buf = &cmd->req.arg[2];
834 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
836 err = qlcnic_issue_cmd(adapter, cmd);
842 qlcnic_free_mbx_args(cmd);
848 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
850 if ((cmd->req.arg[0] >> 29) != 0x3)
856 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,
857 struct qlcnic_vf_info *vf,
860 struct qlcnic_sriov *sriov;
864 sriov = adapter->ahw->sriov;
866 spin_lock_bh(&vf->vlan_list_lock);
868 for (i = 0; i < sriov->num_allowed_vlans; i++) {
869 vlan = vf->sriov_vlans[i];
871 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,
875 spin_unlock_bh(&vf->vlan_list_lock);
877 if (vf->vp->vlan_mode != QLC_PVID_MODE) {
878 if (qlcnic_83xx_pf_check(adapter) &&
879 qlcnic_sriov_check_any_vlan(vf))
881 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);
885 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
886 struct qlcnic_cmd_args *cmd)
888 struct qlcnic_vf_info *vf = tran->vf;
889 struct qlcnic_adapter *adapter = vf->adapter;
890 struct qlcnic_rcv_mbx_out *mbx_out;
893 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
895 cmd->rsp.arg[0] |= (0x6 << 25);
899 cmd->req.arg[6] = vf->vp->handle;
900 err = qlcnic_issue_cmd(adapter, cmd);
903 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
904 vf->rx_ctx_id = mbx_out->ctx_id;
905 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);
913 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
914 struct qlcnic_cmd_args *cmd)
916 struct qlcnic_vf_info *vf = trans->vf;
919 type = cmd->req.arg[1];
921 case QLCNIC_SET_STATION_MAC:
922 case QLCNIC_SET_FAC_DEF_MAC:
923 cmd->rsp.arg[0] = (2 << 25);
925 case QLCNIC_GET_CURRENT_MAC:
926 cmd->rsp.arg[0] = (1 << 25);
928 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
929 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
930 ((mac[3]) << 16 & 0xff0000) |
931 ((mac[2]) << 24 & 0xff000000);
937 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
939 if ((cmd->req.arg[0] >> 29) != 0x3)
945 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
946 struct qlcnic_cmd_args *cmd)
948 struct qlcnic_vf_info *vf = trans->vf;
949 struct qlcnic_adapter *adapter = vf->adapter;
950 struct qlcnic_tx_mbx_out *mbx_out;
953 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
955 cmd->rsp.arg[0] |= (0x6 << 25);
959 cmd->req.arg[5] |= vf->vp->handle << 16;
960 err = qlcnic_issue_cmd(adapter, cmd);
962 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
963 vf->tx_ctx_id = mbx_out->ctx_id;
971 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
972 struct qlcnic_cmd_args *cmd)
974 if ((cmd->req.arg[0] >> 29) != 0x3)
977 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
983 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
984 struct qlcnic_cmd_args *cmd)
986 struct qlcnic_vf_info *vf = trans->vf;
987 struct qlcnic_adapter *adapter = vf->adapter;
990 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
992 cmd->rsp.arg[0] |= (0x6 << 25);
996 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);
997 cmd->req.arg[1] |= vf->vp->handle << 16;
998 err = qlcnic_issue_cmd(adapter, cmd);
1006 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
1007 struct qlcnic_cmd_args *cmd)
1009 if ((cmd->req.arg[0] >> 29) != 0x3)
1012 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
1018 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
1019 struct qlcnic_cmd_args *cmd)
1021 struct qlcnic_vf_info *vf = trans->vf;
1022 struct qlcnic_adapter *adapter = vf->adapter;
1025 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
1027 cmd->rsp.arg[0] |= (0x6 << 25);
1031 cmd->req.arg[1] |= vf->vp->handle << 16;
1032 err = qlcnic_issue_cmd(adapter, cmd);
1040 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
1041 struct qlcnic_cmd_args *cmd)
1043 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1049 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
1050 struct qlcnic_cmd_args *cmd)
1052 struct qlcnic_vf_info *vf = trans->vf;
1053 struct qlcnic_adapter *adapter = vf->adapter;
1056 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
1058 cmd->rsp.arg[0] |= (0x6 << 25);
1062 err = qlcnic_issue_cmd(adapter, cmd);
1066 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
1067 struct qlcnic_cmd_args *cmd)
1069 struct qlcnic_vf_info *vf = trans->vf;
1070 struct qlcnic_adapter *adapter = vf->adapter;
1074 op = cmd->req.arg[1] & 0xff;
1076 cmd->req.arg[1] |= vf->vp->handle << 16;
1077 cmd->req.arg[1] |= BIT_31;
1079 err = qlcnic_issue_cmd(adapter, cmd);
1083 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
1084 struct qlcnic_cmd_args *cmd)
1086 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
1089 if (!(cmd->req.arg[1] & BIT_16))
1092 if ((cmd->req.arg[1] & 0xff) != 0x1)
1098 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
1099 struct qlcnic_cmd_args *cmd)
1101 struct qlcnic_vf_info *vf = trans->vf;
1102 struct qlcnic_adapter *adapter = vf->adapter;
1105 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
1107 cmd->rsp.arg[0] |= (0x6 << 25);
1109 err = qlcnic_issue_cmd(adapter, cmd);
1114 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
1115 struct qlcnic_vf_info *vf,
1116 struct qlcnic_cmd_args *cmd)
1118 if (cmd->req.arg[1] != vf->rx_ctx_id)
1121 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
1127 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
1128 struct qlcnic_cmd_args *cmd)
1130 struct qlcnic_vf_info *vf = trans->vf;
1131 struct qlcnic_adapter *adapter = vf->adapter;
1134 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
1136 cmd->rsp.arg[0] |= (0x6 << 25);
1138 err = qlcnic_issue_cmd(adapter, cmd);
1143 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1144 struct qlcnic_cmd_args *cmd)
1146 if (cmd->req.arg[1] & BIT_31) {
1147 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1150 cmd->req.arg[1] |= vf->vp->handle << 16;
1156 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1157 struct qlcnic_cmd_args *cmd)
1159 struct qlcnic_vf_info *vf = trans->vf;
1160 struct qlcnic_adapter *adapter = vf->adapter;
1163 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1165 cmd->rsp.arg[0] |= (0x6 << 25);
1169 err = qlcnic_issue_cmd(adapter, cmd);
1173 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1174 struct qlcnic_cmd_args *cmd)
1176 if (cmd->req.arg[1] != vf->rx_ctx_id)
1182 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1183 struct qlcnic_cmd_args *cmd)
1185 struct qlcnic_vf_info *vf = trans->vf;
1186 struct qlcnic_adapter *adapter = vf->adapter;
1189 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1191 cmd->rsp.arg[0] |= (0x6 << 25);
1193 err = qlcnic_issue_cmd(adapter, cmd);
1198 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1199 struct qlcnic_vf_info *vf,
1200 struct qlcnic_cmd_args *cmd)
1202 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1203 u16 ctx_id, pkts, time;
1207 type = cmd->req.arg[1] & QLC_INTR_COAL_TYPE_MASK;
1208 ctx_id = cmd->req.arg[1] >> 16;
1209 pkts = cmd->req.arg[2] & 0xffff;
1210 time = cmd->req.arg[2] >> 16;
1213 case QLCNIC_INTR_COAL_TYPE_RX:
1214 if (ctx_id != vf->rx_ctx_id || pkts > coal->rx_packets ||
1215 time < coal->rx_time_us)
1218 case QLCNIC_INTR_COAL_TYPE_TX:
1219 if (ctx_id != vf->tx_ctx_id || pkts > coal->tx_packets ||
1220 time < coal->tx_time_us)
1224 netdev_err(adapter->netdev, "Invalid coalescing type 0x%x received\n",
1232 netdev_err(adapter->netdev, "Expected: rx_ctx_id 0x%x rx_packets 0x%x rx_time_us 0x%x tx_ctx_id 0x%x tx_packets 0x%x tx_time_us 0x%x\n",
1233 vf->rx_ctx_id, coal->rx_packets, coal->rx_time_us,
1234 vf->tx_ctx_id, coal->tx_packets, coal->tx_time_us);
1235 netdev_err(adapter->netdev, "Received: ctx_id 0x%x packets 0x%x time_us 0x%x type 0x%x\n",
1236 ctx_id, pkts, time, type);
1241 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1242 struct qlcnic_cmd_args *cmd)
1244 struct qlcnic_vf_info *vf = tran->vf;
1245 struct qlcnic_adapter *adapter = vf->adapter;
1248 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1250 cmd->rsp.arg[0] |= (0x6 << 25);
1254 err = qlcnic_issue_cmd(adapter, cmd);
1258 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1259 struct qlcnic_vf_info *vf,
1260 struct qlcnic_cmd_args *cmd)
1262 struct qlcnic_vport *vp = vf->vp;
1265 if (!(cmd->req.arg[1] & BIT_8))
1268 cmd->req.arg[1] |= (vf->vp->handle << 16);
1269 cmd->req.arg[1] |= BIT_31;
1271 if (vp->vlan_mode == QLC_PVID_MODE) {
1272 op = cmd->req.arg[1] & 0x7;
1273 cmd->req.arg[1] &= ~0x7;
1274 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1275 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1276 cmd->req.arg[3] |= vp->pvid << 16;
1277 cmd->req.arg[1] |= new_op;
1283 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1284 struct qlcnic_cmd_args *cmd)
1286 struct qlcnic_vf_info *vf = trans->vf;
1287 struct qlcnic_adapter *adapter = vf->adapter;
1290 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1292 cmd->rsp.arg[0] |= (0x6 << 25);
1296 err = qlcnic_issue_cmd(adapter, cmd);
1300 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1301 struct qlcnic_cmd_args *cmd)
1303 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1309 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1310 struct qlcnic_cmd_args *cmd)
1312 struct qlcnic_vf_info *vf = trans->vf;
1313 struct qlcnic_adapter *adapter = vf->adapter;
1316 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1318 cmd->rsp.arg[0] |= (0x6 << 25);
1322 err = qlcnic_issue_cmd(adapter, cmd);
1326 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1327 struct qlcnic_cmd_args *cmd)
1329 struct qlcnic_vf_info *vf = trans->vf;
1330 struct qlcnic_adapter *adapter = vf->adapter;
1333 cmd->req.arg[1] |= vf->vp->handle << 16;
1334 cmd->req.arg[1] |= BIT_31;
1335 err = qlcnic_issue_cmd(adapter, cmd);
1339 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1340 struct qlcnic_cmd_args *cmd)
1342 struct qlcnic_vf_info *vf = trans->vf;
1343 struct qlcnic_vport *vp = vf->vp;
1344 u8 cmd_op, mode = vp->vlan_mode;
1345 struct qlcnic_adapter *adapter;
1346 struct qlcnic_sriov *sriov;
1348 adapter = vf->adapter;
1349 sriov = adapter->ahw->sriov;
1351 cmd_op = trans->req_hdr->cmd_op;
1352 cmd->rsp.arg[0] |= 1 << 25;
1354 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1355 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1357 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1361 case QLC_GUEST_VLAN_MODE:
1362 cmd->rsp.arg[1] = mode | 1 << 8;
1363 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16;
1366 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16;
1373 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1374 struct qlcnic_vf_info *vf,
1375 struct qlcnic_cmd_args *cmd)
1377 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1380 if (!qlcnic_sriov_check_any_vlan(vf))
1383 vlan = cmd->req.arg[1] >> 16;
1384 if (!vf->rx_ctx_id) {
1385 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1389 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL);
1390 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1392 if (qlcnic_83xx_pf_check(adapter))
1393 qlcnic_sriov_cfg_vf_def_mac(adapter, vf,
1398 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1399 struct qlcnic_vf_info *vf,
1400 struct qlcnic_cmd_args *cmd)
1402 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1406 if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf))
1409 vlan = cmd->req.arg[1] >> 16;
1411 if (!vf->rx_ctx_id) {
1412 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1416 if (qlcnic_83xx_pf_check(adapter)) {
1417 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1423 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD);
1426 if (qlcnic_83xx_pf_check(adapter))
1427 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1432 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1436 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1437 struct qlcnic_cmd_args *cmd)
1439 struct qlcnic_vf_info *vf = tran->vf;
1440 struct qlcnic_adapter *adapter = vf->adapter;
1441 struct qlcnic_vport *vp = vf->vp;
1445 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1446 cmd->rsp.arg[0] |= 2 << 25;
1450 op = cmd->req.arg[1] & 0xf;
1453 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1455 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd);
1457 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1461 static const int qlcnic_pf_passthru_supp_cmds[] = {
1462 QLCNIC_CMD_GET_STATISTICS,
1463 QLCNIC_CMD_GET_PORT_CONFIG,
1464 QLCNIC_CMD_GET_LINK_STATUS,
1465 QLCNIC_CMD_INIT_NIC_FUNC,
1466 QLCNIC_CMD_STOP_NIC_FUNC,
1469 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1470 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1471 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1472 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1473 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1476 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1477 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1478 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1479 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1480 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1481 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1482 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1483 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1484 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1485 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1486 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1487 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1488 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1489 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1490 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1491 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1494 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1495 struct qlcnic_bc_trans *trans,
1496 struct qlcnic_cmd_args *cmd)
1500 cmd_op = trans->req_hdr->cmd_op;
1502 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1503 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1504 if (cmd_op < size) {
1505 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1510 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1511 for (i = 0; i < size; i++) {
1512 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1513 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1518 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1519 for (i = 0; i < size; i++) {
1520 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1521 qlcnic_issue_cmd(adapter, cmd);
1527 cmd->rsp.arg[0] |= (0x9 << 25);
1530 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1535 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1536 adapter->ahw->pci_func);
1540 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1545 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1546 adapter->ahw->pci_func);
1547 *int_id |= vpid << 16;
1550 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1555 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1556 adapter->ahw->pci_func);
1557 *int_id |= vpid << 16;
1560 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1565 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1566 adapter->ahw->pci_func);
1567 *int_id |= vpid << 16;
1570 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1575 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1576 adapter->ahw->pci_func);
1577 *int_id |= (vpid << 16) | BIT_31;
1580 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1585 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1586 adapter->ahw->pci_func);
1587 *int_id |= (vpid << 16) | BIT_31;
1590 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1595 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1596 adapter->ahw->pci_func);
1597 *int_id |= (vpid << 16) | BIT_31;
1600 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1601 struct qlcnic_vf_info *vf)
1603 struct qlcnic_cmd_args cmd;
1609 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1612 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1614 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1615 if (qlcnic_issue_cmd(adapter, &cmd))
1616 dev_err(&adapter->pdev->dev,
1617 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1623 qlcnic_free_mbx_args(&cmd);
1626 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1627 struct qlcnic_vf_info *vf)
1629 struct qlcnic_cmd_args cmd;
1635 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1638 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1640 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1641 if (qlcnic_issue_cmd(adapter, &cmd))
1642 dev_err(&adapter->pdev->dev,
1643 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1649 qlcnic_free_mbx_args(&cmd);
1652 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1653 struct qlcnic_vf_info *vf,
1654 struct qlcnic_bc_trans *trans)
1656 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1659 spin_lock_irqsave(&t_list->lock, flag);
1661 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1663 spin_unlock_irqrestore(&t_list->lock, flag);
1667 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1669 struct qlcnic_adapter *adapter = vf->adapter;
1671 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1672 cancel_work_sync(&vf->trans_work);
1673 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1675 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1676 qlcnic_sriov_del_tx_ctx(adapter, vf);
1677 qlcnic_sriov_del_rx_ctx(adapter, vf);
1680 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1682 clear_bit(QLC_BC_VF_FLR, &vf->state);
1683 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1684 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1686 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1687 vf->flr_trans = NULL;
1691 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1693 struct qlcnic_vf_info *vf;
1695 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1696 __qlcnic_sriov_process_flr(vf);
1700 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1701 struct qlcnic_vf_info *vf,
1704 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1707 INIT_WORK(&vf->flr_work, func);
1708 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1711 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1712 struct qlcnic_bc_trans *trans,
1713 struct qlcnic_vf_info *vf)
1715 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1717 set_bit(QLC_BC_VF_FLR, &vf->state);
1718 clear_bit(QLC_BC_VF_STATE, &vf->state);
1719 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1720 vf->flr_trans = trans;
1721 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1722 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1726 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1727 struct qlcnic_bc_trans *trans,
1728 struct qlcnic_vf_info *vf)
1730 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1732 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1733 (hdr->op_type == QLC_BC_CMD) &&
1734 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1735 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1742 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1743 struct qlcnic_vf_info *vf)
1745 struct net_device *dev = vf->adapter->netdev;
1746 struct qlcnic_vport *vp = vf->vp;
1748 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1749 clear_bit(QLC_BC_VF_FLR, &vf->state);
1753 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1754 netdev_info(dev, "FLR for PCI func %d in progress\n",
1759 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1760 memset(vf->sriov_vlans, 0,
1761 sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans);
1763 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1764 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1767 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1769 struct qlcnic_hardware_context *ahw = adapter->ahw;
1770 struct qlcnic_sriov *sriov = ahw->sriov;
1771 struct qlcnic_vf_info *vf;
1772 u16 num_vfs = sriov->num_vfs;
1775 for (i = 0; i < num_vfs; i++) {
1776 vf = &sriov->vf_info[i];
1779 cancel_work_sync(&vf->flr_work);
1780 __qlcnic_sriov_process_flr(vf);
1781 clear_bit(QLC_BC_VF_STATE, &vf->state);
1784 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1785 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1788 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1790 struct qlcnic_hardware_context *ahw = adapter->ahw;
1793 if (!qlcnic_sriov_enable_check(adapter))
1796 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1798 err = qlcnic_sriov_pf_init(adapter);
1802 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1803 __func__, ahw->op_mode);
1807 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1809 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1810 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1812 struct qlcnic_vf_info *vf_info;
1815 if (!qlcnic_sriov_pf_check(adapter))
1818 num_vfs = sriov->num_vfs;
1820 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1823 if (ether_addr_equal(adapter->mac_addr, mac)) {
1824 netdev_err(netdev, "MAC address is already in use by the PF\n");
1828 for (i = 0; i < num_vfs; i++) {
1829 vf_info = &sriov->vf_info[i];
1830 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1832 "MAC address is already in use by VF %d\n",
1838 vf_info = &sriov->vf_info[vf];
1839 curr_mac = vf_info->vp->mac;
1841 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1843 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1848 memcpy(curr_mac, mac, netdev->addr_len);
1849 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1854 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf,
1855 int min_tx_rate, int max_tx_rate)
1857 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1858 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1859 struct qlcnic_vf_info *vf_info;
1860 struct qlcnic_info nic_info;
1861 struct qlcnic_vport *vp;
1864 if (!qlcnic_sriov_pf_check(adapter))
1867 if (vf >= sriov->num_vfs)
1870 vf_info = &sriov->vf_info[vf];
1875 min_tx_rate = QLC_VF_MIN_TX_RATE;
1878 (max_tx_rate >= 10000 || max_tx_rate < min_tx_rate)) {
1880 "Invalid max Tx rate, allowed range is [%d - %d]",
1881 min_tx_rate, QLC_VF_MAX_TX_RATE);
1886 max_tx_rate = 10000;
1889 (min_tx_rate > max_tx_rate || min_tx_rate < QLC_VF_MIN_TX_RATE)) {
1891 "Invalid min Tx rate, allowed range is [%d - %d]",
1892 QLC_VF_MIN_TX_RATE, max_tx_rate);
1896 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1897 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1900 nic_info.max_tx_bw = max_tx_rate / 100;
1901 nic_info.min_tx_bw = min_tx_rate / 100;
1902 nic_info.bit_offsets = BIT_0;
1904 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1908 vp->max_tx_bw = max_tx_rate / 100;
1910 "Setting Max Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1911 max_tx_rate, vp->max_tx_bw, vf);
1912 vp->min_tx_bw = min_tx_rate / 100;
1914 "Setting Min Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1915 min_tx_rate, vp->min_tx_bw, vf);
1919 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1920 u16 vlan, u8 qos, __be16 vlan_proto)
1922 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1923 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1924 struct qlcnic_vf_info *vf_info;
1925 struct qlcnic_vport *vp;
1927 if (!qlcnic_sriov_pf_check(adapter))
1930 if (vf >= sriov->num_vfs || qos > 7)
1933 if (vlan_proto != htons(ETH_P_8021Q))
1934 return -EPROTONOSUPPORT;
1936 if (vlan > MAX_VLAN_ID) {
1938 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1943 vf_info = &sriov->vf_info[vf];
1945 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1947 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1952 memset(vf_info->sriov_vlans, 0,
1953 sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans);
1957 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1960 vp->vlan_mode = QLC_NO_VLAN_MODE;
1964 vp->vlan_mode = QLC_PVID_MODE;
1965 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan);
1970 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1975 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1976 struct qlcnic_vport *vp, int vf)
1980 switch (vp->vlan_mode) {
1984 case QLC_GUEST_VLAN_MODE:
1987 case QLC_NO_VLAN_MODE:
1991 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1998 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1999 int vf, struct ifla_vf_info *ivi)
2001 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2002 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
2003 struct qlcnic_vport *vp;
2005 if (!qlcnic_sriov_pf_check(adapter))
2008 if (vf >= sriov->num_vfs)
2011 vp = sriov->vf_info[vf].vp;
2012 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
2013 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
2015 ivi->spoofchk = vp->spoofchk;
2016 if (vp->max_tx_bw == MAX_BW)
2017 ivi->max_tx_rate = 0;
2019 ivi->max_tx_rate = vp->max_tx_bw * 100;
2020 if (vp->min_tx_bw == MIN_BW)
2021 ivi->min_tx_rate = 0;
2023 ivi->min_tx_rate = vp->min_tx_bw * 100;
2029 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
2031 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2032 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
2033 struct qlcnic_vf_info *vf_info;
2034 struct qlcnic_vport *vp;
2036 if (!qlcnic_sriov_pf_check(adapter))
2039 if (vf >= sriov->num_vfs)
2042 vf_info = &sriov->vf_info[vf];
2044 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
2046 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",