e1000e: cleanup PARENTHESIS_ALIGNMENT checkpatch checks
authorBruce Allan <bruce.w.allan@intel.com>
Wed, 20 Feb 2013 04:06:01 +0000 (04:06 +0000)
committerJeff Kirsher <jeffrey.t.kirsher@intel.com>
Fri, 8 Mar 2013 08:49:14 +0000 (00:49 -0800)
CHECK:PARENTHESIS_ALIGNMENT: Alignment should match open parenthesis

Signed-off-by: Bruce Allan <bruce.w.allan@intel.com>
Tested-by: Aaron Brown <aaron.f.brown@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
drivers/net/ethernet/intel/e1000e/80003es2lan.c
drivers/net/ethernet/intel/e1000e/82571.c
drivers/net/ethernet/intel/e1000e/ethtool.c
drivers/net/ethernet/intel/e1000e/ich8lan.c
drivers/net/ethernet/intel/e1000e/netdev.c
drivers/net/ethernet/intel/e1000e/param.c
drivers/net/ethernet/intel/e1000e/phy.c

index c4bc569997b0dbf1f1122c3bfb64b25761e503e0..6c0d96b9889d0c809cd116ebb7a6f1ceb653330e 100644 (file)
@@ -580,7 +580,7 @@ static s32 e1000_phy_force_speed_duplex_80003es2lan(struct e1000_hw *hw)
                e_dbg("Waiting for forced speed/duplex link on GG82563 phy.\n");
 
                ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
-                                                    100000, &link);
+                                                     100000, &link);
                if (ret_val)
                        return ret_val;
 
@@ -595,7 +595,7 @@ static s32 e1000_phy_force_speed_duplex_80003es2lan(struct e1000_hw *hw)
 
                /* Try once more */
                ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
-                                                    100000, &link);
+                                                     100000, &link);
                if (ret_val)
                        return ret_val;
        }
@@ -666,14 +666,12 @@ static s32 e1000_get_link_up_info_80003es2lan(struct e1000_hw *hw, u16 *speed,
        s32 ret_val;
 
        if (hw->phy.media_type == e1000_media_type_copper) {
-               ret_val = e1000e_get_speed_and_duplex_copper(hw,
-                                                                   speed,
-                                                                   duplex);
+               ret_val = e1000e_get_speed_and_duplex_copper(hw, speed, duplex);
                hw->phy.ops.cfg_on_link_up(hw);
        } else {
                ret_val = e1000e_get_speed_and_duplex_fiber_serdes(hw,
-                                                                 speed,
-                                                                 duplex);
+                                                                  speed,
+                                                                  duplex);
        }
 
        return ret_val;
@@ -823,7 +821,7 @@ static s32 e1000_init_hw_80003es2lan(struct e1000_hw *hw)
                                            E1000_KMRNCTRLSTA_OFFSET_SHIFT, &i);
        if (!ret_val) {
                if ((i & E1000_KMRNCTRLSTA_OPMODE_MASK) ==
-                    E1000_KMRNCTRLSTA_OPMODE_INBAND_MDIO)
+                   E1000_KMRNCTRLSTA_OPMODE_INBAND_MDIO)
                        hw->dev_spec.e80003es2lan.mdic_wa_enable = false;
        }
 
@@ -890,7 +888,7 @@ static s32 e1000_copper_link_setup_gg82563_80003es2lan(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-       u32 ctrl_ext;
+       u32 reg;
        u16 data;
 
        ret_val = e1e_rphy(hw, GG82563_PHY_MAC_SPEC_CTRL, &data);
@@ -953,22 +951,19 @@ static s32 e1000_copper_link_setup_gg82563_80003es2lan(struct e1000_hw *hw)
        }
 
        /* Bypass Rx and Tx FIFO's */
-       ret_val = e1000_write_kmrn_reg_80003es2lan(hw,
-                                       E1000_KMRNCTRLSTA_OFFSET_FIFO_CTRL,
-                                       E1000_KMRNCTRLSTA_FIFO_CTRL_RX_BYPASS |
-                                       E1000_KMRNCTRLSTA_FIFO_CTRL_TX_BYPASS);
+       reg = E1000_KMRNCTRLSTA_OFFSET_FIFO_CTRL;
+       data = (E1000_KMRNCTRLSTA_FIFO_CTRL_RX_BYPASS |
+               E1000_KMRNCTRLSTA_FIFO_CTRL_TX_BYPASS);
+       ret_val = e1000_write_kmrn_reg_80003es2lan(hw, reg, data);
        if (ret_val)
                return ret_val;
 
