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