1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* Copyright (c) 2021, Intel Corporation 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the Intel Corporation nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /** 33 * @file iavf_lib.c 34 * @brief library code common to both legacy and iflib 35 * 36 * Contains functions common to the iflib and legacy drivers. Includes 37 * hardware initialization and control functions, as well as sysctl handlers 38 * for the sysctls which are shared between the legacy and iflib drivers. 39 */ 40 #include "iavf_iflib.h" 41 #include "iavf_vc_common.h" 42 43 static void iavf_init_hw(struct iavf_hw *hw, device_t dev); 44 static u_int iavf_mc_filter_apply(void *arg, struct sockaddr_dl *sdl, u_int cnt); 45 46 /** 47 * iavf_msec_pause - Pause for at least the specified number of milliseconds 48 * @msecs: number of milliseconds to pause for 49 * 50 * Pause execution of the current thread for a specified number of 51 * milliseconds. Used to enforce minimum delay times when waiting for various 52 * hardware events. 53 */ 54 void 55 iavf_msec_pause(int msecs) 56 { 57 pause("iavf_msec_pause", MSEC_2_TICKS(msecs)); 58 } 59 60 /** 61 * iavf_get_default_rss_key - Get the default RSS key for this driver 62 * @key: output parameter to store the key in 63 * 64 * Copies the driver's default RSS key into the provided key variable. 65 * 66 * @pre assumes that key is not NULL and has at least IAVF_RSS_KEY_SIZE 67 * storage space. 68 */ 69 void 70 iavf_get_default_rss_key(u32 *key) 71 { 72 MPASS(key != NULL); 73 74 u32 rss_seed[IAVF_RSS_KEY_SIZE_REG] = {0x41b01687, 75 0x183cfd8c, 0xce880440, 0x580cbc3c, 76 0x35897377, 0x328b25e1, 0x4fa98922, 77 0xb7d90c14, 0xd5bad70d, 0xcd15a2c1, 78 0x0, 0x0, 0x0}; 79 80 bcopy(rss_seed, key, IAVF_RSS_KEY_SIZE); 81 } 82 83 /** 84 * iavf_allocate_pci_resources_common - Allocate PCI resources 85 * @sc: the private device softc pointer 86 * 87 * @pre sc->dev is set 88 * 89 * Allocates the common PCI resources used by the driver. 90 * 91 * @returns zero on success, or an error code on failure. 92 */ 93 int 94 iavf_allocate_pci_resources_common(struct iavf_sc *sc) 95 { 96 struct iavf_hw *hw = &sc->hw; 97 device_t dev = sc->dev; 98 int rid; 99 100 /* Map PCI BAR0 */ 101 rid = PCIR_BAR(0); 102 sc->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 103 &rid, RF_ACTIVE); 104 105 if (!(sc->pci_mem)) { 106 device_printf(dev, "Unable to allocate bus resource: PCI memory\n"); 107 return (ENXIO); 108 } 109 110 iavf_init_hw(hw, dev); 111 112 /* Save off register access information */ 113 sc->osdep.mem_bus_space_tag = 114 rman_get_bustag(sc->pci_mem); 115 sc->osdep.mem_bus_space_handle = 116 rman_get_bushandle(sc->pci_mem); 117 sc->osdep.mem_bus_space_size = rman_get_size(sc->pci_mem); 118 sc->osdep.flush_reg = IAVF_VFGEN_RSTAT; 119 sc->osdep.dev = dev; 120 121 sc->hw.hw_addr = (u8 *)&sc->osdep.mem_bus_space_handle; 122 sc->hw.back = &sc->osdep; 123 124 return (0); 125 } 126 127 /** 128 * iavf_init_hw - Initialize the device HW 129 * @hw: device hardware structure 130 * @dev: the stack device_t pointer 131 * 132 * Attach helper function. Gathers information about the (virtual) hardware 133 * for use elsewhere in the driver. 134 */ 135 static void 136 iavf_init_hw(struct iavf_hw *hw, device_t dev) 137 { 138 /* Save off the information about this board */ 139 hw->vendor_id = pci_get_vendor(dev); 140 hw->device_id = pci_get_device(dev); 141 hw->revision_id = pci_read_config(dev, PCIR_REVID, 1); 142 hw->subsystem_vendor_id = 143 pci_read_config(dev, PCIR_SUBVEND_0, 2); 144 hw->subsystem_device_id = 145 pci_read_config(dev, PCIR_SUBDEV_0, 2); 146 147 hw->bus.device = pci_get_slot(dev); 148 hw->bus.func = pci_get_function(dev); 149 } 150 151 /** 152 * iavf_sysctl_current_speed - Sysctl to display the current device speed 153 * @oidp: syctl oid pointer 154 * @arg1: pointer to the device softc typecasted to void * 155 * @arg2: unused sysctl argument 156 * @req: sysctl request structure 157 * 158 * Reads the current speed reported from the physical device into a string for 159 * display by the current_speed sysctl. 160 * 161 * @returns zero or an error code on failure. 162 */ 163 int 164 iavf_sysctl_current_speed(SYSCTL_HANDLER_ARGS) 165 { 166 struct iavf_sc *sc = (struct iavf_sc *)arg1; 167 int error = 0; 168 169 UNREFERENCED_PARAMETER(arg2); 170 171 if (iavf_driver_is_detaching(sc)) 172 return (ESHUTDOWN); 173 174 if (IAVF_CAP_ADV_LINK_SPEED(sc)) 175 error = sysctl_handle_string(oidp, 176 __DECONST(char *, iavf_ext_speed_to_str(iavf_adv_speed_to_ext_speed(sc->link_speed_adv))), 177 8, req); 178 else 179 error = sysctl_handle_string(oidp, 180 __DECONST(char *, iavf_vc_speed_to_string(sc->link_speed)), 181 8, req); 182 183 return (error); 184 } 185 186 /** 187 * iavf_reset_complete - Wait for a device reset to complete 188 * @hw: pointer to the hardware structure 189 * 190 * Reads the reset registers and waits until they indicate that a device reset 191 * is complete. 192 * 193 * @pre this function may call pause() and must not be called from a context 194 * that cannot sleep. 195 * 196 * @returns zero on success, or EBUSY if it times out waiting for reset. 197 */ 198 int 199 iavf_reset_complete(struct iavf_hw *hw) 200 { 201 u32 reg; 202 203 /* Wait up to ~10 seconds */ 204 for (int i = 0; i < 100; i++) { 205 reg = rd32(hw, IAVF_VFGEN_RSTAT) & 206 IAVF_VFGEN_RSTAT_VFR_STATE_MASK; 207 208 if ((reg == VIRTCHNL_VFR_VFACTIVE) || 209 (reg == VIRTCHNL_VFR_COMPLETED)) 210 return (0); 211 iavf_msec_pause(100); 212 } 213 214 return (EBUSY); 215 } 216 217 /** 218 * iavf_setup_vc - Setup virtchnl communication 219 * @sc: device private softc 220 * 221 * iavf_attach() helper function. Initializes the admin queue and attempts to 222 * establish contact with the PF by retrying the initial "API version" message 223 * several times or until the PF responds. 224 * 225 * @returns zero on success, or an error code on failure. 226 */ 227 int 228 iavf_setup_vc(struct iavf_sc *sc) 229 { 230 struct iavf_hw *hw = &sc->hw; 231 device_t dev = sc->dev; 232 int error = 0, ret_error = 0, asq_retries = 0; 233 bool send_api_ver_retried = 0; 234 235 /* Need to set these AQ parameters before initializing AQ */ 236 hw->aq.num_arq_entries = IAVF_AQ_LEN; 237 hw->aq.num_asq_entries = IAVF_AQ_LEN; 238 hw->aq.arq_buf_size = IAVF_AQ_BUF_SZ; 239 hw->aq.asq_buf_size = IAVF_AQ_BUF_SZ; 240 241 for (int i = 0; i < IAVF_AQ_MAX_ERR; i++) { 242 /* Initialize admin queue */ 243 error = iavf_init_adminq(hw); 244 if (error) { 245 device_printf(dev, "%s: init_adminq failed: %d\n", 246 __func__, error); 247 ret_error = 1; 248 continue; 249 } 250 251 iavf_dbg_init(sc, "Initialized Admin Queue; starting" 252 " send_api_ver attempt %d", i+1); 253 254 retry_send: 255 /* Send VF's API version */ 256 error = iavf_send_api_ver(sc); 257 if (error) { 258 iavf_shutdown_adminq(hw); 259 ret_error = 2; 260 device_printf(dev, "%s: unable to send api" 261 " version to PF on attempt %d, error %d\n", 262 __func__, i+1, error); 263 } 264 265 asq_retries = 0; 266 while (!iavf_asq_done(hw)) { 267 if (++asq_retries > IAVF_AQ_MAX_ERR) { 268 iavf_shutdown_adminq(hw); 269 device_printf(dev, "Admin Queue timeout " 270 "(waiting for send_api_ver), %d more tries...\n", 271 IAVF_AQ_MAX_ERR - (i + 1)); 272 ret_error = 3; 273 break; 274 } 275 iavf_msec_pause(10); 276 } 277 if (asq_retries > IAVF_AQ_MAX_ERR) 278 continue; 279 280 iavf_dbg_init(sc, "Sent API version message to PF"); 281 282 /* Verify that the VF accepts the PF's API version */ 283 error = iavf_verify_api_ver(sc); 284 if (error == ETIMEDOUT) { 285 if (!send_api_ver_retried) { 286 /* Resend message, one more time */ 287 send_api_ver_retried = true; 288 device_printf(dev, 289 "%s: Timeout while verifying API version on first" 290 " try!\n", __func__); 291 goto retry_send; 292 } else { 293 device_printf(dev, 294 "%s: Timeout while verifying API version on second" 295 " try!\n", __func__); 296 ret_error = 4; 297 break; 298 } 299 } 300 if (error) { 301 device_printf(dev, 302 "%s: Unable to verify API version," 303 " error %d\n", __func__, error); 304 ret_error = 5; 305 } 306 break; 307 } 308 309 if (ret_error >= 4) 310 iavf_shutdown_adminq(hw); 311 return (ret_error); 312 } 313 314 /** 315 * iavf_reset - Requests a VF reset from the PF. 316 * @sc: device private softc 317 * 318 * @pre Requires the VF's Admin Queue to be initialized. 319 * @returns zero on success, or an error code on failure. 320 */ 321 int 322 iavf_reset(struct iavf_sc *sc) 323 { 324 struct iavf_hw *hw = &sc->hw; 325 device_t dev = sc->dev; 326 int error = 0; 327 328 /* Ask the PF to reset us if we are initiating */ 329 if (!iavf_test_state(&sc->state, IAVF_STATE_RESET_PENDING)) 330 iavf_request_reset(sc); 331 332 iavf_msec_pause(100); 333 error = iavf_reset_complete(hw); 334 if (error) { 335 device_printf(dev, "%s: VF reset failed\n", 336 __func__); 337 return (error); 338 } 339 pci_enable_busmaster(dev); 340 341 error = iavf_shutdown_adminq(hw); 342 if (error) { 343 device_printf(dev, "%s: shutdown_adminq failed: %d\n", 344 __func__, error); 345 return (error); 346 } 347 348 error = iavf_init_adminq(hw); 349 if (error) { 350 device_printf(dev, "%s: init_adminq failed: %d\n", 351 __func__, error); 352 return (error); 353 } 354 355 /* IFLIB: This is called only in the iflib driver */ 356 iavf_enable_adminq_irq(hw); 357 return (0); 358 } 359 360 /** 361 * iavf_enable_admin_irq - Enable the administrative interrupt 362 * @hw: pointer to the hardware structure 363 * 364 * Writes to registers to enable the administrative interrupt cause, in order 365 * to handle non-queue related interrupt events. 366 */ 367 void 368 iavf_enable_adminq_irq(struct iavf_hw *hw) 369 { 370 wr32(hw, IAVF_VFINT_DYN_CTL01, 371 IAVF_VFINT_DYN_CTL01_INTENA_MASK | 372 IAVF_VFINT_DYN_CTL01_CLEARPBA_MASK | 373 IAVF_VFINT_DYN_CTL01_ITR_INDX_MASK); 374 wr32(hw, IAVF_VFINT_ICR0_ENA1, IAVF_VFINT_ICR0_ENA1_ADMINQ_MASK); 375 /* flush */ 376 rd32(hw, IAVF_VFGEN_RSTAT); 377 } 378 379 /** 380 * iavf_disable_admin_irq - Disable the administrative interrupt cause 381 * @hw: pointer to the hardware structure 382 * 383 * Writes to registers to disable the administrative interrupt cause. 384 */ 385 void 386 iavf_disable_adminq_irq(struct iavf_hw *hw) 387 { 388 wr32(hw, IAVF_VFINT_DYN_CTL01, 0); 389 wr32(hw, IAVF_VFINT_ICR0_ENA1, 0); 390 iavf_flush(hw); 391 } 392 393 /** 394 * iavf_vf_config - Configure this VF over the virtchnl 395 * @sc: device private softc 396 * 397 * iavf_attach() helper function. Asks the PF for this VF's configuration, and 398 * saves the information if it receives it. 399 * 400 * @returns zero on success, or an error code on failure. 401 */ 402 int 403 iavf_vf_config(struct iavf_sc *sc) 404 { 405 struct iavf_hw *hw = &sc->hw; 406 device_t dev = sc->dev; 407 int bufsz, error = 0, ret_error = 0; 408 int asq_retries, retried = 0; 409 410 retry_config: 411 error = iavf_send_vf_config_msg(sc); 412 if (error) { 413 device_printf(dev, 414 "%s: Unable to send VF config request, attempt %d," 415 " error %d\n", __func__, retried + 1, error); 416 ret_error = 2; 417 } 418 419 asq_retries = 0; 420 while (!iavf_asq_done(hw)) { 421 if (++asq_retries > IAVF_AQ_MAX_ERR) { 422 device_printf(dev, "%s: Admin Queue timeout " 423 "(waiting for send_vf_config_msg), attempt %d\n", 424 __func__, retried + 1); 425 ret_error = 3; 426 goto fail; 427 } 428 iavf_msec_pause(10); 429 } 430 431 iavf_dbg_init(sc, "Sent VF config message to PF, attempt %d\n", 432 retried + 1); 433 434 if (!sc->vf_res) { 435 bufsz = sizeof(struct virtchnl_vf_resource) + 436 (IAVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource)); 437 sc->vf_res = (struct virtchnl_vf_resource *)malloc(bufsz, M_IAVF, M_NOWAIT); 438 if (!sc->vf_res) { 439 device_printf(dev, 440 "%s: Unable to allocate memory for VF configuration" 441 " message from PF on attempt %d\n", __func__, retried + 1); 442 ret_error = 1; 443 goto fail; 444 } 445 } 446 447 /* Check for VF config response */ 448 error = iavf_get_vf_config(sc); 449 if (error == ETIMEDOUT) { 450 /* The 1st time we timeout, send the configuration message again */ 451 if (!retried) { 452 retried++; 453 goto retry_config; 454 } 455 device_printf(dev, 456 "%s: iavf_get_vf_config() timed out waiting for a response\n", 457 __func__); 458 } 459 if (error) { 460 device_printf(dev, 461 "%s: Unable to get VF configuration from PF after %d tries!\n", 462 __func__, retried + 1); 463 ret_error = 4; 464 } 465 goto done; 466 467 fail: 468 free(sc->vf_res, M_IAVF); 469 done: 470 return (ret_error); 471 } 472 473 /** 474 * iavf_print_device_info - Print some device parameters at attach 475 * @sc: device private softc 476 * 477 * Log a message about this virtual device's capabilities at attach time. 478 */ 479 void 480 iavf_print_device_info(struct iavf_sc *sc) 481 { 482 device_t dev = sc->dev; 483 484 device_printf(dev, 485 "VSIs %d, QPs %d, MSI-X %d, RSS sizes: key %d lut %d\n", 486 sc->vf_res->num_vsis, 487 sc->vf_res->num_queue_pairs, 488 sc->vf_res->max_vectors, 489 sc->vf_res->rss_key_size, 490 sc->vf_res->rss_lut_size); 491 iavf_dbg_info(sc, "Capabilities=%b\n", 492 sc->vf_res->vf_cap_flags, IAVF_PRINTF_VF_OFFLOAD_FLAGS); 493 } 494 495 /** 496 * iavf_get_vsi_res_from_vf_res - Get VSI parameters and info for this VF 497 * @sc: device private softc 498 * 499 * Get the VSI parameters and information from the general VF resource info 500 * received by the physical device. 501 * 502 * @returns zero on success, or an error code on failure. 503 */ 504 int 505 iavf_get_vsi_res_from_vf_res(struct iavf_sc *sc) 506 { 507 struct iavf_vsi *vsi = &sc->vsi; 508 device_t dev = sc->dev; 509 510 sc->vsi_res = NULL; 511 512 for (int i = 0; i < sc->vf_res->num_vsis; i++) { 513 /* XXX: We only use the first VSI we find */ 514 if (sc->vf_res->vsi_res[i].vsi_type == IAVF_VSI_SRIOV) 515 sc->vsi_res = &sc->vf_res->vsi_res[i]; 516 } 517 if (!sc->vsi_res) { 518 device_printf(dev, "%s: no LAN VSI found\n", __func__); 519 return (EIO); 520 } 521 522 vsi->id = sc->vsi_res->vsi_id; 523 return (0); 524 } 525 526 /** 527 * iavf_set_mac_addresses - Set the MAC address for this interface 528 * @sc: device private softc 529 * 530 * Set the permanent MAC address field in the HW structure. If a MAC address 531 * has not yet been set for this device by the physical function, generate one 532 * randomly. 533 */ 534 void 535 iavf_set_mac_addresses(struct iavf_sc *sc) 536 { 537 struct iavf_hw *hw = &sc->hw; 538 device_t dev = sc->dev; 539 u8 addr[ETHER_ADDR_LEN]; 540 541 /* If no mac address was assigned just make a random one */ 542 if (ETHER_IS_ZERO(hw->mac.addr)) { 543 arc4rand(&addr, sizeof(addr), 0); 544 addr[0] &= 0xFE; 545 addr[0] |= 0x02; 546 memcpy(hw->mac.addr, addr, sizeof(addr)); 547 device_printf(dev, "Generated random MAC address\n"); 548 } 549 memcpy(hw->mac.perm_addr, hw->mac.addr, ETHER_ADDR_LEN); 550 } 551 552 /** 553 * iavf_init_filters - Initialize filter structures 554 * @sc: device private softc 555 * 556 * Initialize the MAC and VLAN filter list heads. 557 * 558 * @remark this is intended to be called only once during the device attach 559 * process. 560 * 561 * @pre Because it uses M_WAITOK, this function should only be called in 562 * a context that is safe to sleep. 563 */ 564 void 565 iavf_init_filters(struct iavf_sc *sc) 566 { 567 sc->mac_filters = (struct mac_list *)malloc(sizeof(struct iavf_mac_filter), 568 M_IAVF, M_WAITOK | M_ZERO); 569 SLIST_INIT(sc->mac_filters); 570 sc->vlan_filters = (struct vlan_list *)malloc(sizeof(struct iavf_vlan_filter), 571 M_IAVF, M_WAITOK | M_ZERO); 572 SLIST_INIT(sc->vlan_filters); 573 } 574 575 /** 576 * iavf_free_filters - Release filter lists 577 * @sc: device private softc 578 * 579 * Free the MAC and VLAN filter lists. 580 * 581 * @remark this is intended to be called only once during the device detach 582 * process. 583 */ 584 void 585 iavf_free_filters(struct iavf_sc *sc) 586 { 587 struct iavf_mac_filter *f; 588 struct iavf_vlan_filter *v; 589 590 while (!SLIST_EMPTY(sc->mac_filters)) { 591 f = SLIST_FIRST(sc->mac_filters); 592 SLIST_REMOVE_HEAD(sc->mac_filters, next); 593 free(f, M_IAVF); 594 } 595 free(sc->mac_filters, M_IAVF); 596 while (!SLIST_EMPTY(sc->vlan_filters)) { 597 v = SLIST_FIRST(sc->vlan_filters); 598 SLIST_REMOVE_HEAD(sc->vlan_filters, next); 599 free(v, M_IAVF); 600 } 601 free(sc->vlan_filters, M_IAVF); 602 } 603 604 /** 605 * iavf_add_device_sysctls_common - Initialize common device sysctls 606 * @sc: device private softc 607 * 608 * Setup sysctls common to both the iflib and legacy drivers. 609 */ 610 void 611 iavf_add_device_sysctls_common(struct iavf_sc *sc) 612 { 613 device_t dev = sc->dev; 614 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 615 struct sysctl_oid_list *ctx_list = 616 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 617 618 SYSCTL_ADD_PROC(ctx, ctx_list, 619 OID_AUTO, "current_speed", CTLTYPE_STRING | CTLFLAG_RD, 620 sc, 0, iavf_sysctl_current_speed, "A", "Current Port Speed"); 621 622 SYSCTL_ADD_PROC(ctx, ctx_list, 623 OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW, 624 sc, 0, iavf_sysctl_tx_itr, "I", 625 "Immediately set TX ITR value for all queues"); 626 627 SYSCTL_ADD_PROC(ctx, ctx_list, 628 OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW, 629 sc, 0, iavf_sysctl_rx_itr, "I", 630 "Immediately set RX ITR value for all queues"); 631 632 SYSCTL_ADD_UQUAD(ctx, ctx_list, 633 OID_AUTO, "admin_irq", CTLFLAG_RD, 634 &sc->admin_irq, "Admin Queue IRQ Handled"); 635 } 636 637 /** 638 * iavf_add_debug_sysctls_common - Initialize common debug sysctls 639 * @sc: device private softc 640 * @debug_list: pionter to debug sysctl node 641 * 642 * Setup sysctls used for debugging the device driver into the debug sysctl 643 * node. 644 */ 645 void 646 iavf_add_debug_sysctls_common(struct iavf_sc *sc, struct sysctl_oid_list *debug_list) 647 { 648 device_t dev = sc->dev; 649 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 650 651 SYSCTL_ADD_UINT(ctx, debug_list, 652 OID_AUTO, "shared_debug_mask", CTLFLAG_RW, 653 &sc->hw.debug_mask, 0, "Shared code debug message level"); 654 655 SYSCTL_ADD_UINT(ctx, debug_list, 656 OID_AUTO, "core_debug_mask", CTLFLAG_RW, 657 (unsigned int *)&sc->dbg_mask, 0, "Non-shared code debug message level"); 658 659 SYSCTL_ADD_PROC(ctx, debug_list, 660 OID_AUTO, "filter_list", CTLTYPE_STRING | CTLFLAG_RD, 661 sc, 0, iavf_sysctl_sw_filter_list, "A", "SW Filter List"); 662 } 663 664 /** 665 * iavf_sysctl_tx_itr - Sysctl to set the Tx ITR value 666 * @oidp: sysctl oid pointer 667 * @arg1: pointer to the device softc 668 * @arg2: unused sysctl argument 669 * @req: sysctl req pointer 670 * 671 * On read, returns the Tx ITR value for all of the VF queues. On write, 672 * update the Tx ITR registers with the new Tx ITR value. 673 * 674 * @returns zero on success, or an error code on failure. 675 */ 676 int 677 iavf_sysctl_tx_itr(SYSCTL_HANDLER_ARGS) 678 { 679 struct iavf_sc *sc = (struct iavf_sc *)arg1; 680 device_t dev = sc->dev; 681 int requested_tx_itr; 682 int error = 0; 683 684 UNREFERENCED_PARAMETER(arg2); 685 686 if (iavf_driver_is_detaching(sc)) 687 return (ESHUTDOWN); 688 689 requested_tx_itr = sc->tx_itr; 690 error = sysctl_handle_int(oidp, &requested_tx_itr, 0, req); 691 if ((error) || (req->newptr == NULL)) 692 return (error); 693 if (requested_tx_itr < 0 || requested_tx_itr > IAVF_MAX_ITR) { 694 device_printf(dev, 695 "Invalid TX itr value; value must be between 0 and %d\n", 696 IAVF_MAX_ITR); 697 return (EINVAL); 698 } 699 700 sc->tx_itr = requested_tx_itr; 701 iavf_configure_tx_itr(sc); 702 703 return (error); 704 } 705 706 /** 707 * iavf_sysctl_rx_itr - Sysctl to set the Rx ITR value 708 * @oidp: sysctl oid pointer 709 * @arg1: pointer to the device softc 710 * @arg2: unused sysctl argument 711 * @req: sysctl req pointer 712 * 713 * On read, returns the Rx ITR value for all of the VF queues. On write, 714 * update the ITR registers with the new Rx ITR value. 715 * 716 * @returns zero on success, or an error code on failure. 717 */ 718 int 719 iavf_sysctl_rx_itr(SYSCTL_HANDLER_ARGS) 720 { 721 struct iavf_sc *sc = (struct iavf_sc *)arg1; 722 device_t dev = sc->dev; 723 int requested_rx_itr; 724 int error = 0; 725 726 UNREFERENCED_PARAMETER(arg2); 727 728 if (iavf_driver_is_detaching(sc)) 729 return (ESHUTDOWN); 730 731 requested_rx_itr = sc->rx_itr; 732 error = sysctl_handle_int(oidp, &requested_rx_itr, 0, req); 733 if ((error) || (req->newptr == NULL)) 734 return (error); 735 if (requested_rx_itr < 0 || requested_rx_itr > IAVF_MAX_ITR) { 736 device_printf(dev, 737 "Invalid RX itr value; value must be between 0 and %d\n", 738 IAVF_MAX_ITR); 739 return (EINVAL); 740 } 741 742 sc->rx_itr = requested_rx_itr; 743 iavf_configure_rx_itr(sc); 744 745 return (error); 746 } 747 748 /** 749 * iavf_configure_tx_itr - Configure the Tx ITR 750 * @sc: device private softc 751 * 752 * Updates the ITR registers with a new Tx ITR setting. 753 */ 754 void 755 iavf_configure_tx_itr(struct iavf_sc *sc) 756 { 757 struct iavf_hw *hw = &sc->hw; 758 struct iavf_vsi *vsi = &sc->vsi; 759 struct iavf_tx_queue *que = vsi->tx_queues; 760 761 vsi->tx_itr_setting = sc->tx_itr; 762 763 for (int i = 0; i < IAVF_NTXQS(vsi); i++, que++) { 764 struct tx_ring *txr = &que->txr; 765 766 wr32(hw, IAVF_VFINT_ITRN1(IAVF_TX_ITR, i), 767 vsi->tx_itr_setting); 768 txr->itr = vsi->tx_itr_setting; 769 txr->latency = IAVF_AVE_LATENCY; 770 } 771 } 772 773 /** 774 * iavf_configure_rx_itr - Configure the Rx ITR 775 * @sc: device private softc 776 * 777 * Updates the ITR registers with a new Rx ITR setting. 778 */ 779 void 780 iavf_configure_rx_itr(struct iavf_sc *sc) 781 { 782 struct iavf_hw *hw = &sc->hw; 783 struct iavf_vsi *vsi = &sc->vsi; 784 struct iavf_rx_queue *que = vsi->rx_queues; 785 786 vsi->rx_itr_setting = sc->rx_itr; 787 788 for (int i = 0; i < IAVF_NRXQS(vsi); i++, que++) { 789 struct rx_ring *rxr = &que->rxr; 790 791 wr32(hw, IAVF_VFINT_ITRN1(IAVF_RX_ITR, i), 792 vsi->rx_itr_setting); 793 rxr->itr = vsi->rx_itr_setting; 794 rxr->latency = IAVF_AVE_LATENCY; 795 } 796 } 797 798 /** 799 * iavf_create_debug_sysctl_tree - Create a debug sysctl node 800 * @sc: device private softc 801 * 802 * Create a sysctl node meant to hold sysctls used to print debug information. 803 * Mark it as CTLFLAG_SKIP so that these sysctls do not show up in the 804 * "sysctl -a" output. 805 * 806 * @returns a pointer to the created sysctl node. 807 */ 808 struct sysctl_oid_list * 809 iavf_create_debug_sysctl_tree(struct iavf_sc *sc) 810 { 811 device_t dev = sc->dev; 812 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 813 struct sysctl_oid_list *ctx_list = 814 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 815 struct sysctl_oid *debug_node; 816 817 debug_node = SYSCTL_ADD_NODE(ctx, ctx_list, 818 OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP, NULL, "Debug Sysctls"); 819 820 return (SYSCTL_CHILDREN(debug_node)); 821 } 822 823 /** 824 * iavf_add_vsi_sysctls - Add sysctls for a given VSI 825 * @dev: device pointer 826 * @vsi: pointer to the VSI 827 * @ctx: sysctl context to add to 828 * @sysctl_name: name of the sysctl node (containing the VSI number) 829 * 830 * Adds a new sysctl node for holding specific sysctls for the given VSI. 831 */ 832 void 833 iavf_add_vsi_sysctls(device_t dev, struct iavf_vsi *vsi, 834 struct sysctl_ctx_list *ctx, const char *sysctl_name) 835 { 836 struct sysctl_oid *tree; 837 struct sysctl_oid_list *child; 838 struct sysctl_oid_list *vsi_list; 839 840 tree = device_get_sysctl_tree(dev); 841 child = SYSCTL_CHILDREN(tree); 842 vsi->vsi_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, sysctl_name, 843 CTLFLAG_RD, NULL, "VSI Number"); 844 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); 845 846 iavf_add_sysctls_eth_stats(ctx, vsi_list, &vsi->eth_stats); 847 } 848 849 /** 850 * iavf_sysctl_sw_filter_list - Dump software filters 851 * @oidp: sysctl oid pointer 852 * @arg1: pointer to the device softc 853 * @arg2: unused sysctl argument 854 * @req: sysctl req pointer 855 * 856 * On read, generates a string which lists the MAC and VLAN filters added to 857 * this virtual device. Useful for debugging to see whether or not the 858 * expected filters have been configured by software. 859 * 860 * @returns zero on success, or an error code on failure. 861 */ 862 int 863 iavf_sysctl_sw_filter_list(SYSCTL_HANDLER_ARGS) 864 { 865 struct iavf_sc *sc = (struct iavf_sc *)arg1; 866 struct iavf_mac_filter *f; 867 struct iavf_vlan_filter *v; 868 device_t dev = sc->dev; 869 int ftl_len, ftl_counter = 0, error = 0; 870 struct sbuf *buf; 871 872 UNREFERENCED_2PARAMETER(arg2, oidp); 873 874 if (iavf_driver_is_detaching(sc)) 875 return (ESHUTDOWN); 876 877 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 878 if (!buf) { 879 device_printf(dev, "Could not allocate sbuf for output.\n"); 880 return (ENOMEM); 881 } 882 883 sbuf_printf(buf, "\n"); 884 885 /* Print MAC filters */ 886 sbuf_printf(buf, "MAC Filters:\n"); 887 ftl_len = 0; 888 SLIST_FOREACH(f, sc->mac_filters, next) 889 ftl_len++; 890 if (ftl_len < 1) 891 sbuf_printf(buf, "(none)\n"); 892 else { 893 SLIST_FOREACH(f, sc->mac_filters, next) { 894 sbuf_printf(buf, 895 MAC_FORMAT ", flags %#06x\n", 896 MAC_FORMAT_ARGS(f->macaddr), f->flags); 897 } 898 } 899 900 /* Print VLAN filters */ 901 sbuf_printf(buf, "VLAN Filters:\n"); 902 ftl_len = 0; 903 SLIST_FOREACH(v, sc->vlan_filters, next) 904 ftl_len++; 905 if (ftl_len < 1) 906 sbuf_printf(buf, "(none)"); 907 else { 908 SLIST_FOREACH(v, sc->vlan_filters, next) { 909 sbuf_printf(buf, 910 "%d, flags %#06x", 911 v->vlan, v->flags); 912 /* don't print '\n' for last entry */ 913 if (++ftl_counter != ftl_len) 914 sbuf_printf(buf, "\n"); 915 } 916 } 917 918 error = sbuf_finish(buf); 919 if (error) 920 device_printf(dev, "Error finishing sbuf: %d\n", error); 921 922 sbuf_delete(buf); 923 return (error); 924 } 925 926 /** 927 * iavf_media_status_common - Get media status for this device 928 * @sc: device softc pointer 929 * @ifmr: ifmedia request structure 930 * 931 * Report the media status for this device into the given ifmr structure. 932 */ 933 void 934 iavf_media_status_common(struct iavf_sc *sc, struct ifmediareq *ifmr) 935 { 936 enum iavf_ext_link_speed ext_speed; 937 938 iavf_update_link_status(sc); 939 940 ifmr->ifm_status = IFM_AVALID; 941 ifmr->ifm_active = IFM_ETHER; 942 943 if (!sc->link_up) 944 return; 945 946 ifmr->ifm_status |= IFM_ACTIVE; 947 /* Hardware is always full-duplex */ 948 ifmr->ifm_active |= IFM_FDX; 949 950 /* Based on the link speed reported by the PF over the AdminQ, choose a 951 * PHY type to report. This isn't 100% correct since we don't really 952 * know the underlying PHY type of the PF, but at least we can report 953 * a valid link speed... 954 */ 955 if (IAVF_CAP_ADV_LINK_SPEED(sc)) 956 ext_speed = iavf_adv_speed_to_ext_speed(sc->link_speed_adv); 957 else 958 ext_speed = iavf_vc_speed_to_ext_speed(sc->link_speed); 959 960 ifmr->ifm_active |= iavf_ext_speed_to_ifmedia(ext_speed); 961 } 962 963 /** 964 * iavf_media_change_common - Change the media type for this device 965 * @ifp: ifnet structure 966 * 967 * @returns ENODEV because changing the media and speed is not supported. 968 */ 969 int 970 iavf_media_change_common(if_t ifp) 971 { 972 if_printf(ifp, "Changing speed is not supported\n"); 973 974 return (ENODEV); 975 } 976 977 /** 978 * iavf_set_initial_baudrate - Set the initial device baudrate 979 * @ifp: ifnet structure 980 * 981 * Set the baudrate for this ifnet structure to the expected initial value of 982 * 40Gbps. This maybe updated to a lower baudrate after the physical function 983 * reports speed to us over the virtchnl interface. 984 */ 985 void 986 iavf_set_initial_baudrate(if_t ifp) 987 { 988 if_setbaudrate(ifp, IF_Gbps(40)); 989 } 990 991 /** 992 * iavf_add_sysctls_eth_stats - Add ethernet statistics sysctls 993 * @ctx: the sysctl ctx to add to 994 * @child: the node to add the sysctls to 995 * @eth_stats: ethernet stats structure 996 * 997 * Creates sysctls that report the values of the provided ethernet stats 998 * structure. 999 */ 1000 void 1001 iavf_add_sysctls_eth_stats(struct sysctl_ctx_list *ctx, 1002 struct sysctl_oid_list *child, 1003 struct iavf_eth_stats *eth_stats) 1004 { 1005 struct iavf_sysctl_info ctls[] = 1006 { 1007 {ð_stats->rx_bytes, "good_octets_rcvd", "Good Octets Received"}, 1008 {ð_stats->rx_unicast, "ucast_pkts_rcvd", 1009 "Unicast Packets Received"}, 1010 {ð_stats->rx_multicast, "mcast_pkts_rcvd", 1011 "Multicast Packets Received"}, 1012 {ð_stats->rx_broadcast, "bcast_pkts_rcvd", 1013 "Broadcast Packets Received"}, 1014 {ð_stats->rx_discards, "rx_discards", "Discarded RX packets"}, 1015 {ð_stats->rx_unknown_protocol, "rx_unknown_proto", 1016 "RX unknown protocol packets"}, 1017 {ð_stats->tx_bytes, "good_octets_txd", "Good Octets Transmitted"}, 1018 {ð_stats->tx_unicast, "ucast_pkts_txd", "Unicast Packets Transmitted"}, 1019 {ð_stats->tx_multicast, "mcast_pkts_txd", 1020 "Multicast Packets Transmitted"}, 1021 {ð_stats->tx_broadcast, "bcast_pkts_txd", 1022 "Broadcast Packets Transmitted"}, 1023 {ð_stats->tx_errors, "tx_errors", "TX packet errors"}, 1024 // end 1025 {0,0,0} 1026 }; 1027 1028 struct iavf_sysctl_info *entry = ctls; 1029 1030 while (entry->stat != 0) 1031 { 1032 SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, entry->name, 1033 CTLFLAG_RD, entry->stat, 1034 entry->description); 1035 entry++; 1036 } 1037 } 1038 1039 /** 1040 * iavf_max_vc_speed_to_value - Convert link speed to IF speed value 1041 * @link_speeds: bitmap of supported link speeds 1042 * 1043 * @returns the link speed value for the highest speed reported in the 1044 * link_speeds bitmap. 1045 */ 1046 u64 1047 iavf_max_vc_speed_to_value(u8 link_speeds) 1048 { 1049 if (link_speeds & VIRTCHNL_LINK_SPEED_40GB) 1050 return IF_Gbps(40); 1051 if (link_speeds & VIRTCHNL_LINK_SPEED_25GB) 1052 return IF_Gbps(25); 1053 if (link_speeds & VIRTCHNL_LINK_SPEED_20GB) 1054 return IF_Gbps(20); 1055 if (link_speeds & VIRTCHNL_LINK_SPEED_10GB) 1056 return IF_Gbps(10); 1057 if (link_speeds & VIRTCHNL_LINK_SPEED_1GB) 1058 return IF_Gbps(1); 1059 if (link_speeds & VIRTCHNL_LINK_SPEED_100MB) 1060 return IF_Mbps(100); 1061 else 1062 /* Minimum supported link speed */ 1063 return IF_Mbps(100); 1064 } 1065 1066 /** 1067 * iavf_config_rss_reg - Configure RSS using registers 1068 * @sc: device private softc 1069 * 1070 * Configures RSS for this function using the device registers. Called if the 1071 * PF does not support configuring RSS over the virtchnl interface. 1072 */ 1073 void 1074 iavf_config_rss_reg(struct iavf_sc *sc) 1075 { 1076 struct iavf_hw *hw = &sc->hw; 1077 struct iavf_vsi *vsi = &sc->vsi; 1078 u32 lut = 0; 1079 u64 set_hena = 0, hena; 1080 int i, j, que_id; 1081 u32 rss_seed[IAVF_RSS_KEY_SIZE_REG]; 1082 #ifdef RSS 1083 u32 rss_hash_config; 1084 #endif 1085 1086 /* Don't set up RSS if using a single queue */ 1087 if (IAVF_NRXQS(vsi) == 1) { 1088 wr32(hw, IAVF_VFQF_HENA(0), 0); 1089 wr32(hw, IAVF_VFQF_HENA(1), 0); 1090 iavf_flush(hw); 1091 return; 1092 } 1093 1094 #ifdef RSS 1095 /* Fetch the configured RSS key */ 1096 rss_getkey((uint8_t *) &rss_seed); 1097 #else 1098 iavf_get_default_rss_key(rss_seed); 1099 #endif 1100 1101 /* Fill out hash function seed */ 1102 for (i = 0; i < IAVF_RSS_KEY_SIZE_REG; i++) 1103 wr32(hw, IAVF_VFQF_HKEY(i), rss_seed[i]); 1104 1105 /* Enable PCTYPES for RSS: */ 1106 #ifdef RSS 1107 rss_hash_config = rss_gethashconfig(); 1108 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 1109 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_OTHER); 1110 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 1111 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_TCP); 1112 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 1113 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_UDP); 1114 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 1115 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_OTHER); 1116 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 1117 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_FRAG_IPV6); 1118 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 1119 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_TCP); 1120 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 1121 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_UDP); 1122 #else 1123 set_hena = IAVF_DEFAULT_RSS_HENA_XL710; 1124 #endif 1125 hena = (u64)rd32(hw, IAVF_VFQF_HENA(0)) | 1126 ((u64)rd32(hw, IAVF_VFQF_HENA(1)) << 32); 1127 hena |= set_hena; 1128 wr32(hw, IAVF_VFQF_HENA(0), (u32)hena); 1129 wr32(hw, IAVF_VFQF_HENA(1), (u32)(hena >> 32)); 1130 1131 /* Populate the LUT with max no. of queues in round robin fashion */ 1132 for (i = 0, j = 0; i < IAVF_RSS_VSI_LUT_SIZE; i++, j++) { 1133 if (j == IAVF_NRXQS(vsi)) 1134 j = 0; 1135 #ifdef RSS 1136 /* 1137 * Fetch the RSS bucket id for the given indirection entry. 1138 * Cap it at the number of configured buckets (which is 1139 * num_rx_queues.) 1140 */ 1141 que_id = rss_get_indirection_to_bucket(i); 1142 que_id = que_id % IAVF_NRXQS(vsi); 1143 #else 1144 que_id = j; 1145 #endif 1146 /* lut = 4-byte sliding window of 4 lut entries */ 1147 lut = (lut << 8) | (que_id & IAVF_RSS_VF_LUT_ENTRY_MASK); 1148 /* On i = 3, we have 4 entries in lut; write to the register */ 1149 if ((i & 3) == 3) { 1150 wr32(hw, IAVF_VFQF_HLUT(i >> 2), lut); 1151 iavf_dbg_rss(sc, "%s: HLUT(%2d): %#010x", __func__, 1152 i, lut); 1153 } 1154 } 1155 iavf_flush(hw); 1156 } 1157 1158 /** 1159 * iavf_config_rss_pf - Configure RSS using PF virtchnl messages 1160 * @sc: device private softc 1161 * 1162 * Configure RSS by sending virtchnl messages to the PF. 1163 */ 1164 void 1165 iavf_config_rss_pf(struct iavf_sc *sc) 1166 { 1167 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIG_RSS_KEY); 1168 1169 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_SET_RSS_HENA); 1170 1171 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIG_RSS_LUT); 1172 } 1173 1174 /** 1175 * iavf_config_rss - setup RSS 1176 * @sc: device private softc 1177 * 1178 * Configures RSS using the method determined by capability flags in the VF 1179 * resources structure sent from the PF over the virtchnl interface. 1180 * 1181 * @remark RSS keys and table are cleared on VF reset. 1182 */ 1183 void 1184 iavf_config_rss(struct iavf_sc *sc) 1185 { 1186 if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_REG) { 1187 iavf_dbg_info(sc, "Setting up RSS using VF registers...\n"); 1188 iavf_config_rss_reg(sc); 1189 } else if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF) { 1190 iavf_dbg_info(sc, "Setting up RSS using messages to PF...\n"); 1191 iavf_config_rss_pf(sc); 1192 } else 1193 device_printf(sc->dev, "VF does not support RSS capability sent by PF.\n"); 1194 } 1195 1196 /** 1197 * iavf_config_promisc - setup promiscuous mode 1198 * @sc: device private softc 1199 * @flags: promiscuous flags to configure 1200 * 1201 * Request that promiscuous modes be enabled from the PF 1202 * 1203 * @returns zero on success, or an error code on failure. 1204 */ 1205 int 1206 iavf_config_promisc(struct iavf_sc *sc, int flags) 1207 { 1208 if_t ifp = sc->vsi.ifp; 1209 1210 sc->promisc_flags = 0; 1211 1212 if (flags & IFF_ALLMULTI || 1213 if_llmaddr_count(ifp) == MAX_MULTICAST_ADDR) 1214 sc->promisc_flags |= FLAG_VF_MULTICAST_PROMISC; 1215 if (flags & IFF_PROMISC) 1216 sc->promisc_flags |= FLAG_VF_UNICAST_PROMISC; 1217 1218 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIGURE_PROMISC); 1219 1220 return (0); 1221 } 1222 1223 /** 1224 * iavf_mc_filter_apply - Program a MAC filter for this VF 1225 * @arg: pointer to the device softc 1226 * @sdl: MAC multicast address 1227 * @cnt: unused parameter 1228 * 1229 * Program a MAC address multicast filter for this device. Intended 1230 * to be used with the map-like function if_foreach_llmaddr(). 1231 * 1232 * @returns 1 on success, or 0 on failure 1233 */ 1234 static u_int 1235 iavf_mc_filter_apply(void *arg, struct sockaddr_dl *sdl, u_int cnt __unused) 1236 { 1237 struct iavf_sc *sc = (struct iavf_sc *)arg; 1238 int error; 1239 1240 error = iavf_add_mac_filter(sc, (u8*)LLADDR(sdl), IAVF_FILTER_MC); 1241 1242 return (!error); 1243 } 1244 1245 /** 1246 * iavf_init_multi - Initialize multicast address filters 1247 * @sc: device private softc 1248 * 1249 * Called during initialization to reset multicast address filters to a known 1250 * fresh state by deleting all currently active filters. 1251 */ 1252 void 1253 iavf_init_multi(struct iavf_sc *sc) 1254 { 1255 struct iavf_mac_filter *f; 1256 int mcnt = 0; 1257 1258 /* First clear any multicast filters */ 1259 SLIST_FOREACH(f, sc->mac_filters, next) { 1260 if ((f->flags & IAVF_FILTER_USED) 1261 && (f->flags & IAVF_FILTER_MC)) { 1262 f->flags |= IAVF_FILTER_DEL; 1263 mcnt++; 1264 } 1265 } 1266 if (mcnt > 0) 1267 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_DEL_MAC_FILTER); 1268 } 1269 1270 /** 1271 * iavf_multi_set - Set multicast filters 1272 * @sc: device private softc 1273 * 1274 * Set multicast MAC filters for this device. If there are too many filters, 1275 * this will request the device to go into multicast promiscuous mode instead. 1276 */ 1277 void 1278 iavf_multi_set(struct iavf_sc *sc) 1279 { 1280 if_t ifp = sc->vsi.ifp; 1281 int mcnt = 0; 1282 1283 IOCTL_DEBUGOUT("iavf_multi_set: begin"); 1284 1285 mcnt = if_llmaddr_count(ifp); 1286 if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) { 1287 /* Delete MC filters and enable mulitcast promisc instead */ 1288 iavf_init_multi(sc); 1289 sc->promisc_flags |= FLAG_VF_MULTICAST_PROMISC; 1290 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIGURE_PROMISC); 1291 return; 1292 } 1293 1294 /* If there aren't too many filters, delete existing MC filters */ 1295 iavf_init_multi(sc); 1296 1297 /* And (re-)install filters for all mcast addresses */ 1298 mcnt = if_foreach_llmaddr(ifp, iavf_mc_filter_apply, sc); 1299 1300 if (mcnt > 0) 1301 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_ADD_MAC_FILTER); 1302 } 1303 1304 /** 1305 * iavf_add_mac_filter - Add a MAC filter to the sc MAC list 1306 * @sc: device private softc 1307 * @macaddr: MAC address to add 1308 * @flags: filter flags 1309 * 1310 * Add a new MAC filter to the softc MAC filter list. These will later be sent 1311 * to the physical function (and ultimately hardware) via the virtchnl 1312 * interface. 1313 * 1314 * @returns zero on success, EEXIST if the filter already exists, and ENOMEM 1315 * if we ran out of memory allocating the filter structure. 1316 */ 1317 int 1318 iavf_add_mac_filter(struct iavf_sc *sc, u8 *macaddr, u16 flags) 1319 { 1320 struct iavf_mac_filter *f; 1321 1322 /* Does one already exist? */ 1323 f = iavf_find_mac_filter(sc, macaddr); 1324 if (f != NULL) { 1325 iavf_dbg_filter(sc, "exists: " MAC_FORMAT "\n", 1326 MAC_FORMAT_ARGS(macaddr)); 1327 return (EEXIST); 1328 } 1329 1330 /* If not, get a new empty filter */ 1331 f = iavf_get_mac_filter(sc); 1332 if (f == NULL) { 1333 device_printf(sc->dev, "%s: no filters available!!\n", 1334 __func__); 1335 return (ENOMEM); 1336 } 1337 1338 iavf_dbg_filter(sc, "marked: " MAC_FORMAT "\n", 1339 MAC_FORMAT_ARGS(macaddr)); 1340 1341 bcopy(macaddr, f->macaddr, ETHER_ADDR_LEN); 1342 f->flags |= (IAVF_FILTER_ADD | IAVF_FILTER_USED); 1343 f->flags |= flags; 1344 return (0); 1345 } 1346 1347 /** 1348 * iavf_find_mac_filter - Find a MAC filter with the given address 1349 * @sc: device private softc 1350 * @macaddr: the MAC address to find 1351 * 1352 * Finds the filter structure in the MAC filter list with the corresponding 1353 * MAC address. 1354 * 1355 * @returns a pointer to the filter structure, or NULL if no such filter 1356 * exists in the list yet. 1357 */ 1358 struct iavf_mac_filter * 1359 iavf_find_mac_filter(struct iavf_sc *sc, u8 *macaddr) 1360 { 1361 struct iavf_mac_filter *f; 1362 bool match = FALSE; 1363 1364 SLIST_FOREACH(f, sc->mac_filters, next) { 1365 if (cmp_etheraddr(f->macaddr, macaddr)) { 1366 match = TRUE; 1367 break; 1368 } 1369 } 1370 1371 if (!match) 1372 f = NULL; 1373 return (f); 1374 } 1375 1376 /** 1377 * iavf_get_mac_filter - Get a new MAC address filter 1378 * @sc: device private softc 1379 * 1380 * Allocates a new filter structure and inserts it into the MAC filter list. 1381 * 1382 * @post the caller must fill in the structure details after calling this 1383 * function, but does not need to insert it into the linked list. 1384 * 1385 * @returns a pointer to the new filter structure, or NULL of we failed to 1386 * allocate it. 1387 */ 1388 struct iavf_mac_filter * 1389 iavf_get_mac_filter(struct iavf_sc *sc) 1390 { 1391 struct iavf_mac_filter *f; 1392 1393 f = (struct iavf_mac_filter *)malloc(sizeof(struct iavf_mac_filter), 1394 M_IAVF, M_NOWAIT | M_ZERO); 1395 if (f) 1396 SLIST_INSERT_HEAD(sc->mac_filters, f, next); 1397 1398 return (f); 1399 } 1400 1401 /** 1402 * iavf_baudrate_from_link_speed - Convert link speed to baudrate 1403 * @sc: device private softc 1404 * 1405 * @post The link_speed_adv field is in Mbps, so it is multipled by 1406 * 1,000,000 before it's returned. 1407 * 1408 * @returns the adapter link speed in bits/sec 1409 */ 1410 u64 1411 iavf_baudrate_from_link_speed(struct iavf_sc *sc) 1412 { 1413 if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_CAP_ADV_LINK_SPEED) 1414 return (sc->link_speed_adv * IAVF_ADV_LINK_SPEED_SCALE); 1415 else 1416 return iavf_max_vc_speed_to_value(sc->link_speed); 1417 } 1418 1419 /** 1420 * iavf_add_vlan_filter - Add a VLAN filter to the softc VLAN list 1421 * @sc: device private softc 1422 * @vtag: the VLAN id to filter 1423 * 1424 * Allocate a new VLAN filter structure and insert it into the VLAN list. 1425 */ 1426 void 1427 iavf_add_vlan_filter(struct iavf_sc *sc, u16 vtag) 1428 { 1429 struct iavf_vlan_filter *v; 1430 1431 v = (struct iavf_vlan_filter *)malloc(sizeof(struct iavf_vlan_filter), 1432 M_IAVF, M_WAITOK | M_ZERO); 1433 SLIST_INSERT_HEAD(sc->vlan_filters, v, next); 1434 v->vlan = vtag; 1435 v->flags = IAVF_FILTER_ADD; 1436 } 1437 1438 /** 1439 * iavf_mark_del_vlan_filter - Mark a given VLAN id for deletion 1440 * @sc: device private softc 1441 * @vtag: the VLAN id to delete 1442 * 1443 * Marks all VLAN filters matching the given vtag for deletion. 1444 * 1445 * @returns the number of filters marked for deletion. 1446 * 1447 * @remark the filters are not removed immediately, but will be removed from 1448 * the list by another function that synchronizes over the virtchnl interface. 1449 */ 1450 int 1451 iavf_mark_del_vlan_filter(struct iavf_sc *sc, u16 vtag) 1452 { 1453 struct iavf_vlan_filter *v; 1454 int i = 0; 1455 1456 SLIST_FOREACH(v, sc->vlan_filters, next) { 1457 if (v->vlan == vtag) { 1458 v->flags = IAVF_FILTER_DEL; 1459 ++i; 1460 } 1461 } 1462 1463 return (i); 1464 } 1465 1466 /** 1467 * iavf_update_msix_devinfo - Fix MSIX values for pci_msix_count() 1468 * @dev: pointer to kernel device 1469 * 1470 * Fix cached MSI-X control register information. This is a workaround 1471 * for an issue where VFs spawned in non-passthrough mode on FreeBSD 1472 * will have their PCI information cached before the PF driver 1473 * finishes updating their PCI information. 1474 * 1475 * @pre Must be called before pci_msix_count() 1476 */ 1477 void 1478 iavf_update_msix_devinfo(device_t dev) 1479 { 1480 struct pci_devinfo *dinfo; 1481 u32 msix_ctrl; 1482 1483 dinfo = (struct pci_devinfo *)device_get_ivars(dev); 1484 /* We can hardcode this offset since we know the device */ 1485 msix_ctrl = pci_read_config(dev, 0x70 + PCIR_MSIX_CTRL, 2); 1486 dinfo->cfg.msix.msix_ctrl = msix_ctrl; 1487 dinfo->cfg.msix.msix_msgnum = (msix_ctrl & PCIM_MSIXCTRL_TABLE_SIZE) + 1; 1488 } 1489 1490 /** 1491 * iavf_disable_queues_with_retries - Send PF multiple DISABLE_QUEUES messages 1492 * @sc: device softc 1493 * 1494 * Send a virtual channel message to the PF to DISABLE_QUEUES, but resend it up 1495 * to IAVF_MAX_DIS_Q_RETRY times if the response says that it wasn't 1496 * successful. This is intended to workaround a bug that can appear on the PF. 1497 */ 1498 void 1499 iavf_disable_queues_with_retries(struct iavf_sc *sc) 1500 { 1501 bool in_detach = iavf_driver_is_detaching(sc); 1502 int max_attempts = IAVF_MAX_DIS_Q_RETRY; 1503 int msg_count = 0; 1504 1505 /* While the driver is detaching, it doesn't care if the queue 1506 * disable finishes successfully or not. Just send one message 1507 * to just notify the PF driver. 1508 */ 1509 if (in_detach) 1510 max_attempts = 1; 1511 1512 while ((msg_count < max_attempts) && 1513 atomic_load_acq_32(&sc->queues_enabled)) { 1514 msg_count++; 1515 iavf_send_vc_msg_sleep(sc, IAVF_FLAG_AQ_DISABLE_QUEUES); 1516 } 1517 1518 /* Possibly print messages about retry attempts and issues */ 1519 if (msg_count > 1) 1520 iavf_dbg_vc(sc, "DISABLE_QUEUES messages sent: %d\n", 1521 msg_count); 1522 1523 if (!in_detach && msg_count >= max_attempts) 1524 device_printf(sc->dev, "%s: DISABLE_QUEUES may have failed\n", 1525 __func__); 1526 } 1527