-       ret_val = e1000_read_kmrn_reg_80003es2lan(hw,
-                                      E1000_KMRNCTRLSTA_OFFSET_MAC2PHY_OPMODE,
-                                      &data);
+       reg = E1000_KMRNCTRLSTA_OFFSET_MAC2PHY_OPMODE;
+       ret_val = e1000_read_kmrn_reg_80003es2lan(hw, reg, &data);
        if (ret_val)
                return ret_val;
        data |= E1000_KMRNCTRLSTA_OPMODE_E_IDLE;
-       ret_val = e1000_write_kmrn_reg_80003es2lan(hw,
-                                       E1000_KMRNCTRLSTA_OFFSET_MAC2PHY_OPMODE,
-                                       data);
+       ret_val = e1000_write_kmrn_reg_80003es2lan(hw, reg, data);
        if (ret_val)
                return ret_val;
 
@@ -981,9 +976,9 @@ static s32 e1000_copper_link_setup_gg82563_80003es2lan(struct e1000_hw *hw)
        if (ret_val)
                return ret_val;
 
-       ctrl_ext = er32(CTRL_EXT);
-       ctrl_ext &= ~(E1000_CTRL_EXT_LINK_MODE_MASK);
-       ew32(CTRL_EXT, ctrl_ext);
+       reg = er32(CTRL_EXT);
+       reg &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
+       ew32(CTRL_EXT, reg);
 
        ret_val = e1e_rphy(hw, GG82563_PHY_PWR_MGMT_CTRL, &data);
        if (ret_val)
index 2a4ae28e658785404df4498a569db7df4ada3ad2..64fc15bd35a626c21c70ede85f37fdedfd6abe37 100644 (file)
@@ -184,7 +184,7 @@ static s32 e1000_init_nvm_params_82571(struct e1000_hw *hw)
        default:
                nvm->type = e1000_nvm_eeprom_spi;
                size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
-                                 E1000_EECD_SIZE_EX_SHIFT);
+                            E1000_EECD_SIZE_EX_SHIFT);
                /* Added to a constant, "size" becomes the left-shift value
                 * for setting word_size.
                 */
index 6e9d433f122b1c6947b4748920b5aae3ccb4e470..b328943ae00303e8a27534a64e86b223d1873181 100644 (file)
@@ -499,8 +499,8 @@ static int e1000_get_eeprom(struct net_device *netdev,
        first_word = eeprom->offset >> 1;
        last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 
-       eeprom_buff = kmalloc(sizeof(u16) *
-                       (last_word - first_word + 1), GFP_KERNEL);
+       eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
+                             GFP_KERNEL);
        if (!eeprom_buff)
                return -ENOMEM;
 
@@ -511,7 +511,7 @@ static int e1000_get_eeprom(struct net_device *netdev,
        } else {
                for (i = 0; i < last_word - first_word + 1; i++) {
                        ret_val = e1000_read_nvm(hw, first_word + i, 1,
-                                                     &eeprom_buff[i]);
+                                                &eeprom_buff[i]);
                        if (ret_val)
                                break;
                }
@@ -576,7 +576,7 @@ static int e1000_set_eeprom(struct net_device *netdev,
                /* need read/modify/write of last changed EEPROM word */
                /* only the first byte of the word is being modified */
                ret_val = e1000_read_nvm(hw, last_word, 1,
-                                 &eeprom_buff[last_word - first_word]);
+                                        &eeprom_buff[last_word - first_word]);
 
        if (ret_val)
                goto out;
