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 1071 cmd->req.arg[1] |= vf->vp->handle << 16; 1072 cmd->req.arg[1] |= BIT_31; 1073 1074 err = qlcnic_issue_cmd(adapter, cmd); 1075 return err; 1076 } 1077 1078 static int qlcnic_sriov_validate_cfg_intrpt(struct qlcnic_vf_info *vf, 1079 struct qlcnic_cmd_args *cmd) 1080 { 1081 if (((cmd->req.arg[1] >> 8) & 0xff) != vf->pci_func) 1082 return -EINVAL; 1083 1084 if (!(cmd->req.arg[1] & BIT_16)) 1085 return -EINVAL; 1086 1087 if ((cmd->req.arg[1] & 0xff) != 0x1) 1088 return -EINVAL; 1089 1090 return 0; 1091 } 1092 1093 static int qlcnic_sriov_pf_cfg_intrpt_cmd(struct qlcnic_bc_trans *trans, 1094 struct qlcnic_cmd_args *cmd) 1095 { 1096 struct qlcnic_vf_info *vf = trans->vf; 1097 struct qlcnic_adapter *adapter = vf->adapter; 1098 int err; 1099 1100 err = qlcnic_sriov_validate_cfg_intrpt(vf, cmd); 1101 if (err) 1102 cmd->rsp.arg[0] |= (0x6 << 25); 1103 else 1104 err = qlcnic_issue_cmd(adapter, cmd); 1105 1106 return err; 1107 } 1108 1109 static int qlcnic_sriov_validate_mtu(struct qlcnic_adapter *adapter, 1110 struct qlcnic_vf_info *vf, 1111 struct qlcnic_cmd_args *cmd) 1112 { 1113 if (cmd->req.arg[1] != vf->rx_ctx_id) 1114 return -EINVAL; 1115 1116 if (cmd->req.arg[2] > adapter->ahw->max_mtu) 1117 return -EINVAL; 1118 1119 return 0; 1120 } 1121 1122 static int qlcnic_sriov_pf_set_mtu_cmd(struct qlcnic_bc_trans *trans, 1123 struct qlcnic_cmd_args *cmd) 1124 { 1125 struct qlcnic_vf_info *vf = trans->vf; 1126 struct qlcnic_adapter *adapter = vf->adapter; 1127 int err; 1128 1129 err = qlcnic_sriov_validate_mtu(adapter, vf, cmd); 1130 if (err) 1131 cmd->rsp.arg[0] |= (0x6 << 25); 1132 else 1133 err = qlcnic_issue_cmd(adapter, cmd); 1134 1135 return err; 1136 } 1137 1138 static int qlcnic_sriov_validate_get_nic_info(struct qlcnic_vf_info *vf, 1139 struct qlcnic_cmd_args *cmd) 1140 { 1141 if (cmd->req.arg[1] & BIT_31) { 1142 if (((cmd->req.arg[1] >> 16) & 0x7fff) != vf->pci_func) 1143 return -EINVAL; 1144 } else { 1145 cmd->req.arg[1] |= vf->vp->handle << 16; 1146 } 1147 1148 return 0; 1149 } 1150 1151 static int qlcnic_sriov_pf_get_nic_info_cmd(struct qlcnic_bc_trans *trans, 1152 struct qlcnic_cmd_args *cmd) 1153 { 1154 struct qlcnic_vf_info *vf = trans->vf; 1155 struct qlcnic_adapter *adapter = vf->adapter; 1156 int err; 1157 1158 err = qlcnic_sriov_validate_get_nic_info(vf, cmd); 1159 if (err) { 1160 cmd->rsp.arg[0] |= (0x6 << 25); 1161 return err; 1162 } 1163 1164 err = qlcnic_issue_cmd(adapter, cmd); 1165 return err; 1166 } 1167 1168 static int qlcnic_sriov_validate_cfg_rss(struct qlcnic_vf_info *vf, 1169 struct qlcnic_cmd_args *cmd) 1170 { 1171 if (cmd->req.arg[1] != vf->rx_ctx_id) 1172 return -EINVAL; 1173 1174 return 0; 1175 } 1176 1177 static int qlcnic_sriov_pf_cfg_rss_cmd(struct qlcnic_bc_trans *trans, 1178 struct qlcnic_cmd_args *cmd) 1179 { 1180 struct qlcnic_vf_info *vf = trans->vf; 1181 struct qlcnic_adapter *adapter = vf->adapter; 1182 int err; 1183 1184 err = qlcnic_sriov_validate_cfg_rss(vf, cmd); 1185 if (err) 1186 cmd->rsp.arg[0] |= (0x6 << 25); 1187 else 1188 err = qlcnic_issue_cmd(adapter, cmd); 1189 1190 return err; 1191 } 1192 1193 static int qlcnic_sriov_validate_cfg_intrcoal(struct qlcnic_adapter *adapter, 1194 struct qlcnic_vf_info *vf, 1195 struct qlcnic_cmd_args *cmd) 1196 { 1197 struct qlcnic_nic_intr_coalesce *coal = &adapter->ahw->coal; 1198 u16 ctx_id, pkts, time; 1199 int err = -EINVAL; 1200 u8 type; 1201 1202 type = cmd->req.arg[1] & QLC_INTR_COAL_TYPE_MASK; 1203 ctx_id = cmd->req.arg[1] >> 16; 1204 pkts = cmd->req.arg[2] & 0xffff; 1205 time = cmd->req.arg[2] >> 16; 1206 1207 switch (type) { 1208 case QLCNIC_INTR_COAL_TYPE_RX: 1209 if (ctx_id != vf->rx_ctx_id || pkts > coal->rx_packets || 1210 time < coal->rx_time_us) 1211 goto err_label; 1212 break; 1213 case QLCNIC_INTR_COAL_TYPE_TX: 1214 if (ctx_id != vf->tx_ctx_id || pkts > coal->tx_packets || 1215 time < coal->tx_time_us) 1216 goto err_label; 1217 break; 1218 default: 1219 netdev_err(adapter->netdev, "Invalid coalescing type 0x%x received\n", 1220 type); 1221 return err; 1222 } 1223 1224 return 0; 1225 1226 err_label: 1227 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", 1228 vf->rx_ctx_id, coal->rx_packets, coal->rx_time_us, 1229 vf->tx_ctx_id, coal->tx_packets, coal->tx_time_us); 1230 netdev_err(adapter->netdev, "Received: ctx_id 0x%x packets 0x%x time_us 0x%x type 0x%x\n", 1231 ctx_id, pkts, time, type); 1232 1233 return err; 1234 } 1235 1236 static int qlcnic_sriov_pf_cfg_intrcoal_cmd(struct qlcnic_bc_trans *tran, 1237 struct qlcnic_cmd_args *cmd) 1238 { 1239 struct qlcnic_vf_info *vf = tran->vf; 1240 struct qlcnic_adapter *adapter = vf->adapter; 1241 int err; 1242 1243 err = qlcnic_sriov_validate_cfg_intrcoal(adapter, vf, cmd); 1244 if (err) { 1245 cmd->rsp.arg[0] |= (0x6 << 25); 1246 return err; 1247 } 1248 1249 err = qlcnic_issue_cmd(adapter, cmd); 1250 return err; 1251 } 1252 1253 static int qlcnic_sriov_validate_cfg_macvlan(struct qlcnic_adapter *adapter, 1254 struct qlcnic_vf_info *vf, 1255 struct qlcnic_cmd_args *cmd) 1256 { 1257 struct qlcnic_vport *vp = vf->vp; 1258 u8 op, new_op; 1259 1260 if (!(cmd->req.arg[1] & BIT_8)) 1261 return -EINVAL; 1262 1263 cmd->req.arg[1] |= (vf->vp->handle << 16); 1264 cmd->req.arg[1] |= BIT_31; 1265 1266 if (vp->vlan_mode == QLC_PVID_MODE) { 1267 op = cmd->req.arg[1] & 0x7; 1268 cmd->req.arg[1] &= ~0x7; 1269 new_op = (op == QLCNIC_MAC_ADD || op == QLCNIC_MAC_VLAN_ADD) ? 1270 QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_VLAN_DEL; 1271 cmd->req.arg[3] |= vp->pvid << 16; 1272 cmd->req.arg[1] |= new_op; 1273 } 1274 1275 return 0; 1276 } 1277 1278 static int qlcnic_sriov_pf_cfg_macvlan_cmd(struct qlcnic_bc_trans *trans, 1279 struct qlcnic_cmd_args *cmd) 1280 { 1281 struct qlcnic_vf_info *vf = trans->vf; 1282 struct qlcnic_adapter *adapter = vf->adapter; 1283 int err; 1284 1285 err = qlcnic_sriov_validate_cfg_macvlan(adapter, vf, cmd); 1286 if (err) { 1287 cmd->rsp.arg[0] |= (0x6 << 25); 1288 return err; 1289 } 1290 1291 err = qlcnic_issue_cmd(adapter, cmd); 1292 return err; 1293 } 1294 1295 static int qlcnic_sriov_validate_linkevent(struct qlcnic_vf_info *vf, 1296 struct qlcnic_cmd_args *cmd) 1297 { 1298 if ((cmd->req.arg[1] >> 16) != vf->rx_ctx_id) 1299 return -EINVAL; 1300 1301 return 0; 1302 } 1303 1304 static int qlcnic_sriov_pf_linkevent_cmd(struct qlcnic_bc_trans *trans, 1305 struct qlcnic_cmd_args *cmd) 1306 { 1307 struct qlcnic_vf_info *vf = trans->vf; 1308 struct qlcnic_adapter *adapter = vf->adapter; 1309 int err; 1310 1311 err = qlcnic_sriov_validate_linkevent(vf, cmd); 1312 if (err) { 1313 cmd->rsp.arg[0] |= (0x6 << 25); 1314 return err; 1315 } 1316 1317 err = qlcnic_issue_cmd(adapter, cmd); 1318 return err; 1319 } 1320 1321 static int qlcnic_sriov_pf_cfg_promisc_cmd(struct qlcnic_bc_trans *trans, 1322 struct qlcnic_cmd_args *cmd) 1323 { 1324 struct qlcnic_vf_info *vf = trans->vf; 1325 struct qlcnic_adapter *adapter = vf->adapter; 1326 int err; 1327 1328 cmd->req.arg[1] |= vf->vp->handle << 16; 1329 cmd->req.arg[1] |= BIT_31; 1330 err = qlcnic_issue_cmd(adapter, cmd); 1331 return err; 1332 } 1333 1334 static int qlcnic_sriov_pf_get_acl_cmd(struct qlcnic_bc_trans *trans, 1335 struct qlcnic_cmd_args *cmd) 1336 { 1337 struct qlcnic_vf_info *vf = trans->vf; 1338 struct qlcnic_vport *vp = vf->vp; 1339 u8 mode = vp->vlan_mode; 1340 struct qlcnic_adapter *adapter; 1341 struct qlcnic_sriov *sriov; 1342 1343 adapter = vf->adapter; 1344 sriov = adapter->ahw->sriov; 1345 1346 cmd->rsp.arg[0] |= 1 << 25; 1347 1348 /* For 84xx adapter in case of PVID , PFD should send vlan mode as 1349 * QLC_NO_VLAN_MODE to VFD which is zero in mailbox response 1350 */ 1351 if (qlcnic_84xx_check(adapter) && mode == QLC_PVID_MODE) 1352 return 0; 1353 1354 switch (mode) { 1355 case QLC_GUEST_VLAN_MODE: 1356 cmd->rsp.arg[1] = mode | 1 << 8; 1357 cmd->rsp.arg[2] = sriov->num_allowed_vlans << 16; 1358 break; 1359 case QLC_PVID_MODE: 1360 cmd->rsp.arg[1] = mode | 1 << 8 | vp->pvid << 16; 1361 break; 1362 } 1363 1364 return 0; 1365 } 1366 1367 static int qlcnic_sriov_pf_del_guest_vlan(struct qlcnic_adapter *adapter, 1368 struct qlcnic_vf_info *vf, 1369 struct qlcnic_cmd_args *cmd) 1370 { 1371 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1372 u16 vlan; 1373 1374 if (!qlcnic_sriov_check_any_vlan(vf)) 1375 return -EINVAL; 1376 1377 vlan = cmd->req.arg[1] >> 16; 1378 if (!vf->rx_ctx_id) { 1379 qlcnic_sriov_del_vlan_id(sriov, vf, vlan); 1380 return 0; 1381 } 1382 1383 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_DEL); 1384 qlcnic_sriov_del_vlan_id(sriov, vf, vlan); 1385 1386 if (qlcnic_83xx_pf_check(adapter)) 1387 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 1388 0, QLCNIC_MAC_ADD); 1389 return 0; 1390 } 1391 1392 static int qlcnic_sriov_pf_add_guest_vlan(struct qlcnic_adapter *adapter, 1393 struct qlcnic_vf_info *vf, 1394 struct qlcnic_cmd_args *cmd) 1395 { 1396 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1397 int err = -EIO; 1398 u16 vlan; 1399 1400 if (qlcnic_83xx_pf_check(adapter) && qlcnic_sriov_check_any_vlan(vf)) 1401 return err; 1402 1403 vlan = cmd->req.arg[1] >> 16; 1404 1405 if (!vf->rx_ctx_id) { 1406 qlcnic_sriov_add_vlan_id(sriov, vf, vlan); 1407 return 0; 1408 } 1409 1410 if (qlcnic_83xx_pf_check(adapter)) { 1411 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, 1412 QLCNIC_MAC_DEL); 1413 if (err) 1414 return err; 1415 } 1416 1417 err = qlcnic_sriov_cfg_vf_def_mac(adapter, vf, vlan, QLCNIC_MAC_ADD); 1418 1419 if (err) { 1420 if (qlcnic_83xx_pf_check(adapter)) 1421 qlcnic_sriov_cfg_vf_def_mac(adapter, vf, 0, 1422 QLCNIC_MAC_ADD); 1423 return err; 1424 } 1425 1426 qlcnic_sriov_add_vlan_id(sriov, vf, vlan); 1427 return err; 1428 } 1429 1430 static int qlcnic_sriov_pf_cfg_guest_vlan_cmd(struct qlcnic_bc_trans *tran, 1431 struct qlcnic_cmd_args *cmd) 1432 { 1433 struct qlcnic_vf_info *vf = tran->vf; 1434 struct qlcnic_adapter *adapter = vf->adapter; 1435 struct qlcnic_vport *vp = vf->vp; 1436 int err = -EIO; 1437 u8 op; 1438 1439 if (vp->vlan_mode != QLC_GUEST_VLAN_MODE) { 1440 cmd->rsp.arg[0] |= 2 << 25; 1441 return err; 1442 } 1443 1444 op = cmd->req.arg[1] & 0xf; 1445 1446 if (op) 1447 err = qlcnic_sriov_pf_add_guest_vlan(adapter, vf, cmd); 1448 else 1449 err = qlcnic_sriov_pf_del_guest_vlan(adapter, vf, cmd); 1450 1451 cmd->rsp.arg[0] |= err ? 2 << 25 : 1 << 25; 1452 return err; 1453 } 1454 1455 static const int qlcnic_pf_passthru_supp_cmds[] = { 1456 QLCNIC_CMD_GET_STATISTICS, 1457 QLCNIC_CMD_GET_PORT_CONFIG, 1458 QLCNIC_CMD_GET_LINK_STATUS, 1459 QLCNIC_CMD_INIT_NIC_FUNC, 1460 QLCNIC_CMD_STOP_NIC_FUNC, 1461 }; 1462 1463 static const struct qlcnic_sriov_cmd_handler qlcnic_pf_bc_cmd_hdlr[] = { 1464 [QLCNIC_BC_CMD_CHANNEL_INIT] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1465 [QLCNIC_BC_CMD_CHANNEL_TERM] = {&qlcnic_sriov_pf_channel_cfg_cmd}, 1466 [QLCNIC_BC_CMD_GET_ACL] = {&qlcnic_sriov_pf_get_acl_cmd}, 1467 [QLCNIC_BC_CMD_CFG_GUEST_VLAN] = {&qlcnic_sriov_pf_cfg_guest_vlan_cmd}, 1468 }; 1469 1470 static const struct qlcnic_sriov_fw_cmd_handler qlcnic_pf_fw_cmd_hdlr[] = { 1471 {QLCNIC_CMD_CREATE_RX_CTX, qlcnic_sriov_pf_create_rx_ctx_cmd}, 1472 {QLCNIC_CMD_CREATE_TX_CTX, qlcnic_sriov_pf_create_tx_ctx_cmd}, 1473 {QLCNIC_CMD_MAC_ADDRESS, qlcnic_sriov_pf_mac_address_cmd}, 1474 {QLCNIC_CMD_DESTROY_RX_CTX, qlcnic_sriov_pf_del_rx_ctx_cmd}, 1475 {QLCNIC_CMD_DESTROY_TX_CTX, qlcnic_sriov_pf_del_tx_ctx_cmd}, 1476 {QLCNIC_CMD_CONFIGURE_HW_LRO, qlcnic_sriov_pf_cfg_lro_cmd}, 1477 {QLCNIC_CMD_CONFIGURE_IP_ADDR, qlcnic_sriov_pf_cfg_ip_cmd}, 1478 {QLCNIC_CMD_CONFIG_INTRPT, qlcnic_sriov_pf_cfg_intrpt_cmd}, 1479 {QLCNIC_CMD_SET_MTU, qlcnic_sriov_pf_set_mtu_cmd}, 1480 {QLCNIC_CMD_GET_NIC_INFO, qlcnic_sriov_pf_get_nic_info_cmd}, 1481 {QLCNIC_CMD_CONFIGURE_RSS, qlcnic_sriov_pf_cfg_rss_cmd}, 1482 {QLCNIC_CMD_CONFIG_INTR_COAL, qlcnic_sriov_pf_cfg_intrcoal_cmd}, 1483 {QLCNIC_CMD_CONFIG_MAC_VLAN, qlcnic_sriov_pf_cfg_macvlan_cmd}, 1484 {QLCNIC_CMD_GET_LINK_EVENT, qlcnic_sriov_pf_linkevent_cmd}, 1485 {QLCNIC_CMD_CONFIGURE_MAC_RX_MODE, qlcnic_sriov_pf_cfg_promisc_cmd}, 1486 }; 1487 1488 void qlcnic_sriov_pf_process_bc_cmd(struct qlcnic_adapter *adapter, 1489 struct qlcnic_bc_trans *trans, 1490 struct qlcnic_cmd_args *cmd) 1491 { 1492 u8 size, cmd_op; 1493 1494 cmd_op = trans->req_hdr->cmd_op; 1495 1496 if (trans->req_hdr->op_type == QLC_BC_CMD) { 1497 size = ARRAY_SIZE(qlcnic_pf_bc_cmd_hdlr); 1498 if (cmd_op < size) { 1499 qlcnic_pf_bc_cmd_hdlr[cmd_op].fn(trans, cmd); 1500 return; 1501 } 1502 } else { 1503 int i; 1504 size = ARRAY_SIZE(qlcnic_pf_fw_cmd_hdlr); 1505 for (i = 0; i < size; i++) { 1506 if (cmd_op == qlcnic_pf_fw_cmd_hdlr[i].cmd) { 1507 qlcnic_pf_fw_cmd_hdlr[i].fn(trans, cmd); 1508 return; 1509 } 1510 } 1511 1512 size = ARRAY_SIZE(qlcnic_pf_passthru_supp_cmds); 1513 for (i = 0; i < size; i++) { 1514 if (cmd_op == qlcnic_pf_passthru_supp_cmds[i]) { 1515 qlcnic_issue_cmd(adapter, cmd); 1516 return; 1517 } 1518 } 1519 } 1520 1521 cmd->rsp.arg[0] |= (0x9 << 25); 1522 } 1523 1524 void qlcnic_pf_set_interface_id_create_rx_ctx(struct qlcnic_adapter *adapter, 1525 u32 *int_id) 1526 { 1527 u16 vpid; 1528 1529 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1530 adapter->ahw->pci_func); 1531 *int_id |= vpid; 1532 } 1533 1534 void qlcnic_pf_set_interface_id_del_rx_ctx(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; 1542 } 1543 1544 void qlcnic_pf_set_interface_id_create_tx_ctx(struct qlcnic_adapter *adapter, 1545 u32 *int_id) 1546 { 1547 int vpid; 1548 1549 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1550 adapter->ahw->pci_func); 1551 *int_id |= vpid << 16; 1552 } 1553 1554 void qlcnic_pf_set_interface_id_del_tx_ctx(struct qlcnic_adapter *adapter, 1555 u32 *int_id) 1556 { 1557 u16 vpid; 1558 1559 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1560 adapter->ahw->pci_func); 1561 *int_id |= vpid << 16; 1562 } 1563 1564 void qlcnic_pf_set_interface_id_promisc(struct qlcnic_adapter *adapter, 1565 u32 *int_id) 1566 { 1567 u16 vpid; 1568 1569 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1570 adapter->ahw->pci_func); 1571 *int_id |= (vpid << 16) | BIT_31; 1572 } 1573 1574 void qlcnic_pf_set_interface_id_ipaddr(struct qlcnic_adapter *adapter, 1575 u32 *int_id) 1576 { 1577 u16 vpid; 1578 1579 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1580 adapter->ahw->pci_func); 1581 *int_id |= (vpid << 16) | BIT_31; 1582 } 1583 1584 void qlcnic_pf_set_interface_id_macaddr(struct qlcnic_adapter *adapter, 1585 u32 *int_id) 1586 { 1587 u16 vpid; 1588 1589 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, 1590 adapter->ahw->pci_func); 1591 *int_id |= (vpid << 16) | BIT_31; 1592 } 1593 1594 static void qlcnic_sriov_del_rx_ctx(struct qlcnic_adapter *adapter, 1595 struct qlcnic_vf_info *vf) 1596 { 1597 struct qlcnic_cmd_args cmd; 1598 int vpid; 1599 1600 if (!vf->rx_ctx_id) 1601 return; 1602 1603 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_RX_CTX)) 1604 return; 1605 1606 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1607 if (vpid >= 0) { 1608 cmd.req.arg[1] = vf->rx_ctx_id | (vpid & 0xffff) << 16; 1609 if (qlcnic_issue_cmd(adapter, &cmd)) 1610 dev_err(&adapter->pdev->dev, 1611 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1612 vf->pci_func); 1613 else 1614 vf->rx_ctx_id = 0; 1615 } 1616 1617 qlcnic_free_mbx_args(&cmd); 1618 } 1619 1620 static void qlcnic_sriov_del_tx_ctx(struct qlcnic_adapter *adapter, 1621 struct qlcnic_vf_info *vf) 1622 { 1623 struct qlcnic_cmd_args cmd; 1624 int vpid; 1625 1626 if (!vf->tx_ctx_id) 1627 return; 1628 1629 if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_DESTROY_TX_CTX)) 1630 return; 1631 1632 vpid = qlcnic_sriov_pf_get_vport_handle(adapter, vf->pci_func); 1633 if (vpid >= 0) { 1634 cmd.req.arg[1] |= vf->tx_ctx_id | (vpid & 0xffff) << 16; 1635 if (qlcnic_issue_cmd(adapter, &cmd)) 1636 dev_err(&adapter->pdev->dev, 1637 "Failed to delete Tx ctx in firmware for func 0x%x\n", 1638 vf->pci_func); 1639 else 1640 vf->tx_ctx_id = 0; 1641 } 1642 1643 qlcnic_free_mbx_args(&cmd); 1644 } 1645 1646 static int qlcnic_sriov_add_act_list_irqsave(struct qlcnic_sriov *sriov, 1647 struct qlcnic_vf_info *vf, 1648 struct qlcnic_bc_trans *trans) 1649 { 1650 struct qlcnic_trans_list *t_list = &vf->rcv_act; 1651 unsigned long flag; 1652 1653 spin_lock_irqsave(&t_list->lock, flag); 1654 1655 __qlcnic_sriov_add_act_list(sriov, vf, trans); 1656 1657 spin_unlock_irqrestore(&t_list->lock, flag); 1658 return 0; 1659 } 1660 1661 static void __qlcnic_sriov_process_flr(struct qlcnic_vf_info *vf) 1662 { 1663 struct qlcnic_adapter *adapter = vf->adapter; 1664 1665 qlcnic_sriov_cleanup_list(&vf->rcv_pend); 1666 cancel_work_sync(&vf->trans_work); 1667 qlcnic_sriov_cleanup_list(&vf->rcv_act); 1668 1669 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1670 qlcnic_sriov_del_tx_ctx(adapter, vf); 1671 qlcnic_sriov_del_rx_ctx(adapter, vf); 1672 } 1673 1674 qlcnic_sriov_pf_config_vport(adapter, 0, vf->pci_func); 1675 1676 clear_bit(QLC_BC_VF_FLR, &vf->state); 1677 if (test_bit(QLC_BC_VF_SOFT_FLR, &vf->state)) { 1678 qlcnic_sriov_add_act_list_irqsave(adapter->ahw->sriov, vf, 1679 vf->flr_trans); 1680 clear_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1681 vf->flr_trans = NULL; 1682 } 1683 } 1684 1685 static void qlcnic_sriov_pf_process_flr(struct work_struct *work) 1686 { 1687 struct qlcnic_vf_info *vf; 1688 1689 vf = container_of(work, struct qlcnic_vf_info, flr_work); 1690 __qlcnic_sriov_process_flr(vf); 1691 return; 1692 } 1693 1694 static void qlcnic_sriov_schedule_flr(struct qlcnic_sriov *sriov, 1695 struct qlcnic_vf_info *vf, 1696 work_func_t func) 1697 { 1698 if (test_bit(__QLCNIC_RESETTING, &vf->adapter->state)) 1699 return; 1700 1701 INIT_WORK(&vf->flr_work, func); 1702 queue_work(sriov->bc.bc_flr_wq, &vf->flr_work); 1703 } 1704 1705 static void qlcnic_sriov_handle_soft_flr(struct qlcnic_adapter *adapter, 1706 struct qlcnic_bc_trans *trans, 1707 struct qlcnic_vf_info *vf) 1708 { 1709 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1710 1711 set_bit(QLC_BC_VF_FLR, &vf->state); 1712 clear_bit(QLC_BC_VF_STATE, &vf->state); 1713 set_bit(QLC_BC_VF_SOFT_FLR, &vf->state); 1714 vf->flr_trans = trans; 1715 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1716 netdev_info(adapter->netdev, "Software FLR for PCI func %d\n", 1717 vf->pci_func); 1718 } 1719 1720 bool qlcnic_sriov_soft_flr_check(struct qlcnic_adapter *adapter, 1721 struct qlcnic_bc_trans *trans, 1722 struct qlcnic_vf_info *vf) 1723 { 1724 struct qlcnic_bc_hdr *hdr = trans->req_hdr; 1725 1726 if ((hdr->cmd_op == QLCNIC_BC_CMD_CHANNEL_INIT) && 1727 (hdr->op_type == QLC_BC_CMD) && 1728 test_bit(QLC_BC_VF_STATE, &vf->state)) { 1729 qlcnic_sriov_handle_soft_flr(adapter, trans, vf); 1730 return true; 1731 } 1732 1733 return false; 1734 } 1735 1736 void qlcnic_sriov_pf_handle_flr(struct qlcnic_sriov *sriov, 1737 struct qlcnic_vf_info *vf) 1738 { 1739 struct net_device *dev = vf->adapter->netdev; 1740 struct qlcnic_vport *vp = vf->vp; 1741 1742 if (!test_and_clear_bit(QLC_BC_VF_STATE, &vf->state)) { 1743 clear_bit(QLC_BC_VF_FLR, &vf->state); 1744 return; 1745 } 1746 1747 if (test_and_set_bit(QLC_BC_VF_FLR, &vf->state)) { 1748 netdev_info(dev, "FLR for PCI func %d in progress\n", 1749 vf->pci_func); 1750 return; 1751 } 1752 1753 if (vp->vlan_mode == QLC_GUEST_VLAN_MODE) 1754 memset(vf->sriov_vlans, 0, 1755 sizeof(*vf->sriov_vlans) * sriov->num_allowed_vlans); 1756 1757 qlcnic_sriov_schedule_flr(sriov, vf, qlcnic_sriov_pf_process_flr); 1758 netdev_info(dev, "FLR received for PCI func %d\n", vf->pci_func); 1759 } 1760 1761 void qlcnic_sriov_pf_reset(struct qlcnic_adapter *adapter) 1762 { 1763 struct qlcnic_hardware_context *ahw = adapter->ahw; 1764 struct qlcnic_sriov *sriov = ahw->sriov; 1765 struct qlcnic_vf_info *vf; 1766 u16 num_vfs = sriov->num_vfs; 1767 int i; 1768 1769 for (i = 0; i < num_vfs; i++) { 1770 vf = &sriov->vf_info[i]; 1771 vf->rx_ctx_id = 0; 1772 vf->tx_ctx_id = 0; 1773 cancel_work_sync(&vf->flr_work); 1774 __qlcnic_sriov_process_flr(vf); 1775 clear_bit(QLC_BC_VF_STATE, &vf->state); 1776 } 1777 1778 qlcnic_sriov_pf_reset_vport_handle(adapter, ahw->pci_func); 1779 QLCWRX(ahw, QLCNIC_MBX_INTR_ENBL, (ahw->num_msix - 1) << 8); 1780 } 1781 1782 int qlcnic_sriov_pf_reinit(struct qlcnic_adapter *adapter) 1783 { 1784 struct qlcnic_hardware_context *ahw = adapter->ahw; 1785 int err; 1786 1787 if (!qlcnic_sriov_enable_check(adapter)) 1788 return 0; 1789 1790 ahw->op_mode = QLCNIC_SRIOV_PF_FUNC; 1791 1792 err = qlcnic_sriov_pf_init(adapter); 1793 if (err) 1794 return err; 1795 1796 dev_info(&adapter->pdev->dev, "%s: op_mode %d\n", 1797 __func__, ahw->op_mode); 1798 return err; 1799 } 1800 1801 int qlcnic_sriov_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) 1802 { 1803 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1804 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1805 int i, num_vfs; 1806 struct qlcnic_vf_info *vf_info; 1807 u8 *curr_mac; 1808 1809 if (!qlcnic_sriov_pf_check(adapter)) 1810 return -EOPNOTSUPP; 1811 1812 num_vfs = sriov->num_vfs; 1813 1814 if (!is_valid_ether_addr(mac) || vf >= num_vfs) 1815 return -EINVAL; 1816 1817 if (ether_addr_equal(adapter->mac_addr, mac)) { 1818 netdev_err(netdev, "MAC address is already in use by the PF\n"); 1819 return -EINVAL; 1820 } 1821 1822 for (i = 0; i < num_vfs; i++) { 1823 vf_info = &sriov->vf_info[i]; 1824 if (ether_addr_equal(vf_info->vp->mac, mac)) { 1825 netdev_err(netdev, 1826 "MAC address is already in use by VF %d\n", 1827 i); 1828 return -EINVAL; 1829 } 1830 } 1831 1832 vf_info = &sriov->vf_info[vf]; 1833 curr_mac = vf_info->vp->mac; 1834 1835 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1836 netdev_err(netdev, 1837 "MAC address change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1838 vf); 1839 return -EOPNOTSUPP; 1840 } 1841 1842 memcpy(curr_mac, mac, netdev->addr_len); 1843 netdev_info(netdev, "MAC Address %pM is configured for VF %d\n", 1844 mac, vf); 1845 return 0; 1846 } 1847 1848 int qlcnic_sriov_set_vf_tx_rate(struct net_device *netdev, int vf, 1849 int min_tx_rate, int max_tx_rate) 1850 { 1851 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1852 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1853 struct qlcnic_vf_info *vf_info; 1854 struct qlcnic_info nic_info; 1855 struct qlcnic_vport *vp; 1856 u16 vpid; 1857 1858 if (!qlcnic_sriov_pf_check(adapter)) 1859 return -EOPNOTSUPP; 1860 1861 if (vf >= sriov->num_vfs) 1862 return -EINVAL; 1863 1864 vf_info = &sriov->vf_info[vf]; 1865 vp = vf_info->vp; 1866 vpid = vp->handle; 1867 1868 if (!min_tx_rate) 1869 min_tx_rate = QLC_VF_MIN_TX_RATE; 1870 1871 if (max_tx_rate && 1872 (max_tx_rate >= 10000 || max_tx_rate < min_tx_rate)) { 1873 netdev_err(netdev, 1874 "Invalid max Tx rate, allowed range is [%d - %d]", 1875 min_tx_rate, QLC_VF_MAX_TX_RATE); 1876 return -EINVAL; 1877 } 1878 1879 if (!max_tx_rate) 1880 max_tx_rate = 10000; 1881 1882 if (min_tx_rate && 1883 (min_tx_rate > max_tx_rate || min_tx_rate < QLC_VF_MIN_TX_RATE)) { 1884 netdev_err(netdev, 1885 "Invalid min Tx rate, allowed range is [%d - %d]", 1886 QLC_VF_MIN_TX_RATE, max_tx_rate); 1887 return -EINVAL; 1888 } 1889 1890 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1891 if (qlcnic_sriov_get_vf_vport_info(adapter, &nic_info, vpid)) 1892 return -EIO; 1893 1894 nic_info.max_tx_bw = max_tx_rate / 100; 1895 nic_info.min_tx_bw = min_tx_rate / 100; 1896 nic_info.bit_offsets = BIT_0; 1897 1898 if (qlcnic_sriov_pf_set_vport_info(adapter, &nic_info, vpid)) 1899 return -EIO; 1900 } 1901 1902 vp->max_tx_bw = max_tx_rate / 100; 1903 netdev_info(netdev, 1904 "Setting Max Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1905 max_tx_rate, vp->max_tx_bw, vf); 1906 vp->min_tx_bw = min_tx_rate / 100; 1907 netdev_info(netdev, 1908 "Setting Min Tx rate %d (Mbps), %d %% of PF bandwidth, for VF %d\n", 1909 min_tx_rate, vp->min_tx_bw, vf); 1910 return 0; 1911 } 1912 1913 int qlcnic_sriov_set_vf_vlan(struct net_device *netdev, int vf, 1914 u16 vlan, u8 qos, __be16 vlan_proto) 1915 { 1916 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1917 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1918 struct qlcnic_vf_info *vf_info; 1919 struct qlcnic_vport *vp; 1920 1921 if (!qlcnic_sriov_pf_check(adapter)) 1922 return -EOPNOTSUPP; 1923 1924 if (vf >= sriov->num_vfs || qos > 7) 1925 return -EINVAL; 1926 1927 if (vlan_proto != htons(ETH_P_8021Q)) 1928 return -EPROTONOSUPPORT; 1929 1930 if (vlan > MAX_VLAN_ID) { 1931 netdev_err(netdev, 1932 "Invalid VLAN ID, allowed range is [0 - %d]\n", 1933 MAX_VLAN_ID); 1934 return -EINVAL; 1935 } 1936 1937 vf_info = &sriov->vf_info[vf]; 1938 vp = vf_info->vp; 1939 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 1940 netdev_err(netdev, 1941 "VLAN change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 1942 vf); 1943 return -EOPNOTSUPP; 1944 } 1945 1946 memset(vf_info->sriov_vlans, 0, 1947 sizeof(*vf_info->sriov_vlans) * sriov->num_allowed_vlans); 1948 1949 switch (vlan) { 1950 case 4095: 1951 vp->vlan_mode = QLC_GUEST_VLAN_MODE; 1952 break; 1953 case 0: 1954 vp->vlan_mode = QLC_NO_VLAN_MODE; 1955 vp->qos = 0; 1956 break; 1957 default: 1958 vp->vlan_mode = QLC_PVID_MODE; 1959 qlcnic_sriov_add_vlan_id(sriov, vf_info, vlan); 1960 vp->qos = qos; 1961 vp->pvid = vlan; 1962 } 1963 1964 netdev_info(netdev, "Setting VLAN %d, QoS %d, for VF %d\n", 1965 vlan, qos, vf); 1966 return 0; 1967 } 1968 1969 static __u32 qlcnic_sriov_get_vf_vlan(struct qlcnic_adapter *adapter, 1970 struct qlcnic_vport *vp, int vf) 1971 { 1972 __u32 vlan = 0; 1973 1974 switch (vp->vlan_mode) { 1975 case QLC_PVID_MODE: 1976 vlan = vp->pvid; 1977 break; 1978 case QLC_GUEST_VLAN_MODE: 1979 vlan = MAX_VLAN_ID; 1980 break; 1981 case QLC_NO_VLAN_MODE: 1982 vlan = 0; 1983 break; 1984 default: 1985 netdev_info(adapter->netdev, "Invalid VLAN mode = %d for VF %d\n", 1986 vp->vlan_mode, vf); 1987 } 1988 1989 return vlan; 1990 } 1991 1992 int qlcnic_sriov_get_vf_config(struct net_device *netdev, 1993 int vf, struct ifla_vf_info *ivi) 1994 { 1995 struct qlcnic_adapter *adapter = netdev_priv(netdev); 1996 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 1997 struct qlcnic_vport *vp; 1998 1999 if (!qlcnic_sriov_pf_check(adapter)) 2000 return -EOPNOTSUPP; 2001 2002 if (vf >= sriov->num_vfs) 2003 return -EINVAL; 2004 2005 vp = sriov->vf_info[vf].vp; 2006 memcpy(&ivi->mac, vp->mac, ETH_ALEN); 2007 ivi->vlan = qlcnic_sriov_get_vf_vlan(adapter, vp, vf); 2008 ivi->qos = vp->qos; 2009 ivi->spoofchk = vp->spoofchk; 2010 if (vp->max_tx_bw == MAX_BW) 2011 ivi->max_tx_rate = 0; 2012 else 2013 ivi->max_tx_rate = vp->max_tx_bw * 100; 2014 if (vp->min_tx_bw == MIN_BW) 2015 ivi->min_tx_rate = 0; 2016 else 2017 ivi->min_tx_rate = vp->min_tx_bw * 100; 2018 2019 ivi->vf = vf; 2020 return 0; 2021 } 2022 2023 int qlcnic_sriov_set_vf_spoofchk(struct net_device *netdev, int vf, bool chk) 2024 { 2025 struct qlcnic_adapter *adapter = netdev_priv(netdev); 2026 struct qlcnic_sriov *sriov = adapter->ahw->sriov; 2027 struct qlcnic_vf_info *vf_info; 2028 struct qlcnic_vport *vp; 2029 2030 if (!qlcnic_sriov_pf_check(adapter)) 2031 return -EOPNOTSUPP; 2032 2033 if (vf >= sriov->num_vfs) 2034 return -EINVAL; 2035 2036 vf_info = &sriov->vf_info[vf]; 2037 vp = vf_info->vp; 2038 if (test_bit(QLC_BC_VF_STATE, &vf_info->state)) { 2039 netdev_err(netdev, 2040 "Spoof check change failed for VF %d, as VF driver is loaded. Please unload VF driver and retry the operation\n", 2041 vf); 2042 return -EOPNOTSUPP; 2043 } 2044 2045 vp->spoofchk = chk; 2046 return 0; 2047 } 2048