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