svn commit: r280182 - in head/sys: amd64/conf conf dev/ixgbe modules/ix modules/ixgbe modules/ixv
Nathan Whitehorn
nwhitehorn at freebsd.org
Wed Mar 18 15:20:48 UTC 2015
On 03/17/15 11:32, Jack F Vogel wrote:
> Author: jfv
> Date: Tue Mar 17 18:32:28 2015
> New Revision: 280182
> URL: https://svnweb.freebsd.org/changeset/base/280182
>
> Log:
> Update to the Intel ixgbe driver:
> - Split the driver into independent pf and vf loadables. This is
> in preparation for SRIOV support which will be following shortly.
> This also allows us to keep a seperate revision control over the
> two parts, making for easier sustaining.
> - Make the TX/RX code a shared/seperated file, in the old code base
> the ixv code would miss fixes that went into ixgbe, this model
> will eliminate that problem.
> - The driver loadables will now match the device names, something that
> has been requested for some time.
> - Rather than a modules/ixgbe there is now modules/ix and modules/ixv
> - It will also be possible to make your static kernel with only one
> or the other for streamlined installs, or both.
>
> Enjoy!
>
> Submitted by: jfv and erj
>
> Added:
> head/sys/dev/ixgbe/if_ix.c (contents, props changed)
> head/sys/dev/ixgbe/if_ixv.c (contents, props changed)
> head/sys/dev/ixgbe/ix_txrx.c (contents, props changed)
> head/sys/modules/ix/
> head/sys/modules/ix/Makefile (contents, props changed)
> head/sys/modules/ixv/
> head/sys/modules/ixv/Makefile (contents, props changed)
> Deleted:
> head/sys/dev/ixgbe/ixgbe.c
> head/sys/dev/ixgbe/ixv.c
> head/sys/dev/ixgbe/ixv.h
> head/sys/modules/ixgbe/
> Modified:
> head/sys/amd64/conf/GENERIC
Note that the mips OCTEON1 and PowerPC GENERIC64 config files also need
to be changed here and are currently unbuildable.
-Nathan
> head/sys/conf/NOTES
> head/sys/conf/files
> head/sys/dev/ixgbe/LICENSE
> head/sys/dev/ixgbe/ixgbe.h
> head/sys/dev/ixgbe/ixgbe_82598.c
> head/sys/dev/ixgbe/ixgbe_82598.h
> head/sys/dev/ixgbe/ixgbe_82599.c
> head/sys/dev/ixgbe/ixgbe_82599.h
> head/sys/dev/ixgbe/ixgbe_api.c
> head/sys/dev/ixgbe/ixgbe_api.h
> head/sys/dev/ixgbe/ixgbe_common.c
> head/sys/dev/ixgbe/ixgbe_common.h
> head/sys/dev/ixgbe/ixgbe_dcb.c
> head/sys/dev/ixgbe/ixgbe_dcb.h
> head/sys/dev/ixgbe/ixgbe_dcb_82598.c
> head/sys/dev/ixgbe/ixgbe_dcb_82598.h
> head/sys/dev/ixgbe/ixgbe_dcb_82599.c
> head/sys/dev/ixgbe/ixgbe_dcb_82599.h
> head/sys/dev/ixgbe/ixgbe_mbx.c
> head/sys/dev/ixgbe/ixgbe_mbx.h
> head/sys/dev/ixgbe/ixgbe_phy.c
> head/sys/dev/ixgbe/ixgbe_phy.h
> head/sys/dev/ixgbe/ixgbe_type.h
> head/sys/dev/ixgbe/ixgbe_vf.c
> head/sys/dev/ixgbe/ixgbe_vf.h
> head/sys/dev/ixgbe/ixgbe_x540.c
> head/sys/dev/ixgbe/ixgbe_x540.h
>
> Modified: head/sys/amd64/conf/GENERIC
> ==============================================================================
> --- head/sys/amd64/conf/GENERIC Tue Mar 17 15:48:19 2015 (r280181)
> +++ head/sys/amd64/conf/GENERIC Tue Mar 17 18:32:28 2015 (r280182)
> @@ -216,7 +216,8 @@ device bxe # Broadcom NetXtreme II BC
> device de # DEC/Intel DC21x4x (``Tulip'')
> device em # Intel PRO/1000 Gigabit Ethernet Family
> device igb # Intel PRO/1000 PCIE Server Gigabit Family
> -device ixgbe # Intel PRO/10GbE PCIE Ethernet Family
> +device ix # Intel PRO/10GbE PCIE PF Ethernet
> +device ixv # Intel PRO/10GbE PCIE VF Ethernet
> device ixl # Intel XL710 40Gbe PCIE Ethernet
> device ixlv # Intel XL710 40Gbe VF PCIE Ethernet
> device le # AMD Am7900 LANCE and Am79C9xx PCnet
>
> Modified: head/sys/conf/NOTES
> ==============================================================================
> --- head/sys/conf/NOTES Tue Mar 17 15:48:19 2015 (r280181)
> +++ head/sys/conf/NOTES Tue Mar 17 18:32:28 2015 (r280182)
> @@ -2100,7 +2100,8 @@ device de # DEC/Intel DC21x4x (``Tulip
> device em # Intel Pro/1000 Gigabit Ethernet
> device igb # Intel Pro/1000 PCIE Gigabit Ethernet
> device ixgb # Intel Pro/10Gbe PCI-X Ethernet
> -device ixgbe # Intel Pro/10Gbe PCIE Ethernet
> +device ix # Intel Pro/10Gbe PCIE Ethernet
> +device ixv # Intel Pro/10Gbe PCIE Ethernet VF
> device le # AMD Am7900 LANCE and Am79C9xx PCnet
> device mxge # Myricom Myri-10G 10GbE NIC
> device nxge # Neterion Xframe 10GbE Server/Storage Adapter
>
> Modified: head/sys/conf/files
> ==============================================================================
> --- head/sys/conf/files Tue Mar 17 15:48:19 2015 (r280181)
> +++ head/sys/conf/files Tue Mar 17 18:32:28 2015 (r280182)
> @@ -1769,31 +1769,31 @@ iwn6050.fw optional iwn6050fw | iwnfw
> dev/ixgb/if_ixgb.c optional ixgb
> dev/ixgb/ixgb_ee.c optional ixgb
> dev/ixgb/ixgb_hw.c optional ixgb
> -dev/ixgbe/ixgbe.c optional ixgbe inet \
> +dev/ixgbe/if_ix.c optional ix inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe -DSMP"
> -dev/ixgbe/ixv.c optional ixgbe inet \
> - compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_phy.c optional ixgbe inet \
> +dev/ixgbe/if_ixv.c optional ixv inet \
> + compile-with "${NORMAL_C} -I$S/dev/ixgbe -DSMP"
> +dev/ixgbe/ixgbe_phy.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_api.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_api.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_common.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_common.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_mbx.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_mbx.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_vf.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_vf.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_82598.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_82598.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_82599.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_82599.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_x540.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_x540.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_dcb.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_dcb.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_dcb_82598.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_dcb_82598.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> -dev/ixgbe/ixgbe_dcb_82599.c optional ixgbe inet \
> +dev/ixgbe/ixgbe_dcb_82599.c optional ix ixv inet \
> compile-with "${NORMAL_C} -I$S/dev/ixgbe"
> dev/jme/if_jme.c optional jme pci
> dev/joy/joy.c optional joy
>
> Modified: head/sys/dev/ixgbe/LICENSE
> ==============================================================================
> --- head/sys/dev/ixgbe/LICENSE Tue Mar 17 15:48:19 2015 (r280181)
> +++ head/sys/dev/ixgbe/LICENSE Tue Mar 17 18:32:28 2015 (r280182)
> @@ -1,6 +1,6 @@
> /******************************************************************************
>
> - Copyright (c) 2001-2013, Intel Corporation
> + Copyright (c) 2001-2015, Intel Corporation
> All rights reserved.
>
> Redistribution and use in source and binary forms, with or without
>
> Added: head/sys/dev/ixgbe/if_ix.c
> ==============================================================================
> --- /dev/null 00:00:00 1970 (empty, because file is newly added)
> +++ head/sys/dev/ixgbe/if_ix.c Tue Mar 17 18:32:28 2015 (r280182)
> @@ -0,0 +1,4163 @@
> +/******************************************************************************
> +
> + Copyright (c) 2001-2015, Intel Corporation
> + All rights reserved.
> +
> + Redistribution and use in source and binary forms, with or without
> + modification, are permitted provided that the following conditions are met:
> +
> + 1. Redistributions of source code must retain the above copyright notice,
> + this list of conditions and the following disclaimer.
> +
> + 2. Redistributions in binary form must reproduce the above copyright
> + notice, this list of conditions and the following disclaimer in the
> + documentation and/or other materials provided with the distribution.
> +
> + 3. Neither the name of the Intel Corporation nor the names of its
> + contributors may be used to endorse or promote products derived from
> + this software without specific prior written permission.
> +
> + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
> + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
> + POSSIBILITY OF SUCH DAMAGE.
> +
> +******************************************************************************/
> +/*$FreeBSD$*/
> +
> +
> +#ifndef IXGBE_STANDALONE_BUILD
> +#include "opt_inet.h"
> +#include "opt_inet6.h"
> +#include "opt_rss.h"
> +#endif
> +
> +#include "ixgbe.h"
> +
> +#ifdef RSS
> +#include <netinet/in_rss.h>
> +#endif
> +
> +/*********************************************************************
> + * Set this to one to display debug statistics
> + *********************************************************************/
> +int ixgbe_display_debug_stats = 0;
> +
> +/*********************************************************************
> + * Driver version
> + *********************************************************************/
> +char ixgbe_driver_version[] = "2.7.4";
> +
> +/*********************************************************************
> + * PCI Device ID Table
> + *
> + * Used by probe to select devices to load on
> + * Last field stores an index into ixgbe_strings
> + * Last entry must be all 0s
> + *
> + * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
> + *********************************************************************/
> +
> +static ixgbe_vendor_info_t ixgbe_vendor_info_array[] =
> +{
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, 0, 0, 0},
> + {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, 0, 0, 0},
> + /* required last entry */
> + {0, 0, 0, 0, 0}
> +};
> +
> +/*********************************************************************
> + * Table of branding strings
> + *********************************************************************/
> +
> +static char *ixgbe_strings[] = {
> + "Intel(R) PRO/10GbE PCI-Express Network Driver"
> +};
> +
> +/*********************************************************************
> + * Function prototypes
> + *********************************************************************/
> +static int ixgbe_probe(device_t);
> +static int ixgbe_attach(device_t);
> +static int ixgbe_detach(device_t);
> +static int ixgbe_shutdown(device_t);
> +static int ixgbe_ioctl(struct ifnet *, u_long, caddr_t);
> +static void ixgbe_init(void *);
> +static void ixgbe_init_locked(struct adapter *);
> +static void ixgbe_stop(void *);
> +#if __FreeBSD_version >= 1100036
> +static uint64_t ixgbe_get_counter(struct ifnet *, ift_counter);
> +#endif
> +static void ixgbe_add_media_types(struct adapter *);
> +static void ixgbe_media_status(struct ifnet *, struct ifmediareq *);
> +static int ixgbe_media_change(struct ifnet *);
> +static void ixgbe_identify_hardware(struct adapter *);
> +static int ixgbe_allocate_pci_resources(struct adapter *);
> +static void ixgbe_get_slot_info(struct ixgbe_hw *);
> +static int ixgbe_allocate_msix(struct adapter *);
> +static int ixgbe_allocate_legacy(struct adapter *);
> +static int ixgbe_setup_msix(struct adapter *);
> +static void ixgbe_free_pci_resources(struct adapter *);
> +static void ixgbe_local_timer(void *);
> +static int ixgbe_setup_interface(device_t, struct adapter *);
> +static void ixgbe_config_link(struct adapter *);
> +static void ixgbe_rearm_queues(struct adapter *, u64);
> +
> +static void ixgbe_initialize_transmit_units(struct adapter *);
> +static void ixgbe_initialize_receive_units(struct adapter *);
> +static void ixgbe_enable_rx_drop(struct adapter *);
> +static void ixgbe_disable_rx_drop(struct adapter *);
> +
> +static void ixgbe_enable_intr(struct adapter *);
> +static void ixgbe_disable_intr(struct adapter *);
> +static void ixgbe_update_stats_counters(struct adapter *);
> +static void ixgbe_set_promisc(struct adapter *);
> +static void ixgbe_set_multi(struct adapter *);
> +static void ixgbe_update_link_status(struct adapter *);
> +static int ixgbe_set_flowcntl(SYSCTL_HANDLER_ARGS);
> +static int ixgbe_set_advertise(SYSCTL_HANDLER_ARGS);
> +static int ixgbe_set_thermal_test(SYSCTL_HANDLER_ARGS);
> +static void ixgbe_set_ivar(struct adapter *, u8, u8, s8);
> +static void ixgbe_configure_ivars(struct adapter *);
> +static u8 * ixgbe_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *);
> +
> +static void ixgbe_setup_vlan_hw_support(struct adapter *);
> +static void ixgbe_register_vlan(void *, struct ifnet *, u16);
> +static void ixgbe_unregister_vlan(void *, struct ifnet *, u16);
> +
> +static void ixgbe_add_hw_stats(struct adapter *adapter);
> +
> +/* Support for pluggable optic modules */
> +static bool ixgbe_sfp_probe(struct adapter *);
> +static void ixgbe_setup_optics(struct adapter *);
> +
> +/* Legacy (single vector interrupt handler */
> +static void ixgbe_legacy_irq(void *);
> +
> +/* The MSI/X Interrupt handlers */
> +static void ixgbe_msix_que(void *);
> +static void ixgbe_msix_link(void *);
> +
> +/* Deferred interrupt tasklets */
> +static void ixgbe_handle_que(void *, int);
> +static void ixgbe_handle_link(void *, int);
> +static void ixgbe_handle_msf(void *, int);
> +static void ixgbe_handle_mod(void *, int);
> +
> +#ifdef IXGBE_FDIR
> +static void ixgbe_reinit_fdir(void *, int);
> +#endif
> +
> +
> +/* Missing shared code prototype */
> +extern void ixgbe_stop_mac_link_on_d3_82599(struct ixgbe_hw *hw);
> +
> +/*********************************************************************
> + * FreeBSD Device Interface Entry Points
> + *********************************************************************/
> +
> +static device_method_t ixgbe_methods[] = {
> + /* Device interface */
> + DEVMETHOD(device_probe, ixgbe_probe),
> + DEVMETHOD(device_attach, ixgbe_attach),
> + DEVMETHOD(device_detach, ixgbe_detach),
> + DEVMETHOD(device_shutdown, ixgbe_shutdown),
> + DEVMETHOD_END
> +};
> +
> +static driver_t ixgbe_driver = {
> + "ix", ixgbe_methods, sizeof(struct adapter),
> +};
> +
> +devclass_t ixgbe_devclass;
> +DRIVER_MODULE(ixgbe, pci, ixgbe_driver, ixgbe_devclass, 0, 0);
> +
> +MODULE_DEPEND(ixgbe, pci, 1, 1, 1);
> +MODULE_DEPEND(ixgbe, ether, 1, 1, 1);
> +
> +/*
> +** TUNEABLE PARAMETERS:
> +*/
> +
> +static SYSCTL_NODE(_hw, OID_AUTO, ix, CTLFLAG_RD, 0,
> + "IXGBE driver parameters");
> +
> +/*
> +** AIM: Adaptive Interrupt Moderation
> +** which means that the interrupt rate
> +** is varied over time based on the
> +** traffic for that interrupt vector
> +*/
> +static int ixgbe_enable_aim = TRUE;
> +SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RWTUN, &ixgbe_enable_aim, 0,
> + "Enable adaptive interrupt moderation");
> +
> +static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY);
> +SYSCTL_INT(_hw_ix, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN,
> + &ixgbe_max_interrupt_rate, 0, "Maximum interrupts per second");
> +
> +/* How many packets rxeof tries to clean at a time */
> +static int ixgbe_rx_process_limit = 256;
> +TUNABLE_INT("hw.ixgbe.rx_process_limit", &ixgbe_rx_process_limit);
> +SYSCTL_INT(_hw_ix, OID_AUTO, rx_process_limit, CTLFLAG_RDTUN,
> + &ixgbe_rx_process_limit, 0,
> + "Maximum number of received packets to process at a time,"
> + "-1 means unlimited");
> +
> +/* How many packets txeof tries to clean at a time */
> +static int ixgbe_tx_process_limit = 256;
> +TUNABLE_INT("hw.ixgbe.tx_process_limit", &ixgbe_tx_process_limit);
> +SYSCTL_INT(_hw_ix, OID_AUTO, tx_process_limit, CTLFLAG_RDTUN,
> + &ixgbe_tx_process_limit, 0,
> + "Maximum number of sent packets to process at a time,"
> + "-1 means unlimited");
> +
> +/*
> +** Smart speed setting, default to on
> +** this only works as a compile option
> +** right now as its during attach, set
> +** this to 'ixgbe_smart_speed_off' to
> +** disable.
> +*/
> +static int ixgbe_smart_speed = ixgbe_smart_speed_on;
> +
> +/*
> + * MSIX should be the default for best performance,
> + * but this allows it to be forced off for testing.
> + */
> +static int ixgbe_enable_msix = 1;
> +SYSCTL_INT(_hw_ix, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixgbe_enable_msix, 0,
> + "Enable MSI-X interrupts");
> +
> +/*
> + * Number of Queues, can be set to 0,
> + * it then autoconfigures based on the
> + * number of cpus with a max of 8. This
> + * can be overriden manually here.
> + */
> +static int ixgbe_num_queues = 0;
> +SYSCTL_INT(_hw_ix, OID_AUTO, num_queues, CTLFLAG_RDTUN, &ixgbe_num_queues, 0,
> + "Number of queues to configure, 0 indicates autoconfigure");
> +
> +/*
> +** Number of TX descriptors per ring,
> +** setting higher than RX as this seems
> +** the better performing choice.
> +*/
> +static int ixgbe_txd = PERFORM_TXD;
> +SYSCTL_INT(_hw_ix, OID_AUTO, txd, CTLFLAG_RDTUN, &ixgbe_txd, 0,
> + "Number of transmit descriptors per queue");
> +
> +/* Number of RX descriptors per ring */
> +static int ixgbe_rxd = PERFORM_RXD;
> +SYSCTL_INT(_hw_ix, OID_AUTO, rxd, CTLFLAG_RDTUN, &ixgbe_rxd, 0,
> + "Number of receive descriptors per queue");
> +
> +/*
> +** Defining this on will allow the use
> +** of unsupported SFP+ modules, note that
> +** doing so you are on your own :)
> +*/
> +static int allow_unsupported_sfp = FALSE;
> +TUNABLE_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp);
> +
> +/* Keep running tab on them for sanity check */
> +static int ixgbe_total_ports;
> +
> +#ifdef IXGBE_FDIR
> +/*
> +** Flow Director actually 'steals'
> +** part of the packet buffer as its
> +** filter pool, this variable controls
> +** how much it uses:
> +** 0 = 64K, 1 = 128K, 2 = 256K
> +*/
> +static int fdir_pballoc = 1;
> +#endif
> +
> +#ifdef DEV_NETMAP
> +/*
> + * The #ifdef DEV_NETMAP / #endif blocks in this file are meant to
> + * be a reference on how to implement netmap support in a driver.
> + * Additional comments are in ixgbe_netmap.h .
> + *
> + * <dev/netmap/ixgbe_netmap.h> contains functions for netmap support
> + * that extend the standard driver.
> + */
> +#include <dev/netmap/ixgbe_netmap.h>
> +#endif /* DEV_NETMAP */
> +
> +/*********************************************************************
> + * Device identification routine
> + *
> + * ixgbe_probe determines if the driver should be loaded on
> + * adapter based on PCI vendor/device id of the adapter.
> + *
> + * return BUS_PROBE_DEFAULT on success, positive on failure
> + *********************************************************************/
> +
> +static int
> +ixgbe_probe(device_t dev)
> +{
> + ixgbe_vendor_info_t *ent;
> +
> + u16 pci_vendor_id = 0;
> + u16 pci_device_id = 0;
> + u16 pci_subvendor_id = 0;
> + u16 pci_subdevice_id = 0;
> + char adapter_name[256];
> +
> + INIT_DEBUGOUT("ixgbe_probe: begin");
> +
> + pci_vendor_id = pci_get_vendor(dev);
> + if (pci_vendor_id != IXGBE_INTEL_VENDOR_ID)
> + return (ENXIO);
> +
> + pci_device_id = pci_get_device(dev);
> + pci_subvendor_id = pci_get_subvendor(dev);
> + pci_subdevice_id = pci_get_subdevice(dev);
> +
> + ent = ixgbe_vendor_info_array;
> + while (ent->vendor_id != 0) {
> + if ((pci_vendor_id == ent->vendor_id) &&
> + (pci_device_id == ent->device_id) &&
> +
> + ((pci_subvendor_id == ent->subvendor_id) ||
> + (ent->subvendor_id == 0)) &&
> +
> + ((pci_subdevice_id == ent->subdevice_id) ||
> + (ent->subdevice_id == 0))) {
> + sprintf(adapter_name, "%s, Version - %s",
> + ixgbe_strings[ent->index],
> + ixgbe_driver_version);
> + device_set_desc_copy(dev, adapter_name);
> + ++ixgbe_total_ports;
> + return (BUS_PROBE_DEFAULT);
> + }
> + ent++;
> + }
> + return (ENXIO);
> +}
> +
> +/*********************************************************************
> + * Device initialization routine
> + *
> + * The attach entry point is called when the driver is being loaded.
> + * This routine identifies the type of hardware, allocates all resources
> + * and initializes the hardware.
> + *
> + * return 0 on success, positive on failure
> + *********************************************************************/
> +
> +static int
> +ixgbe_attach(device_t dev)
> +{
> + struct adapter *adapter;
> + struct ixgbe_hw *hw;
> + int error = 0;
> + u16 csum;
> + u32 ctrl_ext;
> +
> + INIT_DEBUGOUT("ixgbe_attach: begin");
> +
> + /* Allocate, clear, and link in our adapter structure */
> + adapter = device_get_softc(dev);
> + adapter->dev = adapter->osdep.dev = dev;
> + hw = &adapter->hw;
> +
> + /* Core Lock Init*/
> + IXGBE_CORE_LOCK_INIT(adapter, device_get_nameunit(dev));
> +
> + /* SYSCTL APIs */
> + SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
> + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
> + OID_AUTO, "fc", CTLTYPE_INT | CTLFLAG_RW,
> + adapter, 0, ixgbe_set_flowcntl, "I", IXGBE_SYSCTL_DESC_SET_FC);
> +
> + SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
> + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
> + OID_AUTO, "enable_aim", CTLFLAG_RW,
> + &ixgbe_enable_aim, 1, "Interrupt Moderation");
> +
> + /*
> + ** Allow a kind of speed control by forcing the autoneg
> + ** advertised speed list to only a certain value, this
> + ** supports 1G on 82599 devices, and 100Mb on x540.
> + */
> + SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
> + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
> + OID_AUTO, "advertise_speed", CTLTYPE_INT | CTLFLAG_RW,
> + adapter, 0, ixgbe_set_advertise, "I", IXGBE_SYSCTL_DESC_ADV_SPEED);
> +
> + SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
> + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
> + OID_AUTO, "ts", CTLTYPE_INT | CTLFLAG_RW, adapter,
> + 0, ixgbe_set_thermal_test, "I", "Thermal Test");
> +
> + /* Set up the timer callout */
> + callout_init_mtx(&adapter->timer, &adapter->core_mtx, 0);
> +
> + /* Determine hardware revision */
> + ixgbe_identify_hardware(adapter);
> +
> + /* Do base PCI setup - map BAR0 */
> + if (ixgbe_allocate_pci_resources(adapter)) {
> + device_printf(dev, "Allocation of PCI resources failed\n");
> + error = ENXIO;
> + goto err_out;
> + }
> +
> + /* Do descriptor calc and sanity checks */
> + if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 ||
> + ixgbe_txd < MIN_TXD || ixgbe_txd > MAX_TXD) {
> + device_printf(dev, "TXD config issue, using default!\n");
> + adapter->num_tx_desc = DEFAULT_TXD;
> + } else
> + adapter->num_tx_desc = ixgbe_txd;
> +
> + /*
> + ** With many RX rings it is easy to exceed the
> + ** system mbuf allocation. Tuning nmbclusters
> + ** can alleviate this.
> + */
> + if (nmbclusters > 0) {
> + int s;
> + s = (ixgbe_rxd * adapter->num_queues) * ixgbe_total_ports;
> + if (s > nmbclusters) {
> + device_printf(dev, "RX Descriptors exceed "
> + "system mbuf max, using default instead!\n");
> + ixgbe_rxd = DEFAULT_RXD;
> + }
> + }
> +
> + if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 ||
> + ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) {
> + device_printf(dev, "RXD config issue, using default!\n");
> + adapter->num_rx_desc = DEFAULT_RXD;
> + } else
> + adapter->num_rx_desc = ixgbe_rxd;
> +
> + /* Allocate our TX/RX Queues */
> + if (ixgbe_allocate_queues(adapter)) {
> + error = ENOMEM;
> + goto err_out;
> + }
> +
> + /* Allocate multicast array memory. */
> + adapter->mta = malloc(sizeof(u8) * IXGBE_ETH_LENGTH_OF_ADDRESS *
> + MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT);
> + if (adapter->mta == NULL) {
> + device_printf(dev, "Can not allocate multicast setup array\n");
> + error = ENOMEM;
> + goto err_late;
> + }
> +
> + /* Initialize the shared code */
> + hw->allow_unsupported_sfp = allow_unsupported_sfp;
> + error = ixgbe_init_shared_code(hw);
> + if (error == IXGBE_ERR_SFP_NOT_PRESENT) {
> + /*
> + ** No optics in this port, set up
> + ** so the timer routine will probe
> + ** for later insertion.
> + */
> + adapter->sfp_probe = TRUE;
> + error = 0;
> + } else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) {
> + device_printf(dev,"Unsupported SFP+ module detected!\n");
> + error = EIO;
> + goto err_late;
> + } else if (error) {
> + device_printf(dev,"Unable to initialize the shared code\n");
> + error = EIO;
> + goto err_late;
> + }
> +
> + /* Make sure we have a good EEPROM before we read from it */
> + if (ixgbe_validate_eeprom_checksum(&adapter->hw, &csum) < 0) {
> + device_printf(dev,"The EEPROM Checksum Is Not Valid\n");
> + error = EIO;
> + goto err_late;
> + }
> +
> + error = ixgbe_init_hw(hw);
> + switch (error) {
> + case IXGBE_ERR_EEPROM_VERSION:
> + device_printf(dev, "This device is a pre-production adapter/"
> + "LOM. Please be aware there may be issues associated "
> + "with your hardware.\n If you are experiencing problems "
> + "please contact your Intel or hardware representative "
> + "who provided you with this hardware.\n");
> + break;
> + case IXGBE_ERR_SFP_NOT_SUPPORTED:
> + device_printf(dev,"Unsupported SFP+ Module\n");
> + error = EIO;
> + goto err_late;
> + case IXGBE_ERR_SFP_NOT_PRESENT:
> + device_printf(dev,"No SFP+ Module found\n");
> + /* falls thru */
> + default:
> + break;
> + }
> +
> + /* Detect and set physical type */
> + ixgbe_setup_optics(adapter);
> +
> + if ((adapter->msix > 1) && (ixgbe_enable_msix))
> + error = ixgbe_allocate_msix(adapter);
> + else
> + error = ixgbe_allocate_legacy(adapter);
> + if (error)
> + goto err_late;
> +
> + /* Setup OS specific network interface */
> + if (ixgbe_setup_interface(dev, adapter) != 0)
> + goto err_late;
> +
> + /* Initialize statistics */
> + ixgbe_update_stats_counters(adapter);
> +
> + /* Register for VLAN events */
> + adapter->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
> + ixgbe_register_vlan, adapter, EVENTHANDLER_PRI_FIRST);
> + adapter->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
> + ixgbe_unregister_vlan, adapter, EVENTHANDLER_PRI_FIRST);
> +
> + /*
> + ** Check PCIE slot type/speed/width
> + */
> + ixgbe_get_slot_info(hw);
> +
> +
> + /* Set an initial default flow control value */
> + adapter->fc = ixgbe_fc_full;
> +
> + /* let hardware know driver is loaded */
> + ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
> + ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD;
> + IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
> +
> + ixgbe_add_hw_stats(adapter);
> +
> +#ifdef DEV_NETMAP
> + ixgbe_netmap_attach(adapter);
> +#endif /* DEV_NETMAP */
> + INIT_DEBUGOUT("ixgbe_attach: end");
> + return (0);
> +
> +err_late:
> + ixgbe_free_transmit_structures(adapter);
> + ixgbe_free_receive_structures(adapter);
> +err_out:
> + if (adapter->ifp != NULL)
> + if_free(adapter->ifp);
> + ixgbe_free_pci_resources(adapter);
> + free(adapter->mta, M_DEVBUF);
> + return (error);
> +}
> +
> +/*********************************************************************
> + * Device removal routine
> + *
> + * The detach entry point is called when the driver is being removed.
> + * This routine stops the adapter and deallocates all the resources
> + * that were allocated for driver operation.
> + *
> + * return 0 on success, positive on failure
> + *********************************************************************/
> +
> +static int
> +ixgbe_detach(device_t dev)
> +{
> + struct adapter *adapter = device_get_softc(dev);
> + struct ix_queue *que = adapter->queues;
> + struct tx_ring *txr = adapter->tx_rings;
> + u32 ctrl_ext;
> +
> + INIT_DEBUGOUT("ixgbe_detach: begin");
> +
> + /* Make sure VLANS are not using driver */
> + if (adapter->ifp->if_vlantrunk != NULL) {
> + device_printf(dev,"Vlan in use, detach first\n");
> + return (EBUSY);
> + }
> +
> + IXGBE_CORE_LOCK(adapter);
> + ixgbe_stop(adapter);
> + IXGBE_CORE_UNLOCK(adapter);
> +
> + for (int i = 0; i < adapter->num_queues; i++, que++, txr++) {
> + if (que->tq) {
> +#ifndef IXGBE_LEGACY_TX
> + taskqueue_drain(que->tq, &txr->txq_task);
> +#endif
> + taskqueue_drain(que->tq, &que->que_task);
> + taskqueue_free(que->tq);
> + }
> + }
> +
> + /* Drain the Link queue */
> + if (adapter->tq) {
> + taskqueue_drain(adapter->tq, &adapter->link_task);
> + taskqueue_drain(adapter->tq, &adapter->mod_task);
> + taskqueue_drain(adapter->tq, &adapter->msf_task);
> +#ifdef IXGBE_FDIR
> + taskqueue_drain(adapter->tq, &adapter->fdir_task);
> +#endif
> + taskqueue_free(adapter->tq);
> + }
> +
> + /* let hardware know driver is unloading */
> + ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
> + ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD;
> + IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext);
> +
> + /* Unregister VLAN events */
> + if (adapter->vlan_attach != NULL)
> + EVENTHANDLER_DEREGISTER(vlan_config, adapter->vlan_attach);
> + if (adapter->vlan_detach != NULL)
> + EVENTHANDLER_DEREGISTER(vlan_unconfig, adapter->vlan_detach);
> +
> + ether_ifdetach(adapter->ifp);
> + callout_drain(&adapter->timer);
> +#ifdef DEV_NETMAP
> + netmap_detach(adapter->ifp);
> +#endif /* DEV_NETMAP */
> + ixgbe_free_pci_resources(adapter);
> + bus_generic_detach(dev);
> + if_free(adapter->ifp);
> +
> + ixgbe_free_transmit_structures(adapter);
> + ixgbe_free_receive_structures(adapter);
> + free(adapter->mta, M_DEVBUF);
> +
> + IXGBE_CORE_LOCK_DESTROY(adapter);
> + return (0);
> +}
> +
> +/*********************************************************************
> + *
> + * Shutdown entry point
> + *
> + **********************************************************************/
> +
> +static int
> +ixgbe_shutdown(device_t dev)
> +{
> + struct adapter *adapter = device_get_softc(dev);
> + IXGBE_CORE_LOCK(adapter);
> + ixgbe_stop(adapter);
> + IXGBE_CORE_UNLOCK(adapter);
> + return (0);
> +}
> +
> +
> +/*********************************************************************
> + * Ioctl entry point
> + *
> + * ixgbe_ioctl is called when the user wants to configure the
> + * interface.
> + *
> + * return 0 on success, positive on failure
> + **********************************************************************/
> +
> +static int
> +ixgbe_ioctl(struct ifnet * ifp, u_long command, caddr_t data)
> +{
> + struct adapter *adapter = ifp->if_softc;
> + struct ifreq *ifr = (struct ifreq *) data;
> +#if defined(INET) || defined(INET6)
> + struct ifaddr *ifa = (struct ifaddr *)data;
> + bool avoid_reset = FALSE;
> +#endif
> + int error = 0;
> +
> + switch (command) {
> +
> + case SIOCSIFADDR:
> +#ifdef INET
> + if (ifa->ifa_addr->sa_family == AF_INET)
> + avoid_reset = TRUE;
> +#endif
> +#ifdef INET6
> + if (ifa->ifa_addr->sa_family == AF_INET6)
> + avoid_reset = TRUE;
> +#endif
> +#if defined(INET) || defined(INET6)
> + /*
> + ** Calling init results in link renegotiation,
> + ** so we avoid doing it when possible.
> + */
> + if (avoid_reset) {
> + ifp->if_flags |= IFF_UP;
> + if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
> + ixgbe_init(adapter);
> + if (!(ifp->if_flags & IFF_NOARP))
> + arp_ifinit(ifp, ifa);
> + } else
> + error = ether_ioctl(ifp, command, data);
> +#endif
> + break;
> + case SIOCSIFMTU:
> + IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
> + if (ifr->ifr_mtu > IXGBE_MAX_FRAME_SIZE - ETHER_HDR_LEN) {
> + error = EINVAL;
> + } else {
> + IXGBE_CORE_LOCK(adapter);
> + ifp->if_mtu = ifr->ifr_mtu;
> + adapter->max_frame_size =
> + ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
> + ixgbe_init_locked(adapter);
> + IXGBE_CORE_UNLOCK(adapter);
> + }
> + break;
> + case SIOCSIFFLAGS:
> + IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)");
> + IXGBE_CORE_LOCK(adapter);
> + if (ifp->if_flags & IFF_UP) {
> + if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) {
> + if ((ifp->if_flags ^ adapter->if_flags) &
> + (IFF_PROMISC | IFF_ALLMULTI)) {
> + ixgbe_set_promisc(adapter);
> + }
> + } else
> + ixgbe_init_locked(adapter);
> + } else
> + if (ifp->if_drv_flags & IFF_DRV_RUNNING)
> + ixgbe_stop(adapter);
> + adapter->if_flags = ifp->if_flags;
> + IXGBE_CORE_UNLOCK(adapter);
> + break;
> + case SIOCADDMULTI:
> + case SIOCDELMULTI:
> + IOCTL_DEBUGOUT("ioctl: SIOC(ADD|DEL)MULTI");
> + if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
> + IXGBE_CORE_LOCK(adapter);
> + ixgbe_disable_intr(adapter);
> + ixgbe_set_multi(adapter);
> + ixgbe_enable_intr(adapter);
> + IXGBE_CORE_UNLOCK(adapter);
> + }
> + break;
> + case SIOCSIFMEDIA:
> + case SIOCGIFMEDIA:
> + IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)");
> + error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
> + break;
> + case SIOCSIFCAP:
> + {
> + int mask = ifr->ifr_reqcap ^ ifp->if_capenable;
> + IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)");
> + if (mask & IFCAP_HWCSUM)
> + ifp->if_capenable ^= IFCAP_HWCSUM;
> + if (mask & IFCAP_TSO4)
> + ifp->if_capenable ^= IFCAP_TSO4;
> + if (mask & IFCAP_TSO6)
> + ifp->if_capenable ^= IFCAP_TSO6;
> + if (mask & IFCAP_LRO)
> + ifp->if_capenable ^= IFCAP_LRO;
> + if (mask & IFCAP_VLAN_HWTAGGING)
> + ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
> + if (mask & IFCAP_VLAN_HWFILTER)
> + ifp->if_capenable ^= IFCAP_VLAN_HWFILTER;
> + if (mask & IFCAP_VLAN_HWTSO)
> + ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
> + if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
> + IXGBE_CORE_LOCK(adapter);
> + ixgbe_init_locked(adapter);
> + IXGBE_CORE_UNLOCK(adapter);
> + }
> + VLAN_CAPABILITIES(ifp);
> + break;
> + }
> +#if __FreeBSD_version >= 1100036
> + case SIOCGI2C:
> + {
> + struct ixgbe_hw *hw = &adapter->hw;
> + struct ifi2creq i2c;
> + int i;
> + IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)");
> + error = copyin(ifr->ifr_data, &i2c, sizeof(i2c));
> + if (error != 0)
> + break;
> + if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) {
> + error = EINVAL;
> + break;
> + }
> + if (i2c.len > sizeof(i2c.data)) {
> + error = EINVAL;
> + break;
> + }
> +
> + for (i = 0; i < i2c.len; i++)
> + hw->phy.ops.read_i2c_byte(hw, i2c.offset + i,
> + i2c.dev_addr, &i2c.data[i]);
> + error = copyout(&i2c, ifr->ifr_data, sizeof(i2c));
> + break;
> + }
> +#endif
> + default:
> + IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)\n", (int)command);
> + error = ether_ioctl(ifp, command, data);
> + break;
> + }
> +
> + return (error);
> +}
> +
> +/*********************************************************************
> + * Init entry point
> + *
> + * This routine is used in two ways. It is used by the stack as
> + * init entry point in network interface structure. It is also used
> + * by the driver as a hw/sw initialization routine to get to a
> + * consistent state.
> + *
> + * return 0 on success, positive on failure
> + **********************************************************************/
> +#define IXGBE_MHADD_MFS_SHIFT 16
> +
> +static void
> +ixgbe_init_locked(struct adapter *adapter)
> +{
> + struct ifnet *ifp = adapter->ifp;
> + device_t dev = adapter->dev;
> + struct ixgbe_hw *hw = &adapter->hw;
> + u32 k, txdctl, mhadd, gpie;
> + u32 rxdctl, rxctrl;
> +
> + mtx_assert(&adapter->core_mtx, MA_OWNED);
> + INIT_DEBUGOUT("ixgbe_init_locked: begin");
> + hw->adapter_stopped = FALSE;
> + ixgbe_stop_adapter(hw);
> + callout_stop(&adapter->timer);
> +
> + /* reprogram the RAR[0] in case user changed it. */
> + ixgbe_set_rar(hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV);
> +
> + /* Get the latest mac address, User can use a LAA */
> + bcopy(IF_LLADDR(adapter->ifp), hw->mac.addr,
> + IXGBE_ETH_LENGTH_OF_ADDRESS);
> + ixgbe_set_rar(hw, 0, hw->mac.addr, 0, 1);
> + hw->addr_ctrl.rar_used_count = 1;
> +
> + /* Set the various hardware offload abilities */
> + ifp->if_hwassist = 0;
> + if (ifp->if_capenable & IFCAP_TSO)
> + ifp->if_hwassist |= CSUM_TSO;
> + if (ifp->if_capenable & IFCAP_TXCSUM) {
> + ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP);
> +#if __FreeBSD_version >= 800000
> + if (hw->mac.type != ixgbe_mac_82598EB)
> + ifp->if_hwassist |= CSUM_SCTP;
> +#endif
> + }
> +
> + /* Prepare transmit descriptors and buffers */
> + if (ixgbe_setup_transmit_structures(adapter)) {
> + device_printf(dev,"Could not setup transmit structures\n");
> + ixgbe_stop(adapter);
> + return;
> + }
> +
> + ixgbe_init_hw(hw);
> + ixgbe_initialize_transmit_units(adapter);
> +
> + /* Setup Multicast table */
> + ixgbe_set_multi(adapter);
> +
> + /*
> + ** Determine the correct mbuf pool
> + ** for doing jumbo frames
> + */
> + if (adapter->max_frame_size <= 2048)
> + adapter->rx_mbuf_sz = MCLBYTES;
> + else if (adapter->max_frame_size <= 4096)
> + adapter->rx_mbuf_sz = MJUMPAGESIZE;
> + else if (adapter->max_frame_size <= 9216)
> + adapter->rx_mbuf_sz = MJUM9BYTES;
> + else
> + adapter->rx_mbuf_sz = MJUM16BYTES;
>
> *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
>
More information about the svn-src-all
mailing list