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