1 /* 2 * QLogic qlcnic NIC Driver 3 * Copyright (c) 2009-2013 QLogic Corporation 4 * 5 * See LICENSE.qlcnic for copyright and licensing details. 6 */ 7 8 #include "qlcnic_sriov.h" 9 #include "qlcnic.h" 10 #include <linux/types.h> 11 12 #define QLCNIC_SRIOV_VF_MAX_MAC 1 13 #define QLC_VF_MIN_TX_RATE 100 14 #define QLC_VF_MAX_TX_RATE 9999 15 16 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *, u8); 17 18 struct qlcnic_sriov_cmd_handler { 19 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *); 20 }; 21 22 struct qlcnic_sriov_fw_cmd_handler { 23 u32 cmd; 24 int (*fn) (struct qlcnic_bc_trans *, struct qlcnic_cmd_args *); 25 }; 26 27 static int qlcnic_sriov_pf_set_vport_info(struct qlcnic_adapter *adapter, 28 struct qlcnic_info *npar_info, 29 u16 vport_id) 30 { 31 struct qlcnic_cmd_args cmd; 32 int err; 33 34 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO)) 35 return -ENOMEM; 36 37 cmd.req.arg[1] = (vport_id << 16) | 0x1; 38 cmd.req.arg[2] = npar_info->bit_offsets; 39 cmd.req.arg[2] |= npar_info->min_tx_bw << 16; 40 cmd.req.arg[3] = npar_info->max_tx_bw | (npar_info->max_tx_ques << 16); 41 cmd.req.arg[4] = npar_info->max_tx_mac_filters; 42 cmd.req.arg[4] |= npar_info->max_rx_mcast_mac_filters << 16; 43 cmd.req.arg[5] = npar_info->max_rx_ucast_mac_filters | 44 (npar_info->max_rx_ip_addr << 16); 45 cmd.req.arg[6] = npar_info->max_rx_lro_flow | 46 (npar_info->max_rx_status_rings << 16); 47 cmd.req.arg[7] = npar_info->max_rx_buf_rings | 48 (npar_info->max_rx_ques << 16); 49 cmd.req.arg[8] = npar_info->max_tx_vlan_keys; 50 cmd.req.arg[8] |= npar_info->max_local_ipv6_addrs << 16; 51 cmd.req.arg[9] = npar_info->max_remote_ipv6_addrs; 52 53 err = qlcnic_issue_cmd(adapter, &cmd); 54 if (err) 55 dev_err(&adapter->pdev->dev, 56 "Failed to set vport info, err=%d\n", err); 57 58 qlcnic_free_mbx_args(&cmd); 59 return err; 60 } 61 62 static int qlcnic_sriov_pf_cal_res_limit(struct qlcnic_adapter *adapter, 63 struct qlcnic_info *info, u16 func) 64 { 65 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 66 struct qlcnic_resources *res = &sriov->ff_max; 67 u32 temp, num_vf_macs, num_vfs, max; 68 int ret = -EIO, vpid, id; 69 struct qlcnic_vport *vp; 70 71 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func); 72 if (vpid < 0) 73 return -EINVAL; 74 75 num_vfs = sriov->num_vfs; 76 max = num_vfs + 1; 77 info->bit_offsets = 0xffff; 78 info->max_tx_ques = res->num_tx_queues / max; 79 info->max_rx_mcast_mac_filters = res->num_rx_mcast_mac_filters; 80 num_vf_macs = QLCNIC_SRIOV_VF_MAX_MAC; 81 82 if (adapter->ahw->pci_func == func) { 83 temp = res->num_rx_mcast_mac_filters - (num_vfs * num_vf_macs); 84 info->max_rx_ucast_mac_filters = temp; 85 temp = res->num_tx_mac_filters - (num_vfs * num_vf_macs); 86 info->max_tx_mac_filters = temp; 87 info->min_tx_bw = 0; 88 info->max_tx_bw = MAX_BW; 89 } else { 90 id = qlcnic_sriov_func_to_index(adapter, func); 91 if (id < 0) 92 return id; 93 vp = sriov->vf_info[id].vp; 94 info->min_tx_bw = vp->min_tx_bw; 95 info->max_tx_bw = vp->max_tx_bw; 96 info->max_rx_ucast_mac_filters = num_vf_macs; 97 info->max_tx_mac_filters = num_vf_macs; 98 } 99 100 info->max_rx_ip_addr = res->num_destip / max; 101 info->max_rx_status_rings = res->num_rx_status_rings / max; 102 info->max_rx_buf_rings = res->num_rx_buf_rings / max; 103 info->max_rx_ques = res->num_rx_queues / max; 104 info->max_rx_lro_flow = res->num_lro_flows_supported / max; 105 info->max_tx_vlan_keys = res->num_txvlan_keys; 106 info->max_local_ipv6_addrs = res->max_local_ipv6_addrs; 107 info->max_remote_ipv6_addrs = res->max_remote_ipv6_addrs; 108 109 ret = qlcnic_sriov_pf_set_vport_info(adapter, info, vpid); 110 if (ret) 111 return ret; 112 113 return 0; 114 } 115 116 static void qlcnic_sriov_pf_set_ff_max_res(struct qlcnic_adapter *adapter, 117 struct qlcnic_info *info) 118 { 119 struct qlcnic_resources *ff_max = &adapter->ahw->sriov->ff_max; 120 121 ff_max->num_tx_mac_filters = info->max_tx_mac_filters; 122 ff_max->num_rx_ucast_mac_filters = info->max_rx_ucast_mac_filters; 123 ff_max->num_rx_mcast_mac_filters = info->max_rx_mcast_mac_filters; 124 ff_max->num_txvlan_keys = info->max_tx_vlan_keys; 125 ff_max->num_rx_queues = info->max_rx_ques; 126 ff_max->num_tx_queues = info->max_tx_ques; 127 ff_max->num_lro_flows_supported = info->max_rx_lro_flow; 128 ff_max->num_destip = info->max_rx_ip_addr; 129 ff_max->num_rx_buf_rings = info->max_rx_buf_rings; 130 ff_max->num_rx_status_rings = info->max_rx_status_rings; 131 ff_max->max_remote_ipv6_addrs = info->max_remote_ipv6_addrs; 132 ff_max->max_local_ipv6_addrs = info->max_local_ipv6_addrs; 133 } 134 135 static int qlcnic_sriov_get_pf_info(struct qlcnic_adapter *adapter, 136 struct qlcnic_info *npar_info) 137 { 138 int err; 139 struct qlcnic_cmd_args cmd; 140 141 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_NIC_INFO)) 142 return -ENOMEM; 143 144 cmd.req.arg[1] = 0x2; 145 err = qlcnic_issue_cmd(adapter, &cmd); 146 if (err) { 147 dev_err(&adapter->pdev->dev, 148 "Failed to get PF info, err=%d\n", err); 149 goto out; 150 } 151 152 npar_info->total_pf = cmd.rsp.arg[2] & 0xff; 153 npar_info->total_rss_engines = (cmd.rsp.arg[2] >> 8) & 0xff; 154 npar_info->max_vports = MSW(cmd.rsp.arg[2]); 155 npar_info->max_tx_ques = LSW(cmd.rsp.arg[3]); 156 npar_info->max_tx_mac_filters = MSW(cmd.rsp.arg[3]); 157 npar_info->max_rx_mcast_mac_filters = LSW(cmd.rsp.arg[4]); 158 npar_info->max_rx_ucast_mac_filters = MSW(cmd.rsp.arg[4]); 159 npar_info->max_rx_ip_addr = LSW(cmd.rsp.arg[5]); 160 npar_info->max_rx_lro_flow = MSW(cmd.rsp.arg[5]); 161 npar_info->max_rx_status_rings = LSW(cmd.rsp.arg[6]); 162 npar_info->max_rx_buf_rings = MSW(cmd.rsp.arg[6]); 163 npar_info->max_rx_ques = LSW(cmd.rsp.arg[7]); 164 npar_info->max_tx_vlan_keys = MSW(cmd.rsp.arg[7]); 165 npar_info->max_local_ipv6_addrs = LSW(cmd.rsp.arg[8]); 166 npar_info->max_remote_ipv6_addrs = MSW(cmd.rsp.arg[8]); 167 168 qlcnic_sriov_pf_set_ff_max_res(adapter, npar_info); 169 dev_info(&adapter->pdev->dev, 170 "\n\ttotal_pf: %d,\n" 171 "\n\ttotal_rss_engines: %d max_vports: %d max_tx_ques %d,\n" 172 "\tmax_tx_mac_filters: %d max_rx_mcast_mac_filters: %d,\n" 173 "\tmax_rx_ucast_mac_filters: 0x%x, max_rx_ip_addr: %d,\n" 174 "\tmax_rx_lro_flow: %d max_rx_status_rings: %d,\n" 175 "\tmax_rx_buf_rings: %d, max_rx_ques: %d, max_tx_vlan_keys %d\n" 176 "\tmax_local_ipv6_addrs: %d, max_remote_ipv6_addrs: %d\n", 177 npar_info->total_pf, npar_info->total_rss_engines, 178 npar_info->max_vports, npar_info->max_tx_ques, 179 npar_info->max_tx_mac_filters, 180 npar_info->max_rx_mcast_mac_filters, 181 npar_info->max_rx_ucast_mac_filters, npar_info->max_rx_ip_addr, 182 npar_info->max_rx_lro_flow, npar_info->max_rx_status_rings, 183 npar_info->max_rx_buf_rings, npar_info->max_rx_ques, 184 npar_info->max_tx_vlan_keys, npar_info->max_local_ipv6_addrs, 185 npar_info->max_remote_ipv6_addrs); 186 187 out: 188 qlcnic_free_mbx_args(&cmd); 189 return err; 190 } 191 192 static void qlcnic_sriov_pf_reset_vport_handle(struct qlcnic_adapter *adapter, 193 u8 func) 194 { 195 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 196 struct qlcnic_vport *vp; 197 int index; 198 199 if (adapter->ahw->pci_func == func) { 200 sriov->vp_handle = 0; 201 } else { 202 index = qlcnic_sriov_func_to_index(adapter, func); 203 if (index < 0) 204 return; 205 vp = sriov->vf_info[index].vp; 206 vp->handle = 0; 207 } 208 } 209 210 static void qlcnic_sriov_pf_set_vport_handle(struct qlcnic_adapter *adapter, 211 u16 vport_handle, u8 func) 212 { 213 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 214 struct qlcnic_vport *vp; 215 int index; 216 217 if (adapter->ahw->pci_func == func) { 218 sriov->vp_handle = vport_handle; 219 } else { 220 index = qlcnic_sriov_func_to_index(adapter, func); 221 if (index < 0) 222 return; 223 vp = sriov->vf_info[index].vp; 224 vp->handle = vport_handle; 225 } 226 } 227 228 static int qlcnic_sriov_pf_get_vport_handle(struct qlcnic_adapter *adapter, 229 u8 func) 230 { 231 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 232 struct qlcnic_vf_info *vf_info; 233 int index; 234 235 if (adapter->ahw->pci_func == func) { 236 return sriov->vp_handle; 237 } else { 238 index = qlcnic_sriov_func_to_index(adapter, func); 239 if (index >= 0) { 240 vf_info = &sriov->vf_info[index]; 241 return vf_info->vp->handle; 242 } 243 } 244 245 return -EINVAL; 246 } 247 248 static int qlcnic_sriov_pf_config_vport(struct qlcnic_adapter *adapter, 249 u8 flag, u16 func) 250 { 251 struct qlcnic_cmd_args cmd; 252 int ret; 253 int vpid; 254 255 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_VPORT)) 256 return -ENOMEM; 257 258 if (flag) { 259 cmd.req.arg[3] = func << 8; 260 } else { 261 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func); 262 if (vpid < 0) { 263 ret = -EINVAL; 264 goto out; 265 } 266 cmd.req.arg[3] = ((vpid & 0xffff) << 8) | 1; 267 } 268 269 ret = qlcnic_issue_cmd(adapter, &cmd); 270 if (ret) { 271 dev_err(&adapter->pdev->dev, 272 "Failed %s vport, err %d for func 0x%x\n", 273 (flag ? "enable" : "disable"), ret, func); 274 goto out; 275 } 276 277 if (flag) { 278 vpid = cmd.rsp.arg[2] & 0xffff; 279 qlcnic_sriov_pf_set_vport_handle(adapter, vpid, func); 280 } else { 281 qlcnic_sriov_pf_reset_vport_handle(adapter, func); 282 } 283 284 out: 285 qlcnic_free_mbx_args(&cmd); 286 return ret; 287 } 288 289 static int qlcnic_sriov_pf_cfg_vlan_filtering(struct qlcnic_adapter *adapter, 290 u8 enable) 291 { 292 struct qlcnic_cmd_args cmd; 293 int err; 294 295 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO); 296 if (err) 297 return err; 298 299 cmd.req.arg[1] = 0x4; 300 if (enable) 301 cmd.req.arg[1] |= BIT_16; 302 303 err = qlcnic_issue_cmd(adapter, &cmd); 304 if (err) 305 dev_err(&adapter->pdev->dev, 306 "Failed to configure VLAN filtering, err=%d\n", err); 307 308 qlcnic_free_mbx_args(&cmd); 309 return err; 310 } 311 312 static int qlcnic_sriov_pf_cfg_eswitch(struct qlcnic_adapter *adapter, 313 u8 func, u8 enable) 314 { 315 struct qlcnic_cmd_args cmd; 316 int err = -EIO; 317 318 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TOGGLE_ESWITCH)) 319 return -ENOMEM; 320 321 cmd.req.arg[0] |= (3 << 29); 322 cmd.req.arg[1] = ((func & 0xf) << 2) | BIT_6 | BIT_1; 323 if (enable) 324 cmd.req.arg[1] |= BIT_0; 325 326 err = qlcnic_issue_cmd(adapter, &cmd); 327 328 if (err != QLCNIC_RCODE_SUCCESS) { 329 dev_err(&adapter->pdev->dev, 330 "Failed to enable sriov eswitch%d\n", err); 331 err = -EIO; 332 } 333 334 qlcnic_free_mbx_args(&cmd); 335 return err; 336 } 337 338 static void qlcnic_sriov_pf_del_flr_queue(struct qlcnic_adapter *adapter) 339 { 340 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 341 struct qlcnic_back_channel *bc = &sriov->bc; 342 int i; 343 344 for (i = 0; i < sriov->num_vfs; i++) 345 cancel_work_sync(&sriov->vf_info[i].flr_work); 346 347 destroy_workqueue(bc->bc_flr_wq); 348 } 349 350 static int qlcnic_sriov_pf_create_flr_queue(struct qlcnic_adapter *adapter) 351 { 352 struct qlcnic_back_channel *bc = &adapter->ahw->sriov->bc; 353 struct workqueue_struct *wq; 354 355 wq = create_singlethread_workqueue("qlcnic-flr"); 356 if (wq == NULL) { 357 dev_err(&adapter->pdev->dev, "Cannot create FLR workqueue\n"); 358 return -ENOMEM; 359 } 360 361 bc->bc_flr_wq = wq; 362 return 0; 363 } 364 365 void qlcnic_sriov_pf_cleanup(struct qlcnic_adapter *adapter) 366 { 367 u8 func = adapter->ahw->pci_func; 368 369 if (!qlcnic_sriov_enable_check(adapter)) 370 return; 371 372 qlcnic_sriov_pf_del_flr_queue(adapter); 373 qlcnic_sriov_cfg_bc_intr(adapter, 0); 374 qlcnic_sriov_pf_config_vport(adapter, 0, func); 375 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0); 376 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0); 377 __qlcnic_sriov_cleanup(adapter); 378 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC; 379 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state); 380 } 381 382 void qlcnic_sriov_pf_disable(struct qlcnic_adapter *adapter) 383 { 384 if (!qlcnic_sriov_pf_check(adapter)) 385 return; 386 387 if (!qlcnic_sriov_enable_check(adapter)) 388 return; 389 390 pci_disable_sriov(adapter->pdev); 391 netdev_info(adapter->netdev, 392 "SR-IOV is disabled successfully on port %d\n", 393 adapter->portnum); 394 } 395 396 static int qlcnic_pci_sriov_disable(struct qlcnic_adapter *adapter) 397 { 398 struct net_device *netdev = adapter->netdev; 399 400 if (netif_running(netdev)) 401 __qlcnic_down(adapter, netdev); 402 403 qlcnic_sriov_pf_disable(adapter); 404 405 qlcnic_sriov_pf_cleanup(adapter); 406 407 /* After disabling SRIOV re-init the driver in default mode 408 configure opmode based on op_mode of function 409 */ 410 if (qlcnic_83xx_configure_opmode(adapter)) 411 return -EIO; 412 413 if (netif_running(netdev)) 414 __qlcnic_up(adapter, netdev); 415 416 return 0; 417 } 418 419 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter) 420 { 421 struct qlcnic_hardware_context *ahw = adapter->ahw; 422 struct qlcnic_info nic_info, pf_info, vp_info; 423 int err; 424 u8 func = ahw->pci_func; 425 426 if (!qlcnic_sriov_enable_check(adapter)) 427 return 0; 428 429 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1); 430 if (err) 431 return err; 432 433 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1); 434 if (err) 435 goto disable_vlan_filtering; 436 437 err = qlcnic_sriov_pf_config_vport(adapter, 1, func); 438 if (err) 439 goto disable_eswitch; 440 441 err = qlcnic_sriov_get_pf_info(adapter, &pf_info); 442 if (err) 443 goto delete_vport; 444 445 err = qlcnic_get_nic_info(adapter, &nic_info, func); 446 if (err) 447 goto delete_vport; 448 449 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func); 450 if (err) 451 goto delete_vport; 452 453 err = qlcnic_sriov_cfg_bc_intr(adapter, 1); 454 if (err) 455 goto delete_vport; 456 457 ahw->physical_port = (u8) nic_info.phys_port; 458 ahw->switch_mode = nic_info.switch_mode; 459 ahw->max_mtu = nic_info.max_mtu; 460 ahw->capabilities = nic_info.capabilities; 461 ahw->nic_mode = QLC_83XX_SRIOV_MODE; 462 return err; 463 464 delete_vport: 465 qlcnic_sriov_pf_config_vport(adapter, 0, func); 466 467 disable_eswitch: 468 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0); 469 470 disable_vlan_filtering: 471 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0); 472 473 return err; 474 } 475 476 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs) 477 { 478 int err; 479 480 if (!qlcnic_sriov_enable_check(adapter)) 481 return 0; 482 483 err = pci_enable_sriov(adapter->pdev, num_vfs); 484 if (err) 485 qlcnic_sriov_pf_cleanup(adapter); 486 487 return err; 488 } 489 490 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, 491 int num_vfs) 492 { 493 int err = 0; 494 495 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state); 496 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 497 498 err = qlcnic_sriov_init(adapter, num_vfs); 499 if (err) 500 goto clear_op_mode; 501 502 err = qlcnic_sriov_pf_create_flr_queue(adapter); 503 if (err) 504 goto sriov_cleanup; 505 506 err = qlcnic_sriov_pf_init(adapter); 507 if (err) 508 goto del_flr_queue; 509 510 err = qlcnic_sriov_pf_enable(adapter, num_vfs); 511 return err; 512 513 del_flr_queue: 514 qlcnic_sriov_pf_del_flr_queue(adapter); 515 516 sriov_cleanup: 517 __qlcnic_sriov_cleanup(adapter); 518 519 clear_op_mode: 520 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state); 521 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC; 522 return err; 523 } 524 525 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs) 526 { 527 struct net_device *netdev = adapter->netdev; 528 int err; 529 530 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) { 531 netdev_err(netdev, 532 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n"); 533 return -EIO; 534 } 535 536 if (netif_running(netdev)) 537 __qlcnic_down(adapter, netdev); 538 539 err = __qlcnic_pci_sriov_enable(adapter, num_vfs); 540 if (err) { 541 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n", 542 adapter->portnum); 543 544 err = -EIO; 545 if (qlcnic_83xx_configure_opmode(adapter)) 546 goto error; 547 } else { 548 netdev_info(netdev, 549 "SR-IOV is enabled successfully on port %d\n", 550 adapter->portnum); 551 /* Return number of vfs enabled */ 552 err = num_vfs; 553 } 554 if (netif_running(netdev)) 555 __qlcnic_up(adapter, netdev); 556 557 error: 558 return err; 559 } 560 561 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs) 562 { 563 struct qlcnic_adapter *adapter = pci_get_drvdata(dev); 564 int err; 565 566 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 567 return -EBUSY; 568 569 if (num_vfs == 0) 570 err = qlcnic_pci_sriov_disable(adapter); 571 else 572 err = qlcnic_pci_sriov_enable(adapter, num_vfs); 573 574 clear_bit(__QLCNIC_RESETTING, &adapter->state); 575 return err; 576 } 577 578 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func) 579 { 580 struct qlcnic_cmd_args cmd; 581 struct qlcnic_vport *vp; 582 int err, id; 583 u8 *mac; 584 585 id = qlcnic_sriov_func_to_index(adapter, func); 586 if (id < 0) 587 return id; 588 589 vp = adapter->ahw->sriov->vf_info[id].vp; 590 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO); 591 if (err) 592 return err; 593 594 cmd.req.arg[1] = 0x3 | func << 16; 595 if (vp->spoofchk == true) { 596 mac = vp->mac; 597 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8; 598 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 | 599 mac[2] << 24; 600 cmd.req.arg[5] = mac[1] | mac[0] << 8; 601 } 602 603 if (vp->vlan_mode == QLC_PVID_MODE) { 604 cmd.req.arg[2] |= BIT_6; 605 cmd.req.arg[3] |= vp->vlan << 8; 606 } 607 608 err = qlcnic_issue_cmd(adapter, &cmd); 609 if (err) 610 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n", 611 err); 612 613 qlcnic_free_mbx_args(&cmd); 614 return err; 615 } 616 617 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter, 618 u16 func) 619 { 620 struct qlcnic_info defvp_info; 621 int err; 622 623 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func); 624 if (err) 625 return -EIO; 626 627 err = qlcnic_sriov_set_vf_acl(adapter, func); 628 if (err) 629 return err; 630 631 return 0; 632 } 633 634 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans, 635 struct qlcnic_cmd_args *cmd) 636 { 637 struct qlcnic_vf_info *vf = trans->vf; 638 struct qlcnic_vport *vp = vf->vp; 639 struct qlcnic_adapter *adapter; 640 u16 func = vf->pci_func; 641 int err; 642 643 adapter = vf->adapter; 644 645 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) { 646 err = qlcnic_sriov_pf_config_vport(adapter, 1, func); 647 if (!err) { 648 err = qlcnic_sriov_set_vf_vport_info(adapter, func); 649 if (err) 650 qlcnic_sriov_pf_config_vport(adapter, 0, func); 651 } 652 } else { 653 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) 654 vp->vlan = 0; 655 err = qlcnic_sriov_pf_config_vport(adapter, 0, func); 656 } 657 658 if (err) 659 goto err_out; 660 661 cmd->rsp.arg[0] |= (1 << 25); 662 663 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) 664 set_bit(QLC_BC_VF_STATE, &vf->state); 665 else 666 clear_bit(QLC_BC_VF_STATE, &vf->state); 667 668 return err; 669 670 err_out: 671 cmd->rsp.arg[0] |= (2 << 25); 672 return err; 673 } 674 675 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter, 676 struct qlcnic_vport *vp, 677 u16 func, u16 vlan, u8 op) 678 { 679 struct qlcnic_cmd_args cmd; 680 struct qlcnic_macvlan_mbx mv; 681 u8 *addr; 682 int err; 683 u32 *buf; 684 int vpid; 685 686 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN)) 687 return -ENOMEM; 688 689 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func); 690 if (vpid < 0) { 691 err = -EINVAL; 692 goto out; 693 } 694 695 if (vlan) 696 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 697 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL); 698 699 cmd.req.arg[1] = op | (1 << 8) | (3 << 6); 700 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31; 701 702 addr = vp->mac; 703 mv.vlan = vlan; 704 mv.mac_addr0 = addr[0]; 705 mv.mac_addr1 = addr[1]; 706 mv.mac_addr2 = addr[2]; 707 mv.mac_addr3 = addr[3]; 708 mv.mac_addr4 = addr[4]; 709 mv.mac_addr5 = addr[5]; 710 buf = &cmd.req.arg[2]; 711 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx)); 712 713 err = qlcnic_issue_cmd(adapter, &cmd); 714 715 if (err) 716 dev_err(&adapter->pdev->dev, 717 "MAC-VLAN %s to CAM failed, err=%d.\n", 718 ((op == 1) ? "add " : "delete "), err); 719 720 out: 721 qlcnic_free_mbx_args(&cmd); 722 return err; 723 } 724 725 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd) 726 { 727 if ((cmd->req.arg[0] >> 29) != 0x3) 728 return -EINVAL; 729 730 return 0; 731 } 732 733 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran, 734 struct qlcnic_cmd_args *cmd) 735 { 736 struct qlcnic_vf_info *vf = tran->vf; 737 struct qlcnic_adapter *adapter = vf->adapter; 738 struct qlcnic_rcv_mbx_out *mbx_out; 739 int err; 740 u16 vlan; 741 742 err = qlcnic_sriov_validate_create_rx_ctx(cmd); 743 if (err) { 744 cmd->rsp.arg[0] |= (0x6 << 25); 745 return err; 746 } 747 748 cmd->req.arg[6] = vf->vp->handle; 749 err = qlcnic_issue_cmd(adapter, cmd); 750 751 vlan = vf->vp->vlan; 752 if (!err) { 753 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1]; 754 vf->rx_ctx_id = mbx_out->ctx_id; 755 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func, 756 vlan, QLCNIC_MAC_ADD); 757 } else { 758 vf->rx_ctx_id = 0; 759 } 760 761 return err; 762 } 763 764 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans, 765 struct qlcnic_cmd_args *cmd) 766 { 767 struct qlcnic_vf_info *vf = trans->vf; 768 u8 type, *mac; 769 770 type = cmd->req.arg[1]; 771 switch (type) { 772 case QLCNIC_SET_STATION_MAC: 773 case QLCNIC_SET_FAC_DEF_MAC: 774 cmd->rsp.arg[0] = (2 << 25); 775 break; 776 case QLCNIC_GET_CURRENT_MAC: 777 cmd->rsp.arg[0] = (1 << 25); 778 mac = vf->vp->mac; 779 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00); 780 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) | 781 ((mac[3]) << 16 & 0xff0000) | 782 ((mac[2]) << 24 & 0xff000000); 783 } 784 785 return 0; 786 } 787 788 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd) 789 { 790 if ((cmd->req.arg[0] >> 29) != 0x3) 791 return -EINVAL; 792 793 return 0; 794 } 795 796 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 797 struct qlcnic_cmd_args *cmd) 798 { 799 struct qlcnic_vf_info *vf = trans->vf; 800 struct qlcnic_adapter *adapter = vf->adapter; 801 struct qlcnic_tx_mbx_out *mbx_out; 802 int err; 803 804 err = qlcnic_sriov_validate_create_tx_ctx(cmd); 805 if (err) { 806 cmd->rsp.arg[0] |= (0x6 << 25); 807 return err; 808 } 809 810 cmd->req.arg[5] |= vf->vp->handle << 16; 811 err = qlcnic_issue_cmd(adapter, cmd); 812 if (!err) { 813 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2]; 814 vf->tx_ctx_id = mbx_out->ctx_id; 815 } else { 816 vf->tx_ctx_id = 0; 817 } 818 819 return err; 820 } 821 822 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf, 823 struct qlcnic_cmd_args *cmd) 824 { 825 if ((cmd->req.arg[0] >> 29) != 0x3) 826 return -EINVAL; 827 828 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id) 829 return -EINVAL; 830 831 return 0; 832 } 833 834 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans, 835 struct qlcnic_cmd_args *cmd) 836 { 837 struct qlcnic_vf_info *vf = trans->vf; 838 struct qlcnic_adapter *adapter = vf->adapter; 839 int err; 840 u16 vlan; 841 842 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd); 843 if (err) { 844 cmd->rsp.arg[0] |= (0x6 << 25); 845 return err; 846 } 847 848 vlan = vf->vp->vlan; 849 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func, 850 vlan, QLCNIC_MAC_DEL); 851 cmd->req.arg[1] |= vf->vp->handle << 16; 852 err = qlcnic_issue_cmd(adapter, cmd); 853 854 if (!err) 855 vf->rx_ctx_id = 0; 856 857 return err; 858 } 859 860 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf, 861 struct qlcnic_cmd_args *cmd) 862 { 863 if ((cmd->req.arg[0] >> 29) != 0x3) 864 return -EINVAL; 865 866 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id) 867 return -EINVAL; 868 869 return 0; 870 } 871 872 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 873 struct qlcnic_cmd_args *cmd) 874 { 875 struct qlcnic_vf_info *vf = trans->vf; 876 struct qlcnic_adapter *adapter = vf->adapter; 877 int err; 878 879 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd); 880 if (err) { 881 cmd->rsp.arg[0] |= (0x6 << 25); 882 return err; 883 } 884 885 cmd->req.arg[1] |= vf->vp->handle << 16; 886 err = qlcnic_issue_cmd(adapter, cmd); 887 888 if (!err) 889 vf->tx_ctx_id = 0; 890 891 return err; 892 } 893 894 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf, 895 struct qlcnic_cmd_args *cmd) 896 { 897 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 898 return -EINVAL; 899 900 return 0; 901 } 902 903 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans, 904 struct qlcnic_cmd_args *cmd) 905 { 906 struct qlcnic_vf_info *vf = trans->vf; 907 struct qlcnic_adapter *adapter = vf->adapter; 908 int err; 909 910 err = qlcnic_sriov_validate_cfg_lro(vf, cmd); 911 if (err) { 912 cmd->rsp.arg[0] |= (0x6 << 25); 913 return err; 914 } 915 916 err = qlcnic_issue_cmd(adapter, cmd); 917 return err; 918 } 919 920 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans, 921 struct qlcnic_cmd_args *cmd) 922 { 923 struct qlcnic_vf_info *vf = trans->vf; 924 struct qlcnic_adapter *adapter = vf->adapter; 925 int err = -EIO; 926 u8 op; 927 928 op = cmd->req.arg[1] & 0xff; 929 930 cmd->req.arg[1] |= vf->vp->handle << 16; 931 cmd->req.arg[1] |= BIT_31; 932 933 err = qlcnic_issue_cmd(adapter, cmd); 934 return err; 935 } 936 937 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf, 938 struct qlcnic_cmd_args *cmd) 939 { 940 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func) 941 return -EINVAL; 942 943 if (!(cmd->req.arg[1] & BIT_16)) 944 return -EINVAL; 945 946 if ((cmd->req.arg[1] & 0xff) != 0x1) 947 return -EINVAL; 948 949 return 0; 950 } 951 952 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans, 953 struct qlcnic_cmd_args *cmd) 954 { 955 struct qlcnic_vf_info *vf = trans->vf; 956 struct qlcnic_adapter *adapter = vf->adapter; 957 int err; 958 959 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd); 960 if (err) 961 cmd->rsp.arg[0] |= (0x6 << 25); 962 else 963 err = qlcnic_issue_cmd(adapter, cmd); 964 965 return err; 966 } 967 968 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter, 969 struct qlcnic_vf_info *vf, 970 struct qlcnic_cmd_args *cmd) 971 { 972 if (cmd->req.arg[1] != vf->rx_ctx_id) 973 return -EINVAL; 974 975 if (cmd->req.arg[2] > adapter->ahw->max_mtu) 976 return -EINVAL; 977 978 return 0; 979 } 980 981 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans, 982 struct qlcnic_cmd_args *cmd) 983 { 984 struct qlcnic_vf_info *vf = trans->vf; 985 struct qlcnic_adapter *adapter = vf->adapter; 986 int err; 987 988 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd); 989 if (err) 990 cmd->rsp.arg[0] |= (0x6 << 25); 991 else 992 err = qlcnic_issue_cmd(adapter, cmd); 993 994 return err; 995 } 996 997 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf, 998 struct qlcnic_cmd_args *cmd) 999 { 1000 if (cmd->req.arg[1] & BIT_31) { 1001 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func) 1002 return -EINVAL; 1003 } else { 1004 cmd->req.arg[1] |= vf->vp->handle << 16; 1005 } 1006 1007 return 0; 1008 } 1009 1010 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans, 1011 struct qlcnic_cmd_args *cmd) 1012 { 1013 struct qlcnic_vf_info *vf = trans->vf; 1014 struct qlcnic_adapter *adapter = vf->adapter; 1015 int err; 1016 1017 err = qlcnic_sriov_validate_get_nic_info(vf, cmd); 1018 if (err) { 1019 cmd->rsp.arg[0] |= (0x6 << 25); 1020 return err; 1021 } 1022 1023 err = qlcnic_issue_cmd(adapter, cmd); 1024 return err; 1025 } 1026 1027 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf, 1028 struct qlcnic_cmd_args *cmd) 1029 { 1030 if (cmd->req.arg[1] != vf->rx_ctx_id) 1031 return -EINVAL; 1032 1033 return 0; 1034 } 1035 1036 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans, 1037 struct qlcnic_cmd_args *cmd) 1038 { 1039 struct qlcnic_vf_info *vf = trans->vf; 1040 struct qlcnic_adapter *adapter = vf->adapter; 1041 int err; 1042 1043 err = qlcnic_sriov_validate_cfg_rss(vf, cmd); 1044 if (err) 1045 cmd->rsp.arg[0] |= (0x6 << 25); 1046 else 1047 err = qlcnic_issue_cmd(adapter, cmd); 1048 1049 return err; 1050 } 1051 1052 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter, 1053 struct qlcnic_vf_info *vf, 1054 struct qlcnic_cmd_args *cmd) 1055 { 1056 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal; 1057 u16 ctx_id, pkts, time; 1058 1059 ctx_id = cmd->req.arg[1] >> 16; 1060 pkts = cmd->req.arg[2] & 0xffff; 1061 time = cmd->req.arg[2] >> 16; 1062 1063 if (ctx_id != vf->rx_ctx_id) 1064 return -EINVAL; 1065 if (pkts > coal->rx_packets) 1066 return -EINVAL; 1067 if (time < coal->rx_time_us) 1068 return -EINVAL; 1069 1070 return 0; 1071 } 1072 1073 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran, 1074 struct qlcnic_cmd_args *cmd) 1075 { 1076 struct qlcnic_vf_info *vf = tran->vf; 1077 struct qlcnic_adapter *adapter = vf->adapter; 1078 int err; 1079 1080 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd); 1081 if (err) { 1082 cmd->rsp.arg[0] |= (0x6 << 25); 1083 return err; 1084 } 1085 1086 err = qlcnic_issue_cmd(adapter, cmd); 1087 return err; 1088 } 1089 1090 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter, 1091 struct qlcnic_vf_info *vf, 1092 struct qlcnic_cmd_args *cmd) 1093 { 1094 struct qlcnic_macvlan_mbx *macvlan; 1095 struct qlcnic_vport *vp = vf->vp; 1096 u8 op, new_op; 1097 1098 if (!(cmd->req.arg[1] & BIT_8)) 1099 return -EINVAL; 1100 1101 cmd->req.arg[1] |= (vf->vp->handle << 16); 1102 cmd->req.arg[1] |= BIT_31; 1103 1104 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2]; 1105 if (!(macvlan->mac_addr0 & BIT_0)) { 1106 dev_err(&adapter->pdev->dev, 1107 "MAC address change is not allowed from VF %d", 1108 vf->pci_func); 1109 return -EINVAL; 1110 } 1111 1112 if (vp->vlan_mode == QLC_PVID_MODE) { 1113 op = cmd->req.arg[1] & 0x7; 1114 cmd->req.arg[1] &= ~0x7; 1115 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 1116 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL; 1117 cmd->req.arg[3] |= vp->vlan << 16; 1118 cmd->req.arg[1] |= new_op; 1119 } 1120 1121 return 0; 1122 } 1123 1124 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans, 1125 struct qlcnic_cmd_args *cmd) 1126 { 1127 struct qlcnic_vf_info *vf = trans->vf; 1128 struct qlcnic_adapter *adapter = vf->adapter; 1129 int err; 1130 1131 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd); 1132 if (err) { 1133 cmd->rsp.arg[0] |= (0x6 << 25); 1134 return err; 1135 } 1136 1137 err = qlcnic_issue_cmd(adapter, cmd); 1138 return err; 1139 } 1140 1141 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf, 1142 struct qlcnic_cmd_args *cmd) 1143 { 1144 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 1145 return -EINVAL; 1146 1147 return 0; 1148 } 1149 1150 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans, 1151 struct qlcnic_cmd_args *cmd) 1152 { 1153 struct qlcnic_vf_info *vf = trans->vf; 1154 struct qlcnic_adapter *adapter = vf->adapter; 1155 int err; 1156 1157 err = qlcnic_sriov_validate_linkevent(vf, cmd); 1158 if (err) { 1159 cmd->rsp.arg[0] |= (0x6 << 25); 1160 return err; 1161 } 1162 1163 err = qlcnic_issue_cmd(adapter, cmd); 1164 return err; 1165 } 1166 1167 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans, 1168 struct qlcnic_cmd_args *cmd) 1169 { 1170 struct qlcnic_vf_info *vf = trans->vf; 1171 struct qlcnic_adapter *adapter = vf->adapter; 1172 int err; 1173 1174 cmd->req.arg[1] |= vf->vp->handle << 16; 1175 cmd->req.arg[1] |= BIT_31; 1176 err = qlcnic_issue_cmd(adapter, cmd); 1177 return err; 1178 } 1179 1180 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans, 1181 struct qlcnic_cmd_args *cmd) 1182 { 1183 struct qlcnic_vf_info *vf = trans->vf; 1184 struct qlcnic_vport *vp = vf->vp; 1185 u8 cmd_op, mode = vp->vlan_mode; 1186 1187 cmd_op = trans->req_hdr->cmd_op; 1188 cmd->rsp.arg[0] |= 1 << 25; 1189 1190 switch (mode) { 1191 case QLC_GUEST_VLAN_MODE: 1192 cmd->rsp.arg[1] = mode | 1 << 8; 1193 cmd->rsp.arg[2] = 1 << 16; 1194 break; 1195 case QLC_PVID_MODE: 1196 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16; 1197 break; 1198 } 1199 1200 return 0; 1201 } 1202 1203 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter, 1204 struct qlcnic_vf_info *vf) 1205 1206 { 1207 struct qlcnic_vport *vp = vf->vp; 1208 1209 if (!vp->vlan) 1210 return -EINVAL; 1211 1212 if (!vf->rx_ctx_id) { 1213 vp->vlan = 0; 1214 return 0; 1215 } 1216 1217 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1218 vp->vlan, QLCNIC_MAC_DEL); 1219 vp->vlan = 0; 1220 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1221 0, QLCNIC_MAC_ADD); 1222 return 0; 1223 } 1224 1225 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter, 1226 struct qlcnic_vf_info *vf, 1227 struct qlcnic_cmd_args *cmd) 1228 { 1229 struct qlcnic_vport *vp = vf->vp; 1230 int err = -EIO; 1231 1232 if (vp->vlan) 1233 return err; 1234 1235 if (!vf->rx_ctx_id) { 1236 vp->vlan = cmd->req.arg[1] >> 16; 1237 return 0; 1238 } 1239 1240 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1241 0, QLCNIC_MAC_DEL); 1242 if (err) 1243 return err; 1244 1245 vp->vlan = cmd->req.arg[1] >> 16; 1246 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1247 vp->vlan, QLCNIC_MAC_ADD); 1248 1249 if (err) { 1250 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1251 0, QLCNIC_MAC_ADD); 1252 vp->vlan = 0; 1253 } 1254 1255 return err; 1256 } 1257 1258 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran, 1259 struct qlcnic_cmd_args *cmd) 1260 { 1261 struct qlcnic_vf_info *vf = tran->vf; 1262 struct qlcnic_adapter *adapter = vf->adapter; 1263 struct qlcnic_vport *vp = vf->vp; 1264 int err = -EIO; 1265 u8 op; 1266 1267 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) { 1268 cmd->rsp.arg[0] |= 2 << 25; 1269 return err; 1270 } 1271 1272 op = cmd->req.arg[1] & 0xf; 1273 1274 if (op) 1275 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd); 1276 else 1277 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf); 1278 1279 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25; 1280 return err; 1281 } 1282 1283 static const int qlcnic_pf_passthru_supp_cmds[] = { 1284 QLCNIC_CMD_GET_STATISTICS, 1285 QLCNIC_CMD_GET_PORT_CONFIG, 1286 QLCNIC_CMD_GET_LINK_STATUS, 1287 }; 1288 1289 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = { 1290 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1291 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1292 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd}, 1293 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd}, 1294 }; 1295 1296 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = { 1297 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd}, 1298 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd}, 1299 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd}, 1300 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd}, 1301 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd}, 1302 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd}, 1303 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd}, 1304 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd}, 1305 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd}, 1306 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd}, 1307 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd}, 1308 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd}, 1309 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd}, 1310 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd}, 1311 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd}, 1312 }; 1313 1314 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter, 1315 struct qlcnic_bc_trans *trans, 1316 struct qlcnic_cmd_args *cmd) 1317 { 1318 u8 size, cmd_op; 1319 1320 cmd_op = trans->req_hdr->cmd_op; 1321 1322 if (trans->req_hdr->op_type == QLC_BC_CMD) { 1323 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr); 1324 if (cmd_op < size) { 1325 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd); 1326 return; 1327 } 1328 } else { 1329 int i; 1330 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr); 1331 for (i = 0; i < size; i++) { 1332 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) { 1333 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd); 1334 return; 1335 } 1336 } 1337 1338 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds); 1339 for (i = 0; i < size; i++) { 1340 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) { 1341 qlcnic_issue_cmd(adapter, cmd); 1342 return; 1343 } 1344 } 1345 } 1346 1347 cmd->rsp.arg[0] |= (0x9 << 25); 1348 } 1349 1350 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter, 1351 u32 *int_id) 1352 { 1353 u16 vpid; 1354 1355 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1356 adapter->ahw->pci_func); 1357 *int_id |= vpid; 1358 } 1359 1360 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter, 1361 u32 *int_id) 1362 { 1363 u16 vpid; 1364 1365 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1366 adapter->ahw->pci_func); 1367 *int_id |= vpid << 16; 1368 } 1369 1370 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter, 1371 u32 *int_id) 1372 { 1373 int vpid; 1374 1375 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1376 adapter->ahw->pci_func); 1377 *int_id |= vpid << 16; 1378 } 1379 1380 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter, 1381 u32 *int_id) 1382 { 1383 u16 vpid; 1384 1385 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1386 adapter->ahw->pci_func); 1387 *int_id |= vpid << 16; 1388 } 1389 1390 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter, 1391 u32 *int_id) 1392 { 1393 u16 vpid; 1394 1395 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1396 adapter->ahw->pci_func); 1397 *int_id |= (vpid << 16) | BIT_31; 1398 } 1399 1400 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter, 1401 u32 *int_id) 1402 { 1403 u16 vpid; 1404 1405 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1406 adapter->ahw->pci_func); 1407 *int_id |= (vpid << 16) | BIT_31; 1408 } 1409 1410 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter, 1411 u32 *int_id) 1412 { 1413 u16 vpid; 1414 1415 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1416 adapter->ahw->pci_func); 1417 *int_id |= (vpid << 16) | BIT_31; 1418 } 1419 1420 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter, 1421 struct qlcnic_vf_info *vf) 1422 { 1423 struct qlcnic_cmd_args cmd; 1424 int vpid; 1425 1426 if (!vf->rx_ctx_id) 1427 return; 1428 1429 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX)) 1430 return; 1431 1432 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1433 if (vpid >= 0) { 1434 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16; 1435 if (qlcnic_issue_cmd(adapter, &cmd)) 1436 dev_err(&adapter->pdev->dev, 1437 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1438 vf->pci_func); 1439 else 1440 vf->rx_ctx_id = 0; 1441 } 1442 1443 qlcnic_free_mbx_args(&cmd); 1444 } 1445 1446 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter, 1447 struct qlcnic_vf_info *vf) 1448 { 1449 struct qlcnic_cmd_args cmd; 1450 int vpid; 1451 1452 if (!vf->tx_ctx_id) 1453 return; 1454 1455 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX)) 1456 return; 1457 1458 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1459 if (vpid >= 0) { 1460 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16; 1461 if (qlcnic_issue_cmd(adapter, &cmd)) 1462 dev_err(&adapter->pdev->dev, 1463 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1464 vf->pci_func); 1465 else 1466 vf->tx_ctx_id = 0; 1467 } 1468 1469 qlcnic_free_mbx_args(&cmd); 1470 } 1471 1472 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov, 1473 struct qlcnic_vf_info *vf, 1474 struct qlcnic_bc_trans *trans) 1475 { 1476 struct qlcnic_trans_list *t_list = &vf->rcv_act; 1477 unsigned long flag; 1478 1479 spin_lock_irqsave(&t_list->lock, flag); 1480 1481 __qlcnic_sriov_add_act_list(sriov, vf, trans); 1482 1483 spin_unlock_irqrestore(&t_list->lock, flag); 1484 return 0; 1485 } 1486 1487 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf) 1488 { 1489 struct qlcnic_adapter *adapter = vf->adapter; 1490 1491 qlcnic_sriov_cleanup_list(&vf->rcv_pend); 1492 cancel_work_sync(&vf->trans_work); 1493 qlcnic_sriov_cleanup_list(&vf->rcv_act); 1494 1495 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1496 qlcnic_sriov_del_tx_ctx(adapter, vf); 1497 qlcnic_sriov_del_rx_ctx(adapter, vf); 1498 } 1499 1500 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func); 1501 1502 clear_bit(QLC_BC_VF_FLR, &vf->state); 1503 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1504 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf, 1505 vf->flr_trans); 1506 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1507 vf->flr_trans = NULL; 1508 } 1509 } 1510 1511 static void qlcnic_sriov_pf_process_flr(struct work_struct *work) 1512 { 1513 struct qlcnic_vf_info *vf; 1514 1515 vf = container_of(work, struct qlcnic_vf_info, flr_work); 1516 __qlcnic_sriov_process_flr(vf); 1517 return; 1518 } 1519 1520 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov, 1521 struct qlcnic_vf_info *vf, 1522 work_func_t func) 1523 { 1524 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state)) 1525 return; 1526 1527 INIT_WORK(&vf->flr_work, func); 1528 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work); 1529 } 1530 1531 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter, 1532 struct qlcnic_bc_trans *trans, 1533 struct qlcnic_vf_info *vf) 1534 { 1535 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1536 1537 set_bit(QLC_BC_VF_FLR, &vf->state); 1538 clear_bit(QLC_BC_VF_STATE, &vf->state); 1539 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1540 vf->flr_trans = trans; 1541 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1542 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n", 1543 vf->pci_func); 1544 } 1545 1546 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter, 1547 struct qlcnic_bc_trans *trans, 1548 struct qlcnic_vf_info *vf) 1549 { 1550 struct qlcnic_bc_hdr *hdr = trans->req_hdr; 1551 1552 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) && 1553 (hdr->op_type == QLC_BC_CMD) && 1554 test_bit(QLC_BC_VF_STATE, &vf->state)) { 1555 qlcnic_sriov_handle_soft_flr(adapter, trans, vf); 1556 return true; 1557 } 1558 1559 return false; 1560 } 1561 1562 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov, 1563 struct qlcnic_vf_info *vf) 1564 { 1565 struct net_device *dev = vf->adapter->netdev; 1566 struct qlcnic_vport *vp = vf->vp; 1567 1568 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) { 1569 clear_bit(QLC_BC_VF_FLR, &vf->state); 1570 return; 1571 } 1572 1573 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) { 1574 netdev_info(dev, "FLR for PCI func %d in progress\n", 1575 vf->pci_func); 1576 return; 1577 } 1578 1579 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) 1580 vp->vlan = 0; 1581 1582 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1583 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func); 1584 } 1585 1586 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter) 1587 { 1588 struct qlcnic_hardware_context *ahw = adapter->ahw; 1589 struct qlcnic_sriov *sriov = ahw->sriov; 1590 struct qlcnic_vf_info *vf; 1591 u16 num_vfs = sriov->num_vfs; 1592 int i; 1593 1594 for (i = 0; i < num_vfs; i++) { 1595 vf = &sriov->vf_info[i]; 1596 vf->rx_ctx_id = 0; 1597 vf->tx_ctx_id = 0; 1598 cancel_work_sync(&vf->flr_work); 1599 __qlcnic_sriov_process_flr(vf); 1600 clear_bit(QLC_BC_VF_STATE, &vf->state); 1601 } 1602 1603 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func); 1604 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8); 1605 } 1606 1607 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter) 1608 { 1609 struct qlcnic_hardware_context *ahw = adapter->ahw; 1610 int err; 1611 1612 if (!qlcnic_sriov_enable_check(adapter)) 1613 return 0; 1614 1615 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 1616 1617 err = qlcnic_sriov_pf_init(adapter); 1618 if (err) 1619 return err; 1620 1621 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n", 1622 __func__, ahw->op_mode); 1623 return err; 1624 } 1625 1626 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1627 { 1628 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1629 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1630 int i, num_vfs; 1631 struct qlcnic_vf_info *vf_info; 1632 u8 *curr_mac; 1633 1634 if (!qlcnic_sriov_pf_check(adapter)) 1635 return -EOPNOTSUPP; 1636 1637 num_vfs = sriov->num_vfs; 1638 1639 if (!is_valid_ether_addr(mac) || vf >= num_vfs) 1640 return -EINVAL; 1641 1642 if (!compare_ether_addr(adapter->mac_addr, mac)) { 1643 netdev_err(netdev, "MAC address is already in use by the PF\n"); 1644 return -EINVAL; 1645 } 1646 1647 for (i = 0; i < num_vfs; i++) { 1648 vf_info = &sriov->vf_info[i]; 1649 if (!compare_ether_addr(vf_info->vp->mac, mac)) { 1650 netdev_err(netdev, 1651 "MAC address is already in use by VF %d\n", 1652 i); 1653 return -EINVAL; 1654 } 1655 } 1656 1657 vf_info = &sriov->vf_info[vf]; 1658 curr_mac = vf_info->vp->mac; 1659 1660 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1661 netdev_err(netdev, 1662 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1663 vf); 1664 return -EOPNOTSUPP; 1665 } 1666 1667 memcpy(curr_mac, mac, netdev->addr_len); 1668 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n", 1669 mac, vf); 1670 return 0; 1671 } 1672 1673 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate) 1674 { 1675 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1676 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1677 struct qlcnic_vf_info *vf_info; 1678 struct qlcnic_info nic_info; 1679 struct qlcnic_vport *vp; 1680 u16 vpid; 1681 1682 if (!qlcnic_sriov_pf_check(adapter)) 1683 return -EOPNOTSUPP; 1684 1685 if (vf >= sriov->num_vfs) 1686 return -EINVAL; 1687 1688 if (tx_rate >= 10000 || tx_rate < 100) { 1689 netdev_err(netdev, 1690 "Invalid Tx rate, allowed range is [%d - %d]", 1691 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE); 1692 return -EINVAL; 1693 } 1694 1695 if (tx_rate == 0) 1696 tx_rate = 10000; 1697 1698 vf_info = &sriov->vf_info[vf]; 1699 vp = vf_info->vp; 1700 vpid = vp->handle; 1701 1702 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1703 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid)) 1704 return -EIO; 1705 1706 nic_info.max_tx_bw = tx_rate / 100; 1707 nic_info.bit_offsets = BIT_0; 1708 1709 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid)) 1710 return -EIO; 1711 } 1712 1713 vp->max_tx_bw = tx_rate / 100; 1714 netdev_info(netdev, 1715 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1716 tx_rate, vp->max_tx_bw, vf); 1717 return 0; 1718 } 1719 1720 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf, 1721 u16 vlan, u8 qos) 1722 { 1723 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1724 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1725 struct qlcnic_vf_info *vf_info; 1726 struct qlcnic_vport *vp; 1727 1728 if (!qlcnic_sriov_pf_check(adapter)) 1729 return -EOPNOTSUPP; 1730 1731 if (vf >= sriov->num_vfs || qos > 7) 1732 return -EINVAL; 1733 1734 if (vlan > MAX_VLAN_ID) { 1735 netdev_err(netdev, 1736 "Invalid VLAN ID, allowed range is [0 - %d]\n", 1737 MAX_VLAN_ID); 1738 return -EINVAL; 1739 } 1740 1741 vf_info = &sriov->vf_info[vf]; 1742 vp = vf_info->vp; 1743 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1744 netdev_err(netdev, 1745 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1746 vf); 1747 return -EOPNOTSUPP; 1748 } 1749 1750 switch (vlan) { 1751 case 4095: 1752 vp->vlan = 0; 1753 vp->vlan_mode = QLC_GUEST_VLAN_MODE; 1754 break; 1755 case 0: 1756 vp->vlan_mode = QLC_NO_VLAN_MODE; 1757 vp->vlan = 0; 1758 vp->qos = 0; 1759 break; 1760 default: 1761 vp->vlan_mode = QLC_PVID_MODE; 1762 vp->vlan = vlan; 1763 vp->qos = qos; 1764 } 1765 1766 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n", 1767 vlan, qos, vf); 1768 return 0; 1769 } 1770 1771 static inline __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter, 1772 struct qlcnic_vport *vp, int vf) 1773 { 1774 __u32 vlan = 0; 1775 1776 switch (vp->vlan_mode) { 1777 case QLC_PVID_MODE: 1778 vlan = vp->vlan; 1779 break; 1780 case QLC_GUEST_VLAN_MODE: 1781 vlan = MAX_VLAN_ID; 1782 break; 1783 case QLC_NO_VLAN_MODE: 1784 vlan = 0; 1785 break; 1786 default: 1787 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n", 1788 vp->vlan_mode, vf); 1789 } 1790 1791 return vlan; 1792 } 1793 1794 int qlcnic_sriov_get_vf_config(struct net_device *netdev, 1795 int vf, struct ifla_vf_info *ivi) 1796 { 1797 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1798 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1799 struct qlcnic_vport *vp; 1800 1801 if (!qlcnic_sriov_pf_check(adapter)) 1802 return -EOPNOTSUPP; 1803 1804 if (vf >= sriov->num_vfs) 1805 return -EINVAL; 1806 1807 vp = sriov->vf_info[vf].vp; 1808 memcpy(&ivi->mac, vp->mac, ETH_ALEN); 1809 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf); 1810 ivi->qos = vp->qos; 1811 ivi->spoofchk = vp->spoofchk; 1812 if (vp->max_tx_bw == MAX_BW) 1813 ivi->tx_rate = 0; 1814 else 1815 ivi->tx_rate = vp->max_tx_bw * 100; 1816 1817 ivi->vf = vf; 1818 return 0; 1819 } 1820 1821 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk) 1822 { 1823 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1824 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1825 struct qlcnic_vf_info *vf_info; 1826 struct qlcnic_vport *vp; 1827 1828 if (!qlcnic_sriov_pf_check(adapter)) 1829 return -EOPNOTSUPP; 1830 1831 if (vf >= sriov->num_vfs) 1832 return -EINVAL; 1833 1834 vf_info = &sriov->vf_info[vf]; 1835 vp = vf_info->vp; 1836 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1837 netdev_err(netdev, 1838 "Spoof check 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 vp->spoofchk = chk; 1844 return 0; 1845 } 1846