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_MAC_STAR_ADD 6
17 #define QLC_MAC_STAR_DEL 7
18 #define QLC_VF_FLOOD_BIT BIT_16
19 #define QLC_FLOOD_MODE 0x5
21 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
23 struct qlcnic_sriov_cmd_handler {
24 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
27 struct qlcnic_sriov_fw_cmd_handler {
29 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
32 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
33 struct qlcnic_info *npar_info,
36 struct qlcnic_cmd_args cmd;
39 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
42 cmd.req.arg[1] = (vport_id << 16) | 0x1;
43 cmd.req.arg[2] = npar_info->bit_offsets;
44 cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
45 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
46 cmd.req.arg[4] = npar_info->max_tx_mac_filters;
47 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
48 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
49 (npar_info->max_rx_ip_addr << 16);
50 cmd.req.arg[6] = npar_info->max_rx_lro_flow |
51 (npar_info->max_rx_status_rings << 16);
52 cmd.req.arg[7] = npar_info->max_rx_buf_rings |
53 (npar_info->max_rx_ques << 16);
54 cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
55 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
56 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
58 err = qlcnic_issue_cmd(adapter, &cmd);
60 dev_err(&adapter->pdev->dev,
61 "Failed to set vport info, err=%d\n", err);
63 qlcnic_free_mbx_args(&cmd);
67 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
68 struct qlcnic_info *info, u16 func)
70 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
71 struct qlcnic_resources *res = &sriov->ff_max;
72 u16 num_macs = sriov->num_allowed_vlans + 1;
73 int ret = -EIO, vpid, id;
74 struct qlcnic_vport *vp;
75 u32 num_vfs, max, temp;
77 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
81 num_vfs = sriov->num_vfs;
83 info->bit_offsets = 0xffff;
84 info->max_tx_ques = res->num_tx_queues / max;
86 if (qlcnic_83xx_pf_check(adapter))
89 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
91 if (adapter->ahw->pci_func == func) {
93 info->max_tx_bw = MAX_BW;
95 temp = res->num_rx_ucast_mac_filters - num_macs * num_vfs;
96 info->max_rx_ucast_mac_filters = temp;
97 temp = res->num_tx_mac_filters - num_macs * num_vfs;
98 info->max_tx_mac_filters = temp;
99 temp = num_macs * num_vfs * QLCNIC_SRIOV_VF_MAX_MAC;
100 temp = res->num_rx_mcast_mac_filters - temp;
101 info->max_rx_mcast_mac_filters = temp;
103 info->max_tx_ques = res->num_tx_queues - sriov->num_vfs;
105 id = qlcnic_sriov_func_to_index(adapter, func);
108 vp = sriov->vf_info[id].vp;
109 info->min_tx_bw = vp->min_tx_bw;
110 info->max_tx_bw = vp->max_tx_bw;
112 info->max_rx_ucast_mac_filters = num_macs;
113 info->max_tx_mac_filters = num_macs;
114 temp = num_macs * QLCNIC_SRIOV_VF_MAX_MAC;
115 info->max_rx_mcast_mac_filters = temp;
117 info->max_tx_ques = QLCNIC_SINGLE_RING;
120 info->max_rx_ip_addr = res->num_destip / max;
121 info->max_rx_status_rings = res->num_rx_status_rings / max;
122 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
123 info->max_rx_ques = res->num_rx_queues / max;
124 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
125 info->max_tx_vlan_keys = res->num_txvlan_keys;
126 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
127 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
129 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
136 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
137 struct qlcnic_info *info)
139 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
141 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
142 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
143 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
144 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
145 ff_max->num_rx_queues = info->max_rx_ques;
146 ff_max->num_tx_queues = info->max_tx_ques;
147 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
148 ff_max->num_destip = info->max_rx_ip_addr;
149 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
150 ff_max->num_rx_status_rings = info->max_rx_status_rings;
151 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
152 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
155 static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter *adapter,
156 struct qlcnic_info *npar_info)
158 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
161 temp = npar_info->max_rx_mcast_mac_filters;
162 total_fn = sriov->num_vfs + 1;
164 temp = temp / (QLCNIC_SRIOV_VF_MAX_MAC * total_fn);
165 sriov->num_allowed_vlans = temp - 1;
167 if (qlcnic_83xx_pf_check(adapter))
168 sriov->num_allowed_vlans = 1;
170 netdev_info(adapter->netdev, "Max Guest VLANs supported per VF = %d\n",
171 sriov->num_allowed_vlans);
174 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
175 struct qlcnic_info *npar_info)
178 struct qlcnic_cmd_args cmd;
180 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
183 cmd.req.arg[1] = 0x2;
184 err = qlcnic_issue_cmd(adapter, &cmd);
186 dev_err(&adapter->pdev->dev,
187 "Failed to get PF info, err=%d\n", err);
191 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
192 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
193 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
194 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
195 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
196 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
197 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
198 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
199 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
200 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
201 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
202 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
203 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
204 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
205 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
207 qlcnic_sriov_set_vf_max_vlan(adapter, npar_info);
208 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
209 dev_info(&adapter->pdev->dev,
210 "\n\ttotal_pf: %d,\n"
211 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
212 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
213 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
214 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
215 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
216 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
217 npar_info->total_pf, npar_info->total_rss_engines,
218 npar_info->max_vports, npar_info->max_tx_ques,
219 npar_info->max_tx_mac_filters,
220 npar_info->max_rx_mcast_mac_filters,
221 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
222 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
223 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
224 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
225 npar_info->max_remote_ipv6_addrs);
228 qlcnic_free_mbx_args(&cmd);
232 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
235 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
236 struct qlcnic_vport *vp;
239 if (adapter->ahw->pci_func == func) {
240 sriov->vp_handle = 0;
242 index = qlcnic_sriov_func_to_index(adapter, func);
245 vp = sriov->vf_info[index].vp;
250 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
251 u16 vport_handle, u8 func)
253 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
254 struct qlcnic_vport *vp;
257 if (adapter->ahw->pci_func == func) {
258 sriov->vp_handle = vport_handle;
260 index = qlcnic_sriov_func_to_index(adapter, func);
263 vp = sriov->vf_info[index].vp;
264 vp->handle = vport_handle;
268 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
271 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
272 struct qlcnic_vf_info *vf_info;
275 if (adapter->ahw->pci_func == func) {
276 return sriov->vp_handle;
278 index = qlcnic_sriov_func_to_index(adapter, func);
280 vf_info = &sriov->vf_info[index];
281 return vf_info->vp->handle;
288 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
291 struct qlcnic_cmd_args cmd;
295 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
299 cmd.req.arg[3] = func << 8;
301 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
306 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
309 ret = qlcnic_issue_cmd(adapter, &cmd);
311 dev_err(&adapter->pdev->dev,
312 "Failed %s vport, err %d for func 0x%x\n",
313 (flag ? "enable" : "disable"), ret, func);
318 vpid = cmd.rsp.arg[2] & 0xffff;
319 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
321 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
325 qlcnic_free_mbx_args(&cmd);
329 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
332 struct qlcnic_cmd_args cmd;
335 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
339 cmd.req.arg[1] = 0x4;
341 cmd.req.arg[1] |= BIT_16;
343 err = qlcnic_issue_cmd(adapter, &cmd);
345 dev_err(&adapter->pdev->dev,
346 "Failed to configure VLAN filtering, err=%d\n", err);
348 qlcnic_free_mbx_args(&cmd);
352 /* On configuring VF flood bit, PFD will receive traffic from all VFs */
353 static int qlcnic_sriov_pf_cfg_flood(struct qlcnic_adapter *adapter)
355 struct qlcnic_cmd_args cmd;
358 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
362 cmd.req.arg[1] = QLC_FLOOD_MODE | QLC_VF_FLOOD_BIT;
364 err = qlcnic_issue_cmd(adapter, &cmd);
366 dev_err(&adapter->pdev->dev,
367 "Failed to configure VF Flood bit on PF, err=%d\n",
370 qlcnic_free_mbx_args(&cmd);
374 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
377 struct qlcnic_cmd_args cmd;
380 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
383 cmd.req.arg[0] |= (3 << 29);
384 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
386 cmd.req.arg[1] |= BIT_0;
388 err = qlcnic_issue_cmd(adapter, &cmd);
390 if (err != QLCNIC_RCODE_SUCCESS) {
391 dev_err(&adapter->pdev->dev,
392 "Failed to enable sriov eswitch%d\n", err);
396 qlcnic_free_mbx_args(&cmd);
400 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
402 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
403 struct qlcnic_back_channel *bc = &sriov->bc;
406 for (i = 0; i < sriov->num_vfs; i++)
407 cancel_work_sync(&sriov->vf_info[i].flr_work);
409 destroy_workqueue(bc->bc_flr_wq);
412 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
414 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
415 struct workqueue_struct *wq;
417 wq = create_singlethread_workqueue("qlcnic-flr");
419 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
427 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
429 u8 func = adapter->ahw->pci_func;
431 if (!qlcnic_sriov_enable_check(adapter))
434 qlcnic_sriov_pf_del_flr_queue(adapter);
435 qlcnic_sriov_cfg_bc_intr(adapter, 0);
436 qlcnic_sriov_pf_config_vport(adapter, 0, func);
437 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
438 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
439 __qlcnic_sriov_cleanup(adapter);
440 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
441 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
444 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
446 if (!qlcnic_sriov_pf_check(adapter))
449 if (!qlcnic_sriov_enable_check(adapter))
452 pci_disable_sriov(adapter->pdev);
453 netdev_info(adapter->netdev,
454 "SR-IOV is disabled successfully on port %d\n",
458 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
460 struct net_device *netdev = adapter->netdev;
463 if (netif_running(netdev))
464 __qlcnic_down(adapter, netdev);
466 qlcnic_sriov_pf_disable(adapter);
468 qlcnic_sriov_free_vlans(adapter);
470 qlcnic_sriov_pf_cleanup(adapter);
472 /* After disabling SRIOV re-init the driver in default mode
473 configure opmode based on op_mode of function
475 if (qlcnic_83xx_configure_opmode(adapter)) {
480 if (netif_running(netdev))
481 __qlcnic_up(adapter, netdev);
487 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
489 struct qlcnic_hardware_context *ahw = adapter->ahw;
490 struct qlcnic_info nic_info, pf_info, vp_info;
492 u8 func = ahw->pci_func;
494 if (!qlcnic_sriov_enable_check(adapter))
497 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
501 if (qlcnic_84xx_check(adapter)) {
502 err = qlcnic_sriov_pf_cfg_flood(adapter);
504 goto disable_vlan_filtering;
507 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
509 goto disable_vlan_filtering;
511 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
513 goto disable_eswitch;
515 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
519 err = qlcnic_get_nic_info(adapter, &nic_info, func);
523 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
527 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
531 ahw->physical_port = (u8) nic_info.phys_port;
532 ahw->switch_mode = nic_info.switch_mode;
533 ahw->max_mtu = nic_info.max_mtu;
534 ahw->capabilities = nic_info.capabilities;
535 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
539 qlcnic_sriov_pf_config_vport(adapter, 0, func);
542 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
544 disable_vlan_filtering:
545 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
550 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
554 if (!qlcnic_sriov_enable_check(adapter))
557 err = pci_enable_sriov(adapter->pdev, num_vfs);
559 qlcnic_sriov_pf_cleanup(adapter);
564 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
569 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
570 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
572 err = qlcnic_sriov_init(adapter, num_vfs);
576 err = qlcnic_sriov_pf_create_flr_queue(adapter);
580 err = qlcnic_sriov_pf_init(adapter);
584 qlcnic_sriov_alloc_vlans(adapter);
586 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
590 qlcnic_sriov_pf_del_flr_queue(adapter);
593 __qlcnic_sriov_cleanup(adapter);
596 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
597 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
601 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
603 struct net_device *netdev = adapter->netdev;
606 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
608 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
613 if (netif_running(netdev))
614 __qlcnic_down(adapter, netdev);
616 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
618 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
622 if (qlcnic_83xx_configure_opmode(adapter))
626 "SR-IOV is enabled successfully on port %d\n",
628 /* Return number of vfs enabled */
631 if (netif_running(netdev))
632 __qlcnic_up(adapter, netdev);
639 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
641 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
644 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
648 err = qlcnic_pci_sriov_disable(adapter);
650 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
652 clear_bit(__QLCNIC_RESETTING, &adapter->state);
656 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
658 struct qlcnic_cmd_args cmd;
659 struct qlcnic_vport *vp;
663 id = qlcnic_sriov_func_to_index(adapter, func);
667 vp = adapter->ahw->sriov->vf_info[id].vp;
668 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
672 cmd.req.arg[1] = 0x3 | func << 16;
673 if (vp->spoofchk == true) {
675 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
676 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
678 cmd.req.arg[5] = mac[1] | mac[0] << 8;
681 if (vp->vlan_mode == QLC_PVID_MODE) {
682 cmd.req.arg[2] |= BIT_6;
683 cmd.req.arg[3] |= vp->pvid << 8;
686 err = qlcnic_issue_cmd(adapter, &cmd);
688 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
691 qlcnic_free_mbx_args(&cmd);
695 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
698 struct qlcnic_info defvp_info;
701 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
705 err = qlcnic_sriov_set_vf_acl(adapter, func);
712 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
713 struct qlcnic_cmd_args *cmd)
715 struct qlcnic_vf_info *vf = trans->vf;
716 struct qlcnic_vport *vp = vf->vp;
717 struct qlcnic_adapter *adapter;
718 struct qlcnic_sriov *sriov;
719 u16 func = vf->pci_func;
723 adapter = vf->adapter;
724 sriov = adapter->ahw->sriov;
726 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
727 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
729 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
731 qlcnic_sriov_pf_config_vport(adapter, 0, func);
734 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {
735 size = sizeof(*vf->sriov_vlans);
736 size = size * sriov->num_allowed_vlans;
737 memset(vf->sriov_vlans, 0, size);
740 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
746 cmd->rsp.arg[0] |= (1 << 25);
748 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
749 set_bit(QLC_BC_VF_STATE, &vf->state);
751 clear_bit(QLC_BC_VF_STATE, &vf->state);
756 cmd->rsp.arg[0] |= (2 << 25);
760 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
761 struct qlcnic_vf_info *vf,
764 struct qlcnic_cmd_args cmd;
765 struct qlcnic_macvlan_mbx mv;
766 struct qlcnic_vport *vp;
774 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
777 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
784 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
785 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
787 cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
788 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
792 mv.mac_addr0 = addr[0];
793 mv.mac_addr1 = addr[1];
794 mv.mac_addr2 = addr[2];
795 mv.mac_addr3 = addr[3];
796 mv.mac_addr4 = addr[4];
797 mv.mac_addr5 = addr[5];
798 buf = &cmd.req.arg[2];
799 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
801 err = qlcnic_issue_cmd(adapter, &cmd);
804 dev_err(&adapter->pdev->dev,
805 "MAC-VLAN %s to CAM failed, err=%d.\n",
806 ((op == 1) ? "add " : "delete "), err);
809 qlcnic_free_mbx_args(&cmd);
813 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
815 if ((cmd->req.arg[0] >> 29) != 0x3)
821 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,
822 struct qlcnic_vf_info *vf,
825 struct qlcnic_sriov *sriov;
829 sriov = adapter->ahw->sriov;
831 mutex_lock(&vf->vlan_list_lock);
833 for (i = 0; i < sriov->num_allowed_vlans; i++) {
834 vlan = vf->sriov_vlans[i];
836 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,
840 mutex_unlock(&vf->vlan_list_lock);
842 if (vf->vp->vlan_mode != QLC_PVID_MODE) {
843 if (qlcnic_83xx_pf_check(adapter) &&
844 qlcnic_sriov_check_any_vlan(vf))
846 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);
850 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
851 struct qlcnic_cmd_args *cmd)
853 struct qlcnic_vf_info *vf = tran->vf;
854 struct qlcnic_adapter *adapter = vf->adapter;
855 struct qlcnic_rcv_mbx_out *mbx_out;
858 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
860 cmd->rsp.arg[0] |= (0x6 << 25);
864 cmd->req.arg[6] = vf->vp->handle;
865 err = qlcnic_issue_cmd(adapter, cmd);
868 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
869 vf->rx_ctx_id = mbx_out->ctx_id;
870 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);
878 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
879 struct qlcnic_cmd_args *cmd)
881 struct qlcnic_vf_info *vf = trans->vf;
884 type = cmd->req.arg[1];
886 case QLCNIC_SET_STATION_MAC:
887 case QLCNIC_SET_FAC_DEF_MAC:
888 cmd->rsp.arg[0] = (2 << 25);
890 case QLCNIC_GET_CURRENT_MAC:
891 cmd->rsp.arg[0] = (1 << 25);
893 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
894 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
895 ((mac[3]) << 16 & 0xff0000) |
896 ((mac[2]) << 24 & 0xff000000);
902 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
904 if ((cmd->req.arg[0] >> 29) != 0x3)
910 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
911 struct qlcnic_cmd_args *cmd)
913 struct qlcnic_vf_info *vf = trans->vf;
914 struct qlcnic_adapter *adapter = vf->adapter;
915 struct qlcnic_tx_mbx_out *mbx_out;
918 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
920 cmd->rsp.arg[0] |= (0x6 << 25);
924 cmd->req.arg[5] |= vf->vp->handle << 16;
925 err = qlcnic_issue_cmd(adapter, cmd);
927 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
928 vf->tx_ctx_id = mbx_out->ctx_id;
936 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
937 struct qlcnic_cmd_args *cmd)
939 if ((cmd->req.arg[0] >> 29) != 0x3)
942 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
948 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
949 struct qlcnic_cmd_args *cmd)
951 struct qlcnic_vf_info *vf = trans->vf;
952 struct qlcnic_adapter *adapter = vf->adapter;
955 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
957 cmd->rsp.arg[0] |= (0x6 << 25);
961 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);
962 cmd->req.arg[1] |= vf->vp->handle << 16;
963 err = qlcnic_issue_cmd(adapter, cmd);
971 static int qlcnic_sriov_validate_del_tx_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->tx_ctx_id)
983 static int qlcnic_sriov_pf_del_tx_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_tx_ctx(vf, cmd);
992 cmd->rsp.arg[0] |= (0x6 << 25);
996 cmd->req.arg[1] |= vf->vp->handle << 16;
997 err = qlcnic_issue_cmd(adapter, cmd);
1005 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
1006 struct qlcnic_cmd_args *cmd)
1008 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1014 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
1015 struct qlcnic_cmd_args *cmd)
1017 struct qlcnic_vf_info *vf = trans->vf;
1018 struct qlcnic_adapter *adapter = vf->adapter;
1021 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
1023 cmd->rsp.arg[0] |= (0x6 << 25);
1027 err = qlcnic_issue_cmd(adapter, cmd);
1031 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
1032 struct qlcnic_cmd_args *cmd)
1034 struct qlcnic_vf_info *vf = trans->vf;
1035 struct qlcnic_adapter *adapter = vf->adapter;
1039 op = cmd->req.arg[1] & 0xff;
1041 cmd->req.arg[1] |= vf->vp->handle << 16;
1042 cmd->req.arg[1] |= BIT_31;
1044 err = qlcnic_issue_cmd(adapter, cmd);
1048 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
1049 struct qlcnic_cmd_args *cmd)
1051 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
1054 if (!(cmd->req.arg[1] & BIT_16))
1057 if ((cmd->req.arg[1] & 0xff) != 0x1)
1063 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
1064 struct qlcnic_cmd_args *cmd)
1066 struct qlcnic_vf_info *vf = trans->vf;
1067 struct qlcnic_adapter *adapter = vf->adapter;
1070 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
1072 cmd->rsp.arg[0] |= (0x6 << 25);
1074 err = qlcnic_issue_cmd(adapter, cmd);
1079 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
1080 struct qlcnic_vf_info *vf,
1081 struct qlcnic_cmd_args *cmd)
1083 if (cmd->req.arg[1] != vf->rx_ctx_id)
1086 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
1092 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
1093 struct qlcnic_cmd_args *cmd)
1095 struct qlcnic_vf_info *vf = trans->vf;
1096 struct qlcnic_adapter *adapter = vf->adapter;
1099 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
1101 cmd->rsp.arg[0] |= (0x6 << 25);
1103 err = qlcnic_issue_cmd(adapter, cmd);
1108 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1109 struct qlcnic_cmd_args *cmd)
1111 if (cmd->req.arg[1] & BIT_31) {
1112 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1115 cmd->req.arg[1] |= vf->vp->handle << 16;
1121 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1122 struct qlcnic_cmd_args *cmd)
1124 struct qlcnic_vf_info *vf = trans->vf;
1125 struct qlcnic_adapter *adapter = vf->adapter;
1128 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1130 cmd->rsp.arg[0] |= (0x6 << 25);
1134 err = qlcnic_issue_cmd(adapter, cmd);
1138 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1139 struct qlcnic_cmd_args *cmd)
1141 if (cmd->req.arg[1] != vf->rx_ctx_id)
1147 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1148 struct qlcnic_cmd_args *cmd)
1150 struct qlcnic_vf_info *vf = trans->vf;
1151 struct qlcnic_adapter *adapter = vf->adapter;
1154 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1156 cmd->rsp.arg[0] |= (0x6 << 25);
1158 err = qlcnic_issue_cmd(adapter, cmd);
1163 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1164 struct qlcnic_vf_info *vf,
1165 struct qlcnic_cmd_args *cmd)
1167 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1168 u16 ctx_id, pkts, time;
1170 ctx_id = cmd->req.arg[1] >> 16;
1171 pkts = cmd->req.arg[2] & 0xffff;
1172 time = cmd->req.arg[2] >> 16;
1174 if (ctx_id != vf->rx_ctx_id)
1176 if (pkts > coal->rx_packets)
1178 if (time < coal->rx_time_us)
1184 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1185 struct qlcnic_cmd_args *cmd)
1187 struct qlcnic_vf_info *vf = tran->vf;
1188 struct qlcnic_adapter *adapter = vf->adapter;
1191 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1193 cmd->rsp.arg[0] |= (0x6 << 25);
1197 err = qlcnic_issue_cmd(adapter, cmd);
1201 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1202 struct qlcnic_vf_info *vf,
1203 struct qlcnic_cmd_args *cmd)
1205 struct qlcnic_macvlan_mbx *macvlan;
1206 struct qlcnic_vport *vp = vf->vp;
1209 if (((cmd->req.arg[1] & QLC_MAC_OPCODE_MASK) == QLC_MAC_STAR_ADD) ||
1210 ((cmd->req.arg[1] & QLC_MAC_OPCODE_MASK) == QLC_MAC_STAR_DEL)) {
1211 netdev_err(adapter->netdev, "MAC + any VLAN filter not allowed from VF %d\n",
1216 if (!(cmd->req.arg[1] & BIT_8))
1219 cmd->req.arg[1] |= (vf->vp->handle << 16);
1220 cmd->req.arg[1] |= BIT_31;
1222 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1223 if (!(macvlan->mac_addr0 & BIT_0)) {
1224 dev_err(&adapter->pdev->dev,
1225 "MAC address change is not allowed from VF %d",
1230 if (vp->vlan_mode == QLC_PVID_MODE) {
1231 op = cmd->req.arg[1] & 0x7;
1232 cmd->req.arg[1] &= ~0x7;
1233 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1234 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1235 cmd->req.arg[3] |= vp->pvid << 16;
1236 cmd->req.arg[1] |= new_op;
1242 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1243 struct qlcnic_cmd_args *cmd)
1245 struct qlcnic_vf_info *vf = trans->vf;
1246 struct qlcnic_adapter *adapter = vf->adapter;
1249 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1251 cmd->rsp.arg[0] |= (0x6 << 25);
1255 err = qlcnic_issue_cmd(adapter, cmd);
1259 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1260 struct qlcnic_cmd_args *cmd)
1262 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1268 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1269 struct qlcnic_cmd_args *cmd)
1271 struct qlcnic_vf_info *vf = trans->vf;
1272 struct qlcnic_adapter *adapter = vf->adapter;
1275 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1277 cmd->rsp.arg[0] |= (0x6 << 25);
1281 err = qlcnic_issue_cmd(adapter, cmd);
1285 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1286 struct qlcnic_cmd_args *cmd)
1288 struct qlcnic_vf_info *vf = trans->vf;
1289 struct qlcnic_adapter *adapter = vf->adapter;
1292 cmd->req.arg[1] |= vf->vp->handle << 16;
1293 cmd->req.arg[1] |= BIT_31;
1294 err = qlcnic_issue_cmd(adapter, cmd);
1298 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1299 struct qlcnic_cmd_args *cmd)
1301 struct qlcnic_vf_info *vf = trans->vf;
1302 struct qlcnic_vport *vp = vf->vp;
1303 u8 cmd_op, mode = vp->vlan_mode;
1304 struct qlcnic_adapter *adapter;
1305 struct qlcnic_sriov *sriov;
1307 adapter = vf->adapter;
1308 sriov = adapter->ahw->sriov;
1310 cmd_op = trans->req_hdr->cmd_op;
1311 cmd->rsp.arg[0] |= 1 << 25;
1313 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1314 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1316 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1320 case QLC_GUEST_VLAN_MODE:
1321 cmd->rsp.arg[1] = mode | 1 << 8;
1322 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16;
1325 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16;
1332 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1333 struct qlcnic_vf_info *vf,
1334 struct qlcnic_cmd_args *cmd)
1336 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1339 if (!qlcnic_sriov_check_any_vlan(vf))
1342 vlan = cmd->req.arg[1] >> 16;
1343 if (!vf->rx_ctx_id) {
1344 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1348 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL);
1349 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1351 if (qlcnic_83xx_pf_check(adapter))
1352 qlcnic_sriov_cfg_vf_def_mac(adapter, vf,
1357 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1358 struct qlcnic_vf_info *vf,
1359 struct qlcnic_cmd_args *cmd)
1361 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1365 if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf))
1368 vlan = cmd->req.arg[1] >> 16;
1370 if (!vf->rx_ctx_id) {
1371 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1375 if (qlcnic_83xx_pf_check(adapter)) {
1376 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1382 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD);
1385 if (qlcnic_83xx_pf_check(adapter))
1386 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1391 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1395 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1396 struct qlcnic_cmd_args *cmd)
1398 struct qlcnic_vf_info *vf = tran->vf;
1399 struct qlcnic_adapter *adapter = vf->adapter;
1400 struct qlcnic_vport *vp = vf->vp;
1404 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1405 cmd->rsp.arg[0] |= 2 << 25;
1409 op = cmd->req.arg[1] & 0xf;
1412 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1414 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd);
1416 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1420 static const int qlcnic_pf_passthru_supp_cmds[] = {
1421 QLCNIC_CMD_GET_STATISTICS,
1422 QLCNIC_CMD_GET_PORT_CONFIG,
1423 QLCNIC_CMD_GET_LINK_STATUS,
1424 QLCNIC_CMD_INIT_NIC_FUNC,
1425 QLCNIC_CMD_STOP_NIC_FUNC,
1428 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1429 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1430 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1431 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1432 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1435 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1436 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1437 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1438 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1439 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1440 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1441 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1442 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1443 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1444 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1445 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1446 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1447 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1448 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1449 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1450 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1453 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1454 struct qlcnic_bc_trans *trans,
1455 struct qlcnic_cmd_args *cmd)
1459 cmd_op = trans->req_hdr->cmd_op;
1461 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1462 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1463 if (cmd_op < size) {
1464 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1469 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1470 for (i = 0; i < size; i++) {
1471 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1472 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1477 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1478 for (i = 0; i < size; i++) {
1479 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1480 qlcnic_issue_cmd(adapter, cmd);
1486 cmd->rsp.arg[0] |= (0x9 << 25);
1489 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1494 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1495 adapter->ahw->pci_func);
1499 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1504 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1505 adapter->ahw->pci_func);
1506 *int_id |= vpid << 16;
1509 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1514 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1515 adapter->ahw->pci_func);
1516 *int_id |= vpid << 16;
1519 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1524 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1525 adapter->ahw->pci_func);
1526 *int_id |= vpid << 16;
1529 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1534 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1535 adapter->ahw->pci_func);
1536 *int_id |= (vpid << 16) | BIT_31;
1539 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1544 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1545 adapter->ahw->pci_func);
1546 *int_id |= (vpid << 16) | BIT_31;
1549 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1554 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1555 adapter->ahw->pci_func);
1556 *int_id |= (vpid << 16) | BIT_31;
1559 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1560 struct qlcnic_vf_info *vf)
1562 struct qlcnic_cmd_args cmd;
1568 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1571 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1573 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1574 if (qlcnic_issue_cmd(adapter, &cmd))
1575 dev_err(&adapter->pdev->dev,
1576 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1582 qlcnic_free_mbx_args(&cmd);
1585 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1586 struct qlcnic_vf_info *vf)
1588 struct qlcnic_cmd_args cmd;
1594 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1597 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1599 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1600 if (qlcnic_issue_cmd(adapter, &cmd))
1601 dev_err(&adapter->pdev->dev,
1602 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1608 qlcnic_free_mbx_args(&cmd);
1611 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1612 struct qlcnic_vf_info *vf,
1613 struct qlcnic_bc_trans *trans)
1615 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1618 spin_lock_irqsave(&t_list->lock, flag);
1620 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1622 spin_unlock_irqrestore(&t_list->lock, flag);
1626 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1628 struct qlcnic_adapter *adapter = vf->adapter;
1630 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1631 cancel_work_sync(&vf->trans_work);
1632 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1634 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1635 qlcnic_sriov_del_tx_ctx(adapter, vf);
1636 qlcnic_sriov_del_rx_ctx(adapter, vf);
1639 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1641 clear_bit(QLC_BC_VF_FLR, &vf->state);
1642 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1643 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1645 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1646 vf->flr_trans = NULL;
1650 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1652 struct qlcnic_vf_info *vf;
1654 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1655 __qlcnic_sriov_process_flr(vf);
1659 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1660 struct qlcnic_vf_info *vf,
1663 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1666 INIT_WORK(&vf->flr_work, func);
1667 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1670 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1671 struct qlcnic_bc_trans *trans,
1672 struct qlcnic_vf_info *vf)
1674 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1676 set_bit(QLC_BC_VF_FLR, &vf->state);
1677 clear_bit(QLC_BC_VF_STATE, &vf->state);
1678 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1679 vf->flr_trans = trans;
1680 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1681 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1685 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1686 struct qlcnic_bc_trans *trans,
1687 struct qlcnic_vf_info *vf)
1689 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1691 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1692 (hdr->op_type == QLC_BC_CMD) &&
1693 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1694 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1701 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1702 struct qlcnic_vf_info *vf)
1704 struct net_device *dev = vf->adapter->netdev;
1705 struct qlcnic_vport *vp = vf->vp;
1707 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1708 clear_bit(QLC_BC_VF_FLR, &vf->state);
1712 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1713 netdev_info(dev, "FLR for PCI func %d in progress\n",
1718 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1719 memset(vf->sriov_vlans, 0,
1720 sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans);
1722 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1723 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1726 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1728 struct qlcnic_hardware_context *ahw = adapter->ahw;
1729 struct qlcnic_sriov *sriov = ahw->sriov;
1730 struct qlcnic_vf_info *vf;
1731 u16 num_vfs = sriov->num_vfs;
1734 for (i = 0; i < num_vfs; i++) {
1735 vf = &sriov->vf_info[i];
1738 cancel_work_sync(&vf->flr_work);
1739 __qlcnic_sriov_process_flr(vf);
1740 clear_bit(QLC_BC_VF_STATE, &vf->state);
1743 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1744 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1747 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1749 struct qlcnic_hardware_context *ahw = adapter->ahw;
1752 if (!qlcnic_sriov_enable_check(adapter))
1755 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1757 err = qlcnic_sriov_pf_init(adapter);
1761 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1762 __func__, ahw->op_mode);
1766 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1768 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1769 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1771 struct qlcnic_vf_info *vf_info;
1774 if (!qlcnic_sriov_pf_check(adapter))
1777 num_vfs = sriov->num_vfs;
1779 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1782 if (ether_addr_equal(adapter->mac_addr, mac)) {
1783 netdev_err(netdev, "MAC address is already in use by the PF\n");
1787 for (i = 0; i < num_vfs; i++) {
1788 vf_info = &sriov->vf_info[i];
1789 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1791 "MAC address is already in use by VF %d\n",
1797 vf_info = &sriov->vf_info[vf];
1798 curr_mac = vf_info->vp->mac;
1800 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1802 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1807 memcpy(curr_mac, mac, netdev->addr_len);
1808 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1813 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1815 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1816 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1817 struct qlcnic_vf_info *vf_info;
1818 struct qlcnic_info nic_info;
1819 struct qlcnic_vport *vp;
1822 if (!qlcnic_sriov_pf_check(adapter))
1825 if (vf >= sriov->num_vfs)
1828 if (tx_rate >= 10000 || tx_rate < 100) {
1830 "Invalid Tx rate, allowed range is [%d - %d]",
1831 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1838 vf_info = &sriov->vf_info[vf];
1842 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1843 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1846 nic_info.max_tx_bw = tx_rate / 100;
1847 nic_info.bit_offsets = BIT_0;
1849 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1853 vp->max_tx_bw = tx_rate / 100;
1855 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1856 tx_rate, vp->max_tx_bw, vf);
1860 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1863 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1864 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1865 struct qlcnic_vf_info *vf_info;
1866 struct qlcnic_vport *vp;
1868 if (!qlcnic_sriov_pf_check(adapter))
1871 if (vf >= sriov->num_vfs || qos > 7)
1874 if (vlan > MAX_VLAN_ID) {
1876 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1881 vf_info = &sriov->vf_info[vf];
1883 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1885 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1890 memset(vf_info->sriov_vlans, 0,
1891 sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans);
1895 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1898 vp->vlan_mode = QLC_NO_VLAN_MODE;
1902 vp->vlan_mode = QLC_PVID_MODE;
1903 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan);
1908 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1913 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1914 struct qlcnic_vport *vp, int vf)
1918 switch (vp->vlan_mode) {
1922 case QLC_GUEST_VLAN_MODE:
1925 case QLC_NO_VLAN_MODE:
1929 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1936 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1937 int vf, struct ifla_vf_info *ivi)
1939 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1940 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1941 struct qlcnic_vport *vp;
1943 if (!qlcnic_sriov_pf_check(adapter))
1946 if (vf >= sriov->num_vfs)
1949 vp = sriov->vf_info[vf].vp;
1950 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1951 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1953 ivi->spoofchk = vp->spoofchk;
1954 if (vp->max_tx_bw == MAX_BW)
1957 ivi->tx_rate = vp->max_tx_bw * 100;
1963 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1965 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1966 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1967 struct qlcnic_vf_info *vf_info;
1968 struct qlcnic_vport *vp;
1970 if (!qlcnic_sriov_pf_check(adapter))
1973 if (vf >= sriov->num_vfs)
1976 vf_info = &sriov->vf_info[vf];
1978 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1980 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",