@@ -624,10 +624,10 @@ static void e1000_get_drvinfo(struct net_device *netdev,
         * PCI-E controllers
         */
        snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
-               "%d.%d-%d",
-               (adapter->eeprom_vers & 0xF000) >> 12,
-               (adapter->eeprom_vers & 0x0FF0) >> 4,
-               (adapter->eeprom_vers & 0x000F));
+                "%d.%d-%d",
+                (adapter->eeprom_vers & 0xF000) >> 12,
+                (adapter->eeprom_vers & 0x0FF0) >> 4,
+                (adapter->eeprom_vers & 0x000F));
 
        strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
                sizeof(drvinfo->bus_info));
@@ -966,8 +966,8 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
        if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
                         netdev)) {
                shared_int = 0;
-       } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
-                netdev->name, netdev)) {
+       } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, netdev->name,
+                              netdev)) {
                *data = 1;
                ret_val = -1;
                goto out;
@@ -1077,28 +1077,33 @@ static void e1000_free_desc_rings(struct e1000_adapter *adapter)
        struct e1000_ring *tx_ring = &adapter->test_tx_ring;
        struct e1000_ring *rx_ring = &adapter->test_rx_ring;
        struct pci_dev *pdev = adapter->pdev;
+       struct e1000_buffer *buffer_info;
        int i;
 
        if (tx_ring->desc && tx_ring->buffer_info) {
                for (i = 0; i < tx_ring->count; i++) {
-                       if (tx_ring->buffer_info[i].dma)
+                       buffer_info = &tx_ring->buffer_info[i];
+
+                       if (buffer_info->dma)
                                dma_unmap_single(&pdev->dev,
-                                       tx_ring->buffer_info[i].dma,
-                                       tx_ring->buffer_info[i].length,
-                                       DMA_TO_DEVICE);
-                       if (tx_ring->buffer_info[i].skb)
-                               dev_kfree_skb(tx_ring->buffer_info[i].skb);
+                                                buffer_info->dma,
+                                                buffer_info->length,
+                                                DMA_TO_DEVICE);
+                       if (buffer_info->skb)
+                               dev_kfree_skb(buffer_info->skb);
                }
        }
 
        if (rx_ring->desc && rx_ring->buffer_info) {
                for (i = 0; i < rx_ring->count; i++) {
-                       if (rx_ring->buffer_info[i].dma)
+                       buffer_info = &rx_ring->buffer_info[i];
+
+                       if (buffer_info->dma)
                                dma_unmap_single(&pdev->dev,
-                                       rx_ring->buffer_info[i].dma,
-                                       2048, DMA_FROM_DEVICE);
-                       if (rx_ring->buffer_info[i].skb)
-                               dev_kfree_skb(rx_ring->buffer_info[i].skb);
+                                                buffer_info->dma,
+                                                2048, DMA_FROM_DEVICE);
+                       if (buffer_info->skb)
+                               dev_kfree_skb(buffer_info->skb);
                }
        }
 
@@ -1561,7 +1566,7 @@ static int e1000_check_lbtest_frame(struct sk_buff *skb,
        frame_size &= ~1;
        if (*(skb->data + 3) == 0xFF)
                if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
-                  (*(skb->data + frame_size / 2 + 12) == 0xAF))
+                   (*(skb->data + frame_size / 2 + 12) == 0xAF))
                        return 0;
        return 13;
 }
@@ -1572,6 +1577,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
        struct e1000_ring *rx_ring = &adapter->test_rx_ring;
        struct pci_dev *pdev = adapter->pdev;
        struct e1000_hw *hw = &adapter->hw;
+       struct e1000_buffer *buffer_info;
        int i, j, k, l;
        int lc;
        int good_cnt;
