ixgbe.c revision 1.52
1 /****************************************************************************** 2 3 Copyright (c) 2001-2015, 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/if_ix.c 302384 2016-07-07 03:39:18Z sbruno $*/ 62 /*$NetBSD: ixgbe.c,v 1.52 2016/12/05 08:50:29 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 * Driver version 74 *********************************************************************/ 75 char ixgbe_driver_version[] = "3.1.13-k"; 76 77 78 /********************************************************************* 79 * PCI Device ID Table 80 * 81 * Used by probe to select devices to load on 82 * Last field stores an index into ixgbe_strings 83 * Last entry must be all 0s 84 * 85 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 86 *********************************************************************/ 87 88 static ixgbe_vendor_info_t ixgbe_vendor_info_array[] = 89 { 90 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0}, 91 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0}, 92 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0}, 93 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0}, 94 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0}, 95 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0}, 96 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0}, 97 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0}, 98 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0}, 99 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0}, 100 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0}, 101 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0}, 102 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0}, 103 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0}, 104 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0}, 105 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0}, 106 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0}, 107 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0}, 108 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0}, 109 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0}, 110 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0}, 111 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0}, 112 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0}, 113 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, 0, 0, 0}, 114 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0}, 115 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, 0, 0, 0}, 116 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, 0, 0, 0}, 117 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T1, 0, 0, 0}, 118 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, 0, 0, 0}, 119 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, 0, 0, 0}, 120 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, 0, 0, 0}, 121 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_SFP, 0, 0, 0}, 122 /* required last entry */ 123 {0, 0, 0, 0, 0} 124 }; 125 126 /********************************************************************* 127 * Table of branding strings 128 *********************************************************************/ 129 130 static const char *ixgbe_strings[] = { 131 "Intel(R) PRO/10GbE PCI-Express Network Driver" 132 }; 133 134 /********************************************************************* 135 * Function prototypes 136 *********************************************************************/ 137 static int ixgbe_probe(device_t, cfdata_t, void *); 138 static void ixgbe_attach(device_t, device_t, void *); 139 static int ixgbe_detach(device_t, int); 140 #if 0 141 static int ixgbe_shutdown(device_t); 142 #endif 143 static bool ixgbe_suspend(device_t, const pmf_qual_t *); 144 static bool ixgbe_resume(device_t, const pmf_qual_t *); 145 static int ixgbe_ioctl(struct ifnet *, u_long, void *); 146 static void ixgbe_ifstop(struct ifnet *, int); 147 static int ixgbe_init(struct ifnet *); 148 static void ixgbe_init_locked(struct adapter *); 149 static void ixgbe_stop(void *); 150 static void ixgbe_add_media_types(struct adapter *); 151 static void ixgbe_media_status(struct ifnet *, struct ifmediareq *); 152 static int ixgbe_media_change(struct ifnet *); 153 static void ixgbe_identify_hardware(struct adapter *); 154 static int ixgbe_allocate_pci_resources(struct adapter *, 155 const struct pci_attach_args *); 156 static void ixgbe_get_slot_info(struct adapter *); 157 static int ixgbe_allocate_msix(struct adapter *, 158 const struct pci_attach_args *); 159 static int ixgbe_allocate_legacy(struct adapter *, 160 const struct pci_attach_args *); 161 static int ixgbe_setup_msix(struct adapter *); 162 static void ixgbe_free_pci_resources(struct adapter *); 163 static void ixgbe_local_timer(void *); 164 static int ixgbe_setup_interface(device_t, struct adapter *); 165 static void ixgbe_config_gpie(struct adapter *); 166 static void ixgbe_config_dmac(struct adapter *); 167 static void ixgbe_config_delay_values(struct adapter *); 168 static void ixgbe_config_link(struct adapter *); 169 static void ixgbe_check_wol_support(struct adapter *); 170 static int ixgbe_setup_low_power_mode(struct adapter *); 171 static void ixgbe_rearm_queues(struct adapter *, u64); 172 173 static void ixgbe_initialize_transmit_units(struct adapter *); 174 static void ixgbe_initialize_receive_units(struct adapter *); 175 static void ixgbe_enable_rx_drop(struct adapter *); 176 static void ixgbe_disable_rx_drop(struct adapter *); 177 static void ixgbe_initialize_rss_mapping(struct adapter *); 178 179 static void ixgbe_enable_intr(struct adapter *); 180 static void ixgbe_disable_intr(struct adapter *); 181 static void ixgbe_update_stats_counters(struct adapter *); 182 static void ixgbe_set_promisc(struct adapter *); 183 static void ixgbe_set_multi(struct adapter *); 184 static void ixgbe_update_link_status(struct adapter *); 185 static void ixgbe_set_ivar(struct adapter *, u8, u8, s8); 186 static void ixgbe_configure_ivars(struct adapter *); 187 static u8 * ixgbe_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 188 189 static void ixgbe_setup_vlan_hw_support(struct adapter *); 190 #if 0 191 static void ixgbe_register_vlan(void *, struct ifnet *, u16); 192 static void ixgbe_unregister_vlan(void *, struct ifnet *, u16); 193 #endif 194 195 static void ixgbe_add_device_sysctls(struct adapter *); 196 static void ixgbe_add_hw_stats(struct adapter *); 197 static int ixgbe_set_flowcntl(struct adapter *, int); 198 static int ixgbe_set_advertise(struct adapter *, int); 199 200 /* Sysctl handlers */ 201 static void ixgbe_set_sysctl_value(struct adapter *, const char *, 202 const char *, int *, int); 203 static int ixgbe_sysctl_flowcntl(SYSCTLFN_PROTO); 204 static int ixgbe_sysctl_advertise(SYSCTLFN_PROTO); 205 static int ixgbe_sysctl_thermal_test(SYSCTLFN_PROTO); 206 static int ixgbe_sysctl_dmac(SYSCTLFN_PROTO); 207 static int ixgbe_sysctl_phy_temp(SYSCTLFN_PROTO); 208 static int ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_PROTO); 209 #ifdef IXGBE_DEBUG 210 static int ixgbe_sysctl_power_state(SYSCTLFN_PROTO); 211 static int ixgbe_sysctl_print_rss_config(SYSCTLFN_PROTO); 212 #endif 213 static int ixgbe_sysctl_wol_enable(SYSCTLFN_PROTO); 214 static int ixgbe_sysctl_wufc(SYSCTLFN_PROTO); 215 static int ixgbe_sysctl_eee_enable(SYSCTLFN_PROTO); 216 static int ixgbe_sysctl_eee_negotiated(SYSCTLFN_PROTO); 217 static int ixgbe_sysctl_eee_rx_lpi_status(SYSCTLFN_PROTO); 218 static int ixgbe_sysctl_eee_tx_lpi_status(SYSCTLFN_PROTO); 219 static int ixgbe_sysctl_eee_tx_lpi_delay(SYSCTLFN_PROTO); 220 221 /* Support for pluggable optic modules */ 222 static bool ixgbe_sfp_probe(struct adapter *); 223 static void ixgbe_setup_optics(struct adapter *); 224 225 /* Legacy (single vector interrupt handler */ 226 static int ixgbe_legacy_irq(void *); 227 228 /* The MSI/X Interrupt handlers */ 229 static int ixgbe_msix_que(void *); 230 static int ixgbe_msix_link(void *); 231 232 /* Software interrupts for deferred work */ 233 static void ixgbe_handle_que(void *); 234 static void ixgbe_handle_link(void *); 235 static void ixgbe_handle_msf(void *); 236 static void ixgbe_handle_mod(void *); 237 static void ixgbe_handle_phy(void *); 238 239 const struct sysctlnode *ixgbe_sysctl_instance(struct adapter *); 240 static ixgbe_vendor_info_t *ixgbe_lookup(const struct pci_attach_args *); 241 242 #ifdef IXGBE_FDIR 243 static void ixgbe_reinit_fdir(void *, int); 244 #endif 245 246 #ifdef PCI_IOV 247 static void ixgbe_ping_all_vfs(struct adapter *); 248 static void ixgbe_handle_mbx(void *, int); 249 static int ixgbe_init_iov(device_t, u16, const nvlist_t *); 250 static void ixgbe_uninit_iov(device_t); 251 static int ixgbe_add_vf(device_t, u16, const nvlist_t *); 252 static void ixgbe_initialize_iov(struct adapter *); 253 static void ixgbe_recalculate_max_frame(struct adapter *); 254 static void ixgbe_init_vf(struct adapter *, struct ixgbe_vf *); 255 #endif /* PCI_IOV */ 256 257 258 /********************************************************************* 259 * FreeBSD Device Interface Entry Points 260 *********************************************************************/ 261 262 CFATTACH_DECL3_NEW(ixg, sizeof(struct adapter), 263 ixgbe_probe, ixgbe_attach, ixgbe_detach, NULL, NULL, NULL, 264 DVF_DETACH_SHUTDOWN); 265 266 #if 0 267 devclass_t ix_devclass; 268 DRIVER_MODULE(ix, pci, ix_driver, ix_devclass, 0, 0); 269 270 MODULE_DEPEND(ix, pci, 1, 1, 1); 271 MODULE_DEPEND(ix, ether, 1, 1, 1); 272 #endif 273 274 /* 275 ** TUNEABLE PARAMETERS: 276 */ 277 278 /* 279 ** AIM: Adaptive Interrupt Moderation 280 ** which means that the interrupt rate 281 ** is varied over time based on the 282 ** traffic for that interrupt vector 283 */ 284 static int ixgbe_enable_aim = TRUE; 285 #define SYSCTL_INT(_a1, _a2, _a3, _a4, _a5, _a6, _a7) 286 SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RWTUN, &ixgbe_enable_aim, 0, 287 "Enable adaptive interrupt moderation"); 288 289 static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 290 SYSCTL_INT(_hw_ix, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN, 291 &ixgbe_max_interrupt_rate, 0, "Maximum interrupts per second"); 292 293 /* How many packets rxeof tries to clean at a time */ 294 static int ixgbe_rx_process_limit = 256; 295 SYSCTL_INT(_hw_ix, OID_AUTO, rx_process_limit, CTLFLAG_RDTUN, 296 &ixgbe_rx_process_limit, 0, 297 "Maximum number of received packets to process at a time," 298 "-1 means unlimited"); 299 300 /* How many packets txeof tries to clean at a time */ 301 static int ixgbe_tx_process_limit = 256; 302 SYSCTL_INT(_hw_ix, OID_AUTO, tx_process_limit, CTLFLAG_RDTUN, 303 &ixgbe_tx_process_limit, 0, 304 "Maximum number of sent packets to process at a time," 305 "-1 means unlimited"); 306 307 /* Flow control setting, default to full */ 308 static int ixgbe_flow_control = ixgbe_fc_full; 309 SYSCTL_INT(_hw_ix, OID_AUTO, flow_control, CTLFLAG_RDTUN, 310 &ixgbe_flow_control, 0, "Default flow control used for all adapters"); 311 312 /* Advertise Speed, default to 0 (auto) */ 313 static int ixgbe_advertise_speed = 0; 314 SYSCTL_INT(_hw_ix, OID_AUTO, advertise_speed, CTLFLAG_RDTUN, 315 &ixgbe_advertise_speed, 0, "Default advertised speed for all adapters"); 316 317 /* 318 ** Smart speed setting, default to on 319 ** this only works as a compile option 320 ** right now as its during attach, set 321 ** this to 'ixgbe_smart_speed_off' to 322 ** disable. 323 */ 324 static int ixgbe_smart_speed = ixgbe_smart_speed_on; 325 326 /* 327 * MSIX should be the default for best performance, 328 * but this allows it to be forced off for testing. 329 */ 330 static int ixgbe_enable_msix = 1; 331 SYSCTL_INT(_hw_ix, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixgbe_enable_msix, 0, 332 "Enable MSI-X interrupts"); 333 334 /* 335 * Number of Queues, can be set to 0, 336 * it then autoconfigures based on the 337 * number of cpus with a max of 8. This 338 * can be overriden manually here. 339 */ 340 static int ixgbe_num_queues = 1; 341 SYSCTL_INT(_hw_ix, OID_AUTO, num_queues, CTLFLAG_RDTUN, &ixgbe_num_queues, 0, 342 "Number of queues to configure, 0 indicates autoconfigure"); 343 344 /* 345 ** Number of TX descriptors per ring, 346 ** setting higher than RX as this seems 347 ** the better performing choice. 348 */ 349 static int ixgbe_txd = PERFORM_TXD; 350 SYSCTL_INT(_hw_ix, OID_AUTO, txd, CTLFLAG_RDTUN, &ixgbe_txd, 0, 351 "Number of transmit descriptors per queue"); 352 353 /* Number of RX descriptors per ring */ 354 static int ixgbe_rxd = PERFORM_RXD; 355 SYSCTL_INT(_hw_ix, OID_AUTO, rxd, CTLFLAG_RDTUN, &ixgbe_rxd, 0, 356 "Number of receive descriptors per queue"); 357 358 /* 359 ** Defining this on will allow the use 360 ** of unsupported SFP+ modules, note that 361 ** doing so you are on your own :) 362 */ 363 static int allow_unsupported_sfp = false; 364 #define TUNABLE_INT(__x, __y) 365 TUNABLE_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp); 366 367 /* Keep running tab on them for sanity check */ 368 static int ixgbe_total_ports; 369 370 #ifdef IXGBE_FDIR 371 /* 372 ** Flow Director actually 'steals' 373 ** part of the packet buffer as its 374 ** filter pool, this variable controls 375 ** how much it uses: 376 ** 0 = 64K, 1 = 128K, 2 = 256K 377 */ 378 static int fdir_pballoc = 1; 379 #endif 380 381 #ifdef DEV_NETMAP 382 /* 383 * The #ifdef DEV_NETMAP / #endif blocks in this file are meant to 384 * be a reference on how to implement netmap support in a driver. 385 * Additional comments are in ixgbe_netmap.h . 386 * 387 * <dev/netmap/ixgbe_netmap.h> contains functions for netmap support 388 * that extend the standard driver. 389 */ 390 #include <dev/netmap/ixgbe_netmap.h> 391 #endif /* DEV_NETMAP */ 392 393 /********************************************************************* 394 * Device identification routine 395 * 396 * ixgbe_probe determines if the driver should be loaded on 397 * adapter based on PCI vendor/device id of the adapter. 398 * 399 * return 1 on success, 0 on failure 400 *********************************************************************/ 401 402 static int 403 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 404 { 405 const struct pci_attach_args *pa = aux; 406 407 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 408 } 409 410 static ixgbe_vendor_info_t * 411 ixgbe_lookup(const struct pci_attach_args *pa) 412 { 413 pcireg_t subid; 414 ixgbe_vendor_info_t *ent; 415 416 INIT_DEBUGOUT("ixgbe_probe: begin"); 417 418 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 419 return NULL; 420 421 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 422 423 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 424 if (PCI_VENDOR(pa->pa_id) == ent->vendor_id && 425 PCI_PRODUCT(pa->pa_id) == ent->device_id && 426 427 (PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id || 428 ent->subvendor_id == 0) && 429 430 (PCI_SUBSYS_ID(subid) == ent->subdevice_id || 431 ent->subdevice_id == 0)) { 432 ++ixgbe_total_ports; 433 return ent; 434 } 435 } 436 return NULL; 437 } 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 = 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 #ifdef DEV_NETMAP 480 adapter->init_locked = ixgbe_init_locked; 481 adapter->stop_locked = ixgbe_stop; 482 #endif 483 484 /* Core Lock Init*/ 485 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 486 487 /* Set up the timer callout */ 488 callout_init(&adapter->timer, 0); 489 490 /* Determine hardware revision */ 491 ixgbe_identify_hardware(adapter); 492 493 /* Do base PCI setup - map BAR0 */ 494 if (ixgbe_allocate_pci_resources(adapter, pa)) { 495 aprint_error_dev(dev, "Allocation of PCI resources failed\n"); 496 error = ENXIO; 497 goto err_out; 498 } 499 500 /* Sysctls for limiting the amount of work done in the taskqueues */ 501 ixgbe_set_sysctl_value(adapter, "rx_processing_limit", 502 "max number of rx packets to process", 503 &adapter->rx_process_limit, ixgbe_rx_process_limit); 504 505 ixgbe_set_sysctl_value(adapter, "tx_processing_limit", 506 "max number of tx packets to process", 507 &adapter->tx_process_limit, ixgbe_tx_process_limit); 508 509 /* Do descriptor calc and sanity checks */ 510 if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 511 ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) { 512 aprint_error_dev(dev, "TXD config issue, using default!\n"); 513 adapter->num_tx_desc = DEFAULT_TXD; 514 } else 515 adapter->num_tx_desc = ixgbe_txd; 516 517 /* 518 ** With many RX rings it is easy to exceed the 519 ** system mbuf allocation. Tuning nmbclusters 520 ** can alleviate this. 521 */ 522 if (nmbclusters > 0) { 523 int s; 524 s = (ixgbe_rxd * adapter->num_queues) * ixgbe_total_ports; 525 if (s > nmbclusters) { 526 aprint_error_dev(dev, "RX Descriptors exceed " 527 "system mbuf max, using default instead!\n"); 528 ixgbe_rxd = DEFAULT_RXD; 529 } 530 } 531 532 if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 533 ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) { 534 aprint_error_dev(dev, "RXD config issue, using default!\n"); 535 adapter->num_rx_desc = DEFAULT_RXD; 536 } else 537 adapter->num_rx_desc = ixgbe_rxd; 538 539 /* Allocate our TX/RX Queues */ 540 if (ixgbe_allocate_queues(adapter)) { 541 error = ENOMEM; 542 goto err_out; 543 } 544 545 /* Allocate multicast array memory. */ 546 adapter->mta = malloc(sizeof(*adapter->mta) * 547 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT); 548 if (adapter->mta == NULL) { 549 aprint_error_dev(dev, "Cannot allocate multicast setup array\n"); 550 error = ENOMEM; 551 goto err_late; 552 } 553 554 /* Initialize the shared code */ 555 hw->allow_unsupported_sfp = allow_unsupported_sfp; 556 error = ixgbe_init_shared_code(hw); 557 if (error == IXGBE_ERR_SFP_NOT_PRESENT) { 558 /* 559 ** No optics in this port, set up 560 ** so the timer routine will probe 561 ** for later insertion. 562 */ 563 adapter->sfp_probe = TRUE; 564 error = 0; 565 } else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) { 566 aprint_error_dev(dev, "Unsupported SFP+ module detected!\n"); 567 error = EIO; 568 goto err_late; 569 } else if (error) { 570 aprint_error_dev(dev, "Unable to initialize the shared code\n"); 571 error = EIO; 572 goto err_late; 573 } 574 575 /* Make sure we have a good EEPROM before we read from it */ 576 if (ixgbe_validate_eeprom_checksum(&adapter->hw, &csum) < 0) { 577 aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n"); 578 error = EIO; 579 goto err_late; 580 } 581 582 error = ixgbe_init_hw(hw); 583 switch (error) { 584 case IXGBE_ERR_EEPROM_VERSION: 585 aprint_error_dev(dev, "This device is a pre-production adapter/" 586 "LOM. Please be aware there may be issues associated " 587 "with your hardware.\nIf you are experiencing problems " 588 "please contact your Intel or hardware representative " 589 "who provided you with this hardware.\n"); 590 break; 591 case IXGBE_ERR_SFP_NOT_SUPPORTED: 592 aprint_error_dev(dev, "Unsupported SFP+ Module\n"); 593 error = EIO; 594 aprint_error_dev(dev, "Hardware Initialization Failure\n"); 595 goto err_late; 596 case IXGBE_ERR_SFP_NOT_PRESENT: 597 aprint_error_dev(dev, "No SFP+ Module found\n"); 598 /* falls thru */ 599 default: 600 break; 601 } 602 603 /* hw.ix defaults init */ 604 ixgbe_set_advertise(adapter, ixgbe_advertise_speed); 605 ixgbe_set_flowcntl(adapter, ixgbe_flow_control); 606 adapter->enable_aim = ixgbe_enable_aim; 607 608 error = -1; 609 if ((adapter->msix > 1) && (ixgbe_enable_msix)) 610 error = ixgbe_allocate_msix(adapter, pa); 611 if (error != 0) 612 error = ixgbe_allocate_legacy(adapter, pa); 613 if (error) 614 goto err_late; 615 616 /* Enable the optics for 82599 SFP+ fiber */ 617 ixgbe_enable_tx_laser(hw); 618 619 /* Enable power to the phy. */ 620 ixgbe_set_phy_power(hw, TRUE); 621 622 /* Setup OS specific network interface */ 623 if (ixgbe_setup_interface(dev, adapter) != 0) 624 goto err_late; 625 626 /* Initialize statistics */ 627 ixgbe_update_stats_counters(adapter); 628 629 /* Check PCIE slot type/speed/width */ 630 ixgbe_get_slot_info(adapter); 631 632 /* Set an initial default flow control & dmac value */ 633 adapter->fc = ixgbe_fc_full; 634 adapter->dmac = 0; 635 adapter->eee_enabled = 0; 636 637 #ifdef PCI_IOV 638 if ((hw->mac.type != ixgbe_mac_82598EB) && (adapter->msix > 1)) { 639 nvlist_t *pf_schema, *vf_schema; 640 641 hw->mbx.ops.init_params(hw); 642 pf_schema = pci_iov_schema_alloc_node(); 643 vf_schema = pci_iov_schema_alloc_node(); 644 pci_iov_schema_add_unicast_mac(vf_schema, "mac-addr", 0, NULL); 645 pci_iov_schema_add_bool(vf_schema, "mac-anti-spoof", 646 IOV_SCHEMA_HASDEFAULT, TRUE); 647 pci_iov_schema_add_bool(vf_schema, "allow-set-mac", 648 IOV_SCHEMA_HASDEFAULT, FALSE); 649 pci_iov_schema_add_bool(vf_schema, "allow-promisc", 650 IOV_SCHEMA_HASDEFAULT, FALSE); 651 error = pci_iov_attach(dev, pf_schema, vf_schema); 652 if (error != 0) { 653 device_printf(dev, 654 "Error %d setting up SR-IOV\n", error); 655 } 656 } 657 #endif /* PCI_IOV */ 658 659 /* Check for certain supported features */ 660 ixgbe_check_wol_support(adapter); 661 662 /* Add sysctls */ 663 ixgbe_add_device_sysctls(adapter); 664 ixgbe_add_hw_stats(adapter); 665 666 /* let hardware know driver is loaded */ 667 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 668 ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD; 669 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 670 671 #ifdef DEV_NETMAP 672 ixgbe_netmap_attach(adapter); 673 #endif /* DEV_NETMAP */ 674 675 if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume)) 676 pmf_class_network_register(dev, adapter->ifp); 677 else 678 aprint_error_dev(dev, "couldn't establish power handler\n"); 679 680 INIT_DEBUGOUT("ixgbe_attach: end"); 681 adapter->osdep.attached = true; 682 return; 683 684 err_late: 685 ixgbe_free_transmit_structures(adapter); 686 ixgbe_free_receive_structures(adapter); 687 err_out: 688 if (adapter->ifp != NULL) 689 if_free(adapter->ifp); 690 ixgbe_free_pci_resources(adapter); 691 if (adapter->mta != NULL) 692 free(adapter->mta, M_DEVBUF); 693 return; 694 } 695 696 /********************************************************************* 697 * Device removal routine 698 * 699 * The detach entry point is called when the driver is being removed. 700 * This routine stops the adapter and deallocates all the resources 701 * that were allocated for driver operation. 702 * 703 * return 0 on success, positive on failure 704 *********************************************************************/ 705 706 static int 707 ixgbe_detach(device_t dev, int flags) 708 { 709 struct adapter *adapter = device_private(dev); 710 struct rx_ring *rxr = adapter->rx_rings; 711 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 712 struct ix_queue *que = adapter->queues; 713 struct tx_ring *txr = adapter->tx_rings; 714 u32 ctrl_ext; 715 716 INIT_DEBUGOUT("ixgbe_detach: begin"); 717 if (adapter->osdep.attached == false) 718 return 0; 719 720 #if NVLAN > 0 721 /* Make sure VLANs are not using driver */ 722 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 723 ; /* nothing to do: no VLANs */ 724 else if ((flags & (DETACH_SHUTDOWN|DETACH_FORCE)) != 0) 725 vlan_ifdetach(adapter->ifp); 726 else { 727 aprint_error_dev(dev, "VLANs in use\n"); 728 return EBUSY; 729 } 730 #endif 731 732 #ifdef PCI_IOV 733 if (pci_iov_detach(dev) != 0) { 734 device_printf(dev, "SR-IOV in use; detach first.\n"); 735 return (EBUSY); 736 } 737 #endif /* PCI_IOV */ 738 739 pmf_device_deregister(dev); 740 741 ether_ifdetach(adapter->ifp); 742 /* Stop the adapter */ 743 IXGBE_CORE_LOCK(adapter); 744 ixgbe_setup_low_power_mode(adapter); 745 IXGBE_CORE_UNLOCK(adapter); 746 747 for (int i = 0; i < adapter->num_queues; i++, que++, txr++) { 748 #ifndef IXGBE_LEGACY_TX 749 softint_disestablish(txr->txq_si); 750 #endif 751 softint_disestablish(que->que_si); 752 } 753 754 /* Drain the Link queue */ 755 softint_disestablish(adapter->link_si); 756 softint_disestablish(adapter->mod_si); 757 softint_disestablish(adapter->msf_si); 758 #ifdef PCI_IOV 759 softint_disestablish(adapter->mbx_si); 760 #endif 761 softint_disestablish(adapter->phy_si); 762 #ifdef IXGBE_FDIR 763 softint_disestablish(adapter->fdir_si); 764 #endif 765 766 /* let hardware know driver is unloading */ 767 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 768 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 769 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 770 771 callout_halt(&adapter->timer, NULL); 772 #ifdef DEV_NETMAP 773 netmap_detach(adapter->ifp); 774 #endif /* DEV_NETMAP */ 775 ixgbe_free_pci_resources(adapter); 776 #if 0 /* XXX the NetBSD port is probably missing something here */ 777 bus_generic_detach(dev); 778 #endif 779 if_detach(adapter->ifp); 780 781 sysctl_teardown(&adapter->sysctllog); 782 evcnt_detach(&adapter->handleq); 783 evcnt_detach(&adapter->req); 784 evcnt_detach(&adapter->morerx); 785 evcnt_detach(&adapter->moretx); 786 evcnt_detach(&adapter->txloops); 787 evcnt_detach(&adapter->efbig_tx_dma_setup); 788 evcnt_detach(&adapter->m_defrag_failed); 789 evcnt_detach(&adapter->efbig2_tx_dma_setup); 790 evcnt_detach(&adapter->einval_tx_dma_setup); 791 evcnt_detach(&adapter->other_tx_dma_setup); 792 evcnt_detach(&adapter->eagain_tx_dma_setup); 793 evcnt_detach(&adapter->enomem_tx_dma_setup); 794 evcnt_detach(&adapter->watchdog_events); 795 evcnt_detach(&adapter->tso_err); 796 evcnt_detach(&adapter->link_irq); 797 798 txr = adapter->tx_rings; 799 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 800 evcnt_detach(&txr->no_desc_avail); 801 evcnt_detach(&txr->total_packets); 802 evcnt_detach(&txr->tso_tx); 803 804 if (i < __arraycount(adapter->stats.pf.mpc)) { 805 evcnt_detach(&adapter->stats.pf.mpc[i]); 806 } 807 if (i < __arraycount(adapter->stats.pf.pxontxc)) { 808 evcnt_detach(&adapter->stats.pf.pxontxc[i]); 809 evcnt_detach(&adapter->stats.pf.pxonrxc[i]); 810 evcnt_detach(&adapter->stats.pf.pxofftxc[i]); 811 evcnt_detach(&adapter->stats.pf.pxoffrxc[i]); 812 evcnt_detach(&adapter->stats.pf.pxon2offc[i]); 813 } 814 if (i < __arraycount(adapter->stats.pf.qprc)) { 815 evcnt_detach(&adapter->stats.pf.qprc[i]); 816 evcnt_detach(&adapter->stats.pf.qptc[i]); 817 evcnt_detach(&adapter->stats.pf.qbrc[i]); 818 evcnt_detach(&adapter->stats.pf.qbtc[i]); 819 evcnt_detach(&adapter->stats.pf.qprdc[i]); 820 } 821 822 evcnt_detach(&rxr->rx_packets); 823 evcnt_detach(&rxr->rx_bytes); 824 evcnt_detach(&rxr->rx_copies); 825 evcnt_detach(&rxr->no_jmbuf); 826 evcnt_detach(&rxr->rx_discarded); 827 evcnt_detach(&rxr->rx_irq); 828 } 829 evcnt_detach(&stats->ipcs); 830 evcnt_detach(&stats->l4cs); 831 evcnt_detach(&stats->ipcs_bad); 832 evcnt_detach(&stats->l4cs_bad); 833 evcnt_detach(&stats->intzero); 834 evcnt_detach(&stats->legint); 835 evcnt_detach(&stats->crcerrs); 836 evcnt_detach(&stats->illerrc); 837 evcnt_detach(&stats->errbc); 838 evcnt_detach(&stats->mspdc); 839 evcnt_detach(&stats->mlfc); 840 evcnt_detach(&stats->mrfc); 841 evcnt_detach(&stats->rlec); 842 evcnt_detach(&stats->lxontxc); 843 evcnt_detach(&stats->lxonrxc); 844 evcnt_detach(&stats->lxofftxc); 845 evcnt_detach(&stats->lxoffrxc); 846 847 /* Packet Reception Stats */ 848 evcnt_detach(&stats->tor); 849 evcnt_detach(&stats->gorc); 850 evcnt_detach(&stats->tpr); 851 evcnt_detach(&stats->gprc); 852 evcnt_detach(&stats->mprc); 853 evcnt_detach(&stats->bprc); 854 evcnt_detach(&stats->prc64); 855 evcnt_detach(&stats->prc127); 856 evcnt_detach(&stats->prc255); 857 evcnt_detach(&stats->prc511); 858 evcnt_detach(&stats->prc1023); 859 evcnt_detach(&stats->prc1522); 860 evcnt_detach(&stats->ruc); 861 evcnt_detach(&stats->rfc); 862 evcnt_detach(&stats->roc); 863 evcnt_detach(&stats->rjc); 864 evcnt_detach(&stats->mngprc); 865 evcnt_detach(&stats->xec); 866 867 /* Packet Transmission Stats */ 868 evcnt_detach(&stats->gotc); 869 evcnt_detach(&stats->tpt); 870 evcnt_detach(&stats->gptc); 871 evcnt_detach(&stats->bptc); 872 evcnt_detach(&stats->mptc); 873 evcnt_detach(&stats->mngptc); 874 evcnt_detach(&stats->ptc64); 875 evcnt_detach(&stats->ptc127); 876 evcnt_detach(&stats->ptc255); 877 evcnt_detach(&stats->ptc511); 878 evcnt_detach(&stats->ptc1023); 879 evcnt_detach(&stats->ptc1522); 880 881 ixgbe_free_transmit_structures(adapter); 882 ixgbe_free_receive_structures(adapter); 883 free(adapter->mta, M_DEVBUF); 884 885 IXGBE_CORE_LOCK_DESTROY(adapter); 886 return (0); 887 } 888 889 /********************************************************************* 890 * 891 * Shutdown entry point 892 * 893 **********************************************************************/ 894 895 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 896 static int 897 ixgbe_shutdown(device_t dev) 898 { 899 struct adapter *adapter = device_private(dev); 900 int error = 0; 901 902 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 903 904 IXGBE_CORE_LOCK(adapter); 905 error = ixgbe_setup_low_power_mode(adapter); 906 IXGBE_CORE_UNLOCK(adapter); 907 908 return (error); 909 } 910 #endif 911 912 /** 913 * Methods for going from: 914 * D0 -> D3: ixgbe_suspend 915 * D3 -> D0: ixgbe_resume 916 */ 917 static bool 918 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 919 { 920 struct adapter *adapter = device_private(dev); 921 int error = 0; 922 923 INIT_DEBUGOUT("ixgbe_suspend: begin"); 924 925 IXGBE_CORE_LOCK(adapter); 926 927 error = ixgbe_setup_low_power_mode(adapter); 928 929 IXGBE_CORE_UNLOCK(adapter); 930 931 return (error); 932 } 933 934 static bool 935 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 936 { 937 struct adapter *adapter = device_private(dev); 938 struct ifnet *ifp = adapter->ifp; 939 struct ixgbe_hw *hw = &adapter->hw; 940 u32 wus; 941 942 INIT_DEBUGOUT("ixgbe_resume: begin"); 943 944 IXGBE_CORE_LOCK(adapter); 945 946 /* Read & clear WUS register */ 947 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 948 if (wus) 949 device_printf(dev, "Woken up by (WUS): %#010x\n", 950 IXGBE_READ_REG(hw, IXGBE_WUS)); 951 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 952 /* And clear WUFC until next low-power transition */ 953 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 954 955 /* 956 * Required after D3->D0 transition; 957 * will re-advertise all previous advertised speeds 958 */ 959 if (ifp->if_flags & IFF_UP) 960 ixgbe_init_locked(adapter); 961 962 IXGBE_CORE_UNLOCK(adapter); 963 964 return true; 965 } 966 967 static int 968 ixgbe_ifflags_cb(struct ethercom *ec) 969 { 970 struct ifnet *ifp = &ec->ec_if; 971 struct adapter *adapter = ifp->if_softc; 972 int change = ifp->if_flags ^ adapter->if_flags, rc = 0; 973 974 IXGBE_CORE_LOCK(adapter); 975 976 if (change != 0) 977 adapter->if_flags = ifp->if_flags; 978 979 if ((change & ~(IFF_CANTCHANGE|IFF_DEBUG)) != 0) 980 rc = ENETRESET; 981 else if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 982 ixgbe_set_promisc(adapter); 983 984 /* Set up VLAN support and filter */ 985 ixgbe_setup_vlan_hw_support(adapter); 986 987 IXGBE_CORE_UNLOCK(adapter); 988 989 return rc; 990 } 991 992 /********************************************************************* 993 * Ioctl entry point 994 * 995 * ixgbe_ioctl is called when the user wants to configure the 996 * interface. 997 * 998 * return 0 on success, positive on failure 999 **********************************************************************/ 1000 1001 static int 1002 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 1003 { 1004 struct adapter *adapter = ifp->if_softc; 1005 struct ifcapreq *ifcr = data; 1006 struct ifreq *ifr = data; 1007 int error = 0; 1008 int l4csum_en; 1009 const int l4csum = IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx| 1010 IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx; 1011 1012 switch (command) { 1013 case SIOCSIFFLAGS: 1014 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 1015 break; 1016 case SIOCADDMULTI: 1017 case SIOCDELMULTI: 1018 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 1019 break; 1020 case SIOCSIFMEDIA: 1021 case SIOCGIFMEDIA: 1022 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 1023 break; 1024 case SIOCSIFCAP: 1025 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 1026 break; 1027 case SIOCSIFMTU: 1028 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 1029 break; 1030 default: 1031 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)\n", (int)command); 1032 break; 1033 } 1034 1035 switch (command) { 1036 case SIOCSIFMEDIA: 1037 case SIOCGIFMEDIA: 1038 return ifmedia_ioctl(ifp, ifr, &adapter->media, command); 1039 case SIOCGI2C: 1040 { 1041 struct ixgbe_hw *hw = &adapter->hw; 1042 struct ixgbe_i2c_req i2c; 1043 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 1044 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 1045 if (error != 0) 1046 break; 1047 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 1048 error = EINVAL; 1049 break; 1050 } 1051 if (i2c.len > sizeof(i2c.data)) { 1052 error = EINVAL; 1053 break; 1054 } 1055 1056 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 1057 i2c.dev_addr, i2c.data); 1058 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 1059 break; 1060 } 1061 case SIOCSIFCAP: 1062 /* Layer-4 Rx checksum offload has to be turned on and 1063 * off as a unit. 1064 */ 1065 l4csum_en = ifcr->ifcr_capenable & l4csum; 1066 if (l4csum_en != l4csum && l4csum_en != 0) 1067 return EINVAL; 1068 /*FALLTHROUGH*/ 1069 case SIOCADDMULTI: 1070 case SIOCDELMULTI: 1071 case SIOCSIFFLAGS: 1072 case SIOCSIFMTU: 1073 default: 1074 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 1075 return error; 1076 if ((ifp->if_flags & IFF_RUNNING) == 0) 1077 ; 1078 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 1079 IXGBE_CORE_LOCK(adapter); 1080 ixgbe_init_locked(adapter); 1081 #ifdef PCI_IOV 1082 ixgbe_recalculate_max_frame(adapter); 1083 #endif 1084 IXGBE_CORE_UNLOCK(adapter); 1085 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 1086 /* 1087 * Multicast list has changed; set the hardware filter 1088 * accordingly. 1089 */ 1090 IXGBE_CORE_LOCK(adapter); 1091 ixgbe_disable_intr(adapter); 1092 ixgbe_set_multi(adapter); 1093 ixgbe_enable_intr(adapter); 1094 IXGBE_CORE_UNLOCK(adapter); 1095 } 1096 return 0; 1097 } 1098 1099 return error; 1100 } 1101 1102 /* 1103 * Set the various hardware offload abilities. 1104 * 1105 * This takes the ifnet's if_capenable flags (e.g. set by the user using 1106 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 1107 * mbuf offload flags the driver will understand. 1108 */ 1109 static void 1110 ixgbe_set_if_hwassist(struct adapter *adapter) 1111 { 1112 /* XXX */ 1113 } 1114 1115 /********************************************************************* 1116 * Init entry point 1117 * 1118 * This routine is used in two ways. It is used by the stack as 1119 * init entry point in network interface structure. It is also used 1120 * by the driver as a hw/sw initialization routine to get to a 1121 * consistent state. 1122 * 1123 * return 0 on success, positive on failure 1124 **********************************************************************/ 1125 #define IXGBE_MHADD_MFS_SHIFT 16 1126 1127 static void 1128 ixgbe_init_locked(struct adapter *adapter) 1129 { 1130 struct ifnet *ifp = adapter->ifp; 1131 device_t dev = adapter->dev; 1132 struct ixgbe_hw *hw = &adapter->hw; 1133 struct tx_ring *txr; 1134 struct rx_ring *rxr; 1135 u32 txdctl, mhadd; 1136 u32 rxdctl, rxctrl; 1137 int err = 0; 1138 #ifdef PCI_IOV 1139 enum ixgbe_iov_mode mode; 1140 #endif 1141 1142 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 1143 1144 KASSERT(mutex_owned(&adapter->core_mtx)); 1145 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 1146 1147 hw->adapter_stopped = FALSE; 1148 ixgbe_stop_adapter(hw); 1149 callout_stop(&adapter->timer); 1150 1151 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 1152 adapter->max_frame_size = 1153 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1154 1155 #ifdef PCI_IOV 1156 mode = ixgbe_get_iov_mode(adapter); 1157 adapter->pool = ixgbe_max_vfs(mode); 1158 /* Queue indices may change with IOV mode */ 1159 for (int i = 0; i < adapter->num_queues; i++) { 1160 adapter->rx_rings[i].me = ixgbe_pf_que_index(mode, i); 1161 adapter->tx_rings[i].me = ixgbe_pf_que_index(mode, i); 1162 } 1163 #endif 1164 /* reprogram the RAR[0] in case user changed it. */ 1165 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 1166 1167 /* Get the latest mac address, User can use a LAA */ 1168 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 1169 IXGBE_ETH_LENGTH_OF_ADDRESS); 1170 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 1171 hw->addr_ctrl.rar_used_count = 1; 1172 1173 /* Set hardware offload abilities from ifnet flags */ 1174 ixgbe_set_if_hwassist(adapter); 1175 1176 /* Prepare transmit descriptors and buffers */ 1177 if (ixgbe_setup_transmit_structures(adapter)) { 1178 device_printf(dev, "Could not setup transmit structures\n"); 1179 ixgbe_stop(adapter); 1180 return; 1181 } 1182 1183 ixgbe_init_hw(hw); 1184 #ifdef PCI_IOV 1185 ixgbe_initialize_iov(adapter); 1186 #endif 1187 ixgbe_initialize_transmit_units(adapter); 1188 1189 /* Setup Multicast table */ 1190 ixgbe_set_multi(adapter); 1191 1192 /* Determine the correct mbuf pool, based on frame size */ 1193 if (adapter->max_frame_size <= MCLBYTES) 1194 adapter->rx_mbuf_sz = MCLBYTES; 1195 else 1196 adapter->rx_mbuf_sz = MJUMPAGESIZE; 1197 1198 /* Prepare receive descriptors and buffers */ 1199 if (ixgbe_setup_receive_structures(adapter)) { 1200 device_printf(dev, "Could not setup receive structures\n"); 1201 ixgbe_stop(adapter); 1202 return; 1203 } 1204 1205 /* Configure RX settings */ 1206 ixgbe_initialize_receive_units(adapter); 1207 1208 /* Enable SDP & MSIX interrupts based on adapter */ 1209 ixgbe_config_gpie(adapter); 1210 1211 /* Set MTU size */ 1212 if (ifp->if_mtu > ETHERMTU) { 1213 /* aka IXGBE_MAXFRS on 82599 and newer */ 1214 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 1215 mhadd &= ~IXGBE_MHADD_MFS_MASK; 1216 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 1217 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 1218 } 1219 1220 /* Now enable all the queues */ 1221 for (int i = 0; i < adapter->num_queues; i++) { 1222 txr = &adapter->tx_rings[i]; 1223 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 1224 txdctl |= IXGBE_TXDCTL_ENABLE; 1225 /* Set WTHRESH to 8, burst writeback */ 1226 txdctl |= (8 << 16); 1227 /* 1228 * When the internal queue falls below PTHRESH (32), 1229 * start prefetching as long as there are at least 1230 * HTHRESH (1) buffers ready. The values are taken 1231 * from the Intel linux driver 3.8.21. 1232 * Prefetching enables tx line rate even with 1 queue. 1233 */ 1234 txdctl |= (32 << 0) | (1 << 8); 1235 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 1236 } 1237 1238 for (int i = 0, j = 0; i < adapter->num_queues; i++) { 1239 rxr = &adapter->rx_rings[i]; 1240 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 1241 if (hw->mac.type == ixgbe_mac_82598EB) { 1242 /* 1243 ** PTHRESH = 21 1244 ** HTHRESH = 4 1245 ** WTHRESH = 8 1246 */ 1247 rxdctl &= ~0x3FFFFF; 1248 rxdctl |= 0x080420; 1249 } 1250 rxdctl |= IXGBE_RXDCTL_ENABLE; 1251 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 1252 for (; j < 10; j++) { 1253 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 1254 IXGBE_RXDCTL_ENABLE) 1255 break; 1256 else 1257 msec_delay(1); 1258 } 1259 wmb(); 1260 #ifdef DEV_NETMAP 1261 /* 1262 * In netmap mode, we must preserve the buffers made 1263 * available to userspace before the if_init() 1264 * (this is true by default on the TX side, because 1265 * init makes all buffers available to userspace). 1266 * 1267 * netmap_reset() and the device specific routines 1268 * (e.g. ixgbe_setup_receive_rings()) map these 1269 * buffers at the end of the NIC ring, so here we 1270 * must set the RDT (tail) register to make sure 1271 * they are not overwritten. 1272 * 1273 * In this driver the NIC ring starts at RDH = 0, 1274 * RDT points to the last slot available for reception (?), 1275 * so RDT = num_rx_desc - 1 means the whole ring is available. 1276 */ 1277 if (ifp->if_capenable & IFCAP_NETMAP) { 1278 struct netmap_adapter *na = NA(adapter->ifp); 1279 struct netmap_kring *kring = &na->rx_rings[i]; 1280 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 1281 1282 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 1283 } else 1284 #endif /* DEV_NETMAP */ 1285 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), adapter->num_rx_desc - 1); 1286 } 1287 1288 /* Enable Receive engine */ 1289 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 1290 if (hw->mac.type == ixgbe_mac_82598EB) 1291 rxctrl |= IXGBE_RXCTRL_DMBYPS; 1292 rxctrl |= IXGBE_RXCTRL_RXEN; 1293 ixgbe_enable_rx_dma(hw, rxctrl); 1294 1295 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 1296 1297 /* Set up MSI/X routing */ 1298 if (ixgbe_enable_msix) { 1299 ixgbe_configure_ivars(adapter); 1300 /* Set up auto-mask */ 1301 if (hw->mac.type == ixgbe_mac_82598EB) 1302 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 1303 else { 1304 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 1305 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 1306 } 1307 } else { /* Simple settings for Legacy/MSI */ 1308 ixgbe_set_ivar(adapter, 0, 0, 0); 1309 ixgbe_set_ivar(adapter, 0, 0, 1); 1310 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 1311 } 1312 1313 #ifdef IXGBE_FDIR 1314 /* Init Flow director */ 1315 if (hw->mac.type != ixgbe_mac_82598EB) { 1316 u32 hdrm = 32 << fdir_pballoc; 1317 1318 hw->mac.ops.setup_rxpba(hw, 0, hdrm, PBA_STRATEGY_EQUAL); 1319 ixgbe_init_fdir_signature_82599(&adapter->hw, fdir_pballoc); 1320 } 1321 #endif 1322 1323 /* 1324 * Check on any SFP devices that 1325 * need to be kick-started 1326 */ 1327 if (hw->phy.type == ixgbe_phy_none) { 1328 err = hw->phy.ops.identify(hw); 1329 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 1330 device_printf(dev, 1331 "Unsupported SFP+ module type was detected.\n"); 1332 return; 1333 } 1334 } 1335 1336 /* Set moderation on the Link interrupt */ 1337 IXGBE_WRITE_REG(hw, IXGBE_EITR(adapter->vector), IXGBE_LINK_ITR); 1338 1339 /* Configure Energy Efficient Ethernet for supported devices */ 1340 if (hw->mac.ops.setup_eee) { 1341 err = hw->mac.ops.setup_eee(hw, adapter->eee_enabled); 1342 if (err) 1343 device_printf(dev, "Error setting up EEE: %d\n", err); 1344 } 1345 1346 /* Enable power to the phy. */ 1347 ixgbe_set_phy_power(hw, TRUE); 1348 1349 /* Config/Enable Link */ 1350 ixgbe_config_link(adapter); 1351 1352 /* Hardware Packet Buffer & Flow Control setup */ 1353 ixgbe_config_delay_values(adapter); 1354 1355 /* Initialize the FC settings */ 1356 ixgbe_start_hw(hw); 1357 1358 /* Set up VLAN support and filter */ 1359 ixgbe_setup_vlan_hw_support(adapter); 1360 1361 /* Setup DMA Coalescing */ 1362 ixgbe_config_dmac(adapter); 1363 1364 /* And now turn on interrupts */ 1365 ixgbe_enable_intr(adapter); 1366 1367 #ifdef PCI_IOV 1368 /* Enable the use of the MBX by the VF's */ 1369 { 1370 u32 reg = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 1371 reg |= IXGBE_CTRL_EXT_PFRSTD; 1372 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, reg); 1373 } 1374 #endif 1375 1376 /* Now inform the stack we're ready */ 1377 ifp->if_flags |= IFF_RUNNING; 1378 1379 return; 1380 } 1381 1382 static int 1383 ixgbe_init(struct ifnet *ifp) 1384 { 1385 struct adapter *adapter = ifp->if_softc; 1386 1387 IXGBE_CORE_LOCK(adapter); 1388 ixgbe_init_locked(adapter); 1389 IXGBE_CORE_UNLOCK(adapter); 1390 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 1391 } 1392 1393 static void 1394 ixgbe_config_gpie(struct adapter *adapter) 1395 { 1396 struct ixgbe_hw *hw = &adapter->hw; 1397 u32 gpie; 1398 1399 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 1400 1401 /* Fan Failure Interrupt */ 1402 if (hw->device_id == IXGBE_DEV_ID_82598AT) 1403 gpie |= IXGBE_SDP1_GPIEN; 1404 1405 /* 1406 * Module detection (SDP2) 1407 * Media ready (SDP1) 1408 */ 1409 if (hw->mac.type == ixgbe_mac_82599EB) { 1410 gpie |= IXGBE_SDP2_GPIEN; 1411 if (hw->device_id != IXGBE_DEV_ID_82599_QSFP_SF_QP) 1412 gpie |= IXGBE_SDP1_GPIEN; 1413 } 1414 1415 /* 1416 * Thermal Failure Detection (X540) 1417 * Link Detection (X552 SFP+, X552/X557-AT) 1418 */ 1419 if (hw->mac.type == ixgbe_mac_X540 || 1420 hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 1421 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 1422 gpie |= IXGBE_SDP0_GPIEN_X540; 1423 1424 if (adapter->msix > 1) { 1425 /* Enable Enhanced MSIX mode */ 1426 gpie |= IXGBE_GPIE_MSIX_MODE; 1427 gpie |= IXGBE_GPIE_EIAME | IXGBE_GPIE_PBA_SUPPORT | 1428 IXGBE_GPIE_OCD; 1429 } 1430 1431 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 1432 return; 1433 } 1434 1435 /* 1436 * Requires adapter->max_frame_size to be set. 1437 */ 1438 static void 1439 ixgbe_config_delay_values(struct adapter *adapter) 1440 { 1441 struct ixgbe_hw *hw = &adapter->hw; 1442 u32 rxpb, frame, size, tmp; 1443 1444 frame = adapter->max_frame_size; 1445 1446 /* Calculate High Water */ 1447 switch (hw->mac.type) { 1448 case ixgbe_mac_X540: 1449 case ixgbe_mac_X550: 1450 case ixgbe_mac_X550EM_x: 1451 tmp = IXGBE_DV_X540(frame, frame); 1452 break; 1453 default: 1454 tmp = IXGBE_DV(frame, frame); 1455 break; 1456 } 1457 size = IXGBE_BT2KB(tmp); 1458 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 1459 hw->fc.high_water[0] = rxpb - size; 1460 1461 /* Now calculate Low Water */ 1462 switch (hw->mac.type) { 1463 case ixgbe_mac_X540: 1464 case ixgbe_mac_X550: 1465 case ixgbe_mac_X550EM_x: 1466 tmp = IXGBE_LOW_DV_X540(frame); 1467 break; 1468 default: 1469 tmp = IXGBE_LOW_DV(frame); 1470 break; 1471 } 1472 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 1473 1474 hw->fc.requested_mode = adapter->fc; 1475 hw->fc.pause_time = IXGBE_FC_PAUSE; 1476 hw->fc.send_xon = TRUE; 1477 } 1478 1479 /* 1480 ** 1481 ** MSIX Interrupt Handlers and Tasklets 1482 ** 1483 */ 1484 1485 static inline void 1486 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 1487 { 1488 struct ixgbe_hw *hw = &adapter->hw; 1489 u64 queue = (u64)(1ULL << vector); 1490 u32 mask; 1491 1492 if (hw->mac.type == ixgbe_mac_82598EB) { 1493 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 1494 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 1495 } else { 1496 mask = (queue & 0xFFFFFFFF); 1497 if (mask) 1498 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 1499 mask = (queue >> 32); 1500 if (mask) 1501 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 1502 } 1503 } 1504 1505 __unused static inline void 1506 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 1507 { 1508 struct ixgbe_hw *hw = &adapter->hw; 1509 u64 queue = (u64)(1ULL << vector); 1510 u32 mask; 1511 1512 if (hw->mac.type == ixgbe_mac_82598EB) { 1513 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 1514 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 1515 } else { 1516 mask = (queue & 0xFFFFFFFF); 1517 if (mask) 1518 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 1519 mask = (queue >> 32); 1520 if (mask) 1521 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 1522 } 1523 } 1524 1525 static void 1526 ixgbe_handle_que(void *context) 1527 { 1528 struct ix_queue *que = context; 1529 struct adapter *adapter = que->adapter; 1530 struct tx_ring *txr = que->txr; 1531 struct ifnet *ifp = adapter->ifp; 1532 1533 adapter->handleq.ev_count++; 1534 1535 if (ifp->if_flags & IFF_RUNNING) { 1536 ixgbe_rxeof(que); 1537 IXGBE_TX_LOCK(txr); 1538 ixgbe_txeof(txr); 1539 #ifndef IXGBE_LEGACY_TX 1540 if (!drbr_empty(ifp, txr->br)) 1541 ixgbe_mq_start_locked(ifp, txr); 1542 #else 1543 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1544 ixgbe_start_locked(txr, ifp); 1545 #endif 1546 IXGBE_TX_UNLOCK(txr); 1547 } 1548 1549 /* Reenable this interrupt */ 1550 if (que->res != NULL) 1551 ixgbe_enable_queue(adapter, que->msix); 1552 else 1553 ixgbe_enable_intr(adapter); 1554 return; 1555 } 1556 1557 1558 /********************************************************************* 1559 * 1560 * Legacy Interrupt Service routine 1561 * 1562 **********************************************************************/ 1563 1564 static int 1565 ixgbe_legacy_irq(void *arg) 1566 { 1567 struct ix_queue *que = arg; 1568 struct adapter *adapter = que->adapter; 1569 struct ixgbe_hw *hw = &adapter->hw; 1570 struct ifnet *ifp = adapter->ifp; 1571 struct tx_ring *txr = adapter->tx_rings; 1572 bool more = false; 1573 u32 reg_eicr; 1574 1575 1576 reg_eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 1577 1578 adapter->stats.pf.legint.ev_count++; 1579 ++que->irqs.ev_count; 1580 if (reg_eicr == 0) { 1581 adapter->stats.pf.intzero.ev_count++; 1582 if ((ifp->if_flags & IFF_UP) != 0) 1583 ixgbe_enable_intr(adapter); 1584 return 0; 1585 } 1586 1587 if ((ifp->if_flags & IFF_RUNNING) != 0) { 1588 #ifdef __NetBSD__ 1589 /* Don't run ixgbe_rxeof in interrupt context */ 1590 more = true; 1591 #else 1592 more = ixgbe_rxeof(que); 1593 #endif 1594 1595 IXGBE_TX_LOCK(txr); 1596 ixgbe_txeof(txr); 1597 #ifdef IXGBE_LEGACY_TX 1598 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 1599 ixgbe_start_locked(txr, ifp); 1600 #else 1601 if (!drbr_empty(ifp, txr->br)) 1602 ixgbe_mq_start_locked(ifp, txr); 1603 #endif 1604 IXGBE_TX_UNLOCK(txr); 1605 } 1606 1607 /* Check for fan failure */ 1608 if ((hw->device_id == IXGBE_DEV_ID_82598AT) && 1609 (reg_eicr & IXGBE_EICR_GPI_SDP1)) { 1610 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! " 1611 "REPLACE IMMEDIATELY!!\n"); 1612 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 1613 } 1614 1615 /* Link status change */ 1616 if (reg_eicr & IXGBE_EICR_LSC) 1617 softint_schedule(adapter->link_si); 1618 1619 /* External PHY interrupt */ 1620 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 1621 (reg_eicr & IXGBE_EICR_GPI_SDP0_X540)) 1622 softint_schedule(adapter->phy_si); 1623 1624 if (more) 1625 #ifndef IXGBE_LEGACY_TX 1626 softint_schedule(txr->txq_si); 1627 #else 1628 softint_schedule(que->que_si); 1629 #endif 1630 else 1631 ixgbe_enable_intr(adapter); 1632 return 1; 1633 } 1634 1635 1636 /********************************************************************* 1637 * 1638 * MSIX Queue Interrupt Service routine 1639 * 1640 **********************************************************************/ 1641 static int 1642 ixgbe_msix_que(void *arg) 1643 { 1644 struct ix_queue *que = arg; 1645 struct adapter *adapter = que->adapter; 1646 struct ifnet *ifp = adapter->ifp; 1647 struct tx_ring *txr = que->txr; 1648 struct rx_ring *rxr = que->rxr; 1649 bool more; 1650 u32 newitr = 0; 1651 1652 1653 /* Protect against spurious interrupts */ 1654 if ((ifp->if_flags & IFF_RUNNING) == 0) 1655 return 0; 1656 1657 ixgbe_disable_queue(adapter, que->msix); 1658 ++que->irqs.ev_count; 1659 1660 #ifdef __NetBSD__ 1661 /* Don't run ixgbe_rxeof in interrupt context */ 1662 more = true; 1663 #else 1664 more = ixgbe_rxeof(que); 1665 #endif 1666 1667 IXGBE_TX_LOCK(txr); 1668 ixgbe_txeof(txr); 1669 #ifdef IXGBE_LEGACY_TX 1670 if (!IFQ_IS_EMPTY(&adapter->ifp->if_snd)) 1671 ixgbe_start_locked(txr, ifp); 1672 #else 1673 if (!drbr_empty(ifp, txr->br)) 1674 ixgbe_mq_start_locked(ifp, txr); 1675 #endif 1676 IXGBE_TX_UNLOCK(txr); 1677 1678 /* Do AIM now? */ 1679 1680 if (adapter->enable_aim == FALSE) 1681 goto no_calc; 1682 /* 1683 ** Do Adaptive Interrupt Moderation: 1684 ** - Write out last calculated setting 1685 ** - Calculate based on average size over 1686 ** the last interval. 1687 */ 1688 if (que->eitr_setting) 1689 IXGBE_WRITE_REG(&adapter->hw, 1690 IXGBE_EITR(que->msix), que->eitr_setting); 1691 1692 que->eitr_setting = 0; 1693 1694 /* Idle, do nothing */ 1695 if ((txr->bytes == 0) && (rxr->bytes == 0)) 1696 goto no_calc; 1697 1698 if ((txr->bytes) && (txr->packets)) 1699 newitr = txr->bytes/txr->packets; 1700 if ((rxr->bytes) && (rxr->packets)) 1701 newitr = max(newitr, 1702 (rxr->bytes / rxr->packets)); 1703 newitr += 24; /* account for hardware frame, crc */ 1704 1705 /* set an upper boundary */ 1706 newitr = min(newitr, 3000); 1707 1708 /* Be nice to the mid range */ 1709 if ((newitr > 300) && (newitr < 1200)) 1710 newitr = (newitr / 3); 1711 else 1712 newitr = (newitr / 2); 1713 1714 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 1715 newitr |= newitr << 16; 1716 else 1717 newitr |= IXGBE_EITR_CNT_WDIS; 1718 1719 /* save for next interrupt */ 1720 que->eitr_setting = newitr; 1721 1722 /* Reset state */ 1723 txr->bytes = 0; 1724 txr->packets = 0; 1725 rxr->bytes = 0; 1726 rxr->packets = 0; 1727 1728 no_calc: 1729 if (more) 1730 softint_schedule(que->que_si); 1731 else 1732 ixgbe_enable_queue(adapter, que->msix); 1733 return 1; 1734 } 1735 1736 1737 static int 1738 ixgbe_msix_link(void *arg) 1739 { 1740 struct adapter *adapter = arg; 1741 struct ixgbe_hw *hw = &adapter->hw; 1742 u32 reg_eicr, mod_mask; 1743 1744 ++adapter->link_irq.ev_count; 1745 1746 /* Pause other interrupts */ 1747 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_OTHER); 1748 1749 /* First get the cause */ 1750 reg_eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 1751 /* Be sure the queue bits are not cleared */ 1752 reg_eicr &= ~IXGBE_EICR_RTX_QUEUE; 1753 /* Clear interrupt with write */ 1754 IXGBE_WRITE_REG(hw, IXGBE_EICR, reg_eicr); 1755 1756 /* Link status change */ 1757 if (reg_eicr & IXGBE_EICR_LSC) { 1758 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); 1759 softint_schedule(adapter->link_si); 1760 } 1761 1762 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 1763 #ifdef IXGBE_FDIR 1764 if (reg_eicr & IXGBE_EICR_FLOW_DIR) { 1765 /* This is probably overkill :) */ 1766 if (!atomic_cmpset_int(&adapter->fdir_reinit, 0, 1)) 1767 return 1; 1768 /* Disable the interrupt */ 1769 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EICR_FLOW_DIR); 1770 softint_schedule(adapter->fdir_si); 1771 } else 1772 #endif 1773 if (reg_eicr & IXGBE_EICR_ECC) { 1774 device_printf(adapter->dev, "CRITICAL: ECC ERROR!! " 1775 "Please Reboot!!\n"); 1776 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC); 1777 } 1778 1779 /* Check for over temp condition */ 1780 if (reg_eicr & IXGBE_EICR_TS) { 1781 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! " 1782 "PHY IS SHUT DOWN!!\n"); 1783 device_printf(adapter->dev, "System shutdown required!\n"); 1784 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS); 1785 } 1786 #ifdef PCI_IOV 1787 if (reg_eicr & IXGBE_EICR_MAILBOX) 1788 taskqueue_enqueue(adapter->tq, &adapter->mbx_task); 1789 #endif 1790 } 1791 1792 /* Pluggable optics-related interrupt */ 1793 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP) 1794 mod_mask = IXGBE_EICR_GPI_SDP0_X540; 1795 else 1796 mod_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 1797 1798 if (ixgbe_is_sfp(hw)) { 1799 if (reg_eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw)) { 1800 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 1801 softint_schedule(adapter->msf_si); 1802 } else if (reg_eicr & mod_mask) { 1803 IXGBE_WRITE_REG(hw, IXGBE_EICR, mod_mask); 1804 softint_schedule(adapter->mod_si); 1805 } 1806 } 1807 1808 /* Check for fan failure */ 1809 if ((hw->device_id == IXGBE_DEV_ID_82598AT) && 1810 (reg_eicr & IXGBE_EICR_GPI_SDP1)) { 1811 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1); 1812 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! " 1813 "REPLACE IMMEDIATELY!!\n"); 1814 } 1815 1816 /* External PHY interrupt */ 1817 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 1818 (reg_eicr & IXGBE_EICR_GPI_SDP0_X540)) { 1819 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540); 1820 softint_schedule(adapter->phy_si); 1821 } 1822 1823 /* Re-enable other interrupts */ 1824 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, IXGBE_EIMS_OTHER); 1825 return 1; 1826 } 1827 1828 /********************************************************************* 1829 * 1830 * Media Ioctl callback 1831 * 1832 * This routine is called whenever the user queries the status of 1833 * the interface using ifconfig. 1834 * 1835 **********************************************************************/ 1836 static void 1837 ixgbe_media_status(struct ifnet * ifp, struct ifmediareq * ifmr) 1838 { 1839 struct adapter *adapter = ifp->if_softc; 1840 struct ixgbe_hw *hw = &adapter->hw; 1841 int layer; 1842 1843 INIT_DEBUGOUT("ixgbe_media_status: begin"); 1844 IXGBE_CORE_LOCK(adapter); 1845 ixgbe_update_link_status(adapter); 1846 1847 ifmr->ifm_status = IFM_AVALID; 1848 ifmr->ifm_active = IFM_ETHER; 1849 1850 if (!adapter->link_active) { 1851 IXGBE_CORE_UNLOCK(adapter); 1852 return; 1853 } 1854 1855 ifmr->ifm_status |= IFM_ACTIVE; 1856 layer = adapter->phy_layer; 1857 1858 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 1859 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 1860 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) 1861 switch (adapter->link_speed) { 1862 case IXGBE_LINK_SPEED_10GB_FULL: 1863 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 1864 break; 1865 case IXGBE_LINK_SPEED_1GB_FULL: 1866 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 1867 break; 1868 case IXGBE_LINK_SPEED_100_FULL: 1869 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 1870 break; 1871 } 1872 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 1873 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 1874 switch (adapter->link_speed) { 1875 case IXGBE_LINK_SPEED_10GB_FULL: 1876 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 1877 break; 1878 } 1879 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 1880 switch (adapter->link_speed) { 1881 case IXGBE_LINK_SPEED_10GB_FULL: 1882 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 1883 break; 1884 case IXGBE_LINK_SPEED_1GB_FULL: 1885 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 1886 break; 1887 } 1888 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 1889 switch (adapter->link_speed) { 1890 case IXGBE_LINK_SPEED_10GB_FULL: 1891 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 1892 break; 1893 case IXGBE_LINK_SPEED_1GB_FULL: 1894 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 1895 break; 1896 } 1897 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 1898 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 1899 switch (adapter->link_speed) { 1900 case IXGBE_LINK_SPEED_10GB_FULL: 1901 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 1902 break; 1903 case IXGBE_LINK_SPEED_1GB_FULL: 1904 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 1905 break; 1906 } 1907 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 1908 switch (adapter->link_speed) { 1909 case IXGBE_LINK_SPEED_10GB_FULL: 1910 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 1911 break; 1912 } 1913 /* 1914 ** XXX: These need to use the proper media types once 1915 ** they're added. 1916 */ 1917 #ifndef IFM_ETH_XTYPE 1918 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 1919 switch (adapter->link_speed) { 1920 case IXGBE_LINK_SPEED_10GB_FULL: 1921 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 1922 break; 1923 case IXGBE_LINK_SPEED_2_5GB_FULL: 1924 ifmr->ifm_active |= IFM_2500_SX | IFM_FDX; 1925 break; 1926 case IXGBE_LINK_SPEED_1GB_FULL: 1927 ifmr->ifm_active |= IFM_1000_CX | IFM_FDX; 1928 break; 1929 } 1930 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 1931 || layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 1932 switch (adapter->link_speed) { 1933 case IXGBE_LINK_SPEED_10GB_FULL: 1934 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 1935 break; 1936 case IXGBE_LINK_SPEED_2_5GB_FULL: 1937 ifmr->ifm_active |= IFM_2500_SX | IFM_FDX; 1938 break; 1939 case IXGBE_LINK_SPEED_1GB_FULL: 1940 ifmr->ifm_active |= IFM_1000_CX | IFM_FDX; 1941 break; 1942 } 1943 #else 1944 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 1945 switch (adapter->link_speed) { 1946 case IXGBE_LINK_SPEED_10GB_FULL: 1947 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 1948 break; 1949 case IXGBE_LINK_SPEED_2_5GB_FULL: 1950 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 1951 break; 1952 case IXGBE_LINK_SPEED_1GB_FULL: 1953 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 1954 break; 1955 } 1956 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 1957 || layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 1958 switch (adapter->link_speed) { 1959 case IXGBE_LINK_SPEED_10GB_FULL: 1960 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 1961 break; 1962 case IXGBE_LINK_SPEED_2_5GB_FULL: 1963 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 1964 break; 1965 case IXGBE_LINK_SPEED_1GB_FULL: 1966 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 1967 break; 1968 } 1969 #endif 1970 1971 /* If nothing is recognized... */ 1972 #if 0 1973 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 1974 ifmr->ifm_active |= IFM_UNKNOWN; 1975 #endif 1976 1977 /* Display current flow control setting used on link */ 1978 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 1979 hw->fc.current_mode == ixgbe_fc_full) 1980 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 1981 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 1982 hw->fc.current_mode == ixgbe_fc_full) 1983 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 1984 1985 IXGBE_CORE_UNLOCK(adapter); 1986 1987 return; 1988 } 1989 1990 /********************************************************************* 1991 * 1992 * Media Ioctl callback 1993 * 1994 * This routine is called when the user changes speed/duplex using 1995 * media/mediopt option with ifconfig. 1996 * 1997 **********************************************************************/ 1998 static int 1999 ixgbe_media_change(struct ifnet * ifp) 2000 { 2001 struct adapter *adapter = ifp->if_softc; 2002 struct ifmedia *ifm = &adapter->media; 2003 struct ixgbe_hw *hw = &adapter->hw; 2004 ixgbe_link_speed speed = 0; 2005 2006 INIT_DEBUGOUT("ixgbe_media_change: begin"); 2007 2008 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 2009 return (EINVAL); 2010 2011 if (hw->phy.media_type == ixgbe_media_type_backplane) 2012 return (ENODEV); 2013 2014 /* 2015 ** We don't actually need to check against the supported 2016 ** media types of the adapter; ifmedia will take care of 2017 ** that for us. 2018 */ 2019 #ifndef IFM_ETH_XTYPE 2020 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2021 case IFM_AUTO: 2022 case IFM_10G_T: 2023 speed |= IXGBE_LINK_SPEED_100_FULL; 2024 case IFM_10G_LRM: 2025 case IFM_10G_SR: /* KR, too */ 2026 case IFM_10G_LR: 2027 case IFM_10G_CX4: /* KX4 */ 2028 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2029 case IFM_10G_TWINAX: 2030 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2031 break; 2032 case IFM_1000_T: 2033 speed |= IXGBE_LINK_SPEED_100_FULL; 2034 case IFM_1000_LX: 2035 case IFM_1000_SX: 2036 case IFM_1000_CX: /* KX */ 2037 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2038 break; 2039 case IFM_100_TX: 2040 speed |= IXGBE_LINK_SPEED_100_FULL; 2041 break; 2042 default: 2043 goto invalid; 2044 } 2045 #else 2046 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2047 case IFM_AUTO: 2048 case IFM_10G_T: 2049 speed |= IXGBE_LINK_SPEED_100_FULL; 2050 case IFM_10G_LRM: 2051 case IFM_10G_KR: 2052 case IFM_10G_LR: 2053 case IFM_10G_KX4: 2054 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2055 case IFM_10G_TWINAX: 2056 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2057 break; 2058 case IFM_1000_T: 2059 speed |= IXGBE_LINK_SPEED_100_FULL; 2060 case IFM_1000_LX: 2061 case IFM_1000_SX: 2062 case IFM_1000_KX: 2063 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2064 break; 2065 case IFM_100_TX: 2066 speed |= IXGBE_LINK_SPEED_100_FULL; 2067 break; 2068 default: 2069 goto invalid; 2070 } 2071 #endif 2072 2073 hw->mac.autotry_restart = TRUE; 2074 hw->mac.ops.setup_link(hw, speed, TRUE); 2075 if (IFM_SUBTYPE(ifm->ifm_media) == IFM_AUTO) { 2076 adapter->advertise = 0; 2077 } else { 2078 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 2079 adapter->advertise |= 1 << 2; 2080 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 2081 adapter->advertise |= 1 << 1; 2082 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 2083 adapter->advertise |= 1 << 0; 2084 } 2085 2086 return (0); 2087 2088 invalid: 2089 device_printf(adapter->dev, "Invalid media type!\n"); 2090 return (EINVAL); 2091 } 2092 2093 static void 2094 ixgbe_set_promisc(struct adapter *adapter) 2095 { 2096 struct ether_multi *enm; 2097 struct ether_multistep step; 2098 u_int32_t reg_rctl; 2099 struct ethercom *ec = &adapter->osdep.ec; 2100 struct ifnet *ifp = adapter->ifp; 2101 int mcnt = 0; 2102 2103 reg_rctl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 2104 reg_rctl &= (~IXGBE_FCTRL_UPE); 2105 if (ifp->if_flags & IFF_ALLMULTI) 2106 mcnt = MAX_NUM_MULTICAST_ADDRESSES; 2107 else { 2108 ETHER_FIRST_MULTI(step, ec, enm); 2109 while (enm != NULL) { 2110 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) 2111 break; 2112 mcnt++; 2113 ETHER_NEXT_MULTI(step, enm); 2114 } 2115 } 2116 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) 2117 reg_rctl &= (~IXGBE_FCTRL_MPE); 2118 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 2119 2120 if (ifp->if_flags & IFF_PROMISC) { 2121 reg_rctl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 2122 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 2123 } else if (ifp->if_flags & IFF_ALLMULTI) { 2124 reg_rctl |= IXGBE_FCTRL_MPE; 2125 reg_rctl &= ~IXGBE_FCTRL_UPE; 2126 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, reg_rctl); 2127 } 2128 return; 2129 } 2130 2131 2132 /********************************************************************* 2133 * Multicast Update 2134 * 2135 * This routine is called whenever multicast address list is updated. 2136 * 2137 **********************************************************************/ 2138 #define IXGBE_RAR_ENTRIES 16 2139 2140 static void 2141 ixgbe_set_multi(struct adapter *adapter) 2142 { 2143 u32 fctrl; 2144 u8 *update_ptr; 2145 struct ixgbe_mc_addr *mta; 2146 int mcnt = 0; 2147 struct ifnet *ifp = adapter->ifp; 2148 struct ethercom *ec = &adapter->osdep.ec; 2149 struct ether_multi *enm; 2150 struct ether_multistep step; 2151 2152 IOCTL_DEBUGOUT("ixgbe_set_multi: begin"); 2153 2154 mta = adapter->mta; 2155 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 2156 2157 ifp->if_flags &= ~IFF_ALLMULTI; 2158 ETHER_FIRST_MULTI(step, ec, enm); 2159 while (enm != NULL) { 2160 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 2161 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 2162 ETHER_ADDR_LEN) != 0)) { 2163 ifp->if_flags |= IFF_ALLMULTI; 2164 break; 2165 } 2166 bcopy(enm->enm_addrlo, 2167 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 2168 mta[mcnt].vmdq = adapter->pool; 2169 mcnt++; 2170 ETHER_NEXT_MULTI(step, enm); 2171 } 2172 2173 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 2174 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 2175 if (ifp->if_flags & IFF_PROMISC) 2176 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 2177 else if (ifp->if_flags & IFF_ALLMULTI) { 2178 fctrl |= IXGBE_FCTRL_MPE; 2179 } 2180 2181 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 2182 2183 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) { 2184 update_ptr = (u8 *)mta; 2185 ixgbe_update_mc_addr_list(&adapter->hw, 2186 update_ptr, mcnt, ixgbe_mc_array_itr, TRUE); 2187 } 2188 2189 return; 2190 } 2191 2192 /* 2193 * This is an iterator function now needed by the multicast 2194 * shared code. It simply feeds the shared code routine the 2195 * addresses in the array of ixgbe_set_multi() one by one. 2196 */ 2197 static u8 * 2198 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 2199 { 2200 struct ixgbe_mc_addr *mta; 2201 2202 mta = (struct ixgbe_mc_addr *)*update_ptr; 2203 *vmdq = mta->vmdq; 2204 2205 *update_ptr = (u8*)(mta + 1); 2206 return (mta->addr); 2207 } 2208 2209 2210 /********************************************************************* 2211 * Timer routine 2212 * 2213 * This routine checks for link status,updates statistics, 2214 * and runs the watchdog check. 2215 * 2216 **********************************************************************/ 2217 2218 static void 2219 ixgbe_local_timer1(void *arg) 2220 { 2221 struct adapter *adapter = arg; 2222 device_t dev = adapter->dev; 2223 struct ix_queue *que = adapter->queues; 2224 u64 queues = 0; 2225 int hung = 0; 2226 2227 KASSERT(mutex_owned(&adapter->core_mtx)); 2228 2229 /* Check for pluggable optics */ 2230 if (adapter->sfp_probe) 2231 if (!ixgbe_sfp_probe(adapter)) 2232 goto out; /* Nothing to do */ 2233 2234 ixgbe_update_link_status(adapter); 2235 ixgbe_update_stats_counters(adapter); 2236 2237 /* 2238 ** Check the TX queues status 2239 ** - mark hung queues so we don't schedule on them 2240 ** - watchdog only if all queues show hung 2241 */ 2242 for (int i = 0; i < adapter->num_queues; i++, que++) { 2243 /* Keep track of queues with work for soft irq */ 2244 if (que->txr->busy) 2245 queues |= ((u64)1 << que->me); 2246 /* 2247 ** Each time txeof runs without cleaning, but there 2248 ** are uncleaned descriptors it increments busy. If 2249 ** we get to the MAX we declare it hung. 2250 */ 2251 if (que->busy == IXGBE_QUEUE_HUNG) { 2252 ++hung; 2253 /* Mark the queue as inactive */ 2254 adapter->active_queues &= ~((u64)1 << que->me); 2255 continue; 2256 } else { 2257 /* Check if we've come back from hung */ 2258 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 2259 adapter->active_queues |= ((u64)1 << que->me); 2260 } 2261 if (que->busy >= IXGBE_MAX_TX_BUSY) { 2262 device_printf(dev,"Warning queue %d " 2263 "appears to be hung!\n", i); 2264 que->txr->busy = IXGBE_QUEUE_HUNG; 2265 ++hung; 2266 } 2267 2268 } 2269 /* Only truely watchdog if all queues show hung */ 2270 if (hung == adapter->num_queues) 2271 goto watchdog; 2272 else if (queues != 0) { /* Force an IRQ on queues with work */ 2273 ixgbe_rearm_queues(adapter, queues); 2274 } 2275 2276 out: 2277 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 2278 return; 2279 2280 watchdog: 2281 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 2282 adapter->ifp->if_flags &= ~IFF_RUNNING; 2283 adapter->watchdog_events.ev_count++; 2284 ixgbe_init_locked(adapter); 2285 } 2286 2287 static void 2288 ixgbe_local_timer(void *arg) 2289 { 2290 struct adapter *adapter = arg; 2291 2292 IXGBE_CORE_LOCK(adapter); 2293 ixgbe_local_timer1(adapter); 2294 IXGBE_CORE_UNLOCK(adapter); 2295 } 2296 2297 2298 /* 2299 ** Note: this routine updates the OS on the link state 2300 ** the real check of the hardware only happens with 2301 ** a link interrupt. 2302 */ 2303 static void 2304 ixgbe_update_link_status(struct adapter *adapter) 2305 { 2306 struct ifnet *ifp = adapter->ifp; 2307 device_t dev = adapter->dev; 2308 2309 if (adapter->link_up){ 2310 if (adapter->link_active == FALSE) { 2311 if (bootverbose) 2312 device_printf(dev,"Link is up %d Gbps %s \n", 2313 ((adapter->link_speed == 128)? 10:1), 2314 "Full Duplex"); 2315 adapter->link_active = TRUE; 2316 /* Update any Flow Control changes */ 2317 ixgbe_fc_enable(&adapter->hw); 2318 /* Update DMA coalescing config */ 2319 ixgbe_config_dmac(adapter); 2320 if_link_state_change(ifp, LINK_STATE_UP); 2321 #ifdef PCI_IOV 2322 ixgbe_ping_all_vfs(adapter); 2323 #endif 2324 } 2325 } else { /* Link down */ 2326 if (adapter->link_active == TRUE) { 2327 if (bootverbose) 2328 device_printf(dev,"Link is Down\n"); 2329 if_link_state_change(ifp, LINK_STATE_DOWN); 2330 adapter->link_active = FALSE; 2331 #ifdef PCI_IOV 2332 ixgbe_ping_all_vfs(adapter); 2333 #endif 2334 } 2335 } 2336 2337 return; 2338 } 2339 2340 2341 static void 2342 ixgbe_ifstop(struct ifnet *ifp, int disable) 2343 { 2344 struct adapter *adapter = ifp->if_softc; 2345 2346 IXGBE_CORE_LOCK(adapter); 2347 ixgbe_stop(adapter); 2348 IXGBE_CORE_UNLOCK(adapter); 2349 } 2350 2351 /********************************************************************* 2352 * 2353 * This routine disables all traffic on the adapter by issuing a 2354 * global reset on the MAC and deallocates TX/RX buffers. 2355 * 2356 **********************************************************************/ 2357 2358 static void 2359 ixgbe_stop(void *arg) 2360 { 2361 struct ifnet *ifp; 2362 struct adapter *adapter = arg; 2363 struct ixgbe_hw *hw = &adapter->hw; 2364 ifp = adapter->ifp; 2365 2366 KASSERT(mutex_owned(&adapter->core_mtx)); 2367 2368 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 2369 ixgbe_disable_intr(adapter); 2370 callout_stop(&adapter->timer); 2371 2372 /* Let the stack know...*/ 2373 ifp->if_flags &= ~IFF_RUNNING; 2374 2375 ixgbe_reset_hw(hw); 2376 hw->adapter_stopped = FALSE; 2377 ixgbe_stop_adapter(hw); 2378 if (hw->mac.type == ixgbe_mac_82599EB) 2379 ixgbe_stop_mac_link_on_d3_82599(hw); 2380 /* Turn off the laser - noop with no optics */ 2381 ixgbe_disable_tx_laser(hw); 2382 2383 /* Update the stack */ 2384 adapter->link_up = FALSE; 2385 ixgbe_update_link_status(adapter); 2386 2387 /* reprogram the RAR[0] in case user changed it. */ 2388 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 2389 2390 return; 2391 } 2392 2393 2394 /********************************************************************* 2395 * 2396 * Determine hardware revision. 2397 * 2398 **********************************************************************/ 2399 static void 2400 ixgbe_identify_hardware(struct adapter *adapter) 2401 { 2402 pcitag_t tag; 2403 pci_chipset_tag_t pc; 2404 pcireg_t subid, id; 2405 struct ixgbe_hw *hw = &adapter->hw; 2406 2407 pc = adapter->osdep.pc; 2408 tag = adapter->osdep.tag; 2409 2410 id = pci_conf_read(pc, tag, PCI_ID_REG); 2411 subid = pci_conf_read(pc, tag, PCI_SUBSYS_ID_REG); 2412 2413 /* Save off the information about this board */ 2414 hw->vendor_id = PCI_VENDOR(id); 2415 hw->device_id = PCI_PRODUCT(id); 2416 hw->revision_id = 2417 PCI_REVISION(pci_conf_read(pc, tag, PCI_CLASS_REG)); 2418 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 2419 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 2420 2421 /* 2422 ** Make sure BUSMASTER is set 2423 */ 2424 ixgbe_pci_enable_busmaster(pc, tag); 2425 2426 /* We need this here to set the num_segs below */ 2427 ixgbe_set_mac_type(hw); 2428 2429 /* Pick up the 82599 settings */ 2430 if (hw->mac.type != ixgbe_mac_82598EB) { 2431 hw->phy.smart_speed = ixgbe_smart_speed; 2432 adapter->num_segs = IXGBE_82599_SCATTER; 2433 } else 2434 adapter->num_segs = IXGBE_82598_SCATTER; 2435 2436 return; 2437 } 2438 2439 /********************************************************************* 2440 * 2441 * Determine optic type 2442 * 2443 **********************************************************************/ 2444 static void 2445 ixgbe_setup_optics(struct adapter *adapter) 2446 { 2447 struct ixgbe_hw *hw = &adapter->hw; 2448 int layer; 2449 2450 layer = adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 2451 2452 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) { 2453 adapter->optics = IFM_10G_T; 2454 return; 2455 } 2456 2457 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) { 2458 adapter->optics = IFM_1000_T; 2459 return; 2460 } 2461 2462 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) { 2463 adapter->optics = IFM_1000_SX; 2464 return; 2465 } 2466 2467 if (layer & (IXGBE_PHYSICAL_LAYER_10GBASE_LR | 2468 IXGBE_PHYSICAL_LAYER_10GBASE_LRM)) { 2469 adapter->optics = IFM_10G_LR; 2470 return; 2471 } 2472 2473 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 2474 adapter->optics = IFM_10G_SR; 2475 return; 2476 } 2477 2478 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU) { 2479 adapter->optics = IFM_10G_TWINAX; 2480 return; 2481 } 2482 2483 if (layer & (IXGBE_PHYSICAL_LAYER_10GBASE_KX4 | 2484 IXGBE_PHYSICAL_LAYER_10GBASE_CX4)) { 2485 adapter->optics = IFM_10G_CX4; 2486 return; 2487 } 2488 2489 /* If we get here just set the default */ 2490 adapter->optics = IFM_ETHER | IFM_AUTO; 2491 return; 2492 } 2493 2494 /********************************************************************* 2495 * 2496 * Setup the Legacy or MSI Interrupt handler 2497 * 2498 **********************************************************************/ 2499 static int 2500 ixgbe_allocate_legacy(struct adapter *adapter, 2501 const struct pci_attach_args *pa) 2502 { 2503 device_t dev = adapter->dev; 2504 struct ix_queue *que = adapter->queues; 2505 #ifndef IXGBE_LEGACY_TX 2506 struct tx_ring *txr = adapter->tx_rings; 2507 #endif 2508 int counts[PCI_INTR_TYPE_SIZE]; 2509 pci_intr_type_t intr_type, max_type; 2510 char intrbuf[PCI_INTRSTR_LEN]; 2511 const char *intrstr = NULL; 2512 2513 /* Allocation settings */ 2514 max_type = PCI_INTR_TYPE_MSI; 2515 counts[PCI_INTR_TYPE_MSIX] = 0; 2516 counts[PCI_INTR_TYPE_MSI] = 1; 2517 counts[PCI_INTR_TYPE_INTX] = 1; 2518 2519 alloc_retry: 2520 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 2521 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 2522 return ENXIO; 2523 } 2524 adapter->osdep.nintrs = 1; 2525 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 2526 intrbuf, sizeof(intrbuf)); 2527 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 2528 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 2529 device_xname(dev)); 2530 if (adapter->osdep.ihs[0] == NULL) { 2531 intr_type = pci_intr_type(adapter->osdep.pc, 2532 adapter->osdep.intrs[0]); 2533 aprint_error_dev(dev,"unable to establish %s\n", 2534 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 2535 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 2536 switch (intr_type) { 2537 case PCI_INTR_TYPE_MSI: 2538 /* The next try is for INTx: Disable MSI */ 2539 max_type = PCI_INTR_TYPE_INTX; 2540 counts[PCI_INTR_TYPE_INTX] = 1; 2541 goto alloc_retry; 2542 case PCI_INTR_TYPE_INTX: 2543 default: 2544 /* See below */ 2545 break; 2546 } 2547 } 2548 if (adapter->osdep.ihs[0] == NULL) { 2549 aprint_error_dev(dev, 2550 "couldn't establish interrupt%s%s\n", 2551 intrstr ? " at " : "", intrstr ? intrstr : ""); 2552 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 2553 return ENXIO; 2554 } 2555 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 2556 /* 2557 * Try allocating a fast interrupt and the associated deferred 2558 * processing contexts. 2559 */ 2560 #ifndef IXGBE_LEGACY_TX 2561 txr->txq_si = softint_establish(SOFTINT_NET, ixgbe_deferred_mq_start, 2562 txr); 2563 #endif 2564 que->que_si = softint_establish(SOFTINT_NET, ixgbe_handle_que, que); 2565 2566 /* Tasklets for Link, SFP and Multispeed Fiber */ 2567 adapter->link_si = 2568 softint_establish(SOFTINT_NET, ixgbe_handle_link, adapter); 2569 adapter->mod_si = 2570 softint_establish(SOFTINT_NET, ixgbe_handle_mod, adapter); 2571 adapter->msf_si = 2572 softint_establish(SOFTINT_NET, ixgbe_handle_msf, adapter); 2573 adapter->phy_si = 2574 softint_establish(SOFTINT_NET, ixgbe_handle_phy, adapter); 2575 2576 #ifdef IXGBE_FDIR 2577 adapter->fdir_si = 2578 softint_establish(SOFTINT_NET, ixgbe_reinit_fdir, adapter); 2579 #endif 2580 if (que->que_si == NULL || 2581 adapter->link_si == NULL || 2582 adapter->mod_si == NULL || 2583 #ifdef IXGBE_FDIR 2584 adapter->fdir_si == NULL || 2585 #endif 2586 adapter->msf_si == NULL) { 2587 aprint_error_dev(dev, 2588 "could not establish software interrupts\n"); 2589 return ENXIO; 2590 } 2591 2592 /* For simplicity in the handlers */ 2593 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 2594 2595 return (0); 2596 } 2597 2598 2599 /********************************************************************* 2600 * 2601 * Setup MSIX Interrupt resources and handlers 2602 * 2603 **********************************************************************/ 2604 static int 2605 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 2606 { 2607 device_t dev = adapter->dev; 2608 struct ix_queue *que = adapter->queues; 2609 struct tx_ring *txr = adapter->tx_rings; 2610 pci_chipset_tag_t pc; 2611 char intrbuf[PCI_INTRSTR_LEN]; 2612 char intr_xname[32]; 2613 const char *intrstr = NULL; 2614 int error, vector = 0; 2615 int cpu_id = 0; 2616 kcpuset_t *affinity; 2617 #ifdef RSS 2618 cpuset_t cpu_mask; 2619 #endif 2620 2621 pc = adapter->osdep.pc; 2622 #ifdef RSS 2623 /* 2624 * If we're doing RSS, the number of queues needs to 2625 * match the number of RSS buckets that are configured. 2626 * 2627 * + If there's more queues than RSS buckets, we'll end 2628 * up with queues that get no traffic. 2629 * 2630 * + If there's more RSS buckets than queues, we'll end 2631 * up having multiple RSS buckets map to the same queue, 2632 * so there'll be some contention. 2633 */ 2634 if (adapter->num_queues != rss_getnumbuckets()) { 2635 device_printf(dev, 2636 "%s: number of queues (%d) != number of RSS buckets (%d)" 2637 "; performance will be impacted.\n", 2638 __func__, 2639 adapter->num_queues, 2640 rss_getnumbuckets()); 2641 } 2642 #endif 2643 2644 adapter->osdep.nintrs = adapter->num_queues + 1; 2645 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 2646 adapter->osdep.nintrs) != 0) { 2647 aprint_error_dev(dev, 2648 "failed to allocate MSI-X interrupt\n"); 2649 return (ENXIO); 2650 } 2651 2652 kcpuset_create(&affinity, false); 2653 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 2654 snprintf(intr_xname, sizeof(intr_xname), "%s TX/RX", 2655 device_xname(dev)); 2656 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 2657 sizeof(intrbuf)); 2658 #ifdef IXG_MPSAFE 2659 pci_intr_setattr(pc, adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 2660 true); 2661 #endif 2662 /* Set the handler function */ 2663 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 2664 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 2665 intr_xname); 2666 if (que->res == NULL) { 2667 pci_intr_release(pc, adapter->osdep.intrs, 2668 adapter->osdep.nintrs); 2669 aprint_error_dev(dev, 2670 "Failed to register QUE handler\n"); 2671 kcpuset_destroy(affinity); 2672 return ENXIO; 2673 } 2674 que->msix = vector; 2675 adapter->active_queues |= (u64)(1 << que->msix); 2676 #ifdef RSS 2677 /* 2678 * The queue ID is used as the RSS layer bucket ID. 2679 * We look up the queue ID -> RSS CPU ID and select 2680 * that. 2681 */ 2682 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 2683 #else 2684 /* 2685 * Bind the msix vector, and thus the 2686 * rings to the corresponding cpu. 2687 * 2688 * This just happens to match the default RSS round-robin 2689 * bucket -> queue -> CPU allocation. 2690 */ 2691 if (adapter->num_queues > 1) 2692 cpu_id = i; 2693 #endif 2694 /* Round-robin affinity */ 2695 kcpuset_zero(affinity); 2696 kcpuset_set(affinity, cpu_id % ncpu); 2697 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 2698 NULL); 2699 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 2700 intrstr); 2701 if (error == 0) { 2702 #ifdef IXGBE_DEBUG 2703 #ifdef RSS 2704 aprintf_normal( 2705 ", bound RSS bucket %d to CPU %d\n", 2706 i, cpu_id); 2707 #else 2708 aprint_normal( 2709 ", bound queue %d to cpu %d\n", 2710 i, cpu_id); 2711 #endif 2712 #endif /* IXGBE_DEBUG */ 2713 } else 2714 aprint_normal("\n"); 2715 #ifndef IXGBE_LEGACY_TX 2716 txr->txq_si = softint_establish(SOFTINT_NET, 2717 ixgbe_deferred_mq_start, txr); 2718 #endif 2719 que->que_si = softint_establish(SOFTINT_NET, ixgbe_handle_que, 2720 que); 2721 if (que->que_si == NULL) { 2722 aprint_error_dev(dev, 2723 "could not establish software interrupt\n"); 2724 } 2725 } 2726 2727 /* and Link */ 2728 cpu_id++; 2729 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 2730 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 2731 sizeof(intrbuf)); 2732 #ifdef IXG_MPSAFE 2733 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 2734 true); 2735 #endif 2736 /* Set the link handler function */ 2737 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 2738 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 2739 intr_xname); 2740 if (adapter->osdep.ihs[vector] == NULL) { 2741 adapter->res = NULL; 2742 aprint_error_dev(dev, "Failed to register LINK handler\n"); 2743 kcpuset_destroy(affinity); 2744 return (ENXIO); 2745 } 2746 /* Round-robin affinity */ 2747 kcpuset_zero(affinity); 2748 kcpuset_set(affinity, cpu_id % ncpu); 2749 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity,NULL); 2750 2751 aprint_normal_dev(dev, 2752 "for link, interrupting at %s", intrstr); 2753 if (error == 0) 2754 aprint_normal(", affinity to cpu %d\n", cpu_id); 2755 else 2756 aprint_normal("\n"); 2757 2758 adapter->vector = vector; 2759 /* Tasklets for Link, SFP and Multispeed Fiber */ 2760 adapter->link_si = 2761 softint_establish(SOFTINT_NET, ixgbe_handle_link, adapter); 2762 adapter->mod_si = 2763 softint_establish(SOFTINT_NET, ixgbe_handle_mod, adapter); 2764 adapter->msf_si = 2765 softint_establish(SOFTINT_NET, ixgbe_handle_msf, adapter); 2766 #ifdef PCI_IOV 2767 TASK_INIT(&adapter->mbx_task, 0, ixgbe_handle_mbx, adapter); 2768 #endif 2769 adapter->phy_si = 2770 softint_establish(SOFTINT_NET, ixgbe_handle_phy, adapter); 2771 #ifdef IXGBE_FDIR 2772 adapter->fdir_si = 2773 softint_establish(SOFTINT_NET, ixgbe_reinit_fdir, adapter); 2774 #endif 2775 2776 kcpuset_destroy(affinity); 2777 return (0); 2778 } 2779 2780 /* 2781 * Setup Either MSI/X or MSI 2782 */ 2783 static int 2784 ixgbe_setup_msix(struct adapter *adapter) 2785 { 2786 device_t dev = adapter->dev; 2787 int want, queues, msgs; 2788 2789 /* Override by tuneable */ 2790 if (ixgbe_enable_msix == 0) 2791 goto msi; 2792 2793 /* First try MSI/X */ 2794 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 2795 if (msgs < IXG_MSIX_NINTR) 2796 goto msi; 2797 2798 adapter->msix_mem = (void *)1; /* XXX */ 2799 2800 /* Figure out a reasonable auto config value */ 2801 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 2802 2803 #ifdef RSS 2804 /* If we're doing RSS, clamp at the number of RSS buckets */ 2805 if (queues > rss_getnumbuckets()) 2806 queues = rss_getnumbuckets(); 2807 #endif 2808 2809 if (ixgbe_num_queues != 0) 2810 queues = ixgbe_num_queues; 2811 /* Set max queues to 8 when autoconfiguring */ 2812 else if ((ixgbe_num_queues == 0) && (queues > 8)) 2813 queues = 8; 2814 2815 /* reflect correct sysctl value */ 2816 ixgbe_num_queues = queues; 2817 2818 /* 2819 ** Want one vector (RX/TX pair) per queue 2820 ** plus an additional for Link. 2821 */ 2822 want = queues + 1; 2823 if (msgs >= want) 2824 msgs = want; 2825 else { 2826 aprint_error_dev(dev, 2827 "MSIX Configuration Problem, " 2828 "%d vectors but %d queues wanted!\n", 2829 msgs, want); 2830 goto msi; 2831 } 2832 device_printf(dev, 2833 "Using MSIX interrupts with %d vectors\n", msgs); 2834 adapter->num_queues = queues; 2835 return (msgs); 2836 2837 /* 2838 ** If MSIX alloc failed or provided us with 2839 ** less than needed, free and fall through to MSI 2840 */ 2841 msi: 2842 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 2843 adapter->msix_mem = NULL; /* XXX */ 2844 msgs = 1; 2845 aprint_normal_dev(dev, "Using an MSI interrupt\n"); 2846 return (msgs); 2847 } 2848 2849 2850 static int 2851 ixgbe_allocate_pci_resources(struct adapter *adapter, 2852 const struct pci_attach_args *pa) 2853 { 2854 pcireg_t memtype; 2855 device_t dev = adapter->dev; 2856 bus_addr_t addr; 2857 int flags; 2858 2859 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 2860 switch (memtype) { 2861 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 2862 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 2863 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 2864 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 2865 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 2866 goto map_err; 2867 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 2868 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 2869 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 2870 } 2871 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 2872 adapter->osdep.mem_size, flags, 2873 &adapter->osdep.mem_bus_space_handle) != 0) { 2874 map_err: 2875 adapter->osdep.mem_size = 0; 2876 aprint_error_dev(dev, "unable to map BAR0\n"); 2877 return ENXIO; 2878 } 2879 break; 2880 default: 2881 aprint_error_dev(dev, "unexpected type on BAR0\n"); 2882 return ENXIO; 2883 } 2884 adapter->hw.back = adapter; 2885 2886 /* Default to 1 queue if MSI-X setup fails */ 2887 adapter->num_queues = 1; 2888 2889 /* 2890 ** Now setup MSI or MSI-X, should 2891 ** return us the number of supported 2892 ** vectors. (Will be 1 for MSI) 2893 */ 2894 adapter->msix = ixgbe_setup_msix(adapter); 2895 return (0); 2896 } 2897 2898 static void 2899 ixgbe_free_pci_resources(struct adapter * adapter) 2900 { 2901 struct ix_queue *que = adapter->queues; 2902 int rid; 2903 2904 /* 2905 ** Release all msix queue resources: 2906 */ 2907 for (int i = 0; i < adapter->num_queues; i++, que++) { 2908 if (que->res != NULL) 2909 pci_intr_disestablish(adapter->osdep.pc, 2910 adapter->osdep.ihs[i]); 2911 } 2912 2913 2914 /* Clean the Legacy or Link interrupt last */ 2915 if (adapter->vector) /* we are doing MSIX */ 2916 rid = adapter->vector; 2917 else 2918 rid = 0; 2919 2920 if (adapter->osdep.ihs[rid] != NULL) { 2921 pci_intr_disestablish(adapter->osdep.pc, 2922 adapter->osdep.ihs[rid]); 2923 adapter->osdep.ihs[rid] = NULL; 2924 } 2925 2926 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 2927 adapter->osdep.nintrs); 2928 2929 if (adapter->osdep.mem_size != 0) { 2930 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 2931 adapter->osdep.mem_bus_space_handle, 2932 adapter->osdep.mem_size); 2933 } 2934 2935 return; 2936 } 2937 2938 /********************************************************************* 2939 * 2940 * Setup networking device structure and register an interface. 2941 * 2942 **********************************************************************/ 2943 static int 2944 ixgbe_setup_interface(device_t dev, struct adapter *adapter) 2945 { 2946 struct ethercom *ec = &adapter->osdep.ec; 2947 struct ifnet *ifp; 2948 2949 INIT_DEBUGOUT("ixgbe_setup_interface: begin"); 2950 2951 ifp = adapter->ifp = &ec->ec_if; 2952 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 2953 ifp->if_baudrate = IF_Gbps(10); 2954 ifp->if_init = ixgbe_init; 2955 ifp->if_stop = ixgbe_ifstop; 2956 ifp->if_softc = adapter; 2957 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 2958 ifp->if_ioctl = ixgbe_ioctl; 2959 #if __FreeBSD_version >= 1100045 2960 /* TSO parameters */ 2961 ifp->if_hw_tsomax = 65518; 2962 ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER; 2963 ifp->if_hw_tsomaxsegsize = 2048; 2964 #endif 2965 #ifndef IXGBE_LEGACY_TX 2966 ifp->if_transmit = ixgbe_mq_start; 2967 ifp->if_qflush = ixgbe_qflush; 2968 #else 2969 ifp->if_start = ixgbe_start; 2970 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 2971 #if 0 2972 ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 2; 2973 #endif 2974 IFQ_SET_READY(&ifp->if_snd); 2975 #endif 2976 2977 if_initialize(ifp); 2978 ether_ifattach(ifp, adapter->hw.mac.addr); 2979 if_register(ifp); 2980 ether_set_ifflags_cb(ec, ixgbe_ifflags_cb); 2981 2982 adapter->max_frame_size = 2983 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 2984 2985 /* 2986 * Tell the upper layer(s) we support long frames. 2987 */ 2988 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 2989 2990 /* Set capability flags */ 2991 ifp->if_capabilities |= IFCAP_RXCSUM 2992 | IFCAP_TXCSUM 2993 | IFCAP_TSOv4 2994 | IFCAP_TSOv6 2995 | IFCAP_LRO; 2996 ifp->if_capenable = 0; 2997 2998 ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING 2999 | ETHERCAP_VLAN_HWCSUM 3000 | ETHERCAP_JUMBO_MTU 3001 | ETHERCAP_VLAN_MTU; 3002 3003 /* Enable the above capabilities by default */ 3004 ec->ec_capenable = ec->ec_capabilities; 3005 3006 /* 3007 ** Don't turn this on by default, if vlans are 3008 ** created on another pseudo device (eg. lagg) 3009 ** then vlan events are not passed thru, breaking 3010 ** operation, but with HW FILTER off it works. If 3011 ** using vlans directly on the ixgbe driver you can 3012 ** enable this and get full hardware tag filtering. 3013 */ 3014 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER; 3015 3016 /* 3017 * Specify the media types supported by this adapter and register 3018 * callbacks to update media and link information 3019 */ 3020 ifmedia_init(&adapter->media, IFM_IMASK, ixgbe_media_change, 3021 ixgbe_media_status); 3022 3023 adapter->phy_layer = ixgbe_get_supported_physical_layer(&adapter->hw); 3024 ixgbe_add_media_types(adapter); 3025 3026 /* Set autoselect media by default */ 3027 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 3028 3029 return (0); 3030 } 3031 3032 static void 3033 ixgbe_add_media_types(struct adapter *adapter) 3034 { 3035 struct ixgbe_hw *hw = &adapter->hw; 3036 device_t dev = adapter->dev; 3037 int layer; 3038 3039 layer = adapter->phy_layer; 3040 3041 /* Media types with matching NetBSD media defines */ 3042 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) 3043 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_T, 0, NULL); 3044 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) 3045 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 3046 if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) 3047 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 0, NULL); 3048 3049 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 3050 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 3051 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_TWINAX, 0, NULL); 3052 3053 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) { 3054 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_LR, 0, NULL); 3055 if (hw->phy.multispeed_fiber) 3056 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_LX, 0, NULL); 3057 } 3058 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 3059 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_SR, 0, NULL); 3060 if (hw->phy.multispeed_fiber) 3061 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 0, NULL); 3062 } else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 3063 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 0, NULL); 3064 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 3065 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_CX4, 0, NULL); 3066 3067 #ifdef IFM_ETH_XTYPE 3068 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 3069 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_KR, 0, NULL); 3070 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) 3071 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_KX4, 0, NULL); 3072 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 3073 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_KX, 0, NULL); 3074 #else 3075 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) { 3076 device_printf(dev, "Media supported: 10GbaseKR\n"); 3077 device_printf(dev, "10GbaseKR mapped to 10GbaseSR\n"); 3078 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_SR, 0, NULL); 3079 } 3080 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) { 3081 device_printf(dev, "Media supported: 10GbaseKX4\n"); 3082 device_printf(dev, "10GbaseKX4 mapped to 10GbaseCX4\n"); 3083 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10G_CX4, 0, NULL); 3084 } 3085 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) { 3086 device_printf(dev, "Media supported: 1000baseKX\n"); 3087 device_printf(dev, "1000baseKX mapped to 1000baseCX\n"); 3088 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_CX, 0, NULL); 3089 } 3090 #endif 3091 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX) 3092 device_printf(dev, "Media supported: 1000baseBX\n"); 3093 3094 if (hw->device_id == IXGBE_DEV_ID_82598AT) { 3095 ifmedia_add(&adapter->media, 3096 IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL); 3097 ifmedia_add(&adapter->media, 3098 IFM_ETHER | IFM_1000_T, 0, NULL); 3099 } 3100 3101 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 3102 } 3103 3104 static void 3105 ixgbe_config_link(struct adapter *adapter) 3106 { 3107 struct ixgbe_hw *hw = &adapter->hw; 3108 u32 autoneg, err = 0; 3109 bool sfp, negotiate; 3110 3111 sfp = ixgbe_is_sfp(hw); 3112 3113 if (sfp) { 3114 kpreempt_disable(); 3115 softint_schedule(adapter->mod_si); 3116 kpreempt_enable(); 3117 } else { 3118 if (hw->mac.ops.check_link) 3119 err = ixgbe_check_link(hw, &adapter->link_speed, 3120 &adapter->link_up, FALSE); 3121 if (err) 3122 goto out; 3123 autoneg = hw->phy.autoneg_advertised; 3124 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 3125 err = hw->mac.ops.get_link_capabilities(hw, 3126 &autoneg, &negotiate); 3127 else 3128 negotiate = 0; 3129 if (err) 3130 goto out; 3131 if (hw->mac.ops.setup_link) 3132 err = hw->mac.ops.setup_link(hw, 3133 autoneg, adapter->link_up); 3134 } 3135 out: 3136 return; 3137 } 3138 3139 3140 /********************************************************************* 3141 * 3142 * Enable transmit units. 3143 * 3144 **********************************************************************/ 3145 static void 3146 ixgbe_initialize_transmit_units(struct adapter *adapter) 3147 { 3148 struct tx_ring *txr = adapter->tx_rings; 3149 struct ixgbe_hw *hw = &adapter->hw; 3150 3151 /* Setup the Base and Length of the Tx Descriptor Ring */ 3152 for (int i = 0; i < adapter->num_queues; i++, txr++) { 3153 u64 tdba = txr->txdma.dma_paddr; 3154 u32 txctrl = 0; 3155 int j = txr->me; 3156 3157 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j), 3158 (tdba & 0x00000000ffffffffULL)); 3159 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32)); 3160 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), 3161 adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc)); 3162 3163 /* Setup the HW Tx Head and Tail descriptor pointers */ 3164 IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0); 3165 IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); 3166 3167 /* Cache the tail address */ 3168 txr->tail = IXGBE_TDT(j); 3169 3170 /* Disable Head Writeback */ 3171 /* 3172 * Note: for X550 series devices, these registers are actually 3173 * prefixed with TPH_ isntead of DCA_, but the addresses and 3174 * fields remain the same. 3175 */ 3176 switch (hw->mac.type) { 3177 case ixgbe_mac_82598EB: 3178 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); 3179 break; 3180 default: 3181 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j)); 3182 break; 3183 } 3184 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 3185 switch (hw->mac.type) { 3186 case ixgbe_mac_82598EB: 3187 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); 3188 break; 3189 default: 3190 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl); 3191 break; 3192 } 3193 3194 } 3195 3196 if (hw->mac.type != ixgbe_mac_82598EB) { 3197 u32 dmatxctl, rttdcs; 3198 #ifdef PCI_IOV 3199 enum ixgbe_iov_mode mode = ixgbe_get_iov_mode(adapter); 3200 #endif 3201 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL); 3202 dmatxctl |= IXGBE_DMATXCTL_TE; 3203 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl); 3204 /* Disable arbiter to set MTQC */ 3205 rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS); 3206 rttdcs |= IXGBE_RTTDCS_ARBDIS; 3207 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 3208 #ifdef PCI_IOV 3209 IXGBE_WRITE_REG(hw, IXGBE_MTQC, ixgbe_get_mtqc(mode)); 3210 #else 3211 IXGBE_WRITE_REG(hw, IXGBE_MTQC, IXGBE_MTQC_64Q_1PB); 3212 #endif 3213 rttdcs &= ~IXGBE_RTTDCS_ARBDIS; 3214 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 3215 } 3216 3217 return; 3218 } 3219 3220 static void 3221 ixgbe_initialize_rss_mapping(struct adapter *adapter) 3222 { 3223 struct ixgbe_hw *hw = &adapter->hw; 3224 u32 reta = 0, mrqc, rss_key[10]; 3225 int queue_id, table_size, index_mult; 3226 #ifdef RSS 3227 u32 rss_hash_config; 3228 #endif 3229 #ifdef PCI_IOV 3230 enum ixgbe_iov_mode mode; 3231 #endif 3232 3233 #ifdef RSS 3234 /* Fetch the configured RSS key */ 3235 rss_getkey((uint8_t *) &rss_key); 3236 #else 3237 /* set up random bits */ 3238 cprng_fast(&rss_key, sizeof(rss_key)); 3239 #endif 3240 3241 /* Set multiplier for RETA setup and table size based on MAC */ 3242 index_mult = 0x1; 3243 table_size = 128; 3244 switch (adapter->hw.mac.type) { 3245 case ixgbe_mac_82598EB: 3246 index_mult = 0x11; 3247 break; 3248 case ixgbe_mac_X550: 3249 case ixgbe_mac_X550EM_x: 3250 table_size = 512; 3251 break; 3252 default: 3253 break; 3254 } 3255 3256 /* Set up the redirection table */ 3257 for (int i = 0, j = 0; i < table_size; i++, j++) { 3258 if (j == adapter->num_queues) j = 0; 3259 #ifdef RSS 3260 /* 3261 * Fetch the RSS bucket id for the given indirection entry. 3262 * Cap it at the number of configured buckets (which is 3263 * num_queues.) 3264 */ 3265 queue_id = rss_get_indirection_to_bucket(i); 3266 queue_id = queue_id % adapter->num_queues; 3267 #else 3268 queue_id = (j * index_mult); 3269 #endif 3270 /* 3271 * The low 8 bits are for hash value (n+0); 3272 * The next 8 bits are for hash value (n+1), etc. 3273 */ 3274 reta = reta >> 8; 3275 reta = reta | ( ((uint32_t) queue_id) << 24); 3276 if ((i & 3) == 3) { 3277 if (i < 128) 3278 IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta); 3279 else 3280 IXGBE_WRITE_REG(hw, IXGBE_ERETA((i >> 2) - 32), reta); 3281 reta = 0; 3282 } 3283 } 3284 3285 /* Now fill our hash function seeds */ 3286 for (int i = 0; i < 10; i++) 3287 IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), rss_key[i]); 3288 3289 /* Perform hash on these packet types */ 3290 #ifdef RSS 3291 mrqc = IXGBE_MRQC_RSSEN; 3292 rss_hash_config = rss_gethashconfig(); 3293 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 3294 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 3295 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 3296 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 3297 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 3298 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 3299 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 3300 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 3301 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 3302 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX; 3303 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 3304 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP; 3305 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 3306 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 3307 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4_EX) 3308 device_printf(adapter->dev, 3309 "%s: RSS_HASHTYPE_RSS_UDP_IPV4_EX defined, " 3310 "but not supported\n", __func__); 3311 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 3312 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 3313 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 3314 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP; 3315 #else 3316 /* 3317 * Disable UDP - IP fragments aren't currently being handled 3318 * and so we end up with a mix of 2-tuple and 4-tuple 3319 * traffic. 3320 */ 3321 mrqc = IXGBE_MRQC_RSSEN 3322 | IXGBE_MRQC_RSS_FIELD_IPV4 3323 | IXGBE_MRQC_RSS_FIELD_IPV4_TCP 3324 | IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP 3325 | IXGBE_MRQC_RSS_FIELD_IPV6_EX 3326 | IXGBE_MRQC_RSS_FIELD_IPV6 3327 | IXGBE_MRQC_RSS_FIELD_IPV6_TCP 3328 ; 3329 #endif /* RSS */ 3330 #ifdef PCI_IOV 3331 mode = ixgbe_get_iov_mode(adapter); 3332 mrqc |= ixgbe_get_mrqc(mode); 3333 #endif 3334 IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc); 3335 } 3336 3337 3338 /********************************************************************* 3339 * 3340 * Setup receive registers and features. 3341 * 3342 **********************************************************************/ 3343 #define IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT 2 3344 3345 #define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1) 3346 3347 static void 3348 ixgbe_initialize_receive_units(struct adapter *adapter) 3349 { 3350 int i; 3351 struct rx_ring *rxr = adapter->rx_rings; 3352 struct ixgbe_hw *hw = &adapter->hw; 3353 struct ifnet *ifp = adapter->ifp; 3354 u32 bufsz, fctrl, srrctl, rxcsum; 3355 u32 hlreg; 3356 3357 /* 3358 * Make sure receives are disabled while 3359 * setting up the descriptor ring 3360 */ 3361 ixgbe_disable_rx(hw); 3362 3363 /* Enable broadcasts */ 3364 fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL); 3365 fctrl |= IXGBE_FCTRL_BAM; 3366 if (adapter->hw.mac.type == ixgbe_mac_82598EB) { 3367 fctrl |= IXGBE_FCTRL_DPF; 3368 fctrl |= IXGBE_FCTRL_PMCF; 3369 } 3370 IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl); 3371 3372 /* Set for Jumbo Frames? */ 3373 hlreg = IXGBE_READ_REG(hw, IXGBE_HLREG0); 3374 if (ifp->if_mtu > ETHERMTU) 3375 hlreg |= IXGBE_HLREG0_JUMBOEN; 3376 else 3377 hlreg &= ~IXGBE_HLREG0_JUMBOEN; 3378 #ifdef DEV_NETMAP 3379 /* crcstrip is conditional in netmap (in RDRXCTL too ?) */ 3380 if (ifp->if_capenable & IFCAP_NETMAP && !ix_crcstrip) 3381 hlreg &= ~IXGBE_HLREG0_RXCRCSTRP; 3382 else 3383 hlreg |= IXGBE_HLREG0_RXCRCSTRP; 3384 #endif /* DEV_NETMAP */ 3385 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg); 3386 3387 bufsz = (adapter->rx_mbuf_sz + 3388 BSIZEPKT_ROUNDUP) >> IXGBE_SRRCTL_BSIZEPKT_SHIFT; 3389 3390 for (i = 0; i < adapter->num_queues; i++, rxr++) { 3391 u64 rdba = rxr->rxdma.dma_paddr; 3392 int j = rxr->me; 3393 3394 /* Setup the Base and Length of the Rx Descriptor Ring */ 3395 IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), 3396 (rdba & 0x00000000ffffffffULL)); 3397 IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32)); 3398 IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), 3399 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 3400 3401 /* Set up the SRRCTL register */ 3402 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(j)); 3403 srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 3404 srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 3405 srrctl |= bufsz; 3406 srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 3407 3408 /* 3409 * Set DROP_EN iff we have no flow control and >1 queue. 3410 * Note that srrctl was cleared shortly before during reset, 3411 * so we do not need to clear the bit, but do it just in case 3412 * this code is moved elsewhere. 3413 */ 3414 if (adapter->num_queues > 1 && 3415 adapter->hw.fc.requested_mode == ixgbe_fc_none) { 3416 srrctl |= IXGBE_SRRCTL_DROP_EN; 3417 } else { 3418 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 3419 } 3420 3421 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(j), srrctl); 3422 3423 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 3424 IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0); 3425 IXGBE_WRITE_REG(hw, IXGBE_RDT(j), 0); 3426 3427 /* Set the driver rx tail address */ 3428 rxr->tail = IXGBE_RDT(rxr->me); 3429 } 3430 3431 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 3432 u32 psrtype = IXGBE_PSRTYPE_TCPHDR | 3433 IXGBE_PSRTYPE_UDPHDR | 3434 IXGBE_PSRTYPE_IPV4HDR | 3435 IXGBE_PSRTYPE_IPV6HDR; 3436 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype); 3437 } 3438 3439 rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM); 3440 3441 ixgbe_initialize_rss_mapping(adapter); 3442 3443 if (adapter->num_queues > 1) { 3444 /* RSS and RX IPP Checksum are mutually exclusive */ 3445 rxcsum |= IXGBE_RXCSUM_PCSD; 3446 } 3447 3448 if (ifp->if_capenable & IFCAP_RXCSUM) 3449 rxcsum |= IXGBE_RXCSUM_PCSD; 3450 3451 /* This is useful for calculating UDP/IP fragment checksums */ 3452 if (!(rxcsum & IXGBE_RXCSUM_PCSD)) 3453 rxcsum |= IXGBE_RXCSUM_IPPCSE; 3454 3455 IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum); 3456 3457 return; 3458 } 3459 3460 3461 #if 0 /* XXX Badly need to overhaul vlan(4) on NetBSD. */ 3462 /* 3463 ** This routine is run via an vlan config EVENT, 3464 ** it enables us to use the HW Filter table since 3465 ** we can get the vlan id. This just creates the 3466 ** entry in the soft version of the VFTA, init will 3467 ** repopulate the real table. 3468 */ 3469 static void 3470 ixgbe_register_vlan(void *arg, struct ifnet *ifp, u16 vtag) 3471 { 3472 struct adapter *adapter = ifp->if_softc; 3473 u16 index, bit; 3474 3475 if (ifp->if_softc != arg) /* Not our event */ 3476 return; 3477 3478 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 3479 return; 3480 3481 IXGBE_CORE_LOCK(adapter); 3482 index = (vtag >> 5) & 0x7F; 3483 bit = vtag & 0x1F; 3484 adapter->shadow_vfta[index] |= (1 << bit); 3485 ixgbe_setup_vlan_hw_support(adapter); 3486 IXGBE_CORE_UNLOCK(adapter); 3487 } 3488 3489 /* 3490 ** This routine is run via an vlan 3491 ** unconfig EVENT, remove our entry 3492 ** in the soft vfta. 3493 */ 3494 static void 3495 ixgbe_unregister_vlan(void *arg, struct ifnet *ifp, u16 vtag) 3496 { 3497 struct adapter *adapter = ifp->if_softc; 3498 u16 index, bit; 3499 3500 if (ifp->if_softc != arg) 3501 return; 3502 3503 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 3504 return; 3505 3506 IXGBE_CORE_LOCK(adapter); 3507 index = (vtag >> 5) & 0x7F; 3508 bit = vtag & 0x1F; 3509 adapter->shadow_vfta[index] &= ~(1 << bit); 3510 /* Re-init to load the changes */ 3511 ixgbe_setup_vlan_hw_support(adapter); 3512 IXGBE_CORE_UNLOCK(adapter); 3513 } 3514 #endif 3515 3516 static void 3517 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 3518 { 3519 struct ethercom *ec = &adapter->osdep.ec; 3520 struct ixgbe_hw *hw = &adapter->hw; 3521 struct rx_ring *rxr; 3522 u32 ctrl; 3523 3524 3525 /* 3526 ** We get here thru init_locked, meaning 3527 ** a soft reset, this has already cleared 3528 ** the VFTA and other state, so if there 3529 ** have been no vlan's registered do nothing. 3530 */ 3531 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 3532 return; 3533 3534 /* Setup the queues for vlans */ 3535 for (int i = 0; i < adapter->num_queues; i++) { 3536 rxr = &adapter->rx_rings[i]; 3537 /* On 82599 the VLAN enable is per/queue in RXDCTL */ 3538 if (hw->mac.type != ixgbe_mac_82598EB) { 3539 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 3540 ctrl |= IXGBE_RXDCTL_VME; 3541 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 3542 } 3543 rxr->vtag_strip = TRUE; 3544 } 3545 3546 if ((ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) == 0) 3547 return; 3548 /* 3549 ** A soft reset zero's out the VFTA, so 3550 ** we need to repopulate it now. 3551 */ 3552 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) 3553 if (adapter->shadow_vfta[i] != 0) 3554 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 3555 adapter->shadow_vfta[i]); 3556 3557 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 3558 /* Enable the Filter Table if enabled */ 3559 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) { 3560 ctrl &= ~IXGBE_VLNCTRL_CFIEN; 3561 ctrl |= IXGBE_VLNCTRL_VFE; 3562 } 3563 if (hw->mac.type == ixgbe_mac_82598EB) 3564 ctrl |= IXGBE_VLNCTRL_VME; 3565 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 3566 } 3567 3568 static void 3569 ixgbe_enable_intr(struct adapter *adapter) 3570 { 3571 struct ixgbe_hw *hw = &adapter->hw; 3572 struct ix_queue *que = adapter->queues; 3573 u32 mask, fwsm; 3574 3575 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 3576 /* Enable Fan Failure detection */ 3577 if (hw->device_id == IXGBE_DEV_ID_82598AT) 3578 mask |= IXGBE_EIMS_GPI_SDP1; 3579 3580 switch (adapter->hw.mac.type) { 3581 case ixgbe_mac_82599EB: 3582 mask |= IXGBE_EIMS_ECC; 3583 /* Temperature sensor on some adapters */ 3584 mask |= IXGBE_EIMS_GPI_SDP0; 3585 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 3586 mask |= IXGBE_EIMS_GPI_SDP1; 3587 mask |= IXGBE_EIMS_GPI_SDP2; 3588 #ifdef IXGBE_FDIR 3589 mask |= IXGBE_EIMS_FLOW_DIR; 3590 #endif 3591 #ifdef PCI_IOV 3592 mask |= IXGBE_EIMS_MAILBOX; 3593 #endif 3594 break; 3595 case ixgbe_mac_X540: 3596 /* Detect if Thermal Sensor is enabled */ 3597 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 3598 if (fwsm & IXGBE_FWSM_TS_ENABLED) 3599 mask |= IXGBE_EIMS_TS; 3600 mask |= IXGBE_EIMS_ECC; 3601 #ifdef IXGBE_FDIR 3602 mask |= IXGBE_EIMS_FLOW_DIR; 3603 #endif 3604 break; 3605 case ixgbe_mac_X550: 3606 case ixgbe_mac_X550EM_x: 3607 /* MAC thermal sensor is automatically enabled */ 3608 mask |= IXGBE_EIMS_TS; 3609 /* Some devices use SDP0 for important information */ 3610 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 3611 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 3612 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 3613 mask |= IXGBE_EIMS_ECC; 3614 #ifdef IXGBE_FDIR 3615 mask |= IXGBE_EIMS_FLOW_DIR; 3616 #endif 3617 #ifdef PCI_IOV 3618 mask |= IXGBE_EIMS_MAILBOX; 3619 #endif 3620 /* falls through */ 3621 default: 3622 break; 3623 } 3624 3625 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 3626 3627 /* With MSI-X we use auto clear */ 3628 if (adapter->msix_mem) { 3629 mask = IXGBE_EIMS_ENABLE_MASK; 3630 /* Don't autoclear Link */ 3631 mask &= ~IXGBE_EIMS_OTHER; 3632 mask &= ~IXGBE_EIMS_LSC; 3633 #ifdef PCI_IOV 3634 mask &= ~IXGBE_EIMS_MAILBOX; 3635 #endif 3636 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 3637 } 3638 3639 /* 3640 ** Now enable all queues, this is done separately to 3641 ** allow for handling the extended (beyond 32) MSIX 3642 ** vectors that can be used by 82599 3643 */ 3644 for (int i = 0; i < adapter->num_queues; i++, que++) 3645 ixgbe_enable_queue(adapter, que->msix); 3646 3647 IXGBE_WRITE_FLUSH(hw); 3648 3649 return; 3650 } 3651 3652 static void 3653 ixgbe_disable_intr(struct adapter *adapter) 3654 { 3655 if (adapter->msix_mem) 3656 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 3657 if (adapter->hw.mac.type == ixgbe_mac_82598EB) { 3658 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0); 3659 } else { 3660 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, 0xFFFF0000); 3661 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(0), ~0); 3662 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(1), ~0); 3663 } 3664 IXGBE_WRITE_FLUSH(&adapter->hw); 3665 return; 3666 } 3667 3668 /* 3669 ** Get the width and transaction speed of 3670 ** the slot this adapter is plugged into. 3671 */ 3672 static void 3673 ixgbe_get_slot_info(struct adapter *adapter) 3674 { 3675 device_t dev = adapter->dev; 3676 struct ixgbe_hw *hw = &adapter->hw; 3677 struct ixgbe_mac_info *mac = &hw->mac; 3678 u16 link; 3679 3680 /* For most devices simply call the shared code routine */ 3681 if (hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) { 3682 ixgbe_get_bus_info(hw); 3683 /* These devices don't use PCI-E */ 3684 switch (hw->mac.type) { 3685 case ixgbe_mac_X550EM_x: 3686 return; 3687 default: 3688 goto display; 3689 } 3690 } 3691 3692 /* 3693 ** For the Quad port adapter we need to parse back 3694 ** up the PCI tree to find the speed of the expansion 3695 ** slot into which this adapter is plugged. A bit more work. 3696 */ 3697 dev = device_parent(device_parent(dev)); 3698 #ifdef IXGBE_DEBUG 3699 device_printf(dev, "parent pcib = %x,%x,%x\n", 3700 pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev)); 3701 #endif 3702 dev = device_parent(device_parent(dev)); 3703 #ifdef IXGBE_DEBUG 3704 device_printf(dev, "slot pcib = %x,%x,%x\n", 3705 pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev)); 3706 #endif 3707 /* Now get the PCI Express Capabilities offset */ 3708 /* ...and read the Link Status Register */ 3709 link = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_LINK_STATUS); 3710 switch (link & IXGBE_PCI_LINK_WIDTH) { 3711 case IXGBE_PCI_LINK_WIDTH_1: 3712 hw->bus.width = ixgbe_bus_width_pcie_x1; 3713 break; 3714 case IXGBE_PCI_LINK_WIDTH_2: 3715 hw->bus.width = ixgbe_bus_width_pcie_x2; 3716 break; 3717 case IXGBE_PCI_LINK_WIDTH_4: 3718 hw->bus.width = ixgbe_bus_width_pcie_x4; 3719 break; 3720 case IXGBE_PCI_LINK_WIDTH_8: 3721 hw->bus.width = ixgbe_bus_width_pcie_x8; 3722 break; 3723 default: 3724 hw->bus.width = ixgbe_bus_width_unknown; 3725 break; 3726 } 3727 3728 switch (link & IXGBE_PCI_LINK_SPEED) { 3729 case IXGBE_PCI_LINK_SPEED_2500: 3730 hw->bus.speed = ixgbe_bus_speed_2500; 3731 break; 3732 case IXGBE_PCI_LINK_SPEED_5000: 3733 hw->bus.speed = ixgbe_bus_speed_5000; 3734 break; 3735 case IXGBE_PCI_LINK_SPEED_8000: 3736 hw->bus.speed = ixgbe_bus_speed_8000; 3737 break; 3738 default: 3739 hw->bus.speed = ixgbe_bus_speed_unknown; 3740 break; 3741 } 3742 3743 mac->ops.set_lan_id(hw); 3744 3745 display: 3746 device_printf(dev,"PCI Express Bus: Speed %s Width %s\n", 3747 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s": 3748 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s": 3749 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s":"Unknown"), 3750 (hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 3751 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 3752 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 3753 ("Unknown")); 3754 3755 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 3756 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 3757 (hw->bus.speed == ixgbe_bus_speed_2500))) { 3758 device_printf(dev, "PCI-Express bandwidth available" 3759 " for this card\n is not sufficient for" 3760 " optimal performance.\n"); 3761 device_printf(dev, "For optimal performance a x8 " 3762 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 3763 } 3764 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 3765 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 3766 (hw->bus.speed < ixgbe_bus_speed_8000))) { 3767 device_printf(dev, "PCI-Express bandwidth available" 3768 " for this card\n is not sufficient for" 3769 " optimal performance.\n"); 3770 device_printf(dev, "For optimal performance a x8 " 3771 "PCIE Gen3 slot is required.\n"); 3772 } 3773 3774 return; 3775 } 3776 3777 3778 /* 3779 ** Setup the correct IVAR register for a particular MSIX interrupt 3780 ** (yes this is all very magic and confusing :) 3781 ** - entry is the register array entry 3782 ** - vector is the MSIX vector for this queue 3783 ** - type is RX/TX/MISC 3784 */ 3785 static void 3786 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 3787 { 3788 struct ixgbe_hw *hw = &adapter->hw; 3789 u32 ivar, index; 3790 3791 vector |= IXGBE_IVAR_ALLOC_VAL; 3792 3793 switch (hw->mac.type) { 3794 3795 case ixgbe_mac_82598EB: 3796 if (type == -1) 3797 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 3798 else 3799 entry += (type * 64); 3800 index = (entry >> 2) & 0x1F; 3801 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 3802 ivar &= ~(0xFF << (8 * (entry & 0x3))); 3803 ivar |= (vector << (8 * (entry & 0x3))); 3804 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 3805 break; 3806 3807 case ixgbe_mac_82599EB: 3808 case ixgbe_mac_X540: 3809 case ixgbe_mac_X550: 3810 case ixgbe_mac_X550EM_x: 3811 if (type == -1) { /* MISC IVAR */ 3812 index = (entry & 1) * 8; 3813 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 3814 ivar &= ~(0xFF << index); 3815 ivar |= (vector << index); 3816 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 3817 } else { /* RX/TX IVARS */ 3818 index = (16 * (entry & 1)) + (8 * type); 3819 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 3820 ivar &= ~(0xFF << index); 3821 ivar |= (vector << index); 3822 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 3823 } 3824 3825 default: 3826 break; 3827 } 3828 } 3829 3830 static void 3831 ixgbe_configure_ivars(struct adapter *adapter) 3832 { 3833 struct ix_queue *que = adapter->queues; 3834 u32 newitr; 3835 3836 if (ixgbe_max_interrupt_rate > 0) 3837 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 3838 else { 3839 /* 3840 ** Disable DMA coalescing if interrupt moderation is 3841 ** disabled. 3842 */ 3843 adapter->dmac = 0; 3844 newitr = 0; 3845 } 3846 3847 for (int i = 0; i < adapter->num_queues; i++, que++) { 3848 struct rx_ring *rxr = &adapter->rx_rings[i]; 3849 struct tx_ring *txr = &adapter->tx_rings[i]; 3850 /* First the RX queue entry */ 3851 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 3852 /* ... and the TX */ 3853 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 3854 /* Set an Initial EITR value */ 3855 IXGBE_WRITE_REG(&adapter->hw, 3856 IXGBE_EITR(que->msix), newitr); 3857 } 3858 3859 /* For the Link interrupt */ 3860 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 3861 } 3862 3863 /* 3864 ** ixgbe_sfp_probe - called in the local timer to 3865 ** determine if a port had optics inserted. 3866 */ 3867 static bool 3868 ixgbe_sfp_probe(struct adapter *adapter) 3869 { 3870 struct ixgbe_hw *hw = &adapter->hw; 3871 device_t dev = adapter->dev; 3872 bool result = FALSE; 3873 3874 if ((hw->phy.type == ixgbe_phy_nl) && 3875 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 3876 s32 ret = hw->phy.ops.identify_sfp(hw); 3877 if (ret) 3878 goto out; 3879 ret = hw->phy.ops.reset(hw); 3880 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3881 device_printf(dev,"Unsupported SFP+ module detected!"); 3882 device_printf(dev, "Reload driver with supported module.\n"); 3883 adapter->sfp_probe = FALSE; 3884 goto out; 3885 } else 3886 device_printf(dev, "SFP+ module detected!\n"); 3887 /* We now have supported optics */ 3888 adapter->sfp_probe = FALSE; 3889 /* Set the optics type so system reports correctly */ 3890 ixgbe_setup_optics(adapter); 3891 result = TRUE; 3892 } 3893 out: 3894 return (result); 3895 } 3896 3897 /* 3898 ** Tasklet handler for MSIX Link interrupts 3899 ** - do outside interrupt since it might sleep 3900 */ 3901 static void 3902 ixgbe_handle_link(void *context) 3903 { 3904 struct adapter *adapter = context; 3905 struct ixgbe_hw *hw = &adapter->hw; 3906 3907 ixgbe_check_link(hw, 3908 &adapter->link_speed, &adapter->link_up, 0); 3909 ixgbe_update_link_status(adapter); 3910 3911 /* Re-enable link interrupts */ 3912 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 3913 } 3914 3915 /* 3916 ** Tasklet for handling SFP module interrupts 3917 */ 3918 static void 3919 ixgbe_handle_mod(void *context) 3920 { 3921 struct adapter *adapter = context; 3922 struct ixgbe_hw *hw = &adapter->hw; 3923 enum ixgbe_phy_type orig_type = hw->phy.type; 3924 device_t dev = adapter->dev; 3925 u32 err; 3926 3927 IXGBE_CORE_LOCK(adapter); 3928 3929 /* Check to see if the PHY type changed */ 3930 if (hw->phy.ops.identify) { 3931 hw->phy.type = ixgbe_phy_unknown; 3932 hw->phy.ops.identify(hw); 3933 } 3934 3935 if (hw->phy.type != orig_type) { 3936 device_printf(dev, "Detected phy_type %d\n", hw->phy.type); 3937 3938 if (hw->phy.type == ixgbe_phy_none) { 3939 hw->phy.sfp_type = ixgbe_sfp_type_unknown; 3940 goto out; 3941 } 3942 3943 /* Try to do the initialization that was skipped before */ 3944 if (hw->phy.ops.init) 3945 hw->phy.ops.init(hw); 3946 if (hw->phy.ops.reset) 3947 hw->phy.ops.reset(hw); 3948 } 3949 3950 err = hw->phy.ops.identify_sfp(hw); 3951 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3952 device_printf(dev, 3953 "Unsupported SFP+ module type was detected.\n"); 3954 goto out; 3955 } 3956 3957 err = hw->mac.ops.setup_sfp(hw); 3958 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3959 device_printf(dev, 3960 "Setup failure - unsupported SFP+ module type.\n"); 3961 goto out; 3962 } 3963 if (hw->phy.multispeed_fiber) 3964 softint_schedule(adapter->msf_si); 3965 out: 3966 /* Update media type */ 3967 switch (hw->mac.ops.get_media_type(hw)) { 3968 case ixgbe_media_type_fiber: 3969 adapter->optics = IFM_10G_SR; 3970 break; 3971 case ixgbe_media_type_copper: 3972 adapter->optics = IFM_10G_TWINAX; 3973 break; 3974 case ixgbe_media_type_cx4: 3975 adapter->optics = IFM_10G_CX4; 3976 break; 3977 default: 3978 adapter->optics = 0; 3979 break; 3980 } 3981 3982 IXGBE_CORE_UNLOCK(adapter); 3983 return; 3984 } 3985 3986 3987 /* 3988 ** Tasklet for handling MSF (multispeed fiber) interrupts 3989 */ 3990 static void 3991 ixgbe_handle_msf(void *context) 3992 { 3993 struct adapter *adapter = context; 3994 struct ixgbe_hw *hw = &adapter->hw; 3995 u32 autoneg; 3996 bool negotiate; 3997 3998 IXGBE_CORE_LOCK(adapter); 3999 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4000 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4001 4002 autoneg = hw->phy.autoneg_advertised; 4003 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4004 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4005 else 4006 negotiate = 0; 4007 if (hw->mac.ops.setup_link) 4008 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4009 4010 /* Adjust media types shown in ifconfig */ 4011 ifmedia_removeall(&adapter->media); 4012 ixgbe_add_media_types(adapter); 4013 IXGBE_CORE_UNLOCK(adapter); 4014 return; 4015 } 4016 4017 /* 4018 ** Tasklet for handling interrupts from an external PHY 4019 */ 4020 static void 4021 ixgbe_handle_phy(void *context) 4022 { 4023 struct adapter *adapter = context; 4024 struct ixgbe_hw *hw = &adapter->hw; 4025 int error; 4026 4027 error = hw->phy.ops.handle_lasi(hw); 4028 if (error == IXGBE_ERR_OVERTEMP) 4029 device_printf(adapter->dev, 4030 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4031 " PHY will downshift to lower power state!\n"); 4032 else if (error) 4033 device_printf(adapter->dev, 4034 "Error handling LASI interrupt: %d\n", 4035 error); 4036 return; 4037 } 4038 4039 #ifdef IXGBE_FDIR 4040 /* 4041 ** Tasklet for reinitializing the Flow Director filter table 4042 */ 4043 static void 4044 ixgbe_reinit_fdir(void *context) 4045 { 4046 struct adapter *adapter = context; 4047 struct ifnet *ifp = adapter->ifp; 4048 4049 if (adapter->fdir_reinit != 1) /* Shouldn't happen */ 4050 return; 4051 ixgbe_reinit_fdir_tables_82599(&adapter->hw); 4052 adapter->fdir_reinit = 0; 4053 /* re-enable flow director interrupts */ 4054 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, IXGBE_EIMS_FLOW_DIR); 4055 /* Restart the interface */ 4056 ifp->if_flags |= IFF_RUNNING; 4057 return; 4058 } 4059 #endif 4060 4061 /********************************************************************* 4062 * 4063 * Configure DMA Coalescing 4064 * 4065 **********************************************************************/ 4066 static void 4067 ixgbe_config_dmac(struct adapter *adapter) 4068 { 4069 struct ixgbe_hw *hw = &adapter->hw; 4070 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4071 4072 if (hw->mac.type < ixgbe_mac_X550 || 4073 !hw->mac.ops.dmac_config) 4074 return; 4075 4076 if (dcfg->watchdog_timer ^ adapter->dmac || 4077 dcfg->link_speed ^ adapter->link_speed) { 4078 dcfg->watchdog_timer = adapter->dmac; 4079 dcfg->fcoe_en = false; 4080 dcfg->link_speed = adapter->link_speed; 4081 dcfg->num_tcs = 1; 4082 4083 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4084 dcfg->watchdog_timer, dcfg->link_speed); 4085 4086 hw->mac.ops.dmac_config(hw); 4087 } 4088 } 4089 4090 /* 4091 * Checks whether the adapter's ports are capable of 4092 * Wake On LAN by reading the adapter's NVM. 4093 * 4094 * Sets each port's hw->wol_enabled value depending 4095 * on the value read here. 4096 */ 4097 static void 4098 ixgbe_check_wol_support(struct adapter *adapter) 4099 { 4100 struct ixgbe_hw *hw = &adapter->hw; 4101 u16 dev_caps = 0; 4102 4103 /* Find out WoL support for port */ 4104 adapter->wol_support = hw->wol_enabled = 0; 4105 ixgbe_get_device_caps(hw, &dev_caps); 4106 if ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0_1) || 4107 ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0) && 4108 hw->bus.func == 0)) 4109 adapter->wol_support = hw->wol_enabled = 1; 4110 4111 /* Save initial wake up filter configuration */ 4112 adapter->wufc = IXGBE_READ_REG(hw, IXGBE_WUFC); 4113 4114 return; 4115 } 4116 4117 /* 4118 * Prepare the adapter/port for LPLU and/or WoL 4119 */ 4120 static int 4121 ixgbe_setup_low_power_mode(struct adapter *adapter) 4122 { 4123 struct ixgbe_hw *hw = &adapter->hw; 4124 device_t dev = adapter->dev; 4125 s32 error = 0; 4126 4127 KASSERT(mutex_owned(&adapter->core_mtx)); 4128 4129 if (!hw->wol_enabled) 4130 ixgbe_set_phy_power(hw, FALSE); 4131 4132 /* Limit power management flow to X550EM baseT */ 4133 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T 4134 && hw->phy.ops.enter_lplu) { 4135 /* Turn off support for APM wakeup. (Using ACPI instead) */ 4136 IXGBE_WRITE_REG(hw, IXGBE_GRC, 4137 IXGBE_READ_REG(hw, IXGBE_GRC) & ~(u32)2); 4138 4139 /* 4140 * Clear Wake Up Status register to prevent any previous wakeup 4141 * events from waking us up immediately after we suspend. 4142 */ 4143 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 4144 4145 /* 4146 * Program the Wakeup Filter Control register with user filter 4147 * settings 4148 */ 4149 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 4150 4151 /* Enable wakeups and power management in Wakeup Control */ 4152 IXGBE_WRITE_REG(hw, IXGBE_WUC, 4153 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 4154 4155 /* X550EM baseT adapters need a special LPLU flow */ 4156 hw->phy.reset_disable = true; 4157 ixgbe_stop(adapter); 4158 error = hw->phy.ops.enter_lplu(hw); 4159 if (error) 4160 device_printf(dev, 4161 "Error entering LPLU: %d\n", error); 4162 hw->phy.reset_disable = false; 4163 } else { 4164 /* Just stop for other adapters */ 4165 ixgbe_stop(adapter); 4166 } 4167 4168 return error; 4169 } 4170 4171 /********************************************************************** 4172 * 4173 * Update the board statistics counters. 4174 * 4175 **********************************************************************/ 4176 static void 4177 ixgbe_update_stats_counters(struct adapter *adapter) 4178 { 4179 struct ifnet *ifp = adapter->ifp; 4180 struct ixgbe_hw *hw = &adapter->hw; 4181 u32 missed_rx = 0, bprc, lxon, lxoff, total; 4182 u64 total_missed_rx = 0; 4183 uint64_t crcerrs, rlec; 4184 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 4185 4186 crcerrs = IXGBE_READ_REG(hw, IXGBE_CRCERRS); 4187 stats->crcerrs.ev_count += crcerrs; 4188 stats->illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 4189 stats->errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 4190 stats->mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 4191 4192 for (int i = 0; i < __arraycount(stats->qprc); i++) { 4193 int j = i % adapter->num_queues; 4194 stats->qprc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 4195 stats->qptc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 4196 stats->qprdc[j].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 4197 } 4198 stats->mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 4199 stats->mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 4200 rlec = IXGBE_READ_REG(hw, IXGBE_RLEC); 4201 stats->rlec.ev_count += rlec; 4202 4203 /* Hardware workaround, gprc counts missed packets */ 4204 stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 4205 4206 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 4207 stats->lxontxc.ev_count += lxon; 4208 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 4209 stats->lxofftxc.ev_count += lxoff; 4210 total = lxon + lxoff; 4211 4212 if (hw->mac.type != ixgbe_mac_82598EB) { 4213 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 4214 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 4215 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 4216 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) - total * ETHER_MIN_LEN; 4217 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 4218 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 4219 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 4220 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 4221 } else { 4222 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 4223 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 4224 /* 82598 only has a counter in the high register */ 4225 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 4226 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) - total * ETHER_MIN_LEN; 4227 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 4228 } 4229 4230 /* 4231 * Workaround: mprc hardware is incorrectly counting 4232 * broadcasts, so for now we subtract those. 4233 */ 4234 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 4235 stats->bprc.ev_count += bprc; 4236 stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 4237 4238 stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 4239 stats->prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 4240 stats->prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 4241 stats->prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 4242 stats->prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 4243 stats->prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 4244 4245 stats->gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 4246 stats->mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 4247 stats->ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 4248 4249 stats->ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 4250 stats->rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 4251 stats->roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 4252 stats->rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 4253 stats->mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 4254 stats->mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 4255 stats->mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 4256 stats->tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 4257 stats->tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 4258 stats->ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 4259 stats->ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 4260 stats->ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 4261 stats->ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 4262 stats->ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 4263 stats->bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 4264 stats->xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 4265 stats->fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 4266 stats->fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 4267 /* Only read FCOE on 82599 */ 4268 if (hw->mac.type != ixgbe_mac_82598EB) { 4269 stats->fcoerpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 4270 stats->fcoeprc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 4271 stats->fcoeptc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 4272 stats->fcoedwrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 4273 stats->fcoedwtc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 4274 } 4275 4276 /* Fill out the OS statistics structure */ 4277 /* 4278 * NetBSD: Don't override if_{i|o}{packets|bytes|mcasts} with 4279 * adapter->stats counters. It's required to make ifconfig -z 4280 * (SOICZIFDATA) work. 4281 */ 4282 ifp->if_collisions = 0; 4283 4284 /* Rx Errors */ 4285 ifp->if_iqdrops += total_missed_rx; 4286 ifp->if_ierrors += crcerrs + rlec; 4287 } 4288 4289 /** ixgbe_sysctl_tdh_handler - Handler function 4290 * Retrieves the TDH value from the hardware 4291 */ 4292 static int 4293 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 4294 { 4295 struct sysctlnode node = *rnode; 4296 uint32_t val; 4297 struct tx_ring *txr; 4298 4299 txr = (struct tx_ring *)node.sysctl_data; 4300 if (txr == NULL) 4301 return 0; 4302 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDH(txr->me)); 4303 node.sysctl_data = &val; 4304 return sysctl_lookup(SYSCTLFN_CALL(&node)); 4305 } 4306 4307 /** ixgbe_sysctl_tdt_handler - Handler function 4308 * Retrieves the TDT value from the hardware 4309 */ 4310 static int 4311 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 4312 { 4313 struct sysctlnode node = *rnode; 4314 uint32_t val; 4315 struct tx_ring *txr; 4316 4317 txr = (struct tx_ring *)node.sysctl_data; 4318 if (txr == NULL) 4319 return 0; 4320 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDT(txr->me)); 4321 node.sysctl_data = &val; 4322 return sysctl_lookup(SYSCTLFN_CALL(&node)); 4323 } 4324 4325 /** ixgbe_sysctl_rdh_handler - Handler function 4326 * Retrieves the RDH value from the hardware 4327 */ 4328 static int 4329 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 4330 { 4331 struct sysctlnode node = *rnode; 4332 uint32_t val; 4333 struct rx_ring *rxr; 4334 4335 rxr = (struct rx_ring *)node.sysctl_data; 4336 if (rxr == NULL) 4337 return 0; 4338 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDH(rxr->me)); 4339 node.sysctl_data = &val; 4340 return sysctl_lookup(SYSCTLFN_CALL(&node)); 4341 } 4342 4343 /** ixgbe_sysctl_rdt_handler - Handler function 4344 * Retrieves the RDT value from the hardware 4345 */ 4346 static int 4347 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 4348 { 4349 struct sysctlnode node = *rnode; 4350 uint32_t val; 4351 struct rx_ring *rxr; 4352 4353 rxr = (struct rx_ring *)node.sysctl_data; 4354 if (rxr == NULL) 4355 return 0; 4356 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDT(rxr->me)); 4357 node.sysctl_data = &val; 4358 return sysctl_lookup(SYSCTLFN_CALL(&node)); 4359 } 4360 4361 static int 4362 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 4363 { 4364 struct sysctlnode node = *rnode; 4365 struct ix_queue *que; 4366 uint32_t reg, usec, rate; 4367 int error; 4368 4369 que = (struct ix_queue *)node.sysctl_data; 4370 if (que == NULL) 4371 return 0; 4372 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_EITR(que->msix)); 4373 usec = ((reg & 0x0FF8) >> 3); 4374 if (usec > 0) 4375 rate = 500000 / usec; 4376 else 4377 rate = 0; 4378 node.sysctl_data = &rate; 4379 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4380 if (error) 4381 return error; 4382 reg &= ~0xfff; /* default, no limitation */ 4383 ixgbe_max_interrupt_rate = 0; 4384 if (rate > 0 && rate < 500000) { 4385 if (rate < 1000) 4386 rate = 1000; 4387 ixgbe_max_interrupt_rate = rate; 4388 reg |= ((4000000/rate) & 0xff8 ); 4389 } 4390 IXGBE_WRITE_REG(&que->adapter->hw, IXGBE_EITR(que->msix), reg); 4391 return 0; 4392 } 4393 4394 const struct sysctlnode * 4395 ixgbe_sysctl_instance(struct adapter *adapter) 4396 { 4397 const char *dvname; 4398 struct sysctllog **log; 4399 int rc; 4400 const struct sysctlnode *rnode; 4401 4402 log = &adapter->sysctllog; 4403 dvname = device_xname(adapter->dev); 4404 4405 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 4406 0, CTLTYPE_NODE, dvname, 4407 SYSCTL_DESCR("ixgbe information and settings"), 4408 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 4409 goto err; 4410 4411 return rnode; 4412 err: 4413 printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc); 4414 return NULL; 4415 } 4416 4417 static void 4418 ixgbe_add_device_sysctls(struct adapter *adapter) 4419 { 4420 device_t dev = adapter->dev; 4421 struct ixgbe_hw *hw = &adapter->hw; 4422 struct sysctllog **log; 4423 const struct sysctlnode *rnode, *cnode; 4424 4425 log = &adapter->sysctllog; 4426 4427 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4428 aprint_error_dev(dev, "could not create sysctl root\n"); 4429 return; 4430 } 4431 4432 if (sysctl_createv(log, 0, &rnode, &cnode, 4433 CTLFLAG_READONLY, CTLTYPE_INT, 4434 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 4435 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 4436 aprint_error_dev(dev, "could not create sysctl\n"); 4437 4438 if (sysctl_createv(log, 0, &rnode, &cnode, 4439 CTLFLAG_READONLY, CTLTYPE_INT, 4440 "num_queues", SYSCTL_DESCR("Number of queues"), 4441 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 4442 aprint_error_dev(dev, "could not create sysctl\n"); 4443 4444 /* Sysctls for all devices */ 4445 if (sysctl_createv(log, 0, &rnode, &cnode, 4446 CTLFLAG_READWRITE, CTLTYPE_INT, 4447 "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 4448 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4449 aprint_error_dev(dev, "could not create sysctl\n"); 4450 4451 /* XXX This is an *instance* sysctl controlling a *global* variable. 4452 * XXX It's that way in the FreeBSD driver that this derives from. 4453 */ 4454 if (sysctl_createv(log, 0, &rnode, &cnode, 4455 CTLFLAG_READWRITE, CTLTYPE_INT, 4456 "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 4457 NULL, 0, &ixgbe_enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 4458 aprint_error_dev(dev, "could not create sysctl\n"); 4459 4460 if (sysctl_createv(log, 0, &rnode, &cnode, 4461 CTLFLAG_READWRITE, CTLTYPE_INT, 4462 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 4463 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4464 aprint_error_dev(dev, "could not create sysctl\n"); 4465 4466 if (sysctl_createv(log, 0, &rnode, &cnode, 4467 CTLFLAG_READWRITE, CTLTYPE_INT, 4468 "ts", SYSCTL_DESCR("Thermal Test"), 4469 ixgbe_sysctl_thermal_test, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4470 aprint_error_dev(dev, "could not create sysctl\n"); 4471 4472 #ifdef IXGBE_DEBUG 4473 /* testing sysctls (for all devices) */ 4474 if (sysctl_createv(log, 0, &rnode, &cnode, 4475 CTLFLAG_READWRITE, CTLTYPE_INT, 4476 "power_state", SYSCTL_DESCR("PCI Power State"), 4477 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4478 aprint_error_dev(dev, "could not create sysctl\n"); 4479 4480 if (sysctl_createv(log, 0, &rnode, &cnode, 4481 CTLFLAG_READONLY, CTLTYPE_STRING, 4482 "print_rss_config", SYSCTL_DESCR("Prints RSS Configuration"), 4483 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4484 aprint_error_dev(dev, "could not create sysctl\n"); 4485 #endif 4486 /* for X550 series devices */ 4487 if (hw->mac.type >= ixgbe_mac_X550) 4488 if (sysctl_createv(log, 0, &rnode, &cnode, 4489 CTLFLAG_READWRITE, CTLTYPE_INT, 4490 "dmac", SYSCTL_DESCR("DMA Coalesce"), 4491 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4492 aprint_error_dev(dev, "could not create sysctl\n"); 4493 4494 /* for X552 backplane devices */ 4495 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_KR) { 4496 const struct sysctlnode *eee_node; 4497 4498 if (sysctl_createv(log, 0, &rnode, &eee_node, 4499 0, CTLTYPE_NODE, 4500 "eee", SYSCTL_DESCR("Energy Efficient Ethernet sysctls"), 4501 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 4502 aprint_error_dev(dev, "could not create sysctl\n"); 4503 return; 4504 } 4505 4506 if (sysctl_createv(log, 0, &eee_node, &cnode, 4507 CTLFLAG_READWRITE, CTLTYPE_INT, 4508 "enable", SYSCTL_DESCR("Enable or Disable EEE"), 4509 ixgbe_sysctl_eee_enable, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4510 aprint_error_dev(dev, "could not create sysctl\n"); 4511 4512 if (sysctl_createv(log, 0, &eee_node, &cnode, 4513 CTLFLAG_READONLY, CTLTYPE_BOOL, 4514 "negotiated", SYSCTL_DESCR("EEE negotiated on link"), 4515 ixgbe_sysctl_eee_negotiated, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4516 aprint_error_dev(dev, "could not create sysctl\n"); 4517 4518 if (sysctl_createv(log, 0, &eee_node, &cnode, 4519 CTLFLAG_READONLY, CTLTYPE_BOOL, 4520 "tx_lpi_status", SYSCTL_DESCR("Whether or not TX link is in LPI state"), 4521 ixgbe_sysctl_eee_tx_lpi_status, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4522 aprint_error_dev(dev, "could not create sysctl\n"); 4523 4524 if (sysctl_createv(log, 0, &eee_node, &cnode, 4525 CTLFLAG_READONLY, CTLTYPE_BOOL, 4526 "rx_lpi_status", SYSCTL_DESCR("Whether or not RX link is in LPI state"), 4527 ixgbe_sysctl_eee_rx_lpi_status, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4528 aprint_error_dev(dev, "could not create sysctl\n"); 4529 4530 if (sysctl_createv(log, 0, &eee_node, &cnode, 4531 CTLFLAG_READONLY, CTLTYPE_BOOL, 4532 "tx_lpi_delay", SYSCTL_DESCR("TX LPI entry delay in microseconds"), 4533 ixgbe_sysctl_eee_tx_lpi_delay, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4534 aprint_error_dev(dev, "could not create sysctl\n"); 4535 } 4536 4537 /* for WoL-capable devices */ 4538 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 4539 if (sysctl_createv(log, 0, &rnode, &cnode, 4540 CTLFLAG_READWRITE, CTLTYPE_INT, 4541 "wol_enable", SYSCTL_DESCR("Enable/Disable Wake on LAN"), 4542 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4543 aprint_error_dev(dev, "could not create sysctl\n"); 4544 4545 if (sysctl_createv(log, 0, &rnode, &cnode, 4546 CTLFLAG_READWRITE, CTLTYPE_INT, 4547 "wufc", SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 4548 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4549 aprint_error_dev(dev, "could not create sysctl\n"); 4550 } 4551 4552 /* for X552/X557-AT devices */ 4553 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 4554 const struct sysctlnode *phy_node; 4555 4556 if (sysctl_createv(log, 0, &rnode, &phy_node, 4557 0, CTLTYPE_NODE, 4558 "phy", SYSCTL_DESCR("External PHY sysctls"), 4559 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 4560 aprint_error_dev(dev, "could not create sysctl\n"); 4561 return; 4562 } 4563 4564 if (sysctl_createv(log, 0, &phy_node, &cnode, 4565 CTLFLAG_READONLY, CTLTYPE_INT, 4566 "temp", SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 4567 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4568 aprint_error_dev(dev, "could not create sysctl\n"); 4569 4570 if (sysctl_createv(log, 0, &phy_node, &cnode, 4571 CTLFLAG_READONLY, CTLTYPE_INT, 4572 "overtemp_occurred", SYSCTL_DESCR("External PHY High Temperature Event Occurred"), 4573 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 4574 aprint_error_dev(dev, "could not create sysctl\n"); 4575 } 4576 } 4577 4578 /* 4579 * Add sysctl variables, one per statistic, to the system. 4580 */ 4581 static void 4582 ixgbe_add_hw_stats(struct adapter *adapter) 4583 { 4584 device_t dev = adapter->dev; 4585 const struct sysctlnode *rnode, *cnode; 4586 struct sysctllog **log = &adapter->sysctllog; 4587 struct tx_ring *txr = adapter->tx_rings; 4588 struct rx_ring *rxr = adapter->rx_rings; 4589 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 4590 4591 /* Driver Statistics */ 4592 #if 0 4593 /* These counters are not updated by the software */ 4594 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped", 4595 CTLFLAG_RD, &adapter->dropped_pkts, 4596 "Driver dropped packets"); 4597 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_header_failed", 4598 CTLFLAG_RD, &adapter->mbuf_header_failed, 4599 "???"); 4600 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_packet_failed", 4601 CTLFLAG_RD, &adapter->mbuf_packet_failed, 4602 "???"); 4603 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "no_tx_map_avail", 4604 CTLFLAG_RD, &adapter->no_tx_map_avail, 4605 "???"); 4606 #endif 4607 evcnt_attach_dynamic(&adapter->handleq, EVCNT_TYPE_MISC, 4608 NULL, device_xname(dev), "Handled queue in softint"); 4609 evcnt_attach_dynamic(&adapter->req, EVCNT_TYPE_MISC, 4610 NULL, device_xname(dev), "Requeued in softint"); 4611 evcnt_attach_dynamic(&adapter->morerx, EVCNT_TYPE_MISC, 4612 NULL, device_xname(dev), "Interrupt handler more rx"); 4613 evcnt_attach_dynamic(&adapter->moretx, EVCNT_TYPE_MISC, 4614 NULL, device_xname(dev), "Interrupt handler more tx"); 4615 evcnt_attach_dynamic(&adapter->txloops, EVCNT_TYPE_MISC, 4616 NULL, device_xname(dev), "Interrupt handler tx loops"); 4617 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 4618 NULL, device_xname(dev), "Driver tx dma soft fail EFBIG"); 4619 evcnt_attach_dynamic(&adapter->m_defrag_failed, EVCNT_TYPE_MISC, 4620 NULL, device_xname(dev), "m_defrag() failed"); 4621 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 4622 NULL, device_xname(dev), "Driver tx dma hard fail EFBIG"); 4623 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 4624 NULL, device_xname(dev), "Driver tx dma hard fail EINVAL"); 4625 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 4626 NULL, device_xname(dev), "Driver tx dma hard fail other"); 4627 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 4628 NULL, device_xname(dev), "Driver tx dma soft fail EAGAIN"); 4629 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 4630 NULL, device_xname(dev), "Driver tx dma soft fail ENOMEM"); 4631 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 4632 NULL, device_xname(dev), "Watchdog timeouts"); 4633 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 4634 NULL, device_xname(dev), "TSO errors"); 4635 evcnt_attach_dynamic(&adapter->link_irq, EVCNT_TYPE_MISC, 4636 NULL, device_xname(dev), "Link MSIX IRQ Handled"); 4637 4638 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 4639 snprintf(adapter->queues[i].evnamebuf, 4640 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 4641 device_xname(dev), i); 4642 snprintf(adapter->queues[i].namebuf, 4643 sizeof(adapter->queues[i].namebuf), "q%d", i); 4644 4645 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4646 aprint_error_dev(dev, "could not create sysctl root\n"); 4647 break; 4648 } 4649 4650 if (sysctl_createv(log, 0, &rnode, &rnode, 4651 0, CTLTYPE_NODE, 4652 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 4653 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 4654 break; 4655 4656 if (sysctl_createv(log, 0, &rnode, &cnode, 4657 CTLFLAG_READWRITE, CTLTYPE_INT, 4658 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 4659 ixgbe_sysctl_interrupt_rate_handler, 0, 4660 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 4661 break; 4662 4663 #if 0 /* XXX msaitoh */ 4664 if (sysctl_createv(log, 0, &rnode, &cnode, 4665 CTLFLAG_READONLY, CTLTYPE_QUAD, 4666 "irqs", SYSCTL_DESCR("irqs on this queue"), 4667 NULL, 0, &(adapter->queues[i].irqs), 4668 0, CTL_CREATE, CTL_EOL) != 0) 4669 break; 4670 #endif 4671 4672 if (sysctl_createv(log, 0, &rnode, &cnode, 4673 CTLFLAG_READONLY, CTLTYPE_INT, 4674 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 4675 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 4676 0, CTL_CREATE, CTL_EOL) != 0) 4677 break; 4678 4679 if (sysctl_createv(log, 0, &rnode, &cnode, 4680 CTLFLAG_READONLY, CTLTYPE_INT, 4681 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 4682 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 4683 0, CTL_CREATE, CTL_EOL) != 0) 4684 break; 4685 4686 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 4687 NULL, device_xname(dev), "TSO"); 4688 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 4689 NULL, adapter->queues[i].evnamebuf, 4690 "Queue No Descriptor Available"); 4691 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 4692 NULL, adapter->queues[i].evnamebuf, 4693 "Queue Packets Transmitted"); 4694 #ifndef IXGBE_LEGACY_TX 4695 evcnt_attach_dynamic(&txr->br->br_drops, EVCNT_TYPE_MISC, 4696 NULL, adapter->queues[i].evnamebuf, 4697 "Packets dropped in buf_ring"); 4698 #endif 4699 4700 #ifdef LRO 4701 struct lro_ctrl *lro = &rxr->lro; 4702 #endif /* LRO */ 4703 4704 if (sysctl_createv(log, 0, &rnode, &cnode, 4705 CTLFLAG_READONLY, 4706 CTLTYPE_INT, 4707 "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"), 4708 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 4709 CTL_CREATE, CTL_EOL) != 0) 4710 break; 4711 4712 if (sysctl_createv(log, 0, &rnode, &cnode, 4713 CTLFLAG_READONLY, 4714 CTLTYPE_INT, 4715 "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"), 4716 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 4717 CTL_CREATE, CTL_EOL) != 0) 4718 break; 4719 4720 if (i < __arraycount(stats->mpc)) { 4721 evcnt_attach_dynamic(&stats->mpc[i], 4722 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4723 "Missed Packet Count"); 4724 } 4725 if (i < __arraycount(stats->pxontxc)) { 4726 evcnt_attach_dynamic(&stats->pxontxc[i], 4727 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4728 "pxontxc"); 4729 evcnt_attach_dynamic(&stats->pxonrxc[i], 4730 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4731 "pxonrxc"); 4732 evcnt_attach_dynamic(&stats->pxofftxc[i], 4733 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4734 "pxofftxc"); 4735 evcnt_attach_dynamic(&stats->pxoffrxc[i], 4736 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4737 "pxoffrxc"); 4738 evcnt_attach_dynamic(&stats->pxon2offc[i], 4739 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4740 "pxon2offc"); 4741 } 4742 if (i < __arraycount(stats->qprc)) { 4743 evcnt_attach_dynamic(&stats->qprc[i], 4744 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4745 "qprc"); 4746 evcnt_attach_dynamic(&stats->qptc[i], 4747 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4748 "qptc"); 4749 evcnt_attach_dynamic(&stats->qbrc[i], 4750 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4751 "qbrc"); 4752 evcnt_attach_dynamic(&stats->qbtc[i], 4753 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4754 "qbtc"); 4755 evcnt_attach_dynamic(&stats->qprdc[i], 4756 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 4757 "qprdc"); 4758 } 4759 4760 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 4761 NULL, adapter->queues[i].evnamebuf, "Queue Packets Received"); 4762 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 4763 NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received"); 4764 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 4765 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 4766 evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC, 4767 NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf"); 4768 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 4769 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 4770 evcnt_attach_dynamic(&rxr->rx_irq, EVCNT_TYPE_MISC, 4771 NULL, adapter->queues[i].evnamebuf, "Rx interrupts"); 4772 #ifdef LRO 4773 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 4774 CTLFLAG_RD, &lro->lro_queued, 0, 4775 "LRO Queued"); 4776 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 4777 CTLFLAG_RD, &lro->lro_flushed, 0, 4778 "LRO Flushed"); 4779 #endif /* LRO */ 4780 } 4781 4782 /* MAC stats get the own sub node */ 4783 4784 4785 snprintf(stats->namebuf, 4786 sizeof(stats->namebuf), "%s MAC Statistics", device_xname(dev)); 4787 4788 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 4789 stats->namebuf, "rx csum offload - IP"); 4790 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 4791 stats->namebuf, "rx csum offload - L4"); 4792 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 4793 stats->namebuf, "rx csum offload - IP bad"); 4794 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 4795 stats->namebuf, "rx csum offload - L4 bad"); 4796 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 4797 stats->namebuf, "Interrupt conditions zero"); 4798 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 4799 stats->namebuf, "Legacy interrupts"); 4800 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 4801 stats->namebuf, "CRC Errors"); 4802 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 4803 stats->namebuf, "Illegal Byte Errors"); 4804 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 4805 stats->namebuf, "Byte Errors"); 4806 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 4807 stats->namebuf, "MAC Short Packets Discarded"); 4808 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 4809 stats->namebuf, "MAC Local Faults"); 4810 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 4811 stats->namebuf, "MAC Remote Faults"); 4812 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 4813 stats->namebuf, "Receive Length Errors"); 4814 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 4815 stats->namebuf, "Link XON Transmitted"); 4816 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 4817 stats->namebuf, "Link XON Received"); 4818 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 4819 stats->namebuf, "Link XOFF Transmitted"); 4820 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 4821 stats->namebuf, "Link XOFF Received"); 4822 4823 /* Packet Reception Stats */ 4824 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 4825 stats->namebuf, "Total Octets Received"); 4826 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 4827 stats->namebuf, "Good Octets Received"); 4828 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 4829 stats->namebuf, "Total Packets Received"); 4830 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 4831 stats->namebuf, "Good Packets Received"); 4832 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 4833 stats->namebuf, "Multicast Packets Received"); 4834 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 4835 stats->namebuf, "Broadcast Packets Received"); 4836 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 4837 stats->namebuf, "64 byte frames received "); 4838 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 4839 stats->namebuf, "65-127 byte frames received"); 4840 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 4841 stats->namebuf, "128-255 byte frames received"); 4842 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 4843 stats->namebuf, "256-511 byte frames received"); 4844 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 4845 stats->namebuf, "512-1023 byte frames received"); 4846 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 4847 stats->namebuf, "1023-1522 byte frames received"); 4848 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 4849 stats->namebuf, "Receive Undersized"); 4850 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 4851 stats->namebuf, "Fragmented Packets Received "); 4852 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 4853 stats->namebuf, "Oversized Packets Received"); 4854 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 4855 stats->namebuf, "Received Jabber"); 4856 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 4857 stats->namebuf, "Management Packets Received"); 4858 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 4859 stats->namebuf, "Checksum Errors"); 4860 4861 /* Packet Transmission Stats */ 4862 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 4863 stats->namebuf, "Good Octets Transmitted"); 4864 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 4865 stats->namebuf, "Total Packets Transmitted"); 4866 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 4867 stats->namebuf, "Good Packets Transmitted"); 4868 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 4869 stats->namebuf, "Broadcast Packets Transmitted"); 4870 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 4871 stats->namebuf, "Multicast Packets Transmitted"); 4872 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 4873 stats->namebuf, "Management Packets Transmitted"); 4874 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 4875 stats->namebuf, "64 byte frames transmitted "); 4876 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 4877 stats->namebuf, "65-127 byte frames transmitted"); 4878 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 4879 stats->namebuf, "128-255 byte frames transmitted"); 4880 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 4881 stats->namebuf, "256-511 byte frames transmitted"); 4882 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 4883 stats->namebuf, "512-1023 byte frames transmitted"); 4884 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 4885 stats->namebuf, "1024-1522 byte frames transmitted"); 4886 } 4887 4888 static void 4889 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 4890 const char *description, int *limit, int value) 4891 { 4892 device_t dev = adapter->dev; 4893 struct sysctllog **log; 4894 const struct sysctlnode *rnode, *cnode; 4895 4896 log = &adapter->sysctllog; 4897 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4898 aprint_error_dev(dev, "could not create sysctl root\n"); 4899 return; 4900 } 4901 if (sysctl_createv(log, 0, &rnode, &cnode, 4902 CTLFLAG_READWRITE, CTLTYPE_INT, 4903 name, SYSCTL_DESCR(description), 4904 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 4905 aprint_error_dev(dev, "could not create sysctl\n"); 4906 *limit = value; 4907 } 4908 4909 /* 4910 ** Set flow control using sysctl: 4911 ** Flow control values: 4912 ** 0 - off 4913 ** 1 - rx pause 4914 ** 2 - tx pause 4915 ** 3 - full 4916 */ 4917 static int 4918 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 4919 { 4920 int error, fc; 4921 struct sysctlnode node = *rnode; 4922 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4923 4924 node.sysctl_data = &adapter->fc; 4925 fc = adapter->fc; 4926 4927 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4928 if (error != 0 || newp == NULL) 4929 return error; 4930 4931 /* Don't bother if it's not changed */ 4932 if (adapter->fc == fc) 4933 return (0); 4934 4935 return ixgbe_set_flowcntl(adapter, fc); 4936 } 4937 4938 4939 static int 4940 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 4941 { 4942 4943 switch (fc) { 4944 case ixgbe_fc_rx_pause: 4945 case ixgbe_fc_tx_pause: 4946 case ixgbe_fc_full: 4947 adapter->hw.fc.requested_mode = adapter->fc; 4948 if (adapter->num_queues > 1) 4949 ixgbe_disable_rx_drop(adapter); 4950 break; 4951 case ixgbe_fc_none: 4952 adapter->hw.fc.requested_mode = ixgbe_fc_none; 4953 if (adapter->num_queues > 1) 4954 ixgbe_enable_rx_drop(adapter); 4955 break; 4956 default: 4957 return (EINVAL); 4958 } 4959 adapter->fc = fc; 4960 /* Don't autoneg if forcing a value */ 4961 adapter->hw.fc.disable_fc_autoneg = TRUE; 4962 ixgbe_fc_enable(&adapter->hw); 4963 return (0); 4964 } 4965 4966 /* 4967 ** Control advertised link speed: 4968 ** Flags: 4969 ** 0x1 - advertise 100 Mb 4970 ** 0x2 - advertise 1G 4971 ** 0x4 - advertise 10G 4972 */ 4973 static int 4974 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 4975 { 4976 struct sysctlnode node = *rnode; 4977 int error = 0, advertise; 4978 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4979 4980 advertise = adapter->advertise; 4981 node.sysctl_data = &advertise; 4982 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4983 if (error != 0 || newp == NULL) 4984 return error; 4985 4986 return ixgbe_set_advertise(adapter, advertise); 4987 } 4988 4989 static int 4990 ixgbe_set_advertise(struct adapter *adapter, int advertise) 4991 { 4992 device_t dev; 4993 struct ixgbe_hw *hw; 4994 ixgbe_link_speed speed; 4995 4996 /* Checks to validate new value */ 4997 if (adapter->advertise == advertise) /* no change */ 4998 return (0); 4999 5000 hw = &adapter->hw; 5001 dev = adapter->dev; 5002 5003 /* No speed changes for backplane media */ 5004 if (hw->phy.media_type == ixgbe_media_type_backplane) 5005 return (ENODEV); 5006 5007 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5008 (hw->phy.multispeed_fiber))) { 5009 device_printf(dev, 5010 "Advertised speed can only be set on copper or " 5011 "multispeed fiber media types.\n"); 5012 return (EINVAL); 5013 } 5014 5015 if (advertise < 0x1 || advertise > 0x7) { 5016 device_printf(dev, 5017 "Invalid advertised speed; valid modes are 0x1 through 0x7\n"); 5018 return (EINVAL); 5019 } 5020 5021 if ((advertise & 0x1) 5022 && (hw->mac.type != ixgbe_mac_X540) 5023 && (hw->mac.type != ixgbe_mac_X550)) { 5024 device_printf(dev, "Set Advertise: 100Mb on X540/X550 only\n"); 5025 return (EINVAL); 5026 } 5027 5028 /* Set new value and report new advertised mode */ 5029 speed = 0; 5030 if (advertise & 0x1) 5031 speed |= IXGBE_LINK_SPEED_100_FULL; 5032 if (advertise & 0x2) 5033 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5034 if (advertise & 0x4) 5035 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5036 adapter->advertise = advertise; 5037 5038 hw->mac.autotry_restart = TRUE; 5039 hw->mac.ops.setup_link(hw, speed, TRUE); 5040 5041 return 0; 5042 } 5043 5044 /* 5045 * The following two sysctls are for X552/X557-AT devices; 5046 * they deal with the external PHY used in them. 5047 */ 5048 static int 5049 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5050 { 5051 struct sysctlnode node = *rnode; 5052 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5053 struct ixgbe_hw *hw = &adapter->hw; 5054 int val; 5055 u16 reg; 5056 int error; 5057 5058 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5059 device_printf(adapter->dev, 5060 "Device has no supported external thermal sensor.\n"); 5061 return (ENODEV); 5062 } 5063 5064 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5065 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, 5066 ®)) { 5067 device_printf(adapter->dev, 5068 "Error reading from PHY's current temperature register\n"); 5069 return (EAGAIN); 5070 } 5071 5072 node.sysctl_data = &val; 5073 5074 /* Shift temp for output */ 5075 val = reg >> 8; 5076 5077 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5078 if ((error) || (newp == NULL)) 5079 return (error); 5080 5081 return (0); 5082 } 5083 5084 /* 5085 * Reports whether the current PHY temperature is over 5086 * the overtemp threshold. 5087 * - This is reported directly from the PHY 5088 */ 5089 static int 5090 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5091 { 5092 struct sysctlnode node = *rnode; 5093 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5094 struct ixgbe_hw *hw = &adapter->hw; 5095 int val, error; 5096 u16 reg; 5097 5098 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5099 device_printf(adapter->dev, 5100 "Device has no supported external thermal sensor.\n"); 5101 return (ENODEV); 5102 } 5103 5104 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5105 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, 5106 ®)) { 5107 device_printf(adapter->dev, 5108 "Error reading from PHY's temperature status register\n"); 5109 return (EAGAIN); 5110 } 5111 5112 node.sysctl_data = &val; 5113 5114 /* Get occurrence bit */ 5115 val = !!(reg & 0x4000); 5116 5117 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5118 if ((error) || (newp == NULL)) 5119 return (error); 5120 5121 return (0); 5122 } 5123 5124 /* 5125 ** Thermal Shutdown Trigger (internal MAC) 5126 ** - Set this to 1 to cause an overtemp event to occur 5127 */ 5128 static int 5129 ixgbe_sysctl_thermal_test(SYSCTLFN_ARGS) 5130 { 5131 struct sysctlnode node = *rnode; 5132 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5133 int error, fire = 0; 5134 struct ixgbe_hw *hw; 5135 5136 hw = &adapter->hw; 5137 5138 node.sysctl_data = &fire; 5139 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5140 if ((error) || (newp == NULL)) 5141 return (error); 5142 5143 if (fire) { 5144 u32 reg = IXGBE_READ_REG(hw, IXGBE_EICS); 5145 reg |= IXGBE_EICR_TS; 5146 IXGBE_WRITE_REG(hw, IXGBE_EICS, reg); 5147 } 5148 5149 return (0); 5150 } 5151 5152 /* 5153 ** Manage DMA Coalescing. 5154 ** Control values: 5155 ** 0/1 - off / on (use default value of 1000) 5156 ** 5157 ** Legal timer values are: 5158 ** 50,100,250,500,1000,2000,5000,10000 5159 ** 5160 ** Turning off interrupt moderation will also turn this off. 5161 */ 5162 static int 5163 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5164 { 5165 struct sysctlnode node = *rnode; 5166 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5167 struct ifnet *ifp = adapter->ifp; 5168 int error; 5169 u16 oldval; 5170 int newval; 5171 5172 oldval = adapter->dmac; 5173 newval = oldval; 5174 node.sysctl_data = &newval; 5175 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5176 if ((error) || (newp == NULL)) 5177 return (error); 5178 5179 switch (newval) { 5180 case 0: 5181 /* Disabled */ 5182 adapter->dmac = 0; 5183 break; 5184 case 1: 5185 /* Enable and use default */ 5186 adapter->dmac = 1000; 5187 break; 5188 case 50: 5189 case 100: 5190 case 250: 5191 case 500: 5192 case 1000: 5193 case 2000: 5194 case 5000: 5195 case 10000: 5196 /* Legal values - allow */ 5197 adapter->dmac = newval; 5198 break; 5199 default: 5200 /* Do nothing, illegal value */ 5201 return (EINVAL); 5202 } 5203 5204 /* Re-initialize hardware if it's already running */ 5205 if (ifp->if_flags & IFF_RUNNING) 5206 ixgbe_init(ifp); 5207 5208 return (0); 5209 } 5210 5211 #ifdef IXGBE_DEBUG 5212 /** 5213 * Sysctl to test power states 5214 * Values: 5215 * 0 - set device to D0 5216 * 3 - set device to D3 5217 * (none) - get current device power state 5218 */ 5219 static int 5220 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5221 { 5222 struct sysctlnode node = *rnode; 5223 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5224 device_t dev = adapter->dev; 5225 int curr_ps, new_ps, error = 0; 5226 5227 #if notyet 5228 curr_ps = new_ps = pci_get_powerstate(dev); 5229 5230 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5231 if ((error) || (req->newp == NULL)) 5232 return (error); 5233 5234 if (new_ps == curr_ps) 5235 return (0); 5236 5237 if (new_ps == 3 && curr_ps == 0) 5238 error = DEVICE_SUSPEND(dev); 5239 else if (new_ps == 0 && curr_ps == 3) 5240 error = DEVICE_RESUME(dev); 5241 else 5242 return (EINVAL); 5243 5244 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5245 5246 return (error); 5247 #else 5248 return 0; 5249 #endif 5250 } 5251 #endif 5252 /* 5253 * Sysctl to enable/disable the WoL capability, if supported by the adapter. 5254 * Values: 5255 * 0 - disabled 5256 * 1 - enabled 5257 */ 5258 static int 5259 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5260 { 5261 struct sysctlnode node = *rnode; 5262 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5263 struct ixgbe_hw *hw = &adapter->hw; 5264 int new_wol_enabled; 5265 int error = 0; 5266 5267 new_wol_enabled = hw->wol_enabled; 5268 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5269 if ((error) || (newp == NULL)) 5270 return (error); 5271 new_wol_enabled = !!(new_wol_enabled); 5272 if (new_wol_enabled == hw->wol_enabled) 5273 return (0); 5274 5275 if (new_wol_enabled > 0 && !adapter->wol_support) 5276 return (ENODEV); 5277 else 5278 hw->wol_enabled = new_wol_enabled; 5279 5280 return (0); 5281 } 5282 5283 /* 5284 * Sysctl to enable/disable the Energy Efficient Ethernet capability, 5285 * if supported by the adapter. 5286 * Values: 5287 * 0 - disabled 5288 * 1 - enabled 5289 */ 5290 static int 5291 ixgbe_sysctl_eee_enable(SYSCTLFN_ARGS) 5292 { 5293 struct sysctlnode node = *rnode; 5294 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5295 struct ixgbe_hw *hw = &adapter->hw; 5296 struct ifnet *ifp = adapter->ifp; 5297 int new_eee_enabled, error = 0; 5298 5299 new_eee_enabled = adapter->eee_enabled; 5300 node.sysctl_data = &new_eee_enabled; 5301 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5302 if ((error) || (newp == NULL)) 5303 return (error); 5304 new_eee_enabled = !!(new_eee_enabled); 5305 if (new_eee_enabled == adapter->eee_enabled) 5306 return (0); 5307 5308 if (new_eee_enabled > 0 && !hw->mac.ops.setup_eee) 5309 return (ENODEV); 5310 else 5311 adapter->eee_enabled = new_eee_enabled; 5312 5313 /* Re-initialize hardware if it's already running */ 5314 if (ifp->if_flags & IFF_RUNNING) 5315 ixgbe_init(ifp); 5316 5317 return (0); 5318 } 5319 5320 /* 5321 * Read-only sysctl indicating whether EEE support was negotiated 5322 * on the link. 5323 */ 5324 static int 5325 ixgbe_sysctl_eee_negotiated(SYSCTLFN_ARGS) 5326 { 5327 struct sysctlnode node = *rnode; 5328 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5329 struct ixgbe_hw *hw = &adapter->hw; 5330 bool status; 5331 5332 status = !!(IXGBE_READ_REG(hw, IXGBE_EEE_STAT) & IXGBE_EEE_STAT_NEG); 5333 5334 node.sysctl_data = &status; 5335 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 5336 } 5337 5338 /* 5339 * Read-only sysctl indicating whether RX Link is in LPI state. 5340 */ 5341 static int 5342 ixgbe_sysctl_eee_rx_lpi_status(SYSCTLFN_ARGS) 5343 { 5344 struct sysctlnode node = *rnode; 5345 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5346 struct ixgbe_hw *hw = &adapter->hw; 5347 bool status; 5348 5349 status = !!(IXGBE_READ_REG(hw, IXGBE_EEE_STAT) & 5350 IXGBE_EEE_RX_LPI_STATUS); 5351 5352 node.sysctl_data = &status; 5353 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 5354 } 5355 5356 /* 5357 * Read-only sysctl indicating whether TX Link is in LPI state. 5358 */ 5359 static int 5360 ixgbe_sysctl_eee_tx_lpi_status(SYSCTLFN_ARGS) 5361 { 5362 struct sysctlnode node = *rnode; 5363 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5364 struct ixgbe_hw *hw = &adapter->hw; 5365 bool status; 5366 5367 status = !!(IXGBE_READ_REG(hw, IXGBE_EEE_STAT) & 5368 IXGBE_EEE_TX_LPI_STATUS); 5369 5370 node.sysctl_data = &status; 5371 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 5372 } 5373 5374 /* 5375 * Read-only sysctl indicating TX Link LPI delay 5376 */ 5377 static int 5378 ixgbe_sysctl_eee_tx_lpi_delay(SYSCTLFN_ARGS) 5379 { 5380 struct sysctlnode node = *rnode; 5381 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5382 struct ixgbe_hw *hw = &adapter->hw; 5383 u32 reg; 5384 5385 reg = IXGBE_READ_REG(hw, IXGBE_EEE_SU); 5386 5387 reg >>= 26; 5388 node.sysctl_data = ® 5389 return (sysctl_lookup(SYSCTLFN_CALL(&node))); 5390 } 5391 5392 /* 5393 * Sysctl to enable/disable the types of packets that the 5394 * adapter will wake up on upon receipt. 5395 * WUFC - Wake Up Filter Control 5396 * Flags: 5397 * 0x1 - Link Status Change 5398 * 0x2 - Magic Packet 5399 * 0x4 - Direct Exact 5400 * 0x8 - Directed Multicast 5401 * 0x10 - Broadcast 5402 * 0x20 - ARP/IPv4 Request Packet 5403 * 0x40 - Direct IPv4 Packet 5404 * 0x80 - Direct IPv6 Packet 5405 * 5406 * Setting another flag will cause the sysctl to return an 5407 * error. 5408 */ 5409 static int 5410 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5411 { 5412 struct sysctlnode node = *rnode; 5413 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5414 int error = 0; 5415 u32 new_wufc; 5416 5417 new_wufc = adapter->wufc; 5418 5419 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5420 if ((error) || (newp == NULL)) 5421 return (error); 5422 if (new_wufc == adapter->wufc) 5423 return (0); 5424 5425 if (new_wufc & 0xffffff00) 5426 return (EINVAL); 5427 else { 5428 new_wufc &= 0xff; 5429 new_wufc |= (0xffffff & adapter->wufc); 5430 adapter->wufc = new_wufc; 5431 } 5432 5433 return (0); 5434 } 5435 5436 #ifdef IXGBE_DEBUG 5437 static int 5438 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5439 { 5440 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5441 struct ixgbe_hw *hw = &adapter->hw; 5442 device_t dev = adapter->dev; 5443 int error = 0, reta_size; 5444 struct sbuf *buf; 5445 u32 reg; 5446 5447 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5448 if (!buf) { 5449 device_printf(dev, "Could not allocate sbuf for output.\n"); 5450 return (ENOMEM); 5451 } 5452 5453 // TODO: use sbufs to make a string to print out 5454 /* Set multiplier for RETA setup and table size based on MAC */ 5455 switch (adapter->hw.mac.type) { 5456 case ixgbe_mac_X550: 5457 case ixgbe_mac_X550EM_x: 5458 reta_size = 128; 5459 break; 5460 default: 5461 reta_size = 32; 5462 break; 5463 } 5464 5465 /* Print out the redirection table */ 5466 sbuf_cat(buf, "\n"); 5467 for (int i = 0; i < reta_size; i++) { 5468 if (i < 32) { 5469 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5470 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5471 } else { 5472 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5473 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5474 } 5475 } 5476 5477 // TODO: print more config 5478 5479 error = sbuf_finish(buf); 5480 if (error) 5481 device_printf(dev, "Error finishing sbuf: %d\n", error); 5482 5483 sbuf_delete(buf); 5484 return (0); 5485 } 5486 #endif /* IXGBE_DEBUG */ 5487 5488 /* 5489 ** Enable the hardware to drop packets when the buffer is 5490 ** full. This is useful when multiqueue,so that no single 5491 ** queue being full stalls the entire RX engine. We only 5492 ** enable this when Multiqueue AND when Flow Control is 5493 ** disabled. 5494 */ 5495 static void 5496 ixgbe_enable_rx_drop(struct adapter *adapter) 5497 { 5498 struct ixgbe_hw *hw = &adapter->hw; 5499 5500 for (int i = 0; i < adapter->num_queues; i++) { 5501 struct rx_ring *rxr = &adapter->rx_rings[i]; 5502 u32 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5503 srrctl |= IXGBE_SRRCTL_DROP_EN; 5504 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5505 } 5506 #ifdef PCI_IOV 5507 /* enable drop for each vf */ 5508 for (int i = 0; i < adapter->num_vfs; i++) { 5509 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5510 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 5511 IXGBE_QDE_ENABLE)); 5512 } 5513 #endif 5514 } 5515 5516 static void 5517 ixgbe_disable_rx_drop(struct adapter *adapter) 5518 { 5519 struct ixgbe_hw *hw = &adapter->hw; 5520 5521 for (int i = 0; i < adapter->num_queues; i++) { 5522 struct rx_ring *rxr = &adapter->rx_rings[i]; 5523 u32 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5524 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 5525 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5526 } 5527 #ifdef PCI_IOV 5528 /* disable drop for each vf */ 5529 for (int i = 0; i < adapter->num_vfs; i++) { 5530 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5531 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 5532 } 5533 #endif 5534 } 5535 5536 #ifdef PCI_IOV 5537 5538 /* 5539 ** Support functions for SRIOV/VF management 5540 */ 5541 5542 static void 5543 ixgbe_ping_all_vfs(struct adapter *adapter) 5544 { 5545 struct ixgbe_vf *vf; 5546 5547 for (int i = 0; i < adapter->num_vfs; i++) { 5548 vf = &adapter->vfs[i]; 5549 if (vf->flags & IXGBE_VF_ACTIVE) 5550 ixgbe_send_vf_msg(adapter, vf, IXGBE_PF_CONTROL_MSG); 5551 } 5552 } 5553 5554 5555 static void 5556 ixgbe_vf_set_default_vlan(struct adapter *adapter, struct ixgbe_vf *vf, 5557 uint16_t tag) 5558 { 5559 struct ixgbe_hw *hw; 5560 uint32_t vmolr, vmvir; 5561 5562 hw = &adapter->hw; 5563 5564 vf->vlan_tag = tag; 5565 5566 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf->pool)); 5567 5568 /* Do not receive packets that pass inexact filters. */ 5569 vmolr &= ~(IXGBE_VMOLR_ROMPE | IXGBE_VMOLR_ROPE); 5570 5571 /* Disable Multicast Promicuous Mode. */ 5572 vmolr &= ~IXGBE_VMOLR_MPE; 5573 5574 /* Accept broadcasts. */ 5575 vmolr |= IXGBE_VMOLR_BAM; 5576 5577 if (tag == 0) { 5578 /* Accept non-vlan tagged traffic. */ 5579 //vmolr |= IXGBE_VMOLR_AUPE; 5580 5581 /* Allow VM to tag outgoing traffic; no default tag. */ 5582 vmvir = 0; 5583 } else { 5584 /* Require vlan-tagged traffic. */ 5585 vmolr &= ~IXGBE_VMOLR_AUPE; 5586 5587 /* Tag all traffic with provided vlan tag. */ 5588 vmvir = (tag | IXGBE_VMVIR_VLANA_DEFAULT); 5589 } 5590 IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf->pool), vmolr); 5591 IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf->pool), vmvir); 5592 } 5593 5594 5595 static boolean_t 5596 ixgbe_vf_frame_size_compatible(struct adapter *adapter, struct ixgbe_vf *vf) 5597 { 5598 5599 /* 5600 * Frame size compatibility between PF and VF is only a problem on 5601 * 82599-based cards. X540 and later support any combination of jumbo 5602 * frames on PFs and VFs. 5603 */ 5604 if (adapter->hw.mac.type != ixgbe_mac_82599EB) 5605 return (TRUE); 5606 5607 switch (vf->api_ver) { 5608 case IXGBE_API_VER_1_0: 5609 case IXGBE_API_VER_UNKNOWN: 5610 /* 5611 * On legacy (1.0 and older) VF versions, we don't support jumbo 5612 * frames on either the PF or the VF. 5613 */ 5614 if (adapter->max_frame_size > ETHER_MAX_LEN || 5615 vf->max_frame_size > ETHER_MAX_LEN) 5616 return (FALSE); 5617 5618 return (TRUE); 5619 5620 break; 5621 case IXGBE_API_VER_1_1: 5622 default: 5623 /* 5624 * 1.1 or later VF versions always work if they aren't using 5625 * jumbo frames. 5626 */ 5627 if (vf->max_frame_size <= ETHER_MAX_LEN) 5628 return (TRUE); 5629 5630 /* 5631 * Jumbo frames only work with VFs if the PF is also using jumbo 5632 * frames. 5633 */ 5634 if (adapter->max_frame_size <= ETHER_MAX_LEN) 5635 return (TRUE); 5636 5637 return (FALSE); 5638 5639 } 5640 } 5641 5642 5643 static void 5644 ixgbe_process_vf_reset(struct adapter *adapter, struct ixgbe_vf *vf) 5645 { 5646 ixgbe_vf_set_default_vlan(adapter, vf, vf->default_vlan); 5647 5648 // XXX clear multicast addresses 5649 5650 ixgbe_clear_rar(&adapter->hw, vf->rar_index); 5651 5652 vf->api_ver = IXGBE_API_VER_UNKNOWN; 5653 } 5654 5655 5656 static void 5657 ixgbe_vf_enable_transmit(struct adapter *adapter, struct ixgbe_vf *vf) 5658 { 5659 struct ixgbe_hw *hw; 5660 uint32_t vf_index, vfte; 5661 5662 hw = &adapter->hw; 5663 5664 vf_index = IXGBE_VF_INDEX(vf->pool); 5665 vfte = IXGBE_READ_REG(hw, IXGBE_VFTE(vf_index)); 5666 vfte |= IXGBE_VF_BIT(vf->pool); 5667 IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_index), vfte); 5668 } 5669 5670 5671 static void 5672 ixgbe_vf_enable_receive(struct adapter *adapter, struct ixgbe_vf *vf) 5673 { 5674 struct ixgbe_hw *hw; 5675 uint32_t vf_index, vfre; 5676 5677 hw = &adapter->hw; 5678 5679 vf_index = IXGBE_VF_INDEX(vf->pool); 5680 vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(vf_index)); 5681 if (ixgbe_vf_frame_size_compatible(adapter, vf)) 5682 vfre |= IXGBE_VF_BIT(vf->pool); 5683 else 5684 vfre &= ~IXGBE_VF_BIT(vf->pool); 5685 IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_index), vfre); 5686 } 5687 5688 5689 static void 5690 ixgbe_vf_reset_msg(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg) 5691 { 5692 struct ixgbe_hw *hw; 5693 uint32_t ack; 5694 uint32_t resp[IXGBE_VF_PERMADDR_MSG_LEN]; 5695 5696 hw = &adapter->hw; 5697 5698 ixgbe_process_vf_reset(adapter, vf); 5699 5700 if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) { 5701 ixgbe_set_rar(&adapter->hw, vf->rar_index, 5702 vf->ether_addr, vf->pool, TRUE); 5703 ack = IXGBE_VT_MSGTYPE_ACK; 5704 } else 5705 ack = IXGBE_VT_MSGTYPE_NACK; 5706 5707 ixgbe_vf_enable_transmit(adapter, vf); 5708 ixgbe_vf_enable_receive(adapter, vf); 5709 5710 vf->flags |= IXGBE_VF_CTS; 5711 5712 resp[0] = IXGBE_VF_RESET | ack | IXGBE_VT_MSGTYPE_CTS; 5713 bcopy(vf->ether_addr, &resp[1], ETHER_ADDR_LEN); 5714 resp[3] = hw->mac.mc_filter_type; 5715 ixgbe_write_mbx(hw, resp, IXGBE_VF_PERMADDR_MSG_LEN, vf->pool); 5716 } 5717 5718 5719 static void 5720 ixgbe_vf_set_mac(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg) 5721 { 5722 uint8_t *mac; 5723 5724 mac = (uint8_t*)&msg[1]; 5725 5726 /* Check that the VF has permission to change the MAC address. */ 5727 if (!(vf->flags & IXGBE_VF_CAP_MAC) && ixgbe_vf_mac_changed(vf, mac)) { 5728 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5729 return; 5730 } 5731 5732 if (ixgbe_validate_mac_addr(mac) != 0) { 5733 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5734 return; 5735 } 5736 5737 bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN); 5738 5739 ixgbe_set_rar(&adapter->hw, vf->rar_index, vf->ether_addr, 5740 vf->pool, TRUE); 5741 5742 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5743 } 5744 5745 5746 /* 5747 ** VF multicast addresses are set by using the appropriate bit in 5748 ** 1 of 128 32 bit addresses (4096 possible). 5749 */ 5750 static void 5751 ixgbe_vf_set_mc_addr(struct adapter *adapter, struct ixgbe_vf *vf, u32 *msg) 5752 { 5753 u16 *list = (u16*)&msg[1]; 5754 int entries; 5755 u32 vmolr, vec_bit, vec_reg, mta_reg; 5756 5757 entries = (msg[0] & IXGBE_VT_MSGINFO_MASK) >> IXGBE_VT_MSGINFO_SHIFT; 5758 entries = min(entries, IXGBE_MAX_VF_MC); 5759 5760 vmolr = IXGBE_READ_REG(&adapter->hw, IXGBE_VMOLR(vf->pool)); 5761 5762 vf->num_mc_hashes = entries; 5763 5764 /* Set the appropriate MTA bit */ 5765 for (int i = 0; i < entries; i++) { 5766 vf->mc_hash[i] = list[i]; 5767 vec_reg = (vf->mc_hash[i] >> 5) & 0x7F; 5768 vec_bit = vf->mc_hash[i] & 0x1F; 5769 mta_reg = IXGBE_READ_REG(&adapter->hw, IXGBE_MTA(vec_reg)); 5770 mta_reg |= (1 << vec_bit); 5771 IXGBE_WRITE_REG(&adapter->hw, IXGBE_MTA(vec_reg), mta_reg); 5772 } 5773 5774 vmolr |= IXGBE_VMOLR_ROMPE; 5775 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VMOLR(vf->pool), vmolr); 5776 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5777 return; 5778 } 5779 5780 5781 static void 5782 ixgbe_vf_set_vlan(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg) 5783 { 5784 struct ixgbe_hw *hw; 5785 int enable; 5786 uint16_t tag; 5787 5788 hw = &adapter->hw; 5789 enable = IXGBE_VT_MSGINFO(msg[0]); 5790 tag = msg[1] & IXGBE_VLVF_VLANID_MASK; 5791 5792 if (!(vf->flags & IXGBE_VF_CAP_VLAN)) { 5793 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5794 return; 5795 } 5796 5797 /* It is illegal to enable vlan tag 0. */ 5798 if (tag == 0 && enable != 0){ 5799 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5800 return; 5801 } 5802 5803 ixgbe_set_vfta(hw, tag, vf->pool, enable); 5804 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5805 } 5806 5807 5808 static void 5809 ixgbe_vf_set_lpe(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg) 5810 { 5811 struct ixgbe_hw *hw; 5812 uint32_t vf_max_size, pf_max_size, mhadd; 5813 5814 hw = &adapter->hw; 5815 vf_max_size = msg[1]; 5816 5817 if (vf_max_size < ETHER_CRC_LEN) { 5818 /* We intentionally ACK invalid LPE requests. */ 5819 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5820 return; 5821 } 5822 5823 vf_max_size -= ETHER_CRC_LEN; 5824 5825 if (vf_max_size > IXGBE_MAX_FRAME_SIZE) { 5826 /* We intentionally ACK invalid LPE requests. */ 5827 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5828 return; 5829 } 5830 5831 vf->max_frame_size = vf_max_size; 5832 ixgbe_update_max_frame(adapter, vf->max_frame_size); 5833 5834 /* 5835 * We might have to disable reception to this VF if the frame size is 5836 * not compatible with the config on the PF. 5837 */ 5838 ixgbe_vf_enable_receive(adapter, vf); 5839 5840 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 5841 pf_max_size = (mhadd & IXGBE_MHADD_MFS_MASK) >> IXGBE_MHADD_MFS_SHIFT; 5842 5843 if (pf_max_size < adapter->max_frame_size) { 5844 mhadd &= ~IXGBE_MHADD_MFS_MASK; 5845 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 5846 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 5847 } 5848 5849 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5850 } 5851 5852 5853 static void 5854 ixgbe_vf_set_macvlan(struct adapter *adapter, struct ixgbe_vf *vf, 5855 uint32_t *msg) 5856 { 5857 //XXX implement this 5858 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5859 } 5860 5861 5862 static void 5863 ixgbe_vf_api_negotiate(struct adapter *adapter, struct ixgbe_vf *vf, 5864 uint32_t *msg) 5865 { 5866 5867 switch (msg[1]) { 5868 case IXGBE_API_VER_1_0: 5869 case IXGBE_API_VER_1_1: 5870 vf->api_ver = msg[1]; 5871 ixgbe_send_vf_ack(adapter, vf, msg[0]); 5872 break; 5873 default: 5874 vf->api_ver = IXGBE_API_VER_UNKNOWN; 5875 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5876 break; 5877 } 5878 } 5879 5880 5881 static void 5882 ixgbe_vf_get_queues(struct adapter *adapter, struct ixgbe_vf *vf, 5883 uint32_t *msg) 5884 { 5885 struct ixgbe_hw *hw; 5886 uint32_t resp[IXGBE_VF_GET_QUEUES_RESP_LEN]; 5887 int num_queues; 5888 5889 hw = &adapter->hw; 5890 5891 /* GET_QUEUES is not supported on pre-1.1 APIs. */ 5892 switch (msg[0]) { 5893 case IXGBE_API_VER_1_0: 5894 case IXGBE_API_VER_UNKNOWN: 5895 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5896 return; 5897 } 5898 5899 resp[0] = IXGBE_VF_GET_QUEUES | IXGBE_VT_MSGTYPE_ACK | 5900 IXGBE_VT_MSGTYPE_CTS; 5901 5902 num_queues = ixgbe_vf_queues(ixgbe_get_iov_mode(adapter)); 5903 resp[IXGBE_VF_TX_QUEUES] = num_queues; 5904 resp[IXGBE_VF_RX_QUEUES] = num_queues; 5905 resp[IXGBE_VF_TRANS_VLAN] = (vf->default_vlan != 0); 5906 resp[IXGBE_VF_DEF_QUEUE] = 0; 5907 5908 ixgbe_write_mbx(hw, resp, IXGBE_VF_GET_QUEUES_RESP_LEN, vf->pool); 5909 } 5910 5911 5912 static void 5913 ixgbe_process_vf_msg(struct adapter *adapter, struct ixgbe_vf *vf) 5914 { 5915 struct ixgbe_hw *hw; 5916 uint32_t msg[IXGBE_VFMAILBOX_SIZE]; 5917 int error; 5918 5919 hw = &adapter->hw; 5920 5921 error = ixgbe_read_mbx(hw, msg, IXGBE_VFMAILBOX_SIZE, vf->pool); 5922 5923 if (error != 0) 5924 return; 5925 5926 CTR3(KTR_MALLOC, "%s: received msg %x from %d", 5927 adapter->ifp->if_xname, msg[0], vf->pool); 5928 if (msg[0] == IXGBE_VF_RESET) { 5929 ixgbe_vf_reset_msg(adapter, vf, msg); 5930 return; 5931 } 5932 5933 if (!(vf->flags & IXGBE_VF_CTS)) { 5934 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5935 return; 5936 } 5937 5938 switch (msg[0] & IXGBE_VT_MSG_MASK) { 5939 case IXGBE_VF_SET_MAC_ADDR: 5940 ixgbe_vf_set_mac(adapter, vf, msg); 5941 break; 5942 case IXGBE_VF_SET_MULTICAST: 5943 ixgbe_vf_set_mc_addr(adapter, vf, msg); 5944 break; 5945 case IXGBE_VF_SET_VLAN: 5946 ixgbe_vf_set_vlan(adapter, vf, msg); 5947 break; 5948 case IXGBE_VF_SET_LPE: 5949 ixgbe_vf_set_lpe(adapter, vf, msg); 5950 break; 5951 case IXGBE_VF_SET_MACVLAN: 5952 ixgbe_vf_set_macvlan(adapter, vf, msg); 5953 break; 5954 case IXGBE_VF_API_NEGOTIATE: 5955 ixgbe_vf_api_negotiate(adapter, vf, msg); 5956 break; 5957 case IXGBE_VF_GET_QUEUES: 5958 ixgbe_vf_get_queues(adapter, vf, msg); 5959 break; 5960 default: 5961 ixgbe_send_vf_nack(adapter, vf, msg[0]); 5962 } 5963 } 5964 5965 5966 /* 5967 * Tasklet for handling VF -> PF mailbox messages. 5968 */ 5969 static void 5970 ixgbe_handle_mbx(void *context, int pending) 5971 { 5972 struct adapter *adapter; 5973 struct ixgbe_hw *hw; 5974 struct ixgbe_vf *vf; 5975 int i; 5976 5977 adapter = context; 5978 hw = &adapter->hw; 5979 5980 IXGBE_CORE_LOCK(adapter); 5981 for (i = 0; i < adapter->num_vfs; i++) { 5982 vf = &adapter->vfs[i]; 5983 5984 if (vf->flags & IXGBE_VF_ACTIVE) { 5985 if (ixgbe_check_for_rst(hw, vf->pool) == 0) 5986 ixgbe_process_vf_reset(adapter, vf); 5987 5988 if (ixgbe_check_for_msg(hw, vf->pool) == 0) 5989 ixgbe_process_vf_msg(adapter, vf); 5990 5991 if (ixgbe_check_for_ack(hw, vf->pool) == 0) 5992 ixgbe_process_vf_ack(adapter, vf); 5993 } 5994 } 5995 IXGBE_CORE_UNLOCK(adapter); 5996 } 5997 5998 5999 static int 6000 ixgbe_init_iov(device_t dev, u16 num_vfs, const nvlist_t *config) 6001 { 6002 struct adapter *adapter; 6003 enum ixgbe_iov_mode mode; 6004 6005 adapter = device_get_softc(dev); 6006 adapter->num_vfs = num_vfs; 6007 mode = ixgbe_get_iov_mode(adapter); 6008 6009 if (num_vfs > ixgbe_max_vfs(mode)) { 6010 adapter->num_vfs = 0; 6011 return (ENOSPC); 6012 } 6013 6014 IXGBE_CORE_LOCK(adapter); 6015 6016 adapter->vfs = malloc(sizeof(*adapter->vfs) * num_vfs, M_IXGBE, 6017 M_NOWAIT | M_ZERO); 6018 6019 if (adapter->vfs == NULL) { 6020 adapter->num_vfs = 0; 6021 IXGBE_CORE_UNLOCK(adapter); 6022 return (ENOMEM); 6023 } 6024 6025 ixgbe_init_locked(adapter); 6026 6027 IXGBE_CORE_UNLOCK(adapter); 6028 6029 return (0); 6030 } 6031 6032 6033 static void 6034 ixgbe_uninit_iov(device_t dev) 6035 { 6036 struct ixgbe_hw *hw; 6037 struct adapter *adapter; 6038 uint32_t pf_reg, vf_reg; 6039 6040 adapter = device_get_softc(dev); 6041 hw = &adapter->hw; 6042 6043 IXGBE_CORE_LOCK(adapter); 6044 6045 /* Enable rx/tx for the PF and disable it for all VFs. */ 6046 pf_reg = IXGBE_VF_INDEX(adapter->pool); 6047 IXGBE_WRITE_REG(hw, IXGBE_VFRE(pf_reg), 6048 IXGBE_VF_BIT(adapter->pool)); 6049 IXGBE_WRITE_REG(hw, IXGBE_VFTE(pf_reg), 6050 IXGBE_VF_BIT(adapter->pool)); 6051 6052 if (pf_reg == 0) 6053 vf_reg = 1; 6054 else 6055 vf_reg = 0; 6056 IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), 0); 6057 IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), 0); 6058 6059 IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, 0); 6060 6061 free(adapter->vfs, M_IXGBE); 6062 adapter->vfs = NULL; 6063 adapter->num_vfs = 0; 6064 6065 IXGBE_CORE_UNLOCK(adapter); 6066 } 6067 6068 6069 static void 6070 ixgbe_initialize_iov(struct adapter *adapter) 6071 { 6072 struct ixgbe_hw *hw = &adapter->hw; 6073 uint32_t mrqc, mtqc, vt_ctl, vf_reg, gcr_ext, gpie; 6074 enum ixgbe_iov_mode mode; 6075 int i; 6076 6077 mode = ixgbe_get_iov_mode(adapter); 6078 if (mode == IXGBE_NO_VM) 6079 return; 6080 6081 IXGBE_CORE_LOCK_ASSERT(adapter); 6082 6083 mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC); 6084 mrqc &= ~IXGBE_MRQC_MRQE_MASK; 6085 6086 switch (mode) { 6087 case IXGBE_64_VM: 6088 mrqc |= IXGBE_MRQC_VMDQRSS64EN; 6089 break; 6090 case IXGBE_32_VM: 6091 mrqc |= IXGBE_MRQC_VMDQRSS32EN; 6092 break; 6093 default: 6094 panic("Unexpected SR-IOV mode %d", mode); 6095 } 6096 IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc); 6097 6098 mtqc = IXGBE_MTQC_VT_ENA; 6099 switch (mode) { 6100 case IXGBE_64_VM: 6101 mtqc |= IXGBE_MTQC_64VF; 6102 break; 6103 case IXGBE_32_VM: 6104 mtqc |= IXGBE_MTQC_32VF; 6105 break; 6106 default: 6107 panic("Unexpected SR-IOV mode %d", mode); 6108 } 6109 IXGBE_WRITE_REG(hw, IXGBE_MTQC, mtqc); 6110 6111 6112 gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT); 6113 gcr_ext |= IXGBE_GCR_EXT_MSIX_EN; 6114 gcr_ext &= ~IXGBE_GCR_EXT_VT_MODE_MASK; 6115 switch (mode) { 6116 case IXGBE_64_VM: 6117 gcr_ext |= IXGBE_GCR_EXT_VT_MODE_64; 6118 break; 6119 case IXGBE_32_VM: 6120 gcr_ext |= IXGBE_GCR_EXT_VT_MODE_32; 6121 break; 6122 default: 6123 panic("Unexpected SR-IOV mode %d", mode); 6124 } 6125 IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext); 6126 6127 6128 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 6129 gcr_ext &= ~IXGBE_GPIE_VTMODE_MASK; 6130 switch (mode) { 6131 case IXGBE_64_VM: 6132 gpie |= IXGBE_GPIE_VTMODE_64; 6133 break; 6134 case IXGBE_32_VM: 6135 gpie |= IXGBE_GPIE_VTMODE_32; 6136 break; 6137 default: 6138 panic("Unexpected SR-IOV mode %d", mode); 6139 } 6140 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 6141 6142 /* Enable rx/tx for the PF. */ 6143 vf_reg = IXGBE_VF_INDEX(adapter->pool); 6144 IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), 6145 IXGBE_VF_BIT(adapter->pool)); 6146 IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), 6147 IXGBE_VF_BIT(adapter->pool)); 6148 6149 /* Allow VM-to-VM communication. */ 6150 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN); 6151 6152 vt_ctl = IXGBE_VT_CTL_VT_ENABLE | IXGBE_VT_CTL_REPLEN; 6153 vt_ctl |= (adapter->pool << IXGBE_VT_CTL_POOL_SHIFT); 6154 IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vt_ctl); 6155 6156 for (i = 0; i < adapter->num_vfs; i++) 6157 ixgbe_init_vf(adapter, &adapter->vfs[i]); 6158 } 6159 6160 6161 /* 6162 ** Check the max frame setting of all active VF's 6163 */ 6164 static void 6165 ixgbe_recalculate_max_frame(struct adapter *adapter) 6166 { 6167 struct ixgbe_vf *vf; 6168 6169 IXGBE_CORE_LOCK_ASSERT(adapter); 6170 6171 for (int i = 0; i < adapter->num_vfs; i++) { 6172 vf = &adapter->vfs[i]; 6173 if (vf->flags & IXGBE_VF_ACTIVE) 6174 ixgbe_update_max_frame(adapter, vf->max_frame_size); 6175 } 6176 } 6177 6178 6179 static void 6180 ixgbe_init_vf(struct adapter *adapter, struct ixgbe_vf *vf) 6181 { 6182 struct ixgbe_hw *hw; 6183 uint32_t vf_index, pfmbimr; 6184 6185 IXGBE_CORE_LOCK_ASSERT(adapter); 6186 6187 hw = &adapter->hw; 6188 6189 if (!(vf->flags & IXGBE_VF_ACTIVE)) 6190 return; 6191 6192 vf_index = IXGBE_VF_INDEX(vf->pool); 6193 pfmbimr = IXGBE_READ_REG(hw, IXGBE_PFMBIMR(vf_index)); 6194 pfmbimr |= IXGBE_VF_BIT(vf->pool); 6195 IXGBE_WRITE_REG(hw, IXGBE_PFMBIMR(vf_index), pfmbimr); 6196 6197 ixgbe_vf_set_default_vlan(adapter, vf, vf->vlan_tag); 6198 6199 // XXX multicast addresses 6200 6201 if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) { 6202 ixgbe_set_rar(&adapter->hw, vf->rar_index, 6203 vf->ether_addr, vf->pool, TRUE); 6204 } 6205 6206 ixgbe_vf_enable_transmit(adapter, vf); 6207 ixgbe_vf_enable_receive(adapter, vf); 6208 6209 ixgbe_send_vf_msg(adapter, vf, IXGBE_PF_CONTROL_MSG); 6210 } 6211 6212 static int 6213 ixgbe_add_vf(device_t dev, u16 vfnum, const nvlist_t *config) 6214 { 6215 struct adapter *adapter; 6216 struct ixgbe_vf *vf; 6217 const void *mac; 6218 6219 adapter = device_get_softc(dev); 6220 6221 KASSERT(vfnum < adapter->num_vfs, ("VF index %d is out of range %d", 6222 vfnum, adapter->num_vfs)); 6223 6224 IXGBE_CORE_LOCK(adapter); 6225 vf = &adapter->vfs[vfnum]; 6226 vf->pool= vfnum; 6227 6228 /* RAR[0] is used by the PF so use vfnum + 1 for VF RAR. */ 6229 vf->rar_index = vfnum + 1; 6230 vf->default_vlan = 0; 6231 vf->max_frame_size = ETHER_MAX_LEN; 6232 ixgbe_update_max_frame(adapter, vf->max_frame_size); 6233 6234 if (nvlist_exists_binary(config, "mac-addr")) { 6235 mac = nvlist_get_binary(config, "mac-addr", NULL); 6236 bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN); 6237 if (nvlist_get_bool(config, "allow-set-mac")) 6238 vf->flags |= IXGBE_VF_CAP_MAC; 6239 } else 6240 /* 6241 * If the administrator has not specified a MAC address then 6242 * we must allow the VF to choose one. 6243 */ 6244 vf->flags |= IXGBE_VF_CAP_MAC; 6245 6246 vf->flags = IXGBE_VF_ACTIVE; 6247 6248 ixgbe_init_vf(adapter, vf); 6249 IXGBE_CORE_UNLOCK(adapter); 6250 6251 return (0); 6252 } 6253 #endif /* PCI_IOV */ 6254 static void 6255 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6256 { 6257 u32 mask; 6258 6259 switch (adapter->hw.mac.type) { 6260 case ixgbe_mac_82598EB: 6261 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6262 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6263 break; 6264 case ixgbe_mac_82599EB: 6265 case ixgbe_mac_X540: 6266 case ixgbe_mac_X550: 6267 case ixgbe_mac_X550EM_x: 6268 mask = (queues & 0xFFFFFFFF); 6269 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6270 mask = (queues >> 32); 6271 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6272 break; 6273 default: 6274 break; 6275 } 6276 } 6277
Indexes created Mon Sep 29 13:09:55 GMT 2025