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