ixv.c revision 1.151
1 /*$NetBSD: ixv.c,v 1.151 2020/06/25 07:53:02 msaitoh Exp $*/ 2 3 /****************************************************************************** 4 5 Copyright (c) 2001-2017, Intel Corporation 6 All rights reserved. 7 8 Redistribution and use in source and binary forms, with or without 9 modification, are permitted provided that the following conditions are met: 10 11 1. Redistributions of source code must retain the above copyright notice, 12 this list of conditions and the following disclaimer. 13 14 2. Redistributions in binary form must reproduce the above copyright 15 notice, this list of conditions and the following disclaimer in the 16 documentation and/or other materials provided with the distribution. 17 18 3. Neither the name of the Intel Corporation nor the names of its 19 contributors may be used to endorse or promote products derived from 20 this software without specific prior written permission. 21 22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 23 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 POSSIBILITY OF SUCH DAMAGE. 33 34 ******************************************************************************/ 35 /*$FreeBSD: head/sys/dev/ixgbe/if_ixv.c 331224 2018-03-19 20:55:05Z erj $*/ 36 37 #ifdef _KERNEL_OPT 38 #include "opt_inet.h" 39 #include "opt_inet6.h" 40 #include "opt_net_mpsafe.h" 41 #endif 42 43 #include "ixgbe.h" 44 #include "vlan.h" 45 46 /************************************************************************ 47 * Driver version 48 ************************************************************************/ 49 static const char ixv_driver_version[] = "2.0.1-k"; 50 /* XXX NetBSD: + 1.5.17 */ 51 52 /************************************************************************ 53 * PCI Device ID Table 54 * 55 * Used by probe to select devices to load on 56 * Last field stores an index into ixv_strings 57 * Last entry must be all 0s 58 * 59 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 60 ************************************************************************/ 61 static const ixgbe_vendor_info_t ixv_vendor_info_array[] = 62 { 63 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, 0, 0, 0}, 64 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, 0, 0, 0}, 65 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, 0, 0, 0}, 66 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, 0, 0, 0}, 67 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, 0, 0, 0}, 68 /* required last entry */ 69 {0, 0, 0, 0, 0} 70 }; 71 72 /************************************************************************ 73 * Table of branding strings 74 ************************************************************************/ 75 static const char *ixv_strings[] = { 76 "Intel(R) PRO/10GbE Virtual Function Network Driver" 77 }; 78 79 /********************************************************************* 80 * Function prototypes 81 *********************************************************************/ 82 static int ixv_probe(device_t, cfdata_t, void *); 83 static void ixv_attach(device_t, device_t, void *); 84 static int ixv_detach(device_t, int); 85 #if 0 86 static int ixv_shutdown(device_t); 87 #endif 88 static int ixv_ifflags_cb(struct ethercom *); 89 static int ixv_ioctl(struct ifnet *, u_long, void *); 90 static int ixv_init(struct ifnet *); 91 static void ixv_init_locked(struct adapter *); 92 static void ixv_ifstop(struct ifnet *, int); 93 static void ixv_stop(void *); 94 static void ixv_init_device_features(struct adapter *); 95 static void ixv_media_status(struct ifnet *, struct ifmediareq *); 96 static int ixv_media_change(struct ifnet *); 97 static int ixv_allocate_pci_resources(struct adapter *, 98 const struct pci_attach_args *); 99 static void ixv_free_workqueue(struct adapter *); 100 static int ixv_allocate_msix(struct adapter *, 101 const struct pci_attach_args *); 102 static int ixv_configure_interrupts(struct adapter *); 103 static void ixv_free_pci_resources(struct adapter *); 104 static void ixv_local_timer(void *); 105 static void ixv_handle_timer(struct work *, void *); 106 static int ixv_setup_interface(device_t, struct adapter *); 107 static void ixv_schedule_admin_tasklet(struct adapter *); 108 static int ixv_negotiate_api(struct adapter *); 109 110 static void ixv_initialize_transmit_units(struct adapter *); 111 static void ixv_initialize_receive_units(struct adapter *); 112 static void ixv_initialize_rss_mapping(struct adapter *); 113 static s32 ixv_check_link(struct adapter *); 114 115 static void ixv_enable_intr(struct adapter *); 116 static void ixv_disable_intr(struct adapter *); 117 static int ixv_set_rxfilter(struct adapter *); 118 static void ixv_update_link_status(struct adapter *); 119 static int ixv_sysctl_debug(SYSCTLFN_PROTO); 120 static void ixv_set_ivar(struct adapter *, u8, u8, s8); 121 static void ixv_configure_ivars(struct adapter *); 122 static u8 * ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 123 static void ixv_eitr_write(struct adapter *, uint32_t, uint32_t); 124 125 static void ixv_setup_vlan_tagging(struct adapter *); 126 static int ixv_setup_vlan_support(struct adapter *); 127 static int ixv_vlan_cb(struct ethercom *, uint16_t, bool); 128 static int ixv_register_vlan(struct adapter *, u16); 129 static int ixv_unregister_vlan(struct adapter *, u16); 130 131 static void ixv_add_device_sysctls(struct adapter *); 132 static void ixv_save_stats(struct adapter *); 133 static void ixv_init_stats(struct adapter *); 134 static void ixv_update_stats(struct adapter *); 135 static void ixv_add_stats_sysctls(struct adapter *); 136 static void ixv_clear_evcnt(struct adapter *); 137 138 /* Sysctl handlers */ 139 static void ixv_set_sysctl_value(struct adapter *, const char *, 140 const char *, int *, int); 141 static int ixv_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO); 142 static int ixv_sysctl_next_to_check_handler(SYSCTLFN_PROTO); 143 static int ixv_sysctl_rdh_handler(SYSCTLFN_PROTO); 144 static int ixv_sysctl_rdt_handler(SYSCTLFN_PROTO); 145 static int ixv_sysctl_tdt_handler(SYSCTLFN_PROTO); 146 static int ixv_sysctl_tdh_handler(SYSCTLFN_PROTO); 147 148 /* The MSI-X Interrupt handlers */ 149 static int ixv_msix_que(void *); 150 static int ixv_msix_mbx(void *); 151 152 /* Event handlers running on workqueue */ 153 static void ixv_handle_que(void *); 154 155 /* Deferred workqueue handlers */ 156 static void ixv_handle_admin(struct work *, void *); 157 static void ixv_handle_que_work(struct work *, void *); 158 159 const struct sysctlnode *ixv_sysctl_instance(struct adapter *); 160 static const ixgbe_vendor_info_t *ixv_lookup(const struct pci_attach_args *); 161 162 /************************************************************************ 163 * NetBSD Device Interface Entry Points 164 ************************************************************************/ 165 CFATTACH_DECL3_NEW(ixv, sizeof(struct adapter), 166 ixv_probe, ixv_attach, ixv_detach, NULL, NULL, NULL, 167 DVF_DETACH_SHUTDOWN); 168 169 #if 0 170 static driver_t ixv_driver = { 171 "ixv", ixv_methods, sizeof(struct adapter), 172 }; 173 174 devclass_t ixv_devclass; 175 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0); 176 MODULE_DEPEND(ixv, pci, 1, 1, 1); 177 MODULE_DEPEND(ixv, ether, 1, 1, 1); 178 #endif 179 180 /* 181 * TUNEABLE PARAMETERS: 182 */ 183 184 /* Number of Queues - do not exceed MSI-X vectors - 1 */ 185 static int ixv_num_queues = 0; 186 #define TUNABLE_INT(__x, __y) 187 TUNABLE_INT("hw.ixv.num_queues", &ixv_num_queues); 188 189 /* 190 * AIM: Adaptive Interrupt Moderation 191 * which means that the interrupt rate 192 * is varied over time based on the 193 * traffic for that interrupt vector 194 */ 195 static bool ixv_enable_aim = false; 196 TUNABLE_INT("hw.ixv.enable_aim", &ixv_enable_aim); 197 198 static int ixv_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 199 TUNABLE_INT("hw.ixv.max_interrupt_rate", &ixv_max_interrupt_rate); 200 201 /* How many packets rxeof tries to clean at a time */ 202 static int ixv_rx_process_limit = 256; 203 TUNABLE_INT("hw.ixv.rx_process_limit", &ixv_rx_process_limit); 204 205 /* How many packets txeof tries to clean at a time */ 206 static int ixv_tx_process_limit = 256; 207 TUNABLE_INT("hw.ixv.tx_process_limit", &ixv_tx_process_limit); 208 209 /* Which packet processing uses workqueue or softint */ 210 static bool ixv_txrx_workqueue = false; 211 212 /* 213 * Number of TX descriptors per ring, 214 * setting higher than RX as this seems 215 * the better performing choice. 216 */ 217 static int ixv_txd = PERFORM_TXD; 218 TUNABLE_INT("hw.ixv.txd", &ixv_txd); 219 220 /* Number of RX descriptors per ring */ 221 static int ixv_rxd = PERFORM_RXD; 222 TUNABLE_INT("hw.ixv.rxd", &ixv_rxd); 223 224 /* Legacy Transmit (single queue) */ 225 static int ixv_enable_legacy_tx = 0; 226 TUNABLE_INT("hw.ixv.enable_legacy_tx", &ixv_enable_legacy_tx); 227 228 #ifdef NET_MPSAFE 229 #define IXGBE_MPSAFE 1 230 #define IXGBE_CALLOUT_FLAGS CALLOUT_MPSAFE 231 #define IXGBE_SOFTINT_FLAGS SOFTINT_MPSAFE 232 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU | WQ_MPSAFE 233 #define IXGBE_TASKLET_WQ_FLAGS WQ_MPSAFE 234 #else 235 #define IXGBE_CALLOUT_FLAGS 0 236 #define IXGBE_SOFTINT_FLAGS 0 237 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU 238 #define IXGBE_TASKLET_WQ_FLAGS 0 239 #endif 240 #define IXGBE_WORKQUEUE_PRI PRI_SOFTNET 241 242 #if 0 243 static int (*ixv_start_locked)(struct ifnet *, struct tx_ring *); 244 static int (*ixv_ring_empty)(struct ifnet *, struct buf_ring *); 245 #endif 246 247 /************************************************************************ 248 * ixv_probe - Device identification routine 249 * 250 * Determines if the driver should be loaded on 251 * adapter based on its PCI vendor/device ID. 252 * 253 * return BUS_PROBE_DEFAULT on success, positive on failure 254 ************************************************************************/ 255 static int 256 ixv_probe(device_t dev, cfdata_t cf, void *aux) 257 { 258 #ifdef __HAVE_PCI_MSI_MSIX 259 const struct pci_attach_args *pa = aux; 260 261 return (ixv_lookup(pa) != NULL) ? 1 : 0; 262 #else 263 return 0; 264 #endif 265 } /* ixv_probe */ 266 267 static const ixgbe_vendor_info_t * 268 ixv_lookup(const struct pci_attach_args *pa) 269 { 270 const ixgbe_vendor_info_t *ent; 271 pcireg_t subid; 272 273 INIT_DEBUGOUT("ixv_lookup: begin"); 274 275 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 276 return NULL; 277 278 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 279 280 for (ent = ixv_vendor_info_array; ent->vendor_id != 0; ent++) { 281 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 282 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 283 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 284 (ent->subvendor_id == 0)) && 285 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 286 (ent->subdevice_id == 0))) { 287 return ent; 288 } 289 } 290 291 return NULL; 292 } 293 294 /************************************************************************ 295 * ixv_attach - Device initialization routine 296 * 297 * Called when the driver is being loaded. 298 * Identifies the type of hardware, allocates all resources 299 * and initializes the hardware. 300 * 301 * return 0 on success, positive on failure 302 ************************************************************************/ 303 static void 304 ixv_attach(device_t parent, device_t dev, void *aux) 305 { 306 struct adapter *adapter; 307 struct ixgbe_hw *hw; 308 int error = 0; 309 pcireg_t id, subid; 310 const ixgbe_vendor_info_t *ent; 311 const struct pci_attach_args *pa = aux; 312 const char *apivstr; 313 const char *str; 314 char wqname[MAXCOMLEN]; 315 char buf[256]; 316 317 INIT_DEBUGOUT("ixv_attach: begin"); 318 319 /* 320 * Make sure BUSMASTER is set, on a VM under 321 * KVM it may not be and will break things. 322 */ 323 ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag); 324 325 /* Allocate, clear, and link in our adapter structure */ 326 adapter = device_private(dev); 327 adapter->hw.back = adapter; 328 adapter->dev = dev; 329 hw = &adapter->hw; 330 331 adapter->init_locked = ixv_init_locked; 332 adapter->stop_locked = ixv_stop; 333 334 adapter->osdep.pc = pa->pa_pc; 335 adapter->osdep.tag = pa->pa_tag; 336 if (pci_dma64_available(pa)) 337 adapter->osdep.dmat = pa->pa_dmat64; 338 else 339 adapter->osdep.dmat = pa->pa_dmat; 340 adapter->osdep.attached = false; 341 342 ent = ixv_lookup(pa); 343 344 KASSERT(ent != NULL); 345 346 aprint_normal(": %s, Version - %s\n", 347 ixv_strings[ent->index], ixv_driver_version); 348 349 /* Core Lock Init */ 350 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 351 352 /* Do base PCI setup - map BAR0 */ 353 if (ixv_allocate_pci_resources(adapter, pa)) { 354 aprint_error_dev(dev, "ixv_allocate_pci_resources() failed!\n"); 355 error = ENXIO; 356 goto err_out; 357 } 358 359 /* SYSCTL APIs */ 360 ixv_add_device_sysctls(adapter); 361 362 /* Set up the timer callout and workqueue */ 363 callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS); 364 snprintf(wqname, sizeof(wqname), "%s-timer", device_xname(dev)); 365 error = workqueue_create(&adapter->timer_wq, wqname, 366 ixv_handle_timer, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 367 IXGBE_TASKLET_WQ_FLAGS); 368 if (error) { 369 aprint_error_dev(dev, 370 "could not create timer workqueue (%d)\n", error); 371 goto err_out; 372 } 373 374 /* Save off the information about this board */ 375 id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 376 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 377 hw->vendor_id = PCI_VENDOR(id); 378 hw->device_id = PCI_PRODUCT(id); 379 hw->revision_id = 380 PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG)); 381 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 382 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 383 384 /* A subset of set_mac_type */ 385 switch (hw->device_id) { 386 case IXGBE_DEV_ID_82599_VF: 387 hw->mac.type = ixgbe_mac_82599_vf; 388 str = "82599 VF"; 389 break; 390 case IXGBE_DEV_ID_X540_VF: 391 hw->mac.type = ixgbe_mac_X540_vf; 392 str = "X540 VF"; 393 break; 394 case IXGBE_DEV_ID_X550_VF: 395 hw->mac.type = ixgbe_mac_X550_vf; 396 str = "X550 VF"; 397 break; 398 case IXGBE_DEV_ID_X550EM_X_VF: 399 hw->mac.type = ixgbe_mac_X550EM_x_vf; 400 str = "X550EM X VF"; 401 break; 402 case IXGBE_DEV_ID_X550EM_A_VF: 403 hw->mac.type = ixgbe_mac_X550EM_a_vf; 404 str = "X550EM A VF"; 405 break; 406 default: 407 /* Shouldn't get here since probe succeeded */ 408 aprint_error_dev(dev, "Unknown device ID!\n"); 409 error = ENXIO; 410 goto err_out; 411 break; 412 } 413 aprint_normal_dev(dev, "device %s\n", str); 414 415 ixv_init_device_features(adapter); 416 417 /* Initialize the shared code */ 418 error = ixgbe_init_ops_vf(hw); 419 if (error) { 420 aprint_error_dev(dev, "ixgbe_init_ops_vf() failed!\n"); 421 error = EIO; 422 goto err_out; 423 } 424 425 /* Setup the mailbox */ 426 ixgbe_init_mbx_params_vf(hw); 427 428 /* Set the right number of segments */ 429 adapter->num_segs = IXGBE_82599_SCATTER; 430 431 /* Reset mbox api to 1.0 */ 432 error = hw->mac.ops.reset_hw(hw); 433 if (error == IXGBE_ERR_RESET_FAILED) 434 aprint_error_dev(dev, "...reset_hw() failure: Reset Failed!\n"); 435 else if (error) 436 aprint_error_dev(dev, "...reset_hw() failed with error %d\n", 437 error); 438 if (error) { 439 error = EIO; 440 goto err_out; 441 } 442 443 error = hw->mac.ops.init_hw(hw); 444 if (error) { 445 aprint_error_dev(dev, "...init_hw() failed!\n"); 446 error = EIO; 447 goto err_out; 448 } 449 450 /* Negotiate mailbox API version */ 451 error = ixv_negotiate_api(adapter); 452 if (error) 453 aprint_normal_dev(dev, 454 "MBX API negotiation failed during attach!\n"); 455 switch (hw->api_version) { 456 case ixgbe_mbox_api_10: 457 apivstr = "1.0"; 458 break; 459 case ixgbe_mbox_api_20: 460 apivstr = "2.0"; 461 break; 462 case ixgbe_mbox_api_11: 463 apivstr = "1.1"; 464 break; 465 case ixgbe_mbox_api_12: 466 apivstr = "1.2"; 467 break; 468 case ixgbe_mbox_api_13: 469 apivstr = "1.3"; 470 break; 471 default: 472 apivstr = "unknown"; 473 break; 474 } 475 aprint_normal_dev(dev, "Mailbox API %s\n", apivstr); 476 477 /* If no mac address was assigned, make a random one */ 478 if (!ixv_check_ether_addr(hw->mac.addr)) { 479 u8 addr[ETHER_ADDR_LEN]; 480 uint64_t rndval = cprng_strong64(); 481 482 memcpy(addr, &rndval, sizeof(addr)); 483 addr[0] &= 0xFE; 484 addr[0] |= 0x02; 485 bcopy(addr, hw->mac.addr, sizeof(addr)); 486 } 487 488 /* Register for VLAN events */ 489 ether_set_vlan_cb(&adapter->osdep.ec, ixv_vlan_cb); 490 491 /* Sysctls for limiting the amount of work done in the taskqueues */ 492 ixv_set_sysctl_value(adapter, "rx_processing_limit", 493 "max number of rx packets to process", 494 &adapter->rx_process_limit, ixv_rx_process_limit); 495 496 ixv_set_sysctl_value(adapter, "tx_processing_limit", 497 "max number of tx packets to process", 498 &adapter->tx_process_limit, ixv_tx_process_limit); 499 500 /* Do descriptor calc and sanity checks */ 501 if (((ixv_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 502 ixv_txd < MIN_TXD || ixv_txd > MAX_TXD) { 503 aprint_error_dev(dev, "TXD config issue, using default!\n"); 504 adapter->num_tx_desc = DEFAULT_TXD; 505 } else 506 adapter->num_tx_desc = ixv_txd; 507 508 if (((ixv_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 509 ixv_rxd < MIN_RXD || ixv_rxd > MAX_RXD) { 510 aprint_error_dev(dev, "RXD config issue, using default!\n"); 511 adapter->num_rx_desc = DEFAULT_RXD; 512 } else 513 adapter->num_rx_desc = ixv_rxd; 514 515 /* Setup MSI-X */ 516 error = ixv_configure_interrupts(adapter); 517 if (error) 518 goto err_out; 519 520 /* Allocate our TX/RX Queues */ 521 if (ixgbe_allocate_queues(adapter)) { 522 aprint_error_dev(dev, "ixgbe_allocate_queues() failed!\n"); 523 error = ENOMEM; 524 goto err_out; 525 } 526 527 /* hw.ix defaults init */ 528 adapter->enable_aim = ixv_enable_aim; 529 530 adapter->txrx_use_workqueue = ixv_txrx_workqueue; 531 532 error = ixv_allocate_msix(adapter, pa); 533 if (error) { 534 aprint_error_dev(dev, "ixv_allocate_msix() failed!\n"); 535 goto err_late; 536 } 537 538 /* Setup OS specific network interface */ 539 error = ixv_setup_interface(dev, adapter); 540 if (error != 0) { 541 aprint_error_dev(dev, "ixv_setup_interface() failed!\n"); 542 goto err_late; 543 } 544 545 /* Do the stats setup */ 546 ixv_save_stats(adapter); 547 ixv_init_stats(adapter); 548 ixv_add_stats_sysctls(adapter); 549 550 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 551 ixgbe_netmap_attach(adapter); 552 553 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap); 554 aprint_verbose_dev(dev, "feature cap %s\n", buf); 555 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en); 556 aprint_verbose_dev(dev, "feature ena %s\n", buf); 557 558 INIT_DEBUGOUT("ixv_attach: end"); 559 adapter->osdep.attached = true; 560 561 return; 562 563 err_late: 564 ixgbe_free_queues(adapter); 565 err_out: 566 ixv_free_pci_resources(adapter); 567 IXGBE_CORE_LOCK_DESTROY(adapter); 568 569 return; 570 } /* ixv_attach */ 571 572 /************************************************************************ 573 * ixv_detach - Device removal routine 574 * 575 * Called when the driver is being removed. 576 * Stops the adapter and deallocates all the resources 577 * that were allocated for driver operation. 578 * 579 * return 0 on success, positive on failure 580 ************************************************************************/ 581 static int 582 ixv_detach(device_t dev, int flags) 583 { 584 struct adapter *adapter = device_private(dev); 585 struct ixgbe_hw *hw = &adapter->hw; 586 struct tx_ring *txr = adapter->tx_rings; 587 struct rx_ring *rxr = adapter->rx_rings; 588 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 589 590 INIT_DEBUGOUT("ixv_detach: begin"); 591 if (adapter->osdep.attached == false) 592 return 0; 593 594 /* Stop the interface. Callouts are stopped in it. */ 595 ixv_ifstop(adapter->ifp, 1); 596 597 #if NVLAN > 0 598 /* Make sure VLANs are not using driver */ 599 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 600 ; /* nothing to do: no VLANs */ 601 else if ((flags & (DETACH_SHUTDOWN | DETACH_FORCE)) != 0) 602 vlan_ifdetach(adapter->ifp); 603 else { 604 aprint_error_dev(dev, "VLANs in use, detach first\n"); 605 return EBUSY; 606 } 607 #endif 608 609 ether_ifdetach(adapter->ifp); 610 callout_halt(&adapter->timer, NULL); 611 ixv_free_workqueue(adapter); 612 613 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 614 netmap_detach(adapter->ifp); 615 616 ixv_free_pci_resources(adapter); 617 #if 0 /* XXX the NetBSD port is probably missing something here */ 618 bus_generic_detach(dev); 619 #endif 620 if_detach(adapter->ifp); 621 ifmedia_fini(&adapter->media); 622 if_percpuq_destroy(adapter->ipq); 623 624 sysctl_teardown(&adapter->sysctllog); 625 evcnt_detach(&adapter->efbig_tx_dma_setup); 626 evcnt_detach(&adapter->mbuf_defrag_failed); 627 evcnt_detach(&adapter->efbig2_tx_dma_setup); 628 evcnt_detach(&adapter->einval_tx_dma_setup); 629 evcnt_detach(&adapter->other_tx_dma_setup); 630 evcnt_detach(&adapter->eagain_tx_dma_setup); 631 evcnt_detach(&adapter->enomem_tx_dma_setup); 632 evcnt_detach(&adapter->watchdog_events); 633 evcnt_detach(&adapter->tso_err); 634 evcnt_detach(&adapter->admin_irqev); 635 evcnt_detach(&adapter->link_workev); 636 637 txr = adapter->tx_rings; 638 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 639 evcnt_detach(&adapter->queues[i].irqs); 640 evcnt_detach(&adapter->queues[i].handleq); 641 evcnt_detach(&adapter->queues[i].req); 642 evcnt_detach(&txr->no_desc_avail); 643 evcnt_detach(&txr->total_packets); 644 evcnt_detach(&txr->tso_tx); 645 #ifndef IXGBE_LEGACY_TX 646 evcnt_detach(&txr->pcq_drops); 647 #endif 648 649 evcnt_detach(&rxr->rx_packets); 650 evcnt_detach(&rxr->rx_bytes); 651 evcnt_detach(&rxr->rx_copies); 652 evcnt_detach(&rxr->no_jmbuf); 653 evcnt_detach(&rxr->rx_discarded); 654 } 655 evcnt_detach(&stats->ipcs); 656 evcnt_detach(&stats->l4cs); 657 evcnt_detach(&stats->ipcs_bad); 658 evcnt_detach(&stats->l4cs_bad); 659 660 /* Packet Reception Stats */ 661 evcnt_detach(&stats->vfgorc); 662 evcnt_detach(&stats->vfgprc); 663 evcnt_detach(&stats->vfmprc); 664 665 /* Packet Transmission Stats */ 666 evcnt_detach(&stats->vfgotc); 667 evcnt_detach(&stats->vfgptc); 668 669 /* Mailbox Stats */ 670 evcnt_detach(&hw->mbx.stats.msgs_tx); 671 evcnt_detach(&hw->mbx.stats.msgs_rx); 672 evcnt_detach(&hw->mbx.stats.acks); 673 evcnt_detach(&hw->mbx.stats.reqs); 674 evcnt_detach(&hw->mbx.stats.rsts); 675 676 ixgbe_free_queues(adapter); 677 678 IXGBE_CORE_LOCK_DESTROY(adapter); 679 680 return (0); 681 } /* ixv_detach */ 682 683 /************************************************************************ 684 * ixv_init_locked - Init entry point 685 * 686 * Used in two ways: It is used by the stack as an init entry 687 * point in network interface structure. It is also used 688 * by the driver as a hw/sw initialization routine to get 689 * to a consistent state. 690 * 691 * return 0 on success, positive on failure 692 ************************************************************************/ 693 static void 694 ixv_init_locked(struct adapter *adapter) 695 { 696 struct ifnet *ifp = adapter->ifp; 697 device_t dev = adapter->dev; 698 struct ixgbe_hw *hw = &adapter->hw; 699 struct ix_queue *que; 700 int error = 0; 701 uint32_t mask; 702 int i; 703 704 INIT_DEBUGOUT("ixv_init_locked: begin"); 705 KASSERT(mutex_owned(&adapter->core_mtx)); 706 hw->adapter_stopped = FALSE; 707 hw->mac.ops.stop_adapter(hw); 708 callout_stop(&adapter->timer); 709 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 710 que->disabled_count = 0; 711 712 adapter->max_frame_size = 713 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 714 715 /* reprogram the RAR[0] in case user changed it. */ 716 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 717 718 /* Get the latest mac address, User can use a LAA */ 719 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 720 IXGBE_ETH_LENGTH_OF_ADDRESS); 721 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1); 722 723 /* Prepare transmit descriptors and buffers */ 724 if (ixgbe_setup_transmit_structures(adapter)) { 725 aprint_error_dev(dev, "Could not setup transmit structures\n"); 726 ixv_stop(adapter); 727 return; 728 } 729 730 /* Reset VF and renegotiate mailbox API version */ 731 hw->mac.ops.reset_hw(hw); 732 hw->mac.ops.start_hw(hw); 733 error = ixv_negotiate_api(adapter); 734 if (error) 735 device_printf(dev, 736 "Mailbox API negotiation failed in init_locked!\n"); 737 738 ixv_initialize_transmit_units(adapter); 739 740 /* Setup Multicast table */ 741 ixv_set_rxfilter(adapter); 742 743 /* 744 * Determine the correct mbuf pool 745 * for doing jumbo/headersplit 746 */ 747 if (adapter->max_frame_size <= MCLBYTES) 748 adapter->rx_mbuf_sz = MCLBYTES; 749 else 750 adapter->rx_mbuf_sz = MJUMPAGESIZE; 751 752 /* Prepare receive descriptors and buffers */ 753 if (ixgbe_setup_receive_structures(adapter)) { 754 device_printf(dev, "Could not setup receive structures\n"); 755 ixv_stop(adapter); 756 return; 757 } 758 759 /* Configure RX settings */ 760 ixv_initialize_receive_units(adapter); 761 762 /* Initialize variable holding task enqueue requests interrupts */ 763 adapter->task_requests = 0; 764 765 /* Set up VLAN offload and filter */ 766 ixv_setup_vlan_support(adapter); 767 768 /* Set up MSI-X routing */ 769 ixv_configure_ivars(adapter); 770 771 /* Set up auto-mask */ 772 mask = (1 << adapter->vector); 773 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 774 mask |= (1 << que->msix); 775 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, mask); 776 777 /* Set moderation on the Link interrupt */ 778 ixv_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 779 780 /* Stats init */ 781 ixv_init_stats(adapter); 782 783 /* Config/Enable Link */ 784 hw->mac.get_link_status = TRUE; 785 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up, 786 FALSE); 787 788 /* Start watchdog */ 789 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 790 atomic_and_uint(&adapter->timer_pending, ~1); 791 792 /* OK to schedule workqueues. */ 793 adapter->schedule_wqs_ok = true; 794 795 /* And now turn on interrupts */ 796 ixv_enable_intr(adapter); 797 798 /* Update saved flags. See ixgbe_ifflags_cb() */ 799 adapter->if_flags = ifp->if_flags; 800 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 801 802 /* Now inform the stack we're ready */ 803 ifp->if_flags |= IFF_RUNNING; 804 ifp->if_flags &= ~IFF_OACTIVE; 805 806 return; 807 } /* ixv_init_locked */ 808 809 /************************************************************************ 810 * ixv_enable_queue 811 ************************************************************************/ 812 static inline void 813 ixv_enable_queue(struct adapter *adapter, u32 vector) 814 { 815 struct ixgbe_hw *hw = &adapter->hw; 816 struct ix_queue *que = &adapter->queues[vector]; 817 u32 queue = 1UL << vector; 818 u32 mask; 819 820 mutex_enter(&que->dc_mtx); 821 if (que->disabled_count > 0 && --que->disabled_count > 0) 822 goto out; 823 824 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 825 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask); 826 out: 827 mutex_exit(&que->dc_mtx); 828 } /* ixv_enable_queue */ 829 830 /************************************************************************ 831 * ixv_disable_queue 832 ************************************************************************/ 833 static inline void 834 ixv_disable_queue(struct adapter *adapter, u32 vector) 835 { 836 struct ixgbe_hw *hw = &adapter->hw; 837 struct ix_queue *que = &adapter->queues[vector]; 838 u32 queue = 1UL << vector; 839 u32 mask; 840 841 mutex_enter(&que->dc_mtx); 842 if (que->disabled_count++ > 0) 843 goto out; 844 845 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 846 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask); 847 out: 848 mutex_exit(&que->dc_mtx); 849 } /* ixv_disable_queue */ 850 851 #if 0 852 static inline void 853 ixv_rearm_queues(struct adapter *adapter, u64 queues) 854 { 855 u32 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 856 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEICS, mask); 857 } /* ixv_rearm_queues */ 858 #endif 859 860 861 /************************************************************************ 862 * ixv_msix_que - MSI-X Queue Interrupt Service routine 863 ************************************************************************/ 864 static int 865 ixv_msix_que(void *arg) 866 { 867 struct ix_queue *que = arg; 868 struct adapter *adapter = que->adapter; 869 struct tx_ring *txr = que->txr; 870 struct rx_ring *rxr = que->rxr; 871 bool more; 872 u32 newitr = 0; 873 874 ixv_disable_queue(adapter, que->msix); 875 ++que->irqs.ev_count; 876 877 #ifdef __NetBSD__ 878 /* Don't run ixgbe_rxeof in interrupt context */ 879 more = true; 880 #else 881 more = ixgbe_rxeof(que); 882 #endif 883 884 IXGBE_TX_LOCK(txr); 885 ixgbe_txeof(txr); 886 IXGBE_TX_UNLOCK(txr); 887 888 /* Do AIM now? */ 889 890 if (adapter->enable_aim == false) 891 goto no_calc; 892 /* 893 * Do Adaptive Interrupt Moderation: 894 * - Write out last calculated setting 895 * - Calculate based on average size over 896 * the last interval. 897 */ 898 if (que->eitr_setting) 899 ixv_eitr_write(adapter, que->msix, que->eitr_setting); 900 901 que->eitr_setting = 0; 902 903 /* Idle, do nothing */ 904 if ((txr->bytes == 0) && (rxr->bytes == 0)) 905 goto no_calc; 906 907 if ((txr->bytes) && (txr->packets)) 908 newitr = txr->bytes/txr->packets; 909 if ((rxr->bytes) && (rxr->packets)) 910 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 911 newitr += 24; /* account for hardware frame, crc */ 912 913 /* set an upper boundary */ 914 newitr = uimin(newitr, 3000); 915 916 /* Be nice to the mid range */ 917 if ((newitr > 300) && (newitr < 1200)) 918 newitr = (newitr / 3); 919 else 920 newitr = (newitr / 2); 921 922 /* 923 * When RSC is used, ITR interval must be larger than RSC_DELAY. 924 * Currently, we use 2us for RSC_DELAY. The minimum value is always 925 * greater than 2us on 100M (and 10M?(not documented)), but it's not 926 * on 1G and higher. 927 */ 928 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 929 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 930 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 931 newitr = IXGBE_MIN_RSC_EITR_10G1G; 932 } 933 934 /* save for next interrupt */ 935 que->eitr_setting = newitr; 936 937 /* Reset state */ 938 txr->bytes = 0; 939 txr->packets = 0; 940 rxr->bytes = 0; 941 rxr->packets = 0; 942 943 no_calc: 944 if (more) 945 softint_schedule(que->que_si); 946 else /* Re-enable this interrupt */ 947 ixv_enable_queue(adapter, que->msix); 948 949 return 1; 950 } /* ixv_msix_que */ 951 952 /************************************************************************ 953 * ixv_msix_mbx 954 ************************************************************************/ 955 static int 956 ixv_msix_mbx(void *arg) 957 { 958 struct adapter *adapter = arg; 959 struct ixgbe_hw *hw = &adapter->hw; 960 961 ++adapter->admin_irqev.ev_count; 962 /* NetBSD: We use auto-clear, so it's not required to write VTEICR */ 963 964 /* Link status change */ 965 hw->mac.get_link_status = TRUE; 966 atomic_or_32(&adapter->task_requests, IXGBE_REQUEST_TASK_MBX); 967 ixv_schedule_admin_tasklet(adapter); 968 969 return 1; 970 } /* ixv_msix_mbx */ 971 972 static void 973 ixv_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 974 { 975 976 /* 977 * Newer devices than 82598 have VF function, so this function is 978 * simple. 979 */ 980 itr |= IXGBE_EITR_CNT_WDIS; 981 982 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(index), itr); 983 } 984 985 986 /************************************************************************ 987 * ixv_media_status - Media Ioctl callback 988 * 989 * Called whenever the user queries the status of 990 * the interface using ifconfig. 991 ************************************************************************/ 992 static void 993 ixv_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 994 { 995 struct adapter *adapter = ifp->if_softc; 996 997 INIT_DEBUGOUT("ixv_media_status: begin"); 998 ixv_update_link_status(adapter); 999 1000 ifmr->ifm_status = IFM_AVALID; 1001 ifmr->ifm_active = IFM_ETHER; 1002 1003 if (adapter->link_active != LINK_STATE_UP) { 1004 ifmr->ifm_active |= IFM_NONE; 1005 return; 1006 } 1007 1008 ifmr->ifm_status |= IFM_ACTIVE; 1009 1010 switch (adapter->link_speed) { 1011 case IXGBE_LINK_SPEED_10GB_FULL: 1012 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 1013 break; 1014 case IXGBE_LINK_SPEED_5GB_FULL: 1015 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 1016 break; 1017 case IXGBE_LINK_SPEED_2_5GB_FULL: 1018 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 1019 break; 1020 case IXGBE_LINK_SPEED_1GB_FULL: 1021 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 1022 break; 1023 case IXGBE_LINK_SPEED_100_FULL: 1024 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1025 break; 1026 case IXGBE_LINK_SPEED_10_FULL: 1027 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 1028 break; 1029 } 1030 1031 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 1032 } /* ixv_media_status */ 1033 1034 /************************************************************************ 1035 * ixv_media_change - Media Ioctl callback 1036 * 1037 * Called when the user changes speed/duplex using 1038 * media/mediopt option with ifconfig. 1039 ************************************************************************/ 1040 static int 1041 ixv_media_change(struct ifnet *ifp) 1042 { 1043 struct adapter *adapter = ifp->if_softc; 1044 struct ifmedia *ifm = &adapter->media; 1045 1046 INIT_DEBUGOUT("ixv_media_change: begin"); 1047 1048 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 1049 return (EINVAL); 1050 1051 switch (IFM_SUBTYPE(ifm->ifm_media)) { 1052 case IFM_AUTO: 1053 break; 1054 default: 1055 device_printf(adapter->dev, "Only auto media type\n"); 1056 return (EINVAL); 1057 } 1058 1059 return (0); 1060 } /* ixv_media_change */ 1061 1062 static void 1063 ixv_schedule_admin_tasklet(struct adapter *adapter) 1064 { 1065 if (adapter->schedule_wqs_ok) { 1066 if (!adapter->admin_pending) { 1067 atomic_or_uint(&adapter->admin_pending, 1); 1068 workqueue_enqueue(adapter->admin_wq, 1069 &adapter->admin_wc, NULL); 1070 } 1071 } 1072 } 1073 1074 /************************************************************************ 1075 * ixv_negotiate_api 1076 * 1077 * Negotiate the Mailbox API with the PF; 1078 * start with the most featured API first. 1079 ************************************************************************/ 1080 static int 1081 ixv_negotiate_api(struct adapter *adapter) 1082 { 1083 struct ixgbe_hw *hw = &adapter->hw; 1084 int mbx_api[] = { ixgbe_mbox_api_13, 1085 ixgbe_mbox_api_12, 1086 ixgbe_mbox_api_11, 1087 ixgbe_mbox_api_10, 1088 ixgbe_mbox_api_unknown }; 1089 int i = 0; 1090 1091 while (mbx_api[i] != ixgbe_mbox_api_unknown) { 1092 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0) 1093 return (0); 1094 i++; 1095 } 1096 1097 return (EINVAL); 1098 } /* ixv_negotiate_api */ 1099 1100 1101 /************************************************************************ 1102 * ixv_set_rxfilter - Multicast Update 1103 * 1104 * Called whenever multicast address list is updated. 1105 ************************************************************************/ 1106 static int 1107 ixv_set_rxfilter(struct adapter *adapter) 1108 { 1109 u8 mta[IXGBE_MAX_VF_MC * IXGBE_ETH_LENGTH_OF_ADDRESS]; 1110 struct ifnet *ifp = adapter->ifp; 1111 struct ixgbe_hw *hw = &adapter->hw; 1112 u8 *update_ptr; 1113 int mcnt = 0; 1114 struct ethercom *ec = &adapter->osdep.ec; 1115 struct ether_multi *enm; 1116 struct ether_multistep step; 1117 bool overflow = false; 1118 int error, rc = 0; 1119 1120 KASSERT(mutex_owned(&adapter->core_mtx)); 1121 IOCTL_DEBUGOUT("ixv_set_rxfilter: begin"); 1122 1123 /* 1: For PROMISC */ 1124 if (ifp->if_flags & IFF_PROMISC) { 1125 error = hw->mac.ops.update_xcast_mode(hw, 1126 IXGBEVF_XCAST_MODE_PROMISC); 1127 if (error == IXGBE_ERR_NOT_TRUSTED) { 1128 device_printf(adapter->dev, 1129 "this interface is not trusted\n"); 1130 error = EPERM; 1131 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1132 device_printf(adapter->dev, 1133 "the PF doesn't support promisc mode\n"); 1134 error = EOPNOTSUPP; 1135 } else if (error == IXGBE_ERR_NOT_IN_PROMISC) { 1136 device_printf(adapter->dev, 1137 "the PF may not in promisc mode\n"); 1138 error = EINVAL; 1139 } else if (error) { 1140 device_printf(adapter->dev, 1141 "failed to set promisc mode. error = %d\n", 1142 error); 1143 error = EIO; 1144 } else 1145 return 0; 1146 rc = error; 1147 } 1148 1149 /* 2: For ALLMULTI or normal */ 1150 ETHER_LOCK(ec); 1151 ETHER_FIRST_MULTI(step, ec, enm); 1152 while (enm != NULL) { 1153 if ((mcnt >= IXGBE_MAX_VF_MC) || 1154 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 1155 ETHER_ADDR_LEN) != 0)) { 1156 overflow = true; 1157 break; 1158 } 1159 bcopy(enm->enm_addrlo, 1160 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS], 1161 IXGBE_ETH_LENGTH_OF_ADDRESS); 1162 mcnt++; 1163 ETHER_NEXT_MULTI(step, enm); 1164 } 1165 ETHER_UNLOCK(ec); 1166 1167 /* 3: For ALLMULTI */ 1168 if (overflow) { 1169 error = hw->mac.ops.update_xcast_mode(hw, 1170 IXGBEVF_XCAST_MODE_ALLMULTI); 1171 if (error == IXGBE_ERR_NOT_TRUSTED) { 1172 device_printf(adapter->dev, 1173 "this interface is not trusted\n"); 1174 error = EPERM; 1175 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 1176 device_printf(adapter->dev, 1177 "the PF doesn't support allmulti mode\n"); 1178 error = EOPNOTSUPP; 1179 } else if (error) { 1180 device_printf(adapter->dev, 1181 "number of Ethernet multicast addresses " 1182 "exceeds the limit (%d). error = %d\n", 1183 IXGBE_MAX_VF_MC, error); 1184 error = ENOSPC; 1185 } else { 1186 ETHER_LOCK(ec); 1187 ec->ec_flags |= ETHER_F_ALLMULTI; 1188 ETHER_UNLOCK(ec); 1189 return rc; /* Promisc might have failed */ 1190 } 1191 1192 if (rc == 0) 1193 rc = error; 1194 1195 /* Continue to update the multicast table as many as we can */ 1196 } 1197 1198 /* 4: For normal operation */ 1199 error = hw->mac.ops.update_xcast_mode(hw, IXGBEVF_XCAST_MODE_MULTI); 1200 if ((error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) || (error == 0)) { 1201 /* Normal operation */ 1202 ETHER_LOCK(ec); 1203 ec->ec_flags &= ~ETHER_F_ALLMULTI; 1204 ETHER_UNLOCK(ec); 1205 error = 0; 1206 } else if (error) { 1207 device_printf(adapter->dev, 1208 "failed to set Ethernet multicast address " 1209 "operation to normal. error = %d\n", error); 1210 } 1211 1212 update_ptr = mta; 1213 1214 error = adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, 1215 update_ptr, mcnt, ixv_mc_array_itr, TRUE); 1216 if (rc == 0) 1217 rc = error; 1218 1219 return rc; 1220 } /* ixv_set_rxfilter */ 1221 1222 /************************************************************************ 1223 * ixv_mc_array_itr 1224 * 1225 * An iterator function needed by the multicast shared code. 1226 * It feeds the shared code routine the addresses in the 1227 * array of ixv_set_rxfilter() one by one. 1228 ************************************************************************/ 1229 static u8 * 1230 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 1231 { 1232 u8 *addr = *update_ptr; 1233 u8 *newptr; 1234 1235 *vmdq = 0; 1236 1237 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS; 1238 *update_ptr = newptr; 1239 1240 return addr; 1241 } /* ixv_mc_array_itr */ 1242 1243 /************************************************************************ 1244 * ixv_local_timer - Timer routine 1245 * 1246 * Checks for link status, updates statistics, 1247 * and runs the watchdog check. 1248 ************************************************************************/ 1249 static void 1250 ixv_local_timer(void *arg) 1251 { 1252 struct adapter *adapter = arg; 1253 1254 if (adapter->schedule_wqs_ok) { 1255 if (!adapter->timer_pending) { 1256 atomic_or_uint(&adapter->timer_pending, 1); 1257 workqueue_enqueue(adapter->timer_wq, 1258 &adapter->timer_wc, NULL); 1259 } 1260 } 1261 } 1262 1263 static void 1264 ixv_handle_timer(struct work *wk, void *context) 1265 { 1266 struct adapter *adapter = context; 1267 device_t dev = adapter->dev; 1268 struct ix_queue *que = adapter->queues; 1269 u64 queues = 0; 1270 u64 v0, v1, v2, v3, v4, v5, v6, v7; 1271 int hung = 0; 1272 int i; 1273 1274 IXGBE_CORE_LOCK(adapter); 1275 1276 if (ixv_check_link(adapter)) { 1277 ixv_init_locked(adapter); 1278 IXGBE_CORE_UNLOCK(adapter); 1279 return; 1280 } 1281 1282 /* Stats Update */ 1283 ixv_update_stats(adapter); 1284 1285 /* Update some event counters */ 1286 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 1287 que = adapter->queues; 1288 for (i = 0; i < adapter->num_queues; i++, que++) { 1289 struct tx_ring *txr = que->txr; 1290 1291 v0 += txr->q_efbig_tx_dma_setup; 1292 v1 += txr->q_mbuf_defrag_failed; 1293 v2 += txr->q_efbig2_tx_dma_setup; 1294 v3 += txr->q_einval_tx_dma_setup; 1295 v4 += txr->q_other_tx_dma_setup; 1296 v5 += txr->q_eagain_tx_dma_setup; 1297 v6 += txr->q_enomem_tx_dma_setup; 1298 v7 += txr->q_tso_err; 1299 } 1300 adapter->efbig_tx_dma_setup.ev_count = v0; 1301 adapter->mbuf_defrag_failed.ev_count = v1; 1302 adapter->efbig2_tx_dma_setup.ev_count = v2; 1303 adapter->einval_tx_dma_setup.ev_count = v3; 1304 adapter->other_tx_dma_setup.ev_count = v4; 1305 adapter->eagain_tx_dma_setup.ev_count = v5; 1306 adapter->enomem_tx_dma_setup.ev_count = v6; 1307 adapter->tso_err.ev_count = v7; 1308 1309 /* 1310 * Check the TX queues status 1311 * - mark hung queues so we don't schedule on them 1312 * - watchdog only if all queues show hung 1313 */ 1314 que = adapter->queues; 1315 for (i = 0; i < adapter->num_queues; i++, que++) { 1316 /* Keep track of queues with work for soft irq */ 1317 if (que->txr->busy) 1318 queues |= ((u64)1 << que->me); 1319 /* 1320 * Each time txeof runs without cleaning, but there 1321 * are uncleaned descriptors it increments busy. If 1322 * we get to the MAX we declare it hung. 1323 */ 1324 if (que->busy == IXGBE_QUEUE_HUNG) { 1325 ++hung; 1326 /* Mark the queue as inactive */ 1327 adapter->active_queues &= ~((u64)1 << que->me); 1328 continue; 1329 } else { 1330 /* Check if we've come back from hung */ 1331 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 1332 adapter->active_queues |= ((u64)1 << que->me); 1333 } 1334 if (que->busy >= IXGBE_MAX_TX_BUSY) { 1335 device_printf(dev, 1336 "Warning queue %d appears to be hung!\n", i); 1337 que->txr->busy = IXGBE_QUEUE_HUNG; 1338 ++hung; 1339 } 1340 } 1341 1342 /* Only truly watchdog if all queues show hung */ 1343 if (hung == adapter->num_queues) 1344 goto watchdog; 1345 #if 0 1346 else if (queues != 0) { /* Force an IRQ on queues with work */ 1347 ixv_rearm_queues(adapter, queues); 1348 } 1349 #endif 1350 1351 atomic_and_uint(&adapter->timer_pending, ~1); 1352 IXGBE_CORE_UNLOCK(adapter); 1353 callout_reset(&adapter->timer, hz, ixv_local_timer, adapter); 1354 1355 return; 1356 1357 watchdog: 1358 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 1359 adapter->ifp->if_flags &= ~IFF_RUNNING; 1360 adapter->watchdog_events.ev_count++; 1361 ixv_init_locked(adapter); 1362 IXGBE_CORE_UNLOCK(adapter); 1363 } /* ixv_handle_timer */ 1364 1365 /************************************************************************ 1366 * ixv_update_link_status - Update OS on link state 1367 * 1368 * Note: Only updates the OS on the cached link state. 1369 * The real check of the hardware only happens with 1370 * a link interrupt. 1371 ************************************************************************/ 1372 static void 1373 ixv_update_link_status(struct adapter *adapter) 1374 { 1375 struct ifnet *ifp = adapter->ifp; 1376 device_t dev = adapter->dev; 1377 1378 KASSERT(mutex_owned(&adapter->core_mtx)); 1379 1380 if (adapter->link_up) { 1381 if (adapter->link_active != LINK_STATE_UP) { 1382 if (bootverbose) { 1383 const char *bpsmsg; 1384 1385 switch (adapter->link_speed) { 1386 case IXGBE_LINK_SPEED_10GB_FULL: 1387 bpsmsg = "10 Gbps"; 1388 break; 1389 case IXGBE_LINK_SPEED_5GB_FULL: 1390 bpsmsg = "5 Gbps"; 1391 break; 1392 case IXGBE_LINK_SPEED_2_5GB_FULL: 1393 bpsmsg = "2.5 Gbps"; 1394 break; 1395 case IXGBE_LINK_SPEED_1GB_FULL: 1396 bpsmsg = "1 Gbps"; 1397 break; 1398 case IXGBE_LINK_SPEED_100_FULL: 1399 bpsmsg = "100 Mbps"; 1400 break; 1401 case IXGBE_LINK_SPEED_10_FULL: 1402 bpsmsg = "10 Mbps"; 1403 break; 1404 default: 1405 bpsmsg = "unknown speed"; 1406 break; 1407 } 1408 device_printf(dev, "Link is up %s %s \n", 1409 bpsmsg, "Full Duplex"); 1410 } 1411 adapter->link_active = LINK_STATE_UP; 1412 if_link_state_change(ifp, LINK_STATE_UP); 1413 } 1414 } else { 1415 /* 1416 * Do it when link active changes to DOWN. i.e. 1417 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 1418 * b) LINK_STATE_UP -> LINK_STATE_DOWN 1419 */ 1420 if (adapter->link_active != LINK_STATE_DOWN) { 1421 if (bootverbose) 1422 device_printf(dev, "Link is Down\n"); 1423 if_link_state_change(ifp, LINK_STATE_DOWN); 1424 adapter->link_active = LINK_STATE_DOWN; 1425 } 1426 } 1427 } /* ixv_update_link_status */ 1428 1429 1430 /************************************************************************ 1431 * ixv_stop - Stop the hardware 1432 * 1433 * Disables all traffic on the adapter by issuing a 1434 * global reset on the MAC and deallocates TX/RX buffers. 1435 ************************************************************************/ 1436 static void 1437 ixv_ifstop(struct ifnet *ifp, int disable) 1438 { 1439 struct adapter *adapter = ifp->if_softc; 1440 1441 IXGBE_CORE_LOCK(adapter); 1442 ixv_stop(adapter); 1443 IXGBE_CORE_UNLOCK(adapter); 1444 1445 workqueue_wait(adapter->admin_wq, &adapter->admin_wc); 1446 atomic_and_uint(&adapter->admin_pending, ~1); 1447 workqueue_wait(adapter->timer_wq, &adapter->timer_wc); 1448 atomic_and_uint(&adapter->timer_pending, ~1); 1449 } 1450 1451 static void 1452 ixv_stop(void *arg) 1453 { 1454 struct ifnet *ifp; 1455 struct adapter *adapter = arg; 1456 struct ixgbe_hw *hw = &adapter->hw; 1457 1458 ifp = adapter->ifp; 1459 1460 KASSERT(mutex_owned(&adapter->core_mtx)); 1461 1462 INIT_DEBUGOUT("ixv_stop: begin\n"); 1463 ixv_disable_intr(adapter); 1464 1465 /* Tell the stack that the interface is no longer active */ 1466 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1467 1468 hw->mac.ops.reset_hw(hw); 1469 adapter->hw.adapter_stopped = FALSE; 1470 hw->mac.ops.stop_adapter(hw); 1471 callout_stop(&adapter->timer); 1472 1473 /* Don't schedule workqueues. */ 1474 adapter->schedule_wqs_ok = false; 1475 1476 /* reprogram the RAR[0] in case user changed it. */ 1477 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 1478 1479 return; 1480 } /* ixv_stop */ 1481 1482 1483 /************************************************************************ 1484 * ixv_allocate_pci_resources 1485 ************************************************************************/ 1486 static int 1487 ixv_allocate_pci_resources(struct adapter *adapter, 1488 const struct pci_attach_args *pa) 1489 { 1490 pcireg_t memtype, csr; 1491 device_t dev = adapter->dev; 1492 bus_addr_t addr; 1493 int flags; 1494 1495 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 1496 switch (memtype) { 1497 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 1498 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 1499 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 1500 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 1501 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 1502 goto map_err; 1503 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 1504 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 1505 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 1506 } 1507 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 1508 adapter->osdep.mem_size, flags, 1509 &adapter->osdep.mem_bus_space_handle) != 0) { 1510 map_err: 1511 adapter->osdep.mem_size = 0; 1512 aprint_error_dev(dev, "unable to map BAR0\n"); 1513 return ENXIO; 1514 } 1515 /* 1516 * Enable address decoding for memory range in case it's not 1517 * set. 1518 */ 1519 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 1520 PCI_COMMAND_STATUS_REG); 1521 csr |= PCI_COMMAND_MEM_ENABLE; 1522 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 1523 csr); 1524 break; 1525 default: 1526 aprint_error_dev(dev, "unexpected type on BAR0\n"); 1527 return ENXIO; 1528 } 1529 1530 /* Pick up the tuneable queues */ 1531 adapter->num_queues = ixv_num_queues; 1532 1533 return (0); 1534 } /* ixv_allocate_pci_resources */ 1535 1536 static void 1537 ixv_free_workqueue(struct adapter *adapter) 1538 { 1539 struct ix_queue *que = adapter->queues; 1540 struct tx_ring *txr = adapter->tx_rings; 1541 int i; 1542 1543 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 1544 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 1545 if (txr->txr_si != NULL) 1546 softint_disestablish(txr->txr_si); 1547 } 1548 if (que->que_si != NULL) 1549 softint_disestablish(que->que_si); 1550 } 1551 if (adapter->txr_wq != NULL) 1552 workqueue_destroy(adapter->txr_wq); 1553 if (adapter->txr_wq_enqueued != NULL) 1554 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 1555 if (adapter->que_wq != NULL) 1556 workqueue_destroy(adapter->que_wq); 1557 1558 /* Drain the Mailbox(link) queue */ 1559 if (adapter->admin_wq != NULL) { 1560 workqueue_destroy(adapter->admin_wq); 1561 adapter->admin_wq = NULL; 1562 } 1563 if (adapter->timer_wq != NULL) { 1564 workqueue_destroy(adapter->timer_wq); 1565 adapter->timer_wq = NULL; 1566 } 1567 } /* ixv_free_workqueue */ 1568 1569 /************************************************************************ 1570 * ixv_free_pci_resources 1571 ************************************************************************/ 1572 static void 1573 ixv_free_pci_resources(struct adapter * adapter) 1574 { 1575 struct ix_queue *que = adapter->queues; 1576 int rid; 1577 1578 /* 1579 * Release all msix queue resources: 1580 */ 1581 for (int i = 0; i < adapter->num_queues; i++, que++) { 1582 if (que->res != NULL) 1583 pci_intr_disestablish(adapter->osdep.pc, 1584 adapter->osdep.ihs[i]); 1585 } 1586 1587 1588 /* Clean the Mailbox interrupt last */ 1589 rid = adapter->vector; 1590 1591 if (adapter->osdep.ihs[rid] != NULL) { 1592 pci_intr_disestablish(adapter->osdep.pc, 1593 adapter->osdep.ihs[rid]); 1594 adapter->osdep.ihs[rid] = NULL; 1595 } 1596 1597 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1598 adapter->osdep.nintrs); 1599 1600 if (adapter->osdep.mem_size != 0) { 1601 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 1602 adapter->osdep.mem_bus_space_handle, 1603 adapter->osdep.mem_size); 1604 } 1605 1606 return; 1607 } /* ixv_free_pci_resources */ 1608 1609 /************************************************************************ 1610 * ixv_setup_interface 1611 * 1612 * Setup networking device structure and register an interface. 1613 ************************************************************************/ 1614 static int 1615 ixv_setup_interface(device_t dev, struct adapter *adapter) 1616 { 1617 struct ethercom *ec = &adapter->osdep.ec; 1618 struct ifnet *ifp; 1619 int rv; 1620 1621 INIT_DEBUGOUT("ixv_setup_interface: begin"); 1622 1623 ifp = adapter->ifp = &ec->ec_if; 1624 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1625 ifp->if_baudrate = IF_Gbps(10); 1626 ifp->if_init = ixv_init; 1627 ifp->if_stop = ixv_ifstop; 1628 ifp->if_softc = adapter; 1629 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1630 #ifdef IXGBE_MPSAFE 1631 ifp->if_extflags = IFEF_MPSAFE; 1632 #endif 1633 ifp->if_ioctl = ixv_ioctl; 1634 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1635 #if 0 1636 ixv_start_locked = ixgbe_legacy_start_locked; 1637 #endif 1638 } else { 1639 ifp->if_transmit = ixgbe_mq_start; 1640 #if 0 1641 ixv_start_locked = ixgbe_mq_start_locked; 1642 #endif 1643 } 1644 ifp->if_start = ixgbe_legacy_start; 1645 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1646 IFQ_SET_READY(&ifp->if_snd); 1647 1648 rv = if_initialize(ifp); 1649 if (rv != 0) { 1650 aprint_error_dev(dev, "if_initialize failed(%d)\n", rv); 1651 return rv; 1652 } 1653 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1654 ether_ifattach(ifp, adapter->hw.mac.addr); 1655 aprint_normal_dev(dev, "Ethernet address %s\n", 1656 ether_sprintf(adapter->hw.mac.addr)); 1657 /* 1658 * We use per TX queue softint, so if_deferred_start_init() isn't 1659 * used. 1660 */ 1661 ether_set_ifflags_cb(ec, ixv_ifflags_cb); 1662 1663 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR; 1664 1665 /* 1666 * Tell the upper layer(s) we support long frames. 1667 */ 1668 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1669 1670 /* Set capability flags */ 1671 ifp->if_capabilities |= IFCAP_HWCSUM 1672 | IFCAP_TSOv4 1673 | IFCAP_TSOv6; 1674 ifp->if_capenable = 0; 1675 1676 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER 1677 | ETHERCAP_VLAN_HWTAGGING 1678 | ETHERCAP_VLAN_HWCSUM 1679 | ETHERCAP_JUMBO_MTU 1680 | ETHERCAP_VLAN_MTU; 1681 1682 /* Enable the above capabilities by default */ 1683 ec->ec_capenable = ec->ec_capabilities; 1684 1685 /* Don't enable LRO by default */ 1686 #if 0 1687 /* NetBSD doesn't support LRO yet */ 1688 ifp->if_capabilities |= IFCAP_LRO; 1689 #endif 1690 1691 /* 1692 * Specify the media types supported by this adapter and register 1693 * callbacks to update media and link information 1694 */ 1695 ec->ec_ifmedia = &adapter->media; 1696 ifmedia_init_with_lock(&adapter->media, IFM_IMASK, ixv_media_change, 1697 ixv_media_status, &adapter->core_mtx); 1698 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1699 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1700 1701 if_register(ifp); 1702 1703 return 0; 1704 } /* ixv_setup_interface */ 1705 1706 1707 /************************************************************************ 1708 * ixv_initialize_transmit_units - Enable transmit unit. 1709 ************************************************************************/ 1710 static void 1711 ixv_initialize_transmit_units(struct adapter *adapter) 1712 { 1713 struct tx_ring *txr = adapter->tx_rings; 1714 struct ixgbe_hw *hw = &adapter->hw; 1715 int i; 1716 1717 for (i = 0; i < adapter->num_queues; i++, txr++) { 1718 u64 tdba = txr->txdma.dma_paddr; 1719 u32 txctrl, txdctl; 1720 int j = txr->me; 1721 1722 /* Set WTHRESH to 8, burst writeback */ 1723 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1724 txdctl |= (8 << 16); 1725 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1726 1727 /* Set the HW Tx Head and Tail indices */ 1728 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0); 1729 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0); 1730 1731 /* Set Tx Tail register */ 1732 txr->tail = IXGBE_VFTDT(j); 1733 1734 txr->txr_no_space = false; 1735 1736 /* Set Ring parameters */ 1737 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j), 1738 (tdba & 0x00000000ffffffffULL)); 1739 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32)); 1740 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j), 1741 adapter->num_tx_desc * sizeof(struct ixgbe_legacy_tx_desc)); 1742 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j)); 1743 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 1744 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl); 1745 1746 /* Now enable */ 1747 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j)); 1748 txdctl |= IXGBE_TXDCTL_ENABLE; 1749 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl); 1750 } 1751 1752 return; 1753 } /* ixv_initialize_transmit_units */ 1754 1755 1756 /************************************************************************ 1757 * ixv_initialize_rss_mapping 1758 ************************************************************************/ 1759 static void 1760 ixv_initialize_rss_mapping(struct adapter *adapter) 1761 { 1762 struct ixgbe_hw *hw = &adapter->hw; 1763 u32 reta = 0, mrqc, rss_key[10]; 1764 int queue_id; 1765 int i, j; 1766 u32 rss_hash_config; 1767 1768 /* force use default RSS key. */ 1769 #ifdef __NetBSD__ 1770 rss_getkey((uint8_t *) &rss_key); 1771 #else 1772 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1773 /* Fetch the configured RSS key */ 1774 rss_getkey((uint8_t *)&rss_key); 1775 } else { 1776 /* set up random bits */ 1777 cprng_fast(&rss_key, sizeof(rss_key)); 1778 } 1779 #endif 1780 1781 /* Now fill out hash function seeds */ 1782 for (i = 0; i < 10; i++) 1783 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]); 1784 1785 /* Set up the redirection table */ 1786 for (i = 0, j = 0; i < 64; i++, j++) { 1787 if (j == adapter->num_queues) 1788 j = 0; 1789 1790 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 1791 /* 1792 * Fetch the RSS bucket id for the given indirection 1793 * entry. Cap it at the number of configured buckets 1794 * (which is num_queues.) 1795 */ 1796 queue_id = rss_get_indirection_to_bucket(i); 1797 queue_id = queue_id % adapter->num_queues; 1798 } else 1799 queue_id = j; 1800 1801 /* 1802 * The low 8 bits are for hash value (n+0); 1803 * The next 8 bits are for hash value (n+1), etc. 1804 */ 1805 reta >>= 8; 1806 reta |= ((uint32_t)queue_id) << 24; 1807 if ((i & 3) == 3) { 1808 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta); 1809 reta = 0; 1810 } 1811 } 1812 1813 /* Perform hash on these packet types */ 1814 if (adapter->feat_en & IXGBE_FEATURE_RSS) 1815 rss_hash_config = rss_gethashconfig(); 1816 else { 1817 /* 1818 * Disable UDP - IP fragments aren't currently being handled 1819 * and so we end up with a mix of 2-tuple and 4-tuple 1820 * traffic. 1821 */ 1822 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 1823 | RSS_HASHTYPE_RSS_TCP_IPV4 1824 | RSS_HASHTYPE_RSS_IPV6 1825 | RSS_HASHTYPE_RSS_TCP_IPV6; 1826 } 1827 1828 mrqc = IXGBE_MRQC_RSSEN; 1829 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 1830 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 1831 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 1832 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 1833 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 1834 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 1835 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 1836 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 1837 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 1838 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n", 1839 __func__); 1840 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 1841 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n", 1842 __func__); 1843 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 1844 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 1845 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 1846 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 1847 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 1848 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n", 1849 __func__); 1850 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc); 1851 } /* ixv_initialize_rss_mapping */ 1852 1853 1854 /************************************************************************ 1855 * ixv_initialize_receive_units - Setup receive registers and features. 1856 ************************************************************************/ 1857 static void 1858 ixv_initialize_receive_units(struct adapter *adapter) 1859 { 1860 struct rx_ring *rxr = adapter->rx_rings; 1861 struct ixgbe_hw *hw = &adapter->hw; 1862 struct ifnet *ifp = adapter->ifp; 1863 u32 bufsz, psrtype; 1864 1865 if (ifp->if_mtu > ETHERMTU) 1866 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1867 else 1868 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 1869 1870 psrtype = IXGBE_PSRTYPE_TCPHDR 1871 | IXGBE_PSRTYPE_UDPHDR 1872 | IXGBE_PSRTYPE_IPV4HDR 1873 | IXGBE_PSRTYPE_IPV6HDR 1874 | IXGBE_PSRTYPE_L2HDR; 1875 1876 if (adapter->num_queues > 1) 1877 psrtype |= 1 << 29; 1878 1879 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype); 1880 1881 /* Tell PF our max_frame size */ 1882 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) { 1883 device_printf(adapter->dev, "There is a problem with the PF setup. It is likely the receive unit for this VF will not function correctly.\n"); 1884 } 1885 1886 for (int i = 0; i < adapter->num_queues; i++, rxr++) { 1887 u64 rdba = rxr->rxdma.dma_paddr; 1888 u32 reg, rxdctl; 1889 int j = rxr->me; 1890 1891 /* Disable the queue */ 1892 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)); 1893 rxdctl &= ~IXGBE_RXDCTL_ENABLE; 1894 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1895 for (int k = 0; k < 10; k++) { 1896 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1897 IXGBE_RXDCTL_ENABLE) 1898 msec_delay(1); 1899 else 1900 break; 1901 } 1902 IXGBE_WRITE_BARRIER(hw); 1903 /* Setup the Base and Length of the Rx Descriptor Ring */ 1904 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j), 1905 (rdba & 0x00000000ffffffffULL)); 1906 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32)); 1907 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j), 1908 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 1909 1910 /* Reset the ring indices */ 1911 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0); 1912 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0); 1913 1914 /* Set up the SRRCTL register */ 1915 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j)); 1916 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 1917 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 1918 reg |= bufsz; 1919 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 1920 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg); 1921 1922 /* Capture Rx Tail index */ 1923 rxr->tail = IXGBE_VFRDT(rxr->me); 1924 1925 /* Do the queue enabling last */ 1926 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME; 1927 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl); 1928 for (int k = 0; k < 10; k++) { 1929 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) & 1930 IXGBE_RXDCTL_ENABLE) 1931 break; 1932 msec_delay(1); 1933 } 1934 IXGBE_WRITE_BARRIER(hw); 1935 1936 /* Set the Tail Pointer */ 1937 #ifdef DEV_NETMAP 1938 /* 1939 * In netmap mode, we must preserve the buffers made 1940 * available to userspace before the if_init() 1941 * (this is true by default on the TX side, because 1942 * init makes all buffers available to userspace). 1943 * 1944 * netmap_reset() and the device specific routines 1945 * (e.g. ixgbe_setup_receive_rings()) map these 1946 * buffers at the end of the NIC ring, so here we 1947 * must set the RDT (tail) register to make sure 1948 * they are not overwritten. 1949 * 1950 * In this driver the NIC ring starts at RDH = 0, 1951 * RDT points to the last slot available for reception (?), 1952 * so RDT = num_rx_desc - 1 means the whole ring is available. 1953 */ 1954 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 1955 (ifp->if_capenable & IFCAP_NETMAP)) { 1956 struct netmap_adapter *na = NA(adapter->ifp); 1957 struct netmap_kring *kring = na->rx_rings[i]; 1958 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1959 1960 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t); 1961 } else 1962 #endif /* DEV_NETMAP */ 1963 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 1964 adapter->num_rx_desc - 1); 1965 } 1966 1967 if (adapter->hw.mac.type >= ixgbe_mac_X550_vf) 1968 ixv_initialize_rss_mapping(adapter); 1969 } /* ixv_initialize_receive_units */ 1970 1971 /************************************************************************ 1972 * ixv_sysctl_tdh_handler - Transmit Descriptor Head handler function 1973 * 1974 * Retrieves the TDH value from the hardware 1975 ************************************************************************/ 1976 static int 1977 ixv_sysctl_tdh_handler(SYSCTLFN_ARGS) 1978 { 1979 struct sysctlnode node = *rnode; 1980 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 1981 uint32_t val; 1982 1983 if (!txr) 1984 return (0); 1985 1986 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDH(txr->me)); 1987 node.sysctl_data = &val; 1988 return sysctl_lookup(SYSCTLFN_CALL(&node)); 1989 } /* ixv_sysctl_tdh_handler */ 1990 1991 /************************************************************************ 1992 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 1993 * 1994 * Retrieves the TDT value from the hardware 1995 ************************************************************************/ 1996 static int 1997 ixv_sysctl_tdt_handler(SYSCTLFN_ARGS) 1998 { 1999 struct sysctlnode node = *rnode; 2000 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2001 uint32_t val; 2002 2003 if (!txr) 2004 return (0); 2005 2006 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_VFTDT(txr->me)); 2007 node.sysctl_data = &val; 2008 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2009 } /* ixv_sysctl_tdt_handler */ 2010 2011 /************************************************************************ 2012 * ixv_sysctl_next_to_check_handler - Receive Descriptor next to check 2013 * handler function 2014 * 2015 * Retrieves the next_to_check value 2016 ************************************************************************/ 2017 static int 2018 ixv_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 2019 { 2020 struct sysctlnode node = *rnode; 2021 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2022 uint32_t val; 2023 2024 if (!rxr) 2025 return (0); 2026 2027 val = rxr->next_to_check; 2028 node.sysctl_data = &val; 2029 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2030 } /* ixv_sysctl_next_to_check_handler */ 2031 2032 /************************************************************************ 2033 * ixv_sysctl_rdh_handler - Receive Descriptor Head handler function 2034 * 2035 * Retrieves the RDH value from the hardware 2036 ************************************************************************/ 2037 static int 2038 ixv_sysctl_rdh_handler(SYSCTLFN_ARGS) 2039 { 2040 struct sysctlnode node = *rnode; 2041 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2042 uint32_t val; 2043 2044 if (!rxr) 2045 return (0); 2046 2047 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDH(rxr->me)); 2048 node.sysctl_data = &val; 2049 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2050 } /* ixv_sysctl_rdh_handler */ 2051 2052 /************************************************************************ 2053 * ixv_sysctl_rdt_handler - Receive Descriptor Tail handler function 2054 * 2055 * Retrieves the RDT value from the hardware 2056 ************************************************************************/ 2057 static int 2058 ixv_sysctl_rdt_handler(SYSCTLFN_ARGS) 2059 { 2060 struct sysctlnode node = *rnode; 2061 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2062 uint32_t val; 2063 2064 if (!rxr) 2065 return (0); 2066 2067 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_VFRDT(rxr->me)); 2068 node.sysctl_data = &val; 2069 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2070 } /* ixv_sysctl_rdt_handler */ 2071 2072 static void 2073 ixv_setup_vlan_tagging(struct adapter *adapter) 2074 { 2075 struct ethercom *ec = &adapter->osdep.ec; 2076 struct ixgbe_hw *hw = &adapter->hw; 2077 struct rx_ring *rxr; 2078 u32 ctrl; 2079 int i; 2080 bool hwtagging; 2081 2082 /* Enable HW tagging only if any vlan is attached */ 2083 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 2084 && VLAN_ATTACHED(ec); 2085 2086 /* Enable the queues */ 2087 for (i = 0; i < adapter->num_queues; i++) { 2088 rxr = &adapter->rx_rings[i]; 2089 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(rxr->me)); 2090 if (hwtagging) 2091 ctrl |= IXGBE_RXDCTL_VME; 2092 else 2093 ctrl &= ~IXGBE_RXDCTL_VME; 2094 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(rxr->me), ctrl); 2095 /* 2096 * Let Rx path know that it needs to store VLAN tag 2097 * as part of extra mbuf info. 2098 */ 2099 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2100 } 2101 } /* ixv_setup_vlan_tagging */ 2102 2103 /************************************************************************ 2104 * ixv_setup_vlan_support 2105 ************************************************************************/ 2106 static int 2107 ixv_setup_vlan_support(struct adapter *adapter) 2108 { 2109 struct ethercom *ec = &adapter->osdep.ec; 2110 struct ixgbe_hw *hw = &adapter->hw; 2111 u32 vid, vfta, retry; 2112 struct vlanid_list *vlanidp; 2113 int rv, error = 0; 2114 2115 /* 2116 * This function is called from both if_init and ifflags_cb() 2117 * on NetBSD. 2118 */ 2119 2120 /* 2121 * Part 1: 2122 * Setup VLAN HW tagging 2123 */ 2124 ixv_setup_vlan_tagging(adapter); 2125 2126 if (!VLAN_ATTACHED(ec)) 2127 return 0; 2128 2129 /* 2130 * Part 2: 2131 * Setup VLAN HW filter 2132 */ 2133 /* Cleanup shadow_vfta */ 2134 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) 2135 adapter->shadow_vfta[i] = 0; 2136 /* Generate shadow_vfta from ec_vids */ 2137 ETHER_LOCK(ec); 2138 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2139 uint32_t idx; 2140 2141 idx = vlanidp->vid / 32; 2142 KASSERT(idx < IXGBE_VFTA_SIZE); 2143 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2144 } 2145 ETHER_UNLOCK(ec); 2146 2147 /* 2148 * A soft reset zero's out the VFTA, so 2149 * we need to repopulate it now. 2150 */ 2151 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) { 2152 if (adapter->shadow_vfta[i] == 0) 2153 continue; 2154 vfta = adapter->shadow_vfta[i]; 2155 /* 2156 * Reconstruct the vlan id's 2157 * based on the bits set in each 2158 * of the array ints. 2159 */ 2160 for (int j = 0; j < 32; j++) { 2161 retry = 0; 2162 if ((vfta & ((u32)1 << j)) == 0) 2163 continue; 2164 vid = (i * 32) + j; 2165 2166 /* Call the shared code mailbox routine */ 2167 while ((rv = hw->mac.ops.set_vfta(hw, vid, 0, TRUE, 2168 FALSE)) != 0) { 2169 if (++retry > 5) { 2170 device_printf(adapter->dev, 2171 "%s: max retry exceeded\n", 2172 __func__); 2173 break; 2174 } 2175 } 2176 if (rv != 0) { 2177 device_printf(adapter->dev, 2178 "failed to set vlan %d\n", vid); 2179 error = EACCES; 2180 } 2181 } 2182 } 2183 return error; 2184 } /* ixv_setup_vlan_support */ 2185 2186 static int 2187 ixv_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2188 { 2189 struct ifnet *ifp = &ec->ec_if; 2190 struct adapter *adapter = ifp->if_softc; 2191 int rv; 2192 2193 if (set) 2194 rv = ixv_register_vlan(adapter, vid); 2195 else 2196 rv = ixv_unregister_vlan(adapter, vid); 2197 2198 if (rv != 0) 2199 return rv; 2200 2201 /* 2202 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2203 * or 0 to 1. 2204 */ 2205 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2206 ixv_setup_vlan_tagging(adapter); 2207 2208 return rv; 2209 } 2210 2211 /************************************************************************ 2212 * ixv_register_vlan 2213 * 2214 * Run via a vlan config EVENT, it enables us to use the 2215 * HW Filter table since we can get the vlan id. This just 2216 * creates the entry in the soft version of the VFTA, init 2217 * will repopulate the real table. 2218 ************************************************************************/ 2219 static int 2220 ixv_register_vlan(struct adapter *adapter, u16 vtag) 2221 { 2222 struct ixgbe_hw *hw = &adapter->hw; 2223 u16 index, bit; 2224 int error; 2225 2226 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2227 return EINVAL; 2228 IXGBE_CORE_LOCK(adapter); 2229 index = (vtag >> 5) & 0x7F; 2230 bit = vtag & 0x1F; 2231 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2232 error = hw->mac.ops.set_vfta(hw, vtag, 0, true, false); 2233 IXGBE_CORE_UNLOCK(adapter); 2234 2235 if (error != 0) { 2236 device_printf(adapter->dev, "failed to register vlan %hu\n", 2237 vtag); 2238 error = EACCES; 2239 } 2240 return error; 2241 } /* ixv_register_vlan */ 2242 2243 /************************************************************************ 2244 * ixv_unregister_vlan 2245 * 2246 * Run via a vlan unconfig EVENT, remove our entry 2247 * in the soft vfta. 2248 ************************************************************************/ 2249 static int 2250 ixv_unregister_vlan(struct adapter *adapter, u16 vtag) 2251 { 2252 struct ixgbe_hw *hw = &adapter->hw; 2253 u16 index, bit; 2254 int error; 2255 2256 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2257 return EINVAL; 2258 2259 IXGBE_CORE_LOCK(adapter); 2260 index = (vtag >> 5) & 0x7F; 2261 bit = vtag & 0x1F; 2262 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2263 error = hw->mac.ops.set_vfta(hw, vtag, 0, false, false); 2264 IXGBE_CORE_UNLOCK(adapter); 2265 2266 if (error != 0) { 2267 device_printf(adapter->dev, "failed to unregister vlan %hu\n", 2268 vtag); 2269 error = EIO; 2270 } 2271 return error; 2272 } /* ixv_unregister_vlan */ 2273 2274 /************************************************************************ 2275 * ixv_enable_intr 2276 ************************************************************************/ 2277 static void 2278 ixv_enable_intr(struct adapter *adapter) 2279 { 2280 struct ixgbe_hw *hw = &adapter->hw; 2281 struct ix_queue *que = adapter->queues; 2282 u32 mask; 2283 int i; 2284 2285 /* For VTEIAC */ 2286 mask = (1 << adapter->vector); 2287 for (i = 0; i < adapter->num_queues; i++, que++) 2288 mask |= (1 << que->msix); 2289 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask); 2290 2291 /* For VTEIMS */ 2292 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 2293 que = adapter->queues; 2294 for (i = 0; i < adapter->num_queues; i++, que++) 2295 ixv_enable_queue(adapter, que->msix); 2296 2297 IXGBE_WRITE_FLUSH(hw); 2298 } /* ixv_enable_intr */ 2299 2300 /************************************************************************ 2301 * ixv_disable_intr 2302 ************************************************************************/ 2303 static void 2304 ixv_disable_intr(struct adapter *adapter) 2305 { 2306 struct ix_queue *que = adapter->queues; 2307 2308 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0); 2309 2310 /* disable interrupts other than queues */ 2311 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, adapter->vector); 2312 2313 for (int i = 0; i < adapter->num_queues; i++, que++) 2314 ixv_disable_queue(adapter, que->msix); 2315 2316 IXGBE_WRITE_FLUSH(&adapter->hw); 2317 } /* ixv_disable_intr */ 2318 2319 /************************************************************************ 2320 * ixv_set_ivar 2321 * 2322 * Setup the correct IVAR register for a particular MSI-X interrupt 2323 * - entry is the register array entry 2324 * - vector is the MSI-X vector for this queue 2325 * - type is RX/TX/MISC 2326 ************************************************************************/ 2327 static void 2328 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 2329 { 2330 struct ixgbe_hw *hw = &adapter->hw; 2331 u32 ivar, index; 2332 2333 vector |= IXGBE_IVAR_ALLOC_VAL; 2334 2335 if (type == -1) { /* MISC IVAR */ 2336 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); 2337 ivar &= ~0xFF; 2338 ivar |= vector; 2339 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar); 2340 } else { /* RX/TX IVARS */ 2341 index = (16 * (entry & 1)) + (8 * type); 2342 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1)); 2343 ivar &= ~(0xffUL << index); 2344 ivar |= ((u32)vector << index); 2345 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar); 2346 } 2347 } /* ixv_set_ivar */ 2348 2349 /************************************************************************ 2350 * ixv_configure_ivars 2351 ************************************************************************/ 2352 static void 2353 ixv_configure_ivars(struct adapter *adapter) 2354 { 2355 struct ix_queue *que = adapter->queues; 2356 2357 /* XXX We should sync EITR value calculation with ixgbe.c? */ 2358 2359 for (int i = 0; i < adapter->num_queues; i++, que++) { 2360 /* First the RX queue entry */ 2361 ixv_set_ivar(adapter, i, que->msix, 0); 2362 /* ... and the TX */ 2363 ixv_set_ivar(adapter, i, que->msix, 1); 2364 /* Set an initial value in EITR */ 2365 ixv_eitr_write(adapter, que->msix, IXGBE_EITR_DEFAULT); 2366 } 2367 2368 /* For the mailbox interrupt */ 2369 ixv_set_ivar(adapter, 1, adapter->vector, -1); 2370 } /* ixv_configure_ivars */ 2371 2372 2373 /************************************************************************ 2374 * ixv_save_stats 2375 * 2376 * The VF stats registers never have a truly virgin 2377 * starting point, so this routine tries to make an 2378 * artificial one, marking ground zero on attach as 2379 * it were. 2380 ************************************************************************/ 2381 static void 2382 ixv_save_stats(struct adapter *adapter) 2383 { 2384 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2385 2386 if (stats->vfgprc.ev_count || stats->vfgptc.ev_count) { 2387 stats->saved_reset_vfgprc += 2388 stats->vfgprc.ev_count - stats->base_vfgprc; 2389 stats->saved_reset_vfgptc += 2390 stats->vfgptc.ev_count - stats->base_vfgptc; 2391 stats->saved_reset_vfgorc += 2392 stats->vfgorc.ev_count - stats->base_vfgorc; 2393 stats->saved_reset_vfgotc += 2394 stats->vfgotc.ev_count - stats->base_vfgotc; 2395 stats->saved_reset_vfmprc += 2396 stats->vfmprc.ev_count - stats->base_vfmprc; 2397 } 2398 } /* ixv_save_stats */ 2399 2400 /************************************************************************ 2401 * ixv_init_stats 2402 ************************************************************************/ 2403 static void 2404 ixv_init_stats(struct adapter *adapter) 2405 { 2406 struct ixgbe_hw *hw = &adapter->hw; 2407 2408 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC); 2409 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB); 2410 adapter->stats.vf.last_vfgorc |= 2411 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32); 2412 2413 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC); 2414 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB); 2415 adapter->stats.vf.last_vfgotc |= 2416 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32); 2417 2418 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC); 2419 2420 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc; 2421 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc; 2422 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc; 2423 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc; 2424 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc; 2425 } /* ixv_init_stats */ 2426 2427 #define UPDATE_STAT_32(reg, last, count) \ 2428 { \ 2429 u32 current = IXGBE_READ_REG(hw, (reg)); \ 2430 if (current < (last)) \ 2431 count.ev_count += 0x100000000LL; \ 2432 (last) = current; \ 2433 count.ev_count &= 0xFFFFFFFF00000000LL; \ 2434 count.ev_count |= current; \ 2435 } 2436 2437 #define UPDATE_STAT_36(lsb, msb, last, count) \ 2438 { \ 2439 u64 cur_lsb = IXGBE_READ_REG(hw, (lsb)); \ 2440 u64 cur_msb = IXGBE_READ_REG(hw, (msb)); \ 2441 u64 current = ((cur_msb << 32) | cur_lsb); \ 2442 if (current < (last)) \ 2443 count.ev_count += 0x1000000000LL; \ 2444 (last) = current; \ 2445 count.ev_count &= 0xFFFFFFF000000000LL; \ 2446 count.ev_count |= current; \ 2447 } 2448 2449 /************************************************************************ 2450 * ixv_update_stats - Update the board statistics counters. 2451 ************************************************************************/ 2452 void 2453 ixv_update_stats(struct adapter *adapter) 2454 { 2455 struct ixgbe_hw *hw = &adapter->hw; 2456 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2457 2458 UPDATE_STAT_32(IXGBE_VFGPRC, stats->last_vfgprc, stats->vfgprc); 2459 UPDATE_STAT_32(IXGBE_VFGPTC, stats->last_vfgptc, stats->vfgptc); 2460 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB, stats->last_vfgorc, 2461 stats->vfgorc); 2462 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB, stats->last_vfgotc, 2463 stats->vfgotc); 2464 UPDATE_STAT_32(IXGBE_VFMPRC, stats->last_vfmprc, stats->vfmprc); 2465 2466 /* VF doesn't count errors by hardware */ 2467 2468 } /* ixv_update_stats */ 2469 2470 /************************************************************************ 2471 * ixv_sysctl_interrupt_rate_handler 2472 ************************************************************************/ 2473 static int 2474 ixv_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 2475 { 2476 struct sysctlnode node = *rnode; 2477 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 2478 struct adapter *adapter = que->adapter; 2479 uint32_t reg, usec, rate; 2480 int error; 2481 2482 if (que == NULL) 2483 return 0; 2484 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_VTEITR(que->msix)); 2485 usec = ((reg & 0x0FF8) >> 3); 2486 if (usec > 0) 2487 rate = 500000 / usec; 2488 else 2489 rate = 0; 2490 node.sysctl_data = &rate; 2491 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2492 if (error || newp == NULL) 2493 return error; 2494 reg &= ~0xfff; /* default, no limitation */ 2495 if (rate > 0 && rate < 500000) { 2496 if (rate < 1000) 2497 rate = 1000; 2498 reg |= ((4000000 / rate) & 0xff8); 2499 /* 2500 * When RSC is used, ITR interval must be larger than 2501 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 2502 * The minimum value is always greater than 2us on 100M 2503 * (and 10M?(not documented)), but it's not on 1G and higher. 2504 */ 2505 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2506 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2507 if ((adapter->num_queues > 1) 2508 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 2509 return EINVAL; 2510 } 2511 ixv_max_interrupt_rate = rate; 2512 } else 2513 ixv_max_interrupt_rate = 0; 2514 ixv_eitr_write(adapter, que->msix, reg); 2515 2516 return (0); 2517 } /* ixv_sysctl_interrupt_rate_handler */ 2518 2519 const struct sysctlnode * 2520 ixv_sysctl_instance(struct adapter *adapter) 2521 { 2522 const char *dvname; 2523 struct sysctllog **log; 2524 int rc; 2525 const struct sysctlnode *rnode; 2526 2527 log = &adapter->sysctllog; 2528 dvname = device_xname(adapter->dev); 2529 2530 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 2531 0, CTLTYPE_NODE, dvname, 2532 SYSCTL_DESCR("ixv information and settings"), 2533 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 2534 goto err; 2535 2536 return rnode; 2537 err: 2538 device_printf(adapter->dev, 2539 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 2540 return NULL; 2541 } 2542 2543 static void 2544 ixv_add_device_sysctls(struct adapter *adapter) 2545 { 2546 struct sysctllog **log; 2547 const struct sysctlnode *rnode, *cnode; 2548 device_t dev; 2549 2550 dev = adapter->dev; 2551 log = &adapter->sysctllog; 2552 2553 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2554 aprint_error_dev(dev, "could not create sysctl root\n"); 2555 return; 2556 } 2557 2558 if (sysctl_createv(log, 0, &rnode, &cnode, 2559 CTLFLAG_READWRITE, CTLTYPE_INT, 2560 "debug", SYSCTL_DESCR("Debug Info"), 2561 ixv_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 2562 aprint_error_dev(dev, "could not create sysctl\n"); 2563 2564 if (sysctl_createv(log, 0, &rnode, &cnode, 2565 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2566 "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 2567 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 2568 aprint_error_dev(dev, "could not create sysctl\n"); 2569 2570 if (sysctl_createv(log, 0, &rnode, &cnode, 2571 CTLFLAG_READWRITE, CTLTYPE_BOOL, 2572 "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 2573 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 2574 aprint_error_dev(dev, "could not create sysctl\n"); 2575 } 2576 2577 /************************************************************************ 2578 * ixv_add_stats_sysctls - Add statistic sysctls for the VF. 2579 ************************************************************************/ 2580 static void 2581 ixv_add_stats_sysctls(struct adapter *adapter) 2582 { 2583 device_t dev = adapter->dev; 2584 struct tx_ring *txr = adapter->tx_rings; 2585 struct rx_ring *rxr = adapter->rx_rings; 2586 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2587 struct ixgbe_hw *hw = &adapter->hw; 2588 const struct sysctlnode *rnode, *cnode; 2589 struct sysctllog **log = &adapter->sysctllog; 2590 const char *xname = device_xname(dev); 2591 2592 /* Driver Statistics */ 2593 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 2594 NULL, xname, "Driver tx dma soft fail EFBIG"); 2595 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 2596 NULL, xname, "m_defrag() failed"); 2597 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 2598 NULL, xname, "Driver tx dma hard fail EFBIG"); 2599 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 2600 NULL, xname, "Driver tx dma hard fail EINVAL"); 2601 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 2602 NULL, xname, "Driver tx dma hard fail other"); 2603 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 2604 NULL, xname, "Driver tx dma soft fail EAGAIN"); 2605 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 2606 NULL, xname, "Driver tx dma soft fail ENOMEM"); 2607 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 2608 NULL, xname, "Watchdog timeouts"); 2609 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 2610 NULL, xname, "TSO errors"); 2611 evcnt_attach_dynamic(&adapter->admin_irqev, EVCNT_TYPE_INTR, 2612 NULL, xname, "Admin MSI-X IRQ Handled"); 2613 evcnt_attach_dynamic(&adapter->link_workev, EVCNT_TYPE_INTR, 2614 NULL, xname, "Admin event"); 2615 2616 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2617 snprintf(adapter->queues[i].evnamebuf, 2618 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 2619 xname, i); 2620 snprintf(adapter->queues[i].namebuf, 2621 sizeof(adapter->queues[i].namebuf), "q%d", i); 2622 2623 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2624 aprint_error_dev(dev, "could not create sysctl root\n"); 2625 break; 2626 } 2627 2628 if (sysctl_createv(log, 0, &rnode, &rnode, 2629 0, CTLTYPE_NODE, 2630 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 2631 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 2632 break; 2633 2634 if (sysctl_createv(log, 0, &rnode, &cnode, 2635 CTLFLAG_READWRITE, CTLTYPE_INT, 2636 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 2637 ixv_sysctl_interrupt_rate_handler, 0, 2638 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 2639 break; 2640 2641 if (sysctl_createv(log, 0, &rnode, &cnode, 2642 CTLFLAG_READONLY, CTLTYPE_INT, 2643 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 2644 ixv_sysctl_tdh_handler, 0, (void *)txr, 2645 0, CTL_CREATE, CTL_EOL) != 0) 2646 break; 2647 2648 if (sysctl_createv(log, 0, &rnode, &cnode, 2649 CTLFLAG_READONLY, CTLTYPE_INT, 2650 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 2651 ixv_sysctl_tdt_handler, 0, (void *)txr, 2652 0, CTL_CREATE, CTL_EOL) != 0) 2653 break; 2654 2655 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 2656 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 2657 evcnt_attach_dynamic(&adapter->queues[i].handleq, 2658 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 2659 "Handled queue in softint"); 2660 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 2661 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 2662 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 2663 NULL, adapter->queues[i].evnamebuf, "TSO"); 2664 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 2665 NULL, adapter->queues[i].evnamebuf, 2666 "Queue No Descriptor Available"); 2667 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 2668 NULL, adapter->queues[i].evnamebuf, 2669 "Queue Packets Transmitted"); 2670 #ifndef IXGBE_LEGACY_TX 2671 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 2672 NULL, adapter->queues[i].evnamebuf, 2673 "Packets dropped in pcq"); 2674 #endif 2675 2676 #ifdef LRO 2677 struct lro_ctrl *lro = &rxr->lro; 2678 #endif /* LRO */ 2679 2680 if (sysctl_createv(log, 0, &rnode, &cnode, 2681 CTLFLAG_READONLY, 2682 CTLTYPE_INT, 2683 "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"), 2684 ixv_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 2685 CTL_CREATE, CTL_EOL) != 0) 2686 break; 2687 2688 if (sysctl_createv(log, 0, &rnode, &cnode, 2689 CTLFLAG_READONLY, 2690 CTLTYPE_INT, 2691 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 2692 ixv_sysctl_rdh_handler, 0, (void *)rxr, 0, 2693 CTL_CREATE, CTL_EOL) != 0) 2694 break; 2695 2696 if (sysctl_createv(log, 0, &rnode, &cnode, 2697 CTLFLAG_READONLY, 2698 CTLTYPE_INT, 2699 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 2700 ixv_sysctl_rdt_handler, 0, (void *)rxr, 0, 2701 CTL_CREATE, CTL_EOL) != 0) 2702 break; 2703 2704 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 2705 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 2706 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 2707 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 2708 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 2709 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 2710 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 2711 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 2712 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 2713 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 2714 #ifdef LRO 2715 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 2716 CTLFLAG_RD, &lro->lro_queued, 0, 2717 "LRO Queued"); 2718 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 2719 CTLFLAG_RD, &lro->lro_flushed, 0, 2720 "LRO Flushed"); 2721 #endif /* LRO */ 2722 } 2723 2724 /* MAC stats get their own sub node */ 2725 2726 snprintf(stats->namebuf, 2727 sizeof(stats->namebuf), "%s MAC Statistics", xname); 2728 2729 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 2730 stats->namebuf, "rx csum offload - IP"); 2731 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 2732 stats->namebuf, "rx csum offload - L4"); 2733 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 2734 stats->namebuf, "rx csum offload - IP bad"); 2735 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 2736 stats->namebuf, "rx csum offload - L4 bad"); 2737 2738 /* Packet Reception Stats */ 2739 evcnt_attach_dynamic(&stats->vfgprc, EVCNT_TYPE_MISC, NULL, 2740 xname, "Good Packets Received"); 2741 evcnt_attach_dynamic(&stats->vfgorc, EVCNT_TYPE_MISC, NULL, 2742 xname, "Good Octets Received"); 2743 evcnt_attach_dynamic(&stats->vfmprc, EVCNT_TYPE_MISC, NULL, 2744 xname, "Multicast Packets Received"); 2745 evcnt_attach_dynamic(&stats->vfgptc, EVCNT_TYPE_MISC, NULL, 2746 xname, "Good Packets Transmitted"); 2747 evcnt_attach_dynamic(&stats->vfgotc, EVCNT_TYPE_MISC, NULL, 2748 xname, "Good Octets Transmitted"); 2749 2750 /* Mailbox Stats */ 2751 evcnt_attach_dynamic(&hw->mbx.stats.msgs_tx, EVCNT_TYPE_MISC, NULL, 2752 xname, "message TXs"); 2753 evcnt_attach_dynamic(&hw->mbx.stats.msgs_rx, EVCNT_TYPE_MISC, NULL, 2754 xname, "message RXs"); 2755 evcnt_attach_dynamic(&hw->mbx.stats.acks, EVCNT_TYPE_MISC, NULL, 2756 xname, "ACKs"); 2757 evcnt_attach_dynamic(&hw->mbx.stats.reqs, EVCNT_TYPE_MISC, NULL, 2758 xname, "REQs"); 2759 evcnt_attach_dynamic(&hw->mbx.stats.rsts, EVCNT_TYPE_MISC, NULL, 2760 xname, "RSTs"); 2761 2762 } /* ixv_add_stats_sysctls */ 2763 2764 static void 2765 ixv_clear_evcnt(struct adapter *adapter) 2766 { 2767 struct tx_ring *txr = adapter->tx_rings; 2768 struct rx_ring *rxr = adapter->rx_rings; 2769 struct ixgbevf_hw_stats *stats = &adapter->stats.vf; 2770 struct ixgbe_hw *hw = &adapter->hw; 2771 int i; 2772 2773 /* Driver Statistics */ 2774 adapter->efbig_tx_dma_setup.ev_count = 0; 2775 adapter->mbuf_defrag_failed.ev_count = 0; 2776 adapter->efbig2_tx_dma_setup.ev_count = 0; 2777 adapter->einval_tx_dma_setup.ev_count = 0; 2778 adapter->other_tx_dma_setup.ev_count = 0; 2779 adapter->eagain_tx_dma_setup.ev_count = 0; 2780 adapter->enomem_tx_dma_setup.ev_count = 0; 2781 adapter->watchdog_events.ev_count = 0; 2782 adapter->tso_err.ev_count = 0; 2783 adapter->admin_irqev.ev_count = 0; 2784 adapter->link_workev.ev_count = 0; 2785 2786 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2787 adapter->queues[i].irqs.ev_count = 0; 2788 adapter->queues[i].handleq.ev_count = 0; 2789 adapter->queues[i].req.ev_count = 0; 2790 txr->tso_tx.ev_count = 0; 2791 txr->no_desc_avail.ev_count = 0; 2792 txr->total_packets.ev_count = 0; 2793 #ifndef IXGBE_LEGACY_TX 2794 txr->pcq_drops.ev_count = 0; 2795 #endif 2796 txr->q_efbig_tx_dma_setup = 0; 2797 txr->q_mbuf_defrag_failed = 0; 2798 txr->q_efbig2_tx_dma_setup = 0; 2799 txr->q_einval_tx_dma_setup = 0; 2800 txr->q_other_tx_dma_setup = 0; 2801 txr->q_eagain_tx_dma_setup = 0; 2802 txr->q_enomem_tx_dma_setup = 0; 2803 txr->q_tso_err = 0; 2804 2805 rxr->rx_packets.ev_count = 0; 2806 rxr->rx_bytes.ev_count = 0; 2807 rxr->rx_copies.ev_count = 0; 2808 rxr->no_jmbuf.ev_count = 0; 2809 rxr->rx_discarded.ev_count = 0; 2810 } 2811 2812 /* MAC stats get their own sub node */ 2813 2814 stats->ipcs.ev_count = 0; 2815 stats->l4cs.ev_count = 0; 2816 stats->ipcs_bad.ev_count = 0; 2817 stats->l4cs_bad.ev_count = 0; 2818 2819 /* Packet Reception Stats */ 2820 stats->vfgprc.ev_count = 0; 2821 stats->vfgorc.ev_count = 0; 2822 stats->vfmprc.ev_count = 0; 2823 stats->vfgptc.ev_count = 0; 2824 stats->vfgotc.ev_count = 0; 2825 2826 /* Mailbox Stats */ 2827 hw->mbx.stats.msgs_tx.ev_count = 0; 2828 hw->mbx.stats.msgs_rx.ev_count = 0; 2829 hw->mbx.stats.acks.ev_count = 0; 2830 hw->mbx.stats.reqs.ev_count = 0; 2831 hw->mbx.stats.rsts.ev_count = 0; 2832 2833 } /* ixv_clear_evcnt */ 2834 2835 /************************************************************************ 2836 * ixv_set_sysctl_value 2837 ************************************************************************/ 2838 static void 2839 ixv_set_sysctl_value(struct adapter *adapter, const char *name, 2840 const char *description, int *limit, int value) 2841 { 2842 device_t dev = adapter->dev; 2843 struct sysctllog **log; 2844 const struct sysctlnode *rnode, *cnode; 2845 2846 log = &adapter->sysctllog; 2847 if ((rnode = ixv_sysctl_instance(adapter)) == NULL) { 2848 aprint_error_dev(dev, "could not create sysctl root\n"); 2849 return; 2850 } 2851 if (sysctl_createv(log, 0, &rnode, &cnode, 2852 CTLFLAG_READWRITE, CTLTYPE_INT, 2853 name, SYSCTL_DESCR(description), 2854 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 2855 aprint_error_dev(dev, "could not create sysctl\n"); 2856 *limit = value; 2857 } /* ixv_set_sysctl_value */ 2858 2859 /************************************************************************ 2860 * ixv_print_debug_info 2861 * 2862 * Called only when em_display_debug_stats is enabled. 2863 * Provides a way to take a look at important statistics 2864 * maintained by the driver and hardware. 2865 ************************************************************************/ 2866 static void 2867 ixv_print_debug_info(struct adapter *adapter) 2868 { 2869 device_t dev = adapter->dev; 2870 struct ix_queue *que = adapter->queues; 2871 struct rx_ring *rxr; 2872 struct tx_ring *txr; 2873 #ifdef LRO 2874 struct lro_ctrl *lro; 2875 #endif /* LRO */ 2876 2877 for (int i = 0; i < adapter->num_queues; i++, que++) { 2878 txr = que->txr; 2879 rxr = que->rxr; 2880 #ifdef LRO 2881 lro = &rxr->lro; 2882 #endif /* LRO */ 2883 device_printf(dev, "QUE(%d) IRQs Handled: %lu\n", 2884 que->msix, (long)que->irqs.ev_count); 2885 device_printf(dev, "RX(%d) Packets Received: %lld\n", 2886 rxr->me, (long long)rxr->rx_packets.ev_count); 2887 device_printf(dev, "RX(%d) Bytes Received: %lu\n", 2888 rxr->me, (long)rxr->rx_bytes.ev_count); 2889 #ifdef LRO 2890 device_printf(dev, "RX(%d) LRO Queued= %ju\n", 2891 rxr->me, (uintmax_t)lro->lro_queued); 2892 device_printf(dev, "RX(%d) LRO Flushed= %ju\n", 2893 rxr->me, (uintmax_t)lro->lro_flushed); 2894 #endif /* LRO */ 2895 device_printf(dev, "TX(%d) Packets Sent: %lu\n", 2896 txr->me, (long)txr->total_packets.ev_count); 2897 device_printf(dev, "TX(%d) NO Desc Avail: %lu\n", 2898 txr->me, (long)txr->no_desc_avail.ev_count); 2899 } 2900 2901 device_printf(dev, "Admin IRQ Handled: %lu\n", 2902 (long)adapter->admin_irqev.ev_count); 2903 device_printf(dev, "Admin work Handled: %lu\n", 2904 (long)adapter->link_workev.ev_count); 2905 } /* ixv_print_debug_info */ 2906 2907 /************************************************************************ 2908 * ixv_sysctl_debug 2909 ************************************************************************/ 2910 static int 2911 ixv_sysctl_debug(SYSCTLFN_ARGS) 2912 { 2913 struct sysctlnode node = *rnode; 2914 struct adapter *adapter = (struct adapter *)node.sysctl_data; 2915 int error, result; 2916 2917 node.sysctl_data = &result; 2918 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 2919 2920 if (error || newp == NULL) 2921 return error; 2922 2923 if (result == 1) 2924 ixv_print_debug_info(adapter); 2925 2926 return 0; 2927 } /* ixv_sysctl_debug */ 2928 2929 /************************************************************************ 2930 * ixv_init_device_features 2931 ************************************************************************/ 2932 static void 2933 ixv_init_device_features(struct adapter *adapter) 2934 { 2935 adapter->feat_cap = IXGBE_FEATURE_NETMAP 2936 | IXGBE_FEATURE_VF 2937 | IXGBE_FEATURE_RSS 2938 | IXGBE_FEATURE_LEGACY_TX; 2939 2940 /* A tad short on feature flags for VFs, atm. */ 2941 switch (adapter->hw.mac.type) { 2942 case ixgbe_mac_82599_vf: 2943 break; 2944 case ixgbe_mac_X540_vf: 2945 break; 2946 case ixgbe_mac_X550_vf: 2947 case ixgbe_mac_X550EM_x_vf: 2948 case ixgbe_mac_X550EM_a_vf: 2949 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD; 2950 break; 2951 default: 2952 break; 2953 } 2954 2955 /* Enabled by default... */ 2956 /* Is a virtual function (VF) */ 2957 if (adapter->feat_cap & IXGBE_FEATURE_VF) 2958 adapter->feat_en |= IXGBE_FEATURE_VF; 2959 /* Netmap */ 2960 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 2961 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 2962 /* Receive-Side Scaling (RSS) */ 2963 if (adapter->feat_cap & IXGBE_FEATURE_RSS) 2964 adapter->feat_en |= IXGBE_FEATURE_RSS; 2965 /* Needs advanced context descriptor regardless of offloads req'd */ 2966 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD) 2967 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD; 2968 2969 /* Enabled via sysctl... */ 2970 /* Legacy (single queue) transmit */ 2971 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 2972 ixv_enable_legacy_tx) 2973 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 2974 } /* ixv_init_device_features */ 2975 2976 /************************************************************************ 2977 * ixv_shutdown - Shutdown entry point 2978 ************************************************************************/ 2979 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 2980 static int 2981 ixv_shutdown(device_t dev) 2982 { 2983 struct adapter *adapter = device_private(dev); 2984 IXGBE_CORE_LOCK(adapter); 2985 ixv_stop(adapter); 2986 IXGBE_CORE_UNLOCK(adapter); 2987 2988 return (0); 2989 } /* ixv_shutdown */ 2990 #endif 2991 2992 static int 2993 ixv_ifflags_cb(struct ethercom *ec) 2994 { 2995 struct ifnet *ifp = &ec->ec_if; 2996 struct adapter *adapter = ifp->if_softc; 2997 u_short saved_flags; 2998 u_short change; 2999 int rv = 0; 3000 3001 IXGBE_CORE_LOCK(adapter); 3002 3003 saved_flags = adapter->if_flags; 3004 change = ifp->if_flags ^ adapter->if_flags; 3005 if (change != 0) 3006 adapter->if_flags = ifp->if_flags; 3007 3008 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 3009 rv = ENETRESET; 3010 goto out; 3011 } else if ((change & IFF_PROMISC) != 0) { 3012 rv = ixv_set_rxfilter(adapter); 3013 if (rv != 0) { 3014 /* Restore previous */ 3015 adapter->if_flags = saved_flags; 3016 goto out; 3017 } 3018 } 3019 3020 /* Check for ec_capenable. */ 3021 change = ec->ec_capenable ^ adapter->ec_capenable; 3022 adapter->ec_capenable = ec->ec_capenable; 3023 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 3024 | ETHERCAP_VLAN_HWFILTER)) != 0) { 3025 rv = ENETRESET; 3026 goto out; 3027 } 3028 3029 /* 3030 * Special handling is not required for ETHERCAP_VLAN_MTU. 3031 * PF's MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 3032 */ 3033 3034 /* Set up VLAN support and filter */ 3035 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 3036 rv = ixv_setup_vlan_support(adapter); 3037 3038 out: 3039 IXGBE_CORE_UNLOCK(adapter); 3040 3041 return rv; 3042 } 3043 3044 3045 /************************************************************************ 3046 * ixv_ioctl - Ioctl entry point 3047 * 3048 * Called when the user wants to configure the interface. 3049 * 3050 * return 0 on success, positive on failure 3051 ************************************************************************/ 3052 static int 3053 ixv_ioctl(struct ifnet *ifp, u_long command, void *data) 3054 { 3055 struct adapter *adapter = ifp->if_softc; 3056 struct ixgbe_hw *hw = &adapter->hw; 3057 struct ifcapreq *ifcr = data; 3058 int error; 3059 int l4csum_en; 3060 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 3061 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 3062 3063 switch (command) { 3064 case SIOCSIFFLAGS: 3065 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 3066 break; 3067 case SIOCADDMULTI: { 3068 struct ether_multi *enm; 3069 struct ether_multistep step; 3070 struct ethercom *ec = &adapter->osdep.ec; 3071 bool overflow = false; 3072 int mcnt = 0; 3073 3074 /* 3075 * Check the number of multicast address. If it exceeds, 3076 * return ENOSPC. 3077 * Update this code when we support API 1.3. 3078 */ 3079 ETHER_LOCK(ec); 3080 ETHER_FIRST_MULTI(step, ec, enm); 3081 while (enm != NULL) { 3082 mcnt++; 3083 3084 /* 3085 * This code is before adding, so one room is required 3086 * at least. 3087 */ 3088 if (mcnt > (IXGBE_MAX_VF_MC - 1)) { 3089 overflow = true; 3090 break; 3091 } 3092 ETHER_NEXT_MULTI(step, enm); 3093 } 3094 ETHER_UNLOCK(ec); 3095 error = 0; 3096 if (overflow && ((ec->ec_flags & ETHER_F_ALLMULTI) == 0)) { 3097 error = hw->mac.ops.update_xcast_mode(hw, 3098 IXGBEVF_XCAST_MODE_ALLMULTI); 3099 if (error == IXGBE_ERR_NOT_TRUSTED) { 3100 device_printf(adapter->dev, 3101 "this interface is not trusted\n"); 3102 error = EPERM; 3103 } else if (error == IXGBE_ERR_FEATURE_NOT_SUPPORTED) { 3104 device_printf(adapter->dev, 3105 "the PF doesn't support allmulti mode\n"); 3106 error = EOPNOTSUPP; 3107 } else if (error) { 3108 device_printf(adapter->dev, 3109 "number of Ethernet multicast addresses " 3110 "exceeds the limit (%d). error = %d\n", 3111 IXGBE_MAX_VF_MC, error); 3112 error = ENOSPC; 3113 } else 3114 ec->ec_flags |= ETHER_F_ALLMULTI; 3115 } 3116 if (error) 3117 return error; 3118 } 3119 /*FALLTHROUGH*/ 3120 case SIOCDELMULTI: 3121 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 3122 break; 3123 case SIOCSIFMEDIA: 3124 case SIOCGIFMEDIA: 3125 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 3126 break; 3127 case SIOCSIFCAP: 3128 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 3129 break; 3130 case SIOCSIFMTU: 3131 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 3132 break; 3133 case SIOCZIFDATA: 3134 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 3135 ixv_update_stats(adapter); 3136 ixv_clear_evcnt(adapter); 3137 break; 3138 default: 3139 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 3140 break; 3141 } 3142 3143 switch (command) { 3144 case SIOCSIFCAP: 3145 /* Layer-4 Rx checksum offload has to be turned on and 3146 * off as a unit. 3147 */ 3148 l4csum_en = ifcr->ifcr_capenable & l4csum; 3149 if (l4csum_en != l4csum && l4csum_en != 0) 3150 return EINVAL; 3151 /*FALLTHROUGH*/ 3152 case SIOCADDMULTI: 3153 case SIOCDELMULTI: 3154 case SIOCSIFFLAGS: 3155 case SIOCSIFMTU: 3156 default: 3157 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 3158 return error; 3159 if ((ifp->if_flags & IFF_RUNNING) == 0) 3160 ; 3161 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 3162 IXGBE_CORE_LOCK(adapter); 3163 ixv_init_locked(adapter); 3164 IXGBE_CORE_UNLOCK(adapter); 3165 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 3166 /* 3167 * Multicast list has changed; set the hardware filter 3168 * accordingly. 3169 */ 3170 IXGBE_CORE_LOCK(adapter); 3171 ixv_disable_intr(adapter); 3172 ixv_set_rxfilter(adapter); 3173 ixv_enable_intr(adapter); 3174 IXGBE_CORE_UNLOCK(adapter); 3175 } 3176 return 0; 3177 } 3178 } /* ixv_ioctl */ 3179 3180 /************************************************************************ 3181 * ixv_init 3182 ************************************************************************/ 3183 static int 3184 ixv_init(struct ifnet *ifp) 3185 { 3186 struct adapter *adapter = ifp->if_softc; 3187 3188 IXGBE_CORE_LOCK(adapter); 3189 ixv_init_locked(adapter); 3190 IXGBE_CORE_UNLOCK(adapter); 3191 3192 return 0; 3193 } /* ixv_init */ 3194 3195 /************************************************************************ 3196 * ixv_handle_que 3197 ************************************************************************/ 3198 static void 3199 ixv_handle_que(void *context) 3200 { 3201 struct ix_queue *que = context; 3202 struct adapter *adapter = que->adapter; 3203 struct tx_ring *txr = que->txr; 3204 struct ifnet *ifp = adapter->ifp; 3205 bool more; 3206 3207 que->handleq.ev_count++; 3208 3209 if (ifp->if_flags & IFF_RUNNING) { 3210 more = ixgbe_rxeof(que); 3211 IXGBE_TX_LOCK(txr); 3212 more |= ixgbe_txeof(txr); 3213 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 3214 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 3215 ixgbe_mq_start_locked(ifp, txr); 3216 /* Only for queue 0 */ 3217 /* NetBSD still needs this for CBQ */ 3218 if ((&adapter->queues[0] == que) 3219 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 3220 ixgbe_legacy_start_locked(ifp, txr); 3221 IXGBE_TX_UNLOCK(txr); 3222 if (more) { 3223 que->req.ev_count++; 3224 if (adapter->txrx_use_workqueue) { 3225 /* 3226 * "enqueued flag" is not required here 3227 * the same as ixg(4). See ixgbe_msix_que(). 3228 */ 3229 workqueue_enqueue(adapter->que_wq, 3230 &que->wq_cookie, curcpu()); 3231 } else 3232 softint_schedule(que->que_si); 3233 return; 3234 } 3235 } 3236 3237 /* Re-enable this interrupt */ 3238 ixv_enable_queue(adapter, que->msix); 3239 3240 return; 3241 } /* ixv_handle_que */ 3242 3243 /************************************************************************ 3244 * ixv_handle_que_work 3245 ************************************************************************/ 3246 static void 3247 ixv_handle_que_work(struct work *wk, void *context) 3248 { 3249 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 3250 3251 /* 3252 * "enqueued flag" is not required here the same as ixg(4). 3253 * See ixgbe_msix_que(). 3254 */ 3255 ixv_handle_que(que); 3256 } 3257 3258 /************************************************************************ 3259 * ixv_allocate_msix - Setup MSI-X Interrupt resources and handlers 3260 ************************************************************************/ 3261 static int 3262 ixv_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 3263 { 3264 device_t dev = adapter->dev; 3265 struct ix_queue *que = adapter->queues; 3266 struct tx_ring *txr = adapter->tx_rings; 3267 int error, msix_ctrl, rid, vector = 0; 3268 pci_chipset_tag_t pc; 3269 pcitag_t tag; 3270 char intrbuf[PCI_INTRSTR_LEN]; 3271 char wqname[MAXCOMLEN]; 3272 char intr_xname[32]; 3273 const char *intrstr = NULL; 3274 kcpuset_t *affinity; 3275 int cpu_id = 0; 3276 3277 pc = adapter->osdep.pc; 3278 tag = adapter->osdep.tag; 3279 3280 adapter->osdep.nintrs = adapter->num_queues + 1; 3281 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 3282 adapter->osdep.nintrs) != 0) { 3283 aprint_error_dev(dev, 3284 "failed to allocate MSI-X interrupt\n"); 3285 return (ENXIO); 3286 } 3287 3288 kcpuset_create(&affinity, false); 3289 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 3290 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 3291 device_xname(dev), i); 3292 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 3293 sizeof(intrbuf)); 3294 #ifdef IXGBE_MPSAFE 3295 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 3296 true); 3297 #endif 3298 /* Set the handler function */ 3299 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 3300 adapter->osdep.intrs[i], IPL_NET, ixv_msix_que, que, 3301 intr_xname); 3302 if (que->res == NULL) { 3303 pci_intr_release(pc, adapter->osdep.intrs, 3304 adapter->osdep.nintrs); 3305 aprint_error_dev(dev, 3306 "Failed to register QUE handler\n"); 3307 kcpuset_destroy(affinity); 3308 return (ENXIO); 3309 } 3310 que->msix = vector; 3311 adapter->active_queues |= (u64)(1 << que->msix); 3312 3313 cpu_id = i; 3314 /* Round-robin affinity */ 3315 kcpuset_zero(affinity); 3316 kcpuset_set(affinity, cpu_id % ncpu); 3317 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 3318 NULL); 3319 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 3320 intrstr); 3321 if (error == 0) 3322 aprint_normal(", bound queue %d to cpu %d\n", 3323 i, cpu_id % ncpu); 3324 else 3325 aprint_normal("\n"); 3326 3327 #ifndef IXGBE_LEGACY_TX 3328 txr->txr_si 3329 = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 3330 ixgbe_deferred_mq_start, txr); 3331 #endif 3332 que->que_si 3333 = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 3334 ixv_handle_que, que); 3335 if (que->que_si == NULL) { 3336 aprint_error_dev(dev, 3337 "could not establish software interrupt\n"); 3338 } 3339 } 3340 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 3341 error = workqueue_create(&adapter->txr_wq, wqname, 3342 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3343 IXGBE_WORKQUEUE_FLAGS); 3344 if (error) { 3345 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 3346 } 3347 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 3348 3349 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 3350 error = workqueue_create(&adapter->que_wq, wqname, 3351 ixv_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3352 IXGBE_WORKQUEUE_FLAGS); 3353 if (error) { 3354 aprint_error_dev(dev, 3355 "couldn't create workqueue\n"); 3356 } 3357 3358 /* and Mailbox */ 3359 cpu_id++; 3360 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 3361 adapter->vector = vector; 3362 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 3363 sizeof(intrbuf)); 3364 #ifdef IXGBE_MPSAFE 3365 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 3366 true); 3367 #endif 3368 /* Set the mbx handler function */ 3369 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 3370 adapter->osdep.intrs[vector], IPL_NET, ixv_msix_mbx, adapter, 3371 intr_xname); 3372 if (adapter->osdep.ihs[vector] == NULL) { 3373 aprint_error_dev(dev, "Failed to register LINK handler\n"); 3374 kcpuset_destroy(affinity); 3375 return (ENXIO); 3376 } 3377 /* Round-robin affinity */ 3378 kcpuset_zero(affinity); 3379 kcpuset_set(affinity, cpu_id % ncpu); 3380 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 3381 NULL); 3382 3383 aprint_normal_dev(dev, 3384 "for link, interrupting at %s", intrstr); 3385 if (error == 0) 3386 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 3387 else 3388 aprint_normal("\n"); 3389 3390 /* Tasklets for Mailbox */ 3391 snprintf(wqname, sizeof(wqname), "%s-admin", device_xname(dev)); 3392 error = workqueue_create(&adapter->admin_wq, wqname, 3393 ixv_handle_admin, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 3394 IXGBE_TASKLET_WQ_FLAGS); 3395 if (error) { 3396 aprint_error_dev(dev, 3397 "could not create admin workqueue (%d)\n", error); 3398 goto err_out; 3399 } 3400 3401 /* 3402 * Due to a broken design QEMU will fail to properly 3403 * enable the guest for MSI-X unless the vectors in 3404 * the table are all set up, so we must rewrite the 3405 * ENABLE in the MSI-X control register again at this 3406 * point to cause it to successfully initialize us. 3407 */ 3408 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) { 3409 pci_get_capability(pc, tag, PCI_CAP_MSIX, &rid, NULL); 3410 rid += PCI_MSIX_CTL; 3411 msix_ctrl = pci_conf_read(pc, tag, rid); 3412 msix_ctrl |= PCI_MSIX_CTL_ENABLE; 3413 pci_conf_write(pc, tag, rid, msix_ctrl); 3414 } 3415 3416 kcpuset_destroy(affinity); 3417 return (0); 3418 err_out: 3419 kcpuset_destroy(affinity); 3420 ixv_free_workqueue(adapter); 3421 ixv_free_pci_resources(adapter); 3422 return (error); 3423 } /* ixv_allocate_msix */ 3424 3425 /************************************************************************ 3426 * ixv_configure_interrupts - Setup MSI-X resources 3427 * 3428 * Note: The VF device MUST use MSI-X, there is no fallback. 3429 ************************************************************************/ 3430 static int 3431 ixv_configure_interrupts(struct adapter *adapter) 3432 { 3433 device_t dev = adapter->dev; 3434 int want, queues, msgs; 3435 3436 /* Must have at least 2 MSI-X vectors */ 3437 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 3438 if (msgs < 2) { 3439 aprint_error_dev(dev, "MSIX config error\n"); 3440 return (ENXIO); 3441 } 3442 msgs = MIN(msgs, IXG_MAX_NINTR); 3443 3444 /* Figure out a reasonable auto config value */ 3445 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 3446 3447 if (ixv_num_queues != 0) 3448 queues = ixv_num_queues; 3449 else if ((ixv_num_queues == 0) && (queues > IXGBE_VF_MAX_TX_QUEUES)) 3450 queues = IXGBE_VF_MAX_TX_QUEUES; 3451 3452 /* 3453 * Want vectors for the queues, 3454 * plus an additional for mailbox. 3455 */ 3456 want = queues + 1; 3457 if (msgs >= want) 3458 msgs = want; 3459 else { 3460 aprint_error_dev(dev, 3461 "MSI-X Configuration Problem, " 3462 "%d vectors but %d queues wanted!\n", 3463 msgs, want); 3464 return -1; 3465 } 3466 3467 adapter->msix_mem = (void *)1; /* XXX */ 3468 aprint_normal_dev(dev, 3469 "Using MSI-X interrupts with %d vectors\n", msgs); 3470 adapter->num_queues = queues; 3471 3472 return (0); 3473 } /* ixv_configure_interrupts */ 3474 3475 3476 /************************************************************************ 3477 * ixv_handle_admin - Tasklet handler for MSI-X MBX interrupts 3478 * 3479 * Done outside of interrupt context since the driver might sleep 3480 ************************************************************************/ 3481 static void 3482 ixv_handle_admin(struct work *wk, void *context) 3483 { 3484 struct adapter *adapter = context; 3485 struct ixgbe_hw *hw = &adapter->hw; 3486 3487 IXGBE_CORE_LOCK(adapter); 3488 3489 ++adapter->link_workev.ev_count; 3490 adapter->hw.mac.ops.check_link(&adapter->hw, &adapter->link_speed, 3491 &adapter->link_up, FALSE); 3492 ixv_update_link_status(adapter); 3493 3494 adapter->task_requests = 0; 3495 atomic_and_uint(&adapter->admin_pending, ~1); 3496 3497 /* Re-enable interrupts */ 3498 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, (1 << adapter->vector)); 3499 3500 IXGBE_CORE_UNLOCK(adapter); 3501 } /* ixv_handle_admin */ 3502 3503 /************************************************************************ 3504 * ixv_check_link - Used in the local timer to poll for link changes 3505 ************************************************************************/ 3506 static s32 3507 ixv_check_link(struct adapter *adapter) 3508 { 3509 s32 error; 3510 3511 KASSERT(mutex_owned(&adapter->core_mtx)); 3512 3513 adapter->hw.mac.get_link_status = TRUE; 3514 3515 error = adapter->hw.mac.ops.check_link(&adapter->hw, 3516 &adapter->link_speed, &adapter->link_up, FALSE); 3517 ixv_update_link_status(adapter); 3518 3519 return error; 3520 } /* ixv_check_link */ 3521
Indexes created Tue Sep 30 20:09:53 GMT 2025