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