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