ixgbe.c revision 1.300
1 /* $NetBSD: ixgbe.c,v 1.300 2021/12/16 10:48:49 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.300 2021/12/16 10:48:49 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.10 */ 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, lxon, lxoff, total; 1631 u64 total_missed_rx = 0; 1632 unsigned int queue_counters; 1633 int i; 1634 1635 stats->crcerrs.ev_count += IXGBE_READ_REG(hw, IXGBE_CRCERRS); 1636 stats->illerrc.ev_count += IXGBE_READ_REG(hw, IXGBE_ILLERRC); 1637 stats->errbc.ev_count += IXGBE_READ_REG(hw, IXGBE_ERRBC); 1638 stats->mspdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MSPDC); 1639 if (hw->mac.type >= ixgbe_mac_X550) 1640 stats->mbsdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MBSDC); 1641 1642 /* 16 registers exist */ 1643 queue_counters = uimin(__arraycount(stats->qprc), adapter->num_queues); 1644 for (i = 0; i < queue_counters; i++) { 1645 stats->qprc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 1646 stats->qptc[i].ev_count += IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 1647 if (hw->mac.type >= ixgbe_mac_82599EB) { 1648 stats->qprdc[i].ev_count 1649 += IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 1650 } 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 stats->mpc[i].ev_count += mp; 1661 /* running comprehensive total for stats display */ 1662 total_missed_rx += mp; 1663 1664 if (hw->mac.type == ixgbe_mac_82598EB) 1665 stats->rnbc[i].ev_count 1666 += IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 1667 1668 stats->pxontxc[i].ev_count 1669 += IXGBE_READ_REG(hw, IXGBE_PXONTXC(i)); 1670 stats->pxofftxc[i].ev_count 1671 += IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i)); 1672 if (hw->mac.type >= ixgbe_mac_82599EB) { 1673 stats->pxonrxc[i].ev_count 1674 += IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i)); 1675 stats->pxoffrxc[i].ev_count 1676 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(i)); 1677 stats->pxon2offc[i].ev_count 1678 += IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i)); 1679 } else { 1680 stats->pxonrxc[i].ev_count 1681 += IXGBE_READ_REG(hw, IXGBE_PXONRXC(i)); 1682 stats->pxoffrxc[i].ev_count 1683 += IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i)); 1684 } 1685 } 1686 stats->mpctotal.ev_count += total_missed_rx; 1687 1688 /* Document says M[LR]FC are valid when link is up and 10Gbps */ 1689 if ((adapter->link_active == LINK_STATE_UP) 1690 && (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL)) { 1691 stats->mlfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MLFC); 1692 stats->mrfc.ev_count += IXGBE_READ_REG(hw, IXGBE_MRFC); 1693 } 1694 stats->rlec.ev_count += IXGBE_READ_REG(hw, IXGBE_RLEC); 1695 1696 /* Hardware workaround, gprc counts missed packets */ 1697 stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx; 1698 1699 lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC); 1700 stats->lxontxc.ev_count += lxon; 1701 lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 1702 stats->lxofftxc.ev_count += lxoff; 1703 total = lxon + lxoff; 1704 1705 if (hw->mac.type != ixgbe_mac_82598EB) { 1706 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) + 1707 ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32); 1708 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) + 1709 ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) 1710 - total * ETHER_MIN_LEN; 1711 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) + 1712 ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32); 1713 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 1714 stats->lxoffrxc.ev_count 1715 += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 1716 } else { 1717 stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC); 1718 stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 1719 /* 82598 only has a counter in the high register */ 1720 stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH); 1721 stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) 1722 - total * ETHER_MIN_LEN; 1723 stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH); 1724 } 1725 1726 /* 1727 * Workaround: mprc hardware is incorrectly counting 1728 * broadcasts, so for now we subtract those. 1729 */ 1730 bprc = IXGBE_READ_REG(hw, IXGBE_BPRC); 1731 stats->bprc.ev_count += bprc; 1732 stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC) 1733 - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0); 1734 1735 stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64); 1736 stats->prc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC127); 1737 stats->prc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC255); 1738 stats->prc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC511); 1739 stats->prc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1023); 1740 stats->prc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC1522); 1741 1742 stats->gptc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPTC) - total; 1743 stats->mptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPTC) - total; 1744 stats->ptc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC64) - total; 1745 1746 stats->ruc.ev_count += IXGBE_READ_REG(hw, IXGBE_RUC); 1747 stats->rfc.ev_count += IXGBE_READ_REG(hw, IXGBE_RFC); 1748 stats->roc.ev_count += IXGBE_READ_REG(hw, IXGBE_ROC); 1749 stats->rjc.ev_count += IXGBE_READ_REG(hw, IXGBE_RJC); 1750 stats->mngprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPRC); 1751 stats->mngpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPDC); 1752 stats->mngptc.ev_count += IXGBE_READ_REG(hw, IXGBE_MNGPTC); 1753 stats->tpr.ev_count += IXGBE_READ_REG(hw, IXGBE_TPR); 1754 stats->tpt.ev_count += IXGBE_READ_REG(hw, IXGBE_TPT); 1755 stats->ptc127.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC127); 1756 stats->ptc255.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC255); 1757 stats->ptc511.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC511); 1758 stats->ptc1023.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1023); 1759 stats->ptc1522.ev_count += IXGBE_READ_REG(hw, IXGBE_PTC1522); 1760 stats->bptc.ev_count += IXGBE_READ_REG(hw, IXGBE_BPTC); 1761 stats->xec.ev_count += IXGBE_READ_REG(hw, IXGBE_XEC); 1762 stats->fccrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCCRC); 1763 stats->fclast.ev_count += IXGBE_READ_REG(hw, IXGBE_FCLAST); 1764 /* Only read FCOE on 82599 */ 1765 if (hw->mac.type != ixgbe_mac_82598EB) { 1766 stats->fcoerpdc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOERPDC); 1767 stats->fcoeprc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPRC); 1768 stats->fcoeptc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEPTC); 1769 stats->fcoedwrc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWRC); 1770 stats->fcoedwtc.ev_count += IXGBE_READ_REG(hw, IXGBE_FCOEDWTC); 1771 } 1772 1773 /* 1774 * Fill out the OS statistics structure. Only RX errors are required 1775 * here because all TX counters are incremented in the TX path and 1776 * normal RX counters are prepared in ether_input(). 1777 */ 1778 net_stat_ref_t nsr = IF_STAT_GETREF(ifp); 1779 if_statadd_ref(nsr, if_iqdrops, total_missed_rx); 1780 1781 /* 1782 * Aggregate following types of errors as RX errors: 1783 * - CRC error count, 1784 * - illegal byte error count, 1785 * - length error count, 1786 * - undersized packets count, 1787 * - fragmented packets count, 1788 * - oversized packets count, 1789 * - jabber count. 1790 */ 1791 #define EVC(x) stats->x.ev_count 1792 if_statadd_ref(nsr, if_ierrors, 1793 EVC(crcerrs) + 1794 EVC(illerrc) + 1795 EVC(rlec) + 1796 EVC(ruc) + 1797 EVC(rfc) + 1798 EVC(roc) + 1799 EVC(rjc)); 1800 #undef EVC 1801 1802 IF_STAT_PUTREF(ifp); 1803 } /* ixgbe_update_stats_counters */ 1804 1805 /************************************************************************ 1806 * ixgbe_add_hw_stats 1807 * 1808 * Add sysctl variables, one per statistic, to the system. 1809 ************************************************************************/ 1810 static void 1811 ixgbe_add_hw_stats(struct adapter *adapter) 1812 { 1813 device_t dev = adapter->dev; 1814 const struct sysctlnode *rnode, *cnode; 1815 struct sysctllog **log = &adapter->sysctllog; 1816 struct tx_ring *txr = adapter->tx_rings; 1817 struct rx_ring *rxr = adapter->rx_rings; 1818 struct ixgbe_hw *hw = &adapter->hw; 1819 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 1820 const char *xname = device_xname(dev); 1821 int i; 1822 1823 /* Driver Statistics */ 1824 evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC, 1825 NULL, xname, "Driver tx dma soft fail EFBIG"); 1826 evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC, 1827 NULL, xname, "m_defrag() failed"); 1828 evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC, 1829 NULL, xname, "Driver tx dma hard fail EFBIG"); 1830 evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC, 1831 NULL, xname, "Driver tx dma hard fail EINVAL"); 1832 evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC, 1833 NULL, xname, "Driver tx dma hard fail other"); 1834 evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC, 1835 NULL, xname, "Driver tx dma soft fail EAGAIN"); 1836 evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC, 1837 NULL, xname, "Driver tx dma soft fail ENOMEM"); 1838 evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC, 1839 NULL, xname, "Watchdog timeouts"); 1840 evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC, 1841 NULL, xname, "TSO errors"); 1842 evcnt_attach_dynamic(&adapter->admin_irqev, EVCNT_TYPE_INTR, 1843 NULL, xname, "Admin MSI-X IRQ Handled"); 1844 evcnt_attach_dynamic(&adapter->link_workev, EVCNT_TYPE_INTR, 1845 NULL, xname, "Link event"); 1846 evcnt_attach_dynamic(&adapter->mod_workev, EVCNT_TYPE_INTR, 1847 NULL, xname, "SFP+ module event"); 1848 evcnt_attach_dynamic(&adapter->msf_workev, EVCNT_TYPE_INTR, 1849 NULL, xname, "Multispeed event"); 1850 evcnt_attach_dynamic(&adapter->phy_workev, EVCNT_TYPE_INTR, 1851 NULL, xname, "External PHY event"); 1852 1853 /* Max number of traffic class is 8 */ 1854 KASSERT(IXGBE_DCB_MAX_TRAFFIC_CLASS == 8); 1855 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 1856 snprintf(adapter->tcs[i].evnamebuf, 1857 sizeof(adapter->tcs[i].evnamebuf), "%s tc%d", 1858 xname, i); 1859 if (i < __arraycount(stats->mpc)) { 1860 evcnt_attach_dynamic(&stats->mpc[i], 1861 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1862 "RX Missed Packet Count"); 1863 if (hw->mac.type == ixgbe_mac_82598EB) 1864 evcnt_attach_dynamic(&stats->rnbc[i], 1865 EVCNT_TYPE_MISC, NULL, 1866 adapter->tcs[i].evnamebuf, 1867 "Receive No Buffers"); 1868 } 1869 if (i < __arraycount(stats->pxontxc)) { 1870 evcnt_attach_dynamic(&stats->pxontxc[i], 1871 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1872 "pxontxc"); 1873 evcnt_attach_dynamic(&stats->pxonrxc[i], 1874 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1875 "pxonrxc"); 1876 evcnt_attach_dynamic(&stats->pxofftxc[i], 1877 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1878 "pxofftxc"); 1879 evcnt_attach_dynamic(&stats->pxoffrxc[i], 1880 EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf, 1881 "pxoffrxc"); 1882 if (hw->mac.type >= ixgbe_mac_82599EB) 1883 evcnt_attach_dynamic(&stats->pxon2offc[i], 1884 EVCNT_TYPE_MISC, NULL, 1885 adapter->tcs[i].evnamebuf, 1886 "pxon2offc"); 1887 } 1888 } 1889 1890 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 1891 #ifdef LRO 1892 struct lro_ctrl *lro = &rxr->lro; 1893 #endif /* LRO */ 1894 1895 snprintf(adapter->queues[i].evnamebuf, 1896 sizeof(adapter->queues[i].evnamebuf), "%s q%d", 1897 xname, i); 1898 snprintf(adapter->queues[i].namebuf, 1899 sizeof(adapter->queues[i].namebuf), "q%d", i); 1900 1901 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 1902 aprint_error_dev(dev, "could not create sysctl root\n"); 1903 break; 1904 } 1905 1906 if (sysctl_createv(log, 0, &rnode, &rnode, 1907 0, CTLTYPE_NODE, 1908 adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"), 1909 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) 1910 break; 1911 1912 if (sysctl_createv(log, 0, &rnode, &cnode, 1913 CTLFLAG_READWRITE, CTLTYPE_INT, 1914 "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"), 1915 ixgbe_sysctl_interrupt_rate_handler, 0, 1916 (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0) 1917 break; 1918 1919 if (sysctl_createv(log, 0, &rnode, &cnode, 1920 CTLFLAG_READONLY, CTLTYPE_INT, 1921 "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"), 1922 ixgbe_sysctl_tdh_handler, 0, (void *)txr, 1923 0, CTL_CREATE, CTL_EOL) != 0) 1924 break; 1925 1926 if (sysctl_createv(log, 0, &rnode, &cnode, 1927 CTLFLAG_READONLY, CTLTYPE_INT, 1928 "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"), 1929 ixgbe_sysctl_tdt_handler, 0, (void *)txr, 1930 0, CTL_CREATE, CTL_EOL) != 0) 1931 break; 1932 1933 evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR, 1934 NULL, adapter->queues[i].evnamebuf, "IRQs on queue"); 1935 evcnt_attach_dynamic(&adapter->queues[i].handleq, 1936 EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf, 1937 "Handled queue in softint"); 1938 evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC, 1939 NULL, adapter->queues[i].evnamebuf, "Requeued in softint"); 1940 evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC, 1941 NULL, adapter->queues[i].evnamebuf, "TSO"); 1942 evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC, 1943 NULL, adapter->queues[i].evnamebuf, 1944 "TX Queue No Descriptor Available"); 1945 evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC, 1946 NULL, adapter->queues[i].evnamebuf, 1947 "Queue Packets Transmitted"); 1948 #ifndef IXGBE_LEGACY_TX 1949 evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC, 1950 NULL, adapter->queues[i].evnamebuf, 1951 "Packets dropped in pcq"); 1952 #endif 1953 1954 if (sysctl_createv(log, 0, &rnode, &cnode, 1955 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxck", 1956 SYSCTL_DESCR("Receive Descriptor next to check"), 1957 ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0, 1958 CTL_CREATE, CTL_EOL) != 0) 1959 break; 1960 1961 if (sysctl_createv(log, 0, &rnode, &cnode, 1962 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxrf", 1963 SYSCTL_DESCR("Receive Descriptor next to refresh"), 1964 ixgbe_sysctl_next_to_refresh_handler, 0, (void *)rxr, 0, 1965 CTL_CREATE, CTL_EOL) != 0) 1966 break; 1967 1968 if (sysctl_createv(log, 0, &rnode, &cnode, 1969 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_head", 1970 SYSCTL_DESCR("Receive Descriptor Head"), 1971 ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0, 1972 CTL_CREATE, CTL_EOL) != 0) 1973 break; 1974 1975 if (sysctl_createv(log, 0, &rnode, &cnode, 1976 CTLFLAG_READONLY, CTLTYPE_INT, "rxd_tail", 1977 SYSCTL_DESCR("Receive Descriptor Tail"), 1978 ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0, 1979 CTL_CREATE, CTL_EOL) != 0) 1980 break; 1981 1982 if (i < __arraycount(stats->qprc)) { 1983 evcnt_attach_dynamic(&stats->qprc[i], EVCNT_TYPE_MISC, 1984 NULL, adapter->queues[i].evnamebuf, "qprc"); 1985 evcnt_attach_dynamic(&stats->qptc[i], EVCNT_TYPE_MISC, 1986 NULL, adapter->queues[i].evnamebuf, "qptc"); 1987 evcnt_attach_dynamic(&stats->qbrc[i], EVCNT_TYPE_MISC, 1988 NULL, adapter->queues[i].evnamebuf, "qbrc"); 1989 evcnt_attach_dynamic(&stats->qbtc[i], EVCNT_TYPE_MISC, 1990 NULL, adapter->queues[i].evnamebuf, "qbtc"); 1991 if (hw->mac.type >= ixgbe_mac_82599EB) 1992 evcnt_attach_dynamic(&stats->qprdc[i], 1993 EVCNT_TYPE_MISC, NULL, 1994 adapter->queues[i].evnamebuf, "qprdc"); 1995 } 1996 1997 evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC, 1998 NULL, adapter->queues[i].evnamebuf, 1999 "Queue Packets Received"); 2000 evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC, 2001 NULL, adapter->queues[i].evnamebuf, 2002 "Queue Bytes Received"); 2003 evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC, 2004 NULL, adapter->queues[i].evnamebuf, "Copied RX Frames"); 2005 evcnt_attach_dynamic(&rxr->no_mbuf, EVCNT_TYPE_MISC, 2006 NULL, adapter->queues[i].evnamebuf, "Rx no mbuf"); 2007 evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC, 2008 NULL, adapter->queues[i].evnamebuf, "Rx discarded"); 2009 #ifdef LRO 2010 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued", 2011 CTLFLAG_RD, &lro->lro_queued, 0, 2012 "LRO Queued"); 2013 SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed", 2014 CTLFLAG_RD, &lro->lro_flushed, 0, 2015 "LRO Flushed"); 2016 #endif /* LRO */ 2017 } 2018 2019 /* MAC stats get their own sub node */ 2020 2021 snprintf(stats->namebuf, 2022 sizeof(stats->namebuf), "%s MAC Statistics", xname); 2023 2024 evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL, 2025 stats->namebuf, "rx csum offload - IP"); 2026 evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL, 2027 stats->namebuf, "rx csum offload - L4"); 2028 evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL, 2029 stats->namebuf, "rx csum offload - IP bad"); 2030 evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL, 2031 stats->namebuf, "rx csum offload - L4 bad"); 2032 evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL, 2033 stats->namebuf, "Interrupt conditions zero"); 2034 evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL, 2035 stats->namebuf, "Legacy interrupts"); 2036 2037 evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL, 2038 stats->namebuf, "CRC Errors"); 2039 evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL, 2040 stats->namebuf, "Illegal Byte Errors"); 2041 evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL, 2042 stats->namebuf, "Byte Errors"); 2043 evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL, 2044 stats->namebuf, "MAC Short Packets Discarded"); 2045 if (hw->mac.type >= ixgbe_mac_X550) 2046 evcnt_attach_dynamic(&stats->mbsdc, EVCNT_TYPE_MISC, NULL, 2047 stats->namebuf, "Bad SFD"); 2048 evcnt_attach_dynamic(&stats->mpctotal, EVCNT_TYPE_MISC, NULL, 2049 stats->namebuf, "Total Packets Missed"); 2050 evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL, 2051 stats->namebuf, "MAC Local Faults"); 2052 evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL, 2053 stats->namebuf, "MAC Remote Faults"); 2054 evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL, 2055 stats->namebuf, "Receive Length Errors"); 2056 evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL, 2057 stats->namebuf, "Link XON Transmitted"); 2058 evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL, 2059 stats->namebuf, "Link XON Received"); 2060 evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL, 2061 stats->namebuf, "Link XOFF Transmitted"); 2062 evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL, 2063 stats->namebuf, "Link XOFF Received"); 2064 2065 /* Packet Reception Stats */ 2066 evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL, 2067 stats->namebuf, "Total Octets Received"); 2068 evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL, 2069 stats->namebuf, "Good Octets Received"); 2070 evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL, 2071 stats->namebuf, "Total Packets Received"); 2072 evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL, 2073 stats->namebuf, "Good Packets Received"); 2074 evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL, 2075 stats->namebuf, "Multicast Packets Received"); 2076 evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL, 2077 stats->namebuf, "Broadcast Packets Received"); 2078 evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL, 2079 stats->namebuf, "64 byte frames received "); 2080 evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL, 2081 stats->namebuf, "65-127 byte frames received"); 2082 evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL, 2083 stats->namebuf, "128-255 byte frames received"); 2084 evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL, 2085 stats->namebuf, "256-511 byte frames received"); 2086 evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL, 2087 stats->namebuf, "512-1023 byte frames received"); 2088 evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL, 2089 stats->namebuf, "1023-1522 byte frames received"); 2090 evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL, 2091 stats->namebuf, "Receive Undersized"); 2092 evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL, 2093 stats->namebuf, "Fragmented Packets Received "); 2094 evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL, 2095 stats->namebuf, "Oversized Packets Received"); 2096 evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL, 2097 stats->namebuf, "Received Jabber"); 2098 evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL, 2099 stats->namebuf, "Management Packets Received"); 2100 evcnt_attach_dynamic(&stats->mngpdc, EVCNT_TYPE_MISC, NULL, 2101 stats->namebuf, "Management Packets Dropped"); 2102 evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL, 2103 stats->namebuf, "Checksum Errors"); 2104 2105 /* Packet Transmission Stats */ 2106 evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL, 2107 stats->namebuf, "Good Octets Transmitted"); 2108 evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL, 2109 stats->namebuf, "Total Packets Transmitted"); 2110 evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL, 2111 stats->namebuf, "Good Packets Transmitted"); 2112 evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL, 2113 stats->namebuf, "Broadcast Packets Transmitted"); 2114 evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL, 2115 stats->namebuf, "Multicast Packets Transmitted"); 2116 evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL, 2117 stats->namebuf, "Management Packets Transmitted"); 2118 evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL, 2119 stats->namebuf, "64 byte frames transmitted "); 2120 evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL, 2121 stats->namebuf, "65-127 byte frames transmitted"); 2122 evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL, 2123 stats->namebuf, "128-255 byte frames transmitted"); 2124 evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL, 2125 stats->namebuf, "256-511 byte frames transmitted"); 2126 evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL, 2127 stats->namebuf, "512-1023 byte frames transmitted"); 2128 evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL, 2129 stats->namebuf, "1024-1522 byte frames transmitted"); 2130 } /* ixgbe_add_hw_stats */ 2131 2132 static void 2133 ixgbe_clear_evcnt(struct adapter *adapter) 2134 { 2135 struct tx_ring *txr = adapter->tx_rings; 2136 struct rx_ring *rxr = adapter->rx_rings; 2137 struct ixgbe_hw *hw = &adapter->hw; 2138 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 2139 int i; 2140 2141 adapter->efbig_tx_dma_setup.ev_count = 0; 2142 adapter->mbuf_defrag_failed.ev_count = 0; 2143 adapter->efbig2_tx_dma_setup.ev_count = 0; 2144 adapter->einval_tx_dma_setup.ev_count = 0; 2145 adapter->other_tx_dma_setup.ev_count = 0; 2146 adapter->eagain_tx_dma_setup.ev_count = 0; 2147 adapter->enomem_tx_dma_setup.ev_count = 0; 2148 adapter->tso_err.ev_count = 0; 2149 adapter->watchdog_events.ev_count = 0; 2150 adapter->admin_irqev.ev_count = 0; 2151 adapter->link_workev.ev_count = 0; 2152 adapter->mod_workev.ev_count = 0; 2153 adapter->msf_workev.ev_count = 0; 2154 adapter->phy_workev.ev_count = 0; 2155 2156 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 2157 if (i < __arraycount(stats->mpc)) { 2158 stats->mpc[i].ev_count = 0; 2159 if (hw->mac.type == ixgbe_mac_82598EB) 2160 stats->rnbc[i].ev_count = 0; 2161 } 2162 if (i < __arraycount(stats->pxontxc)) { 2163 stats->pxontxc[i].ev_count = 0; 2164 stats->pxonrxc[i].ev_count = 0; 2165 stats->pxofftxc[i].ev_count = 0; 2166 stats->pxoffrxc[i].ev_count = 0; 2167 if (hw->mac.type >= ixgbe_mac_82599EB) 2168 stats->pxon2offc[i].ev_count = 0; 2169 } 2170 } 2171 2172 txr = adapter->tx_rings; 2173 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 2174 adapter->queues[i].irqs.ev_count = 0; 2175 adapter->queues[i].handleq.ev_count = 0; 2176 adapter->queues[i].req.ev_count = 0; 2177 txr->no_desc_avail.ev_count = 0; 2178 txr->total_packets.ev_count = 0; 2179 txr->tso_tx.ev_count = 0; 2180 #ifndef IXGBE_LEGACY_TX 2181 txr->pcq_drops.ev_count = 0; 2182 #endif 2183 txr->q_efbig_tx_dma_setup = 0; 2184 txr->q_mbuf_defrag_failed = 0; 2185 txr->q_efbig2_tx_dma_setup = 0; 2186 txr->q_einval_tx_dma_setup = 0; 2187 txr->q_other_tx_dma_setup = 0; 2188 txr->q_eagain_tx_dma_setup = 0; 2189 txr->q_enomem_tx_dma_setup = 0; 2190 txr->q_tso_err = 0; 2191 2192 if (i < __arraycount(stats->qprc)) { 2193 stats->qprc[i].ev_count = 0; 2194 stats->qptc[i].ev_count = 0; 2195 stats->qbrc[i].ev_count = 0; 2196 stats->qbtc[i].ev_count = 0; 2197 if (hw->mac.type >= ixgbe_mac_82599EB) 2198 stats->qprdc[i].ev_count = 0; 2199 } 2200 2201 rxr->rx_packets.ev_count = 0; 2202 rxr->rx_bytes.ev_count = 0; 2203 rxr->rx_copies.ev_count = 0; 2204 rxr->no_mbuf.ev_count = 0; 2205 rxr->rx_discarded.ev_count = 0; 2206 } 2207 stats->ipcs.ev_count = 0; 2208 stats->l4cs.ev_count = 0; 2209 stats->ipcs_bad.ev_count = 0; 2210 stats->l4cs_bad.ev_count = 0; 2211 stats->intzero.ev_count = 0; 2212 stats->legint.ev_count = 0; 2213 stats->crcerrs.ev_count = 0; 2214 stats->illerrc.ev_count = 0; 2215 stats->errbc.ev_count = 0; 2216 stats->mspdc.ev_count = 0; 2217 if (hw->mac.type >= ixgbe_mac_X550) 2218 stats->mbsdc.ev_count = 0; 2219 stats->mpctotal.ev_count = 0; 2220 stats->mlfc.ev_count = 0; 2221 stats->mrfc.ev_count = 0; 2222 stats->rlec.ev_count = 0; 2223 stats->lxontxc.ev_count = 0; 2224 stats->lxonrxc.ev_count = 0; 2225 stats->lxofftxc.ev_count = 0; 2226 stats->lxoffrxc.ev_count = 0; 2227 2228 /* Packet Reception Stats */ 2229 stats->tor.ev_count = 0; 2230 stats->gorc.ev_count = 0; 2231 stats->tpr.ev_count = 0; 2232 stats->gprc.ev_count = 0; 2233 stats->mprc.ev_count = 0; 2234 stats->bprc.ev_count = 0; 2235 stats->prc64.ev_count = 0; 2236 stats->prc127.ev_count = 0; 2237 stats->prc255.ev_count = 0; 2238 stats->prc511.ev_count = 0; 2239 stats->prc1023.ev_count = 0; 2240 stats->prc1522.ev_count = 0; 2241 stats->ruc.ev_count = 0; 2242 stats->rfc.ev_count = 0; 2243 stats->roc.ev_count = 0; 2244 stats->rjc.ev_count = 0; 2245 stats->mngprc.ev_count = 0; 2246 stats->mngpdc.ev_count = 0; 2247 stats->xec.ev_count = 0; 2248 2249 /* Packet Transmission Stats */ 2250 stats->gotc.ev_count = 0; 2251 stats->tpt.ev_count = 0; 2252 stats->gptc.ev_count = 0; 2253 stats->bptc.ev_count = 0; 2254 stats->mptc.ev_count = 0; 2255 stats->mngptc.ev_count = 0; 2256 stats->ptc64.ev_count = 0; 2257 stats->ptc127.ev_count = 0; 2258 stats->ptc255.ev_count = 0; 2259 stats->ptc511.ev_count = 0; 2260 stats->ptc1023.ev_count = 0; 2261 stats->ptc1522.ev_count = 0; 2262 } 2263 2264 /************************************************************************ 2265 * ixgbe_sysctl_tdh_handler - Transmit Descriptor Head handler function 2266 * 2267 * Retrieves the TDH value from the hardware 2268 ************************************************************************/ 2269 static int 2270 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 2271 { 2272 struct sysctlnode node = *rnode; 2273 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2274 struct adapter *adapter; 2275 uint32_t val; 2276 2277 if (!txr) 2278 return (0); 2279 2280 adapter = txr->adapter; 2281 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2282 return (EPERM); 2283 2284 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDH(txr->me)); 2285 node.sysctl_data = &val; 2286 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2287 } /* ixgbe_sysctl_tdh_handler */ 2288 2289 /************************************************************************ 2290 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 2291 * 2292 * Retrieves the TDT value from the hardware 2293 ************************************************************************/ 2294 static int 2295 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 2296 { 2297 struct sysctlnode node = *rnode; 2298 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2299 struct adapter *adapter; 2300 uint32_t val; 2301 2302 if (!txr) 2303 return (0); 2304 2305 adapter = txr->adapter; 2306 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2307 return (EPERM); 2308 2309 val = IXGBE_READ_REG(&adapter->hw, IXGBE_TDT(txr->me)); 2310 node.sysctl_data = &val; 2311 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2312 } /* ixgbe_sysctl_tdt_handler */ 2313 2314 /************************************************************************ 2315 * ixgbe_sysctl_next_to_check_handler - Receive Descriptor next to check 2316 * handler function 2317 * 2318 * Retrieves the next_to_check value 2319 ************************************************************************/ 2320 static int 2321 ixgbe_sysctl_next_to_check_handler(SYSCTLFN_ARGS) 2322 { 2323 struct sysctlnode node = *rnode; 2324 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2325 struct adapter *adapter; 2326 uint32_t val; 2327 2328 if (!rxr) 2329 return (0); 2330 2331 adapter = rxr->adapter; 2332 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2333 return (EPERM); 2334 2335 val = rxr->next_to_check; 2336 node.sysctl_data = &val; 2337 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2338 } /* ixgbe_sysctl_next_to_check_handler */ 2339 2340 /************************************************************************ 2341 * ixgbe_sysctl_next_to_refresh_handler - Receive Descriptor next to check 2342 * handler function 2343 * 2344 * Retrieves the next_to_refresh value 2345 ************************************************************************/ 2346 static int 2347 ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_ARGS) 2348 { 2349 struct sysctlnode node = *rnode; 2350 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2351 struct adapter *adapter; 2352 uint32_t val; 2353 2354 if (!rxr) 2355 return (0); 2356 2357 adapter = rxr->adapter; 2358 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2359 return (EPERM); 2360 2361 val = rxr->next_to_refresh; 2362 node.sysctl_data = &val; 2363 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2364 } /* ixgbe_sysctl_next_to_refresh_handler */ 2365 2366 /************************************************************************ 2367 * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function 2368 * 2369 * Retrieves the RDH value from the hardware 2370 ************************************************************************/ 2371 static int 2372 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 2373 { 2374 struct sysctlnode node = *rnode; 2375 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2376 struct adapter *adapter; 2377 uint32_t val; 2378 2379 if (!rxr) 2380 return (0); 2381 2382 adapter = rxr->adapter; 2383 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2384 return (EPERM); 2385 2386 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDH(rxr->me)); 2387 node.sysctl_data = &val; 2388 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2389 } /* ixgbe_sysctl_rdh_handler */ 2390 2391 /************************************************************************ 2392 * ixgbe_sysctl_rdt_handler - Receive Descriptor Tail handler function 2393 * 2394 * Retrieves the RDT value from the hardware 2395 ************************************************************************/ 2396 static int 2397 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 2398 { 2399 struct sysctlnode node = *rnode; 2400 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2401 struct adapter *adapter; 2402 uint32_t val; 2403 2404 if (!rxr) 2405 return (0); 2406 2407 adapter = rxr->adapter; 2408 if (ixgbe_fw_recovery_mode_swflag(adapter)) 2409 return (EPERM); 2410 2411 val = IXGBE_READ_REG(&adapter->hw, IXGBE_RDT(rxr->me)); 2412 node.sysctl_data = &val; 2413 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2414 } /* ixgbe_sysctl_rdt_handler */ 2415 2416 static int 2417 ixgbe_vlan_cb(struct ethercom *ec, uint16_t vid, bool set) 2418 { 2419 struct ifnet *ifp = &ec->ec_if; 2420 struct adapter *adapter = ifp->if_softc; 2421 int rv; 2422 2423 if (set) 2424 rv = ixgbe_register_vlan(adapter, vid); 2425 else 2426 rv = ixgbe_unregister_vlan(adapter, vid); 2427 2428 if (rv != 0) 2429 return rv; 2430 2431 /* 2432 * Control VLAN HW tagging when ec_nvlan is changed from 1 to 0 2433 * or 0 to 1. 2434 */ 2435 if ((set && (ec->ec_nvlans == 1)) || (!set && (ec->ec_nvlans == 0))) 2436 ixgbe_setup_vlan_hw_tagging(adapter); 2437 2438 return rv; 2439 } 2440 2441 /************************************************************************ 2442 * ixgbe_register_vlan 2443 * 2444 * Run via vlan config EVENT, it enables us to use the 2445 * HW Filter table since we can get the vlan id. This 2446 * just creates the entry in the soft version of the 2447 * VFTA, init will repopulate the real table. 2448 ************************************************************************/ 2449 static int 2450 ixgbe_register_vlan(struct adapter *adapter, u16 vtag) 2451 { 2452 u16 index, bit; 2453 int error; 2454 2455 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2456 return EINVAL; 2457 2458 IXGBE_CORE_LOCK(adapter); 2459 index = (vtag >> 5) & 0x7F; 2460 bit = vtag & 0x1F; 2461 adapter->shadow_vfta[index] |= ((u32)1 << bit); 2462 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, true, 2463 true); 2464 IXGBE_CORE_UNLOCK(adapter); 2465 if (error != 0) 2466 error = EACCES; 2467 2468 return error; 2469 } /* ixgbe_register_vlan */ 2470 2471 /************************************************************************ 2472 * ixgbe_unregister_vlan 2473 * 2474 * Run via vlan unconfig EVENT, remove our entry in the soft vfta. 2475 ************************************************************************/ 2476 static int 2477 ixgbe_unregister_vlan(struct adapter *adapter, u16 vtag) 2478 { 2479 u16 index, bit; 2480 int error; 2481 2482 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2483 return EINVAL; 2484 2485 IXGBE_CORE_LOCK(adapter); 2486 index = (vtag >> 5) & 0x7F; 2487 bit = vtag & 0x1F; 2488 adapter->shadow_vfta[index] &= ~((u32)1 << bit); 2489 error = adapter->hw.mac.ops.set_vfta(&adapter->hw, vtag, 0, false, 2490 true); 2491 IXGBE_CORE_UNLOCK(adapter); 2492 if (error != 0) 2493 error = EACCES; 2494 2495 return error; 2496 } /* ixgbe_unregister_vlan */ 2497 2498 static void 2499 ixgbe_setup_vlan_hw_tagging(struct adapter *adapter) 2500 { 2501 struct ethercom *ec = &adapter->osdep.ec; 2502 struct ixgbe_hw *hw = &adapter->hw; 2503 struct rx_ring *rxr; 2504 u32 ctrl; 2505 int i; 2506 bool hwtagging; 2507 2508 /* Enable HW tagging only if any vlan is attached */ 2509 hwtagging = (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) 2510 && VLAN_ATTACHED(ec); 2511 2512 /* Setup the queues for vlans */ 2513 for (i = 0; i < adapter->num_queues; i++) { 2514 rxr = &adapter->rx_rings[i]; 2515 /* 2516 * On 82599 and later, the VLAN enable is per/queue in RXDCTL. 2517 */ 2518 if (hw->mac.type != ixgbe_mac_82598EB) { 2519 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 2520 if (hwtagging) 2521 ctrl |= IXGBE_RXDCTL_VME; 2522 else 2523 ctrl &= ~IXGBE_RXDCTL_VME; 2524 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 2525 } 2526 rxr->vtag_strip = hwtagging ? TRUE : FALSE; 2527 } 2528 2529 /* VLAN hw tagging for 82598 */ 2530 if (hw->mac.type == ixgbe_mac_82598EB) { 2531 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2532 if (hwtagging) 2533 ctrl |= IXGBE_VLNCTRL_VME; 2534 else 2535 ctrl &= ~IXGBE_VLNCTRL_VME; 2536 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2537 } 2538 } /* ixgbe_setup_vlan_hw_tagging */ 2539 2540 static void 2541 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2542 { 2543 struct ethercom *ec = &adapter->osdep.ec; 2544 struct ixgbe_hw *hw = &adapter->hw; 2545 int i; 2546 u32 ctrl; 2547 struct vlanid_list *vlanidp; 2548 2549 /* 2550 * This function is called from both if_init and ifflags_cb() 2551 * on NetBSD. 2552 */ 2553 2554 /* 2555 * Part 1: 2556 * Setup VLAN HW tagging 2557 */ 2558 ixgbe_setup_vlan_hw_tagging(adapter); 2559 2560 /* 2561 * Part 2: 2562 * Setup VLAN HW filter 2563 */ 2564 /* Cleanup shadow_vfta */ 2565 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2566 adapter->shadow_vfta[i] = 0; 2567 /* Generate shadow_vfta from ec_vids */ 2568 ETHER_LOCK(ec); 2569 SIMPLEQ_FOREACH(vlanidp, &ec->ec_vids, vid_list) { 2570 uint32_t idx; 2571 2572 idx = vlanidp->vid / 32; 2573 KASSERT(idx < IXGBE_VFTA_SIZE); 2574 adapter->shadow_vfta[idx] |= (u32)1 << (vlanidp->vid % 32); 2575 } 2576 ETHER_UNLOCK(ec); 2577 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2578 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), adapter->shadow_vfta[i]); 2579 2580 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2581 /* Enable the Filter Table if enabled */ 2582 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) 2583 ctrl |= IXGBE_VLNCTRL_VFE; 2584 else 2585 ctrl &= ~IXGBE_VLNCTRL_VFE; 2586 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2587 } /* ixgbe_setup_vlan_hw_support */ 2588 2589 /************************************************************************ 2590 * ixgbe_get_slot_info 2591 * 2592 * Get the width and transaction speed of 2593 * the slot this adapter is plugged into. 2594 ************************************************************************/ 2595 static void 2596 ixgbe_get_slot_info(struct adapter *adapter) 2597 { 2598 device_t dev = adapter->dev; 2599 struct ixgbe_hw *hw = &adapter->hw; 2600 u32 offset; 2601 u16 link; 2602 int bus_info_valid = TRUE; 2603 2604 /* Some devices are behind an internal bridge */ 2605 switch (hw->device_id) { 2606 case IXGBE_DEV_ID_82599_SFP_SF_QP: 2607 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 2608 goto get_parent_info; 2609 default: 2610 break; 2611 } 2612 2613 ixgbe_get_bus_info(hw); 2614 2615 /* 2616 * Some devices don't use PCI-E, but there is no need 2617 * to display "Unknown" for bus speed and width. 2618 */ 2619 switch (hw->mac.type) { 2620 case ixgbe_mac_X550EM_x: 2621 case ixgbe_mac_X550EM_a: 2622 return; 2623 default: 2624 goto display; 2625 } 2626 2627 get_parent_info: 2628 /* 2629 * For the Quad port adapter we need to parse back 2630 * up the PCI tree to find the speed of the expansion 2631 * slot into which this adapter is plugged. A bit more work. 2632 */ 2633 dev = device_parent(device_parent(dev)); 2634 #if 0 2635 #ifdef IXGBE_DEBUG 2636 device_printf(dev, "parent pcib = %x,%x,%x\n", pci_get_bus(dev), 2637 pci_get_slot(dev), pci_get_function(dev)); 2638 #endif 2639 dev = device_parent(device_parent(dev)); 2640 #ifdef IXGBE_DEBUG 2641 device_printf(dev, "slot pcib = %x,%x,%x\n", pci_get_bus(dev), 2642 pci_get_slot(dev), pci_get_function(dev)); 2643 #endif 2644 #endif 2645 /* Now get the PCI Express Capabilities offset */ 2646 if (pci_get_capability(adapter->osdep.pc, adapter->osdep.tag, 2647 PCI_CAP_PCIEXPRESS, &offset, NULL)) { 2648 /* 2649 * Hmm...can't get PCI-Express capabilities. 2650 * Falling back to default method. 2651 */ 2652 bus_info_valid = FALSE; 2653 ixgbe_get_bus_info(hw); 2654 goto display; 2655 } 2656 /* ...and read the Link Status Register */ 2657 link = pci_conf_read(adapter->osdep.pc, adapter->osdep.tag, 2658 offset + PCIE_LCSR) >> 16; 2659 ixgbe_set_pci_config_data_generic(hw, link); 2660 2661 display: 2662 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 2663 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s" : 2664 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s" : 2665 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s" : 2666 "Unknown"), 2667 ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 2668 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 2669 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 2670 "Unknown")); 2671 2672 if (bus_info_valid) { 2673 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 2674 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 2675 (hw->bus.speed == ixgbe_bus_speed_2500))) { 2676 device_printf(dev, "PCI-Express bandwidth available" 2677 " for this card\n is not sufficient for" 2678 " optimal performance.\n"); 2679 device_printf(dev, "For optimal performance a x8 " 2680 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 2681 } 2682 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 2683 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 2684 (hw->bus.speed < ixgbe_bus_speed_8000))) { 2685 device_printf(dev, "PCI-Express bandwidth available" 2686 " for this card\n is not sufficient for" 2687 " optimal performance.\n"); 2688 device_printf(dev, "For optimal performance a x8 " 2689 "PCIE Gen3 slot is required.\n"); 2690 } 2691 } else 2692 device_printf(dev, "Unable to determine slot speed/width. The speed/width reported are that of the internal switch.\n"); 2693 2694 return; 2695 } /* ixgbe_get_slot_info */ 2696 2697 /************************************************************************ 2698 * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets 2699 ************************************************************************/ 2700 static inline void 2701 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 2702 { 2703 struct ixgbe_hw *hw = &adapter->hw; 2704 struct ix_queue *que = &adapter->queues[vector]; 2705 u64 queue = 1ULL << vector; 2706 u32 mask; 2707 2708 mutex_enter(&que->dc_mtx); 2709 if (que->disabled_count > 0 && --que->disabled_count > 0) 2710 goto out; 2711 2712 if (hw->mac.type == ixgbe_mac_82598EB) { 2713 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2714 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 2715 } else { 2716 mask = (queue & 0xFFFFFFFF); 2717 if (mask) 2718 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 2719 mask = (queue >> 32); 2720 if (mask) 2721 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 2722 } 2723 out: 2724 mutex_exit(&que->dc_mtx); 2725 } /* ixgbe_enable_queue */ 2726 2727 /************************************************************************ 2728 * ixgbe_disable_queue_internal 2729 ************************************************************************/ 2730 static inline void 2731 ixgbe_disable_queue_internal(struct adapter *adapter, u32 vector, bool nestok) 2732 { 2733 struct ixgbe_hw *hw = &adapter->hw; 2734 struct ix_queue *que = &adapter->queues[vector]; 2735 u64 queue = 1ULL << vector; 2736 u32 mask; 2737 2738 mutex_enter(&que->dc_mtx); 2739 2740 if (que->disabled_count > 0) { 2741 if (nestok) 2742 que->disabled_count++; 2743 goto out; 2744 } 2745 que->disabled_count++; 2746 2747 if (hw->mac.type == ixgbe_mac_82598EB) { 2748 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2749 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 2750 } else { 2751 mask = (queue & 0xFFFFFFFF); 2752 if (mask) 2753 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 2754 mask = (queue >> 32); 2755 if (mask) 2756 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 2757 } 2758 out: 2759 mutex_exit(&que->dc_mtx); 2760 } /* ixgbe_disable_queue_internal */ 2761 2762 /************************************************************************ 2763 * ixgbe_disable_queue 2764 ************************************************************************/ 2765 static inline void 2766 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 2767 { 2768 2769 ixgbe_disable_queue_internal(adapter, vector, true); 2770 } /* ixgbe_disable_queue */ 2771 2772 /************************************************************************ 2773 * ixgbe_sched_handle_que - schedule deferred packet processing 2774 ************************************************************************/ 2775 static inline void 2776 ixgbe_sched_handle_que(struct adapter *adapter, struct ix_queue *que) 2777 { 2778 2779 if (que->txrx_use_workqueue) { 2780 /* 2781 * adapter->que_wq is bound to each CPU instead of 2782 * each NIC queue to reduce workqueue kthread. As we 2783 * should consider about interrupt affinity in this 2784 * function, the workqueue kthread must be WQ_PERCPU. 2785 * If create WQ_PERCPU workqueue kthread for each NIC 2786 * queue, that number of created workqueue kthread is 2787 * (number of used NIC queue) * (number of CPUs) = 2788 * (number of CPUs) ^ 2 most often. 2789 * 2790 * The same NIC queue's interrupts are avoided by 2791 * masking the queue's interrupt. And different 2792 * NIC queue's interrupts use different struct work 2793 * (que->wq_cookie). So, "enqueued flag" to avoid 2794 * twice workqueue_enqueue() is not required . 2795 */ 2796 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, curcpu()); 2797 } else { 2798 softint_schedule(que->que_si); 2799 } 2800 } 2801 2802 /************************************************************************ 2803 * ixgbe_msix_que - MSI-X Queue Interrupt Service routine 2804 ************************************************************************/ 2805 static int 2806 ixgbe_msix_que(void *arg) 2807 { 2808 struct ix_queue *que = arg; 2809 struct adapter *adapter = que->adapter; 2810 struct ifnet *ifp = adapter->ifp; 2811 struct tx_ring *txr = que->txr; 2812 struct rx_ring *rxr = que->rxr; 2813 bool more; 2814 u32 newitr = 0; 2815 2816 /* Protect against spurious interrupts */ 2817 if ((ifp->if_flags & IFF_RUNNING) == 0) 2818 return 0; 2819 2820 ixgbe_disable_queue(adapter, que->msix); 2821 ++que->irqs.ev_count; 2822 2823 /* 2824 * Don't change "que->txrx_use_workqueue" from this point to avoid 2825 * flip-flopping softint/workqueue mode in one deferred processing. 2826 */ 2827 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 2828 2829 #ifdef __NetBSD__ 2830 /* Don't run ixgbe_rxeof in interrupt context */ 2831 more = true; 2832 #else 2833 more = ixgbe_rxeof(que); 2834 #endif 2835 2836 IXGBE_TX_LOCK(txr); 2837 ixgbe_txeof(txr); 2838 IXGBE_TX_UNLOCK(txr); 2839 2840 /* Do AIM now? */ 2841 2842 if (adapter->enable_aim == false) 2843 goto no_calc; 2844 /* 2845 * Do Adaptive Interrupt Moderation: 2846 * - Write out last calculated setting 2847 * - Calculate based on average size over 2848 * the last interval. 2849 */ 2850 if (que->eitr_setting) 2851 ixgbe_eitr_write(adapter, que->msix, que->eitr_setting); 2852 2853 que->eitr_setting = 0; 2854 2855 /* Idle, do nothing */ 2856 if ((txr->bytes == 0) && (rxr->bytes == 0)) 2857 goto no_calc; 2858 2859 if ((txr->bytes) && (txr->packets)) 2860 newitr = txr->bytes/txr->packets; 2861 if ((rxr->bytes) && (rxr->packets)) 2862 newitr = uimax(newitr, (rxr->bytes / rxr->packets)); 2863 newitr += 24; /* account for hardware frame, crc */ 2864 2865 /* set an upper boundary */ 2866 newitr = uimin(newitr, 3000); 2867 2868 /* Be nice to the mid range */ 2869 if ((newitr > 300) && (newitr < 1200)) 2870 newitr = (newitr / 3); 2871 else 2872 newitr = (newitr / 2); 2873 2874 /* 2875 * When RSC is used, ITR interval must be larger than RSC_DELAY. 2876 * Currently, we use 2us for RSC_DELAY. The minimum value is always 2877 * greater than 2us on 100M (and 10M?(not documented)), but it's not 2878 * on 1G and higher. 2879 */ 2880 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2881 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2882 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 2883 newitr = IXGBE_MIN_RSC_EITR_10G1G; 2884 } 2885 2886 /* save for next interrupt */ 2887 que->eitr_setting = newitr; 2888 2889 /* Reset state */ 2890 txr->bytes = 0; 2891 txr->packets = 0; 2892 rxr->bytes = 0; 2893 rxr->packets = 0; 2894 2895 no_calc: 2896 if (more) 2897 ixgbe_sched_handle_que(adapter, que); 2898 else 2899 ixgbe_enable_queue(adapter, que->msix); 2900 2901 return 1; 2902 } /* ixgbe_msix_que */ 2903 2904 /************************************************************************ 2905 * ixgbe_media_status - Media Ioctl callback 2906 * 2907 * Called whenever the user queries the status of 2908 * the interface using ifconfig. 2909 ************************************************************************/ 2910 static void 2911 ixgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2912 { 2913 struct adapter *adapter = ifp->if_softc; 2914 struct ixgbe_hw *hw = &adapter->hw; 2915 int layer; 2916 2917 INIT_DEBUGOUT("ixgbe_media_status: begin"); 2918 ixgbe_update_link_status(adapter); 2919 2920 ifmr->ifm_status = IFM_AVALID; 2921 ifmr->ifm_active = IFM_ETHER; 2922 2923 if (adapter->link_active != LINK_STATE_UP) { 2924 ifmr->ifm_active |= IFM_NONE; 2925 return; 2926 } 2927 2928 ifmr->ifm_status |= IFM_ACTIVE; 2929 layer = adapter->phy_layer; 2930 2931 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2932 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2933 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2934 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2935 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2936 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2937 switch (adapter->link_speed) { 2938 case IXGBE_LINK_SPEED_10GB_FULL: 2939 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2940 break; 2941 case IXGBE_LINK_SPEED_5GB_FULL: 2942 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2943 break; 2944 case IXGBE_LINK_SPEED_2_5GB_FULL: 2945 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2946 break; 2947 case IXGBE_LINK_SPEED_1GB_FULL: 2948 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2949 break; 2950 case IXGBE_LINK_SPEED_100_FULL: 2951 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2952 break; 2953 case IXGBE_LINK_SPEED_10_FULL: 2954 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2955 break; 2956 } 2957 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2958 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2959 switch (adapter->link_speed) { 2960 case IXGBE_LINK_SPEED_10GB_FULL: 2961 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2962 break; 2963 } 2964 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2965 switch (adapter->link_speed) { 2966 case IXGBE_LINK_SPEED_10GB_FULL: 2967 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2968 break; 2969 case IXGBE_LINK_SPEED_1GB_FULL: 2970 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2971 break; 2972 } 2973 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2974 switch (adapter->link_speed) { 2975 case IXGBE_LINK_SPEED_10GB_FULL: 2976 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2977 break; 2978 case IXGBE_LINK_SPEED_1GB_FULL: 2979 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2980 break; 2981 } 2982 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2983 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2984 switch (adapter->link_speed) { 2985 case IXGBE_LINK_SPEED_10GB_FULL: 2986 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2987 break; 2988 case IXGBE_LINK_SPEED_1GB_FULL: 2989 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2990 break; 2991 } 2992 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2993 switch (adapter->link_speed) { 2994 case IXGBE_LINK_SPEED_10GB_FULL: 2995 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2996 break; 2997 } 2998 /* 2999 * XXX: These need to use the proper media types once 3000 * they're added. 3001 */ 3002 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 3003 switch (adapter->link_speed) { 3004 case IXGBE_LINK_SPEED_10GB_FULL: 3005 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 3006 break; 3007 case IXGBE_LINK_SPEED_2_5GB_FULL: 3008 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 3009 break; 3010 case IXGBE_LINK_SPEED_1GB_FULL: 3011 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 3012 break; 3013 } 3014 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 3015 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 3016 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 3017 switch (adapter->link_speed) { 3018 case IXGBE_LINK_SPEED_10GB_FULL: 3019 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 3020 break; 3021 case IXGBE_LINK_SPEED_2_5GB_FULL: 3022 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 3023 break; 3024 case IXGBE_LINK_SPEED_1GB_FULL: 3025 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 3026 break; 3027 } 3028 3029 /* If nothing is recognized... */ 3030 #if 0 3031 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 3032 ifmr->ifm_active |= IFM_UNKNOWN; 3033 #endif 3034 3035 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 3036 3037 /* Display current flow control setting used on link */ 3038 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 3039 hw->fc.current_mode == ixgbe_fc_full) 3040 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 3041 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 3042 hw->fc.current_mode == ixgbe_fc_full) 3043 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 3044 3045 return; 3046 } /* ixgbe_media_status */ 3047 3048 /************************************************************************ 3049 * ixgbe_media_change - Media Ioctl callback 3050 * 3051 * Called when the user changes speed/duplex using 3052 * media/mediopt option with ifconfig. 3053 ************************************************************************/ 3054 static int 3055 ixgbe_media_change(struct ifnet *ifp) 3056 { 3057 struct adapter *adapter = ifp->if_softc; 3058 struct ifmedia *ifm = &adapter->media; 3059 struct ixgbe_hw *hw = &adapter->hw; 3060 ixgbe_link_speed speed = 0; 3061 ixgbe_link_speed link_caps = 0; 3062 bool negotiate = false; 3063 s32 err = IXGBE_NOT_IMPLEMENTED; 3064 3065 INIT_DEBUGOUT("ixgbe_media_change: begin"); 3066 3067 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 3068 return (EINVAL); 3069 3070 if (hw->phy.media_type == ixgbe_media_type_backplane) 3071 return (EPERM); 3072 3073 /* 3074 * We don't actually need to check against the supported 3075 * media types of the adapter; ifmedia will take care of 3076 * that for us. 3077 */ 3078 switch (IFM_SUBTYPE(ifm->ifm_media)) { 3079 case IFM_AUTO: 3080 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 3081 &negotiate); 3082 if (err != IXGBE_SUCCESS) { 3083 device_printf(adapter->dev, "Unable to determine " 3084 "supported advertise speeds\n"); 3085 return (ENODEV); 3086 } 3087 speed |= link_caps; 3088 break; 3089 case IFM_10G_T: 3090 case IFM_10G_LRM: 3091 case IFM_10G_LR: 3092 case IFM_10G_TWINAX: 3093 case IFM_10G_SR: 3094 case IFM_10G_CX4: 3095 case IFM_10G_KR: 3096 case IFM_10G_KX4: 3097 speed |= IXGBE_LINK_SPEED_10GB_FULL; 3098 break; 3099 case IFM_5000_T: 3100 speed |= IXGBE_LINK_SPEED_5GB_FULL; 3101 break; 3102 case IFM_2500_T: 3103 case IFM_2500_KX: 3104 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 3105 break; 3106 case IFM_1000_T: 3107 case IFM_1000_LX: 3108 case IFM_1000_SX: 3109 case IFM_1000_KX: 3110 speed |= IXGBE_LINK_SPEED_1GB_FULL; 3111 break; 3112 case IFM_100_TX: 3113 speed |= IXGBE_LINK_SPEED_100_FULL; 3114 break; 3115 case IFM_10_T: 3116 speed |= IXGBE_LINK_SPEED_10_FULL; 3117 break; 3118 case IFM_NONE: 3119 break; 3120 default: 3121 goto invalid; 3122 } 3123 3124 hw->mac.autotry_restart = TRUE; 3125 hw->mac.ops.setup_link(hw, speed, TRUE); 3126 adapter->advertise = 0; 3127 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 3128 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 3129 adapter->advertise |= 1 << 2; 3130 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 3131 adapter->advertise |= 1 << 1; 3132 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 3133 adapter->advertise |= 1 << 0; 3134 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 3135 adapter->advertise |= 1 << 3; 3136 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 3137 adapter->advertise |= 1 << 4; 3138 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 3139 adapter->advertise |= 1 << 5; 3140 } 3141 3142 return (0); 3143 3144 invalid: 3145 device_printf(adapter->dev, "Invalid media type!\n"); 3146 3147 return (EINVAL); 3148 } /* ixgbe_media_change */ 3149 3150 /************************************************************************ 3151 * ixgbe_msix_admin - Link status change ISR (MSI/MSI-X) 3152 ************************************************************************/ 3153 static int 3154 ixgbe_msix_admin(void *arg) 3155 { 3156 struct adapter *adapter = arg; 3157 struct ixgbe_hw *hw = &adapter->hw; 3158 u32 eicr; 3159 u32 eims_orig; 3160 u32 eims_disable = 0; 3161 3162 ++adapter->admin_irqev.ev_count; 3163 3164 eims_orig = IXGBE_READ_REG(hw, IXGBE_EIMS); 3165 /* Pause other interrupts */ 3166 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_MSIX_OTHER_CLEAR_MASK); 3167 3168 /* 3169 * First get the cause. 3170 * 3171 * The specifications of 82598, 82599, X540 and X550 say EICS register 3172 * is write only. However, Linux says it is a workaround for silicon 3173 * errata to read EICS instead of EICR to get interrupt cause. 3174 * At least, reading EICR clears lower 16bits of EIMS on 82598. 3175 */ 3176 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 3177 /* Be sure the queue bits are not cleared */ 3178 eicr &= ~IXGBE_EICR_RTX_QUEUE; 3179 /* Clear all OTHER interrupts with write */ 3180 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 3181 3182 ixgbe_intr_admin_common(adapter, eicr, &eims_disable); 3183 3184 /* Re-enable some OTHER interrupts */ 3185 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_orig & ~eims_disable); 3186 3187 return 1; 3188 } /* ixgbe_msix_admin */ 3189 3190 static void 3191 ixgbe_intr_admin_common(struct adapter *adapter, u32 eicr, u32 *eims_disable) 3192 { 3193 struct ixgbe_hw *hw = &adapter->hw; 3194 u32 eicr_mask; 3195 u32 task_requests = 0; 3196 s32 retval; 3197 3198 /* Link status change */ 3199 if (eicr & IXGBE_EICR_LSC) { 3200 task_requests |= IXGBE_REQUEST_TASK_LSC; 3201 *eims_disable |= IXGBE_EIMS_LSC; 3202 } 3203 3204 if (ixgbe_is_sfp(hw)) { 3205 /* Pluggable optics-related interrupt */ 3206 if (hw->mac.type >= ixgbe_mac_X540) 3207 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 3208 else 3209 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 3210 3211 /* 3212 * An interrupt might not arrive when a module is inserted. 3213 * When an link status change interrupt occurred and the driver 3214 * still regard SFP as unplugged, issue the module softint 3215 * and then issue LSC interrupt. 3216 */ 3217 if ((eicr & eicr_mask) 3218 || ((hw->phy.sfp_type == ixgbe_sfp_type_not_present) 3219 && (eicr & IXGBE_EICR_LSC))) { 3220 task_requests |= IXGBE_REQUEST_TASK_MOD; 3221 *eims_disable |= IXGBE_EIMS_LSC; 3222 } 3223 3224 if ((hw->mac.type == ixgbe_mac_82599EB) && 3225 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 3226 task_requests |= IXGBE_REQUEST_TASK_MSF; 3227 *eims_disable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 3228 } 3229 } 3230 3231 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 3232 if ((adapter->feat_en & IXGBE_FEATURE_FDIR) && 3233 (eicr & IXGBE_EICR_FLOW_DIR)) { 3234 if (!atomic_cas_uint(&adapter->fdir_reinit, 0, 1)) { 3235 task_requests |= IXGBE_REQUEST_TASK_FDIR; 3236 /* Disable the interrupt */ 3237 *eims_disable |= IXGBE_EIMS_FLOW_DIR; 3238 } 3239 } 3240 3241 if (eicr & IXGBE_EICR_ECC) { 3242 device_printf(adapter->dev, 3243 "CRITICAL: ECC ERROR!! Please Reboot!!\n"); 3244 /* Disable interrupt to prevent log spam */ 3245 *eims_disable |= IXGBE_EICR_ECC; 3246 } 3247 3248 /* Check for over temp condition */ 3249 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) { 3250 switch (adapter->hw.mac.type) { 3251 case ixgbe_mac_X550EM_a: 3252 if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a)) 3253 break; 3254 /* Disable interrupt to prevent log spam */ 3255 *eims_disable |= IXGBE_EICR_GPI_SDP0_X550EM_a; 3256 3257 retval = hw->phy.ops.check_overtemp(hw); 3258 if (retval != IXGBE_ERR_OVERTEMP) 3259 break; 3260 device_printf(adapter->dev, 3261 "CRITICAL: OVER TEMP!! " 3262 "PHY IS SHUT DOWN!!\n"); 3263 device_printf(adapter->dev, 3264 "System shutdown required!\n"); 3265 break; 3266 default: 3267 if (!(eicr & IXGBE_EICR_TS)) 3268 break; 3269 /* Disable interrupt to prevent log spam */ 3270 *eims_disable |= IXGBE_EIMS_TS; 3271 3272 retval = hw->phy.ops.check_overtemp(hw); 3273 if (retval != IXGBE_ERR_OVERTEMP) 3274 break; 3275 device_printf(adapter->dev, 3276 "CRITICAL: OVER TEMP!! " 3277 "PHY IS SHUT DOWN!!\n"); 3278 device_printf(adapter->dev, 3279 "System shutdown required!\n"); 3280 break; 3281 } 3282 } 3283 3284 /* Check for VF message */ 3285 if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) && 3286 (eicr & IXGBE_EICR_MAILBOX)) { 3287 task_requests |= IXGBE_REQUEST_TASK_MBX; 3288 *eims_disable |= IXGBE_EIMS_MAILBOX; 3289 } 3290 } 3291 3292 /* Check for fan failure */ 3293 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 3294 retval = ixgbe_check_fan_failure(adapter, eicr, true); 3295 if (retval == IXGBE_ERR_FAN_FAILURE) { 3296 /* Disable interrupt to prevent log spam */ 3297 *eims_disable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 3298 } 3299 } 3300 3301 /* External PHY interrupt */ 3302 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 3303 (eicr & IXGBE_EICR_GPI_SDP0_X540)) { 3304 task_requests |= IXGBE_REQUEST_TASK_PHY; 3305 *eims_disable |= IXGBE_EICR_GPI_SDP0_X540; 3306 } 3307 3308 if (task_requests != 0) { 3309 mutex_enter(&adapter->admin_mtx); 3310 adapter->task_requests |= task_requests; 3311 ixgbe_schedule_admin_tasklet(adapter); 3312 mutex_exit(&adapter->admin_mtx); 3313 } 3314 3315 } 3316 3317 static void 3318 ixgbe_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 3319 { 3320 3321 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 3322 itr |= itr << 16; 3323 else 3324 itr |= IXGBE_EITR_CNT_WDIS; 3325 3326 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(index), itr); 3327 } 3328 3329 3330 /************************************************************************ 3331 * ixgbe_sysctl_interrupt_rate_handler 3332 ************************************************************************/ 3333 static int 3334 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3335 { 3336 struct sysctlnode node = *rnode; 3337 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 3338 struct adapter *adapter; 3339 uint32_t reg, usec, rate; 3340 int error; 3341 3342 if (que == NULL) 3343 return 0; 3344 3345 adapter = que->adapter; 3346 if (ixgbe_fw_recovery_mode_swflag(adapter)) 3347 return (EPERM); 3348 3349 reg = IXGBE_READ_REG(&adapter->hw, IXGBE_EITR(que->msix)); 3350 usec = ((reg & 0x0FF8) >> 3); 3351 if (usec > 0) 3352 rate = 500000 / usec; 3353 else 3354 rate = 0; 3355 node.sysctl_data = &rate; 3356 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3357 if (error || newp == NULL) 3358 return error; 3359 reg &= ~0xfff; /* default, no limitation */ 3360 if (rate > 0 && rate < 500000) { 3361 if (rate < 1000) 3362 rate = 1000; 3363 reg |= ((4000000 / rate) & 0xff8); 3364 /* 3365 * When RSC is used, ITR interval must be larger than 3366 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 3367 * The minimum value is always greater than 2us on 100M 3368 * (and 10M?(not documented)), but it's not on 1G and higher. 3369 */ 3370 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 3371 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 3372 if ((adapter->num_queues > 1) 3373 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 3374 return EINVAL; 3375 } 3376 ixgbe_max_interrupt_rate = rate; 3377 } else 3378 ixgbe_max_interrupt_rate = 0; 3379 ixgbe_eitr_write(adapter, que->msix, reg); 3380 3381 return (0); 3382 } /* ixgbe_sysctl_interrupt_rate_handler */ 3383 3384 const struct sysctlnode * 3385 ixgbe_sysctl_instance(struct adapter *adapter) 3386 { 3387 const char *dvname; 3388 struct sysctllog **log; 3389 int rc; 3390 const struct sysctlnode *rnode; 3391 3392 if (adapter->sysctltop != NULL) 3393 return adapter->sysctltop; 3394 3395 log = &adapter->sysctllog; 3396 dvname = device_xname(adapter->dev); 3397 3398 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3399 0, CTLTYPE_NODE, dvname, 3400 SYSCTL_DESCR("ixgbe information and settings"), 3401 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3402 goto err; 3403 3404 return rnode; 3405 err: 3406 device_printf(adapter->dev, 3407 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3408 return NULL; 3409 } 3410 3411 /************************************************************************ 3412 * ixgbe_add_device_sysctls 3413 ************************************************************************/ 3414 static void 3415 ixgbe_add_device_sysctls(struct adapter *adapter) 3416 { 3417 device_t dev = adapter->dev; 3418 struct ixgbe_hw *hw = &adapter->hw; 3419 struct sysctllog **log; 3420 const struct sysctlnode *rnode, *cnode; 3421 3422 log = &adapter->sysctllog; 3423 3424 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3425 aprint_error_dev(dev, "could not create sysctl root\n"); 3426 return; 3427 } 3428 3429 if (sysctl_createv(log, 0, &rnode, &cnode, 3430 CTLFLAG_READWRITE, CTLTYPE_INT, 3431 "debug", SYSCTL_DESCR("Debug Info"), 3432 ixgbe_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) 3433 != 0) 3434 aprint_error_dev(dev, "could not create sysctl\n"); 3435 3436 if (sysctl_createv(log, 0, &rnode, &cnode, 3437 CTLFLAG_READWRITE, CTLTYPE_INT, 3438 "rx_copy_len", SYSCTL_DESCR("RX Copy Length"), 3439 ixgbe_sysctl_rx_copy_len, 0, 3440 (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 3441 aprint_error_dev(dev, "could not create sysctl\n"); 3442 3443 if (sysctl_createv(log, 0, &rnode, &cnode, 3444 CTLFLAG_READONLY, CTLTYPE_INT, 3445 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 3446 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 3447 aprint_error_dev(dev, "could not create sysctl\n"); 3448 3449 if (sysctl_createv(log, 0, &rnode, &cnode, 3450 CTLFLAG_READONLY, CTLTYPE_INT, 3451 "num_queues", SYSCTL_DESCR("Number of queues"), 3452 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 3453 aprint_error_dev(dev, "could not create sysctl\n"); 3454 3455 /* Sysctls for all devices */ 3456 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3457 CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 3458 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, 3459 CTL_EOL) != 0) 3460 aprint_error_dev(dev, "could not create sysctl\n"); 3461 3462 adapter->enable_aim = ixgbe_enable_aim; 3463 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3464 CTLTYPE_BOOL, "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 3465 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 3466 aprint_error_dev(dev, "could not create sysctl\n"); 3467 3468 if (sysctl_createv(log, 0, &rnode, &cnode, 3469 CTLFLAG_READWRITE, CTLTYPE_INT, 3470 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 3471 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, 3472 CTL_EOL) != 0) 3473 aprint_error_dev(dev, "could not create sysctl\n"); 3474 3475 /* 3476 * If each "que->txrx_use_workqueue" is changed in sysctl handler, 3477 * it causesflip-flopping softint/workqueue mode in one deferred 3478 * processing. Therefore, preempt_disable()/preempt_enable() are 3479 * required in ixgbe_sched_handle_que() to avoid 3480 * KASSERT(ixgbe_sched_handle_que()) in softint_schedule(). 3481 * I think changing "que->txrx_use_workqueue" in interrupt handler 3482 * is lighter than doing preempt_disable()/preempt_enable() in every 3483 * ixgbe_sched_handle_que(). 3484 */ 3485 adapter->txrx_use_workqueue = ixgbe_txrx_workqueue; 3486 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3487 CTLTYPE_BOOL, "txrx_workqueue", 3488 SYSCTL_DESCR("Use workqueue for packet processing"), 3489 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, 3490 CTL_EOL) != 0) 3491 aprint_error_dev(dev, "could not create sysctl\n"); 3492 3493 #ifdef IXGBE_DEBUG 3494 /* testing sysctls (for all devices) */ 3495 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3496 CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"), 3497 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, 3498 CTL_EOL) != 0) 3499 aprint_error_dev(dev, "could not create sysctl\n"); 3500 3501 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY, 3502 CTLTYPE_STRING, "print_rss_config", 3503 SYSCTL_DESCR("Prints RSS Configuration"), 3504 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, 3505 CTL_EOL) != 0) 3506 aprint_error_dev(dev, "could not create sysctl\n"); 3507 #endif 3508 /* for X550 series devices */ 3509 if (hw->mac.type >= ixgbe_mac_X550) 3510 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3511 CTLTYPE_INT, "dmac", SYSCTL_DESCR("DMA Coalesce"), 3512 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, 3513 CTL_EOL) != 0) 3514 aprint_error_dev(dev, "could not create sysctl\n"); 3515 3516 /* for WoL-capable devices */ 3517 if (adapter->wol_support) { 3518 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3519 CTLTYPE_BOOL, "wol_enable", 3520 SYSCTL_DESCR("Enable/Disable Wake on LAN"), 3521 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, 3522 CTL_EOL) != 0) 3523 aprint_error_dev(dev, "could not create sysctl\n"); 3524 3525 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3526 CTLTYPE_INT, "wufc", 3527 SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 3528 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, 3529 CTL_EOL) != 0) 3530 aprint_error_dev(dev, "could not create sysctl\n"); 3531 } 3532 3533 /* for X552/X557-AT devices */ 3534 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3535 const struct sysctlnode *phy_node; 3536 3537 if (sysctl_createv(log, 0, &rnode, &phy_node, 0, CTLTYPE_NODE, 3538 "phy", SYSCTL_DESCR("External PHY sysctls"), 3539 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 3540 aprint_error_dev(dev, "could not create sysctl\n"); 3541 return; 3542 } 3543 3544 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3545 CTLTYPE_INT, "temp", 3546 SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 3547 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, 3548 CTL_EOL) != 0) 3549 aprint_error_dev(dev, "could not create sysctl\n"); 3550 3551 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3552 CTLTYPE_INT, "overtemp_occurred", 3553 SYSCTL_DESCR( 3554 "External PHY High Temperature Event Occurred"), 3555 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, 3556 CTL_CREATE, CTL_EOL) != 0) 3557 aprint_error_dev(dev, "could not create sysctl\n"); 3558 } 3559 3560 if ((hw->mac.type == ixgbe_mac_X550EM_a) 3561 && (hw->phy.type == ixgbe_phy_fw)) 3562 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3563 CTLTYPE_BOOL, "force_10_100_autonego", 3564 SYSCTL_DESCR("Force autonego on 10M and 100M"), 3565 NULL, 0, &hw->phy.force_10_100_autonego, 0, 3566 CTL_CREATE, CTL_EOL) != 0) 3567 aprint_error_dev(dev, "could not create sysctl\n"); 3568 3569 if (adapter->feat_cap & IXGBE_FEATURE_EEE) { 3570 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3571 CTLTYPE_INT, "eee_state", 3572 SYSCTL_DESCR("EEE Power Save State"), 3573 ixgbe_sysctl_eee_state, 0, (void *)adapter, 0, CTL_CREATE, 3574 CTL_EOL) != 0) 3575 aprint_error_dev(dev, "could not create sysctl\n"); 3576 } 3577 } /* ixgbe_add_device_sysctls */ 3578 3579 /************************************************************************ 3580 * ixgbe_allocate_pci_resources 3581 ************************************************************************/ 3582 static int 3583 ixgbe_allocate_pci_resources(struct adapter *adapter, 3584 const struct pci_attach_args *pa) 3585 { 3586 pcireg_t memtype, csr; 3587 device_t dev = adapter->dev; 3588 bus_addr_t addr; 3589 int flags; 3590 3591 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 3592 switch (memtype) { 3593 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 3594 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 3595 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 3596 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 3597 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 3598 goto map_err; 3599 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 3600 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 3601 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 3602 } 3603 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 3604 adapter->osdep.mem_size, flags, 3605 &adapter->osdep.mem_bus_space_handle) != 0) { 3606 map_err: 3607 adapter->osdep.mem_size = 0; 3608 aprint_error_dev(dev, "unable to map BAR0\n"); 3609 return ENXIO; 3610 } 3611 /* 3612 * Enable address decoding for memory range in case BIOS or 3613 * UEFI don't set it. 3614 */ 3615 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 3616 PCI_COMMAND_STATUS_REG); 3617 csr |= PCI_COMMAND_MEM_ENABLE; 3618 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 3619 csr); 3620 break; 3621 default: 3622 aprint_error_dev(dev, "unexpected type on BAR0\n"); 3623 return ENXIO; 3624 } 3625 3626 return (0); 3627 } /* ixgbe_allocate_pci_resources */ 3628 3629 static void 3630 ixgbe_free_deferred_handlers(struct adapter *adapter) 3631 { 3632 struct ix_queue *que = adapter->queues; 3633 struct tx_ring *txr = adapter->tx_rings; 3634 int i; 3635 3636 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 3637 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 3638 if (txr->txr_si != NULL) 3639 softint_disestablish(txr->txr_si); 3640 } 3641 if (que->que_si != NULL) 3642 softint_disestablish(que->que_si); 3643 } 3644 if (adapter->txr_wq != NULL) 3645 workqueue_destroy(adapter->txr_wq); 3646 if (adapter->txr_wq_enqueued != NULL) 3647 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 3648 if (adapter->que_wq != NULL) 3649 workqueue_destroy(adapter->que_wq); 3650 3651 if (adapter->admin_wq != NULL) { 3652 workqueue_destroy(adapter->admin_wq); 3653 adapter->admin_wq = NULL; 3654 } 3655 if (adapter->timer_wq != NULL) { 3656 workqueue_destroy(adapter->timer_wq); 3657 adapter->timer_wq = NULL; 3658 } 3659 if (adapter->recovery_mode_timer_wq != NULL) { 3660 /* 3661 * ixgbe_ifstop() doesn't call the workqueue_wait() for 3662 * the recovery_mode_timer workqueue, so call it here. 3663 */ 3664 workqueue_wait(adapter->recovery_mode_timer_wq, 3665 &adapter->recovery_mode_timer_wc); 3666 atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0); 3667 workqueue_destroy(adapter->recovery_mode_timer_wq); 3668 adapter->recovery_mode_timer_wq = NULL; 3669 } 3670 } /* ixgbe_free_deferred_handlers */ 3671 3672 /************************************************************************ 3673 * ixgbe_detach - Device removal routine 3674 * 3675 * Called when the driver is being removed. 3676 * Stops the adapter and deallocates all the resources 3677 * that were allocated for driver operation. 3678 * 3679 * return 0 on success, positive on failure 3680 ************************************************************************/ 3681 static int 3682 ixgbe_detach(device_t dev, int flags) 3683 { 3684 struct adapter *adapter = device_private(dev); 3685 struct rx_ring *rxr = adapter->rx_rings; 3686 struct tx_ring *txr = adapter->tx_rings; 3687 struct ixgbe_hw *hw = &adapter->hw; 3688 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 3689 u32 ctrl_ext; 3690 int i; 3691 3692 INIT_DEBUGOUT("ixgbe_detach: begin"); 3693 if (adapter->osdep.attached == false) 3694 return 0; 3695 3696 if (ixgbe_pci_iov_detach(dev) != 0) { 3697 device_printf(dev, "SR-IOV in use; detach first.\n"); 3698 return (EBUSY); 3699 } 3700 3701 if (VLAN_ATTACHED(&adapter->osdep.ec) && 3702 (flags & (DETACH_SHUTDOWN | DETACH_FORCE)) == 0) { 3703 aprint_error_dev(dev, "VLANs in use, detach first\n"); 3704 return (EBUSY); 3705 } 3706 3707 ether_ifdetach(adapter->ifp); 3708 3709 adapter->osdep.detaching = true; 3710 /* 3711 * Stop the interface. ixgbe_setup_low_power_mode() calls 3712 * ixgbe_ifstop(), so it's not required to call ixgbe_ifstop() 3713 * directly. 3714 */ 3715 ixgbe_setup_low_power_mode(adapter); 3716 3717 callout_halt(&adapter->timer, NULL); 3718 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 3719 callout_halt(&adapter->recovery_mode_timer, NULL); 3720 3721 workqueue_wait(adapter->admin_wq, &adapter->admin_wc); 3722 atomic_store_relaxed(&adapter->admin_pending, 0); 3723 workqueue_wait(adapter->timer_wq, &adapter->timer_wc); 3724 atomic_store_relaxed(&adapter->timer_pending, 0); 3725 3726 pmf_device_deregister(dev); 3727 3728 ixgbe_free_deferred_handlers(adapter); 3729 3730 /* let hardware know driver is unloading */ 3731 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 3732 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 3733 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 3734 3735 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 3736 netmap_detach(adapter->ifp); 3737 3738 ixgbe_free_pci_resources(adapter); 3739 #if 0 /* XXX the NetBSD port is probably missing something here */ 3740 bus_generic_detach(dev); 3741 #endif 3742 if_detach(adapter->ifp); 3743 ifmedia_fini(&adapter->media); 3744 if_percpuq_destroy(adapter->ipq); 3745 3746 sysctl_teardown(&adapter->sysctllog); 3747 evcnt_detach(&adapter->efbig_tx_dma_setup); 3748 evcnt_detach(&adapter->mbuf_defrag_failed); 3749 evcnt_detach(&adapter->efbig2_tx_dma_setup); 3750 evcnt_detach(&adapter->einval_tx_dma_setup); 3751 evcnt_detach(&adapter->other_tx_dma_setup); 3752 evcnt_detach(&adapter->eagain_tx_dma_setup); 3753 evcnt_detach(&adapter->enomem_tx_dma_setup); 3754 evcnt_detach(&adapter->watchdog_events); 3755 evcnt_detach(&adapter->tso_err); 3756 evcnt_detach(&adapter->admin_irqev); 3757 evcnt_detach(&adapter->link_workev); 3758 evcnt_detach(&adapter->mod_workev); 3759 evcnt_detach(&adapter->msf_workev); 3760 evcnt_detach(&adapter->phy_workev); 3761 3762 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 3763 if (i < __arraycount(stats->mpc)) { 3764 evcnt_detach(&stats->mpc[i]); 3765 if (hw->mac.type == ixgbe_mac_82598EB) 3766 evcnt_detach(&stats->rnbc[i]); 3767 } 3768 if (i < __arraycount(stats->pxontxc)) { 3769 evcnt_detach(&stats->pxontxc[i]); 3770 evcnt_detach(&stats->pxonrxc[i]); 3771 evcnt_detach(&stats->pxofftxc[i]); 3772 evcnt_detach(&stats->pxoffrxc[i]); 3773 if (hw->mac.type >= ixgbe_mac_82599EB) 3774 evcnt_detach(&stats->pxon2offc[i]); 3775 } 3776 } 3777 3778 txr = adapter->tx_rings; 3779 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3780 evcnt_detach(&adapter->queues[i].irqs); 3781 evcnt_detach(&adapter->queues[i].handleq); 3782 evcnt_detach(&adapter->queues[i].req); 3783 evcnt_detach(&txr->no_desc_avail); 3784 evcnt_detach(&txr->total_packets); 3785 evcnt_detach(&txr->tso_tx); 3786 #ifndef IXGBE_LEGACY_TX 3787 evcnt_detach(&txr->pcq_drops); 3788 #endif 3789 3790 if (i < __arraycount(stats->qprc)) { 3791 evcnt_detach(&stats->qprc[i]); 3792 evcnt_detach(&stats->qptc[i]); 3793 evcnt_detach(&stats->qbrc[i]); 3794 evcnt_detach(&stats->qbtc[i]); 3795 if (hw->mac.type >= ixgbe_mac_82599EB) 3796 evcnt_detach(&stats->qprdc[i]); 3797 } 3798 3799 evcnt_detach(&rxr->rx_packets); 3800 evcnt_detach(&rxr->rx_bytes); 3801 evcnt_detach(&rxr->rx_copies); 3802 evcnt_detach(&rxr->no_mbuf); 3803 evcnt_detach(&rxr->rx_discarded); 3804 } 3805 evcnt_detach(&stats->ipcs); 3806 evcnt_detach(&stats->l4cs); 3807 evcnt_detach(&stats->ipcs_bad); 3808 evcnt_detach(&stats->l4cs_bad); 3809 evcnt_detach(&stats->intzero); 3810 evcnt_detach(&stats->legint); 3811 evcnt_detach(&stats->crcerrs); 3812 evcnt_detach(&stats->illerrc); 3813 evcnt_detach(&stats->errbc); 3814 evcnt_detach(&stats->mspdc); 3815 if (hw->mac.type >= ixgbe_mac_X550) 3816 evcnt_detach(&stats->mbsdc); 3817 evcnt_detach(&stats->mpctotal); 3818 evcnt_detach(&stats->mlfc); 3819 evcnt_detach(&stats->mrfc); 3820 evcnt_detach(&stats->rlec); 3821 evcnt_detach(&stats->lxontxc); 3822 evcnt_detach(&stats->lxonrxc); 3823 evcnt_detach(&stats->lxofftxc); 3824 evcnt_detach(&stats->lxoffrxc); 3825 3826 /* Packet Reception Stats */ 3827 evcnt_detach(&stats->tor); 3828 evcnt_detach(&stats->gorc); 3829 evcnt_detach(&stats->tpr); 3830 evcnt_detach(&stats->gprc); 3831 evcnt_detach(&stats->mprc); 3832 evcnt_detach(&stats->bprc); 3833 evcnt_detach(&stats->prc64); 3834 evcnt_detach(&stats->prc127); 3835 evcnt_detach(&stats->prc255); 3836 evcnt_detach(&stats->prc511); 3837 evcnt_detach(&stats->prc1023); 3838 evcnt_detach(&stats->prc1522); 3839 evcnt_detach(&stats->ruc); 3840 evcnt_detach(&stats->rfc); 3841 evcnt_detach(&stats->roc); 3842 evcnt_detach(&stats->rjc); 3843 evcnt_detach(&stats->mngprc); 3844 evcnt_detach(&stats->mngpdc); 3845 evcnt_detach(&stats->xec); 3846 3847 /* Packet Transmission Stats */ 3848 evcnt_detach(&stats->gotc); 3849 evcnt_detach(&stats->tpt); 3850 evcnt_detach(&stats->gptc); 3851 evcnt_detach(&stats->bptc); 3852 evcnt_detach(&stats->mptc); 3853 evcnt_detach(&stats->mngptc); 3854 evcnt_detach(&stats->ptc64); 3855 evcnt_detach(&stats->ptc127); 3856 evcnt_detach(&stats->ptc255); 3857 evcnt_detach(&stats->ptc511); 3858 evcnt_detach(&stats->ptc1023); 3859 evcnt_detach(&stats->ptc1522); 3860 3861 ixgbe_free_queues(adapter); 3862 free(adapter->mta, M_DEVBUF); 3863 3864 mutex_destroy(&adapter->admin_mtx); /* XXX appropriate order? */ 3865 IXGBE_CORE_LOCK_DESTROY(adapter); 3866 3867 return (0); 3868 } /* ixgbe_detach */ 3869 3870 /************************************************************************ 3871 * ixgbe_setup_low_power_mode - LPLU/WoL preparation 3872 * 3873 * Prepare the adapter/port for LPLU and/or WoL 3874 ************************************************************************/ 3875 static int 3876 ixgbe_setup_low_power_mode(struct adapter *adapter) 3877 { 3878 struct ixgbe_hw *hw = &adapter->hw; 3879 device_t dev = adapter->dev; 3880 struct ifnet *ifp = adapter->ifp; 3881 s32 error = 0; 3882 3883 /* Limit power management flow to X550EM baseT */ 3884 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 3885 hw->phy.ops.enter_lplu) { 3886 /* X550EM baseT adapters need a special LPLU flow */ 3887 hw->phy.reset_disable = true; 3888 ixgbe_ifstop(ifp, 1); 3889 error = hw->phy.ops.enter_lplu(hw); 3890 if (error) 3891 device_printf(dev, 3892 "Error entering LPLU: %d\n", error); 3893 hw->phy.reset_disable = false; 3894 } else { 3895 /* Just stop for other adapters */ 3896 ixgbe_ifstop(ifp, 1); 3897 } 3898 3899 IXGBE_CORE_LOCK(adapter); 3900 3901 if (!hw->wol_enabled) { 3902 ixgbe_set_phy_power(hw, FALSE); 3903 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3904 IXGBE_WRITE_REG(hw, IXGBE_WUC, 0); 3905 } else { 3906 /* Turn off support for APM wakeup. (Using ACPI instead) */ 3907 IXGBE_WRITE_REG(hw, IXGBE_GRC_BY_MAC(hw), 3908 IXGBE_READ_REG(hw, IXGBE_GRC_BY_MAC(hw)) & ~(u32)2); 3909 3910 /* 3911 * Clear Wake Up Status register to prevent any previous wakeup 3912 * events from waking us up immediately after we suspend. 3913 */ 3914 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3915 3916 /* 3917 * Program the Wakeup Filter Control register with user filter 3918 * settings 3919 */ 3920 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 3921 3922 /* Enable wakeups and power management in Wakeup Control */ 3923 IXGBE_WRITE_REG(hw, IXGBE_WUC, 3924 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 3925 3926 } 3927 3928 IXGBE_CORE_UNLOCK(adapter); 3929 3930 return error; 3931 } /* ixgbe_setup_low_power_mode */ 3932 3933 /************************************************************************ 3934 * ixgbe_shutdown - Shutdown entry point 3935 ************************************************************************/ 3936 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 3937 static int 3938 ixgbe_shutdown(device_t dev) 3939 { 3940 struct adapter *adapter = device_private(dev); 3941 int error = 0; 3942 3943 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 3944 3945 error = ixgbe_setup_low_power_mode(adapter); 3946 3947 return (error); 3948 } /* ixgbe_shutdown */ 3949 #endif 3950 3951 /************************************************************************ 3952 * ixgbe_suspend 3953 * 3954 * From D0 to D3 3955 ************************************************************************/ 3956 static bool 3957 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 3958 { 3959 struct adapter *adapter = device_private(dev); 3960 int error = 0; 3961 3962 INIT_DEBUGOUT("ixgbe_suspend: begin"); 3963 3964 error = ixgbe_setup_low_power_mode(adapter); 3965 3966 return (error); 3967 } /* ixgbe_suspend */ 3968 3969 /************************************************************************ 3970 * ixgbe_resume 3971 * 3972 * From D3 to D0 3973 ************************************************************************/ 3974 static bool 3975 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 3976 { 3977 struct adapter *adapter = device_private(dev); 3978 struct ifnet *ifp = adapter->ifp; 3979 struct ixgbe_hw *hw = &adapter->hw; 3980 u32 wus; 3981 3982 INIT_DEBUGOUT("ixgbe_resume: begin"); 3983 3984 IXGBE_CORE_LOCK(adapter); 3985 3986 /* Read & clear WUS register */ 3987 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 3988 if (wus) 3989 device_printf(dev, "Woken up by (WUS): %#010x\n", 3990 IXGBE_READ_REG(hw, IXGBE_WUS)); 3991 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3992 /* And clear WUFC until next low-power transition */ 3993 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3994 3995 /* 3996 * Required after D3->D0 transition; 3997 * will re-advertise all previous advertised speeds 3998 */ 3999 if (ifp->if_flags & IFF_UP) 4000 ixgbe_init_locked(adapter); 4001 4002 IXGBE_CORE_UNLOCK(adapter); 4003 4004 return true; 4005 } /* ixgbe_resume */ 4006 4007 /* 4008 * Set the various hardware offload abilities. 4009 * 4010 * This takes the ifnet's if_capenable flags (e.g. set by the user using 4011 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 4012 * mbuf offload flags the driver will understand. 4013 */ 4014 static void 4015 ixgbe_set_if_hwassist(struct adapter *adapter) 4016 { 4017 /* XXX */ 4018 } 4019 4020 /************************************************************************ 4021 * ixgbe_init_locked - Init entry point 4022 * 4023 * Used in two ways: It is used by the stack as an init 4024 * entry point in network interface structure. It is also 4025 * used by the driver as a hw/sw initialization routine to 4026 * get to a consistent state. 4027 * 4028 * return 0 on success, positive on failure 4029 ************************************************************************/ 4030 static void 4031 ixgbe_init_locked(struct adapter *adapter) 4032 { 4033 struct ifnet *ifp = adapter->ifp; 4034 device_t dev = adapter->dev; 4035 struct ixgbe_hw *hw = &adapter->hw; 4036 struct ix_queue *que; 4037 struct tx_ring *txr; 4038 struct rx_ring *rxr; 4039 u32 txdctl, mhadd; 4040 u32 rxdctl, rxctrl; 4041 u32 ctrl_ext; 4042 bool unsupported_sfp = false; 4043 int i, j, error; 4044 4045 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 4046 4047 KASSERT(mutex_owned(&adapter->core_mtx)); 4048 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 4049 4050 hw->need_unsupported_sfp_recovery = false; 4051 hw->adapter_stopped = FALSE; 4052 ixgbe_stop_adapter(hw); 4053 callout_stop(&adapter->timer); 4054 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 4055 callout_stop(&adapter->recovery_mode_timer); 4056 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 4057 que->disabled_count = 0; 4058 4059 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 4060 adapter->max_frame_size = 4061 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 4062 4063 /* Queue indices may change with IOV mode */ 4064 ixgbe_align_all_queue_indices(adapter); 4065 4066 /* reprogram the RAR[0] in case user changed it. */ 4067 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 4068 4069 /* Get the latest mac address, User can use a LAA */ 4070 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 4071 IXGBE_ETH_LENGTH_OF_ADDRESS); 4072 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 4073 hw->addr_ctrl.rar_used_count = 1; 4074 4075 /* Set hardware offload abilities from ifnet flags */ 4076 ixgbe_set_if_hwassist(adapter); 4077 4078 /* Prepare transmit descriptors and buffers */ 4079 if (ixgbe_setup_transmit_structures(adapter)) { 4080 device_printf(dev, "Could not setup transmit structures\n"); 4081 ixgbe_stop_locked(adapter); 4082 return; 4083 } 4084 4085 ixgbe_init_hw(hw); 4086 4087 ixgbe_initialize_iov(adapter); 4088 4089 ixgbe_initialize_transmit_units(adapter); 4090 4091 /* Setup Multicast table */ 4092 ixgbe_set_rxfilter(adapter); 4093 4094 /* Use fixed buffer size, even for jumbo frames */ 4095 adapter->rx_mbuf_sz = MCLBYTES; 4096 4097 /* Prepare receive descriptors and buffers */ 4098 error = ixgbe_setup_receive_structures(adapter); 4099 if (error) { 4100 device_printf(dev, 4101 "Could not setup receive structures (err = %d)\n", error); 4102 ixgbe_stop_locked(adapter); 4103 return; 4104 } 4105 4106 /* Configure RX settings */ 4107 ixgbe_initialize_receive_units(adapter); 4108 4109 /* Initialize variable holding task enqueue requests interrupts */ 4110 adapter->task_requests = 0; 4111 4112 /* Enable SDP & MSI-X interrupts based on adapter */ 4113 ixgbe_config_gpie(adapter); 4114 4115 /* Set MTU size */ 4116 if (ifp->if_mtu > ETHERMTU) { 4117 /* aka IXGBE_MAXFRS on 82599 and newer */ 4118 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 4119 mhadd &= ~IXGBE_MHADD_MFS_MASK; 4120 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 4121 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 4122 } 4123 4124 /* Now enable all the queues */ 4125 for (i = 0; i < adapter->num_queues; i++) { 4126 txr = &adapter->tx_rings[i]; 4127 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 4128 txdctl |= IXGBE_TXDCTL_ENABLE; 4129 /* Set WTHRESH to 8, burst writeback */ 4130 txdctl |= IXGBE_TX_WTHRESH << IXGBE_TXDCTL_WTHRESH_SHIFT; 4131 /* 4132 * When the internal queue falls below PTHRESH (32), 4133 * start prefetching as long as there are at least 4134 * HTHRESH (1) buffers ready. The values are taken 4135 * from the Intel linux driver 3.8.21. 4136 * Prefetching enables tx line rate even with 1 queue. 4137 */ 4138 txdctl |= (32 << 0) | (1 << 8); 4139 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 4140 } 4141 4142 for (i = 0; i < adapter->num_queues; i++) { 4143 rxr = &adapter->rx_rings[i]; 4144 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 4145 if (hw->mac.type == ixgbe_mac_82598EB) { 4146 /* 4147 * PTHRESH = 21 4148 * HTHRESH = 4 4149 * WTHRESH = 8 4150 */ 4151 rxdctl &= ~0x3FFFFF; 4152 rxdctl |= 0x080420; 4153 } 4154 rxdctl |= IXGBE_RXDCTL_ENABLE; 4155 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 4156 for (j = 0; j < 10; j++) { 4157 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 4158 IXGBE_RXDCTL_ENABLE) 4159 break; 4160 else 4161 msec_delay(1); 4162 } 4163 IXGBE_WRITE_BARRIER(hw); 4164 4165 /* 4166 * In netmap mode, we must preserve the buffers made 4167 * available to userspace before the if_init() 4168 * (this is true by default on the TX side, because 4169 * init makes all buffers available to userspace). 4170 * 4171 * netmap_reset() and the device specific routines 4172 * (e.g. ixgbe_setup_receive_rings()) map these 4173 * buffers at the end of the NIC ring, so here we 4174 * must set the RDT (tail) register to make sure 4175 * they are not overwritten. 4176 * 4177 * In this driver the NIC ring starts at RDH = 0, 4178 * RDT points to the last slot available for reception (?), 4179 * so RDT = num_rx_desc - 1 means the whole ring is available. 4180 */ 4181 #ifdef DEV_NETMAP 4182 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 4183 (ifp->if_capenable & IFCAP_NETMAP)) { 4184 struct netmap_adapter *na = NA(adapter->ifp); 4185 struct netmap_kring *kring = na->rx_rings[i]; 4186 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 4187 4188 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 4189 } else 4190 #endif /* DEV_NETMAP */ 4191 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), 4192 adapter->num_rx_desc - 1); 4193 } 4194 4195 /* Enable Receive engine */ 4196 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 4197 if (hw->mac.type == ixgbe_mac_82598EB) 4198 rxctrl |= IXGBE_RXCTRL_DMBYPS; 4199 rxctrl |= IXGBE_RXCTRL_RXEN; 4200 ixgbe_enable_rx_dma(hw, rxctrl); 4201 4202 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4203 atomic_store_relaxed(&adapter->timer_pending, 0); 4204 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 4205 callout_reset(&adapter->recovery_mode_timer, hz, 4206 ixgbe_recovery_mode_timer, adapter); 4207 4208 /* Set up MSI/MSI-X routing */ 4209 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4210 ixgbe_configure_ivars(adapter); 4211 /* Set up auto-mask */ 4212 if (hw->mac.type == ixgbe_mac_82598EB) 4213 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4214 else { 4215 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 4216 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 4217 } 4218 } else { /* Simple settings for Legacy/MSI */ 4219 ixgbe_set_ivar(adapter, 0, 0, 0); 4220 ixgbe_set_ivar(adapter, 0, 0, 1); 4221 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4222 } 4223 4224 ixgbe_init_fdir(adapter); 4225 4226 /* 4227 * Check on any SFP devices that 4228 * need to be kick-started 4229 */ 4230 if (hw->phy.type == ixgbe_phy_none) { 4231 error = hw->phy.ops.identify(hw); 4232 if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) 4233 unsupported_sfp = true; 4234 } else if (hw->phy.type == ixgbe_phy_sfp_unsupported) 4235 unsupported_sfp = true; 4236 4237 if (unsupported_sfp) 4238 device_printf(dev, 4239 "Unsupported SFP+ module type was detected.\n"); 4240 4241 /* Set moderation on the Link interrupt */ 4242 ixgbe_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 4243 4244 /* Enable EEE power saving */ 4245 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 4246 hw->mac.ops.setup_eee(hw, 4247 adapter->feat_en & IXGBE_FEATURE_EEE); 4248 4249 /* Enable power to the phy. */ 4250 if (!unsupported_sfp) { 4251 ixgbe_set_phy_power(hw, TRUE); 4252 4253 /* Config/Enable Link */ 4254 ixgbe_config_link(adapter); 4255 } 4256 4257 /* Hardware Packet Buffer & Flow Control setup */ 4258 ixgbe_config_delay_values(adapter); 4259 4260 /* Initialize the FC settings */ 4261 ixgbe_start_hw(hw); 4262 4263 /* Set up VLAN support and filter */ 4264 ixgbe_setup_vlan_hw_support(adapter); 4265 4266 /* Setup DMA Coalescing */ 4267 ixgbe_config_dmac(adapter); 4268 4269 /* OK to schedule workqueues. */ 4270 adapter->schedule_wqs_ok = true; 4271 4272 /* And now turn on interrupts */ 4273 ixgbe_enable_intr(adapter); 4274 4275 /* Enable the use of the MBX by the VF's */ 4276 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 4277 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 4278 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 4279 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 4280 } 4281 4282 /* Update saved flags. See ixgbe_ifflags_cb() */ 4283 adapter->if_flags = ifp->if_flags; 4284 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 4285 4286 /* Now inform the stack we're ready */ 4287 ifp->if_flags |= IFF_RUNNING; 4288 4289 return; 4290 } /* ixgbe_init_locked */ 4291 4292 /************************************************************************ 4293 * ixgbe_init 4294 ************************************************************************/ 4295 static int 4296 ixgbe_init(struct ifnet *ifp) 4297 { 4298 struct adapter *adapter = ifp->if_softc; 4299 4300 IXGBE_CORE_LOCK(adapter); 4301 ixgbe_init_locked(adapter); 4302 IXGBE_CORE_UNLOCK(adapter); 4303 4304 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 4305 } /* ixgbe_init */ 4306 4307 /************************************************************************ 4308 * ixgbe_set_ivar 4309 * 4310 * Setup the correct IVAR register for a particular MSI-X interrupt 4311 * (yes this is all very magic and confusing :) 4312 * - entry is the register array entry 4313 * - vector is the MSI-X vector for this queue 4314 * - type is RX/TX/MISC 4315 ************************************************************************/ 4316 static void 4317 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 4318 { 4319 struct ixgbe_hw *hw = &adapter->hw; 4320 u32 ivar, index; 4321 4322 vector |= IXGBE_IVAR_ALLOC_VAL; 4323 4324 switch (hw->mac.type) { 4325 case ixgbe_mac_82598EB: 4326 if (type == -1) 4327 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 4328 else 4329 entry += (type * 64); 4330 index = (entry >> 2) & 0x1F; 4331 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 4332 ivar &= ~(0xffUL << (8 * (entry & 0x3))); 4333 ivar |= ((u32)vector << (8 * (entry & 0x3))); 4334 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 4335 break; 4336 case ixgbe_mac_82599EB: 4337 case ixgbe_mac_X540: 4338 case ixgbe_mac_X550: 4339 case ixgbe_mac_X550EM_x: 4340 case ixgbe_mac_X550EM_a: 4341 if (type == -1) { /* MISC IVAR */ 4342 index = (entry & 1) * 8; 4343 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 4344 ivar &= ~(0xffUL << index); 4345 ivar |= ((u32)vector << index); 4346 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 4347 } else { /* RX/TX IVARS */ 4348 index = (16 * (entry & 1)) + (8 * type); 4349 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 4350 ivar &= ~(0xffUL << index); 4351 ivar |= ((u32)vector << index); 4352 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 4353 } 4354 break; 4355 default: 4356 break; 4357 } 4358 } /* ixgbe_set_ivar */ 4359 4360 /************************************************************************ 4361 * ixgbe_configure_ivars 4362 ************************************************************************/ 4363 static void 4364 ixgbe_configure_ivars(struct adapter *adapter) 4365 { 4366 struct ix_queue *que = adapter->queues; 4367 u32 newitr; 4368 4369 if (ixgbe_max_interrupt_rate > 0) 4370 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 4371 else { 4372 /* 4373 * Disable DMA coalescing if interrupt moderation is 4374 * disabled. 4375 */ 4376 adapter->dmac = 0; 4377 newitr = 0; 4378 } 4379 4380 for (int i = 0; i < adapter->num_queues; i++, que++) { 4381 struct rx_ring *rxr = &adapter->rx_rings[i]; 4382 struct tx_ring *txr = &adapter->tx_rings[i]; 4383 /* First the RX queue entry */ 4384 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 4385 /* ... and the TX */ 4386 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 4387 /* Set an Initial EITR value */ 4388 ixgbe_eitr_write(adapter, que->msix, newitr); 4389 /* 4390 * To eliminate influence of the previous state. 4391 * At this point, Tx/Rx interrupt handler 4392 * (ixgbe_msix_que()) cannot be called, so both 4393 * IXGBE_TX_LOCK and IXGBE_RX_LOCK are not required. 4394 */ 4395 que->eitr_setting = 0; 4396 } 4397 4398 /* For the Link interrupt */ 4399 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 4400 } /* ixgbe_configure_ivars */ 4401 4402 /************************************************************************ 4403 * ixgbe_config_gpie 4404 ************************************************************************/ 4405 static void 4406 ixgbe_config_gpie(struct adapter *adapter) 4407 { 4408 struct ixgbe_hw *hw = &adapter->hw; 4409 u32 gpie; 4410 4411 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 4412 4413 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4414 /* Enable Enhanced MSI-X mode */ 4415 gpie |= IXGBE_GPIE_MSIX_MODE 4416 | IXGBE_GPIE_EIAME 4417 | IXGBE_GPIE_PBA_SUPPORT 4418 | IXGBE_GPIE_OCD; 4419 } 4420 4421 /* Fan Failure Interrupt */ 4422 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4423 gpie |= IXGBE_SDP1_GPIEN; 4424 4425 /* Thermal Sensor Interrupt */ 4426 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) 4427 gpie |= IXGBE_SDP0_GPIEN_X540; 4428 4429 /* Link detection */ 4430 switch (hw->mac.type) { 4431 case ixgbe_mac_82599EB: 4432 gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN; 4433 break; 4434 case ixgbe_mac_X550EM_x: 4435 case ixgbe_mac_X550EM_a: 4436 gpie |= IXGBE_SDP0_GPIEN_X540; 4437 break; 4438 default: 4439 break; 4440 } 4441 4442 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 4443 4444 } /* ixgbe_config_gpie */ 4445 4446 /************************************************************************ 4447 * ixgbe_config_delay_values 4448 * 4449 * Requires adapter->max_frame_size to be set. 4450 ************************************************************************/ 4451 static void 4452 ixgbe_config_delay_values(struct adapter *adapter) 4453 { 4454 struct ixgbe_hw *hw = &adapter->hw; 4455 u32 rxpb, frame, size, tmp; 4456 4457 frame = adapter->max_frame_size; 4458 4459 /* Calculate High Water */ 4460 switch (hw->mac.type) { 4461 case ixgbe_mac_X540: 4462 case ixgbe_mac_X550: 4463 case ixgbe_mac_X550EM_x: 4464 case ixgbe_mac_X550EM_a: 4465 tmp = IXGBE_DV_X540(frame, frame); 4466 break; 4467 default: 4468 tmp = IXGBE_DV(frame, frame); 4469 break; 4470 } 4471 size = IXGBE_BT2KB(tmp); 4472 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 4473 hw->fc.high_water[0] = rxpb - size; 4474 4475 /* Now calculate Low Water */ 4476 switch (hw->mac.type) { 4477 case ixgbe_mac_X540: 4478 case ixgbe_mac_X550: 4479 case ixgbe_mac_X550EM_x: 4480 case ixgbe_mac_X550EM_a: 4481 tmp = IXGBE_LOW_DV_X540(frame); 4482 break; 4483 default: 4484 tmp = IXGBE_LOW_DV(frame); 4485 break; 4486 } 4487 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 4488 4489 hw->fc.pause_time = IXGBE_FC_PAUSE; 4490 hw->fc.send_xon = TRUE; 4491 } /* ixgbe_config_delay_values */ 4492 4493 /************************************************************************ 4494 * ixgbe_set_rxfilter - Multicast Update 4495 * 4496 * Called whenever multicast address list is updated. 4497 ************************************************************************/ 4498 static void 4499 ixgbe_set_rxfilter(struct adapter *adapter) 4500 { 4501 struct ixgbe_mc_addr *mta; 4502 struct ifnet *ifp = adapter->ifp; 4503 u8 *update_ptr; 4504 int mcnt = 0; 4505 u32 fctrl; 4506 struct ethercom *ec = &adapter->osdep.ec; 4507 struct ether_multi *enm; 4508 struct ether_multistep step; 4509 4510 KASSERT(mutex_owned(&adapter->core_mtx)); 4511 IOCTL_DEBUGOUT("ixgbe_set_rxfilter: begin"); 4512 4513 mta = adapter->mta; 4514 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 4515 4516 ETHER_LOCK(ec); 4517 ec->ec_flags &= ~ETHER_F_ALLMULTI; 4518 ETHER_FIRST_MULTI(step, ec, enm); 4519 while (enm != NULL) { 4520 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 4521 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 4522 ETHER_ADDR_LEN) != 0)) { 4523 ec->ec_flags |= ETHER_F_ALLMULTI; 4524 break; 4525 } 4526 bcopy(enm->enm_addrlo, 4527 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 4528 mta[mcnt].vmdq = adapter->pool; 4529 mcnt++; 4530 ETHER_NEXT_MULTI(step, enm); 4531 } 4532 4533 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 4534 if (ifp->if_flags & IFF_PROMISC) 4535 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4536 else if (ec->ec_flags & ETHER_F_ALLMULTI) { 4537 fctrl |= IXGBE_FCTRL_MPE; 4538 fctrl &= ~IXGBE_FCTRL_UPE; 4539 } else 4540 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4541 4542 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 4543 4544 /* Update multicast filter entries only when it's not ALLMULTI */ 4545 if ((ec->ec_flags & ETHER_F_ALLMULTI) == 0) { 4546 ETHER_UNLOCK(ec); 4547 update_ptr = (u8 *)mta; 4548 ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 4549 ixgbe_mc_array_itr, TRUE); 4550 } else 4551 ETHER_UNLOCK(ec); 4552 } /* ixgbe_set_rxfilter */ 4553 4554 /************************************************************************ 4555 * ixgbe_mc_array_itr 4556 * 4557 * An iterator function needed by the multicast shared code. 4558 * It feeds the shared code routine the addresses in the 4559 * array of ixgbe_set_rxfilter() one by one. 4560 ************************************************************************/ 4561 static u8 * 4562 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 4563 { 4564 struct ixgbe_mc_addr *mta; 4565 4566 mta = (struct ixgbe_mc_addr *)*update_ptr; 4567 *vmdq = mta->vmdq; 4568 4569 *update_ptr = (u8*)(mta + 1); 4570 4571 return (mta->addr); 4572 } /* ixgbe_mc_array_itr */ 4573 4574 /************************************************************************ 4575 * ixgbe_local_timer - Timer routine 4576 * 4577 * Checks for link status, updates statistics, 4578 * and runs the watchdog check. 4579 ************************************************************************/ 4580 static void 4581 ixgbe_local_timer(void *arg) 4582 { 4583 struct adapter *adapter = arg; 4584 4585 if (adapter->schedule_wqs_ok) { 4586 if (atomic_cas_uint(&adapter->timer_pending, 0, 1) == 0) 4587 workqueue_enqueue(adapter->timer_wq, 4588 &adapter->timer_wc, NULL); 4589 } 4590 } 4591 4592 static void 4593 ixgbe_handle_timer(struct work *wk, void *context) 4594 { 4595 struct adapter *adapter = context; 4596 struct ixgbe_hw *hw = &adapter->hw; 4597 device_t dev = adapter->dev; 4598 struct ix_queue *que = adapter->queues; 4599 u64 queues = 0; 4600 u64 v0, v1, v2, v3, v4, v5, v6, v7; 4601 int hung = 0; 4602 int i; 4603 4604 IXGBE_CORE_LOCK(adapter); 4605 4606 /* Check for pluggable optics */ 4607 if (ixgbe_is_sfp(hw)) { 4608 bool sched_mod_task = false; 4609 4610 if (hw->mac.type == ixgbe_mac_82598EB) { 4611 /* 4612 * On 82598EB, SFP+'s MOD_ABS pin is not connected to 4613 * any GPIO(SDP). So just schedule TASK_MOD. 4614 */ 4615 sched_mod_task = true; 4616 } else { 4617 bool was_full, is_full; 4618 4619 was_full = 4620 hw->phy.sfp_type != ixgbe_sfp_type_not_present; 4621 is_full = ixgbe_sfp_cage_full(hw); 4622 4623 /* Do probe if cage state changed */ 4624 if (was_full ^ is_full) 4625 sched_mod_task = true; 4626 } 4627 if (sched_mod_task) { 4628 mutex_enter(&adapter->admin_mtx); 4629 adapter->task_requests |= IXGBE_REQUEST_TASK_MOD_WOI; 4630 ixgbe_schedule_admin_tasklet(adapter); 4631 mutex_exit(&adapter->admin_mtx); 4632 } 4633 } 4634 4635 ixgbe_update_link_status(adapter); 4636 ixgbe_update_stats_counters(adapter); 4637 4638 /* Update some event counters */ 4639 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 4640 que = adapter->queues; 4641 for (i = 0; i < adapter->num_queues; i++, que++) { 4642 struct tx_ring *txr = que->txr; 4643 4644 v0 += txr->q_efbig_tx_dma_setup; 4645 v1 += txr->q_mbuf_defrag_failed; 4646 v2 += txr->q_efbig2_tx_dma_setup; 4647 v3 += txr->q_einval_tx_dma_setup; 4648 v4 += txr->q_other_tx_dma_setup; 4649 v5 += txr->q_eagain_tx_dma_setup; 4650 v6 += txr->q_enomem_tx_dma_setup; 4651 v7 += txr->q_tso_err; 4652 } 4653 adapter->efbig_tx_dma_setup.ev_count = v0; 4654 adapter->mbuf_defrag_failed.ev_count = v1; 4655 adapter->efbig2_tx_dma_setup.ev_count = v2; 4656 adapter->einval_tx_dma_setup.ev_count = v3; 4657 adapter->other_tx_dma_setup.ev_count = v4; 4658 adapter->eagain_tx_dma_setup.ev_count = v5; 4659 adapter->enomem_tx_dma_setup.ev_count = v6; 4660 adapter->tso_err.ev_count = v7; 4661 4662 /* 4663 * Check the TX queues status 4664 * - mark hung queues so we don't schedule on them 4665 * - watchdog only if all queues show hung 4666 */ 4667 que = adapter->queues; 4668 for (i = 0; i < adapter->num_queues; i++, que++) { 4669 /* Keep track of queues with work for soft irq */ 4670 if (que->txr->busy) 4671 queues |= 1ULL << que->me; 4672 /* 4673 * Each time txeof runs without cleaning, but there 4674 * are uncleaned descriptors it increments busy. If 4675 * we get to the MAX we declare it hung. 4676 */ 4677 if (que->busy == IXGBE_QUEUE_HUNG) { 4678 ++hung; 4679 /* Mark the queue as inactive */ 4680 adapter->active_queues &= ~(1ULL << que->me); 4681 continue; 4682 } else { 4683 /* Check if we've come back from hung */ 4684 if ((adapter->active_queues & (1ULL << que->me)) == 0) 4685 adapter->active_queues |= 1ULL << que->me; 4686 } 4687 if (que->busy >= IXGBE_MAX_TX_BUSY) { 4688 device_printf(dev, 4689 "Warning queue %d appears to be hung!\n", i); 4690 que->txr->busy = IXGBE_QUEUE_HUNG; 4691 ++hung; 4692 } 4693 } 4694 4695 /* Only truly watchdog if all queues show hung */ 4696 if (hung == adapter->num_queues) 4697 goto watchdog; 4698 #if 0 /* XXX Avoid unexpectedly disabling interrupt forever (PR#53294) */ 4699 else if (queues != 0) { /* Force an IRQ on queues with work */ 4700 que = adapter->queues; 4701 for (i = 0; i < adapter->num_queues; i++, que++) { 4702 mutex_enter(&que->dc_mtx); 4703 if (que->disabled_count == 0) 4704 ixgbe_rearm_queues(adapter, 4705 queues & ((u64)1 << i)); 4706 mutex_exit(&que->dc_mtx); 4707 } 4708 } 4709 #endif 4710 4711 atomic_store_relaxed(&adapter->timer_pending, 0); 4712 IXGBE_CORE_UNLOCK(adapter); 4713 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4714 return; 4715 4716 watchdog: 4717 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4718 adapter->ifp->if_flags &= ~IFF_RUNNING; 4719 adapter->watchdog_events.ev_count++; 4720 ixgbe_init_locked(adapter); 4721 IXGBE_CORE_UNLOCK(adapter); 4722 } /* ixgbe_handle_timer */ 4723 4724 /************************************************************************ 4725 * ixgbe_recovery_mode_timer - Recovery mode timer routine 4726 ************************************************************************/ 4727 static void 4728 ixgbe_recovery_mode_timer(void *arg) 4729 { 4730 struct adapter *adapter = arg; 4731 4732 if (__predict_true(adapter->osdep.detaching == false)) { 4733 if (atomic_cas_uint(&adapter->recovery_mode_timer_pending, 4734 0, 1) == 0) { 4735 workqueue_enqueue(adapter->recovery_mode_timer_wq, 4736 &adapter->recovery_mode_timer_wc, NULL); 4737 } 4738 } 4739 } 4740 4741 static void 4742 ixgbe_handle_recovery_mode_timer(struct work *wk, void *context) 4743 { 4744 struct adapter *adapter = context; 4745 struct ixgbe_hw *hw = &adapter->hw; 4746 4747 IXGBE_CORE_LOCK(adapter); 4748 if (ixgbe_fw_recovery_mode(hw)) { 4749 if (atomic_cas_uint(&adapter->recovery_mode, 0, 1)) { 4750 /* Firmware error detected, entering recovery mode */ 4751 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"); 4752 4753 if (hw->adapter_stopped == FALSE) 4754 ixgbe_stop_locked(adapter); 4755 } 4756 } else 4757 atomic_cas_uint(&adapter->recovery_mode, 1, 0); 4758 4759 atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0); 4760 callout_reset(&adapter->recovery_mode_timer, hz, 4761 ixgbe_recovery_mode_timer, adapter); 4762 IXGBE_CORE_UNLOCK(adapter); 4763 } /* ixgbe_handle_recovery_mode_timer */ 4764 4765 /************************************************************************ 4766 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4767 * bool int_en: true if it's called when the interrupt is enabled. 4768 ************************************************************************/ 4769 static void 4770 ixgbe_handle_mod(void *context, bool int_en) 4771 { 4772 struct adapter *adapter = context; 4773 struct ixgbe_hw *hw = &adapter->hw; 4774 device_t dev = adapter->dev; 4775 enum ixgbe_sfp_type last_sfp_type; 4776 u32 err; 4777 bool last_unsupported_sfp_recovery; 4778 4779 KASSERT(mutex_owned(&adapter->core_mtx)); 4780 4781 last_sfp_type = hw->phy.sfp_type; 4782 last_unsupported_sfp_recovery = hw->need_unsupported_sfp_recovery; 4783 ++adapter->mod_workev.ev_count; 4784 if (adapter->hw.need_crosstalk_fix) { 4785 if ((hw->mac.type != ixgbe_mac_82598EB) && 4786 !ixgbe_sfp_cage_full(hw)) 4787 goto out; 4788 } 4789 4790 err = hw->phy.ops.identify_sfp(hw); 4791 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4792 if (last_unsupported_sfp_recovery == false) 4793 device_printf(dev, 4794 "Unsupported SFP+ module type was detected.\n"); 4795 goto out; 4796 } 4797 4798 if (hw->need_unsupported_sfp_recovery) { 4799 device_printf(dev, "Recovering from unsupported SFP\n"); 4800 /* 4801 * We could recover the status by calling setup_sfp(), 4802 * setup_link() and some others. It's complex and might not 4803 * work correctly on some unknown cases. To avoid such type of 4804 * problem, call ixgbe_init_locked(). It's simple and safe 4805 * approach. 4806 */ 4807 ixgbe_init_locked(adapter); 4808 } else if ((hw->phy.sfp_type != ixgbe_sfp_type_not_present) && 4809 (hw->phy.sfp_type != last_sfp_type)) { 4810 /* A module is inserted and changed. */ 4811 4812 if (hw->mac.type == ixgbe_mac_82598EB) 4813 err = hw->phy.ops.reset(hw); 4814 else { 4815 err = hw->mac.ops.setup_sfp(hw); 4816 hw->phy.sfp_setup_needed = FALSE; 4817 } 4818 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4819 device_printf(dev, 4820 "Setup failure - unsupported SFP+ module type.\n"); 4821 goto out; 4822 } 4823 } 4824 4825 out: 4826 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4827 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4828 4829 /* Adjust media types shown in ifconfig */ 4830 IXGBE_CORE_UNLOCK(adapter); 4831 ifmedia_removeall(&adapter->media); 4832 ixgbe_add_media_types(adapter); 4833 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4834 IXGBE_CORE_LOCK(adapter); 4835 4836 /* 4837 * Don't schedule MSF event if the chip is 82598. 82598 doesn't support 4838 * MSF. At least, calling ixgbe_handle_msf on 82598 DA makes the link 4839 * flap because the function calls setup_link(). 4840 */ 4841 if (hw->mac.type != ixgbe_mac_82598EB) { 4842 mutex_enter(&adapter->admin_mtx); 4843 if (int_en) 4844 adapter->task_requests |= IXGBE_REQUEST_TASK_MSF; 4845 else 4846 adapter->task_requests |= IXGBE_REQUEST_TASK_MSF_WOI; 4847 mutex_exit(&adapter->admin_mtx); 4848 } 4849 4850 /* 4851 * Don't call ixgbe_schedule_admin_tasklet() because we are on 4852 * the workqueue now. 4853 */ 4854 } /* ixgbe_handle_mod */ 4855 4856 4857 /************************************************************************ 4858 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4859 ************************************************************************/ 4860 static void 4861 ixgbe_handle_msf(void *context) 4862 { 4863 struct adapter *adapter = context; 4864 struct ixgbe_hw *hw = &adapter->hw; 4865 u32 autoneg; 4866 bool negotiate; 4867 4868 KASSERT(mutex_owned(&adapter->core_mtx)); 4869 4870 ++adapter->msf_workev.ev_count; 4871 4872 autoneg = hw->phy.autoneg_advertised; 4873 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4874 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4875 if (hw->mac.ops.setup_link) 4876 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4877 } /* ixgbe_handle_msf */ 4878 4879 /************************************************************************ 4880 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4881 ************************************************************************/ 4882 static void 4883 ixgbe_handle_phy(void *context) 4884 { 4885 struct adapter *adapter = context; 4886 struct ixgbe_hw *hw = &adapter->hw; 4887 int error; 4888 4889 KASSERT(mutex_owned(&adapter->core_mtx)); 4890 4891 ++adapter->phy_workev.ev_count; 4892 error = hw->phy.ops.handle_lasi(hw); 4893 if (error == IXGBE_ERR_OVERTEMP) 4894 device_printf(adapter->dev, 4895 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4896 " PHY will downshift to lower power state!\n"); 4897 else if (error) 4898 device_printf(adapter->dev, 4899 "Error handling LASI interrupt: %d\n", error); 4900 } /* ixgbe_handle_phy */ 4901 4902 static void 4903 ixgbe_handle_admin(struct work *wk, void *context) 4904 { 4905 struct adapter *adapter = context; 4906 struct ifnet *ifp = adapter->ifp; 4907 struct ixgbe_hw *hw = &adapter->hw; 4908 u32 task_requests; 4909 u32 eims_enable = 0; 4910 4911 mutex_enter(&adapter->admin_mtx); 4912 adapter->admin_pending = 0; 4913 task_requests = adapter->task_requests; 4914 adapter->task_requests = 0; 4915 mutex_exit(&adapter->admin_mtx); 4916 4917 /* 4918 * Hold the IFNET_LOCK across this entire call. This will 4919 * prevent additional changes to adapter->phy_layer 4920 * and serialize calls to this tasklet. We cannot hold the 4921 * CORE_LOCK while calling into the ifmedia functions as 4922 * they call ifmedia_lock() and the lock is CORE_LOCK. 4923 */ 4924 IFNET_LOCK(ifp); 4925 IXGBE_CORE_LOCK(adapter); 4926 if ((task_requests & IXGBE_REQUEST_TASK_LSC) != 0) { 4927 ixgbe_handle_link(adapter); 4928 eims_enable |= IXGBE_EIMS_LSC; 4929 } 4930 if ((task_requests & IXGBE_REQUEST_TASK_MOD_WOI) != 0) { 4931 ixgbe_handle_mod(adapter, false); 4932 } 4933 if ((task_requests & IXGBE_REQUEST_TASK_MOD) != 0) { 4934 ixgbe_handle_mod(adapter, true); 4935 if (hw->mac.type >= ixgbe_mac_X540) 4936 eims_enable |= IXGBE_EICR_GPI_SDP0_X540; 4937 else 4938 eims_enable |= IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 4939 } 4940 if ((task_requests 4941 & (IXGBE_REQUEST_TASK_MSF_WOI | IXGBE_REQUEST_TASK_MSF)) != 0) { 4942 ixgbe_handle_msf(adapter); 4943 if (((task_requests & IXGBE_REQUEST_TASK_MSF) != 0) && 4944 (hw->mac.type == ixgbe_mac_82599EB)) 4945 eims_enable |= IXGBE_EIMS_GPI_SDP1_BY_MAC(hw); 4946 } 4947 if ((task_requests & IXGBE_REQUEST_TASK_PHY) != 0) { 4948 ixgbe_handle_phy(adapter); 4949 eims_enable |= IXGBE_EICR_GPI_SDP0_X540; 4950 } 4951 if ((task_requests & IXGBE_REQUEST_TASK_FDIR) != 0) { 4952 ixgbe_reinit_fdir(adapter); 4953 eims_enable |= IXGBE_EIMS_FLOW_DIR; 4954 } 4955 #if 0 /* notyet */ 4956 if ((task_requests & IXGBE_REQUEST_TASK_MBX) != 0) { 4957 ixgbe_handle_mbx(adapter); 4958 eims_enable |= IXGBE_EIMS_MAILBOX; 4959 } 4960 #endif 4961 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_enable); 4962 4963 IXGBE_CORE_UNLOCK(adapter); 4964 IFNET_UNLOCK(ifp); 4965 } /* ixgbe_handle_admin */ 4966 4967 static void 4968 ixgbe_ifstop(struct ifnet *ifp, int disable) 4969 { 4970 struct adapter *adapter = ifp->if_softc; 4971 4972 IXGBE_CORE_LOCK(adapter); 4973 ixgbe_stop_locked(adapter); 4974 IXGBE_CORE_UNLOCK(adapter); 4975 4976 workqueue_wait(adapter->timer_wq, &adapter->timer_wc); 4977 atomic_store_relaxed(&adapter->timer_pending, 0); 4978 } 4979 4980 /************************************************************************ 4981 * ixgbe_stop_locked - Stop the hardware 4982 * 4983 * Disables all traffic on the adapter by issuing a 4984 * global reset on the MAC and deallocates TX/RX buffers. 4985 ************************************************************************/ 4986 static void 4987 ixgbe_stop_locked(void *arg) 4988 { 4989 struct ifnet *ifp; 4990 struct adapter *adapter = arg; 4991 struct ixgbe_hw *hw = &adapter->hw; 4992 4993 ifp = adapter->ifp; 4994 4995 KASSERT(mutex_owned(&adapter->core_mtx)); 4996 4997 INIT_DEBUGOUT("ixgbe_stop_locked: begin\n"); 4998 ixgbe_disable_intr(adapter); 4999 callout_stop(&adapter->timer); 5000 5001 /* Don't schedule workqueues. */ 5002 adapter->schedule_wqs_ok = false; 5003 5004 /* Let the stack know...*/ 5005 ifp->if_flags &= ~IFF_RUNNING; 5006 5007 ixgbe_reset_hw(hw); 5008 hw->adapter_stopped = FALSE; 5009 ixgbe_stop_adapter(hw); 5010 if (hw->mac.type == ixgbe_mac_82599EB) 5011 ixgbe_stop_mac_link_on_d3_82599(hw); 5012 /* Turn off the laser - noop with no optics */ 5013 ixgbe_disable_tx_laser(hw); 5014 5015 /* Update the stack */ 5016 adapter->link_up = FALSE; 5017 ixgbe_update_link_status(adapter); 5018 5019 /* reprogram the RAR[0] in case user changed it. */ 5020 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 5021 5022 return; 5023 } /* ixgbe_stop_locked */ 5024 5025 /************************************************************************ 5026 * ixgbe_update_link_status - Update OS on link state 5027 * 5028 * Note: Only updates the OS on the cached link state. 5029 * The real check of the hardware only happens with 5030 * a link interrupt. 5031 ************************************************************************/ 5032 static void 5033 ixgbe_update_link_status(struct adapter *adapter) 5034 { 5035 struct ifnet *ifp = adapter->ifp; 5036 device_t dev = adapter->dev; 5037 struct ixgbe_hw *hw = &adapter->hw; 5038 5039 KASSERT(mutex_owned(&adapter->core_mtx)); 5040 5041 if (adapter->link_up) { 5042 if (adapter->link_active != LINK_STATE_UP) { 5043 /* 5044 * To eliminate influence of the previous state 5045 * in the same way as ixgbe_init_locked(). 5046 */ 5047 struct ix_queue *que = adapter->queues; 5048 for (int i = 0; i < adapter->num_queues; i++, que++) 5049 que->eitr_setting = 0; 5050 5051 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 5052 /* 5053 * Discard count for both MAC Local Fault and 5054 * Remote Fault because those registers are 5055 * valid only when the link speed is up and 5056 * 10Gbps. 5057 */ 5058 IXGBE_READ_REG(hw, IXGBE_MLFC); 5059 IXGBE_READ_REG(hw, IXGBE_MRFC); 5060 } 5061 5062 if (bootverbose) { 5063 const char *bpsmsg; 5064 5065 switch (adapter->link_speed) { 5066 case IXGBE_LINK_SPEED_10GB_FULL: 5067 bpsmsg = "10 Gbps"; 5068 break; 5069 case IXGBE_LINK_SPEED_5GB_FULL: 5070 bpsmsg = "5 Gbps"; 5071 break; 5072 case IXGBE_LINK_SPEED_2_5GB_FULL: 5073 bpsmsg = "2.5 Gbps"; 5074 break; 5075 case IXGBE_LINK_SPEED_1GB_FULL: 5076 bpsmsg = "1 Gbps"; 5077 break; 5078 case IXGBE_LINK_SPEED_100_FULL: 5079 bpsmsg = "100 Mbps"; 5080 break; 5081 case IXGBE_LINK_SPEED_10_FULL: 5082 bpsmsg = "10 Mbps"; 5083 break; 5084 default: 5085 bpsmsg = "unknown speed"; 5086 break; 5087 } 5088 device_printf(dev, "Link is up %s %s \n", 5089 bpsmsg, "Full Duplex"); 5090 } 5091 adapter->link_active = LINK_STATE_UP; 5092 /* Update any Flow Control changes */ 5093 ixgbe_fc_enable(&adapter->hw); 5094 /* Update DMA coalescing config */ 5095 ixgbe_config_dmac(adapter); 5096 if_link_state_change(ifp, LINK_STATE_UP); 5097 5098 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5099 ixgbe_ping_all_vfs(adapter); 5100 } 5101 } else { 5102 /* 5103 * Do it when link active changes to DOWN. i.e. 5104 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 5105 * b) LINK_STATE_UP -> LINK_STATE_DOWN 5106 */ 5107 if (adapter->link_active != LINK_STATE_DOWN) { 5108 if (bootverbose) 5109 device_printf(dev, "Link is Down\n"); 5110 if_link_state_change(ifp, LINK_STATE_DOWN); 5111 adapter->link_active = LINK_STATE_DOWN; 5112 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5113 ixgbe_ping_all_vfs(adapter); 5114 ixgbe_drain_all(adapter); 5115 } 5116 } 5117 } /* ixgbe_update_link_status */ 5118 5119 /************************************************************************ 5120 * ixgbe_config_dmac - Configure DMA Coalescing 5121 ************************************************************************/ 5122 static void 5123 ixgbe_config_dmac(struct adapter *adapter) 5124 { 5125 struct ixgbe_hw *hw = &adapter->hw; 5126 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 5127 5128 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 5129 return; 5130 5131 if (dcfg->watchdog_timer ^ adapter->dmac || 5132 dcfg->link_speed ^ adapter->link_speed) { 5133 dcfg->watchdog_timer = adapter->dmac; 5134 dcfg->fcoe_en = false; 5135 dcfg->link_speed = adapter->link_speed; 5136 dcfg->num_tcs = 1; 5137 5138 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 5139 dcfg->watchdog_timer, dcfg->link_speed); 5140 5141 hw->mac.ops.dmac_config(hw); 5142 } 5143 } /* ixgbe_config_dmac */ 5144 5145 /************************************************************************ 5146 * ixgbe_enable_intr 5147 ************************************************************************/ 5148 static void 5149 ixgbe_enable_intr(struct adapter *adapter) 5150 { 5151 struct ixgbe_hw *hw = &adapter->hw; 5152 struct ix_queue *que = adapter->queues; 5153 u32 mask, fwsm; 5154 5155 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 5156 5157 switch (adapter->hw.mac.type) { 5158 case ixgbe_mac_82599EB: 5159 mask |= IXGBE_EIMS_ECC; 5160 /* Temperature sensor on some adapters */ 5161 mask |= IXGBE_EIMS_GPI_SDP0; 5162 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 5163 mask |= IXGBE_EIMS_GPI_SDP1; 5164 mask |= IXGBE_EIMS_GPI_SDP2; 5165 break; 5166 case ixgbe_mac_X540: 5167 /* Detect if Thermal Sensor is enabled */ 5168 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 5169 if (fwsm & IXGBE_FWSM_TS_ENABLED) 5170 mask |= IXGBE_EIMS_TS; 5171 mask |= IXGBE_EIMS_ECC; 5172 break; 5173 case ixgbe_mac_X550: 5174 /* MAC thermal sensor is automatically enabled */ 5175 mask |= IXGBE_EIMS_TS; 5176 mask |= IXGBE_EIMS_ECC; 5177 break; 5178 case ixgbe_mac_X550EM_x: 5179 case ixgbe_mac_X550EM_a: 5180 /* Some devices use SDP0 for important information */ 5181 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 5182 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 5183 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 5184 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 5185 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 5186 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 5187 mask |= IXGBE_EICR_GPI_SDP0_X540; 5188 mask |= IXGBE_EIMS_ECC; 5189 break; 5190 default: 5191 break; 5192 } 5193 5194 /* Enable Fan Failure detection */ 5195 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 5196 mask |= IXGBE_EIMS_GPI_SDP1; 5197 /* Enable SR-IOV */ 5198 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 5199 mask |= IXGBE_EIMS_MAILBOX; 5200 /* Enable Flow Director */ 5201 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 5202 mask |= IXGBE_EIMS_FLOW_DIR; 5203 5204 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 5205 5206 /* With MSI-X we use auto clear */ 5207 if (adapter->msix_mem) { 5208 /* 5209 * It's not required to set TCP_TIMER because we don't use 5210 * it. 5211 */ 5212 IXGBE_WRITE_REG(hw, IXGBE_EIAC, IXGBE_EIMS_RTX_QUEUE); 5213 } 5214 5215 /* 5216 * Now enable all queues, this is done separately to 5217 * allow for handling the extended (beyond 32) MSI-X 5218 * vectors that can be used by 82599 5219 */ 5220 for (int i = 0; i < adapter->num_queues; i++, que++) 5221 ixgbe_enable_queue(adapter, que->msix); 5222 5223 IXGBE_WRITE_FLUSH(hw); 5224 5225 } /* ixgbe_enable_intr */ 5226 5227 /************************************************************************ 5228 * ixgbe_disable_intr_internal 5229 ************************************************************************/ 5230 static void 5231 ixgbe_disable_intr_internal(struct adapter *adapter, bool nestok) 5232 { 5233 struct ix_queue *que = adapter->queues; 5234 5235 /* disable interrupts other than queues */ 5236 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 5237 5238 if (adapter->msix_mem) 5239 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 5240 5241 for (int i = 0; i < adapter->num_queues; i++, que++) 5242 ixgbe_disable_queue_internal(adapter, que->msix, nestok); 5243 5244 IXGBE_WRITE_FLUSH(&adapter->hw); 5245 5246 } /* ixgbe_do_disable_intr_internal */ 5247 5248 /************************************************************************ 5249 * ixgbe_disable_intr 5250 ************************************************************************/ 5251 static void 5252 ixgbe_disable_intr(struct adapter *adapter) 5253 { 5254 5255 ixgbe_disable_intr_internal(adapter, true); 5256 } /* ixgbe_disable_intr */ 5257 5258 /************************************************************************ 5259 * ixgbe_ensure_disabled_intr 5260 ************************************************************************/ 5261 void 5262 ixgbe_ensure_disabled_intr(struct adapter *adapter) 5263 { 5264 5265 ixgbe_disable_intr_internal(adapter, false); 5266 } /* ixgbe_ensure_disabled_intr */ 5267 5268 /************************************************************************ 5269 * ixgbe_legacy_irq - Legacy Interrupt Service routine 5270 ************************************************************************/ 5271 static int 5272 ixgbe_legacy_irq(void *arg) 5273 { 5274 struct ix_queue *que = arg; 5275 struct adapter *adapter = que->adapter; 5276 struct ixgbe_hw *hw = &adapter->hw; 5277 struct tx_ring *txr = adapter->tx_rings; 5278 u32 eicr; 5279 u32 eims_orig; 5280 u32 eims_enable = 0; 5281 u32 eims_disable = 0; 5282 5283 eims_orig = IXGBE_READ_REG(hw, IXGBE_EIMS); 5284 /* 5285 * Silicon errata #26 on 82598. Disable all interrupts before reading 5286 * EICR. 5287 */ 5288 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 5289 5290 /* Read and clear EICR */ 5291 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 5292 5293 adapter->stats.pf.legint.ev_count++; 5294 if (eicr == 0) { 5295 adapter->stats.pf.intzero.ev_count++; 5296 IXGBE_WRITE_REG(hw, IXGBE_EIMS, eims_orig); 5297 return 0; 5298 } 5299 5300 /* Queue (0) intr */ 5301 if ((eicr & IXGBE_EIMC_RTX_QUEUE) != 0) { 5302 ++que->irqs.ev_count; 5303 5304 /* 5305 * The same as ixgbe_msix_que() about 5306 * "que->txrx_use_workqueue". 5307 */ 5308 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 5309 5310 IXGBE_TX_LOCK(txr); 5311 ixgbe_txeof(txr); 5312 #ifdef notyet 5313 if (!ixgbe_ring_empty(ifp, txr->br)) 5314 ixgbe_start_locked(ifp, txr); 5315 #endif 5316 IXGBE_TX_UNLOCK(txr); 5317 5318 que->req.ev_count++; 5319 ixgbe_sched_handle_que(adapter, que); 5320 /* Disable queue 0 interrupt */ 5321 eims_disable |= 1UL << 0; 5322 5323 } else 5324 eims_enable |= IXGBE_EIMC_RTX_QUEUE; 5325 5326 ixgbe_intr_admin_common(adapter, eicr, &eims_disable); 5327 5328 /* Re-enable some interrupts */ 5329 IXGBE_WRITE_REG(hw, IXGBE_EIMS, 5330 (eims_orig & ~eims_disable) | eims_enable); 5331 5332 return 1; 5333 } /* ixgbe_legacy_irq */ 5334 5335 /************************************************************************ 5336 * ixgbe_free_pciintr_resources 5337 ************************************************************************/ 5338 static void 5339 ixgbe_free_pciintr_resources(struct adapter *adapter) 5340 { 5341 struct ix_queue *que = adapter->queues; 5342 int rid; 5343 5344 /* 5345 * Release all msix queue resources: 5346 */ 5347 for (int i = 0; i < adapter->num_queues; i++, que++) { 5348 if (que->res != NULL) { 5349 pci_intr_disestablish(adapter->osdep.pc, 5350 adapter->osdep.ihs[i]); 5351 adapter->osdep.ihs[i] = NULL; 5352 } 5353 } 5354 5355 /* Clean the Legacy or Link interrupt last */ 5356 if (adapter->vector) /* we are doing MSIX */ 5357 rid = adapter->vector; 5358 else 5359 rid = 0; 5360 5361 if (adapter->osdep.ihs[rid] != NULL) { 5362 pci_intr_disestablish(adapter->osdep.pc, 5363 adapter->osdep.ihs[rid]); 5364 adapter->osdep.ihs[rid] = NULL; 5365 } 5366 5367 if (adapter->osdep.intrs != NULL) { 5368 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 5369 adapter->osdep.nintrs); 5370 adapter->osdep.intrs = NULL; 5371 } 5372 } /* ixgbe_free_pciintr_resources */ 5373 5374 /************************************************************************ 5375 * ixgbe_free_pci_resources 5376 ************************************************************************/ 5377 static void 5378 ixgbe_free_pci_resources(struct adapter *adapter) 5379 { 5380 5381 ixgbe_free_pciintr_resources(adapter); 5382 5383 if (adapter->osdep.mem_size != 0) { 5384 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 5385 adapter->osdep.mem_bus_space_handle, 5386 adapter->osdep.mem_size); 5387 } 5388 5389 } /* ixgbe_free_pci_resources */ 5390 5391 /************************************************************************ 5392 * ixgbe_set_sysctl_value 5393 ************************************************************************/ 5394 static void 5395 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 5396 const char *description, int *limit, int value) 5397 { 5398 device_t dev = adapter->dev; 5399 struct sysctllog **log; 5400 const struct sysctlnode *rnode, *cnode; 5401 5402 /* 5403 * It's not required to check recovery mode because this function never 5404 * touches hardware. 5405 */ 5406 5407 log = &adapter->sysctllog; 5408 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 5409 aprint_error_dev(dev, "could not create sysctl root\n"); 5410 return; 5411 } 5412 if (sysctl_createv(log, 0, &rnode, &cnode, 5413 CTLFLAG_READWRITE, CTLTYPE_INT, 5414 name, SYSCTL_DESCR(description), 5415 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 5416 aprint_error_dev(dev, "could not create sysctl\n"); 5417 *limit = value; 5418 } /* ixgbe_set_sysctl_value */ 5419 5420 /************************************************************************ 5421 * ixgbe_sysctl_flowcntl 5422 * 5423 * SYSCTL wrapper around setting Flow Control 5424 ************************************************************************/ 5425 static int 5426 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 5427 { 5428 struct sysctlnode node = *rnode; 5429 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5430 int error, fc; 5431 5432 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5433 return (EPERM); 5434 5435 fc = adapter->hw.fc.current_mode; 5436 node.sysctl_data = &fc; 5437 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5438 if (error != 0 || newp == NULL) 5439 return error; 5440 5441 /* Don't bother if it's not changed */ 5442 if (fc == adapter->hw.fc.current_mode) 5443 return (0); 5444 5445 return ixgbe_set_flowcntl(adapter, fc); 5446 } /* ixgbe_sysctl_flowcntl */ 5447 5448 /************************************************************************ 5449 * ixgbe_set_flowcntl - Set flow control 5450 * 5451 * Flow control values: 5452 * 0 - off 5453 * 1 - rx pause 5454 * 2 - tx pause 5455 * 3 - full 5456 ************************************************************************/ 5457 static int 5458 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 5459 { 5460 switch (fc) { 5461 case ixgbe_fc_rx_pause: 5462 case ixgbe_fc_tx_pause: 5463 case ixgbe_fc_full: 5464 adapter->hw.fc.requested_mode = fc; 5465 if (adapter->num_queues > 1) 5466 ixgbe_disable_rx_drop(adapter); 5467 break; 5468 case ixgbe_fc_none: 5469 adapter->hw.fc.requested_mode = ixgbe_fc_none; 5470 if (adapter->num_queues > 1) 5471 ixgbe_enable_rx_drop(adapter); 5472 break; 5473 default: 5474 return (EINVAL); 5475 } 5476 5477 #if 0 /* XXX NetBSD */ 5478 /* Don't autoneg if forcing a value */ 5479 adapter->hw.fc.disable_fc_autoneg = TRUE; 5480 #endif 5481 ixgbe_fc_enable(&adapter->hw); 5482 5483 return (0); 5484 } /* ixgbe_set_flowcntl */ 5485 5486 /************************************************************************ 5487 * ixgbe_enable_rx_drop 5488 * 5489 * Enable the hardware to drop packets when the buffer is 5490 * full. This is useful with multiqueue, so that no single 5491 * queue being full stalls the entire RX engine. We only 5492 * enable this when Multiqueue is enabled AND Flow Control 5493 * is disabled. 5494 ************************************************************************/ 5495 static void 5496 ixgbe_enable_rx_drop(struct adapter *adapter) 5497 { 5498 struct ixgbe_hw *hw = &adapter->hw; 5499 struct rx_ring *rxr; 5500 u32 srrctl; 5501 5502 for (int i = 0; i < adapter->num_queues; i++) { 5503 rxr = &adapter->rx_rings[i]; 5504 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5505 srrctl |= IXGBE_SRRCTL_DROP_EN; 5506 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5507 } 5508 5509 /* enable drop for each vf */ 5510 for (int i = 0; i < adapter->num_vfs; i++) { 5511 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5512 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 5513 IXGBE_QDE_ENABLE)); 5514 } 5515 } /* ixgbe_enable_rx_drop */ 5516 5517 /************************************************************************ 5518 * ixgbe_disable_rx_drop 5519 ************************************************************************/ 5520 static void 5521 ixgbe_disable_rx_drop(struct adapter *adapter) 5522 { 5523 struct ixgbe_hw *hw = &adapter->hw; 5524 struct rx_ring *rxr; 5525 u32 srrctl; 5526 5527 for (int i = 0; i < adapter->num_queues; i++) { 5528 rxr = &adapter->rx_rings[i]; 5529 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5530 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 5531 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5532 } 5533 5534 /* disable drop for each vf */ 5535 for (int i = 0; i < adapter->num_vfs; i++) { 5536 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5537 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 5538 } 5539 } /* ixgbe_disable_rx_drop */ 5540 5541 /************************************************************************ 5542 * ixgbe_sysctl_advertise 5543 * 5544 * SYSCTL wrapper around setting advertised speed 5545 ************************************************************************/ 5546 static int 5547 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 5548 { 5549 struct sysctlnode node = *rnode; 5550 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5551 int error = 0, advertise; 5552 5553 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5554 return (EPERM); 5555 5556 advertise = adapter->advertise; 5557 node.sysctl_data = &advertise; 5558 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5559 if (error != 0 || newp == NULL) 5560 return error; 5561 5562 return ixgbe_set_advertise(adapter, advertise); 5563 } /* ixgbe_sysctl_advertise */ 5564 5565 /************************************************************************ 5566 * ixgbe_set_advertise - Control advertised link speed 5567 * 5568 * Flags: 5569 * 0x00 - Default (all capable link speed) 5570 * 0x1 - advertise 100 Mb 5571 * 0x2 - advertise 1G 5572 * 0x4 - advertise 10G 5573 * 0x8 - advertise 10 Mb (yes, Mb) 5574 * 0x10 - advertise 2.5G 5575 * 0x20 - advertise 5G 5576 ************************************************************************/ 5577 static int 5578 ixgbe_set_advertise(struct adapter *adapter, int advertise) 5579 { 5580 device_t dev; 5581 struct ixgbe_hw *hw; 5582 ixgbe_link_speed speed = 0; 5583 ixgbe_link_speed link_caps = 0; 5584 s32 err = IXGBE_NOT_IMPLEMENTED; 5585 bool negotiate = FALSE; 5586 5587 /* Checks to validate new value */ 5588 if (adapter->advertise == advertise) /* no change */ 5589 return (0); 5590 5591 dev = adapter->dev; 5592 hw = &adapter->hw; 5593 5594 /* No speed changes for backplane media */ 5595 if (hw->phy.media_type == ixgbe_media_type_backplane) 5596 return (ENODEV); 5597 5598 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5599 (hw->phy.multispeed_fiber))) { 5600 device_printf(dev, 5601 "Advertised speed can only be set on copper or " 5602 "multispeed fiber media types.\n"); 5603 return (EINVAL); 5604 } 5605 5606 if (advertise < 0x0 || advertise > 0x3f) { 5607 device_printf(dev, "Invalid advertised speed; valid modes are 0x0 through 0x3f\n"); 5608 return (EINVAL); 5609 } 5610 5611 if (hw->mac.ops.get_link_capabilities) { 5612 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5613 &negotiate); 5614 if (err != IXGBE_SUCCESS) { 5615 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5616 return (ENODEV); 5617 } 5618 } 5619 5620 /* Set new value and report new advertised mode */ 5621 if (advertise & 0x1) { 5622 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5623 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5624 return (EINVAL); 5625 } 5626 speed |= IXGBE_LINK_SPEED_100_FULL; 5627 } 5628 if (advertise & 0x2) { 5629 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5630 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5631 return (EINVAL); 5632 } 5633 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5634 } 5635 if (advertise & 0x4) { 5636 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5637 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5638 return (EINVAL); 5639 } 5640 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5641 } 5642 if (advertise & 0x8) { 5643 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5644 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5645 return (EINVAL); 5646 } 5647 speed |= IXGBE_LINK_SPEED_10_FULL; 5648 } 5649 if (advertise & 0x10) { 5650 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5651 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5652 return (EINVAL); 5653 } 5654 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5655 } 5656 if (advertise & 0x20) { 5657 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5658 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5659 return (EINVAL); 5660 } 5661 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5662 } 5663 if (advertise == 0) 5664 speed = link_caps; /* All capable link speed */ 5665 5666 hw->mac.autotry_restart = TRUE; 5667 hw->mac.ops.setup_link(hw, speed, TRUE); 5668 adapter->advertise = advertise; 5669 5670 return (0); 5671 } /* ixgbe_set_advertise */ 5672 5673 /************************************************************************ 5674 * ixgbe_get_default_advertise - Get default advertised speed settings 5675 * 5676 * Formatted for sysctl usage. 5677 * Flags: 5678 * 0x1 - advertise 100 Mb 5679 * 0x2 - advertise 1G 5680 * 0x4 - advertise 10G 5681 * 0x8 - advertise 10 Mb (yes, Mb) 5682 * 0x10 - advertise 2.5G 5683 * 0x20 - advertise 5G 5684 ************************************************************************/ 5685 static int 5686 ixgbe_get_default_advertise(struct adapter *adapter) 5687 { 5688 struct ixgbe_hw *hw = &adapter->hw; 5689 int speed; 5690 ixgbe_link_speed link_caps = 0; 5691 s32 err; 5692 bool negotiate = FALSE; 5693 5694 /* 5695 * Advertised speed means nothing unless it's copper or 5696 * multi-speed fiber 5697 */ 5698 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5699 !(hw->phy.multispeed_fiber)) 5700 return (0); 5701 5702 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5703 if (err != IXGBE_SUCCESS) 5704 return (0); 5705 5706 speed = 5707 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x4 : 0) | 5708 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0) | 5709 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5710 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x2 : 0) | 5711 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x1 : 0) | 5712 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x8 : 0); 5713 5714 return speed; 5715 } /* ixgbe_get_default_advertise */ 5716 5717 /************************************************************************ 5718 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5719 * 5720 * Control values: 5721 * 0/1 - off / on (use default value of 1000) 5722 * 5723 * Legal timer values are: 5724 * 50,100,250,500,1000,2000,5000,10000 5725 * 5726 * Turning off interrupt moderation will also turn this off. 5727 ************************************************************************/ 5728 static int 5729 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5730 { 5731 struct sysctlnode node = *rnode; 5732 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5733 struct ifnet *ifp = adapter->ifp; 5734 int error; 5735 int newval; 5736 5737 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5738 return (EPERM); 5739 5740 newval = adapter->dmac; 5741 node.sysctl_data = &newval; 5742 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5743 if ((error) || (newp == NULL)) 5744 return (error); 5745 5746 switch (newval) { 5747 case 0: 5748 /* Disabled */ 5749 adapter->dmac = 0; 5750 break; 5751 case 1: 5752 /* Enable and use default */ 5753 adapter->dmac = 1000; 5754 break; 5755 case 50: 5756 case 100: 5757 case 250: 5758 case 500: 5759 case 1000: 5760 case 2000: 5761 case 5000: 5762 case 10000: 5763 /* Legal values - allow */ 5764 adapter->dmac = newval; 5765 break; 5766 default: 5767 /* Do nothing, illegal value */ 5768 return (EINVAL); 5769 } 5770 5771 /* Re-initialize hardware if it's already running */ 5772 if (ifp->if_flags & IFF_RUNNING) 5773 ifp->if_init(ifp); 5774 5775 return (0); 5776 } 5777 5778 #ifdef IXGBE_DEBUG 5779 /************************************************************************ 5780 * ixgbe_sysctl_power_state 5781 * 5782 * Sysctl to test power states 5783 * Values: 5784 * 0 - set device to D0 5785 * 3 - set device to D3 5786 * (none) - get current device power state 5787 ************************************************************************/ 5788 static int 5789 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5790 { 5791 #ifdef notyet 5792 struct sysctlnode node = *rnode; 5793 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5794 device_t dev = adapter->dev; 5795 int curr_ps, new_ps, error = 0; 5796 5797 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5798 return (EPERM); 5799 5800 curr_ps = new_ps = pci_get_powerstate(dev); 5801 5802 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5803 if ((error) || (req->newp == NULL)) 5804 return (error); 5805 5806 if (new_ps == curr_ps) 5807 return (0); 5808 5809 if (new_ps == 3 && curr_ps == 0) 5810 error = DEVICE_SUSPEND(dev); 5811 else if (new_ps == 0 && curr_ps == 3) 5812 error = DEVICE_RESUME(dev); 5813 else 5814 return (EINVAL); 5815 5816 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5817 5818 return (error); 5819 #else 5820 return 0; 5821 #endif 5822 } /* ixgbe_sysctl_power_state */ 5823 #endif 5824 5825 /************************************************************************ 5826 * ixgbe_sysctl_wol_enable 5827 * 5828 * Sysctl to enable/disable the WoL capability, 5829 * if supported by the adapter. 5830 * 5831 * Values: 5832 * 0 - disabled 5833 * 1 - enabled 5834 ************************************************************************/ 5835 static int 5836 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5837 { 5838 struct sysctlnode node = *rnode; 5839 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5840 struct ixgbe_hw *hw = &adapter->hw; 5841 bool new_wol_enabled; 5842 int error = 0; 5843 5844 /* 5845 * It's not required to check recovery mode because this function never 5846 * touches hardware. 5847 */ 5848 new_wol_enabled = hw->wol_enabled; 5849 node.sysctl_data = &new_wol_enabled; 5850 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5851 if ((error) || (newp == NULL)) 5852 return (error); 5853 if (new_wol_enabled == hw->wol_enabled) 5854 return (0); 5855 5856 if (new_wol_enabled && !adapter->wol_support) 5857 return (ENODEV); 5858 else 5859 hw->wol_enabled = new_wol_enabled; 5860 5861 return (0); 5862 } /* ixgbe_sysctl_wol_enable */ 5863 5864 /************************************************************************ 5865 * ixgbe_sysctl_wufc - Wake Up Filter Control 5866 * 5867 * Sysctl to enable/disable the types of packets that the 5868 * adapter will wake up on upon receipt. 5869 * Flags: 5870 * 0x1 - Link Status Change 5871 * 0x2 - Magic Packet 5872 * 0x4 - Direct Exact 5873 * 0x8 - Directed Multicast 5874 * 0x10 - Broadcast 5875 * 0x20 - ARP/IPv4 Request Packet 5876 * 0x40 - Direct IPv4 Packet 5877 * 0x80 - Direct IPv6 Packet 5878 * 5879 * Settings not listed above will cause the sysctl to return an error. 5880 ************************************************************************/ 5881 static int 5882 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5883 { 5884 struct sysctlnode node = *rnode; 5885 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5886 int error = 0; 5887 u32 new_wufc; 5888 5889 /* 5890 * It's not required to check recovery mode because this function never 5891 * touches hardware. 5892 */ 5893 new_wufc = adapter->wufc; 5894 node.sysctl_data = &new_wufc; 5895 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5896 if ((error) || (newp == NULL)) 5897 return (error); 5898 if (new_wufc == adapter->wufc) 5899 return (0); 5900 5901 if (new_wufc & 0xffffff00) 5902 return (EINVAL); 5903 5904 new_wufc &= 0xff; 5905 new_wufc |= (0xffffff & adapter->wufc); 5906 adapter->wufc = new_wufc; 5907 5908 return (0); 5909 } /* ixgbe_sysctl_wufc */ 5910 5911 #ifdef IXGBE_DEBUG 5912 /************************************************************************ 5913 * ixgbe_sysctl_print_rss_config 5914 ************************************************************************/ 5915 static int 5916 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5917 { 5918 #ifdef notyet 5919 struct sysctlnode node = *rnode; 5920 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5921 struct ixgbe_hw *hw = &adapter->hw; 5922 device_t dev = adapter->dev; 5923 struct sbuf *buf; 5924 int error = 0, reta_size; 5925 u32 reg; 5926 5927 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5928 return (EPERM); 5929 5930 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5931 if (!buf) { 5932 device_printf(dev, "Could not allocate sbuf for output.\n"); 5933 return (ENOMEM); 5934 } 5935 5936 // TODO: use sbufs to make a string to print out 5937 /* Set multiplier for RETA setup and table size based on MAC */ 5938 switch (adapter->hw.mac.type) { 5939 case ixgbe_mac_X550: 5940 case ixgbe_mac_X550EM_x: 5941 case ixgbe_mac_X550EM_a: 5942 reta_size = 128; 5943 break; 5944 default: 5945 reta_size = 32; 5946 break; 5947 } 5948 5949 /* Print out the redirection table */ 5950 sbuf_cat(buf, "\n"); 5951 for (int i = 0; i < reta_size; i++) { 5952 if (i < 32) { 5953 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5954 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5955 } else { 5956 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5957 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5958 } 5959 } 5960 5961 // TODO: print more config 5962 5963 error = sbuf_finish(buf); 5964 if (error) 5965 device_printf(dev, "Error finishing sbuf: %d\n", error); 5966 5967 sbuf_delete(buf); 5968 #endif 5969 return (0); 5970 } /* ixgbe_sysctl_print_rss_config */ 5971 #endif /* IXGBE_DEBUG */ 5972 5973 /************************************************************************ 5974 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5975 * 5976 * For X552/X557-AT devices using an external PHY 5977 ************************************************************************/ 5978 static int 5979 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5980 { 5981 struct sysctlnode node = *rnode; 5982 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5983 struct ixgbe_hw *hw = &adapter->hw; 5984 int val; 5985 u16 reg; 5986 int error; 5987 5988 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5989 return (EPERM); 5990 5991 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5992 device_printf(adapter->dev, 5993 "Device has no supported external thermal sensor.\n"); 5994 return (ENODEV); 5995 } 5996 5997 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5998 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5999 device_printf(adapter->dev, 6000 "Error reading from PHY's current temperature register\n"); 6001 return (EAGAIN); 6002 } 6003 6004 node.sysctl_data = &val; 6005 6006 /* Shift temp for output */ 6007 val = reg >> 8; 6008 6009 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6010 if ((error) || (newp == NULL)) 6011 return (error); 6012 6013 return (0); 6014 } /* ixgbe_sysctl_phy_temp */ 6015 6016 /************************************************************************ 6017 * ixgbe_sysctl_phy_overtemp_occurred 6018 * 6019 * Reports (directly from the PHY) whether the current PHY 6020 * temperature is over the overtemp threshold. 6021 ************************************************************************/ 6022 static int 6023 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 6024 { 6025 struct sysctlnode node = *rnode; 6026 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6027 struct ixgbe_hw *hw = &adapter->hw; 6028 int val, error; 6029 u16 reg; 6030 6031 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6032 return (EPERM); 6033 6034 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 6035 device_printf(adapter->dev, 6036 "Device has no supported external thermal sensor.\n"); 6037 return (ENODEV); 6038 } 6039 6040 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 6041 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 6042 device_printf(adapter->dev, 6043 "Error reading from PHY's temperature status register\n"); 6044 return (EAGAIN); 6045 } 6046 6047 node.sysctl_data = &val; 6048 6049 /* Get occurrence bit */ 6050 val = !!(reg & 0x4000); 6051 6052 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6053 if ((error) || (newp == NULL)) 6054 return (error); 6055 6056 return (0); 6057 } /* ixgbe_sysctl_phy_overtemp_occurred */ 6058 6059 /************************************************************************ 6060 * ixgbe_sysctl_eee_state 6061 * 6062 * Sysctl to set EEE power saving feature 6063 * Values: 6064 * 0 - disable EEE 6065 * 1 - enable EEE 6066 * (none) - get current device EEE state 6067 ************************************************************************/ 6068 static int 6069 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 6070 { 6071 struct sysctlnode node = *rnode; 6072 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6073 struct ifnet *ifp = adapter->ifp; 6074 device_t dev = adapter->dev; 6075 int curr_eee, new_eee, error = 0; 6076 s32 retval; 6077 6078 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6079 return (EPERM); 6080 6081 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 6082 node.sysctl_data = &new_eee; 6083 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6084 if ((error) || (newp == NULL)) 6085 return (error); 6086 6087 /* Nothing to do */ 6088 if (new_eee == curr_eee) 6089 return (0); 6090 6091 /* Not supported */ 6092 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 6093 return (EINVAL); 6094 6095 /* Bounds checking */ 6096 if ((new_eee < 0) || (new_eee > 1)) 6097 return (EINVAL); 6098 6099 retval = ixgbe_setup_eee(&adapter->hw, new_eee); 6100 if (retval) { 6101 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 6102 return (EINVAL); 6103 } 6104 6105 /* Restart auto-neg */ 6106 ifp->if_init(ifp); 6107 6108 device_printf(dev, "New EEE state: %d\n", new_eee); 6109 6110 /* Cache new value */ 6111 if (new_eee) 6112 adapter->feat_en |= IXGBE_FEATURE_EEE; 6113 else 6114 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 6115 6116 return (error); 6117 } /* ixgbe_sysctl_eee_state */ 6118 6119 #define PRINTQS(adapter, regname) \ 6120 do { \ 6121 struct ixgbe_hw *_hw = &(adapter)->hw; \ 6122 int _i; \ 6123 \ 6124 printf("%s: %s", device_xname((adapter)->dev), #regname); \ 6125 for (_i = 0; _i < (adapter)->num_queues; _i++) { \ 6126 printf((_i == 0) ? "\t" : " "); \ 6127 printf("%08x", IXGBE_READ_REG(_hw, \ 6128 IXGBE_##regname(_i))); \ 6129 } \ 6130 printf("\n"); \ 6131 } while (0) 6132 6133 /************************************************************************ 6134 * ixgbe_print_debug_info 6135 * 6136 * Called only when em_display_debug_stats is enabled. 6137 * Provides a way to take a look at important statistics 6138 * maintained by the driver and hardware. 6139 ************************************************************************/ 6140 static void 6141 ixgbe_print_debug_info(struct adapter *adapter) 6142 { 6143 device_t dev = adapter->dev; 6144 struct ixgbe_hw *hw = &adapter->hw; 6145 int table_size; 6146 int i; 6147 6148 switch (adapter->hw.mac.type) { 6149 case ixgbe_mac_X550: 6150 case ixgbe_mac_X550EM_x: 6151 case ixgbe_mac_X550EM_a: 6152 table_size = 128; 6153 break; 6154 default: 6155 table_size = 32; 6156 break; 6157 } 6158 6159 device_printf(dev, "[E]RETA:\n"); 6160 for (i = 0; i < table_size; i++) { 6161 if (i < 32) 6162 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 6163 IXGBE_RETA(i))); 6164 else 6165 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 6166 IXGBE_ERETA(i - 32))); 6167 } 6168 6169 device_printf(dev, "queue:"); 6170 for (i = 0; i < adapter->num_queues; i++) { 6171 printf((i == 0) ? "\t" : " "); 6172 printf("%8d", i); 6173 } 6174 printf("\n"); 6175 PRINTQS(adapter, RDBAL); 6176 PRINTQS(adapter, RDBAH); 6177 PRINTQS(adapter, RDLEN); 6178 PRINTQS(adapter, SRRCTL); 6179 PRINTQS(adapter, RDH); 6180 PRINTQS(adapter, RDT); 6181 PRINTQS(adapter, RXDCTL); 6182 6183 device_printf(dev, "RQSMR:"); 6184 for (i = 0; i < adapter->num_queues / 4; i++) { 6185 printf((i == 0) ? "\t" : " "); 6186 printf("%08x", IXGBE_READ_REG(hw, IXGBE_RQSMR(i))); 6187 } 6188 printf("\n"); 6189 6190 device_printf(dev, "disabled_count:"); 6191 for (i = 0; i < adapter->num_queues; i++) { 6192 printf((i == 0) ? "\t" : " "); 6193 printf("%8d", adapter->queues[i].disabled_count); 6194 } 6195 printf("\n"); 6196 6197 device_printf(dev, "EIMS:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIMS)); 6198 if (hw->mac.type != ixgbe_mac_82598EB) { 6199 device_printf(dev, "EIMS_EX(0):\t%08x\n", 6200 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(0))); 6201 device_printf(dev, "EIMS_EX(1):\t%08x\n", 6202 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(1))); 6203 } 6204 device_printf(dev, "EIAM:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIAM)); 6205 device_printf(dev, "EIAC:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIAC)); 6206 } /* ixgbe_print_debug_info */ 6207 6208 /************************************************************************ 6209 * ixgbe_sysctl_debug 6210 ************************************************************************/ 6211 static int 6212 ixgbe_sysctl_debug(SYSCTLFN_ARGS) 6213 { 6214 struct sysctlnode node = *rnode; 6215 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6216 int error, result = 0; 6217 6218 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6219 return (EPERM); 6220 6221 node.sysctl_data = &result; 6222 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6223 6224 if (error || newp == NULL) 6225 return error; 6226 6227 if (result == 1) 6228 ixgbe_print_debug_info(adapter); 6229 6230 return 0; 6231 } /* ixgbe_sysctl_debug */ 6232 6233 /************************************************************************ 6234 * ixgbe_sysctl_rx_copy_len 6235 ************************************************************************/ 6236 static int 6237 ixgbe_sysctl_rx_copy_len(SYSCTLFN_ARGS) 6238 { 6239 struct sysctlnode node = *rnode; 6240 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6241 int error; 6242 int result = adapter->rx_copy_len; 6243 6244 node.sysctl_data = &result; 6245 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6246 6247 if (error || newp == NULL) 6248 return error; 6249 6250 if ((result < 0) || (result > IXGBE_RX_COPY_LEN_MAX)) 6251 return EINVAL; 6252 6253 adapter->rx_copy_len = result; 6254 6255 return 0; 6256 } /* ixgbe_sysctl_rx_copy_len */ 6257 6258 /************************************************************************ 6259 * ixgbe_init_device_features 6260 ************************************************************************/ 6261 static void 6262 ixgbe_init_device_features(struct adapter *adapter) 6263 { 6264 adapter->feat_cap = IXGBE_FEATURE_NETMAP 6265 | IXGBE_FEATURE_RSS 6266 | IXGBE_FEATURE_MSI 6267 | IXGBE_FEATURE_MSIX 6268 | IXGBE_FEATURE_LEGACY_IRQ 6269 | IXGBE_FEATURE_LEGACY_TX; 6270 6271 /* Set capabilities first... */ 6272 switch (adapter->hw.mac.type) { 6273 case ixgbe_mac_82598EB: 6274 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 6275 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 6276 break; 6277 case ixgbe_mac_X540: 6278 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6279 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6280 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 6281 (adapter->hw.bus.func == 0)) 6282 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6283 break; 6284 case ixgbe_mac_X550: 6285 /* 6286 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6287 * NVM Image version. 6288 */ 6289 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6290 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6291 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6292 break; 6293 case ixgbe_mac_X550EM_x: 6294 /* 6295 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6296 * NVM Image version. 6297 */ 6298 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6299 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6300 break; 6301 case ixgbe_mac_X550EM_a: 6302 /* 6303 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6304 * NVM Image version. 6305 */ 6306 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6307 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6308 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6309 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 6310 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 6311 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6312 adapter->feat_cap |= IXGBE_FEATURE_EEE; 6313 } 6314 break; 6315 case ixgbe_mac_82599EB: 6316 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6317 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6318 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 6319 (adapter->hw.bus.func == 0)) 6320 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6321 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 6322 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6323 break; 6324 default: 6325 break; 6326 } 6327 6328 /* Enabled by default... */ 6329 /* Fan failure detection */ 6330 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 6331 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 6332 /* Netmap */ 6333 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 6334 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 6335 /* EEE */ 6336 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 6337 adapter->feat_en |= IXGBE_FEATURE_EEE; 6338 /* Thermal Sensor */ 6339 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 6340 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 6341 /* 6342 * Recovery mode: 6343 * NetBSD: IXGBE_FEATURE_RECOVERY_MODE will be controlled after reading 6344 * NVM Image version. 6345 */ 6346 6347 /* Enabled via global sysctl... */ 6348 /* Flow Director */ 6349 if (ixgbe_enable_fdir) { 6350 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 6351 adapter->feat_en |= IXGBE_FEATURE_FDIR; 6352 else 6353 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 6354 } 6355 /* Legacy (single queue) transmit */ 6356 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 6357 ixgbe_enable_legacy_tx) 6358 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 6359 /* 6360 * Message Signal Interrupts - Extended (MSI-X) 6361 * Normal MSI is only enabled if MSI-X calls fail. 6362 */ 6363 if (!ixgbe_enable_msix) 6364 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 6365 /* Receive-Side Scaling (RSS) */ 6366 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 6367 adapter->feat_en |= IXGBE_FEATURE_RSS; 6368 6369 /* Disable features with unmet dependencies... */ 6370 /* No MSI-X */ 6371 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 6372 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6373 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6374 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6375 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6376 } 6377 } /* ixgbe_init_device_features */ 6378 6379 /************************************************************************ 6380 * ixgbe_probe - Device identification routine 6381 * 6382 * Determines if the driver should be loaded on 6383 * adapter based on its PCI vendor/device ID. 6384 * 6385 * return BUS_PROBE_DEFAULT on success, positive on failure 6386 ************************************************************************/ 6387 static int 6388 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 6389 { 6390 const struct pci_attach_args *pa = aux; 6391 6392 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 6393 } 6394 6395 static const ixgbe_vendor_info_t * 6396 ixgbe_lookup(const struct pci_attach_args *pa) 6397 { 6398 const ixgbe_vendor_info_t *ent; 6399 pcireg_t subid; 6400 6401 INIT_DEBUGOUT("ixgbe_lookup: begin"); 6402 6403 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 6404 return NULL; 6405 6406 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 6407 6408 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 6409 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 6410 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 6411 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 6412 (ent->subvendor_id == 0)) && 6413 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 6414 (ent->subdevice_id == 0))) { 6415 return ent; 6416 } 6417 } 6418 return NULL; 6419 } 6420 6421 static int 6422 ixgbe_ifflags_cb(struct ethercom *ec) 6423 { 6424 struct ifnet *ifp = &ec->ec_if; 6425 struct adapter *adapter = ifp->if_softc; 6426 u_short change; 6427 int rv = 0; 6428 6429 IXGBE_CORE_LOCK(adapter); 6430 6431 change = ifp->if_flags ^ adapter->if_flags; 6432 if (change != 0) 6433 adapter->if_flags = ifp->if_flags; 6434 6435 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 6436 rv = ENETRESET; 6437 goto out; 6438 } else if ((change & IFF_PROMISC) != 0) 6439 ixgbe_set_rxfilter(adapter); 6440 6441 /* Check for ec_capenable. */ 6442 change = ec->ec_capenable ^ adapter->ec_capenable; 6443 adapter->ec_capenable = ec->ec_capenable; 6444 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 6445 | ETHERCAP_VLAN_HWFILTER)) != 0) { 6446 rv = ENETRESET; 6447 goto out; 6448 } 6449 6450 /* 6451 * Special handling is not required for ETHERCAP_VLAN_MTU. 6452 * MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 6453 */ 6454 6455 /* Set up VLAN support and filter */ 6456 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 6457 ixgbe_setup_vlan_hw_support(adapter); 6458 6459 out: 6460 IXGBE_CORE_UNLOCK(adapter); 6461 6462 return rv; 6463 } 6464 6465 /************************************************************************ 6466 * ixgbe_ioctl - Ioctl entry point 6467 * 6468 * Called when the user wants to configure the interface. 6469 * 6470 * return 0 on success, positive on failure 6471 ************************************************************************/ 6472 static int 6473 ixgbe_ioctl(struct ifnet *ifp, u_long command, void *data) 6474 { 6475 struct adapter *adapter = ifp->if_softc; 6476 struct ixgbe_hw *hw = &adapter->hw; 6477 struct ifcapreq *ifcr = data; 6478 struct ifreq *ifr = data; 6479 int error = 0; 6480 int l4csum_en; 6481 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 6482 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 6483 6484 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6485 return (EPERM); 6486 6487 switch (command) { 6488 case SIOCSIFFLAGS: 6489 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 6490 break; 6491 case SIOCADDMULTI: 6492 case SIOCDELMULTI: 6493 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 6494 break; 6495 case SIOCSIFMEDIA: 6496 case SIOCGIFMEDIA: 6497 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 6498 break; 6499 case SIOCSIFCAP: 6500 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 6501 break; 6502 case SIOCSIFMTU: 6503 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 6504 break; 6505 #ifdef __NetBSD__ 6506 case SIOCINITIFADDR: 6507 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 6508 break; 6509 case SIOCGIFFLAGS: 6510 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 6511 break; 6512 case SIOCGIFAFLAG_IN: 6513 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 6514 break; 6515 case SIOCGIFADDR: 6516 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 6517 break; 6518 case SIOCGIFMTU: 6519 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 6520 break; 6521 case SIOCGIFCAP: 6522 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 6523 break; 6524 case SIOCGETHERCAP: 6525 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 6526 break; 6527 case SIOCGLIFADDR: 6528 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 6529 break; 6530 case SIOCZIFDATA: 6531 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 6532 hw->mac.ops.clear_hw_cntrs(hw); 6533 ixgbe_clear_evcnt(adapter); 6534 break; 6535 case SIOCAIFADDR: 6536 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 6537 break; 6538 #endif 6539 default: 6540 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 6541 break; 6542 } 6543 6544 switch (command) { 6545 case SIOCGI2C: 6546 { 6547 struct ixgbe_i2c_req i2c; 6548 6549 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 6550 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 6551 if (error != 0) 6552 break; 6553 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 6554 error = EINVAL; 6555 break; 6556 } 6557 if (i2c.len > sizeof(i2c.data)) { 6558 error = EINVAL; 6559 break; 6560 } 6561 6562 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 6563 i2c.dev_addr, i2c.data); 6564 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 6565 break; 6566 } 6567 case SIOCSIFCAP: 6568 /* Layer-4 Rx checksum offload has to be turned on and 6569 * off as a unit. 6570 */ 6571 l4csum_en = ifcr->ifcr_capenable & l4csum; 6572 if (l4csum_en != l4csum && l4csum_en != 0) 6573 return EINVAL; 6574 /*FALLTHROUGH*/ 6575 case SIOCADDMULTI: 6576 case SIOCDELMULTI: 6577 case SIOCSIFFLAGS: 6578 case SIOCSIFMTU: 6579 default: 6580 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 6581 return error; 6582 if ((ifp->if_flags & IFF_RUNNING) == 0) 6583 ; 6584 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 6585 IXGBE_CORE_LOCK(adapter); 6586 if ((ifp->if_flags & IFF_RUNNING) != 0) 6587 ixgbe_init_locked(adapter); 6588 ixgbe_recalculate_max_frame(adapter); 6589 IXGBE_CORE_UNLOCK(adapter); 6590 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 6591 /* 6592 * Multicast list has changed; set the hardware filter 6593 * accordingly. 6594 */ 6595 IXGBE_CORE_LOCK(adapter); 6596 ixgbe_disable_intr(adapter); 6597 ixgbe_set_rxfilter(adapter); 6598 ixgbe_enable_intr(adapter); 6599 IXGBE_CORE_UNLOCK(adapter); 6600 } 6601 return 0; 6602 } 6603 6604 return error; 6605 } /* ixgbe_ioctl */ 6606 6607 /************************************************************************ 6608 * ixgbe_check_fan_failure 6609 ************************************************************************/ 6610 static int 6611 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 6612 { 6613 u32 mask; 6614 6615 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 6616 IXGBE_ESDP_SDP1; 6617 6618 if (reg & mask) { 6619 device_printf(adapter->dev, 6620 "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 6621 return IXGBE_ERR_FAN_FAILURE; 6622 } 6623 6624 return IXGBE_SUCCESS; 6625 } /* ixgbe_check_fan_failure */ 6626 6627 /************************************************************************ 6628 * ixgbe_handle_que 6629 ************************************************************************/ 6630 static void 6631 ixgbe_handle_que(void *context) 6632 { 6633 struct ix_queue *que = context; 6634 struct adapter *adapter = que->adapter; 6635 struct tx_ring *txr = que->txr; 6636 struct ifnet *ifp = adapter->ifp; 6637 bool more = false; 6638 6639 que->handleq.ev_count++; 6640 6641 if (ifp->if_flags & IFF_RUNNING) { 6642 more = ixgbe_rxeof(que); 6643 IXGBE_TX_LOCK(txr); 6644 more |= ixgbe_txeof(txr); 6645 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 6646 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 6647 ixgbe_mq_start_locked(ifp, txr); 6648 /* Only for queue 0 */ 6649 /* NetBSD still needs this for CBQ */ 6650 if ((&adapter->queues[0] == que) 6651 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 6652 ixgbe_legacy_start_locked(ifp, txr); 6653 IXGBE_TX_UNLOCK(txr); 6654 } 6655 6656 if (more) { 6657 que->req.ev_count++; 6658 ixgbe_sched_handle_que(adapter, que); 6659 } else if (que->res != NULL) { 6660 /* MSIX: Re-enable this interrupt */ 6661 ixgbe_enable_queue(adapter, que->msix); 6662 } else { 6663 /* INTx or MSI */ 6664 ixgbe_enable_queue(adapter, 0); 6665 } 6666 6667 return; 6668 } /* ixgbe_handle_que */ 6669 6670 /************************************************************************ 6671 * ixgbe_handle_que_work 6672 ************************************************************************/ 6673 static void 6674 ixgbe_handle_que_work(struct work *wk, void *context) 6675 { 6676 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 6677 6678 /* 6679 * "enqueued flag" is not required here. 6680 * See ixgbe_msix_que(). 6681 */ 6682 ixgbe_handle_que(que); 6683 } 6684 6685 /************************************************************************ 6686 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 6687 ************************************************************************/ 6688 static int 6689 ixgbe_allocate_legacy(struct adapter *adapter, 6690 const struct pci_attach_args *pa) 6691 { 6692 device_t dev = adapter->dev; 6693 struct ix_queue *que = adapter->queues; 6694 struct tx_ring *txr = adapter->tx_rings; 6695 int counts[PCI_INTR_TYPE_SIZE]; 6696 pci_intr_type_t intr_type, max_type; 6697 char intrbuf[PCI_INTRSTR_LEN]; 6698 char wqname[MAXCOMLEN]; 6699 const char *intrstr = NULL; 6700 int defertx_error = 0, error; 6701 6702 /* We allocate a single interrupt resource */ 6703 max_type = PCI_INTR_TYPE_MSI; 6704 counts[PCI_INTR_TYPE_MSIX] = 0; 6705 counts[PCI_INTR_TYPE_MSI] = 6706 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 6707 /* Check not feat_en but feat_cap to fallback to INTx */ 6708 counts[PCI_INTR_TYPE_INTX] = 6709 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 6710 6711 alloc_retry: 6712 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 6713 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 6714 return ENXIO; 6715 } 6716 adapter->osdep.nintrs = 1; 6717 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 6718 intrbuf, sizeof(intrbuf)); 6719 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 6720 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 6721 device_xname(dev)); 6722 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 6723 if (adapter->osdep.ihs[0] == NULL) { 6724 aprint_error_dev(dev,"unable to establish %s\n", 6725 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 6726 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6727 adapter->osdep.intrs = NULL; 6728 switch (intr_type) { 6729 case PCI_INTR_TYPE_MSI: 6730 /* The next try is for INTx: Disable MSI */ 6731 max_type = PCI_INTR_TYPE_INTX; 6732 counts[PCI_INTR_TYPE_INTX] = 1; 6733 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6734 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 6735 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6736 goto alloc_retry; 6737 } else 6738 break; 6739 case PCI_INTR_TYPE_INTX: 6740 default: 6741 /* See below */ 6742 break; 6743 } 6744 } 6745 if (intr_type == PCI_INTR_TYPE_INTX) { 6746 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6747 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6748 } 6749 if (adapter->osdep.ihs[0] == NULL) { 6750 aprint_error_dev(dev, 6751 "couldn't establish interrupt%s%s\n", 6752 intrstr ? " at " : "", intrstr ? intrstr : ""); 6753 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6754 adapter->osdep.intrs = NULL; 6755 return ENXIO; 6756 } 6757 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 6758 /* 6759 * Try allocating a fast interrupt and the associated deferred 6760 * processing contexts. 6761 */ 6762 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6763 txr->txr_si = 6764 softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6765 ixgbe_deferred_mq_start, txr); 6766 6767 snprintf(wqname, sizeof(wqname), "%sdeferTx", 6768 device_xname(dev)); 6769 defertx_error = workqueue_create(&adapter->txr_wq, wqname, 6770 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, 6771 IPL_NET, IXGBE_WORKQUEUE_FLAGS); 6772 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6773 } 6774 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6775 ixgbe_handle_que, que); 6776 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6777 error = workqueue_create(&adapter->que_wq, wqname, 6778 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6779 IXGBE_WORKQUEUE_FLAGS); 6780 6781 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 6782 && ((txr->txr_si == NULL) || defertx_error != 0)) 6783 || (que->que_si == NULL) || error != 0) { 6784 aprint_error_dev(dev, 6785 "could not establish software interrupts\n"); 6786 6787 return ENXIO; 6788 } 6789 /* For simplicity in the handlers */ 6790 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 6791 6792 return (0); 6793 } /* ixgbe_allocate_legacy */ 6794 6795 /************************************************************************ 6796 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 6797 ************************************************************************/ 6798 static int 6799 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 6800 { 6801 device_t dev = adapter->dev; 6802 struct ix_queue *que = adapter->queues; 6803 struct tx_ring *txr = adapter->tx_rings; 6804 pci_chipset_tag_t pc; 6805 char intrbuf[PCI_INTRSTR_LEN]; 6806 char intr_xname[32]; 6807 char wqname[MAXCOMLEN]; 6808 const char *intrstr = NULL; 6809 int error, vector = 0; 6810 int cpu_id = 0; 6811 kcpuset_t *affinity; 6812 #ifdef RSS 6813 unsigned int rss_buckets = 0; 6814 kcpuset_t cpu_mask; 6815 #endif 6816 6817 pc = adapter->osdep.pc; 6818 #ifdef RSS 6819 /* 6820 * If we're doing RSS, the number of queues needs to 6821 * match the number of RSS buckets that are configured. 6822 * 6823 * + If there's more queues than RSS buckets, we'll end 6824 * up with queues that get no traffic. 6825 * 6826 * + If there's more RSS buckets than queues, we'll end 6827 * up having multiple RSS buckets map to the same queue, 6828 * so there'll be some contention. 6829 */ 6830 rss_buckets = rss_getnumbuckets(); 6831 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6832 (adapter->num_queues != rss_buckets)) { 6833 device_printf(dev, 6834 "%s: number of queues (%d) != number of RSS buckets (%d)" 6835 "; performance will be impacted.\n", 6836 __func__, adapter->num_queues, rss_buckets); 6837 } 6838 #endif 6839 6840 adapter->osdep.nintrs = adapter->num_queues + 1; 6841 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6842 adapter->osdep.nintrs) != 0) { 6843 aprint_error_dev(dev, 6844 "failed to allocate MSI-X interrupt\n"); 6845 return (ENXIO); 6846 } 6847 6848 kcpuset_create(&affinity, false); 6849 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6850 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6851 device_xname(dev), i); 6852 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6853 sizeof(intrbuf)); 6854 #ifdef IXGBE_MPSAFE 6855 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6856 true); 6857 #endif 6858 /* Set the handler function */ 6859 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6860 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6861 intr_xname); 6862 if (que->res == NULL) { 6863 aprint_error_dev(dev, 6864 "Failed to register QUE handler\n"); 6865 error = ENXIO; 6866 goto err_out; 6867 } 6868 que->msix = vector; 6869 adapter->active_queues |= 1ULL << que->msix; 6870 6871 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6872 #ifdef RSS 6873 /* 6874 * The queue ID is used as the RSS layer bucket ID. 6875 * We look up the queue ID -> RSS CPU ID and select 6876 * that. 6877 */ 6878 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6879 CPU_SETOF(cpu_id, &cpu_mask); 6880 #endif 6881 } else { 6882 /* 6883 * Bind the MSI-X vector, and thus the 6884 * rings to the corresponding CPU. 6885 * 6886 * This just happens to match the default RSS 6887 * round-robin bucket -> queue -> CPU allocation. 6888 */ 6889 if (adapter->num_queues > 1) 6890 cpu_id = i; 6891 } 6892 /* Round-robin affinity */ 6893 kcpuset_zero(affinity); 6894 kcpuset_set(affinity, cpu_id % ncpu); 6895 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6896 NULL); 6897 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6898 intrstr); 6899 if (error == 0) { 6900 #if 1 /* def IXGBE_DEBUG */ 6901 #ifdef RSS 6902 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6903 cpu_id % ncpu); 6904 #else 6905 aprint_normal(", bound queue %d to cpu %d", i, 6906 cpu_id % ncpu); 6907 #endif 6908 #endif /* IXGBE_DEBUG */ 6909 } 6910 aprint_normal("\n"); 6911 6912 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6913 txr->txr_si = softint_establish( 6914 SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6915 ixgbe_deferred_mq_start, txr); 6916 if (txr->txr_si == NULL) { 6917 aprint_error_dev(dev, 6918 "couldn't establish software interrupt\n"); 6919 error = ENXIO; 6920 goto err_out; 6921 } 6922 } 6923 que->que_si 6924 = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS, 6925 ixgbe_handle_que, que); 6926 if (que->que_si == NULL) { 6927 aprint_error_dev(dev, 6928 "couldn't establish software interrupt\n"); 6929 error = ENXIO; 6930 goto err_out; 6931 } 6932 } 6933 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6934 error = workqueue_create(&adapter->txr_wq, wqname, 6935 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6936 IXGBE_WORKQUEUE_FLAGS); 6937 if (error) { 6938 aprint_error_dev(dev, 6939 "couldn't create workqueue for deferred Tx\n"); 6940 goto err_out; 6941 } 6942 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6943 6944 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6945 error = workqueue_create(&adapter->que_wq, wqname, 6946 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6947 IXGBE_WORKQUEUE_FLAGS); 6948 if (error) { 6949 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6950 goto err_out; 6951 } 6952 6953 /* and Link */ 6954 cpu_id++; 6955 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6956 adapter->vector = vector; 6957 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6958 sizeof(intrbuf)); 6959 #ifdef IXGBE_MPSAFE 6960 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6961 true); 6962 #endif 6963 /* Set the link handler function */ 6964 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6965 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_admin, adapter, 6966 intr_xname); 6967 if (adapter->osdep.ihs[vector] == NULL) { 6968 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6969 error = ENXIO; 6970 goto err_out; 6971 } 6972 /* Round-robin affinity */ 6973 kcpuset_zero(affinity); 6974 kcpuset_set(affinity, cpu_id % ncpu); 6975 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6976 NULL); 6977 6978 aprint_normal_dev(dev, 6979 "for link, interrupting at %s", intrstr); 6980 if (error == 0) 6981 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6982 else 6983 aprint_normal("\n"); 6984 6985 kcpuset_destroy(affinity); 6986 aprint_normal_dev(dev, 6987 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6988 6989 return (0); 6990 6991 err_out: 6992 kcpuset_destroy(affinity); 6993 ixgbe_free_deferred_handlers(adapter); 6994 ixgbe_free_pciintr_resources(adapter); 6995 return (error); 6996 } /* ixgbe_allocate_msix */ 6997 6998 /************************************************************************ 6999 * ixgbe_configure_interrupts 7000 * 7001 * Setup MSI-X, MSI, or legacy interrupts (in that order). 7002 * This will also depend on user settings. 7003 ************************************************************************/ 7004 static int 7005 ixgbe_configure_interrupts(struct adapter *adapter) 7006 { 7007 device_t dev = adapter->dev; 7008 struct ixgbe_mac_info *mac = &adapter->hw.mac; 7009 int want, queues, msgs; 7010 7011 /* Default to 1 queue if MSI-X setup fails */ 7012 adapter->num_queues = 1; 7013 7014 /* Override by tuneable */ 7015 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 7016 goto msi; 7017 7018 /* 7019 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 7020 * interrupt slot. 7021 */ 7022 if (ncpu == 1) 7023 goto msi; 7024 7025 /* First try MSI-X */ 7026 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 7027 msgs = MIN(msgs, IXG_MAX_NINTR); 7028 if (msgs < 2) 7029 goto msi; 7030 7031 adapter->msix_mem = (void *)1; /* XXX */ 7032 7033 /* Figure out a reasonable auto config value */ 7034 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 7035 7036 #ifdef RSS 7037 /* If we're doing RSS, clamp at the number of RSS buckets */ 7038 if (adapter->feat_en & IXGBE_FEATURE_RSS) 7039 queues = uimin(queues, rss_getnumbuckets()); 7040 #endif 7041 if (ixgbe_num_queues > queues) { 7042 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 7043 ixgbe_num_queues = queues; 7044 } 7045 7046 if (ixgbe_num_queues != 0) 7047 queues = ixgbe_num_queues; 7048 else 7049 queues = uimin(queues, 7050 uimin(mac->max_tx_queues, mac->max_rx_queues)); 7051 7052 /* reflect correct sysctl value */ 7053 ixgbe_num_queues = queues; 7054 7055 /* 7056 * Want one vector (RX/TX pair) per queue 7057 * plus an additional for Link. 7058 */ 7059 want = queues + 1; 7060 if (msgs >= want) 7061 msgs = want; 7062 else { 7063 aprint_error_dev(dev, "MSI-X Configuration Problem, " 7064 "%d vectors but %d queues wanted!\n", 7065 msgs, want); 7066 goto msi; 7067 } 7068 adapter->num_queues = queues; 7069 adapter->feat_en |= IXGBE_FEATURE_MSIX; 7070 return (0); 7071 7072 /* 7073 * MSI-X allocation failed or provided us with 7074 * less vectors than needed. Free MSI-X resources 7075 * and we'll try enabling MSI. 7076 */ 7077 msi: 7078 /* Without MSI-X, some features are no longer supported */ 7079 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 7080 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 7081 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 7082 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 7083 7084 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 7085 adapter->msix_mem = NULL; /* XXX */ 7086 if (msgs > 1) 7087 msgs = 1; 7088 if (msgs != 0) { 7089 msgs = 1; 7090 adapter->feat_en |= IXGBE_FEATURE_MSI; 7091 return (0); 7092 } 7093 7094 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 7095 aprint_error_dev(dev, 7096 "Device does not support legacy interrupts.\n"); 7097 return 1; 7098 } 7099 7100 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 7101 7102 return (0); 7103 } /* ixgbe_configure_interrupts */ 7104 7105 7106 /************************************************************************ 7107 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 7108 * 7109 * Done outside of interrupt context since the driver might sleep 7110 ************************************************************************/ 7111 static void 7112 ixgbe_handle_link(void *context) 7113 { 7114 struct adapter *adapter = context; 7115 struct ixgbe_hw *hw = &adapter->hw; 7116 7117 KASSERT(mutex_owned(&adapter->core_mtx)); 7118 7119 ++adapter->link_workev.ev_count; 7120 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 7121 ixgbe_update_link_status(adapter); 7122 7123 /* Re-enable link interrupts */ 7124 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 7125 } /* ixgbe_handle_link */ 7126 7127 #if 0 7128 /************************************************************************ 7129 * ixgbe_rearm_queues 7130 ************************************************************************/ 7131 static __inline void 7132 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 7133 { 7134 u32 mask; 7135 7136 switch (adapter->hw.mac.type) { 7137 case ixgbe_mac_82598EB: 7138 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 7139 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 7140 break; 7141 case ixgbe_mac_82599EB: 7142 case ixgbe_mac_X540: 7143 case ixgbe_mac_X550: 7144 case ixgbe_mac_X550EM_x: 7145 case ixgbe_mac_X550EM_a: 7146 mask = (queues & 0xFFFFFFFF); 7147 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 7148 mask = (queues >> 32); 7149 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 7150 break; 7151 default: 7152 break; 7153 } 7154 } /* ixgbe_rearm_queues */ 7155 #endif 7156
Indexes created Mon Sep 29 03:10:08 GMT 2025