// SPDX-License-Identifier: GPL-2.0 /* Copyright(c) 2007 - 2018 Intel Corporation. */ #define pr_fmt(fmt) … #include <linux/module.h> #include <linux/types.h> #include <linux/init.h> #include <linux/bitops.h> #include <linux/vmalloc.h> #include <linux/pagemap.h> #include <linux/netdevice.h> #include <linux/ipv6.h> #include <linux/slab.h> #include <net/checksum.h> #include <net/ip6_checksum.h> #include <net/pkt_sched.h> #include <net/pkt_cls.h> #include <linux/net_tstamp.h> #include <linux/mii.h> #include <linux/ethtool.h> #include <linux/if.h> #include <linux/if_vlan.h> #include <linux/pci.h> #include <linux/delay.h> #include <linux/interrupt.h> #include <linux/ip.h> #include <linux/tcp.h> #include <linux/sctp.h> #include <linux/if_ether.h> #include <linux/prefetch.h> #include <linux/bpf.h> #include <linux/bpf_trace.h> #include <linux/pm_runtime.h> #include <linux/etherdevice.h> #include <linux/lockdep.h> #ifdef CONFIG_IGB_DCA #include <linux/dca.h> #endif #include <linux/i2c.h> #include "igb.h" enum queue_mode { … }; enum tx_queue_prio { … }; char igb_driver_name[] = …; static const char igb_driver_string[] = …; static const char igb_copyright[] = …; static const struct e1000_info *igb_info_tbl[] = …; static const struct pci_device_id igb_pci_tbl[] = …; MODULE_DEVICE_TABLE(pci, igb_pci_tbl); static int igb_setup_all_tx_resources(struct igb_adapter *); static int igb_setup_all_rx_resources(struct igb_adapter *); static void igb_free_all_tx_resources(struct igb_adapter *); static void igb_free_all_rx_resources(struct igb_adapter *); static void igb_setup_mrqc(struct igb_adapter *); static void igb_init_queue_configuration(struct igb_adapter *adapter); static int igb_sw_init(struct igb_adapter *); int igb_open(struct net_device *); int igb_close(struct net_device *); static void igb_configure(struct igb_adapter *); static void igb_configure_tx(struct igb_adapter *); static void igb_configure_rx(struct igb_adapter *); static void igb_clean_all_tx_rings(struct igb_adapter *); static void igb_clean_all_rx_rings(struct igb_adapter *); static void igb_clean_tx_ring(struct igb_ring *); static void igb_clean_rx_ring(struct igb_ring *); static void igb_set_rx_mode(struct net_device *); static void igb_update_phy_info(struct timer_list *); static void igb_watchdog(struct timer_list *); static void igb_watchdog_task(struct work_struct *); static netdev_tx_t igb_xmit_frame(struct sk_buff *skb, struct net_device *); static void igb_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats); static int igb_change_mtu(struct net_device *, int); static int igb_set_mac(struct net_device *, void *); static void igb_set_uta(struct igb_adapter *adapter, bool set); static irqreturn_t igb_intr(int irq, void *); static irqreturn_t igb_intr_msi(int irq, void *); static irqreturn_t igb_msix_other(int irq, void *); static irqreturn_t igb_msix_ring(int irq, void *); #ifdef CONFIG_IGB_DCA static void igb_update_dca(struct igb_q_vector *); static void igb_setup_dca(struct igb_adapter *); #endif /* CONFIG_IGB_DCA */ static int igb_poll(struct napi_struct *, int); static bool igb_clean_tx_irq(struct igb_q_vector *, int); static int igb_clean_rx_irq(struct igb_q_vector *, int); static int igb_ioctl(struct net_device *, struct ifreq *, int cmd); static void igb_tx_timeout(struct net_device *, unsigned int txqueue); static void igb_reset_task(struct work_struct *); static void igb_vlan_mode(struct net_device *netdev, netdev_features_t features); static int igb_vlan_rx_add_vid(struct net_device *, __be16, u16); static int igb_vlan_rx_kill_vid(struct net_device *, __be16, u16); static void igb_restore_vlan(struct igb_adapter *); static void igb_rar_set_index(struct igb_adapter *, u32); static void igb_ping_all_vfs(struct igb_adapter *); static void igb_msg_task(struct igb_adapter *); static void igb_vmm_control(struct igb_adapter *); static int igb_set_vf_mac(struct igb_adapter *, int, unsigned char *); static void igb_flush_mac_table(struct igb_adapter *); static int igb_available_rars(struct igb_adapter *, u8); static void igb_set_default_mac_filter(struct igb_adapter *); static int igb_uc_sync(struct net_device *, const unsigned char *); static int igb_uc_unsync(struct net_device *, const unsigned char *); static void igb_restore_vf_multicasts(struct igb_adapter *adapter); static int igb_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac); static int igb_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos, __be16 vlan_proto); static int igb_ndo_set_vf_bw(struct net_device *, int, int, int); static int igb_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting); static int igb_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting); static int igb_ndo_get_vf_config(struct net_device *netdev, int vf, struct ifla_vf_info *ivi); static void igb_check_vf_rate_limit(struct igb_adapter *); static void igb_nfc_filter_exit(struct igb_adapter *adapter); static void igb_nfc_filter_restore(struct igb_adapter *adapter); #ifdef CONFIG_PCI_IOV static int igb_vf_configure(struct igb_adapter *adapter, int vf); static int igb_disable_sriov(struct pci_dev *dev, bool reinit); #endif #ifdef CONFIG_IGB_DCA static int igb_notify_dca(struct notifier_block *, unsigned long, void *); static struct notifier_block dca_notifier = …; #endif #ifdef CONFIG_PCI_IOV static unsigned int max_vfs; module_param(max_vfs, uint, 0444); MODULE_PARM_DESC(…) …; #endif /* CONFIG_PCI_IOV */ static pci_ers_result_t igb_io_error_detected(struct pci_dev *, pci_channel_state_t); static pci_ers_result_t igb_io_slot_reset(struct pci_dev *); static void igb_io_resume(struct pci_dev *); static const struct pci_error_handlers igb_err_handler = …; static void igb_init_dmac(struct igb_adapter *adapter, u32 pba); MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …; #define DEFAULT_MSG_ENABLE … static int debug = …; module_param(debug, int, 0); MODULE_PARM_DESC(…) …; struct igb_reg_info { … }; static const struct igb_reg_info igb_reg_info_tbl[] = …; /* igb_regdump - register printout routine */ static void igb_regdump(struct e1000_hw *hw, struct igb_reg_info *reginfo) { … } /* igb_dump - Print registers, Tx-rings and Rx-rings */ static void igb_dump(struct igb_adapter *adapter) { … } /** * igb_get_i2c_data - Reads the I2C SDA data bit * @data: opaque pointer to adapter struct * * Returns the I2C data bit value **/ static int igb_get_i2c_data(void *data) { … } /** * igb_set_i2c_data - Sets the I2C data bit * @data: pointer to hardware structure * @state: I2C data value (0 or 1) to set * * Sets the I2C data bit **/ static void igb_set_i2c_data(void *data, int state) { … } /** * igb_set_i2c_clk - Sets the I2C SCL clock * @data: pointer to hardware structure * @state: state to set clock * * Sets the I2C clock line to state **/ static void igb_set_i2c_clk(void *data, int state) { … } /** * igb_get_i2c_clk - Gets the I2C SCL clock state * @data: pointer to hardware structure * * Gets the I2C clock state **/ static int igb_get_i2c_clk(void *data) { … } static const struct i2c_algo_bit_data igb_i2c_algo = …; /** * igb_get_hw_dev - return device * @hw: pointer to hardware structure * * used by hardware layer to print debugging information **/ struct net_device *igb_get_hw_dev(struct e1000_hw *hw) { … } static struct pci_driver igb_driver; /** * igb_init_module - Driver Registration Routine * * igb_init_module is the first routine called when the driver is * loaded. All it does is register with the PCI subsystem. **/ static int __init igb_init_module(void) { … } module_init(…) …; /** * igb_exit_module - Driver Exit Cleanup Routine * * igb_exit_module is called just before the driver is removed * from memory. **/ static void __exit igb_exit_module(void) { … } module_exit(igb_exit_module); #define Q_IDX_82576(i) … /** * igb_cache_ring_register - Descriptor ring to register mapping * @adapter: board private structure to initialize * * Once we know the feature-set enabled for the device, we'll cache * the register offset the descriptor ring is assigned to. **/ static void igb_cache_ring_register(struct igb_adapter *adapter) { … } u32 igb_rd32(struct e1000_hw *hw, u32 reg) { … } /** * igb_write_ivar - configure ivar for given MSI-X vector * @hw: pointer to the HW structure * @msix_vector: vector number we are allocating to a given ring * @index: row index of IVAR register to write within IVAR table * @offset: column offset of in IVAR, should be multiple of 8 * * This function is intended to handle the writing of the IVAR register * for adapters 82576 and newer. The IVAR table consists of 2 columns, * each containing an cause allocation for an Rx and Tx ring, and a * variable number of rows depending on the number of queues supported. **/ static void igb_write_ivar(struct e1000_hw *hw, int msix_vector, int index, int offset) { … } #define IGB_N0_QUEUE … static void igb_assign_vector(struct igb_q_vector *q_vector, int msix_vector) { … } /** * igb_configure_msix - Configure MSI-X hardware * @adapter: board private structure to initialize * * igb_configure_msix sets up the hardware to properly * generate MSI-X interrupts. **/ static void igb_configure_msix(struct igb_adapter *adapter) { … } /** * igb_request_msix - Initialize MSI-X interrupts * @adapter: board private structure to initialize * * igb_request_msix allocates MSI-X vectors and requests interrupts from the * kernel. **/ static int igb_request_msix(struct igb_adapter *adapter) { … } /** * igb_free_q_vector - Free memory allocated for specific interrupt vector * @adapter: board private structure to initialize * @v_idx: Index of vector to be freed * * This function frees the memory allocated to the q_vector. **/ static void igb_free_q_vector(struct igb_adapter *adapter, int v_idx) { … } /** * igb_reset_q_vector - Reset config for interrupt vector * @adapter: board private structure to initialize * @v_idx: Index of vector to be reset * * If NAPI is enabled it will delete any references to the * NAPI struct. This is preparation for igb_free_q_vector. **/ static void igb_reset_q_vector(struct igb_adapter *adapter, int v_idx) { … } static void igb_reset_interrupt_capability(struct igb_adapter *adapter) { … } /** * igb_free_q_vectors - Free memory allocated for interrupt vectors * @adapter: board private structure to initialize * * This function frees the memory allocated to the q_vectors. In addition if * NAPI is enabled it will delete any references to the NAPI struct prior * to freeing the q_vector. **/ static void igb_free_q_vectors(struct igb_adapter *adapter) { … } /** * igb_clear_interrupt_scheme - reset the device to a state of no interrupts * @adapter: board private structure to initialize * * This function resets the device so that it has 0 Rx queues, Tx queues, and * MSI-X interrupts allocated. */ static void igb_clear_interrupt_scheme(struct igb_adapter *adapter) { … } /** * igb_set_interrupt_capability - set MSI or MSI-X if supported * @adapter: board private structure to initialize * @msix: boolean value of MSIX capability * * Attempt to configure interrupts using the best available * capabilities of the hardware and kernel. **/ static void igb_set_interrupt_capability(struct igb_adapter *adapter, bool msix) { … } static void igb_add_ring(struct igb_ring *ring, struct igb_ring_container *head) { … } /** * igb_alloc_q_vector - Allocate memory for a single interrupt vector * @adapter: board private structure to initialize * @v_count: q_vectors allocated on adapter, used for ring interleaving * @v_idx: index of vector in adapter struct * @txr_count: total number of Tx rings to allocate * @txr_idx: index of first Tx ring to allocate * @rxr_count: total number of Rx rings to allocate * @rxr_idx: index of first Rx ring to allocate * * We allocate one q_vector. If allocation fails we return -ENOMEM. **/ static int igb_alloc_q_vector(struct igb_adapter *adapter, int v_count, int v_idx, int txr_count, int txr_idx, int rxr_count, int rxr_idx) { … } /** * igb_alloc_q_vectors - Allocate memory for interrupt vectors * @adapter: board private structure to initialize * * We allocate one q_vector per queue interrupt. If allocation fails we * return -ENOMEM. **/ static int igb_alloc_q_vectors(struct igb_adapter *adapter) { … } /** * igb_init_interrupt_scheme - initialize interrupts, allocate queues/vectors * @adapter: board private structure to initialize * @msix: boolean value of MSIX capability * * This function initializes the interrupts and allocates all of the queues. **/ static int igb_init_interrupt_scheme(struct igb_adapter *adapter, bool msix) { … } /** * igb_request_irq - initialize interrupts * @adapter: board private structure to initialize * * Attempts to configure interrupts using the best available * capabilities of the hardware and kernel. **/ static int igb_request_irq(struct igb_adapter *adapter) { … } static void igb_free_irq(struct igb_adapter *adapter) { … } /** * igb_irq_disable - Mask off interrupt generation on the NIC * @adapter: board private structure **/ static void igb_irq_disable(struct igb_adapter *adapter) { … } /** * igb_irq_enable - Enable default interrupt generation settings * @adapter: board private structure **/ static void igb_irq_enable(struct igb_adapter *adapter) { … } static void igb_update_mng_vlan(struct igb_adapter *adapter) { … } /** * igb_release_hw_control - release control of the h/w to f/w * @adapter: address of board private structure * * igb_release_hw_control resets CTRL_EXT:DRV_LOAD bit. * For ASF and Pass Through versions of f/w this means that the * driver is no longer loaded. **/ static void igb_release_hw_control(struct igb_adapter *adapter) { … } /** * igb_get_hw_control - get control of the h/w from f/w * @adapter: address of board private structure * * igb_get_hw_control sets CTRL_EXT:DRV_LOAD bit. * For ASF and Pass Through versions of f/w this means that * the driver is loaded. **/ static void igb_get_hw_control(struct igb_adapter *adapter) { … } static void enable_fqtss(struct igb_adapter *adapter, bool enable) { … } static bool is_fqtss_enabled(struct igb_adapter *adapter) { … } static void set_tx_desc_fetch_prio(struct e1000_hw *hw, int queue, enum tx_queue_prio prio) { … } static void set_queue_mode(struct e1000_hw *hw, int queue, enum queue_mode mode) { … } static bool is_any_cbs_enabled(struct igb_adapter *adapter) { … } static bool is_any_txtime_enabled(struct igb_adapter *adapter) { … } /** * igb_config_tx_modes - Configure "Qav Tx mode" features on igb * @adapter: pointer to adapter struct * @queue: queue number * * Configure CBS and Launchtime for a given hardware queue. * Parameters are retrieved from the correct Tx ring, so * igb_save_cbs_params() and igb_save_txtime_params() should be used * for setting those correctly prior to this function being called. **/ static void igb_config_tx_modes(struct igb_adapter *adapter, int queue) { … } static int igb_save_txtime_params(struct igb_adapter *adapter, int queue, bool enable) { … } static int igb_save_cbs_params(struct igb_adapter *adapter, int queue, bool enable, int idleslope, int sendslope, int hicredit, int locredit) { … } /** * igb_setup_tx_mode - Switch to/from Qav Tx mode when applicable * @adapter: pointer to adapter struct * * Configure TQAVCTRL register switching the controller's Tx mode * if FQTSS mode is enabled or disabled. Additionally, will issue * a call to igb_config_tx_modes() per queue so any previously saved * Tx parameters are applied. **/ static void igb_setup_tx_mode(struct igb_adapter *adapter) { … } /** * igb_configure - configure the hardware for RX and TX * @adapter: private board structure **/ static void igb_configure(struct igb_adapter *adapter) { … } /** * igb_power_up_link - Power up the phy/serdes link * @adapter: address of board private structure **/ void igb_power_up_link(struct igb_adapter *adapter) { … } /** * igb_power_down_link - Power down the phy/serdes link * @adapter: address of board private structure */ static void igb_power_down_link(struct igb_adapter *adapter) { … } /** * igb_check_swap_media - Detect and switch function for Media Auto Sense * @adapter: address of the board private structure **/ static void igb_check_swap_media(struct igb_adapter *adapter) { … } /** * igb_up - Open the interface and prepare it to handle traffic * @adapter: board private structure **/ int igb_up(struct igb_adapter *adapter) { … } void igb_down(struct igb_adapter *adapter) { … } void igb_reinit_locked(struct igb_adapter *adapter) { … } /** igb_enable_mas - Media Autosense re-enable after swap * * @adapter: adapter struct **/ static void igb_enable_mas(struct igb_adapter *adapter) { … } #ifdef CONFIG_IGB_HWMON /** * igb_set_i2c_bb - Init I2C interface * @hw: pointer to hardware structure **/ static void igb_set_i2c_bb(struct e1000_hw *hw) { … } #endif void igb_reset(struct igb_adapter *adapter) { … } static netdev_features_t igb_fix_features(struct net_device *netdev, netdev_features_t features) { … } static int igb_set_features(struct net_device *netdev, netdev_features_t features) { … } static int igb_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], struct net_device *dev, const unsigned char *addr, u16 vid, u16 flags, struct netlink_ext_ack *extack) { … } #define IGB_MAX_MAC_HDR_LEN … #define IGB_MAX_NETWORK_HDR_LEN … static netdev_features_t igb_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t features) { … } static void igb_offload_apply(struct igb_adapter *adapter, s32 queue) { … } static int igb_offload_cbs(struct igb_adapter *adapter, struct tc_cbs_qopt_offload *qopt) { … } #define ETHER_TYPE_FULL_MASK … #define VLAN_PRIO_FULL_MASK … static int igb_parse_cls_flower(struct igb_adapter *adapter, struct flow_cls_offload *f, int traffic_class, struct igb_nfc_filter *input) { … } static int igb_configure_clsflower(struct igb_adapter *adapter, struct flow_cls_offload *cls_flower) { … } static int igb_delete_clsflower(struct igb_adapter *adapter, struct flow_cls_offload *cls_flower) { … } static int igb_setup_tc_cls_flower(struct igb_adapter *adapter, struct flow_cls_offload *cls_flower) { … } static int igb_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv) { … } static int igb_offload_txtime(struct igb_adapter *adapter, struct tc_etf_qopt_offload *qopt) { … } static int igb_tc_query_caps(struct igb_adapter *adapter, struct tc_query_caps_base *base) { … } static LIST_HEAD(igb_block_cb_list); static int igb_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data) { … } static int igb_xdp_setup(struct net_device *dev, struct netdev_bpf *bpf) { … } static int igb_xdp(struct net_device *dev, struct netdev_bpf *xdp) { … } /* This function assumes __netif_tx_lock is held by the caller. */ static void igb_xdp_ring_update_tail(struct igb_ring *ring) { … } static struct igb_ring *igb_xdp_tx_queue_mapping(struct igb_adapter *adapter) { … } static int igb_xdp_xmit_back(struct igb_adapter *adapter, struct xdp_buff *xdp) { … } static int igb_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **frames, u32 flags) { … } static const struct net_device_ops igb_netdev_ops = …; /** * igb_set_fw_version - Configure version string for ethtool * @adapter: adapter struct **/ void igb_set_fw_version(struct igb_adapter *adapter) { … } /** * igb_init_mas - init Media Autosense feature if enabled in the NVM * * @adapter: adapter struct **/ static void igb_init_mas(struct igb_adapter *adapter) { … } /** * igb_init_i2c - Init I2C interface * @adapter: pointer to adapter structure **/ static s32 igb_init_i2c(struct igb_adapter *adapter) { … } /** * igb_probe - Device Initialization Routine * @pdev: PCI device information struct * @ent: entry in igb_pci_tbl * * Returns 0 on success, negative on failure * * igb_probe initializes an adapter identified by a pci_dev structure. * The OS initialization, configuring of the adapter private structure, * and a hardware reset occur. **/ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { … } #ifdef CONFIG_PCI_IOV static int igb_sriov_reinit(struct pci_dev *dev) { … } static int igb_disable_sriov(struct pci_dev *pdev, bool reinit) { … } static int igb_enable_sriov(struct pci_dev *pdev, int num_vfs, bool reinit) { … } #endif /** * igb_remove_i2c - Cleanup I2C interface * @adapter: pointer to adapter structure **/ static void igb_remove_i2c(struct igb_adapter *adapter) { … } /** * igb_remove - Device Removal Routine * @pdev: PCI device information struct * * igb_remove is called by the PCI subsystem to alert the driver * that it should release a PCI device. The could be caused by a * Hot-Plug event, or because the driver is going to be removed from * memory. **/ static void igb_remove(struct pci_dev *pdev) { … } /** * igb_probe_vfs - Initialize vf data storage and add VFs to pci config space * @adapter: board private structure to initialize * * This function initializes the vf specific data storage and then attempts to * allocate the VFs. The reason for ordering it this way is because it is much * mor expensive time wise to disable SR-IOV than it is to allocate and free * the memory for the VFs. **/ static void igb_probe_vfs(struct igb_adapter *adapter) { … } unsigned int igb_get_max_rss_queues(struct igb_adapter *adapter) { … } static void igb_init_queue_configuration(struct igb_adapter *adapter) { … } void igb_set_flag_queue_pairs(struct igb_adapter *adapter, const u32 max_rss_queues) { … } /** * igb_sw_init - Initialize general software structures (struct igb_adapter) * @adapter: board private structure to initialize * * igb_sw_init initializes the Adapter private data structure. * Fields are initialized based on PCI device information and * OS network device settings (MTU size). **/ static int igb_sw_init(struct igb_adapter *adapter) { … } /** * __igb_open - Called when a network interface is made active * @netdev: network interface device structure * @resuming: indicates whether we are in a resume call * * Returns 0 on success, negative value on failure * * The open entry point is called when a network interface is made * active by the system (IFF_UP). At this point all resources needed * for transmit and receive operations are allocated, the interrupt * handler is registered with the OS, the watchdog timer is started, * and the stack is notified that the interface is ready. **/ static int __igb_open(struct net_device *netdev, bool resuming) { … } int igb_open(struct net_device *netdev) { … } /** * __igb_close - Disables a network interface * @netdev: network interface device structure * @suspending: indicates we are in a suspend call * * Returns 0, this is not allowed to fail * * The close entry point is called when an interface is de-activated * by the OS. The hardware is still under the driver's control, but * needs to be disabled. A global MAC reset is issued to stop the * hardware, and all transmit and receive resources are freed. **/ static int __igb_close(struct net_device *netdev, bool suspending) { … } int igb_close(struct net_device *netdev) { … } /** * igb_setup_tx_resources - allocate Tx resources (Descriptors) * @tx_ring: tx descriptor ring (for a specific queue) to setup * * Return 0 on success, negative on failure **/ int igb_setup_tx_resources(struct igb_ring *tx_ring) { … } /** * igb_setup_all_tx_resources - wrapper to allocate Tx resources * (Descriptors) for all queues * @adapter: board private structure * * Return 0 on success, negative on failure **/ static int igb_setup_all_tx_resources(struct igb_adapter *adapter) { … } /** * igb_setup_tctl - configure the transmit control registers * @adapter: Board private structure **/ void igb_setup_tctl(struct igb_adapter *adapter) { … } /** * igb_configure_tx_ring - Configure transmit ring after Reset * @adapter: board private structure * @ring: tx ring to configure * * Configure a transmit ring after a reset. **/ void igb_configure_tx_ring(struct igb_adapter *adapter, struct igb_ring *ring) { … } /** * igb_configure_tx - Configure transmit Unit after Reset * @adapter: board private structure * * Configure the Tx unit of the MAC after a reset. **/ static void igb_configure_tx(struct igb_adapter *adapter) { … } /** * igb_setup_rx_resources - allocate Rx resources (Descriptors) * @rx_ring: Rx descriptor ring (for a specific queue) to setup * * Returns 0 on success, negative on failure **/ int igb_setup_rx_resources(struct igb_ring *rx_ring) { … } /** * igb_setup_all_rx_resources - wrapper to allocate Rx resources * (Descriptors) for all queues * @adapter: board private structure * * Return 0 on success, negative on failure **/ static int igb_setup_all_rx_resources(struct igb_adapter *adapter) { … } /** * igb_setup_mrqc - configure the multiple receive queue control registers * @adapter: Board private structure **/ static void igb_setup_mrqc(struct igb_adapter *adapter) { … } /** * igb_setup_rctl - configure the receive control registers * @adapter: Board private structure **/ void igb_setup_rctl(struct igb_adapter *adapter) { … } static inline int igb_set_vf_rlpml(struct igb_adapter *adapter, int size, int vfn) { … } static inline void igb_set_vf_vlan_strip(struct igb_adapter *adapter, int vfn, bool enable) { … } static inline void igb_set_vmolr(struct igb_adapter *adapter, int vfn, bool aupe) { … } /** * igb_setup_srrctl - configure the split and replication receive control * registers * @adapter: Board private structure * @ring: receive ring to be configured **/ void igb_setup_srrctl(struct igb_adapter *adapter, struct igb_ring *ring) { … } /** * igb_configure_rx_ring - Configure a receive ring after Reset * @adapter: board private structure * @ring: receive ring to be configured * * Configure the Rx unit of the MAC after a reset. **/ void igb_configure_rx_ring(struct igb_adapter *adapter, struct igb_ring *ring) { … } static void igb_set_rx_buffer_len(struct igb_adapter *adapter, struct igb_ring *rx_ring) { … } /** * igb_configure_rx - Configure receive Unit after Reset * @adapter: board private structure * * Configure the Rx unit of the MAC after a reset. **/ static void igb_configure_rx(struct igb_adapter *adapter) { … } /** * igb_free_tx_resources - Free Tx Resources per Queue * @tx_ring: Tx descriptor ring for a specific queue * * Free all transmit software resources **/ void igb_free_tx_resources(struct igb_ring *tx_ring) { … } /** * igb_free_all_tx_resources - Free Tx Resources for All Queues * @adapter: board private structure * * Free all transmit software resources **/ static void igb_free_all_tx_resources(struct igb_adapter *adapter) { … } /** * igb_clean_tx_ring - Free Tx Buffers * @tx_ring: ring to be cleaned **/ static void igb_clean_tx_ring(struct igb_ring *tx_ring) { … } /** * igb_clean_all_tx_rings - Free Tx Buffers for all queues * @adapter: board private structure **/ static void igb_clean_all_tx_rings(struct igb_adapter *adapter) { … } /** * igb_free_rx_resources - Free Rx Resources * @rx_ring: ring to clean the resources from * * Free all receive software resources **/ void igb_free_rx_resources(struct igb_ring *rx_ring) { … } /** * igb_free_all_rx_resources - Free Rx Resources for All Queues * @adapter: board private structure * * Free all receive software resources **/ static void igb_free_all_rx_resources(struct igb_adapter *adapter) { … } /** * igb_clean_rx_ring - Free Rx Buffers per Queue * @rx_ring: ring to free buffers from **/ static void igb_clean_rx_ring(struct igb_ring *rx_ring) { … } /** * igb_clean_all_rx_rings - Free Rx Buffers for all queues * @adapter: board private structure **/ static void igb_clean_all_rx_rings(struct igb_adapter *adapter) { … } /** * igb_set_mac - Change the Ethernet Address of the NIC * @netdev: network interface device structure * @p: pointer to an address structure * * Returns 0 on success, negative on failure **/ static int igb_set_mac(struct net_device *netdev, void *p) { … } /** * igb_write_mc_addr_list - write multicast addresses to MTA * @netdev: network interface device structure * * Writes multicast address list to the MTA hash table. * Returns: -ENOMEM on failure * 0 on no addresses written * X on writing X addresses to MTA **/ static int igb_write_mc_addr_list(struct net_device *netdev) { … } static int igb_vlan_promisc_enable(struct igb_adapter *adapter) { … } #define VFTA_BLOCK_SIZE … static void igb_scrub_vfta(struct igb_adapter *adapter, u32 vfta_offset) { … } static void igb_vlan_promisc_disable(struct igb_adapter *adapter) { … } /** * igb_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set * @netdev: network interface device structure * * The set_rx_mode entry point is called whenever the unicast or multicast * address lists or the network interface flags are updated. This routine is * responsible for configuring the hardware for proper unicast, multicast, * promiscuous mode, and all-multi behavior. **/ static void igb_set_rx_mode(struct net_device *netdev) { … } static void igb_check_wvbr(struct igb_adapter *adapter) { … } #define IGB_STAGGERED_QUEUE_OFFSET … static void igb_spoof_check(struct igb_adapter *adapter) { … } /* Need to wait a few seconds after link up to get diagnostic information from * the phy */ static void igb_update_phy_info(struct timer_list *t) { … } /** * igb_has_link - check shared code for link and determine up/down * @adapter: pointer to driver private info **/ bool igb_has_link(struct igb_adapter *adapter) { … } static bool igb_thermal_sensor_event(struct e1000_hw *hw, u32 event) { … } /** * igb_check_lvmmc - check for malformed packets received * and indicated in LVMMC register * @adapter: pointer to adapter **/ static void igb_check_lvmmc(struct igb_adapter *adapter) { … } /** * igb_watchdog - Timer Call-back * @t: pointer to timer_list containing our private info pointer **/ static void igb_watchdog(struct timer_list *t) { … } static void igb_watchdog_task(struct work_struct *work) { … } enum latency_range { … }; /** * igb_update_ring_itr - update the dynamic ITR value based on packet size * @q_vector: pointer to q_vector * * Stores a new ITR value based on strictly on packet size. This * algorithm is less sophisticated than that used in igb_update_itr, * due to the difficulty of synchronizing statistics across multiple * receive rings. The divisors and thresholds used by this function * were determined based on theoretical maximum wire speed and testing * data, in order to minimize response time while increasing bulk * throughput. * This functionality is controlled by ethtool's coalescing settings. * NOTE: This function is called only when operating in a multiqueue * receive environment. **/ static void igb_update_ring_itr(struct igb_q_vector *q_vector) { … } /** * igb_update_itr - update the dynamic ITR value based on statistics * @q_vector: pointer to q_vector * @ring_container: ring info to update the itr for * * Stores a new ITR value based on packets and byte * counts during the last interrupt. The advantage of per interrupt * computation is faster updates and more accurate ITR for the current * traffic pattern. Constants in this function were computed * based on theoretical maximum wire speed and thresholds were set based * on testing data as well as attempting to minimize response time * while increasing bulk throughput. * This functionality is controlled by ethtool's coalescing settings. * NOTE: These calculations are only valid when operating in a single- * queue environment. **/ static void igb_update_itr(struct igb_q_vector *q_vector, struct igb_ring_container *ring_container) { … } static void igb_set_itr(struct igb_q_vector *q_vector) { … } static void igb_tx_ctxtdesc(struct igb_ring *tx_ring, struct igb_tx_buffer *first, u32 vlan_macip_lens, u32 type_tucmd, u32 mss_l4len_idx) { … } static int igb_tso(struct igb_ring *tx_ring, struct igb_tx_buffer *first, u8 *hdr_len) { … } static void igb_tx_csum(struct igb_ring *tx_ring, struct igb_tx_buffer *first) { … } #define IGB_SET_FLAG(_input, _flag, _result) … static u32 igb_tx_cmd_type(struct sk_buff *skb, u32 tx_flags) { … } static void igb_tx_olinfo_status(struct igb_ring *tx_ring, union e1000_adv_tx_desc *tx_desc, u32 tx_flags, unsigned int paylen) { … } static int __igb_maybe_stop_tx(struct igb_ring *tx_ring, const u16 size) { … } static inline int igb_maybe_stop_tx(struct igb_ring *tx_ring, const u16 size) { … } static int igb_tx_map(struct igb_ring *tx_ring, struct igb_tx_buffer *first, const u8 hdr_len) { … } int igb_xmit_xdp_ring(struct igb_adapter *adapter, struct igb_ring *tx_ring, struct xdp_frame *xdpf) { … } netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb, struct igb_ring *tx_ring) { … } static inline struct igb_ring *igb_tx_queue_mapping(struct igb_adapter *adapter, struct sk_buff *skb) { … } static netdev_tx_t igb_xmit_frame(struct sk_buff *skb, struct net_device *netdev) { … } /** * igb_tx_timeout - Respond to a Tx Hang * @netdev: network interface device structure * @txqueue: number of the Tx queue that hung (unused) **/ static void igb_tx_timeout(struct net_device *netdev, unsigned int __always_unused txqueue) { … } static void igb_reset_task(struct work_struct *work) { … } /** * igb_get_stats64 - Get System Network Statistics * @netdev: network interface device structure * @stats: rtnl_link_stats64 pointer **/ static void igb_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) { … } /** * igb_change_mtu - Change the Maximum Transfer Unit * @netdev: network interface device structure * @new_mtu: new value for maximum frame size * * Returns 0 on success, negative on failure **/ static int igb_change_mtu(struct net_device *netdev, int new_mtu) { … } /** * igb_update_stats - Update the board statistics counters * @adapter: board private structure **/ void igb_update_stats(struct igb_adapter *adapter) { … } static void igb_perout(struct igb_adapter *adapter, int tsintr_tt) { … } static void igb_extts(struct igb_adapter *adapter, int tsintr_tt) { … } static void igb_tsync_interrupt(struct igb_adapter *adapter) { … } static irqreturn_t igb_msix_other(int irq, void *data) { … } static void igb_write_itr(struct igb_q_vector *q_vector) { … } static irqreturn_t igb_msix_ring(int irq, void *data) { … } #ifdef CONFIG_IGB_DCA static void igb_update_tx_dca(struct igb_adapter *adapter, struct igb_ring *tx_ring, int cpu) { … } static void igb_update_rx_dca(struct igb_adapter *adapter, struct igb_ring *rx_ring, int cpu) { … } static void igb_update_dca(struct igb_q_vector *q_vector) { … } static void igb_setup_dca(struct igb_adapter *adapter) { … } static int __igb_notify_dca(struct device *dev, void *data) { … } static int igb_notify_dca(struct notifier_block *nb, unsigned long event, void *p) { … } #endif /* CONFIG_IGB_DCA */ #ifdef CONFIG_PCI_IOV static int igb_vf_configure(struct igb_adapter *adapter, int vf) { … } #endif static void igb_ping_all_vfs(struct igb_adapter *adapter) { … } static int igb_set_vf_promisc(struct igb_adapter *adapter, u32 *msgbuf, u32 vf) { … } static int igb_set_vf_multicasts(struct igb_adapter *adapter, u32 *msgbuf, u32 vf) { … } static void igb_restore_vf_multicasts(struct igb_adapter *adapter) { … } static void igb_clear_vf_vfta(struct igb_adapter *adapter, u32 vf) { … } static int igb_find_vlvf_entry(struct e1000_hw *hw, u32 vlan) { … } static void igb_update_pf_vlvf(struct igb_adapter *adapter, u32 vid) { … } static s32 igb_set_vf_vlan(struct igb_adapter *adapter, u32 vid, bool add, u32 vf) { … } static void igb_set_vmvir(struct igb_adapter *adapter, u32 vid, u32 vf) { … } static int igb_enable_port_vlan(struct igb_adapter *adapter, int vf, u16 vlan, u8 qos) { … } static int igb_disable_port_vlan(struct igb_adapter *adapter, int vf) { … } static int igb_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos, __be16 vlan_proto) { … } static int igb_set_vf_vlan_msg(struct igb_adapter *adapter, u32 *msgbuf, u32 vf) { … } static inline void igb_vf_reset(struct igb_adapter *adapter, u32 vf) { … } static void igb_vf_reset_event(struct igb_adapter *adapter, u32 vf) { … } static void igb_vf_reset_msg(struct igb_adapter *adapter, u32 vf) { … } static void igb_flush_mac_table(struct igb_adapter *adapter) { … } static int igb_available_rars(struct igb_adapter *adapter, u8 queue) { … } /* Set default MAC address for the PF in the first RAR entry */ static void igb_set_default_mac_filter(struct igb_adapter *adapter) { … } /* If the filter to be added and an already existing filter express * the same address and address type, it should be possible to only * override the other configurations, for example the queue to steer * traffic. */ static bool igb_mac_entry_can_be_used(const struct igb_mac_addr *entry, const u8 *addr, const u8 flags) { … } /* Add a MAC filter for 'addr' directing matching traffic to 'queue', * 'flags' is used to indicate what kind of match is made, match is by * default for the destination address, if matching by source address * is desired the flag IGB_MAC_STATE_SRC_ADDR can be used. */ static int igb_add_mac_filter_flags(struct igb_adapter *adapter, const u8 *addr, const u8 queue, const u8 flags) { … } static int igb_add_mac_filter(struct igb_adapter *adapter, const u8 *addr, const u8 queue) { … } /* Remove a MAC filter for 'addr' directing matching traffic to * 'queue', 'flags' is used to indicate what kind of match need to be * removed, match is by default for the destination address, if * matching by source address is to be removed the flag * IGB_MAC_STATE_SRC_ADDR can be used. */ static int igb_del_mac_filter_flags(struct igb_adapter *adapter, const u8 *addr, const u8 queue, const u8 flags) { … } static int igb_del_mac_filter(struct igb_adapter *adapter, const u8 *addr, const u8 queue) { … } int igb_add_mac_steering_filter(struct igb_adapter *adapter, const u8 *addr, u8 queue, u8 flags) { … } int igb_del_mac_steering_filter(struct igb_adapter *adapter, const u8 *addr, u8 queue, u8 flags) { … } static int igb_uc_sync(struct net_device *netdev, const unsigned char *addr) { … } static int igb_uc_unsync(struct net_device *netdev, const unsigned char *addr) { … } static int igb_set_vf_mac_filter(struct igb_adapter *adapter, const int vf, const u32 info, const u8 *addr) { … } static int igb_set_vf_mac_addr(struct igb_adapter *adapter, u32 *msg, int vf) { … } static void igb_rcv_ack_from_vf(struct igb_adapter *adapter, u32 vf) { … } static void igb_rcv_msg_from_vf(struct igb_adapter *adapter, u32 vf) { … } static void igb_msg_task(struct igb_adapter *adapter) { … } /** * igb_set_uta - Set unicast filter table address * @adapter: board private structure * @set: boolean indicating if we are setting or clearing bits * * The unicast table address is a register array of 32-bit registers. * The table is meant to be used in a way similar to how the MTA is used * however due to certain limitations in the hardware it is necessary to * set all the hash bits to 1 and use the VMOLR ROPE bit as a promiscuous * enable bit to allow vlan tag stripping when promiscuous mode is enabled **/ static void igb_set_uta(struct igb_adapter *adapter, bool set) { … } /** * igb_intr_msi - Interrupt Handler * @irq: interrupt number * @data: pointer to a network interface device structure **/ static irqreturn_t igb_intr_msi(int irq, void *data) { … } /** * igb_intr - Legacy Interrupt Handler * @irq: interrupt number * @data: pointer to a network interface device structure **/ static irqreturn_t igb_intr(int irq, void *data) { … } static void igb_ring_irq_enable(struct igb_q_vector *q_vector) { … } /** * igb_poll - NAPI Rx polling callback * @napi: napi polling structure * @budget: count of how many packets we should handle **/ static int igb_poll(struct napi_struct *napi, int budget) { … } /** * igb_clean_tx_irq - Reclaim resources after transmit completes * @q_vector: pointer to q_vector containing needed info * @napi_budget: Used to determine if we are in netpoll * * returns true if ring is completely cleaned **/ static bool igb_clean_tx_irq(struct igb_q_vector *q_vector, int napi_budget) { … } /** * igb_reuse_rx_page - page flip buffer and store it back on the ring * @rx_ring: rx descriptor ring to store buffers on * @old_buff: donor buffer to have page reused * * Synchronizes page for reuse by the adapter **/ static void igb_reuse_rx_page(struct igb_ring *rx_ring, struct igb_rx_buffer *old_buff) { … } static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer, int rx_buf_pgcnt) { … } /** * igb_add_rx_frag - Add contents of Rx buffer to sk_buff * @rx_ring: rx descriptor ring to transact packets on * @rx_buffer: buffer containing page to add * @skb: sk_buff to place the data into * @size: size of buffer to be added * * This function will add the data contained in rx_buffer->page to the skb. **/ static void igb_add_rx_frag(struct igb_ring *rx_ring, struct igb_rx_buffer *rx_buffer, struct sk_buff *skb, unsigned int size) { … } static struct sk_buff *igb_construct_skb(struct igb_ring *rx_ring, struct igb_rx_buffer *rx_buffer, struct xdp_buff *xdp, ktime_t timestamp) { … } static struct sk_buff *igb_build_skb(struct igb_ring *rx_ring, struct igb_rx_buffer *rx_buffer, struct xdp_buff *xdp, ktime_t timestamp) { … } static struct sk_buff *igb_run_xdp(struct igb_adapter *adapter, struct igb_ring *rx_ring, struct xdp_buff *xdp) { … } static unsigned int igb_rx_frame_truesize(struct igb_ring *rx_ring, unsigned int size) { … } static void igb_rx_buffer_flip(struct igb_ring *rx_ring, struct igb_rx_buffer *rx_buffer, unsigned int size) { … } static inline void igb_rx_checksum(struct igb_ring *ring, union e1000_adv_rx_desc *rx_desc, struct sk_buff *skb) { … } static inline void igb_rx_hash(struct igb_ring *ring, union e1000_adv_rx_desc *rx_desc, struct sk_buff *skb) { … } /** * igb_is_non_eop - process handling of non-EOP buffers * @rx_ring: Rx ring being processed * @rx_desc: Rx descriptor for current buffer * * This function updates next to clean. If the buffer is an EOP buffer * this function exits returning false, otherwise it will place the * sk_buff in the next buffer to be chained and return true indicating * that this is in fact a non-EOP buffer. **/ static bool igb_is_non_eop(struct igb_ring *rx_ring, union e1000_adv_rx_desc *rx_desc) { … } /** * igb_cleanup_headers - Correct corrupted or empty headers * @rx_ring: rx descriptor ring packet is being transacted on * @rx_desc: pointer to the EOP Rx descriptor * @skb: pointer to current skb being fixed * * Address the case where we are pulling data in on pages only * and as such no data is present in the skb header. * * In addition if skb is not at least 60 bytes we need to pad it so that * it is large enough to qualify as a valid Ethernet frame. * * Returns true if an error was encountered and skb was freed. **/ static bool igb_cleanup_headers(struct igb_ring *rx_ring, union e1000_adv_rx_desc *rx_desc, struct sk_buff *skb) { … } /** * igb_process_skb_fields - Populate skb header fields from Rx descriptor * @rx_ring: rx descriptor ring packet is being transacted on * @rx_desc: pointer to the EOP Rx descriptor * @skb: pointer to current skb being populated * * This function checks the ring, descriptor, and packet information in * order to populate the hash, checksum, VLAN, timestamp, protocol, and * other fields within the skb. **/ static void igb_process_skb_fields(struct igb_ring *rx_ring, union e1000_adv_rx_desc *rx_desc, struct sk_buff *skb) { … } static unsigned int igb_rx_offset(struct igb_ring *rx_ring) { … } static struct igb_rx_buffer *igb_get_rx_buffer(struct igb_ring *rx_ring, const unsigned int size, int *rx_buf_pgcnt) { … } static void igb_put_rx_buffer(struct igb_ring *rx_ring, struct igb_rx_buffer *rx_buffer, int rx_buf_pgcnt) { … } static int igb_clean_rx_irq(struct igb_q_vector *q_vector, const int budget) { … } static bool igb_alloc_mapped_page(struct igb_ring *rx_ring, struct igb_rx_buffer *bi) { … } /** * igb_alloc_rx_buffers - Replace used receive buffers * @rx_ring: rx descriptor ring to allocate new receive buffers * @cleaned_count: count of buffers to allocate **/ void igb_alloc_rx_buffers(struct igb_ring *rx_ring, u16 cleaned_count) { … } /** * igb_mii_ioctl - * @netdev: pointer to netdev struct * @ifr: interface structure * @cmd: ioctl command to execute **/ static int igb_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) { … } /** * igb_ioctl - * @netdev: pointer to netdev struct * @ifr: interface structure * @cmd: ioctl command to execute **/ static int igb_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) { … } void igb_read_pci_cfg(struct e1000_hw *hw, u32 reg, u16 *value) { … } void igb_write_pci_cfg(struct e1000_hw *hw, u32 reg, u16 *value) { … } s32 igb_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value) { … } s32 igb_write_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value) { … } static void igb_vlan_mode(struct net_device *netdev, netdev_features_t features) { … } static int igb_vlan_rx_add_vid(struct net_device *netdev, __be16 proto, u16 vid) { … } static int igb_vlan_rx_kill_vid(struct net_device *netdev, __be16 proto, u16 vid) { … } static void igb_restore_vlan(struct igb_adapter *adapter) { … } int igb_set_spd_dplx(struct igb_adapter *adapter, u32 spd, u8 dplx) { … } static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, bool runtime) { … } static void igb_deliver_wake_packet(struct net_device *netdev) { … } static int igb_suspend(struct device *dev) { … } static int __igb_resume(struct device *dev, bool rpm) { … } static int igb_resume(struct device *dev) { … } static int igb_runtime_idle(struct device *dev) { … } static int igb_runtime_suspend(struct device *dev) { … } static int igb_runtime_resume(struct device *dev) { … } static void igb_shutdown(struct pci_dev *pdev) { … } static int igb_pci_sriov_configure(struct pci_dev *dev, int num_vfs) { … } /** * igb_io_error_detected - called when PCI error is detected * @pdev: Pointer to PCI device * @state: The current pci connection state * * This function is called after a PCI bus error affecting * this device has been detected. **/ static pci_ers_result_t igb_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state) { … } /** * igb_io_slot_reset - called after the pci bus has been reset. * @pdev: Pointer to PCI device * * Restart the card from scratch, as if from a cold-boot. Implementation * resembles the first-half of the __igb_resume routine. **/ static pci_ers_result_t igb_io_slot_reset(struct pci_dev *pdev) { … } /** * igb_io_resume - called when traffic can start flowing again. * @pdev: Pointer to PCI device * * This callback is called when the error recovery driver tells us that * its OK to resume normal operation. Implementation resembles the * second-half of the __igb_resume routine. */ static void igb_io_resume(struct pci_dev *pdev) { … } /** * igb_rar_set_index - Sync RAL[index] and RAH[index] registers with MAC table * @adapter: Pointer to adapter structure * @index: Index of the RAR entry which need to be synced with MAC table **/ static void igb_rar_set_index(struct igb_adapter *adapter, u32 index) { … } static int igb_set_vf_mac(struct igb_adapter *adapter, int vf, unsigned char *mac_addr) { … } static int igb_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac) { … } static int igb_link_mbps(int internal_link_speed) { … } static void igb_set_vf_rate_limit(struct e1000_hw *hw, int vf, int tx_rate, int link_speed) { … } static void igb_check_vf_rate_limit(struct igb_adapter *adapter) { … } static int igb_ndo_set_vf_bw(struct net_device *netdev, int vf, int min_tx_rate, int max_tx_rate) { … } static int igb_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting) { … } static int igb_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting) { … } static int igb_ndo_get_vf_config(struct net_device *netdev, int vf, struct ifla_vf_info *ivi) { … } static void igb_vmm_control(struct igb_adapter *adapter) { … } static void igb_init_dmac(struct igb_adapter *adapter, u32 pba) { … } /** * igb_read_i2c_byte - Reads 8 bit word over I2C * @hw: pointer to hardware structure * @byte_offset: byte offset to read * @dev_addr: device address * @data: value read * * Performs byte read operation over I2C interface at * a specified device address. **/ s32 igb_read_i2c_byte(struct e1000_hw *hw, u8 byte_offset, u8 dev_addr, u8 *data) { … } /** * igb_write_i2c_byte - Writes 8 bit word over I2C * @hw: pointer to hardware structure * @byte_offset: byte offset to write * @dev_addr: device address * @data: value to write * * Performs byte write operation over I2C interface at * a specified device address. **/ s32 igb_write_i2c_byte(struct e1000_hw *hw, u8 byte_offset, u8 dev_addr, u8 data) { … } int igb_reinit_queues(struct igb_adapter *adapter) { … } static void igb_nfc_filter_exit(struct igb_adapter *adapter) { … } static void igb_nfc_filter_restore(struct igb_adapter *adapter) { … } static _DEFINE_DEV_PM_OPS(igb_pm_ops, igb_suspend, igb_resume, igb_runtime_suspend, igb_runtime_resume, igb_runtime_idle); static struct pci_driver igb_driver = …; /* igb_main.c */
Codebase Browser
linux