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 struct qlcnic_adapter *adapter; 1187 1188 adapter = vf->adapter; 1189 1190 cmd_op = trans->req_hdr->cmd_op; 1191 cmd->rsp.arg[0] |= 1 << 25; 1192 1193 /* For 84xx adapter in case of PVID , PFD should send vlan mode as 1194 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response 1195 */ 1196 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE) 1197 return 0; 1198 1199 switch (mode) { 1200 case QLC_GUEST_VLAN_MODE: 1201 cmd->rsp.arg[1] = mode | 1 << 8; 1202 cmd->rsp.arg[2] = 1 << 16; 1203 break; 1204 case QLC_PVID_MODE: 1205 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16; 1206 break; 1207 } 1208 1209 return 0; 1210 } 1211 1212 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter, 1213 struct qlcnic_vf_info *vf) 1214 1215 { 1216 struct qlcnic_vport *vp = vf->vp; 1217 1218 if (!vp->vlan) 1219 return -EINVAL; 1220 1221 if (!vf->rx_ctx_id) { 1222 vp->vlan = 0; 1223 return 0; 1224 } 1225 1226 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1227 vp->vlan, QLCNIC_MAC_DEL); 1228 vp->vlan = 0; 1229 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1230 0, QLCNIC_MAC_ADD); 1231 return 0; 1232 } 1233 1234 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter, 1235 struct qlcnic_vf_info *vf, 1236 struct qlcnic_cmd_args *cmd) 1237 { 1238 struct qlcnic_vport *vp = vf->vp; 1239 int err = -EIO; 1240 1241 if (vp->vlan) 1242 return err; 1243 1244 if (!vf->rx_ctx_id) { 1245 vp->vlan = cmd->req.arg[1] >> 16; 1246 return 0; 1247 } 1248 1249 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1250 0, QLCNIC_MAC_DEL); 1251 if (err) 1252 return err; 1253 1254 vp->vlan = cmd->req.arg[1] >> 16; 1255 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1256 vp->vlan, QLCNIC_MAC_ADD); 1257 1258 if (err) { 1259 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1260 0, QLCNIC_MAC_ADD); 1261 vp->vlan = 0; 1262 } 1263 1264 return err; 1265 } 1266 1267 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran, 1268 struct qlcnic_cmd_args *cmd) 1269 { 1270 struct qlcnic_vf_info *vf = tran->vf; 1271 struct qlcnic_adapter *adapter = vf->adapter; 1272 struct qlcnic_vport *vp = vf->vp; 1273 int err = -EIO; 1274 u8 op; 1275 1276 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) { 1277 cmd->rsp.arg[0] |= 2 << 25; 1278 return err; 1279 } 1280 1281 op = cmd->req.arg[1] & 0xf; 1282 1283 if (op) 1284 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd); 1285 else 1286 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf); 1287 1288 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25; 1289 return err; 1290 } 1291 1292 static const int qlcnic_pf_passthru_supp_cmds[] = { 1293 QLCNIC_CMD_GET_STATISTICS, 1294 QLCNIC_CMD_GET_PORT_CONFIG, 1295 QLCNIC_CMD_GET_LINK_STATUS, 1296 QLCNIC_CMD_DCB_QUERY_CAP, 1297 QLCNIC_CMD_DCB_QUERY_PARAM, 1298 QLCNIC_CMD_INIT_NIC_FUNC, 1299 QLCNIC_CMD_STOP_NIC_FUNC, 1300 }; 1301 1302 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = { 1303 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1304 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1305 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd}, 1306 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd}, 1307 }; 1308 1309 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = { 1310 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd}, 1311 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd}, 1312 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd}, 1313 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd}, 1314 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd}, 1315 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd}, 1316 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd}, 1317 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd}, 1318 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd}, 1319 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd}, 1320 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd}, 1321 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd}, 1322 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd}, 1323 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd}, 1324 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd}, 1325 }; 1326 1327 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter, 1328 struct qlcnic_bc_trans *trans, 1329 struct qlcnic_cmd_args *cmd) 1330 { 1331 u8 size, cmd_op; 1332 1333 cmd_op = trans->req_hdr->cmd_op; 1334 1335 if (trans->req_hdr->op_type == QLC_BC_CMD) { 1336 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr); 1337 if (cmd_op < size) { 1338 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd); 1339 return; 1340 } 1341 } else { 1342 int i; 1343 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr); 1344 for (i = 0; i < size; i++) { 1345 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) { 1346 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd); 1347 return; 1348 } 1349 } 1350 1351 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds); 1352 for (i = 0; i < size; i++) { 1353 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) { 1354 qlcnic_issue_cmd(adapter, cmd); 1355 return; 1356 } 1357 } 1358 } 1359 1360 cmd->rsp.arg[0] |= (0x9 << 25); 1361 } 1362 1363 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter, 1364 u32 *int_id) 1365 { 1366 u16 vpid; 1367 1368 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1369 adapter->ahw->pci_func); 1370 *int_id |= vpid; 1371 } 1372 1373 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter, 1374 u32 *int_id) 1375 { 1376 u16 vpid; 1377 1378 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1379 adapter->ahw->pci_func); 1380 *int_id |= vpid << 16; 1381 } 1382 1383 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter, 1384 u32 *int_id) 1385 { 1386 int vpid; 1387 1388 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1389 adapter->ahw->pci_func); 1390 *int_id |= vpid << 16; 1391 } 1392 1393 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter, 1394 u32 *int_id) 1395 { 1396 u16 vpid; 1397 1398 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1399 adapter->ahw->pci_func); 1400 *int_id |= vpid << 16; 1401 } 1402 1403 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter, 1404 u32 *int_id) 1405 { 1406 u16 vpid; 1407 1408 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1409 adapter->ahw->pci_func); 1410 *int_id |= (vpid << 16) | BIT_31; 1411 } 1412 1413 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter, 1414 u32 *int_id) 1415 { 1416 u16 vpid; 1417 1418 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1419 adapter->ahw->pci_func); 1420 *int_id |= (vpid << 16) | BIT_31; 1421 } 1422 1423 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter, 1424 u32 *int_id) 1425 { 1426 u16 vpid; 1427 1428 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1429 adapter->ahw->pci_func); 1430 *int_id |= (vpid << 16) | BIT_31; 1431 } 1432 1433 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter, 1434 struct qlcnic_vf_info *vf) 1435 { 1436 struct qlcnic_cmd_args cmd; 1437 int vpid; 1438 1439 if (!vf->rx_ctx_id) 1440 return; 1441 1442 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX)) 1443 return; 1444 1445 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1446 if (vpid >= 0) { 1447 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16; 1448 if (qlcnic_issue_cmd(adapter, &cmd)) 1449 dev_err(&adapter->pdev->dev, 1450 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1451 vf->pci_func); 1452 else 1453 vf->rx_ctx_id = 0; 1454 } 1455 1456 qlcnic_free_mbx_args(&cmd); 1457 } 1458 1459 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter, 1460 struct qlcnic_vf_info *vf) 1461 { 1462 struct qlcnic_cmd_args cmd; 1463 int vpid; 1464 1465 if (!vf->tx_ctx_id) 1466 return; 1467 1468 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX)) 1469 return; 1470 1471 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1472 if (vpid >= 0) { 1473 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16; 1474 if (qlcnic_issue_cmd(adapter, &cmd)) 1475 dev_err(&adapter->pdev->dev, 1476 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1477 vf->pci_func); 1478 else 1479 vf->tx_ctx_id = 0; 1480 } 1481 1482 qlcnic_free_mbx_args(&cmd); 1483 } 1484 1485 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov, 1486 struct qlcnic_vf_info *vf, 1487 struct qlcnic_bc_trans *trans) 1488 { 1489 struct qlcnic_trans_list *t_list = &vf->rcv_act; 1490 unsigned long flag; 1491 1492 spin_lock_irqsave(&t_list->lock, flag); 1493 1494 __qlcnic_sriov_add_act_list(sriov, vf, trans); 1495 1496 spin_unlock_irqrestore(&t_list->lock, flag); 1497 return 0; 1498 } 1499 1500 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf) 1501 { 1502 struct qlcnic_adapter *adapter = vf->adapter; 1503 1504 qlcnic_sriov_cleanup_list(&vf->rcv_pend); 1505 cancel_work_sync(&vf->trans_work); 1506 qlcnic_sriov_cleanup_list(&vf->rcv_act); 1507 1508 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1509 qlcnic_sriov_del_tx_ctx(adapter, vf); 1510 qlcnic_sriov_del_rx_ctx(adapter, vf); 1511 } 1512 1513 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func); 1514 1515 clear_bit(QLC_BC_VF_FLR, &vf->state); 1516 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1517 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf, 1518 vf->flr_trans); 1519 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1520 vf->flr_trans = NULL; 1521 } 1522 } 1523 1524 static void qlcnic_sriov_pf_process_flr(struct work_struct *work) 1525 { 1526 struct qlcnic_vf_info *vf; 1527 1528 vf = container_of(work, struct qlcnic_vf_info, flr_work); 1529 __qlcnic_sriov_process_flr(vf); 1530 return; 1531 } 1532 1533 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov, 1534 struct qlcnic_vf_info *vf, 1535 work_func_t func) 1536 { 1537 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state)) 1538 return; 1539 1540 INIT_WORK(&vf->flr_work, func); 1541 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work); 1542 } 1543 1544 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter, 1545 struct qlcnic_bc_trans *trans, 1546 struct qlcnic_vf_info *vf) 1547 { 1548 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1549 1550 set_bit(QLC_BC_VF_FLR, &vf->state); 1551 clear_bit(QLC_BC_VF_STATE, &vf->state); 1552 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1553 vf->flr_trans = trans; 1554 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1555 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n", 1556 vf->pci_func); 1557 } 1558 1559 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter, 1560 struct qlcnic_bc_trans *trans, 1561 struct qlcnic_vf_info *vf) 1562 { 1563 struct qlcnic_bc_hdr *hdr = trans->req_hdr; 1564 1565 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) && 1566 (hdr->op_type == QLC_BC_CMD) && 1567 test_bit(QLC_BC_VF_STATE, &vf->state)) { 1568 qlcnic_sriov_handle_soft_flr(adapter, trans, vf); 1569 return true; 1570 } 1571 1572 return false; 1573 } 1574 1575 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov, 1576 struct qlcnic_vf_info *vf) 1577 { 1578 struct net_device *dev = vf->adapter->netdev; 1579 struct qlcnic_vport *vp = vf->vp; 1580 1581 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) { 1582 clear_bit(QLC_BC_VF_FLR, &vf->state); 1583 return; 1584 } 1585 1586 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) { 1587 netdev_info(dev, "FLR for PCI func %d in progress\n", 1588 vf->pci_func); 1589 return; 1590 } 1591 1592 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) 1593 vp->vlan = 0; 1594 1595 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1596 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func); 1597 } 1598 1599 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter) 1600 { 1601 struct qlcnic_hardware_context *ahw = adapter->ahw; 1602 struct qlcnic_sriov *sriov = ahw->sriov; 1603 struct qlcnic_vf_info *vf; 1604 u16 num_vfs = sriov->num_vfs; 1605 int i; 1606 1607 for (i = 0; i < num_vfs; i++) { 1608 vf = &sriov->vf_info[i]; 1609 vf->rx_ctx_id = 0; 1610 vf->tx_ctx_id = 0; 1611 cancel_work_sync(&vf->flr_work); 1612 __qlcnic_sriov_process_flr(vf); 1613 clear_bit(QLC_BC_VF_STATE, &vf->state); 1614 } 1615 1616 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func); 1617 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8); 1618 } 1619 1620 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter) 1621 { 1622 struct qlcnic_hardware_context *ahw = adapter->ahw; 1623 int err; 1624 1625 if (!qlcnic_sriov_enable_check(adapter)) 1626 return 0; 1627 1628 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 1629 1630 err = qlcnic_sriov_pf_init(adapter); 1631 if (err) 1632 return err; 1633 1634 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n", 1635 __func__, ahw->op_mode); 1636 return err; 1637 } 1638 1639 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1640 { 1641 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1642 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1643 int i, num_vfs; 1644 struct qlcnic_vf_info *vf_info; 1645 u8 *curr_mac; 1646 1647 if (!qlcnic_sriov_pf_check(adapter)) 1648 return -EOPNOTSUPP; 1649 1650 num_vfs = sriov->num_vfs; 1651 1652 if (!is_valid_ether_addr(mac) || vf >= num_vfs) 1653 return -EINVAL; 1654 1655 if (ether_addr_equal(adapter->mac_addr, mac)) { 1656 netdev_err(netdev, "MAC address is already in use by the PF\n"); 1657 return -EINVAL; 1658 } 1659 1660 for (i = 0; i < num_vfs; i++) { 1661 vf_info = &sriov->vf_info[i]; 1662 if (ether_addr_equal(vf_info->vp->mac, mac)) { 1663 netdev_err(netdev, 1664 "MAC address is already in use by VF %d\n", 1665 i); 1666 return -EINVAL; 1667 } 1668 } 1669 1670 vf_info = &sriov->vf_info[vf]; 1671 curr_mac = vf_info->vp->mac; 1672 1673 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1674 netdev_err(netdev, 1675 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1676 vf); 1677 return -EOPNOTSUPP; 1678 } 1679 1680 memcpy(curr_mac, mac, netdev->addr_len); 1681 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n", 1682 mac, vf); 1683 return 0; 1684 } 1685 1686 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate) 1687 { 1688 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1689 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1690 struct qlcnic_vf_info *vf_info; 1691 struct qlcnic_info nic_info; 1692 struct qlcnic_vport *vp; 1693 u16 vpid; 1694 1695 if (!qlcnic_sriov_pf_check(adapter)) 1696 return -EOPNOTSUPP; 1697 1698 if (vf >= sriov->num_vfs) 1699 return -EINVAL; 1700 1701 if (tx_rate >= 10000 || tx_rate < 100) { 1702 netdev_err(netdev, 1703 "Invalid Tx rate, allowed range is [%d - %d]", 1704 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE); 1705 return -EINVAL; 1706 } 1707 1708 if (tx_rate == 0) 1709 tx_rate = 10000; 1710 1711 vf_info = &sriov->vf_info[vf]; 1712 vp = vf_info->vp; 1713 vpid = vp->handle; 1714 1715 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1716 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid)) 1717 return -EIO; 1718 1719 nic_info.max_tx_bw = tx_rate / 100; 1720 nic_info.bit_offsets = BIT_0; 1721 1722 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid)) 1723 return -EIO; 1724 } 1725 1726 vp->max_tx_bw = tx_rate / 100; 1727 netdev_info(netdev, 1728 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1729 tx_rate, vp->max_tx_bw, vf); 1730 return 0; 1731 } 1732 1733 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf, 1734 u16 vlan, u8 qos) 1735 { 1736 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1737 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1738 struct qlcnic_vf_info *vf_info; 1739 struct qlcnic_vport *vp; 1740 1741 if (!qlcnic_sriov_pf_check(adapter)) 1742 return -EOPNOTSUPP; 1743 1744 if (vf >= sriov->num_vfs || qos > 7) 1745 return -EINVAL; 1746 1747 if (vlan > MAX_VLAN_ID) { 1748 netdev_err(netdev, 1749 "Invalid VLAN ID, allowed range is [0 - %d]\n", 1750 MAX_VLAN_ID); 1751 return -EINVAL; 1752 } 1753 1754 vf_info = &sriov->vf_info[vf]; 1755 vp = vf_info->vp; 1756 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1757 netdev_err(netdev, 1758 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1759 vf); 1760 return -EOPNOTSUPP; 1761 } 1762 1763 switch (vlan) { 1764 case 4095: 1765 vp->vlan = 0; 1766 vp->vlan_mode = QLC_GUEST_VLAN_MODE; 1767 break; 1768 case 0: 1769 vp->vlan_mode = QLC_NO_VLAN_MODE; 1770 vp->vlan = 0; 1771 vp->qos = 0; 1772 break; 1773 default: 1774 vp->vlan_mode = QLC_PVID_MODE; 1775 vp->vlan = vlan; 1776 vp->qos = qos; 1777 } 1778 1779 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n", 1780 vlan, qos, vf); 1781 return 0; 1782 } 1783 1784 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter, 1785 struct qlcnic_vport *vp, int vf) 1786 { 1787 __u32 vlan = 0; 1788 1789 switch (vp->vlan_mode) { 1790 case QLC_PVID_MODE: 1791 vlan = vp->vlan; 1792 break; 1793 case QLC_GUEST_VLAN_MODE: 1794 vlan = MAX_VLAN_ID; 1795 break; 1796 case QLC_NO_VLAN_MODE: 1797 vlan = 0; 1798 break; 1799 default: 1800 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n", 1801 vp->vlan_mode, vf); 1802 } 1803 1804 return vlan; 1805 } 1806 1807 int qlcnic_sriov_get_vf_config(struct net_device *netdev, 1808 int vf, struct ifla_vf_info *ivi) 1809 { 1810 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1811 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1812 struct qlcnic_vport *vp; 1813 1814 if (!qlcnic_sriov_pf_check(adapter)) 1815 return -EOPNOTSUPP; 1816 1817 if (vf >= sriov->num_vfs) 1818 return -EINVAL; 1819 1820 vp = sriov->vf_info[vf].vp; 1821 memcpy(&ivi->mac, vp->mac, ETH_ALEN); 1822 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf); 1823 ivi->qos = vp->qos; 1824 ivi->spoofchk = vp->spoofchk; 1825 if (vp->max_tx_bw == MAX_BW) 1826 ivi->tx_rate = 0; 1827 else 1828 ivi->tx_rate = vp->max_tx_bw * 100; 1829 1830 ivi->vf = vf; 1831 return 0; 1832 } 1833 1834 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk) 1835 { 1836 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1837 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1838 struct qlcnic_vf_info *vf_info; 1839 struct qlcnic_vport *vp; 1840 1841 if (!qlcnic_sriov_pf_check(adapter)) 1842 return -EOPNOTSUPP; 1843 1844 if (vf >= sriov->num_vfs) 1845 return -EINVAL; 1846 1847 vf_info = &sriov->vf_info[vf]; 1848 vp = vf_info->vp; 1849 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1850 netdev_err(netdev, 1851 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1852 vf); 1853 return -EOPNOTSUPP; 1854 } 1855 1856 vp->spoofchk = chk; 1857 return 0; 1858 } 1859