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