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 1
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 u32 temp, num_vf_macs, num_vfs, max;
68 int ret = -EIO, vpid, id;
69 struct qlcnic_vport *vp;
71 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
75 num_vfs = sriov->num_vfs;
77 info->bit_offsets = 0xffff;
78 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
79 num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC;
81 if (adapter->ahw->pci_func == func) {
82 temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs);
83 info->max_rx_ucast_mac_filters = temp;
84 temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs);
85 info->max_tx_mac_filters = temp;
87 info->max_tx_bw = MAX_BW;
88 info->max_tx_ques = res->num_tx_queues - sriov->num_vfs;
90 id = qlcnic_sriov_func_to_index(adapter, func);
93 vp = sriov->vf_info[id].vp;
94 info->min_tx_bw = vp->min_tx_bw;
95 info->max_tx_bw = vp->max_tx_bw;
96 info->max_rx_ucast_mac_filters = num_vf_macs;
97 info->max_tx_mac_filters = num_vf_macs;
98 info->max_tx_ques = QLCNIC_SINGLE_RING;
101 info->max_rx_ip_addr = res->num_destip / max;
102 info->max_rx_status_rings = res->num_rx_status_rings / max;
103 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
104 info->max_rx_ques = res->num_rx_queues / max;
105 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
106 info->max_tx_vlan_keys = res->num_txvlan_keys;
107 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
108 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
110 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
117 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
118 struct qlcnic_info *info)
120 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
122 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
123 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
124 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
125 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
126 ff_max->num_rx_queues = info->max_rx_ques;
127 ff_max->num_tx_queues = info->max_tx_ques;
128 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
129 ff_max->num_destip = info->max_rx_ip_addr;
130 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
131 ff_max->num_rx_status_rings = info->max_rx_status_rings;
132 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
133 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
136 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
137 struct qlcnic_info *npar_info)
140 struct qlcnic_cmd_args cmd;
142 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
145 cmd.req.arg[1] = 0x2;
146 err = qlcnic_issue_cmd(adapter, &cmd);
148 dev_err(&adapter->pdev->dev,
149 "Failed to get PF info, err=%d\n", err);
153 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
154 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
155 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
156 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
157 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
158 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
159 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
160 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
161 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
162 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
163 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
164 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
165 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
166 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
167 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
169 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
170 dev_info(&adapter->pdev->dev,
171 "\n\ttotal_pf: %d,\n"
172 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
173 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
174 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
175 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
176 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
177 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
178 npar_info->total_pf, npar_info->total_rss_engines,
179 npar_info->max_vports, npar_info->max_tx_ques,
180 npar_info->max_tx_mac_filters,
181 npar_info->max_rx_mcast_mac_filters,
182 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
183 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
184 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
185 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
186 npar_info->max_remote_ipv6_addrs);
189 qlcnic_free_mbx_args(&cmd);
193 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
196 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
197 struct qlcnic_vport *vp;
200 if (adapter->ahw->pci_func == func) {
201 sriov->vp_handle = 0;
203 index = qlcnic_sriov_func_to_index(adapter, func);
206 vp = sriov->vf_info[index].vp;
211 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
212 u16 vport_handle, u8 func)
214 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
215 struct qlcnic_vport *vp;
218 if (adapter->ahw->pci_func == func) {
219 sriov->vp_handle = vport_handle;
221 index = qlcnic_sriov_func_to_index(adapter, func);
224 vp = sriov->vf_info[index].vp;
225 vp->handle = vport_handle;
229 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
232 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
233 struct qlcnic_vf_info *vf_info;
236 if (adapter->ahw->pci_func == func) {
237 return sriov->vp_handle;
239 index = qlcnic_sriov_func_to_index(adapter, func);
241 vf_info = &sriov->vf_info[index];
242 return vf_info->vp->handle;
249 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
252 struct qlcnic_cmd_args cmd;
256 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
260 cmd.req.arg[3] = func << 8;
262 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
267 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
270 ret = qlcnic_issue_cmd(adapter, &cmd);
272 dev_err(&adapter->pdev->dev,
273 "Failed %s vport, err %d for func 0x%x\n",
274 (flag ? "enable" : "disable"), ret, func);
279 vpid = cmd.rsp.arg[2] & 0xffff;
280 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
282 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
286 qlcnic_free_mbx_args(&cmd);
290 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
293 struct qlcnic_cmd_args cmd;
296 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
300 cmd.req.arg[1] = 0x4;
302 cmd.req.arg[1] |= BIT_16;
304 err = qlcnic_issue_cmd(adapter, &cmd);
306 dev_err(&adapter->pdev->dev,
307 "Failed to configure VLAN filtering, err=%d\n", err);
309 qlcnic_free_mbx_args(&cmd);
313 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
316 struct qlcnic_cmd_args cmd;
319 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
322 cmd.req.arg[0] |= (3 << 29);
323 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
325 cmd.req.arg[1] |= BIT_0;
327 err = qlcnic_issue_cmd(adapter, &cmd);
329 if (err != QLCNIC_RCODE_SUCCESS) {
330 dev_err(&adapter->pdev->dev,
331 "Failed to enable sriov eswitch%d\n", err);
335 qlcnic_free_mbx_args(&cmd);
339 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
341 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
342 struct qlcnic_back_channel *bc = &sriov->bc;
345 for (i = 0; i < sriov->num_vfs; i++)
346 cancel_work_sync(&sriov->vf_info[i].flr_work);
348 destroy_workqueue(bc->bc_flr_wq);
351 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
353 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
354 struct workqueue_struct *wq;
356 wq = create_singlethread_workqueue("qlcnic-flr");
358 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
366 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
368 u8 func = adapter->ahw->pci_func;
370 if (!qlcnic_sriov_enable_check(adapter))
373 qlcnic_sriov_pf_del_flr_queue(adapter);
374 qlcnic_sriov_cfg_bc_intr(adapter, 0);
375 qlcnic_sriov_pf_config_vport(adapter, 0, func);
376 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
377 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
378 __qlcnic_sriov_cleanup(adapter);
379 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
380 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
383 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
385 if (!qlcnic_sriov_pf_check(adapter))
388 if (!qlcnic_sriov_enable_check(adapter))
391 pci_disable_sriov(adapter->pdev);
392 netdev_info(adapter->netdev,
393 "SR-IOV is disabled successfully on port %d\n",
397 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
399 struct net_device *netdev = adapter->netdev;
402 if (netif_running(netdev))
403 __qlcnic_down(adapter, netdev);
405 qlcnic_sriov_pf_disable(adapter);
407 qlcnic_sriov_pf_cleanup(adapter);
409 /* After disabling SRIOV re-init the driver in default mode
410 configure opmode based on op_mode of function
412 if (qlcnic_83xx_configure_opmode(adapter)) {
417 if (netif_running(netdev))
418 __qlcnic_up(adapter, netdev);
424 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
426 struct qlcnic_hardware_context *ahw = adapter->ahw;
427 struct qlcnic_info nic_info, pf_info, vp_info;
429 u8 func = ahw->pci_func;
431 if (!qlcnic_sriov_enable_check(adapter))
434 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
438 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
440 goto disable_vlan_filtering;
442 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
444 goto disable_eswitch;
446 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
450 err = qlcnic_get_nic_info(adapter, &nic_info, func);
454 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
458 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
462 ahw->physical_port = (u8) nic_info.phys_port;
463 ahw->switch_mode = nic_info.switch_mode;
464 ahw->max_mtu = nic_info.max_mtu;
465 ahw->capabilities = nic_info.capabilities;
466 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
470 qlcnic_sriov_pf_config_vport(adapter, 0, func);
473 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
475 disable_vlan_filtering:
476 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
481 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
485 if (!qlcnic_sriov_enable_check(adapter))
488 err = pci_enable_sriov(adapter->pdev, num_vfs);
490 qlcnic_sriov_pf_cleanup(adapter);
495 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
500 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
501 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
503 err = qlcnic_sriov_init(adapter, num_vfs);
507 err = qlcnic_sriov_pf_create_flr_queue(adapter);
511 err = qlcnic_sriov_pf_init(adapter);
515 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
519 qlcnic_sriov_pf_del_flr_queue(adapter);
522 __qlcnic_sriov_cleanup(adapter);
525 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
526 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
530 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
532 struct net_device *netdev = adapter->netdev;
535 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
537 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
542 if (netif_running(netdev))
543 __qlcnic_down(adapter, netdev);
545 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
547 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
551 if (qlcnic_83xx_configure_opmode(adapter))
555 "SR-IOV is enabled successfully on port %d\n",
557 /* Return number of vfs enabled */
560 if (netif_running(netdev))
561 __qlcnic_up(adapter, netdev);
568 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
570 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
573 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
577 err = qlcnic_pci_sriov_disable(adapter);
579 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
581 clear_bit(__QLCNIC_RESETTING, &adapter->state);
585 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
587 struct qlcnic_cmd_args cmd;
588 struct qlcnic_vport *vp;
592 id = qlcnic_sriov_func_to_index(adapter, func);
596 vp = adapter->ahw->sriov->vf_info[id].vp;
597 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
601 cmd.req.arg[1] = 0x3 | func << 16;
602 if (vp->spoofchk == true) {
604 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
605 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
607 cmd.req.arg[5] = mac[1] | mac[0] << 8;
610 if (vp->vlan_mode == QLC_PVID_MODE) {
611 cmd.req.arg[2] |= BIT_6;
612 cmd.req.arg[3] |= vp->vlan << 8;
615 err = qlcnic_issue_cmd(adapter, &cmd);
617 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
620 qlcnic_free_mbx_args(&cmd);
624 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
627 struct qlcnic_info defvp_info;
630 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
634 err = qlcnic_sriov_set_vf_acl(adapter, func);
641 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
642 struct qlcnic_cmd_args *cmd)
644 struct qlcnic_vf_info *vf = trans->vf;
645 struct qlcnic_vport *vp = vf->vp;
646 struct qlcnic_adapter *adapter;
647 u16 func = vf->pci_func;
650 adapter = vf->adapter;
652 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
653 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
655 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
657 qlcnic_sriov_pf_config_vport(adapter, 0, func);
660 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
662 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
668 cmd->rsp.arg[0] |= (1 << 25);
670 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
671 set_bit(QLC_BC_VF_STATE, &vf->state);
673 clear_bit(QLC_BC_VF_STATE, &vf->state);
678 cmd->rsp.arg[0] |= (2 << 25);
682 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
683 struct qlcnic_vport *vp,
684 u16 func, u16 vlan, u8 op)
686 struct qlcnic_cmd_args cmd;
687 struct qlcnic_macvlan_mbx mv;
693 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
696 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
703 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
704 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
706 cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
707 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
711 mv.mac_addr0 = addr[0];
712 mv.mac_addr1 = addr[1];
713 mv.mac_addr2 = addr[2];
714 mv.mac_addr3 = addr[3];
715 mv.mac_addr4 = addr[4];
716 mv.mac_addr5 = addr[5];
717 buf = &cmd.req.arg[2];
718 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
720 err = qlcnic_issue_cmd(adapter, &cmd);
723 dev_err(&adapter->pdev->dev,
724 "MAC-VLAN %s to CAM failed, err=%d.\n",
725 ((op == 1) ? "add " : "delete "), err);
728 qlcnic_free_mbx_args(&cmd);
732 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
734 if ((cmd->req.arg[0] >> 29) != 0x3)
740 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
741 struct qlcnic_cmd_args *cmd)
743 struct qlcnic_vf_info *vf = tran->vf;
744 struct qlcnic_adapter *adapter = vf->adapter;
745 struct qlcnic_rcv_mbx_out *mbx_out;
749 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
751 cmd->rsp.arg[0] |= (0x6 << 25);
755 cmd->req.arg[6] = vf->vp->handle;
756 err = qlcnic_issue_cmd(adapter, cmd);
760 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
761 vf->rx_ctx_id = mbx_out->ctx_id;
762 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
763 vlan, QLCNIC_MAC_ADD);
771 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
772 struct qlcnic_cmd_args *cmd)
774 struct qlcnic_vf_info *vf = trans->vf;
777 type = cmd->req.arg[1];
779 case QLCNIC_SET_STATION_MAC:
780 case QLCNIC_SET_FAC_DEF_MAC:
781 cmd->rsp.arg[0] = (2 << 25);
783 case QLCNIC_GET_CURRENT_MAC:
784 cmd->rsp.arg[0] = (1 << 25);
786 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
787 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
788 ((mac[3]) << 16 & 0xff0000) |
789 ((mac[2]) << 24 & 0xff000000);
795 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
797 if ((cmd->req.arg[0] >> 29) != 0x3)
803 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
804 struct qlcnic_cmd_args *cmd)
806 struct qlcnic_vf_info *vf = trans->vf;
807 struct qlcnic_adapter *adapter = vf->adapter;
808 struct qlcnic_tx_mbx_out *mbx_out;
811 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
813 cmd->rsp.arg[0] |= (0x6 << 25);
817 cmd->req.arg[5] |= vf->vp->handle << 16;
818 err = qlcnic_issue_cmd(adapter, cmd);
820 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
821 vf->tx_ctx_id = mbx_out->ctx_id;
829 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
830 struct qlcnic_cmd_args *cmd)
832 if ((cmd->req.arg[0] >> 29) != 0x3)
835 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
841 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
842 struct qlcnic_cmd_args *cmd)
844 struct qlcnic_vf_info *vf = trans->vf;
845 struct qlcnic_adapter *adapter = vf->adapter;
849 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
851 cmd->rsp.arg[0] |= (0x6 << 25);
856 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
857 vlan, QLCNIC_MAC_DEL);
858 cmd->req.arg[1] |= vf->vp->handle << 16;
859 err = qlcnic_issue_cmd(adapter, cmd);
867 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
868 struct qlcnic_cmd_args *cmd)
870 if ((cmd->req.arg[0] >> 29) != 0x3)
873 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
879 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
880 struct qlcnic_cmd_args *cmd)
882 struct qlcnic_vf_info *vf = trans->vf;
883 struct qlcnic_adapter *adapter = vf->adapter;
886 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
888 cmd->rsp.arg[0] |= (0x6 << 25);
892 cmd->req.arg[1] |= vf->vp->handle << 16;
893 err = qlcnic_issue_cmd(adapter, cmd);
901 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
902 struct qlcnic_cmd_args *cmd)
904 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
910 static int qlcnic_sriov_pf_cfg_lro_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;
917 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
919 cmd->rsp.arg[0] |= (0x6 << 25);
923 err = qlcnic_issue_cmd(adapter, cmd);
927 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
928 struct qlcnic_cmd_args *cmd)
930 struct qlcnic_vf_info *vf = trans->vf;
931 struct qlcnic_adapter *adapter = vf->adapter;
935 op = cmd->req.arg[1] & 0xff;
937 cmd->req.arg[1] |= vf->vp->handle << 16;
938 cmd->req.arg[1] |= BIT_31;
940 err = qlcnic_issue_cmd(adapter, cmd);
944 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
945 struct qlcnic_cmd_args *cmd)
947 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
950 if (!(cmd->req.arg[1] & BIT_16))
953 if ((cmd->req.arg[1] & 0xff) != 0x1)
959 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
960 struct qlcnic_cmd_args *cmd)
962 struct qlcnic_vf_info *vf = trans->vf;
963 struct qlcnic_adapter *adapter = vf->adapter;
966 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
968 cmd->rsp.arg[0] |= (0x6 << 25);
970 err = qlcnic_issue_cmd(adapter, cmd);
975 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
976 struct qlcnic_vf_info *vf,
977 struct qlcnic_cmd_args *cmd)
979 if (cmd->req.arg[1] != vf->rx_ctx_id)
982 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
988 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
989 struct qlcnic_cmd_args *cmd)
991 struct qlcnic_vf_info *vf = trans->vf;
992 struct qlcnic_adapter *adapter = vf->adapter;
995 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
997 cmd->rsp.arg[0] |= (0x6 << 25);
999 err = qlcnic_issue_cmd(adapter, cmd);
1004 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1005 struct qlcnic_cmd_args *cmd)
1007 if (cmd->req.arg[1] & BIT_31) {
1008 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1011 cmd->req.arg[1] |= vf->vp->handle << 16;
1017 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1018 struct qlcnic_cmd_args *cmd)
1020 struct qlcnic_vf_info *vf = trans->vf;
1021 struct qlcnic_adapter *adapter = vf->adapter;
1024 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1026 cmd->rsp.arg[0] |= (0x6 << 25);
1030 err = qlcnic_issue_cmd(adapter, cmd);
1034 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1035 struct qlcnic_cmd_args *cmd)
1037 if (cmd->req.arg[1] != vf->rx_ctx_id)
1043 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1044 struct qlcnic_cmd_args *cmd)
1046 struct qlcnic_vf_info *vf = trans->vf;
1047 struct qlcnic_adapter *adapter = vf->adapter;
1050 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1052 cmd->rsp.arg[0] |= (0x6 << 25);
1054 err = qlcnic_issue_cmd(adapter, cmd);
1059 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1060 struct qlcnic_vf_info *vf,
1061 struct qlcnic_cmd_args *cmd)
1063 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1064 u16 ctx_id, pkts, time;
1066 ctx_id = cmd->req.arg[1] >> 16;
1067 pkts = cmd->req.arg[2] & 0xffff;
1068 time = cmd->req.arg[2] >> 16;
1070 if (ctx_id != vf->rx_ctx_id)
1072 if (pkts > coal->rx_packets)
1074 if (time < coal->rx_time_us)
1080 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1081 struct qlcnic_cmd_args *cmd)
1083 struct qlcnic_vf_info *vf = tran->vf;
1084 struct qlcnic_adapter *adapter = vf->adapter;
1087 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1089 cmd->rsp.arg[0] |= (0x6 << 25);
1093 err = qlcnic_issue_cmd(adapter, cmd);
1097 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1098 struct qlcnic_vf_info *vf,
1099 struct qlcnic_cmd_args *cmd)
1101 struct qlcnic_macvlan_mbx *macvlan;
1102 struct qlcnic_vport *vp = vf->vp;
1105 if (!(cmd->req.arg[1] & BIT_8))
1108 cmd->req.arg[1] |= (vf->vp->handle << 16);
1109 cmd->req.arg[1] |= BIT_31;
1111 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1112 if (!(macvlan->mac_addr0 & BIT_0)) {
1113 dev_err(&adapter->pdev->dev,
1114 "MAC address change is not allowed from VF %d",
1119 if (vp->vlan_mode == QLC_PVID_MODE) {
1120 op = cmd->req.arg[1] & 0x7;
1121 cmd->req.arg[1] &= ~0x7;
1122 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1123 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1124 cmd->req.arg[3] |= vp->vlan << 16;
1125 cmd->req.arg[1] |= new_op;
1131 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1132 struct qlcnic_cmd_args *cmd)
1134 struct qlcnic_vf_info *vf = trans->vf;
1135 struct qlcnic_adapter *adapter = vf->adapter;
1138 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1140 cmd->rsp.arg[0] |= (0x6 << 25);
1144 err = qlcnic_issue_cmd(adapter, cmd);
1148 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1149 struct qlcnic_cmd_args *cmd)
1151 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1157 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1158 struct qlcnic_cmd_args *cmd)
1160 struct qlcnic_vf_info *vf = trans->vf;
1161 struct qlcnic_adapter *adapter = vf->adapter;
1164 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1166 cmd->rsp.arg[0] |= (0x6 << 25);
1170 err = qlcnic_issue_cmd(adapter, cmd);
1174 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1175 struct qlcnic_cmd_args *cmd)
1177 struct qlcnic_vf_info *vf = trans->vf;
1178 struct qlcnic_adapter *adapter = vf->adapter;
1181 cmd->req.arg[1] |= vf->vp->handle << 16;
1182 cmd->req.arg[1] |= BIT_31;
1183 err = qlcnic_issue_cmd(adapter, cmd);
1187 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1188 struct qlcnic_cmd_args *cmd)
1190 struct qlcnic_vf_info *vf = trans->vf;
1191 struct qlcnic_vport *vp = vf->vp;
1192 u8 cmd_op, mode = vp->vlan_mode;
1193 struct qlcnic_adapter *adapter;
1195 adapter = vf->adapter;
1197 cmd_op = trans->req_hdr->cmd_op;
1198 cmd->rsp.arg[0] |= 1 << 25;
1200 /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1201 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1203 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1207 case QLC_GUEST_VLAN_MODE:
1208 cmd->rsp.arg[1] = mode | 1 << 8;
1209 cmd->rsp.arg[2] = 1 << 16;
1212 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16;
1219 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1220 struct qlcnic_vf_info *vf)
1223 struct qlcnic_vport *vp = vf->vp;
1228 if (!vf->rx_ctx_id) {
1233 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1234 vp->vlan, QLCNIC_MAC_DEL);
1236 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1241 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1242 struct qlcnic_vf_info *vf,
1243 struct qlcnic_cmd_args *cmd)
1245 struct qlcnic_vport *vp = vf->vp;
1251 if (!vf->rx_ctx_id) {
1252 vp->vlan = cmd->req.arg[1] >> 16;
1256 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1261 vp->vlan = cmd->req.arg[1] >> 16;
1262 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1263 vp->vlan, QLCNIC_MAC_ADD);
1266 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1274 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1275 struct qlcnic_cmd_args *cmd)
1277 struct qlcnic_vf_info *vf = tran->vf;
1278 struct qlcnic_adapter *adapter = vf->adapter;
1279 struct qlcnic_vport *vp = vf->vp;
1283 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1284 cmd->rsp.arg[0] |= 2 << 25;
1288 op = cmd->req.arg[1] & 0xf;
1291 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1293 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf);
1295 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1299 static const int qlcnic_pf_passthru_supp_cmds[] = {
1300 QLCNIC_CMD_GET_STATISTICS,
1301 QLCNIC_CMD_GET_PORT_CONFIG,
1302 QLCNIC_CMD_GET_LINK_STATUS,
1303 QLCNIC_CMD_DCB_QUERY_CAP,
1304 QLCNIC_CMD_DCB_QUERY_PARAM,
1305 QLCNIC_CMD_INIT_NIC_FUNC,
1306 QLCNIC_CMD_STOP_NIC_FUNC,
1309 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1310 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1311 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1312 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1313 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1316 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1317 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1318 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1319 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1320 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1321 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1322 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1323 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1324 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1325 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1326 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1327 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1328 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1329 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1330 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1331 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1334 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1335 struct qlcnic_bc_trans *trans,
1336 struct qlcnic_cmd_args *cmd)
1340 cmd_op = trans->req_hdr->cmd_op;
1342 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1343 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1344 if (cmd_op < size) {
1345 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1350 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1351 for (i = 0; i < size; i++) {
1352 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1353 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1358 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1359 for (i = 0; i < size; i++) {
1360 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1361 qlcnic_issue_cmd(adapter, cmd);
1367 cmd->rsp.arg[0] |= (0x9 << 25);
1370 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1375 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1376 adapter->ahw->pci_func);
1380 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1385 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1386 adapter->ahw->pci_func);
1387 *int_id |= vpid << 16;
1390 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1395 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1396 adapter->ahw->pci_func);
1397 *int_id |= vpid << 16;
1400 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1405 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1406 adapter->ahw->pci_func);
1407 *int_id |= vpid << 16;
1410 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1415 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1416 adapter->ahw->pci_func);
1417 *int_id |= (vpid << 16) | BIT_31;
1420 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1425 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1426 adapter->ahw->pci_func);
1427 *int_id |= (vpid << 16) | BIT_31;
1430 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1435 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1436 adapter->ahw->pci_func);
1437 *int_id |= (vpid << 16) | BIT_31;
1440 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1441 struct qlcnic_vf_info *vf)
1443 struct qlcnic_cmd_args cmd;
1449 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1452 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1454 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1455 if (qlcnic_issue_cmd(adapter, &cmd))
1456 dev_err(&adapter->pdev->dev,
1457 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1463 qlcnic_free_mbx_args(&cmd);
1466 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1467 struct qlcnic_vf_info *vf)
1469 struct qlcnic_cmd_args cmd;
1475 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1478 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1480 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1481 if (qlcnic_issue_cmd(adapter, &cmd))
1482 dev_err(&adapter->pdev->dev,
1483 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1489 qlcnic_free_mbx_args(&cmd);
1492 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1493 struct qlcnic_vf_info *vf,
1494 struct qlcnic_bc_trans *trans)
1496 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1499 spin_lock_irqsave(&t_list->lock, flag);
1501 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1503 spin_unlock_irqrestore(&t_list->lock, flag);
1507 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1509 struct qlcnic_adapter *adapter = vf->adapter;
1511 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1512 cancel_work_sync(&vf->trans_work);
1513 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1515 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1516 qlcnic_sriov_del_tx_ctx(adapter, vf);
1517 qlcnic_sriov_del_rx_ctx(adapter, vf);
1520 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1522 clear_bit(QLC_BC_VF_FLR, &vf->state);
1523 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1524 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1526 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1527 vf->flr_trans = NULL;
1531 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1533 struct qlcnic_vf_info *vf;
1535 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1536 __qlcnic_sriov_process_flr(vf);
1540 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1541 struct qlcnic_vf_info *vf,
1544 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1547 INIT_WORK(&vf->flr_work, func);
1548 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1551 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1552 struct qlcnic_bc_trans *trans,
1553 struct qlcnic_vf_info *vf)
1555 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1557 set_bit(QLC_BC_VF_FLR, &vf->state);
1558 clear_bit(QLC_BC_VF_STATE, &vf->state);
1559 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1560 vf->flr_trans = trans;
1561 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1562 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1566 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1567 struct qlcnic_bc_trans *trans,
1568 struct qlcnic_vf_info *vf)
1570 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1572 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1573 (hdr->op_type == QLC_BC_CMD) &&
1574 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1575 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1582 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1583 struct qlcnic_vf_info *vf)
1585 struct net_device *dev = vf->adapter->netdev;
1586 struct qlcnic_vport *vp = vf->vp;
1588 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1589 clear_bit(QLC_BC_VF_FLR, &vf->state);
1593 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1594 netdev_info(dev, "FLR for PCI func %d in progress\n",
1599 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1602 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1603 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1606 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1608 struct qlcnic_hardware_context *ahw = adapter->ahw;
1609 struct qlcnic_sriov *sriov = ahw->sriov;
1610 struct qlcnic_vf_info *vf;
1611 u16 num_vfs = sriov->num_vfs;
1614 for (i = 0; i < num_vfs; i++) {
1615 vf = &sriov->vf_info[i];
1618 cancel_work_sync(&vf->flr_work);
1619 __qlcnic_sriov_process_flr(vf);
1620 clear_bit(QLC_BC_VF_STATE, &vf->state);
1623 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1624 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1627 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1629 struct qlcnic_hardware_context *ahw = adapter->ahw;
1632 if (!qlcnic_sriov_enable_check(adapter))
1635 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1637 err = qlcnic_sriov_pf_init(adapter);
1641 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1642 __func__, ahw->op_mode);
1646 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1648 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1649 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1651 struct qlcnic_vf_info *vf_info;
1654 if (!qlcnic_sriov_pf_check(adapter))
1657 num_vfs = sriov->num_vfs;
1659 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1662 if (ether_addr_equal(adapter->mac_addr, mac)) {
1663 netdev_err(netdev, "MAC address is already in use by the PF\n");
1667 for (i = 0; i < num_vfs; i++) {
1668 vf_info = &sriov->vf_info[i];
1669 if (ether_addr_equal(vf_info->vp->mac, mac)) {
1671 "MAC address is already in use by VF %d\n",
1677 vf_info = &sriov->vf_info[vf];
1678 curr_mac = vf_info->vp->mac;
1680 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1682 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1687 memcpy(curr_mac, mac, netdev->addr_len);
1688 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1693 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1695 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1696 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1697 struct qlcnic_vf_info *vf_info;
1698 struct qlcnic_info nic_info;
1699 struct qlcnic_vport *vp;
1702 if (!qlcnic_sriov_pf_check(adapter))
1705 if (vf >= sriov->num_vfs)
1708 if (tx_rate >= 10000 || tx_rate < 100) {
1710 "Invalid Tx rate, allowed range is [%d - %d]",
1711 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1718 vf_info = &sriov->vf_info[vf];
1722 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1723 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1726 nic_info.max_tx_bw = tx_rate / 100;
1727 nic_info.bit_offsets = BIT_0;
1729 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1733 vp->max_tx_bw = tx_rate / 100;
1735 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1736 tx_rate, vp->max_tx_bw, vf);
1740 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1743 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1744 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1745 struct qlcnic_vf_info *vf_info;
1746 struct qlcnic_vport *vp;
1748 if (!qlcnic_sriov_pf_check(adapter))
1751 if (vf >= sriov->num_vfs || qos > 7)
1754 if (vlan > MAX_VLAN_ID) {
1756 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1761 vf_info = &sriov->vf_info[vf];
1763 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1765 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1773 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1776 vp->vlan_mode = QLC_NO_VLAN_MODE;
1781 vp->vlan_mode = QLC_PVID_MODE;
1786 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1791 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1792 struct qlcnic_vport *vp, int vf)
1796 switch (vp->vlan_mode) {
1800 case QLC_GUEST_VLAN_MODE:
1803 case QLC_NO_VLAN_MODE:
1807 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1814 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1815 int vf, struct ifla_vf_info *ivi)
1817 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1818 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1819 struct qlcnic_vport *vp;
1821 if (!qlcnic_sriov_pf_check(adapter))
1824 if (vf >= sriov->num_vfs)
1827 vp = sriov->vf_info[vf].vp;
1828 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1829 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1831 ivi->spoofchk = vp->spoofchk;
1832 if (vp->max_tx_bw == MAX_BW)
1835 ivi->tx_rate = vp->max_tx_bw * 100;
1841 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1843 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1844 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1845 struct qlcnic_vf_info *vf_info;
1846 struct qlcnic_vport *vp;
1848 if (!qlcnic_sriov_pf_check(adapter))
1851 if (vf >= sriov->num_vfs)
1854 vf_info = &sriov->vf_info[vf];
1856 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1858 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",