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