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_adapter *adapter = vf->adapter; 639 int err; 640 u16 func = vf->pci_func; 641 642 cmd->rsp.arg[0] = trans->req_hdr->cmd_op; 643 cmd->rsp.arg[0] |= (1 << 16); 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 err = qlcnic_sriov_pf_config_vport(adapter, 0, func); 654 } 655 656 if (err) 657 goto err_out; 658 659 cmd->rsp.arg[0] |= (1 << 25); 660 661 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) 662 set_bit(QLC_BC_VF_STATE, &vf->state); 663 else 664 clear_bit(QLC_BC_VF_STATE, &vf->state); 665 666 return err; 667 668 err_out: 669 cmd->rsp.arg[0] |= (2 << 25); 670 return err; 671 } 672 673 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter, 674 struct qlcnic_vport *vp, 675 u16 func, u16 vlan, u8 op) 676 { 677 struct qlcnic_cmd_args cmd; 678 struct qlcnic_macvlan_mbx mv; 679 u8 *addr; 680 int err; 681 u32 *buf; 682 int vpid; 683 684 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN)) 685 return -ENOMEM; 686 687 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, func); 688 if (vpid < 0) { 689 err = -EINVAL; 690 goto out; 691 } 692 693 if (vlan) 694 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 695 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL); 696 697 cmd.req.arg[1] = op | (1 << 8) | (3 << 6); 698 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31; 699 700 addr = vp->mac; 701 mv.vlan = vlan; 702 mv.mac_addr0 = addr[0]; 703 mv.mac_addr1 = addr[1]; 704 mv.mac_addr2 = addr[2]; 705 mv.mac_addr3 = addr[3]; 706 mv.mac_addr4 = addr[4]; 707 mv.mac_addr5 = addr[5]; 708 buf = &cmd.req.arg[2]; 709 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx)); 710 711 err = qlcnic_issue_cmd(adapter, &cmd); 712 713 if (err) 714 dev_err(&adapter->pdev->dev, 715 "MAC-VLAN %s to CAM failed, err=%d.\n", 716 ((op == 1) ? "add " : "delete "), err); 717 718 out: 719 qlcnic_free_mbx_args(&cmd); 720 return err; 721 } 722 723 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd) 724 { 725 if ((cmd->req.arg[0] >> 29) != 0x3) 726 return -EINVAL; 727 728 return 0; 729 } 730 731 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran, 732 struct qlcnic_cmd_args *cmd) 733 { 734 struct qlcnic_vf_info *vf = tran->vf; 735 struct qlcnic_adapter *adapter = vf->adapter; 736 struct qlcnic_rcv_mbx_out *mbx_out; 737 int err; 738 u16 vlan; 739 740 err = qlcnic_sriov_validate_create_rx_ctx(cmd); 741 if (err) { 742 cmd->rsp.arg[0] |= (0x6 << 25); 743 return err; 744 } 745 746 cmd->req.arg[6] = vf->vp->handle; 747 err = qlcnic_issue_cmd(adapter, cmd); 748 749 vlan = vf->vp->vlan; 750 if (!err) { 751 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1]; 752 vf->rx_ctx_id = mbx_out->ctx_id; 753 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func, 754 vlan, QLCNIC_MAC_ADD); 755 } else { 756 vf->rx_ctx_id = 0; 757 } 758 759 return err; 760 } 761 762 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans, 763 struct qlcnic_cmd_args *cmd) 764 { 765 struct qlcnic_vf_info *vf = trans->vf; 766 u8 type, *mac; 767 768 type = cmd->req.arg[1]; 769 switch (type) { 770 case QLCNIC_SET_STATION_MAC: 771 case QLCNIC_SET_FAC_DEF_MAC: 772 cmd->rsp.arg[0] = (2 << 25); 773 break; 774 case QLCNIC_GET_CURRENT_MAC: 775 cmd->rsp.arg[0] = (1 << 25); 776 mac = vf->vp->mac; 777 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00); 778 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) | 779 ((mac[3]) << 16 & 0xff0000) | 780 ((mac[2]) << 24 & 0xff000000); 781 } 782 783 return 0; 784 } 785 786 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd) 787 { 788 if ((cmd->req.arg[0] >> 29) != 0x3) 789 return -EINVAL; 790 791 return 0; 792 } 793 794 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 795 struct qlcnic_cmd_args *cmd) 796 { 797 struct qlcnic_vf_info *vf = trans->vf; 798 struct qlcnic_adapter *adapter = vf->adapter; 799 struct qlcnic_tx_mbx_out *mbx_out; 800 int err; 801 802 err = qlcnic_sriov_validate_create_tx_ctx(cmd); 803 if (err) { 804 cmd->rsp.arg[0] |= (0x6 << 25); 805 return err; 806 } 807 808 cmd->req.arg[5] |= vf->vp->handle << 16; 809 err = qlcnic_issue_cmd(adapter, cmd); 810 if (!err) { 811 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2]; 812 vf->tx_ctx_id = mbx_out->ctx_id; 813 } else { 814 vf->tx_ctx_id = 0; 815 } 816 817 return err; 818 } 819 820 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf, 821 struct qlcnic_cmd_args *cmd) 822 { 823 if ((cmd->req.arg[0] >> 29) != 0x3) 824 return -EINVAL; 825 826 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id) 827 return -EINVAL; 828 829 return 0; 830 } 831 832 static int qlcnic_sriov_pf_del_rx_ctx_cmd(struct qlcnic_bc_trans *trans, 833 struct qlcnic_cmd_args *cmd) 834 { 835 struct qlcnic_vf_info *vf = trans->vf; 836 struct qlcnic_adapter *adapter = vf->adapter; 837 int err; 838 u16 vlan; 839 840 err = qlcnic_sriov_validate_del_rx_ctx(vf, cmd); 841 if (err) { 842 cmd->rsp.arg[0] |= (0x6 << 25); 843 return err; 844 } 845 846 vlan = vf->vp->vlan; 847 qlcnic_sriov_cfg_vf_def_mac(adapter, vf->vp, vf->pci_func, 848 vlan, QLCNIC_MAC_DEL); 849 cmd->req.arg[1] |= vf->vp->handle << 16; 850 err = qlcnic_issue_cmd(adapter, cmd); 851 852 if (!err) 853 vf->rx_ctx_id = 0; 854 855 return err; 856 } 857 858 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf, 859 struct qlcnic_cmd_args *cmd) 860 { 861 if ((cmd->req.arg[0] >> 29) != 0x3) 862 return -EINVAL; 863 864 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id) 865 return -EINVAL; 866 867 return 0; 868 } 869 870 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 871 struct qlcnic_cmd_args *cmd) 872 { 873 struct qlcnic_vf_info *vf = trans->vf; 874 struct qlcnic_adapter *adapter = vf->adapter; 875 int err; 876 877 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd); 878 if (err) { 879 cmd->rsp.arg[0] |= (0x6 << 25); 880 return err; 881 } 882 883 cmd->req.arg[1] |= vf->vp->handle << 16; 884 err = qlcnic_issue_cmd(adapter, cmd); 885 886 if (!err) 887 vf->tx_ctx_id = 0; 888 889 return err; 890 } 891 892 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf, 893 struct qlcnic_cmd_args *cmd) 894 { 895 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 896 return -EINVAL; 897 898 return 0; 899 } 900 901 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans, 902 struct qlcnic_cmd_args *cmd) 903 { 904 struct qlcnic_vf_info *vf = trans->vf; 905 struct qlcnic_adapter *adapter = vf->adapter; 906 int err; 907 908 err = qlcnic_sriov_validate_cfg_lro(vf, cmd); 909 if (err) { 910 cmd->rsp.arg[0] |= (0x6 << 25); 911 return err; 912 } 913 914 err = qlcnic_issue_cmd(adapter, cmd); 915 return err; 916 } 917 918 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans, 919 struct qlcnic_cmd_args *cmd) 920 { 921 struct qlcnic_vf_info *vf = trans->vf; 922 struct qlcnic_adapter *adapter = vf->adapter; 923 int err = -EIO; 924 u8 op; 925 926 op = cmd->req.arg[1] & 0xff; 927 928 cmd->req.arg[1] |= vf->vp->handle << 16; 929 cmd->req.arg[1] |= BIT_31; 930 931 err = qlcnic_issue_cmd(adapter, cmd); 932 return err; 933 } 934 935 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf, 936 struct qlcnic_cmd_args *cmd) 937 { 938 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func) 939 return -EINVAL; 940 941 if (!(cmd->req.arg[1] & BIT_16)) 942 return -EINVAL; 943 944 if ((cmd->req.arg[1] & 0xff) != 0x1) 945 return -EINVAL; 946 947 return 0; 948 } 949 950 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans, 951 struct qlcnic_cmd_args *cmd) 952 { 953 struct qlcnic_vf_info *vf = trans->vf; 954 struct qlcnic_adapter *adapter = vf->adapter; 955 int err; 956 957 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd); 958 if (err) 959 cmd->rsp.arg[0] |= (0x6 << 25); 960 else 961 err = qlcnic_issue_cmd(adapter, cmd); 962 963 return err; 964 } 965 966 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter, 967 struct qlcnic_vf_info *vf, 968 struct qlcnic_cmd_args *cmd) 969 { 970 if (cmd->req.arg[1] != vf->rx_ctx_id) 971 return -EINVAL; 972 973 if (cmd->req.arg[2] > adapter->ahw->max_mtu) 974 return -EINVAL; 975 976 return 0; 977 } 978 979 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans, 980 struct qlcnic_cmd_args *cmd) 981 { 982 struct qlcnic_vf_info *vf = trans->vf; 983 struct qlcnic_adapter *adapter = vf->adapter; 984 int err; 985 986 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd); 987 if (err) 988 cmd->rsp.arg[0] |= (0x6 << 25); 989 else 990 err = qlcnic_issue_cmd(adapter, cmd); 991 992 return err; 993 } 994 995 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf, 996 struct qlcnic_cmd_args *cmd) 997 { 998 if (cmd->req.arg[1] & BIT_31) { 999 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func) 1000 return -EINVAL; 1001 } else { 1002 cmd->req.arg[1] |= vf->vp->handle << 16; 1003 } 1004 1005 return 0; 1006 } 1007 1008 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans, 1009 struct qlcnic_cmd_args *cmd) 1010 { 1011 struct qlcnic_vf_info *vf = trans->vf; 1012 struct qlcnic_adapter *adapter = vf->adapter; 1013 int err; 1014 1015 err = qlcnic_sriov_validate_get_nic_info(vf, cmd); 1016 if (err) { 1017 cmd->rsp.arg[0] |= (0x6 << 25); 1018 return err; 1019 } 1020 1021 err = qlcnic_issue_cmd(adapter, cmd); 1022 return err; 1023 } 1024 1025 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf, 1026 struct qlcnic_cmd_args *cmd) 1027 { 1028 if (cmd->req.arg[1] != vf->rx_ctx_id) 1029 return -EINVAL; 1030 1031 return 0; 1032 } 1033 1034 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans, 1035 struct qlcnic_cmd_args *cmd) 1036 { 1037 struct qlcnic_vf_info *vf = trans->vf; 1038 struct qlcnic_adapter *adapter = vf->adapter; 1039 int err; 1040 1041 err = qlcnic_sriov_validate_cfg_rss(vf, cmd); 1042 if (err) 1043 cmd->rsp.arg[0] |= (0x6 << 25); 1044 else 1045 err = qlcnic_issue_cmd(adapter, cmd); 1046 1047 return err; 1048 } 1049 1050 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter, 1051 struct qlcnic_vf_info *vf, 1052 struct qlcnic_cmd_args *cmd) 1053 { 1054 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal; 1055 u16 ctx_id, pkts, time; 1056 1057 ctx_id = cmd->req.arg[1] >> 16; 1058 pkts = cmd->req.arg[2] & 0xffff; 1059 time = cmd->req.arg[2] >> 16; 1060 1061 if (ctx_id != vf->rx_ctx_id) 1062 return -EINVAL; 1063 if (pkts > coal->rx_packets) 1064 return -EINVAL; 1065 if (time < coal->rx_time_us) 1066 return -EINVAL; 1067 1068 return 0; 1069 } 1070 1071 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran, 1072 struct qlcnic_cmd_args *cmd) 1073 { 1074 struct qlcnic_vf_info *vf = tran->vf; 1075 struct qlcnic_adapter *adapter = vf->adapter; 1076 int err; 1077 1078 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd); 1079 if (err) { 1080 cmd->rsp.arg[0] |= (0x6 << 25); 1081 return err; 1082 } 1083 1084 err = qlcnic_issue_cmd(adapter, cmd); 1085 return err; 1086 } 1087 1088 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter, 1089 struct qlcnic_vf_info *vf, 1090 struct qlcnic_cmd_args *cmd) 1091 { 1092 struct qlcnic_macvlan_mbx *macvlan; 1093 struct qlcnic_vport *vp = vf->vp; 1094 u8 op, new_op; 1095 1096 if (!(cmd->req.arg[1] & BIT_8)) 1097 return -EINVAL; 1098 1099 cmd->req.arg[1] |= (vf->vp->handle << 16); 1100 cmd->req.arg[1] |= BIT_31; 1101 1102 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2]; 1103 if (!(macvlan->mac_addr0 & BIT_0)) { 1104 dev_err(&adapter->pdev->dev, 1105 "MAC address change is not allowed from VF %d", 1106 vf->pci_func); 1107 return -EINVAL; 1108 } 1109 1110 if (vp->vlan_mode == QLC_PVID_MODE) { 1111 op = cmd->req.arg[1] & 0x7; 1112 cmd->req.arg[1] &= ~0x7; 1113 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 1114 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL; 1115 cmd->req.arg[3] |= vp->vlan << 16; 1116 cmd->req.arg[1] |= new_op; 1117 } 1118 1119 return 0; 1120 } 1121 1122 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans, 1123 struct qlcnic_cmd_args *cmd) 1124 { 1125 struct qlcnic_vf_info *vf = trans->vf; 1126 struct qlcnic_adapter *adapter = vf->adapter; 1127 int err; 1128 1129 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd); 1130 if (err) { 1131 cmd->rsp.arg[0] |= (0x6 << 25); 1132 return err; 1133 } 1134 1135 err = qlcnic_issue_cmd(adapter, cmd); 1136 return err; 1137 } 1138 1139 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf, 1140 struct qlcnic_cmd_args *cmd) 1141 { 1142 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 1143 return -EINVAL; 1144 1145 return 0; 1146 } 1147 1148 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans, 1149 struct qlcnic_cmd_args *cmd) 1150 { 1151 struct qlcnic_vf_info *vf = trans->vf; 1152 struct qlcnic_adapter *adapter = vf->adapter; 1153 int err; 1154 1155 err = qlcnic_sriov_validate_linkevent(vf, cmd); 1156 if (err) { 1157 cmd->rsp.arg[0] |= (0x6 << 25); 1158 return err; 1159 } 1160 1161 err = qlcnic_issue_cmd(adapter, cmd); 1162 return err; 1163 } 1164 1165 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans, 1166 struct qlcnic_cmd_args *cmd) 1167 { 1168 struct qlcnic_vf_info *vf = trans->vf; 1169 struct qlcnic_adapter *adapter = vf->adapter; 1170 int err; 1171 1172 cmd->req.arg[1] |= vf->vp->handle << 16; 1173 cmd->req.arg[1] |= BIT_31; 1174 err = qlcnic_issue_cmd(adapter, cmd); 1175 return err; 1176 } 1177 1178 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans, 1179 struct qlcnic_cmd_args *cmd) 1180 { 1181 struct qlcnic_vf_info *vf = trans->vf; 1182 struct qlcnic_vport *vp = vf->vp; 1183 u8 cmd_op, mode = vp->vlan_mode; 1184 1185 cmd_op = trans->req_hdr->cmd_op; 1186 cmd->rsp.arg[0] = (cmd_op & 0xffff) | 14 << 16 | 1 << 25; 1187 1188 switch (mode) { 1189 case QLC_GUEST_VLAN_MODE: 1190 cmd->rsp.arg[1] = mode | 1 << 8; 1191 cmd->rsp.arg[2] = 1 << 16; 1192 break; 1193 case QLC_PVID_MODE: 1194 cmd->rsp.arg[1] = mode | 1 << 8 | vp->vlan << 16; 1195 break; 1196 } 1197 1198 return 0; 1199 } 1200 1201 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter, 1202 struct qlcnic_vf_info *vf) 1203 1204 { 1205 struct qlcnic_vport *vp = vf->vp; 1206 1207 if (!vp->vlan) 1208 return -EINVAL; 1209 1210 if (!vf->rx_ctx_id) { 1211 vp->vlan = 0; 1212 return 0; 1213 } 1214 1215 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1216 vp->vlan, QLCNIC_MAC_DEL); 1217 vp->vlan = 0; 1218 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1219 0, QLCNIC_MAC_ADD); 1220 return 0; 1221 } 1222 1223 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter, 1224 struct qlcnic_vf_info *vf, 1225 struct qlcnic_cmd_args *cmd) 1226 { 1227 struct qlcnic_vport *vp = vf->vp; 1228 int err = -EIO; 1229 1230 if (vp->vlan) 1231 return err; 1232 1233 if (!vf->rx_ctx_id) { 1234 vp->vlan = cmd->req.arg[1] >> 16; 1235 return 0; 1236 } 1237 1238 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1239 0, QLCNIC_MAC_DEL); 1240 if (err) 1241 return err; 1242 1243 vp->vlan = cmd->req.arg[1] >> 16; 1244 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1245 vp->vlan, QLCNIC_MAC_ADD); 1246 1247 if (err) { 1248 qlcnic_sriov_cfg_vf_def_mac(adapter, vp, vf->pci_func, 1249 0, QLCNIC_MAC_ADD); 1250 vp->vlan = 0; 1251 } 1252 1253 return err; 1254 } 1255 1256 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran, 1257 struct qlcnic_cmd_args *cmd) 1258 { 1259 struct qlcnic_vf_info *vf = tran->vf; 1260 struct qlcnic_adapter *adapter = vf->adapter; 1261 struct qlcnic_vport *vp = vf->vp; 1262 int err = -EIO; 1263 u8 op; 1264 1265 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) { 1266 cmd->rsp.arg[0] |= 2 << 25; 1267 return err; 1268 } 1269 1270 op = cmd->req.arg[1] & 0xf; 1271 1272 if (op) 1273 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd); 1274 else 1275 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf); 1276 1277 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25; 1278 return err; 1279 } 1280 1281 static const int qlcnic_pf_passthru_supp_cmds[] = { 1282 QLCNIC_CMD_GET_STATISTICS, 1283 QLCNIC_CMD_GET_PORT_CONFIG, 1284 QLCNIC_CMD_GET_LINK_STATUS, 1285 }; 1286 1287 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = { 1288 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1289 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1290 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd}, 1291 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd}, 1292 }; 1293 1294 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = { 1295 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd}, 1296 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd}, 1297 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd}, 1298 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd}, 1299 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd}, 1300 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd}, 1301 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd}, 1302 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd}, 1303 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd}, 1304 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd}, 1305 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd}, 1306 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd}, 1307 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd}, 1308 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd}, 1309 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd}, 1310 }; 1311 1312 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter, 1313 struct qlcnic_bc_trans *trans, 1314 struct qlcnic_cmd_args *cmd) 1315 { 1316 u8 size, cmd_op; 1317 1318 cmd_op = trans->req_hdr->cmd_op; 1319 1320 if (trans->req_hdr->op_type == QLC_BC_CMD) { 1321 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr); 1322 if (cmd_op < size) { 1323 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd); 1324 return; 1325 } 1326 } else { 1327 int i; 1328 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr); 1329 for (i = 0; i < size; i++) { 1330 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) { 1331 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd); 1332 return; 1333 } 1334 } 1335 1336 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds); 1337 for (i = 0; i < size; i++) { 1338 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) { 1339 qlcnic_issue_cmd(adapter, cmd); 1340 return; 1341 } 1342 } 1343 } 1344 1345 cmd->rsp.arg[0] |= (0x9 << 25); 1346 } 1347 1348 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter, 1349 u32 *int_id) 1350 { 1351 u16 vpid; 1352 1353 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1354 adapter->ahw->pci_func); 1355 *int_id |= vpid; 1356 } 1357 1358 void qlcnic_pf_set_interface_id_del_rx_ctx(struct qlcnic_adapter *adapter, 1359 u32 *int_id) 1360 { 1361 u16 vpid; 1362 1363 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1364 adapter->ahw->pci_func); 1365 *int_id |= vpid << 16; 1366 } 1367 1368 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter, 1369 u32 *int_id) 1370 { 1371 int vpid; 1372 1373 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1374 adapter->ahw->pci_func); 1375 *int_id |= vpid << 16; 1376 } 1377 1378 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter, 1379 u32 *int_id) 1380 { 1381 u16 vpid; 1382 1383 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1384 adapter->ahw->pci_func); 1385 *int_id |= vpid << 16; 1386 } 1387 1388 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter, 1389 u32 *int_id) 1390 { 1391 u16 vpid; 1392 1393 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1394 adapter->ahw->pci_func); 1395 *int_id |= (vpid << 16) | BIT_31; 1396 } 1397 1398 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter, 1399 u32 *int_id) 1400 { 1401 u16 vpid; 1402 1403 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1404 adapter->ahw->pci_func); 1405 *int_id |= (vpid << 16) | BIT_31; 1406 } 1407 1408 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter, 1409 u32 *int_id) 1410 { 1411 u16 vpid; 1412 1413 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1414 adapter->ahw->pci_func); 1415 *int_id |= (vpid << 16) | BIT_31; 1416 } 1417 1418 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter, 1419 struct qlcnic_vf_info *vf) 1420 { 1421 struct qlcnic_cmd_args cmd; 1422 int vpid; 1423 1424 if (!vf->rx_ctx_id) 1425 return; 1426 1427 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX)) 1428 return; 1429 1430 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1431 if (vpid >= 0) { 1432 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16; 1433 if (qlcnic_issue_cmd(adapter, &cmd)) 1434 dev_err(&adapter->pdev->dev, 1435 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1436 vf->pci_func); 1437 else 1438 vf->rx_ctx_id = 0; 1439 } 1440 1441 qlcnic_free_mbx_args(&cmd); 1442 } 1443 1444 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter, 1445 struct qlcnic_vf_info *vf) 1446 { 1447 struct qlcnic_cmd_args cmd; 1448 int vpid; 1449 1450 if (!vf->tx_ctx_id) 1451 return; 1452 1453 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX)) 1454 return; 1455 1456 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1457 if (vpid >= 0) { 1458 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16; 1459 if (qlcnic_issue_cmd(adapter, &cmd)) 1460 dev_err(&adapter->pdev->dev, 1461 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1462 vf->pci_func); 1463 else 1464 vf->tx_ctx_id = 0; 1465 } 1466 1467 qlcnic_free_mbx_args(&cmd); 1468 } 1469 1470 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov, 1471 struct qlcnic_vf_info *vf, 1472 struct qlcnic_bc_trans *trans) 1473 { 1474 struct qlcnic_trans_list *t_list = &vf->rcv_act; 1475 unsigned long flag; 1476 1477 spin_lock_irqsave(&t_list->lock, flag); 1478 1479 __qlcnic_sriov_add_act_list(sriov, vf, trans); 1480 1481 spin_unlock_irqrestore(&t_list->lock, flag); 1482 return 0; 1483 } 1484 1485 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf) 1486 { 1487 struct qlcnic_adapter *adapter = vf->adapter; 1488 1489 qlcnic_sriov_cleanup_list(&vf->rcv_pend); 1490 cancel_work_sync(&vf->trans_work); 1491 qlcnic_sriov_cleanup_list(&vf->rcv_act); 1492 1493 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1494 qlcnic_sriov_del_tx_ctx(adapter, vf); 1495 qlcnic_sriov_del_rx_ctx(adapter, vf); 1496 } 1497 1498 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func); 1499 1500 clear_bit(QLC_BC_VF_FLR, &vf->state); 1501 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1502 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf, 1503 vf->flr_trans); 1504 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1505 vf->flr_trans = NULL; 1506 } 1507 } 1508 1509 static void qlcnic_sriov_pf_process_flr(struct work_struct *work) 1510 { 1511 struct qlcnic_vf_info *vf; 1512 1513 vf = container_of(work, struct qlcnic_vf_info, flr_work); 1514 __qlcnic_sriov_process_flr(vf); 1515 return; 1516 } 1517 1518 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov, 1519 struct qlcnic_vf_info *vf, 1520 work_func_t func) 1521 { 1522 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state)) 1523 return; 1524 1525 INIT_WORK(&vf->flr_work, func); 1526 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work); 1527 } 1528 1529 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter, 1530 struct qlcnic_bc_trans *trans, 1531 struct qlcnic_vf_info *vf) 1532 { 1533 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1534 1535 set_bit(QLC_BC_VF_FLR, &vf->state); 1536 clear_bit(QLC_BC_VF_STATE, &vf->state); 1537 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1538 vf->flr_trans = trans; 1539 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1540 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n", 1541 vf->pci_func); 1542 } 1543 1544 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter, 1545 struct qlcnic_bc_trans *trans, 1546 struct qlcnic_vf_info *vf) 1547 { 1548 struct qlcnic_bc_hdr *hdr = trans->req_hdr; 1549 1550 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) && 1551 (hdr->op_type == QLC_BC_CMD) && 1552 test_bit(QLC_BC_VF_STATE, &vf->state)) { 1553 qlcnic_sriov_handle_soft_flr(adapter, trans, vf); 1554 return true; 1555 } 1556 1557 return false; 1558 } 1559 1560 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov, 1561 struct qlcnic_vf_info *vf) 1562 { 1563 struct net_device *dev = vf->adapter->netdev; 1564 1565 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) { 1566 clear_bit(QLC_BC_VF_FLR, &vf->state); 1567 return; 1568 } 1569 1570 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) { 1571 netdev_info(dev, "FLR for PCI func %d in progress\n", 1572 vf->pci_func); 1573 return; 1574 } 1575 1576 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1577 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func); 1578 } 1579 1580 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter) 1581 { 1582 struct qlcnic_hardware_context *ahw = adapter->ahw; 1583 struct qlcnic_sriov *sriov = ahw->sriov; 1584 struct qlcnic_vf_info *vf; 1585 u16 num_vfs = sriov->num_vfs; 1586 int i; 1587 1588 for (i = 0; i < num_vfs; i++) { 1589 vf = &sriov->vf_info[i]; 1590 vf->rx_ctx_id = 0; 1591 vf->tx_ctx_id = 0; 1592 cancel_work_sync(&vf->flr_work); 1593 __qlcnic_sriov_process_flr(vf); 1594 clear_bit(QLC_BC_VF_STATE, &vf->state); 1595 } 1596 1597 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func); 1598 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8); 1599 } 1600 1601 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter) 1602 { 1603 struct qlcnic_hardware_context *ahw = adapter->ahw; 1604 int err; 1605 1606 if (!qlcnic_sriov_enable_check(adapter)) 1607 return 0; 1608 1609 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 1610 1611 err = qlcnic_sriov_pf_init(adapter); 1612 if (err) 1613 return err; 1614 1615 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n", 1616 __func__, ahw->op_mode); 1617 return err; 1618 } 1619 1620 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1621 { 1622 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1623 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1624 int i, num_vfs = sriov->num_vfs; 1625 struct qlcnic_vf_info *vf_info; 1626 u8 *curr_mac; 1627 1628 if (!qlcnic_sriov_pf_check(adapter)) 1629 return -EOPNOTSUPP; 1630 1631 if (!is_valid_ether_addr(mac) || vf >= num_vfs) 1632 return -EINVAL; 1633 1634 if (!compare_ether_addr(adapter->mac_addr, mac)) { 1635 netdev_err(netdev, "MAC address is already in use by the PF\n"); 1636 return -EINVAL; 1637 } 1638 1639 for (i = 0; i < num_vfs; i++) { 1640 vf_info = &sriov->vf_info[i]; 1641 if (!compare_ether_addr(vf_info->vp->mac, mac)) { 1642 netdev_err(netdev, 1643 "MAC address is already in use by VF %d\n", 1644 i); 1645 return -EINVAL; 1646 } 1647 } 1648 1649 vf_info = &sriov->vf_info[vf]; 1650 curr_mac = vf_info->vp->mac; 1651 1652 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1653 netdev_err(netdev, 1654 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1655 vf); 1656 return -EOPNOTSUPP; 1657 } 1658 1659 memcpy(curr_mac, mac, netdev->addr_len); 1660 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n", 1661 mac, vf); 1662 return 0; 1663 } 1664 1665 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate) 1666 { 1667 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1668 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1669 struct qlcnic_vf_info *vf_info; 1670 struct qlcnic_info nic_info; 1671 struct qlcnic_vport *vp; 1672 u16 vpid; 1673 1674 if (!qlcnic_sriov_pf_check(adapter)) 1675 return -EOPNOTSUPP; 1676 1677 if (vf >= sriov->num_vfs) 1678 return -EINVAL; 1679 1680 if (tx_rate >= 10000 || tx_rate < 100) { 1681 netdev_err(netdev, 1682 "Invalid Tx rate, allowed range is [%d - %d]", 1683 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE); 1684 return -EINVAL; 1685 } 1686 1687 if (tx_rate == 0) 1688 tx_rate = 10000; 1689 1690 vf_info = &sriov->vf_info[vf]; 1691 vp = vf_info->vp; 1692 vpid = vp->handle; 1693 1694 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1695 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid)) 1696 return -EIO; 1697 1698 nic_info.max_tx_bw = tx_rate / 100; 1699 nic_info.bit_offsets = BIT_0; 1700 1701 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid)) 1702 return -EIO; 1703 } 1704 1705 vp->max_tx_bw = tx_rate / 100; 1706 netdev_info(netdev, 1707 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1708 tx_rate, vp->max_tx_bw, vf); 1709 return 0; 1710 } 1711 1712 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf, 1713 u16 vlan, u8 qos) 1714 { 1715 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1716 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1717 struct qlcnic_vf_info *vf_info; 1718 struct qlcnic_vport *vp; 1719 1720 if (!qlcnic_sriov_pf_check(adapter)) 1721 return -EOPNOTSUPP; 1722 1723 if (vf >= sriov->num_vfs || qos > 7) 1724 return -EINVAL; 1725 1726 if (vlan > MAX_VLAN_ID) { 1727 netdev_err(netdev, 1728 "Invalid VLAN ID, allowed range is [0 - %d]\n", 1729 MAX_VLAN_ID); 1730 return -EINVAL; 1731 } 1732 1733 vf_info = &sriov->vf_info[vf]; 1734 vp = vf_info->vp; 1735 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1736 netdev_err(netdev, 1737 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1738 vf); 1739 return -EOPNOTSUPP; 1740 } 1741 1742 switch (vlan) { 1743 case 4095: 1744 vp->vlan_mode = QLC_GUEST_VLAN_MODE; 1745 break; 1746 case 0: 1747 vp->vlan_mode = QLC_NO_VLAN_MODE; 1748 vp->vlan = 0; 1749 vp->qos = 0; 1750 break; 1751 default: 1752 vp->vlan_mode = QLC_PVID_MODE; 1753 vp->vlan = vlan; 1754 vp->qos = qos; 1755 } 1756 1757 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n", 1758 vlan, qos, vf); 1759 return 0; 1760 } 1761 1762 int qlcnic_sriov_get_vf_config(struct net_device *netdev, 1763 int vf, struct ifla_vf_info *ivi) 1764 { 1765 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1766 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1767 struct qlcnic_vport *vp; 1768 1769 if (!qlcnic_sriov_pf_check(adapter)) 1770 return -EOPNOTSUPP; 1771 1772 if (vf >= sriov->num_vfs) 1773 return -EINVAL; 1774 1775 vp = sriov->vf_info[vf].vp; 1776 memcpy(&ivi->mac, vp->mac, ETH_ALEN); 1777 ivi->vlan = vp->vlan; 1778 ivi->qos = vp->qos; 1779 ivi->spoofchk = vp->spoofchk; 1780 if (vp->max_tx_bw == MAX_BW) 1781 ivi->tx_rate = 0; 1782 else 1783 ivi->tx_rate = vp->max_tx_bw * 100; 1784 1785 ivi->vf = vf; 1786 return 0; 1787 } 1788 1789 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk) 1790 { 1791 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1792 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1793 struct qlcnic_vf_info *vf_info; 1794 struct qlcnic_vport *vp; 1795 1796 if (!qlcnic_sriov_pf_check(adapter)) 1797 return -EOPNOTSUPP; 1798 1799 if (vf >= sriov->num_vfs) 1800 return -EINVAL; 1801 1802 vf_info = &sriov->vf_info[vf]; 1803 vp = vf_info->vp; 1804 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1805 netdev_err(netdev, 1806 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1807 vf); 1808 return -EOPNOTSUPP; 1809 } 1810 1811 vp->spoofchk = chk; 1812 return 0; 1813 } 1814