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