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 rtnl_lock(); 465 if (netif_running(netdev)) 466 __qlcnic_down(adapter, netdev); 467 468 qlcnic_sriov_pf_disable(adapter); 469 470 qlcnic_sriov_free_vlans(adapter); 471 472 qlcnic_sriov_pf_cleanup(adapter); 473 474 /* After disabling SRIOV re-init the driver in default mode 475 configure opmode based on op_mode of function 476 */ 477 if (qlcnic_83xx_configure_opmode(adapter)) { 478 rtnl_unlock(); 479 return -EIO; 480 } 481 482 if (netif_running(netdev)) 483 __qlcnic_up(adapter, netdev); 484 485 rtnl_unlock(); 486 return 0; 487 } 488 489 static int qlcnic_sriov_pf_init(struct qlcnic_adapter *adapter) 490 { 491 struct qlcnic_hardware_context *ahw = adapter->ahw; 492 struct qlcnic_info nic_info, pf_info, vp_info; 493 int err; 494 u8 func = ahw->pci_func; 495 496 if (!qlcnic_sriov_enable_check(adapter)) 497 return 0; 498 499 err = qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 1); 500 if (err) 501 return err; 502 503 if (qlcnic_84xx_check(adapter)) { 504 err = qlcnic_sriov_pf_cfg_flood(adapter); 505 if (err) 506 goto disable_vlan_filtering; 507 } 508 509 err = qlcnic_sriov_pf_cfg_eswitch(adapter, func, 1); 510 if (err) 511 goto disable_vlan_filtering; 512 513 err = qlcnic_sriov_pf_config_vport(adapter, 1, func); 514 if (err) 515 goto disable_eswitch; 516 517 err = qlcnic_sriov_get_pf_info(adapter, &pf_info); 518 if (err) 519 goto delete_vport; 520 521 err = qlcnic_get_nic_info(adapter, &nic_info, func); 522 if (err) 523 goto delete_vport; 524 525 err = qlcnic_sriov_pf_cal_res_limit(adapter, &vp_info, func); 526 if (err) 527 goto delete_vport; 528 529 err = qlcnic_sriov_cfg_bc_intr(adapter, 1); 530 if (err) 531 goto delete_vport; 532 533 ahw->physical_port = (u8) nic_info.phys_port; 534 ahw->switch_mode = nic_info.switch_mode; 535 ahw->max_mtu = nic_info.max_mtu; 536 ahw->capabilities = nic_info.capabilities; 537 ahw->nic_mode = QLC_83XX_SRIOV_MODE; 538 return err; 539 540 delete_vport: 541 qlcnic_sriov_pf_config_vport(adapter, 0, func); 542 543 disable_eswitch: 544 qlcnic_sriov_pf_cfg_eswitch(adapter, func, 0); 545 546 disable_vlan_filtering: 547 qlcnic_sriov_pf_cfg_vlan_filtering(adapter, 0); 548 549 return err; 550 } 551 552 static int qlcnic_sriov_pf_enable(struct qlcnic_adapter *adapter, int num_vfs) 553 { 554 int err; 555 556 if (!qlcnic_sriov_enable_check(adapter)) 557 return 0; 558 559 err = pci_enable_sriov(adapter->pdev, num_vfs); 560 if (err) 561 qlcnic_sriov_pf_cleanup(adapter); 562 563 return err; 564 } 565 566 static int __qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, 567 int num_vfs) 568 { 569 int err = 0; 570 571 set_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state); 572 adapter->ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 573 574 err = qlcnic_sriov_init(adapter, num_vfs); 575 if (err) 576 goto clear_op_mode; 577 578 err = qlcnic_sriov_pf_create_flr_queue(adapter); 579 if (err) 580 goto sriov_cleanup; 581 582 err = qlcnic_sriov_pf_init(adapter); 583 if (err) 584 goto del_flr_queue; 585 586 qlcnic_sriov_alloc_vlans(adapter); 587 588 err = qlcnic_sriov_pf_enable(adapter, num_vfs); 589 return err; 590 591 del_flr_queue: 592 qlcnic_sriov_pf_del_flr_queue(adapter); 593 594 sriov_cleanup: 595 __qlcnic_sriov_cleanup(adapter); 596 597 clear_op_mode: 598 clear_bit(__QLCNIC_SRIOV_ENABLE, &adapter->state); 599 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC; 600 return err; 601 } 602 603 static int qlcnic_pci_sriov_enable(struct qlcnic_adapter *adapter, int num_vfs) 604 { 605 struct net_device *netdev = adapter->netdev; 606 int err; 607 608 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) { 609 netdev_err(netdev, 610 "SR-IOV cannot be enabled, when legacy interrupts are enabled\n"); 611 return -EIO; 612 } 613 614 rtnl_lock(); 615 if (netif_running(netdev)) 616 __qlcnic_down(adapter, netdev); 617 618 err = __qlcnic_pci_sriov_enable(adapter, num_vfs); 619 if (err) { 620 netdev_info(netdev, "Failed to enable SR-IOV on port %d\n", 621 adapter->portnum); 622 623 err = -EIO; 624 if (qlcnic_83xx_configure_opmode(adapter)) 625 goto error; 626 } else { 627 netdev_info(netdev, 628 "SR-IOV is enabled successfully on port %d\n", 629 adapter->portnum); 630 /* Return number of vfs enabled */ 631 err = num_vfs; 632 } 633 if (netif_running(netdev)) 634 __qlcnic_up(adapter, netdev); 635 636 error: 637 rtnl_unlock(); 638 return err; 639 } 640 641 int qlcnic_pci_sriov_configure(struct pci_dev *dev, int num_vfs) 642 { 643 struct qlcnic_adapter *adapter = pci_get_drvdata(dev); 644 int err; 645 646 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) 647 return -EBUSY; 648 649 if (num_vfs == 0) 650 err = qlcnic_pci_sriov_disable(adapter); 651 else 652 err = qlcnic_pci_sriov_enable(adapter, num_vfs); 653 654 clear_bit(__QLCNIC_RESETTING, &adapter->state); 655 return err; 656 } 657 658 static int qlcnic_sriov_set_vf_acl(struct qlcnic_adapter *adapter, u8 func) 659 { 660 struct qlcnic_cmd_args cmd; 661 struct qlcnic_vport *vp; 662 int err, id; 663 u8 *mac; 664 665 id = qlcnic_sriov_func_to_index(adapter, func); 666 if (id < 0) 667 return id; 668 669 vp = adapter->ahw->sriov->vf_info[id].vp; 670 err = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_SET_NIC_INFO); 671 if (err) 672 return err; 673 674 cmd.req.arg[1] = 0x3 | func << 16; 675 if (vp->spoofchk == true) { 676 mac = vp->mac; 677 cmd.req.arg[2] |= BIT_1 | BIT_3 | BIT_8; 678 cmd.req.arg[4] = mac[5] | mac[4] << 8 | mac[3] << 16 | 679 mac[2] << 24; 680 cmd.req.arg[5] = mac[1] | mac[0] << 8; 681 } 682 683 if (vp->vlan_mode == QLC_PVID_MODE) { 684 cmd.req.arg[2] |= BIT_6; 685 cmd.req.arg[3] |= vp->pvid << 8; 686 } 687 688 err = qlcnic_issue_cmd(adapter, &cmd); 689 if (err) 690 dev_err(&adapter->pdev->dev, "Failed to set ACL, err=%d\n", 691 err); 692 693 qlcnic_free_mbx_args(&cmd); 694 return err; 695 } 696 697 static int qlcnic_sriov_set_vf_vport_info(struct qlcnic_adapter *adapter, 698 u16 func) 699 { 700 struct qlcnic_info defvp_info; 701 int err; 702 703 err = qlcnic_sriov_pf_cal_res_limit(adapter, &defvp_info, func); 704 if (err) 705 return -EIO; 706 707 err = qlcnic_sriov_set_vf_acl(adapter, func); 708 if (err) 709 return err; 710 711 return 0; 712 } 713 714 static int qlcnic_sriov_pf_channel_cfg_cmd(struct qlcnic_bc_trans *trans, 715 struct qlcnic_cmd_args *cmd) 716 { 717 struct qlcnic_vf_info *vf = trans->vf; 718 struct qlcnic_vport *vp = vf->vp; 719 struct qlcnic_adapter *adapter; 720 struct qlcnic_sriov *sriov; 721 u16 func = vf->pci_func; 722 size_t size; 723 int err; 724 725 adapter = vf->adapter; 726 sriov = adapter->ahw->sriov; 727 728 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) { 729 err = qlcnic_sriov_pf_config_vport(adapter, 1, func); 730 if (!err) { 731 err = qlcnic_sriov_set_vf_vport_info(adapter, func); 732 if (err) 733 qlcnic_sriov_pf_config_vport(adapter, 0, func); 734 } 735 } else { 736 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) { 737 size = sizeof(*vf->sriov_vlans); 738 size = size * sriov->num_allowed_vlans; 739 memset(vf->sriov_vlans, 0, size); 740 } 741 742 err = qlcnic_sriov_pf_config_vport(adapter, 0, func); 743 } 744 745 if (err) 746 goto err_out; 747 748 cmd->rsp.arg[0] |= (1 << 25); 749 750 if (trans->req_hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) 751 set_bit(QLC_BC_VF_STATE, &vf->state); 752 else 753 clear_bit(QLC_BC_VF_STATE, &vf->state); 754 755 return err; 756 757 err_out: 758 cmd->rsp.arg[0] |= (2 << 25); 759 return err; 760 } 761 762 static int qlcnic_sriov_cfg_vf_def_mac(struct qlcnic_adapter *adapter, 763 struct qlcnic_vf_info *vf, 764 u16 vlan, u8 op) 765 { 766 struct qlcnic_cmd_args cmd; 767 struct qlcnic_macvlan_mbx mv; 768 struct qlcnic_vport *vp; 769 u8 *addr; 770 int err; 771 u32 *buf; 772 int vpid; 773 774 vp = vf->vp; 775 776 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_CONFIG_MAC_VLAN)) 777 return -ENOMEM; 778 779 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 780 if (vpid < 0) { 781 err = -EINVAL; 782 goto out; 783 } 784 785 if (vlan) 786 op = ((op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 787 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL); 788 789 cmd.req.arg[1] = op | (1 << 8) | (3 << 6); 790 cmd.req.arg[1] |= ((vpid & 0xffff) << 16) | BIT_31; 791 792 addr = vp->mac; 793 mv.vlan = vlan; 794 mv.mac_addr0 = addr[0]; 795 mv.mac_addr1 = addr[1]; 796 mv.mac_addr2 = addr[2]; 797 mv.mac_addr3 = addr[3]; 798 mv.mac_addr4 = addr[4]; 799 mv.mac_addr5 = addr[5]; 800 buf = &cmd.req.arg[2]; 801 memcpy(buf, &mv, sizeof(struct qlcnic_macvlan_mbx)); 802 803 err = qlcnic_issue_cmd(adapter, &cmd); 804 805 if (err) 806 dev_err(&adapter->pdev->dev, 807 "MAC-VLAN %s to CAM failed, err=%d.\n", 808 ((op == 1) ? "add " : "delete "), err); 809 810 out: 811 qlcnic_free_mbx_args(&cmd); 812 return err; 813 } 814 815 static int qlcnic_sriov_validate_create_rx_ctx(struct qlcnic_cmd_args *cmd) 816 { 817 if ((cmd->req.arg[0] >> 29) != 0x3) 818 return -EINVAL; 819 820 return 0; 821 } 822 823 static void qlcnic_83xx_cfg_default_mac_vlan(struct qlcnic_adapter *adapter, 824 struct qlcnic_vf_info *vf, 825 int opcode) 826 { 827 struct qlcnic_sriov *sriov; 828 u16 vlan; 829 int i; 830 831 sriov = adapter->ahw->sriov; 832 833 mutex_lock(&vf->vlan_list_lock); 834 if (vf->num_vlan) { 835 for (i = 0; i < sriov->num_allowed_vlans; i++) { 836 vlan = vf->sriov_vlans[i]; 837 if (vlan) 838 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, 839 opcode); 840 } 841 } 842 mutex_unlock(&vf->vlan_list_lock); 843 844 if (vf->vp->vlan_mode != QLC_PVID_MODE) { 845 if (qlcnic_83xx_pf_check(adapter) && 846 qlcnic_sriov_check_any_vlan(vf)) 847 return; 848 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, opcode); 849 } 850 } 851 852 static int qlcnic_sriov_pf_create_rx_ctx_cmd(struct qlcnic_bc_trans *tran, 853 struct qlcnic_cmd_args *cmd) 854 { 855 struct qlcnic_vf_info *vf = tran->vf; 856 struct qlcnic_adapter *adapter = vf->adapter; 857 struct qlcnic_rcv_mbx_out *mbx_out; 858 int err; 859 860 err = qlcnic_sriov_validate_create_rx_ctx(cmd); 861 if (err) { 862 cmd->rsp.arg[0] |= (0x6 << 25); 863 return err; 864 } 865 866 cmd->req.arg[6] = vf->vp->handle; 867 err = qlcnic_issue_cmd(adapter, cmd); 868 869 if (!err) { 870 mbx_out = (struct qlcnic_rcv_mbx_out *)&cmd->rsp.arg[1]; 871 vf->rx_ctx_id = mbx_out->ctx_id; 872 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_ADD); 873 } else { 874 vf->rx_ctx_id = 0; 875 } 876 877 return err; 878 } 879 880 static int qlcnic_sriov_pf_mac_address_cmd(struct qlcnic_bc_trans *trans, 881 struct qlcnic_cmd_args *cmd) 882 { 883 struct qlcnic_vf_info *vf = trans->vf; 884 u8 type, *mac; 885 886 type = cmd->req.arg[1]; 887 switch (type) { 888 case QLCNIC_SET_STATION_MAC: 889 case QLCNIC_SET_FAC_DEF_MAC: 890 cmd->rsp.arg[0] = (2 << 25); 891 break; 892 case QLCNIC_GET_CURRENT_MAC: 893 cmd->rsp.arg[0] = (1 << 25); 894 mac = vf->vp->mac; 895 cmd->rsp.arg[2] = mac[1] | ((mac[0] << 8) & 0xff00); 896 cmd->rsp.arg[1] = mac[5] | ((mac[4] << 8) & 0xff00) | 897 ((mac[3]) << 16 & 0xff0000) | 898 ((mac[2]) << 24 & 0xff000000); 899 } 900 901 return 0; 902 } 903 904 static int qlcnic_sriov_validate_create_tx_ctx(struct qlcnic_cmd_args *cmd) 905 { 906 if ((cmd->req.arg[0] >> 29) != 0x3) 907 return -EINVAL; 908 909 return 0; 910 } 911 912 static int qlcnic_sriov_pf_create_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 913 struct qlcnic_cmd_args *cmd) 914 { 915 struct qlcnic_vf_info *vf = trans->vf; 916 struct qlcnic_adapter *adapter = vf->adapter; 917 struct qlcnic_tx_mbx_out *mbx_out; 918 int err; 919 920 err = qlcnic_sriov_validate_create_tx_ctx(cmd); 921 if (err) { 922 cmd->rsp.arg[0] |= (0x6 << 25); 923 return err; 924 } 925 926 cmd->req.arg[5] |= vf->vp->handle << 16; 927 err = qlcnic_issue_cmd(adapter, cmd); 928 if (!err) { 929 mbx_out = (struct qlcnic_tx_mbx_out *)&cmd->rsp.arg[2]; 930 vf->tx_ctx_id = mbx_out->ctx_id; 931 } else { 932 vf->tx_ctx_id = 0; 933 } 934 935 return err; 936 } 937 938 static int qlcnic_sriov_validate_del_rx_ctx(struct qlcnic_vf_info *vf, 939 struct qlcnic_cmd_args *cmd) 940 { 941 if ((cmd->req.arg[0] >> 29) != 0x3) 942 return -EINVAL; 943 944 if ((cmd->req.arg[1] & 0xffff) != vf->rx_ctx_id) 945 return -EINVAL; 946 947 return 0; 948 } 949 950 static int qlcnic_sriov_pf_del_rx_ctx_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_del_rx_ctx(vf, cmd); 958 if (err) { 959 cmd->rsp.arg[0] |= (0x6 << 25); 960 return err; 961 } 962 963 qlcnic_83xx_cfg_default_mac_vlan(adapter, vf, QLCNIC_MAC_DEL); 964 cmd->req.arg[1] |= vf->vp->handle << 16; 965 err = qlcnic_issue_cmd(adapter, cmd); 966 967 if (!err) 968 vf->rx_ctx_id = 0; 969 970 return err; 971 } 972 973 static int qlcnic_sriov_validate_del_tx_ctx(struct qlcnic_vf_info *vf, 974 struct qlcnic_cmd_args *cmd) 975 { 976 if ((cmd->req.arg[0] >> 29) != 0x3) 977 return -EINVAL; 978 979 if ((cmd->req.arg[1] & 0xffff) != vf->tx_ctx_id) 980 return -EINVAL; 981 982 return 0; 983 } 984 985 static int qlcnic_sriov_pf_del_tx_ctx_cmd(struct qlcnic_bc_trans *trans, 986 struct qlcnic_cmd_args *cmd) 987 { 988 struct qlcnic_vf_info *vf = trans->vf; 989 struct qlcnic_adapter *adapter = vf->adapter; 990 int err; 991 992 err = qlcnic_sriov_validate_del_tx_ctx(vf, cmd); 993 if (err) { 994 cmd->rsp.arg[0] |= (0x6 << 25); 995 return err; 996 } 997 998 cmd->req.arg[1] |= vf->vp->handle << 16; 999 err = qlcnic_issue_cmd(adapter, cmd); 1000 1001 if (!err) 1002 vf->tx_ctx_id = 0; 1003 1004 return err; 1005 } 1006 1007 static int qlcnic_sriov_validate_cfg_lro(struct qlcnic_vf_info *vf, 1008 struct qlcnic_cmd_args *cmd) 1009 { 1010 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 1011 return -EINVAL; 1012 1013 return 0; 1014 } 1015 1016 static int qlcnic_sriov_pf_cfg_lro_cmd(struct qlcnic_bc_trans *trans, 1017 struct qlcnic_cmd_args *cmd) 1018 { 1019 struct qlcnic_vf_info *vf = trans->vf; 1020 struct qlcnic_adapter *adapter = vf->adapter; 1021 int err; 1022 1023 err = qlcnic_sriov_validate_cfg_lro(vf, cmd); 1024 if (err) { 1025 cmd->rsp.arg[0] |= (0x6 << 25); 1026 return err; 1027 } 1028 1029 err = qlcnic_issue_cmd(adapter, cmd); 1030 return err; 1031 } 1032 1033 static int qlcnic_sriov_pf_cfg_ip_cmd(struct qlcnic_bc_trans *trans, 1034 struct qlcnic_cmd_args *cmd) 1035 { 1036 struct qlcnic_vf_info *vf = trans->vf; 1037 struct qlcnic_adapter *adapter = vf->adapter; 1038 int err = -EIO; 1039 u8 op; 1040 1041 op = cmd->req.arg[1] & 0xff; 1042 1043 cmd->req.arg[1] |= vf->vp->handle << 16; 1044 cmd->req.arg[1] |= BIT_31; 1045 1046 err = qlcnic_issue_cmd(adapter, cmd); 1047 return err; 1048 } 1049 1050 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf, 1051 struct qlcnic_cmd_args *cmd) 1052 { 1053 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func) 1054 return -EINVAL; 1055 1056 if (!(cmd->req.arg[1] & BIT_16)) 1057 return -EINVAL; 1058 1059 if ((cmd->req.arg[1] & 0xff) != 0x1) 1060 return -EINVAL; 1061 1062 return 0; 1063 } 1064 1065 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans, 1066 struct qlcnic_cmd_args *cmd) 1067 { 1068 struct qlcnic_vf_info *vf = trans->vf; 1069 struct qlcnic_adapter *adapter = vf->adapter; 1070 int err; 1071 1072 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd); 1073 if (err) 1074 cmd->rsp.arg[0] |= (0x6 << 25); 1075 else 1076 err = qlcnic_issue_cmd(adapter, cmd); 1077 1078 return err; 1079 } 1080 1081 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter, 1082 struct qlcnic_vf_info *vf, 1083 struct qlcnic_cmd_args *cmd) 1084 { 1085 if (cmd->req.arg[1] != vf->rx_ctx_id) 1086 return -EINVAL; 1087 1088 if (cmd->req.arg[2] > adapter->ahw->max_mtu) 1089 return -EINVAL; 1090 1091 return 0; 1092 } 1093 1094 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans, 1095 struct qlcnic_cmd_args *cmd) 1096 { 1097 struct qlcnic_vf_info *vf = trans->vf; 1098 struct qlcnic_adapter *adapter = vf->adapter; 1099 int err; 1100 1101 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd); 1102 if (err) 1103 cmd->rsp.arg[0] |= (0x6 << 25); 1104 else 1105 err = qlcnic_issue_cmd(adapter, cmd); 1106 1107 return err; 1108 } 1109 1110 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf, 1111 struct qlcnic_cmd_args *cmd) 1112 { 1113 if (cmd->req.arg[1] & BIT_31) { 1114 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func) 1115 return -EINVAL; 1116 } else { 1117 cmd->req.arg[1] |= vf->vp->handle << 16; 1118 } 1119 1120 return 0; 1121 } 1122 1123 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans, 1124 struct qlcnic_cmd_args *cmd) 1125 { 1126 struct qlcnic_vf_info *vf = trans->vf; 1127 struct qlcnic_adapter *adapter = vf->adapter; 1128 int err; 1129 1130 err = qlcnic_sriov_validate_get_nic_info(vf, cmd); 1131 if (err) { 1132 cmd->rsp.arg[0] |= (0x6 << 25); 1133 return err; 1134 } 1135 1136 err = qlcnic_issue_cmd(adapter, cmd); 1137 return err; 1138 } 1139 1140 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf, 1141 struct qlcnic_cmd_args *cmd) 1142 { 1143 if (cmd->req.arg[1] != vf->rx_ctx_id) 1144 return -EINVAL; 1145 1146 return 0; 1147 } 1148 1149 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans, 1150 struct qlcnic_cmd_args *cmd) 1151 { 1152 struct qlcnic_vf_info *vf = trans->vf; 1153 struct qlcnic_adapter *adapter = vf->adapter; 1154 int err; 1155 1156 err = qlcnic_sriov_validate_cfg_rss(vf, cmd); 1157 if (err) 1158 cmd->rsp.arg[0] |= (0x6 << 25); 1159 else 1160 err = qlcnic_issue_cmd(adapter, cmd); 1161 1162 return err; 1163 } 1164 1165 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter, 1166 struct qlcnic_vf_info *vf, 1167 struct qlcnic_cmd_args *cmd) 1168 { 1169 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal; 1170 u16 ctx_id, pkts, time; 1171 1172 ctx_id = cmd->req.arg[1] >> 16; 1173 pkts = cmd->req.arg[2] & 0xffff; 1174 time = cmd->req.arg[2] >> 16; 1175 1176 if (ctx_id != vf->rx_ctx_id) 1177 return -EINVAL; 1178 if (pkts > coal->rx_packets) 1179 return -EINVAL; 1180 if (time < coal->rx_time_us) 1181 return -EINVAL; 1182 1183 return 0; 1184 } 1185 1186 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran, 1187 struct qlcnic_cmd_args *cmd) 1188 { 1189 struct qlcnic_vf_info *vf = tran->vf; 1190 struct qlcnic_adapter *adapter = vf->adapter; 1191 int err; 1192 1193 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd); 1194 if (err) { 1195 cmd->rsp.arg[0] |= (0x6 << 25); 1196 return err; 1197 } 1198 1199 err = qlcnic_issue_cmd(adapter, cmd); 1200 return err; 1201 } 1202 1203 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter, 1204 struct qlcnic_vf_info *vf, 1205 struct qlcnic_cmd_args *cmd) 1206 { 1207 struct qlcnic_macvlan_mbx *macvlan; 1208 struct qlcnic_vport *vp = vf->vp; 1209 u8 op, new_op; 1210 1211 if (!(cmd->req.arg[1] & BIT_8)) 1212 return -EINVAL; 1213 1214 cmd->req.arg[1] |= (vf->vp->handle << 16); 1215 cmd->req.arg[1] |= BIT_31; 1216 1217 macvlan = (struct qlcnic_macvlan_mbx *)&cmd->req.arg[2]; 1218 if (!(macvlan->mac_addr0 & BIT_0)) { 1219 dev_err(&adapter->pdev->dev, 1220 "MAC address change is not allowed from VF %d", 1221 vf->pci_func); 1222 return -EINVAL; 1223 } 1224 1225 if (vp->vlan_mode == QLC_PVID_MODE) { 1226 op = cmd->req.arg[1] & 0x7; 1227 cmd->req.arg[1] &= ~0x7; 1228 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 1229 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL; 1230 cmd->req.arg[3] |= vp->pvid << 16; 1231 cmd->req.arg[1] |= new_op; 1232 } 1233 1234 return 0; 1235 } 1236 1237 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans, 1238 struct qlcnic_cmd_args *cmd) 1239 { 1240 struct qlcnic_vf_info *vf = trans->vf; 1241 struct qlcnic_adapter *adapter = vf->adapter; 1242 int err; 1243 1244 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd); 1245 if (err) { 1246 cmd->rsp.arg[0] |= (0x6 << 25); 1247 return err; 1248 } 1249 1250 err = qlcnic_issue_cmd(adapter, cmd); 1251 return err; 1252 } 1253 1254 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf, 1255 struct qlcnic_cmd_args *cmd) 1256 { 1257 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 1258 return -EINVAL; 1259 1260 return 0; 1261 } 1262 1263 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans, 1264 struct qlcnic_cmd_args *cmd) 1265 { 1266 struct qlcnic_vf_info *vf = trans->vf; 1267 struct qlcnic_adapter *adapter = vf->adapter; 1268 int err; 1269 1270 err = qlcnic_sriov_validate_linkevent(vf, cmd); 1271 if (err) { 1272 cmd->rsp.arg[0] |= (0x6 << 25); 1273 return err; 1274 } 1275 1276 err = qlcnic_issue_cmd(adapter, cmd); 1277 return err; 1278 } 1279 1280 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans, 1281 struct qlcnic_cmd_args *cmd) 1282 { 1283 struct qlcnic_vf_info *vf = trans->vf; 1284 struct qlcnic_adapter *adapter = vf->adapter; 1285 int err; 1286 1287 cmd->req.arg[1] |= vf->vp->handle << 16; 1288 cmd->req.arg[1] |= BIT_31; 1289 err = qlcnic_issue_cmd(adapter, cmd); 1290 return err; 1291 } 1292 1293 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans, 1294 struct qlcnic_cmd_args *cmd) 1295 { 1296 struct qlcnic_vf_info *vf = trans->vf; 1297 struct qlcnic_vport *vp = vf->vp; 1298 u8 cmd_op, mode = vp->vlan_mode; 1299 struct qlcnic_adapter *adapter; 1300 struct qlcnic_sriov *sriov; 1301 1302 adapter = vf->adapter; 1303 sriov = adapter->ahw->sriov; 1304 1305 cmd_op = trans->req_hdr->cmd_op; 1306 cmd->rsp.arg[0] |= 1 << 25; 1307 1308 /* For 84xx adapter in case of PVID , PFD should send vlan mode as 1309 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response 1310 */ 1311 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE) 1312 return 0; 1313 1314 switch (mode) { 1315 case QLC_GUEST_VLAN_MODE: 1316 cmd->rsp.arg[1] = mode | 1 << 8; 1317 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16; 1318 break; 1319 case QLC_PVID_MODE: 1320 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16; 1321 break; 1322 } 1323 1324 return 0; 1325 } 1326 1327 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter, 1328 struct qlcnic_vf_info *vf, 1329 struct qlcnic_cmd_args *cmd) 1330 { 1331 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1332 u16 vlan; 1333 1334 if (!qlcnic_sriov_check_any_vlan(vf)) 1335 return -EINVAL; 1336 1337 vlan = cmd->req.arg[1] >> 16; 1338 if (!vf->rx_ctx_id) { 1339 qlcnic_sriov_del_vlan_id(sriov, vf, vlan); 1340 return 0; 1341 } 1342 1343 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL); 1344 qlcnic_sriov_del_vlan_id(sriov, vf, vlan); 1345 1346 if (qlcnic_83xx_pf_check(adapter)) 1347 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 1348 0, QLCNIC_MAC_ADD); 1349 return 0; 1350 } 1351 1352 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter, 1353 struct qlcnic_vf_info *vf, 1354 struct qlcnic_cmd_args *cmd) 1355 { 1356 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1357 int err = -EIO; 1358 u16 vlan; 1359 1360 if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf)) 1361 return err; 1362 1363 vlan = cmd->req.arg[1] >> 16; 1364 1365 if (!vf->rx_ctx_id) { 1366 qlcnic_sriov_add_vlan_id(sriov, vf, vlan); 1367 return 0; 1368 } 1369 1370 if (qlcnic_83xx_pf_check(adapter)) { 1371 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, 1372 QLCNIC_MAC_DEL); 1373 if (err) 1374 return err; 1375 } 1376 1377 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD); 1378 1379 if (err) { 1380 if (qlcnic_83xx_pf_check(adapter)) 1381 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, 1382 QLCNIC_MAC_ADD); 1383 return err; 1384 } 1385 1386 qlcnic_sriov_add_vlan_id(sriov, vf, vlan); 1387 return err; 1388 } 1389 1390 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran, 1391 struct qlcnic_cmd_args *cmd) 1392 { 1393 struct qlcnic_vf_info *vf = tran->vf; 1394 struct qlcnic_adapter *adapter = vf->adapter; 1395 struct qlcnic_vport *vp = vf->vp; 1396 int err = -EIO; 1397 u8 op; 1398 1399 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) { 1400 cmd->rsp.arg[0] |= 2 << 25; 1401 return err; 1402 } 1403 1404 op = cmd->req.arg[1] & 0xf; 1405 1406 if (op) 1407 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd); 1408 else 1409 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd); 1410 1411 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25; 1412 return err; 1413 } 1414 1415 static const int qlcnic_pf_passthru_supp_cmds[] = { 1416 QLCNIC_CMD_GET_STATISTICS, 1417 QLCNIC_CMD_GET_PORT_CONFIG, 1418 QLCNIC_CMD_GET_LINK_STATUS, 1419 QLCNIC_CMD_INIT_NIC_FUNC, 1420 QLCNIC_CMD_STOP_NIC_FUNC, 1421 }; 1422 1423 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = { 1424 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1425 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1426 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd}, 1427 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd}, 1428 }; 1429 1430 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = { 1431 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd}, 1432 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd}, 1433 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd}, 1434 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd}, 1435 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd}, 1436 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd}, 1437 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd}, 1438 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd}, 1439 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd}, 1440 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd}, 1441 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd}, 1442 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd}, 1443 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd}, 1444 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd}, 1445 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd}, 1446 }; 1447 1448 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter, 1449 struct qlcnic_bc_trans *trans, 1450 struct qlcnic_cmd_args *cmd) 1451 { 1452 u8 size, cmd_op; 1453 1454 cmd_op = trans->req_hdr->cmd_op; 1455 1456 if (trans->req_hdr->op_type == QLC_BC_CMD) { 1457 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr); 1458 if (cmd_op < size) { 1459 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd); 1460 return; 1461 } 1462 } else { 1463 int i; 1464 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr); 1465 for (i = 0; i < size; i++) { 1466 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) { 1467 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd); 1468 return; 1469 } 1470 } 1471 1472 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds); 1473 for (i = 0; i < size; i++) { 1474 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) { 1475 qlcnic_issue_cmd(adapter, cmd); 1476 return; 1477 } 1478 } 1479 } 1480 1481 cmd->rsp.arg[0] |= (0x9 << 25); 1482 } 1483 1484 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter, 1485 u32 *int_id) 1486 { 1487 u16 vpid; 1488 1489 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1490 adapter->ahw->pci_func); 1491 *int_id |= vpid; 1492 } 1493 1494 void qlcnic_pf_set_interface_id_del_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 << 16; 1502 } 1503 1504 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter, 1505 u32 *int_id) 1506 { 1507 int 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_del_tx_ctx(struct qlcnic_adapter *adapter, 1515 u32 *int_id) 1516 { 1517 u16 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_promisc(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) | BIT_31; 1532 } 1533 1534 void qlcnic_pf_set_interface_id_ipaddr(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_macaddr(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 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter, 1555 struct qlcnic_vf_info *vf) 1556 { 1557 struct qlcnic_cmd_args cmd; 1558 int vpid; 1559 1560 if (!vf->rx_ctx_id) 1561 return; 1562 1563 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX)) 1564 return; 1565 1566 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1567 if (vpid >= 0) { 1568 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16; 1569 if (qlcnic_issue_cmd(adapter, &cmd)) 1570 dev_err(&adapter->pdev->dev, 1571 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1572 vf->pci_func); 1573 else 1574 vf->rx_ctx_id = 0; 1575 } 1576 1577 qlcnic_free_mbx_args(&cmd); 1578 } 1579 1580 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter, 1581 struct qlcnic_vf_info *vf) 1582 { 1583 struct qlcnic_cmd_args cmd; 1584 int vpid; 1585 1586 if (!vf->tx_ctx_id) 1587 return; 1588 1589 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX)) 1590 return; 1591 1592 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1593 if (vpid >= 0) { 1594 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16; 1595 if (qlcnic_issue_cmd(adapter, &cmd)) 1596 dev_err(&adapter->pdev->dev, 1597 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1598 vf->pci_func); 1599 else 1600 vf->tx_ctx_id = 0; 1601 } 1602 1603 qlcnic_free_mbx_args(&cmd); 1604 } 1605 1606 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov, 1607 struct qlcnic_vf_info *vf, 1608 struct qlcnic_bc_trans *trans) 1609 { 1610 struct qlcnic_trans_list *t_list = &vf->rcv_act; 1611 unsigned long flag; 1612 1613 spin_lock_irqsave(&t_list->lock, flag); 1614 1615 __qlcnic_sriov_add_act_list(sriov, vf, trans); 1616 1617 spin_unlock_irqrestore(&t_list->lock, flag); 1618 return 0; 1619 } 1620 1621 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf) 1622 { 1623 struct qlcnic_adapter *adapter = vf->adapter; 1624 1625 qlcnic_sriov_cleanup_list(&vf->rcv_pend); 1626 cancel_work_sync(&vf->trans_work); 1627 qlcnic_sriov_cleanup_list(&vf->rcv_act); 1628 1629 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1630 qlcnic_sriov_del_tx_ctx(adapter, vf); 1631 qlcnic_sriov_del_rx_ctx(adapter, vf); 1632 } 1633 1634 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func); 1635 1636 clear_bit(QLC_BC_VF_FLR, &vf->state); 1637 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1638 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf, 1639 vf->flr_trans); 1640 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1641 vf->flr_trans = NULL; 1642 } 1643 } 1644 1645 static void qlcnic_sriov_pf_process_flr(struct work_struct *work) 1646 { 1647 struct qlcnic_vf_info *vf; 1648 1649 vf = container_of(work, struct qlcnic_vf_info, flr_work); 1650 __qlcnic_sriov_process_flr(vf); 1651 return; 1652 } 1653 1654 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov, 1655 struct qlcnic_vf_info *vf, 1656 work_func_t func) 1657 { 1658 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state)) 1659 return; 1660 1661 INIT_WORK(&vf->flr_work, func); 1662 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work); 1663 } 1664 1665 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter, 1666 struct qlcnic_bc_trans *trans, 1667 struct qlcnic_vf_info *vf) 1668 { 1669 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1670 1671 set_bit(QLC_BC_VF_FLR, &vf->state); 1672 clear_bit(QLC_BC_VF_STATE, &vf->state); 1673 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1674 vf->flr_trans = trans; 1675 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1676 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n", 1677 vf->pci_func); 1678 } 1679 1680 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter, 1681 struct qlcnic_bc_trans *trans, 1682 struct qlcnic_vf_info *vf) 1683 { 1684 struct qlcnic_bc_hdr *hdr = trans->req_hdr; 1685 1686 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) && 1687 (hdr->op_type == QLC_BC_CMD) && 1688 test_bit(QLC_BC_VF_STATE, &vf->state)) { 1689 qlcnic_sriov_handle_soft_flr(adapter, trans, vf); 1690 return true; 1691 } 1692 1693 return false; 1694 } 1695 1696 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov, 1697 struct qlcnic_vf_info *vf) 1698 { 1699 struct net_device *dev = vf->adapter->netdev; 1700 struct qlcnic_vport *vp = vf->vp; 1701 1702 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) { 1703 clear_bit(QLC_BC_VF_FLR, &vf->state); 1704 return; 1705 } 1706 1707 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) { 1708 netdev_info(dev, "FLR for PCI func %d in progress\n", 1709 vf->pci_func); 1710 return; 1711 } 1712 1713 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) 1714 memset(vf->sriov_vlans, 0, 1715 sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans); 1716 1717 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1718 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func); 1719 } 1720 1721 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter) 1722 { 1723 struct qlcnic_hardware_context *ahw = adapter->ahw; 1724 struct qlcnic_sriov *sriov = ahw->sriov; 1725 struct qlcnic_vf_info *vf; 1726 u16 num_vfs = sriov->num_vfs; 1727 int i; 1728 1729 for (i = 0; i < num_vfs; i++) { 1730 vf = &sriov->vf_info[i]; 1731 vf->rx_ctx_id = 0; 1732 vf->tx_ctx_id = 0; 1733 cancel_work_sync(&vf->flr_work); 1734 __qlcnic_sriov_process_flr(vf); 1735 clear_bit(QLC_BC_VF_STATE, &vf->state); 1736 } 1737 1738 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func); 1739 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8); 1740 } 1741 1742 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter) 1743 { 1744 struct qlcnic_hardware_context *ahw = adapter->ahw; 1745 int err; 1746 1747 if (!qlcnic_sriov_enable_check(adapter)) 1748 return 0; 1749 1750 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 1751 1752 err = qlcnic_sriov_pf_init(adapter); 1753 if (err) 1754 return err; 1755 1756 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n", 1757 __func__, ahw->op_mode); 1758 return err; 1759 } 1760 1761 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1762 { 1763 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1764 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1765 int i, num_vfs; 1766 struct qlcnic_vf_info *vf_info; 1767 u8 *curr_mac; 1768 1769 if (!qlcnic_sriov_pf_check(adapter)) 1770 return -EOPNOTSUPP; 1771 1772 num_vfs = sriov->num_vfs; 1773 1774 if (!is_valid_ether_addr(mac) || vf >= num_vfs) 1775 return -EINVAL; 1776 1777 if (ether_addr_equal(adapter->mac_addr, mac)) { 1778 netdev_err(netdev, "MAC address is already in use by the PF\n"); 1779 return -EINVAL; 1780 } 1781 1782 for (i = 0; i < num_vfs; i++) { 1783 vf_info = &sriov->vf_info[i]; 1784 if (ether_addr_equal(vf_info->vp->mac, mac)) { 1785 netdev_err(netdev, 1786 "MAC address is already in use by VF %d\n", 1787 i); 1788 return -EINVAL; 1789 } 1790 } 1791 1792 vf_info = &sriov->vf_info[vf]; 1793 curr_mac = vf_info->vp->mac; 1794 1795 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1796 netdev_err(netdev, 1797 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1798 vf); 1799 return -EOPNOTSUPP; 1800 } 1801 1802 memcpy(curr_mac, mac, netdev->addr_len); 1803 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n", 1804 mac, vf); 1805 return 0; 1806 } 1807 1808 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, int tx_rate) 1809 { 1810 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1811 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1812 struct qlcnic_vf_info *vf_info; 1813 struct qlcnic_info nic_info; 1814 struct qlcnic_vport *vp; 1815 u16 vpid; 1816 1817 if (!qlcnic_sriov_pf_check(adapter)) 1818 return -EOPNOTSUPP; 1819 1820 if (vf >= sriov->num_vfs) 1821 return -EINVAL; 1822 1823 if (tx_rate >= 10000 || tx_rate < 100) { 1824 netdev_err(netdev, 1825 "Invalid Tx rate, allowed range is [%d - %d]", 1826 QLC_VF_MIN_TX_RATE, QLC_VF_MAX_TX_RATE); 1827 return -EINVAL; 1828 } 1829 1830 if (tx_rate == 0) 1831 tx_rate = 10000; 1832 1833 vf_info = &sriov->vf_info[vf]; 1834 vp = vf_info->vp; 1835 vpid = vp->handle; 1836 1837 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1838 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid)) 1839 return -EIO; 1840 1841 nic_info.max_tx_bw = tx_rate / 100; 1842 nic_info.bit_offsets = BIT_0; 1843 1844 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid)) 1845 return -EIO; 1846 } 1847 1848 vp->max_tx_bw = tx_rate / 100; 1849 netdev_info(netdev, 1850 "Setting Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1851 tx_rate, vp->max_tx_bw, vf); 1852 return 0; 1853 } 1854 1855 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf, 1856 u16 vlan, u8 qos) 1857 { 1858 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1859 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1860 struct qlcnic_vf_info *vf_info; 1861 struct qlcnic_vport *vp; 1862 1863 if (!qlcnic_sriov_pf_check(adapter)) 1864 return -EOPNOTSUPP; 1865 1866 if (vf >= sriov->num_vfs || qos > 7) 1867 return -EINVAL; 1868 1869 if (vlan > MAX_VLAN_ID) { 1870 netdev_err(netdev, 1871 "Invalid VLAN ID, allowed range is [0 - %d]\n", 1872 MAX_VLAN_ID); 1873 return -EINVAL; 1874 } 1875 1876 vf_info = &sriov->vf_info[vf]; 1877 vp = vf_info->vp; 1878 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1879 netdev_err(netdev, 1880 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1881 vf); 1882 return -EOPNOTSUPP; 1883 } 1884 1885 memset(vf_info->sriov_vlans, 0, 1886 sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans); 1887 1888 switch (vlan) { 1889 case 4095: 1890 vp->vlan_mode = QLC_GUEST_VLAN_MODE; 1891 break; 1892 case 0: 1893 vp->vlan_mode = QLC_NO_VLAN_MODE; 1894 vp->qos = 0; 1895 break; 1896 default: 1897 vp->vlan_mode = QLC_PVID_MODE; 1898 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan); 1899 vp->qos = qos; 1900 vp->pvid = vlan; 1901 } 1902 1903 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n", 1904 vlan, qos, vf); 1905 return 0; 1906 } 1907 1908 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter, 1909 struct qlcnic_vport *vp, int vf) 1910 { 1911 __u32 vlan = 0; 1912 1913 switch (vp->vlan_mode) { 1914 case QLC_PVID_MODE: 1915 vlan = vp->pvid; 1916 break; 1917 case QLC_GUEST_VLAN_MODE: 1918 vlan = MAX_VLAN_ID; 1919 break; 1920 case QLC_NO_VLAN_MODE: 1921 vlan = 0; 1922 break; 1923 default: 1924 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n", 1925 vp->vlan_mode, vf); 1926 } 1927 1928 return vlan; 1929 } 1930 1931 int qlcnic_sriov_get_vf_config(struct net_device *netdev, 1932 int vf, struct ifla_vf_info *ivi) 1933 { 1934 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1935 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1936 struct qlcnic_vport *vp; 1937 1938 if (!qlcnic_sriov_pf_check(adapter)) 1939 return -EOPNOTSUPP; 1940 1941 if (vf >= sriov->num_vfs) 1942 return -EINVAL; 1943 1944 vp = sriov->vf_info[vf].vp; 1945 memcpy(&ivi->mac, vp->mac, ETH_ALEN); 1946 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf); 1947 ivi->qos = vp->qos; 1948 ivi->spoofchk = vp->spoofchk; 1949 if (vp->max_tx_bw == MAX_BW) 1950 ivi->tx_rate = 0; 1951 else 1952 ivi->tx_rate = vp->max_tx_bw * 100; 1953 1954 ivi->vf = vf; 1955 return 0; 1956 } 1957 1958 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk) 1959 { 1960 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1961 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1962 struct qlcnic_vf_info *vf_info; 1963 struct qlcnic_vport *vp; 1964 1965 if (!qlcnic_sriov_pf_check(adapter)) 1966 return -EOPNOTSUPP; 1967 1968 if (vf >= sriov->num_vfs) 1969 return -EINVAL; 1970 1971 vf_info = &sriov->vf_info[vf]; 1972 vp = vf_info->vp; 1973 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1974 netdev_err(netdev, 1975 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1976 vf); 1977 return -EOPNOTSUPP; 1978 } 1979 1980 vp->spoofchk = chk; 1981 return 0; 1982 } 1983