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