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