ixgbe.c revision 1.42
1 /****************************************************************************** 2 3 Copyright (c) 2001-2013, Intel Corporation 4 All rights reserved. 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 12 2. Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in the 14 documentation and/or other materials provided with the distribution. 15 16 3. Neither the name of the Intel Corporation nor the names of its 17 contributors may be used to endorse or promote products derived from 18 this software without specific prior written permission. 19 20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 POSSIBILITY OF SUCH DAMAGE. 31 32 ******************************************************************************/ 33 /* 34 * Copyright (c) 2011 The NetBSD Foundation, Inc. 35 * All rights reserved. 36 * 37 * This code is derived from software contributed to The NetBSD Foundation 38 * by Coyote Point Systems, Inc. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 1. Redistributions of source code must retain the above copyright 44 * notice, this list of conditions and the following disclaimer. 45 * 2. Redistributions in binary form must reproduce the above copyright 46 * notice, this list of conditions and the following disclaimer in the 47 * documentation and/or other materials provided with the distribution. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 50 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 51 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 52 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 53 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 54 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 55 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 56 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 57 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 58 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 59 * POSSIBILITY OF SUCH DAMAGE. 60 */ 61 /*$FreeBSD: head/sys/dev/ixgbe/ixgbe.c 279805 2015-03-09 10:29:15Z araujo $*/ 62 /*$NetBSD: ixgbe.c,v 1.42 2016/11/28 02:23:33 msaitoh Exp $*/ 63 64 #include "opt_inet.h" 65 #include "opt_inet6.h" 66 67 #include "ixgbe.h" 68 #include "vlan.h" 69 70 #include <sys/cprng.h> 71 72 /********************************************************************* 73 * Set this to one to display debug statistics 74 *********************************************************************/ 75 int ixgbe_display_debug_stats = 0; 76 77 /********************************************************************* 78 * Driver version 79 *********************************************************************/ 80 char ixgbe_driver_version[] = "2.5.15"; 81 82 /********************************************************************* 83 * PCI Device ID Table 84 * 85 * Used by probe to select devices to load on 86 * Last field stores an index into ixgbe_strings 87 * Last entry must be all 0s 88 * 89 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 90 *********************************************************************/ 91 92 static ixgbe_vendor_info_t ixgbe_vendor_info_array[] = 93 { 94 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0}, 95 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0}, 96 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0}, 97 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0}, 98 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0}, 99 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0}, 100 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0}, 101 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0}, 102 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0}, 103 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0}, 104 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0}, 105 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0}, 106 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0}, 107 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0}, 108 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0}, 109 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0}, 110 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0}, 111 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0}, 112 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0}, 113 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0}, 114 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0}, 115 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0}, 116 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0}, 117 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0}, 118 /* required last entry */ 119 {0, 0, 0, 0, 0} 120 }; 121 122 /********************************************************************* 123 * Table of branding strings 124 *********************************************************************/ 125 126 static const char *ixgbe_strings[] = { 127 "Intel(R) PRO/10GbE PCI-Express Network Driver" 128 }; 129 130 /********************************************************************* 131 * Function prototypes 132 *********************************************************************/ 133 static int ixgbe_probe(device_t, cfdata_t, void *); 134 static void ixgbe_attach(device_t, device_t, void *); 135 static int ixgbe_detach(device_t, int); 136 #if 0 137 static int ixgbe_shutdown(device_t); 138 #endif 139 static int ixgbe_ioctl(struct ifnet *, u_long, void *); 140 static void ixgbe_ifstop(struct ifnet *, int); 141 static int ixgbe_init(struct ifnet *); 142 static void ixgbe_init_locked(struct adapter *); 143 static void ixgbe_stop(void *); 144 static void ixgbe_media_status(struct ifnet *, struct ifmediareq *); 145 static int ixgbe_media_change(struct ifnet *); 146 static void ixgbe_identify_hardware(struct adapter *); 147 static int ixgbe_allocate_pci_resources(struct adapter *, 148 const struct pci_attach_args *); 149 static void ixgbe_get_slot_info(struct ixgbe_hw *); 150 static int ixgbe_allocate_msix(struct adapter *, 151 const struct pci_attach_args *); 152 static int ixgbe_allocate_legacy(struct adapter *, 153 const struct pci_attach_args *); 154 static int ixgbe_setup_msix(struct adapter *); 155 static void ixgbe_free_pci_resources(struct adapter *); 156 static void ixgbe_local_timer(void *); 157 static int ixgbe_setup_interface(device_t, struct adapter *); 158 static void ixgbe_config_link(struct adapter *); 159 160 static void ixgbe_initialize_transmit_units(struct adapter *); 161 162 163 static void ixgbe_initialize_receive_units(struct adapter *); 164 165 static void ixgbe_enable_intr(struct adapter *); 166 static void ixgbe_disable_intr(struct adapter *); 167 static void ixgbe_update_stats_counters(struct adapter *); 168 static void ixgbe_set_promisc(struct adapter *); 169 static void ixgbe_set_multi(struct adapter *); 170 static void ixgbe_update_link_status(struct adapter *); 171 static int ixgbe_set_flowcntl(SYSCTLFN_PROTO); 172 static int ixgbe_set_advertise(SYSCTLFN_PROTO); 173 static int ixgbe_set_thermal_test(SYSCTLFN_PROTO); 174 static void ixgbe_set_ivar(struct adapter *, u8, u8, s8); 175 static void ixgbe_configure_ivars(struct adapter *); 176 static u8 * ixgbe_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 177 178 static void ixgbe_setup_vlan_hw_support(struct adapter *); 179 #if 0 180 static void ixgbe_register_vlan(void *, struct ifnet *, u16); 181 static void ixgbe_unregister_vlan(void *, struct ifnet *, u16); 182 #endif 183 184 static void ixgbe_add_hw_stats(struct adapter *adapter); 185 186 static void ixgbe_enable_rx_drop(struct adapter *); 187 static void ixgbe_disable_rx_drop(struct adapter *); 188 189 /* Support for pluggable optic modules */ 190 static bool ixgbe_sfp_probe(struct adapter *); 191 static void ixgbe_setup_optics(struct adapter *); 192 193 /* Legacy (single vector interrupt handler */ 194 static int ixgbe_legacy_irq(void *); 195 196 /* The MSI/X Interrupt handlers */ 197 static int ixgbe_msix_que(void *); 198 static int ixgbe_msix_link(void *); 199 200 /* Software interrupts for deferred work */ 201 static void ixgbe_handle_que(void *); 202 static void ixgbe_handle_link(void *); 203 static void ixgbe_handle_msf(void *); 204 static void ixgbe_handle_mod(void *); 205 206 const struct sysctlnode *ixgbe_sysctl_instance(struct adapter *); 207 static ixgbe_vendor_info_t *ixgbe_lookup(const struct pci_attach_args *); 208 209 #ifdef IXGBE_FDIR 210 static void ixgbe_reinit_fdir(void *, int); 211 #endif 212 213 /* Missing shared code prototype */ 214 extern void ixgbe_stop_mac_link_on_d3_82599(struct ixgbe_hw *hw); 215 216 /********************************************************************* 217 * FreeBSD Device Interface Entry Points 218 *********************************************************************/ 219 220 CFATTACH_DECL3_NEW(ixg, sizeof(struct adapter), 221 ixgbe_probe, ixgbe_attach, ixgbe_detach, NULL, NULL, NULL, 222 DVF_DETACH_SHUTDOWN); 223 224 #if 0 225 devclass_t ixgbe_devclass; 226 DRIVER_MODULE(ixgbe, pci, ixgbe_driver, ixgbe_devclass, 0, 0); 227 228 MODULE_DEPEND(ixgbe, pci, 1, 1, 1); 229 MODULE_DEPEND(ixgbe, ether, 1, 1, 1); 230 #endif 231 232 /* 233 ** TUNEABLE PARAMETERS: 234 */ 235 236 /* 237 ** AIM: Adaptive Interrupt Moderation 238 ** which means that the interrupt rate 239 ** is varied over time based on the 240 ** traffic for that interrupt vector 241 */ 242 static int ixgbe_enable_aim = TRUE; 243 #define SYSCTL_INT(__x, __y) 244 SYSCTL_INT("hw.ixgbe.enable_aim", &ixgbe_enable_aim); 245 246 static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 247 SYSCTL_INT("hw.ixgbe.max_interrupt_rate", &ixgbe_max_interrupt_rate); 248 249 /* How many packets rxeof tries to clean at a time */ 250 static int ixgbe_rx_process_limit = 256; 251 SYSCTL_INT("hw.ixgbe.rx_process_limit", &ixgbe_rx_process_limit); 252 253 /* How many packets txeof tries to clean at a time */ 254 static int ixgbe_tx_process_limit = 256; 255 SYSCTL_INT("hw.ixgbe.tx_process_limit", &ixgbe_tx_process_limit); 256 257 /* 258 ** Smart speed setting, default to on 259 ** this only works as a compile option 260 ** right now as its during attach, set 261 ** this to 'ixgbe_smart_speed_off' to 262 ** disable. 263 */ 264 static int ixgbe_smart_speed = ixgbe_smart_speed_on; 265 266 /* 267 * MSIX should be the default for best performance, 268 * but this allows it to be forced off for testing. 269 */ 270 static int ixgbe_enable_msix = 1; 271 SYSCTL_INT("hw.ixgbe.enable_msix", &ixgbe_enable_msix); 272 273 /* 274 * Number of Queues, can be set to 0, 275 * it then autoconfigures based on the 276 * number of cpus with a max of 8. This 277 * can be overriden manually here. 278 */ 279 static int ixgbe_num_queues = 1; 280 SYSCTL_INT("hw.ixgbe.num_queues", &ixgbe_num_queues); 281 282 /* 283 ** Number of TX descriptors per ring, 284 ** setting higher than RX as this seems 285 ** the better performing choice. 286 */ 287 static int ixgbe_txd = PERFORM_TXD; 288 SYSCTL_INT("hw.ixgbe.txd", &ixgbe_txd); 289 290 /* Number of RX descriptors per ring */ 291 static int ixgbe_rxd = PERFORM_RXD; 292 SYSCTL_INT("hw.ixgbe.rxd", &ixgbe_rxd); 293 294 /* 295 ** Defining this on will allow the use 296 ** of unsupported SFP+ modules, note that 297 ** doing so you are on your own :) 298 */ 299 static int allow_unsupported_sfp = false; 300 SYSCTL_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp); 301 302 /* Keep running tab on them for sanity check */ 303 static int ixgbe_total_ports; 304 305 #ifdef IXGBE_FDIR 306 /* 307 ** For Flow Director: this is the 308 ** number of TX packets we sample 309 ** for the filter pool, this means 310 ** every 20th packet will be probed. 311 ** 312 ** This feature can be disabled by 313 ** setting this to 0. 314 */ 315 static int atr_sample_rate = 20; 316 /* 317 ** Flow Director actually 'steals' 318 ** part of the packet buffer as its 319 ** filter pool, this variable controls 320 ** how much it uses: 321 ** 0 = 64K, 1 = 128K, 2 = 256K 322 */ 323 static int fdir_pballoc = 1; 324 #endif 325 326 #ifdef DEV_NETMAP 327 /* 328 * The #ifdef DEV_NETMAP / #endif blocks in this file are meant to 329 * be a reference on how to implement netmap support in a driver. 330 * Additional comments are in ixgbe_netmap.h . 331 * 332 * <dev/netmap/ixgbe_netmap.h> contains functions for netmap support 333 * that extend the standard driver. 334 */ 335 #include <dev/netmap/ixgbe_netmap.h> 336 #endif /* DEV_NETMAP */ 337 338 /********************************************************************* 339 * Device identification routine 340 * 341 * ixgbe_probe determines if the driver should be loaded on 342 * adapter based on PCI vendor/device id of the adapter. 343 * 344 * return 1 on success, 0 on failure 345 *********************************************************************/ 346 347 static int 348 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 349 { 350 const struct pci_attach_args *pa = aux; 351 352 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 353 } 354 355 static ixgbe_vendor_info_t * 356 ixgbe_lookup(const struct pci_attach_args *pa) 357 { 358 pcireg_t subid; 359 ixgbe_vendor_info_t *ent; 360 361 INIT_DEBUGOUT("ixgbe_probe: begin"); 362 363 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 364 return NULL; 365 366 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 367 368 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 369 if (PCI_VENDOR(pa->pa_id) == ent->vendor_id && 370 PCI_PRODUCT(pa->pa_id) == ent->device_id && 371 372 (PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id || 373 ent->subvendor_id == 0) && 374 375 (PCI_SUBSYS_ID(subid) == ent->subdevice_id || 376 ent->subdevice_id == 0)) { 377 ++ixgbe_total_ports; 378 return ent; 379 } 380 } 381 return NULL; 382 } 383 384 385 static void 386 ixgbe_sysctl_attach(struct adapter *adapter) 387 { 388 struct sysctllog **log; 389 const struct sysctlnode *rnode, *cnode; 390 device_t dev; 391 392 dev = adapter->dev; 393 log = &adapter->sysctllog; 394 395 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 396 aprint_error_dev(dev, "could not create sysctl root\n"); 397 return; 398 } 399 400 if (sysctl_createv(log, 0, &rnode, &cnode, 401 CTLFLAG_READONLY, CTLTYPE_INT, 402 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 403 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 404 aprint_error_dev(dev, "could not create sysctl\n"); 405 406 if (sysctl_createv(log, 0, &rnode, &cnode, 407 CTLFLAG_READONLY, CTLTYPE_INT, 408 "num_queues", SYSCTL_DESCR("Number of queues"), 409 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 410 aprint_error_dev(dev, "could not create sysctl\n"); 411 412 if (sysctl_createv(log, 0, &rnode, &cnode, 413 CTLFLAG_READWRITE, CTLTYPE_INT, 414 "fc", SYSCTL_DESCR("Flow Control"), 415 ixgbe_set_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 416 aprint_error_dev(dev, "could not create sysctl\n"); 417 418 /* XXX This is an *instance* sysctl controlling a *global* variable. 419 * XXX It's that way in the FreeBSD driver that this derives from. 420 */ 421 if (sysctl_createv(log, 0, &rnode, &cnode, 422 CTLFLAG_READWRITE, CTLTYPE_INT, 423 "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 424 NULL, 0, &ixgbe_enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 425 aprint_error_dev(dev, "could not create sysctl\n"); 426 427 if (sysctl_createv(log, 0, &rnode, &cnode, 428 CTLFLAG_READWRITE, CTLTYPE_INT, 429 "advertise_speed", SYSCTL_DESCR("Link Speed"), 430 ixgbe_set_advertise, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 431 aprint_error_dev(dev, "could not create sysctl\n"); 432 433 if (sysctl_createv(log, 0, &rnode, &cnode, 434 CTLFLAG_READWRITE, CTLTYPE_INT, 435 "ts", SYSCTL_DESCR("Thermal Test"), 436 ixgbe_set_thermal_test, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 437 aprint_error_dev(dev, "could not create sysctl\n"); 438 } 439 440 /********************************************************************* 441 * Device initialization routine 442 * 443 * The attach entry point is called when the driver is being loaded. 444 * This routine identifies the type of hardware, allocates all resources 445 * and initializes the hardware. 446 * 447 * return 0 on success, positive on failure 448 *********************************************************************/ 449 450 static void 451 ixgbe_attach(device_t parent, device_t dev, void *aux) 452 { 453 struct adapter *adapter; 454 struct ixgbe_hw *hw; 455 int error = -1; 456 u16 csum; 457 u32 ctrl_ext; 458 ixgbe_vendor_info_t *ent; 459 struct pci_attach_args *pa = aux; 460 461 INIT_DEBUGOUT("ixgbe_attach: begin"); 462 463 /* Allocate, clear, and link in our adapter structure */ 464 adapter = device_private(dev); 465 adapter->dev = adapter->osdep.dev = dev; 466 hw = &adapter->hw; 467 adapter->osdep.pc = pa->pa_pc; 468 adapter->osdep.tag = pa->pa_tag; 469 adapter->osdep.dmat = pa->pa_dmat; 470 adapter->osdep.attached = false; 471 472 ent = ixgbe_lookup(pa); 473 474 KASSERT(ent != NULL); 475 476 aprint_normal(": %s, Version - %s\n", 477 ixgbe_strings[ent->index], ixgbe_driver_version); 478 479 /* Core Lock Init*/ 480 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 481 482 /* SYSCTL APIs */ 483 484 ixgbe_sysctl_attach(adapter); 485 486 /* Set up the timer callout */ 487 callout_init(&adapter->timer, 0); 488 489 /* Determine hardware revision */ 490 ixgbe_identify_hardware(adapter); 491 492 /* Do base PCI setup - map BAR0 */ 493 if (ixgbe_allocate_pci_resources(adapter, pa)) { 494 aprint_error_dev(dev, "Allocation of PCI resources failed\n"); 495 error = ENXIO; 496 goto err_out; 497 } 498 499 /* Do descriptor calc and sanity checks */ 500 if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 501 ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) { 502 aprint_error_dev(dev, "TXD config issue, using default!\n"); 503 adapter->num_tx_desc = DEFAULT_TXD; 504 } else 505 adapter->num_tx_desc = ixgbe_txd; 506 507 /* 508 ** With many RX rings it is easy to exceed the 509 ** system mbuf allocation. Tuning nmbclusters 510 ** can alleviate this. 511 */ 512 if (nmbclusters > 0 ) { 513 int s; 514 s = (ixgbe_rxd * adapter->num_queues) * ixgbe_total_ports; 515 if (s > nmbclusters) { 516 aprint_error_dev(dev, "RX Descriptors exceed " 517 "system mbuf max, using default instead!\n"); 518 ixgbe_rxd = DEFAULT_RXD; 519 } 520 } 521 522 if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 523 ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) { 524 aprint_error_dev(dev, "RXD config issue, using default!\n"); 525 adapter->num_rx_desc = DEFAULT_RXD; 526 } else 527 adapter->num_rx_desc = ixgbe_rxd; 528 529 /* Allocate our TX/RX Queues */ 530 if (ixgbe_allocate_queues(adapter)) { 531 error = ENOMEM; 532 goto err_out; 533 } 534 535 /* Allocate multicast array memory. */ 536 adapter->mta = malloc(sizeof(u8) * IXGBE_ETH_LENGTH_OF_ADDRESS * 537 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT); 538 if (adapter->mta == NULL) { 539 aprint_error_dev(dev, "Cannot allocate multicast setup array\n"); 540 error = ENOMEM; 541 goto err_late; 542 } 543 544 /* Initialize the shared code */ 545 hw->allow_unsupported_sfp = allow_unsupported_sfp; 546 error = ixgbe_init_shared_code(hw); 547 if (error == IXGBE_ERR_SFP_NOT_PRESENT) { 548 /* 549 ** No optics in this port, set up 550 ** so the timer routine will probe 551 ** for later insertion. 552 */ 553 adapter->sfp_probe = TRUE; 554 error = 0; 555 } else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) { 556 aprint_error_dev(dev,"Unsupported SFP+ module detected!\n"); 557 error = EIO; 558 goto err_late; 559 } else if (error) { 560 aprint_error_dev(dev,"Unable to initialize the shared code\n"); 561 error = EIO; 562 goto err_late; 563 } 564 565 /* Make sure we have a good EEPROM before we read from it */ 566 if (ixgbe_validate_eeprom_checksum(&adapter->hw, &csum) < 0) { 567 aprint_error_dev(dev,"The EEPROM Checksum Is Not Valid\n"); 568 error = EIO; 569 goto err_late; 570 } 571 572 error = ixgbe_init_hw(hw); 573 switch (error) { 574 case IXGBE_ERR_EEPROM_VERSION: 575 aprint_error_dev(dev, "This device is a pre-production adapter/" 576 "LOM. Please be aware there may be issues associated " 577 "with your hardware.\n If you are experiencing problems " 578 "please contact your Intel or hardware representative " 579 "who provided you with this hardware.\n"); 580 break; 581 case IXGBE_ERR_SFP_NOT_SUPPORTED: 582 aprint_error_dev(dev,"Unsupported SFP+ Module\n"); 583 error = EIO; 584 aprint_error_dev(dev,"Hardware Initialization Failure\n"); 585 goto err_late; 586 case IXGBE_ERR_SFP_NOT_PRESENT: 587 device_printf(dev,"No SFP+ Module found\n"); 588 /* falls thru */ 589 default: 590 break; 591 } 592 593 /* Detect and set physical type */ 594 ixgbe_setup_optics(adapter); 595 596 error = -1; 597 if ((adapter->msix > 1) && (ixgbe_enable_msix)) 598 error = ixgbe_allocate_msix(adapter, pa); 599 if (error != 0) 600 error = ixgbe_allocate_legacy(adapter, pa); 601 if (error) 602 goto err_late; 603 604 /* Setup OS specific network interface */ 605 if (ixgbe_setup_interface(dev, adapter) != 0) 606 goto err_late; 607 608 /* Initialize statistics */ 609 ixgbe_update_stats_counters(adapter); 610 611 /* 612 ** Check PCIE slot type/speed/width 613 */ 614 ixgbe_get_slot_info(hw); 615 616 /* Set an initial default flow control value */ 617 adapter->fc = ixgbe_fc_full; 618 619 /* let hardware know driver is loaded */ 620 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 621 ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD; 622 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 623 624 ixgbe_add_hw_stats(adapter); 625 626 #ifdef DEV_NETMAP 627 ixgbe_netmap_attach(adapter); 628 #endif /* DEV_NETMAP */ 629 INIT_DEBUGOUT("ixgbe_attach: end"); 630 adapter->osdep.attached = true; 631 return; 632 err_late: 633 ixgbe_free_transmit_structures(adapter); 634 ixgbe_free_receive_structures(adapter); 635 err_out: 636 if (adapter->ifp != NULL) 637 if_free(adapter->ifp); 638 ixgbe_free_pci_resources(adapter); 639 if (adapter->mta != NULL) 640 free(adapter->mta, M_DEVBUF); 641 return; 642 643 } 644 645 /********************************************************************* 646 * Device removal routine 647 * 648 * The detach entry point is called when the driver is being removed. 649 * This routine stops the adapter and deallocates all the resources 650 * that were allocated for driver operation. 651 * 652 * return 0 on success, positive on failure 653 *********************************************************************/ 654 655 static int 656 ixgbe_detach(device_t dev, int flags) 657 { 658 struct adapter *adapter = device_private(dev); 659 struct rx_ring *rxr = adapter->rx_rings; 660 struct ixgbe_hw_stats *stats = &adapter->stats; 661 struct ix_queue *que = adapter->queues; 662 struct tx_ring *txr = adapter->tx_rings; 663 u32 ctrl_ext; 664 665 INIT_DEBUGOUT("ixgbe_detach: begin"); 666 if (adapter->osdep.attached == false) 667 return 0; 668 669 #if NVLAN > 0 670 /* Make sure VLANs are not using driver */ 671 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 672 ; /* nothing to do: no VLANs */ 673 else if ((flags & (DETACH_SHUTDOWN|DETACH_FORCE)) != 0) 674 vlan_ifdetach(adapter->ifp); 675 else { 676 aprint_error_dev(dev, "VLANs in use\n"); 677 return EBUSY; 678 } 679 #endif 680 681 IXGBE_CORE_LOCK(adapter); 682 ixgbe_stop(adapter); 683 IXGBE_CORE_UNLOCK(adapter); 684 685 for (int i = 0; i < adapter->num_queues; i++, que++, txr++) { 686 #ifndef IXGBE_LEGACY_TX 687 softint_disestablish(txr->txq_si); 688 #endif 689 softint_disestablish(que->que_si); 690 } 691 692 /* Drain the Link queue */ 693 softint_disestablish(adapter->link_si); 694 softint_disestablish(adapter->mod_si); 695 softint_disestablish(adapter->msf_si); 696 #ifdef IXGBE_FDIR 697 softint_disestablish(adapter->fdir_si); 698 #endif 699 700 /* let hardware know driver is unloading */ 701 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 702 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 703 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 704 705 ether_ifdetach(adapter->ifp); 706 callout_halt(&adapter->timer, NULL); 707 #ifdef DEV_NETMAP 708 netmap_detach(adapter->ifp); 709 #endif /* DEV_NETMAP */ 710 ixgbe_free_pci_resources(adapter); 711 #if 0 /* XXX the NetBSD port is probably missing something here */ 712 bus_generic_detach(dev); 713 #endif 714 if_detach(adapter->ifp); 715 716 sysctl_teardown(&adapter->sysctllog); 717 evcnt_detach(&adapter->handleq); 718 evcnt_detach(&adapter->req); 719 evcnt_detach(&adapter->morerx); 720 evcnt_detach(&adapter->moretx); 721 evcnt_detach(&adapter->txloops); 722 evcnt_detach(&adapter->efbig_tx_dma_setup); 723 evcnt_detach(&adapter->m_defrag_failed); 724 evcnt_detach(&adapter->efbig2_tx_dma_setup); 725 evcnt_detach(&adapter->einval_tx_dma_setup); 726 evcnt_detach(&adapter->other_tx_dma_setup); 727 evcnt_detach(&adapter->eagain_tx_dma_setup); 728 evcnt_detach(&adapter->enomem_tx_dma_setup); 729 evcnt_detach(&adapter->watchdog_events); 730 evcnt_detach(&adapter->tso_err); 731 evcnt_detach(&adapter->link_irq); 732 733 txr = adapter->tx_rings; 734 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 735 evcnt_detach(&txr->no_desc_avail); 736 evcnt_detach(&txr->total_packets); 737 evcnt_detach(&txr->tso_tx); 738 739 if (i < __arraycount(adapter->stats.mpc)) { 740 evcnt_detach(&adapter->stats.mpc[i]); 741 } 742 if (i < __arraycount(adapter->stats.pxontxc)) { 743 evcnt_detach(&adapter->stats.pxontxc[i]); 744 evcnt_detach(&adapter->stats.pxonrxc[i]); 745 evcnt_detach(&adapter->stats.pxofftxc[i]); 746 evcnt_detach(&adapter->stats.pxoffrxc[i]); 747 evcnt_detach(&adapter->stats.pxon2offc[i]); 748 } 749 if (i < __arraycount(adapter->stats.qprc)) { 750 evcnt_detach(&adapter->stats.qprc[i]); 751 evcnt_detach(&adapter->stats.qptc[i]); 752 evcnt_detach(&adapter->stats.qbrc[i]); 753 evcnt_detach(&adapter->stats.qbtc[i]); 754 evcnt_detach(&adapter->stats.qprdc[i]); 755 } 756 757 evcnt_detach(&rxr->rx_packets); 758 evcnt_detach(&rxr->rx_bytes); 759 evcnt_detach(&rxr->rx_copies); 760 evcnt_detach(&rxr->no_jmbuf); 761 evcnt_detach(&rxr->rx_discarded); 762 evcnt_detach(&rxr->rx_irq); 763 } 764 evcnt_detach(&stats->ipcs); 765 evcnt_detach(&stats->l4cs); 766 evcnt_detach(&stats->ipcs_bad); 767 evcnt_detach(&stats->l4cs_bad); 768 evcnt_detach(&stats->intzero); 769 evcnt_detach(&stats->legint); 770 evcnt_detach(&stats->crcerrs); 771 evcnt_detach(&stats->illerrc); 772 evcnt_detach(&stats->errbc); 773 evcnt_detach(&stats->mspdc); 774 evcnt_detach(&stats->mlfc); 775 evcnt_detach(&stats->mrfc); 776 evcnt_detach(&stats->rlec); 777 evcnt_detach(&stats->lxontxc); 778 evcnt_detach(&stats->lxonrxc); 779 evcnt_detach(&stats->lxofftxc); 780 evcnt_detach(&stats->lxoffrxc); 781 782 /* Packet Reception Stats */ 783 evcnt_detach(&stats->tor); 784 evcnt_detach(&stats->gorc); 785 evcnt_detach(&stats->tpr); 786 evcnt_detach(&stats->gprc); 787 evcnt_detach(&stats->mprc); 788 evcnt_detach(&stats->bprc); 789 evcnt_detach(&stats->prc64); 790 evcnt_detach(&stats->prc127); 791 evcnt_detach(&stats->prc255); 792 evcnt_detach(&stats->prc511); 793 evcnt_detach(&stats->prc1023); 794 evcnt_detach(&stats->prc1522); 795 evcnt_detach(&stats->ruc); 796 evcnt_detach(&stats->rfc); 797 evcnt_detach(&stats->roc); 798 evcnt_detach(&stats->rjc); 799 evcnt_detach(&stats->mngprc); 800 evcnt_detach(&stats->xec); 801 802 /* Packet Transmission Stats */ 803 evcnt_detach(&stats->gotc); 804 evcnt_detach(&stats->tpt); 805 evcnt_detach(&stats->gptc); 806 evcnt_detach(&stats->bptc); 807 evcnt_detach(&stats->mptc); 808 evcnt_detach(&stats->mngptc); 809 evcnt_detach(&stats->ptc64); 810 evcnt_detach(&stats->ptc127); 811 evcnt_detach(&stats->ptc255); 812 evcnt_detach(&stats->ptc511); 813 evcnt_detach(&stats->ptc1023); 814 evcnt_detach(&stats->ptc1522); 815 816 ixgbe_free_transmit_structures(adapter); 817 ixgbe_free_receive_structures(adapter); 818 free(adapter->mta, M_DEVBUF); 819 820 IXGBE_CORE_LOCK_DESTROY(adapter); 821 return (0); 822 } 823 824 /********************************************************************* 825 * 826 * Shutdown entry point 827 * 828 **********************************************************************/ 829 830 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 831 static int 832 ixgbe_shutdown(device_t dev) 833 { 834 struct adapter *adapter = device_private(dev); 835 IXGBE_CORE_LOCK(adapter); 836 ixgbe_stop(adapter); 837 IXGBE_CORE_UNLOCK(adapter); 838 return (0); 839 } 840 #endif 841 842 843 static int 844 ixgbe_ifflags_cb(struct ethercom *ec) 845 { 846 struct ifnet *ifp = &ec->ec_if; 847 struct adapter *adapter = ifp->if_softc; 848 int change = ifp->if_flags ^ adapter->if_flags, rc = 0; 849 850 IXGBE_CORE_LOCK(adapter); 851 852 if (change != 0) 853 adapter->if_flags = ifp->if_flags; 854 855 if ((change & ~(IFF_CANTCHANGE|IFF_DEBUG)) != 0) 856 rc = ENETRESET; 857 else if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 858 ixgbe_set_promisc(adapter); 859 860 /* Set up VLAN support and filter */ 861 ixgbe_setup_vlan_hw_support(adapter); 862 863 IXGBE_CORE_UNLOCK(adapter); 864 865 return rc; 866 } 867 868 /********************************************************************* 869 * Ioctl entry point 870 * 871 * ixgbe_ioctl is called when the user wants to configure the 872 * interface. 873 * 874 * return 0 on success, positive on failure 875 **********************************************************************/ 876 877 static int 878 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 879 { 880 struct adapter *adapter = ifp->if_softc; 881 struct ixgbe_hw *hw = &adapter->hw; 882 struct ifcapreq *ifcr = data; 883 struct ifreq *ifr = data; 884 int error = 0; 885 int l4csum_en; 886 const int l4csum = IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx| 887 IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx; 888 889 switch (command) { 890 case SIOCSIFFLAGS: 891 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 892 break; 893 case SIOCADDMULTI: 894 case SIOCDELMULTI: 895 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 896 break; 897 case SIOCSIFMEDIA: 898 case SIOCGIFMEDIA: 899 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 900 break; 901 case SIOCSIFCAP: 902 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 903 break; 904 case SIOCSIFMTU: 905 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 906 break; 907 default: 908 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)\n", (int)command); 909 break; 910 } 911 912 switch (command) { 913 case SIOCSIFMEDIA: 914 case SIOCGIFMEDIA: 915 return ifmedia_ioctl(ifp, ifr, &adapter->media, command); 916 case SIOCGI2C: 917 { 918 struct ixgbe_i2c_req i2c; 919 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 920 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 921 if (error != 0) 922 break; 923 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 924 error = EINVAL; 925 break; 926 } 927 if (i2c.len > sizeof(i2c.data)) { 928 error = EINVAL; 929 break; 930 } 931 932 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 933 i2c.dev_addr, i2c.data); 934 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 935 break; 936 } 937 case SIOCSIFCAP: 938 /* Layer-4 Rx checksum offload has to be turned on and 939 * off as a unit. 940 */ 941 l4csum_en = ifcr->ifcr_capenable & l4csum; 942 if (l4csum_en != l4csum && l4csum_en != 0) 943 return EINVAL; 944 /*FALLTHROUGH*/ 945 case SIOCADDMULTI: 946 case SIOCDELMULTI: 947 case SIOCSIFFLAGS: 948 case SIOCSIFMTU: 949 default: 950 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 951 return error; 952 if ((ifp->if_flags & IFF_RUNNING) == 0) 953 ; 954 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 955 IXGBE_CORE_LOCK(adapter); 956 ixgbe_init_locked(adapter); 957 IXGBE_CORE_UNLOCK(adapter); 958 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 959 /* 960 * Multicast list has changed; set the hardware filter 961 * accordingly. 962 */ 963 IXGBE_CORE_LOCK(adapter); 964 ixgbe_disable_intr(adapter); 965 ixgbe_set_multi(adapter); 966 ixgbe_enable_intr(adapter); 967 IXGBE_CORE_UNLOCK(adapter); 968 } 969 return 0; 970 } 971 972 return error; 973 } 974 975 /********************************************************************* 976 * Init entry point 977 * 978 * This routine is used in two ways. It is used by the stack as 979 * init entry point in network interface structure. It is also used 980 * by the driver as a hw/sw initialization routine to get to a 981 * consistent state. 982 * 983 * return 0 on success, positive on failure 984 **********************************************************************/ 985 #define IXGBE_MHADD_MFS_SHIFT 16 986 987 static void 988 ixgbe_init_locked(struct adapter *adapter) 989 { 990 struct ifnet *ifp = adapter->ifp; 991 device_t dev = adapter->dev; 992 struct ixgbe_hw *hw = &adapter->hw; 993 u32 k, txdctl, mhadd, gpie; 994 u32 rxdctl, rxctrl; 995 996 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 997 998 KASSERT(mutex_owned(&adapter->core_mtx)); 999 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 1000 hw->adapter_stopped = FALSE; 1001 ixgbe_stop_adapter(hw); 1002 callout_stop(&adapter->timer); 1003 1004 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 1005 adapter->max_frame_size = 1006 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1007 1008 /* reprogram the RAR[0] in case user changed it. */ 1009 ixgbe_set_rar(hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 1010 1011 /* Get the latest mac address, User can use a LAA */ 1012 memcpy(hw->mac.addr, CLLADDR(adapter->ifp->if_sadl), 1013 IXGBE_ETH_LENGTH_OF_ADDRESS); 1014 ixgbe_set_rar(hw, 0, hw->mac.addr, 0, 1); 1015 hw->addr_ctrl.rar_used_count = 1; 1016 1017 /* Prepare transmit descriptors and buffers */ 1018 if (ixgbe_setup_transmit_structures(adapter)) { 1019 device_printf(dev,"Could not setup transmit structures\n"); 1020 ixgbe_stop(adapter); 1021 return; 1022 } 1023 1024 ixgbe_init_hw(hw); 1025 ixgbe_initialize_transmit_units(adapter); 1026 1027 /* Setup Multicast table */ 1028 ixgbe_set_multi(adapter); 1029 1030 /* 1031 ** Determine the correct mbuf pool 1032 ** for doing jumbo frames 1033 */ 1034 if (adapter->max_frame_size <= 2048) 1035 adapter->rx_mbuf_sz = MCLBYTES; 1036 else if (adapter->max_frame_size <= 4096) 1037 adapter->rx_mbuf_sz = MJUMPAGESIZE; 1038 else if (adapter->max_frame_size <= 9216) 1039 adapter->rx_mbuf_sz = MJUM9BYTES; 1040 else 1041 adapter->rx_mbuf_sz = MJUM16BYTES; 1042 1043 /* Prepare receive descriptors and buffers */ 1044 if (ixgbe_setup_receive_structures(adapter)) { 1045 device_printf(dev,"Could not setup receive structures\n"); 1046 ixgbe_stop(adapter); 1047 return; 1048 } 1049 1050 /* Configure RX settings */ 1051 ixgbe_initialize_receive_units(adapter); 1052 1053 gpie = IXGBE_READ_REG(&adapter->hw, IXGBE_GPIE); 1054 1055 /* Enable Fan Failure Interrupt */ 1056 gpie |= IXGBE_SDP1_GPIEN; 1057 1058 /* Add for Module detection */ 1059 if (hw->mac.type == ixgbe_mac_82599EB) 1060 gpie |= IXGBE_SDP2_GPIEN; 1061 1062 /* Thermal Failure Detection */ 1063 if (hw->mac.type == ixgbe_mac_X540) 1064 gpie |= IXGBE_SDP0_GPIEN; 1065 1066 if (adapter->msix > 1) { 1067 /* Enable Enhanced MSIX mode */ 1068 gpie |= IXGBE_GPIE_MSIX_MODE; 1069 gpie |= IXGBE_GPIE_EIAME | IXGBE_GPIE_PBA_SUPPORT | 1070 IXGBE_GPIE_OCD; 1071 } 1072 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 1073 1074 /* Set MTU size */ 1075 if (ifp->if_mtu > ETHERMTU) { 1076 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 1077 mhadd &= ~IXGBE_MHADD_MFS_MASK; 1078 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 1079 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 1080 } 1081 1082 /* Now enable all the queues */ 1083 1084 for (int i = 0; i < adapter->num_queues; i++) { 1085 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(i)); 1086 txdctl |= IXGBE_TXDCTL_ENABLE; 1087 /* Set WTHRESH to 8, burst writeback */ 1088 txdctl |= (8 << 16); 1089 /* 1090 * When the internal queue falls below PTHRESH (32), 1091 * start prefetching as long as there are at least 1092 * HTHRESH (1) buffers ready. The values are taken 1093 * from the Intel linux driver 3.8.21. 1094 * Prefetching enables tx line rate even with 1 queue. 1095 */ 1096 txdctl |= (32 << 0) | (1 << 8); 1097 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(i), txdctl); 1098 } 1099 1100 for (int i = 0; i < adapter->num_queues; i++) { 1101 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(i)); 1102 if (hw->mac.type == ixgbe_mac_82598EB) { 1103 /* 1104 ** PTHRESH = 21 1105 ** HTHRESH = 4 1106 ** WTHRESH = 8 1107 */ 1108 rxdctl &= ~0x3FFFFF; 1109 rxdctl |= 0x080420; 1110 } 1111 rxdctl |= IXGBE_RXDCTL_ENABLE; 1112 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(i), rxdctl); 1113 /* XXX I don't trust this loop, and I don't trust the 1114 * XXX memory barrier. What is this meant to do? --dyoung 1115 */ 1116 for (k = 0; k < 10; k++) { 1117 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(i)) & 1118 IXGBE_RXDCTL_ENABLE) 1119 break; 1120 else 1121 msec_delay(1); 1122 } 1123 wmb(); 1124 #ifdef DEV_NETMAP 1125 /* 1126 * In netmap mode, we must preserve the buffers made 1127 * available to userspace before the if_init() 1128 * (this is true by default on the TX side, because 1129 * init makes all buffers available to userspace). 1130 * 1131 * netmap_reset() and the device specific routines 1132 * (e.g. ixgbe_setup_receive_rings()) map these 1133 * buffers at the end of the NIC ring, so here we 1134 * must set the RDT (tail) register to make sure 1135 * they are not overwritten. 1136 * 1137 * In this driver the NIC ring starts at RDH = 0, 1138 * RDT points to the last slot available for reception (?), 1139 * so RDT = num_rx_desc - 1 means the whole ring is available. 1140 */ 1141 if (ifp->if_capenable & IFCAP_NETMAP) { 1142 struct netmap_adapter *na = NA(adapter->ifp); 1143 struct netmap_kring *kring = &na->rx_rings[i]; 1144 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1145 1146 IXGBE_WRITE_REG(hw, IXGBE_RDT(i), t); 1147 } else 1148 #endif /* DEV_NETMAP */ 1149 IXGBE_WRITE_REG(hw, IXGBE_RDT(i), adapter->num_rx_desc - 1); 1150 } 1151 1152 /* Enable Receive engine */ 1153 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 1154 if (hw->mac.type == ixgbe_mac_82598EB) 1155 rxctrl |= IXGBE_RXCTRL_DMBYPS; 1156 rxctrl |= IXGBE_RXCTRL_RXEN; 1157 ixgbe_enable_rx_dma(hw, rxctrl); 1158 1159 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 1160 1161 /* Set up MSI/X routing */ 1162 if (ixgbe_enable_msix) { 1163 ixgbe_configure_ivars(adapter); 1164 /* Set up auto-mask */ 1165 if (hw->mac.type == ixgbe_mac_82598EB) 1166 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 1167 else { 1168 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 1169 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 1170 } 1171 } else { /* Simple settings for Legacy/MSI */ 1172 ixgbe_set_ivar(adapter, 0, 0, 0); 1173 ixgbe_set_ivar(adapter, 0, 0, 1); 1174 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 1175 } 1176 1177 #ifdef IXGBE_FDIR 1178 /* Init Flow director */ 1179 if (hw->mac.type != ixgbe_mac_82598EB) { 1180 u32 hdrm = 32 << fdir_pballoc; 1181 1182 hw->mac.ops.setup_rxpba(hw, 0, hdrm, PBA_STRATEGY_EQUAL); 1183 ixgbe_init_fdir_signature_82599(&adapter->hw, fdir_pballoc); 1184 } 1185 #endif 1186 1187 /* 1188 ** Check on any SFP devices that 1189 ** need to be kick-started 1190 */ 1191 if (hw->phy.type == ixgbe_phy_none) { 1192 int err = hw->phy.ops.identify(hw); 1193 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 1194 device_printf(dev, 1195 "Unsupported SFP+ module type was detected.\n"); 1196 return; 1197 } 1198 } 1199 1200 /* Set moderation on the Link interrupt */ 1201 IXGBE_WRITE_REG(hw, IXGBE_EITR(adapter->linkvec), IXGBE_LINK_ITR); 1202 1203 /* Config/Enable Link */ 1204 ixgbe_config_link(adapter); 1205 1206 /* Hardware Packet Buffer & Flow Control setup */ 1207 { 1208 u32 rxpb, frame, size, tmp; 1209 1210 frame = adapter->max_frame_size; 1211 1212 /* Calculate High Water */ 1213 if (hw->mac.type == ixgbe_mac_X540) 1214 tmp = IXGBE_DV_X540(frame, frame); 1215 else 1216 tmp = IXGBE_DV(frame, frame); 1217 size = IXGBE_BT2KB(tmp); 1218 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 1219 hw->fc.high_water[0] = rxpb - size; 1220 1221 /* Now calculate Low Water */ 1222 if (hw->mac.type == ixgbe_mac_X540) 1223 tmp = IXGBE_LOW_DV_X540(frame); 1224 else 1225 tmp = IXGBE_LOW_DV(frame); 1226 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 1227 1228 hw->fc.requested_mode = adapter->fc; 1229 hw->fc.pause_time = IXGBE_FC_PAUSE; 1230 hw->fc.send_xon = TRUE; 1231 } 1232 /* Initialize the FC settings */ 1233 ixgbe_start_hw(hw); 1234 1235 /* Set up VLAN support and filter */ 1236 ixgbe_setup_vlan_hw_support(adapter); 1237 1238 /* And now turn on interrupts */ 1239 ixgbe_enable_intr(adapter); 1240 1241 /* Now inform the stack we're ready */ 1242 ifp->if_flags |= IFF_RUNNING; 1243 1244 return; 1245 } 1246 1247 static int 1248 ixgbe_init(struct ifnet *ifp) 1249 { 1250 struct adapter *adapter = ifp->if_softc; 1251 1252 IXGBE_CORE_LOCK(adapter); 1253 ixgbe_init_locked(adapter); 1254 IXGBE_CORE_UNLOCK(adapter); 1255 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 1256 } 1257 1258 1259 /* 1260 ** 1261 ** MSIX Interrupt Handlers and Tasklets 1262 ** 1263 */ 1264 1265 static inline void 1266 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 1267 { 1268 struct ixgbe_hw *hw = &adapter->hw; 1269 u64 queue = (u64)(1ULL << vector); 1270 u32 mask; 1271 1272 if (hw->mac.type == ixgbe_mac_82598EB) { 1273 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 1274 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 1275 } else { 1276 mask = (queue & 0xFFFFFFFF); 1277 if (mask) 1278 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 1279 mask = (queue >> 32); 1280 if (mask) 1281 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 1282 } 1283 } 1284 1285 __unused static inline void 1286 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 1287 { 1288 struct ixgbe_hw *hw = &adapter->hw; 1289 u64 queue = (u64)(1ULL << vector); 1290 u32 mask; 1291 1292 if (hw->mac.type == ixgbe_mac_82598EB) { 1293 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 1294 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 1295 } else { 1296 mask = (queue & 0xFFFFFFFF); 1297 if (mask) 1298 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 1299 mask = (queue >> 32); 1300 if (mask) 1301 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 1302 } 1303 } 1304 1305 static void 1306 ixgbe_handle_que(void *context) 1307 { 1308 struct ix_queue *que = context; 1309 struct adapter *adapter = que->adapter; 1310 struct tx_ring *txr = que->txr; 1311 struct ifnet *ifp = adapter->ifp; 1312 1313 adapter->handleq.ev_count++; 1314 1315 if (ifp->if_flags & IFF_RUNNING) { 1316 ixgbe_rxeof(que); 1317 IXGBE_TX_LOCK(txr); 1318 ixgbe_txeof(txr); 1319 #ifndef IXGBE_LEGACY_TX 1320 if (!drbr_empty(ifp, txr->br)) 1321 ixgbe_mq_start_locked(ifp, txr); 1322 #else 1323 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1324 ixgbe_start_locked(txr, ifp); 1325 #endif 1326 IXGBE_TX_UNLOCK(txr); 1327 } 1328 1329 /* Reenable this interrupt */ 1330 if (que->res != NULL) 1331 ixgbe_enable_queue(adapter, que->msix); 1332 else 1333 ixgbe_enable_intr(adapter); 1334 return; 1335 } 1336 1337 1338 /********************************************************************* 1339 * 1340 * Legacy Interrupt Service routine 1341 * 1342 **********************************************************************/ 1343 1344 static int 1345 ixgbe_legacy_irq(void *arg) 1346 { 1347 struct ix_queue *que = arg; 1348 struct adapter *adapter = que->adapter; 1349 struct ixgbe_hw *hw = &adapter->hw; 1350 struct ifnet *ifp = adapter->ifp; 1351 struct tx_ring *txr = adapter->tx_rings; 1352 bool more = false; 1353 u32 reg_eicr; 1354 1355 1356 reg_eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 1357 1358 adapter->stats.legint.ev_count++; 1359 ++que->irqs; 1360 if (reg_eicr == 0) { 1361 adapter->stats.intzero.ev_count++; 1362 if ((ifp->if_flags & IFF_UP) != 0) 1363 ixgbe_enable_intr(adapter); 1364 return 0; 1365 } 1366 1367 if ((ifp->if_flags & IFF_RUNNING) != 0) { 1368 #ifdef __NetBSD__ 1369 /* Don't run ixgbe_rxeof in interrupt context */ 1370 more = true; 1371 #else 1372 more = ixgbe_rxeof(que); 1373 #endif 1374 1375 IXGBE_TX_LOCK(txr); 1376 ixgbe_txeof(txr); 1377 #ifdef IXGBE_LEGACY_TX 1378 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1379 ixgbe_start_locked(txr, ifp); 1380 #else 1381 if (!drbr_empty(ifp, txr->br)) 1382 ixgbe_mq_start_locked(ifp, txr); 1383 #endif 1384 IXGBE_TX_UNLOCK(txr); 1385 } 1386 1387 /* Check for fan failure */ 1388 if ((hw->phy.media_type == ixgbe_media_type_copper) && 1389 (reg_eicr & IXGBE_EICR_GPI_SDP1)) { 1390 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! " 1391 "REPLACE IMMEDIATELY!!\n"); 1392 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1); 1393 } 1394 1395 /* Link status change */ 1396 if (reg_eicr & IXGBE_EICR_LSC) 1397 softint_schedule(adapter->link_si); 1398 1399 if (more) 1400 #ifndef IXGBE_LEGACY_TX 1401 softint_schedule(txr->txq_si); 1402 #else 1403 softint_schedule(que->que_si); 1404 #endif 1405 else 1406 ixgbe_enable_intr(adapter); 1407 return 1; 1408 } 1409 1410 1411 /********************************************************************* 1412 * 1413 * MSIX Queue Interrupt Service routine 1414 * 1415 **********************************************************************/ 1416 static int 1417 ixgbe_msix_que(void *arg) 1418 { 1419 struct ix_queue *que = arg; 1420 struct adapter *adapter = que->adapter; 1421 struct ifnet *ifp = adapter->ifp; 1422 struct tx_ring *txr = que->txr; 1423 struct rx_ring *rxr = que->rxr; 1424 bool more; 1425 u32 newitr = 0; 1426 1427 /* Protect against spurious interrupts */ 1428 if ((ifp->if_flags & IFF_RUNNING) == 0) 1429 return 0; 1430 1431 ixgbe_disable_queue(adapter, que->msix); 1432 ++que->irqs; 1433 1434 #ifdef __NetBSD__ 1435 /* Don't run ixgbe_rxeof in interrupt context */ 1436 more = true; 1437 #else 1438 more = ixgbe_rxeof(que); 1439 #endif 1440 1441 IXGBE_TX_LOCK(txr); 1442 ixgbe_txeof(txr); 1443 #ifdef IXGBE_LEGACY_TX 1444 if (!IFQ_IS_EMPTY(&adapter->ifp->if_snd)) 1445 ixgbe_start_locked(txr, ifp); 1446 #else 1447 if (!drbr_empty(ifp, txr->br)) 1448 ixgbe_mq_start_locked(ifp, txr); 1449 #endif 1450 IXGBE_TX_UNLOCK(txr); 1451 1452 /* Do AIM now? */ 1453 1454 if (ixgbe_enable_aim == FALSE) 1455 goto no_calc; 1456 /* 1457 ** Do Adaptive Interrupt Moderation: 1458 ** - Write out last calculated setting 1459 ** - Calculate based on average size over 1460 ** the last interval. 1461 */ 1462 if (que->eitr_setting) 1463 IXGBE_WRITE_REG(&adapter->hw, 1464 IXGBE_EITR(que->msix), que->eitr_setting); 1465 1466 que->eitr_setting = 0; 1467 1468 /* Idle, do nothing */ 1469 if ((txr->bytes == 0) && (rxr->bytes == 0)) 1470 goto no_calc; 1471 1472 if ((txr->bytes) && (txr->packets)) 1473 newitr = txr->bytes/txr->packets; 1474 if ((rxr->bytes) && (rxr->packets)) 1475 newitr = max(newitr, 1476 (rxr->bytes / rxr->packets)); 1477 newitr += 24; /* account for hardware frame, crc */ 1478 1479 /* set an upper boundary */ 1480 newitr = min(newitr, 3000); 1481 1482 /* Be nice to the mid range */ 1483 if ((newitr > 300) && (newitr < 1200)) 1484 newitr = (newitr / 3); 1485 else 1486 newitr = (newitr / 2); 1487 1488 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 1489 newitr |= newitr << 16; 1490 else 1491 newitr |= IXGBE_EITR_CNT_WDIS; 1492 1493 /* save for next interrupt */ 1494 que->eitr_setting = newitr; 1495 1496 /* Reset state */ 1497 txr->bytes = 0; 1498 txr->packets = 0; 1499 rxr->bytes = 0; 1500 rxr->packets = 0; 1501 1502 no_calc: 1503 if (more) 1504 softint_schedule(que->que_si); 1505 else 1506 ixgbe_enable_queue(adapter, que->msix); 1507 return 1; 1508 } 1509 1510 1511 static int 1512 ixgbe_msix_link(void *arg) 1513 { 1514 struct adapter *adapter = arg; 1515 struct ixgbe_hw *hw = &adapter->hw; 1516 u32 reg_eicr; 1517 1518 ++adapter->link_irq.ev_count; 1519 1520 /* First get the cause */ 1521 reg_eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 1522 /* Be sure the queue bits are not cleared */ 1523 reg_eicr &= ~IXGBE_EICR_RTX_QUEUE; 1524 /* Clear interrupt with write */ 1525 IXGBE_WRITE_REG(hw, IXGBE_EICR, reg_eicr); 1526 1527 /* Link status change */ 1528 if (reg_eicr & IXGBE_EICR_LSC) 1529 softint_schedule(adapter->link_si); 1530 1531 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 1532 #ifdef IXGBE_FDIR 1533 if (reg_eicr & IXGBE_EICR_FLOW_DIR) { 1534 /* This is probably overkill :) */ 1535 if (!atomic_cmpset_int(&adapter->fdir_reinit, 0, 1)) 1536 return 1; 1537 /* Disable the interrupt */ 1538 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EICR_FLOW_DIR); 1539 softint_schedule(adapter->fdir_si); 1540 } else 1541 #endif 1542 if (reg_eicr & IXGBE_EICR_ECC) { 1543 device_printf(adapter->dev, "\nCRITICAL: ECC ERROR!! " 1544 "Please Reboot!!\n"); 1545 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC); 1546 } else 1547 1548 if (reg_eicr & IXGBE_EICR_GPI_SDP1) { 1549 /* Clear the interrupt */ 1550 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1); 1551 softint_schedule(adapter->msf_si); 1552 } else if (reg_eicr & IXGBE_EICR_GPI_SDP2) { 1553 /* Clear the interrupt */ 1554 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP2); 1555 softint_schedule(adapter->mod_si); 1556 } 1557 } 1558 1559 /* Check for fan failure */ 1560 if ((hw->device_id == IXGBE_DEV_ID_82598AT) && 1561 (reg_eicr & IXGBE_EICR_GPI_SDP1)) { 1562 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! " 1563 "REPLACE IMMEDIATELY!!\n"); 1564 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1); 1565 } 1566 1567 /* Check for over temp condition */ 1568 if ((hw->mac.type == ixgbe_mac_X540) && 1569 (reg_eicr & IXGBE_EICR_TS)) { 1570 device_printf(adapter->dev, "\nCRITICAL: OVER TEMP!! " 1571 "PHY IS SHUT DOWN!!\n"); 1572 device_printf(adapter->dev, "System shutdown required\n"); 1573 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS); 1574 } 1575 1576 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, IXGBE_EIMS_OTHER); 1577 return 1; 1578 } 1579 1580 /********************************************************************* 1581 * 1582 * Media Ioctl callback 1583 * 1584 * This routine is called whenever the user queries the status of 1585 * the interface using ifconfig. 1586 * 1587 **********************************************************************/ 1588 static void 1589 ixgbe_media_status(struct ifnet * ifp, struct ifmediareq * ifmr) 1590 { 1591 struct adapter *adapter = ifp->if_softc; 1592 struct ixgbe_hw *hw = &adapter->hw; 1593 1594 INIT_DEBUGOUT("ixgbe_media_status: begin"); 1595 IXGBE_CORE_LOCK(adapter); 1596 ixgbe_update_link_status(adapter); 1597 1598 ifmr->ifm_status = IFM_AVALID; 1599 ifmr->ifm_active = IFM_ETHER; 1600 1601 if (!adapter->link_active) { 1602 IXGBE_CORE_UNLOCK(adapter); 1603 return; 1604 } 1605 1606 ifmr->ifm_status |= IFM_ACTIVE; 1607 1608 /* 1609 * Not all NIC are 1000baseSX as an example X540T. 1610 * We must set properly the media based on NIC model. 1611 */ 1612 switch (hw->device_id) { 1613 case IXGBE_DEV_ID_X540T: 1614 if (adapter->link_speed == IXGBE_LINK_SPEED_100_FULL) 1615 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1616 else if (adapter->link_speed == IXGBE_LINK_SPEED_1GB_FULL) 1617 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 1618 else if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL) 1619 ifmr->ifm_active |= adapter->optics | IFM_FDX; 1620 break; 1621 default: 1622 if (adapter->link_speed == IXGBE_LINK_SPEED_100_FULL) 1623 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1624 else if (adapter->link_speed == IXGBE_LINK_SPEED_1GB_FULL) 1625 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 1626 else if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL) 1627 ifmr->ifm_active |= adapter->optics | IFM_FDX; 1628 break; 1629 } 1630 1631 IXGBE_CORE_UNLOCK(adapter); 1632 1633 return; 1634 } 1635 1636 /********************************************************************* 1637 * 1638 * Media Ioctl callback 1639 * 1640 * This routine is called when the user changes speed/duplex using 1641 * media/mediopt option with ifconfig. 1642 * 1643 **********************************************************************/ 1644 static int 1645 ixgbe_media_change(struct ifnet * ifp) 1646 { 1647 struct adapter *adapter = ifp->if_softc; 1648 struct ifmedia *ifm = &adapter->media; 1649 1650 INIT_DEBUGOUT("ixgbe_media_change: begin"); 1651 1652 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 1653 return (EINVAL); 1654 1655 switch (IFM_SUBTYPE(ifm->ifm_media)) { 1656 case IFM_10G_T: 1657 case IFM_AUTO: 1658 adapter->hw.phy.autoneg_advertised = 1659 IXGBE_LINK_SPEED_100_FULL | 1660 IXGBE_LINK_SPEED_1GB_FULL | 1661 IXGBE_LINK_SPEED_10GB_FULL; 1662 break; 1663 default: 1664 device_printf(adapter->dev, "Only auto media type\n"); 1665 return (EINVAL); 1666 } 1667 1668 return (0); 1669 } 1670 1671 static void 1672 ixgbe_set_promisc(struct adapter *adapter) 1673 { 1674 struct ether_multi *enm; 1675 struct ether_multistep step; 1676 u_int32_t reg_rctl; 1677 struct ethercom *ec = &adapter->osdep.ec; 1678 struct ifnet *ifp = adapter->ifp; 1679 int mcnt = 0; 1680 1681 reg_rctl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 1682 reg_rctl &= (~IXGBE_FCTRL_UPE); 1683 if (ifp->if_flags & IFF_ALLMULTI) 1684 mcnt = MAX_NUM_MULTICAST_ADDRESSES; 1685 else { 1686 ETHER_FIRST_MULTI(step, ec, enm); 1687 while (enm != NULL) { 1688 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) 1689 break; 1690 mcnt++; 1691 ETHER_NEXT_MULTI(step, enm); 1692 } 1693 } 1694 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) 1695 reg_rctl &= (~IXGBE_FCTRL_MPE); 1696 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 1697 1698 if (ifp->if_flags & IFF_PROMISC) { 1699 reg_rctl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 1700 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 1701 } else if (ifp->if_flags & IFF_ALLMULTI) { 1702 reg_rctl |= IXGBE_FCTRL_MPE; 1703 reg_rctl &= ~IXGBE_FCTRL_UPE; 1704 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 1705 } 1706 return; 1707 } 1708 1709 1710 /********************************************************************* 1711 * Multicast Update 1712 * 1713 * This routine is called whenever multicast address list is updated. 1714 * 1715 **********************************************************************/ 1716 #define IXGBE_RAR_ENTRIES 16 1717 1718 static void 1719 ixgbe_set_multi(struct adapter *adapter) 1720 { 1721 struct ether_multi *enm; 1722 struct ether_multistep step; 1723 u32 fctrl; 1724 u8 *mta; 1725 u8 *update_ptr; 1726 int mcnt = 0; 1727 struct ethercom *ec = &adapter->osdep.ec; 1728 struct ifnet *ifp = adapter->ifp; 1729 1730 IOCTL_DEBUGOUT("ixgbe_set_multi: begin"); 1731 1732 mta = adapter->mta; 1733 bzero(mta, sizeof(u8) * IXGBE_ETH_LENGTH_OF_ADDRESS * 1734 MAX_NUM_MULTICAST_ADDRESSES); 1735 1736 ifp->if_flags &= ~IFF_ALLMULTI; 1737 ETHER_FIRST_MULTI(step, ec, enm); 1738 while (enm != NULL) { 1739 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 1740 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 1741 ETHER_ADDR_LEN) != 0)) { 1742 ifp->if_flags |= IFF_ALLMULTI; 1743 break; 1744 } 1745 bcopy(enm->enm_addrlo, 1746 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS], 1747 IXGBE_ETH_LENGTH_OF_ADDRESS); 1748 mcnt++; 1749 ETHER_NEXT_MULTI(step, enm); 1750 } 1751 1752 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 1753 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 1754 if (ifp->if_flags & IFF_PROMISC) 1755 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 1756 else if (ifp->if_flags & IFF_ALLMULTI) { 1757 fctrl |= IXGBE_FCTRL_MPE; 1758 } 1759 1760 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 1761 1762 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) { 1763 update_ptr = mta; 1764 ixgbe_update_mc_addr_list(&adapter->hw, 1765 update_ptr, mcnt, ixgbe_mc_array_itr, TRUE); 1766 } 1767 1768 return; 1769 } 1770 1771 /* 1772 * This is an iterator function now needed by the multicast 1773 * shared code. It simply feeds the shared code routine the 1774 * addresses in the array of ixgbe_set_multi() one by one. 1775 */ 1776 static u8 * 1777 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 1778 { 1779 u8 *addr = *update_ptr; 1780 u8 *newptr; 1781 *vmdq = 0; 1782 1783 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS; 1784 *update_ptr = newptr; 1785 return addr; 1786 } 1787 1788 1789 /********************************************************************* 1790 * Timer routine 1791 * 1792 * This routine checks for link status,updates statistics, 1793 * and runs the watchdog check. 1794 * 1795 **********************************************************************/ 1796 1797 static void 1798 ixgbe_local_timer1(void *arg) 1799 { 1800 struct adapter *adapter = arg; 1801 device_t dev = adapter->dev; 1802 struct ix_queue *que = adapter->queues; 1803 struct tx_ring *txr = adapter->tx_rings; 1804 int hung = 0, paused = 0; 1805 1806 KASSERT(mutex_owned(&adapter->core_mtx)); 1807 1808 /* Check for pluggable optics */ 1809 if (adapter->sfp_probe) 1810 if (!ixgbe_sfp_probe(adapter)) 1811 goto out; /* Nothing to do */ 1812 1813 ixgbe_update_link_status(adapter); 1814 ixgbe_update_stats_counters(adapter); 1815 1816 /* 1817 * If the interface has been paused 1818 * then don't do the watchdog check 1819 */ 1820 if (IXGBE_READ_REG(&adapter->hw, IXGBE_TFCS) & IXGBE_TFCS_TXOFF) 1821 paused = 1; 1822 1823 /* 1824 ** Check the TX queues status 1825 ** - watchdog only if all queues show hung 1826 */ 1827 for (int i = 0; i < adapter->num_queues; i++, que++, txr++) { 1828 if ((txr->queue_status == IXGBE_QUEUE_HUNG) && 1829 (paused == 0)) 1830 ++hung; 1831 else if (txr->queue_status == IXGBE_QUEUE_WORKING) 1832 #ifndef IXGBE_LEGACY_TX 1833 softint_schedule(txr->txq_si); 1834 #else 1835 softint_schedule(que->que_si); 1836 #endif 1837 } 1838 /* Only truely watchdog if all queues show hung */ 1839 if (hung == adapter->num_queues) 1840 goto watchdog; 1841 1842 out: 1843 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 1844 return; 1845 1846 watchdog: 1847 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 1848 device_printf(dev,"Queue(%d) tdh = %d, hw tdt = %d\n", txr->me, 1849 IXGBE_READ_REG(&adapter->hw, IXGBE_TDH(txr->me)), 1850 IXGBE_READ_REG(&adapter->hw, IXGBE_TDT(txr->me))); 1851 device_printf(dev,"TX(%d) desc avail = %d," 1852 "Next TX to Clean = %d\n", 1853 txr->me, txr->tx_avail, txr->next_to_clean); 1854 adapter->ifp->if_flags &= ~IFF_RUNNING; 1855 adapter->watchdog_events.ev_count++; 1856 ixgbe_init_locked(adapter); 1857 } 1858 1859 static void 1860 ixgbe_local_timer(void *arg) 1861 { 1862 struct adapter *adapter = arg; 1863 1864 IXGBE_CORE_LOCK(adapter); 1865 ixgbe_local_timer1(adapter); 1866 IXGBE_CORE_UNLOCK(adapter); 1867 } 1868 1869 /* 1870 ** Note: this routine updates the OS on the link state 1871 ** the real check of the hardware only happens with 1872 ** a link interrupt. 1873 */ 1874 static void 1875 ixgbe_update_link_status(struct adapter *adapter) 1876 { 1877 struct ifnet *ifp = adapter->ifp; 1878 device_t dev = adapter->dev; 1879 1880 1881 if (adapter->link_up){ 1882 if (adapter->link_active == FALSE) { 1883 if (bootverbose) 1884 device_printf(dev,"Link is up %d Gbps %s \n", 1885 ((adapter->link_speed == 128)? 10:1), 1886 "Full Duplex"); 1887 adapter->link_active = TRUE; 1888 /* Update any Flow Control changes */ 1889 ixgbe_fc_enable(&adapter->hw); 1890 if_link_state_change(ifp, LINK_STATE_UP); 1891 } 1892 } else { /* Link down */ 1893 if (adapter->link_active == TRUE) { 1894 if (bootverbose) 1895 device_printf(dev,"Link is Down\n"); 1896 if_link_state_change(ifp, LINK_STATE_DOWN); 1897 adapter->link_active = FALSE; 1898 } 1899 } 1900 1901 return; 1902 } 1903 1904 1905 static void 1906 ixgbe_ifstop(struct ifnet *ifp, int disable) 1907 { 1908 struct adapter *adapter = ifp->if_softc; 1909 1910 IXGBE_CORE_LOCK(adapter); 1911 ixgbe_stop(adapter); 1912 IXGBE_CORE_UNLOCK(adapter); 1913 } 1914 1915 /********************************************************************* 1916 * 1917 * This routine disables all traffic on the adapter by issuing a 1918 * global reset on the MAC and deallocates TX/RX buffers. 1919 * 1920 **********************************************************************/ 1921 1922 static void 1923 ixgbe_stop(void *arg) 1924 { 1925 struct ifnet *ifp; 1926 struct adapter *adapter = arg; 1927 struct ixgbe_hw *hw = &adapter->hw; 1928 ifp = adapter->ifp; 1929 1930 KASSERT(mutex_owned(&adapter->core_mtx)); 1931 1932 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 1933 ixgbe_disable_intr(adapter); 1934 callout_stop(&adapter->timer); 1935 1936 /* Let the stack know...*/ 1937 ifp->if_flags &= ~IFF_RUNNING; 1938 1939 ixgbe_reset_hw(hw); 1940 hw->adapter_stopped = FALSE; 1941 ixgbe_stop_adapter(hw); 1942 if (hw->mac.type == ixgbe_mac_82599EB) 1943 ixgbe_stop_mac_link_on_d3_82599(hw); 1944 /* Turn off the laser - noop with no optics */ 1945 ixgbe_disable_tx_laser(hw); 1946 1947 /* Update the stack */ 1948 adapter->link_up = FALSE; 1949 ixgbe_update_link_status(adapter); 1950 1951 /* reprogram the RAR[0] in case user changed it. */ 1952 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 1953 1954 return; 1955 } 1956 1957 1958 /********************************************************************* 1959 * 1960 * Determine hardware revision. 1961 * 1962 **********************************************************************/ 1963 static void 1964 ixgbe_identify_hardware(struct adapter *adapter) 1965 { 1966 pcitag_t tag; 1967 pci_chipset_tag_t pc; 1968 pcireg_t subid, id; 1969 struct ixgbe_hw *hw = &adapter->hw; 1970 1971 pc = adapter->osdep.pc; 1972 tag = adapter->osdep.tag; 1973 1974 id = pci_conf_read(pc, tag, PCI_ID_REG); 1975 subid = pci_conf_read(pc, tag, PCI_SUBSYS_ID_REG); 1976 1977 /* Save off the information about this board */ 1978 hw->vendor_id = PCI_VENDOR(id); 1979 hw->device_id = PCI_PRODUCT(id); 1980 hw->revision_id = 1981 PCI_REVISION(pci_conf_read(pc, tag, PCI_CLASS_REG)); 1982 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 1983 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 1984 1985 /* We need this here to set the num_segs below */ 1986 ixgbe_set_mac_type(hw); 1987 1988 /* Pick up the 82599 and VF settings */ 1989 if (hw->mac.type != ixgbe_mac_82598EB) { 1990 hw->phy.smart_speed = ixgbe_smart_speed; 1991 adapter->num_segs = IXGBE_82599_SCATTER; 1992 } else 1993 adapter->num_segs = IXGBE_82598_SCATTER; 1994 1995 return; 1996 } 1997 1998 /********************************************************************* 1999 * 2000 * Determine optic type 2001 * 2002 **********************************************************************/ 2003 static void 2004 ixgbe_setup_optics(struct adapter *adapter) 2005 { 2006 struct ixgbe_hw *hw = &adapter->hw; 2007 int layer; 2008 2009 layer = ixgbe_get_supported_physical_layer(hw); 2010 2011 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) { 2012 adapter->optics = IFM_10G_T; 2013 return; 2014 } 2015 2016 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) { 2017 adapter->optics = IFM_1000_T; 2018 return; 2019 } 2020 2021 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) { 2022 adapter->optics = IFM_1000_SX; 2023 return; 2024 } 2025 2026 if (layer & (IXGBE_PHYSICAL_LAYER_10GBASE_LR | 2027 IXGBE_PHYSICAL_LAYER_10GBASE_LRM)) { 2028 adapter->optics = IFM_10G_LR; 2029 return; 2030 } 2031 2032 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 2033 adapter->optics = IFM_10G_SR; 2034 return; 2035 } 2036 2037 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU) { 2038 adapter->optics = IFM_10G_TWINAX; 2039 return; 2040 } 2041 2042 if (layer & (IXGBE_PHYSICAL_LAYER_10GBASE_KX4 | 2043 IXGBE_PHYSICAL_LAYER_10GBASE_CX4)) { 2044 adapter->optics = IFM_10G_CX4; 2045 return; 2046 } 2047 2048 /* If we get here just set the default */ 2049 adapter->optics = IFM_ETHER | IFM_AUTO; 2050 return; 2051 } 2052 2053 /********************************************************************* 2054 * 2055 * Setup the Legacy or MSI Interrupt handler 2056 * 2057 **********************************************************************/ 2058 static int 2059 ixgbe_allocate_legacy(struct adapter *adapter, 2060 const struct pci_attach_args *pa) 2061 { 2062 device_t dev = adapter->dev; 2063 struct ix_queue *que = adapter->queues; 2064 #ifndef IXGBE_LEGACY_TX 2065 struct tx_ring *txr = adapter->tx_rings; 2066 #endif 2067 int counts[PCI_INTR_TYPE_SIZE]; 2068 pci_intr_type_t intr_type, max_type; 2069 char intrbuf[PCI_INTRSTR_LEN]; 2070 const char *intrstr = NULL; 2071 2072 /* Allocation settings */ 2073 max_type = PCI_INTR_TYPE_MSI; 2074 counts[PCI_INTR_TYPE_MSIX] = 0; 2075 counts[PCI_INTR_TYPE_MSI] = 1; 2076 counts[PCI_INTR_TYPE_INTX] = 1; 2077 2078 alloc_retry: 2079 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 2080 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 2081 return ENXIO; 2082 } 2083 adapter->osdep.nintrs = 1; 2084 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 2085 intrbuf, sizeof(intrbuf)); 2086 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 2087 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 2088 device_xname(dev)); 2089 if (adapter->osdep.ihs[0] == NULL) { 2090 intr_type = pci_intr_type(adapter->osdep.pc, 2091 adapter->osdep.intrs[0]); 2092 aprint_error_dev(dev,"unable to establish %s\n", 2093 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 2094 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 2095 switch (intr_type) { 2096 case PCI_INTR_TYPE_MSI: 2097 /* The next try is for INTx: Disable MSI */ 2098 max_type = PCI_INTR_TYPE_INTX; 2099 counts[PCI_INTR_TYPE_INTX] = 1; 2100 goto alloc_retry; 2101 case PCI_INTR_TYPE_INTX: 2102 default: 2103 /* See below */ 2104 break; 2105 } 2106 } 2107 if (adapter->osdep.ihs[0] == NULL) { 2108 aprint_error_dev(dev, 2109 "couldn't establish interrupt%s%s\n", 2110 intrstr ? " at " : "", intrstr ? intrstr : ""); 2111 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 2112 return ENXIO; 2113 } 2114 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 2115 /* 2116 * Try allocating a fast interrupt and the associated deferred 2117 * processing contexts. 2118 */ 2119 #ifndef IXGBE_LEGACY_TX 2120 txr->txq_si = softint_establish(SOFTINT_NET, ixgbe_deferred_mq_start, 2121 txr); 2122 #endif 2123 que->que_si = softint_establish(SOFTINT_NET, ixgbe_handle_que, que); 2124 2125 /* Tasklets for Link, SFP and Multispeed Fiber */ 2126 adapter->link_si = 2127 softint_establish(SOFTINT_NET, ixgbe_handle_link, adapter); 2128 adapter->mod_si = 2129 softint_establish(SOFTINT_NET, ixgbe_handle_mod, adapter); 2130 adapter->msf_si = 2131 softint_establish(SOFTINT_NET, ixgbe_handle_msf, adapter); 2132 2133 #ifdef IXGBE_FDIR 2134 adapter->fdir_si = 2135 softint_establish(SOFTINT_NET, ixgbe_reinit_fdir, adapter); 2136 #endif 2137 if (que->que_si == NULL || 2138 adapter->link_si == NULL || 2139 adapter->mod_si == NULL || 2140 #ifdef IXGBE_FDIR 2141 adapter->fdir_si == NULL || 2142 #endif 2143 adapter->msf_si == NULL) { 2144 aprint_error_dev(dev, 2145 "could not establish software interrupts\n"); 2146 return ENXIO; 2147 } 2148 2149 /* For simplicity in the handlers */ 2150 adapter->que_mask = IXGBE_EIMS_ENABLE_MASK; 2151 2152 return (0); 2153 } 2154 2155 2156 /********************************************************************* 2157 * 2158 * Setup MSIX Interrupt resources and handlers 2159 * 2160 **********************************************************************/ 2161 static int 2162 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 2163 { 2164 device_t dev = adapter->dev; 2165 struct ix_queue *que = adapter->queues; 2166 struct tx_ring *txr = adapter->tx_rings; 2167 pci_chipset_tag_t pc; 2168 char intrbuf[PCI_INTRSTR_LEN]; 2169 char intr_xname[32]; 2170 const char *intrstr = NULL; 2171 int error, vector = 0; 2172 int cpu_id = 0; 2173 kcpuset_t *affinity; 2174 2175 pc = adapter->osdep.pc; 2176 #ifdef RSS 2177 cpuset_t cpu_mask; 2178 /* 2179 * If we're doing RSS, the number of queues needs to 2180 * match the number of RSS buckets that are configured. 2181 * 2182 * + If there's more queues than RSS buckets, we'll end 2183 * up with queues that get no traffic. 2184 * 2185 * + If there's more RSS buckets than queues, we'll end 2186 * up having multiple RSS buckets map to the same queue, 2187 * so there'll be some contention. 2188 */ 2189 if (adapter->num_queues != rss_getnumbuckets()) { 2190 device_printf(dev, 2191 "%s: number of queues (%d) != number of RSS buckets (%d)" 2192 "; performance will be impacted.\n", 2193 __func__, 2194 adapter->num_queues, 2195 rss_getnumbuckets()); 2196 } 2197 #endif 2198 2199 adapter->osdep.nintrs = adapter->num_queues + 1; 2200 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 2201 adapter->osdep.nintrs) != 0) { 2202 aprint_error_dev(dev, 2203 "failed to allocate MSI-X interrupt\n"); 2204 return (ENXIO); 2205 } 2206 2207 kcpuset_create(&affinity, false); 2208 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 2209 snprintf(intr_xname, sizeof(intr_xname), "%s TX/RX", 2210 device_xname(dev)); 2211 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 2212 sizeof(intrbuf)); 2213 #ifdef IXG_MPSAFE 2214 pci_intr_setattr(pc, adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 2215 true); 2216 #endif 2217 /* Set the handler function */ 2218 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 2219 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 2220 intr_xname); 2221 if (que->res == NULL) { 2222 pci_intr_release(pc, adapter->osdep.intrs, 2223 adapter->osdep.nintrs); 2224 aprint_error_dev(dev, 2225 "Failed to register QUE handler\n"); 2226 kcpuset_destroy(affinity); 2227 return ENXIO; 2228 } 2229 que->msix = vector; 2230 adapter->que_mask |= (u64)(1 << que->msix); 2231 #ifdef RSS 2232 /* 2233 * The queue ID is used as the RSS layer bucket ID. 2234 * We look up the queue ID -> RSS CPU ID and select 2235 * that. 2236 */ 2237 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 2238 #else 2239 /* 2240 * Bind the msix vector, and thus the 2241 * rings to the corresponding cpu. 2242 * 2243 * This just happens to match the default RSS round-robin 2244 * bucket -> queue -> CPU allocation. 2245 */ 2246 if (adapter->num_queues > 1) 2247 cpu_id = i; 2248 #endif 2249 /* Round-robin affinity */ 2250 kcpuset_zero(affinity); 2251 kcpuset_set(affinity, cpu_id % ncpu); 2252 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 2253 NULL); 2254 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 2255 intrstr); 2256 if (error == 0) { 2257 #ifdef RSS 2258 aprintf_normal(", bound RSS bucket %d to CPU %d\n", 2259 i, cpu_id); 2260 #else 2261 aprint_normal(", bound queue %d to cpu %d\n", 2262 i, cpu_id); 2263 #endif 2264 } else 2265 aprint_normal("\n"); 2266 2267 #ifndef IXGBE_LEGACY_TX 2268 txr->txq_si = softint_establish(SOFTINT_NET, 2269 ixgbe_deferred_mq_start, txr); 2270 #endif 2271 que->que_si = softint_establish(SOFTINT_NET, ixgbe_handle_que, 2272 que); 2273 if (que->que_si == NULL) { 2274 aprint_error_dev(dev, 2275 "could not establish software interrupt\n"); 2276 } 2277 } 2278 2279 /* and Link */ 2280 cpu_id++; 2281 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 2282 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 2283 sizeof(intrbuf)); 2284 #ifdef IXG_MPSAFE 2285 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 2286 true); 2287 #endif 2288 /* Set the link handler function */ 2289 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 2290 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 2291 intr_xname); 2292 if (adapter->osdep.ihs[vector] == NULL) { 2293 adapter->res = NULL; 2294 aprint_error_dev(dev, "Failed to register LINK handler\n"); 2295 kcpuset_destroy(affinity); 2296 return (ENXIO); 2297 } 2298 /* Round-robin affinity */ 2299 kcpuset_zero(affinity); 2300 kcpuset_set(affinity, cpu_id % ncpu); 2301 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity,NULL); 2302 2303 aprint_normal_dev(dev, 2304 "for link, interrupting at %s", intrstr); 2305 if (error == 0) 2306 aprint_normal(", affinity to cpu %d\n", cpu_id); 2307 else 2308 aprint_normal("\n"); 2309 2310 adapter->linkvec = vector; 2311 /* Tasklets for Link, SFP and Multispeed Fiber */ 2312 adapter->link_si = 2313 softint_establish(SOFTINT_NET, ixgbe_handle_link, adapter); 2314 adapter->mod_si = 2315 softint_establish(SOFTINT_NET, ixgbe_handle_mod, adapter); 2316 adapter->msf_si = 2317 softint_establish(SOFTINT_NET, ixgbe_handle_msf, adapter); 2318 #ifdef IXGBE_FDIR 2319 adapter->fdir_si = 2320 softint_establish(SOFTINT_NET, ixgbe_reinit_fdir, adapter); 2321 #endif 2322 2323 kcpuset_destroy(affinity); 2324 return (0); 2325 } 2326 2327 /* 2328 * Setup Either MSI/X or MSI 2329 */ 2330 static int 2331 ixgbe_setup_msix(struct adapter *adapter) 2332 { 2333 device_t dev = adapter->dev; 2334 int want, queues, msgs; 2335 2336 /* Override by tuneable */ 2337 if (ixgbe_enable_msix == 0) 2338 goto msi; 2339 2340 /* First try MSI/X */ 2341 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 2342 if (msgs < IXG_MSIX_NINTR) 2343 goto msi; 2344 2345 adapter->msix_mem = (void *)1; /* XXX */ 2346 2347 /* Figure out a reasonable auto config value */ 2348 queues = (ncpu > (msgs-1)) ? (msgs-1) : ncpu; 2349 2350 /* Override based on tuneable */ 2351 if (ixgbe_num_queues != 0) 2352 queues = ixgbe_num_queues; 2353 2354 #ifdef RSS 2355 /* If we're doing RSS, clamp at the number of RSS buckets */ 2356 if (queues > rss_getnumbuckets()) 2357 queues = rss_getnumbuckets(); 2358 #endif 2359 2360 /* reflect correct sysctl value */ 2361 ixgbe_num_queues = queues; 2362 2363 /* 2364 ** Want one vector (RX/TX pair) per queue 2365 ** plus an additional for Link. 2366 */ 2367 want = queues + 1; 2368 if (msgs >= want) 2369 msgs = want; 2370 else { 2371 aprint_error_dev(dev, 2372 "MSIX Configuration Problem, " 2373 "%d vectors but %d queues wanted!\n", 2374 msgs, want); 2375 goto msi; 2376 } 2377 device_printf(dev, 2378 "Using MSIX interrupts with %d vectors\n", msgs); 2379 adapter->num_queues = queues; 2380 return (msgs); 2381 2382 /* 2383 ** If MSIX alloc failed or provided us with 2384 ** less than needed, free and fall through to MSI 2385 */ 2386 msi: 2387 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 2388 adapter->msix_mem = NULL; /* XXX */ 2389 msgs = 1; 2390 aprint_normal_dev(dev,"Using an MSI interrupt\n"); 2391 return (msgs); 2392 } 2393 2394 2395 static int 2396 ixgbe_allocate_pci_resources(struct adapter *adapter, 2397 const struct pci_attach_args *pa) 2398 { 2399 pcireg_t memtype; 2400 device_t dev = adapter->dev; 2401 bus_addr_t addr; 2402 int flags; 2403 2404 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 2405 switch (memtype) { 2406 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 2407 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 2408 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 2409 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 2410 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 2411 goto map_err; 2412 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 2413 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 2414 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 2415 } 2416 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 2417 adapter->osdep.mem_size, flags, 2418 &adapter->osdep.mem_bus_space_handle) != 0) { 2419 map_err: 2420 adapter->osdep.mem_size = 0; 2421 aprint_error_dev(dev, "unable to map BAR0\n"); 2422 return ENXIO; 2423 } 2424 break; 2425 default: 2426 aprint_error_dev(dev, "unexpected type on BAR0\n"); 2427 return ENXIO; 2428 } 2429 2430 /* Legacy defaults */ 2431 adapter->num_queues = 1; 2432 adapter->hw.back = &adapter->osdep; 2433 2434 /* 2435 ** Now setup MSI or MSI/X, should 2436 ** return us the number of supported 2437 ** vectors. (Will be 1 for MSI) 2438 */ 2439 adapter->msix = ixgbe_setup_msix(adapter); 2440 return (0); 2441 } 2442 2443 static void 2444 ixgbe_free_pci_resources(struct adapter * adapter) 2445 { 2446 struct ix_queue *que = adapter->queues; 2447 int rid; 2448 2449 /* 2450 ** Release all msix queue resources: 2451 */ 2452 for (int i = 0; i < adapter->num_queues; i++, que++) { 2453 if (que->res != NULL) 2454 pci_intr_disestablish(adapter->osdep.pc, 2455 adapter->osdep.ihs[i]); 2456 } 2457 2458 /* Clean the Legacy or Link interrupt last */ 2459 if (adapter->linkvec) /* we are doing MSIX */ 2460 rid = adapter->linkvec; 2461 else 2462 rid = 0; 2463 2464 if (adapter->osdep.ihs[rid] != NULL) { 2465 pci_intr_disestablish(adapter->osdep.pc, 2466 adapter->osdep.ihs[rid]); 2467 adapter->osdep.ihs[rid] = NULL; 2468 } 2469 2470 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 2471 adapter->osdep.nintrs); 2472 2473 if (adapter->osdep.mem_size != 0) { 2474 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 2475 adapter->osdep.mem_bus_space_handle, 2476 adapter->osdep.mem_size); 2477 } 2478 2479 return; 2480 } 2481 2482 /********************************************************************* 2483 * 2484 * Setup networking device structure and register an interface. 2485 * 2486 **********************************************************************/ 2487 static int 2488 ixgbe_setup_interface(device_t dev, struct adapter *adapter) 2489 { 2490 struct ethercom *ec = &adapter->osdep.ec; 2491 struct ixgbe_hw *hw = &adapter->hw; 2492 struct ifnet *ifp; 2493 2494 INIT_DEBUGOUT("ixgbe_setup_interface: begin"); 2495 2496 ifp = adapter->ifp = &ec->ec_if; 2497 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 2498 ifp->if_baudrate = IF_Gbps(10); 2499 ifp->if_init = ixgbe_init; 2500 ifp->if_stop = ixgbe_ifstop; 2501 ifp->if_softc = adapter; 2502 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 2503 ifp->if_ioctl = ixgbe_ioctl; 2504 #ifndef IXGBE_LEGACY_TX 2505 ifp->if_transmit = ixgbe_mq_start; 2506 ifp->if_qflush = ixgbe_qflush; 2507 #else 2508 ifp->if_start = ixgbe_start; 2509 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 2510 #if 0 2511 ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 2; 2512 #endif 2513 IFQ_SET_READY(&ifp->if_snd); 2514 #endif 2515 2516 if_initialize(ifp); 2517 ether_ifattach(ifp, adapter->hw.mac.addr); 2518 if_register(ifp); 2519 ether_set_ifflags_cb(ec, ixgbe_ifflags_cb); 2520 2521 adapter->max_frame_size = 2522 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 2523 2524 /* 2525 * Tell the upper layer(s) we support long frames. 2526 */ 2527 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 2528 2529 ifp->if_capabilities |= IFCAP_HWCSUM | IFCAP_TSOv4 | IFCAP_TSOv6; 2530 ifp->if_capenable = 0; 2531 2532 ec->ec_capabilities |= ETHERCAP_VLAN_HWCSUM; 2533 ec->ec_capabilities |= ETHERCAP_JUMBO_MTU; 2534 ifp->if_capabilities |= IFCAP_LRO; 2535 ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING 2536 | ETHERCAP_VLAN_MTU; 2537 ec->ec_capenable = ec->ec_capabilities; 2538 2539 /* 2540 ** Don't turn this on by default, if vlans are 2541 ** created on another pseudo device (eg. lagg) 2542 ** then vlan events are not passed thru, breaking 2543 ** operation, but with HW FILTER off it works. If 2544 ** using vlans directly on the ixgbe driver you can 2545 ** enable this and get full hardware tag filtering. 2546 */ 2547 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER; 2548 2549 /* 2550 * Specify the media types supported by this adapter and register 2551 * callbacks to update media and link information 2552 */ 2553 ifmedia_init(&adapter->media, IFM_IMASK, ixgbe_media_change, 2554 ixgbe_media_status); 2555 ifmedia_add(&adapter->media, IFM_ETHER | adapter->optics, 0, NULL); 2556 ifmedia_set(&adapter->media, IFM_ETHER | adapter->optics); 2557 if (hw->device_id == IXGBE_DEV_ID_82598AT) { 2558 ifmedia_add(&adapter->media, 2559 IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL); 2560 ifmedia_add(&adapter->media, 2561 IFM_ETHER | IFM_1000_T, 0, NULL); 2562 } 2563 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 2564 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 2565 2566 return (0); 2567 } 2568 2569 static void 2570 ixgbe_config_link(struct adapter *adapter) 2571 { 2572 struct ixgbe_hw *hw = &adapter->hw; 2573 u32 autoneg, err = 0; 2574 bool sfp, negotiate; 2575 2576 sfp = ixgbe_is_sfp(hw); 2577 2578 if (sfp) { 2579 void *ip; 2580 2581 if (hw->phy.multispeed_fiber) { 2582 hw->mac.ops.setup_sfp(hw); 2583 ixgbe_enable_tx_laser(hw); 2584 ip = adapter->msf_si; 2585 } else { 2586 ip = adapter->mod_si; 2587 } 2588 2589 kpreempt_disable(); 2590 softint_schedule(ip); 2591 kpreempt_enable(); 2592 } else { 2593 if (hw->mac.ops.check_link) 2594 err = ixgbe_check_link(hw, &adapter->link_speed, 2595 &adapter->link_up, FALSE); 2596 if (err) 2597 goto out; 2598 autoneg = hw->phy.autoneg_advertised; 2599 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 2600 err = hw->mac.ops.get_link_capabilities(hw, 2601 &autoneg, &negotiate); 2602 else 2603 negotiate = 0; 2604 if (err) 2605 goto out; 2606 if (hw->mac.ops.setup_link) 2607 err = hw->mac.ops.setup_link(hw, 2608 autoneg, adapter->link_up); 2609 } 2610 out: 2611 return; 2612 } 2613 2614 /********************************************************************* 2615 * 2616 * Enable transmit unit. 2617 * 2618 **********************************************************************/ 2619 static void 2620 ixgbe_initialize_transmit_units(struct adapter *adapter) 2621 { 2622 struct tx_ring *txr = adapter->tx_rings; 2623 struct ixgbe_hw *hw = &adapter->hw; 2624 2625 /* Setup the Base and Length of the Tx Descriptor Ring */ 2626 2627 for (int i = 0; i < adapter->num_queues; i++, txr++) { 2628 u64 tdba = txr->txdma.dma_paddr; 2629 u32 txctrl; 2630 2631 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(i), 2632 (tdba & 0x00000000ffffffffULL)); 2633 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(i), (tdba >> 32)); 2634 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(i), 2635 adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc)); 2636 2637 /* Setup the HW Tx Head and Tail descriptor pointers */ 2638 IXGBE_WRITE_REG(hw, IXGBE_TDH(i), 0); 2639 IXGBE_WRITE_REG(hw, IXGBE_TDT(i), 0); 2640 2641 /* Setup Transmit Descriptor Cmd Settings */ 2642 txr->txd_cmd = IXGBE_TXD_CMD_IFCS; 2643 txr->queue_status = IXGBE_QUEUE_IDLE; 2644 2645 /* Set the processing limit */ 2646 txr->process_limit = ixgbe_tx_process_limit; 2647 2648 /* Disable Head Writeback */ 2649 switch (hw->mac.type) { 2650 case ixgbe_mac_82598EB: 2651 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i)); 2652 break; 2653 case ixgbe_mac_82599EB: 2654 case ixgbe_mac_X540: 2655 default: 2656 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(i)); 2657 break; 2658 } 2659 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 2660 switch (hw->mac.type) { 2661 case ixgbe_mac_82598EB: 2662 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), txctrl); 2663 break; 2664 case ixgbe_mac_82599EB: 2665 case ixgbe_mac_X540: 2666 default: 2667 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(i), txctrl); 2668 break; 2669 } 2670 2671 } 2672 2673 if (hw->mac.type != ixgbe_mac_82598EB) { 2674 u32 dmatxctl, rttdcs; 2675 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL); 2676 dmatxctl |= IXGBE_DMATXCTL_TE; 2677 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl); 2678 /* Disable arbiter to set MTQC */ 2679 rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS); 2680 rttdcs |= IXGBE_RTTDCS_ARBDIS; 2681 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 2682 IXGBE_WRITE_REG(hw, IXGBE_MTQC, IXGBE_MTQC_64Q_1PB); 2683 rttdcs &= ~IXGBE_RTTDCS_ARBDIS; 2684 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 2685 } 2686 2687 return; 2688 } 2689 2690 static void 2691 ixgbe_initialise_rss_mapping(struct adapter *adapter) 2692 { 2693 struct ixgbe_hw *hw = &adapter->hw; 2694 uint32_t reta; 2695 int i, j, queue_id; 2696 uint32_t rss_key[10]; 2697 uint32_t mrqc; 2698 #ifdef RSS 2699 uint32_t rss_hash_config; 2700 #endif 2701 2702 /* Setup RSS */ 2703 reta = 0; 2704 2705 #ifdef RSS 2706 /* Fetch the configured RSS key */ 2707 rss_getkey((uint8_t *) &rss_key); 2708 #else 2709 /* set up random bits */ 2710 cprng_fast(&rss_key, sizeof(rss_key)); 2711 #endif 2712 2713 /* Set up the redirection table */ 2714 for (i = 0, j = 0; i < 128; i++, j++) { 2715 if (j == adapter->num_queues) j = 0; 2716 #ifdef RSS 2717 /* 2718 * Fetch the RSS bucket id for the given indirection entry. 2719 * Cap it at the number of configured buckets (which is 2720 * num_queues.) 2721 */ 2722 queue_id = rss_get_indirection_to_bucket(i); 2723 queue_id = queue_id % adapter->num_queues; 2724 #else 2725 queue_id = (j * 0x11); 2726 #endif 2727 /* 2728 * The low 8 bits are for hash value (n+0); 2729 * The next 8 bits are for hash value (n+1), etc. 2730 */ 2731 reta = reta >> 8; 2732 reta = reta | ( ((uint32_t) queue_id) << 24); 2733 if ((i & 3) == 3) { 2734 IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta); 2735 reta = 0; 2736 } 2737 } 2738 2739 /* Now fill our hash function seeds */ 2740 for (i = 0; i < 10; i++) 2741 IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), rss_key[i]); 2742 2743 /* Perform hash on these packet types */ 2744 #ifdef RSS 2745 mrqc = IXGBE_MRQC_RSSEN; 2746 rss_hash_config = rss_gethashconfig(); 2747 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 2748 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 2749 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 2750 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 2751 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 2752 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 2753 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 2754 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 2755 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 2756 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX; 2757 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 2758 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP; 2759 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 2760 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 2761 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4_EX) 2762 device_printf(adapter->dev, 2763 "%s: RSS_HASHTYPE_RSS_UDP_IPV4_EX defined, " 2764 "but not supported\n", __func__); 2765 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 2766 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 2767 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 2768 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP; 2769 #else 2770 /* 2771 * Disable UDP - IP fragments aren't currently being handled 2772 * and so we end up with a mix of 2-tuple and 4-tuple 2773 * traffic. 2774 */ 2775 mrqc = IXGBE_MRQC_RSSEN 2776 | IXGBE_MRQC_RSS_FIELD_IPV4 2777 | IXGBE_MRQC_RSS_FIELD_IPV4_TCP 2778 #if 0 2779 | IXGBE_MRQC_RSS_FIELD_IPV4_UDP 2780 #endif 2781 | IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP 2782 | IXGBE_MRQC_RSS_FIELD_IPV6_EX 2783 | IXGBE_MRQC_RSS_FIELD_IPV6 2784 | IXGBE_MRQC_RSS_FIELD_IPV6_TCP 2785 #if 0 2786 | IXGBE_MRQC_RSS_FIELD_IPV6_UDP 2787 | IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP 2788 #endif 2789 ; 2790 #endif /* RSS */ 2791 IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc); 2792 } 2793 2794 2795 /********************************************************************* 2796 * 2797 * Setup receive registers and features. 2798 * 2799 **********************************************************************/ 2800 #define IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT 2 2801 2802 #define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1) 2803 2804 static void 2805 ixgbe_initialize_receive_units(struct adapter *adapter) 2806 { 2807 int i; 2808 struct rx_ring *rxr = adapter->rx_rings; 2809 struct ixgbe_hw *hw = &adapter->hw; 2810 struct ifnet *ifp = adapter->ifp; 2811 u32 bufsz, rxctrl, fctrl, srrctl, rxcsum; 2812 u32 hlreg; 2813 2814 2815 /* 2816 * Make sure receives are disabled while 2817 * setting up the descriptor ring 2818 */ 2819 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 2820 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, 2821 rxctrl & ~IXGBE_RXCTRL_RXEN); 2822 2823 /* Enable broadcasts */ 2824 fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL); 2825 fctrl |= IXGBE_FCTRL_BAM; 2826 fctrl |= IXGBE_FCTRL_DPF; 2827 fctrl |= IXGBE_FCTRL_PMCF; 2828 IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl); 2829 2830 /* Set for Jumbo Frames? */ 2831 hlreg = IXGBE_READ_REG(hw, IXGBE_HLREG0); 2832 if (ifp->if_mtu > ETHERMTU) 2833 hlreg |= IXGBE_HLREG0_JUMBOEN; 2834 else 2835 hlreg &= ~IXGBE_HLREG0_JUMBOEN; 2836 #ifdef DEV_NETMAP 2837 /* crcstrip is conditional in netmap (in RDRXCTL too ?) */ 2838 if (ifp->if_capenable & IFCAP_NETMAP && !ix_crcstrip) 2839 hlreg &= ~IXGBE_HLREG0_RXCRCSTRP; 2840 else 2841 hlreg |= IXGBE_HLREG0_RXCRCSTRP; 2842 #endif /* DEV_NETMAP */ 2843 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg); 2844 2845 bufsz = (adapter->rx_mbuf_sz + 2846 BSIZEPKT_ROUNDUP) >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 2847 2848 for (i = 0; i < adapter->num_queues; i++, rxr++) { 2849 u64 rdba = rxr->rxdma.dma_paddr; 2850 2851 /* Setup the Base and Length of the Rx Descriptor Ring */ 2852 IXGBE_WRITE_REG(hw, IXGBE_RDBAL(i), 2853 (rdba & 0x00000000ffffffffULL)); 2854 IXGBE_WRITE_REG(hw, IXGBE_RDBAH(i), (rdba >> 32)); 2855 IXGBE_WRITE_REG(hw, IXGBE_RDLEN(i), 2856 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 2857 2858 /* Set up the SRRCTL register */ 2859 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(i)); 2860 srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 2861 srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 2862 srrctl |= bufsz; 2863 srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 2864 2865 /* 2866 * Set DROP_EN iff we have no flow control and >1 queue. 2867 * Note that srrctl was cleared shortly before during reset, 2868 * so we do not need to clear the bit, but do it just in case 2869 * this code is moved elsewhere. 2870 */ 2871 if (adapter->num_queues > 1 && 2872 adapter->fc == ixgbe_fc_none) { 2873 srrctl |= IXGBE_SRRCTL_DROP_EN; 2874 } else { 2875 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 2876 } 2877 2878 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(i), srrctl); 2879 2880 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2881 IXGBE_WRITE_REG(hw, IXGBE_RDH(i), 0); 2882 IXGBE_WRITE_REG(hw, IXGBE_RDT(i), 0); 2883 2884 /* Set the processing limit */ 2885 rxr->process_limit = ixgbe_rx_process_limit; 2886 } 2887 2888 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 2889 u32 psrtype = IXGBE_PSRTYPE_TCPHDR | 2890 IXGBE_PSRTYPE_UDPHDR | 2891 IXGBE_PSRTYPE_IPV4HDR | 2892 IXGBE_PSRTYPE_IPV6HDR; 2893 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype); 2894 } 2895 2896 rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM); 2897 2898 ixgbe_initialise_rss_mapping(adapter); 2899 2900 if (adapter->num_queues > 1) { 2901 /* RSS and RX IPP Checksum are mutually exclusive */ 2902 rxcsum |= IXGBE_RXCSUM_PCSD; 2903 } 2904 2905 if (ifp->if_capenable & IFCAP_RXCSUM) 2906 rxcsum |= IXGBE_RXCSUM_PCSD; 2907 2908 if (!(rxcsum & IXGBE_RXCSUM_PCSD)) 2909 rxcsum |= IXGBE_RXCSUM_IPPCSE; 2910 2911 IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum); 2912 2913 return; 2914 } 2915 2916 #if 0 /* XXX Badly need to overhaul vlan(4) on NetBSD. */ 2917 /* 2918 ** This routine is run via an vlan config EVENT, 2919 ** it enables us to use the HW Filter table since 2920 ** we can get the vlan id. This just creates the 2921 ** entry in the soft version of the VFTA, init will 2922 ** repopulate the real table. 2923 */ 2924 static void 2925 ixgbe_register_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2926 { 2927 struct adapter *adapter = ifp->if_softc; 2928 u16 index, bit; 2929 2930 if (ifp->if_softc != arg) /* Not our event */ 2931 return; 2932 2933 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2934 return; 2935 2936 IXGBE_CORE_LOCK(adapter); 2937 index = (vtag >> 5) & 0x7F; 2938 bit = vtag & 0x1F; 2939 adapter->shadow_vfta[index] |= (1 << bit); 2940 ixgbe_setup_vlan_hw_support(adapter); 2941 IXGBE_CORE_UNLOCK(adapter); 2942 } 2943 2944 /* 2945 ** This routine is run via an vlan 2946 ** unconfig EVENT, remove our entry 2947 ** in the soft vfta. 2948 */ 2949 static void 2950 ixgbe_unregister_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2951 { 2952 struct adapter *adapter = ifp->if_softc; 2953 u16 index, bit; 2954 2955 if (ifp->if_softc != arg) 2956 return; 2957 2958 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2959 return; 2960 2961 IXGBE_CORE_LOCK(adapter); 2962 index = (vtag >> 5) & 0x7F; 2963 bit = vtag & 0x1F; 2964 adapter->shadow_vfta[index] &= ~(1 << bit); 2965 /* Re-init to load the changes */ 2966 ixgbe_setup_vlan_hw_support(adapter); 2967 IXGBE_CORE_UNLOCK(adapter); 2968 } 2969 #endif 2970 2971 static void 2972 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2973 { 2974 struct ethercom *ec = &adapter->osdep.ec; 2975 struct ixgbe_hw *hw = &adapter->hw; 2976 struct rx_ring *rxr; 2977 u32 ctrl; 2978 2979 2980 /* 2981 ** We get here thru init_locked, meaning 2982 ** a soft reset, this has already cleared 2983 ** the VFTA and other state, so if there 2984 ** have been no vlan's registered do nothing. 2985 */ 2986 if (!VLAN_ATTACHED(&adapter->osdep.ec)) { 2987 return; 2988 } 2989 2990 /* Setup the queues for vlans */ 2991 for (int i = 0; i < adapter->num_queues; i++) { 2992 rxr = &adapter->rx_rings[i]; 2993 /* On 82599 the VLAN enable is per/queue in RXDCTL */ 2994 if (hw->mac.type != ixgbe_mac_82598EB) { 2995 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(i)); 2996 ctrl |= IXGBE_RXDCTL_VME; 2997 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(i), ctrl); 2998 } 2999 rxr->vtag_strip = TRUE; 3000 } 3001 3002 if ((ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) == 0) 3003 return; 3004 /* 3005 ** A soft reset zero's out the VFTA, so 3006 ** we need to repopulate it now. 3007 */ 3008 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) 3009 if (adapter->shadow_vfta[i] != 0) 3010 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 3011 adapter->shadow_vfta[i]); 3012 3013 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 3014 /* Enable the Filter Table if enabled */ 3015 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) { 3016 ctrl &= ~IXGBE_VLNCTRL_CFIEN; 3017 ctrl |= IXGBE_VLNCTRL_VFE; 3018 } 3019 if (hw->mac.type == ixgbe_mac_82598EB) 3020 ctrl |= IXGBE_VLNCTRL_VME; 3021 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 3022 } 3023 3024 static void 3025 ixgbe_enable_intr(struct adapter *adapter) 3026 { 3027 struct ixgbe_hw *hw = &adapter->hw; 3028 struct ix_queue *que = adapter->queues; 3029 u32 mask, fwsm; 3030 3031 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 3032 /* Enable Fan Failure detection */ 3033 if (hw->device_id == IXGBE_DEV_ID_82598AT) 3034 mask |= IXGBE_EIMS_GPI_SDP1; 3035 3036 switch (adapter->hw.mac.type) { 3037 case ixgbe_mac_82599EB: 3038 mask |= IXGBE_EIMS_ECC; 3039 mask |= IXGBE_EIMS_GPI_SDP0; 3040 mask |= IXGBE_EIMS_GPI_SDP1; 3041 mask |= IXGBE_EIMS_GPI_SDP2; 3042 #ifdef IXGBE_FDIR 3043 mask |= IXGBE_EIMS_FLOW_DIR; 3044 #endif 3045 break; 3046 case ixgbe_mac_X540: 3047 mask |= IXGBE_EIMS_ECC; 3048 /* Detect if Thermal Sensor is enabled */ 3049 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 3050 if (fwsm & IXGBE_FWSM_TS_ENABLED) 3051 mask |= IXGBE_EIMS_TS; 3052 #ifdef IXGBE_FDIR 3053 mask |= IXGBE_EIMS_FLOW_DIR; 3054 #endif 3055 /* falls through */ 3056 default: 3057 break; 3058 } 3059 3060 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 3061 3062 /* With RSS we use auto clear */ 3063 if (adapter->msix_mem) { 3064 mask = IXGBE_EIMS_ENABLE_MASK; 3065 /* Don't autoclear Link */ 3066 mask &= ~IXGBE_EIMS_OTHER; 3067 mask &= ~IXGBE_EIMS_LSC; 3068 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 3069 } 3070 3071 /* 3072 ** Now enable all queues, this is done separately to 3073 ** allow for handling the extended (beyond 32) MSIX 3074 ** vectors that can be used by 82599 3075 */ 3076 for (int i = 0; i < adapter->num_queues; i++, que++) 3077 ixgbe_enable_queue(adapter, que->msix); 3078 3079 IXGBE_WRITE_FLUSH(hw); 3080 3081 return; 3082 } 3083 3084 static void 3085 ixgbe_disable_intr(struct adapter *adapter) 3086 { 3087 if (adapter->msix_mem) 3088 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 3089 if (adapter->hw.mac.type == ixgbe_mac_82598EB) { 3090 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0); 3091 } else { 3092 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, 0xFFFF0000); 3093 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(0), ~0); 3094 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(1), ~0); 3095 } 3096 IXGBE_WRITE_FLUSH(&adapter->hw); 3097 return; 3098 } 3099 3100 u16 3101 ixgbe_read_pci_cfg(struct ixgbe_hw *hw, u32 reg) 3102 { 3103 switch (reg % 4) { 3104 case 0: 3105 return pci_conf_read(hw->back->pc, hw->back->tag, reg) & 3106 __BITS(15, 0); 3107 case 2: 3108 return __SHIFTOUT(pci_conf_read(hw->back->pc, hw->back->tag, 3109 reg - 2), __BITS(31, 16)); 3110 default: 3111 panic("%s: invalid register (%" PRIx32, __func__, reg); 3112 break; 3113 } 3114 } 3115 3116 void 3117 ixgbe_write_pci_cfg(struct ixgbe_hw *hw, u32 reg, u16 value) 3118 { 3119 pcireg_t old; 3120 3121 switch (reg % 4) { 3122 case 0: 3123 old = pci_conf_read(hw->back->pc, hw->back->tag, reg) & 3124 __BITS(31, 16); 3125 pci_conf_write(hw->back->pc, hw->back->tag, reg, value | old); 3126 break; 3127 case 2: 3128 old = pci_conf_read(hw->back->pc, hw->back->tag, reg - 2) & 3129 __BITS(15, 0); 3130 pci_conf_write(hw->back->pc, hw->back->tag, reg - 2, 3131 __SHIFTIN(value, __BITS(31, 16)) | old); 3132 break; 3133 default: 3134 panic("%s: invalid register (%" PRIx32, __func__, reg); 3135 break; 3136 } 3137 3138 return; 3139 } 3140 3141 /* 3142 ** Get the width and transaction speed of 3143 ** the slot this adapter is plugged into. 3144 */ 3145 static void 3146 ixgbe_get_slot_info(struct ixgbe_hw *hw) 3147 { 3148 device_t dev = ((struct ixgbe_osdep *)hw->back)->dev; 3149 struct ixgbe_mac_info *mac = &hw->mac; 3150 u16 link; 3151 3152 /* For most devices simply call the shared code routine */ 3153 if (hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) { 3154 ixgbe_get_bus_info(hw); 3155 goto display; 3156 } 3157 3158 /* 3159 ** For the Quad port adapter we need to parse back 3160 ** up the PCI tree to find the speed of the expansion 3161 ** slot into which this adapter is plugged. A bit more work. 3162 */ 3163 dev = device_parent(device_parent(dev)); 3164 #ifdef IXGBE_DEBUG 3165 device_printf(dev, "parent pcib = %x,%x,%x\n", 3166 pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev)); 3167 #endif 3168 dev = device_parent(device_parent(dev)); 3169 #ifdef IXGBE_DEBUG 3170 device_printf(dev, "slot pcib = %x,%x,%x\n", 3171 pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev)); 3172 #endif 3173 /* Now get the PCI Express Capabilities offset */ 3174 /* ...and read the Link Status Register */ 3175 link = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_LINK_STATUS); 3176 switch (link & IXGBE_PCI_LINK_WIDTH) { 3177 case IXGBE_PCI_LINK_WIDTH_1: 3178 hw->bus.width = ixgbe_bus_width_pcie_x1; 3179 break; 3180 case IXGBE_PCI_LINK_WIDTH_2: 3181 hw->bus.width = ixgbe_bus_width_pcie_x2; 3182 break; 3183 case IXGBE_PCI_LINK_WIDTH_4: 3184 hw->bus.width = ixgbe_bus_width_pcie_x4; 3185 break; 3186 case IXGBE_PCI_LINK_WIDTH_8: 3187 hw->bus.width = ixgbe_bus_width_pcie_x8; 3188 break; 3189 default: 3190 hw->bus.width = ixgbe_bus_width_unknown; 3191 break; 3192 } 3193 3194 switch (link & IXGBE_PCI_LINK_SPEED) { 3195 case IXGBE_PCI_LINK_SPEED_2500: 3196 hw->bus.speed = ixgbe_bus_speed_2500; 3197 break; 3198 case IXGBE_PCI_LINK_SPEED_5000: 3199 hw->bus.speed = ixgbe_bus_speed_5000; 3200 break; 3201 case IXGBE_PCI_LINK_SPEED_8000: 3202 hw->bus.speed = ixgbe_bus_speed_8000; 3203 break; 3204 default: 3205 hw->bus.speed = ixgbe_bus_speed_unknown; 3206 break; 3207 } 3208 3209 mac->ops.set_lan_id(hw); 3210 3211 display: 3212 device_printf(dev,"PCI Express Bus: Speed %s %s\n", 3213 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s": 3214 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s": 3215 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s":"Unknown"), 3216 (hw->bus.width == ixgbe_bus_width_pcie_x8) ? "Width x8" : 3217 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "Width x4" : 3218 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "Width x1" : 3219 ("Unknown")); 3220 3221 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 3222 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 3223 (hw->bus.speed == ixgbe_bus_speed_2500))) { 3224 device_printf(dev, "PCI-Express bandwidth available" 3225 " for this card\n is not sufficient for" 3226 " optimal performance.\n"); 3227 device_printf(dev, "For optimal performance a x8 " 3228 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 3229 } 3230 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 3231 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 3232 (hw->bus.speed < ixgbe_bus_speed_8000))) { 3233 device_printf(dev, "PCI-Express bandwidth available" 3234 " for this card\n is not sufficient for" 3235 " optimal performance.\n"); 3236 device_printf(dev, "For optimal performance a x8 " 3237 "PCIE Gen3 slot is required.\n"); 3238 } 3239 3240 return; 3241 } 3242 3243 3244 /* 3245 ** Setup the correct IVAR register for a particular MSIX interrupt 3246 ** (yes this is all very magic and confusing :) 3247 ** - entry is the register array entry 3248 ** - vector is the MSIX vector for this queue 3249 ** - type is RX/TX/MISC 3250 */ 3251 static void 3252 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 3253 { 3254 struct ixgbe_hw *hw = &adapter->hw; 3255 u32 ivar, index; 3256 3257 vector |= IXGBE_IVAR_ALLOC_VAL; 3258 3259 switch (hw->mac.type) { 3260 3261 case ixgbe_mac_82598EB: 3262 if (type == -1) 3263 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 3264 else 3265 entry += (type * 64); 3266 index = (entry >> 2) & 0x1F; 3267 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 3268 ivar &= ~(0xFF << (8 * (entry & 0x3))); 3269 ivar |= (vector << (8 * (entry & 0x3))); 3270 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 3271 break; 3272 3273 case ixgbe_mac_82599EB: 3274 case ixgbe_mac_X540: 3275 if (type == -1) { /* MISC IVAR */ 3276 index = (entry & 1) * 8; 3277 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 3278 ivar &= ~(0xFF << index); 3279 ivar |= (vector << index); 3280 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 3281 } else { /* RX/TX IVARS */ 3282 index = (16 * (entry & 1)) + (8 * type); 3283 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 3284 ivar &= ~(0xFF << index); 3285 ivar |= (vector << index); 3286 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 3287 } 3288 3289 default: 3290 break; 3291 } 3292 } 3293 3294 static void 3295 ixgbe_configure_ivars(struct adapter *adapter) 3296 { 3297 struct ix_queue *que = adapter->queues; 3298 u32 newitr; 3299 3300 if (ixgbe_max_interrupt_rate > 0) 3301 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 3302 else 3303 newitr = 0; 3304 3305 for (int i = 0; i < adapter->num_queues; i++, que++) { 3306 /* First the RX queue entry */ 3307 ixgbe_set_ivar(adapter, i, que->msix, 0); 3308 /* ... and the TX */ 3309 ixgbe_set_ivar(adapter, i, que->msix, 1); 3310 /* Set an Initial EITR value */ 3311 IXGBE_WRITE_REG(&adapter->hw, 3312 IXGBE_EITR(que->msix), newitr); 3313 } 3314 3315 /* For the Link interrupt */ 3316 ixgbe_set_ivar(adapter, 1, adapter->linkvec, -1); 3317 } 3318 3319 /* 3320 ** ixgbe_sfp_probe - called in the local timer to 3321 ** determine if a port had optics inserted. 3322 */ 3323 static bool ixgbe_sfp_probe(struct adapter *adapter) 3324 { 3325 struct ixgbe_hw *hw = &adapter->hw; 3326 device_t dev = adapter->dev; 3327 bool result = FALSE; 3328 3329 if ((hw->phy.type == ixgbe_phy_nl) && 3330 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 3331 s32 ret = hw->phy.ops.identify_sfp(hw); 3332 if (ret) 3333 goto out; 3334 ret = hw->phy.ops.reset(hw); 3335 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3336 device_printf(dev,"Unsupported SFP+ module detected!"); 3337 device_printf(dev, "Reload driver with supported module.\n"); 3338 adapter->sfp_probe = FALSE; 3339 goto out; 3340 } else 3341 device_printf(dev,"SFP+ module detected!\n"); 3342 /* We now have supported optics */ 3343 adapter->sfp_probe = FALSE; 3344 /* Set the optics type so system reports correctly */ 3345 ixgbe_setup_optics(adapter); 3346 result = TRUE; 3347 } 3348 out: 3349 return (result); 3350 } 3351 3352 /* 3353 ** Tasklet handler for MSIX Link interrupts 3354 ** - do outside interrupt since it might sleep 3355 */ 3356 static void 3357 ixgbe_handle_link(void *context) 3358 { 3359 struct adapter *adapter = context; 3360 3361 if (ixgbe_check_link(&adapter->hw, 3362 &adapter->link_speed, &adapter->link_up, 0) == 0) 3363 ixgbe_update_link_status(adapter); 3364 } 3365 3366 /* 3367 ** Tasklet for handling SFP module interrupts 3368 */ 3369 static void 3370 ixgbe_handle_mod(void *context) 3371 { 3372 struct adapter *adapter = context; 3373 struct ixgbe_hw *hw = &adapter->hw; 3374 device_t dev = adapter->dev; 3375 u32 err; 3376 3377 err = hw->phy.ops.identify_sfp(hw); 3378 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3379 device_printf(dev, 3380 "Unsupported SFP+ module type was detected.\n"); 3381 return; 3382 } 3383 err = hw->mac.ops.setup_sfp(hw); 3384 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3385 device_printf(dev, 3386 "Setup failure - unsupported SFP+ module type.\n"); 3387 return; 3388 } 3389 softint_schedule(adapter->msf_si); 3390 return; 3391 } 3392 3393 3394 /* 3395 ** Tasklet for handling MSF (multispeed fiber) interrupts 3396 */ 3397 static void 3398 ixgbe_handle_msf(void *context) 3399 { 3400 struct adapter *adapter = context; 3401 struct ixgbe_hw *hw = &adapter->hw; 3402 u32 autoneg; 3403 bool negotiate; 3404 3405 autoneg = hw->phy.autoneg_advertised; 3406 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 3407 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 3408 else 3409 negotiate = 0; 3410 if (hw->mac.ops.setup_link) 3411 hw->mac.ops.setup_link(hw, autoneg, TRUE); 3412 return; 3413 } 3414 3415 #ifdef IXGBE_FDIR 3416 /* 3417 ** Tasklet for reinitializing the Flow Director filter table 3418 */ 3419 static void 3420 ixgbe_reinit_fdir(void *context) 3421 { 3422 struct adapter *adapter = context; 3423 struct ifnet *ifp = adapter->ifp; 3424 3425 if (adapter->fdir_reinit != 1) /* Shouldn't happen */ 3426 return; 3427 ixgbe_reinit_fdir_tables_82599(&adapter->hw); 3428 adapter->fdir_reinit = 0; 3429 /* re-enable flow director interrupts */ 3430 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, IXGBE_EIMS_FLOW_DIR); 3431 /* Restart the interface */ 3432 ifp->if_flags |= IFF_RUNNING; 3433 return; 3434 } 3435 #endif 3436 3437 /********************************************************************** 3438 * 3439 * Update the board statistics counters. 3440 * 3441 **********************************************************************/ 3442 static void 3443 ixgbe_update_stats_counters(struct adapter *adapter) 3444 { 3445 struct ifnet *ifp = adapter->ifp; 3446 struct ixgbe_hw *hw = &adapter->hw; 3447 u32 missed_rx = 0, bprc, lxon, lxoff, total; 3448 u64 total_missed_rx = 0; 3449 uint64_t crcerrs, rlec; 3450 3451 crcerrs = IXGBE_READ_REG(hw, IXGBE_CRCERRS); 3452 adapter->stats.crcerrs.ev_count += crcerrs; 3453 adapter->stats.illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 3454 adapter->stats.errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 3455 adapter->stats.mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 3456 3457 /* 3458 ** Note: these are for the 8 possible traffic classes, 3459 ** which in current implementation is unused, 3460 ** therefore only 0 should read real data. 3461 */ 3462 for (int i = 0; i < __arraycount(adapter->stats.mpc); i++) { 3463 int j = i % adapter->num_queues; 3464 u32 mp; 3465 mp = IXGBE_READ_REG(hw, IXGBE_MPC(i)); 3466 /* missed_rx tallies misses for the gprc workaround */ 3467 missed_rx += mp; 3468 /* global total per queue */ 3469 adapter->stats.mpc[j].ev_count += mp; 3470 /* Running comprehensive total for stats display */ 3471 total_missed_rx += mp; 3472 if (hw->mac.type == ixgbe_mac_82598EB) { 3473 adapter->stats.rnbc[j] += 3474 IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 3475 adapter->stats.qbtc[j].ev_count += 3476 IXGBE_READ_REG(hw, IXGBE_QBTC(i)); 3477 adapter->stats.qbrc[j].ev_count += 3478 IXGBE_READ_REG(hw, IXGBE_QBRC(i)); 3479 adapter->stats.pxonrxc[j].ev_count += 3480 IXGBE_READ_REG(hw, IXGBE_PXONRXC(i)); 3481 } else { 3482 adapter->stats.pxonrxc[j].ev_count += 3483 IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i)); 3484 } 3485 adapter->stats.pxontxc[j].ev_count += 3486 IXGBE_READ_REG(hw, IXGBE_PXONTXC(i)); 3487 adapter->stats.pxofftxc[j].ev_count += 3488 IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i)); 3489 adapter->stats.pxoffrxc[j].ev_count += 3490 IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i)); 3491 adapter->stats.pxon2offc[j].ev_count += 3492 IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i)); 3493 } 3494 for (int i = 0; i < __arraycount(adapter->stats.qprc); i++) { 3495 int j = i % adapter->num_queues; 3496 adapter->stats.qprc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 3497 adapter->stats.qptc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 3498 adapter->stats.qprdc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 3499 } 3500 adapter->stats.mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 3501 adapter->stats.mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 3502 rlec = IXGBE_READ_REG(hw, IXGBE_RLEC); 3503 adapter->stats.rlec.ev_count += rlec; 3504 3505 /* Hardware workaround, gprc counts missed packets */ 3506 adapter->stats.gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 3507 3508 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 3509 adapter->stats.lxontxc.ev_count += lxon; 3510 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 3511 adapter->stats.lxofftxc.ev_count += lxoff; 3512 total = lxon + lxoff; 3513 3514 if (hw->mac.type != ixgbe_mac_82598EB) { 3515 adapter->stats.gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 3516 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 3517 adapter->stats.gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 3518 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) - total * ETHER_MIN_LEN; 3519 adapter->stats.tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 3520 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 3521 adapter->stats.lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 3522 adapter->stats.lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 3523 } else { 3524 adapter->stats.lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 3525 adapter->stats.lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 3526 /* 82598 only has a counter in the high register */ 3527 adapter->stats.gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 3528 adapter->stats.gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) - total * ETHER_MIN_LEN; 3529 adapter->stats.tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 3530 } 3531 3532 /* 3533 * Workaround: mprc hardware is incorrectly counting 3534 * broadcasts, so for now we subtract those. 3535 */ 3536 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 3537 adapter->stats.bprc.ev_count += bprc; 3538 adapter->stats.mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 3539 3540 adapter->stats.prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 3541 adapter->stats.prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 3542 adapter->stats.prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 3543 adapter->stats.prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 3544 adapter->stats.prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 3545 adapter->stats.prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 3546 3547 adapter->stats.gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 3548 adapter->stats.mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 3549 adapter->stats.ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 3550 3551 adapter->stats.ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 3552 adapter->stats.rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 3553 adapter->stats.roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 3554 adapter->stats.rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 3555 adapter->stats.mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 3556 adapter->stats.mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 3557 adapter->stats.mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 3558 adapter->stats.tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 3559 adapter->stats.tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 3560 adapter->stats.ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 3561 adapter->stats.ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 3562 adapter->stats.ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 3563 adapter->stats.ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 3564 adapter->stats.ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 3565 adapter->stats.bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 3566 adapter->stats.xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 3567 adapter->stats.fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 3568 adapter->stats.fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 3569 3570 /* Only read FCOE on 82599 */ 3571 if (hw->mac.type != ixgbe_mac_82598EB) { 3572 adapter->stats.fcoerpdc.ev_count += 3573 IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 3574 adapter->stats.fcoeprc.ev_count += 3575 IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 3576 adapter->stats.fcoeptc.ev_count += 3577 IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 3578 adapter->stats.fcoedwrc.ev_count += 3579 IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 3580 adapter->stats.fcoedwtc.ev_count += 3581 IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 3582 } 3583 3584 /* Fill out the OS statistics structure */ 3585 /* 3586 * NetBSD: Don't override if_{i|o}{packets|bytes|mcasts} with 3587 * adapter->stats counters. It's required to make ifconfig -z 3588 * (SOICZIFDATA) work. 3589 */ 3590 ifp->if_collisions = 0; 3591 3592 /* Rx Errors */ 3593 ifp->if_iqdrops += total_missed_rx; 3594 ifp->if_ierrors += crcerrs + rlec; 3595 } 3596 3597 /** ixgbe_sysctl_tdh_handler - Handler function 3598 * Retrieves the TDH value from the hardware 3599 */ 3600 static int 3601 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 3602 { 3603 struct sysctlnode node; 3604 uint32_t val; 3605 struct tx_ring *txr; 3606 3607 node = *rnode; 3608 txr = (struct tx_ring *)node.sysctl_data; 3609 if (txr == NULL) 3610 return 0; 3611 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDH(txr->me)); 3612 node.sysctl_data = &val; 3613 return sysctl_lookup(SYSCTLFN_CALL(&node)); 3614 } 3615 3616 /** ixgbe_sysctl_tdt_handler - Handler function 3617 * Retrieves the TDT value from the hardware 3618 */ 3619 static int 3620 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 3621 { 3622 struct sysctlnode node; 3623 uint32_t val; 3624 struct tx_ring *txr; 3625 3626 node = *rnode; 3627 txr = (struct tx_ring *)node.sysctl_data; 3628 if (txr == NULL) 3629 return 0; 3630 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDT(txr->me)); 3631 node.sysctl_data = &val; 3632 return sysctl_lookup(SYSCTLFN_CALL(&node)); 3633 } 3634 3635 /** ixgbe_sysctl_rdh_handler - Handler function 3636 * Retrieves the RDH value from the hardware 3637 */ 3638 static int 3639 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 3640 { 3641 struct sysctlnode node; 3642 uint32_t val; 3643 struct rx_ring *rxr; 3644 3645 node = *rnode; 3646 rxr = (struct rx_ring *)node.sysctl_data; 3647 if (rxr == NULL) 3648 return 0; 3649 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDH(rxr->me)); 3650 node.sysctl_data = &val; 3651 return sysctl_lookup(SYSCTLFN_CALL(&node)); 3652 } 3653 3654 /** ixgbe_sysctl_rdt_handler - Handler function 3655 * Retrieves the RDT value from the hardware 3656 */ 3657 static int 3658 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 3659 { 3660 struct sysctlnode node; 3661 uint32_t val; 3662 struct rx_ring *rxr; 3663 3664 node = *rnode; 3665 rxr = (struct rx_ring *)node.sysctl_data; 3666 if (rxr == NULL) 3667 return 0; 3668 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDT(rxr->me)); 3669 node.sysctl_data = &val; 3670 return sysctl_lookup(SYSCTLFN_CALL(&node)); 3671 } 3672 3673 static int 3674 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3675 { 3676 int error; 3677 struct sysctlnode node; 3678 struct ix_queue *que; 3679 uint32_t reg, usec, rate; 3680 3681 node = *rnode; 3682 que = (struct ix_queue *)node.sysctl_data; 3683 if (que == NULL) 3684 return 0; 3685 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_EITR(que->msix)); 3686 usec = ((reg & 0x0FF8) >> 3); 3687 if (usec > 0) 3688 rate = 500000 / usec; 3689 else 3690 rate = 0; 3691 node.sysctl_data = &rate; 3692 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3693 if (error) 3694 return error; 3695 reg &= ~0xfff; /* default, no limitation */ 3696 ixgbe_max_interrupt_rate = 0; 3697 if (rate > 0 && rate < 500000) { 3698 if (rate < 1000) 3699 rate = 1000; 3700 ixgbe_max_interrupt_rate = rate; 3701 reg |= ((4000000/rate) & 0xff8 ); 3702 } 3703 IXGBE_WRITE_REG(&que->adapter->hw, IXGBE_EITR(que->msix), reg); 3704 return 0; 3705 } 3706 3707 const struct sysctlnode * 3708 ixgbe_sysctl_instance(struct adapter *adapter) 3709 { 3710 const char *dvname; 3711 struct sysctllog **log; 3712 int rc; 3713 const struct sysctlnode *rnode; 3714 3715 log = &adapter->sysctllog; 3716 dvname = device_xname(adapter->dev); 3717 3718 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3719 0, CTLTYPE_NODE, dvname, 3720 SYSCTL_DESCR("ixgbe information and settings"), 3721 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3722 goto err; 3723 3724 return rnode; 3725 err: 3726 printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3727 return NULL; 3728 } 3729 3730 /* 3731 * Add sysctl variables, one per statistic, to the system. 3732 */ 3733 static void 3734 ixgbe_add_hw_stats(struct adapter *adapter) 3735 { 3736 device_t dev = adapter->dev; 3737 const struct sysctlnode *rnode, *cnode; 3738 struct sysctllog **log = &adapter->sysctllog; 3739 struct tx_ring *txr = adapter->tx_rings; 3740 struct rx_ring *rxr = adapter->rx_rings; 3741 struct ixgbe_hw_stats *stats = &adapter->stats; 3742 3743 /* Driver Statistics */ 3744 #if 0 3745 /* These counters are not updated by the software */ 3746 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped", 3747 CTLFLAG_RD, &adapter->dropped_pkts, 3748 "Driver dropped packets"); 3749 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_header_failed", 3750 CTLFLAG_RD, &adapter->mbuf_header_failed, 3751 "???"); 3752 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_packet_failed", 3753 CTLFLAG_RD, &adapter->mbuf_packet_failed, 3754 "???"); 3755 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "no_tx_map_avail", 3756 CTLFLAG_RD, &adapter->no_tx_map_avail, 3757 "???"); 3758 #endif 3759 evcnt_attach_dynamic(&adapter->handleq, EVCNT_TYPE_MISC, 3760 NULL, device_xname(dev), "Handled queue in softint"); 3761 evcnt_attach_dynamic(&adapter->req, EVCNT_TYPE_MISC, 3762 NULL, device_xname(dev), "Requeued in softint"); 3763 evcnt_attach_dynamic(&adapter->morerx, EVCNT_TYPE_MISC, 3764 NULL, device_xname(dev), "Interrupt handler more rx"); 3765 evcnt_attach_dynamic(&adapter->moretx, EVCNT_TYPE_MISC, 3766 NULL, device_xname(dev), "Interrupt handler more tx"); 3767 evcnt_attach_dynamic(&adapter->txloops, EVCNT_TYPE_MISC, 3768 NULL, device_xname(dev), "Interrupt handler tx loops"); 3769 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 3770 NULL, device_xname(dev), "Driver tx dma soft fail EFBIG"); 3771 evcnt_attach_dynamic(&adapter->m_defrag_failed, EVCNT_TYPE_MISC, 3772 NULL, device_xname(dev), "m_defrag() failed"); 3773 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 3774 NULL, device_xname(dev), "Driver tx dma hard fail EFBIG"); 3775 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 3776 NULL, device_xname(dev), "Driver tx dma hard fail EINVAL"); 3777 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 3778 NULL, device_xname(dev), "Driver tx dma hard fail other"); 3779 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 3780 NULL, device_xname(dev), "Driver tx dma soft fail EAGAIN"); 3781 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 3782 NULL, device_xname(dev), "Driver tx dma soft fail ENOMEM"); 3783 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 3784 NULL, device_xname(dev), "Watchdog timeouts"); 3785 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 3786 NULL, device_xname(dev), "TSO errors"); 3787 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_MISC, 3788 NULL, device_xname(dev), "Link MSIX IRQ Handled"); 3789 3790 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3791 snprintf(adapter->queues[i].evnamebuf, 3792 sizeof(adapter->queues[i].evnamebuf), "%s queue%d", 3793 device_xname(dev), i); 3794 snprintf(adapter->queues[i].namebuf, 3795 sizeof(adapter->queues[i].namebuf), "queue%d", i); 3796 3797 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3798 aprint_error_dev(dev, "could not create sysctl root\n"); 3799 break; 3800 } 3801 3802 if (sysctl_createv(log, 0, &rnode, &rnode, 3803 0, CTLTYPE_NODE, 3804 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 3805 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 3806 break; 3807 3808 if (sysctl_createv(log, 0, &rnode, &cnode, 3809 CTLFLAG_READWRITE, CTLTYPE_INT, 3810 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 3811 ixgbe_sysctl_interrupt_rate_handler, 0, 3812 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 3813 break; 3814 3815 if (sysctl_createv(log, 0, &rnode, &cnode, 3816 CTLFLAG_READONLY, CTLTYPE_QUAD, 3817 "irqs", SYSCTL_DESCR("irqs on this queue"), 3818 NULL, 0, &(adapter->queues[i].irqs), 3819 0, CTL_CREATE, CTL_EOL) != 0) 3820 break; 3821 3822 if (sysctl_createv(log, 0, &rnode, &cnode, 3823 CTLFLAG_READONLY, CTLTYPE_INT, 3824 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 3825 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 3826 0, CTL_CREATE, CTL_EOL) != 0) 3827 break; 3828 3829 if (sysctl_createv(log, 0, &rnode, &cnode, 3830 CTLFLAG_READONLY, CTLTYPE_INT, 3831 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 3832 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 3833 0, CTL_CREATE, CTL_EOL) != 0) 3834 break; 3835 3836 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 3837 NULL, device_xname(dev), "TSO"); 3838 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 3839 NULL, adapter->queues[i].evnamebuf, 3840 "Queue No Descriptor Available"); 3841 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 3842 NULL, adapter->queues[i].evnamebuf, 3843 "Queue Packets Transmitted"); 3844 3845 #ifdef LRO 3846 struct lro_ctrl *lro = &rxr->lro; 3847 #endif /* LRO */ 3848 3849 if (sysctl_createv(log, 0, &rnode, &cnode, 3850 CTLFLAG_READONLY, 3851 CTLTYPE_INT, 3852 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 3853 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 3854 CTL_CREATE, CTL_EOL) != 0) 3855 break; 3856 3857 if (sysctl_createv(log, 0, &rnode, &cnode, 3858 CTLFLAG_READONLY, 3859 CTLTYPE_INT, 3860 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 3861 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 3862 CTL_CREATE, CTL_EOL) != 0) 3863 break; 3864 3865 if (i < __arraycount(adapter->stats.mpc)) { 3866 evcnt_attach_dynamic(&adapter->stats.mpc[i], 3867 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3868 "Missed Packet Count"); 3869 } 3870 if (i < __arraycount(adapter->stats.pxontxc)) { 3871 evcnt_attach_dynamic(&adapter->stats.pxontxc[i], 3872 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3873 "pxontxc"); 3874 evcnt_attach_dynamic(&adapter->stats.pxonrxc[i], 3875 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3876 "pxonrxc"); 3877 evcnt_attach_dynamic(&adapter->stats.pxofftxc[i], 3878 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3879 "pxofftxc"); 3880 evcnt_attach_dynamic(&adapter->stats.pxoffrxc[i], 3881 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3882 "pxoffrxc"); 3883 evcnt_attach_dynamic(&adapter->stats.pxon2offc[i], 3884 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3885 "pxon2offc"); 3886 } 3887 if (i < __arraycount(adapter->stats.qprc)) { 3888 evcnt_attach_dynamic(&adapter->stats.qprc[i], 3889 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3890 "qprc"); 3891 evcnt_attach_dynamic(&adapter->stats.qptc[i], 3892 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3893 "qptc"); 3894 evcnt_attach_dynamic(&adapter->stats.qbrc[i], 3895 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3896 "qbrc"); 3897 evcnt_attach_dynamic(&adapter->stats.qbtc[i], 3898 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3899 "qbtc"); 3900 evcnt_attach_dynamic(&adapter->stats.qprdc[i], 3901 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 3902 "qprdc"); 3903 } 3904 3905 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 3906 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 3907 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 3908 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 3909 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 3910 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 3911 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 3912 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 3913 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 3914 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 3915 evcnt_attach_dynamic(&rxr->rx_irq, EVCNT_TYPE_MISC, 3916 NULL, adapter->queues[i].evnamebuf, "Rx interrupts"); 3917 #ifdef LRO 3918 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 3919 CTLFLAG_RD, &lro->lro_queued, 0, 3920 "LRO Queued"); 3921 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 3922 CTLFLAG_RD, &lro->lro_flushed, 0, 3923 "LRO Flushed"); 3924 #endif /* LRO */ 3925 } 3926 3927 /* MAC stats get the own sub node */ 3928 3929 3930 snprintf(stats->namebuf, 3931 sizeof(stats->namebuf), "%s MAC Statistics", device_xname(dev)); 3932 3933 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 3934 stats->namebuf, "rx csum offload - IP"); 3935 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 3936 stats->namebuf, "rx csum offload - L4"); 3937 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 3938 stats->namebuf, "rx csum offload - IP bad"); 3939 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 3940 stats->namebuf, "rx csum offload - L4 bad"); 3941 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 3942 stats->namebuf, "Interrupt conditions zero"); 3943 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 3944 stats->namebuf, "Legacy interrupts"); 3945 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 3946 stats->namebuf, "CRC Errors"); 3947 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 3948 stats->namebuf, "Illegal Byte Errors"); 3949 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 3950 stats->namebuf, "Byte Errors"); 3951 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 3952 stats->namebuf, "MAC Short Packets Discarded"); 3953 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 3954 stats->namebuf, "MAC Local Faults"); 3955 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 3956 stats->namebuf, "MAC Remote Faults"); 3957 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 3958 stats->namebuf, "Receive Length Errors"); 3959 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 3960 stats->namebuf, "Link XON Transmitted"); 3961 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 3962 stats->namebuf, "Link XON Received"); 3963 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 3964 stats->namebuf, "Link XOFF Transmitted"); 3965 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 3966 stats->namebuf, "Link XOFF Received"); 3967 3968 /* Packet Reception Stats */ 3969 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 3970 stats->namebuf, "Total Octets Received"); 3971 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 3972 stats->namebuf, "Good Octets Received"); 3973 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 3974 stats->namebuf, "Total Packets Received"); 3975 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 3976 stats->namebuf, "Good Packets Received"); 3977 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 3978 stats->namebuf, "Multicast Packets Received"); 3979 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 3980 stats->namebuf, "Broadcast Packets Received"); 3981 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 3982 stats->namebuf, "64 byte frames received "); 3983 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 3984 stats->namebuf, "65-127 byte frames received"); 3985 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 3986 stats->namebuf, "128-255 byte frames received"); 3987 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 3988 stats->namebuf, "256-511 byte frames received"); 3989 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 3990 stats->namebuf, "512-1023 byte frames received"); 3991 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 3992 stats->namebuf, "1023-1522 byte frames received"); 3993 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 3994 stats->namebuf, "Receive Undersized"); 3995 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 3996 stats->namebuf, "Fragmented Packets Received "); 3997 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 3998 stats->namebuf, "Oversized Packets Received"); 3999 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 4000 stats->namebuf, "Received Jabber"); 4001 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 4002 stats->namebuf, "Management Packets Received"); 4003 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 4004 stats->namebuf, "Checksum Errors"); 4005 4006 /* Packet Transmission Stats */ 4007 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 4008 stats->namebuf, "Good Octets Transmitted"); 4009 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 4010 stats->namebuf, "Total Packets Transmitted"); 4011 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 4012 stats->namebuf, "Good Packets Transmitted"); 4013 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 4014 stats->namebuf, "Broadcast Packets Transmitted"); 4015 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 4016 stats->namebuf, "Multicast Packets Transmitted"); 4017 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 4018 stats->namebuf, "Management Packets Transmitted"); 4019 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 4020 stats->namebuf, "64 byte frames transmitted "); 4021 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 4022 stats->namebuf, "65-127 byte frames transmitted"); 4023 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 4024 stats->namebuf, "128-255 byte frames transmitted"); 4025 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 4026 stats->namebuf, "256-511 byte frames transmitted"); 4027 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 4028 stats->namebuf, "512-1023 byte frames transmitted"); 4029 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 4030 stats->namebuf, "1024-1522 byte frames transmitted"); 4031 } 4032 4033 /* 4034 ** Set flow control using sysctl: 4035 ** Flow control values: 4036 ** 0 - off 4037 ** 1 - rx pause 4038 ** 2 - tx pause 4039 ** 3 - full 4040 */ 4041 static int 4042 ixgbe_set_flowcntl(SYSCTLFN_ARGS) 4043 { 4044 struct sysctlnode node; 4045 int error, last; 4046 struct adapter *adapter; 4047 4048 node = *rnode; 4049 adapter = (struct adapter *)node.sysctl_data; 4050 node.sysctl_data = &adapter->fc; 4051 last = adapter->fc; 4052 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4053 if (error != 0 || newp == NULL) 4054 return error; 4055 4056 /* Don't bother if it's not changed */ 4057 if (adapter->fc == last) 4058 return (0); 4059 4060 switch (adapter->fc) { 4061 case ixgbe_fc_rx_pause: 4062 case ixgbe_fc_tx_pause: 4063 case ixgbe_fc_full: 4064 adapter->hw.fc.requested_mode = adapter->fc; 4065 if (adapter->num_queues > 1) 4066 ixgbe_disable_rx_drop(adapter); 4067 break; 4068 case ixgbe_fc_none: 4069 adapter->hw.fc.requested_mode = ixgbe_fc_none; 4070 if (adapter->num_queues > 1) 4071 ixgbe_enable_rx_drop(adapter); 4072 break; 4073 default: 4074 adapter->fc = last; 4075 return (EINVAL); 4076 } 4077 /* Don't autoneg if forcing a value */ 4078 adapter->hw.fc.disable_fc_autoneg = TRUE; 4079 ixgbe_fc_enable(&adapter->hw); 4080 return 0; 4081 } 4082 4083 4084 /* 4085 ** Control link advertise speed: 4086 ** 1 - advertise only 1G 4087 ** 2 - advertise 100Mb 4088 ** 3 - advertise normal 4089 */ 4090 static int 4091 ixgbe_set_advertise(SYSCTLFN_ARGS) 4092 { 4093 struct sysctlnode node; 4094 int t, error = 0; 4095 struct adapter *adapter; 4096 device_t dev; 4097 struct ixgbe_hw *hw; 4098 ixgbe_link_speed speed, last; 4099 4100 node = *rnode; 4101 adapter = (struct adapter *)node.sysctl_data; 4102 dev = adapter->dev; 4103 hw = &adapter->hw; 4104 last = adapter->advertise; 4105 t = adapter->advertise; 4106 node.sysctl_data = &t; 4107 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4108 if (error != 0 || newp == NULL) 4109 return error; 4110 4111 if (adapter->advertise == last) /* no change */ 4112 return (0); 4113 4114 if (t == -1) 4115 return 0; 4116 4117 adapter->advertise = t; 4118 4119 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 4120 (hw->phy.multispeed_fiber))) 4121 return (EINVAL); 4122 4123 if ((adapter->advertise == 2) && (hw->mac.type != ixgbe_mac_X540)) { 4124 device_printf(dev, "Set Advertise: 100Mb on X540 only\n"); 4125 return (EINVAL); 4126 } 4127 4128 if (adapter->advertise == 1) 4129 speed = IXGBE_LINK_SPEED_1GB_FULL; 4130 else if (adapter->advertise == 2) 4131 speed = IXGBE_LINK_SPEED_100_FULL; 4132 else if (adapter->advertise == 3) 4133 speed = IXGBE_LINK_SPEED_1GB_FULL | 4134 IXGBE_LINK_SPEED_10GB_FULL; 4135 else { /* bogus value */ 4136 adapter->advertise = last; 4137 return (EINVAL); 4138 } 4139 4140 hw->mac.autotry_restart = TRUE; 4141 hw->mac.ops.setup_link(hw, speed, TRUE); 4142 4143 return 0; 4144 } 4145 4146 /* 4147 ** Thermal Shutdown Trigger 4148 ** - cause a Thermal Overtemp IRQ 4149 ** - this now requires firmware enabling 4150 */ 4151 static int 4152 ixgbe_set_thermal_test(SYSCTLFN_ARGS) 4153 { 4154 struct sysctlnode node; 4155 int error, fire = 0; 4156 struct adapter *adapter; 4157 struct ixgbe_hw *hw; 4158 4159 node = *rnode; 4160 adapter = (struct adapter *)node.sysctl_data; 4161 hw = &adapter->hw; 4162 4163 if (hw->mac.type != ixgbe_mac_X540) 4164 return (0); 4165 4166 node.sysctl_data = &fire; 4167 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4168 if ((error) || (newp == NULL)) 4169 return (error); 4170 4171 if (fire) { 4172 u32 reg = IXGBE_READ_REG(hw, IXGBE_EICS); 4173 reg |= IXGBE_EICR_TS; 4174 IXGBE_WRITE_REG(hw, IXGBE_EICS, reg); 4175 } 4176 4177 return (0); 4178 } 4179 4180 /* 4181 ** Enable the hardware to drop packets when the buffer is 4182 ** full. This is useful when multiqueue,so that no single 4183 ** queue being full stalls the entire RX engine. We only 4184 ** enable this when Multiqueue AND when Flow Control is 4185 ** disabled. 4186 */ 4187 static void 4188 ixgbe_enable_rx_drop(struct adapter *adapter) 4189 { 4190 struct ixgbe_hw *hw = &adapter->hw; 4191 4192 for (int i = 0; i < adapter->num_queues; i++) { 4193 u32 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(i)); 4194 srrctl |= IXGBE_SRRCTL_DROP_EN; 4195 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(i), srrctl); 4196 } 4197 } 4198 4199 static void 4200 ixgbe_disable_rx_drop(struct adapter *adapter) 4201 { 4202 struct ixgbe_hw *hw = &adapter->hw; 4203 4204 for (int i = 0; i < adapter->num_queues; i++) { 4205 u32 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(i)); 4206 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 4207 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(i), srrctl); 4208 } 4209 } 4210
Indexes created Tue Sep 30 06:09:59 GMT 2025