@@ -1594,12 +1600,13 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
        l = 0;
        for (j = 0; j <= lc; j++) { /* loop count loop */
                for (i = 0; i < 64; i++) { /* send the packets */
-                       e1000_create_lbtest_frame(tx_ring->buffer_info[k].skb,
-                                                 1024);
+                       buffer_info = &tx_ring->buffer_info[k];
+
+                       e1000_create_lbtest_frame(buffer_info->skb, 1024);
                        dma_sync_single_for_device(&pdev->dev,
-                                       tx_ring->buffer_info[k].dma,
-                                       tx_ring->buffer_info[k].length,
-                                       DMA_TO_DEVICE);
+                                                  buffer_info->dma,
+                                                  buffer_info->length,
+                                                  DMA_TO_DEVICE);
                        k++;
                        if (k == tx_ring->count)
                                k = 0;
@@ -1610,12 +1617,14 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                time = jiffies; /* set the start time for the receive */
                good_cnt = 0;
                do { /* receive the sent packets */
+                       buffer_info = &rx_ring->buffer_info[l];
+
                        dma_sync_single_for_cpu(&pdev->dev,
-                                       rx_ring->buffer_info[l].dma, 2048,
-                                       DMA_FROM_DEVICE);
+                                               buffer_info->dma, 2048,
+                                               DMA_FROM_DEVICE);
 
-                       ret_val = e1000_check_lbtest_frame(
-                                       rx_ring->buffer_info[l].skb, 1024);
+                       ret_val = e1000_check_lbtest_frame(buffer_info->skb,
+                                                          1024);
                        if (!ret_val)
                                good_cnt++;
                        l++;
index 705e74f8c1d16b026634e4725f91fd7a89d19e61..a18dd1ca22d9d32a8fd53ae8a1ef84c1c4b0db55 100644 (file)
@@ -1804,8 +1804,8 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                ew32(RCTL, mac_reg);
 
                ret_val = e1000e_read_kmrn_reg(hw,
-                                               E1000_KMRNCTRLSTA_CTRL_OFFSET,
-                                               &data);
+                                              E1000_KMRNCTRLSTA_CTRL_OFFSET,
+                                              &data);
                if (ret_val)
                        return ret_val;
                ret_val = e1000e_write_kmrn_reg(hw,
@@ -1814,8 +1814,8 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                if (ret_val)
                        return ret_val;
                ret_val = e1000e_read_kmrn_reg(hw,
-                                               E1000_KMRNCTRLSTA_HD_CTRL,
-                                               &data);
+                                              E1000_KMRNCTRLSTA_HD_CTRL,
+                                              &data);
                if (ret_val)
                        return ret_val;
                data &= ~(0xF << 8);
@@ -1862,8 +1862,8 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                ew32(RCTL, mac_reg);
 
                ret_val = e1000e_read_kmrn_reg(hw,
-                                               E1000_KMRNCTRLSTA_CTRL_OFFSET,
-                                               &data);
+                                              E1000_KMRNCTRLSTA_CTRL_OFFSET,
+                                              &data);
                if (ret_val)
                        return ret_val;
                ret_val = e1000e_write_kmrn_reg(hw,
@@ -1872,8 +1872,8 @@ s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable)
                if (ret_val)
                        return ret_val;
                ret_val = e1000e_read_kmrn_reg(hw,
-                                               E1000_KMRNCTRLSTA_HD_CTRL,
-                                               &data);
+                                              E1000_KMRNCTRLSTA_HD_CTRL,
+                                              &data);
                if (ret_val)
                        return ret_val;
                data &= ~(0xF << 8);
@@ -2653,8 +2653,9 @@ static s32 e1000_read_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
 
                ew32flash(ICH_FLASH_FADDR, flash_linear_addr);
 
-               ret_val = e1000_flash_cycle_ich8lan(hw,
-                                               ICH_FLASH_READ_COMMAND_TIMEOUT);
+               ret_val =
+                   e1000_flash_cycle_ich8lan(hw,
+                                             ICH_FLASH_READ_COMMAND_TIMEOUT);
 
                /* Check if FCERR is set to 1, if set to 1, clear it
                 * and try the whole sequence a few more times, else
@@ -3017,8 +3018,9 @@ static s32 e1000_write_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
                /* check if FCERR is set to 1 , if set to 1, clear it
                 * and try the whole sequence a few more times else done
                 */
-               ret_val = e1000_flash_cycle_ich8lan(hw,
-                                              ICH_FLASH_WRITE_COMMAND_TIMEOUT);
+               ret_val =
+                   e1000_flash_cycle_ich8lan(hw,
+                                             ICH_FLASH_WRITE_COMMAND_TIMEOUT);
                if (!ret_val)
                        break;
 
