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