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