@@ -3150,6 +3152,8 @@ static s32 e1000_erase_flash_bank_ich8lan(struct e1000_hw *hw, u32 bank)
 
        for (j = 0; j < iteration ; j++) {
                do {
+                       u32 timeout = ICH_FLASH_ERASE_COMMAND_TIMEOUT;
+
                        /* Steps */
                        ret_val = e1000_flash_cycle_init_ich8lan(hw);
                        if (ret_val)
@@ -3169,8 +3173,7 @@ static s32 e1000_erase_flash_bank_ich8lan(struct e1000_hw *hw, u32 bank)
                        flash_linear_addr += (j * sector_size);
                        ew32flash(ICH_FLASH_FADDR, flash_linear_addr);
 
-                       ret_val = e1000_flash_cycle_ich8lan(hw,
-                                              ICH_FLASH_ERASE_COMMAND_TIMEOUT);
+                       ret_val = e1000_flash_cycle_ich8lan(hw, timeout);
                        if (!ret_val)
                                break;
 
@@ -3625,8 +3628,7 @@ static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw)
         */
        hw->fc.current_mode = hw->fc.requested_mode;
 
-       e_dbg("After fix-ups FlowControl is now = %x\n",
-               hw->fc.current_mode);
+       e_dbg("After fix-ups FlowControl is now = %x\n", hw->fc.current_mode);
 
        /* Continue to configure the copper link. */
        ret_val = hw->mac.ops.setup_physical_interface(hw);
@@ -3838,7 +3840,7 @@ static s32 e1000_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw)
  *  /disabled - false).
  **/
 void e1000e_set_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw,
-                                                bool state)
+                                                 bool state)
 {
        struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan;
 
@@ -3920,12 +3922,12 @@ void e1000e_gig_downshift_workaround_ich8lan(struct e1000_hw *hw)
                return;
 
        ret_val = e1000e_read_kmrn_reg(hw, E1000_KMRNCTRLSTA_DIAG_OFFSET,
-                                     &reg_data);
+                                      &reg_data);
        if (ret_val)
                return;
        reg_data |= E1000_KMRNCTRLSTA_DIAG_NELPBK;
        ret_val = e1000e_write_kmrn_reg(hw, E1000_KMRNCTRLSTA_DIAG_OFFSET,
-                                      reg_data);
+                                       reg_data);
        if (ret_val)
                return;
        reg_data &= ~E1000_KMRNCTRLSTA_DIAG_NELPBK;
index 87fa1c9d5ff633c9db58c3bc99ceb14871978b3e..9d76edcca62d1d86f1eca668ba0fbffb2053896d 100644 (file)
@@ -1430,7 +1430,7 @@ copydone:
                e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
                if (rx_desc->wb.upper.header_status &
-                          cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))
+                   cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))
                        adapter->rx_hdr_split++;
 
                e1000_receive_skb(adapter, netdev, skb, staterr,
@@ -1496,6 +1496,7 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
        int cleaned_count = 0;
        bool cleaned = false;
        unsigned int total_rx_bytes = 0, total_rx_packets = 0;
+       struct skb_shared_info *shinfo;
 
        i = rx_ring->next_to_clean;
        rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
@@ -1552,9 +1553,10 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                                                   0, length);
                        } else {
                                /* this is the middle of a chain */
-                               skb_fill_page_desc(rxtop,
-                                   skb_shinfo(rxtop)->nr_frags,
-                                   buffer_info->page, 0, length);
+                               shinfo = skb_shinfo(rxtop);
+                               skb_fill_page_desc(rxtop, shinfo->nr_frags,
+                                                  buffer_info->page, 0,
+                                                  length);
                                /* re-use the skb, only consumed the page */
                                buffer_info->skb = skb;
                        }
