ixgbe.c revision 1.227
1 /* $NetBSD: ixgbe.c,v 1.227 2020/03/15 23:04:50 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_with_lock(&adapter->media, IFM_IMASK, ixgbe_media_change, 1391 ixgbe_media_status, &adapter->core_mtx); 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_update_link_status(adapter); 2820 2821 ifmr->ifm_status = IFM_AVALID; 2822 ifmr->ifm_active = IFM_ETHER; 2823 2824 if (adapter->link_active != LINK_STATE_UP) { 2825 ifmr->ifm_active |= IFM_NONE; 2826 return; 2827 } 2828 2829 ifmr->ifm_status |= IFM_ACTIVE; 2830 layer = adapter->phy_layer; 2831 2832 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2833 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2834 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2835 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2836 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2837 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2838 switch (adapter->link_speed) { 2839 case IXGBE_LINK_SPEED_10GB_FULL: 2840 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2841 break; 2842 case IXGBE_LINK_SPEED_5GB_FULL: 2843 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2844 break; 2845 case IXGBE_LINK_SPEED_2_5GB_FULL: 2846 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2847 break; 2848 case IXGBE_LINK_SPEED_1GB_FULL: 2849 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2850 break; 2851 case IXGBE_LINK_SPEED_100_FULL: 2852 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2853 break; 2854 case IXGBE_LINK_SPEED_10_FULL: 2855 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2856 break; 2857 } 2858 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2859 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2860 switch (adapter->link_speed) { 2861 case IXGBE_LINK_SPEED_10GB_FULL: 2862 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2863 break; 2864 } 2865 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2866 switch (adapter->link_speed) { 2867 case IXGBE_LINK_SPEED_10GB_FULL: 2868 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2869 break; 2870 case IXGBE_LINK_SPEED_1GB_FULL: 2871 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2872 break; 2873 } 2874 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2875 switch (adapter->link_speed) { 2876 case IXGBE_LINK_SPEED_10GB_FULL: 2877 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2878 break; 2879 case IXGBE_LINK_SPEED_1GB_FULL: 2880 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2881 break; 2882 } 2883 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2884 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2885 switch (adapter->link_speed) { 2886 case IXGBE_LINK_SPEED_10GB_FULL: 2887 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2888 break; 2889 case IXGBE_LINK_SPEED_1GB_FULL: 2890 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2891 break; 2892 } 2893 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2894 switch (adapter->link_speed) { 2895 case IXGBE_LINK_SPEED_10GB_FULL: 2896 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2897 break; 2898 } 2899 /* 2900 * XXX: These need to use the proper media types once 2901 * they're added. 2902 */ 2903 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 2904 switch (adapter->link_speed) { 2905 case IXGBE_LINK_SPEED_10GB_FULL: 2906 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 2907 break; 2908 case IXGBE_LINK_SPEED_2_5GB_FULL: 2909 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2910 break; 2911 case IXGBE_LINK_SPEED_1GB_FULL: 2912 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2913 break; 2914 } 2915 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 2916 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 2917 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 2918 switch (adapter->link_speed) { 2919 case IXGBE_LINK_SPEED_10GB_FULL: 2920 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 2921 break; 2922 case IXGBE_LINK_SPEED_2_5GB_FULL: 2923 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2924 break; 2925 case IXGBE_LINK_SPEED_1GB_FULL: 2926 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2927 break; 2928 } 2929 2930 /* If nothing is recognized... */ 2931 #if 0 2932 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 2933 ifmr->ifm_active |= IFM_UNKNOWN; 2934 #endif 2935 2936 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 2937 2938 /* Display current flow control setting used on link */ 2939 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 2940 hw->fc.current_mode == ixgbe_fc_full) 2941 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 2942 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 2943 hw->fc.current_mode == ixgbe_fc_full) 2944 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 2945 2946 return; 2947 } /* ixgbe_media_status */ 2948 2949 /************************************************************************ 2950 * ixgbe_media_change - Media Ioctl callback 2951 * 2952 * Called when the user changes speed/duplex using 2953 * media/mediopt option with ifconfig. 2954 ************************************************************************/ 2955 static int 2956 ixgbe_media_change(struct ifnet *ifp) 2957 { 2958 struct adapter *adapter = ifp->if_softc; 2959 struct ifmedia *ifm = &adapter->media; 2960 struct ixgbe_hw *hw = &adapter->hw; 2961 ixgbe_link_speed speed = 0; 2962 ixgbe_link_speed link_caps = 0; 2963 bool negotiate = false; 2964 s32 err = IXGBE_NOT_IMPLEMENTED; 2965 2966 INIT_DEBUGOUT("ixgbe_media_change: begin"); 2967 2968 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 2969 return (EINVAL); 2970 2971 if (hw->phy.media_type == ixgbe_media_type_backplane) 2972 return (EPERM); 2973 2974 /* 2975 * We don't actually need to check against the supported 2976 * media types of the adapter; ifmedia will take care of 2977 * that for us. 2978 */ 2979 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2980 case IFM_AUTO: 2981 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 2982 &negotiate); 2983 if (err != IXGBE_SUCCESS) { 2984 device_printf(adapter->dev, "Unable to determine " 2985 "supported advertise speeds\n"); 2986 return (ENODEV); 2987 } 2988 speed |= link_caps; 2989 break; 2990 case IFM_10G_T: 2991 case IFM_10G_LRM: 2992 case IFM_10G_LR: 2993 case IFM_10G_TWINAX: 2994 case IFM_10G_SR: 2995 case IFM_10G_CX4: 2996 case IFM_10G_KR: 2997 case IFM_10G_KX4: 2998 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2999 break; 3000 case IFM_5000_T: 3001 speed |= IXGBE_LINK_SPEED_5GB_FULL; 3002 break; 3003 case IFM_2500_T: 3004 case IFM_2500_KX: 3005 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 3006 break; 3007 case IFM_1000_T: 3008 case IFM_1000_LX: 3009 case IFM_1000_SX: 3010 case IFM_1000_KX: 3011 speed |= IXGBE_LINK_SPEED_1GB_FULL; 3012 break; 3013 case IFM_100_TX: 3014 speed |= IXGBE_LINK_SPEED_100_FULL; 3015 break; 3016 case IFM_10_T: 3017 speed |= IXGBE_LINK_SPEED_10_FULL; 3018 break; 3019 case IFM_NONE: 3020 break; 3021 default: 3022 goto invalid; 3023 } 3024 3025 hw->mac.autotry_restart = TRUE; 3026 hw->mac.ops.setup_link(hw, speed, TRUE); 3027 adapter->advertise = 0; 3028 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 3029 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 3030 adapter->advertise |= 1 << 2; 3031 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 3032 adapter->advertise |= 1 << 1; 3033 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 3034 adapter->advertise |= 1 << 0; 3035 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 3036 adapter->advertise |= 1 << 3; 3037 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 3038 adapter->advertise |= 1 << 4; 3039 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 3040 adapter->advertise |= 1 << 5; 3041 } 3042 3043 return (0); 3044 3045 invalid: 3046 device_printf(adapter->dev, "Invalid media type!\n"); 3047 3048 return (EINVAL); 3049 } /* ixgbe_media_change */ 3050 3051 /************************************************************************ 3052 * ixgbe_msix_link - Link status change ISR (MSI/MSI-X) 3053 ************************************************************************/ 3054 static int 3055 ixgbe_msix_link(void *arg) 3056 { 3057 struct adapter *adapter = arg; 3058 struct ixgbe_hw *hw = &adapter->hw; 3059 u32 eicr, eicr_mask; 3060 s32 retval; 3061 3062 ++adapter->link_irq.ev_count; 3063 3064 /* Pause other interrupts */ 3065 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_OTHER); 3066 3067 /* First get the cause */ 3068 /* 3069 * The specifications of 82598, 82599, X540 and X550 say EICS register 3070 * is write only. However, Linux says it is a workaround for silicon 3071 * errata to read EICS instead of EICR to get interrupt cause. It seems 3072 * there is a problem about read clear mechanism for EICR register. 3073 */ 3074 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 3075 /* Be sure the queue bits are not cleared */ 3076 eicr &= ~IXGBE_EICR_RTX_QUEUE; 3077 /* Clear interrupt with write */ 3078 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 3079 3080 if (ixgbe_is_sfp(hw)) { 3081 /* Pluggable optics-related interrupt */ 3082 if (hw->mac.type >= ixgbe_mac_X540) 3083 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 3084 else 3085 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 3086 3087 /* 3088 * An interrupt might not arrive when a module is inserted. 3089 * When an link status change interrupt occurred and the driver 3090 * still regard SFP as unplugged, issue the module softint 3091 * and then issue LSC interrupt. 3092 */ 3093 if ((eicr & eicr_mask) 3094 || ((hw->phy.sfp_type == ixgbe_sfp_type_not_present) 3095 && (eicr & IXGBE_EICR_LSC))) { 3096 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 3097 softint_schedule(adapter->mod_si); 3098 } 3099 3100 if ((hw->mac.type == ixgbe_mac_82599EB) && 3101 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 3102 IXGBE_WRITE_REG(hw, IXGBE_EICR, 3103 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 3104 ixgbe_schedule_msf_tasklet(adapter); 3105 } 3106 } 3107 3108 /* Link status change */ 3109 if (eicr & IXGBE_EICR_LSC) { 3110 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); 3111 softint_schedule(adapter->link_si); 3112 } 3113 3114 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 3115 if ((adapter->feat_en & IXGBE_FEATURE_FDIR) && 3116 (eicr & IXGBE_EICR_FLOW_DIR)) { 3117 /* This is probably overkill :) */ 3118 if (!atomic_cas_uint(&adapter->fdir_reinit, 0, 1)) 3119 return 1; 3120 /* Disable the interrupt */ 3121 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_FLOW_DIR); 3122 softint_schedule(adapter->fdir_si); 3123 } 3124 3125 if (eicr & IXGBE_EICR_ECC) { 3126 device_printf(adapter->dev, 3127 "CRITICAL: ECC ERROR!! Please Reboot!!\n"); 3128 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC); 3129 } 3130 3131 /* Check for over temp condition */ 3132 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) { 3133 switch (adapter->hw.mac.type) { 3134 case ixgbe_mac_X550EM_a: 3135 if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a)) 3136 break; 3137 IXGBE_WRITE_REG(hw, IXGBE_EIMC, 3138 IXGBE_EICR_GPI_SDP0_X550EM_a); 3139 IXGBE_WRITE_REG(hw, IXGBE_EICR, 3140 IXGBE_EICR_GPI_SDP0_X550EM_a); 3141 retval = hw->phy.ops.check_overtemp(hw); 3142 if (retval != IXGBE_ERR_OVERTEMP) 3143 break; 3144 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 3145 device_printf(adapter->dev, "System shutdown required!\n"); 3146 break; 3147 default: 3148 if (!(eicr & IXGBE_EICR_TS)) 3149 break; 3150 retval = hw->phy.ops.check_overtemp(hw); 3151 if (retval != IXGBE_ERR_OVERTEMP) 3152 break; 3153 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 3154 device_printf(adapter->dev, "System shutdown required!\n"); 3155 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS); 3156 break; 3157 } 3158 } 3159 3160 /* Check for VF message */ 3161 if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) && 3162 (eicr & IXGBE_EICR_MAILBOX)) 3163 softint_schedule(adapter->mbx_si); 3164 } 3165 3166 /* Check for fan failure */ 3167 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 3168 ixgbe_check_fan_failure(adapter, eicr, TRUE); 3169 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 3170 } 3171 3172 /* External PHY interrupt */ 3173 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 3174 (eicr & IXGBE_EICR_GPI_SDP0_X540)) { 3175 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540); 3176 softint_schedule(adapter->phy_si); 3177 } 3178 3179 /* Re-enable other interrupts */ 3180 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER); 3181 return 1; 3182 } /* ixgbe_msix_link */ 3183 3184 static void 3185 ixgbe_eitr_write(struct adapter *adapter, uint32_t index, uint32_t itr) 3186 { 3187 3188 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 3189 itr |= itr << 16; 3190 else 3191 itr |= IXGBE_EITR_CNT_WDIS; 3192 3193 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(index), itr); 3194 } 3195 3196 3197 /************************************************************************ 3198 * ixgbe_sysctl_interrupt_rate_handler 3199 ************************************************************************/ 3200 static int 3201 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3202 { 3203 struct sysctlnode node = *rnode; 3204 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 3205 struct adapter *adapter; 3206 uint32_t reg, usec, rate; 3207 int error; 3208 3209 if (que == NULL) 3210 return 0; 3211 3212 adapter = que->adapter; 3213 if (ixgbe_fw_recovery_mode_swflag(adapter)) 3214 return (EPERM); 3215 3216 reg = IXGBE_READ_REG(&adapter->hw, IXGBE_EITR(que->msix)); 3217 usec = ((reg & 0x0FF8) >> 3); 3218 if (usec > 0) 3219 rate = 500000 / usec; 3220 else 3221 rate = 0; 3222 node.sysctl_data = &rate; 3223 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3224 if (error || newp == NULL) 3225 return error; 3226 reg &= ~0xfff; /* default, no limitation */ 3227 if (rate > 0 && rate < 500000) { 3228 if (rate < 1000) 3229 rate = 1000; 3230 reg |= ((4000000/rate) & 0xff8); 3231 /* 3232 * When RSC is used, ITR interval must be larger than 3233 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 3234 * The minimum value is always greater than 2us on 100M 3235 * (and 10M?(not documented)), but it's not on 1G and higher. 3236 */ 3237 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 3238 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 3239 if ((adapter->num_queues > 1) 3240 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 3241 return EINVAL; 3242 } 3243 ixgbe_max_interrupt_rate = rate; 3244 } else 3245 ixgbe_max_interrupt_rate = 0; 3246 ixgbe_eitr_write(adapter, que->msix, reg); 3247 3248 return (0); 3249 } /* ixgbe_sysctl_interrupt_rate_handler */ 3250 3251 const struct sysctlnode * 3252 ixgbe_sysctl_instance(struct adapter *adapter) 3253 { 3254 const char *dvname; 3255 struct sysctllog **log; 3256 int rc; 3257 const struct sysctlnode *rnode; 3258 3259 if (adapter->sysctltop != NULL) 3260 return adapter->sysctltop; 3261 3262 log = &adapter->sysctllog; 3263 dvname = device_xname(adapter->dev); 3264 3265 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3266 0, CTLTYPE_NODE, dvname, 3267 SYSCTL_DESCR("ixgbe information and settings"), 3268 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3269 goto err; 3270 3271 return rnode; 3272 err: 3273 device_printf(adapter->dev, 3274 "%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3275 return NULL; 3276 } 3277 3278 /************************************************************************ 3279 * ixgbe_add_device_sysctls 3280 ************************************************************************/ 3281 static void 3282 ixgbe_add_device_sysctls(struct adapter *adapter) 3283 { 3284 device_t dev = adapter->dev; 3285 struct ixgbe_hw *hw = &adapter->hw; 3286 struct sysctllog **log; 3287 const struct sysctlnode *rnode, *cnode; 3288 3289 log = &adapter->sysctllog; 3290 3291 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3292 aprint_error_dev(dev, "could not create sysctl root\n"); 3293 return; 3294 } 3295 3296 if (sysctl_createv(log, 0, &rnode, &cnode, 3297 CTLFLAG_READWRITE, CTLTYPE_INT, 3298 "debug", SYSCTL_DESCR("Debug Info"), 3299 ixgbe_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0) 3300 aprint_error_dev(dev, "could not create sysctl\n"); 3301 3302 if (sysctl_createv(log, 0, &rnode, &cnode, 3303 CTLFLAG_READONLY, CTLTYPE_INT, 3304 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 3305 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 3306 aprint_error_dev(dev, "could not create sysctl\n"); 3307 3308 if (sysctl_createv(log, 0, &rnode, &cnode, 3309 CTLFLAG_READONLY, CTLTYPE_INT, 3310 "num_queues", SYSCTL_DESCR("Number of queues"), 3311 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 3312 aprint_error_dev(dev, "could not create sysctl\n"); 3313 3314 /* Sysctls for all devices */ 3315 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3316 CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 3317 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, 3318 CTL_EOL) != 0) 3319 aprint_error_dev(dev, "could not create sysctl\n"); 3320 3321 adapter->enable_aim = ixgbe_enable_aim; 3322 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3323 CTLTYPE_BOOL, "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 3324 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 3325 aprint_error_dev(dev, "could not create sysctl\n"); 3326 3327 if (sysctl_createv(log, 0, &rnode, &cnode, 3328 CTLFLAG_READWRITE, CTLTYPE_INT, 3329 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 3330 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, 3331 CTL_EOL) != 0) 3332 aprint_error_dev(dev, "could not create sysctl\n"); 3333 3334 /* 3335 * If each "que->txrx_use_workqueue" is changed in sysctl handler, 3336 * it causesflip-flopping softint/workqueue mode in one deferred 3337 * processing. Therefore, preempt_disable()/preempt_enable() are 3338 * required in ixgbe_sched_handle_que() to avoid 3339 * KASSERT(ixgbe_sched_handle_que()) in softint_schedule(). 3340 * I think changing "que->txrx_use_workqueue" in interrupt handler 3341 * is lighter than doing preempt_disable()/preempt_enable() in every 3342 * ixgbe_sched_handle_que(). 3343 */ 3344 adapter->txrx_use_workqueue = ixgbe_txrx_workqueue; 3345 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3346 CTLTYPE_BOOL, "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 3347 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 3348 aprint_error_dev(dev, "could not create sysctl\n"); 3349 3350 #ifdef IXGBE_DEBUG 3351 /* testing sysctls (for all devices) */ 3352 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3353 CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"), 3354 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, 3355 CTL_EOL) != 0) 3356 aprint_error_dev(dev, "could not create sysctl\n"); 3357 3358 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY, 3359 CTLTYPE_STRING, "print_rss_config", 3360 SYSCTL_DESCR("Prints RSS Configuration"), 3361 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, 3362 CTL_EOL) != 0) 3363 aprint_error_dev(dev, "could not create sysctl\n"); 3364 #endif 3365 /* for X550 series devices */ 3366 if (hw->mac.type >= ixgbe_mac_X550) 3367 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3368 CTLTYPE_INT, "dmac", SYSCTL_DESCR("DMA Coalesce"), 3369 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, 3370 CTL_EOL) != 0) 3371 aprint_error_dev(dev, "could not create sysctl\n"); 3372 3373 /* for WoL-capable devices */ 3374 if (adapter->wol_support) { 3375 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3376 CTLTYPE_BOOL, "wol_enable", 3377 SYSCTL_DESCR("Enable/Disable Wake on LAN"), 3378 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, 3379 CTL_EOL) != 0) 3380 aprint_error_dev(dev, "could not create sysctl\n"); 3381 3382 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3383 CTLTYPE_INT, "wufc", 3384 SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 3385 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, 3386 CTL_EOL) != 0) 3387 aprint_error_dev(dev, "could not create sysctl\n"); 3388 } 3389 3390 /* for X552/X557-AT devices */ 3391 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3392 const struct sysctlnode *phy_node; 3393 3394 if (sysctl_createv(log, 0, &rnode, &phy_node, 0, CTLTYPE_NODE, 3395 "phy", SYSCTL_DESCR("External PHY sysctls"), 3396 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 3397 aprint_error_dev(dev, "could not create sysctl\n"); 3398 return; 3399 } 3400 3401 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3402 CTLTYPE_INT, "temp", 3403 SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 3404 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, 3405 CTL_EOL) != 0) 3406 aprint_error_dev(dev, "could not create sysctl\n"); 3407 3408 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3409 CTLTYPE_INT, "overtemp_occurred", 3410 SYSCTL_DESCR("External PHY High Temperature Event Occurred"), 3411 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, 3412 CTL_CREATE, CTL_EOL) != 0) 3413 aprint_error_dev(dev, "could not create sysctl\n"); 3414 } 3415 3416 if ((hw->mac.type == ixgbe_mac_X550EM_a) 3417 && (hw->phy.type == ixgbe_phy_fw)) 3418 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3419 CTLTYPE_BOOL, "force_10_100_autonego", 3420 SYSCTL_DESCR("Force autonego on 10M and 100M"), 3421 NULL, 0, &hw->phy.force_10_100_autonego, 0, 3422 CTL_CREATE, CTL_EOL) != 0) 3423 aprint_error_dev(dev, "could not create sysctl\n"); 3424 3425 if (adapter->feat_cap & IXGBE_FEATURE_EEE) { 3426 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3427 CTLTYPE_INT, "eee_state", 3428 SYSCTL_DESCR("EEE Power Save State"), 3429 ixgbe_sysctl_eee_state, 0, (void *)adapter, 0, CTL_CREATE, 3430 CTL_EOL) != 0) 3431 aprint_error_dev(dev, "could not create sysctl\n"); 3432 } 3433 } /* ixgbe_add_device_sysctls */ 3434 3435 /************************************************************************ 3436 * ixgbe_allocate_pci_resources 3437 ************************************************************************/ 3438 static int 3439 ixgbe_allocate_pci_resources(struct adapter *adapter, 3440 const struct pci_attach_args *pa) 3441 { 3442 pcireg_t memtype, csr; 3443 device_t dev = adapter->dev; 3444 bus_addr_t addr; 3445 int flags; 3446 3447 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 3448 switch (memtype) { 3449 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 3450 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 3451 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 3452 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 3453 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 3454 goto map_err; 3455 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 3456 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 3457 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 3458 } 3459 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 3460 adapter->osdep.mem_size, flags, 3461 &adapter->osdep.mem_bus_space_handle) != 0) { 3462 map_err: 3463 adapter->osdep.mem_size = 0; 3464 aprint_error_dev(dev, "unable to map BAR0\n"); 3465 return ENXIO; 3466 } 3467 /* 3468 * Enable address decoding for memory range in case BIOS or 3469 * UEFI don't set it. 3470 */ 3471 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, 3472 PCI_COMMAND_STATUS_REG); 3473 csr |= PCI_COMMAND_MEM_ENABLE; 3474 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 3475 csr); 3476 break; 3477 default: 3478 aprint_error_dev(dev, "unexpected type on BAR0\n"); 3479 return ENXIO; 3480 } 3481 3482 return (0); 3483 } /* ixgbe_allocate_pci_resources */ 3484 3485 static void 3486 ixgbe_free_softint(struct adapter *adapter) 3487 { 3488 struct ix_queue *que = adapter->queues; 3489 struct tx_ring *txr = adapter->tx_rings; 3490 int i; 3491 3492 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 3493 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 3494 if (txr->txr_si != NULL) 3495 softint_disestablish(txr->txr_si); 3496 } 3497 if (que->que_si != NULL) 3498 softint_disestablish(que->que_si); 3499 } 3500 if (adapter->txr_wq != NULL) 3501 workqueue_destroy(adapter->txr_wq); 3502 if (adapter->txr_wq_enqueued != NULL) 3503 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 3504 if (adapter->que_wq != NULL) 3505 workqueue_destroy(adapter->que_wq); 3506 3507 /* Drain the Link queue */ 3508 if (adapter->link_si != NULL) { 3509 softint_disestablish(adapter->link_si); 3510 adapter->link_si = NULL; 3511 } 3512 if (adapter->mod_si != NULL) { 3513 softint_disestablish(adapter->mod_si); 3514 adapter->mod_si = NULL; 3515 } 3516 if (adapter->msf_wq != NULL) { 3517 workqueue_destroy(adapter->msf_wq); 3518 adapter->msf_wq = NULL; 3519 } 3520 if (adapter->phy_si != NULL) { 3521 softint_disestablish(adapter->phy_si); 3522 adapter->phy_si = NULL; 3523 } 3524 if (adapter->feat_en & IXGBE_FEATURE_FDIR) { 3525 if (adapter->fdir_si != NULL) { 3526 softint_disestablish(adapter->fdir_si); 3527 adapter->fdir_si = NULL; 3528 } 3529 } 3530 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 3531 if (adapter->mbx_si != NULL) { 3532 softint_disestablish(adapter->mbx_si); 3533 adapter->mbx_si = NULL; 3534 } 3535 } 3536 } /* ixgbe_free_softint */ 3537 3538 /************************************************************************ 3539 * ixgbe_detach - Device removal routine 3540 * 3541 * Called when the driver is being removed. 3542 * Stops the adapter and deallocates all the resources 3543 * that were allocated for driver operation. 3544 * 3545 * return 0 on success, positive on failure 3546 ************************************************************************/ 3547 static int 3548 ixgbe_detach(device_t dev, int flags) 3549 { 3550 struct adapter *adapter = device_private(dev); 3551 struct rx_ring *rxr = adapter->rx_rings; 3552 struct tx_ring *txr = adapter->tx_rings; 3553 struct ixgbe_hw *hw = &adapter->hw; 3554 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 3555 u32 ctrl_ext; 3556 int i; 3557 3558 INIT_DEBUGOUT("ixgbe_detach: begin"); 3559 if (adapter->osdep.attached == false) 3560 return 0; 3561 3562 if (ixgbe_pci_iov_detach(dev) != 0) { 3563 device_printf(dev, "SR-IOV in use; detach first.\n"); 3564 return (EBUSY); 3565 } 3566 3567 /* 3568 * Stop the interface. ixgbe_setup_low_power_mode() calls ixgbe_stop(), 3569 * so it's not required to call ixgbe_stop() directly. 3570 */ 3571 IXGBE_CORE_LOCK(adapter); 3572 ixgbe_setup_low_power_mode(adapter); 3573 IXGBE_CORE_UNLOCK(adapter); 3574 #if NVLAN > 0 3575 /* Make sure VLANs are not using driver */ 3576 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 3577 ; /* nothing to do: no VLANs */ 3578 else if ((flags & (DETACH_SHUTDOWN | DETACH_FORCE)) != 0) 3579 vlan_ifdetach(adapter->ifp); 3580 else { 3581 aprint_error_dev(dev, "VLANs in use, detach first\n"); 3582 return (EBUSY); 3583 } 3584 #endif 3585 3586 pmf_device_deregister(dev); 3587 3588 ether_ifdetach(adapter->ifp); 3589 3590 ixgbe_free_softint(adapter); 3591 3592 /* let hardware know driver is unloading */ 3593 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 3594 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 3595 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 3596 3597 callout_halt(&adapter->timer, NULL); 3598 if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) 3599 callout_halt(&adapter->recovery_mode_timer, NULL); 3600 3601 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 3602 netmap_detach(adapter->ifp); 3603 3604 ixgbe_free_pci_resources(adapter); 3605 #if 0 /* XXX the NetBSD port is probably missing something here */ 3606 bus_generic_detach(dev); 3607 #endif 3608 if_detach(adapter->ifp); 3609 ifmedia_fini(&adapter->media); 3610 if_percpuq_destroy(adapter->ipq); 3611 3612 sysctl_teardown(&adapter->sysctllog); 3613 evcnt_detach(&adapter->efbig_tx_dma_setup); 3614 evcnt_detach(&adapter->mbuf_defrag_failed); 3615 evcnt_detach(&adapter->efbig2_tx_dma_setup); 3616 evcnt_detach(&adapter->einval_tx_dma_setup); 3617 evcnt_detach(&adapter->other_tx_dma_setup); 3618 evcnt_detach(&adapter->eagain_tx_dma_setup); 3619 evcnt_detach(&adapter->enomem_tx_dma_setup); 3620 evcnt_detach(&adapter->watchdog_events); 3621 evcnt_detach(&adapter->tso_err); 3622 evcnt_detach(&adapter->link_irq); 3623 evcnt_detach(&adapter->link_sicount); 3624 evcnt_detach(&adapter->mod_sicount); 3625 evcnt_detach(&adapter->msf_sicount); 3626 evcnt_detach(&adapter->phy_sicount); 3627 3628 for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) { 3629 if (i < __arraycount(stats->mpc)) { 3630 evcnt_detach(&stats->mpc[i]); 3631 if (hw->mac.type == ixgbe_mac_82598EB) 3632 evcnt_detach(&stats->rnbc[i]); 3633 } 3634 if (i < __arraycount(stats->pxontxc)) { 3635 evcnt_detach(&stats->pxontxc[i]); 3636 evcnt_detach(&stats->pxonrxc[i]); 3637 evcnt_detach(&stats->pxofftxc[i]); 3638 evcnt_detach(&stats->pxoffrxc[i]); 3639 if (hw->mac.type >= ixgbe_mac_82599EB) 3640 evcnt_detach(&stats->pxon2offc[i]); 3641 } 3642 } 3643 3644 txr = adapter->tx_rings; 3645 for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3646 evcnt_detach(&adapter->queues[i].irqs); 3647 evcnt_detach(&adapter->queues[i].handleq); 3648 evcnt_detach(&adapter->queues[i].req); 3649 evcnt_detach(&txr->no_desc_avail); 3650 evcnt_detach(&txr->total_packets); 3651 evcnt_detach(&txr->tso_tx); 3652 #ifndef IXGBE_LEGACY_TX 3653 evcnt_detach(&txr->pcq_drops); 3654 #endif 3655 3656 if (i < __arraycount(stats->qprc)) { 3657 evcnt_detach(&stats->qprc[i]); 3658 evcnt_detach(&stats->qptc[i]); 3659 evcnt_detach(&stats->qbrc[i]); 3660 evcnt_detach(&stats->qbtc[i]); 3661 if (hw->mac.type >= ixgbe_mac_82599EB) 3662 evcnt_detach(&stats->qprdc[i]); 3663 } 3664 3665 evcnt_detach(&rxr->rx_packets); 3666 evcnt_detach(&rxr->rx_bytes); 3667 evcnt_detach(&rxr->rx_copies); 3668 evcnt_detach(&rxr->no_jmbuf); 3669 evcnt_detach(&rxr->rx_discarded); 3670 } 3671 evcnt_detach(&stats->ipcs); 3672 evcnt_detach(&stats->l4cs); 3673 evcnt_detach(&stats->ipcs_bad); 3674 evcnt_detach(&stats->l4cs_bad); 3675 evcnt_detach(&stats->intzero); 3676 evcnt_detach(&stats->legint); 3677 evcnt_detach(&stats->crcerrs); 3678 evcnt_detach(&stats->illerrc); 3679 evcnt_detach(&stats->errbc); 3680 evcnt_detach(&stats->mspdc); 3681 if (hw->mac.type >= ixgbe_mac_X550) 3682 evcnt_detach(&stats->mbsdc); 3683 evcnt_detach(&stats->mpctotal); 3684 evcnt_detach(&stats->mlfc); 3685 evcnt_detach(&stats->mrfc); 3686 evcnt_detach(&stats->rlec); 3687 evcnt_detach(&stats->lxontxc); 3688 evcnt_detach(&stats->lxonrxc); 3689 evcnt_detach(&stats->lxofftxc); 3690 evcnt_detach(&stats->lxoffrxc); 3691 3692 /* Packet Reception Stats */ 3693 evcnt_detach(&stats->tor); 3694 evcnt_detach(&stats->gorc); 3695 evcnt_detach(&stats->tpr); 3696 evcnt_detach(&stats->gprc); 3697 evcnt_detach(&stats->mprc); 3698 evcnt_detach(&stats->bprc); 3699 evcnt_detach(&stats->prc64); 3700 evcnt_detach(&stats->prc127); 3701 evcnt_detach(&stats->prc255); 3702 evcnt_detach(&stats->prc511); 3703 evcnt_detach(&stats->prc1023); 3704 evcnt_detach(&stats->prc1522); 3705 evcnt_detach(&stats->ruc); 3706 evcnt_detach(&stats->rfc); 3707 evcnt_detach(&stats->roc); 3708 evcnt_detach(&stats->rjc); 3709 evcnt_detach(&stats->mngprc); 3710 evcnt_detach(&stats->mngpdc); 3711 evcnt_detach(&stats->xec); 3712 3713 /* Packet Transmission Stats */ 3714 evcnt_detach(&stats->gotc); 3715 evcnt_detach(&stats->tpt); 3716 evcnt_detach(&stats->gptc); 3717 evcnt_detach(&stats->bptc); 3718 evcnt_detach(&stats->mptc); 3719 evcnt_detach(&stats->mngptc); 3720 evcnt_detach(&stats->ptc64); 3721 evcnt_detach(&stats->ptc127); 3722 evcnt_detach(&stats->ptc255); 3723 evcnt_detach(&stats->ptc511); 3724 evcnt_detach(&stats->ptc1023); 3725 evcnt_detach(&stats->ptc1522); 3726 3727 ixgbe_free_queues(adapter); 3728 free(adapter->mta, M_DEVBUF); 3729 3730 IXGBE_CORE_LOCK_DESTROY(adapter); 3731 3732 return (0); 3733 } /* ixgbe_detach */ 3734 3735 /************************************************************************ 3736 * ixgbe_setup_low_power_mode - LPLU/WoL preparation 3737 * 3738 * Prepare the adapter/port for LPLU and/or WoL 3739 ************************************************************************/ 3740 static int 3741 ixgbe_setup_low_power_mode(struct adapter *adapter) 3742 { 3743 struct ixgbe_hw *hw = &adapter->hw; 3744 device_t dev = adapter->dev; 3745 s32 error = 0; 3746 3747 KASSERT(mutex_owned(&adapter->core_mtx)); 3748 3749 /* Limit power management flow to X550EM baseT */ 3750 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 3751 hw->phy.ops.enter_lplu) { 3752 /* X550EM baseT adapters need a special LPLU flow */ 3753 hw->phy.reset_disable = true; 3754 ixgbe_stop(adapter); 3755 error = hw->phy.ops.enter_lplu(hw); 3756 if (error) 3757 device_printf(dev, 3758 "Error entering LPLU: %d\n", error); 3759 hw->phy.reset_disable = false; 3760 } else { 3761 /* Just stop for other adapters */ 3762 ixgbe_stop(adapter); 3763 } 3764 3765 if (!hw->wol_enabled) { 3766 ixgbe_set_phy_power(hw, FALSE); 3767 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3768 IXGBE_WRITE_REG(hw, IXGBE_WUC, 0); 3769 } else { 3770 /* Turn off support for APM wakeup. (Using ACPI instead) */ 3771 IXGBE_WRITE_REG(hw, IXGBE_GRC_BY_MAC(hw), 3772 IXGBE_READ_REG(hw, IXGBE_GRC_BY_MAC(hw)) & ~(u32)2); 3773 3774 /* 3775 * Clear Wake Up Status register to prevent any previous wakeup 3776 * events from waking us up immediately after we suspend. 3777 */ 3778 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3779 3780 /* 3781 * Program the Wakeup Filter Control register with user filter 3782 * settings 3783 */ 3784 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 3785 3786 /* Enable wakeups and power management in Wakeup Control */ 3787 IXGBE_WRITE_REG(hw, IXGBE_WUC, 3788 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 3789 3790 } 3791 3792 return error; 3793 } /* ixgbe_setup_low_power_mode */ 3794 3795 /************************************************************************ 3796 * ixgbe_shutdown - Shutdown entry point 3797 ************************************************************************/ 3798 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 3799 static int 3800 ixgbe_shutdown(device_t dev) 3801 { 3802 struct adapter *adapter = device_private(dev); 3803 int error = 0; 3804 3805 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 3806 3807 IXGBE_CORE_LOCK(adapter); 3808 error = ixgbe_setup_low_power_mode(adapter); 3809 IXGBE_CORE_UNLOCK(adapter); 3810 3811 return (error); 3812 } /* ixgbe_shutdown */ 3813 #endif 3814 3815 /************************************************************************ 3816 * ixgbe_suspend 3817 * 3818 * From D0 to D3 3819 ************************************************************************/ 3820 static bool 3821 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 3822 { 3823 struct adapter *adapter = device_private(dev); 3824 int error = 0; 3825 3826 INIT_DEBUGOUT("ixgbe_suspend: begin"); 3827 3828 IXGBE_CORE_LOCK(adapter); 3829 3830 error = ixgbe_setup_low_power_mode(adapter); 3831 3832 IXGBE_CORE_UNLOCK(adapter); 3833 3834 return (error); 3835 } /* ixgbe_suspend */ 3836 3837 /************************************************************************ 3838 * ixgbe_resume 3839 * 3840 * From D3 to D0 3841 ************************************************************************/ 3842 static bool 3843 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 3844 { 3845 struct adapter *adapter = device_private(dev); 3846 struct ifnet *ifp = adapter->ifp; 3847 struct ixgbe_hw *hw = &adapter->hw; 3848 u32 wus; 3849 3850 INIT_DEBUGOUT("ixgbe_resume: begin"); 3851 3852 IXGBE_CORE_LOCK(adapter); 3853 3854 /* Read & clear WUS register */ 3855 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 3856 if (wus) 3857 device_printf(dev, "Woken up by (WUS): %#010x\n", 3858 IXGBE_READ_REG(hw, IXGBE_WUS)); 3859 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3860 /* And clear WUFC until next low-power transition */ 3861 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3862 3863 /* 3864 * Required after D3->D0 transition; 3865 * will re-advertise all previous advertised speeds 3866 */ 3867 if (ifp->if_flags & IFF_UP) 3868 ixgbe_init_locked(adapter); 3869 3870 IXGBE_CORE_UNLOCK(adapter); 3871 3872 return true; 3873 } /* ixgbe_resume */ 3874 3875 /* 3876 * Set the various hardware offload abilities. 3877 * 3878 * This takes the ifnet's if_capenable flags (e.g. set by the user using 3879 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 3880 * mbuf offload flags the driver will understand. 3881 */ 3882 static void 3883 ixgbe_set_if_hwassist(struct adapter *adapter) 3884 { 3885 /* XXX */ 3886 } 3887 3888 /************************************************************************ 3889 * ixgbe_init_locked - Init entry point 3890 * 3891 * Used in two ways: It is used by the stack as an init 3892 * entry point in network interface structure. It is also 3893 * used by the driver as a hw/sw initialization routine to 3894 * get to a consistent state. 3895 * 3896 * return 0 on success, positive on failure 3897 ************************************************************************/ 3898 static void 3899 ixgbe_init_locked(struct adapter *adapter) 3900 { 3901 struct ifnet *ifp = adapter->ifp; 3902 device_t dev = adapter->dev; 3903 struct ixgbe_hw *hw = &adapter->hw; 3904 struct ix_queue *que; 3905 struct tx_ring *txr; 3906 struct rx_ring *rxr; 3907 u32 txdctl, mhadd; 3908 u32 rxdctl, rxctrl; 3909 u32 ctrl_ext; 3910 bool unsupported_sfp = false; 3911 int i, j, err; 3912 3913 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 3914 3915 KASSERT(mutex_owned(&adapter->core_mtx)); 3916 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 3917 3918 hw->need_unsupported_sfp_recovery = false; 3919 hw->adapter_stopped = FALSE; 3920 ixgbe_stop_adapter(hw); 3921 callout_stop(&adapter->timer); 3922 for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++) 3923 que->disabled_count = 0; 3924 3925 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 3926 adapter->max_frame_size = 3927 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 3928 3929 /* Queue indices may change with IOV mode */ 3930 ixgbe_align_all_queue_indices(adapter); 3931 3932 /* reprogram the RAR[0] in case user changed it. */ 3933 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 3934 3935 /* Get the latest mac address, User can use a LAA */ 3936 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 3937 IXGBE_ETH_LENGTH_OF_ADDRESS); 3938 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 3939 hw->addr_ctrl.rar_used_count = 1; 3940 3941 /* Set hardware offload abilities from ifnet flags */ 3942 ixgbe_set_if_hwassist(adapter); 3943 3944 /* Prepare transmit descriptors and buffers */ 3945 if (ixgbe_setup_transmit_structures(adapter)) { 3946 device_printf(dev, "Could not setup transmit structures\n"); 3947 ixgbe_stop(adapter); 3948 return; 3949 } 3950 3951 ixgbe_init_hw(hw); 3952 3953 ixgbe_initialize_iov(adapter); 3954 3955 ixgbe_initialize_transmit_units(adapter); 3956 3957 /* Setup Multicast table */ 3958 ixgbe_set_rxfilter(adapter); 3959 3960 /* Determine the correct mbuf pool, based on frame size */ 3961 if (adapter->max_frame_size <= MCLBYTES) 3962 adapter->rx_mbuf_sz = MCLBYTES; 3963 else 3964 adapter->rx_mbuf_sz = MJUMPAGESIZE; 3965 3966 /* Prepare receive descriptors and buffers */ 3967 if (ixgbe_setup_receive_structures(adapter)) { 3968 device_printf(dev, "Could not setup receive structures\n"); 3969 ixgbe_stop(adapter); 3970 return; 3971 } 3972 3973 /* Configure RX settings */ 3974 ixgbe_initialize_receive_units(adapter); 3975 3976 /* Enable SDP & MSI-X interrupts based on adapter */ 3977 ixgbe_config_gpie(adapter); 3978 3979 /* Set MTU size */ 3980 if (ifp->if_mtu > ETHERMTU) { 3981 /* aka IXGBE_MAXFRS on 82599 and newer */ 3982 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 3983 mhadd &= ~IXGBE_MHADD_MFS_MASK; 3984 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 3985 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 3986 } 3987 3988 /* Now enable all the queues */ 3989 for (i = 0; i < adapter->num_queues; i++) { 3990 txr = &adapter->tx_rings[i]; 3991 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 3992 txdctl |= IXGBE_TXDCTL_ENABLE; 3993 /* Set WTHRESH to 8, burst writeback */ 3994 txdctl |= (8 << 16); 3995 /* 3996 * When the internal queue falls below PTHRESH (32), 3997 * start prefetching as long as there are at least 3998 * HTHRESH (1) buffers ready. The values are taken 3999 * from the Intel linux driver 3.8.21. 4000 * Prefetching enables tx line rate even with 1 queue. 4001 */ 4002 txdctl |= (32 << 0) | (1 << 8); 4003 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 4004 } 4005 4006 for (i = 0; i < adapter->num_queues; i++) { 4007 rxr = &adapter->rx_rings[i]; 4008 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 4009 if (hw->mac.type == ixgbe_mac_82598EB) { 4010 /* 4011 * PTHRESH = 21 4012 * HTHRESH = 4 4013 * WTHRESH = 8 4014 */ 4015 rxdctl &= ~0x3FFFFF; 4016 rxdctl |= 0x080420; 4017 } 4018 rxdctl |= IXGBE_RXDCTL_ENABLE; 4019 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 4020 for (j = 0; j < 10; j++) { 4021 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 4022 IXGBE_RXDCTL_ENABLE) 4023 break; 4024 else 4025 msec_delay(1); 4026 } 4027 IXGBE_WRITE_BARRIER(hw); 4028 4029 /* 4030 * In netmap mode, we must preserve the buffers made 4031 * available to userspace before the if_init() 4032 * (this is true by default on the TX side, because 4033 * init makes all buffers available to userspace). 4034 * 4035 * netmap_reset() and the device specific routines 4036 * (e.g. ixgbe_setup_receive_rings()) map these 4037 * buffers at the end of the NIC ring, so here we 4038 * must set the RDT (tail) register to make sure 4039 * they are not overwritten. 4040 * 4041 * In this driver the NIC ring starts at RDH = 0, 4042 * RDT points to the last slot available for reception (?), 4043 * so RDT = num_rx_desc - 1 means the whole ring is available. 4044 */ 4045 #ifdef DEV_NETMAP 4046 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 4047 (ifp->if_capenable & IFCAP_NETMAP)) { 4048 struct netmap_adapter *na = NA(adapter->ifp); 4049 struct netmap_kring *kring = na->rx_rings[i]; 4050 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 4051 4052 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 4053 } else 4054 #endif /* DEV_NETMAP */ 4055 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), 4056 adapter->num_rx_desc - 1); 4057 } 4058 4059 /* Enable Receive engine */ 4060 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 4061 if (hw->mac.type == ixgbe_mac_82598EB) 4062 rxctrl |= IXGBE_RXCTRL_DMBYPS; 4063 rxctrl |= IXGBE_RXCTRL_RXEN; 4064 ixgbe_enable_rx_dma(hw, rxctrl); 4065 4066 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4067 4068 /* Set up MSI/MSI-X routing */ 4069 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4070 ixgbe_configure_ivars(adapter); 4071 /* Set up auto-mask */ 4072 if (hw->mac.type == ixgbe_mac_82598EB) 4073 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4074 else { 4075 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 4076 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 4077 } 4078 } else { /* Simple settings for Legacy/MSI */ 4079 ixgbe_set_ivar(adapter, 0, 0, 0); 4080 ixgbe_set_ivar(adapter, 0, 0, 1); 4081 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 4082 } 4083 4084 ixgbe_init_fdir(adapter); 4085 4086 /* 4087 * Check on any SFP devices that 4088 * need to be kick-started 4089 */ 4090 if (hw->phy.type == ixgbe_phy_none) { 4091 err = hw->phy.ops.identify(hw); 4092 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) 4093 unsupported_sfp = true; 4094 } else if (hw->phy.type == ixgbe_phy_sfp_unsupported) 4095 unsupported_sfp = true; 4096 4097 if (unsupported_sfp) 4098 device_printf(dev, 4099 "Unsupported SFP+ module type was detected.\n"); 4100 4101 /* Set moderation on the Link interrupt */ 4102 ixgbe_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR); 4103 4104 /* Enable EEE power saving */ 4105 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 4106 hw->mac.ops.setup_eee(hw, 4107 adapter->feat_en & IXGBE_FEATURE_EEE); 4108 4109 /* Enable power to the phy. */ 4110 if (!unsupported_sfp) { 4111 ixgbe_set_phy_power(hw, TRUE); 4112 4113 /* Config/Enable Link */ 4114 ixgbe_config_link(adapter); 4115 } 4116 4117 /* Hardware Packet Buffer & Flow Control setup */ 4118 ixgbe_config_delay_values(adapter); 4119 4120 /* Initialize the FC settings */ 4121 ixgbe_start_hw(hw); 4122 4123 /* Set up VLAN support and filter */ 4124 ixgbe_setup_vlan_hw_support(adapter); 4125 4126 /* Setup DMA Coalescing */ 4127 ixgbe_config_dmac(adapter); 4128 4129 /* And now turn on interrupts */ 4130 ixgbe_enable_intr(adapter); 4131 4132 /* Enable the use of the MBX by the VF's */ 4133 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 4134 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 4135 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 4136 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 4137 } 4138 4139 /* Update saved flags. See ixgbe_ifflags_cb() */ 4140 adapter->if_flags = ifp->if_flags; 4141 adapter->ec_capenable = adapter->osdep.ec.ec_capenable; 4142 4143 /* Now inform the stack we're ready */ 4144 ifp->if_flags |= IFF_RUNNING; 4145 4146 /* OK to schedule workqueues. */ 4147 adapter->schedule_wqs_ok = true; 4148 4149 return; 4150 } /* ixgbe_init_locked */ 4151 4152 /************************************************************************ 4153 * ixgbe_init 4154 ************************************************************************/ 4155 static int 4156 ixgbe_init(struct ifnet *ifp) 4157 { 4158 struct adapter *adapter = ifp->if_softc; 4159 4160 IXGBE_CORE_LOCK(adapter); 4161 ixgbe_init_locked(adapter); 4162 IXGBE_CORE_UNLOCK(adapter); 4163 4164 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 4165 } /* ixgbe_init */ 4166 4167 /************************************************************************ 4168 * ixgbe_set_ivar 4169 * 4170 * Setup the correct IVAR register for a particular MSI-X interrupt 4171 * (yes this is all very magic and confusing :) 4172 * - entry is the register array entry 4173 * - vector is the MSI-X vector for this queue 4174 * - type is RX/TX/MISC 4175 ************************************************************************/ 4176 static void 4177 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 4178 { 4179 struct ixgbe_hw *hw = &adapter->hw; 4180 u32 ivar, index; 4181 4182 vector |= IXGBE_IVAR_ALLOC_VAL; 4183 4184 switch (hw->mac.type) { 4185 case ixgbe_mac_82598EB: 4186 if (type == -1) 4187 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 4188 else 4189 entry += (type * 64); 4190 index = (entry >> 2) & 0x1F; 4191 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 4192 ivar &= ~(0xffUL << (8 * (entry & 0x3))); 4193 ivar |= ((u32)vector << (8 * (entry & 0x3))); 4194 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 4195 break; 4196 case ixgbe_mac_82599EB: 4197 case ixgbe_mac_X540: 4198 case ixgbe_mac_X550: 4199 case ixgbe_mac_X550EM_x: 4200 case ixgbe_mac_X550EM_a: 4201 if (type == -1) { /* MISC IVAR */ 4202 index = (entry & 1) * 8; 4203 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 4204 ivar &= ~(0xffUL << index); 4205 ivar |= ((u32)vector << index); 4206 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 4207 } else { /* RX/TX IVARS */ 4208 index = (16 * (entry & 1)) + (8 * type); 4209 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 4210 ivar &= ~(0xffUL << index); 4211 ivar |= ((u32)vector << index); 4212 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 4213 } 4214 break; 4215 default: 4216 break; 4217 } 4218 } /* ixgbe_set_ivar */ 4219 4220 /************************************************************************ 4221 * ixgbe_configure_ivars 4222 ************************************************************************/ 4223 static void 4224 ixgbe_configure_ivars(struct adapter *adapter) 4225 { 4226 struct ix_queue *que = adapter->queues; 4227 u32 newitr; 4228 4229 if (ixgbe_max_interrupt_rate > 0) 4230 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 4231 else { 4232 /* 4233 * Disable DMA coalescing if interrupt moderation is 4234 * disabled. 4235 */ 4236 adapter->dmac = 0; 4237 newitr = 0; 4238 } 4239 4240 for (int i = 0; i < adapter->num_queues; i++, que++) { 4241 struct rx_ring *rxr = &adapter->rx_rings[i]; 4242 struct tx_ring *txr = &adapter->tx_rings[i]; 4243 /* First the RX queue entry */ 4244 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 4245 /* ... and the TX */ 4246 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 4247 /* Set an Initial EITR value */ 4248 ixgbe_eitr_write(adapter, que->msix, newitr); 4249 /* 4250 * To eliminate influence of the previous state. 4251 * At this point, Tx/Rx interrupt handler 4252 * (ixgbe_msix_que()) cannot be called, so both 4253 * IXGBE_TX_LOCK and IXGBE_RX_LOCK are not required. 4254 */ 4255 que->eitr_setting = 0; 4256 } 4257 4258 /* For the Link interrupt */ 4259 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 4260 } /* ixgbe_configure_ivars */ 4261 4262 /************************************************************************ 4263 * ixgbe_config_gpie 4264 ************************************************************************/ 4265 static void 4266 ixgbe_config_gpie(struct adapter *adapter) 4267 { 4268 struct ixgbe_hw *hw = &adapter->hw; 4269 u32 gpie; 4270 4271 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 4272 4273 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4274 /* Enable Enhanced MSI-X mode */ 4275 gpie |= IXGBE_GPIE_MSIX_MODE 4276 | IXGBE_GPIE_EIAME 4277 | IXGBE_GPIE_PBA_SUPPORT 4278 | IXGBE_GPIE_OCD; 4279 } 4280 4281 /* Fan Failure Interrupt */ 4282 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4283 gpie |= IXGBE_SDP1_GPIEN; 4284 4285 /* Thermal Sensor Interrupt */ 4286 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) 4287 gpie |= IXGBE_SDP0_GPIEN_X540; 4288 4289 /* Link detection */ 4290 switch (hw->mac.type) { 4291 case ixgbe_mac_82599EB: 4292 gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN; 4293 break; 4294 case ixgbe_mac_X550EM_x: 4295 case ixgbe_mac_X550EM_a: 4296 gpie |= IXGBE_SDP0_GPIEN_X540; 4297 break; 4298 default: 4299 break; 4300 } 4301 4302 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 4303 4304 } /* ixgbe_config_gpie */ 4305 4306 /************************************************************************ 4307 * ixgbe_config_delay_values 4308 * 4309 * Requires adapter->max_frame_size to be set. 4310 ************************************************************************/ 4311 static void 4312 ixgbe_config_delay_values(struct adapter *adapter) 4313 { 4314 struct ixgbe_hw *hw = &adapter->hw; 4315 u32 rxpb, frame, size, tmp; 4316 4317 frame = adapter->max_frame_size; 4318 4319 /* Calculate High Water */ 4320 switch (hw->mac.type) { 4321 case ixgbe_mac_X540: 4322 case ixgbe_mac_X550: 4323 case ixgbe_mac_X550EM_x: 4324 case ixgbe_mac_X550EM_a: 4325 tmp = IXGBE_DV_X540(frame, frame); 4326 break; 4327 default: 4328 tmp = IXGBE_DV(frame, frame); 4329 break; 4330 } 4331 size = IXGBE_BT2KB(tmp); 4332 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 4333 hw->fc.high_water[0] = rxpb - size; 4334 4335 /* Now calculate Low Water */ 4336 switch (hw->mac.type) { 4337 case ixgbe_mac_X540: 4338 case ixgbe_mac_X550: 4339 case ixgbe_mac_X550EM_x: 4340 case ixgbe_mac_X550EM_a: 4341 tmp = IXGBE_LOW_DV_X540(frame); 4342 break; 4343 default: 4344 tmp = IXGBE_LOW_DV(frame); 4345 break; 4346 } 4347 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 4348 4349 hw->fc.pause_time = IXGBE_FC_PAUSE; 4350 hw->fc.send_xon = TRUE; 4351 } /* ixgbe_config_delay_values */ 4352 4353 /************************************************************************ 4354 * ixgbe_set_rxfilter - Multicast Update 4355 * 4356 * Called whenever multicast address list is updated. 4357 ************************************************************************/ 4358 static void 4359 ixgbe_set_rxfilter(struct adapter *adapter) 4360 { 4361 struct ixgbe_mc_addr *mta; 4362 struct ifnet *ifp = adapter->ifp; 4363 u8 *update_ptr; 4364 int mcnt = 0; 4365 u32 fctrl; 4366 struct ethercom *ec = &adapter->osdep.ec; 4367 struct ether_multi *enm; 4368 struct ether_multistep step; 4369 4370 KASSERT(mutex_owned(&adapter->core_mtx)); 4371 IOCTL_DEBUGOUT("ixgbe_set_rxfilter: begin"); 4372 4373 mta = adapter->mta; 4374 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 4375 4376 ETHER_LOCK(ec); 4377 ec->ec_flags &= ~ETHER_F_ALLMULTI; 4378 ETHER_FIRST_MULTI(step, ec, enm); 4379 while (enm != NULL) { 4380 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 4381 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 4382 ETHER_ADDR_LEN) != 0)) { 4383 ec->ec_flags |= ETHER_F_ALLMULTI; 4384 break; 4385 } 4386 bcopy(enm->enm_addrlo, 4387 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 4388 mta[mcnt].vmdq = adapter->pool; 4389 mcnt++; 4390 ETHER_NEXT_MULTI(step, enm); 4391 } 4392 4393 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 4394 if (ifp->if_flags & IFF_PROMISC) 4395 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4396 else if (ec->ec_flags & ETHER_F_ALLMULTI) { 4397 fctrl |= IXGBE_FCTRL_MPE; 4398 fctrl &= ~IXGBE_FCTRL_UPE; 4399 } else 4400 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4401 4402 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 4403 4404 /* Update multicast filter entries only when it's not ALLMULTI */ 4405 if ((ec->ec_flags & ETHER_F_ALLMULTI) == 0) { 4406 ETHER_UNLOCK(ec); 4407 update_ptr = (u8 *)mta; 4408 ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 4409 ixgbe_mc_array_itr, TRUE); 4410 } else 4411 ETHER_UNLOCK(ec); 4412 } /* ixgbe_set_rxfilter */ 4413 4414 /************************************************************************ 4415 * ixgbe_mc_array_itr 4416 * 4417 * An iterator function needed by the multicast shared code. 4418 * It feeds the shared code routine the addresses in the 4419 * array of ixgbe_set_rxfilter() one by one. 4420 ************************************************************************/ 4421 static u8 * 4422 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 4423 { 4424 struct ixgbe_mc_addr *mta; 4425 4426 mta = (struct ixgbe_mc_addr *)*update_ptr; 4427 *vmdq = mta->vmdq; 4428 4429 *update_ptr = (u8*)(mta + 1); 4430 4431 return (mta->addr); 4432 } /* ixgbe_mc_array_itr */ 4433 4434 /************************************************************************ 4435 * ixgbe_local_timer - Timer routine 4436 * 4437 * Checks for link status, updates statistics, 4438 * and runs the watchdog check. 4439 ************************************************************************/ 4440 static void 4441 ixgbe_local_timer(void *arg) 4442 { 4443 struct adapter *adapter = arg; 4444 4445 IXGBE_CORE_LOCK(adapter); 4446 ixgbe_local_timer1(adapter); 4447 IXGBE_CORE_UNLOCK(adapter); 4448 } 4449 4450 static void 4451 ixgbe_local_timer1(void *arg) 4452 { 4453 struct adapter *adapter = arg; 4454 device_t dev = adapter->dev; 4455 struct ix_queue *que = adapter->queues; 4456 u64 queues = 0; 4457 u64 v0, v1, v2, v3, v4, v5, v6, v7; 4458 int hung = 0; 4459 int i; 4460 4461 KASSERT(mutex_owned(&adapter->core_mtx)); 4462 4463 /* Check for pluggable optics */ 4464 if (adapter->sfp_probe) 4465 if (!ixgbe_sfp_probe(adapter)) 4466 goto out; /* Nothing to do */ 4467 4468 ixgbe_update_link_status(adapter); 4469 ixgbe_update_stats_counters(adapter); 4470 4471 /* Update some event counters */ 4472 v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0; 4473 que = adapter->queues; 4474 for (i = 0; i < adapter->num_queues; i++, que++) { 4475 struct tx_ring *txr = que->txr; 4476 4477 v0 += txr->q_efbig_tx_dma_setup; 4478 v1 += txr->q_mbuf_defrag_failed; 4479 v2 += txr->q_efbig2_tx_dma_setup; 4480 v3 += txr->q_einval_tx_dma_setup; 4481 v4 += txr->q_other_tx_dma_setup; 4482 v5 += txr->q_eagain_tx_dma_setup; 4483 v6 += txr->q_enomem_tx_dma_setup; 4484 v7 += txr->q_tso_err; 4485 } 4486 adapter->efbig_tx_dma_setup.ev_count = v0; 4487 adapter->mbuf_defrag_failed.ev_count = v1; 4488 adapter->efbig2_tx_dma_setup.ev_count = v2; 4489 adapter->einval_tx_dma_setup.ev_count = v3; 4490 adapter->other_tx_dma_setup.ev_count = v4; 4491 adapter->eagain_tx_dma_setup.ev_count = v5; 4492 adapter->enomem_tx_dma_setup.ev_count = v6; 4493 adapter->tso_err.ev_count = v7; 4494 4495 /* 4496 * Check the TX queues status 4497 * - mark hung queues so we don't schedule on them 4498 * - watchdog only if all queues show hung 4499 */ 4500 que = adapter->queues; 4501 for (i = 0; i < adapter->num_queues; i++, que++) { 4502 /* Keep track of queues with work for soft irq */ 4503 if (que->txr->busy) 4504 queues |= 1ULL << que->me; 4505 /* 4506 * Each time txeof runs without cleaning, but there 4507 * are uncleaned descriptors it increments busy. If 4508 * we get to the MAX we declare it hung. 4509 */ 4510 if (que->busy == IXGBE_QUEUE_HUNG) { 4511 ++hung; 4512 /* Mark the queue as inactive */ 4513 adapter->active_queues &= ~(1ULL << que->me); 4514 continue; 4515 } else { 4516 /* Check if we've come back from hung */ 4517 if ((adapter->active_queues & (1ULL << que->me)) == 0) 4518 adapter->active_queues |= 1ULL << que->me; 4519 } 4520 if (que->busy >= IXGBE_MAX_TX_BUSY) { 4521 device_printf(dev, 4522 "Warning queue %d appears to be hung!\n", i); 4523 que->txr->busy = IXGBE_QUEUE_HUNG; 4524 ++hung; 4525 } 4526 } 4527 4528 /* Only truely watchdog if all queues show hung */ 4529 if (hung == adapter->num_queues) 4530 goto watchdog; 4531 #if 0 /* XXX Avoid unexpectedly disabling interrupt forever (PR#53294) */ 4532 else if (queues != 0) { /* Force an IRQ on queues with work */ 4533 que = adapter->queues; 4534 for (i = 0; i < adapter->num_queues; i++, que++) { 4535 mutex_enter(&que->dc_mtx); 4536 if (que->disabled_count == 0) 4537 ixgbe_rearm_queues(adapter, 4538 queues & ((u64)1 << i)); 4539 mutex_exit(&que->dc_mtx); 4540 } 4541 } 4542 #endif 4543 4544 out: 4545 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4546 return; 4547 4548 watchdog: 4549 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4550 adapter->ifp->if_flags &= ~IFF_RUNNING; 4551 adapter->watchdog_events.ev_count++; 4552 ixgbe_init_locked(adapter); 4553 } /* ixgbe_local_timer */ 4554 4555 /************************************************************************ 4556 * ixgbe_recovery_mode_timer - Recovery mode timer routine 4557 ************************************************************************/ 4558 static void 4559 ixgbe_recovery_mode_timer(void *arg) 4560 { 4561 struct adapter *adapter = arg; 4562 struct ixgbe_hw *hw = &adapter->hw; 4563 4564 IXGBE_CORE_LOCK(adapter); 4565 if (ixgbe_fw_recovery_mode(hw)) { 4566 if (atomic_cas_uint(&adapter->recovery_mode, 0, 1)) { 4567 /* Firmware error detected, entering recovery mode */ 4568 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"); 4569 4570 if (hw->adapter_stopped == FALSE) 4571 ixgbe_stop(adapter); 4572 } 4573 } else 4574 atomic_cas_uint(&adapter->recovery_mode, 1, 0); 4575 4576 callout_reset(&adapter->recovery_mode_timer, hz, 4577 ixgbe_recovery_mode_timer, adapter); 4578 IXGBE_CORE_UNLOCK(adapter); 4579 } /* ixgbe_recovery_mode_timer */ 4580 4581 /************************************************************************ 4582 * ixgbe_sfp_probe 4583 * 4584 * Determine if a port had optics inserted. 4585 ************************************************************************/ 4586 static bool 4587 ixgbe_sfp_probe(struct adapter *adapter) 4588 { 4589 struct ixgbe_hw *hw = &adapter->hw; 4590 device_t dev = adapter->dev; 4591 bool result = FALSE; 4592 4593 if ((hw->phy.type == ixgbe_phy_nl) && 4594 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 4595 s32 ret = hw->phy.ops.identify_sfp(hw); 4596 if (ret) 4597 goto out; 4598 ret = hw->phy.ops.reset(hw); 4599 adapter->sfp_probe = FALSE; 4600 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4601 device_printf(dev,"Unsupported SFP+ module detected!"); 4602 device_printf(dev, 4603 "Reload driver with supported module.\n"); 4604 goto out; 4605 } else 4606 device_printf(dev, "SFP+ module detected!\n"); 4607 /* We now have supported optics */ 4608 result = TRUE; 4609 } 4610 out: 4611 4612 return (result); 4613 } /* ixgbe_sfp_probe */ 4614 4615 /************************************************************************ 4616 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4617 ************************************************************************/ 4618 static void 4619 ixgbe_handle_mod(void *context) 4620 { 4621 struct adapter *adapter = context; 4622 struct ixgbe_hw *hw = &adapter->hw; 4623 device_t dev = adapter->dev; 4624 u32 err, cage_full = 0; 4625 4626 IXGBE_CORE_LOCK(adapter); 4627 ++adapter->mod_sicount.ev_count; 4628 if (adapter->hw.need_crosstalk_fix) { 4629 switch (hw->mac.type) { 4630 case ixgbe_mac_82599EB: 4631 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4632 IXGBE_ESDP_SDP2; 4633 break; 4634 case ixgbe_mac_X550EM_x: 4635 case ixgbe_mac_X550EM_a: 4636 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4637 IXGBE_ESDP_SDP0; 4638 break; 4639 default: 4640 break; 4641 } 4642 4643 if (!cage_full) 4644 goto out; 4645 } 4646 4647 err = hw->phy.ops.identify_sfp(hw); 4648 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4649 device_printf(dev, 4650 "Unsupported SFP+ module type was detected.\n"); 4651 goto out; 4652 } 4653 4654 if (hw->need_unsupported_sfp_recovery) { 4655 device_printf(dev, "Recovering from unsupported SFP\n"); 4656 /* 4657 * We could recover the status by calling setup_sfp(), 4658 * setup_link() and some others. It's complex and might not 4659 * work correctly on some unknown cases. To avoid such type of 4660 * problem, call ixgbe_init_locked(). It's simple and safe 4661 * approach. 4662 */ 4663 ixgbe_init_locked(adapter); 4664 } else { 4665 if (hw->mac.type == ixgbe_mac_82598EB) 4666 err = hw->phy.ops.reset(hw); 4667 else { 4668 err = hw->mac.ops.setup_sfp(hw); 4669 hw->phy.sfp_setup_needed = FALSE; 4670 } 4671 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4672 device_printf(dev, 4673 "Setup failure - unsupported SFP+ module type.\n"); 4674 goto out; 4675 } 4676 } 4677 ixgbe_schedule_msf_tasklet(adapter); 4678 out: 4679 IXGBE_CORE_UNLOCK(adapter); 4680 } /* ixgbe_handle_mod */ 4681 4682 4683 /************************************************************************ 4684 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4685 ************************************************************************/ 4686 static void 4687 ixgbe_handle_msf(struct work *wk, void *context) 4688 { 4689 struct adapter *adapter = context; 4690 struct ifnet *ifp = adapter->ifp; 4691 struct ixgbe_hw *hw = &adapter->hw; 4692 u32 autoneg; 4693 bool negotiate; 4694 4695 /* 4696 * Hold the IFNET_LOCK across this entire call. This will 4697 * prevent additional changes to adapter->phy_layer and 4698 * and serialize calls to this tasklet. We cannot hold the 4699 * CORE_LOCK while calling into the ifmedia functions as 4700 * they may block while allocating memory. 4701 */ 4702 IFNET_LOCK(ifp); 4703 4704 IXGBE_CORE_LOCK(adapter); 4705 adapter->msf_pending = false; 4706 ++adapter->msf_sicount.ev_count; 4707 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4708 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4709 4710 autoneg = hw->phy.autoneg_advertised; 4711 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4712 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4713 else 4714 negotiate = 0; 4715 if (hw->mac.ops.setup_link) 4716 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4717 IXGBE_CORE_UNLOCK(adapter); 4718 4719 /* Adjust media types shown in ifconfig */ 4720 ifmedia_removeall(&adapter->media); 4721 ixgbe_add_media_types(adapter); 4722 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4723 IFNET_UNLOCK(ifp); 4724 } /* ixgbe_handle_msf */ 4725 4726 /************************************************************************ 4727 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4728 ************************************************************************/ 4729 static void 4730 ixgbe_handle_phy(void *context) 4731 { 4732 struct adapter *adapter = context; 4733 struct ixgbe_hw *hw = &adapter->hw; 4734 int error; 4735 4736 ++adapter->phy_sicount.ev_count; 4737 error = hw->phy.ops.handle_lasi(hw); 4738 if (error == IXGBE_ERR_OVERTEMP) 4739 device_printf(adapter->dev, 4740 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4741 " PHY will downshift to lower power state!\n"); 4742 else if (error) 4743 device_printf(adapter->dev, 4744 "Error handling LASI interrupt: %d\n", error); 4745 } /* ixgbe_handle_phy */ 4746 4747 static void 4748 ixgbe_ifstop(struct ifnet *ifp, int disable) 4749 { 4750 struct adapter *adapter = ifp->if_softc; 4751 4752 IXGBE_CORE_LOCK(adapter); 4753 ixgbe_stop(adapter); 4754 IXGBE_CORE_UNLOCK(adapter); 4755 4756 workqueue_wait(adapter->msf_wq, &adapter->msf_wc); 4757 adapter->msf_pending = false; 4758 } 4759 4760 /************************************************************************ 4761 * ixgbe_stop - Stop the hardware 4762 * 4763 * Disables all traffic on the adapter by issuing a 4764 * global reset on the MAC and deallocates TX/RX buffers. 4765 ************************************************************************/ 4766 static void 4767 ixgbe_stop(void *arg) 4768 { 4769 struct ifnet *ifp; 4770 struct adapter *adapter = arg; 4771 struct ixgbe_hw *hw = &adapter->hw; 4772 4773 ifp = adapter->ifp; 4774 4775 KASSERT(mutex_owned(&adapter->core_mtx)); 4776 4777 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 4778 ixgbe_disable_intr(adapter); 4779 callout_stop(&adapter->timer); 4780 4781 /* Don't schedule workqueues. */ 4782 adapter->schedule_wqs_ok = false; 4783 4784 /* Let the stack know...*/ 4785 ifp->if_flags &= ~IFF_RUNNING; 4786 4787 ixgbe_reset_hw(hw); 4788 hw->adapter_stopped = FALSE; 4789 ixgbe_stop_adapter(hw); 4790 if (hw->mac.type == ixgbe_mac_82599EB) 4791 ixgbe_stop_mac_link_on_d3_82599(hw); 4792 /* Turn off the laser - noop with no optics */ 4793 ixgbe_disable_tx_laser(hw); 4794 4795 /* Update the stack */ 4796 adapter->link_up = FALSE; 4797 ixgbe_update_link_status(adapter); 4798 4799 /* reprogram the RAR[0] in case user changed it. */ 4800 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4801 4802 return; 4803 } /* ixgbe_stop */ 4804 4805 /************************************************************************ 4806 * ixgbe_update_link_status - Update OS on link state 4807 * 4808 * Note: Only updates the OS on the cached link state. 4809 * The real check of the hardware only happens with 4810 * a link interrupt. 4811 ************************************************************************/ 4812 static void 4813 ixgbe_update_link_status(struct adapter *adapter) 4814 { 4815 struct ifnet *ifp = adapter->ifp; 4816 device_t dev = adapter->dev; 4817 struct ixgbe_hw *hw = &adapter->hw; 4818 4819 KASSERT(mutex_owned(&adapter->core_mtx)); 4820 4821 if (adapter->link_up) { 4822 if (adapter->link_active != LINK_STATE_UP) { 4823 /* 4824 * To eliminate influence of the previous state 4825 * in the same way as ixgbe_init_locked(). 4826 */ 4827 struct ix_queue *que = adapter->queues; 4828 for (int i = 0; i < adapter->num_queues; i++, que++) 4829 que->eitr_setting = 0; 4830 4831 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 4832 /* 4833 * Discard count for both MAC Local Fault and 4834 * Remote Fault because those registers are 4835 * valid only when the link speed is up and 4836 * 10Gbps. 4837 */ 4838 IXGBE_READ_REG(hw, IXGBE_MLFC); 4839 IXGBE_READ_REG(hw, IXGBE_MRFC); 4840 } 4841 4842 if (bootverbose) { 4843 const char *bpsmsg; 4844 4845 switch (adapter->link_speed) { 4846 case IXGBE_LINK_SPEED_10GB_FULL: 4847 bpsmsg = "10 Gbps"; 4848 break; 4849 case IXGBE_LINK_SPEED_5GB_FULL: 4850 bpsmsg = "5 Gbps"; 4851 break; 4852 case IXGBE_LINK_SPEED_2_5GB_FULL: 4853 bpsmsg = "2.5 Gbps"; 4854 break; 4855 case IXGBE_LINK_SPEED_1GB_FULL: 4856 bpsmsg = "1 Gbps"; 4857 break; 4858 case IXGBE_LINK_SPEED_100_FULL: 4859 bpsmsg = "100 Mbps"; 4860 break; 4861 case IXGBE_LINK_SPEED_10_FULL: 4862 bpsmsg = "10 Mbps"; 4863 break; 4864 default: 4865 bpsmsg = "unknown speed"; 4866 break; 4867 } 4868 device_printf(dev, "Link is up %s %s \n", 4869 bpsmsg, "Full Duplex"); 4870 } 4871 adapter->link_active = LINK_STATE_UP; 4872 /* Update any Flow Control changes */ 4873 ixgbe_fc_enable(&adapter->hw); 4874 /* Update DMA coalescing config */ 4875 ixgbe_config_dmac(adapter); 4876 if_link_state_change(ifp, LINK_STATE_UP); 4877 4878 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4879 ixgbe_ping_all_vfs(adapter); 4880 } 4881 } else { 4882 /* 4883 * Do it when link active changes to DOWN. i.e. 4884 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN 4885 * b) LINK_STATE_UP -> LINK_STATE_DOWN 4886 */ 4887 if (adapter->link_active != LINK_STATE_DOWN) { 4888 if (bootverbose) 4889 device_printf(dev, "Link is Down\n"); 4890 if_link_state_change(ifp, LINK_STATE_DOWN); 4891 adapter->link_active = LINK_STATE_DOWN; 4892 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4893 ixgbe_ping_all_vfs(adapter); 4894 ixgbe_drain_all(adapter); 4895 } 4896 } 4897 } /* ixgbe_update_link_status */ 4898 4899 /************************************************************************ 4900 * ixgbe_config_dmac - Configure DMA Coalescing 4901 ************************************************************************/ 4902 static void 4903 ixgbe_config_dmac(struct adapter *adapter) 4904 { 4905 struct ixgbe_hw *hw = &adapter->hw; 4906 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4907 4908 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 4909 return; 4910 4911 if (dcfg->watchdog_timer ^ adapter->dmac || 4912 dcfg->link_speed ^ adapter->link_speed) { 4913 dcfg->watchdog_timer = adapter->dmac; 4914 dcfg->fcoe_en = false; 4915 dcfg->link_speed = adapter->link_speed; 4916 dcfg->num_tcs = 1; 4917 4918 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4919 dcfg->watchdog_timer, dcfg->link_speed); 4920 4921 hw->mac.ops.dmac_config(hw); 4922 } 4923 } /* ixgbe_config_dmac */ 4924 4925 /************************************************************************ 4926 * ixgbe_enable_intr 4927 ************************************************************************/ 4928 static void 4929 ixgbe_enable_intr(struct adapter *adapter) 4930 { 4931 struct ixgbe_hw *hw = &adapter->hw; 4932 struct ix_queue *que = adapter->queues; 4933 u32 mask, fwsm; 4934 4935 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 4936 4937 switch (adapter->hw.mac.type) { 4938 case ixgbe_mac_82599EB: 4939 mask |= IXGBE_EIMS_ECC; 4940 /* Temperature sensor on some adapters */ 4941 mask |= IXGBE_EIMS_GPI_SDP0; 4942 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 4943 mask |= IXGBE_EIMS_GPI_SDP1; 4944 mask |= IXGBE_EIMS_GPI_SDP2; 4945 break; 4946 case ixgbe_mac_X540: 4947 /* Detect if Thermal Sensor is enabled */ 4948 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 4949 if (fwsm & IXGBE_FWSM_TS_ENABLED) 4950 mask |= IXGBE_EIMS_TS; 4951 mask |= IXGBE_EIMS_ECC; 4952 break; 4953 case ixgbe_mac_X550: 4954 /* MAC thermal sensor is automatically enabled */ 4955 mask |= IXGBE_EIMS_TS; 4956 mask |= IXGBE_EIMS_ECC; 4957 break; 4958 case ixgbe_mac_X550EM_x: 4959 case ixgbe_mac_X550EM_a: 4960 /* Some devices use SDP0 for important information */ 4961 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 4962 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 4963 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 4964 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 4965 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 4966 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 4967 mask |= IXGBE_EICR_GPI_SDP0_X540; 4968 mask |= IXGBE_EIMS_ECC; 4969 break; 4970 default: 4971 break; 4972 } 4973 4974 /* Enable Fan Failure detection */ 4975 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4976 mask |= IXGBE_EIMS_GPI_SDP1; 4977 /* Enable SR-IOV */ 4978 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4979 mask |= IXGBE_EIMS_MAILBOX; 4980 /* Enable Flow Director */ 4981 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 4982 mask |= IXGBE_EIMS_FLOW_DIR; 4983 4984 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 4985 4986 /* With MSI-X we use auto clear */ 4987 if (adapter->msix_mem) { 4988 mask = IXGBE_EIMS_ENABLE_MASK; 4989 /* Don't autoclear Link */ 4990 mask &= ~IXGBE_EIMS_OTHER; 4991 mask &= ~IXGBE_EIMS_LSC; 4992 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 4993 mask &= ~IXGBE_EIMS_MAILBOX; 4994 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 4995 } 4996 4997 /* 4998 * Now enable all queues, this is done separately to 4999 * allow for handling the extended (beyond 32) MSI-X 5000 * vectors that can be used by 82599 5001 */ 5002 for (int i = 0; i < adapter->num_queues; i++, que++) 5003 ixgbe_enable_queue(adapter, que->msix); 5004 5005 IXGBE_WRITE_FLUSH(hw); 5006 5007 } /* ixgbe_enable_intr */ 5008 5009 /************************************************************************ 5010 * ixgbe_disable_intr_internal 5011 ************************************************************************/ 5012 static void 5013 ixgbe_disable_intr_internal(struct adapter *adapter, bool nestok) 5014 { 5015 struct ix_queue *que = adapter->queues; 5016 5017 /* disable interrupts other than queues */ 5018 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 5019 5020 if (adapter->msix_mem) 5021 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 5022 5023 for (int i = 0; i < adapter->num_queues; i++, que++) 5024 ixgbe_disable_queue_internal(adapter, que->msix, nestok); 5025 5026 IXGBE_WRITE_FLUSH(&adapter->hw); 5027 5028 } /* ixgbe_do_disable_intr_internal */ 5029 5030 /************************************************************************ 5031 * ixgbe_disable_intr 5032 ************************************************************************/ 5033 static void 5034 ixgbe_disable_intr(struct adapter *adapter) 5035 { 5036 5037 ixgbe_disable_intr_internal(adapter, true); 5038 } /* ixgbe_disable_intr */ 5039 5040 /************************************************************************ 5041 * ixgbe_ensure_disabled_intr 5042 ************************************************************************/ 5043 void 5044 ixgbe_ensure_disabled_intr(struct adapter *adapter) 5045 { 5046 5047 ixgbe_disable_intr_internal(adapter, false); 5048 } /* ixgbe_ensure_disabled_intr */ 5049 5050 /************************************************************************ 5051 * ixgbe_legacy_irq - Legacy Interrupt Service routine 5052 ************************************************************************/ 5053 static int 5054 ixgbe_legacy_irq(void *arg) 5055 { 5056 struct ix_queue *que = arg; 5057 struct adapter *adapter = que->adapter; 5058 struct ixgbe_hw *hw = &adapter->hw; 5059 struct ifnet *ifp = adapter->ifp; 5060 struct tx_ring *txr = adapter->tx_rings; 5061 bool more = false; 5062 u32 eicr, eicr_mask; 5063 5064 /* Silicon errata #26 on 82598 */ 5065 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 5066 5067 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 5068 5069 adapter->stats.pf.legint.ev_count++; 5070 ++que->irqs.ev_count; 5071 if (eicr == 0) { 5072 adapter->stats.pf.intzero.ev_count++; 5073 if ((ifp->if_flags & IFF_UP) != 0) 5074 ixgbe_enable_intr(adapter); 5075 return 0; 5076 } 5077 5078 if ((ifp->if_flags & IFF_RUNNING) != 0) { 5079 /* 5080 * The same as ixgbe_msix_que() about "que->txrx_use_workqueue". 5081 */ 5082 que->txrx_use_workqueue = adapter->txrx_use_workqueue; 5083 5084 #ifdef __NetBSD__ 5085 /* Don't run ixgbe_rxeof in interrupt context */ 5086 more = true; 5087 #else 5088 more = ixgbe_rxeof(que); 5089 #endif 5090 5091 IXGBE_TX_LOCK(txr); 5092 ixgbe_txeof(txr); 5093 #ifdef notyet 5094 if (!ixgbe_ring_empty(ifp, txr->br)) 5095 ixgbe_start_locked(ifp, txr); 5096 #endif 5097 IXGBE_TX_UNLOCK(txr); 5098 } 5099 5100 /* Check for fan failure */ 5101 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 5102 ixgbe_check_fan_failure(adapter, eicr, true); 5103 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 5104 } 5105 5106 /* Link status change */ 5107 if (eicr & IXGBE_EICR_LSC) 5108 softint_schedule(adapter->link_si); 5109 5110 if (ixgbe_is_sfp(hw)) { 5111 /* Pluggable optics-related interrupt */ 5112 if (hw->mac.type >= ixgbe_mac_X540) 5113 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 5114 else 5115 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 5116 5117 if (eicr & eicr_mask) { 5118 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 5119 softint_schedule(adapter->mod_si); 5120 } 5121 5122 if ((hw->mac.type == ixgbe_mac_82599EB) && 5123 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 5124 IXGBE_WRITE_REG(hw, IXGBE_EICR, 5125 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 5126 ixgbe_schedule_msf_tasklet(adapter); 5127 } 5128 } 5129 5130 /* External PHY interrupt */ 5131 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 5132 (eicr & IXGBE_EICR_GPI_SDP0_X540)) 5133 softint_schedule(adapter->phy_si); 5134 5135 if (more) { 5136 que->req.ev_count++; 5137 ixgbe_sched_handle_que(adapter, que); 5138 } else 5139 ixgbe_enable_intr(adapter); 5140 5141 return 1; 5142 } /* ixgbe_legacy_irq */ 5143 5144 /************************************************************************ 5145 * ixgbe_free_pciintr_resources 5146 ************************************************************************/ 5147 static void 5148 ixgbe_free_pciintr_resources(struct adapter *adapter) 5149 { 5150 struct ix_queue *que = adapter->queues; 5151 int rid; 5152 5153 /* 5154 * Release all msix queue resources: 5155 */ 5156 for (int i = 0; i < adapter->num_queues; i++, que++) { 5157 if (que->res != NULL) { 5158 pci_intr_disestablish(adapter->osdep.pc, 5159 adapter->osdep.ihs[i]); 5160 adapter->osdep.ihs[i] = NULL; 5161 } 5162 } 5163 5164 /* Clean the Legacy or Link interrupt last */ 5165 if (adapter->vector) /* we are doing MSIX */ 5166 rid = adapter->vector; 5167 else 5168 rid = 0; 5169 5170 if (adapter->osdep.ihs[rid] != NULL) { 5171 pci_intr_disestablish(adapter->osdep.pc, 5172 adapter->osdep.ihs[rid]); 5173 adapter->osdep.ihs[rid] = NULL; 5174 } 5175 5176 if (adapter->osdep.intrs != NULL) { 5177 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 5178 adapter->osdep.nintrs); 5179 adapter->osdep.intrs = NULL; 5180 } 5181 } /* ixgbe_free_pciintr_resources */ 5182 5183 /************************************************************************ 5184 * ixgbe_free_pci_resources 5185 ************************************************************************/ 5186 static void 5187 ixgbe_free_pci_resources(struct adapter *adapter) 5188 { 5189 5190 ixgbe_free_pciintr_resources(adapter); 5191 5192 if (adapter->osdep.mem_size != 0) { 5193 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 5194 adapter->osdep.mem_bus_space_handle, 5195 adapter->osdep.mem_size); 5196 } 5197 5198 } /* ixgbe_free_pci_resources */ 5199 5200 /************************************************************************ 5201 * ixgbe_set_sysctl_value 5202 ************************************************************************/ 5203 static void 5204 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 5205 const char *description, int *limit, int value) 5206 { 5207 device_t dev = adapter->dev; 5208 struct sysctllog **log; 5209 const struct sysctlnode *rnode, *cnode; 5210 5211 /* 5212 * It's not required to check recovery mode because this function never 5213 * touches hardware. 5214 */ 5215 5216 log = &adapter->sysctllog; 5217 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 5218 aprint_error_dev(dev, "could not create sysctl root\n"); 5219 return; 5220 } 5221 if (sysctl_createv(log, 0, &rnode, &cnode, 5222 CTLFLAG_READWRITE, CTLTYPE_INT, 5223 name, SYSCTL_DESCR(description), 5224 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 5225 aprint_error_dev(dev, "could not create sysctl\n"); 5226 *limit = value; 5227 } /* ixgbe_set_sysctl_value */ 5228 5229 /************************************************************************ 5230 * ixgbe_sysctl_flowcntl 5231 * 5232 * SYSCTL wrapper around setting Flow Control 5233 ************************************************************************/ 5234 static int 5235 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 5236 { 5237 struct sysctlnode node = *rnode; 5238 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5239 int error, fc; 5240 5241 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5242 return (EPERM); 5243 5244 fc = adapter->hw.fc.current_mode; 5245 node.sysctl_data = &fc; 5246 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5247 if (error != 0 || newp == NULL) 5248 return error; 5249 5250 /* Don't bother if it's not changed */ 5251 if (fc == adapter->hw.fc.current_mode) 5252 return (0); 5253 5254 return ixgbe_set_flowcntl(adapter, fc); 5255 } /* ixgbe_sysctl_flowcntl */ 5256 5257 /************************************************************************ 5258 * ixgbe_set_flowcntl - Set flow control 5259 * 5260 * Flow control values: 5261 * 0 - off 5262 * 1 - rx pause 5263 * 2 - tx pause 5264 * 3 - full 5265 ************************************************************************/ 5266 static int 5267 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 5268 { 5269 switch (fc) { 5270 case ixgbe_fc_rx_pause: 5271 case ixgbe_fc_tx_pause: 5272 case ixgbe_fc_full: 5273 adapter->hw.fc.requested_mode = fc; 5274 if (adapter->num_queues > 1) 5275 ixgbe_disable_rx_drop(adapter); 5276 break; 5277 case ixgbe_fc_none: 5278 adapter->hw.fc.requested_mode = ixgbe_fc_none; 5279 if (adapter->num_queues > 1) 5280 ixgbe_enable_rx_drop(adapter); 5281 break; 5282 default: 5283 return (EINVAL); 5284 } 5285 5286 #if 0 /* XXX NetBSD */ 5287 /* Don't autoneg if forcing a value */ 5288 adapter->hw.fc.disable_fc_autoneg = TRUE; 5289 #endif 5290 ixgbe_fc_enable(&adapter->hw); 5291 5292 return (0); 5293 } /* ixgbe_set_flowcntl */ 5294 5295 /************************************************************************ 5296 * ixgbe_enable_rx_drop 5297 * 5298 * Enable the hardware to drop packets when the buffer is 5299 * full. This is useful with multiqueue, so that no single 5300 * queue being full stalls the entire RX engine. We only 5301 * enable this when Multiqueue is enabled AND Flow Control 5302 * is disabled. 5303 ************************************************************************/ 5304 static void 5305 ixgbe_enable_rx_drop(struct adapter *adapter) 5306 { 5307 struct ixgbe_hw *hw = &adapter->hw; 5308 struct rx_ring *rxr; 5309 u32 srrctl; 5310 5311 for (int i = 0; i < adapter->num_queues; i++) { 5312 rxr = &adapter->rx_rings[i]; 5313 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5314 srrctl |= IXGBE_SRRCTL_DROP_EN; 5315 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5316 } 5317 5318 /* enable drop for each vf */ 5319 for (int i = 0; i < adapter->num_vfs; i++) { 5320 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5321 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 5322 IXGBE_QDE_ENABLE)); 5323 } 5324 } /* ixgbe_enable_rx_drop */ 5325 5326 /************************************************************************ 5327 * ixgbe_disable_rx_drop 5328 ************************************************************************/ 5329 static void 5330 ixgbe_disable_rx_drop(struct adapter *adapter) 5331 { 5332 struct ixgbe_hw *hw = &adapter->hw; 5333 struct rx_ring *rxr; 5334 u32 srrctl; 5335 5336 for (int i = 0; i < adapter->num_queues; i++) { 5337 rxr = &adapter->rx_rings[i]; 5338 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 5339 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 5340 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 5341 } 5342 5343 /* disable drop for each vf */ 5344 for (int i = 0; i < adapter->num_vfs; i++) { 5345 IXGBE_WRITE_REG(hw, IXGBE_QDE, 5346 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 5347 } 5348 } /* ixgbe_disable_rx_drop */ 5349 5350 /************************************************************************ 5351 * ixgbe_sysctl_advertise 5352 * 5353 * SYSCTL wrapper around setting advertised speed 5354 ************************************************************************/ 5355 static int 5356 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 5357 { 5358 struct sysctlnode node = *rnode; 5359 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5360 int error = 0, advertise; 5361 5362 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5363 return (EPERM); 5364 5365 advertise = adapter->advertise; 5366 node.sysctl_data = &advertise; 5367 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5368 if (error != 0 || newp == NULL) 5369 return error; 5370 5371 return ixgbe_set_advertise(adapter, advertise); 5372 } /* ixgbe_sysctl_advertise */ 5373 5374 /************************************************************************ 5375 * ixgbe_set_advertise - Control advertised link speed 5376 * 5377 * Flags: 5378 * 0x00 - Default (all capable link speed) 5379 * 0x01 - advertise 100 Mb 5380 * 0x02 - advertise 1G 5381 * 0x04 - advertise 10G 5382 * 0x08 - advertise 10 Mb 5383 * 0x10 - advertise 2.5G 5384 * 0x20 - advertise 5G 5385 ************************************************************************/ 5386 static int 5387 ixgbe_set_advertise(struct adapter *adapter, int advertise) 5388 { 5389 device_t dev; 5390 struct ixgbe_hw *hw; 5391 ixgbe_link_speed speed = 0; 5392 ixgbe_link_speed link_caps = 0; 5393 s32 err = IXGBE_NOT_IMPLEMENTED; 5394 bool negotiate = FALSE; 5395 5396 /* Checks to validate new value */ 5397 if (adapter->advertise == advertise) /* no change */ 5398 return (0); 5399 5400 dev = adapter->dev; 5401 hw = &adapter->hw; 5402 5403 /* No speed changes for backplane media */ 5404 if (hw->phy.media_type == ixgbe_media_type_backplane) 5405 return (ENODEV); 5406 5407 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5408 (hw->phy.multispeed_fiber))) { 5409 device_printf(dev, 5410 "Advertised speed can only be set on copper or " 5411 "multispeed fiber media types.\n"); 5412 return (EINVAL); 5413 } 5414 5415 if (advertise < 0x0 || advertise > 0x2f) { 5416 device_printf(dev, 5417 "Invalid advertised speed; valid modes are 0x0 through 0x7\n"); 5418 return (EINVAL); 5419 } 5420 5421 if (hw->mac.ops.get_link_capabilities) { 5422 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5423 &negotiate); 5424 if (err != IXGBE_SUCCESS) { 5425 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5426 return (ENODEV); 5427 } 5428 } 5429 5430 /* Set new value and report new advertised mode */ 5431 if (advertise & 0x1) { 5432 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5433 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5434 return (EINVAL); 5435 } 5436 speed |= IXGBE_LINK_SPEED_100_FULL; 5437 } 5438 if (advertise & 0x2) { 5439 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5440 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5441 return (EINVAL); 5442 } 5443 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5444 } 5445 if (advertise & 0x4) { 5446 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5447 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5448 return (EINVAL); 5449 } 5450 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5451 } 5452 if (advertise & 0x8) { 5453 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5454 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5455 return (EINVAL); 5456 } 5457 speed |= IXGBE_LINK_SPEED_10_FULL; 5458 } 5459 if (advertise & 0x10) { 5460 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5461 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5462 return (EINVAL); 5463 } 5464 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5465 } 5466 if (advertise & 0x20) { 5467 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5468 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5469 return (EINVAL); 5470 } 5471 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5472 } 5473 if (advertise == 0) 5474 speed = link_caps; /* All capable link speed */ 5475 5476 hw->mac.autotry_restart = TRUE; 5477 hw->mac.ops.setup_link(hw, speed, TRUE); 5478 adapter->advertise = advertise; 5479 5480 return (0); 5481 } /* ixgbe_set_advertise */ 5482 5483 /************************************************************************ 5484 * ixgbe_get_advertise - Get current advertised speed settings 5485 * 5486 * Formatted for sysctl usage. 5487 * Flags: 5488 * 0x01 - advertise 100 Mb 5489 * 0x02 - advertise 1G 5490 * 0x04 - advertise 10G 5491 * 0x08 - advertise 10 Mb (yes, Mb) 5492 * 0x10 - advertise 2.5G 5493 * 0x20 - advertise 5G 5494 ************************************************************************/ 5495 static int 5496 ixgbe_get_advertise(struct adapter *adapter) 5497 { 5498 struct ixgbe_hw *hw = &adapter->hw; 5499 int speed; 5500 ixgbe_link_speed link_caps = 0; 5501 s32 err; 5502 bool negotiate = FALSE; 5503 5504 /* 5505 * Advertised speed means nothing unless it's copper or 5506 * multi-speed fiber 5507 */ 5508 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5509 !(hw->phy.multispeed_fiber)) 5510 return (0); 5511 5512 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5513 if (err != IXGBE_SUCCESS) 5514 return (0); 5515 5516 speed = 5517 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5518 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5519 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5520 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5521 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5522 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5523 5524 return speed; 5525 } /* ixgbe_get_advertise */ 5526 5527 /************************************************************************ 5528 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5529 * 5530 * Control values: 5531 * 0/1 - off / on (use default value of 1000) 5532 * 5533 * Legal timer values are: 5534 * 50,100,250,500,1000,2000,5000,10000 5535 * 5536 * Turning off interrupt moderation will also turn this off. 5537 ************************************************************************/ 5538 static int 5539 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5540 { 5541 struct sysctlnode node = *rnode; 5542 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5543 struct ifnet *ifp = adapter->ifp; 5544 int error; 5545 int newval; 5546 5547 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5548 return (EPERM); 5549 5550 newval = adapter->dmac; 5551 node.sysctl_data = &newval; 5552 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5553 if ((error) || (newp == NULL)) 5554 return (error); 5555 5556 switch (newval) { 5557 case 0: 5558 /* Disabled */ 5559 adapter->dmac = 0; 5560 break; 5561 case 1: 5562 /* Enable and use default */ 5563 adapter->dmac = 1000; 5564 break; 5565 case 50: 5566 case 100: 5567 case 250: 5568 case 500: 5569 case 1000: 5570 case 2000: 5571 case 5000: 5572 case 10000: 5573 /* Legal values - allow */ 5574 adapter->dmac = newval; 5575 break; 5576 default: 5577 /* Do nothing, illegal value */ 5578 return (EINVAL); 5579 } 5580 5581 /* Re-initialize hardware if it's already running */ 5582 if (ifp->if_flags & IFF_RUNNING) 5583 ifp->if_init(ifp); 5584 5585 return (0); 5586 } 5587 5588 #ifdef IXGBE_DEBUG 5589 /************************************************************************ 5590 * ixgbe_sysctl_power_state 5591 * 5592 * Sysctl to test power states 5593 * Values: 5594 * 0 - set device to D0 5595 * 3 - set device to D3 5596 * (none) - get current device power state 5597 ************************************************************************/ 5598 static int 5599 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5600 { 5601 #ifdef notyet 5602 struct sysctlnode node = *rnode; 5603 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5604 device_t dev = adapter->dev; 5605 int curr_ps, new_ps, error = 0; 5606 5607 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5608 return (EPERM); 5609 5610 curr_ps = new_ps = pci_get_powerstate(dev); 5611 5612 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5613 if ((error) || (req->newp == NULL)) 5614 return (error); 5615 5616 if (new_ps == curr_ps) 5617 return (0); 5618 5619 if (new_ps == 3 && curr_ps == 0) 5620 error = DEVICE_SUSPEND(dev); 5621 else if (new_ps == 0 && curr_ps == 3) 5622 error = DEVICE_RESUME(dev); 5623 else 5624 return (EINVAL); 5625 5626 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5627 5628 return (error); 5629 #else 5630 return 0; 5631 #endif 5632 } /* ixgbe_sysctl_power_state */ 5633 #endif 5634 5635 /************************************************************************ 5636 * ixgbe_sysctl_wol_enable 5637 * 5638 * Sysctl to enable/disable the WoL capability, 5639 * if supported by the adapter. 5640 * 5641 * Values: 5642 * 0 - disabled 5643 * 1 - enabled 5644 ************************************************************************/ 5645 static int 5646 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5647 { 5648 struct sysctlnode node = *rnode; 5649 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5650 struct ixgbe_hw *hw = &adapter->hw; 5651 bool new_wol_enabled; 5652 int error = 0; 5653 5654 /* 5655 * It's not required to check recovery mode because this function never 5656 * touches hardware. 5657 */ 5658 new_wol_enabled = hw->wol_enabled; 5659 node.sysctl_data = &new_wol_enabled; 5660 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5661 if ((error) || (newp == NULL)) 5662 return (error); 5663 if (new_wol_enabled == hw->wol_enabled) 5664 return (0); 5665 5666 if (new_wol_enabled && !adapter->wol_support) 5667 return (ENODEV); 5668 else 5669 hw->wol_enabled = new_wol_enabled; 5670 5671 return (0); 5672 } /* ixgbe_sysctl_wol_enable */ 5673 5674 /************************************************************************ 5675 * ixgbe_sysctl_wufc - Wake Up Filter Control 5676 * 5677 * Sysctl to enable/disable the types of packets that the 5678 * adapter will wake up on upon receipt. 5679 * Flags: 5680 * 0x1 - Link Status Change 5681 * 0x2 - Magic Packet 5682 * 0x4 - Direct Exact 5683 * 0x8 - Directed Multicast 5684 * 0x10 - Broadcast 5685 * 0x20 - ARP/IPv4 Request Packet 5686 * 0x40 - Direct IPv4 Packet 5687 * 0x80 - Direct IPv6 Packet 5688 * 5689 * Settings not listed above will cause the sysctl to return an error. 5690 ************************************************************************/ 5691 static int 5692 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5693 { 5694 struct sysctlnode node = *rnode; 5695 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5696 int error = 0; 5697 u32 new_wufc; 5698 5699 /* 5700 * It's not required to check recovery mode because this function never 5701 * touches hardware. 5702 */ 5703 new_wufc = adapter->wufc; 5704 node.sysctl_data = &new_wufc; 5705 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5706 if ((error) || (newp == NULL)) 5707 return (error); 5708 if (new_wufc == adapter->wufc) 5709 return (0); 5710 5711 if (new_wufc & 0xffffff00) 5712 return (EINVAL); 5713 5714 new_wufc &= 0xff; 5715 new_wufc |= (0xffffff & adapter->wufc); 5716 adapter->wufc = new_wufc; 5717 5718 return (0); 5719 } /* ixgbe_sysctl_wufc */ 5720 5721 #ifdef IXGBE_DEBUG 5722 /************************************************************************ 5723 * ixgbe_sysctl_print_rss_config 5724 ************************************************************************/ 5725 static int 5726 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5727 { 5728 #ifdef notyet 5729 struct sysctlnode node = *rnode; 5730 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5731 struct ixgbe_hw *hw = &adapter->hw; 5732 device_t dev = adapter->dev; 5733 struct sbuf *buf; 5734 int error = 0, reta_size; 5735 u32 reg; 5736 5737 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5738 return (EPERM); 5739 5740 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5741 if (!buf) { 5742 device_printf(dev, "Could not allocate sbuf for output.\n"); 5743 return (ENOMEM); 5744 } 5745 5746 // TODO: use sbufs to make a string to print out 5747 /* Set multiplier for RETA setup and table size based on MAC */ 5748 switch (adapter->hw.mac.type) { 5749 case ixgbe_mac_X550: 5750 case ixgbe_mac_X550EM_x: 5751 case ixgbe_mac_X550EM_a: 5752 reta_size = 128; 5753 break; 5754 default: 5755 reta_size = 32; 5756 break; 5757 } 5758 5759 /* Print out the redirection table */ 5760 sbuf_cat(buf, "\n"); 5761 for (int i = 0; i < reta_size; i++) { 5762 if (i < 32) { 5763 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5764 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5765 } else { 5766 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5767 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5768 } 5769 } 5770 5771 // TODO: print more config 5772 5773 error = sbuf_finish(buf); 5774 if (error) 5775 device_printf(dev, "Error finishing sbuf: %d\n", error); 5776 5777 sbuf_delete(buf); 5778 #endif 5779 return (0); 5780 } /* ixgbe_sysctl_print_rss_config */ 5781 #endif /* IXGBE_DEBUG */ 5782 5783 /************************************************************************ 5784 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5785 * 5786 * For X552/X557-AT devices using an external PHY 5787 ************************************************************************/ 5788 static int 5789 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5790 { 5791 struct sysctlnode node = *rnode; 5792 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5793 struct ixgbe_hw *hw = &adapter->hw; 5794 int val; 5795 u16 reg; 5796 int error; 5797 5798 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5799 return (EPERM); 5800 5801 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5802 device_printf(adapter->dev, 5803 "Device has no supported external thermal sensor.\n"); 5804 return (ENODEV); 5805 } 5806 5807 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5808 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5809 device_printf(adapter->dev, 5810 "Error reading from PHY's current temperature register\n"); 5811 return (EAGAIN); 5812 } 5813 5814 node.sysctl_data = &val; 5815 5816 /* Shift temp for output */ 5817 val = reg >> 8; 5818 5819 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5820 if ((error) || (newp == NULL)) 5821 return (error); 5822 5823 return (0); 5824 } /* ixgbe_sysctl_phy_temp */ 5825 5826 /************************************************************************ 5827 * ixgbe_sysctl_phy_overtemp_occurred 5828 * 5829 * Reports (directly from the PHY) whether the current PHY 5830 * temperature is over the overtemp threshold. 5831 ************************************************************************/ 5832 static int 5833 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5834 { 5835 struct sysctlnode node = *rnode; 5836 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5837 struct ixgbe_hw *hw = &adapter->hw; 5838 int val, error; 5839 u16 reg; 5840 5841 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5842 return (EPERM); 5843 5844 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5845 device_printf(adapter->dev, 5846 "Device has no supported external thermal sensor.\n"); 5847 return (ENODEV); 5848 } 5849 5850 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5851 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5852 device_printf(adapter->dev, 5853 "Error reading from PHY's temperature status register\n"); 5854 return (EAGAIN); 5855 } 5856 5857 node.sysctl_data = &val; 5858 5859 /* Get occurrence bit */ 5860 val = !!(reg & 0x4000); 5861 5862 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5863 if ((error) || (newp == NULL)) 5864 return (error); 5865 5866 return (0); 5867 } /* ixgbe_sysctl_phy_overtemp_occurred */ 5868 5869 /************************************************************************ 5870 * ixgbe_sysctl_eee_state 5871 * 5872 * Sysctl to set EEE power saving feature 5873 * Values: 5874 * 0 - disable EEE 5875 * 1 - enable EEE 5876 * (none) - get current device EEE state 5877 ************************************************************************/ 5878 static int 5879 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 5880 { 5881 struct sysctlnode node = *rnode; 5882 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5883 struct ifnet *ifp = adapter->ifp; 5884 device_t dev = adapter->dev; 5885 int curr_eee, new_eee, error = 0; 5886 s32 retval; 5887 5888 if (ixgbe_fw_recovery_mode_swflag(adapter)) 5889 return (EPERM); 5890 5891 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 5892 node.sysctl_data = &new_eee; 5893 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5894 if ((error) || (newp == NULL)) 5895 return (error); 5896 5897 /* Nothing to do */ 5898 if (new_eee == curr_eee) 5899 return (0); 5900 5901 /* Not supported */ 5902 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 5903 return (EINVAL); 5904 5905 /* Bounds checking */ 5906 if ((new_eee < 0) || (new_eee > 1)) 5907 return (EINVAL); 5908 5909 retval = ixgbe_setup_eee(&adapter->hw, new_eee); 5910 if (retval) { 5911 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 5912 return (EINVAL); 5913 } 5914 5915 /* Restart auto-neg */ 5916 ifp->if_init(ifp); 5917 5918 device_printf(dev, "New EEE state: %d\n", new_eee); 5919 5920 /* Cache new value */ 5921 if (new_eee) 5922 adapter->feat_en |= IXGBE_FEATURE_EEE; 5923 else 5924 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 5925 5926 return (error); 5927 } /* ixgbe_sysctl_eee_state */ 5928 5929 #define PRINTQS(adapter, regname) \ 5930 do { \ 5931 struct ixgbe_hw *_hw = &(adapter)->hw; \ 5932 int _i; \ 5933 \ 5934 printf("%s: %s", device_xname((adapter)->dev), #regname); \ 5935 for (_i = 0; _i < (adapter)->num_queues; _i++) { \ 5936 printf((_i == 0) ? "\t" : " "); \ 5937 printf("%08x", IXGBE_READ_REG(_hw, \ 5938 IXGBE_##regname(_i))); \ 5939 } \ 5940 printf("\n"); \ 5941 } while (0) 5942 5943 /************************************************************************ 5944 * ixgbe_print_debug_info 5945 * 5946 * Called only when em_display_debug_stats is enabled. 5947 * Provides a way to take a look at important statistics 5948 * maintained by the driver and hardware. 5949 ************************************************************************/ 5950 static void 5951 ixgbe_print_debug_info(struct adapter *adapter) 5952 { 5953 device_t dev = adapter->dev; 5954 struct ixgbe_hw *hw = &adapter->hw; 5955 int table_size; 5956 int i; 5957 5958 switch (adapter->hw.mac.type) { 5959 case ixgbe_mac_X550: 5960 case ixgbe_mac_X550EM_x: 5961 case ixgbe_mac_X550EM_a: 5962 table_size = 128; 5963 break; 5964 default: 5965 table_size = 32; 5966 break; 5967 } 5968 5969 device_printf(dev, "[E]RETA:\n"); 5970 for (i = 0; i < table_size; i++) { 5971 if (i < 32) 5972 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 5973 IXGBE_RETA(i))); 5974 else 5975 printf("%02x: %08x\n", i, IXGBE_READ_REG(hw, 5976 IXGBE_ERETA(i - 32))); 5977 } 5978 5979 device_printf(dev, "queue:"); 5980 for (i = 0; i < adapter->num_queues; i++) { 5981 printf((i == 0) ? "\t" : " "); 5982 printf("%8d", i); 5983 } 5984 printf("\n"); 5985 PRINTQS(adapter, RDBAL); 5986 PRINTQS(adapter, RDBAH); 5987 PRINTQS(adapter, RDLEN); 5988 PRINTQS(adapter, SRRCTL); 5989 PRINTQS(adapter, RDH); 5990 PRINTQS(adapter, RDT); 5991 PRINTQS(adapter, RXDCTL); 5992 5993 device_printf(dev, "RQSMR:"); 5994 for (i = 0; i < adapter->num_queues / 4; i++) { 5995 printf((i == 0) ? "\t" : " "); 5996 printf("%08x", IXGBE_READ_REG(hw, IXGBE_RQSMR(i))); 5997 } 5998 printf("\n"); 5999 6000 device_printf(dev, "disabled_count:"); 6001 for (i = 0; i < adapter->num_queues; i++) { 6002 printf((i == 0) ? "\t" : " "); 6003 printf("%8d", adapter->queues[i].disabled_count); 6004 } 6005 printf("\n"); 6006 6007 device_printf(dev, "EIMS:\t%08x\n", IXGBE_READ_REG(hw, IXGBE_EIMS)); 6008 if (hw->mac.type != ixgbe_mac_82598EB) { 6009 device_printf(dev, "EIMS_EX(0):\t%08x\n", 6010 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(0))); 6011 device_printf(dev, "EIMS_EX(1):\t%08x\n", 6012 IXGBE_READ_REG(hw, IXGBE_EIMS_EX(1))); 6013 } 6014 } /* ixgbe_print_debug_info */ 6015 6016 /************************************************************************ 6017 * ixgbe_sysctl_debug 6018 ************************************************************************/ 6019 static int 6020 ixgbe_sysctl_debug(SYSCTLFN_ARGS) 6021 { 6022 struct sysctlnode node = *rnode; 6023 struct adapter *adapter = (struct adapter *)node.sysctl_data; 6024 int error, result = 0; 6025 6026 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6027 return (EPERM); 6028 6029 node.sysctl_data = &result; 6030 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 6031 6032 if (error || newp == NULL) 6033 return error; 6034 6035 if (result == 1) 6036 ixgbe_print_debug_info(adapter); 6037 6038 return 0; 6039 } /* ixgbe_sysctl_debug */ 6040 6041 /************************************************************************ 6042 * ixgbe_init_device_features 6043 ************************************************************************/ 6044 static void 6045 ixgbe_init_device_features(struct adapter *adapter) 6046 { 6047 adapter->feat_cap = IXGBE_FEATURE_NETMAP 6048 | IXGBE_FEATURE_RSS 6049 | IXGBE_FEATURE_MSI 6050 | IXGBE_FEATURE_MSIX 6051 | IXGBE_FEATURE_LEGACY_IRQ 6052 | IXGBE_FEATURE_LEGACY_TX; 6053 6054 /* Set capabilities first... */ 6055 switch (adapter->hw.mac.type) { 6056 case ixgbe_mac_82598EB: 6057 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 6058 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 6059 break; 6060 case ixgbe_mac_X540: 6061 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6062 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6063 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 6064 (adapter->hw.bus.func == 0)) 6065 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6066 break; 6067 case ixgbe_mac_X550: 6068 /* 6069 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6070 * NVM Image version. 6071 */ 6072 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6073 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6074 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6075 break; 6076 case ixgbe_mac_X550EM_x: 6077 /* 6078 * IXGBE_FEATURE_RECOVERY_MODE will be set after reading 6079 * NVM Image version. 6080 */ 6081 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6082 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6083 break; 6084 case ixgbe_mac_X550EM_a: 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 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6092 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 6093 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 6094 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 6095 adapter->feat_cap |= IXGBE_FEATURE_EEE; 6096 } 6097 break; 6098 case ixgbe_mac_82599EB: 6099 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 6100 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 6101 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 6102 (adapter->hw.bus.func == 0)) 6103 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 6104 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 6105 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 6106 break; 6107 default: 6108 break; 6109 } 6110 6111 /* Enabled by default... */ 6112 /* Fan failure detection */ 6113 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 6114 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 6115 /* Netmap */ 6116 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 6117 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 6118 /* EEE */ 6119 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 6120 adapter->feat_en |= IXGBE_FEATURE_EEE; 6121 /* Thermal Sensor */ 6122 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 6123 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 6124 /* 6125 * Recovery mode: 6126 * NetBSD: IXGBE_FEATURE_RECOVERY_MODE will be controlled after reading 6127 * NVM Image version. 6128 */ 6129 6130 /* Enabled via global sysctl... */ 6131 /* Flow Director */ 6132 if (ixgbe_enable_fdir) { 6133 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 6134 adapter->feat_en |= IXGBE_FEATURE_FDIR; 6135 else 6136 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 6137 } 6138 /* Legacy (single queue) transmit */ 6139 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 6140 ixgbe_enable_legacy_tx) 6141 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 6142 /* 6143 * Message Signal Interrupts - Extended (MSI-X) 6144 * Normal MSI is only enabled if MSI-X calls fail. 6145 */ 6146 if (!ixgbe_enable_msix) 6147 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 6148 /* Receive-Side Scaling (RSS) */ 6149 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 6150 adapter->feat_en |= IXGBE_FEATURE_RSS; 6151 6152 /* Disable features with unmet dependencies... */ 6153 /* No MSI-X */ 6154 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 6155 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6156 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6157 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6158 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6159 } 6160 } /* ixgbe_init_device_features */ 6161 6162 /************************************************************************ 6163 * ixgbe_probe - Device identification routine 6164 * 6165 * Determines if the driver should be loaded on 6166 * adapter based on its PCI vendor/device ID. 6167 * 6168 * return BUS_PROBE_DEFAULT on success, positive on failure 6169 ************************************************************************/ 6170 static int 6171 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 6172 { 6173 const struct pci_attach_args *pa = aux; 6174 6175 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 6176 } 6177 6178 static const ixgbe_vendor_info_t * 6179 ixgbe_lookup(const struct pci_attach_args *pa) 6180 { 6181 const ixgbe_vendor_info_t *ent; 6182 pcireg_t subid; 6183 6184 INIT_DEBUGOUT("ixgbe_lookup: begin"); 6185 6186 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 6187 return NULL; 6188 6189 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 6190 6191 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 6192 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 6193 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 6194 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 6195 (ent->subvendor_id == 0)) && 6196 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 6197 (ent->subdevice_id == 0))) { 6198 return ent; 6199 } 6200 } 6201 return NULL; 6202 } 6203 6204 static int 6205 ixgbe_ifflags_cb(struct ethercom *ec) 6206 { 6207 struct ifnet *ifp = &ec->ec_if; 6208 struct adapter *adapter = ifp->if_softc; 6209 u_short change; 6210 int rv = 0; 6211 6212 IXGBE_CORE_LOCK(adapter); 6213 6214 change = ifp->if_flags ^ adapter->if_flags; 6215 if (change != 0) 6216 adapter->if_flags = ifp->if_flags; 6217 6218 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) { 6219 rv = ENETRESET; 6220 goto out; 6221 } else if ((change & IFF_PROMISC) != 0) 6222 ixgbe_set_rxfilter(adapter); 6223 6224 /* Check for ec_capenable. */ 6225 change = ec->ec_capenable ^ adapter->ec_capenable; 6226 adapter->ec_capenable = ec->ec_capenable; 6227 if ((change & ~(ETHERCAP_VLAN_MTU | ETHERCAP_VLAN_HWTAGGING 6228 | ETHERCAP_VLAN_HWFILTER)) != 0) { 6229 rv = ENETRESET; 6230 goto out; 6231 } 6232 6233 /* 6234 * Special handling is not required for ETHERCAP_VLAN_MTU. 6235 * MAXFRS(MHADD) does not include the 4bytes of the VLAN header. 6236 */ 6237 6238 /* Set up VLAN support and filter */ 6239 if ((change & (ETHERCAP_VLAN_HWTAGGING | ETHERCAP_VLAN_HWFILTER)) != 0) 6240 ixgbe_setup_vlan_hw_support(adapter); 6241 6242 out: 6243 IXGBE_CORE_UNLOCK(adapter); 6244 6245 return rv; 6246 } 6247 6248 /************************************************************************ 6249 * ixgbe_ioctl - Ioctl entry point 6250 * 6251 * Called when the user wants to configure the interface. 6252 * 6253 * return 0 on success, positive on failure 6254 ************************************************************************/ 6255 static int 6256 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 6257 { 6258 struct adapter *adapter = ifp->if_softc; 6259 struct ixgbe_hw *hw = &adapter->hw; 6260 struct ifcapreq *ifcr = data; 6261 struct ifreq *ifr = data; 6262 int error = 0; 6263 int l4csum_en; 6264 const int l4csum = IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx | 6265 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx; 6266 6267 if (ixgbe_fw_recovery_mode_swflag(adapter)) 6268 return (EPERM); 6269 6270 switch (command) { 6271 case SIOCSIFFLAGS: 6272 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 6273 break; 6274 case SIOCADDMULTI: 6275 case SIOCDELMULTI: 6276 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 6277 break; 6278 case SIOCSIFMEDIA: 6279 case SIOCGIFMEDIA: 6280 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 6281 break; 6282 case SIOCSIFCAP: 6283 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 6284 break; 6285 case SIOCSIFMTU: 6286 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 6287 break; 6288 #ifdef __NetBSD__ 6289 case SIOCINITIFADDR: 6290 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 6291 break; 6292 case SIOCGIFFLAGS: 6293 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 6294 break; 6295 case SIOCGIFAFLAG_IN: 6296 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 6297 break; 6298 case SIOCGIFADDR: 6299 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 6300 break; 6301 case SIOCGIFMTU: 6302 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 6303 break; 6304 case SIOCGIFCAP: 6305 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 6306 break; 6307 case SIOCGETHERCAP: 6308 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 6309 break; 6310 case SIOCGLIFADDR: 6311 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 6312 break; 6313 case SIOCZIFDATA: 6314 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 6315 hw->mac.ops.clear_hw_cntrs(hw); 6316 ixgbe_clear_evcnt(adapter); 6317 break; 6318 case SIOCAIFADDR: 6319 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 6320 break; 6321 #endif 6322 default: 6323 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 6324 break; 6325 } 6326 6327 switch (command) { 6328 case SIOCGI2C: 6329 { 6330 struct ixgbe_i2c_req i2c; 6331 6332 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 6333 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 6334 if (error != 0) 6335 break; 6336 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 6337 error = EINVAL; 6338 break; 6339 } 6340 if (i2c.len > sizeof(i2c.data)) { 6341 error = EINVAL; 6342 break; 6343 } 6344 6345 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 6346 i2c.dev_addr, i2c.data); 6347 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 6348 break; 6349 } 6350 case SIOCSIFCAP: 6351 /* Layer-4 Rx checksum offload has to be turned on and 6352 * off as a unit. 6353 */ 6354 l4csum_en = ifcr->ifcr_capenable & l4csum; 6355 if (l4csum_en != l4csum && l4csum_en != 0) 6356 return EINVAL; 6357 /*FALLTHROUGH*/ 6358 case SIOCADDMULTI: 6359 case SIOCDELMULTI: 6360 case SIOCSIFFLAGS: 6361 case SIOCSIFMTU: 6362 default: 6363 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 6364 return error; 6365 if ((ifp->if_flags & IFF_RUNNING) == 0) 6366 ; 6367 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 6368 IXGBE_CORE_LOCK(adapter); 6369 if ((ifp->if_flags & IFF_RUNNING) != 0) 6370 ixgbe_init_locked(adapter); 6371 ixgbe_recalculate_max_frame(adapter); 6372 IXGBE_CORE_UNLOCK(adapter); 6373 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 6374 /* 6375 * Multicast list has changed; set the hardware filter 6376 * accordingly. 6377 */ 6378 IXGBE_CORE_LOCK(adapter); 6379 ixgbe_disable_intr(adapter); 6380 ixgbe_set_rxfilter(adapter); 6381 ixgbe_enable_intr(adapter); 6382 IXGBE_CORE_UNLOCK(adapter); 6383 } 6384 return 0; 6385 } 6386 6387 return error; 6388 } /* ixgbe_ioctl */ 6389 6390 /************************************************************************ 6391 * ixgbe_check_fan_failure 6392 ************************************************************************/ 6393 static void 6394 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 6395 { 6396 u32 mask; 6397 6398 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 6399 IXGBE_ESDP_SDP1; 6400 6401 if (reg & mask) 6402 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 6403 } /* ixgbe_check_fan_failure */ 6404 6405 /************************************************************************ 6406 * ixgbe_handle_que 6407 ************************************************************************/ 6408 static void 6409 ixgbe_handle_que(void *context) 6410 { 6411 struct ix_queue *que = context; 6412 struct adapter *adapter = que->adapter; 6413 struct tx_ring *txr = que->txr; 6414 struct ifnet *ifp = adapter->ifp; 6415 bool more = false; 6416 6417 que->handleq.ev_count++; 6418 6419 if (ifp->if_flags & IFF_RUNNING) { 6420 more = ixgbe_rxeof(que); 6421 IXGBE_TX_LOCK(txr); 6422 more |= ixgbe_txeof(txr); 6423 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 6424 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 6425 ixgbe_mq_start_locked(ifp, txr); 6426 /* Only for queue 0 */ 6427 /* NetBSD still needs this for CBQ */ 6428 if ((&adapter->queues[0] == que) 6429 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 6430 ixgbe_legacy_start_locked(ifp, txr); 6431 IXGBE_TX_UNLOCK(txr); 6432 } 6433 6434 if (more) { 6435 que->req.ev_count++; 6436 ixgbe_sched_handle_que(adapter, que); 6437 } else if (que->res != NULL) { 6438 /* Re-enable this interrupt */ 6439 ixgbe_enable_queue(adapter, que->msix); 6440 } else 6441 ixgbe_enable_intr(adapter); 6442 6443 return; 6444 } /* ixgbe_handle_que */ 6445 6446 /************************************************************************ 6447 * ixgbe_handle_que_work 6448 ************************************************************************/ 6449 static void 6450 ixgbe_handle_que_work(struct work *wk, void *context) 6451 { 6452 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 6453 6454 /* 6455 * "enqueued flag" is not required here. 6456 * See ixgbe_msix_que(). 6457 */ 6458 ixgbe_handle_que(que); 6459 } 6460 6461 /************************************************************************ 6462 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 6463 ************************************************************************/ 6464 static int 6465 ixgbe_allocate_legacy(struct adapter *adapter, 6466 const struct pci_attach_args *pa) 6467 { 6468 device_t dev = adapter->dev; 6469 struct ix_queue *que = adapter->queues; 6470 struct tx_ring *txr = adapter->tx_rings; 6471 int counts[PCI_INTR_TYPE_SIZE]; 6472 pci_intr_type_t intr_type, max_type; 6473 char intrbuf[PCI_INTRSTR_LEN]; 6474 char wqname[MAXCOMLEN]; 6475 const char *intrstr = NULL; 6476 int defertx_error = 0, error; 6477 6478 /* We allocate a single interrupt resource */ 6479 max_type = PCI_INTR_TYPE_MSI; 6480 counts[PCI_INTR_TYPE_MSIX] = 0; 6481 counts[PCI_INTR_TYPE_MSI] = 6482 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 6483 /* Check not feat_en but feat_cap to fallback to INTx */ 6484 counts[PCI_INTR_TYPE_INTX] = 6485 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 6486 6487 alloc_retry: 6488 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 6489 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 6490 return ENXIO; 6491 } 6492 adapter->osdep.nintrs = 1; 6493 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 6494 intrbuf, sizeof(intrbuf)); 6495 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 6496 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 6497 device_xname(dev)); 6498 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 6499 if (adapter->osdep.ihs[0] == NULL) { 6500 aprint_error_dev(dev,"unable to establish %s\n", 6501 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 6502 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6503 adapter->osdep.intrs = NULL; 6504 switch (intr_type) { 6505 case PCI_INTR_TYPE_MSI: 6506 /* The next try is for INTx: Disable MSI */ 6507 max_type = PCI_INTR_TYPE_INTX; 6508 counts[PCI_INTR_TYPE_INTX] = 1; 6509 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6510 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 6511 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6512 goto alloc_retry; 6513 } else 6514 break; 6515 case PCI_INTR_TYPE_INTX: 6516 default: 6517 /* See below */ 6518 break; 6519 } 6520 } 6521 if (intr_type == PCI_INTR_TYPE_INTX) { 6522 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 6523 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6524 } 6525 if (adapter->osdep.ihs[0] == NULL) { 6526 aprint_error_dev(dev, 6527 "couldn't establish interrupt%s%s\n", 6528 intrstr ? " at " : "", intrstr ? intrstr : ""); 6529 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 6530 adapter->osdep.intrs = NULL; 6531 return ENXIO; 6532 } 6533 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 6534 /* 6535 * Try allocating a fast interrupt and the associated deferred 6536 * processing contexts. 6537 */ 6538 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6539 txr->txr_si = 6540 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6541 ixgbe_deferred_mq_start, txr); 6542 6543 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6544 defertx_error = workqueue_create(&adapter->txr_wq, wqname, 6545 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, 6546 IPL_NET, IXGBE_WORKQUEUE_FLAGS); 6547 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6548 } 6549 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6550 ixgbe_handle_que, que); 6551 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6552 error = workqueue_create(&adapter->que_wq, wqname, 6553 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6554 IXGBE_WORKQUEUE_FLAGS); 6555 6556 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 6557 && ((txr->txr_si == NULL) || defertx_error != 0)) 6558 || (que->que_si == NULL) || error != 0) { 6559 aprint_error_dev(dev, 6560 "could not establish software interrupts\n"); 6561 6562 return ENXIO; 6563 } 6564 /* For simplicity in the handlers */ 6565 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 6566 6567 return (0); 6568 } /* ixgbe_allocate_legacy */ 6569 6570 /************************************************************************ 6571 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 6572 ************************************************************************/ 6573 static int 6574 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 6575 { 6576 device_t dev = adapter->dev; 6577 struct ix_queue *que = adapter->queues; 6578 struct tx_ring *txr = adapter->tx_rings; 6579 pci_chipset_tag_t pc; 6580 char intrbuf[PCI_INTRSTR_LEN]; 6581 char intr_xname[32]; 6582 char wqname[MAXCOMLEN]; 6583 const char *intrstr = NULL; 6584 int error, vector = 0; 6585 int cpu_id = 0; 6586 kcpuset_t *affinity; 6587 #ifdef RSS 6588 unsigned int rss_buckets = 0; 6589 kcpuset_t cpu_mask; 6590 #endif 6591 6592 pc = adapter->osdep.pc; 6593 #ifdef RSS 6594 /* 6595 * If we're doing RSS, the number of queues needs to 6596 * match the number of RSS buckets that are configured. 6597 * 6598 * + If there's more queues than RSS buckets, we'll end 6599 * up with queues that get no traffic. 6600 * 6601 * + If there's more RSS buckets than queues, we'll end 6602 * up having multiple RSS buckets map to the same queue, 6603 * so there'll be some contention. 6604 */ 6605 rss_buckets = rss_getnumbuckets(); 6606 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6607 (adapter->num_queues != rss_buckets)) { 6608 device_printf(dev, 6609 "%s: number of queues (%d) != number of RSS buckets (%d)" 6610 "; performance will be impacted.\n", 6611 __func__, adapter->num_queues, rss_buckets); 6612 } 6613 #endif 6614 6615 adapter->osdep.nintrs = adapter->num_queues + 1; 6616 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6617 adapter->osdep.nintrs) != 0) { 6618 aprint_error_dev(dev, 6619 "failed to allocate MSI-X interrupt\n"); 6620 return (ENXIO); 6621 } 6622 6623 kcpuset_create(&affinity, false); 6624 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6625 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6626 device_xname(dev), i); 6627 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6628 sizeof(intrbuf)); 6629 #ifdef IXGBE_MPSAFE 6630 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6631 true); 6632 #endif 6633 /* Set the handler function */ 6634 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6635 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6636 intr_xname); 6637 if (que->res == NULL) { 6638 aprint_error_dev(dev, 6639 "Failed to register QUE handler\n"); 6640 error = ENXIO; 6641 goto err_out; 6642 } 6643 que->msix = vector; 6644 adapter->active_queues |= 1ULL << que->msix; 6645 6646 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6647 #ifdef RSS 6648 /* 6649 * The queue ID is used as the RSS layer bucket ID. 6650 * We look up the queue ID -> RSS CPU ID and select 6651 * that. 6652 */ 6653 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6654 CPU_SETOF(cpu_id, &cpu_mask); 6655 #endif 6656 } else { 6657 /* 6658 * Bind the MSI-X vector, and thus the 6659 * rings to the corresponding CPU. 6660 * 6661 * This just happens to match the default RSS 6662 * round-robin bucket -> queue -> CPU allocation. 6663 */ 6664 if (adapter->num_queues > 1) 6665 cpu_id = i; 6666 } 6667 /* Round-robin affinity */ 6668 kcpuset_zero(affinity); 6669 kcpuset_set(affinity, cpu_id % ncpu); 6670 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6671 NULL); 6672 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6673 intrstr); 6674 if (error == 0) { 6675 #if 1 /* def IXGBE_DEBUG */ 6676 #ifdef RSS 6677 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6678 cpu_id % ncpu); 6679 #else 6680 aprint_normal(", bound queue %d to cpu %d", i, 6681 cpu_id % ncpu); 6682 #endif 6683 #endif /* IXGBE_DEBUG */ 6684 } 6685 aprint_normal("\n"); 6686 6687 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6688 txr->txr_si = softint_establish( 6689 SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6690 ixgbe_deferred_mq_start, txr); 6691 if (txr->txr_si == NULL) { 6692 aprint_error_dev(dev, 6693 "couldn't establish software interrupt\n"); 6694 error = ENXIO; 6695 goto err_out; 6696 } 6697 } 6698 que->que_si 6699 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6700 ixgbe_handle_que, que); 6701 if (que->que_si == NULL) { 6702 aprint_error_dev(dev, 6703 "couldn't establish software interrupt\n"); 6704 error = ENXIO; 6705 goto err_out; 6706 } 6707 } 6708 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6709 error = workqueue_create(&adapter->txr_wq, wqname, 6710 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6711 IXGBE_WORKQUEUE_FLAGS); 6712 if (error) { 6713 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 6714 goto err_out; 6715 } 6716 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6717 6718 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6719 error = workqueue_create(&adapter->que_wq, wqname, 6720 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6721 IXGBE_WORKQUEUE_FLAGS); 6722 if (error) { 6723 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6724 goto err_out; 6725 } 6726 6727 /* and Link */ 6728 cpu_id++; 6729 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6730 adapter->vector = vector; 6731 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6732 sizeof(intrbuf)); 6733 #ifdef IXGBE_MPSAFE 6734 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6735 true); 6736 #endif 6737 /* Set the link handler function */ 6738 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6739 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 6740 intr_xname); 6741 if (adapter->osdep.ihs[vector] == NULL) { 6742 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6743 error = ENXIO; 6744 goto err_out; 6745 } 6746 /* Round-robin affinity */ 6747 kcpuset_zero(affinity); 6748 kcpuset_set(affinity, cpu_id % ncpu); 6749 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6750 NULL); 6751 6752 aprint_normal_dev(dev, 6753 "for link, interrupting at %s", intrstr); 6754 if (error == 0) 6755 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6756 else 6757 aprint_normal("\n"); 6758 6759 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 6760 adapter->mbx_si = 6761 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6762 ixgbe_handle_mbx, adapter); 6763 if (adapter->mbx_si == NULL) { 6764 aprint_error_dev(dev, 6765 "could not establish software interrupts\n"); 6766 6767 error = ENXIO; 6768 goto err_out; 6769 } 6770 } 6771 6772 kcpuset_destroy(affinity); 6773 aprint_normal_dev(dev, 6774 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6775 6776 return (0); 6777 6778 err_out: 6779 kcpuset_destroy(affinity); 6780 ixgbe_free_softint(adapter); 6781 ixgbe_free_pciintr_resources(adapter); 6782 return (error); 6783 } /* ixgbe_allocate_msix */ 6784 6785 /************************************************************************ 6786 * ixgbe_configure_interrupts 6787 * 6788 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6789 * This will also depend on user settings. 6790 ************************************************************************/ 6791 static int 6792 ixgbe_configure_interrupts(struct adapter *adapter) 6793 { 6794 device_t dev = adapter->dev; 6795 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6796 int want, queues, msgs; 6797 6798 /* Default to 1 queue if MSI-X setup fails */ 6799 adapter->num_queues = 1; 6800 6801 /* Override by tuneable */ 6802 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6803 goto msi; 6804 6805 /* 6806 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6807 * interrupt slot. 6808 */ 6809 if (ncpu == 1) 6810 goto msi; 6811 6812 /* First try MSI-X */ 6813 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 6814 msgs = MIN(msgs, IXG_MAX_NINTR); 6815 if (msgs < 2) 6816 goto msi; 6817 6818 adapter->msix_mem = (void *)1; /* XXX */ 6819 6820 /* Figure out a reasonable auto config value */ 6821 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 6822 6823 #ifdef RSS 6824 /* If we're doing RSS, clamp at the number of RSS buckets */ 6825 if (adapter->feat_en & IXGBE_FEATURE_RSS) 6826 queues = uimin(queues, rss_getnumbuckets()); 6827 #endif 6828 if (ixgbe_num_queues > queues) { 6829 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 6830 ixgbe_num_queues = queues; 6831 } 6832 6833 if (ixgbe_num_queues != 0) 6834 queues = ixgbe_num_queues; 6835 else 6836 queues = uimin(queues, 6837 uimin(mac->max_tx_queues, mac->max_rx_queues)); 6838 6839 /* reflect correct sysctl value */ 6840 ixgbe_num_queues = queues; 6841 6842 /* 6843 * Want one vector (RX/TX pair) per queue 6844 * plus an additional for Link. 6845 */ 6846 want = queues + 1; 6847 if (msgs >= want) 6848 msgs = want; 6849 else { 6850 aprint_error_dev(dev, "MSI-X Configuration Problem, " 6851 "%d vectors but %d queues wanted!\n", 6852 msgs, want); 6853 goto msi; 6854 } 6855 adapter->num_queues = queues; 6856 adapter->feat_en |= IXGBE_FEATURE_MSIX; 6857 return (0); 6858 6859 /* 6860 * MSI-X allocation failed or provided us with 6861 * less vectors than needed. Free MSI-X resources 6862 * and we'll try enabling MSI. 6863 */ 6864 msi: 6865 /* Without MSI-X, some features are no longer supported */ 6866 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6867 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6868 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6869 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6870 6871 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 6872 adapter->msix_mem = NULL; /* XXX */ 6873 if (msgs > 1) 6874 msgs = 1; 6875 if (msgs != 0) { 6876 msgs = 1; 6877 adapter->feat_en |= IXGBE_FEATURE_MSI; 6878 return (0); 6879 } 6880 6881 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 6882 aprint_error_dev(dev, 6883 "Device does not support legacy interrupts.\n"); 6884 return 1; 6885 } 6886 6887 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6888 6889 return (0); 6890 } /* ixgbe_configure_interrupts */ 6891 6892 6893 /************************************************************************ 6894 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 6895 * 6896 * Done outside of interrupt context since the driver might sleep 6897 ************************************************************************/ 6898 static void 6899 ixgbe_handle_link(void *context) 6900 { 6901 struct adapter *adapter = context; 6902 struct ixgbe_hw *hw = &adapter->hw; 6903 6904 IXGBE_CORE_LOCK(adapter); 6905 ++adapter->link_sicount.ev_count; 6906 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 6907 ixgbe_update_link_status(adapter); 6908 6909 /* Re-enable link interrupts */ 6910 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 6911 6912 IXGBE_CORE_UNLOCK(adapter); 6913 } /* ixgbe_handle_link */ 6914 6915 #if 0 6916 /************************************************************************ 6917 * ixgbe_rearm_queues 6918 ************************************************************************/ 6919 static __inline void 6920 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6921 { 6922 u32 mask; 6923 6924 switch (adapter->hw.mac.type) { 6925 case ixgbe_mac_82598EB: 6926 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6927 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6928 break; 6929 case ixgbe_mac_82599EB: 6930 case ixgbe_mac_X540: 6931 case ixgbe_mac_X550: 6932 case ixgbe_mac_X550EM_x: 6933 case ixgbe_mac_X550EM_a: 6934 mask = (queues & 0xFFFFFFFF); 6935 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6936 mask = (queues >> 32); 6937 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6938 break; 6939 default: 6940 break; 6941 } 6942 } /* ixgbe_rearm_queues */ 6943 #endif 6944
Indexes created Tue Sep 30 07:10:03 GMT 2025