Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * QLogic qlcnic NIC Driver
0004  * Copyright (c) 2009-2013 QLogic Corporation
0005  */
0006 
0007 #include <linux/types.h>
0008 
0009 #include "qlcnic_sriov.h"
0010 #include "qlcnic.h"
0011 
0012 #define QLCNIC_SRIOV_VF_MAX_MAC 7
0013 #define QLC_VF_MIN_TX_RATE  100
0014 #define QLC_VF_MAX_TX_RATE  9999
0015 #define QLC_MAC_OPCODE_MASK 0x7
0016 #define QLC_VF_FLOOD_BIT    BIT_16
0017 #define QLC_FLOOD_MODE      0x5
0018 #define QLC_SRIOV_ALLOW_VLAN0   BIT_19
0019 #define QLC_INTR_COAL_TYPE_MASK 0x7
0020 
0021 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);
0022 
0023 struct qlcnic_sriov_cmd_handler {
0024     int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
0025 };
0026 
0027 struct qlcnic_sriov_fw_cmd_handler {
0028     u32 cmd;
0029     int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);
0030 };
0031 
0032 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,
0033                       struct qlcnic_info *npar_info,
0034                       u16 vport_id)
0035 {
0036     struct qlcnic_cmd_args cmd;
0037     int err;
0038 
0039     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))
0040         return -ENOMEM;
0041 
0042     cmd.req.arg[1] = (vport_id << 16) | 0x1;
0043     cmd.req.arg[2] = npar_info->bit_offsets;
0044     cmd.req.arg[2] |= npar_info->min_tx_bw << 16;
0045     cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);
0046     cmd.req.arg[4] = npar_info->max_tx_mac_filters;
0047     cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;
0048     cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |
0049              (npar_info->max_rx_ip_addr << 16);
0050     cmd.req.arg[6] = npar_info->max_rx_lro_flow |
0051              (npar_info->max_rx_status_rings << 16);
0052     cmd.req.arg[7] = npar_info->max_rx_buf_rings |
0053              (npar_info->max_rx_ques << 16);
0054     cmd.req.arg[8] = npar_info->max_tx_vlan_keys;
0055     cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;
0056     cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;
0057 
0058     err = qlcnic_issue_cmd(adapter, &cmd);
0059     if (err)
0060         dev_err(&adapter->pdev->dev,
0061             "Failed to set vport info, err=%d\n", err);
0062 
0063     qlcnic_free_mbx_args(&cmd);
0064     return err;
0065 }
0066 
0067 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,
0068                      struct qlcnic_info *info, u16 func)
0069 {
0070     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
0071     struct qlcnic_resources *res = &sriov->ff_max;
0072     u16 num_macs = sriov->num_allowed_vlans + 1;
0073     int ret = -EIO, vpid, id;
0074     struct qlcnic_vport *vp;
0075     u32 num_vfs, max, temp;
0076 
0077     vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
0078     if (vpid < 0)
0079         return -EINVAL;
0080 
0081     num_vfs = sriov->num_vfs;
0082     max = num_vfs + 1;
0083     info->bit_offsets = 0xffff;
0084     info->max_tx_ques = res->num_tx_queues / max;
0085 
0086     if (qlcnic_83xx_pf_check(adapter))
0087         num_macs = QLCNIC_83XX_SRIOV_VF_MAX_MAC;
0088 
0089     info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;
0090 
0091     if (adapter->ahw->pci_func == func) {
0092         info->min_tx_bw = 0;
0093         info->max_tx_bw = MAX_BW;
0094 
0095         temp = res->num_rx_ucast_mac_filters - num_macs * num_vfs;
0096         info->max_rx_ucast_mac_filters = temp;
0097         temp = res->num_tx_mac_filters - num_macs * num_vfs;
0098         info->max_tx_mac_filters = temp;
0099         temp = num_macs * num_vfs * QLCNIC_SRIOV_VF_MAX_MAC;
0100         temp = res->num_rx_mcast_mac_filters - temp;
0101         info->max_rx_mcast_mac_filters = temp;
0102 
0103         info->max_tx_ques = res->num_tx_queues - sriov->num_vfs;
0104     } else {
0105         id = qlcnic_sriov_func_to_index(adapter, func);
0106         if (id < 0)
0107             return id;
0108         vp = sriov->vf_info[id].vp;
0109         info->min_tx_bw = vp->min_tx_bw;
0110         info->max_tx_bw = vp->max_tx_bw;
0111 
0112         info->max_rx_ucast_mac_filters = num_macs;
0113         info->max_tx_mac_filters = num_macs;
0114         temp = num_macs * QLCNIC_SRIOV_VF_MAX_MAC;
0115         info->max_rx_mcast_mac_filters = temp;
0116 
0117         info->max_tx_ques = QLCNIC_SINGLE_RING;
0118     }
0119 
0120     info->max_rx_ip_addr = res->num_destip / max;
0121     info->max_rx_status_rings = res->num_rx_status_rings / max;
0122     info->max_rx_buf_rings = res->num_rx_buf_rings / max;
0123     info->max_rx_ques = res->num_rx_queues / max;
0124     info->max_rx_lro_flow = res->num_lro_flows_supported / max;
0125     info->max_tx_vlan_keys = res->num_txvlan_keys;
0126     info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;
0127     info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;
0128 
0129     ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);
0130     if (ret)
0131         return ret;
0132 
0133     return 0;
0134 }
0135 
0136 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,
0137                        struct qlcnic_info *info)
0138 {
0139     struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;
0140 
0141     ff_max->num_tx_mac_filters = info->max_tx_mac_filters;
0142     ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;
0143     ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;
0144     ff_max->num_txvlan_keys = info->max_tx_vlan_keys;
0145     ff_max->num_rx_queues = info->max_rx_ques;
0146     ff_max->num_tx_queues = info->max_tx_ques;
0147     ff_max->num_lro_flows_supported = info->max_rx_lro_flow;
0148     ff_max->num_destip = info->max_rx_ip_addr;
0149     ff_max->num_rx_buf_rings = info->max_rx_buf_rings;
0150     ff_max->num_rx_status_rings = info->max_rx_status_rings;
0151     ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;
0152     ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;
0153 }
0154 
0155 static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter *adapter,
0156                      struct qlcnic_info *npar_info)
0157 {
0158     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
0159     int temp, total_fn;
0160 
0161     temp = npar_info->max_rx_mcast_mac_filters;
0162     total_fn = sriov->num_vfs + 1;
0163 
0164     temp = temp / (QLCNIC_SRIOV_VF_MAX_MAC * total_fn);
0165     sriov->num_allowed_vlans = temp - 1;
0166 
0167     if (qlcnic_83xx_pf_check(adapter))
0168         sriov->num_allowed_vlans = 1;
0169 
0170     netdev_info(adapter->netdev, "Max Guest VLANs supported per VF = %d\n",
0171             sriov->num_allowed_vlans);
0172 }
0173 
0174 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,
0175                     struct qlcnic_info *npar_info)
0176 {
0177     int err;
0178     struct qlcnic_cmd_args cmd;
0179 
0180     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))
0181         return -ENOMEM;
0182 
0183     cmd.req.arg[1] = 0x2;
0184     err = qlcnic_issue_cmd(adapter, &cmd);
0185     if (err) {
0186         dev_err(&adapter->pdev->dev,
0187             "Failed to get PF info, err=%d\n", err);
0188         goto out;
0189     }
0190 
0191     npar_info->total_pf = cmd.rsp.arg[2] & 0xff;
0192     npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;
0193     npar_info->max_vports = MSW(cmd.rsp.arg[2]);
0194     npar_info->max_tx_ques =  LSW(cmd.rsp.arg[3]);
0195     npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);
0196     npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);
0197     npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);
0198     npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);
0199     npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);
0200     npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);
0201     npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);
0202     npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);
0203     npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);
0204     npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);
0205     npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);
0206 
0207     qlcnic_sriov_set_vf_max_vlan(adapter, npar_info);
0208     qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);
0209     dev_info(&adapter->pdev->dev,
0210          "\n\ttotal_pf: %d,\n"
0211          "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"
0212          "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"
0213          "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"
0214          "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"
0215          "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"
0216          "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",
0217          npar_info->total_pf, npar_info->total_rss_engines,
0218          npar_info->max_vports, npar_info->max_tx_ques,
0219          npar_info->max_tx_mac_filters,
0220          npar_info->max_rx_mcast_mac_filters,
0221          npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,
0222          npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,
0223          npar_info->max_rx_buf_rings, npar_info->max_rx_ques,
0224          npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,
0225          npar_info->max_remote_ipv6_addrs);
0226 
0227 out:
0228     qlcnic_free_mbx_args(&cmd);
0229     return err;
0230 }
0231 
0232 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,
0233                            u8 func)
0234 {
0235     struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
0236     struct qlcnic_vport *vp;
0237     int index;
0238 
0239     if (adapter->ahw->pci_func == func) {
0240         sriov->vp_handle = 0;
0241     } else {
0242         index = qlcnic_sriov_func_to_index(adapter, func);
0243         if (index < 0)
0244             return;
0245         vp = sriov->vf_info[index].vp;
0246         vp->handle = 0;
0247     }
0248 }
0249 
0250 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,
0251                          u16 vport_handle, u8 func)
0252 {
0253     struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
0254     struct qlcnic_vport *vp;
0255     int index;
0256 
0257     if (adapter->ahw->pci_func == func) {
0258         sriov->vp_handle = vport_handle;
0259     } else {
0260         index = qlcnic_sriov_func_to_index(adapter, func);
0261         if (index < 0)
0262             return;
0263         vp = sriov->vf_info[index].vp;
0264         vp->handle = vport_handle;
0265     }
0266 }
0267 
0268 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,
0269                         u8 func)
0270 {
0271     struct qlcnic_sriov  *sriov = adapter->ahw->sriov;
0272     struct qlcnic_vf_info *vf_info;
0273     int index;
0274 
0275     if (adapter->ahw->pci_func == func) {
0276         return sriov->vp_handle;
0277     } else {
0278         index = qlcnic_sriov_func_to_index(adapter, func);
0279         if (index >= 0) {
0280             vf_info = &sriov->vf_info[index];
0281             return vf_info->vp->handle;
0282         }
0283     }
0284 
0285     return -EINVAL;
0286 }
0287 
0288 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,
0289                     u8 flag, u16 func)
0290 {
0291     struct qlcnic_cmd_args cmd;
0292     int ret;
0293     int vpid;
0294 
0295     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))
0296         return -ENOMEM;
0297 
0298     if (flag) {
0299         cmd.req.arg[3] = func << 8;
0300     } else {
0301         vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);
0302         if (vpid < 0) {
0303             ret = -EINVAL;
0304             goto out;
0305         }
0306         cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;
0307     }
0308 
0309     ret = qlcnic_issue_cmd(adapter, &cmd);
0310     if (ret) {
0311         dev_err(&adapter->pdev->dev,
0312             "Failed %s vport, err %d for func 0x%x\n",
0313             (flag ? "enable" : "disable"), ret, func);
0314         goto out;
0315     }
0316 
0317     if (flag) {
0318         vpid = cmd.rsp.arg[2] & 0xffff;
0319         qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);
0320     } else {
0321         qlcnic_sriov_pf_reset_vport_handle(adapter, func);
0322     }
0323 
0324 out:
0325     qlcnic_free_mbx_args(&cmd);
0326     return ret;
0327 }
0328 
0329 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,
0330                           u8 enable)
0331 {
0332     struct qlcnic_cmd_args cmd;
0333     int err;
0334 
0335     err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
0336     if (err)
0337         return err;
0338 
0339     cmd.req.arg[1] = 0x4;
0340     if (enable) {
0341         adapter->flags |= QLCNIC_VLAN_FILTERING;
0342         cmd.req.arg[1] |= BIT_16;
0343         if (qlcnic_84xx_check(adapter))
0344             cmd.req.arg[1] |= QLC_SRIOV_ALLOW_VLAN0;
0345     } else {
0346         adapter->flags &= ~QLCNIC_VLAN_FILTERING;
0347     }
0348 
0349     err = qlcnic_issue_cmd(adapter, &cmd);
0350     if (err)
0351         dev_err(&adapter->pdev->dev,
0352             "Failed to configure VLAN filtering, err=%d\n", err);
0353 
0354     qlcnic_free_mbx_args(&cmd);
0355     return err;
0356 }
0357 
0358 /* On configuring VF flood bit, PFD will receive traffic from all VFs */
0359 static int qlcnic_sriov_pf_cfg_flood(struct qlcnic_adapter *adapter)
0360 {
0361     struct qlcnic_cmd_args cmd;
0362     int err;
0363 
0364     err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
0365     if (err)
0366         return err;
0367 
0368     cmd.req.arg[1] = QLC_FLOOD_MODE | QLC_VF_FLOOD_BIT;
0369 
0370     err = qlcnic_issue_cmd(adapter, &cmd);
0371     if (err)
0372         dev_err(&adapter->pdev->dev,
0373             "Failed to configure VF Flood bit on PF, err=%d\n",
0374             err);
0375 
0376     qlcnic_free_mbx_args(&cmd);
0377     return err;
0378 }
0379 
0380 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,
0381                        u8 func, u8 enable)
0382 {
0383     struct qlcnic_cmd_args cmd;
0384     int err = -EIO;
0385 
0386     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))
0387         return -ENOMEM;
0388 
0389     cmd.req.arg[0] |= (3 << 29);
0390     cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;
0391     if (enable)
0392         cmd.req.arg[1] |= BIT_0;
0393 
0394     err = qlcnic_issue_cmd(adapter, &cmd);
0395 
0396     if (err != QLCNIC_RCODE_SUCCESS) {
0397         dev_err(&adapter->pdev->dev,
0398             "Failed to enable sriov eswitch%d\n", err);
0399         err = -EIO;
0400     }
0401 
0402     qlcnic_free_mbx_args(&cmd);
0403     return err;
0404 }
0405 
0406 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)
0407 {
0408     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
0409     struct qlcnic_back_channel *bc = &sriov->bc;
0410     int i;
0411 
0412     for (i = 0; i < sriov->num_vfs; i++)
0413         cancel_work_sync(&sriov->vf_info[i].flr_work);
0414 
0415     destroy_workqueue(bc->bc_flr_wq);
0416 }
0417 
0418 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)
0419 {
0420     struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;
0421     struct workqueue_struct *wq;
0422 
0423     wq = create_singlethread_workqueue("qlcnic-flr");
0424     if (wq == NULL) {
0425         dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");
0426         return -ENOMEM;
0427     }
0428 
0429     bc->bc_flr_wq =  wq;
0430     return 0;
0431 }
0432 
0433 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)
0434 {
0435     u8 func = adapter->ahw->pci_func;
0436 
0437     if (!qlcnic_sriov_enable_check(adapter))
0438         return;
0439 
0440     qlcnic_sriov_pf_del_flr_queue(adapter);
0441     qlcnic_sriov_cfg_bc_intr(adapter, 0);
0442     qlcnic_sriov_pf_config_vport(adapter, 0, func);
0443     qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
0444     qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
0445     __qlcnic_sriov_cleanup(adapter);
0446     adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
0447     clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
0448 }
0449 
0450 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)
0451 {
0452     if (!qlcnic_sriov_pf_check(adapter))
0453         return;
0454 
0455     if (!qlcnic_sriov_enable_check(adapter))
0456         return;
0457 
0458     pci_disable_sriov(adapter->pdev);
0459     netdev_info(adapter->netdev,
0460             "SR-IOV is disabled successfully on port %d\n",
0461             adapter->portnum);
0462 }
0463 
0464 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)
0465 {
0466     struct net_device *netdev = adapter->netdev;
0467 
0468     if (pci_vfs_assigned(adapter->pdev)) {
0469         netdev_err(adapter->netdev,
0470                "SR-IOV VFs belonging to port %d are assigned to VMs. SR-IOV can not be disabled on this port\n",
0471                adapter->portnum);
0472         netdev_info(adapter->netdev,
0473                 "Please detach SR-IOV VFs belonging to port %d from VMs, and then try to disable SR-IOV on this port\n",
0474                 adapter->portnum);
0475         return -EPERM;
0476     }
0477 
0478     qlcnic_sriov_pf_disable(adapter);
0479 
0480     rtnl_lock();
0481     if (netif_running(netdev))
0482         __qlcnic_down(adapter, netdev);
0483 
0484     qlcnic_sriov_free_vlans(adapter);
0485 
0486     qlcnic_sriov_pf_cleanup(adapter);
0487 
0488     /* After disabling SRIOV re-init the driver in default mode
0489        configure opmode based on op_mode of function
0490      */
0491     if (qlcnic_83xx_configure_opmode(adapter)) {
0492         rtnl_unlock();
0493         return -EIO;
0494     }
0495 
0496     if (netif_running(netdev))
0497         __qlcnic_up(adapter, netdev);
0498 
0499     rtnl_unlock();
0500     return 0;
0501 }
0502 
0503 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)
0504 {
0505     struct qlcnic_hardware_context *ahw = adapter->ahw;
0506     struct qlcnic_info nic_info, pf_info, vp_info;
0507     int err;
0508     u8 func = ahw->pci_func;
0509 
0510     if (!qlcnic_sriov_enable_check(adapter))
0511         return 0;
0512 
0513     err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);
0514     if (err)
0515         return err;
0516 
0517     if (qlcnic_84xx_check(adapter)) {
0518         err = qlcnic_sriov_pf_cfg_flood(adapter);
0519         if (err)
0520             goto disable_vlan_filtering;
0521     }
0522 
0523     err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);
0524     if (err)
0525         goto disable_vlan_filtering;
0526 
0527     err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
0528     if (err)
0529         goto disable_eswitch;
0530 
0531     err = qlcnic_sriov_get_pf_info(adapter, &pf_info);
0532     if (err)
0533         goto delete_vport;
0534 
0535     err = qlcnic_get_nic_info(adapter, &nic_info, func);
0536     if (err)
0537         goto delete_vport;
0538 
0539     err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);
0540     if (err)
0541         goto delete_vport;
0542 
0543     err = qlcnic_sriov_cfg_bc_intr(adapter, 1);
0544     if (err)
0545         goto delete_vport;
0546 
0547     ahw->physical_port = (u8) nic_info.phys_port;
0548     ahw->switch_mode = nic_info.switch_mode;
0549     ahw->max_mtu = nic_info.max_mtu;
0550     ahw->capabilities = nic_info.capabilities;
0551     ahw->nic_mode = QLC_83XX_SRIOV_MODE;
0552     return err;
0553 
0554 delete_vport:
0555     qlcnic_sriov_pf_config_vport(adapter, 0, func);
0556 
0557 disable_eswitch:
0558     qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);
0559 
0560 disable_vlan_filtering:
0561     qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);
0562 
0563     return err;
0564 }
0565 
0566 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)
0567 {
0568     int err;
0569 
0570     if (!qlcnic_sriov_enable_check(adapter))
0571         return 0;
0572 
0573     err = pci_enable_sriov(adapter->pdev, num_vfs);
0574     if (err)
0575         qlcnic_sriov_pf_cleanup(adapter);
0576 
0577     return err;
0578 }
0579 
0580 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,
0581                      int num_vfs)
0582 {
0583     int err = 0;
0584 
0585     set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
0586     adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
0587 
0588     err = qlcnic_sriov_init(adapter, num_vfs);
0589     if (err)
0590         goto clear_op_mode;
0591 
0592     err = qlcnic_sriov_pf_create_flr_queue(adapter);
0593     if (err)
0594         goto sriov_cleanup;
0595 
0596     err = qlcnic_sriov_pf_init(adapter);
0597     if (err)
0598         goto del_flr_queue;
0599 
0600     err = qlcnic_sriov_alloc_vlans(adapter);
0601     if (err)
0602         goto del_flr_queue;
0603 
0604     return err;
0605 
0606 del_flr_queue:
0607     qlcnic_sriov_pf_del_flr_queue(adapter);
0608 
0609 sriov_cleanup:
0610     __qlcnic_sriov_cleanup(adapter);
0611 
0612 clear_op_mode:
0613     clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);
0614     adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
0615     return err;
0616 }
0617 
0618 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)
0619 {
0620     struct net_device *netdev = adapter->netdev;
0621     int err;
0622 
0623     if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
0624         netdev_err(netdev,
0625                "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");
0626         return -EIO;
0627     }
0628 
0629     rtnl_lock();
0630     if (netif_running(netdev))
0631         __qlcnic_down(adapter, netdev);
0632 
0633     err = __qlcnic_pci_sriov_enable(adapter, num_vfs);
0634     if (err)
0635         goto error;
0636 
0637     if (netif_running(netdev))
0638         __qlcnic_up(adapter, netdev);
0639 
0640     rtnl_unlock();
0641     err = qlcnic_sriov_pf_enable(adapter, num_vfs);
0642     if (!err) {
0643         netdev_info(netdev,
0644                 "SR-IOV is enabled successfully on port %d\n",
0645                 adapter->portnum);
0646         /* Return number of vfs enabled */
0647         return num_vfs;
0648     }
0649 
0650     rtnl_lock();
0651     if (netif_running(netdev))
0652         __qlcnic_down(adapter, netdev);
0653 
0654 error:
0655     if (!qlcnic_83xx_configure_opmode(adapter)) {
0656         if (netif_running(netdev))
0657             __qlcnic_up(adapter, netdev);
0658     }
0659 
0660     rtnl_unlock();
0661     netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",
0662             adapter->portnum);
0663 
0664     return err;
0665 }
0666 
0667 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
0668 {
0669     struct qlcnic_adapter *adapter = pci_get_drvdata(dev);
0670     int err;
0671 
0672     if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
0673         return -EBUSY;
0674 
0675     if (num_vfs == 0)
0676         err = qlcnic_pci_sriov_disable(adapter);
0677     else
0678         err = qlcnic_pci_sriov_enable(adapter, num_vfs);
0679 
0680     clear_bit(__QLCNIC_RESETTING, &adapter->state);
0681     return err;
0682 }
0683 
0684 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)
0685 {
0686     struct qlcnic_cmd_args cmd;
0687     struct qlcnic_vport *vp;
0688     int err, id;
0689     u8 *mac;
0690 
0691     id = qlcnic_sriov_func_to_index(adapter, func);
0692     if (id < 0)
0693         return id;
0694 
0695     vp = adapter->ahw->sriov->vf_info[id].vp;
0696     err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);
0697     if (err)
0698         return err;
0699 
0700     cmd.req.arg[1] = 0x3 | func << 16;
0701     if (vp->spoofchk == true) {
0702         mac = vp->mac;
0703         cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;
0704         cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |
0705                  mac[2] << 24;
0706         cmd.req.arg[5] = mac[1] | mac[0] << 8;
0707     }
0708 
0709     if (vp->vlan_mode == QLC_PVID_MODE) {
0710         cmd.req.arg[2] |= BIT_6;
0711         cmd.req.arg[3] |= vp->pvid << 8;
0712     }
0713 
0714     err = qlcnic_issue_cmd(adapter, &cmd);
0715     if (err)
0716         dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",
0717             err);
0718 
0719     qlcnic_free_mbx_args(&cmd);
0720     return err;
0721 }
0722 
0723 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,
0724                       u16 func)
0725 {
0726     struct qlcnic_info defvp_info;
0727     int err;
0728 
0729     err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);
0730     if (err)
0731         return -EIO;
0732 
0733     err = qlcnic_sriov_set_vf_acl(adapter, func);
0734     if (err)
0735         return err;
0736 
0737     return 0;
0738 }
0739 
0740 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,
0741                        struct qlcnic_cmd_args *cmd)
0742 {
0743     struct qlcnic_vf_info *vf = trans->vf;
0744     struct qlcnic_vport *vp = vf->vp;
0745     struct qlcnic_adapter *adapter;
0746     struct qlcnic_sriov *sriov;
0747     u16 func = vf->pci_func;
0748     size_t size;
0749     int err;
0750 
0751     adapter = vf->adapter;
0752     sriov = adapter->ahw->sriov;
0753 
0754     if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {
0755         err = qlcnic_sriov_pf_config_vport(adapter, 1, func);
0756         if (!err) {
0757             err = qlcnic_sriov_set_vf_vport_info(adapter, func);
0758             if (err)
0759                 qlcnic_sriov_pf_config_vport(adapter, 0, func);
0760         }
0761     } else {
0762         if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {
0763             size = sizeof(*vf->sriov_vlans);
0764             size = size * sriov->num_allowed_vlans;
0765             memset(vf->sriov_vlans, 0, size);
0766         }
0767 
0768         err = qlcnic_sriov_pf_config_vport(adapter, 0, func);
0769     }
0770 
0771     if (err)
0772         goto err_out;
0773 
0774     cmd->rsp.arg[0] |= (1 << 25);
0775 
0776     if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)
0777         set_bit(QLC_BC_VF_STATE, &vf->state);
0778     else
0779         clear_bit(QLC_BC_VF_STATE, &vf->state);
0780 
0781     return err;
0782 
0783 err_out:
0784     cmd->rsp.arg[0] |= (2 << 25);
0785     return err;
0786 }
0787 
0788 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,
0789                        struct qlcnic_vf_info *vf,
0790                        u16 vlan, u8 op)
0791 {
0792     struct qlcnic_cmd_args *cmd;
0793     struct qlcnic_macvlan_mbx mv;
0794     struct qlcnic_vport *vp;
0795     u8 *addr;
0796     int err;
0797     u32 *buf;
0798     int vpid;
0799 
0800     vp = vf->vp;
0801 
0802     cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
0803     if (!cmd)
0804         return -ENOMEM;
0805 
0806     err = qlcnic_alloc_mbx_args(cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN);
0807     if (err)
0808         goto free_cmd;
0809 
0810     cmd->type = QLC_83XX_MBX_CMD_NO_WAIT;
0811     vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
0812     if (vpid < 0) {
0813         err = -EINVAL;
0814         goto free_args;
0815     }
0816 
0817     if (vlan)
0818         op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
0819               QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);
0820 
0821     cmd->req.arg[1] = op | (1 << 8) | (3 << 6);
0822     cmd->req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;
0823 
0824     addr = vp->mac;
0825     mv.vlan = vlan;
0826     mv.mac_addr0 = addr[0];
0827     mv.mac_addr1 = addr[1];
0828     mv.mac_addr2 = addr[2];
0829     mv.mac_addr3 = addr[3];
0830     mv.mac_addr4 = addr[4];
0831     mv.mac_addr5 = addr[5];
0832     buf = &cmd->req.arg[2];
0833     memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));
0834 
0835     err = qlcnic_issue_cmd(adapter, cmd);
0836 
0837     if (!err)
0838         return err;
0839 
0840 free_args:
0841     qlcnic_free_mbx_args(cmd);
0842 free_cmd:
0843     kfree(cmd);
0844     return err;
0845 }
0846 
0847 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)
0848 {
0849     if ((cmd->req.arg[0] >> 29) != 0x3)
0850         return -EINVAL;
0851 
0852     return 0;
0853 }
0854 
0855 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,
0856                          struct qlcnic_vf_info *vf,
0857                          int opcode)
0858 {
0859     struct qlcnic_sriov *sriov;
0860     u16 vlan;
0861     int i;
0862 
0863     sriov = adapter->ahw->sriov;
0864 
0865     spin_lock_bh(&vf->vlan_list_lock);
0866     if (vf->num_vlan) {
0867         for (i = 0; i < sriov->num_allowed_vlans; i++) {
0868             vlan = vf->sriov_vlans[i];
0869             if (vlan)
0870                 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,
0871                                 opcode);
0872         }
0873     }
0874     spin_unlock_bh(&vf->vlan_list_lock);
0875 
0876     if (vf->vp->vlan_mode != QLC_PVID_MODE) {
0877         if (qlcnic_83xx_pf_check(adapter) &&
0878             qlcnic_sriov_check_any_vlan(vf))
0879             return;
0880         qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);
0881     }
0882 }
0883 
0884 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,
0885                          struct qlcnic_cmd_args *cmd)
0886 {
0887     struct qlcnic_vf_info *vf = tran->vf;
0888     struct qlcnic_adapter *adapter = vf->adapter;
0889     struct qlcnic_rcv_mbx_out *mbx_out;
0890     int err;
0891 
0892     err = qlcnic_sriov_validate_create_rx_ctx(cmd);
0893     if (err) {
0894         cmd->rsp.arg[0] |= (0x6 << 25);
0895         return err;
0896     }
0897 
0898     cmd->req.arg[6] = vf->vp->handle;
0899     err = qlcnic_issue_cmd(adapter, cmd);
0900 
0901     if (!err) {
0902         mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];
0903         vf->rx_ctx_id = mbx_out->ctx_id;
0904         qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);
0905     } else {
0906         vf->rx_ctx_id = 0;
0907     }
0908 
0909     return err;
0910 }
0911 
0912 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,
0913                        struct qlcnic_cmd_args *cmd)
0914 {
0915     struct qlcnic_vf_info *vf = trans->vf;
0916     u8 type, *mac;
0917 
0918     type = cmd->req.arg[1];
0919     switch (type) {
0920     case QLCNIC_SET_STATION_MAC:
0921     case QLCNIC_SET_FAC_DEF_MAC:
0922         cmd->rsp.arg[0] = (2 << 25);
0923         break;
0924     case QLCNIC_GET_CURRENT_MAC:
0925         cmd->rsp.arg[0] = (1 << 25);
0926         mac = vf->vp->mac;
0927         cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);
0928         cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |
0929                   ((mac[3]) << 16 & 0xff0000) |
0930                   ((mac[2]) << 24 & 0xff000000);
0931     }
0932 
0933     return 0;
0934 }
0935 
0936 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)
0937 {
0938     if ((cmd->req.arg[0] >> 29) != 0x3)
0939         return -EINVAL;
0940 
0941     return 0;
0942 }
0943 
0944 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
0945                          struct qlcnic_cmd_args *cmd)
0946 {
0947     struct qlcnic_vf_info *vf = trans->vf;
0948     struct qlcnic_adapter *adapter = vf->adapter;
0949     struct qlcnic_tx_mbx_out *mbx_out;
0950     int err;
0951 
0952     err = qlcnic_sriov_validate_create_tx_ctx(cmd);
0953     if (err) {
0954         cmd->rsp.arg[0] |= (0x6 << 25);
0955         return err;
0956     }
0957 
0958     cmd->req.arg[5] |= vf->vp->handle << 16;
0959     err = qlcnic_issue_cmd(adapter, cmd);
0960     if (!err) {
0961         mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];
0962         vf->tx_ctx_id = mbx_out->ctx_id;
0963     } else {
0964         vf->tx_ctx_id = 0;
0965     }
0966 
0967     return err;
0968 }
0969 
0970 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,
0971                         struct qlcnic_cmd_args *cmd)
0972 {
0973     if ((cmd->req.arg[0] >> 29) != 0x3)
0974         return -EINVAL;
0975 
0976     if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)
0977         return -EINVAL;
0978 
0979     return 0;
0980 }
0981 
0982 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,
0983                       struct qlcnic_cmd_args *cmd)
0984 {
0985     struct qlcnic_vf_info *vf = trans->vf;
0986     struct qlcnic_adapter *adapter = vf->adapter;
0987     int err;
0988 
0989     err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);
0990     if (err) {
0991         cmd->rsp.arg[0] |= (0x6 << 25);
0992         return err;
0993     }
0994 
0995     qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);
0996     cmd->req.arg[1] |= vf->vp->handle << 16;
0997     err = qlcnic_issue_cmd(adapter, cmd);
0998 
0999     if (!err)
1000         vf->rx_ctx_id = 0;
1001 
1002     return err;
1003 }
1004 
1005 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf,
1006                         struct qlcnic_cmd_args *cmd)
1007 {
1008     if ((cmd->req.arg[0] >> 29) != 0x3)
1009         return -EINVAL;
1010 
1011     if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id)
1012         return -EINVAL;
1013 
1014     return 0;
1015 }
1016 
1017 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans,
1018                       struct qlcnic_cmd_args *cmd)
1019 {
1020     struct qlcnic_vf_info *vf = trans->vf;
1021     struct qlcnic_adapter *adapter = vf->adapter;
1022     int err;
1023 
1024     err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd);
1025     if (err) {
1026         cmd->rsp.arg[0] |= (0x6 << 25);
1027         return err;
1028     }
1029 
1030     cmd->req.arg[1] |= vf->vp->handle << 16;
1031     err = qlcnic_issue_cmd(adapter, cmd);
1032 
1033     if (!err)
1034         vf->tx_ctx_id = 0;
1035 
1036     return err;
1037 }
1038 
1039 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf,
1040                      struct qlcnic_cmd_args *cmd)
1041 {
1042     if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1043         return -EINVAL;
1044 
1045     return 0;
1046 }
1047 
1048 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans,
1049                        struct qlcnic_cmd_args *cmd)
1050 {
1051     struct qlcnic_vf_info *vf = trans->vf;
1052     struct qlcnic_adapter *adapter = vf->adapter;
1053     int err;
1054 
1055     err = qlcnic_sriov_validate_cfg_lro(vf, cmd);
1056     if (err) {
1057         cmd->rsp.arg[0] |= (0x6 << 25);
1058         return err;
1059     }
1060 
1061     err = qlcnic_issue_cmd(adapter, cmd);
1062     return err;
1063 }
1064 
1065 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans,
1066                       struct qlcnic_cmd_args *cmd)
1067 {
1068     struct qlcnic_vf_info *vf = trans->vf;
1069     struct qlcnic_adapter *adapter = vf->adapter;
1070     int err;
1071 
1072     cmd->req.arg[1] |= vf->vp->handle << 16;
1073     cmd->req.arg[1] |= BIT_31;
1074 
1075     err = qlcnic_issue_cmd(adapter, cmd);
1076     return err;
1077 }
1078 
1079 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf,
1080                         struct qlcnic_cmd_args *cmd)
1081 {
1082     if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func)
1083         return -EINVAL;
1084 
1085     if (!(cmd->req.arg[1] & BIT_16))
1086         return -EINVAL;
1087 
1088     if ((cmd->req.arg[1] & 0xff) != 0x1)
1089         return -EINVAL;
1090 
1091     return 0;
1092 }
1093 
1094 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans,
1095                       struct qlcnic_cmd_args *cmd)
1096 {
1097     struct qlcnic_vf_info *vf = trans->vf;
1098     struct qlcnic_adapter *adapter = vf->adapter;
1099     int err;
1100 
1101     err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd);
1102     if (err)
1103         cmd->rsp.arg[0] |= (0x6 << 25);
1104     else
1105         err = qlcnic_issue_cmd(adapter, cmd);
1106 
1107     return err;
1108 }
1109 
1110 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter,
1111                      struct qlcnic_vf_info *vf,
1112                      struct qlcnic_cmd_args *cmd)
1113 {
1114     if (cmd->req.arg[1] != vf->rx_ctx_id)
1115         return -EINVAL;
1116 
1117     if (cmd->req.arg[2] > adapter->ahw->max_mtu)
1118         return -EINVAL;
1119 
1120     return 0;
1121 }
1122 
1123 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans,
1124                        struct qlcnic_cmd_args *cmd)
1125 {
1126     struct qlcnic_vf_info *vf = trans->vf;
1127     struct qlcnic_adapter *adapter = vf->adapter;
1128     int err;
1129 
1130     err = qlcnic_sriov_validate_mtu(adapter, vf, cmd);
1131     if (err)
1132         cmd->rsp.arg[0] |= (0x6 << 25);
1133     else
1134         err = qlcnic_issue_cmd(adapter, cmd);
1135 
1136     return err;
1137 }
1138 
1139 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf,
1140                           struct qlcnic_cmd_args *cmd)
1141 {
1142     if (cmd->req.arg[1] & BIT_31) {
1143         if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func)
1144             return -EINVAL;
1145     } else {
1146         cmd->req.arg[1] |= vf->vp->handle << 16;
1147     }
1148 
1149     return 0;
1150 }
1151 
1152 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans,
1153                         struct qlcnic_cmd_args *cmd)
1154 {
1155     struct qlcnic_vf_info *vf = trans->vf;
1156     struct qlcnic_adapter *adapter = vf->adapter;
1157     int err;
1158 
1159     err = qlcnic_sriov_validate_get_nic_info(vf, cmd);
1160     if (err) {
1161         cmd->rsp.arg[0] |= (0x6 << 25);
1162         return err;
1163     }
1164 
1165     err = qlcnic_issue_cmd(adapter, cmd);
1166     return err;
1167 }
1168 
1169 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf,
1170                      struct qlcnic_cmd_args *cmd)
1171 {
1172     if (cmd->req.arg[1] != vf->rx_ctx_id)
1173         return -EINVAL;
1174 
1175     return 0;
1176 }
1177 
1178 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans,
1179                        struct qlcnic_cmd_args *cmd)
1180 {
1181     struct qlcnic_vf_info *vf = trans->vf;
1182     struct qlcnic_adapter *adapter = vf->adapter;
1183     int err;
1184 
1185     err = qlcnic_sriov_validate_cfg_rss(vf, cmd);
1186     if (err)
1187         cmd->rsp.arg[0] |= (0x6 << 25);
1188     else
1189         err = qlcnic_issue_cmd(adapter, cmd);
1190 
1191     return err;
1192 }
1193 
1194 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter,
1195                           struct qlcnic_vf_info *vf,
1196                           struct qlcnic_cmd_args *cmd)
1197 {
1198     struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal;
1199     u16 ctx_id, pkts, time;
1200     int err = -EINVAL;
1201     u8 type;
1202 
1203     type = cmd->req.arg[1] & QLC_INTR_COAL_TYPE_MASK;
1204     ctx_id = cmd->req.arg[1] >> 16;
1205     pkts = cmd->req.arg[2] & 0xffff;
1206     time = cmd->req.arg[2] >> 16;
1207 
1208     switch (type) {
1209     case QLCNIC_INTR_COAL_TYPE_RX:
1210         if (ctx_id != vf->rx_ctx_id || pkts > coal->rx_packets ||
1211             time < coal->rx_time_us)
1212             goto err_label;
1213         break;
1214     case QLCNIC_INTR_COAL_TYPE_TX:
1215         if (ctx_id != vf->tx_ctx_id || pkts > coal->tx_packets ||
1216             time < coal->tx_time_us)
1217             goto err_label;
1218         break;
1219     default:
1220         netdev_err(adapter->netdev, "Invalid coalescing type 0x%x received\n",
1221                type);
1222         return err;
1223     }
1224 
1225     return 0;
1226 
1227 err_label:
1228     netdev_err(adapter->netdev, "Expected: rx_ctx_id 0x%x rx_packets 0x%x rx_time_us 0x%x tx_ctx_id 0x%x tx_packets 0x%x tx_time_us 0x%x\n",
1229            vf->rx_ctx_id, coal->rx_packets, coal->rx_time_us,
1230            vf->tx_ctx_id, coal->tx_packets, coal->tx_time_us);
1231     netdev_err(adapter->netdev, "Received: ctx_id 0x%x packets 0x%x time_us 0x%x type 0x%x\n",
1232            ctx_id, pkts, time, type);
1233 
1234     return err;
1235 }
1236 
1237 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran,
1238                         struct qlcnic_cmd_args *cmd)
1239 {
1240     struct qlcnic_vf_info *vf = tran->vf;
1241     struct qlcnic_adapter *adapter = vf->adapter;
1242     int err;
1243 
1244     err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd);
1245     if (err) {
1246         cmd->rsp.arg[0] |= (0x6 << 25);
1247         return err;
1248     }
1249 
1250     err = qlcnic_issue_cmd(adapter, cmd);
1251     return err;
1252 }
1253 
1254 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter,
1255                          struct qlcnic_vf_info *vf,
1256                          struct qlcnic_cmd_args *cmd)
1257 {
1258     struct qlcnic_vport *vp = vf->vp;
1259     u8 op, new_op;
1260 
1261     if (!(cmd->req.arg[1] & BIT_8))
1262         return -EINVAL;
1263 
1264     cmd->req.arg[1] |= (vf->vp->handle << 16);
1265     cmd->req.arg[1] |= BIT_31;
1266 
1267     if (vp->vlan_mode == QLC_PVID_MODE) {
1268         op = cmd->req.arg[1] & 0x7;
1269         cmd->req.arg[1] &= ~0x7;
1270         new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?
1271              QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL;
1272         cmd->req.arg[3] |= vp->pvid << 16;
1273         cmd->req.arg[1] |= new_op;
1274     }
1275 
1276     return 0;
1277 }
1278 
1279 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans,
1280                        struct qlcnic_cmd_args *cmd)
1281 {
1282     struct qlcnic_vf_info *vf = trans->vf;
1283     struct qlcnic_adapter *adapter = vf->adapter;
1284     int err;
1285 
1286     err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd);
1287     if (err) {
1288         cmd->rsp.arg[0] |= (0x6 << 25);
1289         return err;
1290     }
1291 
1292     err = qlcnic_issue_cmd(adapter, cmd);
1293     return err;
1294 }
1295 
1296 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf,
1297                        struct qlcnic_cmd_args *cmd)
1298 {
1299     if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id)
1300         return -EINVAL;
1301 
1302     return 0;
1303 }
1304 
1305 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans,
1306                      struct qlcnic_cmd_args *cmd)
1307 {
1308     struct qlcnic_vf_info *vf = trans->vf;
1309     struct qlcnic_adapter *adapter = vf->adapter;
1310     int err;
1311 
1312     err = qlcnic_sriov_validate_linkevent(vf, cmd);
1313     if (err) {
1314         cmd->rsp.arg[0] |= (0x6 << 25);
1315         return err;
1316     }
1317 
1318     err = qlcnic_issue_cmd(adapter, cmd);
1319     return err;
1320 }
1321 
1322 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans,
1323                        struct qlcnic_cmd_args *cmd)
1324 {
1325     struct qlcnic_vf_info *vf = trans->vf;
1326     struct qlcnic_adapter *adapter = vf->adapter;
1327     int err;
1328 
1329     cmd->req.arg[1] |= vf->vp->handle << 16;
1330     cmd->req.arg[1] |= BIT_31;
1331     err = qlcnic_issue_cmd(adapter, cmd);
1332     return err;
1333 }
1334 
1335 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans,
1336                        struct qlcnic_cmd_args *cmd)
1337 {
1338     struct qlcnic_vf_info *vf = trans->vf;
1339     struct qlcnic_vport *vp = vf->vp;
1340     u8 mode = vp->vlan_mode;
1341     struct qlcnic_adapter *adapter;
1342     struct qlcnic_sriov *sriov;
1343 
1344     adapter = vf->adapter;
1345     sriov = adapter->ahw->sriov;
1346 
1347     cmd->rsp.arg[0] |= 1 << 25;
1348 
1349     /* For 84xx adapter in case of PVID , PFD should send vlan mode as
1350      * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response
1351      */
1352     if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE)
1353         return 0;
1354 
1355     switch (mode) {
1356     case QLC_GUEST_VLAN_MODE:
1357         cmd->rsp.arg[1] = mode | 1 << 8;
1358         cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16;
1359         break;
1360     case QLC_PVID_MODE:
1361         cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16;
1362         break;
1363     }
1364 
1365     return 0;
1366 }
1367 
1368 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter,
1369                       struct qlcnic_vf_info *vf,
1370                       struct qlcnic_cmd_args *cmd)
1371 {
1372     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1373     u16 vlan;
1374 
1375     if (!qlcnic_sriov_check_any_vlan(vf))
1376         return -EINVAL;
1377 
1378     vlan = cmd->req.arg[1] >> 16;
1379     if (!vf->rx_ctx_id) {
1380         qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1381         return 0;
1382     }
1383 
1384     qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL);
1385     qlcnic_sriov_del_vlan_id(sriov, vf, vlan);
1386 
1387     if (qlcnic_83xx_pf_check(adapter))
1388         qlcnic_sriov_cfg_vf_def_mac(adapter, vf,
1389                         0, QLCNIC_MAC_ADD);
1390     return 0;
1391 }
1392 
1393 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter,
1394                       struct qlcnic_vf_info *vf,
1395                       struct qlcnic_cmd_args *cmd)
1396 {
1397     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1398     int err = -EIO;
1399     u16 vlan;
1400 
1401     if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf))
1402         return err;
1403 
1404     vlan = cmd->req.arg[1] >> 16;
1405 
1406     if (!vf->rx_ctx_id) {
1407         qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1408         return 0;
1409     }
1410 
1411     if (qlcnic_83xx_pf_check(adapter)) {
1412         err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1413                           QLCNIC_MAC_DEL);
1414         if (err)
1415             return err;
1416     }
1417 
1418     err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD);
1419 
1420     if (err) {
1421         if (qlcnic_83xx_pf_check(adapter))
1422             qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0,
1423                             QLCNIC_MAC_ADD);
1424         return err;
1425     }
1426 
1427     qlcnic_sriov_add_vlan_id(sriov, vf, vlan);
1428     return err;
1429 }
1430 
1431 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran,
1432                           struct qlcnic_cmd_args *cmd)
1433 {
1434     struct qlcnic_vf_info  *vf = tran->vf;
1435     struct qlcnic_adapter *adapter =  vf->adapter;
1436     struct qlcnic_vport *vp = vf->vp;
1437     int err = -EIO;
1438     u8 op;
1439 
1440     if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) {
1441         cmd->rsp.arg[0] |= 2 << 25;
1442         return err;
1443     }
1444 
1445     op = cmd->req.arg[1] & 0xf;
1446 
1447     if (op)
1448         err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd);
1449     else
1450         err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd);
1451 
1452     cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25;
1453     return err;
1454 }
1455 
1456 static const int qlcnic_pf_passthru_supp_cmds[] = {
1457     QLCNIC_CMD_GET_STATISTICS,
1458     QLCNIC_CMD_GET_PORT_CONFIG,
1459     QLCNIC_CMD_GET_LINK_STATUS,
1460     QLCNIC_CMD_INIT_NIC_FUNC,
1461     QLCNIC_CMD_STOP_NIC_FUNC,
1462 };
1463 
1464 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = {
1465     [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1466     [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd},
1467     [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd},
1468     [QLCNIC_BC_CMD_CFG_GUEST_VLAN]  = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd},
1469 };
1470 
1471 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = {
1472     {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd},
1473     {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd},
1474     {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd},
1475     {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd},
1476     {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd},
1477     {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd},
1478     {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd},
1479     {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd},
1480     {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd},
1481     {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd},
1482     {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd},
1483     {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd},
1484     {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd},
1485     {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd},
1486     {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd},
1487 };
1488 
1489 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter,
1490                     struct qlcnic_bc_trans *trans,
1491                     struct qlcnic_cmd_args *cmd)
1492 {
1493     u8 size, cmd_op;
1494 
1495     cmd_op = trans->req_hdr->cmd_op;
1496 
1497     if (trans->req_hdr->op_type == QLC_BC_CMD) {
1498         size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr);
1499         if (cmd_op < size) {
1500             qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd);
1501             return;
1502         }
1503     } else {
1504         int i;
1505         size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr);
1506         for (i = 0; i < size; i++) {
1507             if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) {
1508                 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd);
1509                 return;
1510             }
1511         }
1512 
1513         size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds);
1514         for (i = 0; i < size; i++) {
1515             if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) {
1516                 qlcnic_issue_cmd(adapter, cmd);
1517                 return;
1518             }
1519         }
1520     }
1521 
1522     cmd->rsp.arg[0] |= (0x9 << 25);
1523 }
1524 
1525 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter,
1526                          u32 *int_id)
1527 {
1528     u16 vpid;
1529 
1530     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1531                         adapter->ahw->pci_func);
1532     *int_id |= vpid;
1533 }
1534 
1535 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter,
1536                        u32 *int_id)
1537 {
1538     u16 vpid;
1539 
1540     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1541                         adapter->ahw->pci_func);
1542     *int_id |= vpid << 16;
1543 }
1544 
1545 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter,
1546                           u32 *int_id)
1547 {
1548     int vpid;
1549 
1550     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1551                         adapter->ahw->pci_func);
1552     *int_id |= vpid << 16;
1553 }
1554 
1555 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter,
1556                        u32 *int_id)
1557 {
1558     u16 vpid;
1559 
1560     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1561                         adapter->ahw->pci_func);
1562     *int_id |= vpid << 16;
1563 }
1564 
1565 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter,
1566                     u32 *int_id)
1567 {
1568     u16 vpid;
1569 
1570     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1571                         adapter->ahw->pci_func);
1572     *int_id |= (vpid << 16) | BIT_31;
1573 }
1574 
1575 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter,
1576                        u32 *int_id)
1577 {
1578     u16 vpid;
1579 
1580     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1581                         adapter->ahw->pci_func);
1582     *int_id |= (vpid << 16) | BIT_31;
1583 }
1584 
1585 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter,
1586                     u32 *int_id)
1587 {
1588     u16 vpid;
1589 
1590     vpid = qlcnic_sriov_pf_get_vport_handle(adapter,
1591                         adapter->ahw->pci_func);
1592     *int_id |= (vpid << 16) | BIT_31;
1593 }
1594 
1595 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter,
1596                     struct qlcnic_vf_info *vf)
1597 {
1598     struct qlcnic_cmd_args cmd;
1599     int vpid;
1600 
1601     if (!vf->rx_ctx_id)
1602         return;
1603 
1604     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX))
1605         return;
1606 
1607     vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1608     if (vpid >= 0) {
1609         cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16;
1610         if (qlcnic_issue_cmd(adapter, &cmd))
1611             dev_err(&adapter->pdev->dev,
1612                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1613                 vf->pci_func);
1614         else
1615             vf->rx_ctx_id = 0;
1616     }
1617 
1618     qlcnic_free_mbx_args(&cmd);
1619 }
1620 
1621 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter,
1622                     struct qlcnic_vf_info *vf)
1623 {
1624     struct qlcnic_cmd_args cmd;
1625     int vpid;
1626 
1627     if (!vf->tx_ctx_id)
1628         return;
1629 
1630     if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX))
1631         return;
1632 
1633     vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);
1634     if (vpid >= 0) {
1635         cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16;
1636         if (qlcnic_issue_cmd(adapter, &cmd))
1637             dev_err(&adapter->pdev->dev,
1638                 "Failed to delete Tx ctx in firmware for func 0x%x\n",
1639                 vf->pci_func);
1640         else
1641             vf->tx_ctx_id = 0;
1642     }
1643 
1644     qlcnic_free_mbx_args(&cmd);
1645 }
1646 
1647 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov,
1648                          struct qlcnic_vf_info *vf,
1649                          struct qlcnic_bc_trans *trans)
1650 {
1651     struct qlcnic_trans_list *t_list = &vf->rcv_act;
1652     unsigned long flag;
1653 
1654     spin_lock_irqsave(&t_list->lock, flag);
1655 
1656     __qlcnic_sriov_add_act_list(sriov, vf, trans);
1657 
1658     spin_unlock_irqrestore(&t_list->lock, flag);
1659     return 0;
1660 }
1661 
1662 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf)
1663 {
1664     struct qlcnic_adapter *adapter = vf->adapter;
1665 
1666     qlcnic_sriov_cleanup_list(&vf->rcv_pend);
1667     cancel_work_sync(&vf->trans_work);
1668     qlcnic_sriov_cleanup_list(&vf->rcv_act);
1669 
1670     if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1671         qlcnic_sriov_del_tx_ctx(adapter, vf);
1672         qlcnic_sriov_del_rx_ctx(adapter, vf);
1673     }
1674 
1675     qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func);
1676 
1677     clear_bit(QLC_BC_VF_FLR, &vf->state);
1678     if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) {
1679         qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf,
1680                           vf->flr_trans);
1681         clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1682         vf->flr_trans = NULL;
1683     }
1684 }
1685 
1686 static void qlcnic_sriov_pf_process_flr(struct work_struct *work)
1687 {
1688     struct qlcnic_vf_info *vf;
1689 
1690     vf = container_of(work, struct qlcnic_vf_info, flr_work);
1691     __qlcnic_sriov_process_flr(vf);
1692     return;
1693 }
1694 
1695 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov,
1696                       struct qlcnic_vf_info *vf,
1697                       work_func_t func)
1698 {
1699     if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state))
1700         return;
1701 
1702     INIT_WORK(&vf->flr_work, func);
1703     queue_work(sriov->bc.bc_flr_wq, &vf->flr_work);
1704 }
1705 
1706 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter,
1707                      struct qlcnic_bc_trans *trans,
1708                      struct qlcnic_vf_info *vf)
1709 {
1710     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1711 
1712     set_bit(QLC_BC_VF_FLR, &vf->state);
1713     clear_bit(QLC_BC_VF_STATE, &vf->state);
1714     set_bit(QLC_BC_VF_SOFT_FLR, &vf->state);
1715     vf->flr_trans = trans;
1716     qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1717     netdev_info(adapter->netdev, "Software FLR for PCI func %d\n",
1718             vf->pci_func);
1719 }
1720 
1721 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter,
1722                  struct qlcnic_bc_trans *trans,
1723                  struct qlcnic_vf_info *vf)
1724 {
1725     struct qlcnic_bc_hdr *hdr = trans->req_hdr;
1726 
1727     if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) &&
1728         (hdr->op_type == QLC_BC_CMD) &&
1729          test_bit(QLC_BC_VF_STATE, &vf->state)) {
1730         qlcnic_sriov_handle_soft_flr(adapter, trans, vf);
1731         return true;
1732     }
1733 
1734     return false;
1735 }
1736 
1737 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov,
1738                 struct qlcnic_vf_info *vf)
1739 {
1740     struct net_device *dev = vf->adapter->netdev;
1741     struct qlcnic_vport *vp = vf->vp;
1742 
1743     if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) {
1744         clear_bit(QLC_BC_VF_FLR, &vf->state);
1745         return;
1746     }
1747 
1748     if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) {
1749         netdev_info(dev, "FLR for PCI func %d in progress\n",
1750                 vf->pci_func);
1751         return;
1752     }
1753 
1754     if (vp->vlan_mode == QLC_GUEST_VLAN_MODE)
1755         memset(vf->sriov_vlans, 0,
1756                sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans);
1757 
1758     qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr);
1759     netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func);
1760 }
1761 
1762 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter)
1763 {
1764     struct qlcnic_hardware_context *ahw = adapter->ahw;
1765     struct qlcnic_sriov *sriov = ahw->sriov;
1766     struct qlcnic_vf_info *vf;
1767     u16 num_vfs = sriov->num_vfs;
1768     int i;
1769 
1770     for (i = 0; i < num_vfs; i++) {
1771         vf = &sriov->vf_info[i];
1772         vf->rx_ctx_id = 0;
1773         vf->tx_ctx_id = 0;
1774         cancel_work_sync(&vf->flr_work);
1775         __qlcnic_sriov_process_flr(vf);
1776         clear_bit(QLC_BC_VF_STATE, &vf->state);
1777     }
1778 
1779     qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func);
1780     QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8);
1781 }
1782 
1783 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter)
1784 {
1785     struct qlcnic_hardware_context *ahw = adapter->ahw;
1786     int err;
1787 
1788     if (!qlcnic_sriov_enable_check(adapter))
1789         return 0;
1790 
1791     ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;
1792 
1793     err = qlcnic_sriov_pf_init(adapter);
1794     if (err)
1795         return err;
1796 
1797     dev_info(&adapter->pdev->dev, "%s: op_mode %d\n",
1798          __func__, ahw->op_mode);
1799     return err;
1800 }
1801 
1802 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1803 {
1804     struct qlcnic_adapter *adapter = netdev_priv(netdev);
1805     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1806     int i, num_vfs;
1807     struct qlcnic_vf_info *vf_info;
1808     u8 *curr_mac;
1809 
1810     if (!qlcnic_sriov_pf_check(adapter))
1811         return -EOPNOTSUPP;
1812 
1813     num_vfs = sriov->num_vfs;
1814 
1815     if (!is_valid_ether_addr(mac) || vf >= num_vfs)
1816         return -EINVAL;
1817 
1818     if (ether_addr_equal(adapter->mac_addr, mac)) {
1819         netdev_err(netdev, "MAC address is already in use by the PF\n");
1820         return -EINVAL;
1821     }
1822 
1823     for (i = 0; i < num_vfs; i++) {
1824         vf_info = &sriov->vf_info[i];
1825         if (ether_addr_equal(vf_info->vp->mac, mac)) {
1826             netdev_err(netdev,
1827                    "MAC address is already in use by VF %d\n",
1828                    i);
1829             return -EINVAL;
1830         }
1831     }
1832 
1833     vf_info = &sriov->vf_info[vf];
1834     curr_mac = vf_info->vp->mac;
1835 
1836     if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1837         netdev_err(netdev,
1838                "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1839                vf);
1840         return -EOPNOTSUPP;
1841     }
1842 
1843     memcpy(curr_mac, mac, netdev->addr_len);
1844     netdev_info(netdev, "MAC Address %pM  is configured for VF %d\n",
1845             mac, vf);
1846     return 0;
1847 }
1848 
1849 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf,
1850                 int min_tx_rate, int max_tx_rate)
1851 {
1852     struct qlcnic_adapter *adapter = netdev_priv(netdev);
1853     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1854     struct qlcnic_vf_info *vf_info;
1855     struct qlcnic_info nic_info;
1856     struct qlcnic_vport *vp;
1857     u16 vpid;
1858 
1859     if (!qlcnic_sriov_pf_check(adapter))
1860         return -EOPNOTSUPP;
1861 
1862     if (vf >= sriov->num_vfs)
1863         return -EINVAL;
1864 
1865     vf_info = &sriov->vf_info[vf];
1866     vp = vf_info->vp;
1867     vpid = vp->handle;
1868 
1869     if (!min_tx_rate)
1870         min_tx_rate = QLC_VF_MIN_TX_RATE;
1871 
1872     if (max_tx_rate && max_tx_rate >= 10000) {
1873         netdev_err(netdev,
1874                "Invalid max Tx rate, allowed range is [%d - %d]",
1875                min_tx_rate, QLC_VF_MAX_TX_RATE);
1876         return -EINVAL;
1877     }
1878 
1879     if (!max_tx_rate)
1880         max_tx_rate = 10000;
1881 
1882     if (min_tx_rate && min_tx_rate < QLC_VF_MIN_TX_RATE) {
1883         netdev_err(netdev,
1884                "Invalid min Tx rate, allowed range is [%d - %d]",
1885                QLC_VF_MIN_TX_RATE, max_tx_rate);
1886         return -EINVAL;
1887     }
1888 
1889     if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1890         if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid))
1891             return -EIO;
1892 
1893         nic_info.max_tx_bw = max_tx_rate / 100;
1894         nic_info.min_tx_bw = min_tx_rate / 100;
1895         nic_info.bit_offsets = BIT_0;
1896 
1897         if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid))
1898             return -EIO;
1899     }
1900 
1901     vp->max_tx_bw = max_tx_rate / 100;
1902     netdev_info(netdev,
1903             "Setting Max Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1904             max_tx_rate, vp->max_tx_bw, vf);
1905     vp->min_tx_bw = min_tx_rate / 100;
1906     netdev_info(netdev,
1907             "Setting Min Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n",
1908             min_tx_rate, vp->min_tx_bw, vf);
1909     return 0;
1910 }
1911 
1912 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf,
1913                  u16 vlan, u8 qos, __be16 vlan_proto)
1914 {
1915     struct qlcnic_adapter *adapter = netdev_priv(netdev);
1916     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1917     struct qlcnic_vf_info *vf_info;
1918     struct qlcnic_vport *vp;
1919 
1920     if (!qlcnic_sriov_pf_check(adapter))
1921         return -EOPNOTSUPP;
1922 
1923     if (vf >= sriov->num_vfs || qos > 7)
1924         return -EINVAL;
1925 
1926     if (vlan_proto != htons(ETH_P_8021Q))
1927         return -EPROTONOSUPPORT;
1928 
1929     if (vlan > MAX_VLAN_ID) {
1930         netdev_err(netdev,
1931                "Invalid VLAN ID, allowed range is [0 - %d]\n",
1932                MAX_VLAN_ID);
1933         return -EINVAL;
1934     }
1935 
1936     vf_info = &sriov->vf_info[vf];
1937     vp = vf_info->vp;
1938     if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
1939         netdev_err(netdev,
1940                "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
1941                vf);
1942         return -EOPNOTSUPP;
1943     }
1944 
1945     memset(vf_info->sriov_vlans, 0,
1946            sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans);
1947 
1948     switch (vlan) {
1949     case 4095:
1950         vp->vlan_mode = QLC_GUEST_VLAN_MODE;
1951         break;
1952     case 0:
1953         vp->vlan_mode = QLC_NO_VLAN_MODE;
1954         vp->qos = 0;
1955         break;
1956     default:
1957         vp->vlan_mode = QLC_PVID_MODE;
1958         qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan);
1959         vp->qos = qos;
1960         vp->pvid = vlan;
1961     }
1962 
1963     netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n",
1964             vlan, qos, vf);
1965     return 0;
1966 }
1967 
1968 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter,
1969                       struct qlcnic_vport *vp, int vf)
1970 {
1971     __u32 vlan = 0;
1972 
1973     switch (vp->vlan_mode) {
1974     case QLC_PVID_MODE:
1975         vlan = vp->pvid;
1976         break;
1977     case QLC_GUEST_VLAN_MODE:
1978         vlan = MAX_VLAN_ID;
1979         break;
1980     case QLC_NO_VLAN_MODE:
1981         vlan = 0;
1982         break;
1983     default:
1984         netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n",
1985                 vp->vlan_mode, vf);
1986     }
1987 
1988     return vlan;
1989 }
1990 
1991 int qlcnic_sriov_get_vf_config(struct net_device *netdev,
1992                    int vf, struct ifla_vf_info *ivi)
1993 {
1994     struct qlcnic_adapter *adapter = netdev_priv(netdev);
1995     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
1996     struct qlcnic_vport *vp;
1997 
1998     if (!qlcnic_sriov_pf_check(adapter))
1999         return -EOPNOTSUPP;
2000 
2001     if (vf >= sriov->num_vfs)
2002         return -EINVAL;
2003 
2004     vp = sriov->vf_info[vf].vp;
2005     memcpy(&ivi->mac, vp->mac, ETH_ALEN);
2006     ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf);
2007     ivi->qos = vp->qos;
2008     ivi->spoofchk = vp->spoofchk;
2009     if (vp->max_tx_bw == MAX_BW)
2010         ivi->max_tx_rate = 0;
2011     else
2012         ivi->max_tx_rate = vp->max_tx_bw * 100;
2013     if (vp->min_tx_bw == MIN_BW)
2014         ivi->min_tx_rate = 0;
2015     else
2016         ivi->min_tx_rate = vp->min_tx_bw * 100;
2017 
2018     ivi->vf = vf;
2019     return 0;
2020 }
2021 
2022 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk)
2023 {
2024     struct qlcnic_adapter *adapter = netdev_priv(netdev);
2025     struct qlcnic_sriov *sriov = adapter->ahw->sriov;
2026     struct qlcnic_vf_info *vf_info;
2027     struct qlcnic_vport *vp;
2028 
2029     if (!qlcnic_sriov_pf_check(adapter))
2030         return -EOPNOTSUPP;
2031 
2032     if (vf >= sriov->num_vfs)
2033         return -EINVAL;
2034 
2035     vf_info = &sriov->vf_info[vf];
2036     vp = vf_info->vp;
2037     if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) {
2038         netdev_err(netdev,
2039                "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n",
2040                vf);
2041         return -EOPNOTSUPP;
2042     }
2043 
2044     vp->spoofchk = chk;
2045     return 0;
2046 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!