@@ -1563,9 +1565,10 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                } else {
                        if (rxtop) {
                                /* end of the chain */
-                               skb_fill_page_desc(rxtop,
-                                   skb_shinfo(rxtop)->nr_frags,
-                                   buffer_info->page, 0, length);
+                               shinfo = skb_shinfo(rxtop);
+                               skb_fill_page_desc(rxtop, shinfo->nr_frags,
+                                                  buffer_info->page, 0,
+                                                  length);
                                /* re-use the current skb, we only consumed the
                                 * page
                                 */
@@ -1719,7 +1722,8 @@ static void e1000_clean_rx_ring(struct e1000_ring *rx_ring)
 static void e1000e_downshift_workaround(struct work_struct *work)
 {
        struct e1000_adapter *adapter = container_of(work,
-                                       struct e1000_adapter, downshift_task);
+                                                    struct e1000_adapter,
+                                                    downshift_task);
 
        if (test_bit(__E1000_DOWN, &adapter->state))
                return;
@@ -2044,8 +2048,9 @@ void e1000e_set_interrupt_capability(struct e1000_adapter *adapter)
                if (adapter->flags & FLAG_HAS_MSIX) {
                        adapter->num_vectors = 3; /* RxQ0, TxQ0 and other */
                        adapter->msix_entries = kcalloc(adapter->num_vectors,
-                                                     sizeof(struct msix_entry),
-                                                     GFP_KERNEL);
+                                                       sizeof(struct
+                                                              msix_entry),
+                                                       GFP_KERNEL);
                        if (adapter->msix_entries) {
                                for (i = 0; i < adapter->num_vectors; i++)
                                        adapter->msix_entries[i].entry = i;
@@ -3854,13 +3859,13 @@ void e1000e_reset(struct e1000_adapter *adapter)
                if ((adapter->max_frame_size * 2) > (pba << 10)) {
                        if (!(adapter->flags2 & FLAG2_DISABLE_AIM)) {
                                dev_info(&adapter->pdev->dev,
-                                       "Interrupt Throttle Rate turned off\n");
+                                        "Interrupt Throttle Rate off\n");
                                adapter->flags2 |= FLAG2_DISABLE_AIM;
                                e1000e_write_itr(adapter, 0);
                        }
                } else if (adapter->flags2 & FLAG2_DISABLE_AIM) {
                        dev_info(&adapter->pdev->dev,
-                                "Interrupt Throttle Rate turned on\n");
+                                "Interrupt Throttle Rate on\n");
                        adapter->flags2 &= ~FLAG2_DISABLE_AIM;
                        adapter->itr = 20000;
                        e1000e_write_itr(adapter, adapter->itr);
@@ -4429,7 +4434,8 @@ static int e1000_set_mac(struct net_device *netdev, void *p)
 static void e1000e_update_phy_task(struct work_struct *work)
 {
        struct e1000_adapter *adapter = container_of(work,
-                                       struct e1000_adapter, update_phy_task);
+                                                    struct e1000_adapter,
+                                                    update_phy_task);
 
        if (test_bit(__E1000_DOWN, &adapter->state))
                return;
@@ -4789,7 +4795,8 @@ static void e1000_watchdog(unsigned long data)
 static void e1000_watchdog_task(struct work_struct *work)
 {
        struct e1000_adapter *adapter = container_of(work,
-                                       struct e1000_adapter, watchdog_task);
+                                                    struct e1000_adapter,
+                                                    watchdog_task);
        struct net_device *netdev = adapter->netdev;
        struct e1000_mac_info *mac = &adapter->hw.mac;
        struct e1000_phy_info *phy = &adapter->hw.phy;
@@ -4823,8 +4830,8 @@ static void e1000_watchdog_task(struct work_struct *work)
                        /* update snapshot of PHY registers on LSC */
                        e1000_phy_read_status(adapter);
                        mac->ops.get_link_up_info(&adapter->hw,
-                                                  &adapter->link_speed,
-                                                  &adapter->link_duplex);
+                                                 &adapter->link_speed,
+                                                 &adapter->link_duplex);
                        e1000_print_link_info(adapter);
 
                        /* check if SmartSpeed worked */
@@ -4937,7 +4944,7 @@ static void e1000_watchdog_task(struct work_struct *work)
                                adapter->flags |= FLAG_RESTART_NOW;
                        else
                                pm_schedule_suspend(netdev->dev.parent,
-                                                       LINK_TIMEOUT);
+                                                   LINK_TIMEOUT);
                }
        }
 
@@ -4972,8 +4979,8 @@ link_up:
                 */
                u32 goc = (adapter->gotc + adapter->gorc) / 10000;
                u32 dif = (adapter->gotc > adapter->gorc ?
-                           adapter->gotc - adapter->gorc :
-                           adapter->gorc - adapter->gotc) / 10000;
+                          adapter->gotc - adapter->gorc :
+                          adapter->gorc - adapter->gotc) / 10000;
                u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
 
                e1000e_write_itr(adapter, itr);
