if (ecmd->autoneg == AUTONEG_ENABLE ||
           ecmd->speed + ecmd->duplex != SPEED_10000 + DUPLEX_FULL)
                return -EINVAL;
-       
+
        if (netif_running(adapter->netdev)) {
                ixgb_down(adapter, true);
                ixgb_reset(adapter);
 {
        struct ixgb_adapter *adapter = netdev_priv(netdev);
        struct ixgb_hw *hw = &adapter->hw;
-       
+
        pause->autoneg = AUTONEG_DISABLE;
-               
+
        if (hw->fc.type == ixgb_fc_rx_pause)
                pause->rx_pause = 1;
        else if (hw->fc.type == ixgb_fc_tx_pause)
 {
        struct ixgb_adapter *adapter = netdev_priv(netdev);
        struct ixgb_hw *hw = &adapter->hw;
-       
+
        if (pause->autoneg == AUTONEG_ENABLE)
                return -EINVAL;
 
                ixgb_set_speed_duplex(netdev);
        } else
                ixgb_reset(adapter);
-               
+
        return 0;
 }
 
                ixgb_reset(adapter);
        return 0;
 }
-       
+
 static u32
 ixgb_get_tx_csum(struct net_device *netdev)
 {
        else
                netdev->features &= ~NETIF_F_TSO;
        return 0;
-} 
+}
 
 static u32
 ixgb_get_msglevel(struct net_device *netdev)
 }
 #define IXGB_GET_STAT(_A_, _R_) _A_->stats._R_
 
-static int 
+static int
 ixgb_get_regs_len(struct net_device *netdev)
 {
 #define IXGB_REG_DUMP_LEN  136*sizeof(u32)
        if ((eeprom->offset + eeprom->len) & 1) {
                /* need read/modify/write of last changed EEPROM word */
                /* only the first byte of the word is being modified */
-               eeprom_buff[last_word - first_word] 
+               eeprom_buff[last_word - first_word]
                        = ixgb_read_eeprom(hw, last_word);
        }
 
        struct ixgb_desc_ring *txdr = &adapter->tx_ring;
        struct ixgb_desc_ring *rxdr = &adapter->rx_ring;
 
-       ring->rx_max_pending = MAX_RXD; 
+       ring->rx_max_pending = MAX_RXD;
        ring->tx_max_pending = MAX_TXD;
        ring->rx_mini_max_pending = 0;
        ring->rx_jumbo_max_pending = 0;
        ring->rx_jumbo_pending = 0;
 }
 
-static int 
+static int
 ixgb_set_ringparam(struct net_device *netdev,
                struct ethtool_ringparam *ring)
 {
        return 0;
 }
 
-static int 
+static int
 ixgb_get_sset_count(struct net_device *netdev, int sset)
 {
        switch (sset) {
        }
 }
 
