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