ixgbe.c revision 1.292
1 /* $NetBSD: ixgbe.c,v 1.292 2021/09/16 09:55:28 msaitoh Exp $ */ 2 3 /****************************************************************************** 4 5 Copyright (c) 2001-2017, Intel Corporation 6 All rights reserved. 7 8 Redistribution and use in source and binary forms, with or without 9 modification, are permitted provided that the following conditions are met: 10 11 1. Redistributions of source code must retain the above copyright notice, 12 this list of conditions and the following disclaimer. 13 14 2. Redistributions in binary form must reproduce the above copyright 15 notice, this list of conditions and the following disclaimer in the 16 documentation and/or other materials provided with the distribution. 17 18 3. Neither the name of the Intel Corporation nor the names of its 19 contributors may be used to endorse or promote products derived from 20 this software without specific prior written permission. 21 22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 23 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 POSSIBILITY OF SUCH DAMAGE. 33 34 ******************************************************************************/ 35 /*$FreeBSD: head/sys/dev/ixgbe/if_ix.c 331224 2018-03-19 20:55:05Z erj $*/ 36 37 /* 38 * Copyright (c) 2011 The NetBSD Foundation, Inc. 39 * All rights reserved. 40 * 41 * This code is derived from software contributed to The NetBSD Foundation 42 * by Coyote Point Systems, Inc. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 63 * POSSIBILITY OF SUCH DAMAGE. 64 */ 65 66 #include <sys/cdefs.h> 67 __KERNEL_RCSID(0, "$NetBSD: ixgbe.c,v 1.292 2021/09/16 09:55:28 msaitoh Exp $"); 68 69 #ifdef _KERNEL_OPT 70 #include "opt_inet.h" 71 #include "opt_inet6.h" 72 #include "opt_net_mpsafe.h" 73 #endif 74 75 #include "ixgbe.h" 76 #include "ixgbe_phy.h" 77 #include "ixgbe_sriov.h" 78 #include "vlan.h" 79 80 #include <sys/cprng.h> 81 #include <dev/mii/mii.h> 82 #include <dev/mii/miivar.h> 83 84 /************************************************************************ 85 * Driver version 86 ************************************************************************/ 87 static const char ixgbe_driver_version[] = "4.0.1-k"; 88 /* XXX NetBSD: + 3.3.10 */ 89 90 /************************************************************************ 91 * PCI Device ID Table 92 * 93 * Used by probe to select devices to load on 94 * Last field stores an index into ixgbe_strings 95 * Last entry must be all 0s 96 * 97 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 98 ************************************************************************/ 99 static const ixgbe_vendor_info_t ixgbe_vendor_info_array[] = 100 { 101 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0}, 102 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0}, 103 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0}, 104 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0}, 105 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0}, 106 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0}, 107 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_BX, 0, 0, 0}, 108 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0}, 109 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0}, 110 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0}, 111 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0}, 112 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0}, 113 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KR, 0, 0, 0}, 114 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0}, 115 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0}, 116 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0}, 117 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_EM, 0, 0, 0}, 118 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0}, 119 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0}, 120 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0}, 121 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0}, 122 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0}, 123 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0}, 124 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0}, 125 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0}, 126 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0}, 127 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, 0, 0, 0}, 128 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0}, 129 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, 0, 0, 0}, 130 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, 0, 0, 0}, 131 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T1, 0, 0, 0}, 132 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, 0, 0, 0}, 133 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, 0, 0, 0}, 134 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, 0, 0, 0}, 135 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_1G_T, 0, 0, 0}, 136 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_SFP, 0, 0, 0}, 137 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_XFI, 0, 0, 0}, 138 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR, 0, 0, 0}, 139 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR_L, 0, 0, 0}, 140 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_QSFP, 0, 0, 0}, 141 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_QSFP_N, 0, 0, 0}, 142 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP, 0, 0, 0}, 143 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP_N, 0, 0, 0}, 144 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII, 0, 0, 0}, 145 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII_L, 0, 0, 0}, 146 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_10G_T, 0, 0, 0}, 147 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T, 0, 0, 0}, 148 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T_L, 0, 0, 0}, 149 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_BYPASS, 0, 0, 0}, 150 {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BYPASS, 0, 0, 0}, 151 /* required last entry */ 152 {0, 0, 0, 0, 0} 153 }; 154 155 /************************************************************************ 156 * Table of branding strings 157 ************************************************************************/ 158 static const char *ixgbe_strings[] = { 159 "Intel(R) PRO/10GbE PCI-Express Network Driver" 160 }; 161 162 /************************************************************************ 163 * Function prototypes 164 ************************************************************************/ 165 static int ixgbe_probe(device_t, cfdata_t, void *); 166 static void ixgbe_quirks(struct adapter *); 167 static void ixgbe_attach(device_t, device_t, void *); 168 static int ixgbe_detach(device_t, int); 169 #if 0 170 static int ixgbe_shutdown(device_t); 171 #endif 172 static bool ixgbe_suspend(device_t, const pmf_qual_t *); 173 static bool ixgbe_resume(device_t, const pmf_qual_t *); 174 static int ixgbe_ifflags_cb(struct ethercom *); 175 static int ixgbe_ioctl(struct ifnet *, u_long, void *); 176 static int ixgbe_init(struct ifnet *); 177 static void ixgbe_init_locked(struct adapter *); 178 static void ixgbe_ifstop(struct ifnet *, int); 179 static void ixgbe_stop_locked(void *); 180 static void ixgbe_init_device_features(struct adapter *); 181 static int ixgbe_check_fan_failure(struct adapter *, u32, bool); 182 static void ixgbe_add_media_types(struct adapter *); 183 static void ixgbe_media_status(struct ifnet *, struct ifmediareq *); 184 static int ixgbe_media_change(struct ifnet *); 185 static int ixgbe_allocate_pci_resources(struct adapter *, 186 const struct pci_attach_args *); 187 static void ixgbe_free_deferred_handlers(struct adapter *); 188 static void ixgbe_get_slot_info(struct adapter *); 189 static int ixgbe_allocate_msix(struct adapter *, 190 const struct pci_attach_args *); 191 static int ixgbe_allocate_legacy(struct adapter *, 192 const struct pci_attach_args *); 193 static int ixgbe_configure_interrupts(struct adapter *); 194 static void ixgbe_free_pciintr_resources(struct adapter *); 195 static void ixgbe_free_pci_resources(struct adapter *); 196 static void ixgbe_local_timer(void *); 197 static void ixgbe_handle_timer(struct work *, void *); 198 static void ixgbe_recovery_mode_timer(void *); 199 static void ixgbe_handle_recovery_mode_timer(struct work *, void *); 200 static int ixgbe_setup_interface(device_t, struct adapter *); 201 static void ixgbe_config_gpie(struct adapter *); 202 static void ixgbe_config_dmac(struct adapter *); 203 static void ixgbe_config_delay_values(struct adapter *); 204 static void ixgbe_schedule_admin_tasklet(struct adapter *); 205 static void ixgbe_config_link(struct adapter *); 206 static void ixgbe_check_wol_support(struct adapter *); 207 static int ixgbe_setup_low_power_mode(struct adapter *); 208 #if 0 209 static void ixgbe_rearm_queues(struct adapter *, u64); 210 #endif 211 212 static void ixgbe_initialize_transmit_units(struct adapter *); 213 static void ixgbe_initialize_receive_units(struct adapter *); 214 static void ixgbe_enable_rx_drop(struct adapter *); 215 static void ixgbe_disable_rx_drop(struct adapter *); 216 static void ixgbe_initialize_rss_mapping(struct adapter *); 217 218 static void ixgbe_enable_intr(struct adapter *); 219 static void ixgbe_disable_intr(struct adapter *); 220 static void ixgbe_update_stats_counters(struct adapter *); 221 static void ixgbe_set_rxfilter(struct adapter *); 222 static void ixgbe_update_link_status(struct adapter *); 223 static void ixgbe_set_ivar(struct adapter *, u8, u8, s8); 224 static void ixgbe_configure_ivars(struct adapter *); 225 static u8 * ixgbe_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *); 226 static void ixgbe_eitr_write(struct adapter *, uint32_t, uint32_t); 227 228 static void ixgbe_setup_vlan_hw_tagging(struct adapter *); 229 static void ixgbe_setup_vlan_hw_support(struct adapter *); 230 static int ixgbe_vlan_cb(struct ethercom *, uint16_t, bool); 231 static int ixgbe_register_vlan(struct adapter *, u16); 232 static int ixgbe_unregister_vlan(struct adapter *, u16); 233 234 static void ixgbe_add_device_sysctls(struct adapter *); 235 static void ixgbe_add_hw_stats(struct adapter *); 236 static void ixgbe_clear_evcnt(struct adapter *); 237 static int ixgbe_set_flowcntl(struct adapter *, int); 238 static int ixgbe_set_advertise(struct adapter *, int); 239 static int ixgbe_get_advertise(struct adapter *); 240 241 /* Sysctl handlers */ 242 static void ixgbe_set_sysctl_value(struct adapter *, const char *, 243 const char *, int *, int); 244 static int ixgbe_sysctl_flowcntl(SYSCTLFN_PROTO); 245 static int ixgbe_sysctl_advertise(SYSCTLFN_PROTO); 246 static int ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO); 247 static int ixgbe_sysctl_dmac(SYSCTLFN_PROTO); 248 static int ixgbe_sysctl_phy_temp(SYSCTLFN_PROTO); 249 static int ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_PROTO); 250 #ifdef IXGBE_DEBUG 251 static int ixgbe_sysctl_power_state(SYSCTLFN_PROTO); 252 static int ixgbe_sysctl_print_rss_config(SYSCTLFN_PROTO); 253 #endif 254 static int ixgbe_sysctl_next_to_check_handler(SYSCTLFN_PROTO); 255 static int ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_PROTO); 256 static int ixgbe_sysctl_rdh_handler(SYSCTLFN_PROTO); 257 static int ixgbe_sysctl_rdt_handler(SYSCTLFN_PROTO); 258 static int ixgbe_sysctl_tdt_handler(SYSCTLFN_PROTO); 259 static int ixgbe_sysctl_tdh_handler(SYSCTLFN_PROTO); 260 static int ixgbe_sysctl_eee_state(SYSCTLFN_PROTO); 261 static int ixgbe_sysctl_debug(SYSCTLFN_PROTO); 262 static int ixgbe_sysctl_rx_copy_len(SYSCTLFN_PROTO); 263 static int ixgbe_sysctl_wol_enable(SYSCTLFN_PROTO); 264 static int ixgbe_sysctl_wufc(SYSCTLFN_PROTO); 265 266 /* Interrupt functions */ 267 static int ixgbe_msix_que(void *); 268 static int ixgbe_msix_admin(void *); 269 static void ixgbe_intr_admin_common(struct adapter *, u32, u32 *); 270 static int ixgbe_legacy_irq(void *); 271 272 /* Event handlers running on workqueue */ 273 static void ixgbe_handle_que(void *); 274 static void ixgbe_handle_link(void *); 275 static void ixgbe_handle_msf(void *); 276 static void ixgbe_handle_mod(void *, bool); 277 static void ixgbe_handle_phy(void *); 278 279 /* Deferred workqueue handlers */ 280 static void ixgbe_handle_admin(struct work *, void *); 281 static void ixgbe_handle_que_work(struct work *, void *); 282 283 static const ixgbe_vendor_info_t *ixgbe_lookup(const struct pci_attach_args *); 284 285 /************************************************************************ 286 * NetBSD Device Interface Entry Points 287 ************************************************************************/ 288 CFATTACH_DECL3_NEW(ixg, sizeof(struct adapter), 289 ixgbe_probe, ixgbe_attach, ixgbe_detach, NULL, NULL, NULL, 290 DVF_DETACH_SHUTDOWN); 291 292 #if 0 293 devclass_t ix_devclass; 294 DRIVER_MODULE(ix, pci, ix_driver, ix_devclass, 0, 0); 295 296 MODULE_DEPEND(ix, pci, 1, 1, 1); 297 MODULE_DEPEND(ix, ether, 1, 1, 1); 298 #ifdef DEV_NETMAP 299 MODULE_DEPEND(ix, netmap, 1, 1, 1); 300 #endif 301 #endif 302 303 /* 304 * TUNEABLE PARAMETERS: 305 */ 306 307 /* 308 * AIM: Adaptive Interrupt Moderation 309 * which means that the interrupt rate 310 * is varied over time based on the 311 * traffic for that interrupt vector 312 */ 313 static bool ixgbe_enable_aim = true; 314 #define SYSCTL_INT(_a1, _a2, _a3, _a4, _a5, _a6, _a7) 315 SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RDTUN, &ixgbe_enable_aim, 0, 316 "Enable adaptive interrupt moderation"); 317 318 static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY); 319 SYSCTL_INT(_hw_ix, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN, 320 &ixgbe_max_interrupt_rate, 0, "Maximum interrupts per second"); 321 322 /* How many packets rxeof tries to clean at a time */ 323 static int ixgbe_rx_process_limit = 256; 324 SYSCTL_INT(_hw_ix, OID_AUTO, rx_process_limit, CTLFLAG_RDTUN, 325 &ixgbe_rx_process_limit, 0, "Maximum number of received packets to process at a time, -1 means unlimited"); 326 327 /* How many packets txeof tries to clean at a time */ 328 static int ixgbe_tx_process_limit = 256; 329 SYSCTL_INT(_hw_ix, OID_AUTO, tx_process_limit, CTLFLAG_RDTUN, 330 &ixgbe_tx_process_limit, 0, 331 "Maximum number of sent packets to process at a time, -1 means unlimited"); 332 333 /* Flow control setting, default to full */ 334 static int ixgbe_flow_control = ixgbe_fc_full; 335 SYSCTL_INT(_hw_ix, OID_AUTO, flow_control, CTLFLAG_RDTUN, 336 &ixgbe_flow_control, 0, "Default flow control used for all adapters"); 337 338 /* Which packet processing uses workqueue or softint */ 339 static bool ixgbe_txrx_workqueue = false; 340 341 /* 342 * Smart speed setting, default to on 343 * this only works as a compile option 344 * right now as its during attach, set 345 * this to 'ixgbe_smart_speed_off' to 346 * disable. 347 */ 348 static int ixgbe_smart_speed = ixgbe_smart_speed_on; 349 350 /* 351 * MSI-X should be the default for best performance, 352 * but this allows it to be forced off for testing. 353 */ 354 static int ixgbe_enable_msix = 1; 355 SYSCTL_INT(_hw_ix, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixgbe_enable_msix, 0, 356 "Enable MSI-X interrupts"); 357 358 /* 359 * Number of Queues, can be set to 0, 360 * it then autoconfigures based on the 361 * number of cpus with a max of 8. This 362 * can be overridden manually here. 363 */ 364 static int ixgbe_num_queues = 0; 365 SYSCTL_INT(_hw_ix, OID_AUTO, num_queues, CTLFLAG_RDTUN, &ixgbe_num_queues, 0, 366 "Number of queues to configure, 0 indicates autoconfigure"); 367 368 /* 369 * Number of TX descriptors per ring, 370 * setting higher than RX as this seems 371 * the better performing choice. 372 */ 373 static int ixgbe_txd = PERFORM_TXD; 374 SYSCTL_INT(_hw_ix, OID_AUTO, txd, CTLFLAG_RDTUN, &ixgbe_txd, 0, 375 "Number of transmit descriptors per queue"); 376 377 /* Number of RX descriptors per ring */ 378 static int ixgbe_rxd = PERFORM_RXD; 379 SYSCTL_INT(_hw_ix, OID_AUTO, rxd, CTLFLAG_RDTUN, &ixgbe_rxd, 0, 380 "Number of receive descriptors per queue"); 381 382 /* 383 * Defining this on will allow the use 384 * of unsupported SFP+ modules, note that 385 * doing so you are on your own :) 386 */ 387 static int allow_unsupported_sfp = false; 388 #define TUNABLE_INT(__x, __y) 389 TUNABLE_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp); 390 391 /* 392 * Not sure if Flow Director is fully baked, 393 * so we'll default to turning it off. 394 */ 395 static int ixgbe_enable_fdir = 0; 396 SYSCTL_INT(_hw_ix, OID_AUTO, enable_fdir, CTLFLAG_RDTUN, &ixgbe_enable_fdir, 0, 397 "Enable Flow Director"); 398 399 /* Legacy Transmit (single queue) */ 400 static int ixgbe_enable_legacy_tx = 0; 401 SYSCTL_INT(_hw_ix, OID_AUTO, enable_legacy_tx, CTLFLAG_RDTUN, 402 &ixgbe_enable_legacy_tx, 0, "Enable Legacy TX flow"); 403 404 /* Receive-Side Scaling */ 405 static int ixgbe_enable_rss = 1; 406 SYSCTL_INT(_hw_ix, OID_AUTO, enable_rss, CTLFLAG_RDTUN, &ixgbe_enable_rss, 0, 407 "Enable Receive-Side Scaling (RSS)"); 408 409 #if 0 410 static int (*ixgbe_start_locked)(struct ifnet *, struct tx_ring *); 411 static int (*ixgbe_ring_empty)(struct ifnet *, pcq_t *); 412 #endif 413 414 #ifdef NET_MPSAFE 415 #define IXGBE_MPSAFE 1 416 #define IXGBE_CALLOUT_FLAGS CALLOUT_MPSAFE 417 #define IXGBE_SOFTINT_FLAGS SOFTINT_MPSAFE 418 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU | WQ_MPSAFE 419 #define IXGBE_TASKLET_WQ_FLAGS WQ_MPSAFE 420 #else 421 #define IXGBE_CALLOUT_FLAGS 0 422 #define IXGBE_SOFTINT_FLAGS 0 423 #define IXGBE_WORKQUEUE_FLAGS WQ_PERCPU 424 #define IXGBE_TASKLET_WQ_FLAGS 0 425 #endif 426 #define IXGBE_WORKQUEUE_PRI PRI_SOFTNET 427 428 /************************************************************************ 429 * ixgbe_initialize_rss_mapping 430 ************************************************************************/ 431 static void 432 ixgbe_initialize_rss_mapping(struct adapter *adapter) 433 { 434 struct ixgbe_hw *hw = &adapter->hw; 435 u32 reta = 0, mrqc, rss_key[10]; 436 int queue_id, table_size, index_mult; 437 int i, j; 438 u32 rss_hash_config; 439 440 /* force use default RSS key. */ 441 #ifdef __NetBSD__ 442 rss_getkey((uint8_t *) &rss_key); 443 #else 444 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 445 /* Fetch the configured RSS key */ 446 rss_getkey((uint8_t *) &rss_key); 447 } else { 448 /* set up random bits */ 449 cprng_fast(&rss_key, sizeof(rss_key)); 450 } 451 #endif 452 453 /* Set multiplier for RETA setup and table size based on MAC */ 454 index_mult = 0x1; 455 table_size = 128; 456 switch (adapter->hw.mac.type) { 457 case ixgbe_mac_82598EB: 458 index_mult = 0x11; 459 break; 460 case ixgbe_mac_X550: 461 case ixgbe_mac_X550EM_x: 462 case ixgbe_mac_X550EM_a: 463 table_size = 512; 464 break; 465 default: 466 break; 467 } 468 469 /* Set up the redirection table */ 470 for (i = 0, j = 0; i < table_size; i++, j++) { 471 if (j == adapter->num_queues) 472 j = 0; 473 474 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 475 /* 476 * Fetch the RSS bucket id for the given indirection 477 * entry. Cap it at the number of configured buckets 478 * (which is num_queues.) 479 */ 480 queue_id = rss_get_indirection_to_bucket(i); 481 queue_id = queue_id % adapter->num_queues; 482 } else 483 queue_id = (j * index_mult); 484 485 /* 486 * The low 8 bits are for hash value (n+0); 487 * The next 8 bits are for hash value (n+1), etc. 488 */ 489 reta = reta >> 8; 490 reta = reta | (((uint32_t) queue_id) << 24); 491 if ((i & 3) == 3) { 492 if (i < 128) 493 IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta); 494 else 495 IXGBE_WRITE_REG(hw, IXGBE_ERETA((i >> 2) - 32), 496 reta); 497 reta = 0; 498 } 499 } 500 501 /* Now fill our hash function seeds */ 502 for (i = 0; i < 10; i++) 503 IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), rss_key[i]); 504 505 /* Perform hash on these packet types */ 506 if (adapter->feat_en & IXGBE_FEATURE_RSS) 507 rss_hash_config = rss_gethashconfig(); 508 else { 509 /* 510 * Disable UDP - IP fragments aren't currently being handled 511 * and so we end up with a mix of 2-tuple and 4-tuple 512 * traffic. 513 */ 514 rss_hash_config = RSS_HASHTYPE_RSS_IPV4 515 | RSS_HASHTYPE_RSS_TCP_IPV4 516 | RSS_HASHTYPE_RSS_IPV6 517 | RSS_HASHTYPE_RSS_TCP_IPV6 518 | RSS_HASHTYPE_RSS_IPV6_EX 519 | RSS_HASHTYPE_RSS_TCP_IPV6_EX; 520 } 521 522 mrqc = IXGBE_MRQC_RSSEN; 523 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) 524 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4; 525 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) 526 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP; 527 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6) 528 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6; 529 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) 530 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP; 531 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX) 532 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX; 533 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX) 534 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP; 535 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) 536 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP; 537 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) 538 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP; 539 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX) 540 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP; 541 mrqc |= ixgbe_get_mrqc(adapter->iov_mode); 542 IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc); 543 } /* ixgbe_initialize_rss_mapping */ 544 545 /************************************************************************ 546 * ixgbe_initialize_receive_units - Setup receive registers and features. 547 ************************************************************************/ 548 #define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1) 549 550 static void 551 ixgbe_initialize_receive_units(struct adapter *adapter) 552 { 553 struct rx_ring *rxr = adapter->rx_rings; 554 struct ixgbe_hw *hw = &adapter->hw; 555 struct ifnet *ifp = adapter->ifp; 556 int i, j; 557 u32 bufsz, fctrl, srrctl, rxcsum; 558 u32 hlreg; 559 560 /* 561 * Make sure receives are disabled while 562 * setting up the descriptor ring 563 */ 564 ixgbe_disable_rx(hw); 565 566 /* Enable broadcasts */ 567 fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL); 568 fctrl |= IXGBE_FCTRL_BAM; 569 if (adapter->hw.mac.type == ixgbe_mac_82598EB) { 570 fctrl |= IXGBE_FCTRL_DPF; 571 fctrl |= IXGBE_FCTRL_PMCF; 572 } 573 IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl); 574 575 /* Set for Jumbo Frames? */ 576 hlreg = IXGBE_READ_REG(hw, IXGBE_HLREG0); 577 if (ifp->if_mtu > ETHERMTU) 578 hlreg |= IXGBE_HLREG0_JUMBOEN; 579 else 580 hlreg &= ~IXGBE_HLREG0_JUMBOEN; 581 582 #ifdef DEV_NETMAP 583 /* CRC stripping is conditional in Netmap */ 584 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 585 (ifp->if_capenable & IFCAP_NETMAP) && 586 !ix_crcstrip) 587 hlreg &= ~IXGBE_HLREG0_RXCRCSTRP; 588 else 589 #endif /* DEV_NETMAP */ 590 hlreg |= IXGBE_HLREG0_RXCRCSTRP; 591 592 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg); 593 594 bufsz = (adapter->rx_mbuf_sz + BSIZEPKT_ROUNDUP) >> 595 IXGBE_SRRCTL_BSIZEPKT_SHIFT; 596 597 for (i = 0; i < adapter->num_queues; i++, rxr++) { 598 u64 rdba = rxr->rxdma.dma_paddr; 599 u32 reg; 600 int regnum = i / 4; /* 1 register per 4 queues */ 601 int regshift = i % 4; /* 4 bits per 1 queue */ 602 j = rxr->me; 603 604 /* Setup the Base and Length of the Rx Descriptor Ring */ 605 IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j), 606 (rdba & 0x00000000ffffffffULL)); 607 IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32)); 608 IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j), 609 adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc)); 610 611 /* Set up the SRRCTL register */ 612 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(j)); 613 srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK; 614 srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK; 615 srrctl |= bufsz; 616 srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF; 617 618 /* Set RQSMR (Receive Queue Statistic Mapping) register */ 619 reg = IXGBE_READ_REG(hw, IXGBE_RQSMR(regnum)); 620 reg &= ~(0x000000ffUL << (regshift * 8)); 621 reg |= i << (regshift * 8); 622 IXGBE_WRITE_REG(hw, IXGBE_RQSMR(regnum), reg); 623 624 /* 625 * Set DROP_EN iff we have no flow control and >1 queue. 626 * Note that srrctl was cleared shortly before during reset, 627 * so we do not need to clear the bit, but do it just in case 628 * this code is moved elsewhere. 629 */ 630 if (adapter->num_queues > 1 && 631 adapter->hw.fc.requested_mode == ixgbe_fc_none) { 632 srrctl |= IXGBE_SRRCTL_DROP_EN; 633 } else { 634 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 635 } 636 637 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(j), srrctl); 638 639 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 640 IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0); 641 IXGBE_WRITE_REG(hw, IXGBE_RDT(j), 0); 642 643 /* Set the driver rx tail address */ 644 rxr->tail = IXGBE_RDT(rxr->me); 645 } 646 647 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 648 u32 psrtype = IXGBE_PSRTYPE_TCPHDR 649 | IXGBE_PSRTYPE_UDPHDR 650 | IXGBE_PSRTYPE_IPV4HDR 651 | IXGBE_PSRTYPE_IPV6HDR; 652 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype); 653 } 654 655 rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM); 656 657 ixgbe_initialize_rss_mapping(adapter); 658 659 if (adapter->num_queues > 1) { 660 /* RSS and RX IPP Checksum are mutually exclusive */ 661 rxcsum |= IXGBE_RXCSUM_PCSD; 662 } 663 664 if (ifp->if_capenable & IFCAP_RXCSUM) 665 rxcsum |= IXGBE_RXCSUM_PCSD; 666 667 /* This is useful for calculating UDP/IP fragment checksums */ 668 if (!(rxcsum & IXGBE_RXCSUM_PCSD)) 669 rxcsum |= IXGBE_RXCSUM_IPPCSE; 670 671 IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum); 672 673 } /* ixgbe_initialize_receive_units */ 674 675 /************************************************************************ 676 * ixgbe_initialize_transmit_units - Enable transmit units. 677 ************************************************************************/ 678 static void 679 ixgbe_initialize_transmit_units(struct adapter *adapter) 680 { 681 struct tx_ring *txr = adapter->tx_rings; 682 struct ixgbe_hw *hw = &adapter->hw; 683 int i; 684 685 INIT_DEBUGOUT("ixgbe_initialize_transmit_units"); 686 687 /* Setup the Base and Length of the Tx Descriptor Ring */ 688 for (i = 0; i < adapter->num_queues; i++, txr++) { 689 u64 tdba = txr->txdma.dma_paddr; 690 u32 txctrl = 0; 691 u32 tqsmreg, reg; 692 int regnum = i / 4; /* 1 register per 4 queues */ 693 int regshift = i % 4; /* 4 bits per 1 queue */ 694 int j = txr->me; 695 696 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j), 697 (tdba & 0x00000000ffffffffULL)); 698 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32)); 699 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j), 700 adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc)); 701 702 /* 703 * Set TQSMR (Transmit Queue Statistic Mapping) register. 704 * Register location is different between 82598 and others. 705 */ 706 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 707 tqsmreg = IXGBE_TQSMR(regnum); 708 else 709 tqsmreg = IXGBE_TQSM(regnum); 710 reg = IXGBE_READ_REG(hw, tqsmreg); 711 reg &= ~(0x000000ffUL << (regshift * 8)); 712 reg |= i << (regshift * 8); 713 IXGBE_WRITE_REG(hw, tqsmreg, reg); 714 715 /* Setup the HW Tx Head and Tail descriptor pointers */ 716 IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0); 717 IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0); 718 719 /* Cache the tail address */ 720 txr->tail = IXGBE_TDT(j); 721 722 txr->txr_no_space = false; 723 724 /* Disable Head Writeback */ 725 /* 726 * Note: for X550 series devices, these registers are actually 727 * prefixed with TPH_ isntead of DCA_, but the addresses and 728 * fields remain the same. 729 */ 730 switch (hw->mac.type) { 731 case ixgbe_mac_82598EB: 732 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j)); 733 break; 734 default: 735 txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j)); 736 break; 737 } 738 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN; 739 switch (hw->mac.type) { 740 case ixgbe_mac_82598EB: 741 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl); 742 break; 743 default: 744 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl); 745 break; 746 } 747 748 } 749 750 if (hw->mac.type != ixgbe_mac_82598EB) { 751 u32 dmatxctl, rttdcs; 752 753 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL); 754 dmatxctl |= IXGBE_DMATXCTL_TE; 755 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl); 756 /* Disable arbiter to set MTQC */ 757 rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS); 758 rttdcs |= IXGBE_RTTDCS_ARBDIS; 759 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 760 IXGBE_WRITE_REG(hw, IXGBE_MTQC, 761 ixgbe_get_mtqc(adapter->iov_mode)); 762 rttdcs &= ~IXGBE_RTTDCS_ARBDIS; 763 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs); 764 } 765 766 return; 767 } /* ixgbe_initialize_transmit_units */ 768 769 static void 770 ixgbe_quirks(struct adapter *adapter) 771 { 772 device_t dev = adapter->dev; 773 struct ixgbe_hw *hw = &adapter->hw; 774 const char *vendor, *product; 775 776 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N) { 777 /* 778 * Quirk for inverted logic of SFP+'s MOD_ABS on GIGABYTE 779 * MA10-ST0. 780 */ 781 vendor = pmf_get_platform("system-vendor"); 782 product = pmf_get_platform("system-product"); 783 784 if ((vendor == NULL) || (product == NULL)) 785 return; 786 787 if ((strcmp(vendor, "GIGABYTE") == 0) && 788 (strcmp(product, "MA10-ST0") == 0)) { 789 aprint_verbose_dev(dev, 790 "Enable SFP+ MOD_ABS inverse quirk\n"); 791 adapter->hw.quirks |= IXGBE_QUIRK_MOD_ABS_INVERT; 792 } 793 } 794 } 795 796 /************************************************************************ 797 * ixgbe_attach - Device initialization routine 798 * 799 * Called when the driver is being loaded. 800 * Identifies the type of hardware, allocates all resources 801 * and initializes the hardware. 802 * 803 * return 0 on success, positive on failure 804 ************************************************************************/ 805 static void 806 ixgbe_attach(device_t parent, device_t dev, void *aux) 807 { 808 struct adapter *adapter; 809 struct ixgbe_hw *hw; 810 int error = -1; 811 u32 ctrl_ext; 812 u16 high, low, nvmreg; 813 pcireg_t id, subid; 814 const ixgbe_vendor_info_t *ent; 815 struct pci_attach_args *pa = aux; 816 bool unsupported_sfp = false; 817 const char *str; 818 char wqname[MAXCOMLEN]; 819 char buf[256]; 820 821 INIT_DEBUGOUT("ixgbe_attach: begin"); 822 823 /* Allocate, clear, and link in our adapter structure */ 824 adapter = device_private(dev); 825 adapter->hw.back = adapter; 826 adapter->dev = dev; 827 hw = &adapter->hw; 828 adapter->osdep.pc = pa->pa_pc; 829 adapter->osdep.tag = pa->pa_tag; 830 if (pci_dma64_available(pa)) 831 adapter->osdep.dmat = pa->pa_dmat64; 832 else 833 adapter->osdep.dmat = pa->pa_dmat; 834 adapter->osdep.attached = false; 835 adapter->osdep.detaching = false; 836 837 ent = ixgbe_lookup(pa); 838 839 KASSERT(ent != NULL); 840 841 aprint_normal(": %s, Version - %s\n", 842 ixgbe_strings[ent->index], ixgbe_driver_version); 843 844 /* Core Lock Init */ 845 IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev)); 846 847 /* Set up the timer callout and workqueue */ 848 callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS); 849 snprintf(wqname, sizeof(wqname), "%s-timer", device_xname(dev)); 850 error = workqueue_create(&adapter->timer_wq, wqname, 851 ixgbe_handle_timer, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 852 IXGBE_TASKLET_WQ_FLAGS); 853 if (error) { 854 aprint_error_dev(dev, 855 "could not create timer workqueue (%d)\n", error); 856 goto err_out; 857 } 858 859 /* Determine hardware revision */ 860 id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 861 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 862 863 hw->vendor_id = PCI_VENDOR(id); 864 hw->device_id = PCI_PRODUCT(id); 865 hw->revision_id = 866 PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG)); 867 hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid); 868 hw->subsystem_device_id = PCI_SUBSYS_ID(subid); 869 870 /* Set quirk flags */ 871 ixgbe_quirks(adapter); 872 873 /* 874 * Make sure BUSMASTER is set 875 */ 876 ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag); 877 878 /* Do base PCI setup - map BAR0 */ 879 if (ixgbe_allocate_pci_resources(adapter, pa)) { 880 aprint_error_dev(dev, "Allocation of PCI resources failed\n"); 881 error = ENXIO; 882 goto err_out; 883 } 884 885 /* let hardware know driver is loaded */ 886 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 887 ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD; 888 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 889 890 /* 891 * Initialize the shared code 892 */ 893 if (ixgbe_init_shared_code(hw) != 0) { 894 aprint_error_dev(dev, "Unable to initialize the shared code\n"); 895 error = ENXIO; 896 goto err_out; 897 } 898 899 switch (hw->mac.type) { 900 case ixgbe_mac_82598EB: 901 str = "82598EB"; 902 break; 903 case ixgbe_mac_82599EB: 904 str = "82599EB"; 905 break; 906 case ixgbe_mac_X540: 907 str = "X540"; 908 break; 909 case ixgbe_mac_X550: 910 str = "X550"; 911 break; 912 case ixgbe_mac_X550EM_x: 913 str = "X550EM X"; 914 break; 915 case ixgbe_mac_X550EM_a: 916 str = "X550EM A"; 917 break; 918 default: 919 str = "Unknown"; 920 break; 921 } 922 aprint_normal_dev(dev, "device %s\n", str); 923 924 if (hw->mbx.ops.init_params) 925 hw->mbx.ops.init_params(hw); 926 927 hw->allow_unsupported_sfp = allow_unsupported_sfp; 928 929 /* Pick up the 82599 settings */ 930 if (hw->mac.type != ixgbe_mac_82598EB) 931 hw->phy.smart_speed = ixgbe_smart_speed; 932 933 /* Set the right number of segments */ 934 KASSERT(IXGBE_82599_SCATTER_MAX >= IXGBE_SCATTER_DEFAULT); 935 adapter->num_segs = IXGBE_SCATTER_DEFAULT; 936 937 /* Ensure SW/FW semaphore is free */ 938 ixgbe_init_swfw_semaphore(hw); 939 940 hw->mac.ops.set_lan_id(hw); 941 ixgbe_init_device_features(adapter); 942 943 if (ixgbe_configure_interrupts(adapter)) { 944 error = ENXIO; 945 goto err_out; 946 } 947 948 /* Allocate multicast array memory. */ 949 adapter->mta = malloc(sizeof(*adapter->mta) * 950 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_WAITOK); 951 952 /* Enable WoL (if supported) */ 953 ixgbe_check_wol_support(adapter); 954 955 /* Register for VLAN events */ 956 ether_set_vlan_cb(&adapter->osdep.ec, ixgbe_vlan_cb); 957 958 /* Verify adapter fan is still functional (if applicable) */ 959 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 960 u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 961 ixgbe_check_fan_failure(adapter, esdp, FALSE); 962 } 963 964 /* Set an initial default flow control value */ 965 hw->fc.requested_mode = ixgbe_flow_control; 966 967 /* Sysctls for limiting the amount of work done in the taskqueues */ 968 ixgbe_set_sysctl_value(adapter, "rx_processing_limit", 969 "max number of rx packets to process", 970 &adapter->rx_process_limit, ixgbe_rx_process_limit); 971 972 ixgbe_set_sysctl_value(adapter, "tx_processing_limit", 973 "max number of tx packets to process", 974 &adapter->tx_process_limit, ixgbe_tx_process_limit); 975 976 /* Do descriptor calc and sanity checks */ 977 if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 || 978 ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) { 979 aprint_error_dev(dev, "TXD config issue, using default!\n"); 980 adapter->num_tx_desc = DEFAULT_TXD; 981 } else 982 adapter->num_tx_desc = ixgbe_txd; 983 984 if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 || 985 ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) { 986 aprint_error_dev(dev, "RXD config issue, using default!\n"); 987 adapter->num_rx_desc = DEFAULT_RXD; 988 } else 989 adapter->num_rx_desc = ixgbe_rxd; 990 991 /* Set default high limit of copying mbuf in rxeof */ 992 adapter->rx_copy_len = IXGBE_RX_COPY_LEN_MAX; 993 994 /* Allocate our TX/RX Queues */ 995 if (ixgbe_allocate_queues(adapter)) { 996 error = ENOMEM; 997 goto err_out; 998 } 999 1000 hw->phy.reset_if_overtemp = TRUE; 1001 error = ixgbe_reset_hw(hw); 1002 hw->phy.reset_if_overtemp = FALSE; 1003 if (error == IXGBE_ERR_SFP_NOT_PRESENT) 1004 error = IXGBE_SUCCESS; 1005 else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) { 1006 aprint_error_dev(dev, "Unsupported SFP+ module detected!\n"); 1007 unsupported_sfp = true; 1008 error = IXGBE_SUCCESS; 1009 } else if (error) { 1010 aprint_error_dev(dev, 1011 "Hardware initialization failed(error = %d)\n", error); 1012 error = EIO; 1013 goto err_late; 1014 } 1015 1016 /* Make sure we have a good EEPROM before we read from it */ 1017 if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) { 1018 aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n"); 1019 error = EIO; 1020 goto err_late; 1021 } 1022 1023 aprint_normal("%s:", device_xname(dev)); 1024 /* NVM Image Version */ 1025 high = low = 0; 1026 switch (hw->mac.type) { 1027 case ixgbe_mac_X540: 1028 case ixgbe_mac_X550EM_a: 1029 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 1030 if (nvmreg == 0xffff) 1031 break; 1032 high = (nvmreg >> 12) & 0x0f; 1033 low = (nvmreg >> 4) & 0xff; 1034 id = nvmreg & 0x0f; 1035 aprint_normal(" NVM Image Version %u.", high); 1036 if (hw->mac.type == ixgbe_mac_X540) 1037 str = "%x"; 1038 else 1039 str = "%02x"; 1040 aprint_normal(str, low); 1041 aprint_normal(" ID 0x%x,", id); 1042 break; 1043 case ixgbe_mac_X550EM_x: 1044 case ixgbe_mac_X550: 1045 hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg); 1046 if (nvmreg == 0xffff) 1047 break; 1048 high = (nvmreg >> 12) & 0x0f; 1049 low = nvmreg & 0xff; 1050 aprint_normal(" NVM Image Version %u.%02x,", high, low); 1051 break; 1052 default: 1053 break; 1054 } 1055 hw->eeprom.nvm_image_ver_high = high; 1056 hw->eeprom.nvm_image_ver_low = low; 1057 1058 /* PHY firmware revision */ 1059 switch (hw->mac.type) { 1060 case ixgbe_mac_X540: 1061 case ixgbe_mac_X550: 1062 hw->eeprom.ops.read(hw, IXGBE_PHYFW_REV, &nvmreg); 1063 if (nvmreg == 0xffff) 1064 break; 1065 high = (nvmreg >> 12) & 0x0f; 1066 low = (nvmreg >> 4) & 0xff; 1067 id = nvmreg & 0x000f; 1068 aprint_normal(" PHY FW Revision %u.", high); 1069 if (hw->mac.type == ixgbe_mac_X540) 1070 str = "%x"; 1071 else 1072 str = "%02x"; 1073 aprint_normal(str, low); 1074 aprint_normal(" ID 0x%x,", id); 1075 break; 1076 default: 1077 break; 1078 } 1079 1080 /* NVM Map version & OEM NVM Image version */ 1081 switch (hw->mac.type) { 1082 case ixgbe_mac_X550: 1083 case ixgbe_mac_X550EM_x: 1084 case ixgbe_mac_X550EM_a: 1085 hw->eeprom.ops.read(hw, IXGBE_NVM_MAP_VER, &nvmreg); 1086 if (nvmreg != 0xffff) { 1087 high = (nvmreg >> 12) & 0x0f; 1088 low = nvmreg & 0x00ff; 1089 aprint_normal(" NVM Map version %u.%02x,", high, low); 1090 } 1091 hw->eeprom.ops.read(hw, IXGBE_OEM_NVM_IMAGE_VER, &nvmreg); 1092 if (nvmreg != 0xffff) { 1093 high = (nvmreg >> 12) & 0x0f; 1094 low = nvmreg & 0x00ff; 1095 aprint_verbose(" OEM NVM Image version %u.%02x,", high, 1096 low); 1097 } 1098 break; 1099 default: 1100 break; 1101 } 1102 1103 /* Print the ETrackID */ 1104 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_H, &high); 1105 hw->eeprom.ops.read(hw, IXGBE_ETRACKID_L, &low); 1106 aprint_normal(" ETrackID %08x\n", ((uint32_t)high << 16) | low); 1107 1108 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 1109 error = ixgbe_allocate_msix(adapter, pa); 1110 if (error) { 1111 /* Free allocated queue structures first */ 1112 ixgbe_free_queues(adapter); 1113 1114 /* Fallback to legacy interrupt */ 1115 adapter->feat_en &= ~IXGBE_FEATURE_MSIX; 1116 if (adapter->feat_cap & IXGBE_FEATURE_MSI) 1117 adapter->feat_en |= IXGBE_FEATURE_MSI; 1118 adapter->num_queues = 1; 1119 1120 /* Allocate our TX/RX Queues again */ 1121 if (ixgbe_allocate_queues(adapter)) { 1122 error = ENOMEM; 1123 goto err_out; 1124 } 1125 } 1126 } 1127 /* Recovery mode */ 1128 switch (adapter->hw.mac.type) { 1129 case ixgbe_mac_X550: 1130 case ixgbe_mac_X550EM_x: 1131 case ixgbe_mac_X550EM_a: 1132 /* >= 2.00 */ 1133 if (hw->eeprom.nvm_image_ver_high >= 2) { 1134 adapter->feat_cap |= IXGBE_FEATURE_RECOVERY_MODE; 1135 adapter->feat_en |= IXGBE_FEATURE_RECOVERY_MODE; 1136 } 1137 break; 1138 default: 1139 break; 1140 } 1141 1142 if ((adapter->feat_en & IXGBE_FEATURE_MSIX) == 0) 1143 error = ixgbe_allocate_legacy(adapter, pa); 1144 if (error) 1145 goto err_late; 1146 1147 /* Tasklets for Link, SFP, Multispeed Fiber and Flow Director */ 1148 mutex_init(&(adapter)->admin_mtx, MUTEX_DEFAULT, IPL_NET); 1149 snprintf(wqname, sizeof(wqname), "%s-admin", device_xname(dev)); 1150 error = workqueue_create(&adapter->admin_wq, wqname, 1151 ixgbe_handle_admin, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 1152 IXGBE_TASKLET_WQ_FLAGS); 1153 if (error) { 1154 aprint_error_dev(dev, 1155 "could not create admin workqueue (%d)\n", error); 1156 goto err_out; 1157 } 1158 1159 error = ixgbe_start_hw(hw); 1160 switch (error) { 1161 case IXGBE_ERR_EEPROM_VERSION: 1162 aprint_error_dev(dev, "This device is a pre-production adapter/" 1163 "LOM. Please be aware there may be issues associated " 1164 "with your hardware.\nIf you are experiencing problems " 1165 "please contact your Intel or hardware representative " 1166 "who provided you with this hardware.\n"); 1167 break; 1168 default: 1169 break; 1170 } 1171 1172 /* Setup OS specific network interface */ 1173 if (ixgbe_setup_interface(dev, adapter) != 0) 1174 goto err_late; 1175 1176 /* 1177 * Print PHY ID only for copper PHY. On device which has SFP(+) cage 1178 * and a module is inserted, phy.id is not MII PHY id but SFF 8024 ID. 1179 */ 1180 if (hw->phy.media_type == ixgbe_media_type_copper) { 1181 uint16_t id1, id2; 1182 int oui, model, rev; 1183 char descr[MII_MAX_DESCR_LEN]; 1184 1185 id1 = hw->phy.id >> 16; 1186 id2 = hw->phy.id & 0xffff; 1187 oui = MII_OUI(id1, id2); 1188 model = MII_MODEL(id2); 1189 rev = MII_REV(id2); 1190 mii_get_descr(descr, sizeof(descr), oui, model); 1191 if (descr[0]) 1192 aprint_normal_dev(dev, 1193 "PHY: %s (OUI 0x%06x, model 0x%04x), rev. %d\n", 1194 descr, oui, model, rev); 1195 else 1196 aprint_normal_dev(dev, 1197 "PHY OUI 0x%06x, model 0x%04x, rev. %d\n", 1198 oui, model, rev); 1199 } 1200 1201 /* Enable EEE power saving */ 1202 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 1203 hw->mac.ops.setup_eee(hw, 1204 adapter->feat_en & IXGBE_FEATURE_EEE); 1205 1206 /* Enable power to the phy. */ 1207 if (!unsupported_sfp) { 1208 /* Enable the optics for 82599 SFP+ fiber */ 1209 ixgbe_enable_tx_laser(hw); 1210 1211 /* 1212 * XXX Currently, ixgbe_set_phy_power() supports only copper 1213 * PHY, so it's not required to test with !unsupported_sfp. 1214 */ 1215 ixgbe_set_phy_power(hw, TRUE); 1216 } 1217 1218 /* Initialize statistics */ 1219 ixgbe_update_stats_counters(adapter); 1220 1221 /* Check PCIE slot type/speed/width */ 1222 ixgbe_get_slot_info(adapter); 1223 1224 /* 1225 * Do time init and sysctl init here, but 1226 * only on the first port of a bypass adapter. 1227 */ 1228 ixgbe_bypass_init(adapter); 1229 1230 /* Set an initial dmac value */ 1231 adapter->dmac = 0; 1232 /* Set initial advertised speeds (if applicable) */ 1233 adapter->advertise = ixgbe_get_advertise(adapter); 1234 1235 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 1236 ixgbe_define_iov_schemas(dev, &error); 1237 1238 /* Add sysctls */ 1239 ixgbe_add_device_sysctls(adapter); 1240 ixgbe_add_hw_stats(adapter); 1241 1242 /* For Netmap */ 1243 adapter->init_locked = ixgbe_init_locked; 1244 adapter->stop_locked = ixgbe_stop_locked; 1245 1246 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 1247 ixgbe_netmap_attach(adapter); 1248 1249 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap); 1250 aprint_verbose_dev(dev, "feature cap %s\n", buf); 1251 snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en); 1252 aprint_verbose_dev(dev, "feature ena %s\n", buf); 1253 1254 if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume)) 1255 pmf_class_network_register(dev, adapter->ifp); 1256 else 1257 aprint_error_dev(dev, "couldn't establish power handler\n"); 1258 1259 /* Init recovery mode timer and state variable */ 1260 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) { 1261 adapter->recovery_mode = 0; 1262 1263 /* Set up the timer callout */ 1264 callout_init(&adapter->recovery_mode_timer, 1265 IXGBE_CALLOUT_FLAGS); 1266 snprintf(wqname, sizeof(wqname), "%s-recovery", 1267 device_xname(dev)); 1268 error = workqueue_create(&adapter->recovery_mode_timer_wq, 1269 wqname, ixgbe_handle_recovery_mode_timer, adapter, 1270 IXGBE_WORKQUEUE_PRI, IPL_NET, IXGBE_TASKLET_WQ_FLAGS); 1271 if (error) { 1272 aprint_error_dev(dev, "could not create " 1273 "recovery_mode_timer workqueue (%d)\n", error); 1274 goto err_out; 1275 } 1276 1277 /* Start the task */ 1278 callout_reset(&adapter->recovery_mode_timer, hz, 1279 ixgbe_recovery_mode_timer, adapter); 1280 } 1281 1282 INIT_DEBUGOUT("ixgbe_attach: end"); 1283 adapter->osdep.attached = true; 1284 1285 return; 1286 1287 err_late: 1288 ixgbe_free_queues(adapter); 1289 err_out: 1290 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 1291 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 1292 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 1293 ixgbe_free_deferred_handlers(adapter); 1294 ixgbe_free_pci_resources(adapter); 1295 if (adapter->mta != NULL) 1296 free(adapter->mta, M_DEVBUF); 1297 mutex_destroy(&(adapter)->admin_mtx); /* XXX appropriate order? */ 1298 IXGBE_CORE_LOCK_DESTROY(adapter); 1299 1300 return; 1301 } /* ixgbe_attach */ 1302 1303 /************************************************************************ 1304 * ixgbe_check_wol_support 1305 * 1306 * Checks whether the adapter's ports are capable of 1307 * Wake On LAN by reading the adapter's NVM. 1308 * 1309 * Sets each port's hw->wol_enabled value depending 1310 * on the value read here. 1311 ************************************************************************/ 1312 static void 1313 ixgbe_check_wol_support(struct adapter *adapter) 1314 { 1315 struct ixgbe_hw *hw = &adapter->hw; 1316 u16 dev_caps = 0; 1317 1318 /* Find out WoL support for port */ 1319 adapter->wol_support = hw->wol_enabled = 0; 1320 ixgbe_get_device_caps(hw, &dev_caps); 1321 if ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0_1) || 1322 ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0) && 1323 hw->bus.func == 0)) 1324 adapter->wol_support = hw->wol_enabled = 1; 1325 1326 /* Save initial wake up filter configuration */ 1327 adapter->wufc = IXGBE_READ_REG(hw, IXGBE_WUFC); 1328 1329 return; 1330 } /* ixgbe_check_wol_support */ 1331 1332 /************************************************************************ 1333 * ixgbe_setup_interface 1334 * 1335 * Setup networking device structure and register an interface. 1336 ************************************************************************/ 1337 static int 1338 ixgbe_setup_interface(device_t dev, struct adapter *adapter) 1339 { 1340 struct ethercom *ec = &adapter->osdep.ec; 1341 struct ifnet *ifp; 1342 1343 INIT_DEBUGOUT("ixgbe_setup_interface: begin"); 1344 1345 ifp = adapter->ifp = &ec->ec_if; 1346 strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ); 1347 ifp->if_baudrate = IF_Gbps(10); 1348 ifp->if_init = ixgbe_init; 1349 ifp->if_stop = ixgbe_ifstop; 1350 ifp->if_softc = adapter; 1351 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1352 #ifdef IXGBE_MPSAFE 1353 ifp->if_extflags = IFEF_MPSAFE; 1354 #endif 1355 ifp->if_ioctl = ixgbe_ioctl; 1356 #if __FreeBSD_version >= 1100045 1357 /* TSO parameters */ 1358 ifp->if_hw_tsomax = 65518; 1359 ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER; 1360 ifp->if_hw_tsomaxsegsize = 2048; 1361 #endif 1362 if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) { 1363 #if 0 1364 ixgbe_start_locked = ixgbe_legacy_start_locked; 1365 #endif 1366 } else { 1367 ifp->if_transmit = ixgbe_mq_start; 1368 #if 0 1369 ixgbe_start_locked = ixgbe_mq_start_locked; 1370 #endif 1371 } 1372 ifp->if_start = ixgbe_legacy_start; 1373 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2); 1374 IFQ_SET_READY(&ifp->if_snd); 1375 1376 if_initialize(ifp); 1377 adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if); 1378 ether_ifattach(ifp, adapter->hw.mac.addr); 1379 aprint_normal_dev(dev, "Ethernet address %s\n", 1380 ether_sprintf(adapter->hw.mac.addr)); 1381 /* 1382 * We use per TX queue softint, so if_deferred_start_init() isn't 1383 * used. 1384 */ 1385 ether_set_ifflags_cb(ec, ixgbe_ifflags_cb); 1386 1387 adapter->max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 1388 1389 /* 1390 * Tell the upper layer(s) we support long frames. 1391 */ 1392 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 1393 1394 /* Set capability flags */ 1395 ifp->if_capabilities |= IFCAP_RXCSUM 1396 | IFCAP_TXCSUM 1397 | IFCAP_TSOv4 1398 | IFCAP_TSOv6; 1399 ifp->if_capenable = 0; 1400 1401 ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING 1402 | ETHERCAP_VLAN_HWCSUM 1403 | ETHERCAP_JUMBO_MTU 1404 | ETHERCAP_VLAN_MTU; 1405 1406 /* Enable the above capabilities by default */ 1407 ec->ec_capenable = ec->ec_capabilities; 1408 1409 /* 1410 * Don't turn this on by default, if vlans are 1411 * created on another pseudo device (eg. lagg) 1412 * then vlan events are not passed thru, breaking 1413 * operation, but with HW FILTER off it works. If 1414 * using vlans directly on the ixgbe driver you can 1415 * enable this and get full hardware tag filtering. 1416 */ 1417 ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER; 1418 1419 /* 1420 * Specify the media types supported by this adapter and register 1421 * callbacks to update media and link information 1422 */ 1423 ec->ec_ifmedia = &adapter->media; 1424 ifmedia_init_with_lock(&adapter->media, IFM_IMASK, ixgbe_media_change, 1425 ixgbe_media_status, &adapter->core_mtx); 1426 1427 adapter->phy_layer = ixgbe_get_supported_physical_layer(&adapter->hw); 1428 ixgbe_add_media_types(adapter); 1429 1430 /* Set autoselect media by default */ 1431 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1432 1433 if_register(ifp); 1434 1435 return (0); 1436 } /* ixgbe_setup_interface */ 1437 1438 /************************************************************************ 1439 * ixgbe_add_media_types 1440 ************************************************************************/ 1441 static void 1442 ixgbe_add_media_types(struct adapter *adapter) 1443 { 1444 struct ixgbe_hw *hw = &adapter->hw; 1445 u64 layer; 1446 1447 layer = adapter->phy_layer; 1448 1449 #define ADD(mm, dd) \ 1450 ifmedia_add(&adapter->media, IFM_ETHER | (mm), (dd), NULL); 1451 1452 ADD(IFM_NONE, 0); 1453 1454 /* Media types with matching NetBSD media defines */ 1455 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) { 1456 ADD(IFM_10G_T | IFM_FDX, 0); 1457 } 1458 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) { 1459 ADD(IFM_1000_T | IFM_FDX, 0); 1460 } 1461 if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) { 1462 ADD(IFM_100_TX | IFM_FDX, 0); 1463 } 1464 if (layer & IXGBE_PHYSICAL_LAYER_10BASE_T) { 1465 ADD(IFM_10_T | IFM_FDX, 0); 1466 } 1467 1468 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 1469 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) { 1470 ADD(IFM_10G_TWINAX | IFM_FDX, 0); 1471 } 1472 1473 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) { 1474 ADD(IFM_10G_LR | IFM_FDX, 0); 1475 if (hw->phy.multispeed_fiber) { 1476 ADD(IFM_1000_LX | IFM_FDX, 0); 1477 } 1478 } 1479 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) { 1480 ADD(IFM_10G_SR | IFM_FDX, 0); 1481 if (hw->phy.multispeed_fiber) { 1482 ADD(IFM_1000_SX | IFM_FDX, 0); 1483 } 1484 } else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) { 1485 ADD(IFM_1000_SX | IFM_FDX, 0); 1486 } 1487 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) { 1488 ADD(IFM_10G_CX4 | IFM_FDX, 0); 1489 } 1490 1491 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) { 1492 ADD(IFM_10G_KR | IFM_FDX, 0); 1493 } 1494 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) { 1495 ADD(IFM_10G_KX4 | IFM_FDX, 0); 1496 } 1497 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) { 1498 ADD(IFM_1000_KX | IFM_FDX, 0); 1499 } 1500 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX) { 1501 ADD(IFM_2500_KX | IFM_FDX, 0); 1502 } 1503 if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_T) { 1504 ADD(IFM_2500_T | IFM_FDX, 0); 1505 } 1506 if (layer & IXGBE_PHYSICAL_LAYER_5GBASE_T) { 1507 ADD(IFM_5000_T | IFM_FDX, 0); 1508 } 1509 if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX) 1510 ADD(IFM_1000_BX10 | IFM_FDX, 0); 1511 /* XXX no ifmedia_set? */ 1512 1513 ADD(IFM_AUTO, 0); 1514 1515 #undef ADD 1516 } /* ixgbe_add_media_types */ 1517 1518 /************************************************************************ 1519 * ixgbe_is_sfp 1520 ************************************************************************/ 1521 static inline bool 1522 ixgbe_is_sfp(struct ixgbe_hw *hw) 1523 { 1524 switch (hw->mac.type) { 1525 case ixgbe_mac_82598EB: 1526 if (hw->phy.type == ixgbe_phy_nl) 1527 return (TRUE); 1528 return (FALSE); 1529 case ixgbe_mac_82599EB: 1530 case ixgbe_mac_X550EM_x: 1531 case ixgbe_mac_X550EM_a: 1532 switch (hw->mac.ops.get_media_type(hw)) { 1533 case ixgbe_media_type_fiber: 1534 case ixgbe_media_type_fiber_qsfp: 1535 return (TRUE); 1536 default: 1537 return (FALSE); 1538 } 1539 default: 1540 return (FALSE); 1541 } 1542 } /* ixgbe_is_sfp */ 1543 1544 static void 1545 ixgbe_schedule_admin_tasklet(struct adapter *adapter) 1546 { 1547 1548 KASSERT(mutex_owned(&adapter->admin_mtx)); 1549 1550 if (__predict_true(adapter->osdep.detaching == false)) { 1551 if (adapter->admin_pending == 0) 1552 workqueue_enqueue(adapter->admin_wq, 1553 &adapter->admin_wc, NULL); 1554 adapter->admin_pending = 1; 1555 } 1556 } 1557 1558 /************************************************************************ 1559 * ixgbe_config_link 1560 ************************************************************************/ 1561 static void 1562 ixgbe_config_link(struct adapter *adapter) 1563 { 1564 struct ixgbe_hw *hw = &adapter->hw; 1565 u32 autoneg, err = 0; 1566 u32 task_requests = 0; 1567 bool sfp, negotiate = false; 1568 1569 sfp = ixgbe_is_sfp(hw); 1570 1571 if (sfp) { 1572 if (hw->phy.multispeed_fiber) { 1573 ixgbe_enable_tx_laser(hw); 1574 task_requests |= IXGBE_REQUEST_TASK_MSF_WOI; 1575 } 1576 task_requests |= IXGBE_REQUEST_TASK_MOD_WOI; 1577 1578 mutex_enter(&adapter->admin_mtx); 1579 adapter->task_requests |= task_requests; 1580 ixgbe_schedule_admin_tasklet(adapter); 1581 mutex_exit(&adapter->admin_mtx); 1582 } else { 1583 struct ifmedia *ifm = &adapter->media; 1584 1585 if (hw->mac.ops.check_link) 1586 err = ixgbe_check_link(hw, &adapter->link_speed, 1587 &adapter->link_up, FALSE); 1588 if (err) 1589 return; 1590 1591 /* 1592 * Check if it's the first call. If it's the first call, 1593 * get value for auto negotiation. 1594 */ 1595 autoneg = hw->phy.autoneg_advertised; 1596 if ((IFM_SUBTYPE(ifm->ifm_cur->ifm_media) != IFM_NONE) 1597 && ((!autoneg) && (hw->mac.ops.get_link_capabilities))) 1598 err = hw->mac.ops.get_link_capabilities(hw, &autoneg, 1599 &negotiate); 1600 if (err) 1601 return; 1602 if (hw->mac.ops.setup_link) 1603 err = hw->mac.ops.setup_link(hw, autoneg, 1604 adapter->link_up); 1605 } 1606 1607 } /* ixgbe_config_link */ 1608 1609 /************************************************************************ 1610 * ixgbe_update_stats_counters - Update board statistics counters. 1611 ************************************************************************/ 1612 static void 1613 ixgbe_update_stats_counters(struct adapter *adapter) 1614 { 1615 struct ifnet *ifp = adapter->ifp; 1616 struct ixgbe_hw *hw = &adapter->hw; 1617 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1618 u32 missed_rx = 0, bprc, lxon, lxoff, total; 1619 u64 total_missed_rx = 0; 1620 uint64_t crcerrs, rlec; 1621 unsigned int queue_counters; 1622 int i; 1623 1624 crcerrs = IXGBE_READ_REG(hw, IXGBE_CRCERRS); 1625 stats->crcerrs.ev_count += crcerrs; 1626 stats->illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 1627 stats->errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 1628 stats->mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 1629 if (hw->mac.type >= ixgbe_mac_X550) 1630 stats->mbsdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MBSDC); 1631 1632 /* 16 registers exist */ 1633 queue_counters = uimin(__arraycount(stats->qprc), adapter->num_queues); 1634 for (i = 0; i < queue_counters; i++) { 1635 stats->qprc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 1636 stats->qptc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 1637 if (hw->mac.type >= ixgbe_mac_82599EB) { 1638 stats->qprdc[i].ev_count 1639 += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 1640 } 1641 } 1642 1643 /* 8 registers exist */ 1644 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 1645 uint32_t mp; 1646 1647 /* MPC */ 1648 mp = IXGBE_READ_REG(hw, IXGBE_MPC(i)); 1649 /* global total per queue */ 1650 stats->mpc[i].ev_count += mp; 1651 /* running comprehensive total for stats display */ 1652 total_missed_rx += mp; 1653 1654 if (hw->mac.type == ixgbe_mac_82598EB) 1655 stats->rnbc[i].ev_count 1656 += IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 1657 1658 stats->pxontxc[i].ev_count 1659 += IXGBE_READ_REG(hw, IXGBE_PXONTXC(i)); 1660 stats->pxofftxc[i].ev_count 1661 += IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i)); 1662 if (hw->mac.type >= ixgbe_mac_82599EB) { 1663 stats->pxonrxc[i].ev_count 1664 += IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i)); 1665 stats->pxoffrxc[i].ev_count 1666 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(i)); 1667 stats->pxon2offc[i].ev_count 1668 += IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i)); 1669 } else { 1670 stats->pxonrxc[i].ev_count 1671 += IXGBE_READ_REG(hw, IXGBE_PXONRXC(i)); 1672 stats->pxoffrxc[i].ev_count 1673 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i)); 1674 } 1675 } 1676 stats->mpctotal.ev_count += total_missed_rx; 1677 1678 /* Document says M[LR]FC are valid when link is up and 10Gbps */ 1679 if ((adapter->link_active == LINK_STATE_UP) 1680 && (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL)) { 1681 stats->mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 1682 stats->mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 1683 } 1684 rlec = IXGBE_READ_REG(hw, IXGBE_RLEC); 1685 stats->rlec.ev_count += rlec; 1686 1687 /* Hardware workaround, gprc counts missed packets */ 1688 stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 1689 1690 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 1691 stats->lxontxc.ev_count += lxon; 1692 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 1693 stats->lxofftxc.ev_count += lxoff; 1694 total = lxon + lxoff; 1695 1696 if (hw->mac.type != ixgbe_mac_82598EB) { 1697 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 1698 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 1699 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 1700 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) 1701 - total * ETHER_MIN_LEN; 1702 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 1703 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 1704 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 1705 stats->lxoffrxc.ev_count 1706 += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 1707 } else { 1708 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 1709 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 1710 /* 82598 only has a counter in the high register */ 1711 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 1712 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) 1713 - total * ETHER_MIN_LEN; 1714 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 1715 } 1716 1717 /* 1718 * Workaround: mprc hardware is incorrectly counting 1719 * broadcasts, so for now we subtract those. 1720 */ 1721 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 1722 stats->bprc.ev_count += bprc; 1723 stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) 1724 - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 1725 1726 stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 1727 stats->prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 1728 stats->prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 1729 stats->prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 1730 stats->prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 1731 stats->prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 1732 1733 stats->gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 1734 stats->mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 1735 stats->ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 1736 1737 stats->ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 1738 stats->rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 1739 stats->roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 1740 stats->rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 1741 stats->mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 1742 stats->mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 1743 stats->mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 1744 stats->tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 1745 stats->tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 1746 stats->ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 1747 stats->ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 1748 stats->ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 1749 stats->ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 1750 stats->ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 1751 stats->bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 1752 stats->xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 1753 stats->fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 1754 stats->fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 1755 /* Only read FCOE on 82599 */ 1756 if (hw->mac.type != ixgbe_mac_82598EB) { 1757 stats->fcoerpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 1758 stats->fcoeprc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 1759 stats->fcoeptc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 1760 stats->fcoedwrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 1761 stats->fcoedwtc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 1762 } 1763 1764 /* 1765 * Fill out the OS statistics structure. Only RX errors are required 1766 * here because all TX counters are incremented in the TX path and 1767 * normal RX counters are prepared in ether_input(). 1768 */ 1769 net_stat_ref_t nsr = IF_STAT_GETREF(ifp); 1770 if_statadd_ref(nsr, if_iqdrops, total_missed_rx); 1771 if_statadd_ref(nsr, if_ierrors, crcerrs + rlec); 1772 IF_STAT_PUTREF(ifp); 1773 } /* ixgbe_update_stats_counters */ 1774 1775 /************************************************************************ 1776 * ixgbe_add_hw_stats 1777 * 1778 * Add sysctl variables, one per statistic, to the system. 1779 ************************************************************************/ 1780 static void 1781 ixgbe_add_hw_stats(struct adapter *adapter) 1782 { 1783 device_t dev = adapter->dev; 1784 const struct sysctlnode *rnode, *cnode; 1785 struct sysctllog **log = &adapter->sysctllog; 1786 struct tx_ring *txr = adapter->tx_rings; 1787 struct rx_ring *rxr = adapter->rx_rings; 1788 struct ixgbe_hw *hw = &adapter->hw; 1789 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1790 const char *xname = device_xname(dev); 1791 int i; 1792 1793 /* Driver Statistics */ 1794 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 1795 NULL, xname, "Driver tx dma soft fail EFBIG"); 1796 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 1797 NULL, xname, "m_defrag() failed"); 1798 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 1799 NULL, xname, "Driver tx dma hard fail EFBIG"); 1800 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 1801 NULL, xname, "Driver tx dma hard fail EINVAL"); 1802 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 1803 NULL, xname, "Driver tx dma hard fail other"); 1804 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 1805 NULL, xname, "Driver tx dma soft fail EAGAIN"); 1806 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 1807 NULL, xname, "Driver tx dma soft fail ENOMEM"); 1808 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 1809 NULL, xname, "Watchdog timeouts"); 1810 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 1811 NULL, xname, "TSO errors"); 1812 evcnt_attach_dynamic(&adapter->admin_irqev, EVCNT_TYPE_INTR, 1813 NULL, xname, "Admin MSI-X IRQ Handled"); 1814 evcnt_attach_dynamic(&adapter->link_workev, EVCNT_TYPE_INTR, 1815 NULL, xname, "Link event"); 1816 evcnt_attach_dynamic(&adapter->mod_workev, EVCNT_TYPE_INTR, 1817 NULL, xname, "SFP+ module event"); 1818 evcnt_attach_dynamic(&adapter->msf_workev, EVCNT_TYPE_INTR, 1819 NULL, xname, "Multispeed event"); 1820 evcnt_attach_dynamic(&adapter->phy_workev, EVCNT_TYPE_INTR, 1821 NULL, xname, "External PHY event"); 1822 1823 /* Max number of traffic class is 8 */ 1824 KASSERT(IXGBE_DCB_MAX_TRAFFIC_CLASS == 8); 1825 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 1826 snprintf(adapter->tcs[i].evnamebuf, 1827 sizeof(adapter->tcs[i].evnamebuf), "%s tc%d", 1828 xname, i); 1829 if (i < __arraycount(stats->mpc)) { 1830 evcnt_attach_dynamic(&stats->mpc[i], 1831 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1832 "RX Missed Packet Count"); 1833 if (hw->mac.type == ixgbe_mac_82598EB) 1834 evcnt_attach_dynamic(&stats->rnbc[i], 1835 EVCNT_TYPE_MISC, NULL, 1836 adapter->tcs[i].evnamebuf, 1837 "Receive No Buffers"); 1838 } 1839 if (i < __arraycount(stats->pxontxc)) { 1840 evcnt_attach_dynamic(&stats->pxontxc[i], 1841 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1842 "pxontxc"); 1843 evcnt_attach_dynamic(&stats->pxonrxc[i], 1844 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1845 "pxonrxc"); 1846 evcnt_attach_dynamic(&stats->pxofftxc[i], 1847 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1848 "pxofftxc"); 1849 evcnt_attach_dynamic(&stats->pxoffrxc[i], 1850 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1851 "pxoffrxc"); 1852 if (hw->mac.type >= ixgbe_mac_82599EB) 1853 evcnt_attach_dynamic(&stats->pxon2offc[i], 1854 EVCNT_TYPE_MISC, NULL, 1855 adapter->tcs[i].evnamebuf, 1856 "pxon2offc"); 1857 } 1858 } 1859 1860 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 1861 #ifdef LRO 1862 struct lro_ctrl *lro = &rxr->lro; 1863 #endif /* LRO */ 1864 1865 snprintf(adapter->queues[i].evnamebuf, 1866 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 1867 xname, i); 1868 snprintf(adapter->queues[i].namebuf, 1869 sizeof(adapter->queues[i].namebuf), "q%d", i); 1870 1871 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 1872 aprint_error_dev(dev, "could not create sysctl root\n"); 1873 break; 1874 } 1875 1876 if (sysctl_createv(log, 0, &rnode, &rnode, 1877 0, CTLTYPE_NODE, 1878 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 1879 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 1880 break; 1881 1882 if (sysctl_createv(log, 0, &rnode, &cnode, 1883 CTLFLAG_READWRITE, CTLTYPE_INT, 1884 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 1885 ixgbe_sysctl_interrupt_rate_handler, 0, 1886 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 1887 break; 1888 1889 if (sysctl_createv(log, 0, &rnode, &cnode, 1890 CTLFLAG_READONLY, CTLTYPE_INT, 1891 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 1892 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 1893 0, CTL_CREATE, CTL_EOL) != 0) 1894 break; 1895 1896 if (sysctl_createv(log, 0, &rnode, &cnode, 1897 CTLFLAG_READONLY, CTLTYPE_INT, 1898 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 1899 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 1900 0, CTL_CREATE, CTL_EOL) != 0) 1901 break; 1902 1903 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 1904 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 1905 evcnt_attach_dynamic(&adapter->queues[i].handleq, 1906 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1907 "Handled queue in softint"); 1908 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 1909 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 1910 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 1911 NULL, adapter->queues[i].evnamebuf, "TSO"); 1912 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 1913 NULL, adapter->queues[i].evnamebuf, 1914 "TX Queue No Descriptor Available"); 1915 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 1916 NULL, adapter->queues[i].evnamebuf, 1917 "Queue Packets Transmitted"); 1918 #ifndef IXGBE_LEGACY_TX 1919 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 1920 NULL, adapter->queues[i].evnamebuf, 1921 "Packets dropped in pcq"); 1922 #endif 1923 1924 if (sysctl_createv(log, 0, &rnode, &cnode, 1925 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxck", 1926 SYSCTL_DESCR("Receive Descriptor next to check"), 1927 ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 1928 CTL_CREATE, CTL_EOL) != 0) 1929 break; 1930 1931 if (sysctl_createv(log, 0, &rnode, &cnode, 1932 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxrf", 1933 SYSCTL_DESCR("Receive Descriptor next to refresh"), 1934 ixgbe_sysctl_next_to_refresh_handler, 0, (void *)rxr, 0, 1935 CTL_CREATE, CTL_EOL) != 0) 1936 break; 1937 1938 if (sysctl_createv(log, 0, &rnode, &cnode, 1939 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_head", 1940 SYSCTL_DESCR("Receive Descriptor Head"), 1941 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 1942 CTL_CREATE, CTL_EOL) != 0) 1943 break; 1944 1945 if (sysctl_createv(log, 0, &rnode, &cnode, 1946 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_tail", 1947 SYSCTL_DESCR("Receive Descriptor Tail"), 1948 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 1949 CTL_CREATE, CTL_EOL) != 0) 1950 break; 1951 1952 if (i < __arraycount(stats->qprc)) { 1953 evcnt_attach_dynamic(&stats->qprc[i], EVCNT_TYPE_MISC, 1954 NULL, adapter->queues[i].evnamebuf, "qprc"); 1955 evcnt_attach_dynamic(&stats->qptc[i], EVCNT_TYPE_MISC, 1956 NULL, adapter->queues[i].evnamebuf, "qptc"); 1957 evcnt_attach_dynamic(&stats->qbrc[i], EVCNT_TYPE_MISC, 1958 NULL, adapter->queues[i].evnamebuf, "qbrc"); 1959 evcnt_attach_dynamic(&stats->qbtc[i], EVCNT_TYPE_MISC, 1960 NULL, adapter->queues[i].evnamebuf, "qbtc"); 1961 if (hw->mac.type >= ixgbe_mac_82599EB) 1962 evcnt_attach_dynamic(&stats->qprdc[i], 1963 EVCNT_TYPE_MISC, NULL, 1964 adapter->queues[i].evnamebuf, "qprdc"); 1965 } 1966 1967 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 1968 NULL, adapter->queues[i].evnamebuf, 1969 "Queue Packets Received"); 1970 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 1971 NULL, adapter->queues[i].evnamebuf, 1972 "Queue Bytes Received"); 1973 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 1974 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 1975 evcnt_attach_dynamic(&rxr->no_mbuf, EVCNT_TYPE_MISC, 1976 NULL, adapter->queues[i].evnamebuf, "Rx no mbuf"); 1977 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 1978 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 1979 #ifdef LRO 1980 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 1981 CTLFLAG_RD, &lro->lro_queued, 0, 1982 "LRO Queued"); 1983 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 1984 CTLFLAG_RD, &lro->lro_flushed, 0, 1985 "LRO Flushed"); 1986 #endif /* LRO */ 1987 } 1988 1989 /* MAC stats get their own sub node */ 1990 1991 snprintf(stats->namebuf, 1992 sizeof(stats->namebuf), "%s MAC Statistics", xname); 1993 1994 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 1995 stats->namebuf, "rx csum offload - IP"); 1996 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 1997 stats->namebuf, "rx csum offload - L4"); 1998 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 1999 stats->namebuf, "rx csum offload - IP bad"); 2000 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 2001 stats->namebuf, "rx csum offload - L4 bad"); 2002 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 2003 stats->namebuf, "Interrupt conditions zero"); 2004 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 2005 stats->namebuf, "Legacy interrupts"); 2006 2007 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 2008 stats->namebuf, "CRC Errors"); 2009 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 2010 stats->namebuf, "Illegal Byte Errors"); 2011 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 2012 stats->namebuf, "Byte Errors"); 2013 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 2014 stats->namebuf, "MAC Short Packets Discarded"); 2015 if (hw->mac.type >= ixgbe_mac_X550) 2016 evcnt_attach_dynamic(&stats->mbsdc, EVCNT_TYPE_MISC, NULL, 2017 stats->namebuf, "Bad SFD"); 2018 evcnt_attach_dynamic(&stats->mpctotal, EVCNT_TYPE_MISC, NULL, 2019 stats->namebuf, "Total Packets Missed"); 2020 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 2021 stats->namebuf, "MAC Local Faults"); 2022 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 2023 stats->namebuf, "MAC Remote Faults"); 2024 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 2025 stats->namebuf, "Receive Length Errors"); 2026 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 2027 stats->namebuf, "Link XON Transmitted"); 2028 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 2029 stats->namebuf, "Link XON Received"); 2030 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 2031 stats->namebuf, "Link XOFF Transmitted"); 2032 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 2033 stats->namebuf, "Link XOFF Received"); 2034 2035 /* Packet Reception Stats */ 2036 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 2037 stats->namebuf, "Total Octets Received"); 2038 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 2039 stats->namebuf, "Good Octets Received"); 2040 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 2041 stats->namebuf, "Total Packets Received"); 2042 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 2043 stats->namebuf, "Good Packets Received"); 2044 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 2045 stats->namebuf, "Multicast Packets Received"); 2046 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 2047 stats->namebuf, "Broadcast Packets Received"); 2048 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 2049 stats->namebuf, "64 byte frames received "); 2050 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 2051 stats->namebuf, "65-127 byte frames received"); 2052 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 2053 stats->namebuf, "128-255 byte frames received"); 2054 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 2055 stats->namebuf, "256-511 byte frames received"); 2056 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 2057 stats->namebuf, "512-1023 byte frames received"); 2058 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 2059 stats->namebuf, "1023-1522 byte frames received"); 2060 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 2061 stats->namebuf, "Receive Undersized"); 2062 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 2063 stats->namebuf, "Fragmented Packets Received "); 2064 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 2065 stats->namebuf, "Oversized Packets Received"); 2066 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 2067 stats->namebuf, "Received Jabber"); 2068 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 2069 stats->namebuf, "Management Packets Received"); 2070 evcnt_attach_dynamic(&stats->mngpdc, EVCNT_TYPE_MISC, NULL, 2071 stats->namebuf, "Management Packets Dropped"); 2072 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 2073 stats->namebuf, "Checksum Errors"); 2074 2075 /* Packet Transmission Stats */ 2076 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 2077 stats->namebuf, "Good Octets Transmitted"); 2078 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 2079 stats->namebuf, "Total Packets Transmitted"); 2080 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 2081 stats->namebuf, "Good Packets Transmitted"); 2082 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 2083 stats->namebuf, "Broadcast Packets Transmitted"); 2084 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 2085 stats->namebuf, "Multicast Packets Transmitted"); 2086 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 2087 stats->namebuf, "Management Packets Transmitted"); 2088 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 2089 stats->namebuf, "64 byte frames transmitted "); 2090 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 2091 stats->namebuf, "65-127 byte frames transmitted"); 2092 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 2093 stats->namebuf, "128-255 byte frames transmitted"); 2094 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 2095 stats->namebuf, "256-511 byte frames transmitted"); 2096 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 2097 stats->namebuf, "512-1023 byte frames transmitted"); 2098 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 2099 stats->namebuf, "1024-1522 byte frames transmitted"); 2100 } /* ixgbe_add_hw_stats */ 2101 2102 static void 2103 ixgbe_clear_evcnt(struct adapter *adapter) 2104 { 2105 struct tx_ring *txr = adapter->tx_rings; 2106 struct rx_ring *rxr = adapter->rx_rings; 2107 struct ixgbe_hw *hw = &adapter->hw; 2108 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 2109 int i; 2110 2111 adapter->efbig_tx_dma_setup.ev_count = 0; 2112 adapter->mbuf_defrag_failed.ev_count = 0; 2113 adapter->efbig2_tx_dma_setup.ev_count = 0; 2114 adapter->einval_tx_dma_setup.ev_count = 0; 2115 adapter->other_tx_dma_setup.ev_count = 0; 2116 adapter->eagain_tx_dma_setup.ev_count = 0; 2117 adapter->enomem_tx_dma_setup.ev_count = 0; 2118 adapter->tso_err.ev_count = 0; 2119 adapter->watchdog_events.ev_count = 0; 2120 adapter->admin_irqev.ev_count = 0; 2121 adapter->link_workev.ev_count = 0; 2122 adapter->mod_workev.ev_count = 0; 2123 adapter->msf_workev.ev_count = 0; 2124 adapter->phy_workev.ev_count = 0; 2125 2126 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 2127 if (i < __arraycount(stats->mpc)) { 2128 stats->mpc[i].ev_count = 0; 2129 if (hw->mac.type == ixgbe_mac_82598EB) 2130 stats->rnbc[i].ev_count = 0; 2131 } 2132 if (i < __arraycount(stats->pxontxc)) { 2133 stats->pxontxc[i].ev_count = 0; 2134 stats->pxonrxc[i].ev_count = 0; 2135 stats->pxofftxc[i].ev_count = 0; 2136 stats->pxoffrxc[i].ev_count = 0; 2137 if (hw->mac.type >= ixgbe_mac_82599EB) 2138 stats->pxon2offc[i].ev_count = 0; 2139 } 2140 } 2141 2142 txr = adapter->tx_rings; 2143 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2144 adapter->queues[i].irqs.ev_count = 0; 2145 adapter->queues[i].handleq.ev_count = 0; 2146 adapter->queues[i].req.ev_count = 0; 2147 txr->no_desc_avail.ev_count = 0; 2148 txr->total_packets.ev_count = 0; 2149 txr->tso_tx.ev_count = 0; 2150 #ifndef IXGBE_LEGACY_TX 2151 txr->pcq_drops.ev_count = 0; 2152 #endif 2153 txr->q_efbig_tx_dma_setup = 0; 2154 txr->q_mbuf_defrag_failed = 0; 2155 txr->q_efbig2_tx_dma_setup = 0; 2156 txr->q_einval_tx_dma_setup = 0; 2157 txr->q_other_tx_dma_setup = 0; 2158 txr->q_eagain_tx_dma_setup = 0; 2159 txr->q_enomem_tx_dma_setup = 0; 2160 txr->q_tso_err = 0; 2161 2162 if (i < __arraycount(stats->qprc)) { 2163 stats->qprc[i].ev_count = 0; 2164 stats->qptc[i].ev_count = 0; 2165 stats->qbrc[i].ev_count = 0; 2166 stats->qbtc[i].ev_count = 0; 2167 if (hw->mac.type >= ixgbe_mac_82599EB) 2168 stats->qprdc[i].ev_count = 0; 2169 } 2170 2171 rxr->rx_packets.ev_count = 0; 2172 rxr->rx_bytes.ev_count = 0; 2173 rxr->rx_copies.ev_count = 0; 2174 rxr->no_mbuf.ev_count = 0; 2175 rxr->rx_discarded.ev_count = 0; 2176 } 2177 stats->ipcs.ev_count = 0; 2178 stats->l4cs.ev_count = 0; 2179 stats->ipcs_bad.ev_count = 0; 2180 stats->l4cs_bad.ev_count = 0; 2181 stats->intzero.ev_count = 0; 2182 stats->legint.ev_count = 0; 2183 stats->crcerrs.ev_count = 0; 2184 stats->illerrc.ev_count = 0; 2185 stats->errbc.ev_count = 0; 2186 stats->mspdc.ev_count = 0; 2187 if (hw->mac.type >= ixgbe_mac_X550) 2188 stats->mbsdc.ev_count = 0; 2189 stats->mpctotal.ev_count = 0; 2190 stats->mlfc.ev_count = 0; 2191 stats->mrfc.ev_count = 0; 2192 stats->rlec.ev_count = 0; 2193 stats->lxontxc.ev_count = 0; 2194 stats->lxonrxc.ev_count = 0; 2195 stats->lxofftxc.ev_count = 0; 2196 stats->lxoffrxc.ev_count = 0; 2197 2198 /* Packet Reception Stats */ 2199 stats->tor.ev_count = 0; 2200 stats->gorc.ev_count = 0; 2201 stats->tpr.ev_count = 0; 2202 stats->gprc.ev_count = 0; 2203 stats->mprc.ev_count = 0; 2204 stats->bprc.ev_count = 0; 2205 stats->prc64.ev_count = 0; 2206 stats->prc127.ev_count = 0; 2207 stats->prc255.ev_count = 0; 2208 stats->prc511.ev_count = 0; 2209 stats->prc1023.ev_count = 0; 2210 stats->prc1522.ev_count = 0; 2211 stats->ruc.ev_count = 0; 2212 stats->rfc.ev_count = 0; 2213 stats->roc.ev_count = 0; 2214 stats->rjc.ev_count = 0; 2215 stats->mngprc.ev_count = 0; 2216 stats->mngpdc.ev_count = 0; 2217 stats->xec.ev_count = 0; 2218 2219 /* Packet Transmission Stats */ 2220 stats->gotc.ev_count = 0; 2221 stats->tpt.ev_count = 0; 2222 stats->gptc.ev_count = 0; 2223 stats->bptc.ev_count = 0; 2224 stats->mptc.ev_count = 0; 2225 stats->mngptc.ev_count = 0; 2226 stats->ptc64.ev_count = 0; 2227 stats->ptc127.ev_count = 0; 2228 stats->ptc255.ev_count = 0; 2229 stats->ptc511.ev_count = 0; 2230 stats->ptc1023.ev_count = 0; 2231 stats->ptc1522.ev_count = 0; 2232 } 2233 2234 /************************************************************************ 2235 * ixgbe_sysctl_tdh_handler - Transmit Descriptor Head handler function 2236 * 2237 * Retrieves the TDH value from the hardware 2238 ************************************************************************/ 2239 static int 2240 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 2241 { 2242 struct sysctlnode node = *rnode; 2243 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2244 struct adapter *adapter; 2245 uint32_t val; 2246 2247 if (!txr) 2248 return (0); 2249 2250 adapter = txr->adapter; 2251 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2252 return (EPERM); 2253 2254 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDH(txr->me)); 2255 node.sysctl_data = &val; 2256 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2257 } /* ixgbe_sysctl_tdh_handler */ 2258 2259 /************************************************************************ 2260 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 2261 * 2262 * Retrieves the TDT value from the hardware 2263 ************************************************************************/ 2264 static int 2265 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 2266 { 2267 struct sysctlnode node = *rnode; 2268 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2269 struct adapter *adapter; 2270 uint32_t val; 2271 2272 if (!txr) 2273 return (0); 2274 2275 adapter = txr->adapter; 2276 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2277 return (EPERM); 2278 2279 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDT(txr->me)); 2280 node.sysctl_data = &val; 2281 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2282 } /* ixgbe_sysctl_tdt_handler */ 2283 2284 /************************************************************************ 2285 * ixgbe_sysctl_next_to_check_handler - Receive Descriptor next to check 2286 * handler function 2287 * 2288 * Retrieves the next_to_check value 2289 ************************************************************************/ 2290 static int 2291 ixgbe_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 2292 { 2293 struct sysctlnode node = *rnode; 2294 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2295 struct adapter *adapter; 2296 uint32_t val; 2297 2298 if (!rxr) 2299 return (0); 2300 2301 adapter = rxr->adapter; 2302 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2303 return (EPERM); 2304 2305 val = rxr->next_to_check; 2306 node.sysctl_data = &val; 2307 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2308 } /* ixgbe_sysctl_next_to_check_handler */ 2309 2310 /************************************************************************ 2311 * ixgbe_sysctl_next_to_refresh_handler - Receive Descriptor next to check 2312 * handler function 2313 * 2314 * Retrieves the next_to_refresh value 2315 ************************************************************************/ 2316 static int 2317 ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_ARGS) 2318 { 2319 struct sysctlnode node = *rnode; 2320 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2321 struct adapter *adapter; 2322 uint32_t val; 2323 2324 if (!rxr) 2325 return (0); 2326 2327 adapter = rxr->adapter; 2328 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2329 return (EPERM); 2330 2331 val = rxr->next_to_refresh; 2332 node.sysctl_data = &val; 2333 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2334 } /* ixgbe_sysctl_next_to_refresh_handler */ 2335 2336 /************************************************************************ 2337 * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function 2338 * 2339 * Retrieves the RDH value from the hardware 2340 ************************************************************************/ 2341 static int 2342 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 2343 { 2344 struct sysctlnode node = *rnode; 2345 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2346 struct adapter *adapter; 2347 uint32_t val; 2348 2349 if (!rxr) 2350 return (0); 2351 2352 adapter = rxr->adapter; 2353 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2354 return (EPERM); 2355 2356 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDH(rxr->me)); 2357 node.sysctl_data = &val; 2358 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2359 } /* ixgbe_sysctl_rdh_handler */ 2360 2361 /************************************************************************ 2362 * ixgbe_sysctl_rdt_handler - Receive Descriptor Tail handler function 2363 * 2364 * Retrieves the RDT value from the hardware 2365 ************************************************************************/ 2366 static int 2367 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 2368 { 2369 struct sysctlnode node = *rnode; 2370 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2371 struct adapter *adapter; 2372 uint32_t val; 2373 2374 if (!rxr) 2375 return (0); 2376 2377 adapter = rxr->adapter; 2378 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2379 return (EPERM); 2380 2381 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDT(rxr->me)); 2382 node.sysctl_data = &val; 2383 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2384 } /* ixgbe_sysctl_rdt_handler */ 2385 2386 static int 2387 ixgbe_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2388 { 2389 struct ifnet *ifp = &ec->ec_if; 2390 struct adapter *adapter = ifp->if_softc; 2391 int rv; 2392 2393 if (set) 2394 rv = ixgbe_register_vlan(adapter, vid); 2395 else 2396 rv = ixgbe_unregister_vlan(adapter, vid); 2397 2398 if (rv != 0) 2399 return rv; 2400 2401 /* 2402 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2403 * or 0 to 1. 2404 */ 2405 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2406 ixgbe_setup_vlan_hw_tagging(adapter); 2407 2408 return rv; 2409 } 2410 2411 /************************************************************************ 2412 * ixgbe_register_vlan 2413 * 2414 * Run via vlan config EVENT, it enables us to use the 2415 * HW Filter table since we can get the vlan id. This 2416 * just creates the entry in the soft version of the 2417 * VFTA, init will repopulate the real table. 2418 ************************************************************************/ 2419 static int 2420 ixgbe_register_vlan(struct adapter *adapter, u16 vtag) 2421 { 2422 u16 index, bit; 2423 int error; 2424 2425 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2426 return EINVAL; 2427 2428 IXGBE_CORE_LOCK(adapter); 2429 index = (vtag >> 5) & 0x7F; 2430 bit = vtag & 0x1F; 2431 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2432 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, true, 2433 true); 2434 IXGBE_CORE_UNLOCK(adapter); 2435 if (error != 0) 2436 error = EACCES; 2437 2438 return error; 2439 } /* ixgbe_register_vlan */ 2440 2441 /************************************************************************ 2442 * ixgbe_unregister_vlan 2443 * 2444 * Run via vlan unconfig EVENT, remove our entry in the soft vfta. 2445 ************************************************************************/ 2446 static int 2447 ixgbe_unregister_vlan(struct adapter *adapter, u16 vtag) 2448 { 2449 u16 index, bit; 2450 int error; 2451 2452 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2453 return EINVAL; 2454 2455 IXGBE_CORE_LOCK(adapter); 2456 index = (vtag >> 5) & 0x7F; 2457 bit = vtag & 0x1F; 2458 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2459 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, false, 2460 true); 2461 IXGBE_CORE_UNLOCK(adapter); 2462 if (error != 0) 2463 error = EACCES; 2464 2465 return error; 2466 } /* ixgbe_unregister_vlan */ 2467 2468 static void 2469 ixgbe_setup_vlan_hw_tagging(struct adapter *adapter) 2470 { 2471 struct ethercom *ec = &adapter->osdep.ec; 2472 struct ixgbe_hw *hw = &adapter->hw; 2473 struct rx_ring *rxr; 2474 u32 ctrl; 2475 int i; 2476 bool hwtagging; 2477 2478 /* Enable HW tagging only if any vlan is attached */ 2479 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 2480 && VLAN_ATTACHED(ec); 2481 2482 /* Setup the queues for vlans */ 2483 for (i = 0; i < adapter->num_queues; i++) { 2484 rxr = &adapter->rx_rings[i]; 2485 /* 2486 * On 82599 and later, the VLAN enable is per/queue in RXDCTL. 2487 */ 2488 if (hw->mac.type != ixgbe_mac_82598EB) { 2489 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 2490 if (hwtagging) 2491 ctrl |= IXGBE_RXDCTL_VME; 2492 else 2493 ctrl &= ~IXGBE_RXDCTL_VME; 2494 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 2495 } 2496 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2497 } 2498 2499 /* VLAN hw tagging for 82598 */ 2500 if (hw->mac.type == ixgbe_mac_82598EB) { 2501 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2502 if (hwtagging) 2503 ctrl |= IXGBE_VLNCTRL_VME; 2504 else 2505 ctrl &= ~IXGBE_VLNCTRL_VME; 2506 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2507 } 2508 } /* ixgbe_setup_vlan_hw_tagging */ 2509 2510 static void 2511 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2512 { 2513 struct ethercom *ec = &adapter->osdep.ec; 2514 struct ixgbe_hw *hw = &adapter->hw; 2515 int i; 2516 u32 ctrl; 2517 struct vlanid_list *vlanidp; 2518 2519 /* 2520 * This function is called from both if_init and ifflags_cb() 2521 * on NetBSD. 2522 */ 2523 2524 /* 2525 * Part 1: 2526 * Setup VLAN HW tagging 2527 */ 2528 ixgbe_setup_vlan_hw_tagging(adapter); 2529 2530 /* 2531 * Part 2: 2532 * Setup VLAN HW filter 2533 */ 2534 /* Cleanup shadow_vfta */ 2535 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2536 adapter->shadow_vfta[i] = 0; 2537 /* Generate shadow_vfta from ec_vids */ 2538 ETHER_LOCK(ec); 2539 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2540 uint32_t idx; 2541 2542 idx = vlanidp->vid / 32; 2543 KASSERT(idx < IXGBE_VFTA_SIZE); 2544 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2545 } 2546 ETHER_UNLOCK(ec); 2547 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2548 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), adapter->shadow_vfta[i]); 2549 2550 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2551 /* Enable the Filter Table if enabled */ 2552 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) 2553 ctrl |= IXGBE_VLNCTRL_VFE; 2554 else 2555 ctrl &= ~IXGBE_VLNCTRL_VFE; 2556 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2557 } /* ixgbe_setup_vlan_hw_support */ 2558 2559 /************************************************************************ 2560 * ixgbe_get_slot_info 2561 * 2562 * Get the width and transaction speed of 2563 * the slot this adapter is plugged into. 2564 ************************************************************************/ 2565 static void 2566 ixgbe_get_slot_info(struct adapter *adapter) 2567 { 2568 device_t dev = adapter->dev; 2569 struct ixgbe_hw *hw = &adapter->hw; 2570 u32 offset; 2571 u16 link; 2572 int bus_info_valid = TRUE; 2573 2574 /* Some devices are behind an internal bridge */ 2575 switch (hw->device_id) { 2576 case IXGBE_DEV_ID_82599_SFP_SF_QP: 2577 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 2578 goto get_parent_info; 2579 default: 2580 break; 2581 } 2582 2583 ixgbe_get_bus_info(hw); 2584 2585 /* 2586 * Some devices don't use PCI-E, but there is no need 2587 * to display "Unknown" for bus speed and width. 2588 */ 2589 switch (hw->mac.type) { 2590 case ixgbe_mac_X550EM_x: 2591 case ixgbe_mac_X550EM_a: 2592 return; 2593 default: 2594 goto display; 2595 } 2596 2597 get_parent_info: 2598 /* 2599 * For the Quad port adapter we need to parse back 2600 * up the PCI tree to find the speed of the expansion 2601 * slot into which this adapter is plugged. A bit more work. 2602 */ 2603 dev = device_parent(device_parent(dev)); 2604 #if 0 2605 #ifdef IXGBE_DEBUG 2606 device_printf(dev, "parent pcib = %x,%x,%x\n", pci_get_bus(dev), 2607 pci_get_slot(dev), pci_get_function(dev)); 2608 #endif 2609 dev = device_parent(device_parent(dev)); 2610 #ifdef IXGBE_DEBUG 2611 device_printf(dev, "slot pcib = %x,%x,%x\n", pci_get_bus(dev), 2612 pci_get_slot(dev), pci_get_function(dev)); 2613 #endif 2614 #endif 2615 /* Now get the PCI Express Capabilities offset */ 2616 if (pci_get_capability(adapter->osdep.pc, adapter->osdep.tag, 2617 PCI_CAP_PCIEXPRESS, &offset, NULL)) { 2618 /* 2619 * Hmm...can't get PCI-Express capabilities. 2620 * Falling back to default method. 2621 */ 2622 bus_info_valid = FALSE; 2623 ixgbe_get_bus_info(hw); 2624 goto display; 2625 } 2626 /* ...and read the Link Status Register */ 2627 link = pci_conf_read(adapter->osdep.pc, adapter->osdep.tag, 2628 offset + PCIE_LCSR) >> 16; 2629 ixgbe_set_pci_config_data_generic(hw, link); 2630 2631 display: 2632 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 2633 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s" : 2634 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s" : 2635 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s" : 2636 "Unknown"), 2637 ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 2638 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 2639 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 2640 "Unknown")); 2641 2642 if (bus_info_valid) { 2643 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 2644 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 2645 (hw->bus.speed == ixgbe_bus_speed_2500))) { 2646 device_printf(dev, "PCI-Express bandwidth available" 2647 " for this card\n is not sufficient for" 2648 " optimal performance.\n"); 2649 device_printf(dev, "For optimal performance a x8 " 2650 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 2651 } 2652 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 2653 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 2654 (hw->bus.speed < ixgbe_bus_speed_8000))) { 2655 device_printf(dev, "PCI-Express bandwidth available" 2656 " for this card\n is not sufficient for" 2657 " optimal performance.\n"); 2658 device_printf(dev, "For optimal performance a x8 " 2659 "PCIE Gen3 slot is required.\n"); 2660 } 2661 } else 2662 device_printf(dev, "Unable to determine slot speed/width. The speed/width reported are that of the internal switch.\n"); 2663 2664 return; 2665 } /* ixgbe_get_slot_info */ 2666 2667 /************************************************************************ 2668 * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets 2669 ************************************************************************/ 2670 static inline void 2671 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 2672 { 2673 struct ixgbe_hw *hw = &adapter->hw; 2674 struct ix_queue *que = &adapter->queues[vector]; 2675 u64 queue = 1ULL << vector; 2676 u32 mask; 2677 2678 mutex_enter(&que->dc_mtx); 2679 if (que->disabled_count > 0 && --que->disabled_count > 0) 2680 goto out; 2681 2682 if (hw->mac.type == ixgbe_mac_82598EB) { 2683 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2684 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 2685 } else { 2686 mask = (queue & 0xFFFFFFFF); 2687 if (mask) 2688 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 2689 mask = (queue >> 32); 2690 if (mask) 2691 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 2692 } 2693 out: 2694 mutex_exit(&que->dc_mtx); 2695 } /* ixgbe_enable_queue */ 2696 2697 /************************************************************************ 2698 * ixgbe_disable_queue_internal 2699 ************************************************************************/ 2700 static inline void 2701 ixgbe_disable_queue_internal(struct adapter *adapter, u32 vector, bool nestok) 2702 { 2703 struct ixgbe_hw *hw = &adapter->hw; 2704 struct ix_queue *que = &adapter->queues[vector]; 2705 u64 queue = 1ULL << vector; 2706 u32 mask; 2707 2708 mutex_enter(&que->dc_mtx); 2709 2710 if (que->disabled_count > 0) { 2711 if (nestok) 2712 que->disabled_count++; 2713 goto out; 2714 } 2715 que->disabled_count++; 2716 2717 if (hw->mac.type == ixgbe_mac_82598EB) { 2718 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2719 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 2720 } else { 2721 mask = (queue & 0xFFFFFFFF); 2722 if (mask) 2723 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 2724 mask = (queue >> 32); 2725 if (mask) 2726 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 2727 } 2728 out: 2729 mutex_exit(&que->dc_mtx); 2730 } /* ixgbe_disable_queue_internal */ 2731 2732 /************************************************************************ 2733 * ixgbe_disable_queue 2734 ************************************************************************/ 2735 static inline void 2736 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 2737 { 2738 2739 ixgbe_disable_queue_internal(adapter, vector, true); 2740 } /* ixgbe_disable_queue */ 2741 2742 /************************************************************************ 2743 * ixgbe_sched_handle_que - schedule deferred packet processing 2744 ************************************************************************/ 2745 static inline void 2746 ixgbe_sched_handle_que(struct adapter *adapter, struct ix_queue *que) 2747 { 2748 2749 if (que->txrx_use_workqueue) { 2750 /* 2751 * adapter->que_wq is bound to each CPU instead of 2752 * each NIC queue to reduce workqueue kthread. As we 2753 * should consider about interrupt affinity in this 2754 * function, the workqueue kthread must be WQ_PERCPU. 2755 * If create WQ_PERCPU workqueue kthread for each NIC 2756 * queue, that number of created workqueue kthread is 2757 * (number of used NIC queue) * (number of CPUs) = 2758 * (number of CPUs) ^ 2 most often. 2759 * 2760 * The same NIC queue's interrupts are avoided by 2761 * masking the queue's interrupt. And different 2762 * NIC queue's interrupts use different struct work 2763 * (que->wq_cookie). So, "enqueued flag" to avoid 2764 * twice workqueue_enqueue() is not required . 2765 */ 2766 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, curcpu()); 2767 } else { 2768 softint_schedule(que->que_si); 2769 } 2770 } 2771 2772 /************************************************************************ 2773 * ixgbe_msix_que - MSI-X Queue Interrupt Service routine 2774 ************************************************************************/ 2775 static int 2776 ixgbe_msix_que(void *arg) 2777 { 2778 struct ix_queue *que = arg; 2779 struct adapter *adapter = que->adapter; 2780 struct ifnet *ifp = adapter->ifp; 2781 struct tx_ring *txr = que->txr; 2782 struct rx_ring *rxr = que->rxr; 2783 bool more; 2784 u32 newitr = 0; 2785 2786 /* Protect against spurious interrupts */ 2787 if ((ifp->if_flags & IFF_RUNNING) == 0) 2788 return 0; 2789 2790 ixgbe_disable_queue(adapter, que->msix); 2791 ++que->irqs.ev_count; 2792 2793 /* 2794 * Don't change "que->txrx_use_workqueue" from this point to avoid 2795 * flip-flopping softint/workqueue mode in one deferred processing. 2796 */ 2797 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 2798 2799 #ifdef __NetBSD__ 2800 /* Don't run ixgbe_rxeof in interrupt context */ 2801 more = true; 2802 #else 2803 more = ixgbe_rxeof(que); 2804 #endif 2805 2806 IXGBE_TX_LOCK(txr); 2807 ixgbe_txeof(txr); 2808 IXGBE_TX_UNLOCK(txr); 2809 2810 /* Do AIM now? */ 2811 2812 if (adapter->enable_aim == false) 2813 goto no_calc; 2814 /* 2815 * Do Adaptive Interrupt Moderation: 2816 * - Write out last calculated setting 2817 * - Calculate based on average size over 2818 * the last interval. 2819 */ 2820 if (que->eitr_setting) 2821 ixgbe_eitr_write(adapter, que->msix, que->eitr_setting); 2822 2823 que->eitr_setting = 0; 2824 2825 /* Idle, do nothing */ 2826 if ((txr->bytes == 0) && (rxr->bytes == 0)) 2827 goto no_calc; 2828 2829 if ((txr->bytes) && (txr->packets)) 2830 newitr = txr->bytes/txr->packets; 2831 if ((rxr->bytes) && (rxr->packets)) 2832 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 2833 newitr += 24; /* account for hardware frame, crc */ 2834 2835 /* set an upper boundary */ 2836 newitr = uimin(newitr, 3000); 2837 2838 /* Be nice to the mid range */ 2839 if ((newitr > 300) && (newitr < 1200)) 2840 newitr = (newitr / 3); 2841 else 2842 newitr = (newitr / 2); 2843 2844 /* 2845 * When RSC is used, ITR interval must be larger than RSC_DELAY. 2846 * Currently, we use 2us for RSC_DELAY. The minimum value is always 2847 * greater than 2us on 100M (and 10M?(not documented)), but it's not 2848 * on 1G and higher. 2849 */ 2850 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2851 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2852 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 2853 newitr = IXGBE_MIN_RSC_EITR_10G1G; 2854 } 2855 2856 /* save for next interrupt */ 2857 que->eitr_setting = newitr; 2858 2859 /* Reset state */ 2860 txr->bytes = 0; 2861 txr->packets = 0; 2862 rxr->bytes = 0; 2863 rxr->packets = 0; 2864 2865 no_calc: 2866 if (more) 2867 ixgbe_sched_handle_que(adapter, que); 2868 else 2869 ixgbe_enable_queue(adapter, que->msix); 2870 2871 return 1; 2872 } /* ixgbe_msix_que */ 2873 2874 /************************************************************************ 2875 * ixgbe_media_status - Media Ioctl callback 2876 * 2877 * Called whenever the user queries the status of 2878 * the interface using ifconfig. 2879 ************************************************************************/ 2880 static void 2881 ixgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2882 { 2883 struct adapter *adapter = ifp->if_softc; 2884 struct ixgbe_hw *hw = &adapter->hw; 2885 int layer; 2886 2887 INIT_DEBUGOUT("ixgbe_media_status: begin"); 2888 ixgbe_update_link_status(adapter); 2889 2890 ifmr->ifm_status = IFM_AVALID; 2891 ifmr->ifm_active = IFM_ETHER; 2892 2893 if (adapter->link_active != LINK_STATE_UP) { 2894 ifmr->ifm_active |= IFM_NONE; 2895 return; 2896 } 2897 2898 ifmr->ifm_status |= IFM_ACTIVE; 2899 layer = adapter->phy_layer; 2900 2901 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2902 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2903 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2904 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2905 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2906 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2907 switch (adapter->link_speed) { 2908 case IXGBE_LINK_SPEED_10GB_FULL: 2909 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2910 break; 2911 case IXGBE_LINK_SPEED_5GB_FULL: 2912 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2913 break; 2914 case IXGBE_LINK_SPEED_2_5GB_FULL: 2915 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2916 break; 2917 case IXGBE_LINK_SPEED_1GB_FULL: 2918 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2919 break; 2920 case IXGBE_LINK_SPEED_100_FULL: 2921 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2922 break; 2923 case IXGBE_LINK_SPEED_10_FULL: 2924 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2925 break; 2926 } 2927 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2928 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2929 switch (adapter->link_speed) { 2930 case IXGBE_LINK_SPEED_10GB_FULL: 2931 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2932 break; 2933 } 2934 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2935 switch (adapter->link_speed) { 2936 case IXGBE_LINK_SPEED_10GB_FULL: 2937 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2938 break; 2939 case IXGBE_LINK_SPEED_1GB_FULL: 2940 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2941 break; 2942 } 2943 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2944 switch (adapter->link_speed) { 2945 case IXGBE_LINK_SPEED_10GB_FULL: 2946 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2947 break; 2948 case IXGBE_LINK_SPEED_1GB_FULL: 2949 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2950 break; 2951 } 2952 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2953 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2954 switch (adapter->link_speed) { 2955 case IXGBE_LINK_SPEED_10GB_FULL: 2956 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2957 break; 2958 case IXGBE_LINK_SPEED_1GB_FULL: 2959 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2960 break; 2961 } 2962 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2963 switch (adapter->link_speed) { 2964 case IXGBE_LINK_SPEED_10GB_FULL: 2965 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2966 break; 2967 } 2968 /* 2969 * XXX: These need to use the proper media types once 2970 * they're added. 2971 */ 2972 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 2973 switch (adapter->link_speed) { 2974 case IXGBE_LINK_SPEED_10GB_FULL: 2975 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 2976 break; 2977 case IXGBE_LINK_SPEED_2_5GB_FULL: 2978 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2979 break; 2980 case IXGBE_LINK_SPEED_1GB_FULL: 2981 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2982 break; 2983 } 2984 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 2985 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 2986 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 2987 switch (adapter->link_speed) { 2988 case IXGBE_LINK_SPEED_10GB_FULL: 2989 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 2990 break; 2991 case IXGBE_LINK_SPEED_2_5GB_FULL: 2992 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2993 break; 2994 case IXGBE_LINK_SPEED_1GB_FULL: 2995 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2996 break; 2997 } 2998 2999 /* If nothing is recognized... */ 3000 #if 0 3001 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 3002 ifmr->ifm_active |= IFM_UNKNOWN; 3003 #endif 3004 3005 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 3006 3007 /* Display current flow control setting used on link */ 3008 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 3009 hw->fc.current_mode == ixgbe_fc_full) 3010 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 3011 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 3012 hw->fc.current_mode == ixgbe_fc_full) 3013 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 3014 3015 return; 3016 } /* ixgbe_media_status */ 3017 3018 /************************************************************************ 3019 * ixgbe_media_change - Media Ioctl callback 3020 * 3021 * Called when the user changes speed/duplex using 3022 * media/mediopt option with ifconfig. 3023 ************************************************************************/ 3024 static int 3025 ixgbe_media_change(struct ifnet *ifp) 3026 { 3027 struct adapter *adapter = ifp->if_softc; 3028 struct ifmedia *ifm = &adapter->media; 3029 struct ixgbe_hw *hw = &adapter->hw; 3030 ixgbe_link_speed speed = 0; 3031 ixgbe_link_speed link_caps = 0; 3032 bool negotiate = false; 3033 s32 err = IXGBE_NOT_IMPLEMENTED; 3034 3035 INIT_DEBUGOUT("ixgbe_media_change: begin"); 3036 3037 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 3038 return (EINVAL); 3039 3040 if (hw->phy.media_type == ixgbe_media_type_backplane) 3041 return (EPERM); 3042 3043 /* 3044 * We don't actually need to check against the supported 3045 * media types of the adapter; ifmedia will take care of 3046 * that for us. 3047 */ 3048 switch (IFM_SUBTYPE(ifm->ifm_media)) { 3049 case IFM_AUTO: 3050 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 3051 &negotiate); 3052 if (err != IXGBE_SUCCESS) { 3053 device_printf(adapter->dev, "Unable to determine " 3054 "supported advertise speeds\n"); 3055 return (ENODEV); 3056 } 3057 speed |= link_caps; 3058 break; 3059 case IFM_10G_T: 3060 case IFM_10G_LRM: 3061 case IFM_10G_LR: 3062 case IFM_10G_TWINAX: 3063 case IFM_10G_SR: 3064 case IFM_10G_CX4: 3065 case IFM_10G_KR: 3066 case IFM_10G_KX4: 3067 speed |= IXGBE_LINK_SPEED_10GB_FULL; 3068 break; 3069 case IFM_5000_T: 3070 speed |= IXGBE_LINK_SPEED_5GB_FULL; 3071 break; 3072 case IFM_2500_T: 3073 case IFM_2500_KX: 3074 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 3075 break; 3076 case IFM_1000_T: 3077 case IFM_1000_LX: 3078 case IFM_1000_SX: 3079 case IFM_1000_KX: 3080 speed |= IXGBE_LINK_SPEED_1GB_FULL; 3081 break; 3082 case IFM_100_TX: 3083 speed |= IXGBE_LINK_SPEED_100_FULL; 3084 break; 3085 case IFM_10_T: 3086 speed |= IXGBE_LINK_SPEED_10_FULL; 3087 break; 3088 case IFM_NONE: 3089 break; 3090 default: 3091 goto invalid; 3092 } 3093 3094 hw->mac.autotry_restart = TRUE; 3095 hw->mac.ops.setup_link(hw, speed, TRUE); 3096 adapter->advertise = 0; 3097 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 3098 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 3099 adapter->advertise |= 1 << 2; 3100 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 3101 adapter->advertise |= 1 << 1; 3102 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 3103 adapter->advertise |= 1 << 0; 3104 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 3105 adapter->advertise |= 1 << 3; 3106 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 3107 adapter->advertise |= 1 << 4; 3108 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 3109 adapter->advertise |= 1 << 5; 3110 } 3111 3112 return (0); 3113 3114 invalid: 3115 device_printf(adapter->dev, "Invalid media type!\n"); 3116 3117 return (EINVAL); 3118 } /* ixgbe_media_change */ 3119 3120 /************************************************************************ 3121 * ixgbe_msix_admin - Link status change ISR (MSI/MSI-X) 3122 ************************************************************************/ 3123 static int 3124 ixgbe_msix_admin(void *arg) 3125 { 3126 struct adapter *adapter = arg; 3127 struct ixgbe_hw *hw = &adapter->hw; 3128 u32 eicr; 3129 u32 eims_orig; 3130 u32 eims_disable = 0; 3131 3132 ++adapter->admin_irqev.ev_count; 3133 3134 eims_orig = IXGBE_READ_REG(hw, IXGBE_EIMS); 3135 /* Pause other interrupts */ 3136 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_MSIX_OTHER_CLEAR_MASK); 3137 3138 /* 3139 * First get the cause. 3140 * 3141 * The specifications of 82598, 82599, X540 and X550 say EICS register 3142 * is write only. However, Linux says it is a workaround for silicon 3143 * errata to read EICS instead of EICR to get interrupt cause. 3144 * At least, reading EICR clears lower 16bits of EIMS on 82598. 3145 */ 3146 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 3147 /* Be sure the queue bits are not cleared */ 3148 eicr &= ~IXGBE_EICR_RTX_QUEUE; 3149 /* Clear all OTHER interrupts with write */ 3150 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 3151 3152 ixgbe_intr_admin_common(adapter, eicr, &eims_disable); 3153 3154 /* Re-enable some OTHER interrupts */ 3155 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_orig & ~eims_disable); 3156 3157 return 1; 3158 } /* ixgbe_msix_admin */ 3159 3160 static void 3161 ixgbe_intr_admin_common(struct adapter *adapter, u32 eicr, u32 *eims_disable) 3162 { 3163 struct ixgbe_hw *hw = &adapter->hw; 3164 u32 eicr_mask; 3165 u32 task_requests = 0; 3166 s32 retval; 3167 3168 /* Link status change */ 3169 if (eicr & IXGBE_EICR_LSC) { 3170 task_requests |= IXGBE_REQUEST_TASK_LSC; 3171 *eims_disable |= IXGBE_EIMS_LSC; 3172 } 3173 3174 if (ixgbe_is_sfp(hw)) { 3175 /* Pluggable optics-related interrupt */ 3176 if (hw->mac.type >= ixgbe_mac_X540) 3177 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 3178 else 3179 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 3180 3181 /* 3182 * An interrupt might not arrive when a module is inserted. 3183 * When an link status change interrupt occurred and the driver 3184 * still regard SFP as unplugged, issue the module softint 3185 * and then issue LSC interrupt. 3186 */ 3187 if ((eicr & eicr_mask) 3188 || ((hw->phy.sfp_type == ixgbe_sfp_type_not_present) 3189 && (eicr & IXGBE_EICR_LSC))) { 3190 task_requests |= IXGBE_REQUEST_TASK_MOD; 3191 *eims_disable |= IXGBE_EIMS_LSC; 3192 } 3193 3194 if ((hw->mac.type == ixgbe_mac_82599EB) && 3195 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 3196 task_requests |= IXGBE_REQUEST_TASK_MSF; 3197 *eims_disable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 3198 } 3199 } 3200 3201 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 3202 if ((adapter->feat_en & IXGBE_FEATURE_FDIR) && 3203 (eicr & IXGBE_EICR_FLOW_DIR)) { 3204 if (!atomic_cas_uint(&adapter->fdir_reinit, 0, 1)) { 3205 task_requests |= IXGBE_REQUEST_TASK_FDIR; 3206 /* Disable the interrupt */ 3207 *eims_disable |= IXGBE_EIMS_FLOW_DIR; 3208 } 3209 } 3210 3211 if (eicr & IXGBE_EICR_ECC) { 3212 device_printf(adapter->dev, 3213 "CRITICAL: ECC ERROR!! Please Reboot!!\n"); 3214 /* Disable interrupt to prevent log spam */ 3215 *eims_disable |= IXGBE_EICR_ECC; 3216 } 3217 3218 /* Check for over temp condition */ 3219 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) { 3220 switch (adapter->hw.mac.type) { 3221 case ixgbe_mac_X550EM_a: 3222 if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a)) 3223 break; 3224 /* Disable interrupt to prevent log spam */ 3225 *eims_disable |= IXGBE_EICR_GPI_SDP0_X550EM_a; 3226 3227 retval = hw->phy.ops.check_overtemp(hw); 3228 if (retval != IXGBE_ERR_OVERTEMP) 3229 break; 3230 device_printf(adapter->dev, 3231 "CRITICAL: OVER TEMP!! " 3232 "PHY IS SHUT DOWN!!\n"); 3233 device_printf(adapter->dev, 3234 "System shutdown required!\n"); 3235 break; 3236 default: 3237 if (!(eicr & IXGBE_EICR_TS)) 3238 break; 3239 /* Disable interrupt to prevent log spam */ 3240 *eims_disable |= IXGBE_EIMS_TS; 3241 3242 retval = hw->phy.ops.check_overtemp(hw); 3243 if (retval != IXGBE_ERR_OVERTEMP) 3244 break; 3245 device_printf(adapter->dev, 3246 "CRITICAL: OVER TEMP!! " 3247 "PHY IS SHUT DOWN!!\n"); 3248 device_printf(adapter->dev, 3249 "System shutdown required!\n"); 3250 break; 3251 } 3252 } 3253 3254 /* Check for VF message */ 3255 if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) && 3256 (eicr & IXGBE_EICR_MAILBOX)) { 3257 task_requests |= IXGBE_REQUEST_TASK_MBX; 3258 *eims_disable |= IXGBE_EIMS_MAILBOX; 3259 } 3260 } 3261 3262 /* Check for fan failure */ 3263 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 3264 retval = ixgbe_check_fan_failure(adapter, eicr, true); 3265 if (retval == IXGBE_ERR_FAN_FAILURE) { 3266 /* Disable interrupt to prevent log spam */ 3267 *eims_disable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 3268 } 3269 } 3270 3271 /* External PHY interrupt */ 3272 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 3273 (eicr & IXGBE_EICR_GPI_SDP0_X540)) { 3274 task_requests |= IXGBE_REQUEST_TASK_PHY; 3275 *eims_disable |= IXGBE_EICR_GPI_SDP0_X540; 3276 } 3277 3278 if (task_requests != 0) { 3279 mutex_enter(&adapter->admin_mtx); 3280 adapter->task_requests |= task_requests; 3281 ixgbe_schedule_admin_tasklet(adapter); 3282 mutex_exit(&adapter->admin_mtx); 3283 } 3284 3285 } 3286 3287 static void 3288 ixgbe_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 3289 { 3290 3291 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 3292 itr |= itr << 16; 3293 else 3294 itr |= IXGBE_EITR_CNT_WDIS; 3295 3296 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(index), itr); 3297 } 3298 3299 3300 /************************************************************************ 3301 * ixgbe_sysctl_interrupt_rate_handler 3302 ************************************************************************/ 3303 static int 3304 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3305 { 3306 struct sysctlnode node = *rnode; 3307 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 3308 struct adapter *adapter; 3309 uint32_t reg, usec, rate; 3310 int error; 3311 3312 if (que == NULL) 3313 return 0; 3314 3315 adapter = que->adapter; 3316 if (ixgbe_fw_recovery_mode_swflag(adapter)) 3317 return (EPERM); 3318 3319 reg = IXGBE_READ_REG(&adapter->hw, IXGBE_EITR(que->msix)); 3320 usec = ((reg & 0x0FF8) >> 3); 3321 if (usec > 0) 3322 rate = 500000 / usec; 3323 else 3324 rate = 0; 3325 node.sysctl_data = &rate; 3326 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3327 if (error || newp == NULL) 3328 return error; 3329 reg &= ~0xfff; /* default, no limitation */ 3330 if (rate > 0 && rate < 500000) { 3331 if (rate < 1000) 3332 rate = 1000; 3333 reg |= ((4000000 / rate) & 0xff8); 3334 /* 3335 * When RSC is used, ITR interval must be larger than 3336 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 3337 * The minimum value is always greater than 2us on 100M 3338 * (and 10M?(not documented)), but it's not on 1G and higher. 3339 */ 3340 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 3341 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 3342 if ((adapter->num_queues > 1) 3343 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 3344 return EINVAL; 3345 } 3346 ixgbe_max_interrupt_rate = rate; 3347 } else 3348 ixgbe_max_interrupt_rate = 0; 3349 ixgbe_eitr_write(adapter, que->msix, reg); 3350 3351 return (0); 3352 } /* ixgbe_sysctl_interrupt_rate_handler */ 3353 3354 const struct sysctlnode * 3355 ixgbe_sysctl_instance(struct adapter *adapter) 3356 { 3357 const char *dvname; 3358 struct sysctllog **log; 3359 int rc; 3360 const struct sysctlnode *rnode; 3361 3362 if (adapter->sysctltop != NULL) 3363 return adapter->sysctltop; 3364 3365 log = &adapter->sysctllog; 3366 dvname = device_xname(adapter->dev); 3367 3368 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3369 0, CTLTYPE_NODE, dvname, 3370 SYSCTL_DESCR("ixgbe information and settings"), 3371 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3372 goto err; 3373 3374 return rnode; 3375 err: 3376 device_printf(adapter->dev, 3377 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3378 return NULL; 3379 } 3380 3381 /************************************************************************ 3382 * ixgbe_add_device_sysctls 3383 ************************************************************************/ 3384 static void 3385 ixgbe_add_device_sysctls(struct adapter *adapter) 3386 { 3387 device_t dev = adapter->dev; 3388 struct ixgbe_hw *hw = &adapter->hw; 3389 struct sysctllog **log; 3390 const struct sysctlnode *rnode, *cnode; 3391 3392 log = &adapter->sysctllog; 3393 3394 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3395 aprint_error_dev(dev, "could not create sysctl root\n"); 3396 return; 3397 } 3398 3399 if (sysctl_createv(log, 0, &rnode, &cnode, 3400 CTLFLAG_READWRITE, CTLTYPE_INT, 3401 "debug", SYSCTL_DESCR("Debug Info"), 3402 ixgbe_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) 3403 != 0) 3404 aprint_error_dev(dev, "could not create sysctl\n"); 3405 3406 if (sysctl_createv(log, 0, &rnode, &cnode, 3407 CTLFLAG_READWRITE, CTLTYPE_INT, 3408 "rx_copy_len", SYSCTL_DESCR("RX Copy Length"), 3409 ixgbe_sysctl_rx_copy_len, 0, 3410 (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 3411 aprint_error_dev(dev, "could not create sysctl\n"); 3412 3413 if (sysctl_createv(log, 0, &rnode, &cnode, 3414 CTLFLAG_READONLY, CTLTYPE_INT, 3415 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 3416 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 3417 aprint_error_dev(dev, "could not create sysctl\n"); 3418 3419 if (sysctl_createv(log, 0, &rnode, &cnode, 3420 CTLFLAG_READONLY, CTLTYPE_INT, 3421 "num_queues", SYSCTL_DESCR("Number of queues"), 3422 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 3423 aprint_error_dev(dev, "could not create sysctl\n"); 3424 3425 /* Sysctls for all devices */ 3426 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3427 CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 3428 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, 3429 CTL_EOL) != 0) 3430 aprint_error_dev(dev, "could not create sysctl\n"); 3431 3432 adapter->enable_aim = ixgbe_enable_aim; 3433 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3434 CTLTYPE_BOOL, "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 3435 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 3436 aprint_error_dev(dev, "could not create sysctl\n"); 3437 3438 if (sysctl_createv(log, 0, &rnode, &cnode, 3439 CTLFLAG_READWRITE, CTLTYPE_INT, 3440 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 3441 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, 3442 CTL_EOL) != 0) 3443 aprint_error_dev(dev, "could not create sysctl\n"); 3444 3445 /* 3446 * If each "que->txrx_use_workqueue" is changed in sysctl handler, 3447 * it causesflip-flopping softint/workqueue mode in one deferred 3448 * processing. Therefore, preempt_disable()/preempt_enable() are 3449 * required in ixgbe_sched_handle_que() to avoid 3450 * KASSERT(ixgbe_sched_handle_que()) in softint_schedule(). 3451 * I think changing "que->txrx_use_workqueue" in interrupt handler 3452 * is lighter than doing preempt_disable()/preempt_enable() in every 3453 * ixgbe_sched_handle_que(). 3454 */ 3455 adapter->txrx_use_workqueue = ixgbe_txrx_workqueue; 3456 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3457 CTLTYPE_BOOL, "txrx_workqueue", 3458 SYSCTL_DESCR("Use workqueue for packet processing"), 3459 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, 3460 CTL_EOL) != 0) 3461 aprint_error_dev(dev, "could not create sysctl\n"); 3462 3463 #ifdef IXGBE_DEBUG 3464 /* testing sysctls (for all devices) */ 3465 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3466 CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"), 3467 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, 3468 CTL_EOL) != 0) 3469 aprint_error_dev(dev, "could not create sysctl\n"); 3470 3471 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY, 3472 CTLTYPE_STRING, "print_rss_config", 3473 SYSCTL_DESCR("Prints RSS Configuration"), 3474 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, 3475 CTL_EOL) != 0) 3476 aprint_error_dev(dev, "could not create sysctl\n"); 3477 #endif 3478 /* for X550 series devices */ 3479 if (hw->mac.type >= ixgbe_mac_X550) 3480 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3481 CTLTYPE_INT, "dmac", SYSCTL_DESCR("DMA Coalesce"), 3482 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, 3483 CTL_EOL) != 0) 3484 aprint_error_dev(dev, "could not create sysctl\n"); 3485 3486 /* for WoL-capable devices */ 3487 if (adapter->wol_support) { 3488 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3489 CTLTYPE_BOOL, "wol_enable", 3490 SYSCTL_DESCR("Enable/Disable Wake on LAN"), 3491 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, 3492 CTL_EOL) != 0) 3493 aprint_error_dev(dev, "could not create sysctl\n"); 3494 3495 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3496 CTLTYPE_INT, "wufc", 3497 SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 3498 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, 3499 CTL_EOL) != 0) 3500 aprint_error_dev(dev, "could not create sysctl\n"); 3501 } 3502 3503 /* for X552/X557-AT devices */ 3504 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3505 const struct sysctlnode *phy_node; 3506 3507 if (sysctl_createv(log, 0, &rnode, &phy_node, 0, CTLTYPE_NODE, 3508 "phy", SYSCTL_DESCR("External PHY sysctls"), 3509 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 3510 aprint_error_dev(dev, "could not create sysctl\n"); 3511 return; 3512 } 3513 3514 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3515 CTLTYPE_INT, "temp", 3516 SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 3517 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, 3518 CTL_EOL) != 0) 3519 aprint_error_dev(dev, "could not create sysctl\n"); 3520 3521 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3522 CTLTYPE_INT, "overtemp_occurred", 3523 SYSCTL_DESCR( 3524 "External PHY High Temperature Event Occurred"), 3525 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, 3526 CTL_CREATE, CTL_EOL) != 0) 3527 aprint_error_dev(dev, "could not create sysctl\n"); 3528 } 3529 3530 if ((hw->mac.type == ixgbe_mac_X550EM_a) 3531 && (hw->phy.type == ixgbe_phy_fw)) 3532 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3533 CTLTYPE_BOOL, "force_10_100_autonego", 3534 SYSCTL_DESCR("Force autonego on 10M and 100M"), 3535 NULL, 0, &hw->phy.force_10_100_autonego, 0, 3536 CTL_CREATE, CTL_EOL) != 0) 3537 aprint_error_dev(dev, "could not create sysctl\n"); 3538 3539 if (adapter->feat_cap & IXGBE_FEATURE_EEE) { 3540 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3541 CTLTYPE_INT, "eee_state", 3542 SYSCTL_DESCR("EEE Power Save State"), 3543 ixgbe_sysctl_eee_state, 0, (void *)adapter, 0, CTL_CREATE, 3544 CTL_EOL) != 0) 3545 aprint_error_dev(dev, "could not create sysctl\n"); 3546 } 3547 } /* ixgbe_add_device_sysctls */ 3548 3549 /************************************************************************ 3550 * ixgbe_allocate_pci_resources 3551 ************************************************************************/ 3552 static int 3553 ixgbe_allocate_pci_resources(struct adapter *adapter, 3554 const struct pci_attach_args *pa) 3555 { 3556 pcireg_t memtype, csr; 3557 device_t dev = adapter->dev; 3558 bus_addr_t addr; 3559 int flags; 3560 3561 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 3562 switch (memtype) { 3563 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 3564 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 3565 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 3566 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 3567 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 3568 goto map_err; 3569 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 3570 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 3571 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 3572 } 3573 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 3574 adapter->osdep.mem_size, flags, 3575 &adapter->osdep.mem_bus_space_handle) != 0) { 3576 map_err: 3577 adapter->osdep.mem_size = 0; 3578 aprint_error_dev(dev, "unable to map BAR0\n"); 3579 return ENXIO; 3580 } 3581 /* 3582 * Enable address decoding for memory range in case BIOS or 3583 * UEFI don't set it. 3584 */ 3585 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 3586 PCI_COMMAND_STATUS_REG); 3587 csr |= PCI_COMMAND_MEM_ENABLE; 3588 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 3589 csr); 3590 break; 3591 default: 3592 aprint_error_dev(dev, "unexpected type on BAR0\n"); 3593 return ENXIO; 3594 } 3595 3596 return (0); 3597 } /* ixgbe_allocate_pci_resources */ 3598 3599 static void 3600 ixgbe_free_deferred_handlers(struct adapter *adapter) 3601 { 3602 struct ix_queue *que = adapter->queues; 3603 struct tx_ring *txr = adapter->tx_rings; 3604 int i; 3605 3606 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 3607 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 3608 if (txr->txr_si != NULL) 3609 softint_disestablish(txr->txr_si); 3610 } 3611 if (que->que_si != NULL) 3612 softint_disestablish(que->que_si); 3613 } 3614 if (adapter->txr_wq != NULL) 3615 workqueue_destroy(adapter->txr_wq); 3616 if (adapter->txr_wq_enqueued != NULL) 3617 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 3618 if (adapter->que_wq != NULL) 3619 workqueue_destroy(adapter->que_wq); 3620 3621 if (adapter->admin_wq != NULL) { 3622 workqueue_destroy(adapter->admin_wq); 3623 adapter->admin_wq = NULL; 3624 } 3625 if (adapter->timer_wq != NULL) { 3626 workqueue_destroy(adapter->timer_wq); 3627 adapter->timer_wq = NULL; 3628 } 3629 if (adapter->recovery_mode_timer_wq != NULL) { 3630 /* 3631 * ixgbe_ifstop() doesn't call the workqueue_wait() for 3632 * the recovery_mode_timer workqueue, so call it here. 3633 */ 3634 workqueue_wait(adapter->recovery_mode_timer_wq, 3635 &adapter->recovery_mode_timer_wc); 3636 atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0); 3637 workqueue_destroy(adapter->recovery_mode_timer_wq); 3638 adapter->recovery_mode_timer_wq = NULL; 3639 } 3640 } /* ixgbe_free_deferred_handlers */ 3641 3642 /************************************************************************ 3643 * ixgbe_detach - Device removal routine 3644 * 3645 * Called when the driver is being removed. 3646 * Stops the adapter and deallocates all the resources 3647 * that were allocated for driver operation. 3648 * 3649 * return 0 on success, positive on failure 3650 ************************************************************************/ 3651 static int 3652 ixgbe_detach(device_t dev, int flags) 3653 { 3654 struct adapter *adapter = device_private(dev); 3655 struct rx_ring *rxr = adapter->rx_rings; 3656 struct tx_ring *txr = adapter->tx_rings; 3657 struct ixgbe_hw *hw = &adapter->hw; 3658 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 3659 u32 ctrl_ext; 3660 int i; 3661 3662 INIT_DEBUGOUT("ixgbe_detach: begin"); 3663 if (adapter->osdep.attached == false) 3664 return 0; 3665 3666 if (ixgbe_pci_iov_detach(dev) != 0) { 3667 device_printf(dev, "SR-IOV in use; detach first.\n"); 3668 return (EBUSY); 3669 } 3670 3671 #if NVLAN > 0 3672 /* Make sure VLANs are not using driver */ 3673 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 3674 ; /* nothing to do: no VLANs */ 3675 else if ((flags & (DETACH_SHUTDOWN | DETACH_FORCE)) != 0) 3676 vlan_ifdetach(adapter->ifp); 3677 else { 3678 aprint_error_dev(dev, "VLANs in use, detach first\n"); 3679 return (EBUSY); 3680 } 3681 #endif 3682 3683 adapter->osdep.detaching = true; 3684 /* 3685 * Stop the interface. ixgbe_setup_low_power_mode() calls 3686 * ixgbe_ifstop(), so it's not required to call ixgbe_ifstop() 3687 * directly. 3688 */ 3689 ixgbe_setup_low_power_mode(adapter); 3690 3691 callout_halt(&adapter->timer, NULL); 3692 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 3693 callout_halt(&adapter->recovery_mode_timer, NULL); 3694 3695 workqueue_wait(adapter->admin_wq, &adapter->admin_wc); 3696 atomic_store_relaxed(&adapter->admin_pending, 0); 3697 workqueue_wait(adapter->timer_wq, &adapter->timer_wc); 3698 atomic_store_relaxed(&adapter->timer_pending, 0); 3699 3700 pmf_device_deregister(dev); 3701 3702 ether_ifdetach(adapter->ifp); 3703 3704 ixgbe_free_deferred_handlers(adapter); 3705 3706 /* let hardware know driver is unloading */ 3707 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 3708 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 3709 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 3710 3711 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 3712 netmap_detach(adapter->ifp); 3713 3714 ixgbe_free_pci_resources(adapter); 3715 #if 0 /* XXX the NetBSD port is probably missing something here */ 3716 bus_generic_detach(dev); 3717 #endif 3718 if_detach(adapter->ifp); 3719 ifmedia_fini(&adapter->media); 3720 if_percpuq_destroy(adapter->ipq); 3721 3722 sysctl_teardown(&adapter->sysctllog); 3723 evcnt_detach(&adapter->efbig_tx_dma_setup); 3724 evcnt_detach(&adapter->mbuf_defrag_failed); 3725 evcnt_detach(&adapter->efbig2_tx_dma_setup); 3726 evcnt_detach(&adapter->einval_tx_dma_setup); 3727 evcnt_detach(&adapter->other_tx_dma_setup); 3728 evcnt_detach(&adapter->eagain_tx_dma_setup); 3729 evcnt_detach(&adapter->enomem_tx_dma_setup); 3730 evcnt_detach(&adapter->watchdog_events); 3731 evcnt_detach(&adapter->tso_err); 3732 evcnt_detach(&adapter->admin_irqev); 3733 evcnt_detach(&adapter->link_workev); 3734 evcnt_detach(&adapter->mod_workev); 3735 evcnt_detach(&adapter->msf_workev); 3736 evcnt_detach(&adapter->phy_workev); 3737 3738 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 3739 if (i < __arraycount(stats->mpc)) { 3740 evcnt_detach(&stats->mpc[i]); 3741 if (hw->mac.type == ixgbe_mac_82598EB) 3742 evcnt_detach(&stats->rnbc[i]); 3743 } 3744 if (i < __arraycount(stats->pxontxc)) { 3745 evcnt_detach(&stats->pxontxc[i]); 3746 evcnt_detach(&stats->pxonrxc[i]); 3747 evcnt_detach(&stats->pxofftxc[i]); 3748 evcnt_detach(&stats->pxoffrxc[i]); 3749 if (hw->mac.type >= ixgbe_mac_82599EB) 3750 evcnt_detach(&stats->pxon2offc[i]); 3751 } 3752 } 3753 3754 txr = adapter->tx_rings; 3755 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3756 evcnt_detach(&adapter->queues[i].irqs); 3757 evcnt_detach(&adapter->queues[i].handleq); 3758 evcnt_detach(&adapter->queues[i].req); 3759 evcnt_detach(&txr->no_desc_avail); 3760 evcnt_detach(&txr->total_packets); 3761 evcnt_detach(&txr->tso_tx); 3762 #ifndef IXGBE_LEGACY_TX 3763 evcnt_detach(&txr->pcq_drops); 3764 #endif 3765 3766 if (i < __arraycount(stats->qprc)) { 3767 evcnt_detach(&stats->qprc[i]); 3768 evcnt_detach(&stats->qptc[i]); 3769 evcnt_detach(&stats->qbrc[i]); 3770 evcnt_detach(&stats->qbtc[i]); 3771 if (hw->mac.type >= ixgbe_mac_82599EB) 3772 evcnt_detach(&stats->qprdc[i]); 3773 } 3774 3775 evcnt_detach(&rxr->rx_packets); 3776 evcnt_detach(&rxr->rx_bytes); 3777 evcnt_detach(&rxr->rx_copies); 3778 evcnt_detach(&rxr->no_mbuf); 3779 evcnt_detach(&rxr->rx_discarded); 3780 } 3781 evcnt_detach(&stats->ipcs); 3782 evcnt_detach(&stats->l4cs); 3783 evcnt_detach(&stats->ipcs_bad); 3784 evcnt_detach(&stats->l4cs_bad); 3785 evcnt_detach(&stats->intzero); 3786 evcnt_detach(&stats->legint); 3787 evcnt_detach(&stats->crcerrs); 3788 evcnt_detach(&stats->illerrc); 3789 evcnt_detach(&stats->errbc); 3790 evcnt_detach(&stats->mspdc); 3791 if (hw->mac.type >= ixgbe_mac_X550) 3792 evcnt_detach(&stats->mbsdc); 3793 evcnt_detach(&stats->mpctotal); 3794 evcnt_detach(&stats->mlfc); 3795 evcnt_detach(&stats->mrfc); 3796 evcnt_detach(&stats->rlec); 3797 evcnt_detach(&stats->lxontxc); 3798 evcnt_detach(&stats->lxonrxc); 3799 evcnt_detach(&stats->lxofftxc); 3800 evcnt_detach(&stats->lxoffrxc); 3801 3802 /* Packet Reception Stats */ 3803 evcnt_detach(&stats->tor); 3804 evcnt_detach(&stats->gorc); 3805 evcnt_detach(&stats->tpr); 3806 evcnt_detach(&stats->gprc); 3807 evcnt_detach(&stats->mprc); 3808 evcnt_detach(&stats->bprc); 3809 evcnt_detach(&stats->prc64); 3810 evcnt_detach(&stats->prc127); 3811 evcnt_detach(&stats->prc255); 3812 evcnt_detach(&stats->prc511); 3813 evcnt_detach(&stats->prc1023); 3814 evcnt_detach(&stats->prc1522); 3815 evcnt_detach(&stats->ruc); 3816 evcnt_detach(&stats->rfc); 3817 evcnt_detach(&stats->roc); 3818 evcnt_detach(&stats->rjc); 3819 evcnt_detach(&stats->mngprc); 3820 evcnt_detach(&stats->mngpdc); 3821 evcnt_detach(&stats->xec); 3822 3823 /* Packet Transmission Stats */ 3824 evcnt_detach(&stats->gotc); 3825 evcnt_detach(&stats->tpt); 3826 evcnt_detach(&stats->gptc); 3827 evcnt_detach(&stats->bptc); 3828 evcnt_detach(&stats->mptc); 3829 evcnt_detach(&stats->mngptc); 3830 evcnt_detach(&stats->ptc64); 3831 evcnt_detach(&stats->ptc127); 3832 evcnt_detach(&stats->ptc255); 3833 evcnt_detach(&stats->ptc511); 3834 evcnt_detach(&stats->ptc1023); 3835 evcnt_detach(&stats->ptc1522); 3836 3837 ixgbe_free_queues(adapter); 3838 free(adapter->mta, M_DEVBUF); 3839 3840 mutex_destroy(&adapter->admin_mtx); /* XXX appropriate order? */ 3841 IXGBE_CORE_LOCK_DESTROY(adapter); 3842 3843 return (0); 3844 } /* ixgbe_detach */ 3845 3846 /************************************************************************ 3847 * ixgbe_setup_low_power_mode - LPLU/WoL preparation 3848 * 3849 * Prepare the adapter/port for LPLU and/or WoL 3850 ************************************************************************/ 3851 static int 3852 ixgbe_setup_low_power_mode(struct adapter *adapter) 3853 { 3854 struct ixgbe_hw *hw = &adapter->hw; 3855 device_t dev = adapter->dev; 3856 struct ifnet *ifp = adapter->ifp; 3857 s32 error = 0; 3858 3859 /* Limit power management flow to X550EM baseT */ 3860 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 3861 hw->phy.ops.enter_lplu) { 3862 /* X550EM baseT adapters need a special LPLU flow */ 3863 hw->phy.reset_disable = true; 3864 ixgbe_ifstop(ifp, 1); 3865 error = hw->phy.ops.enter_lplu(hw); 3866 if (error) 3867 device_printf(dev, 3868 "Error entering LPLU: %d\n", error); 3869 hw->phy.reset_disable = false; 3870 } else { 3871 /* Just stop for other adapters */ 3872 ixgbe_ifstop(ifp, 1); 3873 } 3874 3875 IXGBE_CORE_LOCK(adapter); 3876 3877 if (!hw->wol_enabled) { 3878 ixgbe_set_phy_power(hw, FALSE); 3879 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3880 IXGBE_WRITE_REG(hw, IXGBE_WUC, 0); 3881 } else { 3882 /* Turn off support for APM wakeup. (Using ACPI instead) */ 3883 IXGBE_WRITE_REG(hw, IXGBE_GRC_BY_MAC(hw), 3884 IXGBE_READ_REG(hw, IXGBE_GRC_BY_MAC(hw)) & ~(u32)2); 3885 3886 /* 3887 * Clear Wake Up Status register to prevent any previous wakeup 3888 * events from waking us up immediately after we suspend. 3889 */ 3890 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3891 3892 /* 3893 * Program the Wakeup Filter Control register with user filter 3894 * settings 3895 */ 3896 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 3897 3898 /* Enable wakeups and power management in Wakeup Control */ 3899 IXGBE_WRITE_REG(hw, IXGBE_WUC, 3900 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 3901 3902 } 3903 3904 IXGBE_CORE_UNLOCK(adapter); 3905 3906 return error; 3907 } /* ixgbe_setup_low_power_mode */ 3908 3909 /************************************************************************ 3910 * ixgbe_shutdown - Shutdown entry point 3911 ************************************************************************/ 3912 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 3913 static int 3914 ixgbe_shutdown(device_t dev) 3915 { 3916 struct adapter *adapter = device_private(dev); 3917 int error = 0; 3918 3919 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 3920 3921 error = ixgbe_setup_low_power_mode(adapter); 3922 3923 return (error); 3924 } /* ixgbe_shutdown */ 3925 #endif 3926 3927 /************************************************************************ 3928 * ixgbe_suspend 3929 * 3930 * From D0 to D3 3931 ************************************************************************/ 3932 static bool 3933 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 3934 { 3935 struct adapter *adapter = device_private(dev); 3936 int error = 0; 3937 3938 INIT_DEBUGOUT("ixgbe_suspend: begin"); 3939 3940 error = ixgbe_setup_low_power_mode(adapter); 3941 3942 return (error); 3943 } /* ixgbe_suspend */ 3944 3945 /************************************************************************ 3946 * ixgbe_resume 3947 * 3948 * From D3 to D0 3949 ************************************************************************/ 3950 static bool 3951 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 3952 { 3953 struct adapter *adapter = device_private(dev); 3954 struct ifnet *ifp = adapter->ifp; 3955 struct ixgbe_hw *hw = &adapter->hw; 3956 u32 wus; 3957 3958 INIT_DEBUGOUT("ixgbe_resume: begin"); 3959 3960 IXGBE_CORE_LOCK(adapter); 3961 3962 /* Read & clear WUS register */ 3963 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 3964 if (wus) 3965 device_printf(dev, "Woken up by (WUS): %#010x\n", 3966 IXGBE_READ_REG(hw, IXGBE_WUS)); 3967 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3968 /* And clear WUFC until next low-power transition */ 3969 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3970 3971 /* 3972 * Required after D3->D0 transition; 3973 * will re-advertise all previous advertised speeds 3974 */ 3975 if (ifp->if_flags & IFF_UP) 3976 ixgbe_init_locked(adapter); 3977 3978 IXGBE_CORE_UNLOCK(adapter); 3979 3980 return true; 3981 } /* ixgbe_resume */ 3982 3983 /* 3984 * Set the various hardware offload abilities. 3985 * 3986 * This takes the ifnet's if_capenable flags (e.g. set by the user using 3987 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 3988 * mbuf offload flags the driver will understand. 3989 */ 3990 static void 3991 ixgbe_set_if_hwassist(struct adapter *adapter) 3992 { 3993 /* XXX */ 3994 } 3995 3996 /************************************************************************ 3997 * ixgbe_init_locked - Init entry point 3998 * 3999 * Used in two ways: It is used by the stack as an init 4000 * entry point in network interface structure. It is also 4001 * used by the driver as a hw/sw initialization routine to 4002 * get to a consistent state. 4003 * 4004 * return 0 on success, positive on failure 4005 ************************************************************************/ 4006 static void 4007 ixgbe_init_locked(struct adapter *adapter) 4008 { 4009 struct ifnet *ifp = adapter->ifp; 4010 device_t dev = adapter->dev; 4011 struct ixgbe_hw *hw = &adapter->hw; 4012 struct ix_queue *que; 4013 struct tx_ring *txr; 4014 struct rx_ring *rxr; 4015 u32 txdctl, mhadd; 4016 u32 rxdctl, rxctrl; 4017 u32 ctrl_ext; 4018 bool unsupported_sfp = false; 4019 int i, j, error; 4020 4021 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 4022 4023 KASSERT(mutex_owned(&adapter->core_mtx)); 4024 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 4025 4026 hw->need_unsupported_sfp_recovery = false; 4027 hw->adapter_stopped = FALSE; 4028 ixgbe_stop_adapter(hw); 4029 callout_stop(&adapter->timer); 4030 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 4031 callout_stop(&adapter->recovery_mode_timer); 4032 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 4033 que->disabled_count = 0; 4034 4035 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 4036 adapter->max_frame_size = 4037 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 4038 4039 /* Queue indices may change with IOV mode */ 4040 ixgbe_align_all_queue_indices(adapter); 4041 4042 /* reprogram the RAR[0] in case user changed it. */ 4043 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 4044 4045 /* Get the latest mac address, User can use a LAA */ 4046 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 4047 IXGBE_ETH_LENGTH_OF_ADDRESS); 4048 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 4049 hw->addr_ctrl.rar_used_count = 1; 4050 4051 /* Set hardware offload abilities from ifnet flags */ 4052 ixgbe_set_if_hwassist(adapter); 4053 4054 /* Prepare transmit descriptors and buffers */ 4055 if (ixgbe_setup_transmit_structures(adapter)) { 4056 device_printf(dev, "Could not setup transmit structures\n"); 4057 ixgbe_stop_locked(adapter); 4058 return; 4059 } 4060 4061 ixgbe_init_hw(hw); 4062 4063 ixgbe_initialize_iov(adapter); 4064 4065 ixgbe_initialize_transmit_units(adapter); 4066 4067 /* Setup Multicast table */ 4068 ixgbe_set_rxfilter(adapter); 4069 4070 /* Use fixed buffer size, even for jumbo frames */ 4071 adapter->rx_mbuf_sz = MCLBYTES; 4072 4073 /* Prepare receive descriptors and buffers */ 4074 error = ixgbe_setup_receive_structures(adapter); 4075 if (error) { 4076 device_printf(dev, 4077 "Could not setup receive structures (err = %d)\n", error); 4078 ixgbe_stop_locked(adapter); 4079 return; 4080 } 4081 4082 /* Configure RX settings */ 4083 ixgbe_initialize_receive_units(adapter); 4084 4085 /* Initialize variable holding task enqueue requests interrupts */ 4086 adapter->task_requests = 0; 4087 4088 /* Enable SDP & MSI-X interrupts based on adapter */ 4089 ixgbe_config_gpie(adapter); 4090 4091 /* Set MTU size */ 4092 if (ifp->if_mtu > ETHERMTU) { 4093 /* aka IXGBE_MAXFRS on 82599 and newer */ 4094 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 4095 mhadd &= ~IXGBE_MHADD_MFS_MASK; 4096 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 4097 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 4098 } 4099 4100 /* Now enable all the queues */ 4101 for (i = 0; i < adapter->num_queues; i++) { 4102 txr = &adapter->tx_rings[i]; 4103 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 4104 txdctl |= IXGBE_TXDCTL_ENABLE; 4105 /* Set WTHRESH to 8, burst writeback */ 4106 txdctl |= IXGBE_TX_WTHRESH << IXGBE_TXDCTL_WTHRESH_SHIFT; 4107 /* 4108 * When the internal queue falls below PTHRESH (32), 4109 * start prefetching as long as there are at least 4110 * HTHRESH (1) buffers ready. The values are taken 4111 * from the Intel linux driver 3.8.21. 4112 * Prefetching enables tx line rate even with 1 queue. 4113 */ 4114 txdctl |= (32 << 0) | (1 << 8); 4115 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 4116 } 4117 4118 for (i = 0; i < adapter->num_queues; i++) { 4119 rxr = &adapter->rx_rings[i]; 4120 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 4121 if (hw->mac.type == ixgbe_mac_82598EB) { 4122 /* 4123 * PTHRESH = 21 4124 * HTHRESH = 4 4125 * WTHRESH = 8 4126 */ 4127 rxdctl &= ~0x3FFFFF; 4128 rxdctl |= 0x080420; 4129 } 4130 rxdctl |= IXGBE_RXDCTL_ENABLE; 4131 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 4132 for (j = 0; j < 10; j++) { 4133 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 4134 IXGBE_RXDCTL_ENABLE) 4135 break; 4136 else 4137 msec_delay(1); 4138 } 4139 IXGBE_WRITE_BARRIER(hw); 4140 4141 /* 4142 * In netmap mode, we must preserve the buffers made 4143 * available to userspace before the if_init() 4144 * (this is true by default on the TX side, because 4145 * init makes all buffers available to userspace). 4146 * 4147 * netmap_reset() and the device specific routines 4148 * (e.g. ixgbe_setup_receive_rings()) map these 4149 * buffers at the end of the NIC ring, so here we 4150 * must set the RDT (tail) register to make sure 4151 * they are not overwritten. 4152 * 4153 * In this driver the NIC ring starts at RDH = 0, 4154 * RDT points to the last slot available for reception (?), 4155 * so RDT = num_rx_desc - 1 means the whole ring is available. 4156 */ 4157 #ifdef DEV_NETMAP 4158 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 4159 (ifp->if_capenable & IFCAP_NETMAP)) { 4160 struct netmap_adapter *na = NA(adapter->ifp); 4161 struct netmap_kring *kring = na->rx_rings[i]; 4162 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 4163 4164 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 4165 } else 4166 #endif /* DEV_NETMAP */ 4167 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), 4168 adapter->num_rx_desc - 1); 4169 } 4170 4171 /* Enable Receive engine */ 4172 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 4173 if (hw->mac.type == ixgbe_mac_82598EB) 4174 rxctrl |= IXGBE_RXCTRL_DMBYPS; 4175 rxctrl |= IXGBE_RXCTRL_RXEN; 4176 ixgbe_enable_rx_dma(hw, rxctrl); 4177 4178 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4179 atomic_store_relaxed(&adapter->timer_pending, 0); 4180 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 4181 callout_reset(&adapter->recovery_mode_timer, hz, 4182 ixgbe_recovery_mode_timer, adapter); 4183 4184 /* Set up MSI/MSI-X routing */ 4185 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4186 ixgbe_configure_ivars(adapter); 4187 /* Set up auto-mask */ 4188 if (hw->mac.type == ixgbe_mac_82598EB) 4189 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4190 else { 4191 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 4192 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 4193 } 4194 } else { /* Simple settings for Legacy/MSI */ 4195 ixgbe_set_ivar(adapter, 0, 0, 0); 4196 ixgbe_set_ivar(adapter, 0, 0, 1); 4197 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4198 } 4199 4200 ixgbe_init_fdir(adapter); 4201 4202 /* 4203 * Check on any SFP devices that 4204 * need to be kick-started 4205 */ 4206 if (hw->phy.type == ixgbe_phy_none) { 4207 error = hw->phy.ops.identify(hw); 4208 if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) 4209 unsupported_sfp = true; 4210 } else if (hw->phy.type == ixgbe_phy_sfp_unsupported) 4211 unsupported_sfp = true; 4212 4213 if (unsupported_sfp) 4214 device_printf(dev, 4215 "Unsupported SFP+ module type was detected.\n"); 4216 4217 /* Set moderation on the Link interrupt */ 4218 ixgbe_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 4219 4220 /* Enable EEE power saving */ 4221 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 4222 hw->mac.ops.setup_eee(hw, 4223 adapter->feat_en & IXGBE_FEATURE_EEE); 4224 4225 /* Enable power to the phy. */ 4226 if (!unsupported_sfp) { 4227 ixgbe_set_phy_power(hw, TRUE); 4228 4229 /* Config/Enable Link */ 4230 ixgbe_config_link(adapter); 4231 } 4232 4233 /* Hardware Packet Buffer & Flow Control setup */ 4234 ixgbe_config_delay_values(adapter); 4235 4236 /* Initialize the FC settings */ 4237 ixgbe_start_hw(hw); 4238 4239 /* Set up VLAN support and filter */ 4240 ixgbe_setup_vlan_hw_support(adapter); 4241 4242 /* Setup DMA Coalescing */ 4243 ixgbe_config_dmac(adapter); 4244 4245 /* OK to schedule workqueues. */ 4246 adapter->schedule_wqs_ok = true; 4247 4248 /* And now turn on interrupts */ 4249 ixgbe_enable_intr(adapter); 4250 4251 /* Enable the use of the MBX by the VF's */ 4252 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 4253 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 4254 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 4255 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 4256 } 4257 4258 /* Update saved flags. See ixgbe_ifflags_cb() */ 4259 adapter->if_flags = ifp->if_flags; 4260 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 4261 4262 /* Now inform the stack we're ready */ 4263 ifp->if_flags |= IFF_RUNNING; 4264 4265 return; 4266 } /* ixgbe_init_locked */ 4267 4268 /************************************************************************ 4269 * ixgbe_init 4270 ************************************************************************/ 4271 static int 4272 ixgbe_init(struct ifnet *ifp) 4273 { 4274 struct adapter *adapter = ifp->if_softc; 4275 4276 IXGBE_CORE_LOCK(adapter); 4277 ixgbe_init_locked(adapter); 4278 IXGBE_CORE_UNLOCK(adapter); 4279 4280 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 4281 } /* ixgbe_init */ 4282 4283 /************************************************************************ 4284 * ixgbe_set_ivar 4285 * 4286 * Setup the correct IVAR register for a particular MSI-X interrupt 4287 * (yes this is all very magic and confusing :) 4288 * - entry is the register array entry 4289 * - vector is the MSI-X vector for this queue 4290 * - type is RX/TX/MISC 4291 ************************************************************************/ 4292 static void 4293 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 4294 { 4295 struct ixgbe_hw *hw = &adapter->hw; 4296 u32 ivar, index; 4297 4298 vector |= IXGBE_IVAR_ALLOC_VAL; 4299 4300 switch (hw->mac.type) { 4301 case ixgbe_mac_82598EB: 4302 if (type == -1) 4303 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 4304 else 4305 entry += (type * 64); 4306 index = (entry >> 2) & 0x1F; 4307 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 4308 ivar &= ~(0xffUL << (8 * (entry & 0x3))); 4309 ivar |= ((u32)vector << (8 * (entry & 0x3))); 4310 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 4311 break; 4312 case ixgbe_mac_82599EB: 4313 case ixgbe_mac_X540: 4314 case ixgbe_mac_X550: 4315 case ixgbe_mac_X550EM_x: 4316 case ixgbe_mac_X550EM_a: 4317 if (type == -1) { /* MISC IVAR */ 4318 index = (entry & 1) * 8; 4319 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 4320 ivar &= ~(0xffUL << index); 4321 ivar |= ((u32)vector << index); 4322 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 4323 } else { /* RX/TX IVARS */ 4324 index = (16 * (entry & 1)) + (8 * type); 4325 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 4326 ivar &= ~(0xffUL << index); 4327 ivar |= ((u32)vector << index); 4328 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 4329 } 4330 break; 4331 default: 4332 break; 4333 } 4334 } /* ixgbe_set_ivar */ 4335 4336 /************************************************************************ 4337 * ixgbe_configure_ivars 4338 ************************************************************************/ 4339 static void 4340 ixgbe_configure_ivars(struct adapter *adapter) 4341 { 4342 struct ix_queue *que = adapter->queues; 4343 u32 newitr; 4344 4345 if (ixgbe_max_interrupt_rate > 0) 4346 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 4347 else { 4348 /* 4349 * Disable DMA coalescing if interrupt moderation is 4350 * disabled. 4351 */ 4352 adapter->dmac = 0; 4353 newitr = 0; 4354 } 4355 4356 for (int i = 0; i < adapter->num_queues; i++, que++) { 4357 struct rx_ring *rxr = &adapter->rx_rings[i]; 4358 struct tx_ring *txr = &adapter->tx_rings[i]; 4359 /* First the RX queue entry */ 4360 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 4361 /* ... and the TX */ 4362 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 4363 /* Set an Initial EITR value */ 4364 ixgbe_eitr_write(adapter, que->msix, newitr); 4365 /* 4366 * To eliminate influence of the previous state. 4367 * At this point, Tx/Rx interrupt handler 4368 * (ixgbe_msix_que()) cannot be called, so both 4369 * IXGBE_TX_LOCK and IXGBE_RX_LOCK are not required. 4370 */ 4371 que->eitr_setting = 0; 4372 } 4373 4374 /* For the Link interrupt */ 4375 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 4376 } /* ixgbe_configure_ivars */ 4377 4378 /************************************************************************ 4379 * ixgbe_config_gpie 4380 ************************************************************************/ 4381 static void 4382 ixgbe_config_gpie(struct adapter *adapter) 4383 { 4384 struct ixgbe_hw *hw = &adapter->hw; 4385 u32 gpie; 4386 4387 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 4388 4389 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4390 /* Enable Enhanced MSI-X mode */ 4391 gpie |= IXGBE_GPIE_MSIX_MODE 4392 | IXGBE_GPIE_EIAME 4393 | IXGBE_GPIE_PBA_SUPPORT 4394 | IXGBE_GPIE_OCD; 4395 } 4396 4397 /* Fan Failure Interrupt */ 4398 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4399 gpie |= IXGBE_SDP1_GPIEN; 4400 4401 /* Thermal Sensor Interrupt */ 4402 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) 4403 gpie |= IXGBE_SDP0_GPIEN_X540; 4404 4405 /* Link detection */ 4406 switch (hw->mac.type) { 4407 case ixgbe_mac_82599EB: 4408 gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN; 4409 break; 4410 case ixgbe_mac_X550EM_x: 4411 case ixgbe_mac_X550EM_a: 4412 gpie |= IXGBE_SDP0_GPIEN_X540; 4413 break; 4414 default: 4415 break; 4416 } 4417 4418 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 4419 4420 } /* ixgbe_config_gpie */ 4421 4422 /************************************************************************ 4423 * ixgbe_config_delay_values 4424 * 4425 * Requires adapter->max_frame_size to be set. 4426 ************************************************************************/ 4427 static void 4428 ixgbe_config_delay_values(struct adapter *adapter) 4429 { 4430 struct ixgbe_hw *hw = &adapter->hw; 4431 u32 rxpb, frame, size, tmp; 4432 4433 frame = adapter->max_frame_size; 4434 4435 /* Calculate High Water */ 4436 switch (hw->mac.type) { 4437 case ixgbe_mac_X540: 4438 case ixgbe_mac_X550: 4439 case ixgbe_mac_X550EM_x: 4440 case ixgbe_mac_X550EM_a: 4441 tmp = IXGBE_DV_X540(frame, frame); 4442 break; 4443 default: 4444 tmp = IXGBE_DV(frame, frame); 4445 break; 4446 } 4447 size = IXGBE_BT2KB(tmp); 4448 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 4449 hw->fc.high_water[0] = rxpb - size; 4450 4451 /* Now calculate Low Water */ 4452 switch (hw->mac.type) { 4453 case ixgbe_mac_X540: 4454 case ixgbe_mac_X550: 4455 case ixgbe_mac_X550EM_x: 4456 case ixgbe_mac_X550EM_a: 4457 tmp = IXGBE_LOW_DV_X540(frame); 4458 break; 4459 default: 4460 tmp = IXGBE_LOW_DV(frame); 4461 break; 4462 } 4463 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 4464 4465 hw->fc.pause_time = IXGBE_FC_PAUSE; 4466 hw->fc.send_xon = TRUE; 4467 } /* ixgbe_config_delay_values */ 4468 4469 /************************************************************************ 4470 * ixgbe_set_rxfilter - Multicast Update 4471 * 4472 * Called whenever multicast address list is updated. 4473 ************************************************************************/ 4474 static void 4475 ixgbe_set_rxfilter(struct adapter *adapter) 4476 { 4477 struct ixgbe_mc_addr *mta; 4478 struct ifnet *ifp = adapter->ifp; 4479 u8 *update_ptr; 4480 int mcnt = 0; 4481 u32 fctrl; 4482 struct ethercom *ec = &adapter->osdep.ec; 4483 struct ether_multi *enm; 4484 struct ether_multistep step; 4485 4486 KASSERT(mutex_owned(&adapter->core_mtx)); 4487 IOCTL_DEBUGOUT("ixgbe_set_rxfilter: begin"); 4488 4489 mta = adapter->mta; 4490 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 4491 4492 ETHER_LOCK(ec); 4493 ec->ec_flags &= ~ETHER_F_ALLMULTI; 4494 ETHER_FIRST_MULTI(step, ec, enm); 4495 while (enm != NULL) { 4496 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 4497 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 4498 ETHER_ADDR_LEN) != 0)) { 4499 ec->ec_flags |= ETHER_F_ALLMULTI; 4500 break; 4501 } 4502 bcopy(enm->enm_addrlo, 4503 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 4504 mta[mcnt].vmdq = adapter->pool; 4505 mcnt++; 4506 ETHER_NEXT_MULTI(step, enm); 4507 } 4508 4509 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 4510 if (ifp->if_flags & IFF_PROMISC) 4511 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4512 else if (ec->ec_flags & ETHER_F_ALLMULTI) { 4513 fctrl |= IXGBE_FCTRL_MPE; 4514 fctrl &= ~IXGBE_FCTRL_UPE; 4515 } else 4516 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4517 4518 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 4519 4520 /* Update multicast filter entries only when it's not ALLMULTI */ 4521 if ((ec->ec_flags & ETHER_F_ALLMULTI) == 0) { 4522 ETHER_UNLOCK(ec); 4523 update_ptr = (u8 *)mta; 4524 ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 4525 ixgbe_mc_array_itr, TRUE); 4526 } else 4527 ETHER_UNLOCK(ec); 4528 } /* ixgbe_set_rxfilter */ 4529 4530 /************************************************************************ 4531 * ixgbe_mc_array_itr 4532 * 4533 * An iterator function needed by the multicast shared code. 4534 * It feeds the shared code routine the addresses in the 4535 * array of ixgbe_set_rxfilter() one by one. 4536 ************************************************************************/ 4537 static u8 * 4538 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 4539 { 4540 struct ixgbe_mc_addr *mta; 4541 4542 mta = (struct ixgbe_mc_addr *)*update_ptr; 4543 *vmdq = mta->vmdq; 4544 4545 *update_ptr = (u8*)(mta + 1); 4546 4547 return (mta->addr); 4548 } /* ixgbe_mc_array_itr */ 4549 4550 /************************************************************************ 4551 * ixgbe_local_timer - Timer routine 4552 * 4553 * Checks for link status, updates statistics, 4554 * and runs the watchdog check. 4555 ************************************************************************/ 4556 static void 4557 ixgbe_local_timer(void *arg) 4558 { 4559 struct adapter *adapter = arg; 4560 4561 if (adapter->schedule_wqs_ok) { 4562 if (atomic_cas_uint(&adapter->timer_pending, 0, 1) == 0) 4563 workqueue_enqueue(adapter->timer_wq, 4564 &adapter->timer_wc, NULL); 4565 } 4566 } 4567 4568 static void 4569 ixgbe_handle_timer(struct work *wk, void *context) 4570 { 4571 struct adapter *adapter = context; 4572 struct ixgbe_hw *hw = &adapter->hw; 4573 device_t dev = adapter->dev; 4574 struct ix_queue *que = adapter->queues; 4575 u64 queues = 0; 4576 u64 v0, v1, v2, v3, v4, v5, v6, v7; 4577 int hung = 0; 4578 int i; 4579 4580 IXGBE_CORE_LOCK(adapter); 4581 4582 /* Check for pluggable optics */ 4583 if (ixgbe_is_sfp(hw)) { 4584 bool sched_mod_task = false; 4585 4586 if (hw->mac.type == ixgbe_mac_82598EB) { 4587 /* 4588 * On 82598EB, SFP+'s MOD_ABS pin is not connected to 4589 * any GPIO(SDP). So just schedule TASK_MOD. 4590 */ 4591 sched_mod_task = true; 4592 } else { 4593 bool was_full, is_full; 4594 4595 was_full = 4596 hw->phy.sfp_type != ixgbe_sfp_type_not_present; 4597 is_full = ixgbe_sfp_cage_full(hw); 4598 4599 /* Do probe if cage state changed */ 4600 if (was_full ^ is_full) 4601 sched_mod_task = true; 4602 } 4603 if (sched_mod_task) { 4604 mutex_enter(&adapter->admin_mtx); 4605 adapter->task_requests |= IXGBE_REQUEST_TASK_MOD_WOI; 4606 ixgbe_schedule_admin_tasklet(adapter); 4607 mutex_exit(&adapter->admin_mtx); 4608 } 4609 } 4610 4611 ixgbe_update_link_status(adapter); 4612 ixgbe_update_stats_counters(adapter); 4613 4614 /* Update some event counters */ 4615 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 4616 que = adapter->queues; 4617 for (i = 0; i < adapter->num_queues; i++, que++) { 4618 struct tx_ring *txr = que->txr; 4619 4620 v0 += txr->q_efbig_tx_dma_setup; 4621 v1 += txr->q_mbuf_defrag_failed; 4622 v2 += txr->q_efbig2_tx_dma_setup; 4623 v3 += txr->q_einval_tx_dma_setup; 4624 v4 += txr->q_other_tx_dma_setup; 4625 v5 += txr->q_eagain_tx_dma_setup; 4626 v6 += txr->q_enomem_tx_dma_setup; 4627 v7 += txr->q_tso_err; 4628 } 4629 adapter->efbig_tx_dma_setup.ev_count = v0; 4630 adapter->mbuf_defrag_failed.ev_count = v1; 4631 adapter->efbig2_tx_dma_setup.ev_count = v2; 4632 adapter->einval_tx_dma_setup.ev_count = v3; 4633 adapter->other_tx_dma_setup.ev_count = v4; 4634 adapter->eagain_tx_dma_setup.ev_count = v5; 4635 adapter->enomem_tx_dma_setup.ev_count = v6; 4636 adapter->tso_err.ev_count = v7; 4637 4638 /* 4639 * Check the TX queues status 4640 * - mark hung queues so we don't schedule on them 4641 * - watchdog only if all queues show hung 4642 */ 4643 que = adapter->queues; 4644 for (i = 0; i < adapter->num_queues; i++, que++) { 4645 /* Keep track of queues with work for soft irq */ 4646 if (que->txr->busy) 4647 queues |= 1ULL << que->me; 4648 /* 4649 * Each time txeof runs without cleaning, but there 4650 * are uncleaned descriptors it increments busy. If 4651 * we get to the MAX we declare it hung. 4652 */ 4653 if (que->busy == IXGBE_QUEUE_HUNG) { 4654 ++hung; 4655 /* Mark the queue as inactive */ 4656 adapter->active_queues &= ~(1ULL << que->me); 4657 continue; 4658 } else { 4659 /* Check if we've come back from hung */ 4660 if ((adapter->active_queues & (1ULL << que->me)) == 0) 4661 adapter->active_queues |= 1ULL << que->me; 4662 } 4663 if (que->busy >= IXGBE_MAX_TX_BUSY) { 4664 device_printf(dev, 4665 "Warning queue %d appears to be hung!\n", i); 4666 que->txr->busy = IXGBE_QUEUE_HUNG; 4667 ++hung; 4668 } 4669 } 4670 4671 /* Only truly watchdog if all queues show hung */ 4672 if (hung == adapter->num_queues) 4673 goto watchdog; 4674 #if 0 /* XXX Avoid unexpectedly disabling interrupt forever (PR#53294) */ 4675 else if (queues != 0) { /* Force an IRQ on queues with work */ 4676 que = adapter->queues; 4677 for (i = 0; i < adapter->num_queues; i++, que++) { 4678 mutex_enter(&que->dc_mtx); 4679 if (que->disabled_count == 0) 4680 ixgbe_rearm_queues(adapter, 4681 queues & ((u64)1 << i)); 4682 mutex_exit(&que->dc_mtx); 4683 } 4684 } 4685 #endif 4686 4687 atomic_store_relaxed(&adapter->timer_pending, 0); 4688 IXGBE_CORE_UNLOCK(adapter); 4689 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4690 return; 4691 4692 watchdog: 4693 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4694 adapter->ifp->if_flags &= ~IFF_RUNNING; 4695 adapter->watchdog_events.ev_count++; 4696 ixgbe_init_locked(adapter); 4697 IXGBE_CORE_UNLOCK(adapter); 4698 } /* ixgbe_handle_timer */ 4699 4700 /************************************************************************ 4701 * ixgbe_recovery_mode_timer - Recovery mode timer routine 4702 ************************************************************************/ 4703 static void 4704 ixgbe_recovery_mode_timer(void *arg) 4705 { 4706 struct adapter *adapter = arg; 4707 4708 if (__predict_true(adapter->osdep.detaching == false)) { 4709 if (atomic_cas_uint(&adapter->recovery_mode_timer_pending, 4710 0, 1) == 0) { 4711 workqueue_enqueue(adapter->recovery_mode_timer_wq, 4712 &adapter->recovery_mode_timer_wc, NULL); 4713 } 4714 } 4715 } 4716 4717 static void 4718 ixgbe_handle_recovery_mode_timer(struct work *wk, void *context) 4719 { 4720 struct adapter *adapter = context; 4721 struct ixgbe_hw *hw = &adapter->hw; 4722 4723 IXGBE_CORE_LOCK(adapter); 4724 if (ixgbe_fw_recovery_mode(hw)) { 4725 if (atomic_cas_uint(&adapter->recovery_mode, 0, 1)) { 4726 /* Firmware error detected, entering recovery mode */ 4727 device_printf(adapter->dev, "Firmware recovery mode detected. Limiting functionality. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n"); 4728 4729 if (hw->adapter_stopped == FALSE) 4730 ixgbe_stop_locked(adapter); 4731 } 4732 } else 4733 atomic_cas_uint(&adapter->recovery_mode, 1, 0); 4734 4735 atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0); 4736 callout_reset(&adapter->recovery_mode_timer, hz, 4737 ixgbe_recovery_mode_timer, adapter); 4738 IXGBE_CORE_UNLOCK(adapter); 4739 } /* ixgbe_handle_recovery_mode_timer */ 4740 4741 /************************************************************************ 4742 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4743 * bool int_en: true if it's called when the interrupt is enabled. 4744 ************************************************************************/ 4745 static void 4746 ixgbe_handle_mod(void *context, bool int_en) 4747 { 4748 struct adapter *adapter = context; 4749 struct ixgbe_hw *hw = &adapter->hw; 4750 device_t dev = adapter->dev; 4751 enum ixgbe_sfp_type last_sfp_type; 4752 u32 err; 4753 bool last_unsupported_sfp_recovery; 4754 4755 KASSERT(mutex_owned(&adapter->core_mtx)); 4756 4757 last_sfp_type = hw->phy.sfp_type; 4758 last_unsupported_sfp_recovery = hw->need_unsupported_sfp_recovery; 4759 ++adapter->mod_workev.ev_count; 4760 if (adapter->hw.need_crosstalk_fix) { 4761 if ((hw->mac.type != ixgbe_mac_82598EB) && 4762 !ixgbe_sfp_cage_full(hw)) 4763 goto out; 4764 } 4765 4766 err = hw->phy.ops.identify_sfp(hw); 4767 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4768 if (last_unsupported_sfp_recovery == false) 4769 device_printf(dev, 4770 "Unsupported SFP+ module type was detected.\n"); 4771 goto out; 4772 } 4773 4774 if (hw->need_unsupported_sfp_recovery) { 4775 device_printf(dev, "Recovering from unsupported SFP\n"); 4776 /* 4777 * We could recover the status by calling setup_sfp(), 4778 * setup_link() and some others. It's complex and might not 4779 * work correctly on some unknown cases. To avoid such type of 4780 * problem, call ixgbe_init_locked(). It's simple and safe 4781 * approach. 4782 */ 4783 ixgbe_init_locked(adapter); 4784 } else if ((hw->phy.sfp_type != ixgbe_sfp_type_not_present) && 4785 (hw->phy.sfp_type != last_sfp_type)) { 4786 /* A module is inserted and changed. */ 4787 4788 if (hw->mac.type == ixgbe_mac_82598EB) 4789 err = hw->phy.ops.reset(hw); 4790 else { 4791 err = hw->mac.ops.setup_sfp(hw); 4792 hw->phy.sfp_setup_needed = FALSE; 4793 } 4794 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4795 device_printf(dev, 4796 "Setup failure - unsupported SFP+ module type.\n"); 4797 goto out; 4798 } 4799 } 4800 4801 out: 4802 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4803 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4804 4805 /* Adjust media types shown in ifconfig */ 4806 IXGBE_CORE_UNLOCK(adapter); 4807 ifmedia_removeall(&adapter->media); 4808 ixgbe_add_media_types(adapter); 4809 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4810 IXGBE_CORE_LOCK(adapter); 4811 4812 /* 4813 * Don't schedule MSF event if the chip is 82598. 82598 doesn't support 4814 * MSF. At least, calling ixgbe_handle_msf on 82598 DA makes the link 4815 * flap because the function calls setup_link(). 4816 */ 4817 if (hw->mac.type != ixgbe_mac_82598EB) { 4818 mutex_enter(&adapter->admin_mtx); 4819 if (int_en) 4820 adapter->task_requests |= IXGBE_REQUEST_TASK_MSF; 4821 else 4822 adapter->task_requests |= IXGBE_REQUEST_TASK_MSF_WOI; 4823 mutex_exit(&adapter->admin_mtx); 4824 } 4825 4826 /* 4827 * Don't call ixgbe_schedule_admin_tasklet() because we are on 4828 * the workqueue now. 4829 */ 4830 } /* ixgbe_handle_mod */ 4831 4832 4833 /************************************************************************ 4834 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4835 ************************************************************************/ 4836 static void 4837 ixgbe_handle_msf(void *context) 4838 { 4839 struct adapter *adapter = context; 4840 struct ixgbe_hw *hw = &adapter->hw; 4841 u32 autoneg; 4842 bool negotiate; 4843 4844 KASSERT(mutex_owned(&adapter->core_mtx)); 4845 4846 ++adapter->msf_workev.ev_count; 4847 4848 autoneg = hw->phy.autoneg_advertised; 4849 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4850 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4851 if (hw->mac.ops.setup_link) 4852 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4853 } /* ixgbe_handle_msf */ 4854 4855 /************************************************************************ 4856 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4857 ************************************************************************/ 4858 static void 4859 ixgbe_handle_phy(void *context) 4860 { 4861 struct adapter *adapter = context; 4862 struct ixgbe_hw *hw = &adapter->hw; 4863 int error; 4864 4865 KASSERT(mutex_owned(&adapter->core_mtx)); 4866 4867 ++adapter->phy_workev.ev_count; 4868 error = hw->phy.ops.handle_lasi(hw); 4869 if (error == IXGBE_ERR_OVERTEMP) 4870 device_printf(adapter->dev, 4871 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4872 " PHY will downshift to lower power state!\n"); 4873 else if (error) 4874 device_printf(adapter->dev, 4875 "Error handling LASI interrupt: %d\n", error); 4876 } /* ixgbe_handle_phy */ 4877 4878 static void 4879 ixgbe_handle_admin(struct work *wk, void *context) 4880 { 4881 struct adapter *adapter = context; 4882 struct ifnet *ifp = adapter->ifp; 4883 struct ixgbe_hw *hw = &adapter->hw; 4884 u32 task_requests; 4885 u32 eims_enable = 0; 4886 4887 mutex_enter(&adapter->admin_mtx); 4888 adapter->admin_pending = 0; 4889 task_requests = adapter->task_requests; 4890 adapter->task_requests = 0; 4891 mutex_exit(&adapter->admin_mtx); 4892 4893 /* 4894 * Hold the IFNET_LOCK across this entire call. This will 4895 * prevent additional changes to adapter->phy_layer 4896 * and serialize calls to this tasklet. We cannot hold the 4897 * CORE_LOCK while calling into the ifmedia functions as 4898 * they call ifmedia_lock() and the lock is CORE_LOCK. 4899 */ 4900 IFNET_LOCK(ifp); 4901 IXGBE_CORE_LOCK(adapter); 4902 if ((task_requests & IXGBE_REQUEST_TASK_LSC) != 0) { 4903 ixgbe_handle_link(adapter); 4904 eims_enable |= IXGBE_EIMS_LSC; 4905 } 4906 if ((task_requests & IXGBE_REQUEST_TASK_MOD_WOI) != 0) { 4907 ixgbe_handle_mod(adapter, false); 4908 } 4909 if ((task_requests & IXGBE_REQUEST_TASK_MOD) != 0) { 4910 ixgbe_handle_mod(adapter, true); 4911 if (hw->mac.type >= ixgbe_mac_X540) 4912 eims_enable |= IXGBE_EICR_GPI_SDP0_X540; 4913 else 4914 eims_enable |= IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 4915 } 4916 if ((task_requests 4917 & (IXGBE_REQUEST_TASK_MSF_WOI | IXGBE_REQUEST_TASK_MSF)) != 0) { 4918 ixgbe_handle_msf(adapter); 4919 if (((task_requests & IXGBE_REQUEST_TASK_MSF) != 0) && 4920 (hw->mac.type == ixgbe_mac_82599EB)) 4921 eims_enable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 4922 } 4923 if ((task_requests & IXGBE_REQUEST_TASK_PHY) != 0) { 4924 ixgbe_handle_phy(adapter); 4925 eims_enable |= IXGBE_EICR_GPI_SDP0_X540; 4926 } 4927 if ((task_requests & IXGBE_REQUEST_TASK_FDIR) != 0) { 4928 ixgbe_reinit_fdir(adapter); 4929 eims_enable |= IXGBE_EIMS_FLOW_DIR; 4930 } 4931 #if 0 /* notyet */ 4932 if ((task_requests & IXGBE_REQUEST_TASK_MBX) != 0) { 4933 ixgbe_handle_mbx(adapter); 4934 eims_enable |= IXGBE_EIMS_MAILBOX; 4935 } 4936 #endif 4937 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_enable); 4938 4939 IXGBE_CORE_UNLOCK(adapter); 4940 IFNET_UNLOCK(ifp); 4941 } /* ixgbe_handle_admin */ 4942 4943 static void 4944 ixgbe_ifstop(struct ifnet *ifp, int disable) 4945 { 4946 struct adapter *adapter = ifp->if_softc; 4947 4948 IXGBE_CORE_LOCK(adapter); 4949 ixgbe_stop_locked(adapter); 4950 IXGBE_CORE_UNLOCK(adapter); 4951 4952 workqueue_wait(adapter->timer_wq, &adapter->timer_wc); 4953 atomic_store_relaxed(&adapter->timer_pending, 0); 4954 } 4955 4956 /************************************************************************ 4957 * ixgbe_stop_locked - Stop the hardware 4958 * 4959 * Disables all traffic on the adapter by issuing a 4960 * global reset on the MAC and deallocates TX/RX buffers. 4961 ************************************************************************/ 4962 static void 4963 ixgbe_stop_locked(void *arg) 4964 { 4965 struct ifnet *ifp; 4966 struct adapter *adapter = arg; 4967 struct ixgbe_hw *hw = &adapter->hw; 4968 4969 ifp = adapter->ifp; 4970 4971 KASSERT(mutex_owned(&adapter->core_mtx)); 4972 4973 INIT_DEBUGOUT("ixgbe_stop_locked: begin\n"); 4974 ixgbe_disable_intr(adapter); 4975 callout_stop(&adapter->timer); 4976 4977 /* Don't schedule workqueues. */ 4978 adapter->schedule_wqs_ok = false; 4979 4980 /* Let the stack know...*/ 4981 ifp->if_flags &= ~IFF_RUNNING; 4982 4983 ixgbe_reset_hw(hw); 4984 hw->adapter_stopped = FALSE; 4985 ixgbe_stop_adapter(hw); 4986 if (hw->mac.type == ixgbe_mac_82599EB) 4987 ixgbe_stop_mac_link_on_d3_82599(hw); 4988 /* Turn off the laser - noop with no optics */ 4989 ixgbe_disable_tx_laser(hw); 4990 4991 /* Update the stack */ 4992 adapter->link_up = FALSE; 4993 ixgbe_update_link_status(adapter); 4994 4995 /* reprogram the RAR[0] in case user changed it. */ 4996 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4997 4998 return; 4999 } /* ixgbe_stop_locked */ 5000 5001 /************************************************************************ 5002 * ixgbe_update_link_status - Update OS on link state 5003 * 5004 * Note: Only updates the OS on the cached link state. 5005 * The real check of the hardware only happens with 5006 * a link interrupt. 5007 ************************************************************************/ 5008 static void 5009 ixgbe_update_link_status(struct adapter *adapter) 5010 { 5011 struct ifnet *ifp = adapter->ifp; 5012 device_t dev = adapter->dev; 5013 struct ixgbe_hw *hw = &adapter->hw; 5014 5015 KASSERT(mutex_owned(&adapter->core_mtx)); 5016 5017 if (adapter->link_up) { 5018 if (adapter->link_active != LINK_STATE_UP) { 5019 /* 5020 * To eliminate influence of the previous state 5021 * in the same way as ixgbe_init_locked(). 5022 */ 5023 struct ix_queue *que = adapter->queues; 5024 for (int i = 0; i < adapter->num_queues; i++, que++) 5025 que->eitr_setting = 0; 5026 5027 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 5028 /* 5029 * Discard count for both MAC Local Fault and 5030 * Remote Fault because those registers are 5031 * valid only when the link speed is up and 5032 * 10Gbps. 5033 */ 5034 IXGBE_READ_REG(hw, IXGBE_MLFC); 5035 IXGBE_READ_REG(hw, IXGBE_MRFC); 5036 } 5037 5038 if (bootverbose) { 5039 const char *bpsmsg; 5040 5041 switch (adapter->link_speed) { 5042 case IXGBE_LINK_SPEED_10GB_FULL: 5043 bpsmsg = "10 Gbps"; 5044 break; 5045 case IXGBE_LINK_SPEED_5GB_FULL: 5046 bpsmsg = "5 Gbps"; 5047 break; 5048 case IXGBE_LINK_SPEED_2_5GB_FULL: 5049 bpsmsg = "2.5 Gbps"; 5050 break; 5051 case IXGBE_LINK_SPEED_1GB_FULL: 5052 bpsmsg = "1 Gbps"; 5053 break; 5054 case IXGBE_LINK_SPEED_100_FULL: 5055 bpsmsg = "100 Mbps"; 5056 break; 5057 case IXGBE_LINK_SPEED_10_FULL: 5058 bpsmsg = "10 Mbps"; 5059 break; 5060 default: 5061 bpsmsg = "unknown speed"; 5062 break; 5063 } 5064 device_printf(dev, "Link is up %s %s \n", 5065 bpsmsg, "Full Duplex"); 5066 } 5067 adapter->link_active = LINK_STATE_UP; 5068 /* Update any Flow Control changes */ 5069 ixgbe_fc_enable(&adapter->hw); 5070 /* Update DMA coalescing config */ 5071 ixgbe_config_dmac(adapter); 5072 if_link_state_change(ifp, LINK_STATE_UP); 5073 5074 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5075 ixgbe_ping_all_vfs(adapter); 5076 } 5077 } else { 5078 /* 5079 * Do it when link active changes to DOWN. i.e. 5080 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 5081 * b) LINK_STATE_UP -> LINK_STATE_DOWN 5082 */ 5083 if (adapter->link_active != LINK_STATE_DOWN) { 5084 if (bootverbose) 5085 device_printf(dev, "Link is Down\n"); 5086 if_link_state_change(ifp, LINK_STATE_DOWN); 5087 adapter->link_active = LINK_STATE_DOWN; 5088 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5089 ixgbe_ping_all_vfs(adapter); 5090 ixgbe_drain_all(adapter); 5091 } 5092 } 5093 } /* ixgbe_update_link_status */ 5094 5095 /************************************************************************ 5096 * ixgbe_config_dmac - Configure DMA Coalescing 5097 ************************************************************************/ 5098 static void 5099 ixgbe_config_dmac(struct adapter *adapter) 5100 { 5101 struct ixgbe_hw *hw = &adapter->hw; 5102 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 5103 5104 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 5105 return; 5106 5107 if (dcfg->watchdog_timer ^ adapter->dmac || 5108 dcfg->link_speed ^ adapter->link_speed) { 5109 dcfg->watchdog_timer = adapter->dmac; 5110 dcfg->fcoe_en = false; 5111 dcfg->link_speed = adapter->link_speed; 5112 dcfg->num_tcs = 1; 5113 5114 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 5115 dcfg->watchdog_timer, dcfg->link_speed); 5116 5117 hw->mac.ops.dmac_config(hw); 5118 } 5119 } /* ixgbe_config_dmac */ 5120 5121 /************************************************************************ 5122 * ixgbe_enable_intr 5123 ************************************************************************/ 5124 static void 5125 ixgbe_enable_intr(struct adapter *adapter) 5126 { 5127 struct ixgbe_hw *hw = &adapter->hw; 5128 struct ix_queue *que = adapter->queues; 5129 u32 mask, fwsm; 5130 5131 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 5132 5133 switch (adapter->hw.mac.type) { 5134 case ixgbe_mac_82599EB: 5135 mask |= IXGBE_EIMS_ECC; 5136 /* Temperature sensor on some adapters */ 5137 mask |= IXGBE_EIMS_GPI_SDP0; 5138 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 5139 mask |= IXGBE_EIMS_GPI_SDP1; 5140 mask |= IXGBE_EIMS_GPI_SDP2; 5141 break; 5142 case ixgbe_mac_X540: 5143 /* Detect if Thermal Sensor is enabled */ 5144 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 5145 if (fwsm & IXGBE_FWSM_TS_ENABLED) 5146 mask |= IXGBE_EIMS_TS; 5147 mask |= IXGBE_EIMS_ECC; 5148 break; 5149 case ixgbe_mac_X550: 5150 /* MAC thermal sensor is automatically enabled */ 5151 mask |= IXGBE_EIMS_TS; 5152 mask |= IXGBE_EIMS_ECC; 5153 break; 5154 case ixgbe_mac_X550EM_x: 5155 case ixgbe_mac_X550EM_a: 5156 /* Some devices use SDP0 for important information */ 5157 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 5158 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 5159 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 5160 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 5161 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 5162 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 5163 mask |= IXGBE_EICR_GPI_SDP0_X540; 5164 mask |= IXGBE_EIMS_ECC; 5165 break; 5166 default: 5167 break; 5168 } 5169 5170 /* Enable Fan Failure detection */ 5171 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 5172 mask |= IXGBE_EIMS_GPI_SDP1; 5173 /* Enable SR-IOV */ 5174 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5175 mask |= IXGBE_EIMS_MAILBOX; 5176 /* Enable Flow Director */ 5177 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 5178 mask |= IXGBE_EIMS_FLOW_DIR; 5179 5180 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 5181 5182 /* With MSI-X we use auto clear */ 5183 if (adapter->msix_mem) { 5184 /* 5185 * It's not required to set TCP_TIMER because we don't use 5186 * it. 5187 */ 5188 IXGBE_WRITE_REG(hw, IXGBE_EIAC, IXGBE_EIMS_RTX_QUEUE); 5189 } 5190 5191 /* 5192 * Now enable all queues, this is done separately to 5193 * allow for handling the extended (beyond 32) MSI-X 5194 * vectors that can be used by 82599 5195 */ 5196 for (int i = 0; i < adapter->num_queues; i++, que++) 5197 ixgbe_enable_queue(adapter, que->msix); 5198 5199 IXGBE_WRITE_FLUSH(hw); 5200 5201 } /* ixgbe_enable_intr */ 5202 5203 /************************************************************************ 5204 * ixgbe_disable_intr_internal 5205 ************************************************************************/ 5206 static void 5207 ixgbe_disable_intr_internal(struct adapter *adapter, bool nestok) 5208 { 5209 struct ix_queue *que = adapter->queues; 5210 5211 /* disable interrupts other than queues */ 5212 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 5213 5214 if (adapter->msix_mem) 5215 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 5216 5217 for (int i = 0; i < adapter->num_queues; i++, que++) 5218 ixgbe_disable_queue_internal(adapter, que->msix, nestok); 5219 5220 IXGBE_WRITE_FLUSH(&adapter->hw); 5221 5222 } /* ixgbe_do_disable_intr_internal */ 5223 5224 /************************************************************************ 5225 * ixgbe_disable_intr 5226 ************************************************************************/ 5227 static void 5228 ixgbe_disable_intr(struct adapter *adapter) 5229 { 5230 5231 ixgbe_disable_intr_internal(adapter, true); 5232 } /* ixgbe_disable_intr */ 5233 5234 /************************************************************************ 5235 * ixgbe_ensure_disabled_intr 5236 ************************************************************************/ 5237 void 5238 ixgbe_ensure_disabled_intr(struct adapter *adapter) 5239 { 5240 5241 ixgbe_disable_intr_internal(adapter, false); 5242 } /* ixgbe_ensure_disabled_intr */ 5243 5244 /************************************************************************ 5245 * ixgbe_legacy_irq - Legacy Interrupt Service routine 5246 ************************************************************************/ 5247 static int 5248 ixgbe_legacy_irq(void *arg) 5249 { 5250 struct ix_queue *que = arg; 5251 struct adapter *adapter = que->adapter; 5252 struct ixgbe_hw *hw = &adapter->hw; 5253 struct tx_ring *txr = adapter->tx_rings; 5254 u32 eicr; 5255 u32 eims_orig; 5256 u32 eims_enable = 0; 5257 u32 eims_disable = 0; 5258 5259 eims_orig = IXGBE_READ_REG(hw, IXGBE_EIMS); 5260 /* 5261 * Silicon errata #26 on 82598. Disable all interrupts before reading 5262 * EICR. 5263 */ 5264 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 5265 5266 /* Read and clear EICR */ 5267 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 5268 5269 adapter->stats.pf.legint.ev_count++; 5270 if (eicr == 0) { 5271 adapter->stats.pf.intzero.ev_count++; 5272 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_orig); 5273 return 0; 5274 } 5275 5276 /* Queue (0) intr */ 5277 if ((eicr & IXGBE_EIMC_RTX_QUEUE) != 0) { 5278 ++que->irqs.ev_count; 5279 5280 /* 5281 * The same as ixgbe_msix_que() about 5282 * "que->txrx_use_workqueue". 5283 */ 5284 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 5285 5286 IXGBE_TX_LOCK(txr); 5287 ixgbe_txeof(txr); 5288 #ifdef notyet 5289 if (!ixgbe_ring_empty(ifp, txr->br)) 5290 ixgbe_start_locked(ifp, txr); 5291 #endif 5292 IXGBE_TX_UNLOCK(txr); 5293 5294 que->req.ev_count++; 5295 ixgbe_sched_handle_que(adapter, que); 5296 /* Disable queue 0 interrupt */ 5297 eims_disable |= 1UL << 0; 5298 5299 } else 5300 eims_enable |= IXGBE_EIMC_RTX_QUEUE; 5301 5302 ixgbe_intr_admin_common(adapter, eicr, &eims_disable); 5303 5304 /* Re-enable some interrupts */ 5305 IXGBE_WRITE_REG(hw, IXGBE_EIMS, 5306 (eims_orig & ~eims_disable) | eims_enable); 5307 5308 return 1; 5309 } /* ixgbe_legacy_irq */ 5310 5311 /************************************************************************ 5312 * ixgbe_free_pciintr_resources 5313 ************************************************************************/ 5314 static void 5315 ixgbe_free_pciintr_resources(struct adapter *adapter) 5316 { 5317 struct ix_queue *que = adapter->queues; 5318 int rid; 5319 5320 /* 5321 * Release all msix queue resources: 5322 */ 5323 for (int i = 0; i < adapter->num_queues; i++, que++) { 5324 if (que->res != NULL) { 5325 pci_intr_disestablish(adapter->osdep.pc, 5326 adapter->osdep.ihs[i]); 5327 adapter->osdep.ihs[i] = NULL; 5328 } 5329 } 5330 5331 /* Clean the Legacy or Link interrupt last */ 5332 if (adapter->vector) /* we are doing MSIX */ 5333 rid = adapter->vector; 5334 else 5335 rid = 0; 5336 5337 if (adapter->osdep.ihs[rid] != NULL) { 5338 pci_intr_disestablish(adapter->osdep.pc, 5339 adapter->osdep.ihs[rid]); 5340 adapter->osdep.ihs[rid] = NULL; 5341 } 5342 5343 if (adapter->osdep.intrs != NULL) { 5344 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 5345 adapter->osdep.nintrs); 5346 adapter->osdep.intrs = NULL; 5347 } 5348 } /* ixgbe_free_pciintr_resources */ 5349 5350 /************************************************************************ 5351 * ixgbe_free_pci_resources 5352 ************************************************************************/ 5353 static void 5354 ixgbe_free_pci_resources(struct adapter *adapter) 5355 { 5356 5357 ixgbe_free_pciintr_resources(adapter); 5358 5359 if (adapter->osdep.mem_size != 0) { 5360 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 5361 adapter->osdep.mem_bus_space_handle, 5362 adapter->osdep.mem_size); 5363 } 5364 5365 } /* ixgbe_free_pci_resources */ 5366 5367 /************************************************************************ 5368 * ixgbe_set_sysctl_value 5369 ************************************************************************/ 5370 static void 5371 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 5372 const char *description, int *limit, int value) 5373 { 5374 device_t dev = adapter->dev; 5375 struct sysctllog **log; 5376 const struct sysctlnode *rnode, *cnode; 5377 5378 /* 5379 * It's not required to check recovery mode because this function never 5380 * touches hardware. 5381 */ 5382 5383 log = &adapter->sysctllog; 5384 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 5385 aprint_error_dev(dev, "could not create sysctl root\n"); 5386 return; 5387 } 5388 if (sysctl_createv(log, 0, &rnode, &cnode, 5389 CTLFLAG_READWRITE, CTLTYPE_INT, 5390 name, SYSCTL_DESCR(description), 5391 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 5392 aprint_error_dev(dev, "could not create sysctl\n"); 5393 *limit = value; 5394 } /* ixgbe_set_sysctl_value */ 5395 5396 /************************************************************************ 5397 * ixgbe_sysctl_flowcntl 5398 * 5399 * SYSCTL wrapper around setting Flow Control 5400 ************************************************************************/ 5401 static int 5402 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 5403 { 5404 struct sysctlnode node = *rnode; 5405 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5406 int error, fc; 5407 5408 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5409 return (EPERM); 5410 5411 fc = adapter->hw.fc.current_mode; 5412 node.sysctl_data = &fc; 5413 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5414 if (error != 0 || newp == NULL) 5415 return error; 5416 5417 /* Don't bother if it's not changed */ 5418 if (fc == adapter->hw.fc.current_mode) 5419 return (0); 5420 5421 return ixgbe_set_flowcntl(adapter, fc); 5422 } /* ixgbe_sysctl_flowcntl */ 5423 5424 /************************************************************************ 5425 * ixgbe_set_flowcntl - Set flow control 5426 * 5427 * Flow control values: 5428 * 0 - off 5429 * 1 - rx pause 5430 * 2 - tx pause 5431 * 3 - full 5432 ************************************************************************/ 5433 static int 5434 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 5435 { 5436 switch (fc) { 5437 case ixgbe_fc_rx_pause: 5438 case ixgbe_fc_tx_pause: 5439 case ixgbe_fc_full: 5440 adapter->hw.fc.requested_mode = fc; 5441 if (adapter->num_queues > 1) 5442 ixgbe_disable_rx_drop(adapter); 5443 break; 5444 case ixgbe_fc_none: 5445 adapter->hw.fc.requested_mode = ixgbe_fc_none; 5446 if (adapter->num_queues > 1) 5447 ixgbe_enable_rx_drop(adapter); 5448 break; 5449 default: 5450 return (EINVAL); 5451 } 5452 5453 #if 0 /* XXX NetBSD */ 5454 /* Don't autoneg if forcing a value */ 5455 adapter->hw.fc.disable_fc_autoneg = TRUE; 5456 #endif 5457 ixgbe_fc_enable(&adapter->hw); 5458 5459 return (0); 5460 } /* ixgbe_set_flowcntl */ 5461 5462 /************************************************************************ 5463 * ixgbe_enable_rx_drop 5464 * 5465 * Enable the hardware to drop packets when the buffer is 5466 * full. This is useful with multiqueue, so that no single 5467 * queue being full stalls the entire RX engine. We only 5468 * enable this when Multiqueue is enabled AND Flow Control 5469 * is disabled. 5470 ************************************************************************/ 5471 static void 5472 ixgbe_enable_rx_drop(struct adapter *adapter) 5473 { 5474 struct ixgbe_hw *hw = &adapter->hw; 5475 struct rx_ring *rxr; 5476 u32 srrctl; 5477 5478 for (int i = 0; i < adapter->num_queues; i++) { 5479 rxr = &adapter->rx_rings[i]; 5480 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5481 srrctl |= IXGBE_SRRCTL_DROP_EN; 5482 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5483 } 5484 5485 /* enable drop for each vf */ 5486 for (int i = 0; i < adapter->num_vfs; i++) { 5487 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5488 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 5489 IXGBE_QDE_ENABLE)); 5490 } 5491 } /* ixgbe_enable_rx_drop */ 5492 5493 /************************************************************************ 5494 * ixgbe_disable_rx_drop 5495 ************************************************************************/ 5496 static void 5497 ixgbe_disable_rx_drop(struct adapter *adapter) 5498 { 5499 struct ixgbe_hw *hw = &adapter->hw; 5500 struct rx_ring *rxr; 5501 u32 srrctl; 5502 5503 for (int i = 0; i < adapter->num_queues; i++) { 5504 rxr = &adapter->rx_rings[i]; 5505 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5506 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 5507 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5508 } 5509 5510 /* disable drop for each vf */ 5511 for (int i = 0; i < adapter->num_vfs; i++) { 5512 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5513 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 5514 } 5515 } /* ixgbe_disable_rx_drop */ 5516 5517 /************************************************************************ 5518 * ixgbe_sysctl_advertise 5519 * 5520 * SYSCTL wrapper around setting advertised speed 5521 ************************************************************************/ 5522 static int 5523 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 5524 { 5525 struct sysctlnode node = *rnode; 5526 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5527 int error = 0, advertise; 5528 5529 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5530 return (EPERM); 5531 5532 advertise = adapter->advertise; 5533 node.sysctl_data = &advertise; 5534 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5535 if (error != 0 || newp == NULL) 5536 return error; 5537 5538 return ixgbe_set_advertise(adapter, advertise); 5539 } /* ixgbe_sysctl_advertise */ 5540 5541 /************************************************************************ 5542 * ixgbe_set_advertise - Control advertised link speed 5543 * 5544 * Flags: 5545 * 0x00 - Default (all capable link speed) 5546 * 0x01 - advertise 100 Mb 5547 * 0x02 - advertise 1G 5548 * 0x04 - advertise 10G 5549 * 0x08 - advertise 10 Mb 5550 * 0x10 - advertise 2.5G 5551 * 0x20 - advertise 5G 5552 ************************************************************************/ 5553 static int 5554 ixgbe_set_advertise(struct adapter *adapter, int advertise) 5555 { 5556 device_t dev; 5557 struct ixgbe_hw *hw; 5558 ixgbe_link_speed speed = 0; 5559 ixgbe_link_speed link_caps = 0; 5560 s32 err = IXGBE_NOT_IMPLEMENTED; 5561 bool negotiate = FALSE; 5562 5563 /* Checks to validate new value */ 5564 if (adapter->advertise == advertise) /* no change */ 5565 return (0); 5566 5567 dev = adapter->dev; 5568 hw = &adapter->hw; 5569 5570 /* No speed changes for backplane media */ 5571 if (hw->phy.media_type == ixgbe_media_type_backplane) 5572 return (ENODEV); 5573 5574 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5575 (hw->phy.multispeed_fiber))) { 5576 device_printf(dev, 5577 "Advertised speed can only be set on copper or " 5578 "multispeed fiber media types.\n"); 5579 return (EINVAL); 5580 } 5581 5582 if (advertise < 0x0 || advertise > 0x3f) { 5583 device_printf(dev, "Invalid advertised speed; valid modes are 0x0 through 0x3f\n"); 5584 return (EINVAL); 5585 } 5586 5587 if (hw->mac.ops.get_link_capabilities) { 5588 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5589 &negotiate); 5590 if (err != IXGBE_SUCCESS) { 5591 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5592 return (ENODEV); 5593 } 5594 } 5595 5596 /* Set new value and report new advertised mode */ 5597 if (advertise & 0x1) { 5598 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5599 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5600 return (EINVAL); 5601 } 5602 speed |= IXGBE_LINK_SPEED_100_FULL; 5603 } 5604 if (advertise & 0x2) { 5605 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5606 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5607 return (EINVAL); 5608 } 5609 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5610 } 5611 if (advertise & 0x4) { 5612 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5613 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5614 return (EINVAL); 5615 } 5616 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5617 } 5618 if (advertise & 0x8) { 5619 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5620 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5621 return (EINVAL); 5622 } 5623 speed |= IXGBE_LINK_SPEED_10_FULL; 5624 } 5625 if (advertise & 0x10) { 5626 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5627 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5628 return (EINVAL); 5629 } 5630 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5631 } 5632 if (advertise & 0x20) { 5633 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5634 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5635 return (EINVAL); 5636 } 5637 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5638 } 5639 if (advertise == 0) 5640 speed = link_caps; /* All capable link speed */ 5641 5642 hw->mac.autotry_restart = TRUE; 5643 hw->mac.ops.setup_link(hw, speed, TRUE); 5644 adapter->advertise = advertise; 5645 5646 return (0); 5647 } /* ixgbe_set_advertise */ 5648 5649 /************************************************************************ 5650 * ixgbe_get_advertise - Get current advertised speed settings 5651 * 5652 * Formatted for sysctl usage. 5653 * Flags: 5654 * 0x01 - advertise 100 Mb 5655 * 0x02 - advertise 1G 5656 * 0x04 - advertise 10G 5657 * 0x08 - advertise 10 Mb (yes, Mb) 5658 * 0x10 - advertise 2.5G 5659 * 0x20 - advertise 5G 5660 ************************************************************************/ 5661 static int 5662 ixgbe_get_advertise(struct adapter *adapter) 5663 { 5664 struct ixgbe_hw *hw = &adapter->hw; 5665 int speed; 5666 ixgbe_link_speed link_caps = 0; 5667 s32 err; 5668 bool negotiate = FALSE; 5669 5670 /* 5671 * Advertised speed means nothing unless it's copper or 5672 * multi-speed fiber 5673 */ 5674 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5675 !(hw->phy.multispeed_fiber)) 5676 return (0); 5677 5678 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5679 if (err != IXGBE_SUCCESS) 5680 return (0); 5681 5682 speed = 5683 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5684 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5685 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5686 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5687 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5688 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5689 5690 return speed; 5691 } /* ixgbe_get_advertise */ 5692 5693 /************************************************************************ 5694 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5695 * 5696 * Control values: 5697 * 0/1 - off / on (use default value of 1000) 5698 * 5699 * Legal timer values are: 5700 * 50,100,250,500,1000,2000,5000,10000 5701 * 5702 * Turning off interrupt moderation will also turn this off. 5703 ************************************************************************/ 5704 static int 5705 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5706 { 5707 struct sysctlnode node = *rnode; 5708 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5709 struct ifnet *ifp = adapter->ifp; 5710 int error; 5711 int newval; 5712 5713 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5714 return (EPERM); 5715 5716 newval = adapter->dmac; 5717 node.sysctl_data = &newval; 5718 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5719 if ((error) || (newp == NULL)) 5720 return (error); 5721 5722 switch (newval) { 5723 case 0: 5724 /* Disabled */ 5725 adapter->dmac = 0; 5726 break; 5727 case 1: 5728 /* Enable and use default */ 5729 adapter->dmac = 1000; 5730 break; 5731 case 50: 5732 case 100: 5733 case 250: 5734 case 500: 5735 case 1000: 5736 case 2000: 5737 case 5000: 5738 case 10000: 5739 /* Legal values - allow */ 5740 adapter->dmac = newval; 5741 break; 5742 default: 5743 /* Do nothing, illegal value */ 5744 return (EINVAL); 5745 } 5746 5747 /* Re-initialize hardware if it's already running */ 5748 if (ifp->if_flags & IFF_RUNNING) 5749 ifp->if_init(ifp); 5750 5751 return (0); 5752 } 5753 5754 #ifdef IXGBE_DEBUG 5755 /************************************************************************ 5756 * ixgbe_sysctl_power_state 5757 * 5758 * Sysctl to test power states 5759 * Values: 5760 * 0 - set device to D0 5761 * 3 - set device to D3 5762 * (none) - get current device power state 5763 ************************************************************************/ 5764 static int 5765 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5766 { 5767 #ifdef notyet 5768 struct sysctlnode node = *rnode; 5769 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5770 device_t dev = adapter->dev; 5771 int curr_ps, new_ps, error = 0; 5772 5773 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5774 return (EPERM); 5775 5776 curr_ps = new_ps = pci_get_powerstate(dev); 5777 5778 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5779 if ((error) || (req->newp == NULL)) 5780 return (error); 5781 5782 if (new_ps == curr_ps) 5783 return (0); 5784 5785 if (new_ps == 3 && curr_ps == 0) 5786 error = DEVICE_SUSPEND(dev); 5787 else if (new_ps == 0 && curr_ps == 3) 5788 error = DEVICE_RESUME(dev); 5789 else 5790 return (EINVAL); 5791 5792 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5793 5794 return (error); 5795 #else 5796 return 0; 5797 #endif 5798 } /* ixgbe_sysctl_power_state */ 5799 #endif 5800 5801 /************************************************************************ 5802 * ixgbe_sysctl_wol_enable 5803 * 5804 * Sysctl to enable/disable the WoL capability, 5805 * if supported by the adapter. 5806 * 5807 * Values: 5808 * 0 - disabled 5809 * 1 - enabled 5810 ************************************************************************/ 5811 static int 5812 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5813 { 5814 struct sysctlnode node = *rnode; 5815 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5816 struct ixgbe_hw *hw = &adapter->hw; 5817 bool new_wol_enabled; 5818 int error = 0; 5819 5820 /* 5821 * It's not required to check recovery mode because this function never 5822 * touches hardware. 5823 */ 5824 new_wol_enabled = hw->wol_enabled; 5825 node.sysctl_data = &new_wol_enabled; 5826 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5827 if ((error) || (newp == NULL)) 5828 return (error); 5829 if (new_wol_enabled == hw->wol_enabled) 5830 return (0); 5831 5832 if (new_wol_enabled && !adapter->wol_support) 5833 return (ENODEV); 5834 else 5835 hw->wol_enabled = new_wol_enabled; 5836 5837 return (0); 5838 } /* ixgbe_sysctl_wol_enable */ 5839 5840 /************************************************************************ 5841 * ixgbe_sysctl_wufc - Wake Up Filter Control 5842 * 5843 * Sysctl to enable/disable the types of packets that the 5844 * adapter will wake up on upon receipt. 5845 * Flags: 5846 * 0x1 - Link Status Change 5847 * 0x2 - Magic Packet 5848 * 0x4 - Direct Exact 5849 * 0x8 - Directed Multicast 5850 * 0x10 - Broadcast 5851 * 0x20 - ARP/IPv4 Request Packet 5852 * 0x40 - Direct IPv4 Packet 5853 * 0x80 - Direct IPv6 Packet 5854 * 5855 * Settings not listed above will cause the sysctl to return an error. 5856 ************************************************************************/ 5857 static int 5858 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5859 { 5860 struct sysctlnode node = *rnode; 5861 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5862 int error = 0; 5863 u32 new_wufc; 5864 5865 /* 5866 * It's not required to check recovery mode because this function never 5867 * touches hardware. 5868 */ 5869 new_wufc = adapter->wufc; 5870 node.sysctl_data = &new_wufc; 5871 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5872 if ((error) || (newp == NULL)) 5873 return (error); 5874 if (new_wufc == adapter->wufc) 5875 return (0); 5876 5877 if (new_wufc & 0xffffff00) 5878 return (EINVAL); 5879 5880 new_wufc &= 0xff; 5881 new_wufc |= (0xffffff & adapter->wufc); 5882 adapter->wufc = new_wufc; 5883 5884 return (0); 5885 } /* ixgbe_sysctl_wufc */ 5886 5887 #ifdef IXGBE_DEBUG 5888 /************************************************************************ 5889 * ixgbe_sysctl_print_rss_config 5890 ************************************************************************/ 5891 static int 5892 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5893 { 5894 #ifdef notyet 5895 struct sysctlnode node = *rnode; 5896 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5897 struct ixgbe_hw *hw = &adapter->hw; 5898 device_t dev = adapter->dev; 5899 struct sbuf *buf; 5900 int error = 0, reta_size; 5901 u32 reg; 5902 5903 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5904 return (EPERM); 5905 5906 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5907 if (!buf) { 5908 device_printf(dev, "Could not allocate sbuf for output.\n"); 5909 return (ENOMEM); 5910 } 5911 5912 // TODO: use sbufs to make a string to print out 5913 /* Set multiplier for RETA setup and table size based on MAC */ 5914 switch (adapter->hw.mac.type) { 5915 case ixgbe_mac_X550: 5916 case ixgbe_mac_X550EM_x: 5917 case ixgbe_mac_X550EM_a: 5918 reta_size = 128; 5919 break; 5920 default: 5921 reta_size = 32; 5922 break; 5923 } 5924 5925 /* Print out the redirection table */ 5926 sbuf_cat(buf, "\n"); 5927 for (int i = 0; i < reta_size; i++) { 5928 if (i < 32) { 5929 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5930 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5931 } else { 5932 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5933 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5934 } 5935 } 5936 5937 // TODO: print more config 5938 5939 error = sbuf_finish(buf); 5940 if (error) 5941 device_printf(dev, "Error finishing sbuf: %d\n", error); 5942 5943 sbuf_delete(buf); 5944 #endif 5945 return (0); 5946 } /* ixgbe_sysctl_print_rss_config */ 5947 #endif /* IXGBE_DEBUG */ 5948 5949 /************************************************************************ 5950 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5951 * 5952 * For X552/X557-AT devices using an external PHY 5953 ************************************************************************/ 5954 static int 5955 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5956 { 5957 struct sysctlnode node = *rnode; 5958 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5959 struct ixgbe_hw *hw = &adapter->hw; 5960 int val; 5961 u16 reg; 5962 int error; 5963 5964 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5965 return (EPERM); 5966 5967 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5968 device_printf(adapter->dev, 5969 "Device has no supported external thermal sensor.\n"); 5970 return (ENODEV); 5971 } 5972 5973 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5974 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5975 device_printf(adapter->dev, 5976 "Error reading from PHY's current temperature register\n"); 5977 return (EAGAIN); 5978 } 5979 5980 node.sysctl_data = &val; 5981 5982 /* Shift temp for output */ 5983 val = reg >> 8; 5984 5985 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5986 if ((error) || (newp == NULL)) 5987 return (error); 5988 5989 return (0); 5990 } /* ixgbe_sysctl_phy_temp */ 5991 5992 /************************************************************************ 5993 * ixgbe_sysctl_phy_overtemp_occurred 5994 * 5995 * Reports (directly from the PHY) whether the current PHY 5996 * temperature is over the overtemp threshold. 5997 ************************************************************************/ 5998 static int 5999 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 6000 { 6001 struct sysctlnode node = *rnode; 6002 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6003 struct ixgbe_hw *hw = &adapter->hw; 6004 int val, error; 6005 u16 reg; 6006 6007 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6008 return (EPERM); 6009 6010 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 6011 device_printf(adapter->dev, 6012 "Device has no supported external thermal sensor.\n"); 6013 return (ENODEV); 6014 } 6015 6016 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 6017 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 6018 device_printf(adapter->dev, 6019 "Error reading from PHY's temperature status register\n"); 6020 return (EAGAIN); 6021 } 6022 6023 node.sysctl_data = &val; 6024 6025 /* Get occurrence bit */ 6026 val = !!(reg & 0x4000); 6027 6028 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6029 if ((error) || (newp == NULL)) 6030 return (error); 6031 6032 return (0); 6033 } /* ixgbe_sysctl_phy_overtemp_occurred */ 6034 6035 /************************************************************************ 6036 * ixgbe_sysctl_eee_state 6037 * 6038 * Sysctl to set EEE power saving feature 6039 * Values: 6040 * 0 - disable EEE 6041 * 1 - enable EEE 6042 * (none) - get current device EEE state 6043 ************************************************************************/ 6044 static int 6045 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 6046 { 6047 struct sysctlnode node = *rnode; 6048 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6049 struct ifnet *ifp = adapter->ifp; 6050 device_t dev = adapter->dev; 6051 int curr_eee, new_eee, error = 0; 6052 s32 retval; 6053 6054 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6055 return (EPERM); 6056 6057 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 6058 node.sysctl_data = &new_eee; 6059 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6060 if ((error) || (newp == NULL)) 6061 return (error); 6062 6063 /* Nothing to do */ 6064 if (new_eee == curr_eee) 6065 return (0); 6066 6067 /* Not supported */ 6068 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 6069 return (EINVAL); 6070 6071 /* Bounds checking */ 6072 if ((new_eee < 0) || (new_eee > 1)) 6073 return (EINVAL); 6074 6075 retval = ixgbe_setup_eee(&adapter->hw, new_eee); 6076 if (retval) { 6077 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 6078 return (EINVAL); 6079 } 6080 6081 /* Restart auto-neg */ 6082 ifp->if_init(ifp); 6083 6084 device_printf(dev, "New EEE state: %d\n", new_eee); 6085 6086 /* Cache new value */ 6087 if (new_eee) 6088 adapter->feat_en |= IXGBE_FEATURE_EEE; 6089 else 6090 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 6091 6092 return (error); 6093 } /* ixgbe_sysctl_eee_state */ 6094 6095 #define PRINTQS(adapter, regname) \ 6096 do { \ 6097 struct ixgbe_hw *_hw = &(adapter)->hw; \ 6098 int _i; \ 6099 \ 6100 printf("%s: %s", device_xname((adapter)->dev), #regname); \ 6101 for (_i = 0; _i < (adapter)->num_queues; _i++) { \ 6102 printf((_i == 0) ? "\t" : " "); \ 6103 printf("%08x", IXGBE_READ_REG(_hw, \ 6104 IXGBE_##regname(_i))); \ 6105 } \ 6106 printf("\n"); \ 6107 } while (0) 6108 6109 /************************************************************************ 6110 * ixgbe_print_debug_info 6111 * 6112 * Called only when em_display_debug_stats is enabled. 6113 * Provides a way to take a look at important statistics 6114 * maintained by the driver and hardware. 6115 ************************************************************************/ 6116 static void 6117 ixgbe_print_debug_info(struct adapter *adapter) 6118 { 6119 device_t dev = adapter->dev; 6120 struct ixgbe_hw *hw = &adapter->hw; 6121 int table_size; 6122 int i; 6123 6124 switch (adapter->hw.mac.type) { 6125 case ixgbe_mac_X550: 6126 case ixgbe_mac_X550EM_x: 6127 case ixgbe_mac_X550EM_a: 6128 table_size = 128; 6129 break; 6130 default: 6131 table_size = 32; 6132 break; 6133 } 6134 6135 device_printf(dev, "[E]RETA:\n"); 6136 for (i = 0; i < table_size; i++) { 6137 if (i < 32) 6138 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 6139 IXGBE_RETA(i))); 6140 else 6141 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 6142 IXGBE_ERETA(i - 32))); 6143 } 6144 6145 device_printf(dev, "queue:"); 6146 for (i = 0; i < adapter->num_queues; i++) { 6147 printf((i == 0) ? "\t" : " "); 6148 printf("%8d", i); 6149 } 6150 printf("\n"); 6151 PRINTQS(adapter, RDBAL); 6152 PRINTQS(adapter, RDBAH); 6153 PRINTQS(adapter, RDLEN); 6154 PRINTQS(adapter, SRRCTL); 6155 PRINTQS(adapter, RDH); 6156 PRINTQS(adapter, RDT); 6157 PRINTQS(adapter, RXDCTL); 6158 6159 device_printf(dev, "RQSMR:"); 6160 for (i = 0; i < adapter->num_queues / 4; i++) { 6161 printf((i == 0) ? "\t" : " "); 6162 printf("%08x", IXGBE_READ_REG(hw, IXGBE_RQSMR(i))); 6163 } 6164 printf("\n"); 6165 6166 device_printf(dev, "disabled_count:"); 6167 for (i = 0; i < adapter->num_queues; i++) { 6168 printf((i == 0) ? "\t" : " "); 6169 printf("%8d", adapter->queues[i].disabled_count); 6170 } 6171 printf("\n"); 6172 6173 device_printf(dev, "EIMS:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIMS)); 6174 if (hw->mac.type != ixgbe_mac_82598EB) { 6175 device_printf(dev, "EIMS_EX(0):\t%08x\n", 6176 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(0))); 6177 device_printf(dev, "EIMS_EX(1):\t%08x\n", 6178 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(1))); 6179 } 6180 device_printf(dev, "EIAM:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIAM)); 6181 device_printf(dev, "EIAC:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIAC)); 6182 } /* ixgbe_print_debug_info */ 6183 6184 /************************************************************************ 6185 * ixgbe_sysctl_debug 6186 ************************************************************************/ 6187 static int 6188 ixgbe_sysctl_debug(SYSCTLFN_ARGS) 6189 { 6190 struct sysctlnode node = *rnode; 6191 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6192 int error, result = 0; 6193 6194 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6195 return (EPERM); 6196 6197 node.sysctl_data = &result; 6198 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6199 6200 if (error || newp == NULL) 6201 return error; 6202 6203 if (result == 1) 6204 ixgbe_print_debug_info(adapter); 6205 6206 return 0; 6207 } /* ixgbe_sysctl_debug */ 6208 6209 /************************************************************************ 6210 * ixgbe_sysctl_rx_copy_len 6211 ************************************************************************/ 6212 static int 6213 ixgbe_sysctl_rx_copy_len(SYSCTLFN_ARGS) 6214 { 6215 struct sysctlnode node = *rnode; 6216 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6217 int error; 6218 int result = adapter->rx_copy_len; 6219 6220 node.sysctl_data = &result; 6221 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6222 6223 if (error || newp == NULL) 6224 return error; 6225 6226 if ((result < 0) || (result > IXGBE_RX_COPY_LEN_MAX)) 6227 return EINVAL; 6228 6229 adapter->rx_copy_len = result; 6230 6231 return 0; 6232 } /* ixgbe_sysctl_rx_copy_len */ 6233 6234 /************************************************************************ 6235 * ixgbe_init_device_features 6236 ************************************************************************/ 6237 static void 6238 ixgbe_init_device_features(struct adapter *adapter) 6239 { 6240 adapter->feat_cap = IXGBE_FEATURE_NETMAP 6241 | IXGBE_FEATURE_RSS 6242 | IXGBE_FEATURE_MSI 6243 | IXGBE_FEATURE_MSIX 6244 | IXGBE_FEATURE_LEGACY_IRQ 6245 | IXGBE_FEATURE_LEGACY_TX; 6246 6247 /* Set capabilities first... */ 6248 switch (adapter->hw.mac.type) { 6249 case ixgbe_mac_82598EB: 6250 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 6251 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 6252 break; 6253 case ixgbe_mac_X540: 6254 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6255 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6256 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 6257 (adapter->hw.bus.func == 0)) 6258 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6259 break; 6260 case ixgbe_mac_X550: 6261 /* 6262 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6263 * NVM Image version. 6264 */ 6265 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6266 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6267 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6268 break; 6269 case ixgbe_mac_X550EM_x: 6270 /* 6271 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6272 * NVM Image version. 6273 */ 6274 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6275 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6276 break; 6277 case ixgbe_mac_X550EM_a: 6278 /* 6279 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6280 * NVM Image version. 6281 */ 6282 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6283 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6284 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6285 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 6286 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 6287 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6288 adapter->feat_cap |= IXGBE_FEATURE_EEE; 6289 } 6290 break; 6291 case ixgbe_mac_82599EB: 6292 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6293 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6294 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 6295 (adapter->hw.bus.func == 0)) 6296 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6297 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 6298 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6299 break; 6300 default: 6301 break; 6302 } 6303 6304 /* Enabled by default... */ 6305 /* Fan failure detection */ 6306 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 6307 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 6308 /* Netmap */ 6309 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 6310 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 6311 /* EEE */ 6312 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 6313 adapter->feat_en |= IXGBE_FEATURE_EEE; 6314 /* Thermal Sensor */ 6315 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 6316 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 6317 /* 6318 * Recovery mode: 6319 * NetBSD: IXGBE_FEATURE_RECOVERY_MODE will be controlled after reading 6320 * NVM Image version. 6321 */ 6322 6323 /* Enabled via global sysctl... */ 6324 /* Flow Director */ 6325 if (ixgbe_enable_fdir) { 6326 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 6327 adapter->feat_en |= IXGBE_FEATURE_FDIR; 6328 else 6329 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 6330 } 6331 /* Legacy (single queue) transmit */ 6332 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 6333 ixgbe_enable_legacy_tx) 6334 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 6335 /* 6336 * Message Signal Interrupts - Extended (MSI-X) 6337 * Normal MSI is only enabled if MSI-X calls fail. 6338 */ 6339 if (!ixgbe_enable_msix) 6340 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 6341 /* Receive-Side Scaling (RSS) */ 6342 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 6343 adapter->feat_en |= IXGBE_FEATURE_RSS; 6344 6345 /* Disable features with unmet dependencies... */ 6346 /* No MSI-X */ 6347 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 6348 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6349 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6350 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6351 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6352 } 6353 } /* ixgbe_init_device_features */ 6354 6355 /************************************************************************ 6356 * ixgbe_probe - Device identification routine 6357 * 6358 * Determines if the driver should be loaded on 6359 * adapter based on its PCI vendor/device ID. 6360 * 6361 * return BUS_PROBE_DEFAULT on success, positive on failure 6362 ************************************************************************/ 6363 static int 6364 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 6365 { 6366 const struct pci_attach_args *pa = aux; 6367 6368 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 6369 } 6370 6371 static const ixgbe_vendor_info_t * 6372 ixgbe_lookup(const struct pci_attach_args *pa) 6373 { 6374 const ixgbe_vendor_info_t *ent; 6375 pcireg_t subid; 6376 6377 INIT_DEBUGOUT("ixgbe_lookup: begin"); 6378 6379 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 6380 return NULL; 6381 6382 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 6383 6384 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 6385 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 6386 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 6387 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 6388 (ent->subvendor_id == 0)) && 6389 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 6390 (ent->subdevice_id == 0))) { 6391 return ent; 6392 } 6393 } 6394 return NULL; 6395 } 6396 6397 static int 6398 ixgbe_ifflags_cb(struct ethercom *ec) 6399 { 6400 struct ifnet *ifp = &ec->ec_if; 6401 struct adapter *adapter = ifp->if_softc; 6402 u_short change; 6403 int rv = 0; 6404 6405 IXGBE_CORE_LOCK(adapter); 6406 6407 change = ifp->if_flags ^ adapter->if_flags; 6408 if (change != 0) 6409 adapter->if_flags = ifp->if_flags; 6410 6411 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 6412 rv = ENETRESET; 6413 goto out; 6414 } else if ((change & IFF_PROMISC) != 0) 6415 ixgbe_set_rxfilter(adapter); 6416 6417 /* Check for ec_capenable. */ 6418 change = ec->ec_capenable ^ adapter->ec_capenable; 6419 adapter->ec_capenable = ec->ec_capenable; 6420 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 6421 | ETHERCAP_VLAN_HWFILTER)) != 0) { 6422 rv = ENETRESET; 6423 goto out; 6424 } 6425 6426 /* 6427 * Special handling is not required for ETHERCAP_VLAN_MTU. 6428 * MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 6429 */ 6430 6431 /* Set up VLAN support and filter */ 6432 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 6433 ixgbe_setup_vlan_hw_support(adapter); 6434 6435 out: 6436 IXGBE_CORE_UNLOCK(adapter); 6437 6438 return rv; 6439 } 6440 6441 /************************************************************************ 6442 * ixgbe_ioctl - Ioctl entry point 6443 * 6444 * Called when the user wants to configure the interface. 6445 * 6446 * return 0 on success, positive on failure 6447 ************************************************************************/ 6448 static int 6449 ixgbe_ioctl(struct ifnet *ifp, u_long command, void *data) 6450 { 6451 struct adapter *adapter = ifp->if_softc; 6452 struct ixgbe_hw *hw = &adapter->hw; 6453 struct ifcapreq *ifcr = data; 6454 struct ifreq *ifr = data; 6455 int error = 0; 6456 int l4csum_en; 6457 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 6458 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 6459 6460 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6461 return (EPERM); 6462 6463 switch (command) { 6464 case SIOCSIFFLAGS: 6465 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 6466 break; 6467 case SIOCADDMULTI: 6468 case SIOCDELMULTI: 6469 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 6470 break; 6471 case SIOCSIFMEDIA: 6472 case SIOCGIFMEDIA: 6473 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 6474 break; 6475 case SIOCSIFCAP: 6476 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 6477 break; 6478 case SIOCSIFMTU: 6479 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 6480 break; 6481 #ifdef __NetBSD__ 6482 case SIOCINITIFADDR: 6483 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 6484 break; 6485 case SIOCGIFFLAGS: 6486 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 6487 break; 6488 case SIOCGIFAFLAG_IN: 6489 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 6490 break; 6491 case SIOCGIFADDR: 6492 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 6493 break; 6494 case SIOCGIFMTU: 6495 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 6496 break; 6497 case SIOCGIFCAP: 6498 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 6499 break; 6500 case SIOCGETHERCAP: 6501 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 6502 break; 6503 case SIOCGLIFADDR: 6504 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 6505 break; 6506 case SIOCZIFDATA: 6507 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 6508 hw->mac.ops.clear_hw_cntrs(hw); 6509 ixgbe_clear_evcnt(adapter); 6510 break; 6511 case SIOCAIFADDR: 6512 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 6513 break; 6514 #endif 6515 default: 6516 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 6517 break; 6518 } 6519 6520 switch (command) { 6521 case SIOCGI2C: 6522 { 6523 struct ixgbe_i2c_req i2c; 6524 6525 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 6526 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 6527 if (error != 0) 6528 break; 6529 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 6530 error = EINVAL; 6531 break; 6532 } 6533 if (i2c.len > sizeof(i2c.data)) { 6534 error = EINVAL; 6535 break; 6536 } 6537 6538 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 6539 i2c.dev_addr, i2c.data); 6540 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 6541 break; 6542 } 6543 case SIOCSIFCAP: 6544 /* Layer-4 Rx checksum offload has to be turned on and 6545 * off as a unit. 6546 */ 6547 l4csum_en = ifcr->ifcr_capenable & l4csum; 6548 if (l4csum_en != l4csum && l4csum_en != 0) 6549 return EINVAL; 6550 /*FALLTHROUGH*/ 6551 case SIOCADDMULTI: 6552 case SIOCDELMULTI: 6553 case SIOCSIFFLAGS: 6554 case SIOCSIFMTU: 6555 default: 6556 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 6557 return error; 6558 if ((ifp->if_flags & IFF_RUNNING) == 0) 6559 ; 6560 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 6561 IXGBE_CORE_LOCK(adapter); 6562 if ((ifp->if_flags & IFF_RUNNING) != 0) 6563 ixgbe_init_locked(adapter); 6564 ixgbe_recalculate_max_frame(adapter); 6565 IXGBE_CORE_UNLOCK(adapter); 6566 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 6567 /* 6568 * Multicast list has changed; set the hardware filter 6569 * accordingly. 6570 */ 6571 IXGBE_CORE_LOCK(adapter); 6572 ixgbe_disable_intr(adapter); 6573 ixgbe_set_rxfilter(adapter); 6574 ixgbe_enable_intr(adapter); 6575 IXGBE_CORE_UNLOCK(adapter); 6576 } 6577 return 0; 6578 } 6579 6580 return error; 6581 } /* ixgbe_ioctl */ 6582 6583 /************************************************************************ 6584 * ixgbe_check_fan_failure 6585 ************************************************************************/ 6586 static int 6587 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 6588 { 6589 u32 mask; 6590 6591 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 6592 IXGBE_ESDP_SDP1; 6593 6594 if (reg & mask) { 6595 device_printf(adapter->dev, 6596 "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 6597 return IXGBE_ERR_FAN_FAILURE; 6598 } 6599 6600 return IXGBE_SUCCESS; 6601 } /* ixgbe_check_fan_failure */ 6602 6603 /************************************************************************ 6604 * ixgbe_handle_que 6605 ************************************************************************/ 6606 static void 6607 ixgbe_handle_que(void *context) 6608 { 6609 struct ix_queue *que = context; 6610 struct adapter *adapter = que->adapter; 6611 struct tx_ring *txr = que->txr; 6612 struct ifnet *ifp = adapter->ifp; 6613 bool more = false; 6614 6615 que->handleq.ev_count++; 6616 6617 if (ifp->if_flags & IFF_RUNNING) { 6618 more = ixgbe_rxeof(que); 6619 IXGBE_TX_LOCK(txr); 6620 more |= ixgbe_txeof(txr); 6621 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 6622 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 6623 ixgbe_mq_start_locked(ifp, txr); 6624 /* Only for queue 0 */ 6625 /* NetBSD still needs this for CBQ */ 6626 if ((&adapter->queues[0] == que) 6627 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 6628 ixgbe_legacy_start_locked(ifp, txr); 6629 IXGBE_TX_UNLOCK(txr); 6630 } 6631 6632 if (more) { 6633 que->req.ev_count++; 6634 ixgbe_sched_handle_que(adapter, que); 6635 } else if (que->res != NULL) { 6636 /* MSIX: Re-enable this interrupt */ 6637 ixgbe_enable_queue(adapter, que->msix); 6638 } else { 6639 /* INTx or MSI */ 6640 ixgbe_enable_queue(adapter, 0); 6641 } 6642 6643 return; 6644 } /* ixgbe_handle_que */ 6645 6646 /************************************************************************ 6647 * ixgbe_handle_que_work 6648 ************************************************************************/ 6649 static void 6650 ixgbe_handle_que_work(struct work *wk, void *context) 6651 { 6652 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 6653 6654 /* 6655 * "enqueued flag" is not required here. 6656 * See ixgbe_msix_que(). 6657 */ 6658 ixgbe_handle_que(que); 6659 } 6660 6661 /************************************************************************ 6662 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 6663 ************************************************************************/ 6664 static int 6665 ixgbe_allocate_legacy(struct adapter *adapter, 6666 const struct pci_attach_args *pa) 6667 { 6668 device_t dev = adapter->dev; 6669 struct ix_queue *que = adapter->queues; 6670 struct tx_ring *txr = adapter->tx_rings; 6671 int counts[PCI_INTR_TYPE_SIZE]; 6672 pci_intr_type_t intr_type, max_type; 6673 char intrbuf[PCI_INTRSTR_LEN]; 6674 char wqname[MAXCOMLEN]; 6675 const char *intrstr = NULL; 6676 int defertx_error = 0, error; 6677 6678 /* We allocate a single interrupt resource */ 6679 max_type = PCI_INTR_TYPE_MSI; 6680 counts[PCI_INTR_TYPE_MSIX] = 0; 6681 counts[PCI_INTR_TYPE_MSI] = 6682 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 6683 /* Check not feat_en but feat_cap to fallback to INTx */ 6684 counts[PCI_INTR_TYPE_INTX] = 6685 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 6686 6687 alloc_retry: 6688 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 6689 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 6690 return ENXIO; 6691 } 6692 adapter->osdep.nintrs = 1; 6693 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 6694 intrbuf, sizeof(intrbuf)); 6695 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 6696 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 6697 device_xname(dev)); 6698 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 6699 if (adapter->osdep.ihs[0] == NULL) { 6700 aprint_error_dev(dev,"unable to establish %s\n", 6701 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 6702 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6703 adapter->osdep.intrs = NULL; 6704 switch (intr_type) { 6705 case PCI_INTR_TYPE_MSI: 6706 /* The next try is for INTx: Disable MSI */ 6707 max_type = PCI_INTR_TYPE_INTX; 6708 counts[PCI_INTR_TYPE_INTX] = 1; 6709 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6710 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 6711 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6712 goto alloc_retry; 6713 } else 6714 break; 6715 case PCI_INTR_TYPE_INTX: 6716 default: 6717 /* See below */ 6718 break; 6719 } 6720 } 6721 if (intr_type == PCI_INTR_TYPE_INTX) { 6722 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6723 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6724 } 6725 if (adapter->osdep.ihs[0] == NULL) { 6726 aprint_error_dev(dev, 6727 "couldn't establish interrupt%s%s\n", 6728 intrstr ? " at " : "", intrstr ? intrstr : ""); 6729 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6730 adapter->osdep.intrs = NULL; 6731 return ENXIO; 6732 } 6733 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 6734 /* 6735 * Try allocating a fast interrupt and the associated deferred 6736 * processing contexts. 6737 */ 6738 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6739 txr->txr_si = 6740 softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6741 ixgbe_deferred_mq_start, txr); 6742 6743 snprintf(wqname, sizeof(wqname), "%sdeferTx", 6744 device_xname(dev)); 6745 defertx_error = workqueue_create(&adapter->txr_wq, wqname, 6746 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, 6747 IPL_NET, IXGBE_WORKQUEUE_FLAGS); 6748 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6749 } 6750 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6751 ixgbe_handle_que, que); 6752 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6753 error = workqueue_create(&adapter->que_wq, wqname, 6754 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6755 IXGBE_WORKQUEUE_FLAGS); 6756 6757 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 6758 && ((txr->txr_si == NULL) || defertx_error != 0)) 6759 || (que->que_si == NULL) || error != 0) { 6760 aprint_error_dev(dev, 6761 "could not establish software interrupts\n"); 6762 6763 return ENXIO; 6764 } 6765 /* For simplicity in the handlers */ 6766 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 6767 6768 return (0); 6769 } /* ixgbe_allocate_legacy */ 6770 6771 /************************************************************************ 6772 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 6773 ************************************************************************/ 6774 static int 6775 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 6776 { 6777 device_t dev = adapter->dev; 6778 struct ix_queue *que = adapter->queues; 6779 struct tx_ring *txr = adapter->tx_rings; 6780 pci_chipset_tag_t pc; 6781 char intrbuf[PCI_INTRSTR_LEN]; 6782 char intr_xname[32]; 6783 char wqname[MAXCOMLEN]; 6784 const char *intrstr = NULL; 6785 int error, vector = 0; 6786 int cpu_id = 0; 6787 kcpuset_t *affinity; 6788 #ifdef RSS 6789 unsigned int rss_buckets = 0; 6790 kcpuset_t cpu_mask; 6791 #endif 6792 6793 pc = adapter->osdep.pc; 6794 #ifdef RSS 6795 /* 6796 * If we're doing RSS, the number of queues needs to 6797 * match the number of RSS buckets that are configured. 6798 * 6799 * + If there's more queues than RSS buckets, we'll end 6800 * up with queues that get no traffic. 6801 * 6802 * + If there's more RSS buckets than queues, we'll end 6803 * up having multiple RSS buckets map to the same queue, 6804 * so there'll be some contention. 6805 */ 6806 rss_buckets = rss_getnumbuckets(); 6807 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6808 (adapter->num_queues != rss_buckets)) { 6809 device_printf(dev, 6810 "%s: number of queues (%d) != number of RSS buckets (%d)" 6811 "; performance will be impacted.\n", 6812 __func__, adapter->num_queues, rss_buckets); 6813 } 6814 #endif 6815 6816 adapter->osdep.nintrs = adapter->num_queues + 1; 6817 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6818 adapter->osdep.nintrs) != 0) { 6819 aprint_error_dev(dev, 6820 "failed to allocate MSI-X interrupt\n"); 6821 return (ENXIO); 6822 } 6823 6824 kcpuset_create(&affinity, false); 6825 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6826 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6827 device_xname(dev), i); 6828 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6829 sizeof(intrbuf)); 6830 #ifdef IXGBE_MPSAFE 6831 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6832 true); 6833 #endif 6834 /* Set the handler function */ 6835 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6836 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6837 intr_xname); 6838 if (que->res == NULL) { 6839 aprint_error_dev(dev, 6840 "Failed to register QUE handler\n"); 6841 error = ENXIO; 6842 goto err_out; 6843 } 6844 que->msix = vector; 6845 adapter->active_queues |= 1ULL << que->msix; 6846 6847 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6848 #ifdef RSS 6849 /* 6850 * The queue ID is used as the RSS layer bucket ID. 6851 * We look up the queue ID -> RSS CPU ID and select 6852 * that. 6853 */ 6854 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6855 CPU_SETOF(cpu_id, &cpu_mask); 6856 #endif 6857 } else { 6858 /* 6859 * Bind the MSI-X vector, and thus the 6860 * rings to the corresponding CPU. 6861 * 6862 * This just happens to match the default RSS 6863 * round-robin bucket -> queue -> CPU allocation. 6864 */ 6865 if (adapter->num_queues > 1) 6866 cpu_id = i; 6867 } 6868 /* Round-robin affinity */ 6869 kcpuset_zero(affinity); 6870 kcpuset_set(affinity, cpu_id % ncpu); 6871 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6872 NULL); 6873 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6874 intrstr); 6875 if (error == 0) { 6876 #if 1 /* def IXGBE_DEBUG */ 6877 #ifdef RSS 6878 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6879 cpu_id % ncpu); 6880 #else 6881 aprint_normal(", bound queue %d to cpu %d", i, 6882 cpu_id % ncpu); 6883 #endif 6884 #endif /* IXGBE_DEBUG */ 6885 } 6886 aprint_normal("\n"); 6887 6888 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6889 txr->txr_si = softint_establish( 6890 SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6891 ixgbe_deferred_mq_start, txr); 6892 if (txr->txr_si == NULL) { 6893 aprint_error_dev(dev, 6894 "couldn't establish software interrupt\n"); 6895 error = ENXIO; 6896 goto err_out; 6897 } 6898 } 6899 que->que_si 6900 = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6901 ixgbe_handle_que, que); 6902 if (que->que_si == NULL) { 6903 aprint_error_dev(dev, 6904 "couldn't establish software interrupt\n"); 6905 error = ENXIO; 6906 goto err_out; 6907 } 6908 } 6909 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6910 error = workqueue_create(&adapter->txr_wq, wqname, 6911 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6912 IXGBE_WORKQUEUE_FLAGS); 6913 if (error) { 6914 aprint_error_dev(dev, 6915 "couldn't create workqueue for deferred Tx\n"); 6916 goto err_out; 6917 } 6918 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6919 6920 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6921 error = workqueue_create(&adapter->que_wq, wqname, 6922 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6923 IXGBE_WORKQUEUE_FLAGS); 6924 if (error) { 6925 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6926 goto err_out; 6927 } 6928 6929 /* and Link */ 6930 cpu_id++; 6931 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6932 adapter->vector = vector; 6933 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6934 sizeof(intrbuf)); 6935 #ifdef IXGBE_MPSAFE 6936 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6937 true); 6938 #endif 6939 /* Set the link handler function */ 6940 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6941 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_admin, adapter, 6942 intr_xname); 6943 if (adapter->osdep.ihs[vector] == NULL) { 6944 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6945 error = ENXIO; 6946 goto err_out; 6947 } 6948 /* Round-robin affinity */ 6949 kcpuset_zero(affinity); 6950 kcpuset_set(affinity, cpu_id % ncpu); 6951 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6952 NULL); 6953 6954 aprint_normal_dev(dev, 6955 "for link, interrupting at %s", intrstr); 6956 if (error == 0) 6957 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6958 else 6959 aprint_normal("\n"); 6960 6961 kcpuset_destroy(affinity); 6962 aprint_normal_dev(dev, 6963 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6964 6965 return (0); 6966 6967 err_out: 6968 kcpuset_destroy(affinity); 6969 ixgbe_free_deferred_handlers(adapter); 6970 ixgbe_free_pciintr_resources(adapter); 6971 return (error); 6972 } /* ixgbe_allocate_msix */ 6973 6974 /************************************************************************ 6975 * ixgbe_configure_interrupts 6976 * 6977 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6978 * This will also depend on user settings. 6979 ************************************************************************/ 6980 static int 6981 ixgbe_configure_interrupts(struct adapter *adapter) 6982 { 6983 device_t dev = adapter->dev; 6984 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6985 int want, queues, msgs; 6986 6987 /* Default to 1 queue if MSI-X setup fails */ 6988 adapter->num_queues = 1; 6989 6990 /* Override by tuneable */ 6991 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6992 goto msi; 6993 6994 /* 6995 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6996 * interrupt slot. 6997 */ 6998 if (ncpu == 1) 6999 goto msi; 7000 7001 /* First try MSI-X */ 7002 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 7003 msgs = MIN(msgs, IXG_MAX_NINTR); 7004 if (msgs < 2) 7005 goto msi; 7006 7007 adapter->msix_mem = (void *)1; /* XXX */ 7008 7009 /* Figure out a reasonable auto config value */ 7010 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 7011 7012 #ifdef RSS 7013 /* If we're doing RSS, clamp at the number of RSS buckets */ 7014 if (adapter->feat_en & IXGBE_FEATURE_RSS) 7015 queues = uimin(queues, rss_getnumbuckets()); 7016 #endif 7017 if (ixgbe_num_queues > queues) { 7018 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 7019 ixgbe_num_queues = queues; 7020 } 7021 7022 if (ixgbe_num_queues != 0) 7023 queues = ixgbe_num_queues; 7024 else 7025 queues = uimin(queues, 7026 uimin(mac->max_tx_queues, mac->max_rx_queues)); 7027 7028 /* reflect correct sysctl value */ 7029 ixgbe_num_queues = queues; 7030 7031 /* 7032 * Want one vector (RX/TX pair) per queue 7033 * plus an additional for Link. 7034 */ 7035 want = queues + 1; 7036 if (msgs >= want) 7037 msgs = want; 7038 else { 7039 aprint_error_dev(dev, "MSI-X Configuration Problem, " 7040 "%d vectors but %d queues wanted!\n", 7041 msgs, want); 7042 goto msi; 7043 } 7044 adapter->num_queues = queues; 7045 adapter->feat_en |= IXGBE_FEATURE_MSIX; 7046 return (0); 7047 7048 /* 7049 * MSI-X allocation failed or provided us with 7050 * less vectors than needed. Free MSI-X resources 7051 * and we'll try enabling MSI. 7052 */ 7053 msi: 7054 /* Without MSI-X, some features are no longer supported */ 7055 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 7056 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 7057 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 7058 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 7059 7060 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 7061 adapter->msix_mem = NULL; /* XXX */ 7062 if (msgs > 1) 7063 msgs = 1; 7064 if (msgs != 0) { 7065 msgs = 1; 7066 adapter->feat_en |= IXGBE_FEATURE_MSI; 7067 return (0); 7068 } 7069 7070 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 7071 aprint_error_dev(dev, 7072 "Device does not support legacy interrupts.\n"); 7073 return 1; 7074 } 7075 7076 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 7077 7078 return (0); 7079 } /* ixgbe_configure_interrupts */ 7080 7081 7082 /************************************************************************ 7083 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 7084 * 7085 * Done outside of interrupt context since the driver might sleep 7086 ************************************************************************/ 7087 static void 7088 ixgbe_handle_link(void *context) 7089 { 7090 struct adapter *adapter = context; 7091 struct ixgbe_hw *hw = &adapter->hw; 7092 7093 KASSERT(mutex_owned(&adapter->core_mtx)); 7094 7095 ++adapter->link_workev.ev_count; 7096 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 7097 ixgbe_update_link_status(adapter); 7098 7099 /* Re-enable link interrupts */ 7100 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 7101 } /* ixgbe_handle_link */ 7102 7103 #if 0 7104 /************************************************************************ 7105 * ixgbe_rearm_queues 7106 ************************************************************************/ 7107 static __inline void 7108 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 7109 { 7110 u32 mask; 7111 7112 switch (adapter->hw.mac.type) { 7113 case ixgbe_mac_82598EB: 7114 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 7115 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 7116 break; 7117 case ixgbe_mac_82599EB: 7118 case ixgbe_mac_X540: 7119 case ixgbe_mac_X550: 7120 case ixgbe_mac_X550EM_x: 7121 case ixgbe_mac_X550EM_a: 7122 mask = (queues & 0xFFFFFFFF); 7123 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 7124 mask = (queues >> 32); 7125 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 7126 break; 7127 default: 7128 break; 7129 } 7130 } /* ixgbe_rearm_queues */ 7131 #endif 7132
Indexes created Tue Sep 30 11:09:46 GMT 2025