2047 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * QLogic qlcnic NIC Driver4 * Copyright (c) 2009-2013 QLogic Corporation5 */6 7#include <linux/types.h>8 9#include "qlcnic_sriov.h"10#include "qlcnic.h"11 12#define QLCNIC_SRIOV_VF_MAX_MAC 713#define QLC_VF_MIN_TX_RATE 10014#define QLC_VF_MAX_TX_RATE 999915#define QLC_MAC_OPCODE_MASK 0x716#define QLC_VF_FLOOD_BIT BIT_1617#define QLC_FLOOD_MODE 0x518#define QLC_SRIOV_ALLOW_VLAN0 BIT_1919#define QLC_INTR_COAL_TYPE_MASK 0x720 21static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8);22 23struct qlcnic_sriov_cmd_handler {24 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);25};26 27struct qlcnic_sriov_fw_cmd_handler {28 u32 cmd;29 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *);30};31 32static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter,33 struct qlcnic_info *npar_info,34 u16 vport_id)35{36 struct qlcnic_cmd_args cmd;37 int err;38 39 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO))40 return -ENOMEM;41 42 cmd.req.arg[1] = (vport_id << 16) | 0x1;43 cmd.req.arg[2] = npar_info->bit_offsets;44 cmd.req.arg[2] |= npar_info->min_tx_bw << 16;45 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16);46 cmd.req.arg[4] = npar_info->max_tx_mac_filters;47 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16;48 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters |49 (npar_info->max_rx_ip_addr << 16);50 cmd.req.arg[6] = npar_info->max_rx_lro_flow |51 (npar_info->max_rx_status_rings << 16);52 cmd.req.arg[7] = npar_info->max_rx_buf_rings |53 (npar_info->max_rx_ques << 16);54 cmd.req.arg[8] = npar_info->max_tx_vlan_keys;55 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16;56 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs;57 58 err = qlcnic_issue_cmd(adapter, &cmd);59 if (err)60 dev_err(&adapter->pdev->dev,61 "Failed to set vport info, err=%d\n", err);62 63 qlcnic_free_mbx_args(&cmd);64 return err;65}66 67static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter,68 struct qlcnic_info *info, u16 func)69{70 struct qlcnic_sriov *sriov = adapter->ahw->sriov;71 struct qlcnic_resources *res = &sriov->ff_max;72 u16 num_macs = sriov->num_allowed_vlans + 1;73 int ret = -EIO, vpid, id;74 struct qlcnic_vport *vp;75 u32 num_vfs, max, temp;76 77 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);78 if (vpid < 0)79 return -EINVAL;80 81 num_vfs = sriov->num_vfs;82 max = num_vfs + 1;83 info->bit_offsets = 0xffff;84 info->max_tx_ques = res->num_tx_queues / max;85 86 if (qlcnic_83xx_pf_check(adapter))87 num_macs = QLCNIC_83XX_SRIOV_VF_MAX_MAC;88 89 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters;90 91 if (adapter->ahw->pci_func == func) {92 info->min_tx_bw = 0;93 info->max_tx_bw = MAX_BW;94 95 temp = res->num_rx_ucast_mac_filters - num_macs * num_vfs;96 info->max_rx_ucast_mac_filters = temp;97 temp = res->num_tx_mac_filters - num_macs * num_vfs;98 info->max_tx_mac_filters = temp;99 temp = num_macs * num_vfs * QLCNIC_SRIOV_VF_MAX_MAC;100 temp = res->num_rx_mcast_mac_filters - temp;101 info->max_rx_mcast_mac_filters = temp;102 103 info->max_tx_ques = res->num_tx_queues - sriov->num_vfs;104 } else {105 id = qlcnic_sriov_func_to_index(adapter, func);106 if (id < 0)107 return id;108 vp = sriov->vf_info[id].vp;109 info->min_tx_bw = vp->min_tx_bw;110 info->max_tx_bw = vp->max_tx_bw;111 112 info->max_rx_ucast_mac_filters = num_macs;113 info->max_tx_mac_filters = num_macs;114 temp = num_macs * QLCNIC_SRIOV_VF_MAX_MAC;115 info->max_rx_mcast_mac_filters = temp;116 117 info->max_tx_ques = QLCNIC_SINGLE_RING;118 }119 120 info->max_rx_ip_addr = res->num_destip / max;121 info->max_rx_status_rings = res->num_rx_status_rings / max;122 info->max_rx_buf_rings = res->num_rx_buf_rings / max;123 info->max_rx_ques = res->num_rx_queues / max;124 info->max_rx_lro_flow = res->num_lro_flows_supported / max;125 info->max_tx_vlan_keys = res->num_txvlan_keys;126 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs;127 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs;128 129 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid);130 if (ret)131 return ret;132 133 return 0;134}135 136static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter,137 struct qlcnic_info *info)138{139 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max;140 141 ff_max->num_tx_mac_filters = info->max_tx_mac_filters;142 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters;143 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters;144 ff_max->num_txvlan_keys = info->max_tx_vlan_keys;145 ff_max->num_rx_queues = info->max_rx_ques;146 ff_max->num_tx_queues = info->max_tx_ques;147 ff_max->num_lro_flows_supported = info->max_rx_lro_flow;148 ff_max->num_destip = info->max_rx_ip_addr;149 ff_max->num_rx_buf_rings = info->max_rx_buf_rings;150 ff_max->num_rx_status_rings = info->max_rx_status_rings;151 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs;152 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs;153}154 155static void qlcnic_sriov_set_vf_max_vlan(struct qlcnic_adapter *adapter,156 struct qlcnic_info *npar_info)157{158 struct qlcnic_sriov *sriov = adapter->ahw->sriov;159 int temp, total_fn;160 161 temp = npar_info->max_rx_mcast_mac_filters;162 total_fn = sriov->num_vfs + 1;163 164 temp = temp / (QLCNIC_SRIOV_VF_MAX_MAC * total_fn);165 sriov->num_allowed_vlans = temp - 1;166 167 if (qlcnic_83xx_pf_check(adapter))168 sriov->num_allowed_vlans = 1;169 170 netdev_info(adapter->netdev, "Max Guest VLANs supported per VF = %d\n",171 sriov->num_allowed_vlans);172}173 174static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter,175 struct qlcnic_info *npar_info)176{177 int err;178 struct qlcnic_cmd_args cmd;179 180 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO))181 return -ENOMEM;182 183 cmd.req.arg[1] = 0x2;184 err = qlcnic_issue_cmd(adapter, &cmd);185 if (err) {186 dev_err(&adapter->pdev->dev,187 "Failed to get PF info, err=%d\n", err);188 goto out;189 }190 191 npar_info->total_pf = cmd.rsp.arg[2] & 0xff;192 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff;193 npar_info->max_vports = MSW(cmd.rsp.arg[2]);194 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]);195 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]);196 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]);197 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]);198 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]);199 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]);200 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]);201 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]);202 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]);203 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]);204 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]);205 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]);206 207 qlcnic_sriov_set_vf_max_vlan(adapter, npar_info);208 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info);209 dev_info(&adapter->pdev->dev,210 "\n\ttotal_pf: %d,\n"211 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n"212 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n"213 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n"214 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n"215 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n"216 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n",217 npar_info->total_pf, npar_info->total_rss_engines,218 npar_info->max_vports, npar_info->max_tx_ques,219 npar_info->max_tx_mac_filters,220 npar_info->max_rx_mcast_mac_filters,221 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr,222 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings,223 npar_info->max_rx_buf_rings, npar_info->max_rx_ques,224 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs,225 npar_info->max_remote_ipv6_addrs);226 227out:228 qlcnic_free_mbx_args(&cmd);229 return err;230}231 232static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter,233 u8 func)234{235 struct qlcnic_sriov *sriov = adapter->ahw->sriov;236 struct qlcnic_vport *vp;237 int index;238 239 if (adapter->ahw->pci_func == func) {240 sriov->vp_handle = 0;241 } else {242 index = qlcnic_sriov_func_to_index(adapter, func);243 if (index < 0)244 return;245 vp = sriov->vf_info[index].vp;246 vp->handle = 0;247 }248}249 250static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter,251 u16 vport_handle, u8 func)252{253 struct qlcnic_sriov *sriov = adapter->ahw->sriov;254 struct qlcnic_vport *vp;255 int index;256 257 if (adapter->ahw->pci_func == func) {258 sriov->vp_handle = vport_handle;259 } else {260 index = qlcnic_sriov_func_to_index(adapter, func);261 if (index < 0)262 return;263 vp = sriov->vf_info[index].vp;264 vp->handle = vport_handle;265 }266}267 268static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter,269 u8 func)270{271 struct qlcnic_sriov *sriov = adapter->ahw->sriov;272 struct qlcnic_vf_info *vf_info;273 int index;274 275 if (adapter->ahw->pci_func == func) {276 return sriov->vp_handle;277 } else {278 index = qlcnic_sriov_func_to_index(adapter, func);279 if (index >= 0) {280 vf_info = &sriov->vf_info[index];281 return vf_info->vp->handle;282 }283 }284 285 return -EINVAL;286}287 288static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter,289 u8 flag, u16 func)290{291 struct qlcnic_cmd_args cmd;292 int ret;293 int vpid;294 295 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT))296 return -ENOMEM;297 298 if (flag) {299 cmd.req.arg[3] = func << 8;300 } else {301 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func);302 if (vpid < 0) {303 ret = -EINVAL;304 goto out;305 }306 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1;307 }308 309 ret = qlcnic_issue_cmd(adapter, &cmd);310 if (ret) {311 dev_err(&adapter->pdev->dev,312 "Failed %s vport, err %d for func 0x%x\n",313 (flag ? "enable" : "disable"), ret, func);314 goto out;315 }316 317 if (flag) {318 vpid = cmd.rsp.arg[2] & 0xffff;319 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func);320 } else {321 qlcnic_sriov_pf_reset_vport_handle(adapter, func);322 }323 324out:325 qlcnic_free_mbx_args(&cmd);326 return ret;327}328 329static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter,330 u8 enable)331{332 struct qlcnic_cmd_args cmd;333 int err;334 335 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);336 if (err)337 return err;338 339 cmd.req.arg[1] = 0x4;340 if (enable) {341 adapter->flags |= QLCNIC_VLAN_FILTERING;342 cmd.req.arg[1] |= BIT_16;343 if (qlcnic_84xx_check(adapter))344 cmd.req.arg[1] |= QLC_SRIOV_ALLOW_VLAN0;345 } else {346 adapter->flags &= ~QLCNIC_VLAN_FILTERING;347 }348 349 err = qlcnic_issue_cmd(adapter, &cmd);350 if (err)351 dev_err(&adapter->pdev->dev,352 "Failed to configure VLAN filtering, err=%d\n", err);353 354 qlcnic_free_mbx_args(&cmd);355 return err;356}357 358/* On configuring VF flood bit, PFD will receive traffic from all VFs */359static int qlcnic_sriov_pf_cfg_flood(struct qlcnic_adapter *adapter)360{361 struct qlcnic_cmd_args cmd;362 int err;363 364 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);365 if (err)366 return err;367 368 cmd.req.arg[1] = QLC_FLOOD_MODE | QLC_VF_FLOOD_BIT;369 370 err = qlcnic_issue_cmd(adapter, &cmd);371 if (err)372 dev_err(&adapter->pdev->dev,373 "Failed to configure VF Flood bit on PF, err=%d\n",374 err);375 376 qlcnic_free_mbx_args(&cmd);377 return err;378}379 380static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter,381 u8 func, u8 enable)382{383 struct qlcnic_cmd_args cmd;384 int err = -EIO;385 386 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH))387 return -ENOMEM;388 389 cmd.req.arg[0] |= (3 << 29);390 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1;391 if (enable)392 cmd.req.arg[1] |= BIT_0;393 394 err = qlcnic_issue_cmd(adapter, &cmd);395 396 if (err != QLCNIC_RCODE_SUCCESS) {397 dev_err(&adapter->pdev->dev,398 "Failed to enable sriov eswitch%d\n", err);399 err = -EIO;400 }401 402 qlcnic_free_mbx_args(&cmd);403 return err;404}405 406static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter)407{408 struct qlcnic_sriov *sriov = adapter->ahw->sriov;409 struct qlcnic_back_channel *bc = &sriov->bc;410 int i;411 412 for (i = 0; i < sriov->num_vfs; i++)413 cancel_work_sync(&sriov->vf_info[i].flr_work);414 415 destroy_workqueue(bc->bc_flr_wq);416}417 418static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter)419{420 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc;421 struct workqueue_struct *wq;422 423 wq = create_singlethread_workqueue("qlcnic-flr");424 if (wq == NULL) {425 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n");426 return -ENOMEM;427 }428 429 bc->bc_flr_wq = wq;430 return 0;431}432 433void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter)434{435 u8 func = adapter->ahw->pci_func;436 437 if (!qlcnic_sriov_enable_check(adapter))438 return;439 440 qlcnic_sriov_pf_del_flr_queue(adapter);441 qlcnic_sriov_cfg_bc_intr(adapter, 0);442 qlcnic_sriov_pf_config_vport(adapter, 0, func);443 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);444 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);445 __qlcnic_sriov_cleanup(adapter);446 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;447 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);448}449 450void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter)451{452 if (!qlcnic_sriov_pf_check(adapter))453 return;454 455 if (!qlcnic_sriov_enable_check(adapter))456 return;457 458 pci_disable_sriov(adapter->pdev);459 netdev_info(adapter->netdev,460 "SR-IOV is disabled successfully on port %d\n",461 adapter->portnum);462}463 464static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter)465{466 struct net_device *netdev = adapter->netdev;467 468 if (pci_vfs_assigned(adapter->pdev)) {469 netdev_err(adapter->netdev,470 "SR-IOV VFs belonging to port %d are assigned to VMs. SR-IOV can not be disabled on this port\n",471 adapter->portnum);472 netdev_info(adapter->netdev,473 "Please detach SR-IOV VFs belonging to port %d from VMs, and then try to disable SR-IOV on this port\n",474 adapter->portnum);475 return -EPERM;476 }477 478 qlcnic_sriov_pf_disable(adapter);479 480 rtnl_lock();481 if (netif_running(netdev))482 __qlcnic_down(adapter, netdev);483 484 qlcnic_sriov_free_vlans(adapter);485 486 qlcnic_sriov_pf_cleanup(adapter);487 488 /* After disabling SRIOV re-init the driver in default mode489 configure opmode based on op_mode of function490 */491 if (qlcnic_83xx_configure_opmode(adapter)) {492 rtnl_unlock();493 return -EIO;494 }495 496 if (netif_running(netdev))497 __qlcnic_up(adapter, netdev);498 499 rtnl_unlock();500 return 0;501}502 503static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter)504{505 struct qlcnic_hardware_context *ahw = adapter->ahw;506 struct qlcnic_info nic_info, pf_info, vp_info;507 int err;508 u8 func = ahw->pci_func;509 510 if (!qlcnic_sriov_enable_check(adapter))511 return 0;512 513 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1);514 if (err)515 return err;516 517 if (qlcnic_84xx_check(adapter)) {518 err = qlcnic_sriov_pf_cfg_flood(adapter);519 if (err)520 goto disable_vlan_filtering;521 }522 523 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1);524 if (err)525 goto disable_vlan_filtering;526 527 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);528 if (err)529 goto disable_eswitch;530 531 err = qlcnic_sriov_get_pf_info(adapter, &pf_info);532 if (err)533 goto delete_vport;534 535 err = qlcnic_get_nic_info(adapter, &nic_info, func);536 if (err)537 goto delete_vport;538 539 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func);540 if (err)541 goto delete_vport;542 543 err = qlcnic_sriov_cfg_bc_intr(adapter, 1);544 if (err)545 goto delete_vport;546 547 ahw->physical_port = (u8) nic_info.phys_port;548 ahw->switch_mode = nic_info.switch_mode;549 ahw->max_mtu = nic_info.max_mtu;550 ahw->capabilities = nic_info.capabilities;551 ahw->nic_mode = QLC_83XX_SRIOV_MODE;552 return err;553 554delete_vport:555 qlcnic_sriov_pf_config_vport(adapter, 0, func);556 557disable_eswitch:558 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0);559 560disable_vlan_filtering:561 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0);562 563 return err;564}565 566static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs)567{568 int err;569 570 if (!qlcnic_sriov_enable_check(adapter))571 return 0;572 573 err = pci_enable_sriov(adapter->pdev, num_vfs);574 if (err)575 qlcnic_sriov_pf_cleanup(adapter);576 577 return err;578}579 580static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter,581 int num_vfs)582{583 int err = 0;584 585 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);586 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC;587 588 err = qlcnic_sriov_init(adapter, num_vfs);589 if (err)590 goto clear_op_mode;591 592 err = qlcnic_sriov_pf_create_flr_queue(adapter);593 if (err)594 goto sriov_cleanup;595 596 err = qlcnic_sriov_pf_init(adapter);597 if (err)598 goto del_flr_queue;599 600 err = qlcnic_sriov_alloc_vlans(adapter);601 if (err)602 goto del_flr_queue;603 604 return err;605 606del_flr_queue:607 qlcnic_sriov_pf_del_flr_queue(adapter);608 609sriov_cleanup:610 __qlcnic_sriov_cleanup(adapter);611 612clear_op_mode:613 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state);614 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;615 return err;616}617 618static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs)619{620 struct net_device *netdev = adapter->netdev;621 int err;622 623 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {624 netdev_err(netdev,625 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n");626 return -EIO;627 }628 629 rtnl_lock();630 if (netif_running(netdev))631 __qlcnic_down(adapter, netdev);632 633 err = __qlcnic_pci_sriov_enable(adapter, num_vfs);634 if (err)635 goto error;636 637 if (netif_running(netdev))638 __qlcnic_up(adapter, netdev);639 640 rtnl_unlock();641 err = qlcnic_sriov_pf_enable(adapter, num_vfs);642 if (!err) {643 netdev_info(netdev,644 "SR-IOV is enabled successfully on port %d\n",645 adapter->portnum);646 /* Return number of vfs enabled */647 return num_vfs;648 }649 650 rtnl_lock();651 if (netif_running(netdev))652 __qlcnic_down(adapter, netdev);653 654error:655 if (!qlcnic_83xx_configure_opmode(adapter)) {656 if (netif_running(netdev))657 __qlcnic_up(adapter, netdev);658 }659 660 rtnl_unlock();661 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n",662 adapter->portnum);663 664 return err;665}666 667int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs)668{669 struct qlcnic_adapter *adapter = pci_get_drvdata(dev);670 int err;671 672 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))673 return -EBUSY;674 675 if (num_vfs == 0)676 err = qlcnic_pci_sriov_disable(adapter);677 else678 err = qlcnic_pci_sriov_enable(adapter, num_vfs);679 680 clear_bit(__QLCNIC_RESETTING, &adapter->state);681 return err;682}683 684static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func)685{686 struct qlcnic_cmd_args cmd;687 struct qlcnic_vport *vp;688 int err, id;689 u8 *mac;690 691 id = qlcnic_sriov_func_to_index(adapter, func);692 if (id < 0)693 return id;694 695 vp = adapter->ahw->sriov->vf_info[id].vp;696 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO);697 if (err)698 return err;699 700 cmd.req.arg[1] = 0x3 | func << 16;701 if (vp->spoofchk == true) {702 mac = vp->mac;703 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8;704 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 |705 mac[2] << 24;706 cmd.req.arg[5] = mac[1] | mac[0] << 8;707 }708 709 if (vp->vlan_mode == QLC_PVID_MODE) {710 cmd.req.arg[2] |= BIT_6;711 cmd.req.arg[3] |= vp->pvid << 8;712 }713 714 err = qlcnic_issue_cmd(adapter, &cmd);715 if (err)716 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n",717 err);718 719 qlcnic_free_mbx_args(&cmd);720 return err;721}722 723static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter,724 u16 func)725{726 struct qlcnic_info defvp_info;727 int err;728 729 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func);730 if (err)731 return -EIO;732 733 err = qlcnic_sriov_set_vf_acl(adapter, func);734 if (err)735 return err;736 737 return 0;738}739 740static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans,741 struct qlcnic_cmd_args *cmd)742{743 struct qlcnic_vf_info *vf = trans->vf;744 struct qlcnic_vport *vp = vf->vp;745 struct qlcnic_adapter *adapter;746 struct qlcnic_sriov *sriov;747 u16 func = vf->pci_func;748 size_t size;749 int err;750 751 adapter = vf->adapter;752 sriov = adapter->ahw->sriov;753 754 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) {755 err = qlcnic_sriov_pf_config_vport(adapter, 1, func);756 if (!err) {757 err = qlcnic_sriov_set_vf_vport_info(adapter, func);758 if (err)759 qlcnic_sriov_pf_config_vport(adapter, 0, func);760 }761 } else {762 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) {763 size = sizeof(*vf->sriov_vlans);764 size = size * sriov->num_allowed_vlans;765 memset(vf->sriov_vlans, 0, size);766 }767 768 err = qlcnic_sriov_pf_config_vport(adapter, 0, func);769 }770 771 if (err)772 goto err_out;773 774 cmd->rsp.arg[0] |= (1 << 25);775 776 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT)777 set_bit(QLC_BC_VF_STATE, &vf->state);778 else779 clear_bit(QLC_BC_VF_STATE, &vf->state);780 781 return err;782 783err_out:784 cmd->rsp.arg[0] |= (2 << 25);785 return err;786}787 788static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter,789 struct qlcnic_vf_info *vf,790 u16 vlan, u8 op)791{792 struct qlcnic_cmd_args *cmd;793 struct qlcnic_macvlan_mbx mv;794 struct qlcnic_vport *vp;795 u8 *addr;796 int err;797 u32 *buf;798 int vpid;799 800 vp = vf->vp;801 802 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);803 if (!cmd)804 return -ENOMEM;805 806 err = qlcnic_alloc_mbx_args(cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN);807 if (err)808 goto free_cmd;809 810 cmd->type = QLC_83XX_MBX_CMD_NO_WAIT;811 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func);812 if (vpid < 0) {813 err = -EINVAL;814 goto free_args;815 }816 817 if (vlan)818 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ?819 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL);820 821 cmd->req.arg[1] = op | (1 << 8) | (3 << 6);822 cmd->req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31;823 824 addr = vp->mac;825 mv.vlan = vlan;826 mv.mac_addr0 = addr[0];827 mv.mac_addr1 = addr[1];828 mv.mac_addr2 = addr[2];829 mv.mac_addr3 = addr[3];830 mv.mac_addr4 = addr[4];831 mv.mac_addr5 = addr[5];832 buf = &cmd->req.arg[2];833 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx));834 835 err = qlcnic_issue_cmd(adapter, cmd);836 837 if (!err)838 return err;839 840free_args:841 qlcnic_free_mbx_args(cmd);842free_cmd:843 kfree(cmd);844 return err;845}846 847static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd)848{849 if ((cmd->req.arg[0] >> 29) != 0x3)850 return -EINVAL;851 852 return 0;853}854 855static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter,856 struct qlcnic_vf_info *vf,857 int opcode)858{859 struct qlcnic_sriov *sriov;860 u16 vlan;861 int i;862 863 sriov = adapter->ahw->sriov;864 865 spin_lock_bh(&vf->vlan_list_lock);866 if (vf->num_vlan) {867 for (i = 0; i < sriov->num_allowed_vlans; i++) {868 vlan = vf->sriov_vlans[i];869 if (vlan)870 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan,871 opcode);872 }873 }874 spin_unlock_bh(&vf->vlan_list_lock);875 876 if (vf->vp->vlan_mode != QLC_PVID_MODE) {877 if (qlcnic_83xx_pf_check(adapter) &&878 qlcnic_sriov_check_any_vlan(vf))879 return;880 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode);881 }882}883 884static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran,885 struct qlcnic_cmd_args *cmd)886{887 struct qlcnic_vf_info *vf = tran->vf;888 struct qlcnic_adapter *adapter = vf->adapter;889 struct qlcnic_rcv_mbx_out *mbx_out;890 int err;891 892 err = qlcnic_sriov_validate_create_rx_ctx(cmd);893 if (err) {894 cmd->rsp.arg[0] |= (0x6 << 25);895 return err;896 }897 898 cmd->req.arg[6] = vf->vp->handle;899 err = qlcnic_issue_cmd(adapter, cmd);900 901 if (!err) {902 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1];903 vf->rx_ctx_id = mbx_out->ctx_id;904 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD);905 } else {906 vf->rx_ctx_id = 0;907 }908 909 return err;910}911 912static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans,913 struct qlcnic_cmd_args *cmd)914{915 struct qlcnic_vf_info *vf = trans->vf;916 u8 type, *mac;917 918 type = cmd->req.arg[1];919 switch (type) {920 case QLCNIC_SET_STATION_MAC:921 case QLCNIC_SET_FAC_DEF_MAC:922 cmd->rsp.arg[0] = (2 << 25);923 break;924 case QLCNIC_GET_CURRENT_MAC:925 cmd->rsp.arg[0] = (1 << 25);926 mac = vf->vp->mac;927 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00);928 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) |929 ((mac[3]) << 16 & 0xff0000) |930 ((mac[2]) << 24 & 0xff000000);931 }932 933 return 0;934}935 936static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd)937{938 if ((cmd->req.arg[0] >> 29) != 0x3)939 return -EINVAL;940 941 return 0;942}943 944static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans,945 struct qlcnic_cmd_args *cmd)946{947 struct qlcnic_vf_info *vf = trans->vf;948 struct qlcnic_adapter *adapter = vf->adapter;949 struct qlcnic_tx_mbx_out *mbx_out;950 int err;951 952 err = qlcnic_sriov_validate_create_tx_ctx(cmd);953 if (err) {954 cmd->rsp.arg[0] |= (0x6 << 25);955 return err;956 }957 958 cmd->req.arg[5] |= vf->vp->handle << 16;959 err = qlcnic_issue_cmd(adapter, cmd);960 if (!err) {961 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2];962 vf->tx_ctx_id = mbx_out->ctx_id;963 } else {964 vf->tx_ctx_id = 0;965 }966 967 return err;968}969 970static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf,971 struct qlcnic_cmd_args *cmd)972{973 if ((cmd->req.arg[0] >> 29) != 0x3)974 return -EINVAL;975 976 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id)977 return -EINVAL;978 979 return 0;980}981 982static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans,983 struct qlcnic_cmd_args *cmd)984{985 struct qlcnic_vf_info *vf = trans->vf;986 struct qlcnic_adapter *adapter = vf->adapter;987 int err;988 989 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd);990 if (err) {991 cmd->rsp.arg[0] |= (0x6 << 25);992 return err;993 }994 995 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL);996 cmd->req.arg[1] |= vf->vp->handle << 16;997 err = qlcnic_issue_cmd(adapter, cmd);998 999 if (!err)1000 vf->rx_ctx_id = 0;1001 1002 return err;1003}1004 1005static 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 1017static 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 1039static 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 1048static 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 1065static 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 1079static 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 1094static 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 else1105 err = qlcnic_issue_cmd(adapter, cmd);1106 1107 return err;1108}1109 1110static 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 1123static 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 else1134 err = qlcnic_issue_cmd(adapter, cmd);1135 1136 return err;1137}1138 1139static 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 1152static 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 1169static 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 1178static 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 else1189 err = qlcnic_issue_cmd(adapter, cmd);1190 1191 return err;1192}1193 1194static 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 1227err_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 1237static 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 1254static 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 1279static 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 1296static 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 1305static 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 1322static 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 1335static 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 as1350 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response1351 */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 1368static 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 1393static 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 1431static 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 else1450 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 1456static 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 1464static 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 1471static 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 1489void 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 1525void 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 1535void 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 1545void 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 1555void 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 1565void 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 1575void 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 1585void 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 1595static 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 else1615 vf->rx_ctx_id = 0;1616 }1617 1618 qlcnic_free_mbx_args(&cmd);1619}1620 1621static 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 else1641 vf->tx_ctx_id = 0;1642 }1643 1644 qlcnic_free_mbx_args(&cmd);1645}1646 1647static 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 1662static 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 1686static 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 1695static 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 1706static 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 1721bool 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 1737void 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 1762void 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 1783int 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 1802int 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 1849int 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 1912int 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 1968static __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 1991int 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 else2012 ivi->max_tx_rate = vp->max_tx_bw * 100;2013 if (vp->min_tx_bw == MIN_BW)2014 ivi->min_tx_rate = 0;2015 else2016 ivi->min_tx_rate = vp->min_tx_bw * 100;2017 2018 ivi->vf = vf;2019 return 0;2020}2021 2022int 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}2047