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