-static void 
-ixgb_get_ethtool_stats(struct net_device *netdev, 
+static void
+ixgb_get_ethtool_stats(struct net_device *netdev,
                struct ethtool_stats *stats, u64 *data)
 {
        struct ixgb_adapter *adapter = netdev_priv(netdev);
 
        ixgb_update_stats(adapter);
        for(i = 0; i < IXGB_STATS_LEN; i++) {
-               char *p = (char *)adapter+ixgb_gstrings_stats[i].stat_offset;   
-               data[i] = (ixgb_gstrings_stats[i].sizeof_stat == 
+               char *p = (char *)adapter+ixgb_gstrings_stats[i].stat_offset;
+               data[i] = (ixgb_gstrings_stats[i].sizeof_stat ==
                        sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
        }
 }
 
-static void 
+static void
 ixgb_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 {
        int i;
        switch(stringset) {
        case ETH_SS_STATS:
                for(i=0; i < IXGB_STATS_LEN; i++) {
-                       memcpy(data + i * ETH_GSTRING_LEN, 
+                       memcpy(data + i * ETH_GSTRING_LEN,
                        ixgb_gstrings_stats[i].stat_string,
                        ETH_GSTRING_LEN);
                }
 
  **/
 
 static int __devinit
-ixgb_probe(struct pci_dev *pdev,
-               const struct pci_device_id *ent)
+ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
        struct net_device *netdev = NULL;
        struct ixgb_adapter *adapter;
           || (hw->device_id == IXGB_DEVICE_ID_82597EX_CX4)
           || (hw->device_id == IXGB_DEVICE_ID_82597EX_LR)
           || (hw->device_id == IXGB_DEVICE_ID_82597EX_SR))
-                       hw->mac_type = ixgb_82597;
+               hw->mac_type = ixgb_82597;
        else {
                /* should never have loaded on this device */
                DPRINTK(PROBE, ERR, "unsupported device id\n");
        u32 tctl;
        struct ixgb_hw *hw = &adapter->hw;
 
-       /* Setup the Base and Length of the Tx Descriptor Ring 
-        * tx_ring.dma can be either a 32 or 64 bit value 
+       /* Setup the Base and Length of the Tx Descriptor Ring
+        * tx_ring.dma can be either a 32 or 64 bit value
         */
 
        IXGB_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
 
        /* Setup Transmit Descriptor Settings for this adapter */
        adapter->tx_cmd_type =
-               IXGB_TX_DESC_TYPE 
-               | (adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0);
+               IXGB_TX_DESC_TYPE |
+               (adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0);
 }
 
 /**
        rctl &= ~(3 << IXGB_RCTL_MO_SHIFT);
 
        rctl |=
-               IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | 
-               IXGB_RCTL_RXEN | IXGB_RCTL_CFF | 
+               IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 |
+               IXGB_RCTL_RXEN | IXGB_RCTL_CFF |
                (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT);
 
        rctl |= IXGB_RCTL_SECRC;
 
 static void
 ixgb_unmap_and_free_tx_resource(struct ixgb_adapter *adapter,
-                                       struct ixgb_buffer *buffer_info)
+                                struct ixgb_buffer *buffer_info)
 {
        struct pci_dev *pdev = adapter->pdev;
 
 
                IXGB_WRITE_REG(hw, RCTL, rctl);
 
-               for(i = 0, mc_ptr = netdev->mc_list; mc_ptr;
-                       i++, mc_ptr = mc_ptr->next)
+               for (i = 0, mc_ptr = netdev->mc_list;
+                    mc_ptr;
+                    i++, mc_ptr = mc_ptr->next)
                        memcpy(&mta[i * IXGB_ETH_LENGTH_OF_ADDRESS],
-                                  mc_ptr->dmi_addr, IXGB_ETH_LENGTH_OF_ADDRESS);
+                              mc_ptr->dmi_addr, IXGB_ETH_LENGTH_OF_ADDRESS);
 
                ixgb_mc_addr_list_update(hw, mta, netdev->mc_count, 0);
        }
                context_desc->hdr_len = hdr_len;
                context_desc->status = 0;
                context_desc->cmd_type_len = cpu_to_le32(
-                                                 IXGB_CONTEXT_DESC_TYPE 
+                                                 IXGB_CONTEXT_DESC_TYPE
                                                | IXGB_CONTEXT_DESC_CMD_TSE
                                                | IXGB_CONTEXT_DESC_CMD_IP
                                                | IXGB_CONTEXT_DESC_CMD_TCP
                if (++i == tx_ring->count) i = 0;
        }
 
-       tx_desc->cmd_type_len |= cpu_to_le32(IXGB_TX_DESC_CMD_EOP 
-                               | IXGB_TX_DESC_CMD_RS );
+       tx_desc->cmd_type_len |=
+               cpu_to_le32(IXGB_TX_DESC_CMD_EOP | IXGB_TX_DESC_CMD_RS);
 
        /* Force memory writes to complete before letting h/w
         * know there are new descriptors to fetch.  (Only
        }
 
        first = adapter->tx_ring.next_to_use;
-       
+
        tso = ixgb_tso(adapter, skb);
        if (tso < 0) {
                dev_kfree_skb_any(skb);
                u64 multi = IXGB_READ_REG(&adapter->hw, MPRCL);
                u32 bcast_l = IXGB_READ_REG(&adapter->hw, BPRCL);
                u32 bcast_h = IXGB_READ_REG(&adapter->hw, BPRCH);
-               u64 bcast = ((u64)bcast_h << 32) | bcast_l; 
+               u64 bcast = ((u64)bcast_h << 32) | bcast_l;
 
                multi |= ((u64)IXGB_READ_REG(&adapter->hw, MPRCH) << 32);
                /* fix up multicast stats by removing broadcasts */
                if (multi >= bcast)
                        multi -= bcast;
-               
+
                adapter->stats.mprcl += (multi & 0xFFFFFFFF);
                adapter->stats.mprch += (multi >> 32);
-               adapter->stats.bprcl += bcast_l; 
+               adapter->stats.bprcl += bcast_l;
                adapter->stats.bprch += bcast_h;
        } else {
                adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL);
 #ifdef CONFIG_IXGB_NAPI
        if (netif_rx_schedule_prep(netdev, &adapter->napi)) {
 
-               /* Disable interrupts and register for poll. The flush 
+               /* Disable interrupts and register for poll. The flush
                  of the posted write is intentionally left out.
                */
 
                if (!ixgb_clean_rx_irq(adapter) &
                   !ixgb_clean_tx_irq(adapter))
                        break;
-#endif 
+#endif
        return IRQ_HANDLED;
 }
 
                        tx_desc = IXGB_TX_DESC(*tx_ring, i);
                        buffer_info = &tx_ring->buffer_info[i];
 
-                       if (tx_desc->popts
-                           & (IXGB_TX_DESC_POPTS_TXSM |
-                              IXGB_TX_DESC_POPTS_IXSM))
+                       if (tx_desc->popts &
+                          (IXGB_TX_DESC_POPTS_TXSM |
+                           IXGB_TX_DESC_POPTS_IXSM))
                                adapter->hw_csum_tx_good++;
 
                        ixgb_unmap_and_free_tx_resource(adapter, buffer_info);
 
 static void
 ixgb_rx_checksum(struct ixgb_adapter *adapter,
-                struct ixgb_rx_desc *rx_desc,
-                struct sk_buff *skb)
+                 struct ixgb_rx_desc *rx_desc,
+                 struct sk_buff *skb)
 {
        /* Ignore Checksum bit is set OR
         * TCP Checksum has not been calculated
                        goto rxdesc_done;
                }
 
-               if (unlikely(rx_desc->errors
-                            & (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE
-                               | IXGB_RX_DESC_ERRORS_P |
-                               IXGB_RX_DESC_ERRORS_RXE))) {
-
+               if (unlikely(rx_desc->errors &
+                   (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE |
+                    IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))) {
                        dev_kfree_skb_irq(skb);
                        goto rxdesc_done;
                }
 #ifdef CONFIG_IXGB_NAPI
                if (adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
                        vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
-                               le16_to_cpu(rx_desc->special));
+                                               le16_to_cpu(rx_desc->special));
                } else {
                        netif_receive_skb(skb);
                }
 #else /* CONFIG_IXGB_NAPI */
                if (adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
                        vlan_hwaccel_rx(skb, adapter->vlgrp,
-                               le16_to_cpu(rx_desc->special));
+                                       le16_to_cpu(rx_desc->special));
                } else {
                        netif_rx(skb);
                }
                rx_desc = IXGB_RX_DESC(*rx_ring, i);
                rx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
                /* guarantee DD bit not set now before h/w gets descriptor
-                * this is the rest of the workaround for h/w double 
+                * this is the rest of the workaround for h/w double
                 * writeback. */
                rx_desc->status = 0;
 
 
 /**
  * ixgb_vlan_rx_register - enables or disables vlan tagging/stripping.
- * 
+ *
  * @param netdev network interface device structure
  * @param grp indicates to enable or disable tagging/stripping
  **/
  * This callback is called by the PCI subsystem whenever
  * a PCI bus error is detected.
  */
-static pci_ers_result_t ixgb_io_error_detected (struct pci_dev *pdev,
-                                    enum pci_channel_state state)
+static pci_ers_result_t ixgb_io_error_detected(struct pci_dev *pdev,
+                                               enum pci_channel_state state)
 {
        struct net_device *netdev = pci_get_drvdata(pdev);
        struct ixgb_adapter *adapter = netdev_priv(netdev);
  * This is a shortened version of the device probe/discovery code,
  * it resembles the first-half of the ixgb_probe() routine.
  */
-static pci_ers_result_t ixgb_io_slot_reset (struct pci_dev *pdev)
+static pci_ers_result_t ixgb_io_slot_reset(struct pci_dev *pdev)
 {
        struct net_device *netdev = pci_get_drvdata(pdev);
        struct ixgb_adapter *adapter = netdev_priv(netdev);
  * normal operation. Implementation resembles the second-half
  * of the ixgb_probe() routine.
  */
-static void ixgb_io_resume (struct pci_dev *pdev)
+static void ixgb_io_resume(struct pci_dev *pdev)
 {
        struct net_device *netdev = pci_get_drvdata(pdev);
        struct ixgb_adapter *adapter = netdev_priv(netdev);