@@ -5211,7 +5218,8 @@ static int e1000_tx_map(struct e1000_ring *tx_ring, struct sk_buff *skb,
                        buffer_info->time_stamp = jiffies;
                        buffer_info->next_to_watch = i;
                        buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
-                                               offset, size, DMA_TO_DEVICE);
+                                                           offset, size,
+                                                           DMA_TO_DEVICE);
                        buffer_info->mapped_as_page = true;
                        if (dma_mapping_error(&pdev->dev, buffer_info->dma))
                                goto dma_error;
@@ -5669,9 +5677,9 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
 
        /* adjust allocation if LPE protects us, and we aren't using SBP */
        if ((max_frame == ETH_FRAME_LEN + ETH_FCS_LEN) ||
-            (max_frame == ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN))
+           (max_frame == ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN))
                adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN
-                                        + ETH_FCS_LEN;
+                   + ETH_FCS_LEN;
 
        if (netif_running(netdev))
                e1000e_up(adapter);
@@ -5850,7 +5858,7 @@ static int e1000_init_phy_wakeup(struct e1000_adapter *adapter, u32 wufc)
        phy_reg &= ~(BM_RCTL_MO_MASK);
        if (mac_reg & E1000_RCTL_MO_3)
                phy_reg |= (((mac_reg & E1000_RCTL_MO_3) >> E1000_RCTL_MO_SHIFT)
-                               << BM_RCTL_MO_SHIFT);
+                           << BM_RCTL_MO_SHIFT);
        if (mac_reg & E1000_RCTL_BAM)
                phy_reg |= BM_RCTL_BAM;
        if (mac_reg & E1000_RCTL_PMCF)
@@ -6098,24 +6106,24 @@ static int __e1000_resume(struct pci_dev *pdev)
                e1e_rphy(&adapter->hw, BM_WUS, &phy_data);
                if (phy_data) {
                        e_info("PHY Wakeup cause - %s\n",
-                               phy_data & E1000_WUS_EX ? "Unicast Packet" :
-                               phy_data & E1000_WUS_MC ? "Multicast Packet" :
-                               phy_data & E1000_WUS_BC ? "Broadcast Packet" :
-                               phy_data & E1000_WUS_MAG ? "Magic Packet" :
-                               phy_data & E1000_WUS_LNKC ?
-                               "Link Status Change" : "other");
+                              phy_data & E1000_WUS_EX ? "Unicast Packet" :
+                              phy_data & E1000_WUS_MC ? "Multicast Packet" :
+                              phy_data & E1000_WUS_BC ? "Broadcast Packet" :
+                              phy_data & E1000_WUS_MAG ? "Magic Packet" :
+                              phy_data & E1000_WUS_LNKC ?
+                              "Link Status Change" : "other");
                }
                e1e_wphy(&adapter->hw, BM_WUS, ~0);
        } else {
                u32 wus = er32(WUS);
                if (wus) {
                        e_info("MAC Wakeup cause - %s\n",
-                               wus & E1000_WUS_EX ? "Unicast Packet" :
-                               wus & E1000_WUS_MC ? "Multicast Packet" :
-                               wus & E1000_WUS_BC ? "Broadcast Packet" :
-                               wus & E1000_WUS_MAG ? "Magic Packet" :
-                               wus & E1000_WUS_LNKC ? "Link Status Change" :
-                               "other");
+                              wus & E1000_WUS_EX ? "Unicast Packet" :
+                              wus & E1000_WUS_MC ? "Multicast Packet" :
+                              wus & E1000_WUS_BC ? "Broadcast Packet" :
+                              wus & E1000_WUS_MAG ? "Magic Packet" :
+                              wus & E1000_WUS_LNKC ? "Link Status Change" :
+                              "other");
                }
                ew32(WUS, ~0);
        }
@@ -6514,7 +6522,7 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        resource_size_t flash_start, flash_len;
        static int cards_found;
        u16 aspm_disable_flag = 0;
