ixgbe.c revision 1.133
1 /* $NetBSD: ixgbe.c,v 1.133 2018/03/08 02:41:27 knakahara 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->watchdog_events.ev_count = 0; 1984 adapter->tso_err.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 1999 if (i < __arraycount(stats->mpc)) { 2000 stats->mpc[i].ev_count = 0; 2001 if (hw->mac.type == ixgbe_mac_82598EB) 2002 stats->rnbc[i].ev_count = 0; 2003 } 2004 if (i < __arraycount(stats->pxontxc)) { 2005 stats->pxontxc[i].ev_count = 0; 2006 stats->pxonrxc[i].ev_count = 0; 2007 stats->pxofftxc[i].ev_count = 0; 2008 stats->pxoffrxc[i].ev_count = 0; 2009 stats->pxon2offc[i].ev_count = 0; 2010 } 2011 if (i < __arraycount(stats->qprc)) { 2012 stats->qprc[i].ev_count = 0; 2013 stats->qptc[i].ev_count = 0; 2014 stats->qbrc[i].ev_count = 0; 2015 stats->qbtc[i].ev_count = 0; 2016 stats->qprdc[i].ev_count = 0; 2017 } 2018 2019 rxr->rx_packets.ev_count = 0; 2020 rxr->rx_bytes.ev_count = 0; 2021 rxr->rx_copies.ev_count = 0; 2022 rxr->no_jmbuf.ev_count = 0; 2023 rxr->rx_discarded.ev_count = 0; 2024 } 2025 stats->ipcs.ev_count = 0; 2026 stats->l4cs.ev_count = 0; 2027 stats->ipcs_bad.ev_count = 0; 2028 stats->l4cs_bad.ev_count = 0; 2029 stats->intzero.ev_count = 0; 2030 stats->legint.ev_count = 0; 2031 stats->crcerrs.ev_count = 0; 2032 stats->illerrc.ev_count = 0; 2033 stats->errbc.ev_count = 0; 2034 stats->mspdc.ev_count = 0; 2035 stats->mbsdc.ev_count = 0; 2036 stats->mpctotal.ev_count = 0; 2037 stats->mlfc.ev_count = 0; 2038 stats->mrfc.ev_count = 0; 2039 stats->rlec.ev_count = 0; 2040 stats->lxontxc.ev_count = 0; 2041 stats->lxonrxc.ev_count = 0; 2042 stats->lxofftxc.ev_count = 0; 2043 stats->lxoffrxc.ev_count = 0; 2044 2045 /* Packet Reception Stats */ 2046 stats->tor.ev_count = 0; 2047 stats->gorc.ev_count = 0; 2048 stats->tpr.ev_count = 0; 2049 stats->gprc.ev_count = 0; 2050 stats->mprc.ev_count = 0; 2051 stats->bprc.ev_count = 0; 2052 stats->prc64.ev_count = 0; 2053 stats->prc127.ev_count = 0; 2054 stats->prc255.ev_count = 0; 2055 stats->prc511.ev_count = 0; 2056 stats->prc1023.ev_count = 0; 2057 stats->prc1522.ev_count = 0; 2058 stats->ruc.ev_count = 0; 2059 stats->rfc.ev_count = 0; 2060 stats->roc.ev_count = 0; 2061 stats->rjc.ev_count = 0; 2062 stats->mngprc.ev_count = 0; 2063 stats->mngpdc.ev_count = 0; 2064 stats->xec.ev_count = 0; 2065 2066 /* Packet Transmission Stats */ 2067 stats->gotc.ev_count = 0; 2068 stats->tpt.ev_count = 0; 2069 stats->gptc.ev_count = 0; 2070 stats->bptc.ev_count = 0; 2071 stats->mptc.ev_count = 0; 2072 stats->mngptc.ev_count = 0; 2073 stats->ptc64.ev_count = 0; 2074 stats->ptc127.ev_count = 0; 2075 stats->ptc255.ev_count = 0; 2076 stats->ptc511.ev_count = 0; 2077 stats->ptc1023.ev_count = 0; 2078 stats->ptc1522.ev_count = 0; 2079 } 2080 2081 /************************************************************************ 2082 * ixgbe_sysctl_tdh_handler - Transmit Descriptor Head handler function 2083 * 2084 * Retrieves the TDH value from the hardware 2085 ************************************************************************/ 2086 static int 2087 ixgbe_sysctl_tdh_handler(SYSCTLFN_ARGS) 2088 { 2089 struct sysctlnode node = *rnode; 2090 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2091 uint32_t val; 2092 2093 if (!txr) 2094 return (0); 2095 2096 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDH(txr->me)); 2097 node.sysctl_data = &val; 2098 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2099 } /* ixgbe_sysctl_tdh_handler */ 2100 2101 /************************************************************************ 2102 * ixgbe_sysctl_tdt_handler - Transmit Descriptor Tail handler function 2103 * 2104 * Retrieves the TDT value from the hardware 2105 ************************************************************************/ 2106 static int 2107 ixgbe_sysctl_tdt_handler(SYSCTLFN_ARGS) 2108 { 2109 struct sysctlnode node = *rnode; 2110 struct tx_ring *txr = (struct tx_ring *)node.sysctl_data; 2111 uint32_t val; 2112 2113 if (!txr) 2114 return (0); 2115 2116 val = IXGBE_READ_REG(&txr->adapter->hw, IXGBE_TDT(txr->me)); 2117 node.sysctl_data = &val; 2118 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2119 } /* ixgbe_sysctl_tdt_handler */ 2120 2121 /************************************************************************ 2122 * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function 2123 * 2124 * Retrieves the RDH value from the hardware 2125 ************************************************************************/ 2126 static int 2127 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS) 2128 { 2129 struct sysctlnode node = *rnode; 2130 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2131 uint32_t val; 2132 2133 if (!rxr) 2134 return (0); 2135 2136 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDH(rxr->me)); 2137 node.sysctl_data = &val; 2138 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2139 } /* ixgbe_sysctl_rdh_handler */ 2140 2141 /************************************************************************ 2142 * ixgbe_sysctl_rdt_handler - Receive Descriptor Tail handler function 2143 * 2144 * Retrieves the RDT value from the hardware 2145 ************************************************************************/ 2146 static int 2147 ixgbe_sysctl_rdt_handler(SYSCTLFN_ARGS) 2148 { 2149 struct sysctlnode node = *rnode; 2150 struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data; 2151 uint32_t val; 2152 2153 if (!rxr) 2154 return (0); 2155 2156 val = IXGBE_READ_REG(&rxr->adapter->hw, IXGBE_RDT(rxr->me)); 2157 node.sysctl_data = &val; 2158 return sysctl_lookup(SYSCTLFN_CALL(&node)); 2159 } /* ixgbe_sysctl_rdt_handler */ 2160 2161 #if 0 /* XXX Badly need to overhaul vlan(4) on NetBSD. */ 2162 /************************************************************************ 2163 * ixgbe_register_vlan 2164 * 2165 * Run via vlan config EVENT, it enables us to use the 2166 * HW Filter table since we can get the vlan id. This 2167 * just creates the entry in the soft version of the 2168 * VFTA, init will repopulate the real table. 2169 ************************************************************************/ 2170 static void 2171 ixgbe_register_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2172 { 2173 struct adapter *adapter = ifp->if_softc; 2174 u16 index, bit; 2175 2176 if (ifp->if_softc != arg) /* Not our event */ 2177 return; 2178 2179 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2180 return; 2181 2182 IXGBE_CORE_LOCK(adapter); 2183 index = (vtag >> 5) & 0x7F; 2184 bit = vtag & 0x1F; 2185 adapter->shadow_vfta[index] |= (1 << bit); 2186 ixgbe_setup_vlan_hw_support(adapter); 2187 IXGBE_CORE_UNLOCK(adapter); 2188 } /* ixgbe_register_vlan */ 2189 2190 /************************************************************************ 2191 * ixgbe_unregister_vlan 2192 * 2193 * Run via vlan unconfig EVENT, remove our entry in the soft vfta. 2194 ************************************************************************/ 2195 static void 2196 ixgbe_unregister_vlan(void *arg, struct ifnet *ifp, u16 vtag) 2197 { 2198 struct adapter *adapter = ifp->if_softc; 2199 u16 index, bit; 2200 2201 if (ifp->if_softc != arg) 2202 return; 2203 2204 if ((vtag == 0) || (vtag > 4095)) /* Invalid */ 2205 return; 2206 2207 IXGBE_CORE_LOCK(adapter); 2208 index = (vtag >> 5) & 0x7F; 2209 bit = vtag & 0x1F; 2210 adapter->shadow_vfta[index] &= ~(1 << bit); 2211 /* Re-init to load the changes */ 2212 ixgbe_setup_vlan_hw_support(adapter); 2213 IXGBE_CORE_UNLOCK(adapter); 2214 } /* ixgbe_unregister_vlan */ 2215 #endif 2216 2217 static void 2218 ixgbe_setup_vlan_hw_support(struct adapter *adapter) 2219 { 2220 struct ethercom *ec = &adapter->osdep.ec; 2221 struct ixgbe_hw *hw = &adapter->hw; 2222 struct rx_ring *rxr; 2223 int i; 2224 u32 ctrl; 2225 2226 2227 /* 2228 * We get here thru init_locked, meaning 2229 * a soft reset, this has already cleared 2230 * the VFTA and other state, so if there 2231 * have been no vlan's registered do nothing. 2232 */ 2233 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 2234 return; 2235 2236 /* Setup the queues for vlans */ 2237 if (ec->ec_capenable & ETHERCAP_VLAN_HWTAGGING) { 2238 for (i = 0; i < adapter->num_queues; i++) { 2239 rxr = &adapter->rx_rings[i]; 2240 /* On 82599 the VLAN enable is per/queue in RXDCTL */ 2241 if (hw->mac.type != ixgbe_mac_82598EB) { 2242 ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 2243 ctrl |= IXGBE_RXDCTL_VME; 2244 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), ctrl); 2245 } 2246 rxr->vtag_strip = TRUE; 2247 } 2248 } 2249 2250 if ((ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) == 0) 2251 return; 2252 /* 2253 * A soft reset zero's out the VFTA, so 2254 * we need to repopulate it now. 2255 */ 2256 for (i = 0; i < IXGBE_VFTA_SIZE; i++) 2257 if (adapter->shadow_vfta[i] != 0) 2258 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 2259 adapter->shadow_vfta[i]); 2260 2261 ctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL); 2262 /* Enable the Filter Table if enabled */ 2263 if (ec->ec_capenable & ETHERCAP_VLAN_HWFILTER) { 2264 ctrl &= ~IXGBE_VLNCTRL_CFIEN; 2265 ctrl |= IXGBE_VLNCTRL_VFE; 2266 } 2267 if (hw->mac.type == ixgbe_mac_82598EB) 2268 ctrl |= IXGBE_VLNCTRL_VME; 2269 IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, ctrl); 2270 } /* ixgbe_setup_vlan_hw_support */ 2271 2272 /************************************************************************ 2273 * ixgbe_get_slot_info 2274 * 2275 * Get the width and transaction speed of 2276 * the slot this adapter is plugged into. 2277 ************************************************************************/ 2278 static void 2279 ixgbe_get_slot_info(struct adapter *adapter) 2280 { 2281 device_t dev = adapter->dev; 2282 struct ixgbe_hw *hw = &adapter->hw; 2283 u32 offset; 2284 // struct ixgbe_mac_info *mac = &hw->mac; 2285 u16 link; 2286 int bus_info_valid = TRUE; 2287 2288 /* Some devices are behind an internal bridge */ 2289 switch (hw->device_id) { 2290 case IXGBE_DEV_ID_82599_SFP_SF_QP: 2291 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 2292 goto get_parent_info; 2293 default: 2294 break; 2295 } 2296 2297 ixgbe_get_bus_info(hw); 2298 2299 /* 2300 * Some devices don't use PCI-E, but there is no need 2301 * to display "Unknown" for bus speed and width. 2302 */ 2303 switch (hw->mac.type) { 2304 case ixgbe_mac_X550EM_x: 2305 case ixgbe_mac_X550EM_a: 2306 return; 2307 default: 2308 goto display; 2309 } 2310 2311 get_parent_info: 2312 /* 2313 * For the Quad port adapter we need to parse back 2314 * up the PCI tree to find the speed of the expansion 2315 * slot into which this adapter is plugged. A bit more work. 2316 */ 2317 dev = device_parent(device_parent(dev)); 2318 #if 0 2319 #ifdef IXGBE_DEBUG 2320 device_printf(dev, "parent pcib = %x,%x,%x\n", pci_get_bus(dev), 2321 pci_get_slot(dev), pci_get_function(dev)); 2322 #endif 2323 dev = device_parent(device_parent(dev)); 2324 #ifdef IXGBE_DEBUG 2325 device_printf(dev, "slot pcib = %x,%x,%x\n", pci_get_bus(dev), 2326 pci_get_slot(dev), pci_get_function(dev)); 2327 #endif 2328 #endif 2329 /* Now get the PCI Express Capabilities offset */ 2330 if (pci_get_capability(adapter->osdep.pc, adapter->osdep.tag, 2331 PCI_CAP_PCIEXPRESS, &offset, NULL)) { 2332 /* 2333 * Hmm...can't get PCI-Express capabilities. 2334 * Falling back to default method. 2335 */ 2336 bus_info_valid = FALSE; 2337 ixgbe_get_bus_info(hw); 2338 goto display; 2339 } 2340 /* ...and read the Link Status Register */ 2341 link = pci_conf_read(adapter->osdep.pc, adapter->osdep.tag, 2342 offset + PCIE_LCSR) >> 16; 2343 ixgbe_set_pci_config_data_generic(hw, link); 2344 2345 display: 2346 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 2347 ((hw->bus.speed == ixgbe_bus_speed_8000) ? "8.0GT/s" : 2348 (hw->bus.speed == ixgbe_bus_speed_5000) ? "5.0GT/s" : 2349 (hw->bus.speed == ixgbe_bus_speed_2500) ? "2.5GT/s" : 2350 "Unknown"), 2351 ((hw->bus.width == ixgbe_bus_width_pcie_x8) ? "x8" : 2352 (hw->bus.width == ixgbe_bus_width_pcie_x4) ? "x4" : 2353 (hw->bus.width == ixgbe_bus_width_pcie_x1) ? "x1" : 2354 "Unknown")); 2355 2356 if (bus_info_valid) { 2357 if ((hw->device_id != IXGBE_DEV_ID_82599_SFP_SF_QP) && 2358 ((hw->bus.width <= ixgbe_bus_width_pcie_x4) && 2359 (hw->bus.speed == ixgbe_bus_speed_2500))) { 2360 device_printf(dev, "PCI-Express bandwidth available" 2361 " for this card\n is not sufficient for" 2362 " optimal performance.\n"); 2363 device_printf(dev, "For optimal performance a x8 " 2364 "PCIE, or x4 PCIE Gen2 slot is required.\n"); 2365 } 2366 if ((hw->device_id == IXGBE_DEV_ID_82599_SFP_SF_QP) && 2367 ((hw->bus.width <= ixgbe_bus_width_pcie_x8) && 2368 (hw->bus.speed < ixgbe_bus_speed_8000))) { 2369 device_printf(dev, "PCI-Express bandwidth available" 2370 " for this card\n is not sufficient for" 2371 " optimal performance.\n"); 2372 device_printf(dev, "For optimal performance a x8 " 2373 "PCIE Gen3 slot is required.\n"); 2374 } 2375 } else 2376 device_printf(dev, "Unable to determine slot speed/width. The speed/width reported are that of the internal switch.\n"); 2377 2378 return; 2379 } /* ixgbe_get_slot_info */ 2380 2381 /************************************************************************ 2382 * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets 2383 ************************************************************************/ 2384 static inline void 2385 ixgbe_enable_queue(struct adapter *adapter, u32 vector) 2386 { 2387 struct ixgbe_hw *hw = &adapter->hw; 2388 struct ix_queue *que = &adapter->queues[vector]; 2389 u64 queue = (u64)(1ULL << vector); 2390 u32 mask; 2391 2392 mutex_enter(&que->im_mtx); 2393 if (que->im_nest > 0 && --que->im_nest > 0) 2394 goto out; 2395 2396 if (hw->mac.type == ixgbe_mac_82598EB) { 2397 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2398 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 2399 } else { 2400 mask = (queue & 0xFFFFFFFF); 2401 if (mask) 2402 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask); 2403 mask = (queue >> 32); 2404 if (mask) 2405 IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask); 2406 } 2407 out: 2408 mutex_exit(&que->im_mtx); 2409 } /* ixgbe_enable_queue */ 2410 2411 /************************************************************************ 2412 * ixgbe_disable_queue 2413 ************************************************************************/ 2414 static inline void 2415 ixgbe_disable_queue(struct adapter *adapter, u32 vector) 2416 { 2417 struct ixgbe_hw *hw = &adapter->hw; 2418 struct ix_queue *que = &adapter->queues[vector]; 2419 u64 queue = (u64)(1ULL << vector); 2420 u32 mask; 2421 2422 mutex_enter(&que->im_mtx); 2423 if (que->im_nest++ > 0) 2424 goto out; 2425 2426 if (hw->mac.type == ixgbe_mac_82598EB) { 2427 mask = (IXGBE_EIMS_RTX_QUEUE & queue); 2428 IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask); 2429 } else { 2430 mask = (queue & 0xFFFFFFFF); 2431 if (mask) 2432 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask); 2433 mask = (queue >> 32); 2434 if (mask) 2435 IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask); 2436 } 2437 out: 2438 mutex_exit(&que->im_mtx); 2439 } /* ixgbe_disable_queue */ 2440 2441 /************************************************************************ 2442 * ixgbe_sched_handle_que - schedule deferred packet processing 2443 ************************************************************************/ 2444 static inline void 2445 ixgbe_sched_handle_que(struct adapter *adapter, struct ix_queue *que) 2446 { 2447 2448 if (adapter->txrx_use_workqueue) { 2449 /* 2450 * adapter->que_wq is bound to each CPU instead of 2451 * each NIC queue to reduce workqueue kthread. As we 2452 * should consider about interrupt affinity in this 2453 * function, the workqueue kthread must be WQ_PERCPU. 2454 * If create WQ_PERCPU workqueue kthread for each NIC 2455 * queue, that number of created workqueue kthread is 2456 * (number of used NIC queue) * (number of CPUs) = 2457 * (number of CPUs) ^ 2 most often. 2458 * 2459 * The same NIC queue's interrupts are avoided by 2460 * masking the queue's interrupt. And different 2461 * NIC queue's interrupts use different struct work 2462 * (que->wq_cookie). So, "enqueued flag" to avoid 2463 * twice workqueue_enqueue() is not required . 2464 */ 2465 workqueue_enqueue(adapter->que_wq, &que->wq_cookie, curcpu()); 2466 } else { 2467 softint_schedule(que->que_si); 2468 } 2469 } 2470 2471 /************************************************************************ 2472 * ixgbe_msix_que - MSI-X Queue Interrupt Service routine 2473 ************************************************************************/ 2474 static int 2475 ixgbe_msix_que(void *arg) 2476 { 2477 struct ix_queue *que = arg; 2478 struct adapter *adapter = que->adapter; 2479 struct ifnet *ifp = adapter->ifp; 2480 struct tx_ring *txr = que->txr; 2481 struct rx_ring *rxr = que->rxr; 2482 bool more; 2483 u32 newitr = 0; 2484 2485 /* Protect against spurious interrupts */ 2486 if ((ifp->if_flags & IFF_RUNNING) == 0) 2487 return 0; 2488 2489 ixgbe_disable_queue(adapter, que->msix); 2490 ++que->irqs.ev_count; 2491 2492 #ifdef __NetBSD__ 2493 /* Don't run ixgbe_rxeof in interrupt context */ 2494 more = true; 2495 #else 2496 more = ixgbe_rxeof(que); 2497 #endif 2498 2499 IXGBE_TX_LOCK(txr); 2500 ixgbe_txeof(txr); 2501 IXGBE_TX_UNLOCK(txr); 2502 2503 /* Do AIM now? */ 2504 2505 if (adapter->enable_aim == false) 2506 goto no_calc; 2507 /* 2508 * Do Adaptive Interrupt Moderation: 2509 * - Write out last calculated setting 2510 * - Calculate based on average size over 2511 * the last interval. 2512 */ 2513 if (que->eitr_setting) 2514 ixgbe_eitr_write(que, que->eitr_setting); 2515 2516 que->eitr_setting = 0; 2517 2518 /* Idle, do nothing */ 2519 if ((txr->bytes == 0) && (rxr->bytes == 0)) 2520 goto no_calc; 2521 2522 if ((txr->bytes) && (txr->packets)) 2523 newitr = txr->bytes/txr->packets; 2524 if ((rxr->bytes) && (rxr->packets)) 2525 newitr = max(newitr, (rxr->bytes / rxr->packets)); 2526 newitr += 24; /* account for hardware frame, crc */ 2527 2528 /* set an upper boundary */ 2529 newitr = min(newitr, 3000); 2530 2531 /* Be nice to the mid range */ 2532 if ((newitr > 300) && (newitr < 1200)) 2533 newitr = (newitr / 3); 2534 else 2535 newitr = (newitr / 2); 2536 2537 /* 2538 * When RSC is used, ITR interval must be larger than RSC_DELAY. 2539 * Currently, we use 2us for RSC_DELAY. The minimum value is always 2540 * greater than 2us on 100M (and 10M?(not documented)), but it's not 2541 * on 1G and higher. 2542 */ 2543 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 2544 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 2545 if (newitr < IXGBE_MIN_RSC_EITR_10G1G) 2546 newitr = IXGBE_MIN_RSC_EITR_10G1G; 2547 } 2548 2549 /* save for next interrupt */ 2550 que->eitr_setting = newitr; 2551 2552 /* Reset state */ 2553 txr->bytes = 0; 2554 txr->packets = 0; 2555 rxr->bytes = 0; 2556 rxr->packets = 0; 2557 2558 no_calc: 2559 if (more) 2560 ixgbe_sched_handle_que(adapter, que); 2561 else 2562 ixgbe_enable_queue(adapter, que->msix); 2563 2564 return 1; 2565 } /* ixgbe_msix_que */ 2566 2567 /************************************************************************ 2568 * ixgbe_media_status - Media Ioctl callback 2569 * 2570 * Called whenever the user queries the status of 2571 * the interface using ifconfig. 2572 ************************************************************************/ 2573 static void 2574 ixgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2575 { 2576 struct adapter *adapter = ifp->if_softc; 2577 struct ixgbe_hw *hw = &adapter->hw; 2578 int layer; 2579 2580 INIT_DEBUGOUT("ixgbe_media_status: begin"); 2581 IXGBE_CORE_LOCK(adapter); 2582 ixgbe_update_link_status(adapter); 2583 2584 ifmr->ifm_status = IFM_AVALID; 2585 ifmr->ifm_active = IFM_ETHER; 2586 2587 if (!adapter->link_active) { 2588 ifmr->ifm_active |= IFM_NONE; 2589 IXGBE_CORE_UNLOCK(adapter); 2590 return; 2591 } 2592 2593 ifmr->ifm_status |= IFM_ACTIVE; 2594 layer = adapter->phy_layer; 2595 2596 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T || 2597 layer & IXGBE_PHYSICAL_LAYER_5GBASE_T || 2598 layer & IXGBE_PHYSICAL_LAYER_2500BASE_T || 2599 layer & IXGBE_PHYSICAL_LAYER_1000BASE_T || 2600 layer & IXGBE_PHYSICAL_LAYER_100BASE_TX || 2601 layer & IXGBE_PHYSICAL_LAYER_10BASE_T) 2602 switch (adapter->link_speed) { 2603 case IXGBE_LINK_SPEED_10GB_FULL: 2604 ifmr->ifm_active |= IFM_10G_T | IFM_FDX; 2605 break; 2606 case IXGBE_LINK_SPEED_5GB_FULL: 2607 ifmr->ifm_active |= IFM_5000_T | IFM_FDX; 2608 break; 2609 case IXGBE_LINK_SPEED_2_5GB_FULL: 2610 ifmr->ifm_active |= IFM_2500_T | IFM_FDX; 2611 break; 2612 case IXGBE_LINK_SPEED_1GB_FULL: 2613 ifmr->ifm_active |= IFM_1000_T | IFM_FDX; 2614 break; 2615 case IXGBE_LINK_SPEED_100_FULL: 2616 ifmr->ifm_active |= IFM_100_TX | IFM_FDX; 2617 break; 2618 case IXGBE_LINK_SPEED_10_FULL: 2619 ifmr->ifm_active |= IFM_10_T | IFM_FDX; 2620 break; 2621 } 2622 if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU || 2623 layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) 2624 switch (adapter->link_speed) { 2625 case IXGBE_LINK_SPEED_10GB_FULL: 2626 ifmr->ifm_active |= IFM_10G_TWINAX | IFM_FDX; 2627 break; 2628 } 2629 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) 2630 switch (adapter->link_speed) { 2631 case IXGBE_LINK_SPEED_10GB_FULL: 2632 ifmr->ifm_active |= IFM_10G_LR | IFM_FDX; 2633 break; 2634 case IXGBE_LINK_SPEED_1GB_FULL: 2635 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2636 break; 2637 } 2638 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LRM) 2639 switch (adapter->link_speed) { 2640 case IXGBE_LINK_SPEED_10GB_FULL: 2641 ifmr->ifm_active |= IFM_10G_LRM | IFM_FDX; 2642 break; 2643 case IXGBE_LINK_SPEED_1GB_FULL: 2644 ifmr->ifm_active |= IFM_1000_LX | IFM_FDX; 2645 break; 2646 } 2647 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR || 2648 layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) 2649 switch (adapter->link_speed) { 2650 case IXGBE_LINK_SPEED_10GB_FULL: 2651 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2652 break; 2653 case IXGBE_LINK_SPEED_1GB_FULL: 2654 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 2655 break; 2656 } 2657 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) 2658 switch (adapter->link_speed) { 2659 case IXGBE_LINK_SPEED_10GB_FULL: 2660 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2661 break; 2662 } 2663 /* 2664 * XXX: These need to use the proper media types once 2665 * they're added. 2666 */ 2667 if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) 2668 switch (adapter->link_speed) { 2669 case IXGBE_LINK_SPEED_10GB_FULL: 2670 #ifndef IFM_ETH_XTYPE 2671 ifmr->ifm_active |= IFM_10G_SR | IFM_FDX; 2672 #else 2673 ifmr->ifm_active |= IFM_10G_KR | IFM_FDX; 2674 #endif 2675 break; 2676 case IXGBE_LINK_SPEED_2_5GB_FULL: 2677 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2678 break; 2679 case IXGBE_LINK_SPEED_1GB_FULL: 2680 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2681 break; 2682 } 2683 else if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4 || 2684 layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX || 2685 layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) 2686 switch (adapter->link_speed) { 2687 case IXGBE_LINK_SPEED_10GB_FULL: 2688 #ifndef IFM_ETH_XTYPE 2689 ifmr->ifm_active |= IFM_10G_CX4 | IFM_FDX; 2690 #else 2691 ifmr->ifm_active |= IFM_10G_KX4 | IFM_FDX; 2692 #endif 2693 break; 2694 case IXGBE_LINK_SPEED_2_5GB_FULL: 2695 ifmr->ifm_active |= IFM_2500_KX | IFM_FDX; 2696 break; 2697 case IXGBE_LINK_SPEED_1GB_FULL: 2698 ifmr->ifm_active |= IFM_1000_KX | IFM_FDX; 2699 break; 2700 } 2701 2702 /* If nothing is recognized... */ 2703 #if 0 2704 if (IFM_SUBTYPE(ifmr->ifm_active) == 0) 2705 ifmr->ifm_active |= IFM_UNKNOWN; 2706 #endif 2707 2708 ifp->if_baudrate = ifmedia_baudrate(ifmr->ifm_active); 2709 2710 /* Display current flow control setting used on link */ 2711 if (hw->fc.current_mode == ixgbe_fc_rx_pause || 2712 hw->fc.current_mode == ixgbe_fc_full) 2713 ifmr->ifm_active |= IFM_ETH_RXPAUSE; 2714 if (hw->fc.current_mode == ixgbe_fc_tx_pause || 2715 hw->fc.current_mode == ixgbe_fc_full) 2716 ifmr->ifm_active |= IFM_ETH_TXPAUSE; 2717 2718 IXGBE_CORE_UNLOCK(adapter); 2719 2720 return; 2721 } /* ixgbe_media_status */ 2722 2723 /************************************************************************ 2724 * ixgbe_media_change - Media Ioctl callback 2725 * 2726 * Called when the user changes speed/duplex using 2727 * media/mediopt option with ifconfig. 2728 ************************************************************************/ 2729 static int 2730 ixgbe_media_change(struct ifnet *ifp) 2731 { 2732 struct adapter *adapter = ifp->if_softc; 2733 struct ifmedia *ifm = &adapter->media; 2734 struct ixgbe_hw *hw = &adapter->hw; 2735 ixgbe_link_speed speed = 0; 2736 ixgbe_link_speed link_caps = 0; 2737 bool negotiate = false; 2738 s32 err = IXGBE_NOT_IMPLEMENTED; 2739 2740 INIT_DEBUGOUT("ixgbe_media_change: begin"); 2741 2742 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 2743 return (EINVAL); 2744 2745 if (hw->phy.media_type == ixgbe_media_type_backplane) 2746 return (ENODEV); 2747 2748 /* 2749 * We don't actually need to check against the supported 2750 * media types of the adapter; ifmedia will take care of 2751 * that for us. 2752 */ 2753 switch (IFM_SUBTYPE(ifm->ifm_media)) { 2754 case IFM_AUTO: 2755 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 2756 &negotiate); 2757 if (err != IXGBE_SUCCESS) { 2758 device_printf(adapter->dev, "Unable to determine " 2759 "supported advertise speeds\n"); 2760 return (ENODEV); 2761 } 2762 speed |= link_caps; 2763 break; 2764 case IFM_10G_T: 2765 case IFM_10G_LRM: 2766 case IFM_10G_LR: 2767 case IFM_10G_TWINAX: 2768 #ifndef IFM_ETH_XTYPE 2769 case IFM_10G_SR: /* KR, too */ 2770 case IFM_10G_CX4: /* KX4 */ 2771 #else 2772 case IFM_10G_KR: 2773 case IFM_10G_KX4: 2774 #endif 2775 speed |= IXGBE_LINK_SPEED_10GB_FULL; 2776 break; 2777 case IFM_5000_T: 2778 speed |= IXGBE_LINK_SPEED_5GB_FULL; 2779 break; 2780 case IFM_2500_T: 2781 case IFM_2500_KX: 2782 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 2783 break; 2784 case IFM_1000_T: 2785 case IFM_1000_LX: 2786 case IFM_1000_SX: 2787 case IFM_1000_KX: 2788 speed |= IXGBE_LINK_SPEED_1GB_FULL; 2789 break; 2790 case IFM_100_TX: 2791 speed |= IXGBE_LINK_SPEED_100_FULL; 2792 break; 2793 case IFM_10_T: 2794 speed |= IXGBE_LINK_SPEED_10_FULL; 2795 break; 2796 default: 2797 goto invalid; 2798 } 2799 2800 hw->mac.autotry_restart = TRUE; 2801 hw->mac.ops.setup_link(hw, speed, TRUE); 2802 adapter->advertise = 0; 2803 if (IFM_SUBTYPE(ifm->ifm_media) != IFM_AUTO) { 2804 if ((speed & IXGBE_LINK_SPEED_10GB_FULL) != 0) 2805 adapter->advertise |= 1 << 2; 2806 if ((speed & IXGBE_LINK_SPEED_1GB_FULL) != 0) 2807 adapter->advertise |= 1 << 1; 2808 if ((speed & IXGBE_LINK_SPEED_100_FULL) != 0) 2809 adapter->advertise |= 1 << 0; 2810 if ((speed & IXGBE_LINK_SPEED_10_FULL) != 0) 2811 adapter->advertise |= 1 << 3; 2812 if ((speed & IXGBE_LINK_SPEED_2_5GB_FULL) != 0) 2813 adapter->advertise |= 1 << 4; 2814 if ((speed & IXGBE_LINK_SPEED_5GB_FULL) != 0) 2815 adapter->advertise |= 1 << 5; 2816 } 2817 2818 return (0); 2819 2820 invalid: 2821 device_printf(adapter->dev, "Invalid media type!\n"); 2822 2823 return (EINVAL); 2824 } /* ixgbe_media_change */ 2825 2826 /************************************************************************ 2827 * ixgbe_set_promisc 2828 ************************************************************************/ 2829 static void 2830 ixgbe_set_promisc(struct adapter *adapter) 2831 { 2832 struct ifnet *ifp = adapter->ifp; 2833 int mcnt = 0; 2834 u32 rctl; 2835 struct ether_multi *enm; 2836 struct ether_multistep step; 2837 struct ethercom *ec = &adapter->osdep.ec; 2838 2839 KASSERT(mutex_owned(&adapter->core_mtx)); 2840 rctl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 2841 rctl &= (~IXGBE_FCTRL_UPE); 2842 if (ifp->if_flags & IFF_ALLMULTI) 2843 mcnt = MAX_NUM_MULTICAST_ADDRESSES; 2844 else { 2845 ETHER_LOCK(ec); 2846 ETHER_FIRST_MULTI(step, ec, enm); 2847 while (enm != NULL) { 2848 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) 2849 break; 2850 mcnt++; 2851 ETHER_NEXT_MULTI(step, enm); 2852 } 2853 ETHER_UNLOCK(ec); 2854 } 2855 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) 2856 rctl &= (~IXGBE_FCTRL_MPE); 2857 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2858 2859 if (ifp->if_flags & IFF_PROMISC) { 2860 rctl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 2861 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2862 } else if (ifp->if_flags & IFF_ALLMULTI) { 2863 rctl |= IXGBE_FCTRL_MPE; 2864 rctl &= ~IXGBE_FCTRL_UPE; 2865 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl); 2866 } 2867 } /* ixgbe_set_promisc */ 2868 2869 /************************************************************************ 2870 * ixgbe_msix_link - Link status change ISR (MSI/MSI-X) 2871 ************************************************************************/ 2872 static int 2873 ixgbe_msix_link(void *arg) 2874 { 2875 struct adapter *adapter = arg; 2876 struct ixgbe_hw *hw = &adapter->hw; 2877 u32 eicr, eicr_mask; 2878 s32 retval; 2879 2880 ++adapter->link_irq.ev_count; 2881 2882 /* Pause other interrupts */ 2883 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_OTHER); 2884 2885 /* First get the cause */ 2886 /* 2887 * The specifications of 82598, 82599, X540 and X550 say EICS register 2888 * is write only. However, Linux says it is a workaround for silicon 2889 * errata to read EICS instead of EICR to get interrupt cause. It seems 2890 * there is a problem about read clear mechanism for EICR register. 2891 */ 2892 eicr = IXGBE_READ_REG(hw, IXGBE_EICS); 2893 /* Be sure the queue bits are not cleared */ 2894 eicr &= ~IXGBE_EICR_RTX_QUEUE; 2895 /* Clear interrupt with write */ 2896 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr); 2897 2898 /* Link status change */ 2899 if (eicr & IXGBE_EICR_LSC) { 2900 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); 2901 softint_schedule(adapter->link_si); 2902 } 2903 2904 if (adapter->hw.mac.type != ixgbe_mac_82598EB) { 2905 if ((adapter->feat_en & IXGBE_FEATURE_FDIR) && 2906 (eicr & IXGBE_EICR_FLOW_DIR)) { 2907 /* This is probably overkill :) */ 2908 if (!atomic_cas_uint(&adapter->fdir_reinit, 0, 1)) 2909 return 1; 2910 /* Disable the interrupt */ 2911 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_FLOW_DIR); 2912 softint_schedule(adapter->fdir_si); 2913 } 2914 2915 if (eicr & IXGBE_EICR_ECC) { 2916 device_printf(adapter->dev, 2917 "CRITICAL: ECC ERROR!! Please Reboot!!\n"); 2918 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC); 2919 } 2920 2921 /* Check for over temp condition */ 2922 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) { 2923 switch (adapter->hw.mac.type) { 2924 case ixgbe_mac_X550EM_a: 2925 if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a)) 2926 break; 2927 IXGBE_WRITE_REG(hw, IXGBE_EIMC, 2928 IXGBE_EICR_GPI_SDP0_X550EM_a); 2929 IXGBE_WRITE_REG(hw, IXGBE_EICR, 2930 IXGBE_EICR_GPI_SDP0_X550EM_a); 2931 retval = hw->phy.ops.check_overtemp(hw); 2932 if (retval != IXGBE_ERR_OVERTEMP) 2933 break; 2934 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 2935 device_printf(adapter->dev, "System shutdown required!\n"); 2936 break; 2937 default: 2938 if (!(eicr & IXGBE_EICR_TS)) 2939 break; 2940 retval = hw->phy.ops.check_overtemp(hw); 2941 if (retval != IXGBE_ERR_OVERTEMP) 2942 break; 2943 device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n"); 2944 device_printf(adapter->dev, "System shutdown required!\n"); 2945 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS); 2946 break; 2947 } 2948 } 2949 2950 /* Check for VF message */ 2951 if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) && 2952 (eicr & IXGBE_EICR_MAILBOX)) 2953 softint_schedule(adapter->mbx_si); 2954 } 2955 2956 if (ixgbe_is_sfp(hw)) { 2957 /* Pluggable optics-related interrupt */ 2958 if (hw->mac.type >= ixgbe_mac_X540) 2959 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 2960 else 2961 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 2962 2963 if (eicr & eicr_mask) { 2964 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 2965 softint_schedule(adapter->mod_si); 2966 } 2967 2968 if ((hw->mac.type == ixgbe_mac_82599EB) && 2969 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 2970 IXGBE_WRITE_REG(hw, IXGBE_EICR, 2971 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 2972 softint_schedule(adapter->msf_si); 2973 } 2974 } 2975 2976 /* Check for fan failure */ 2977 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 2978 ixgbe_check_fan_failure(adapter, eicr, TRUE); 2979 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 2980 } 2981 2982 /* External PHY interrupt */ 2983 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 2984 (eicr & IXGBE_EICR_GPI_SDP0_X540)) { 2985 IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540); 2986 softint_schedule(adapter->phy_si); 2987 } 2988 2989 /* Re-enable other interrupts */ 2990 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER); 2991 return 1; 2992 } /* ixgbe_msix_link */ 2993 2994 static void 2995 ixgbe_eitr_write(struct ix_queue *que, uint32_t itr) 2996 { 2997 struct adapter *adapter = que->adapter; 2998 2999 if (adapter->hw.mac.type == ixgbe_mac_82598EB) 3000 itr |= itr << 16; 3001 else 3002 itr |= IXGBE_EITR_CNT_WDIS; 3003 3004 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(que->msix), 3005 itr); 3006 } 3007 3008 3009 /************************************************************************ 3010 * ixgbe_sysctl_interrupt_rate_handler 3011 ************************************************************************/ 3012 static int 3013 ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_ARGS) 3014 { 3015 struct sysctlnode node = *rnode; 3016 struct ix_queue *que = (struct ix_queue *)node.sysctl_data; 3017 struct adapter *adapter = que->adapter; 3018 uint32_t reg, usec, rate; 3019 int error; 3020 3021 if (que == NULL) 3022 return 0; 3023 reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_EITR(que->msix)); 3024 usec = ((reg & 0x0FF8) >> 3); 3025 if (usec > 0) 3026 rate = 500000 / usec; 3027 else 3028 rate = 0; 3029 node.sysctl_data = &rate; 3030 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 3031 if (error || newp == NULL) 3032 return error; 3033 reg &= ~0xfff; /* default, no limitation */ 3034 if (rate > 0 && rate < 500000) { 3035 if (rate < 1000) 3036 rate = 1000; 3037 reg |= ((4000000/rate) & 0xff8); 3038 /* 3039 * When RSC is used, ITR interval must be larger than 3040 * RSC_DELAY. Currently, we use 2us for RSC_DELAY. 3041 * The minimum value is always greater than 2us on 100M 3042 * (and 10M?(not documented)), but it's not on 1G and higher. 3043 */ 3044 if ((adapter->link_speed != IXGBE_LINK_SPEED_100_FULL) 3045 && (adapter->link_speed != IXGBE_LINK_SPEED_10_FULL)) { 3046 if ((adapter->num_queues > 1) 3047 && (reg < IXGBE_MIN_RSC_EITR_10G1G)) 3048 return EINVAL; 3049 } 3050 ixgbe_max_interrupt_rate = rate; 3051 } else 3052 ixgbe_max_interrupt_rate = 0; 3053 ixgbe_eitr_write(que, reg); 3054 3055 return (0); 3056 } /* ixgbe_sysctl_interrupt_rate_handler */ 3057 3058 const struct sysctlnode * 3059 ixgbe_sysctl_instance(struct adapter *adapter) 3060 { 3061 const char *dvname; 3062 struct sysctllog **log; 3063 int rc; 3064 const struct sysctlnode *rnode; 3065 3066 if (adapter->sysctltop != NULL) 3067 return adapter->sysctltop; 3068 3069 log = &adapter->sysctllog; 3070 dvname = device_xname(adapter->dev); 3071 3072 if ((rc = sysctl_createv(log, 0, NULL, &rnode, 3073 0, CTLTYPE_NODE, dvname, 3074 SYSCTL_DESCR("ixgbe information and settings"), 3075 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) 3076 goto err; 3077 3078 return rnode; 3079 err: 3080 printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc); 3081 return NULL; 3082 } 3083 3084 /************************************************************************ 3085 * ixgbe_add_device_sysctls 3086 ************************************************************************/ 3087 static void 3088 ixgbe_add_device_sysctls(struct adapter *adapter) 3089 { 3090 device_t dev = adapter->dev; 3091 struct ixgbe_hw *hw = &adapter->hw; 3092 struct sysctllog **log; 3093 const struct sysctlnode *rnode, *cnode; 3094 3095 log = &adapter->sysctllog; 3096 3097 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 3098 aprint_error_dev(dev, "could not create sysctl root\n"); 3099 return; 3100 } 3101 3102 if (sysctl_createv(log, 0, &rnode, &cnode, 3103 CTLFLAG_READONLY, CTLTYPE_INT, 3104 "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"), 3105 NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0) 3106 aprint_error_dev(dev, "could not create sysctl\n"); 3107 3108 if (sysctl_createv(log, 0, &rnode, &cnode, 3109 CTLFLAG_READONLY, CTLTYPE_INT, 3110 "num_queues", SYSCTL_DESCR("Number of queues"), 3111 NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0) 3112 aprint_error_dev(dev, "could not create sysctl\n"); 3113 3114 /* Sysctls for all devices */ 3115 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3116 CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC), 3117 ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE, 3118 CTL_EOL) != 0) 3119 aprint_error_dev(dev, "could not create sysctl\n"); 3120 3121 adapter->enable_aim = ixgbe_enable_aim; 3122 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3123 CTLTYPE_BOOL, "enable_aim", SYSCTL_DESCR("Interrupt Moderation"), 3124 NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0) 3125 aprint_error_dev(dev, "could not create sysctl\n"); 3126 3127 if (sysctl_createv(log, 0, &rnode, &cnode, 3128 CTLFLAG_READWRITE, CTLTYPE_INT, 3129 "advertise_speed", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_ADV_SPEED), 3130 ixgbe_sysctl_advertise, 0, (void *)adapter, 0, CTL_CREATE, 3131 CTL_EOL) != 0) 3132 aprint_error_dev(dev, "could not create sysctl\n"); 3133 3134 adapter->txrx_use_workqueue = ixgbe_txrx_workqueue; 3135 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3136 CTLTYPE_BOOL, "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"), 3137 NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0) 3138 aprint_error_dev(dev, "could not create sysctl\n"); 3139 3140 #ifdef IXGBE_DEBUG 3141 /* testing sysctls (for all devices) */ 3142 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3143 CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"), 3144 ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE, 3145 CTL_EOL) != 0) 3146 aprint_error_dev(dev, "could not create sysctl\n"); 3147 3148 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY, 3149 CTLTYPE_STRING, "print_rss_config", 3150 SYSCTL_DESCR("Prints RSS Configuration"), 3151 ixgbe_sysctl_print_rss_config, 0, (void *)adapter, 0, CTL_CREATE, 3152 CTL_EOL) != 0) 3153 aprint_error_dev(dev, "could not create sysctl\n"); 3154 #endif 3155 /* for X550 series devices */ 3156 if (hw->mac.type >= ixgbe_mac_X550) 3157 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3158 CTLTYPE_INT, "dmac", SYSCTL_DESCR("DMA Coalesce"), 3159 ixgbe_sysctl_dmac, 0, (void *)adapter, 0, CTL_CREATE, 3160 CTL_EOL) != 0) 3161 aprint_error_dev(dev, "could not create sysctl\n"); 3162 3163 /* for WoL-capable devices */ 3164 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3165 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3166 CTLTYPE_BOOL, "wol_enable", 3167 SYSCTL_DESCR("Enable/Disable Wake on LAN"), 3168 ixgbe_sysctl_wol_enable, 0, (void *)adapter, 0, CTL_CREATE, 3169 CTL_EOL) != 0) 3170 aprint_error_dev(dev, "could not create sysctl\n"); 3171 3172 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3173 CTLTYPE_INT, "wufc", 3174 SYSCTL_DESCR("Enable/Disable Wake Up Filters"), 3175 ixgbe_sysctl_wufc, 0, (void *)adapter, 0, CTL_CREATE, 3176 CTL_EOL) != 0) 3177 aprint_error_dev(dev, "could not create sysctl\n"); 3178 } 3179 3180 /* for X552/X557-AT devices */ 3181 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) { 3182 const struct sysctlnode *phy_node; 3183 3184 if (sysctl_createv(log, 0, &rnode, &phy_node, 0, CTLTYPE_NODE, 3185 "phy", SYSCTL_DESCR("External PHY sysctls"), 3186 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0) { 3187 aprint_error_dev(dev, "could not create sysctl\n"); 3188 return; 3189 } 3190 3191 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3192 CTLTYPE_INT, "temp", 3193 SYSCTL_DESCR("Current External PHY Temperature (Celsius)"), 3194 ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE, 3195 CTL_EOL) != 0) 3196 aprint_error_dev(dev, "could not create sysctl\n"); 3197 3198 if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY, 3199 CTLTYPE_INT, "overtemp_occurred", 3200 SYSCTL_DESCR("External PHY High Temperature Event Occurred"), 3201 ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0, 3202 CTL_CREATE, CTL_EOL) != 0) 3203 aprint_error_dev(dev, "could not create sysctl\n"); 3204 } 3205 3206 if (adapter->feat_cap & IXGBE_FEATURE_EEE) { 3207 if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE, 3208 CTLTYPE_INT, "eee_state", 3209 SYSCTL_DESCR("EEE Power Save State"), 3210 ixgbe_sysctl_eee_state, 0, (void *)adapter, 0, CTL_CREATE, 3211 CTL_EOL) != 0) 3212 aprint_error_dev(dev, "could not create sysctl\n"); 3213 } 3214 } /* ixgbe_add_device_sysctls */ 3215 3216 /************************************************************************ 3217 * ixgbe_allocate_pci_resources 3218 ************************************************************************/ 3219 static int 3220 ixgbe_allocate_pci_resources(struct adapter *adapter, 3221 const struct pci_attach_args *pa) 3222 { 3223 pcireg_t memtype; 3224 device_t dev = adapter->dev; 3225 bus_addr_t addr; 3226 int flags; 3227 3228 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR(0)); 3229 switch (memtype) { 3230 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT: 3231 case PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT: 3232 adapter->osdep.mem_bus_space_tag = pa->pa_memt; 3233 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, PCI_BAR(0), 3234 memtype, &addr, &adapter->osdep.mem_size, &flags) != 0) 3235 goto map_err; 3236 if ((flags & BUS_SPACE_MAP_PREFETCHABLE) != 0) { 3237 aprint_normal_dev(dev, "clearing prefetchable bit\n"); 3238 flags &= ~BUS_SPACE_MAP_PREFETCHABLE; 3239 } 3240 if (bus_space_map(adapter->osdep.mem_bus_space_tag, addr, 3241 adapter->osdep.mem_size, flags, 3242 &adapter->osdep.mem_bus_space_handle) != 0) { 3243 map_err: 3244 adapter->osdep.mem_size = 0; 3245 aprint_error_dev(dev, "unable to map BAR0\n"); 3246 return ENXIO; 3247 } 3248 break; 3249 default: 3250 aprint_error_dev(dev, "unexpected type on BAR0\n"); 3251 return ENXIO; 3252 } 3253 3254 return (0); 3255 } /* ixgbe_allocate_pci_resources */ 3256 3257 static void 3258 ixgbe_free_softint(struct adapter *adapter) 3259 { 3260 struct ix_queue *que = adapter->queues; 3261 struct tx_ring *txr = adapter->tx_rings; 3262 int i; 3263 3264 for (i = 0; i < adapter->num_queues; i++, que++, txr++) { 3265 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 3266 if (txr->txr_si != NULL) 3267 softint_disestablish(txr->txr_si); 3268 } 3269 if (que->que_si != NULL) 3270 softint_disestablish(que->que_si); 3271 } 3272 if (adapter->txr_wq != NULL) 3273 workqueue_destroy(adapter->txr_wq); 3274 if (adapter->txr_wq_enqueued != NULL) 3275 percpu_free(adapter->txr_wq_enqueued, sizeof(u_int)); 3276 if (adapter->que_wq != NULL) 3277 workqueue_destroy(adapter->que_wq); 3278 3279 /* Drain the Link queue */ 3280 if (adapter->link_si != NULL) { 3281 softint_disestablish(adapter->link_si); 3282 adapter->link_si = NULL; 3283 } 3284 if (adapter->mod_si != NULL) { 3285 softint_disestablish(adapter->mod_si); 3286 adapter->mod_si = NULL; 3287 } 3288 if (adapter->msf_si != NULL) { 3289 softint_disestablish(adapter->msf_si); 3290 adapter->msf_si = NULL; 3291 } 3292 if (adapter->phy_si != NULL) { 3293 softint_disestablish(adapter->phy_si); 3294 adapter->phy_si = NULL; 3295 } 3296 if (adapter->feat_en & IXGBE_FEATURE_FDIR) { 3297 if (adapter->fdir_si != NULL) { 3298 softint_disestablish(adapter->fdir_si); 3299 adapter->fdir_si = NULL; 3300 } 3301 } 3302 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 3303 if (adapter->mbx_si != NULL) { 3304 softint_disestablish(adapter->mbx_si); 3305 adapter->mbx_si = NULL; 3306 } 3307 } 3308 } /* ixgbe_free_softint */ 3309 3310 /************************************************************************ 3311 * ixgbe_detach - Device removal routine 3312 * 3313 * Called when the driver is being removed. 3314 * Stops the adapter and deallocates all the resources 3315 * that were allocated for driver operation. 3316 * 3317 * return 0 on success, positive on failure 3318 ************************************************************************/ 3319 static int 3320 ixgbe_detach(device_t dev, int flags) 3321 { 3322 struct adapter *adapter = device_private(dev); 3323 struct rx_ring *rxr = adapter->rx_rings; 3324 struct tx_ring *txr = adapter->tx_rings; 3325 struct ixgbe_hw *hw = &adapter->hw; 3326 struct ixgbe_hw_stats *stats = &adapter->stats.pf; 3327 u32 ctrl_ext; 3328 3329 INIT_DEBUGOUT("ixgbe_detach: begin"); 3330 if (adapter->osdep.attached == false) 3331 return 0; 3332 3333 if (ixgbe_pci_iov_detach(dev) != 0) { 3334 device_printf(dev, "SR-IOV in use; detach first.\n"); 3335 return (EBUSY); 3336 } 3337 3338 /* Stop the interface. Callouts are stopped in it. */ 3339 ixgbe_ifstop(adapter->ifp, 1); 3340 #if NVLAN > 0 3341 /* Make sure VLANs are not using driver */ 3342 if (!VLAN_ATTACHED(&adapter->osdep.ec)) 3343 ; /* nothing to do: no VLANs */ 3344 else if ((flags & (DETACH_SHUTDOWN|DETACH_FORCE)) != 0) 3345 vlan_ifdetach(adapter->ifp); 3346 else { 3347 aprint_error_dev(dev, "VLANs in use, detach first\n"); 3348 return (EBUSY); 3349 } 3350 #endif 3351 3352 pmf_device_deregister(dev); 3353 3354 ether_ifdetach(adapter->ifp); 3355 /* Stop the adapter */ 3356 IXGBE_CORE_LOCK(adapter); 3357 ixgbe_setup_low_power_mode(adapter); 3358 IXGBE_CORE_UNLOCK(adapter); 3359 3360 ixgbe_free_softint(adapter); 3361 3362 /* let hardware know driver is unloading */ 3363 ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT); 3364 ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD; 3365 IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext); 3366 3367 callout_halt(&adapter->timer, NULL); 3368 3369 if (adapter->feat_en & IXGBE_FEATURE_NETMAP) 3370 netmap_detach(adapter->ifp); 3371 3372 ixgbe_free_pci_resources(adapter); 3373 #if 0 /* XXX the NetBSD port is probably missing something here */ 3374 bus_generic_detach(dev); 3375 #endif 3376 if_detach(adapter->ifp); 3377 if_percpuq_destroy(adapter->ipq); 3378 3379 sysctl_teardown(&adapter->sysctllog); 3380 evcnt_detach(&adapter->efbig_tx_dma_setup); 3381 evcnt_detach(&adapter->mbuf_defrag_failed); 3382 evcnt_detach(&adapter->efbig2_tx_dma_setup); 3383 evcnt_detach(&adapter->einval_tx_dma_setup); 3384 evcnt_detach(&adapter->other_tx_dma_setup); 3385 evcnt_detach(&adapter->eagain_tx_dma_setup); 3386 evcnt_detach(&adapter->enomem_tx_dma_setup); 3387 evcnt_detach(&adapter->watchdog_events); 3388 evcnt_detach(&adapter->tso_err); 3389 evcnt_detach(&adapter->link_irq); 3390 3391 txr = adapter->tx_rings; 3392 for (int i = 0; i < adapter->num_queues; i++, rxr++, txr++) { 3393 evcnt_detach(&adapter->queues[i].irqs); 3394 evcnt_detach(&adapter->queues[i].handleq); 3395 evcnt_detach(&adapter->queues[i].req); 3396 evcnt_detach(&txr->no_desc_avail); 3397 evcnt_detach(&txr->total_packets); 3398 evcnt_detach(&txr->tso_tx); 3399 #ifndef IXGBE_LEGACY_TX 3400 evcnt_detach(&txr->pcq_drops); 3401 #endif 3402 3403 if (i < __arraycount(stats->mpc)) { 3404 evcnt_detach(&stats->mpc[i]); 3405 if (hw->mac.type == ixgbe_mac_82598EB) 3406 evcnt_detach(&stats->rnbc[i]); 3407 } 3408 if (i < __arraycount(stats->pxontxc)) { 3409 evcnt_detach(&stats->pxontxc[i]); 3410 evcnt_detach(&stats->pxonrxc[i]); 3411 evcnt_detach(&stats->pxofftxc[i]); 3412 evcnt_detach(&stats->pxoffrxc[i]); 3413 evcnt_detach(&stats->pxon2offc[i]); 3414 } 3415 if (i < __arraycount(stats->qprc)) { 3416 evcnt_detach(&stats->qprc[i]); 3417 evcnt_detach(&stats->qptc[i]); 3418 evcnt_detach(&stats->qbrc[i]); 3419 evcnt_detach(&stats->qbtc[i]); 3420 evcnt_detach(&stats->qprdc[i]); 3421 } 3422 3423 evcnt_detach(&rxr->rx_packets); 3424 evcnt_detach(&rxr->rx_bytes); 3425 evcnt_detach(&rxr->rx_copies); 3426 evcnt_detach(&rxr->no_jmbuf); 3427 evcnt_detach(&rxr->rx_discarded); 3428 } 3429 evcnt_detach(&stats->ipcs); 3430 evcnt_detach(&stats->l4cs); 3431 evcnt_detach(&stats->ipcs_bad); 3432 evcnt_detach(&stats->l4cs_bad); 3433 evcnt_detach(&stats->intzero); 3434 evcnt_detach(&stats->legint); 3435 evcnt_detach(&stats->crcerrs); 3436 evcnt_detach(&stats->illerrc); 3437 evcnt_detach(&stats->errbc); 3438 evcnt_detach(&stats->mspdc); 3439 if (hw->mac.type >= ixgbe_mac_X550) 3440 evcnt_detach(&stats->mbsdc); 3441 evcnt_detach(&stats->mpctotal); 3442 evcnt_detach(&stats->mlfc); 3443 evcnt_detach(&stats->mrfc); 3444 evcnt_detach(&stats->rlec); 3445 evcnt_detach(&stats->lxontxc); 3446 evcnt_detach(&stats->lxonrxc); 3447 evcnt_detach(&stats->lxofftxc); 3448 evcnt_detach(&stats->lxoffrxc); 3449 3450 /* Packet Reception Stats */ 3451 evcnt_detach(&stats->tor); 3452 evcnt_detach(&stats->gorc); 3453 evcnt_detach(&stats->tpr); 3454 evcnt_detach(&stats->gprc); 3455 evcnt_detach(&stats->mprc); 3456 evcnt_detach(&stats->bprc); 3457 evcnt_detach(&stats->prc64); 3458 evcnt_detach(&stats->prc127); 3459 evcnt_detach(&stats->prc255); 3460 evcnt_detach(&stats->prc511); 3461 evcnt_detach(&stats->prc1023); 3462 evcnt_detach(&stats->prc1522); 3463 evcnt_detach(&stats->ruc); 3464 evcnt_detach(&stats->rfc); 3465 evcnt_detach(&stats->roc); 3466 evcnt_detach(&stats->rjc); 3467 evcnt_detach(&stats->mngprc); 3468 evcnt_detach(&stats->mngpdc); 3469 evcnt_detach(&stats->xec); 3470 3471 /* Packet Transmission Stats */ 3472 evcnt_detach(&stats->gotc); 3473 evcnt_detach(&stats->tpt); 3474 evcnt_detach(&stats->gptc); 3475 evcnt_detach(&stats->bptc); 3476 evcnt_detach(&stats->mptc); 3477 evcnt_detach(&stats->mngptc); 3478 evcnt_detach(&stats->ptc64); 3479 evcnt_detach(&stats->ptc127); 3480 evcnt_detach(&stats->ptc255); 3481 evcnt_detach(&stats->ptc511); 3482 evcnt_detach(&stats->ptc1023); 3483 evcnt_detach(&stats->ptc1522); 3484 3485 ixgbe_free_transmit_structures(adapter); 3486 ixgbe_free_receive_structures(adapter); 3487 for (int i = 0; i < adapter->num_queues; i++) { 3488 struct ix_queue * que = &adapter->queues[i]; 3489 mutex_destroy(&que->im_mtx); 3490 } 3491 free(adapter->queues, M_DEVBUF); 3492 free(adapter->mta, M_DEVBUF); 3493 3494 IXGBE_CORE_LOCK_DESTROY(adapter); 3495 3496 return (0); 3497 } /* ixgbe_detach */ 3498 3499 /************************************************************************ 3500 * ixgbe_setup_low_power_mode - LPLU/WoL preparation 3501 * 3502 * Prepare the adapter/port for LPLU and/or WoL 3503 ************************************************************************/ 3504 static int 3505 ixgbe_setup_low_power_mode(struct adapter *adapter) 3506 { 3507 struct ixgbe_hw *hw = &adapter->hw; 3508 device_t dev = adapter->dev; 3509 s32 error = 0; 3510 3511 KASSERT(mutex_owned(&adapter->core_mtx)); 3512 3513 /* Limit power management flow to X550EM baseT */ 3514 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T && 3515 hw->phy.ops.enter_lplu) { 3516 /* X550EM baseT adapters need a special LPLU flow */ 3517 hw->phy.reset_disable = true; 3518 ixgbe_stop(adapter); 3519 error = hw->phy.ops.enter_lplu(hw); 3520 if (error) 3521 device_printf(dev, 3522 "Error entering LPLU: %d\n", error); 3523 hw->phy.reset_disable = false; 3524 } else { 3525 /* Just stop for other adapters */ 3526 ixgbe_stop(adapter); 3527 } 3528 3529 if (!hw->wol_enabled) { 3530 ixgbe_set_phy_power(hw, FALSE); 3531 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3532 IXGBE_WRITE_REG(hw, IXGBE_WUC, 0); 3533 } else { 3534 /* Turn off support for APM wakeup. (Using ACPI instead) */ 3535 IXGBE_WRITE_REG(hw, IXGBE_GRC, 3536 IXGBE_READ_REG(hw, IXGBE_GRC) & ~(u32)2); 3537 3538 /* 3539 * Clear Wake Up Status register to prevent any previous wakeup 3540 * events from waking us up immediately after we suspend. 3541 */ 3542 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3543 3544 /* 3545 * Program the Wakeup Filter Control register with user filter 3546 * settings 3547 */ 3548 IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc); 3549 3550 /* Enable wakeups and power management in Wakeup Control */ 3551 IXGBE_WRITE_REG(hw, IXGBE_WUC, 3552 IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN); 3553 3554 } 3555 3556 return error; 3557 } /* ixgbe_setup_low_power_mode */ 3558 3559 /************************************************************************ 3560 * ixgbe_shutdown - Shutdown entry point 3561 ************************************************************************/ 3562 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */ 3563 static int 3564 ixgbe_shutdown(device_t dev) 3565 { 3566 struct adapter *adapter = device_private(dev); 3567 int error = 0; 3568 3569 INIT_DEBUGOUT("ixgbe_shutdown: begin"); 3570 3571 IXGBE_CORE_LOCK(adapter); 3572 error = ixgbe_setup_low_power_mode(adapter); 3573 IXGBE_CORE_UNLOCK(adapter); 3574 3575 return (error); 3576 } /* ixgbe_shutdown */ 3577 #endif 3578 3579 /************************************************************************ 3580 * ixgbe_suspend 3581 * 3582 * From D0 to D3 3583 ************************************************************************/ 3584 static bool 3585 ixgbe_suspend(device_t dev, const pmf_qual_t *qual) 3586 { 3587 struct adapter *adapter = device_private(dev); 3588 int error = 0; 3589 3590 INIT_DEBUGOUT("ixgbe_suspend: begin"); 3591 3592 IXGBE_CORE_LOCK(adapter); 3593 3594 error = ixgbe_setup_low_power_mode(adapter); 3595 3596 IXGBE_CORE_UNLOCK(adapter); 3597 3598 return (error); 3599 } /* ixgbe_suspend */ 3600 3601 /************************************************************************ 3602 * ixgbe_resume 3603 * 3604 * From D3 to D0 3605 ************************************************************************/ 3606 static bool 3607 ixgbe_resume(device_t dev, const pmf_qual_t *qual) 3608 { 3609 struct adapter *adapter = device_private(dev); 3610 struct ifnet *ifp = adapter->ifp; 3611 struct ixgbe_hw *hw = &adapter->hw; 3612 u32 wus; 3613 3614 INIT_DEBUGOUT("ixgbe_resume: begin"); 3615 3616 IXGBE_CORE_LOCK(adapter); 3617 3618 /* Read & clear WUS register */ 3619 wus = IXGBE_READ_REG(hw, IXGBE_WUS); 3620 if (wus) 3621 device_printf(dev, "Woken up by (WUS): %#010x\n", 3622 IXGBE_READ_REG(hw, IXGBE_WUS)); 3623 IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff); 3624 /* And clear WUFC until next low-power transition */ 3625 IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0); 3626 3627 /* 3628 * Required after D3->D0 transition; 3629 * will re-advertise all previous advertised speeds 3630 */ 3631 if (ifp->if_flags & IFF_UP) 3632 ixgbe_init_locked(adapter); 3633 3634 IXGBE_CORE_UNLOCK(adapter); 3635 3636 return true; 3637 } /* ixgbe_resume */ 3638 3639 /* 3640 * Set the various hardware offload abilities. 3641 * 3642 * This takes the ifnet's if_capenable flags (e.g. set by the user using 3643 * ifconfig) and indicates to the OS via the ifnet's if_hwassist field what 3644 * mbuf offload flags the driver will understand. 3645 */ 3646 static void 3647 ixgbe_set_if_hwassist(struct adapter *adapter) 3648 { 3649 /* XXX */ 3650 } 3651 3652 /************************************************************************ 3653 * ixgbe_init_locked - Init entry point 3654 * 3655 * Used in two ways: It is used by the stack as an init 3656 * entry point in network interface structure. It is also 3657 * used by the driver as a hw/sw initialization routine to 3658 * get to a consistent state. 3659 * 3660 * return 0 on success, positive on failure 3661 ************************************************************************/ 3662 static void 3663 ixgbe_init_locked(struct adapter *adapter) 3664 { 3665 struct ifnet *ifp = adapter->ifp; 3666 device_t dev = adapter->dev; 3667 struct ixgbe_hw *hw = &adapter->hw; 3668 struct tx_ring *txr; 3669 struct rx_ring *rxr; 3670 u32 txdctl, mhadd; 3671 u32 rxdctl, rxctrl; 3672 u32 ctrl_ext; 3673 int err = 0; 3674 3675 /* XXX check IFF_UP and IFF_RUNNING, power-saving state! */ 3676 3677 KASSERT(mutex_owned(&adapter->core_mtx)); 3678 INIT_DEBUGOUT("ixgbe_init_locked: begin"); 3679 3680 hw->adapter_stopped = FALSE; 3681 ixgbe_stop_adapter(hw); 3682 callout_stop(&adapter->timer); 3683 3684 /* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */ 3685 adapter->max_frame_size = 3686 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 3687 3688 /* Queue indices may change with IOV mode */ 3689 ixgbe_align_all_queue_indices(adapter); 3690 3691 /* reprogram the RAR[0] in case user changed it. */ 3692 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV); 3693 3694 /* Get the latest mac address, User can use a LAA */ 3695 memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl), 3696 IXGBE_ETH_LENGTH_OF_ADDRESS); 3697 ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1); 3698 hw->addr_ctrl.rar_used_count = 1; 3699 3700 /* Set hardware offload abilities from ifnet flags */ 3701 ixgbe_set_if_hwassist(adapter); 3702 3703 /* Prepare transmit descriptors and buffers */ 3704 if (ixgbe_setup_transmit_structures(adapter)) { 3705 device_printf(dev, "Could not setup transmit structures\n"); 3706 ixgbe_stop(adapter); 3707 return; 3708 } 3709 3710 ixgbe_init_hw(hw); 3711 ixgbe_initialize_iov(adapter); 3712 ixgbe_initialize_transmit_units(adapter); 3713 3714 /* Setup Multicast table */ 3715 ixgbe_set_multi(adapter); 3716 3717 /* Determine the correct mbuf pool, based on frame size */ 3718 if (adapter->max_frame_size <= MCLBYTES) 3719 adapter->rx_mbuf_sz = MCLBYTES; 3720 else 3721 adapter->rx_mbuf_sz = MJUMPAGESIZE; 3722 3723 /* Prepare receive descriptors and buffers */ 3724 if (ixgbe_setup_receive_structures(adapter)) { 3725 device_printf(dev, "Could not setup receive structures\n"); 3726 ixgbe_stop(adapter); 3727 return; 3728 } 3729 3730 /* Configure RX settings */ 3731 ixgbe_initialize_receive_units(adapter); 3732 3733 /* Enable SDP & MSI-X interrupts based on adapter */ 3734 ixgbe_config_gpie(adapter); 3735 3736 /* Set MTU size */ 3737 if (ifp->if_mtu > ETHERMTU) { 3738 /* aka IXGBE_MAXFRS on 82599 and newer */ 3739 mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD); 3740 mhadd &= ~IXGBE_MHADD_MFS_MASK; 3741 mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT; 3742 IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd); 3743 } 3744 3745 /* Now enable all the queues */ 3746 for (int i = 0; i < adapter->num_queues; i++) { 3747 txr = &adapter->tx_rings[i]; 3748 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me)); 3749 txdctl |= IXGBE_TXDCTL_ENABLE; 3750 /* Set WTHRESH to 8, burst writeback */ 3751 txdctl |= (8 << 16); 3752 /* 3753 * When the internal queue falls below PTHRESH (32), 3754 * start prefetching as long as there are at least 3755 * HTHRESH (1) buffers ready. The values are taken 3756 * from the Intel linux driver 3.8.21. 3757 * Prefetching enables tx line rate even with 1 queue. 3758 */ 3759 txdctl |= (32 << 0) | (1 << 8); 3760 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl); 3761 } 3762 3763 for (int i = 0, j = 0; i < adapter->num_queues; i++) { 3764 rxr = &adapter->rx_rings[i]; 3765 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)); 3766 if (hw->mac.type == ixgbe_mac_82598EB) { 3767 /* 3768 * PTHRESH = 21 3769 * HTHRESH = 4 3770 * WTHRESH = 8 3771 */ 3772 rxdctl &= ~0x3FFFFF; 3773 rxdctl |= 0x080420; 3774 } 3775 rxdctl |= IXGBE_RXDCTL_ENABLE; 3776 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl); 3777 for (; j < 10; j++) { 3778 if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) & 3779 IXGBE_RXDCTL_ENABLE) 3780 break; 3781 else 3782 msec_delay(1); 3783 } 3784 wmb(); 3785 3786 /* 3787 * In netmap mode, we must preserve the buffers made 3788 * available to userspace before the if_init() 3789 * (this is true by default on the TX side, because 3790 * init makes all buffers available to userspace). 3791 * 3792 * netmap_reset() and the device specific routines 3793 * (e.g. ixgbe_setup_receive_rings()) map these 3794 * buffers at the end of the NIC ring, so here we 3795 * must set the RDT (tail) register to make sure 3796 * they are not overwritten. 3797 * 3798 * In this driver the NIC ring starts at RDH = 0, 3799 * RDT points to the last slot available for reception (?), 3800 * so RDT = num_rx_desc - 1 means the whole ring is available. 3801 */ 3802 #ifdef DEV_NETMAP 3803 if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && 3804 (ifp->if_capenable & IFCAP_NETMAP)) { 3805 struct netmap_adapter *na = NA(adapter->ifp); 3806 struct netmap_kring *kring = &na->rx_rings[i]; 3807 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring); 3808 3809 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t); 3810 } else 3811 #endif /* DEV_NETMAP */ 3812 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), 3813 adapter->num_rx_desc - 1); 3814 } 3815 3816 /* Enable Receive engine */ 3817 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 3818 if (hw->mac.type == ixgbe_mac_82598EB) 3819 rxctrl |= IXGBE_RXCTRL_DMBYPS; 3820 rxctrl |= IXGBE_RXCTRL_RXEN; 3821 ixgbe_enable_rx_dma(hw, rxctrl); 3822 3823 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 3824 3825 /* Set up MSI-X routing */ 3826 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 3827 ixgbe_configure_ivars(adapter); 3828 /* Set up auto-mask */ 3829 if (hw->mac.type == ixgbe_mac_82598EB) 3830 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 3831 else { 3832 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF); 3833 IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF); 3834 } 3835 } else { /* Simple settings for Legacy/MSI */ 3836 ixgbe_set_ivar(adapter, 0, 0, 0); 3837 ixgbe_set_ivar(adapter, 0, 0, 1); 3838 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE); 3839 } 3840 3841 ixgbe_init_fdir(adapter); 3842 3843 /* 3844 * Check on any SFP devices that 3845 * need to be kick-started 3846 */ 3847 if (hw->phy.type == ixgbe_phy_none) { 3848 err = hw->phy.ops.identify(hw); 3849 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 3850 device_printf(dev, 3851 "Unsupported SFP+ module type was detected.\n"); 3852 return; 3853 } 3854 } 3855 3856 /* Set moderation on the Link interrupt */ 3857 IXGBE_WRITE_REG(hw, IXGBE_EITR(adapter->vector), IXGBE_LINK_ITR); 3858 3859 /* Config/Enable Link */ 3860 ixgbe_config_link(adapter); 3861 3862 /* Hardware Packet Buffer & Flow Control setup */ 3863 ixgbe_config_delay_values(adapter); 3864 3865 /* Initialize the FC settings */ 3866 ixgbe_start_hw(hw); 3867 3868 /* Set up VLAN support and filter */ 3869 ixgbe_setup_vlan_hw_support(adapter); 3870 3871 /* Setup DMA Coalescing */ 3872 ixgbe_config_dmac(adapter); 3873 3874 /* And now turn on interrupts */ 3875 ixgbe_enable_intr(adapter); 3876 3877 /* Enable the use of the MBX by the VF's */ 3878 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) { 3879 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 3880 ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD; 3881 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 3882 } 3883 3884 /* Update saved flags. See ixgbe_ifflags_cb() */ 3885 adapter->if_flags = ifp->if_flags; 3886 3887 /* Now inform the stack we're ready */ 3888 ifp->if_flags |= IFF_RUNNING; 3889 3890 return; 3891 } /* ixgbe_init_locked */ 3892 3893 /************************************************************************ 3894 * ixgbe_init 3895 ************************************************************************/ 3896 static int 3897 ixgbe_init(struct ifnet *ifp) 3898 { 3899 struct adapter *adapter = ifp->if_softc; 3900 3901 IXGBE_CORE_LOCK(adapter); 3902 ixgbe_init_locked(adapter); 3903 IXGBE_CORE_UNLOCK(adapter); 3904 3905 return 0; /* XXX ixgbe_init_locked cannot fail? really? */ 3906 } /* ixgbe_init */ 3907 3908 /************************************************************************ 3909 * ixgbe_set_ivar 3910 * 3911 * Setup the correct IVAR register for a particular MSI-X interrupt 3912 * (yes this is all very magic and confusing :) 3913 * - entry is the register array entry 3914 * - vector is the MSI-X vector for this queue 3915 * - type is RX/TX/MISC 3916 ************************************************************************/ 3917 static void 3918 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type) 3919 { 3920 struct ixgbe_hw *hw = &adapter->hw; 3921 u32 ivar, index; 3922 3923 vector |= IXGBE_IVAR_ALLOC_VAL; 3924 3925 switch (hw->mac.type) { 3926 3927 case ixgbe_mac_82598EB: 3928 if (type == -1) 3929 entry = IXGBE_IVAR_OTHER_CAUSES_INDEX; 3930 else 3931 entry += (type * 64); 3932 index = (entry >> 2) & 0x1F; 3933 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index)); 3934 ivar &= ~(0xFF << (8 * (entry & 0x3))); 3935 ivar |= (vector << (8 * (entry & 0x3))); 3936 IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar); 3937 break; 3938 3939 case ixgbe_mac_82599EB: 3940 case ixgbe_mac_X540: 3941 case ixgbe_mac_X550: 3942 case ixgbe_mac_X550EM_x: 3943 case ixgbe_mac_X550EM_a: 3944 if (type == -1) { /* MISC IVAR */ 3945 index = (entry & 1) * 8; 3946 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC); 3947 ivar &= ~(0xFF << index); 3948 ivar |= (vector << index); 3949 IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar); 3950 } else { /* RX/TX IVARS */ 3951 index = (16 * (entry & 1)) + (8 * type); 3952 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1)); 3953 ivar &= ~(0xFF << index); 3954 ivar |= (vector << index); 3955 IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar); 3956 } 3957 3958 default: 3959 break; 3960 } 3961 } /* ixgbe_set_ivar */ 3962 3963 /************************************************************************ 3964 * ixgbe_configure_ivars 3965 ************************************************************************/ 3966 static void 3967 ixgbe_configure_ivars(struct adapter *adapter) 3968 { 3969 struct ix_queue *que = adapter->queues; 3970 u32 newitr; 3971 3972 if (ixgbe_max_interrupt_rate > 0) 3973 newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8; 3974 else { 3975 /* 3976 * Disable DMA coalescing if interrupt moderation is 3977 * disabled. 3978 */ 3979 adapter->dmac = 0; 3980 newitr = 0; 3981 } 3982 3983 for (int i = 0; i < adapter->num_queues; i++, que++) { 3984 struct rx_ring *rxr = &adapter->rx_rings[i]; 3985 struct tx_ring *txr = &adapter->tx_rings[i]; 3986 /* First the RX queue entry */ 3987 ixgbe_set_ivar(adapter, rxr->me, que->msix, 0); 3988 /* ... and the TX */ 3989 ixgbe_set_ivar(adapter, txr->me, que->msix, 1); 3990 /* Set an Initial EITR value */ 3991 ixgbe_eitr_write(que, newitr); 3992 } 3993 3994 /* For the Link interrupt */ 3995 ixgbe_set_ivar(adapter, 1, adapter->vector, -1); 3996 } /* ixgbe_configure_ivars */ 3997 3998 /************************************************************************ 3999 * ixgbe_config_gpie 4000 ************************************************************************/ 4001 static void 4002 ixgbe_config_gpie(struct adapter *adapter) 4003 { 4004 struct ixgbe_hw *hw = &adapter->hw; 4005 u32 gpie; 4006 4007 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE); 4008 4009 if (adapter->feat_en & IXGBE_FEATURE_MSIX) { 4010 /* Enable Enhanced MSI-X mode */ 4011 gpie |= IXGBE_GPIE_MSIX_MODE 4012 | IXGBE_GPIE_EIAME 4013 | IXGBE_GPIE_PBA_SUPPORT 4014 | IXGBE_GPIE_OCD; 4015 } 4016 4017 /* Fan Failure Interrupt */ 4018 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4019 gpie |= IXGBE_SDP1_GPIEN; 4020 4021 /* Thermal Sensor Interrupt */ 4022 if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) 4023 gpie |= IXGBE_SDP0_GPIEN_X540; 4024 4025 /* Link detection */ 4026 switch (hw->mac.type) { 4027 case ixgbe_mac_82599EB: 4028 gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN; 4029 break; 4030 case ixgbe_mac_X550EM_x: 4031 case ixgbe_mac_X550EM_a: 4032 gpie |= IXGBE_SDP0_GPIEN_X540; 4033 break; 4034 default: 4035 break; 4036 } 4037 4038 IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie); 4039 4040 return; 4041 } /* ixgbe_config_gpie */ 4042 4043 /************************************************************************ 4044 * ixgbe_config_delay_values 4045 * 4046 * Requires adapter->max_frame_size to be set. 4047 ************************************************************************/ 4048 static void 4049 ixgbe_config_delay_values(struct adapter *adapter) 4050 { 4051 struct ixgbe_hw *hw = &adapter->hw; 4052 u32 rxpb, frame, size, tmp; 4053 4054 frame = adapter->max_frame_size; 4055 4056 /* Calculate High Water */ 4057 switch (hw->mac.type) { 4058 case ixgbe_mac_X540: 4059 case ixgbe_mac_X550: 4060 case ixgbe_mac_X550EM_x: 4061 case ixgbe_mac_X550EM_a: 4062 tmp = IXGBE_DV_X540(frame, frame); 4063 break; 4064 default: 4065 tmp = IXGBE_DV(frame, frame); 4066 break; 4067 } 4068 size = IXGBE_BT2KB(tmp); 4069 rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10; 4070 hw->fc.high_water[0] = rxpb - size; 4071 4072 /* Now calculate Low Water */ 4073 switch (hw->mac.type) { 4074 case ixgbe_mac_X540: 4075 case ixgbe_mac_X550: 4076 case ixgbe_mac_X550EM_x: 4077 case ixgbe_mac_X550EM_a: 4078 tmp = IXGBE_LOW_DV_X540(frame); 4079 break; 4080 default: 4081 tmp = IXGBE_LOW_DV(frame); 4082 break; 4083 } 4084 hw->fc.low_water[0] = IXGBE_BT2KB(tmp); 4085 4086 hw->fc.pause_time = IXGBE_FC_PAUSE; 4087 hw->fc.send_xon = TRUE; 4088 } /* ixgbe_config_delay_values */ 4089 4090 /************************************************************************ 4091 * ixgbe_set_multi - Multicast Update 4092 * 4093 * Called whenever multicast address list is updated. 4094 ************************************************************************/ 4095 static void 4096 ixgbe_set_multi(struct adapter *adapter) 4097 { 4098 struct ixgbe_mc_addr *mta; 4099 struct ifnet *ifp = adapter->ifp; 4100 u8 *update_ptr; 4101 int mcnt = 0; 4102 u32 fctrl; 4103 struct ethercom *ec = &adapter->osdep.ec; 4104 struct ether_multi *enm; 4105 struct ether_multistep step; 4106 4107 KASSERT(mutex_owned(&adapter->core_mtx)); 4108 IOCTL_DEBUGOUT("ixgbe_set_multi: begin"); 4109 4110 mta = adapter->mta; 4111 bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES); 4112 4113 ifp->if_flags &= ~IFF_ALLMULTI; 4114 ETHER_LOCK(ec); 4115 ETHER_FIRST_MULTI(step, ec, enm); 4116 while (enm != NULL) { 4117 if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) || 4118 (memcmp(enm->enm_addrlo, enm->enm_addrhi, 4119 ETHER_ADDR_LEN) != 0)) { 4120 ifp->if_flags |= IFF_ALLMULTI; 4121 break; 4122 } 4123 bcopy(enm->enm_addrlo, 4124 mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS); 4125 mta[mcnt].vmdq = adapter->pool; 4126 mcnt++; 4127 ETHER_NEXT_MULTI(step, enm); 4128 } 4129 ETHER_UNLOCK(ec); 4130 4131 fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL); 4132 fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4133 if (ifp->if_flags & IFF_PROMISC) 4134 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); 4135 else if (ifp->if_flags & IFF_ALLMULTI) { 4136 fctrl |= IXGBE_FCTRL_MPE; 4137 } 4138 4139 IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl); 4140 4141 if (mcnt < MAX_NUM_MULTICAST_ADDRESSES) { 4142 update_ptr = (u8 *)mta; 4143 ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt, 4144 ixgbe_mc_array_itr, TRUE); 4145 } 4146 4147 return; 4148 } /* ixgbe_set_multi */ 4149 4150 /************************************************************************ 4151 * ixgbe_mc_array_itr 4152 * 4153 * An iterator function needed by the multicast shared code. 4154 * It feeds the shared code routine the addresses in the 4155 * array of ixgbe_set_multi() one by one. 4156 ************************************************************************/ 4157 static u8 * 4158 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq) 4159 { 4160 struct ixgbe_mc_addr *mta; 4161 4162 mta = (struct ixgbe_mc_addr *)*update_ptr; 4163 *vmdq = mta->vmdq; 4164 4165 *update_ptr = (u8*)(mta + 1); 4166 4167 return (mta->addr); 4168 } /* ixgbe_mc_array_itr */ 4169 4170 /************************************************************************ 4171 * ixgbe_local_timer - Timer routine 4172 * 4173 * Checks for link status, updates statistics, 4174 * and runs the watchdog check. 4175 ************************************************************************/ 4176 static void 4177 ixgbe_local_timer(void *arg) 4178 { 4179 struct adapter *adapter = arg; 4180 4181 IXGBE_CORE_LOCK(adapter); 4182 ixgbe_local_timer1(adapter); 4183 IXGBE_CORE_UNLOCK(adapter); 4184 } 4185 4186 static void 4187 ixgbe_local_timer1(void *arg) 4188 { 4189 struct adapter *adapter = arg; 4190 device_t dev = adapter->dev; 4191 struct ix_queue *que = adapter->queues; 4192 u64 queues = 0; 4193 int hung = 0; 4194 4195 KASSERT(mutex_owned(&adapter->core_mtx)); 4196 4197 /* Check for pluggable optics */ 4198 if (adapter->sfp_probe) 4199 if (!ixgbe_sfp_probe(adapter)) 4200 goto out; /* Nothing to do */ 4201 4202 ixgbe_update_link_status(adapter); 4203 ixgbe_update_stats_counters(adapter); 4204 4205 /* 4206 * Check the TX queues status 4207 * - mark hung queues so we don't schedule on them 4208 * - watchdog only if all queues show hung 4209 */ 4210 for (int i = 0; i < adapter->num_queues; i++, que++) { 4211 /* Keep track of queues with work for soft irq */ 4212 if (que->txr->busy) 4213 queues |= ((u64)1 << que->me); 4214 /* 4215 * Each time txeof runs without cleaning, but there 4216 * are uncleaned descriptors it increments busy. If 4217 * we get to the MAX we declare it hung. 4218 */ 4219 if (que->busy == IXGBE_QUEUE_HUNG) { 4220 ++hung; 4221 /* Mark the queue as inactive */ 4222 adapter->active_queues &= ~((u64)1 << que->me); 4223 continue; 4224 } else { 4225 /* Check if we've come back from hung */ 4226 if ((adapter->active_queues & ((u64)1 << que->me)) == 0) 4227 adapter->active_queues |= ((u64)1 << que->me); 4228 } 4229 if (que->busy >= IXGBE_MAX_TX_BUSY) { 4230 device_printf(dev, 4231 "Warning queue %d appears to be hung!\n", i); 4232 que->txr->busy = IXGBE_QUEUE_HUNG; 4233 ++hung; 4234 } 4235 } 4236 4237 /* Only truely watchdog if all queues show hung */ 4238 if (hung == adapter->num_queues) 4239 goto watchdog; 4240 else if (queues != 0) { /* Force an IRQ on queues with work */ 4241 que = adapter->queues; 4242 for (int i = 0; i < adapter->num_queues; i++, que++) { 4243 mutex_enter(&que->im_mtx); 4244 if (que->im_nest == 0) 4245 ixgbe_rearm_queues(adapter, 4246 queues & ((u64)1 << i)); 4247 mutex_exit(&que->im_mtx); 4248 } 4249 } 4250 4251 out: 4252 callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter); 4253 return; 4254 4255 watchdog: 4256 device_printf(adapter->dev, "Watchdog timeout -- resetting\n"); 4257 adapter->ifp->if_flags &= ~IFF_RUNNING; 4258 adapter->watchdog_events.ev_count++; 4259 ixgbe_init_locked(adapter); 4260 } /* ixgbe_local_timer */ 4261 4262 /************************************************************************ 4263 * ixgbe_sfp_probe 4264 * 4265 * Determine if a port had optics inserted. 4266 ************************************************************************/ 4267 static bool 4268 ixgbe_sfp_probe(struct adapter *adapter) 4269 { 4270 struct ixgbe_hw *hw = &adapter->hw; 4271 device_t dev = adapter->dev; 4272 bool result = FALSE; 4273 4274 if ((hw->phy.type == ixgbe_phy_nl) && 4275 (hw->phy.sfp_type == ixgbe_sfp_type_not_present)) { 4276 s32 ret = hw->phy.ops.identify_sfp(hw); 4277 if (ret) 4278 goto out; 4279 ret = hw->phy.ops.reset(hw); 4280 adapter->sfp_probe = FALSE; 4281 if (ret == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4282 device_printf(dev,"Unsupported SFP+ module detected!"); 4283 device_printf(dev, 4284 "Reload driver with supported module.\n"); 4285 goto out; 4286 } else 4287 device_printf(dev, "SFP+ module detected!\n"); 4288 /* We now have supported optics */ 4289 result = TRUE; 4290 } 4291 out: 4292 4293 return (result); 4294 } /* ixgbe_sfp_probe */ 4295 4296 /************************************************************************ 4297 * ixgbe_handle_mod - Tasklet for SFP module interrupts 4298 ************************************************************************/ 4299 static void 4300 ixgbe_handle_mod(void *context) 4301 { 4302 struct adapter *adapter = context; 4303 struct ixgbe_hw *hw = &adapter->hw; 4304 device_t dev = adapter->dev; 4305 u32 err, cage_full = 0; 4306 4307 if (adapter->hw.need_crosstalk_fix) { 4308 switch (hw->mac.type) { 4309 case ixgbe_mac_82599EB: 4310 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4311 IXGBE_ESDP_SDP2; 4312 break; 4313 case ixgbe_mac_X550EM_x: 4314 case ixgbe_mac_X550EM_a: 4315 cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 4316 IXGBE_ESDP_SDP0; 4317 break; 4318 default: 4319 break; 4320 } 4321 4322 if (!cage_full) 4323 return; 4324 } 4325 4326 err = hw->phy.ops.identify_sfp(hw); 4327 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4328 device_printf(dev, 4329 "Unsupported SFP+ module type was detected.\n"); 4330 return; 4331 } 4332 4333 err = hw->mac.ops.setup_sfp(hw); 4334 if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) { 4335 device_printf(dev, 4336 "Setup failure - unsupported SFP+ module type.\n"); 4337 return; 4338 } 4339 softint_schedule(adapter->msf_si); 4340 } /* ixgbe_handle_mod */ 4341 4342 4343 /************************************************************************ 4344 * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts 4345 ************************************************************************/ 4346 static void 4347 ixgbe_handle_msf(void *context) 4348 { 4349 struct adapter *adapter = context; 4350 struct ixgbe_hw *hw = &adapter->hw; 4351 u32 autoneg; 4352 bool negotiate; 4353 4354 /* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */ 4355 adapter->phy_layer = ixgbe_get_supported_physical_layer(hw); 4356 4357 autoneg = hw->phy.autoneg_advertised; 4358 if ((!autoneg) && (hw->mac.ops.get_link_capabilities)) 4359 hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate); 4360 else 4361 negotiate = 0; 4362 if (hw->mac.ops.setup_link) 4363 hw->mac.ops.setup_link(hw, autoneg, TRUE); 4364 4365 /* Adjust media types shown in ifconfig */ 4366 ifmedia_removeall(&adapter->media); 4367 ixgbe_add_media_types(adapter); 4368 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 4369 } /* ixgbe_handle_msf */ 4370 4371 /************************************************************************ 4372 * ixgbe_handle_phy - Tasklet for external PHY interrupts 4373 ************************************************************************/ 4374 static void 4375 ixgbe_handle_phy(void *context) 4376 { 4377 struct adapter *adapter = context; 4378 struct ixgbe_hw *hw = &adapter->hw; 4379 int error; 4380 4381 error = hw->phy.ops.handle_lasi(hw); 4382 if (error == IXGBE_ERR_OVERTEMP) 4383 device_printf(adapter->dev, 4384 "CRITICAL: EXTERNAL PHY OVER TEMP!! " 4385 " PHY will downshift to lower power state!\n"); 4386 else if (error) 4387 device_printf(adapter->dev, 4388 "Error handling LASI interrupt: %d\n", error); 4389 } /* ixgbe_handle_phy */ 4390 4391 static void 4392 ixgbe_ifstop(struct ifnet *ifp, int disable) 4393 { 4394 struct adapter *adapter = ifp->if_softc; 4395 4396 IXGBE_CORE_LOCK(adapter); 4397 ixgbe_stop(adapter); 4398 IXGBE_CORE_UNLOCK(adapter); 4399 } 4400 4401 /************************************************************************ 4402 * ixgbe_stop - Stop the hardware 4403 * 4404 * Disables all traffic on the adapter by issuing a 4405 * global reset on the MAC and deallocates TX/RX buffers. 4406 ************************************************************************/ 4407 static void 4408 ixgbe_stop(void *arg) 4409 { 4410 struct ifnet *ifp; 4411 struct adapter *adapter = arg; 4412 struct ixgbe_hw *hw = &adapter->hw; 4413 4414 ifp = adapter->ifp; 4415 4416 KASSERT(mutex_owned(&adapter->core_mtx)); 4417 4418 INIT_DEBUGOUT("ixgbe_stop: begin\n"); 4419 ixgbe_disable_intr(adapter); 4420 callout_stop(&adapter->timer); 4421 4422 /* Let the stack know...*/ 4423 ifp->if_flags &= ~IFF_RUNNING; 4424 4425 ixgbe_reset_hw(hw); 4426 hw->adapter_stopped = FALSE; 4427 ixgbe_stop_adapter(hw); 4428 if (hw->mac.type == ixgbe_mac_82599EB) 4429 ixgbe_stop_mac_link_on_d3_82599(hw); 4430 /* Turn off the laser - noop with no optics */ 4431 ixgbe_disable_tx_laser(hw); 4432 4433 /* Update the stack */ 4434 adapter->link_up = FALSE; 4435 ixgbe_update_link_status(adapter); 4436 4437 /* reprogram the RAR[0] in case user changed it. */ 4438 ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV); 4439 4440 return; 4441 } /* ixgbe_stop */ 4442 4443 /************************************************************************ 4444 * ixgbe_update_link_status - Update OS on link state 4445 * 4446 * Note: Only updates the OS on the cached link state. 4447 * The real check of the hardware only happens with 4448 * a link interrupt. 4449 ************************************************************************/ 4450 static void 4451 ixgbe_update_link_status(struct adapter *adapter) 4452 { 4453 struct ifnet *ifp = adapter->ifp; 4454 device_t dev = adapter->dev; 4455 struct ixgbe_hw *hw = &adapter->hw; 4456 4457 if (adapter->link_up) { 4458 if (adapter->link_active == FALSE) { 4459 if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){ 4460 /* 4461 * Discard count for both MAC Local Fault and 4462 * Remote Fault because those registers are 4463 * valid only when the link speed is up and 4464 * 10Gbps. 4465 */ 4466 IXGBE_READ_REG(hw, IXGBE_MLFC); 4467 IXGBE_READ_REG(hw, IXGBE_MRFC); 4468 } 4469 4470 if (bootverbose) { 4471 const char *bpsmsg; 4472 4473 switch (adapter->link_speed) { 4474 case IXGBE_LINK_SPEED_10GB_FULL: 4475 bpsmsg = "10 Gbps"; 4476 break; 4477 case IXGBE_LINK_SPEED_5GB_FULL: 4478 bpsmsg = "5 Gbps"; 4479 break; 4480 case IXGBE_LINK_SPEED_2_5GB_FULL: 4481 bpsmsg = "2.5 Gbps"; 4482 break; 4483 case IXGBE_LINK_SPEED_1GB_FULL: 4484 bpsmsg = "1 Gbps"; 4485 break; 4486 case IXGBE_LINK_SPEED_100_FULL: 4487 bpsmsg = "100 Mbps"; 4488 break; 4489 case IXGBE_LINK_SPEED_10_FULL: 4490 bpsmsg = "10 Mbps"; 4491 break; 4492 default: 4493 bpsmsg = "unknown speed"; 4494 break; 4495 } 4496 device_printf(dev, "Link is up %s %s \n", 4497 bpsmsg, "Full Duplex"); 4498 } 4499 adapter->link_active = TRUE; 4500 /* Update any Flow Control changes */ 4501 ixgbe_fc_enable(&adapter->hw); 4502 /* Update DMA coalescing config */ 4503 ixgbe_config_dmac(adapter); 4504 if_link_state_change(ifp, LINK_STATE_UP); 4505 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4506 ixgbe_ping_all_vfs(adapter); 4507 } 4508 } else { /* Link down */ 4509 if (adapter->link_active == TRUE) { 4510 if (bootverbose) 4511 device_printf(dev, "Link is Down\n"); 4512 if_link_state_change(ifp, LINK_STATE_DOWN); 4513 adapter->link_active = FALSE; 4514 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4515 ixgbe_ping_all_vfs(adapter); 4516 } 4517 } 4518 4519 return; 4520 } /* ixgbe_update_link_status */ 4521 4522 /************************************************************************ 4523 * ixgbe_config_dmac - Configure DMA Coalescing 4524 ************************************************************************/ 4525 static void 4526 ixgbe_config_dmac(struct adapter *adapter) 4527 { 4528 struct ixgbe_hw *hw = &adapter->hw; 4529 struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config; 4530 4531 if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config) 4532 return; 4533 4534 if (dcfg->watchdog_timer ^ adapter->dmac || 4535 dcfg->link_speed ^ adapter->link_speed) { 4536 dcfg->watchdog_timer = adapter->dmac; 4537 dcfg->fcoe_en = false; 4538 dcfg->link_speed = adapter->link_speed; 4539 dcfg->num_tcs = 1; 4540 4541 INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n", 4542 dcfg->watchdog_timer, dcfg->link_speed); 4543 4544 hw->mac.ops.dmac_config(hw); 4545 } 4546 } /* ixgbe_config_dmac */ 4547 4548 /************************************************************************ 4549 * ixgbe_enable_intr 4550 ************************************************************************/ 4551 static void 4552 ixgbe_enable_intr(struct adapter *adapter) 4553 { 4554 struct ixgbe_hw *hw = &adapter->hw; 4555 struct ix_queue *que = adapter->queues; 4556 u32 mask, fwsm; 4557 4558 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE); 4559 4560 switch (adapter->hw.mac.type) { 4561 case ixgbe_mac_82599EB: 4562 mask |= IXGBE_EIMS_ECC; 4563 /* Temperature sensor on some adapters */ 4564 mask |= IXGBE_EIMS_GPI_SDP0; 4565 /* SFP+ (RX_LOS_N & MOD_ABS_N) */ 4566 mask |= IXGBE_EIMS_GPI_SDP1; 4567 mask |= IXGBE_EIMS_GPI_SDP2; 4568 break; 4569 case ixgbe_mac_X540: 4570 /* Detect if Thermal Sensor is enabled */ 4571 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM); 4572 if (fwsm & IXGBE_FWSM_TS_ENABLED) 4573 mask |= IXGBE_EIMS_TS; 4574 mask |= IXGBE_EIMS_ECC; 4575 break; 4576 case ixgbe_mac_X550: 4577 /* MAC thermal sensor is automatically enabled */ 4578 mask |= IXGBE_EIMS_TS; 4579 mask |= IXGBE_EIMS_ECC; 4580 break; 4581 case ixgbe_mac_X550EM_x: 4582 case ixgbe_mac_X550EM_a: 4583 /* Some devices use SDP0 for important information */ 4584 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP || 4585 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP || 4586 hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N || 4587 hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) 4588 mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw); 4589 if (hw->phy.type == ixgbe_phy_x550em_ext_t) 4590 mask |= IXGBE_EICR_GPI_SDP0_X540; 4591 mask |= IXGBE_EIMS_ECC; 4592 break; 4593 default: 4594 break; 4595 } 4596 4597 /* Enable Fan Failure detection */ 4598 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) 4599 mask |= IXGBE_EIMS_GPI_SDP1; 4600 /* Enable SR-IOV */ 4601 if (adapter->feat_en & IXGBE_FEATURE_SRIOV) 4602 mask |= IXGBE_EIMS_MAILBOX; 4603 /* Enable Flow Director */ 4604 if (adapter->feat_en & IXGBE_FEATURE_FDIR) 4605 mask |= IXGBE_EIMS_FLOW_DIR; 4606 4607 IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask); 4608 4609 /* With MSI-X we use auto clear */ 4610 if (adapter->msix_mem) { 4611 mask = IXGBE_EIMS_ENABLE_MASK; 4612 /* Don't autoclear Link */ 4613 mask &= ~IXGBE_EIMS_OTHER; 4614 mask &= ~IXGBE_EIMS_LSC; 4615 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) 4616 mask &= ~IXGBE_EIMS_MAILBOX; 4617 IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask); 4618 } 4619 4620 /* 4621 * Now enable all queues, this is done separately to 4622 * allow for handling the extended (beyond 32) MSI-X 4623 * vectors that can be used by 82599 4624 */ 4625 for (int i = 0; i < adapter->num_queues; i++, que++) 4626 ixgbe_enable_queue(adapter, que->msix); 4627 4628 IXGBE_WRITE_FLUSH(hw); 4629 4630 return; 4631 } /* ixgbe_enable_intr */ 4632 4633 /************************************************************************ 4634 * ixgbe_disable_intr 4635 ************************************************************************/ 4636 static void 4637 ixgbe_disable_intr(struct adapter *adapter) 4638 { 4639 struct ix_queue *que = adapter->queues; 4640 4641 /* disable interrupts other than queues */ 4642 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE); 4643 4644 if (adapter->msix_mem) 4645 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0); 4646 4647 for (int i = 0; i < adapter->num_queues; i++, que++) 4648 ixgbe_disable_queue(adapter, que->msix); 4649 4650 IXGBE_WRITE_FLUSH(&adapter->hw); 4651 4652 return; 4653 } /* ixgbe_disable_intr */ 4654 4655 /************************************************************************ 4656 * ixgbe_legacy_irq - Legacy Interrupt Service routine 4657 ************************************************************************/ 4658 static int 4659 ixgbe_legacy_irq(void *arg) 4660 { 4661 struct ix_queue *que = arg; 4662 struct adapter *adapter = que->adapter; 4663 struct ixgbe_hw *hw = &adapter->hw; 4664 struct ifnet *ifp = adapter->ifp; 4665 struct tx_ring *txr = adapter->tx_rings; 4666 bool more = false; 4667 u32 eicr, eicr_mask; 4668 4669 /* Silicon errata #26 on 82598 */ 4670 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 4671 4672 eicr = IXGBE_READ_REG(hw, IXGBE_EICR); 4673 4674 adapter->stats.pf.legint.ev_count++; 4675 ++que->irqs.ev_count; 4676 if (eicr == 0) { 4677 adapter->stats.pf.intzero.ev_count++; 4678 if ((ifp->if_flags & IFF_UP) != 0) 4679 ixgbe_enable_intr(adapter); 4680 return 0; 4681 } 4682 4683 if ((ifp->if_flags & IFF_RUNNING) != 0) { 4684 #ifdef __NetBSD__ 4685 /* Don't run ixgbe_rxeof in interrupt context */ 4686 more = true; 4687 #else 4688 more = ixgbe_rxeof(que); 4689 #endif 4690 4691 IXGBE_TX_LOCK(txr); 4692 ixgbe_txeof(txr); 4693 #ifdef notyet 4694 if (!ixgbe_ring_empty(ifp, txr->br)) 4695 ixgbe_start_locked(ifp, txr); 4696 #endif 4697 IXGBE_TX_UNLOCK(txr); 4698 } 4699 4700 /* Check for fan failure */ 4701 if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) { 4702 ixgbe_check_fan_failure(adapter, eicr, true); 4703 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4704 } 4705 4706 /* Link status change */ 4707 if (eicr & IXGBE_EICR_LSC) 4708 softint_schedule(adapter->link_si); 4709 4710 if (ixgbe_is_sfp(hw)) { 4711 /* Pluggable optics-related interrupt */ 4712 if (hw->mac.type >= ixgbe_mac_X540) 4713 eicr_mask = IXGBE_EICR_GPI_SDP0_X540; 4714 else 4715 eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw); 4716 4717 if (eicr & eicr_mask) { 4718 IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); 4719 softint_schedule(adapter->mod_si); 4720 } 4721 4722 if ((hw->mac.type == ixgbe_mac_82599EB) && 4723 (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { 4724 IXGBE_WRITE_REG(hw, IXGBE_EICR, 4725 IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); 4726 softint_schedule(adapter->msf_si); 4727 } 4728 } 4729 4730 /* External PHY interrupt */ 4731 if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && 4732 (eicr & IXGBE_EICR_GPI_SDP0_X540)) 4733 softint_schedule(adapter->phy_si); 4734 4735 if (more) { 4736 que->req.ev_count++; 4737 ixgbe_sched_handle_que(adapter, que); 4738 } else 4739 ixgbe_enable_intr(adapter); 4740 4741 return 1; 4742 } /* ixgbe_legacy_irq */ 4743 4744 /************************************************************************ 4745 * ixgbe_free_pciintr_resources 4746 ************************************************************************/ 4747 static void 4748 ixgbe_free_pciintr_resources(struct adapter *adapter) 4749 { 4750 struct ix_queue *que = adapter->queues; 4751 int rid; 4752 4753 /* 4754 * Release all msix queue resources: 4755 */ 4756 for (int i = 0; i < adapter->num_queues; i++, que++) { 4757 if (que->res != NULL) { 4758 pci_intr_disestablish(adapter->osdep.pc, 4759 adapter->osdep.ihs[i]); 4760 adapter->osdep.ihs[i] = NULL; 4761 } 4762 } 4763 4764 /* Clean the Legacy or Link interrupt last */ 4765 if (adapter->vector) /* we are doing MSIX */ 4766 rid = adapter->vector; 4767 else 4768 rid = 0; 4769 4770 if (adapter->osdep.ihs[rid] != NULL) { 4771 pci_intr_disestablish(adapter->osdep.pc, 4772 adapter->osdep.ihs[rid]); 4773 adapter->osdep.ihs[rid] = NULL; 4774 } 4775 4776 if (adapter->osdep.intrs != NULL) { 4777 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 4778 adapter->osdep.nintrs); 4779 adapter->osdep.intrs = NULL; 4780 } 4781 4782 return; 4783 } /* ixgbe_free_pciintr_resources */ 4784 4785 /************************************************************************ 4786 * ixgbe_free_pci_resources 4787 ************************************************************************/ 4788 static void 4789 ixgbe_free_pci_resources(struct adapter *adapter) 4790 { 4791 4792 ixgbe_free_pciintr_resources(adapter); 4793 4794 if (adapter->osdep.mem_size != 0) { 4795 bus_space_unmap(adapter->osdep.mem_bus_space_tag, 4796 adapter->osdep.mem_bus_space_handle, 4797 adapter->osdep.mem_size); 4798 } 4799 4800 return; 4801 } /* ixgbe_free_pci_resources */ 4802 4803 /************************************************************************ 4804 * ixgbe_set_sysctl_value 4805 ************************************************************************/ 4806 static void 4807 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name, 4808 const char *description, int *limit, int value) 4809 { 4810 device_t dev = adapter->dev; 4811 struct sysctllog **log; 4812 const struct sysctlnode *rnode, *cnode; 4813 4814 log = &adapter->sysctllog; 4815 if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) { 4816 aprint_error_dev(dev, "could not create sysctl root\n"); 4817 return; 4818 } 4819 if (sysctl_createv(log, 0, &rnode, &cnode, 4820 CTLFLAG_READWRITE, CTLTYPE_INT, 4821 name, SYSCTL_DESCR(description), 4822 NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0) 4823 aprint_error_dev(dev, "could not create sysctl\n"); 4824 *limit = value; 4825 } /* ixgbe_set_sysctl_value */ 4826 4827 /************************************************************************ 4828 * ixgbe_sysctl_flowcntl 4829 * 4830 * SYSCTL wrapper around setting Flow Control 4831 ************************************************************************/ 4832 static int 4833 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS) 4834 { 4835 struct sysctlnode node = *rnode; 4836 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4837 int error, fc; 4838 4839 fc = adapter->hw.fc.current_mode; 4840 node.sysctl_data = &fc; 4841 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4842 if (error != 0 || newp == NULL) 4843 return error; 4844 4845 /* Don't bother if it's not changed */ 4846 if (fc == adapter->hw.fc.current_mode) 4847 return (0); 4848 4849 return ixgbe_set_flowcntl(adapter, fc); 4850 } /* ixgbe_sysctl_flowcntl */ 4851 4852 /************************************************************************ 4853 * ixgbe_set_flowcntl - Set flow control 4854 * 4855 * Flow control values: 4856 * 0 - off 4857 * 1 - rx pause 4858 * 2 - tx pause 4859 * 3 - full 4860 ************************************************************************/ 4861 static int 4862 ixgbe_set_flowcntl(struct adapter *adapter, int fc) 4863 { 4864 switch (fc) { 4865 case ixgbe_fc_rx_pause: 4866 case ixgbe_fc_tx_pause: 4867 case ixgbe_fc_full: 4868 adapter->hw.fc.requested_mode = fc; 4869 if (adapter->num_queues > 1) 4870 ixgbe_disable_rx_drop(adapter); 4871 break; 4872 case ixgbe_fc_none: 4873 adapter->hw.fc.requested_mode = ixgbe_fc_none; 4874 if (adapter->num_queues > 1) 4875 ixgbe_enable_rx_drop(adapter); 4876 break; 4877 default: 4878 return (EINVAL); 4879 } 4880 4881 #if 0 /* XXX NetBSD */ 4882 /* Don't autoneg if forcing a value */ 4883 adapter->hw.fc.disable_fc_autoneg = TRUE; 4884 #endif 4885 ixgbe_fc_enable(&adapter->hw); 4886 4887 return (0); 4888 } /* ixgbe_set_flowcntl */ 4889 4890 /************************************************************************ 4891 * ixgbe_enable_rx_drop 4892 * 4893 * Enable the hardware to drop packets when the buffer is 4894 * full. This is useful with multiqueue, so that no single 4895 * queue being full stalls the entire RX engine. We only 4896 * enable this when Multiqueue is enabled AND Flow Control 4897 * is disabled. 4898 ************************************************************************/ 4899 static void 4900 ixgbe_enable_rx_drop(struct adapter *adapter) 4901 { 4902 struct ixgbe_hw *hw = &adapter->hw; 4903 struct rx_ring *rxr; 4904 u32 srrctl; 4905 4906 for (int i = 0; i < adapter->num_queues; i++) { 4907 rxr = &adapter->rx_rings[i]; 4908 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4909 srrctl |= IXGBE_SRRCTL_DROP_EN; 4910 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4911 } 4912 4913 /* enable drop for each vf */ 4914 for (int i = 0; i < adapter->num_vfs; i++) { 4915 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4916 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT) | 4917 IXGBE_QDE_ENABLE)); 4918 } 4919 } /* ixgbe_enable_rx_drop */ 4920 4921 /************************************************************************ 4922 * ixgbe_disable_rx_drop 4923 ************************************************************************/ 4924 static void 4925 ixgbe_disable_rx_drop(struct adapter *adapter) 4926 { 4927 struct ixgbe_hw *hw = &adapter->hw; 4928 struct rx_ring *rxr; 4929 u32 srrctl; 4930 4931 for (int i = 0; i < adapter->num_queues; i++) { 4932 rxr = &adapter->rx_rings[i]; 4933 srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me)); 4934 srrctl &= ~IXGBE_SRRCTL_DROP_EN; 4935 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl); 4936 } 4937 4938 /* disable drop for each vf */ 4939 for (int i = 0; i < adapter->num_vfs; i++) { 4940 IXGBE_WRITE_REG(hw, IXGBE_QDE, 4941 (IXGBE_QDE_WRITE | (i << IXGBE_QDE_IDX_SHIFT))); 4942 } 4943 } /* ixgbe_disable_rx_drop */ 4944 4945 /************************************************************************ 4946 * ixgbe_sysctl_advertise 4947 * 4948 * SYSCTL wrapper around setting advertised speed 4949 ************************************************************************/ 4950 static int 4951 ixgbe_sysctl_advertise(SYSCTLFN_ARGS) 4952 { 4953 struct sysctlnode node = *rnode; 4954 struct adapter *adapter = (struct adapter *)node.sysctl_data; 4955 int error = 0, advertise; 4956 4957 advertise = adapter->advertise; 4958 node.sysctl_data = &advertise; 4959 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 4960 if (error != 0 || newp == NULL) 4961 return error; 4962 4963 return ixgbe_set_advertise(adapter, advertise); 4964 } /* ixgbe_sysctl_advertise */ 4965 4966 /************************************************************************ 4967 * ixgbe_set_advertise - Control advertised link speed 4968 * 4969 * Flags: 4970 * 0x00 - Default (all capable link speed) 4971 * 0x01 - advertise 100 Mb 4972 * 0x02 - advertise 1G 4973 * 0x04 - advertise 10G 4974 * 0x08 - advertise 10 Mb 4975 * 0x10 - advertise 2.5G 4976 * 0x20 - advertise 5G 4977 ************************************************************************/ 4978 static int 4979 ixgbe_set_advertise(struct adapter *adapter, int advertise) 4980 { 4981 device_t dev; 4982 struct ixgbe_hw *hw; 4983 ixgbe_link_speed speed = 0; 4984 ixgbe_link_speed link_caps = 0; 4985 s32 err = IXGBE_NOT_IMPLEMENTED; 4986 bool negotiate = FALSE; 4987 4988 /* Checks to validate new value */ 4989 if (adapter->advertise == advertise) /* no change */ 4990 return (0); 4991 4992 dev = adapter->dev; 4993 hw = &adapter->hw; 4994 4995 /* No speed changes for backplane media */ 4996 if (hw->phy.media_type == ixgbe_media_type_backplane) 4997 return (ENODEV); 4998 4999 if (!((hw->phy.media_type == ixgbe_media_type_copper) || 5000 (hw->phy.multispeed_fiber))) { 5001 device_printf(dev, 5002 "Advertised speed can only be set on copper or " 5003 "multispeed fiber media types.\n"); 5004 return (EINVAL); 5005 } 5006 5007 if (advertise < 0x0 || advertise > 0x2f) { 5008 device_printf(dev, 5009 "Invalid advertised speed; valid modes are 0x0 through 0x7\n"); 5010 return (EINVAL); 5011 } 5012 5013 if (hw->mac.ops.get_link_capabilities) { 5014 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, 5015 &negotiate); 5016 if (err != IXGBE_SUCCESS) { 5017 device_printf(dev, "Unable to determine supported advertise speeds\n"); 5018 return (ENODEV); 5019 } 5020 } 5021 5022 /* Set new value and report new advertised mode */ 5023 if (advertise & 0x1) { 5024 if (!(link_caps & IXGBE_LINK_SPEED_100_FULL)) { 5025 device_printf(dev, "Interface does not support 100Mb advertised speed\n"); 5026 return (EINVAL); 5027 } 5028 speed |= IXGBE_LINK_SPEED_100_FULL; 5029 } 5030 if (advertise & 0x2) { 5031 if (!(link_caps & IXGBE_LINK_SPEED_1GB_FULL)) { 5032 device_printf(dev, "Interface does not support 1Gb advertised speed\n"); 5033 return (EINVAL); 5034 } 5035 speed |= IXGBE_LINK_SPEED_1GB_FULL; 5036 } 5037 if (advertise & 0x4) { 5038 if (!(link_caps & IXGBE_LINK_SPEED_10GB_FULL)) { 5039 device_printf(dev, "Interface does not support 10Gb advertised speed\n"); 5040 return (EINVAL); 5041 } 5042 speed |= IXGBE_LINK_SPEED_10GB_FULL; 5043 } 5044 if (advertise & 0x8) { 5045 if (!(link_caps & IXGBE_LINK_SPEED_10_FULL)) { 5046 device_printf(dev, "Interface does not support 10Mb advertised speed\n"); 5047 return (EINVAL); 5048 } 5049 speed |= IXGBE_LINK_SPEED_10_FULL; 5050 } 5051 if (advertise & 0x10) { 5052 if (!(link_caps & IXGBE_LINK_SPEED_2_5GB_FULL)) { 5053 device_printf(dev, "Interface does not support 2.5Gb advertised speed\n"); 5054 return (EINVAL); 5055 } 5056 speed |= IXGBE_LINK_SPEED_2_5GB_FULL; 5057 } 5058 if (advertise & 0x20) { 5059 if (!(link_caps & IXGBE_LINK_SPEED_5GB_FULL)) { 5060 device_printf(dev, "Interface does not support 5Gb advertised speed\n"); 5061 return (EINVAL); 5062 } 5063 speed |= IXGBE_LINK_SPEED_5GB_FULL; 5064 } 5065 if (advertise == 0) 5066 speed = link_caps; /* All capable link speed */ 5067 5068 hw->mac.autotry_restart = TRUE; 5069 hw->mac.ops.setup_link(hw, speed, TRUE); 5070 adapter->advertise = advertise; 5071 5072 return (0); 5073 } /* ixgbe_set_advertise */ 5074 5075 /************************************************************************ 5076 * ixgbe_get_advertise - Get current advertised speed settings 5077 * 5078 * Formatted for sysctl usage. 5079 * Flags: 5080 * 0x01 - advertise 100 Mb 5081 * 0x02 - advertise 1G 5082 * 0x04 - advertise 10G 5083 * 0x08 - advertise 10 Mb (yes, Mb) 5084 * 0x10 - advertise 2.5G 5085 * 0x20 - advertise 5G 5086 ************************************************************************/ 5087 static int 5088 ixgbe_get_advertise(struct adapter *adapter) 5089 { 5090 struct ixgbe_hw *hw = &adapter->hw; 5091 int speed; 5092 ixgbe_link_speed link_caps = 0; 5093 s32 err; 5094 bool negotiate = FALSE; 5095 5096 /* 5097 * Advertised speed means nothing unless it's copper or 5098 * multi-speed fiber 5099 */ 5100 if (!(hw->phy.media_type == ixgbe_media_type_copper) && 5101 !(hw->phy.multispeed_fiber)) 5102 return (0); 5103 5104 err = hw->mac.ops.get_link_capabilities(hw, &link_caps, &negotiate); 5105 if (err != IXGBE_SUCCESS) 5106 return (0); 5107 5108 speed = 5109 ((link_caps & IXGBE_LINK_SPEED_10GB_FULL) ? 0x04 : 0) | 5110 ((link_caps & IXGBE_LINK_SPEED_1GB_FULL) ? 0x02 : 0) | 5111 ((link_caps & IXGBE_LINK_SPEED_100_FULL) ? 0x01 : 0) | 5112 ((link_caps & IXGBE_LINK_SPEED_10_FULL) ? 0x08 : 0) | 5113 ((link_caps & IXGBE_LINK_SPEED_2_5GB_FULL) ? 0x10 : 0) | 5114 ((link_caps & IXGBE_LINK_SPEED_5GB_FULL) ? 0x20 : 0); 5115 5116 return speed; 5117 } /* ixgbe_get_advertise */ 5118 5119 /************************************************************************ 5120 * ixgbe_sysctl_dmac - Manage DMA Coalescing 5121 * 5122 * Control values: 5123 * 0/1 - off / on (use default value of 1000) 5124 * 5125 * Legal timer values are: 5126 * 50,100,250,500,1000,2000,5000,10000 5127 * 5128 * Turning off interrupt moderation will also turn this off. 5129 ************************************************************************/ 5130 static int 5131 ixgbe_sysctl_dmac(SYSCTLFN_ARGS) 5132 { 5133 struct sysctlnode node = *rnode; 5134 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5135 struct ifnet *ifp = adapter->ifp; 5136 int error; 5137 int newval; 5138 5139 newval = adapter->dmac; 5140 node.sysctl_data = &newval; 5141 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5142 if ((error) || (newp == NULL)) 5143 return (error); 5144 5145 switch (newval) { 5146 case 0: 5147 /* Disabled */ 5148 adapter->dmac = 0; 5149 break; 5150 case 1: 5151 /* Enable and use default */ 5152 adapter->dmac = 1000; 5153 break; 5154 case 50: 5155 case 100: 5156 case 250: 5157 case 500: 5158 case 1000: 5159 case 2000: 5160 case 5000: 5161 case 10000: 5162 /* Legal values - allow */ 5163 adapter->dmac = newval; 5164 break; 5165 default: 5166 /* Do nothing, illegal value */ 5167 return (EINVAL); 5168 } 5169 5170 /* Re-initialize hardware if it's already running */ 5171 if (ifp->if_flags & IFF_RUNNING) 5172 ixgbe_init(ifp); 5173 5174 return (0); 5175 } 5176 5177 #ifdef IXGBE_DEBUG 5178 /************************************************************************ 5179 * ixgbe_sysctl_power_state 5180 * 5181 * Sysctl to test power states 5182 * Values: 5183 * 0 - set device to D0 5184 * 3 - set device to D3 5185 * (none) - get current device power state 5186 ************************************************************************/ 5187 static int 5188 ixgbe_sysctl_power_state(SYSCTLFN_ARGS) 5189 { 5190 #ifdef notyet 5191 struct sysctlnode node = *rnode; 5192 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5193 device_t dev = adapter->dev; 5194 int curr_ps, new_ps, error = 0; 5195 5196 curr_ps = new_ps = pci_get_powerstate(dev); 5197 5198 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5199 if ((error) || (req->newp == NULL)) 5200 return (error); 5201 5202 if (new_ps == curr_ps) 5203 return (0); 5204 5205 if (new_ps == 3 && curr_ps == 0) 5206 error = DEVICE_SUSPEND(dev); 5207 else if (new_ps == 0 && curr_ps == 3) 5208 error = DEVICE_RESUME(dev); 5209 else 5210 return (EINVAL); 5211 5212 device_printf(dev, "New state: %d\n", pci_get_powerstate(dev)); 5213 5214 return (error); 5215 #else 5216 return 0; 5217 #endif 5218 } /* ixgbe_sysctl_power_state */ 5219 #endif 5220 5221 /************************************************************************ 5222 * ixgbe_sysctl_wol_enable 5223 * 5224 * Sysctl to enable/disable the WoL capability, 5225 * if supported by the adapter. 5226 * 5227 * Values: 5228 * 0 - disabled 5229 * 1 - enabled 5230 ************************************************************************/ 5231 static int 5232 ixgbe_sysctl_wol_enable(SYSCTLFN_ARGS) 5233 { 5234 struct sysctlnode node = *rnode; 5235 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5236 struct ixgbe_hw *hw = &adapter->hw; 5237 bool new_wol_enabled; 5238 int error = 0; 5239 5240 new_wol_enabled = hw->wol_enabled; 5241 node.sysctl_data = &new_wol_enabled; 5242 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5243 if ((error) || (newp == NULL)) 5244 return (error); 5245 if (new_wol_enabled == hw->wol_enabled) 5246 return (0); 5247 5248 if (new_wol_enabled && !adapter->wol_support) 5249 return (ENODEV); 5250 else 5251 hw->wol_enabled = new_wol_enabled; 5252 5253 return (0); 5254 } /* ixgbe_sysctl_wol_enable */ 5255 5256 /************************************************************************ 5257 * ixgbe_sysctl_wufc - Wake Up Filter Control 5258 * 5259 * Sysctl to enable/disable the types of packets that the 5260 * adapter will wake up on upon receipt. 5261 * Flags: 5262 * 0x1 - Link Status Change 5263 * 0x2 - Magic Packet 5264 * 0x4 - Direct Exact 5265 * 0x8 - Directed Multicast 5266 * 0x10 - Broadcast 5267 * 0x20 - ARP/IPv4 Request Packet 5268 * 0x40 - Direct IPv4 Packet 5269 * 0x80 - Direct IPv6 Packet 5270 * 5271 * Settings not listed above will cause the sysctl to return an error. 5272 ************************************************************************/ 5273 static int 5274 ixgbe_sysctl_wufc(SYSCTLFN_ARGS) 5275 { 5276 struct sysctlnode node = *rnode; 5277 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5278 int error = 0; 5279 u32 new_wufc; 5280 5281 new_wufc = adapter->wufc; 5282 node.sysctl_data = &new_wufc; 5283 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5284 if ((error) || (newp == NULL)) 5285 return (error); 5286 if (new_wufc == adapter->wufc) 5287 return (0); 5288 5289 if (new_wufc & 0xffffff00) 5290 return (EINVAL); 5291 5292 new_wufc &= 0xff; 5293 new_wufc |= (0xffffff & adapter->wufc); 5294 adapter->wufc = new_wufc; 5295 5296 return (0); 5297 } /* ixgbe_sysctl_wufc */ 5298 5299 #ifdef IXGBE_DEBUG 5300 /************************************************************************ 5301 * ixgbe_sysctl_print_rss_config 5302 ************************************************************************/ 5303 static int 5304 ixgbe_sysctl_print_rss_config(SYSCTLFN_ARGS) 5305 { 5306 #ifdef notyet 5307 struct sysctlnode node = *rnode; 5308 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5309 struct ixgbe_hw *hw = &adapter->hw; 5310 device_t dev = adapter->dev; 5311 struct sbuf *buf; 5312 int error = 0, reta_size; 5313 u32 reg; 5314 5315 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5316 if (!buf) { 5317 device_printf(dev, "Could not allocate sbuf for output.\n"); 5318 return (ENOMEM); 5319 } 5320 5321 // TODO: use sbufs to make a string to print out 5322 /* Set multiplier for RETA setup and table size based on MAC */ 5323 switch (adapter->hw.mac.type) { 5324 case ixgbe_mac_X550: 5325 case ixgbe_mac_X550EM_x: 5326 case ixgbe_mac_X550EM_a: 5327 reta_size = 128; 5328 break; 5329 default: 5330 reta_size = 32; 5331 break; 5332 } 5333 5334 /* Print out the redirection table */ 5335 sbuf_cat(buf, "\n"); 5336 for (int i = 0; i < reta_size; i++) { 5337 if (i < 32) { 5338 reg = IXGBE_READ_REG(hw, IXGBE_RETA(i)); 5339 sbuf_printf(buf, "RETA(%2d): 0x%08x\n", i, reg); 5340 } else { 5341 reg = IXGBE_READ_REG(hw, IXGBE_ERETA(i - 32)); 5342 sbuf_printf(buf, "ERETA(%2d): 0x%08x\n", i - 32, reg); 5343 } 5344 } 5345 5346 // TODO: print more config 5347 5348 error = sbuf_finish(buf); 5349 if (error) 5350 device_printf(dev, "Error finishing sbuf: %d\n", error); 5351 5352 sbuf_delete(buf); 5353 #endif 5354 return (0); 5355 } /* ixgbe_sysctl_print_rss_config */ 5356 #endif /* IXGBE_DEBUG */ 5357 5358 /************************************************************************ 5359 * ixgbe_sysctl_phy_temp - Retrieve temperature of PHY 5360 * 5361 * For X552/X557-AT devices using an external PHY 5362 ************************************************************************/ 5363 static int 5364 ixgbe_sysctl_phy_temp(SYSCTLFN_ARGS) 5365 { 5366 struct sysctlnode node = *rnode; 5367 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5368 struct ixgbe_hw *hw = &adapter->hw; 5369 int val; 5370 u16 reg; 5371 int error; 5372 5373 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5374 device_printf(adapter->dev, 5375 "Device has no supported external thermal sensor.\n"); 5376 return (ENODEV); 5377 } 5378 5379 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP, 5380 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5381 device_printf(adapter->dev, 5382 "Error reading from PHY's current temperature register\n"); 5383 return (EAGAIN); 5384 } 5385 5386 node.sysctl_data = &val; 5387 5388 /* Shift temp for output */ 5389 val = reg >> 8; 5390 5391 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5392 if ((error) || (newp == NULL)) 5393 return (error); 5394 5395 return (0); 5396 } /* ixgbe_sysctl_phy_temp */ 5397 5398 /************************************************************************ 5399 * ixgbe_sysctl_phy_overtemp_occurred 5400 * 5401 * Reports (directly from the PHY) whether the current PHY 5402 * temperature is over the overtemp threshold. 5403 ************************************************************************/ 5404 static int 5405 ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_ARGS) 5406 { 5407 struct sysctlnode node = *rnode; 5408 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5409 struct ixgbe_hw *hw = &adapter->hw; 5410 int val, error; 5411 u16 reg; 5412 5413 if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) { 5414 device_printf(adapter->dev, 5415 "Device has no supported external thermal sensor.\n"); 5416 return (ENODEV); 5417 } 5418 5419 if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS, 5420 IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, ®)) { 5421 device_printf(adapter->dev, 5422 "Error reading from PHY's temperature status register\n"); 5423 return (EAGAIN); 5424 } 5425 5426 node.sysctl_data = &val; 5427 5428 /* Get occurrence bit */ 5429 val = !!(reg & 0x4000); 5430 5431 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5432 if ((error) || (newp == NULL)) 5433 return (error); 5434 5435 return (0); 5436 } /* ixgbe_sysctl_phy_overtemp_occurred */ 5437 5438 /************************************************************************ 5439 * ixgbe_sysctl_eee_state 5440 * 5441 * Sysctl to set EEE power saving feature 5442 * Values: 5443 * 0 - disable EEE 5444 * 1 - enable EEE 5445 * (none) - get current device EEE state 5446 ************************************************************************/ 5447 static int 5448 ixgbe_sysctl_eee_state(SYSCTLFN_ARGS) 5449 { 5450 struct sysctlnode node = *rnode; 5451 struct adapter *adapter = (struct adapter *)node.sysctl_data; 5452 struct ifnet *ifp = adapter->ifp; 5453 device_t dev = adapter->dev; 5454 int curr_eee, new_eee, error = 0; 5455 s32 retval; 5456 5457 curr_eee = new_eee = !!(adapter->feat_en & IXGBE_FEATURE_EEE); 5458 node.sysctl_data = &new_eee; 5459 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 5460 if ((error) || (newp == NULL)) 5461 return (error); 5462 5463 /* Nothing to do */ 5464 if (new_eee == curr_eee) 5465 return (0); 5466 5467 /* Not supported */ 5468 if (!(adapter->feat_cap & IXGBE_FEATURE_EEE)) 5469 return (EINVAL); 5470 5471 /* Bounds checking */ 5472 if ((new_eee < 0) || (new_eee > 1)) 5473 return (EINVAL); 5474 5475 retval = adapter->hw.mac.ops.setup_eee(&adapter->hw, new_eee); 5476 if (retval) { 5477 device_printf(dev, "Error in EEE setup: 0x%08X\n", retval); 5478 return (EINVAL); 5479 } 5480 5481 /* Restart auto-neg */ 5482 ixgbe_init(ifp); 5483 5484 device_printf(dev, "New EEE state: %d\n", new_eee); 5485 5486 /* Cache new value */ 5487 if (new_eee) 5488 adapter->feat_en |= IXGBE_FEATURE_EEE; 5489 else 5490 adapter->feat_en &= ~IXGBE_FEATURE_EEE; 5491 5492 return (error); 5493 } /* ixgbe_sysctl_eee_state */ 5494 5495 /************************************************************************ 5496 * ixgbe_init_device_features 5497 ************************************************************************/ 5498 static void 5499 ixgbe_init_device_features(struct adapter *adapter) 5500 { 5501 adapter->feat_cap = IXGBE_FEATURE_NETMAP 5502 | IXGBE_FEATURE_RSS 5503 | IXGBE_FEATURE_MSI 5504 | IXGBE_FEATURE_MSIX 5505 | IXGBE_FEATURE_LEGACY_IRQ 5506 | IXGBE_FEATURE_LEGACY_TX; 5507 5508 /* Set capabilities first... */ 5509 switch (adapter->hw.mac.type) { 5510 case ixgbe_mac_82598EB: 5511 if (adapter->hw.device_id == IXGBE_DEV_ID_82598AT) 5512 adapter->feat_cap |= IXGBE_FEATURE_FAN_FAIL; 5513 break; 5514 case ixgbe_mac_X540: 5515 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5516 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5517 if ((adapter->hw.device_id == IXGBE_DEV_ID_X540_BYPASS) && 5518 (adapter->hw.bus.func == 0)) 5519 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5520 break; 5521 case ixgbe_mac_X550: 5522 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5523 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5524 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5525 break; 5526 case ixgbe_mac_X550EM_x: 5527 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5528 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5529 if (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_X_KR) 5530 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5531 break; 5532 case ixgbe_mac_X550EM_a: 5533 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5534 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5535 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5536 if ((adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T) || 5537 (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L)) { 5538 adapter->feat_cap |= IXGBE_FEATURE_TEMP_SENSOR; 5539 adapter->feat_cap |= IXGBE_FEATURE_EEE; 5540 } 5541 break; 5542 case ixgbe_mac_82599EB: 5543 adapter->feat_cap |= IXGBE_FEATURE_SRIOV; 5544 adapter->feat_cap |= IXGBE_FEATURE_FDIR; 5545 if ((adapter->hw.device_id == IXGBE_DEV_ID_82599_BYPASS) && 5546 (adapter->hw.bus.func == 0)) 5547 adapter->feat_cap |= IXGBE_FEATURE_BYPASS; 5548 if (adapter->hw.device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) 5549 adapter->feat_cap &= ~IXGBE_FEATURE_LEGACY_IRQ; 5550 break; 5551 default: 5552 break; 5553 } 5554 5555 /* Enabled by default... */ 5556 /* Fan failure detection */ 5557 if (adapter->feat_cap & IXGBE_FEATURE_FAN_FAIL) 5558 adapter->feat_en |= IXGBE_FEATURE_FAN_FAIL; 5559 /* Netmap */ 5560 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP) 5561 adapter->feat_en |= IXGBE_FEATURE_NETMAP; 5562 /* EEE */ 5563 if (adapter->feat_cap & IXGBE_FEATURE_EEE) 5564 adapter->feat_en |= IXGBE_FEATURE_EEE; 5565 /* Thermal Sensor */ 5566 if (adapter->feat_cap & IXGBE_FEATURE_TEMP_SENSOR) 5567 adapter->feat_en |= IXGBE_FEATURE_TEMP_SENSOR; 5568 5569 /* Enabled via global sysctl... */ 5570 /* Flow Director */ 5571 if (ixgbe_enable_fdir) { 5572 if (adapter->feat_cap & IXGBE_FEATURE_FDIR) 5573 adapter->feat_en |= IXGBE_FEATURE_FDIR; 5574 else 5575 device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled."); 5576 } 5577 /* Legacy (single queue) transmit */ 5578 if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) && 5579 ixgbe_enable_legacy_tx) 5580 adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX; 5581 /* 5582 * Message Signal Interrupts - Extended (MSI-X) 5583 * Normal MSI is only enabled if MSI-X calls fail. 5584 */ 5585 if (!ixgbe_enable_msix) 5586 adapter->feat_cap &= ~IXGBE_FEATURE_MSIX; 5587 /* Receive-Side Scaling (RSS) */ 5588 if ((adapter->feat_cap & IXGBE_FEATURE_RSS) && ixgbe_enable_rss) 5589 adapter->feat_en |= IXGBE_FEATURE_RSS; 5590 5591 /* Disable features with unmet dependencies... */ 5592 /* No MSI-X */ 5593 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) { 5594 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 5595 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 5596 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 5597 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 5598 } 5599 } /* ixgbe_init_device_features */ 5600 5601 /************************************************************************ 5602 * ixgbe_probe - Device identification routine 5603 * 5604 * Determines if the driver should be loaded on 5605 * adapter based on its PCI vendor/device ID. 5606 * 5607 * return BUS_PROBE_DEFAULT on success, positive on failure 5608 ************************************************************************/ 5609 static int 5610 ixgbe_probe(device_t dev, cfdata_t cf, void *aux) 5611 { 5612 const struct pci_attach_args *pa = aux; 5613 5614 return (ixgbe_lookup(pa) != NULL) ? 1 : 0; 5615 } 5616 5617 static ixgbe_vendor_info_t * 5618 ixgbe_lookup(const struct pci_attach_args *pa) 5619 { 5620 ixgbe_vendor_info_t *ent; 5621 pcireg_t subid; 5622 5623 INIT_DEBUGOUT("ixgbe_lookup: begin"); 5624 5625 if (PCI_VENDOR(pa->pa_id) != IXGBE_INTEL_VENDOR_ID) 5626 return NULL; 5627 5628 subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG); 5629 5630 for (ent = ixgbe_vendor_info_array; ent->vendor_id != 0; ent++) { 5631 if ((PCI_VENDOR(pa->pa_id) == ent->vendor_id) && 5632 (PCI_PRODUCT(pa->pa_id) == ent->device_id) && 5633 ((PCI_SUBSYS_VENDOR(subid) == ent->subvendor_id) || 5634 (ent->subvendor_id == 0)) && 5635 ((PCI_SUBSYS_ID(subid) == ent->subdevice_id) || 5636 (ent->subdevice_id == 0))) { 5637 ++ixgbe_total_ports; 5638 return ent; 5639 } 5640 } 5641 return NULL; 5642 } 5643 5644 static int 5645 ixgbe_ifflags_cb(struct ethercom *ec) 5646 { 5647 struct ifnet *ifp = &ec->ec_if; 5648 struct adapter *adapter = ifp->if_softc; 5649 int change = ifp->if_flags ^ adapter->if_flags, rc = 0; 5650 5651 IXGBE_CORE_LOCK(adapter); 5652 5653 if (change != 0) 5654 adapter->if_flags = ifp->if_flags; 5655 5656 if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0) 5657 rc = ENETRESET; 5658 else if ((change & (IFF_PROMISC | IFF_ALLMULTI)) != 0) 5659 ixgbe_set_promisc(adapter); 5660 5661 /* Set up VLAN support and filter */ 5662 ixgbe_setup_vlan_hw_support(adapter); 5663 5664 IXGBE_CORE_UNLOCK(adapter); 5665 5666 return rc; 5667 } 5668 5669 /************************************************************************ 5670 * ixgbe_ioctl - Ioctl entry point 5671 * 5672 * Called when the user wants to configure the interface. 5673 * 5674 * return 0 on success, positive on failure 5675 ************************************************************************/ 5676 static int 5677 ixgbe_ioctl(struct ifnet * ifp, u_long command, void *data) 5678 { 5679 struct adapter *adapter = ifp->if_softc; 5680 struct ixgbe_hw *hw = &adapter->hw; 5681 struct ifcapreq *ifcr = data; 5682 struct ifreq *ifr = data; 5683 int error = 0; 5684 int l4csum_en; 5685 const int l4csum = IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx| 5686 IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx; 5687 5688 switch (command) { 5689 case SIOCSIFFLAGS: 5690 IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)"); 5691 break; 5692 case SIOCADDMULTI: 5693 case SIOCDELMULTI: 5694 IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI"); 5695 break; 5696 case SIOCSIFMEDIA: 5697 case SIOCGIFMEDIA: 5698 IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)"); 5699 break; 5700 case SIOCSIFCAP: 5701 IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)"); 5702 break; 5703 case SIOCSIFMTU: 5704 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)"); 5705 break; 5706 #ifdef __NetBSD__ 5707 case SIOCINITIFADDR: 5708 IOCTL_DEBUGOUT("ioctl: SIOCINITIFADDR"); 5709 break; 5710 case SIOCGIFFLAGS: 5711 IOCTL_DEBUGOUT("ioctl: SIOCGIFFLAGS"); 5712 break; 5713 case SIOCGIFAFLAG_IN: 5714 IOCTL_DEBUGOUT("ioctl: SIOCGIFAFLAG_IN"); 5715 break; 5716 case SIOCGIFADDR: 5717 IOCTL_DEBUGOUT("ioctl: SIOCGIFADDR"); 5718 break; 5719 case SIOCGIFMTU: 5720 IOCTL_DEBUGOUT("ioctl: SIOCGIFMTU (Get Interface MTU)"); 5721 break; 5722 case SIOCGIFCAP: 5723 IOCTL_DEBUGOUT("ioctl: SIOCGIFCAP (Get IF cap)"); 5724 break; 5725 case SIOCGETHERCAP: 5726 IOCTL_DEBUGOUT("ioctl: SIOCGETHERCAP (Get ethercap)"); 5727 break; 5728 case SIOCGLIFADDR: 5729 IOCTL_DEBUGOUT("ioctl: SIOCGLIFADDR (Get Interface addr)"); 5730 break; 5731 case SIOCZIFDATA: 5732 IOCTL_DEBUGOUT("ioctl: SIOCZIFDATA (Zero counter)"); 5733 hw->mac.ops.clear_hw_cntrs(hw); 5734 ixgbe_clear_evcnt(adapter); 5735 break; 5736 case SIOCAIFADDR: 5737 IOCTL_DEBUGOUT("ioctl: SIOCAIFADDR (add/chg IF alias)"); 5738 break; 5739 #endif 5740 default: 5741 IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)", (int)command); 5742 break; 5743 } 5744 5745 switch (command) { 5746 case SIOCSIFMEDIA: 5747 case SIOCGIFMEDIA: 5748 return ifmedia_ioctl(ifp, ifr, &adapter->media, command); 5749 case SIOCGI2C: 5750 { 5751 struct ixgbe_i2c_req i2c; 5752 5753 IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)"); 5754 error = copyin(ifr->ifr_data, &i2c, sizeof(i2c)); 5755 if (error != 0) 5756 break; 5757 if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) { 5758 error = EINVAL; 5759 break; 5760 } 5761 if (i2c.len > sizeof(i2c.data)) { 5762 error = EINVAL; 5763 break; 5764 } 5765 5766 hw->phy.ops.read_i2c_byte(hw, i2c.offset, 5767 i2c.dev_addr, i2c.data); 5768 error = copyout(&i2c, ifr->ifr_data, sizeof(i2c)); 5769 break; 5770 } 5771 case SIOCSIFCAP: 5772 /* Layer-4 Rx checksum offload has to be turned on and 5773 * off as a unit. 5774 */ 5775 l4csum_en = ifcr->ifcr_capenable & l4csum; 5776 if (l4csum_en != l4csum && l4csum_en != 0) 5777 return EINVAL; 5778 /*FALLTHROUGH*/ 5779 case SIOCADDMULTI: 5780 case SIOCDELMULTI: 5781 case SIOCSIFFLAGS: 5782 case SIOCSIFMTU: 5783 default: 5784 if ((error = ether_ioctl(ifp, command, data)) != ENETRESET) 5785 return error; 5786 if ((ifp->if_flags & IFF_RUNNING) == 0) 5787 ; 5788 else if (command == SIOCSIFCAP || command == SIOCSIFMTU) { 5789 IXGBE_CORE_LOCK(adapter); 5790 ixgbe_init_locked(adapter); 5791 ixgbe_recalculate_max_frame(adapter); 5792 IXGBE_CORE_UNLOCK(adapter); 5793 } else if (command == SIOCADDMULTI || command == SIOCDELMULTI) { 5794 /* 5795 * Multicast list has changed; set the hardware filter 5796 * accordingly. 5797 */ 5798 IXGBE_CORE_LOCK(adapter); 5799 ixgbe_disable_intr(adapter); 5800 ixgbe_set_multi(adapter); 5801 ixgbe_enable_intr(adapter); 5802 IXGBE_CORE_UNLOCK(adapter); 5803 } 5804 return 0; 5805 } 5806 5807 return error; 5808 } /* ixgbe_ioctl */ 5809 5810 /************************************************************************ 5811 * ixgbe_check_fan_failure 5812 ************************************************************************/ 5813 static void 5814 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt) 5815 { 5816 u32 mask; 5817 5818 mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) : 5819 IXGBE_ESDP_SDP1; 5820 5821 if (reg & mask) 5822 device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n"); 5823 } /* ixgbe_check_fan_failure */ 5824 5825 /************************************************************************ 5826 * ixgbe_handle_que 5827 ************************************************************************/ 5828 static void 5829 ixgbe_handle_que(void *context) 5830 { 5831 struct ix_queue *que = context; 5832 struct adapter *adapter = que->adapter; 5833 struct tx_ring *txr = que->txr; 5834 struct ifnet *ifp = adapter->ifp; 5835 bool more = false; 5836 5837 que->handleq.ev_count++; 5838 5839 if (ifp->if_flags & IFF_RUNNING) { 5840 more = ixgbe_rxeof(que); 5841 IXGBE_TX_LOCK(txr); 5842 more |= ixgbe_txeof(txr); 5843 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5844 if (!ixgbe_mq_ring_empty(ifp, txr->txr_interq)) 5845 ixgbe_mq_start_locked(ifp, txr); 5846 /* Only for queue 0 */ 5847 /* NetBSD still needs this for CBQ */ 5848 if ((&adapter->queues[0] == que) 5849 && (!ixgbe_legacy_ring_empty(ifp, NULL))) 5850 ixgbe_legacy_start_locked(ifp, txr); 5851 IXGBE_TX_UNLOCK(txr); 5852 } 5853 5854 if (more) { 5855 que->req.ev_count++; 5856 ixgbe_sched_handle_que(adapter, que); 5857 } else if (que->res != NULL) { 5858 /* Re-enable this interrupt */ 5859 ixgbe_enable_queue(adapter, que->msix); 5860 } else 5861 ixgbe_enable_intr(adapter); 5862 5863 return; 5864 } /* ixgbe_handle_que */ 5865 5866 /************************************************************************ 5867 * ixgbe_handle_que_work 5868 ************************************************************************/ 5869 static void 5870 ixgbe_handle_que_work(struct work *wk, void *context) 5871 { 5872 struct ix_queue *que = container_of(wk, struct ix_queue, wq_cookie); 5873 5874 /* 5875 * "enqueued flag" is not required here. 5876 * See ixgbe_msix_que(). 5877 */ 5878 ixgbe_handle_que(que); 5879 } 5880 5881 /************************************************************************ 5882 * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler 5883 ************************************************************************/ 5884 static int 5885 ixgbe_allocate_legacy(struct adapter *adapter, 5886 const struct pci_attach_args *pa) 5887 { 5888 device_t dev = adapter->dev; 5889 struct ix_queue *que = adapter->queues; 5890 struct tx_ring *txr = adapter->tx_rings; 5891 int counts[PCI_INTR_TYPE_SIZE]; 5892 pci_intr_type_t intr_type, max_type; 5893 char intrbuf[PCI_INTRSTR_LEN]; 5894 const char *intrstr = NULL; 5895 5896 /* We allocate a single interrupt resource */ 5897 max_type = PCI_INTR_TYPE_MSI; 5898 counts[PCI_INTR_TYPE_MSIX] = 0; 5899 counts[PCI_INTR_TYPE_MSI] = 5900 (adapter->feat_en & IXGBE_FEATURE_MSI) ? 1 : 0; 5901 /* Check not feat_en but feat_cap to fallback to INTx */ 5902 counts[PCI_INTR_TYPE_INTX] = 5903 (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) ? 1 : 0; 5904 5905 alloc_retry: 5906 if (pci_intr_alloc(pa, &adapter->osdep.intrs, counts, max_type) != 0) { 5907 aprint_error_dev(dev, "couldn't alloc interrupt\n"); 5908 return ENXIO; 5909 } 5910 adapter->osdep.nintrs = 1; 5911 intrstr = pci_intr_string(adapter->osdep.pc, adapter->osdep.intrs[0], 5912 intrbuf, sizeof(intrbuf)); 5913 adapter->osdep.ihs[0] = pci_intr_establish_xname(adapter->osdep.pc, 5914 adapter->osdep.intrs[0], IPL_NET, ixgbe_legacy_irq, que, 5915 device_xname(dev)); 5916 intr_type = pci_intr_type(adapter->osdep.pc, adapter->osdep.intrs[0]); 5917 if (adapter->osdep.ihs[0] == NULL) { 5918 aprint_error_dev(dev,"unable to establish %s\n", 5919 (intr_type == PCI_INTR_TYPE_MSI) ? "MSI" : "INTx"); 5920 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5921 adapter->osdep.intrs = NULL; 5922 switch (intr_type) { 5923 case PCI_INTR_TYPE_MSI: 5924 /* The next try is for INTx: Disable MSI */ 5925 max_type = PCI_INTR_TYPE_INTX; 5926 counts[PCI_INTR_TYPE_INTX] = 1; 5927 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5928 if (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) { 5929 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5930 goto alloc_retry; 5931 } else 5932 break; 5933 case PCI_INTR_TYPE_INTX: 5934 default: 5935 /* See below */ 5936 break; 5937 } 5938 } 5939 if (intr_type == PCI_INTR_TYPE_INTX) { 5940 adapter->feat_en &= ~IXGBE_FEATURE_MSI; 5941 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 5942 } 5943 if (adapter->osdep.ihs[0] == NULL) { 5944 aprint_error_dev(dev, 5945 "couldn't establish interrupt%s%s\n", 5946 intrstr ? " at " : "", intrstr ? intrstr : ""); 5947 pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs, 1); 5948 adapter->osdep.intrs = NULL; 5949 return ENXIO; 5950 } 5951 aprint_normal_dev(dev, "interrupting at %s\n", intrstr); 5952 /* 5953 * Try allocating a fast interrupt and the associated deferred 5954 * processing contexts. 5955 */ 5956 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) 5957 txr->txr_si = 5958 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5959 ixgbe_deferred_mq_start, txr); 5960 que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 5961 ixgbe_handle_que, que); 5962 5963 if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) 5964 & (txr->txr_si == NULL)) || (que->que_si == NULL)) { 5965 aprint_error_dev(dev, 5966 "could not establish software interrupts\n"); 5967 5968 return ENXIO; 5969 } 5970 /* For simplicity in the handlers */ 5971 adapter->active_queues = IXGBE_EIMS_ENABLE_MASK; 5972 5973 return (0); 5974 } /* ixgbe_allocate_legacy */ 5975 5976 /************************************************************************ 5977 * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers 5978 ************************************************************************/ 5979 static int 5980 ixgbe_allocate_msix(struct adapter *adapter, const struct pci_attach_args *pa) 5981 { 5982 device_t dev = adapter->dev; 5983 struct ix_queue *que = adapter->queues; 5984 struct tx_ring *txr = adapter->tx_rings; 5985 pci_chipset_tag_t pc; 5986 char intrbuf[PCI_INTRSTR_LEN]; 5987 char intr_xname[32]; 5988 char wqname[MAXCOMLEN]; 5989 const char *intrstr = NULL; 5990 int error, vector = 0; 5991 int cpu_id = 0; 5992 kcpuset_t *affinity; 5993 #ifdef RSS 5994 unsigned int rss_buckets = 0; 5995 kcpuset_t cpu_mask; 5996 #endif 5997 5998 pc = adapter->osdep.pc; 5999 #ifdef RSS 6000 /* 6001 * If we're doing RSS, the number of queues needs to 6002 * match the number of RSS buckets that are configured. 6003 * 6004 * + If there's more queues than RSS buckets, we'll end 6005 * up with queues that get no traffic. 6006 * 6007 * + If there's more RSS buckets than queues, we'll end 6008 * up having multiple RSS buckets map to the same queue, 6009 * so there'll be some contention. 6010 */ 6011 rss_buckets = rss_getnumbuckets(); 6012 if ((adapter->feat_en & IXGBE_FEATURE_RSS) && 6013 (adapter->num_queues != rss_buckets)) { 6014 device_printf(dev, 6015 "%s: number of queues (%d) != number of RSS buckets (%d)" 6016 "; performance will be impacted.\n", 6017 __func__, adapter->num_queues, rss_buckets); 6018 } 6019 #endif 6020 6021 adapter->osdep.nintrs = adapter->num_queues + 1; 6022 if (pci_msix_alloc_exact(pa, &adapter->osdep.intrs, 6023 adapter->osdep.nintrs) != 0) { 6024 aprint_error_dev(dev, 6025 "failed to allocate MSI-X interrupt\n"); 6026 return (ENXIO); 6027 } 6028 6029 kcpuset_create(&affinity, false); 6030 for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) { 6031 snprintf(intr_xname, sizeof(intr_xname), "%s TXRX%d", 6032 device_xname(dev), i); 6033 intrstr = pci_intr_string(pc, adapter->osdep.intrs[i], intrbuf, 6034 sizeof(intrbuf)); 6035 #ifdef IXGBE_MPSAFE 6036 pci_intr_setattr(pc, &adapter->osdep.intrs[i], PCI_INTR_MPSAFE, 6037 true); 6038 #endif 6039 /* Set the handler function */ 6040 que->res = adapter->osdep.ihs[i] = pci_intr_establish_xname(pc, 6041 adapter->osdep.intrs[i], IPL_NET, ixgbe_msix_que, que, 6042 intr_xname); 6043 if (que->res == NULL) { 6044 aprint_error_dev(dev, 6045 "Failed to register QUE handler\n"); 6046 error = ENXIO; 6047 goto err_out; 6048 } 6049 que->msix = vector; 6050 adapter->active_queues |= (u64)(1 << que->msix); 6051 6052 if (adapter->feat_en & IXGBE_FEATURE_RSS) { 6053 #ifdef RSS 6054 /* 6055 * The queue ID is used as the RSS layer bucket ID. 6056 * We look up the queue ID -> RSS CPU ID and select 6057 * that. 6058 */ 6059 cpu_id = rss_getcpu(i % rss_getnumbuckets()); 6060 CPU_SETOF(cpu_id, &cpu_mask); 6061 #endif 6062 } else { 6063 /* 6064 * Bind the MSI-X vector, and thus the 6065 * rings to the corresponding CPU. 6066 * 6067 * This just happens to match the default RSS 6068 * round-robin bucket -> queue -> CPU allocation. 6069 */ 6070 if (adapter->num_queues > 1) 6071 cpu_id = i; 6072 } 6073 /* Round-robin affinity */ 6074 kcpuset_zero(affinity); 6075 kcpuset_set(affinity, cpu_id % ncpu); 6076 error = interrupt_distribute(adapter->osdep.ihs[i], affinity, 6077 NULL); 6078 aprint_normal_dev(dev, "for TX/RX, interrupting at %s", 6079 intrstr); 6080 if (error == 0) { 6081 #if 1 /* def IXGBE_DEBUG */ 6082 #ifdef RSS 6083 aprintf_normal(", bound RSS bucket %d to CPU %d", i, 6084 cpu_id % ncpu); 6085 #else 6086 aprint_normal(", bound queue %d to cpu %d", i, 6087 cpu_id % ncpu); 6088 #endif 6089 #endif /* IXGBE_DEBUG */ 6090 } 6091 aprint_normal("\n"); 6092 6093 if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) { 6094 txr->txr_si = softint_establish( 6095 SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6096 ixgbe_deferred_mq_start, txr); 6097 if (txr->txr_si == NULL) { 6098 aprint_error_dev(dev, 6099 "couldn't establish software interrupt\n"); 6100 error = ENXIO; 6101 goto err_out; 6102 } 6103 } 6104 que->que_si 6105 = softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6106 ixgbe_handle_que, que); 6107 if (que->que_si == NULL) { 6108 aprint_error_dev(dev, 6109 "couldn't establish software interrupt\n"); 6110 error = ENXIO; 6111 goto err_out; 6112 } 6113 } 6114 snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev)); 6115 error = workqueue_create(&adapter->txr_wq, wqname, 6116 ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6117 IXGBE_WORKQUEUE_FLAGS); 6118 if (error) { 6119 aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n"); 6120 goto err_out; 6121 } 6122 adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int)); 6123 6124 snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev)); 6125 error = workqueue_create(&adapter->que_wq, wqname, 6126 ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET, 6127 IXGBE_WORKQUEUE_FLAGS); 6128 if (error) { 6129 aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n"); 6130 goto err_out; 6131 } 6132 6133 /* and Link */ 6134 cpu_id++; 6135 snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev)); 6136 adapter->vector = vector; 6137 intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf, 6138 sizeof(intrbuf)); 6139 #ifdef IXGBE_MPSAFE 6140 pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE, 6141 true); 6142 #endif 6143 /* Set the link handler function */ 6144 adapter->osdep.ihs[vector] = pci_intr_establish_xname(pc, 6145 adapter->osdep.intrs[vector], IPL_NET, ixgbe_msix_link, adapter, 6146 intr_xname); 6147 if (adapter->osdep.ihs[vector] == NULL) { 6148 adapter->res = NULL; 6149 aprint_error_dev(dev, "Failed to register LINK handler\n"); 6150 error = ENXIO; 6151 goto err_out; 6152 } 6153 /* Round-robin affinity */ 6154 kcpuset_zero(affinity); 6155 kcpuset_set(affinity, cpu_id % ncpu); 6156 error = interrupt_distribute(adapter->osdep.ihs[vector], affinity, 6157 NULL); 6158 6159 aprint_normal_dev(dev, 6160 "for link, interrupting at %s", intrstr); 6161 if (error == 0) 6162 aprint_normal(", affinity to cpu %d\n", cpu_id % ncpu); 6163 else 6164 aprint_normal("\n"); 6165 6166 if (adapter->feat_cap & IXGBE_FEATURE_SRIOV) { 6167 adapter->mbx_si = 6168 softint_establish(SOFTINT_NET | IXGBE_SOFTINFT_FLAGS, 6169 ixgbe_handle_mbx, adapter); 6170 if (adapter->mbx_si == NULL) { 6171 aprint_error_dev(dev, 6172 "could not establish software interrupts\n"); 6173 6174 error = ENXIO; 6175 goto err_out; 6176 } 6177 } 6178 6179 kcpuset_destroy(affinity); 6180 aprint_normal_dev(dev, 6181 "Using MSI-X interrupts with %d vectors\n", vector + 1); 6182 6183 return (0); 6184 6185 err_out: 6186 kcpuset_destroy(affinity); 6187 ixgbe_free_softint(adapter); 6188 ixgbe_free_pciintr_resources(adapter); 6189 return (error); 6190 } /* ixgbe_allocate_msix */ 6191 6192 /************************************************************************ 6193 * ixgbe_configure_interrupts 6194 * 6195 * Setup MSI-X, MSI, or legacy interrupts (in that order). 6196 * This will also depend on user settings. 6197 ************************************************************************/ 6198 static int 6199 ixgbe_configure_interrupts(struct adapter *adapter) 6200 { 6201 device_t dev = adapter->dev; 6202 struct ixgbe_mac_info *mac = &adapter->hw.mac; 6203 int want, queues, msgs; 6204 6205 /* Default to 1 queue if MSI-X setup fails */ 6206 adapter->num_queues = 1; 6207 6208 /* Override by tuneable */ 6209 if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX)) 6210 goto msi; 6211 6212 /* 6213 * NetBSD only: Use single vector MSI when number of CPU is 1 to save 6214 * interrupt slot. 6215 */ 6216 if (ncpu == 1) 6217 goto msi; 6218 6219 /* First try MSI-X */ 6220 msgs = pci_msix_count(adapter->osdep.pc, adapter->osdep.tag); 6221 msgs = MIN(msgs, IXG_MAX_NINTR); 6222 if (msgs < 2) 6223 goto msi; 6224 6225 adapter->msix_mem = (void *)1; /* XXX */ 6226 6227 /* Figure out a reasonable auto config value */ 6228 queues = (ncpu > (msgs - 1)) ? (msgs - 1) : ncpu; 6229 6230 #ifdef RSS 6231 /* If we're doing RSS, clamp at the number of RSS buckets */ 6232 if (adapter->feat_en & IXGBE_FEATURE_RSS) 6233 queues = min(queues, rss_getnumbuckets()); 6234 #endif 6235 if (ixgbe_num_queues > queues) { 6236 aprint_error_dev(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues); 6237 ixgbe_num_queues = queues; 6238 } 6239 6240 if (ixgbe_num_queues != 0) 6241 queues = ixgbe_num_queues; 6242 else 6243 queues = min(queues, 6244 min(mac->max_tx_queues, mac->max_rx_queues)); 6245 6246 /* reflect correct sysctl value */ 6247 ixgbe_num_queues = queues; 6248 6249 /* 6250 * Want one vector (RX/TX pair) per queue 6251 * plus an additional for Link. 6252 */ 6253 want = queues + 1; 6254 if (msgs >= want) 6255 msgs = want; 6256 else { 6257 aprint_error_dev(dev, "MSI-X Configuration Problem, " 6258 "%d vectors but %d queues wanted!\n", 6259 msgs, want); 6260 goto msi; 6261 } 6262 adapter->num_queues = queues; 6263 adapter->feat_en |= IXGBE_FEATURE_MSIX; 6264 return (0); 6265 6266 /* 6267 * MSI-X allocation failed or provided us with 6268 * less vectors than needed. Free MSI-X resources 6269 * and we'll try enabling MSI. 6270 */ 6271 msi: 6272 /* Without MSI-X, some features are no longer supported */ 6273 adapter->feat_cap &= ~IXGBE_FEATURE_RSS; 6274 adapter->feat_en &= ~IXGBE_FEATURE_RSS; 6275 adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV; 6276 adapter->feat_en &= ~IXGBE_FEATURE_SRIOV; 6277 6278 msgs = pci_msi_count(adapter->osdep.pc, adapter->osdep.tag); 6279 adapter->msix_mem = NULL; /* XXX */ 6280 if (msgs > 1) 6281 msgs = 1; 6282 if (msgs != 0) { 6283 msgs = 1; 6284 adapter->feat_en |= IXGBE_FEATURE_MSI; 6285 return (0); 6286 } 6287 6288 if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) { 6289 aprint_error_dev(dev, 6290 "Device does not support legacy interrupts.\n"); 6291 return 1; 6292 } 6293 6294 adapter->feat_en |= IXGBE_FEATURE_LEGACY_IRQ; 6295 6296 return (0); 6297 } /* ixgbe_configure_interrupts */ 6298 6299 6300 /************************************************************************ 6301 * ixgbe_handle_link - Tasklet for MSI-X Link interrupts 6302 * 6303 * Done outside of interrupt context since the driver might sleep 6304 ************************************************************************/ 6305 static void 6306 ixgbe_handle_link(void *context) 6307 { 6308 struct adapter *adapter = context; 6309 struct ixgbe_hw *hw = &adapter->hw; 6310 6311 ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0); 6312 ixgbe_update_link_status(adapter); 6313 6314 /* Re-enable link interrupts */ 6315 IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC); 6316 } /* ixgbe_handle_link */ 6317 6318 /************************************************************************ 6319 * ixgbe_rearm_queues 6320 ************************************************************************/ 6321 static void 6322 ixgbe_rearm_queues(struct adapter *adapter, u64 queues) 6323 { 6324 u32 mask; 6325 6326 switch (adapter->hw.mac.type) { 6327 case ixgbe_mac_82598EB: 6328 mask = (IXGBE_EIMS_RTX_QUEUE & queues); 6329 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask); 6330 break; 6331 case ixgbe_mac_82599EB: 6332 case ixgbe_mac_X540: 6333 case ixgbe_mac_X550: 6334 case ixgbe_mac_X550EM_x: 6335 case ixgbe_mac_X550EM_a: 6336 mask = (queues & 0xFFFFFFFF); 6337 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask); 6338 mask = (queues >> 32); 6339 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask); 6340 break; 6341 default: 6342 break; 6343 } 6344 } /* ixgbe_rearm_queues */ 6345
Indexes created Mon Sep 29 21:09:56 GMT 2025