e1000: convert uint16_t style integers to u16

Conglomerate from 4 separate patches from Joe.

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Auke Kok <auke-jan.h.kok@intel.com>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>

1 files changed, 87 insertions, 87 deletions

diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 757d02f443a5..59579b1d8843 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -127,7 +127,7 @@ int e1000_up(struct e1000_adapter *adapter);
 void e1000_down(struct e1000_adapter *adapter);
 void e1000_reinit_locked(struct e1000_adapter *adapter);
 void e1000_reset(struct e1000_adapter *adapter);
-int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
+int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);
 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
 void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
@@ -203,8 +203,8 @@ static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
                                        struct sk_buff *skb);
 
 static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
-static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
-static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
+static void e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
+static void e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
 static void e1000_restore_vlan(struct e1000_adapter *adapter);
 
 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
@@ -368,8 +368,8 @@ static void
 e1000_update_mng_vlan(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
-        uint16_t vid = adapter->hw.mng_cookie.vlan_id;
-        uint16_t old_vid = adapter->mng_vlan_id;
+        u16 vid = adapter->hw.mng_cookie.vlan_id;
+        u16 old_vid = adapter->mng_vlan_id;
         if (adapter->vlgrp) {
                 if (!vlan_group_get_device(adapter->vlgrp, vid)) {
                         if (adapter->hw.mng_cookie.status &
@@ -379,7 +379,7 @@ e1000_update_mng_vlan(struct e1000_adapter *adapter)
                         } else
                                 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
 
-                        if ((old_vid != (uint16_t)E1000_MNG_VLAN_NONE) &&
+                        if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
                                         (vid != old_vid) &&
                             !vlan_group_get_device(adapter->vlgrp, old_vid))
                                 e1000_vlan_rx_kill_vid(netdev, old_vid);
@@ -402,8 +402,8 @@ e1000_update_mng_vlan(struct e1000_adapter *adapter)
 static void
 e1000_release_hw_control(struct e1000_adapter *adapter)
 {
-        uint32_t ctrl_ext;
-        uint32_t swsm;
+        u32 ctrl_ext;
+        u32 swsm;
 
         /* Let firmware taken over control of h/w */
         switch (adapter->hw.mac_type) {
@@ -439,8 +439,8 @@ e1000_release_hw_control(struct e1000_adapter *adapter)
 static void
 e1000_get_hw_control(struct e1000_adapter *adapter)
 {
-        uint32_t ctrl_ext;
-        uint32_t swsm;
+        u32 ctrl_ext;
+        u32 swsm;
 
         /* Let firmware know the driver has taken over */
         switch (adapter->hw.mac_type) {
@@ -466,7 +466,7 @@ static void
 e1000_init_manageability(struct e1000_adapter *adapter)
 {
         if (adapter->en_mng_pt) {
-                uint32_t manc = E1000_READ_REG(&adapter->hw, MANC);
+                u32 manc = E1000_READ_REG(&adapter->hw, MANC);
 
                 /* disable hardware interception of ARP */
                 manc &= ~(E1000_MANC_ARP_EN);
@@ -475,7 +475,7 @@ e1000_init_manageability(struct e1000_adapter *adapter)
                 /* this will probably generate destination unreachable messages
                  * from the host OS, but the packets will be handled on SMBUS */
                 if (adapter->hw.has_manc2h) {
-                        uint32_t manc2h = E1000_READ_REG(&adapter->hw, MANC2H);
+                        u32 manc2h = E1000_READ_REG(&adapter->hw, MANC2H);
 
                         manc |= E1000_MANC_EN_MNG2HOST;
 #define E1000_MNG2HOST_PORT_623 (1 << 5)
@@ -493,7 +493,7 @@ static void
 e1000_release_manageability(struct e1000_adapter *adapter)
 {
         if (adapter->en_mng_pt) {
-                uint32_t manc = E1000_READ_REG(&adapter->hw, MANC);
+                u32 manc = E1000_READ_REG(&adapter->hw, MANC);
 
                 /* re-enable hardware interception of ARP */
                 manc |= E1000_MANC_ARP_EN;
@@ -566,7 +566,7 @@ int e1000_up(struct e1000_adapter *adapter)
 
 void e1000_power_up_phy(struct e1000_adapter *adapter)
 {
-        uint16_t mii_reg = 0;
+        u16 mii_reg = 0;
 
         /* Just clear the power down bit to wake the phy back up */
         if (adapter->hw.media_type == e1000_media_type_copper) {
@@ -587,7 +587,7 @@ static void e1000_power_down_phy(struct e1000_adapter *adapter)
          * (c) SoL/IDER session is active */
         if (!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
            adapter->hw.media_type == e1000_media_type_copper) {
-                uint16_t mii_reg = 0;
+                u16 mii_reg = 0;
 
                 switch (adapter->hw.mac_type) {
                 case e1000_82540:
@@ -667,8 +667,8 @@ e1000_reinit_locked(struct e1000_adapter *adapter)
 void
 e1000_reset(struct e1000_adapter *adapter)
 {
-        uint32_t pba = 0, tx_space, min_tx_space, min_rx_space;
-        uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
+        u32 pba = 0, tx_space, min_tx_space, min_rx_space;
+        u16 fc_high_water_mark = E1000_FC_HIGH_DIFF;
         bool legacy_pba_adjust = false;
 
         /* Repartition Pba for greater than 9k mtu
@@ -815,7 +815,7 @@ e1000_reset(struct e1000_adapter *adapter)
             adapter->hw.mac_type <= e1000_82547_rev_2 &&
             adapter->hw.autoneg == 1 &&
             adapter->hw.autoneg_advertised == ADVERTISE_1000_FULL) {
-                uint32_t ctrl = E1000_READ_REG(&adapter->hw, CTRL);
+                u32 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
                 /* clear phy power management bit if we are in gig only mode,
                  * which if enabled will attempt negotiation to 100Mb, which
                  * can cause a loss of link at power off or driver unload */
@@ -832,7 +832,7 @@ e1000_reset(struct e1000_adapter *adapter)
         if (!adapter->smart_power_down &&
             (adapter->hw.mac_type == e1000_82571 ||
              adapter->hw.mac_type == e1000_82572)) {
-                uint16_t phy_data = 0;
+                u16 phy_data = 0;
                 /* speed up time to link by disabling smart power down, ignore
                  * the return value of this function because there is nothing
                  * different we would do if it failed */
@@ -926,8 +926,8 @@ e1000_probe(struct pci_dev *pdev,
         static int cards_found = 0;
         static int global_quad_port_a = 0; /* global ksp3 port a indication */
         int i, err, pci_using_dac;
-        uint16_t eeprom_data = 0;
-        uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
+        u16 eeprom_data = 0;
+        u16 eeprom_apme_mask = E1000_EEPROM_APME;
         DECLARE_MAC_BUF(mac);
 
         if ((err = pci_enable_device(pdev)))
@@ -1702,10 +1702,10 @@ e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
 static void
 e1000_configure_tx(struct e1000_adapter *adapter)
 {
-        uint64_t tdba;
+        u64 tdba;
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t tdlen, tctl, tipg, tarc;
-        uint32_t ipgr1, ipgr2;
+        u32 tdlen, tctl, tipg, tarc;
+        u32 ipgr1, ipgr2;
 
         /* Setup the HW Tx Head and Tail descriptor pointers */
 
@@ -1947,10 +1947,10 @@ e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
 static void
 e1000_setup_rctl(struct e1000_adapter *adapter)
 {
-        uint32_t rctl, rfctl;
-        uint32_t psrctl = 0;
+        u32 rctl, rfctl;
+        u32 psrctl = 0;
 #ifndef CONFIG_E1000_DISABLE_PACKET_SPLIT
-        uint32_t pages = 0;
+        u32 pages = 0;
 #endif
 
         rctl = E1000_READ_REG(&adapter->hw, RCTL);
@@ -2065,9 +2065,9 @@ e1000_setup_rctl(struct e1000_adapter *adapter)
 static void
 e1000_configure_rx(struct e1000_adapter *adapter)
 {
-        uint64_t rdba;
+        u64 rdba;
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t rdlen, rctl, rxcsum, ctrl_ext;
+        u32 rdlen, rctl, rxcsum, ctrl_ext;
 
         if (adapter->rx_ps_pages) {
                 /* this is a 32 byte descriptor */
@@ -2387,7 +2387,7 @@ static void
 e1000_enter_82542_rst(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
-        uint32_t rctl;
+        u32 rctl;
 
         e1000_pci_clear_mwi(&adapter->hw);
 
@@ -2405,7 +2405,7 @@ static void
 e1000_leave_82542_rst(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
-        uint32_t rctl;
+        u32 rctl;
 
         rctl = E1000_READ_REG(&adapter->hw, RCTL);
         rctl &= ~E1000_RCTL_RST;
@@ -2490,8 +2490,8 @@ e1000_set_rx_mode(struct net_device *netdev)
         struct e1000_hw *hw = &adapter->hw;
         struct dev_addr_list *uc_ptr;
         struct dev_addr_list *mc_ptr;
-        uint32_t rctl;
-        uint32_t hash_value;
+        u32 rctl;
+        u32 hash_value;
         int i, rar_entries = E1000_RAR_ENTRIES;
         int mta_reg_count = (hw->mac_type == e1000_ich8lan) ?
                                 E1000_NUM_MTA_REGISTERS_ICH8LAN :
@@ -2595,7 +2595,7 @@ e1000_82547_tx_fifo_stall(unsigned long data)
 {
         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
         struct net_device *netdev = adapter->netdev;
-        uint32_t tctl;
+        u32 tctl;
 
         if (atomic_read(&adapter->tx_fifo_stall)) {
                 if ((E1000_READ_REG(&adapter->hw, TDT) ==
@@ -2637,8 +2637,8 @@ e1000_watchdog(unsigned long data)
         struct e1000_adapter *adapter = (struct e1000_adapter *) data;
         struct net_device *netdev = adapter->netdev;
         struct e1000_tx_ring *txdr = adapter->tx_ring;
-        uint32_t link, tctl;
-        int32_t ret_val;
+        u32 link, tctl;
+        s32 ret_val;
 
         ret_val = e1000_check_for_link(&adapter->hw);
         if ((ret_val == E1000_ERR_PHY) &&
@@ -2663,7 +2663,7 @@ e1000_watchdog(unsigned long data)
 
         if (link) {
                 if (!netif_carrier_ok(netdev)) {
-                        uint32_t ctrl;
+                        u32 ctrl;
                         bool txb2b = true;
                         e1000_get_speed_and_duplex(&adapter->hw,
                                                    &adapter->link_speed,
@@ -2700,7 +2700,7 @@ e1000_watchdog(unsigned long data)
                         if ((adapter->hw.mac_type == e1000_82571 ||
                              adapter->hw.mac_type == e1000_82572) &&
                             !txb2b) {
-                                uint32_t tarc0;
+                                u32 tarc0;
                                 tarc0 = E1000_READ_REG(&adapter->hw, TARC0);
                                 tarc0 &= ~(1 << 21);
                                 E1000_WRITE_REG(&adapter->hw, TARC0, tarc0);
@@ -2742,7 +2742,7 @@ e1000_watchdog(unsigned long data)
                         /* make sure the receive unit is started */
                         if (adapter->hw.rx_needs_kicking) {
                                 struct e1000_hw *hw = &adapter->hw;
-                                uint32_t rctl = E1000_READ_REG(hw, RCTL);
+                                u32 rctl = E1000_READ_REG(hw, RCTL);
                                 E1000_WRITE_REG(hw, RCTL, rctl | E1000_RCTL_EN);
                         }
                 }
@@ -2832,7 +2832,7 @@ enum latency_range {
  * @bytes: the number of bytes during this measurement interval
  **/
 static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
-                                   uint16_t itr_setting,
+                                   u16 itr_setting,
                                    int packets,
                                    int bytes)
 {
@@ -2884,8 +2884,8 @@ update_itr_done:
 static void e1000_set_itr(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
-        uint16_t current_itr;
-        uint32_t new_itr = adapter->itr;
+        u16 current_itr;
+        u32 new_itr = adapter->itr;
 
         if (unlikely(hw->mac_type < e1000_82540))
                 return;
@@ -2959,9 +2959,9 @@ e1000_tso(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
         struct e1000_context_desc *context_desc;
         struct e1000_buffer *buffer_info;
         unsigned int i;
-        uint32_t cmd_length = 0;
-        uint16_t ipcse = 0, tucse, mss;
-        uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
+        u32 cmd_length = 0;
+        u16 ipcse = 0, tucse, mss;
+        u8 ipcss, ipcso, tucss, tucso, hdr_len;
         int err;
 
         if (skb_is_gso(skb)) {
@@ -3032,7 +3032,7 @@ e1000_tx_csum(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
         struct e1000_context_desc *context_desc;
         struct e1000_buffer *buffer_info;
         unsigned int i;
-        uint8_t css;
+        u8 css;
 
         if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
                 css = skb_transport_offset(skb);
@@ -3177,7 +3177,7 @@ e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
 {
         struct e1000_tx_desc *tx_desc = NULL;
         struct e1000_buffer *buffer_info;
-        uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
+        u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
         unsigned int i;
 
         if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
@@ -3241,8 +3241,8 @@ e1000_tx_queue(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring,
 static int
 e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
 {
-        uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
-        uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;
+        u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
+        u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
 
         skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
 
@@ -3269,7 +3269,7 @@ static int
 e1000_transfer_dhcp_info(struct e1000_adapter *adapter, struct sk_buff *skb)
 {
         struct e1000_hw *hw =  &adapter->hw;
-        uint16_t length, offset;
+        u16 length, offset;
         if (vlan_tx_tag_present(skb)) {
                 if (!((vlan_tx_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
                         ( adapter->hw.mng_cookie.status &
@@ -3280,17 +3280,17 @@ e1000_transfer_dhcp_info(struct e1000_adapter *adapter, struct sk_buff *skb)
                 struct ethhdr *eth = (struct ethhdr *) skb->data;
                 if ((htons(ETH_P_IP) == eth->h_proto)) {
                         const struct iphdr *ip =
-                                (struct iphdr *)((uint8_t *)skb->data+14);
+                                (struct iphdr *)((u8 *)skb->data+14);
                         if (IPPROTO_UDP == ip->protocol) {
                                 struct udphdr *udp =
-                                        (struct udphdr *)((uint8_t *)ip +
+                                        (struct udphdr *)((u8 *)ip +
                                                 (ip->ihl << 2));
                                 if (ntohs(udp->dest) == 67) {
-                                        offset = (uint8_t *)udp + 8 - skb->data;
+                                        offset = (u8 *)udp + 8 - skb->data;
                                         length = skb->len - offset;
 
                                         return e1000_mng_write_dhcp_info(hw,
-                                                        (uint8_t *)udp + 8,
+                                                        (u8 *)udp + 8,
                                                         length);
                                 }
                         }
@@ -3370,7 +3370,7 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
          * overrun the FIFO, adjust the max buffer len if mss
          * drops. */
         if (mss) {
-                uint8_t hdr_len;
+                u8 hdr_len;
                 max_per_txd = min(mss << 2, max_per_txd);
                 max_txd_pwr = fls(max_per_txd) - 1;
 
@@ -3557,7 +3557,7 @@ e1000_change_mtu(struct net_device *netdev, int new_mtu)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
-        uint16_t eeprom_data = 0;
+        u16 eeprom_data = 0;
 
         if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
             (max_frame > MAX_JUMBO_FRAME_SIZE)) {
@@ -3652,7 +3652,7 @@ e1000_update_stats(struct e1000_adapter *adapter)
         struct e1000_hw *hw = &adapter->hw;
         struct pci_dev *pdev = adapter->pdev;
         unsigned long flags;
-        uint16_t phy_tmp;
+        u16 phy_tmp;
 
 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
 
@@ -3829,7 +3829,7 @@ e1000_intr_msi(int irq, void *data)
 #ifndef CONFIG_E1000_NAPI
         int i;
 #endif
-        uint32_t icr = E1000_READ_REG(hw, ICR);
+        u32 icr = E1000_READ_REG(hw, ICR);
 
         /* in NAPI mode read ICR disables interrupts using IAM */
 
@@ -3841,7 +3841,7 @@ e1000_intr_msi(int irq, void *data)
                 if (netif_carrier_ok(netdev) &&
                     (adapter->hw.mac_type == e1000_80003es2lan)) {
                         /* disable receives */
-                        uint32_t rctl = E1000_READ_REG(hw, RCTL);
+                        u32 rctl = E1000_READ_REG(hw, RCTL);
                         E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN);
                 }
                 /* guard against interrupt when we're going down */
@@ -3888,7 +3888,7 @@ e1000_intr(int irq, void *data)
         struct net_device *netdev = data;
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t rctl, icr = E1000_READ_REG(hw, ICR);
+        u32 rctl, icr = E1000_READ_REG(hw, ICR);
 #ifndef CONFIG_E1000_NAPI
         int i;
 #endif
@@ -4139,11 +4139,11 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter,
 
 static void
 e1000_rx_checksum(struct e1000_adapter *adapter,
-                  uint32_t status_err, uint32_t csum,
+                  u32 status_err, u32 csum,
                   struct sk_buff *skb)
 {
-        uint16_t status = (uint16_t)status_err;
-        uint8_t errors = (uint8_t)(status_err >> 24);
+        u16 status = (u16)status_err;
+        u8 errors = (u8)(status_err >> 24);
         skb->ip_summed = CHECKSUM_NONE;
 
         /* 82543 or newer only */
@@ -4200,8 +4200,8 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
         struct e1000_rx_desc *rx_desc, *next_rxd;
         struct e1000_buffer *buffer_info, *next_buffer;
         unsigned long flags;
-        uint32_t length;
-        uint8_t last_byte;
+        u32 length;
+        u8 last_byte;
         unsigned int i;
         int cleaned_count = 0;
         bool cleaned = false;
@@ -4301,8 +4301,8 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
 
                 /* Receive Checksum Offload */
                 e1000_rx_checksum(adapter,
-                                  (uint32_t)(status) |
-                                  ((uint32_t)(rx_desc->errors) << 24),
+                                  (u32)(status) |
+                                  ((u32)(rx_desc->errors) << 24),
                                   le16_to_cpu(rx_desc->csum), skb);
 
                 skb->protocol = eth_type_trans(skb, netdev);
@@ -4376,7 +4376,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
         struct e1000_ps_page_dma *ps_page_dma;
         struct sk_buff *skb;
         unsigned int i, j;
-        uint32_t length, staterr;
+        u32 length, staterr;
         int cleaned_count = 0;
         bool cleaned = false;
         unsigned int total_rx_bytes=0, total_rx_packets=0;
@@ -4759,8 +4759,8 @@ no_buffers:
 static void
 e1000_smartspeed(struct e1000_adapter *adapter)
 {
-        uint16_t phy_status;
-        uint16_t phy_ctrl;
+        u16 phy_status;
+        u16 phy_ctrl;
 
         if ((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
            !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
@@ -4839,8 +4839,8 @@ e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct mii_ioctl_data *data = if_mii(ifr);
         int retval;
-        uint16_t mii_reg;
-        uint16_t spddplx;
+        u16 mii_reg;
+        u16 spddplx;
         unsigned long flags;
 
         if (adapter->hw.media_type != e1000_media_type_copper)
@@ -4959,11 +4959,11 @@ e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
         pcix_set_mmrbc(adapter->pdev, mmrbc);
 }
 
-int32_t
-e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
+s32
+e1000_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
 {
     struct e1000_adapter *adapter = hw->back;
-    uint16_t cap_offset;
+    u16 cap_offset;
 
     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
     if (!cap_offset)
@@ -4975,7 +4975,7 @@ e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
 }
 
 void
-e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t value)
+e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
 {
         outl(value, port);
 }
@@ -4984,7 +4984,7 @@ static void
 e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        uint32_t ctrl, rctl;
+        u32 ctrl, rctl;
 
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_disable(adapter);
@@ -5016,7 +5016,7 @@ e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
                         rctl &= ~E1000_RCTL_VFE;
                         E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
                         if (adapter->mng_vlan_id !=
-                            (uint16_t)E1000_MNG_VLAN_NONE) {
+                            (u16)E1000_MNG_VLAN_NONE) {
                                 e1000_vlan_rx_kill_vid(netdev,
                                                        adapter->mng_vlan_id);
                                 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
@@ -5029,10 +5029,10 @@ e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
 }
 
 static void
-e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
+e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        uint32_t vfta, index;
+        u32 vfta, index;
 
         if ((adapter->hw.mng_cookie.status &
              E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
@@ -5046,10 +5046,10 @@ e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
 }
 
 static void
-e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
+e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        uint32_t vfta, index;
+        u32 vfta, index;
 
         if (!test_bit(__E1000_DOWN, &adapter->flags))
                 e1000_irq_disable(adapter);
@@ -5078,7 +5078,7 @@ e1000_restore_vlan(struct e1000_adapter *adapter)
         e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);
 
         if (adapter->vlgrp) {
-                uint16_t vid;
+                u16 vid;
                 for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
                         if (!vlan_group_get_device(adapter->vlgrp, vid))
                                 continue;
@@ -5088,7 +5088,7 @@ e1000_restore_vlan(struct e1000_adapter *adapter)
 }
 
 int
-e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
+e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
 {
         adapter->hw.autoneg = 0;
 
@@ -5129,8 +5129,8 @@ e1000_suspend(struct pci_dev *pdev, pm_message_t state)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        uint32_t ctrl, ctrl_ext, rctl, status;
-        uint32_t wufc = adapter->wol;
+        u32 ctrl, ctrl_ext, rctl, status;
+        u32 wufc = adapter->wol;
 #ifdef CONFIG_PM
         int retval = 0;
 #endif
@@ -5227,7 +5227,7 @@ e1000_resume(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        uint32_t err;
+        u32 err;
 
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);