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_tx_ques = res->num_tx_queues / max;
79 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
80 num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC;
82 if (adapter->ahw->pci_func == func) {
83 temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs);
84 info->max_rx_ucast_mac_filters = temp;
85 temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs);
86 info->max_tx_mac_filters = temp;
88 info->max_tx_bw = MAX_BW;
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;
100 info->max_rx_ip_addr = res->num_destip / max;
101 info->max_rx_status_rings = res->num_rx_status_rings / max;
102 info->max_rx_buf_rings = res->num_rx_buf_rings / max;
103 info->max_rx_ques = res->num_rx_queues / max;
104 info->max_rx_lro_flow = res->num_lro_flows_supported / max;
105 info->max_tx_vlan_keys = res->num_txvlan_keys;
106 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
107 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
109 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
116 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
117 struct qlcnic_info *info)
119 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
121 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
122 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
123 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
124 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
125 ff_max->num_rx_queues = info->max_rx_ques;
126 ff_max->num_tx_queues = info->max_tx_ques;
127 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
128 ff_max->num_destip = info->max_rx_ip_addr;
129 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
130 ff_max->num_rx_status_rings = info->max_rx_status_rings;
131 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
132 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
135 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
136 struct qlcnic_info *npar_info)
139 struct qlcnic_cmd_args cmd;
141 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
144 cmd.req.arg[1] = 0x2;
145 err = qlcnic_issue_cmd(adapter, &cmd);
147 dev_err(&adapter->pdev->dev,
148 "Failed to get PF info, err=%d\n", err);
152 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
153 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
154 npar_info->max_vports = MSW(cmd.rsp.arg[2]);
155 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);
156 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
157 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
158 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
159 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
160 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
161 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
162 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
163 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
164 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
165 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
166 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
168 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
169 dev_info(&adapter->pdev->dev,
170 "\n\ttotal_pf: %d,\n"
171 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
172 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
173 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
174 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
175 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
176 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
177 npar_info->total_pf, npar_info->total_rss_engines,
178 npar_info->max_vports, npar_info->max_tx_ques,
179 npar_info->max_tx_mac_filters,
180 npar_info->max_rx_mcast_mac_filters,
181 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
182 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
183 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
184 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
185 npar_info->max_remote_ipv6_addrs);
188 qlcnic_free_mbx_args(&cmd);
192 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
195 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
196 struct qlcnic_vport *vp;
199 if (adapter->ahw->pci_func == func) {
200 sriov->vp_handle = 0;
202 index = qlcnic_sriov_func_to_index(adapter, func);
205 vp = sriov->vf_info[index].vp;
210 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
211 u16 vport_handle, u8 func)
213 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
214 struct qlcnic_vport *vp;
217 if (adapter->ahw->pci_func == func) {
218 sriov->vp_handle = vport_handle;
220 index = qlcnic_sriov_func_to_index(adapter, func);
223 vp = sriov->vf_info[index].vp;
224 vp->handle = vport_handle;
228 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
231 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
232 struct qlcnic_vf_info *vf_info;
235 if (adapter->ahw->pci_func == func) {
236 return sriov->vp_handle;
238 index = qlcnic_sriov_func_to_index(adapter, func);
240 vf_info = &sriov->vf_info[index];
241 return vf_info->vp->handle;
248 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
251 struct qlcnic_cmd_args cmd;
255 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
259 cmd.req.arg[3] = func << 8;
261 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
266 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
269 ret = qlcnic_issue_cmd(adapter, &cmd);
271 dev_err(&adapter->pdev->dev,
272 "Failed %s vport, err %d for func 0x%x\n",
273 (flag ? "enable" : "disable"), ret, func);
278 vpid = cmd.rsp.arg[2] & 0xffff;
279 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
281 qlcnic_sriov_pf_reset_vport_handle(adapter, func);
285 qlcnic_free_mbx_args(&cmd);
289 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
292 struct qlcnic_cmd_args cmd;
295 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
299 cmd.req.arg[1] = 0x4;
301 cmd.req.arg[1] |= BIT_16;
303 err = qlcnic_issue_cmd(adapter, &cmd);
305 dev_err(&adapter->pdev->dev,
306 "Failed to configure VLAN filtering, err=%d\n", err);
308 qlcnic_free_mbx_args(&cmd);
312 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
315 struct qlcnic_cmd_args cmd;
318 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
321 cmd.req.arg[0] |= (3 << 29);
322 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
324 cmd.req.arg[1] |= BIT_0;
326 err = qlcnic_issue_cmd(adapter, &cmd);
328 if (err != QLCNIC_RCODE_SUCCESS) {
329 dev_err(&adapter->pdev->dev,
330 "Failed to enable sriov eswitch%d\n", err);
334 qlcnic_free_mbx_args(&cmd);
338 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
340 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
341 struct qlcnic_back_channel *bc = &sriov->bc;
344 for (i = 0; i < sriov->num_vfs; i++)
345 cancel_work_sync(&sriov->vf_info[i].flr_work);
347 destroy_workqueue(bc->bc_flr_wq);
350 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
352 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
353 struct workqueue_struct *wq;
355 wq = create_singlethread_workqueue("qlcnic-flr");
357 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
365 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
367 u8 func = adapter->ahw->pci_func;
369 if (!qlcnic_sriov_enable_check(adapter))
372 qlcnic_sriov_pf_del_flr_queue(adapter);
373 qlcnic_sriov_cfg_bc_intr(adapter, 0);
374 qlcnic_sriov_pf_config_vport(adapter, 0, func);
375 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
376 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
377 __qlcnic_sriov_cleanup(adapter);
378 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
379 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
382 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
384 if (!qlcnic_sriov_pf_check(adapter))
387 if (!qlcnic_sriov_enable_check(adapter))
390 pci_disable_sriov(adapter->pdev);
391 netdev_info(adapter->netdev,
392 "SR-IOV is disabled successfully on port %d\n",
396 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
398 struct net_device *netdev = adapter->netdev;
400 if (netif_running(netdev))
401 __qlcnic_down(adapter, netdev);
403 qlcnic_sriov_pf_disable(adapter);
405 qlcnic_sriov_pf_cleanup(adapter);
407 /* After disabling SRIOV re-init the driver in default mode
408 configure opmode based on op_mode of function
410 if (qlcnic_83xx_configure_opmode(adapter))
413 if (netif_running(netdev))
414 __qlcnic_up(adapter, netdev);
419 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
421 struct qlcnic_hardware_context *ahw = adapter->ahw;
422 struct qlcnic_info nic_info, pf_info, vp_info;
424 u8 func = ahw->pci_func;
426 if (!qlcnic_sriov_enable_check(adapter))
429 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
433 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
435 goto disable_vlan_filtering;
437 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
439 goto disable_eswitch;
441 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
445 err = qlcnic_get_nic_info(adapter, &nic_info, func);
449 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
453 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
457 ahw->physical_port = (u8) nic_info.phys_port;
458 ahw->switch_mode = nic_info.switch_mode;
459 ahw->max_mtu = nic_info.max_mtu;
460 ahw->capabilities = nic_info.capabilities;
461 ahw->nic_mode = QLC_83XX_SRIOV_MODE;
465 qlcnic_sriov_pf_config_vport(adapter, 0, func);
468 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
470 disable_vlan_filtering:
471 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
476 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
480 if (!qlcnic_sriov_enable_check(adapter))
483 err = pci_enable_sriov(adapter->pdev, num_vfs);
485 qlcnic_sriov_pf_cleanup(adapter);
490 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
495 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
496 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
498 err = qlcnic_sriov_init(adapter, num_vfs);
502 err = qlcnic_sriov_pf_create_flr_queue(adapter);
506 err = qlcnic_sriov_pf_init(adapter);
510 err = qlcnic_sriov_pf_enable(adapter, num_vfs);
514 qlcnic_sriov_pf_del_flr_queue(adapter);
517 __qlcnic_sriov_cleanup(adapter);
520 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
521 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
525 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
527 struct net_device *netdev = adapter->netdev;
530 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
532 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
536 if (netif_running(netdev))
537 __qlcnic_down(adapter, netdev);
539 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
541 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
545 if (qlcnic_83xx_configure_opmode(adapter))
549 "SR-IOV is enabled successfully on port %d\n",
551 /* Return number of vfs enabled */
554 if (netif_running(netdev))
555 __qlcnic_up(adapter, netdev);
561 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
563 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
566 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
570 err = qlcnic_pci_sriov_disable(adapter);
572 err = qlcnic_pci_sriov_enable(adapter, num_vfs);
574 clear_bit(__QLCNIC_RESETTING, &adapter->state);
578 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
580 struct qlcnic_cmd_args cmd;
581 struct qlcnic_vport *vp;
585 id = qlcnic_sriov_func_to_index(adapter, func);
589 vp = adapter->ahw->sriov->vf_info[id].vp;
590 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
594 cmd.req.arg[1] = 0x3 | func << 16;
595 if (vp->spoofchk == true) {
597 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
598 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
600 cmd.req.arg[5] = mac[1] | mac[0] << 8;
603 if (vp->vlan_mode == QLC_PVID_MODE) {
604 cmd.req.arg[2] |= BIT_6;
605 cmd.req.arg[3] |= vp->vlan << 8;
608 err = qlcnic_issue_cmd(adapter, &cmd);
610 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
613 qlcnic_free_mbx_args(&cmd);
617 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
620 struct qlcnic_info defvp_info;
623 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
627 err = qlcnic_sriov_set_vf_acl(adapter, func);
634 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
635 struct qlcnic_cmd_args *cmd)
637 struct qlcnic_vf_info *vf = trans->vf;
638 struct qlcnic_vport *vp = vf->vp;
639 struct qlcnic_adapter *adapter;
640 u16 func = vf->pci_func;
643 adapter = vf->adapter;
645 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
646 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
648 err = qlcnic_sriov_set_vf_vport_info(adapter, func);
650 qlcnic_sriov_pf_config_vport(adapter, 0, func);
653 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
655 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
661 cmd->rsp.arg[0] |= (1 << 25);
663 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
664 set_bit(QLC_BC_VF_STATE, &vf->state);
666 clear_bit(QLC_BC_VF_STATE, &vf->state);
671 cmd->rsp.arg[0] |= (2 << 25);
675 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
676 struct qlcnic_vport *vp,
677 u16 func, u16 vlan, u8 op)
679 struct qlcnic_cmd_args cmd;
680 struct qlcnic_macvlan_mbx mv;
686 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN))
689 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
696 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
697 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
699 cmd.req.arg[1] = op | (1 << 8) | (3 << 6);
700 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
704 mv.mac_addr0 = addr[0];
705 mv.mac_addr1 = addr[1];
706 mv.mac_addr2 = addr[2];
707 mv.mac_addr3 = addr[3];
708 mv.mac_addr4 = addr[4];
709 mv.mac_addr5 = addr[5];
710 buf = &cmd.req.arg[2];
711 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
713 err = qlcnic_issue_cmd(adapter, &cmd);
716 dev_err(&adapter->pdev->dev,
717 "MAC-VLAN %s to CAM failed, err=%d.\n",
718 ((op == 1) ? "add " : "delete "), err);
721 qlcnic_free_mbx_args(&cmd);
725 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
727 if ((cmd->req.arg[0] >> 29) != 0x3)
733 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
734 struct qlcnic_cmd_args *cmd)
736 struct qlcnic_vf_info *vf = tran->vf;
737 struct qlcnic_adapter *adapter = vf->adapter;
738 struct qlcnic_rcv_mbx_out *mbx_out;
742 err = qlcnic_sriov_validate_create_rx_ctx(cmd);
744 cmd->rsp.arg[0] |= (0x6 << 25);
748 cmd->req.arg[6] = vf->vp->handle;
749 err = qlcnic_issue_cmd(adapter, cmd);
753 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
754 vf->rx_ctx_id = mbx_out->ctx_id;
755 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
756 vlan, QLCNIC_MAC_ADD);
764 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
765 struct qlcnic_cmd_args *cmd)
767 struct qlcnic_vf_info *vf = trans->vf;
770 type = cmd->req.arg[1];
772 case QLCNIC_SET_STATION_MAC:
773 case QLCNIC_SET_FAC_DEF_MAC:
774 cmd->rsp.arg[0] = (2 << 25);
776 case QLCNIC_GET_CURRENT_MAC:
777 cmd->rsp.arg[0] = (1 << 25);
779 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
780 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
781 ((mac[3]) << 16 & 0xff0000) |
782 ((mac[2]) << 24 & 0xff000000);
788 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
790 if ((cmd->req.arg[0] >> 29) != 0x3)
796 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
797 struct qlcnic_cmd_args *cmd)
799 struct qlcnic_vf_info *vf = trans->vf;
800 struct qlcnic_adapter *adapter = vf->adapter;
801 struct qlcnic_tx_mbx_out *mbx_out;
804 err = qlcnic_sriov_validate_create_tx_ctx(cmd);
806 cmd->rsp.arg[0] |= (0x6 << 25);
810 cmd->req.arg[5] |= vf->vp->handle << 16;
811 err = qlcnic_issue_cmd(adapter, cmd);
813 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
814 vf->tx_ctx_id = mbx_out->ctx_id;
822 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
823 struct qlcnic_cmd_args *cmd)
825 if ((cmd->req.arg[0] >> 29) != 0x3)
828 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
834 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
835 struct qlcnic_cmd_args *cmd)
837 struct qlcnic_vf_info *vf = trans->vf;
838 struct qlcnic_adapter *adapter = vf->adapter;
842 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
844 cmd->rsp.arg[0] |= (0x6 << 25);
849 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func,
850 vlan, QLCNIC_MAC_DEL);
851 cmd->req.arg[1] |= vf->vp->handle << 16;
852 err = qlcnic_issue_cmd(adapter, cmd);
860 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
861 struct qlcnic_cmd_args *cmd)
863 if ((cmd->req.arg[0] >> 29) != 0x3)
866 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
872 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
873 struct qlcnic_cmd_args *cmd)
875 struct qlcnic_vf_info *vf = trans->vf;
876 struct qlcnic_adapter *adapter = vf->adapter;
879 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
881 cmd->rsp.arg[0] |= (0x6 << 25);
885 cmd->req.arg[1] |= vf->vp->handle << 16;
886 err = qlcnic_issue_cmd(adapter, cmd);
894 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
895 struct qlcnic_cmd_args *cmd)
897 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
903 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
904 struct qlcnic_cmd_args *cmd)
906 struct qlcnic_vf_info *vf = trans->vf;
907 struct qlcnic_adapter *adapter = vf->adapter;
910 err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
912 cmd->rsp.arg[0] |= (0x6 << 25);
916 err = qlcnic_issue_cmd(adapter, cmd);
920 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
921 struct qlcnic_cmd_args *cmd)
923 struct qlcnic_vf_info *vf = trans->vf;
924 struct qlcnic_adapter *adapter = vf->adapter;
928 op = cmd->req.arg[1] & 0xff;
930 cmd->req.arg[1] |= vf->vp->handle << 16;
931 cmd->req.arg[1] |= BIT_31;
933 err = qlcnic_issue_cmd(adapter, cmd);
937 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
938 struct qlcnic_cmd_args *cmd)
940 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
943 if (!(cmd->req.arg[1] & BIT_16))
946 if ((cmd->req.arg[1] & 0xff) != 0x1)
952 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
953 struct qlcnic_cmd_args *cmd)
955 struct qlcnic_vf_info *vf = trans->vf;
956 struct qlcnic_adapter *adapter = vf->adapter;
959 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
961 cmd->rsp.arg[0] |= (0x6 << 25);
963 err = qlcnic_issue_cmd(adapter, cmd);
968 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
969 struct qlcnic_vf_info *vf,
970 struct qlcnic_cmd_args *cmd)
972 if (cmd->req.arg[1] != vf->rx_ctx_id)
975 if (cmd->req.arg[2] > adapter->ahw->max_mtu)
981 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
982 struct qlcnic_cmd_args *cmd)
984 struct qlcnic_vf_info *vf = trans->vf;
985 struct qlcnic_adapter *adapter = vf->adapter;
988 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
990 cmd->rsp.arg[0] |= (0x6 << 25);
992 err = qlcnic_issue_cmd(adapter, cmd);
997 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
998 struct qlcnic_cmd_args *cmd)
1000 if (cmd->req.arg[1] & BIT_31) {
1001 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1004 cmd->req.arg[1] |= vf->vp->handle << 16;
1010 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1011 struct qlcnic_cmd_args *cmd)
1013 struct qlcnic_vf_info *vf = trans->vf;
1014 struct qlcnic_adapter *adapter = vf->adapter;
1017 err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1019 cmd->rsp.arg[0] |= (0x6 << 25);
1023 err = qlcnic_issue_cmd(adapter, cmd);
1027 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1028 struct qlcnic_cmd_args *cmd)
1030 if (cmd->req.arg[1] != vf->rx_ctx_id)
1036 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1037 struct qlcnic_cmd_args *cmd)
1039 struct qlcnic_vf_info *vf = trans->vf;
1040 struct qlcnic_adapter *adapter = vf->adapter;
1043 err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1045 cmd->rsp.arg[0] |= (0x6 << 25);
1047 err = qlcnic_issue_cmd(adapter, cmd);
1052 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1053 struct qlcnic_vf_info *vf,
1054 struct qlcnic_cmd_args *cmd)
1056 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1057 u16 ctx_id, pkts, time;
1059 ctx_id = cmd->req.arg[1] >> 16;
1060 pkts = cmd->req.arg[2] & 0xffff;
1061 time = cmd->req.arg[2] >> 16;
1063 if (ctx_id != vf->rx_ctx_id)
1065 if (pkts > coal->rx_packets)
1067 if (time < coal->rx_time_us)
1073 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1074 struct qlcnic_cmd_args *cmd)
1076 struct qlcnic_vf_info *vf = tran->vf;
1077 struct qlcnic_adapter *adapter = vf->adapter;
1080 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1082 cmd->rsp.arg[0] |= (0x6 << 25);
1086 err = qlcnic_issue_cmd(adapter, cmd);
1090 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1091 struct qlcnic_vf_info *vf,
1092 struct qlcnic_cmd_args *cmd)
1094 struct qlcnic_macvlan_mbx *macvlan;
1095 struct qlcnic_vport *vp = vf->vp;
1098 if (!(cmd->req.arg[1] & BIT_8))
1101 cmd->req.arg[1] |= (vf->vp->handle << 16);
1102 cmd->req.arg[1] |= BIT_31;
1104 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2];
1105 if (!(macvlan->mac_addr0 & BIT_0)) {
1106 dev_err(&adapter->pdev->dev,
1107 "MAC address change is not allowed from VF %d",
1112 if (vp->vlan_mode == QLC_PVID_MODE) {
1113 op = cmd->req.arg[1] & 0x7;
1114 cmd->req.arg[1] &= ~0x7;
1115 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1116 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1117 cmd->req.arg[3] |= vp->vlan << 16;
1118 cmd->req.arg[1] |= new_op;
1124 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1125 struct qlcnic_cmd_args *cmd)
1127 struct qlcnic_vf_info *vf = trans->vf;
1128 struct qlcnic_adapter *adapter = vf->adapter;
1131 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1133 cmd->rsp.arg[0] |= (0x6 << 25);
1137 err = qlcnic_issue_cmd(adapter, cmd);
1141 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1142 struct qlcnic_cmd_args *cmd)
1144 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1150 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1151 struct qlcnic_cmd_args *cmd)
1153 struct qlcnic_vf_info *vf = trans->vf;
1154 struct qlcnic_adapter *adapter = vf->adapter;
1157 err = qlcnic_sriov_validate_linkevent(vf, cmd);
1159 cmd->rsp.arg[0] |= (0x6 << 25);
1163 err = qlcnic_issue_cmd(adapter, cmd);
1167 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1168 struct qlcnic_cmd_args *cmd)
1170 struct qlcnic_vf_info *vf = trans->vf;
1171 struct qlcnic_adapter *adapter = vf->adapter;
1174 cmd->req.arg[1] |= vf->vp->handle << 16;
1175 cmd->req.arg[1] |= BIT_31;
1176 err = qlcnic_issue_cmd(adapter, cmd);
1180 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1181 struct qlcnic_cmd_args *cmd)
1183 struct qlcnic_vf_info *vf = trans->vf;
1184 struct qlcnic_vport *vp = vf->vp;
1185 u8 cmd_op, mode = vp->vlan_mode;
1187 cmd_op = trans->req_hdr->cmd_op;
1188 cmd->rsp.arg[0] |= 1 << 25;
1191 case QLC_GUEST_VLAN_MODE:
1192 cmd->rsp.arg[1] = mode | 1 << 8;
1193 cmd->rsp.arg[2] = 1 << 16;
1196 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16;
1203 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1204 struct qlcnic_vf_info *vf)
1207 struct qlcnic_vport *vp = vf->vp;
1212 if (!vf->rx_ctx_id) {
1217 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1218 vp->vlan, QLCNIC_MAC_DEL);
1220 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1225 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1226 struct qlcnic_vf_info *vf,
1227 struct qlcnic_cmd_args *cmd)
1229 struct qlcnic_vport *vp = vf->vp;
1235 if (!vf->rx_ctx_id) {
1236 vp->vlan = cmd->req.arg[1] >> 16;
1240 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1245 vp->vlan = cmd->req.arg[1] >> 16;
1246 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1247 vp->vlan, QLCNIC_MAC_ADD);
1250 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func,
1258 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1259 struct qlcnic_cmd_args *cmd)
1261 struct qlcnic_vf_info *vf = tran->vf;
1262 struct qlcnic_adapter *adapter = vf->adapter;
1263 struct qlcnic_vport *vp = vf->vp;
1267 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1268 cmd->rsp.arg[0] |= 2 << 25;
1272 op = cmd->req.arg[1] & 0xf;
1275 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1277 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf);
1279 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1283 static const int qlcnic_pf_passthru_supp_cmds[] = {
1284 QLCNIC_CMD_GET_STATISTICS,
1285 QLCNIC_CMD_GET_PORT_CONFIG,
1286 QLCNIC_CMD_GET_LINK_STATUS,
1287 QLCNIC_CMD_DCB_QUERY_CAP,
1288 QLCNIC_CMD_DCB_QUERY_PARAM,
1289 QLCNIC_CMD_INIT_NIC_FUNC,
1290 QLCNIC_CMD_STOP_NIC_FUNC,
1293 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1294 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1295 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1296 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1297 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1300 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1301 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1302 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1303 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1304 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1305 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1306 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1307 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1308 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1309 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1310 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1311 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1312 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1313 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1314 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1315 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1318 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1319 struct qlcnic_bc_trans *trans,
1320 struct qlcnic_cmd_args *cmd)
1324 cmd_op = trans->req_hdr->cmd_op;
1326 if (trans->req_hdr->op_type == QLC_BC_CMD) {
1327 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1328 if (cmd_op < size) {
1329 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1334 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1335 for (i = 0; i < size; i++) {
1336 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1337 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1342 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1343 for (i = 0; i < size; i++) {
1344 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1345 qlcnic_issue_cmd(adapter, cmd);
1351 cmd->rsp.arg[0] |= (0x9 << 25);
1354 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1359 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1360 adapter->ahw->pci_func);
1364 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1369 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1370 adapter->ahw->pci_func);
1371 *int_id |= vpid << 16;
1374 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1379 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1380 adapter->ahw->pci_func);
1381 *int_id |= vpid << 16;
1384 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1389 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1390 adapter->ahw->pci_func);
1391 *int_id |= vpid << 16;
1394 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1399 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1400 adapter->ahw->pci_func);
1401 *int_id |= (vpid << 16) | BIT_31;
1404 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1409 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1410 adapter->ahw->pci_func);
1411 *int_id |= (vpid << 16) | BIT_31;
1414 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1419 vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1420 adapter->ahw->pci_func);
1421 *int_id |= (vpid << 16) | BIT_31;
1424 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1425 struct qlcnic_vf_info *vf)
1427 struct qlcnic_cmd_args cmd;
1433 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1436 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1438 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1439 if (qlcnic_issue_cmd(adapter, &cmd))
1440 dev_err(&adapter->pdev->dev,
1441 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1447 qlcnic_free_mbx_args(&cmd);
1450 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1451 struct qlcnic_vf_info *vf)
1453 struct qlcnic_cmd_args cmd;
1459 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1462 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1464 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1465 if (qlcnic_issue_cmd(adapter, &cmd))
1466 dev_err(&adapter->pdev->dev,
1467 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1473 qlcnic_free_mbx_args(&cmd);
1476 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1477 struct qlcnic_vf_info *vf,
1478 struct qlcnic_bc_trans *trans)
1480 struct qlcnic_trans_list *t_list = &vf->rcv_act;
1483 spin_lock_irqsave(&t_list->lock, flag);
1485 __qlcnic_sriov_add_act_list(sriov, vf, trans);
1487 spin_unlock_irqrestore(&t_list->lock, flag);
1491 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1493 struct qlcnic_adapter *adapter = vf->adapter;
1495 qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1496 cancel_work_sync(&vf->trans_work);
1497 qlcnic_sriov_cleanup_list(&vf->rcv_act);
1499 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1500 qlcnic_sriov_del_tx_ctx(adapter, vf);
1501 qlcnic_sriov_del_rx_ctx(adapter, vf);
1504 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1506 clear_bit(QLC_BC_VF_FLR, &vf->state);
1507 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1508 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1510 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1511 vf->flr_trans = NULL;
1515 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1517 struct qlcnic_vf_info *vf;
1519 vf = container_of(work, struct qlcnic_vf_info, flr_work);
1520 __qlcnic_sriov_process_flr(vf);
1524 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1525 struct qlcnic_vf_info *vf,
1528 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1531 INIT_WORK(&vf->flr_work, func);
1532 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1535 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1536 struct qlcnic_bc_trans *trans,
1537 struct qlcnic_vf_info *vf)
1539 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1541 set_bit(QLC_BC_VF_FLR, &vf->state);
1542 clear_bit(QLC_BC_VF_STATE, &vf->state);
1543 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1544 vf->flr_trans = trans;
1545 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1546 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1550 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1551 struct qlcnic_bc_trans *trans,
1552 struct qlcnic_vf_info *vf)
1554 struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1556 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1557 (hdr->op_type == QLC_BC_CMD) &&
1558 test_bit(QLC_BC_VF_STATE, &vf->state)) {
1559 qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1566 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1567 struct qlcnic_vf_info *vf)
1569 struct net_device *dev = vf->adapter->netdev;
1570 struct qlcnic_vport *vp = vf->vp;
1572 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1573 clear_bit(QLC_BC_VF_FLR, &vf->state);
1577 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1578 netdev_info(dev, "FLR for PCI func %d in progress\n",
1583 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1586 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1587 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1590 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1592 struct qlcnic_hardware_context *ahw = adapter->ahw;
1593 struct qlcnic_sriov *sriov = ahw->sriov;
1594 struct qlcnic_vf_info *vf;
1595 u16 num_vfs = sriov->num_vfs;
1598 for (i = 0; i < num_vfs; i++) {
1599 vf = &sriov->vf_info[i];
1602 cancel_work_sync(&vf->flr_work);
1603 __qlcnic_sriov_process_flr(vf);
1604 clear_bit(QLC_BC_VF_STATE, &vf->state);
1607 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1608 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1611 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1613 struct qlcnic_hardware_context *ahw = adapter->ahw;
1616 if (!qlcnic_sriov_enable_check(adapter))
1619 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1621 err = qlcnic_sriov_pf_init(adapter);
1625 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1626 __func__, ahw->op_mode);
1630 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1632 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1633 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1635 struct qlcnic_vf_info *vf_info;
1638 if (!qlcnic_sriov_pf_check(adapter))
1641 num_vfs = sriov->num_vfs;
1643 if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1646 if (!compare_ether_addr(adapter->mac_addr, mac)) {
1647 netdev_err(netdev, "MAC address is already in use by the PF\n");
1651 for (i = 0; i < num_vfs; i++) {
1652 vf_info = &sriov->vf_info[i];
1653 if (!compare_ether_addr(vf_info->vp->mac, mac)) {
1655 "MAC address is already in use by VF %d\n",
1661 vf_info = &sriov->vf_info[vf];
1662 curr_mac = vf_info->vp->mac;
1664 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1666 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1671 memcpy(curr_mac, mac, netdev->addr_len);
1672 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n",
1677 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate)
1679 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1680 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1681 struct qlcnic_vf_info *vf_info;
1682 struct qlcnic_info nic_info;
1683 struct qlcnic_vport *vp;
1686 if (!qlcnic_sriov_pf_check(adapter))
1689 if (vf >= sriov->num_vfs)
1692 if (tx_rate >= 10000 || tx_rate < 100) {
1694 "Invalid Tx rate, allowed range is [%d - %d]",
1695 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE);
1702 vf_info = &sriov->vf_info[vf];
1706 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1707 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1710 nic_info.max_tx_bw = tx_rate / 100;
1711 nic_info.bit_offsets = BIT_0;
1713 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1717 vp->max_tx_bw = tx_rate / 100;
1719 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1720 tx_rate, vp->max_tx_bw, vf);
1724 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1727 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1728 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1729 struct qlcnic_vf_info *vf_info;
1730 struct qlcnic_vport *vp;
1732 if (!qlcnic_sriov_pf_check(adapter))
1735 if (vf >= sriov->num_vfs || qos > 7)
1738 if (vlan > MAX_VLAN_ID) {
1740 "Invalid VLAN ID, allowed range is [0 - %d]\n",
1745 vf_info = &sriov->vf_info[vf];
1747 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1749 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1757 vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1760 vp->vlan_mode = QLC_NO_VLAN_MODE;
1765 vp->vlan_mode = QLC_PVID_MODE;
1770 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1775 static inline __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1776 struct qlcnic_vport *vp, int vf)
1780 switch (vp->vlan_mode) {
1784 case QLC_GUEST_VLAN_MODE:
1787 case QLC_NO_VLAN_MODE:
1791 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1798 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1799 int vf, struct ifla_vf_info *ivi)
1801 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1802 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1803 struct qlcnic_vport *vp;
1805 if (!qlcnic_sriov_pf_check(adapter))
1808 if (vf >= sriov->num_vfs)
1811 vp = sriov->vf_info[vf].vp;
1812 memcpy(&ivi->mac, vp->mac, ETH_ALEN);
1813 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
1815 ivi->spoofchk = vp->spoofchk;
1816 if (vp->max_tx_bw == MAX_BW)
1819 ivi->tx_rate = vp->max_tx_bw * 100;
1825 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
1827 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1828 struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1829 struct qlcnic_vf_info *vf_info;
1830 struct qlcnic_vport *vp;
1832 if (!qlcnic_sriov_pf_check(adapter))
1835 if (vf >= sriov->num_vfs)
1838 vf_info = &sriov->vf_info[vf];
1840 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1842 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",