-       int i, err, pci_using_dac;
+       int bars, i, err, pci_using_dac;
        u16 eeprom_data = 0;
        u16 eeprom_apme_mask = E1000_EEPROM_APME;
 
@@ -6548,9 +6556,9 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                }
        }
 
-       err = pci_request_selected_regions_exclusive(pdev,
-                                         pci_select_bars(pdev, IORESOURCE_MEM),
-                                         e1000e_driver_name);
+       bars = pci_select_bars(pdev, IORESOURCE_MEM);
+       err = pci_request_selected_regions_exclusive(pdev, bars,
+                                                    e1000e_driver_name);
        if (err)
                goto err_pci_reg;
 
@@ -6995,8 +7003,8 @@ MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
 #ifdef CONFIG_PM
 static const struct dev_pm_ops e1000_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(e1000_suspend, e1000_resume)
-       SET_RUNTIME_PM_OPS(e1000_runtime_suspend,
-                               e1000_runtime_resume, e1000_idle)
+       SET_RUNTIME_PM_OPS(e1000_runtime_suspend, e1000_runtime_resume,
+                          e1000_idle)
 };
 #endif
 
index a0117436826d6ecccee0762942c7bfbf3f9213a4..39fb5072128e27f84b35acdda876b434fd1bef0c 100644 (file)
@@ -45,7 +45,7 @@
 unsigned int copybreak = COPYBREAK_DEFAULT;
 module_param(copybreak, uint, 0644);
 MODULE_PARM_DESC(copybreak,
-       "Maximum size of packet that is copied to a new buffer on receive");
+                "Maximum size of packet that is copied to a new buffer on receive");
 
 /* All parameters are treated the same, as an integer array of values.
  * This macro just reduces the need to repeat the same declaration code
@@ -478,18 +478,17 @@ void e1000e_check_options(struct e1000_adapter *adapter)
                        .err  = "defaulting to Enabled",
                        .def  = OPTION_ENABLED
                };
+               bool enabled = opt.def;
 
                if (num_KumeranLockLoss > bd) {
                        unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
                        e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
-                       if (hw->mac.type == e1000_ich8lan)
-                               e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
-                                                               kmrn_lock_loss);
-               } else {
-                       if (hw->mac.type == e1000_ich8lan)
-                               e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
-                                                                      opt.def);
+                       enabled = kmrn_lock_loss;
                }
+
+               if (hw->mac.type == e1000_ich8lan)
+                       e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
+                                                                    enabled);
        }
        { /* Write-protect NVM */
                static const struct e1000_option opt = {
index 643353f4e6705fa84c45969b66c6faabdaa8b5fa..8ff0060e0ed683d1016da64de64b1fa53133d7f6 100644 (file)
@@ -410,8 +410,7 @@ static s32 __e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data,
                                                    (u16)offset);
        if (!ret_val)
                ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS &
-                                                       offset,
-                                                   data);
+                                                   offset, data);
        if (!locked)
                hw->phy.ops.release(hw);
 
@@ -1296,7 +1295,7 @@ s32 e1000e_phy_force_speed_duplex_m88(struct e1000_hw *hw)
                e_dbg("Waiting for forced speed/duplex link on M88 phy.\n");
 
                ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
-                                                    100000, &link);
+                                                     100000, &link);
                if (ret_val)
                        return ret_val;
 
@@ -1319,7 +1318,7 @@ s32 e1000e_phy_force_speed_duplex_m88(struct e1000_hw *hw)
 
                /* Try once more */
                ret_val = e1000e_phy_has_link_generic(hw, PHY_FORCE_LIMIT,
-                                                    100000, &link);
+                                                     100000, &link);
                if (ret_val)
                        return ret_val;
        }
@@ -1733,7 +1732,7 @@ static s32 e1000_wait_autoneg(struct e1000_hw *hw)
  *  Polls the PHY status register for link, 'iterations' number of times.
  **/
 s32 e1000e_phy_has_link_generic(struct e1000_hw *hw, u32 iterations,
-                              u32 usec_interval, bool *success)
+                               u32 usec_interval, bool *success)
 {
        s32 ret_val = 0;
        u16 i, phy_status;