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 8
13 #define QLC_VF_MIN_TX_RATE 100
14 #define QLC_VF_MAX_TX_RATE 9999
16 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
18 struct qlcnic_sriov_cmd_handler {
19 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
22 struct qlcnic_sriov_fw_cmd_handler {
24 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
27 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
28 struct qlcnic_info *npar_info,
31 struct qlcnic_cmd_args cmd;
34 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
37 cmd.req.arg[1] = (vport_id << 16) | 0x1;
38 cmd.req.arg[2] = npar_info->bit_offsets;
39 cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
40 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
41 cmd.req.arg[4] = npar_info->max_tx_mac_filters;
42 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
43 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
44 (npar_info->max_rx_ip_addr << 16);
45 cmd.req.arg[6] = npar_info->max_rx_lro_flow |
46 (npar_info->max_rx_status_rings << 16);
47 cmd.req.arg[7] = npar_info->max_rx_buf_rings |
48 (npar_info->max_rx_ques << 16);
49 cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
50 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
51 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
53 err = qlcnic_issue_cmd(adapter, &cmd);
55 dev_err(&adapter->pdev->dev,
56 "Failed to set vport info, err=%d\n", err);
58 qlcnic_free_mbx_args(&cmd);
62 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
63 struct qlcnic_info *info, u16 func)
65 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
66 struct qlcnic_resources *res = &sriov->ff_max;
67 u16 num_macs = sriov->num_allowed_vlans + 1;
68 int ret = -EIO, vpid, id;
69 struct qlcnic_vport *vp;
70 u32 num_vfs, max, temp;
72 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
76 num_vfs = sriov->num_vfs;
78 info->bit_offsets = 0xffff;
79 info->max_tx_ques = res->num_tx_queues / max;
81 if (qlcnic_83xx_pf_check(adapter))
84 if (adapter->ahw->pci_func == func) {
86 info->max_tx_bw = MAX_BW;
87 temp = res->num_rx_ucast_mac_filters - num_macs * num_vfs;
88 info->max_rx_ucast_mac_filters = temp;
89 temp = res->num_tx_mac_filters - num_macs * num_vfs;
90 info->max_tx_mac_filters = temp;
91 temp = num_macs * num_vfs * QLCNIC_SRIOV_VF_MAX_MAC;
92 temp = res->num_rx_mcast_mac_filters - temp;
93 info->max_rx_mcast_mac_filters = temp;
96 id = qlcnic_sriov_func_to_index(adapter, func);
99 vp = sriov->vf_info[id].vp;
100 info->min_tx_bw = vp->min_tx_bw;
101 info->max_tx_bw = vp->max_tx_bw;
102 info->max_rx_ucast_mac_filters = num_macs;
103 info->max_tx_mac_filters = num_macs;
104 temp = num_macs * QLCNIC_SRIOV_VF_MAX_MAC;
105 info->max_rx_mcast_mac_filters = temp;
108 info->max_rx_ip_addr = res->num_destip / max;
109 info->max_rx_status_rings = res->num_rx_status_rings / max;
110 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
111 info->max_rx_ques = res->num_rx_queues / max;
112 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
113 info->max_tx_vlan_keys = res->num_txvlan_keys;
114 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
115 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
117 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
124 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
125 struct qlcnic_info *info)
127 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
129 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
130 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
131 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
132 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
133 ff_max->num_rx_queues = info->max_rx_ques;
134 ff_max->num_tx_queues = info->max_tx_ques;
135 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
136 ff_max->num_destip = info->max_rx_ip_addr;
137 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
138 ff_max->num_rx_status_rings = info->max_rx_status_rings;
139 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
140 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
143 static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter *adapter,
144 struct qlcnic_info *npar_info)
146 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
149 temp = npar_info->max_rx_mcast_mac_filters;
150 total_fn = sriov->num_vfs + 1;
152 temp = temp / (QLCNIC_SRIOV_VF_MAX_MAC * total_fn);
153 sriov->num_allowed_vlans = temp - 1;
155 if (qlcnic_83xx_pf_check(adapter))
156 sriov->num_allowed_vlans = 1;
158 netdev_info(adapter->netdev, "Max Guest VLANs supported per VF = %d\n",
159 sriov->num_allowed_vlans);
162 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
163 struct qlcnic_info *npar_info)
166 struct qlcnic_cmd_args cmd;
168 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
171 cmd.req.arg[1] = 0x2;
172 err = qlcnic_issue_cmd(adapter, &cmd);
174 dev_err(&adapter->pdev->dev,
175 "Failed to get PF info, err=%d\n", err);
179 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
180 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
181 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
182 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
183 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
184 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
185 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
186 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
187 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
188 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
189 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
190 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
191 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
192 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
193 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
195 qlcnic_sriov_set_vf_max_vlan(adapter, npar_info);
196 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
197 dev_info(&adapter->pdev->dev,
198 "\n\ttotal_pf: %d,\n"
199 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
200 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
201 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
202 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
203 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
204 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
205 npar_info->total_pf, npar_info->total_rss_engines,
206 npar_info->max_vports, npar_info->max_tx_ques,
207 npar_info->max_tx_mac_filters,
208 npar_info->max_rx_mcast_mac_filters,
209 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
210 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
211 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
212 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
213 npar_info->max_remote_ipv6_addrs);
216 qlcnic_free_mbx_args(&cmd);
220 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
223 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
224 struct qlcnic_vport *vp;
227 if (adapter->ahw->pci_func == func) {
228 sriov->vp_handle = 0;
230 index = qlcnic_sriov_func_to_index(adapter, func);
233 vp = sriov->vf_info[index].vp;
238 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
239 u16 vport_handle, u8 func)
241 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
242 struct qlcnic_vport *vp;
245 if (adapter->ahw->pci_func == func) {
246 sriov->vp_handle = vport_handle;
248 index = qlcnic_sriov_func_to_index(adapter, func);
251 vp = sriov->vf_info[index].vp;
252 vp->handle = vport_handle;
256 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
259 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
260 struct qlcnic_vf_info *vf_info;
263 if (adapter->ahw->pci_func == func) {
264 return sriov->vp_handle;
266 index = qlcnic_sriov_func_to_index(adapter, func);
268 vf_info = &sriov->vf_info[index];
269 return vf_info->vp->handle;
276 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
279 struct qlcnic_cmd_args cmd;
283 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
287 cmd.req.arg[3] = func << 8;
289 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
294 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
297 ret = qlcnic_issue_cmd(adapter, &cmd);
299 dev_err(&adapter->pdev->dev,
300 "Failed %s vport, err %d for func 0x%x\n",
301 (flag ? "enable" : "disable"), ret, func);
306 vpid = cmd.rsp.arg[2] & 0xffff;
307 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
309 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
313 qlcnic_free_mbx_args(&cmd);
317 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
320 struct qlcnic_cmd_args cmd;
323 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
327 cmd.req.arg[1] = 0x4;
329 cmd.req.arg[1] |= BIT_16;
331 err = qlcnic_issue_cmd(adapter, &cmd);
333 dev_err(&adapter->pdev->dev,
334 "Failed to configure VLAN filtering, err=%d\n", err);
336 qlcnic_free_mbx_args(&cmd);
340 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
343 struct qlcnic_cmd_args cmd;
346 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
349 cmd.req.arg[0] |= (3 << 29);
350 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
352 cmd.req.arg[1] |= BIT_0;
354 err = qlcnic_issue_cmd(adapter, &cmd);
356 if (err != QLCNIC_RCODE_SUCCESS) {
357 dev_err(&adapter->pdev->dev,
358 "Failed to enable sriov eswitch%d\n", err);
362 qlcnic_free_mbx_args(&cmd);
366 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
368 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
369 struct qlcnic_back_channel *bc = &sriov->bc;
372 for (i = 0; i < sriov->num_vfs; i++)
373 cancel_work_sync(&sriov->vf_info[i].flr_work);
375 destroy_workqueue(bc->bc_flr_wq);
378 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
380 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
381 struct workqueue_struct *wq;
383 wq = create_singlethread_workqueue("qlcnic-flr");
385 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
393 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
395 u8 func = adapter->ahw->pci_func;
397 if (!qlcnic_sriov_enable_check(adapter))
400 qlcnic_sriov_pf_del_flr_queue(adapter);
401 qlcnic_sriov_cfg_bc_intr(adapter, 0);
402 qlcnic_sriov_pf_config_vport(adapter, 0, func);
403 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
404 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
405 __qlcnic_sriov_cleanup(adapter);
406 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
407 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
410 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
412 if (!qlcnic_sriov_pf_check(adapter))
415 if (!qlcnic_sriov_enable_check(adapter))
418 pci_disable_sriov(adapter->pdev);
419 netdev_info(adapter->netdev,
420 "SR-IOV is disabled successfully on port %d\n",
424 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
426 struct net_device *netdev = adapter->netdev;
429 if (netif_running(netdev))
430 __qlcnic_down(adapter, netdev);
432 qlcnic_sriov_pf_disable(adapter);
434 qlcnic_sriov_free_vlans(adapter);
436 qlcnic_sriov_pf_cleanup(adapter);
438 /* After disabling SRIOV re-init the driver in default mode
439 configure opmode based on op_mode of function
441 if (qlcnic_83xx_configure_opmode(adapter)) {
446 if (netif_running(netdev))
447 __qlcnic_up(adapter, netdev);
453 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
455 struct qlcnic_hardware_context *ahw = adapter->ahw;
456 struct qlcnic_info nic_info, pf_info, vp_info;
458 u8 func = ahw->pci_func;
460 if (!qlcnic_sriov_enable_check(adapter))
463 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
467 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
469 goto disable_vlan_filtering;
471 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
473 goto disable_eswitch;
475 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
479 err = qlcnic_get_nic_info(adapter, &nic_info, func);
483 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
487 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
491 ahw->physical_port = (u8) nic_info.phys_port;
492 ahw->switch_mode = nic_info.switch_mode;
493 ahw->max_mtu = nic_info.max_mtu;
494 ahw->capabilities = nic_info.capabilities;
495 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
499 qlcnic_sriov_pf_config_vport(adapter, 0, func);
502 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
504 disable_vlan_filtering:
505 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
510 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
514 if (!qlcnic_sriov_enable_check(adapter))
517 err = pci_enable_sriov(adapter->pdev, num_vfs);
519 qlcnic_sriov_pf_cleanup(adapter);
524 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
529 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
530 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
532 err = qlcnic_sriov_init(adapter, num_vfs);
536 err = qlcnic_sriov_pf_create_flr_queue(adapter);
540 err = qlcnic_sriov_pf_init(adapter);
544 qlcnic_sriov_alloc_vlans(adapter);
546 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
550 qlcnic_sriov_pf_del_flr_queue(adapter);
553 __qlcnic_sriov_cleanup(adapter);
556 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
557 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
561 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
563 struct net_device *netdev = adapter->netdev;
566 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
568 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
573 if (netif_running(netdev))
574 __qlcnic_down(adapter, netdev);
576 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
578 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
582 if (qlcnic_83xx_configure_opmode(adapter))
586 "SR-IOV is enabled successfully on port %d\n",
588 /* Return number of vfs enabled */
591 if (netif_running(netdev))
592 __qlcnic_up(adapter, netdev);
599 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
601 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
604 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
608 err = qlcnic_pci_sriov_disable(adapter);
610 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
612 clear_bit(__QLCNIC_RESETTING, &adapter->state);
616 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
618 struct qlcnic_cmd_args cmd;
619 struct qlcnic_vport *vp;
623 id = qlcnic_sriov_func_to_index(adapter, func);
627 vp = adapter->ahw->sriov->vf_info[id].vp;
628 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
632 cmd.req.arg[1] = 0x3 | func << 16;
633 if (vp->spoofchk == true) {
635 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
636 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
638 cmd.req.arg[5] = mac[1] | mac[0] << 8;
641 if (vp->vlan_mode == QLC_PVID_MODE) {
642 cmd.req.arg[2] |= BIT_6;
643 cmd.req.arg[3] |= vp->pvid << 8;
646 err = qlcnic_issue_cmd(adapter, &cmd);
648 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
651 qlcnic_free_mbx_args(&cmd);
655 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
658 struct qlcnic_info defvp_info;
661 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
665 err = qlcnic_sriov_set_vf_acl(adapter, func);
672 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
673 struct qlcnic_cmd_args *cmd)
675 struct qlcnic_vf_info *vf = trans->vf;
676 struct qlcnic_vport *vp = vf->vp;
677 struct qlcnic_adapter *adapter;
678 struct qlcnic_sriov *sriov;
679 u16 func = vf->pci_func;
683 adapter = vf->adapter;
684 sriov = adapter->ahw->sriov;
686 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
687 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
689 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
691 qlcnic_sriov_pf_config_vport(adapter, 0, func);
694 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {
695 size = sizeof(*vf->sriov_vlans);
696 size = size * sriov->num_allowed_vlans;
697 memset(vf->sriov_vlans, 0, size);
700 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
706 cmd->rsp.arg[0] |= (1 << 25);
708 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
709 set_bit(QLC_BC_VF_STATE, &vf->state);
711 clear_bit(QLC_BC_VF_STATE, &vf->state);
716 cmd->rsp.arg[0] |= (2 << 25);
720 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
721 struct qlcnic_vf_info *vf,
724 struct qlcnic_cmd_args cmd;
725 struct qlcnic_macvlan_mbx mv;
726 struct qlcnic_vport *vp;
734 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
737 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
744 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
745 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
747 cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
748 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
752 mv.mac_addr0 = addr[0];
753 mv.mac_addr1 = addr[1];
754 mv.mac_addr2 = addr[2];
755 mv.mac_addr3 = addr[3];
756 mv.mac_addr4 = addr[4];
757 mv.mac_addr5 = addr[5];
758 buf = &cmd.req.arg[2];
759 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
761 err = qlcnic_issue_cmd(adapter, &cmd);
764 dev_err(&adapter->pdev->dev,
765 "MAC-VLAN %s to CAM failed, err=%d.\n",
766 ((op == 1) ? "add " : "delete "), err);
769 qlcnic_free_mbx_args(&cmd);
773 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
775 if ((cmd->req.arg[0] >> 29) != 0x3)
781 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,
782 struct qlcnic_vf_info *vf,
785 struct qlcnic_sriov *sriov;
789 sriov = adapter->ahw->sriov;
791 mutex_lock(&vf->vlan_list_lock);
793 for (i = 0; i < sriov->num_allowed_vlans; i++) {
794 vlan = vf->sriov_vlans[i];
796 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,
800 mutex_unlock(&vf->vlan_list_lock);
802 if (vf->vp->vlan_mode != QLC_PVID_MODE) {
803 if (qlcnic_83xx_pf_check(adapter) &&
804 qlcnic_sriov_check_any_vlan(vf))
806 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);
810 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
811 struct qlcnic_cmd_args *cmd)
813 struct qlcnic_vf_info *vf = tran->vf;
814 struct qlcnic_adapter *adapter = vf->adapter;
815 struct qlcnic_rcv_mbx_out *mbx_out;
818 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
820 cmd->rsp.arg[0] |= (0x6 << 25);
824 cmd->req.arg[6] = vf->vp->handle;
825 err = qlcnic_issue_cmd(adapter, cmd);
828 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
829 vf->rx_ctx_id = mbx_out->ctx_id;
830 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);
838 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
839 struct qlcnic_cmd_args *cmd)
841 struct qlcnic_vf_info *vf = trans->vf;
844 type = cmd->req.arg[1];
846 case QLCNIC_SET_STATION_MAC:
847 case QLCNIC_SET_FAC_DEF_MAC:
848 cmd->rsp.arg[0] = (2 << 25);
850 case QLCNIC_GET_CURRENT_MAC:
851 cmd->rsp.arg[0] = (1 << 25);
853 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
854 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
855 ((mac[3]) << 16 & 0xff0000) |
856 ((mac[2]) << 24 & 0xff000000);
862 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
864 if ((cmd->req.arg[0] >> 29) != 0x3)
870 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
871 struct qlcnic_cmd_args *cmd)
873 struct qlcnic_vf_info *vf = trans->vf;
874 struct qlcnic_adapter *adapter = vf->adapter;
875 struct qlcnic_tx_mbx_out *mbx_out;
878 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
880 cmd->rsp.arg[0] |= (0x6 << 25);
884 cmd->req.arg[5] |= vf->vp->handle << 16;
885 err = qlcnic_issue_cmd(adapter, cmd);
887 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
888 vf->tx_ctx_id = mbx_out->ctx_id;
896 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
897 struct qlcnic_cmd_args *cmd)
899 if ((cmd->req.arg[0] >> 29) != 0x3)
902 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
908 static int qlcnic_sriov_pf_del_rx_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;
915 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
917 cmd->rsp.arg[0] |= (0x6 << 25);
921 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);
922 cmd->req.arg[1] |= vf->vp->handle << 16;
923 err = qlcnic_issue_cmd(adapter, cmd);
931 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
932 struct qlcnic_cmd_args *cmd)
934 if ((cmd->req.arg[0] >> 29) != 0x3)
937 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
943 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
944 struct qlcnic_cmd_args *cmd)
946 struct qlcnic_vf_info *vf = trans->vf;
947 struct qlcnic_adapter *adapter = vf->adapter;
950 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
952 cmd->rsp.arg[0] |= (0x6 << 25);
956 cmd->req.arg[1] |= vf->vp->handle << 16;
957 err = qlcnic_issue_cmd(adapter, cmd);
965 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
966 struct qlcnic_cmd_args *cmd)
968 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
974 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
975 struct qlcnic_cmd_args *cmd)
977 struct qlcnic_vf_info *vf = trans->vf;
978 struct qlcnic_adapter *adapter = vf->adapter;
981 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
983 cmd->rsp.arg[0] |= (0x6 << 25);
987 err = qlcnic_issue_cmd(adapter, cmd);
991 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
992 struct qlcnic_cmd_args *cmd)
994 struct qlcnic_vf_info *vf = trans->vf;
995 struct qlcnic_adapter *adapter = vf->adapter;
999 op = cmd->req.arg[1] & 0xff;
1001 cmd->req.arg[1] |= vf->vp->handle << 16;
1002 cmd->req.arg[1] |= BIT_31;
1004 err = qlcnic_issue_cmd(adapter, cmd);
1008 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
1009 struct qlcnic_cmd_args *cmd)
1011 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
1014 if (!(cmd->req.arg[1] & BIT_16))
1017 if ((cmd->req.arg[1] & 0xff) != 0x1)
1023 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
1024 struct qlcnic_cmd_args *cmd)
1026 struct qlcnic_vf_info *vf = trans->vf;
1027 struct qlcnic_adapter *adapter = vf->adapter;
1030 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
1032 cmd->rsp.arg[0] |= (0x6 << 25);
1034 err = qlcnic_issue_cmd(adapter, cmd);
1039 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
1040 struct qlcnic_vf_info *vf,
1041 struct qlcnic_cmd_args *cmd)
1043 if (cmd->req.arg[1] != vf->rx_ctx_id)
1046 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
1052 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
1053 struct qlcnic_cmd_args *cmd)
1055 struct qlcnic_vf_info *vf = trans->vf;
1056 struct qlcnic_adapter *adapter = vf->adapter;
1059 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
1061 cmd->rsp.arg[0] |= (0x6 << 25);
1063 err = qlcnic_issue_cmd(adapter, cmd);
1068 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1069 struct qlcnic_cmd_args *cmd)
1071 if (cmd->req.arg[1] & BIT_31) {
1072 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1075 cmd->req.arg[1] |= vf->vp->handle << 16;
1081 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1082 struct qlcnic_cmd_args *cmd)
1084 struct qlcnic_vf_info *vf = trans->vf;
1085 struct qlcnic_adapter *adapter = vf->adapter;
1088 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1090 cmd->rsp.arg[0] |= (0x6 << 25);
1094 err = qlcnic_issue_cmd(adapter, cmd);
1098 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1099 struct qlcnic_cmd_args *cmd)
1101 if (cmd->req.arg[1] != vf->rx_ctx_id)
1107 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1108 struct qlcnic_cmd_args *cmd)
1110 struct qlcnic_vf_info *vf = trans->vf;
1111 struct qlcnic_adapter *adapter = vf->adapter;
1114 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1116 cmd->rsp.arg[0] |= (0x6 << 25);
1118 err = qlcnic_issue_cmd(adapter, cmd);
1123 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1124 struct qlcnic_vf_info *vf,
1125 struct qlcnic_cmd_args *cmd)
1127 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1128 u16 ctx_id, pkts, time;
1130 ctx_id = cmd->req.arg[1] >> 16;
1131 pkts = cmd->req.arg[2] & 0xffff;
1132 time = cmd->req.arg[2] >> 16;
1134 if (ctx_id != vf->rx_ctx_id)
1136 if (pkts > coal->rx_packets)
1138 if (time < coal->rx_time_us)
1144 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1145 struct qlcnic_cmd_args *cmd)
1147 struct qlcnic_vf_info *vf = tran->vf;
1148 struct qlcnic_adapter *adapter = vf->adapter;
1151 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1153 cmd->rsp.arg[0] |= (0x6 << 25);
1157 err = qlcnic_issue_cmd(adapter, cmd);
1161 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1162 struct qlcnic_vf_info *vf,
1163 struct qlcnic_cmd_args *cmd)
1165 struct qlcnic_macvlan_mbx *macvlan;
1166 struct qlcnic_vport *vp = vf->vp;
1169 if (!(cmd->req.arg[1] & BIT_8))
1172 cmd->req.arg[1] |= (vf->vp->handle << 16);
1173 cmd->req.arg[1] |= BIT_31;
1175 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1176 if (!(macvlan->mac_addr0 & BIT_0)) {
1177 dev_err(&adapter->pdev->dev,
1178 "MAC address change is not allowed from VF %d",
1183 if (vp->vlan_mode == QLC_PVID_MODE) {
1184 op = cmd->req.arg[1] & 0x7;
1185 cmd->req.arg[1] &= ~0x7;
1186 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1187 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1188 cmd->req.arg[3] |= vp->pvid << 16;
1189 cmd->req.arg[1] |= new_op;
1195 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1196 struct qlcnic_cmd_args *cmd)
1198 struct qlcnic_vf_info *vf = trans->vf;
1199 struct qlcnic_adapter *adapter = vf->adapter;
1202 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1204 cmd->rsp.arg[0] |= (0x6 << 25);
1208 err = qlcnic_issue_cmd(adapter, cmd);
1212 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1213 struct qlcnic_cmd_args *cmd)
1215 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1221 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1222 struct qlcnic_cmd_args *cmd)
1224 struct qlcnic_vf_info *vf = trans->vf;
1225 struct qlcnic_adapter *adapter = vf->adapter;
1228 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1230 cmd->rsp.arg[0] |= (0x6 << 25);
1234 err = qlcnic_issue_cmd(adapter, cmd);
1238 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1239 struct qlcnic_cmd_args *cmd)
1241 struct qlcnic_vf_info *vf = trans->vf;
1242 struct qlcnic_adapter *adapter = vf->adapter;
1245 cmd->req.arg[1] |= vf->vp->handle << 16;
1246 cmd->req.arg[1] |= BIT_31;
1247 err = qlcnic_issue_cmd(adapter, cmd);
1251 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1252 struct qlcnic_cmd_args *cmd)
1254 struct qlcnic_vf_info *vf = trans->vf;
1255 struct qlcnic_vport *vp = vf->vp;
1256 u8 cmd_op, mode = vp->vlan_mode;
1257 struct qlcnic_adapter *adapter;
1258 struct qlcnic_sriov *sriov;
1260 adapter = vf->adapter;
1261 sriov = adapter->ahw->sriov;
1263 cmd_op = trans->req_hdr->cmd_op;
1264 cmd->rsp.arg[0] |= 1 << 25;
1266 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1267 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1269 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1273 case QLC_GUEST_VLAN_MODE:
1274 cmd->rsp.arg[1] = mode | 1 << 8;
1275 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16;
1278 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16;
1285 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1286 struct qlcnic_vf_info *vf,
1287 struct qlcnic_cmd_args *cmd)
1289 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1292 if (!qlcnic_sriov_check_any_vlan(vf))
1295 vlan = cmd->req.arg[1] >> 16;
1296 if (!vf->rx_ctx_id) {
1297 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1301 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL);
1302 qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1304 if (qlcnic_83xx_pf_check(adapter))
1305 qlcnic_sriov_cfg_vf_def_mac(adapter, vf,
1310 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1311 struct qlcnic_vf_info *vf,
1312 struct qlcnic_cmd_args *cmd)
1314 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1318 if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf))
1321 vlan = cmd->req.arg[1] >> 16;
1323 if (!vf->rx_ctx_id) {
1324 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1328 if (qlcnic_83xx_pf_check(adapter)) {
1329 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1335 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD);
1338 if (qlcnic_83xx_pf_check(adapter))
1339 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1344 qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1348 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1349 struct qlcnic_cmd_args *cmd)
1351 struct qlcnic_vf_info *vf = tran->vf;
1352 struct qlcnic_adapter *adapter = vf->adapter;
1353 struct qlcnic_vport *vp = vf->vp;
1357 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1358 cmd->rsp.arg[0] |= 2 << 25;
1362 op = cmd->req.arg[1] & 0xf;
1365 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1367 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd);
1369 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1373 static const int qlcnic_pf_passthru_supp_cmds[] = {
1374 QLCNIC_CMD_GET_STATISTICS,
1375 QLCNIC_CMD_GET_PORT_CONFIG,
1376 QLCNIC_CMD_GET_LINK_STATUS,
1377 QLCNIC_CMD_INIT_NIC_FUNC,
1378 QLCNIC_CMD_STOP_NIC_FUNC,
1381 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1382 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1383 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1384 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1385 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1388 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1389 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1390 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1391 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1392 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1393 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1394 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1395 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1396 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1397 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1398 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1399 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1400 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1401 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1402 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1403 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1406 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1407 struct qlcnic_bc_trans *trans,
1408 struct qlcnic_cmd_args *cmd)
1412 cmd_op = trans->req_hdr->cmd_op;
1414 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1415 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1416 if (cmd_op < size) {
1417 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1422 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1423 for (i = 0; i < size; i++) {
1424 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1425 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1430 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1431 for (i = 0; i < size; i++) {
1432 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1433 qlcnic_issue_cmd(adapter, cmd);
1439 cmd->rsp.arg[0] |= (0x9 << 25);
1442 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1447 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1448 adapter->ahw->pci_func);
1452 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1457 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1458 adapter->ahw->pci_func);
1459 *int_id |= vpid << 16;
1462 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1467 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1468 adapter->ahw->pci_func);
1469 *int_id |= vpid << 16;
1472 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1477 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1478 adapter->ahw->pci_func);
1479 *int_id |= vpid << 16;
1482 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1487 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1488 adapter->ahw->pci_func);
1489 *int_id |= (vpid << 16) | BIT_31;
1492 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1497 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1498 adapter->ahw->pci_func);
1499 *int_id |= (vpid << 16) | BIT_31;
1502 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1507 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1508 adapter->ahw->pci_func);
1509 *int_id |= (vpid << 16) | BIT_31;
1512 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1513 struct qlcnic_vf_info *vf)
1515 struct qlcnic_cmd_args cmd;
1521 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1524 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1526 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1527 if (qlcnic_issue_cmd(adapter, &cmd))
1528 dev_err(&adapter->pdev->dev,
1529 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1535 qlcnic_free_mbx_args(&cmd);
1538 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1539 struct qlcnic_vf_info *vf)
1541 struct qlcnic_cmd_args cmd;
1547 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1550 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1552 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1553 if (qlcnic_issue_cmd(adapter, &cmd))
1554 dev_err(&adapter->pdev->dev,
1555 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1561 qlcnic_free_mbx_args(&cmd);
1564 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1565 struct qlcnic_vf_info *vf,
1566 struct qlcnic_bc_trans *trans)
1568 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1571 spin_lock_irqsave(&t_list->lock, flag);
1573 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1575 spin_unlock_irqrestore(&t_list->lock, flag);
1579 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1581 struct qlcnic_adapter *adapter = vf->adapter;
1583 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1584 cancel_work_sync(&vf->trans_work);
1585 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1587 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1588 qlcnic_sriov_del_tx_ctx(adapter, vf);
1589 qlcnic_sriov_del_rx_ctx(adapter, vf);
1592 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1594 clear_bit(QLC_BC_VF_FLR, &vf->state);
1595 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1596 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1598 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1599 vf->flr_trans = NULL;
1603 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1605 struct qlcnic_vf_info *vf;
1607 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1608 __qlcnic_sriov_process_flr(vf);
1612 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1613 struct qlcnic_vf_info *vf,
1616 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1619 INIT_WORK(&vf->flr_work, func);
1620 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1623 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1624 struct qlcnic_bc_trans *trans,
1625 struct qlcnic_vf_info *vf)
1627 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1629 set_bit(QLC_BC_VF_FLR, &vf->state);
1630 clear_bit(QLC_BC_VF_STATE, &vf->state);
1631 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1632 vf->flr_trans = trans;
1633 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1634 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1638 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1639 struct qlcnic_bc_trans *trans,
1640 struct qlcnic_vf_info *vf)
1642 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1644 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1645 (hdr->op_type == QLC_BC_CMD) &&
1646 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1647 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1654 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1655 struct qlcnic_vf_info *vf)
1657 struct net_device *dev = vf->adapter->netdev;
1658 struct qlcnic_vport *vp = vf->vp;
1660 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1661 clear_bit(QLC_BC_VF_FLR, &vf->state);
1665 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1666 netdev_info(dev, "FLR for PCI func %d in progress\n",
1671 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1672 memset(vf->sriov_vlans, 0,
1673 sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans);
1675 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1676 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1679 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1681 struct qlcnic_hardware_context *ahw = adapter->ahw;
1682 struct qlcnic_sriov *sriov = ahw->sriov;
1683 struct qlcnic_vf_info *vf;
1684 u16 num_vfs = sriov->num_vfs;
1687 for (i = 0; i < num_vfs; i++) {
1688 vf = &sriov->vf_info[i];
1691 cancel_work_sync(&vf->flr_work);
1692 __qlcnic_sriov_process_flr(vf);
1693 clear_bit(QLC_BC_VF_STATE, &vf->state);
1696 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1697 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1700 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1702 struct qlcnic_hardware_context *ahw = adapter->ahw;
1705 if (!qlcnic_sriov_enable_check(adapter))
1708 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1710 err = qlcnic_sriov_pf_init(adapter);
1714 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1715 __func__, ahw->op_mode);
1719 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1721 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1722 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1724 struct qlcnic_vf_info *vf_info;
1727 if (!qlcnic_sriov_pf_check(adapter))
1730 num_vfs = sriov->num_vfs;
1732 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1735 if (ether_addr_equal(adapter->mac_addr, mac)) {
1736 netdev_err(netdev, "MAC address is already in use by the PF\n");
1740 for (i = 0; i < num_vfs; i++) {
1741 vf_info = &sriov->vf_info[i];
1742 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1744 "MAC address is already in use by VF %d\n",
1750 vf_info = &sriov->vf_info[vf];
1751 curr_mac = vf_info->vp->mac;
1753 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1755 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1760 memcpy(curr_mac, mac, netdev->addr_len);
1761 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1766 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1768 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1769 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1770 struct qlcnic_vf_info *vf_info;
1771 struct qlcnic_info nic_info;
1772 struct qlcnic_vport *vp;
1775 if (!qlcnic_sriov_pf_check(adapter))
1778 if (vf >= sriov->num_vfs)
1781 if (tx_rate >= 10000 || tx_rate < 100) {
1783 "Invalid Tx rate, allowed range is [%d - %d]",
1784 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1791 vf_info = &sriov->vf_info[vf];
1795 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1796 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1799 nic_info.max_tx_bw = tx_rate / 100;
1800 nic_info.bit_offsets = BIT_0;
1802 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1806 vp->max_tx_bw = tx_rate / 100;
1808 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1809 tx_rate, vp->max_tx_bw, vf);
1813 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1816 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1817 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1818 struct qlcnic_vf_info *vf_info;
1819 struct qlcnic_vport *vp;
1821 if (!qlcnic_sriov_pf_check(adapter))
1824 if (vf >= sriov->num_vfs || qos > 7)
1827 if (vlan > MAX_VLAN_ID) {
1829 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1834 vf_info = &sriov->vf_info[vf];
1836 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1838 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1843 memset(vf_info->sriov_vlans, 0,
1844 sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans);
1848 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1851 vp->vlan_mode = QLC_NO_VLAN_MODE;
1855 vp->vlan_mode = QLC_PVID_MODE;
1856 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan);
1861 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1866 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1867 struct qlcnic_vport *vp, int vf)
1871 switch (vp->vlan_mode) {
1875 case QLC_GUEST_VLAN_MODE:
1878 case QLC_NO_VLAN_MODE:
1882 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1889 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1890 int vf, struct ifla_vf_info *ivi)
1892 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1893 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1894 struct qlcnic_vport *vp;
1896 if (!qlcnic_sriov_pf_check(adapter))
1899 if (vf >= sriov->num_vfs)
1902 vp = sriov->vf_info[vf].vp;
1903 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1904 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1906 ivi->spoofchk = vp->spoofchk;
1907 if (vp->max_tx_bw == MAX_BW)
1910 ivi->tx_rate = vp->max_tx_bw * 100;
1916 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1918 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1919 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1920 struct qlcnic_vf_info *vf_info;
1921 struct qlcnic_vport *vp;
1923 if (!qlcnic_sriov_pf_check(adapter))
1926 if (vf >= sriov->num_vfs)
1929 vf_info = &sriov->vf_info[vf];
1931 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1933 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",