1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2013 - 2019 Intel Corporation. */ 3 4 #include "fm10k.h" 5 #include "fm10k_vf.h" 6 #include "fm10k_pf.h" 7 8 static s32 fm10k_iov_msg_error(struct fm10k_hw *hw, u32 **results, 9 struct fm10k_mbx_info *mbx) 10 { 11 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx; 12 struct fm10k_intfc *interface = hw->back; 13 struct pci_dev *pdev = interface->pdev; 14 15 dev_err(&pdev->dev, "Unknown message ID %u on VF %d\n", 16 **results & FM10K_TLV_ID_MASK, vf_info->vf_idx); 17 18 return fm10k_tlv_msg_error(hw, results, mbx); 19 } 20 21 /** 22 * fm10k_iov_msg_queue_mac_vlan - Message handler for MAC/VLAN request from VF 23 * @hw: Pointer to hardware structure 24 * @results: Pointer array to message, results[0] is pointer to message 25 * @mbx: Pointer to mailbox information structure 26 * 27 * This function is a custom handler for MAC/VLAN requests from the VF. The 28 * assumption is that it is acceptable to directly hand off the message from 29 * the VF to the PF's switch manager. However, we use a MAC/VLAN message 30 * queue to avoid overloading the mailbox when a large number of requests 31 * come in. 32 **/ 33 static s32 fm10k_iov_msg_queue_mac_vlan(struct fm10k_hw *hw, u32 **results, 34 struct fm10k_mbx_info *mbx) 35 { 36 struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx; 37 struct fm10k_intfc *interface = hw->back; 38 u8 mac[ETH_ALEN]; 39 u32 *result; 40 int err = 0; 41 bool set; 42 u16 vlan; 43 u32 vid; 44 45 /* we shouldn't be updating rules on a disabled interface */ 46 if (!FM10K_VF_FLAG_ENABLED(vf_info)) 47 err = FM10K_ERR_PARAM; 48 49 if (!err && !!results[FM10K_MAC_VLAN_MSG_VLAN]) { 50 result = results[FM10K_MAC_VLAN_MSG_VLAN]; 51 52 /* record VLAN id requested */ 53 err = fm10k_tlv_attr_get_u32(result, &vid); 54 if (err) 55 return err; 56 57 set = !(vid & FM10K_VLAN_CLEAR); 58 vid &= ~FM10K_VLAN_CLEAR; 59 60 /* if the length field has been set, this is a multi-bit 61 * update request. For multi-bit requests, simply disallow 62 * them when the pf_vid has been set. In this case, the PF 63 * should have already cleared the VLAN_TABLE, and if we 64 * allowed them, it could allow a rogue VF to receive traffic 65 * on a VLAN it was not assigned. In the single-bit case, we 66 * need to modify requests for VLAN 0 to use the default PF or 67 * SW vid when assigned. 68 */ 69 70 if (vid >> 16) { 71 /* prevent multi-bit requests when PF has 72 * administratively set the VLAN for this VF 73 */ 74 if (vf_info->pf_vid) 75 return FM10K_ERR_PARAM; 76 } else { 77 err = fm10k_iov_select_vid(vf_info, (u16)vid); 78 if (err < 0) 79 return err; 80 81 vid = err; 82 } 83 84 /* update VSI info for VF in regards to VLAN table */ 85 err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set); 86 } 87 88 if (!err && !!results[FM10K_MAC_VLAN_MSG_MAC]) { 89 result = results[FM10K_MAC_VLAN_MSG_MAC]; 90 91 /* record unicast MAC address requested */ 92 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan); 93 if (err) 94 return err; 95 96 /* block attempts to set MAC for a locked device */ 97 if (is_valid_ether_addr(vf_info->mac) && 98 !ether_addr_equal(mac, vf_info->mac)) 99 return FM10K_ERR_PARAM; 100 101 set = !(vlan & FM10K_VLAN_CLEAR); 102 vlan &= ~FM10K_VLAN_CLEAR; 103 104 err = fm10k_iov_select_vid(vf_info, vlan); 105 if (err < 0) 106 return err; 107 108 vlan = (u16)err; 109 110 /* Add this request to the MAC/VLAN queue */ 111 err = fm10k_queue_mac_request(interface, vf_info->glort, 112 mac, vlan, set); 113 } 114 115 if (!err && !!results[FM10K_MAC_VLAN_MSG_MULTICAST]) { 116 result = results[FM10K_MAC_VLAN_MSG_MULTICAST]; 117 118 /* record multicast MAC address requested */ 119 err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan); 120 if (err) 121 return err; 122 123 /* verify that the VF is allowed to request multicast */ 124 if (!(vf_info->vf_flags & FM10K_VF_FLAG_MULTI_ENABLED)) 125 return FM10K_ERR_PARAM; 126 127 set = !(vlan & FM10K_VLAN_CLEAR); 128 vlan &= ~FM10K_VLAN_CLEAR; 129 130 err = fm10k_iov_select_vid(vf_info, vlan); 131 if (err < 0) 132 return err; 133 134 vlan = (u16)err; 135 136 /* Add this request to the MAC/VLAN queue */ 137 err = fm10k_queue_mac_request(interface, vf_info->glort, 138 mac, vlan, set); 139 } 140 141 return err; 142 } 143 144 static const struct fm10k_msg_data iov_mbx_data[] = { 145 FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test), 146 FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf), 147 FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_queue_mac_vlan), 148 FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf), 149 FM10K_TLV_MSG_ERROR_HANDLER(fm10k_iov_msg_error), 150 }; 151 152 s32 fm10k_iov_event(struct fm10k_intfc *interface) 153 { 154 struct fm10k_hw *hw = &interface->hw; 155 struct fm10k_iov_data *iov_data; 156 s64 vflre; 157 int i; 158 159 /* if there is no iov_data then there is no mailbox to process */ 160 if (!READ_ONCE(interface->iov_data)) 161 return 0; 162 163 rcu_read_lock(); 164 165 iov_data = interface->iov_data; 166 167 /* check again now that we are in the RCU block */ 168 if (!iov_data) 169 goto read_unlock; 170 171 if (!(fm10k_read_reg(hw, FM10K_EICR) & FM10K_EICR_VFLR)) 172 goto read_unlock; 173 174 /* read VFLRE to determine if any VFs have been reset */ 175 vflre = fm10k_read_reg(hw, FM10K_PFVFLRE(1)); 176 vflre <<= 32; 177 vflre |= fm10k_read_reg(hw, FM10K_PFVFLRE(0)); 178 179 i = iov_data->num_vfs; 180 181 for (vflre <<= 64 - i; vflre && i--; vflre += vflre) { 182 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 183 184 if (vflre >= 0) 185 continue; 186 187 hw->iov.ops.reset_resources(hw, vf_info); 188 vf_info->mbx.ops.connect(hw, &vf_info->mbx); 189 } 190 191 read_unlock: 192 rcu_read_unlock(); 193 194 return 0; 195 } 196 197 s32 fm10k_iov_mbx(struct fm10k_intfc *interface) 198 { 199 struct fm10k_hw *hw = &interface->hw; 200 struct fm10k_iov_data *iov_data; 201 int i; 202 203 /* if there is no iov_data then there is no mailbox to process */ 204 if (!READ_ONCE(interface->iov_data)) 205 return 0; 206 207 rcu_read_lock(); 208 209 iov_data = interface->iov_data; 210 211 /* check again now that we are in the RCU block */ 212 if (!iov_data) 213 goto read_unlock; 214 215 /* lock the mailbox for transmit and receive */ 216 fm10k_mbx_lock(interface); 217 218 /* Most VF messages sent to the PF cause the PF to respond by 219 * requesting from the SM mailbox. This means that too many VF 220 * messages processed at once could cause a mailbox timeout on the PF. 221 * To prevent this, store a pointer to the next VF mbx to process. Use 222 * that as the start of the loop so that we don't starve whichever VF 223 * got ignored on the previous run. 224 */ 225 process_mbx: 226 for (i = iov_data->next_vf_mbx ? : iov_data->num_vfs; i--;) { 227 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 228 struct fm10k_mbx_info *mbx = &vf_info->mbx; 229 u16 glort = vf_info->glort; 230 231 /* process the SM mailbox first to drain outgoing messages */ 232 hw->mbx.ops.process(hw, &hw->mbx); 233 234 /* verify port mapping is valid, if not reset port */ 235 if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort)) { 236 hw->iov.ops.reset_lport(hw, vf_info); 237 fm10k_clear_macvlan_queue(interface, glort, false); 238 } 239 240 /* reset VFs that have mailbox timed out */ 241 if (!mbx->timeout) { 242 hw->iov.ops.reset_resources(hw, vf_info); 243 mbx->ops.connect(hw, mbx); 244 } 245 246 /* guarantee we have free space in the SM mailbox */ 247 if (hw->mbx.state == FM10K_STATE_OPEN && 248 !hw->mbx.ops.tx_ready(&hw->mbx, FM10K_VFMBX_MSG_MTU)) { 249 /* keep track of how many times this occurs */ 250 interface->hw_sm_mbx_full++; 251 252 /* make sure we try again momentarily */ 253 fm10k_service_event_schedule(interface); 254 255 break; 256 } 257 258 /* cleanup mailbox and process received messages */ 259 mbx->ops.process(hw, mbx); 260 } 261 262 /* if we stopped processing mailboxes early, update next_vf_mbx. 263 * Otherwise, reset next_vf_mbx, and restart loop so that we process 264 * the remaining mailboxes we skipped at the start. 265 */ 266 if (i >= 0) { 267 iov_data->next_vf_mbx = i + 1; 268 } else if (iov_data->next_vf_mbx) { 269 iov_data->next_vf_mbx = 0; 270 goto process_mbx; 271 } 272 273 /* free the lock */ 274 fm10k_mbx_unlock(interface); 275 276 read_unlock: 277 rcu_read_unlock(); 278 279 return 0; 280 } 281 282 void fm10k_iov_suspend(struct pci_dev *pdev) 283 { 284 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 285 struct fm10k_iov_data *iov_data = interface->iov_data; 286 struct fm10k_hw *hw = &interface->hw; 287 int num_vfs, i; 288 289 /* pull out num_vfs from iov_data */ 290 num_vfs = iov_data ? iov_data->num_vfs : 0; 291 292 /* shut down queue mapping for VFs */ 293 fm10k_write_reg(hw, FM10K_DGLORTMAP(fm10k_dglort_vf_rss), 294 FM10K_DGLORTMAP_NONE); 295 296 /* Stop any active VFs and reset their resources */ 297 for (i = 0; i < num_vfs; i++) { 298 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 299 300 hw->iov.ops.reset_resources(hw, vf_info); 301 hw->iov.ops.reset_lport(hw, vf_info); 302 fm10k_clear_macvlan_queue(interface, vf_info->glort, false); 303 } 304 } 305 306 static void fm10k_mask_aer_comp_abort(struct pci_dev *pdev) 307 { 308 u32 err_mask; 309 int pos; 310 311 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR); 312 if (!pos) 313 return; 314 315 /* Mask the completion abort bit in the ERR_UNCOR_MASK register, 316 * preventing the device from reporting these errors to the upstream 317 * PCIe root device. This avoids bringing down platforms which upgrade 318 * non-fatal completer aborts into machine check exceptions. Completer 319 * aborts can occur whenever a VF reads a queue it doesn't own. 320 */ 321 pci_read_config_dword(pdev, pos + PCI_ERR_UNCOR_MASK, &err_mask); 322 err_mask |= PCI_ERR_UNC_COMP_ABORT; 323 pci_write_config_dword(pdev, pos + PCI_ERR_UNCOR_MASK, err_mask); 324 } 325 326 int fm10k_iov_resume(struct pci_dev *pdev) 327 { 328 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 329 struct fm10k_iov_data *iov_data = interface->iov_data; 330 struct fm10k_dglort_cfg dglort = { 0 }; 331 struct fm10k_hw *hw = &interface->hw; 332 int num_vfs, i; 333 334 /* pull out num_vfs from iov_data */ 335 num_vfs = iov_data ? iov_data->num_vfs : 0; 336 337 /* return error if iov_data is not already populated */ 338 if (!iov_data) 339 return -ENOMEM; 340 341 /* Lower severity of completer abort error reporting as 342 * the VFs can trigger this any time they read a queue 343 * that they don't own. 344 */ 345 fm10k_mask_aer_comp_abort(pdev); 346 347 /* allocate hardware resources for the VFs */ 348 hw->iov.ops.assign_resources(hw, num_vfs, num_vfs); 349 350 /* configure DGLORT mapping for RSS */ 351 dglort.glort = hw->mac.dglort_map & FM10K_DGLORTMAP_NONE; 352 dglort.idx = fm10k_dglort_vf_rss; 353 dglort.inner_rss = 1; 354 dglort.rss_l = fls(fm10k_queues_per_pool(hw) - 1); 355 dglort.queue_b = fm10k_vf_queue_index(hw, 0); 356 dglort.vsi_l = fls(hw->iov.total_vfs - 1); 357 dglort.vsi_b = 1; 358 359 hw->mac.ops.configure_dglort_map(hw, &dglort); 360 361 /* assign resources to the device */ 362 for (i = 0; i < num_vfs; i++) { 363 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 364 365 /* allocate all but the last GLORT to the VFs */ 366 if (i == (~hw->mac.dglort_map >> FM10K_DGLORTMAP_MASK_SHIFT)) 367 break; 368 369 /* assign GLORT to VF, and restrict it to multicast */ 370 hw->iov.ops.set_lport(hw, vf_info, i, 371 FM10K_VF_FLAG_MULTI_CAPABLE); 372 373 /* mailbox is disconnected so we don't send a message */ 374 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 375 376 /* now we are ready so we can connect */ 377 vf_info->mbx.ops.connect(hw, &vf_info->mbx); 378 } 379 380 return 0; 381 } 382 383 s32 fm10k_iov_update_pvid(struct fm10k_intfc *interface, u16 glort, u16 pvid) 384 { 385 struct fm10k_iov_data *iov_data = interface->iov_data; 386 struct fm10k_hw *hw = &interface->hw; 387 struct fm10k_vf_info *vf_info; 388 u16 vf_idx = (glort - hw->mac.dglort_map) & FM10K_DGLORTMAP_NONE; 389 390 /* no IOV support, not our message to process */ 391 if (!iov_data) 392 return FM10K_ERR_PARAM; 393 394 /* glort outside our range, not our message to process */ 395 if (vf_idx >= iov_data->num_vfs) 396 return FM10K_ERR_PARAM; 397 398 /* determine if an update has occurred and if so notify the VF */ 399 vf_info = &iov_data->vf_info[vf_idx]; 400 if (vf_info->sw_vid != pvid) { 401 vf_info->sw_vid = pvid; 402 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 403 } 404 405 return 0; 406 } 407 408 static void fm10k_iov_free_data(struct pci_dev *pdev) 409 { 410 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 411 412 if (!interface->iov_data) 413 return; 414 415 /* reclaim hardware resources */ 416 fm10k_iov_suspend(pdev); 417 418 /* drop iov_data from interface */ 419 kfree_rcu(interface->iov_data, rcu); 420 interface->iov_data = NULL; 421 } 422 423 static s32 fm10k_iov_alloc_data(struct pci_dev *pdev, int num_vfs) 424 { 425 struct fm10k_intfc *interface = pci_get_drvdata(pdev); 426 struct fm10k_iov_data *iov_data = interface->iov_data; 427 struct fm10k_hw *hw = &interface->hw; 428 size_t size; 429 int i; 430 431 /* return error if iov_data is already populated */ 432 if (iov_data) 433 return -EBUSY; 434 435 /* The PF should always be able to assign resources */ 436 if (!hw->iov.ops.assign_resources) 437 return -ENODEV; 438 439 /* nothing to do if no VFs are requested */ 440 if (!num_vfs) 441 return 0; 442 443 /* allocate memory for VF storage */ 444 size = offsetof(struct fm10k_iov_data, vf_info[num_vfs]); 445 iov_data = kzalloc(size, GFP_KERNEL); 446 if (!iov_data) 447 return -ENOMEM; 448 449 /* record number of VFs */ 450 iov_data->num_vfs = num_vfs; 451 452 /* loop through vf_info structures initializing each entry */ 453 for (i = 0; i < num_vfs; i++) { 454 struct fm10k_vf_info *vf_info = &iov_data->vf_info[i]; 455 int err; 456 457 /* Record VF VSI value */ 458 vf_info->vsi = i + 1; 459 vf_info->vf_idx = i; 460 461 /* initialize mailbox memory */ 462 err = fm10k_pfvf_mbx_init(hw, &vf_info->mbx, iov_mbx_data, i); 463 if (err) { 464 dev_err(&pdev->dev, 465 "Unable to initialize SR-IOV mailbox\n"); 466 kfree(iov_data); 467 return err; 468 } 469 } 470 471 /* assign iov_data to interface */ 472 interface->iov_data = iov_data; 473 474 /* allocate hardware resources for the VFs */ 475 fm10k_iov_resume(pdev); 476 477 return 0; 478 } 479 480 void fm10k_iov_disable(struct pci_dev *pdev) 481 { 482 if (pci_num_vf(pdev) && pci_vfs_assigned(pdev)) 483 dev_err(&pdev->dev, 484 "Cannot disable SR-IOV while VFs are assigned\n"); 485 else 486 pci_disable_sriov(pdev); 487 488 fm10k_iov_free_data(pdev); 489 } 490 491 int fm10k_iov_configure(struct pci_dev *pdev, int num_vfs) 492 { 493 int current_vfs = pci_num_vf(pdev); 494 int err = 0; 495 496 if (current_vfs && pci_vfs_assigned(pdev)) { 497 dev_err(&pdev->dev, 498 "Cannot modify SR-IOV while VFs are assigned\n"); 499 num_vfs = current_vfs; 500 } else { 501 pci_disable_sriov(pdev); 502 fm10k_iov_free_data(pdev); 503 } 504 505 /* allocate resources for the VFs */ 506 err = fm10k_iov_alloc_data(pdev, num_vfs); 507 if (err) 508 return err; 509 510 /* allocate VFs if not already allocated */ 511 if (num_vfs && num_vfs != current_vfs) { 512 err = pci_enable_sriov(pdev, num_vfs); 513 if (err) { 514 dev_err(&pdev->dev, 515 "Enable PCI SR-IOV failed: %d\n", err); 516 return err; 517 } 518 } 519 520 return num_vfs; 521 } 522 523 /** 524 * fm10k_iov_update_stats - Update stats for all VFs 525 * @interface: device private structure 526 * 527 * Updates the VF statistics for all enabled VFs. Expects to be called by 528 * fm10k_update_stats and assumes that locking via the __FM10K_UPDATING_STATS 529 * bit is already handled. 530 */ 531 void fm10k_iov_update_stats(struct fm10k_intfc *interface) 532 { 533 struct fm10k_iov_data *iov_data = interface->iov_data; 534 struct fm10k_hw *hw = &interface->hw; 535 int i; 536 537 if (!iov_data) 538 return; 539 540 for (i = 0; i < iov_data->num_vfs; i++) 541 hw->iov.ops.update_stats(hw, iov_data->vf_info[i].stats, i); 542 } 543 544 static inline void fm10k_reset_vf_info(struct fm10k_intfc *interface, 545 struct fm10k_vf_info *vf_info) 546 { 547 struct fm10k_hw *hw = &interface->hw; 548 549 /* assigning the MAC address will send a mailbox message */ 550 fm10k_mbx_lock(interface); 551 552 /* disable LPORT for this VF which clears switch rules */ 553 hw->iov.ops.reset_lport(hw, vf_info); 554 555 fm10k_clear_macvlan_queue(interface, vf_info->glort, false); 556 557 /* assign new MAC+VLAN for this VF */ 558 hw->iov.ops.assign_default_mac_vlan(hw, vf_info); 559 560 /* re-enable the LPORT for this VF */ 561 hw->iov.ops.set_lport(hw, vf_info, vf_info->vf_idx, 562 FM10K_VF_FLAG_MULTI_CAPABLE); 563 564 fm10k_mbx_unlock(interface); 565 } 566 567 int fm10k_ndo_set_vf_mac(struct net_device *netdev, int vf_idx, u8 *mac) 568 { 569 struct fm10k_intfc *interface = netdev_priv(netdev); 570 struct fm10k_iov_data *iov_data = interface->iov_data; 571 struct fm10k_vf_info *vf_info; 572 573 /* verify SR-IOV is active and that vf idx is valid */ 574 if (!iov_data || vf_idx >= iov_data->num_vfs) 575 return -EINVAL; 576 577 /* verify MAC addr is valid */ 578 if (!is_zero_ether_addr(mac) && !is_valid_ether_addr(mac)) 579 return -EINVAL; 580 581 /* record new MAC address */ 582 vf_info = &iov_data->vf_info[vf_idx]; 583 ether_addr_copy(vf_info->mac, mac); 584 585 fm10k_reset_vf_info(interface, vf_info); 586 587 return 0; 588 } 589 590 int fm10k_ndo_set_vf_vlan(struct net_device *netdev, int vf_idx, u16 vid, 591 u8 qos, __be16 vlan_proto) 592 { 593 struct fm10k_intfc *interface = netdev_priv(netdev); 594 struct fm10k_iov_data *iov_data = interface->iov_data; 595 struct fm10k_hw *hw = &interface->hw; 596 struct fm10k_vf_info *vf_info; 597 598 /* verify SR-IOV is active and that vf idx is valid */ 599 if (!iov_data || vf_idx >= iov_data->num_vfs) 600 return -EINVAL; 601 602 /* QOS is unsupported and VLAN IDs accepted range 0-4094 */ 603 if (qos || (vid > (VLAN_VID_MASK - 1))) 604 return -EINVAL; 605 606 /* VF VLAN Protocol part to default is unsupported */ 607 if (vlan_proto != htons(ETH_P_8021Q)) 608 return -EPROTONOSUPPORT; 609 610 vf_info = &iov_data->vf_info[vf_idx]; 611 612 /* exit if there is nothing to do */ 613 if (vf_info->pf_vid == vid) 614 return 0; 615 616 /* record default VLAN ID for VF */ 617 vf_info->pf_vid = vid; 618 619 /* Clear the VLAN table for the VF */ 620 hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, vf_info->vsi, false); 621 622 fm10k_reset_vf_info(interface, vf_info); 623 624 return 0; 625 } 626 627 int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx, 628 int __always_unused min_rate, int max_rate) 629 { 630 struct fm10k_intfc *interface = netdev_priv(netdev); 631 struct fm10k_iov_data *iov_data = interface->iov_data; 632 struct fm10k_hw *hw = &interface->hw; 633 634 /* verify SR-IOV is active and that vf idx is valid */ 635 if (!iov_data || vf_idx >= iov_data->num_vfs) 636 return -EINVAL; 637 638 /* rate limit cannot be less than 10Mbs or greater than link speed */ 639 if (max_rate && 640 (max_rate < FM10K_VF_TC_MIN || max_rate > FM10K_VF_TC_MAX)) 641 return -EINVAL; 642 643 /* store values */ 644 iov_data->vf_info[vf_idx].rate = max_rate; 645 646 /* update hardware configuration */ 647 hw->iov.ops.configure_tc(hw, vf_idx, max_rate); 648 649 return 0; 650 } 651 652 int fm10k_ndo_get_vf_config(struct net_device *netdev, 653 int vf_idx, struct ifla_vf_info *ivi) 654 { 655 struct fm10k_intfc *interface = netdev_priv(netdev); 656 struct fm10k_iov_data *iov_data = interface->iov_data; 657 struct fm10k_vf_info *vf_info; 658 659 /* verify SR-IOV is active and that vf idx is valid */ 660 if (!iov_data || vf_idx >= iov_data->num_vfs) 661 return -EINVAL; 662 663 vf_info = &iov_data->vf_info[vf_idx]; 664 665 ivi->vf = vf_idx; 666 ivi->max_tx_rate = vf_info->rate; 667 ivi->min_tx_rate = 0; 668 ether_addr_copy(ivi->mac, vf_info->mac); 669 ivi->vlan = vf_info->pf_vid; 670 ivi->qos = 0; 671 672 return 0; 673 } 674 675 int fm10k_ndo_get_vf_stats(struct net_device *netdev, 676 int vf_idx, struct ifla_vf_stats *stats) 677 { 678 struct fm10k_intfc *interface = netdev_priv(netdev); 679 struct fm10k_iov_data *iov_data = interface->iov_data; 680 struct fm10k_hw *hw = &interface->hw; 681 struct fm10k_hw_stats_q *hw_stats; 682 u32 idx, qpp; 683 684 /* verify SR-IOV is active and that vf idx is valid */ 685 if (!iov_data || vf_idx >= iov_data->num_vfs) 686 return -EINVAL; 687 688 qpp = fm10k_queues_per_pool(hw); 689 hw_stats = iov_data->vf_info[vf_idx].stats; 690 691 for (idx = 0; idx < qpp; idx++) { 692 stats->rx_packets += hw_stats[idx].rx_packets.count; 693 stats->tx_packets += hw_stats[idx].tx_packets.count; 694 stats->rx_bytes += hw_stats[idx].rx_bytes.count; 695 stats->tx_bytes += hw_stats[idx].tx_bytes.count; 696 stats->rx_dropped += hw_stats[idx].rx_drops.count; 697 } 698 699 return 0; 700 } 701