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