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