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, 80 insertions, 80 deletions

diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index 05e1fb3cf49f..701531e72e7b 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -36,7 +36,7 @@ extern int e1000_up(struct e1000_adapter *adapter);
 extern void e1000_down(struct e1000_adapter *adapter);
 extern void e1000_reinit_locked(struct e1000_adapter *adapter);
 extern void e1000_reset(struct e1000_adapter *adapter);
-extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
+extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx);
 extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
 extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
 extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
@@ -289,7 +289,7 @@ e1000_set_pauseparam(struct net_device *netdev,
         return retval;
 }
 
-static uint32_t
+static u32
 e1000_get_rx_csum(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
@@ -297,7 +297,7 @@ e1000_get_rx_csum(struct net_device *netdev)
 }
 
 static int
-e1000_set_rx_csum(struct net_device *netdev, uint32_t data)
+e1000_set_rx_csum(struct net_device *netdev, u32 data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         adapter->rx_csum = data;
@@ -309,14 +309,14 @@ e1000_set_rx_csum(struct net_device *netdev, uint32_t data)
         return 0;
 }
 
-static uint32_t
+static u32
 e1000_get_tx_csum(struct net_device *netdev)
 {
         return (netdev->features & NETIF_F_HW_CSUM) != 0;
 }
 
 static int
-e1000_set_tx_csum(struct net_device *netdev, uint32_t data)
+e1000_set_tx_csum(struct net_device *netdev, u32 data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
 
@@ -335,7 +335,7 @@ e1000_set_tx_csum(struct net_device *netdev, uint32_t data)
 }
 
 static int
-e1000_set_tso(struct net_device *netdev, uint32_t data)
+e1000_set_tso(struct net_device *netdev, u32 data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         if ((adapter->hw.mac_type < e1000_82544) ||
@@ -357,7 +357,7 @@ e1000_set_tso(struct net_device *netdev, uint32_t data)
         return 0;
 }
 
-static uint32_t
+static u32
 e1000_get_msglevel(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
@@ -365,7 +365,7 @@ e1000_get_msglevel(struct net_device *netdev)
 }
 
 static void
-e1000_set_msglevel(struct net_device *netdev, uint32_t data)
+e1000_set_msglevel(struct net_device *netdev, u32 data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         adapter->msg_enable = data;
@@ -375,7 +375,7 @@ static int
 e1000_get_regs_len(struct net_device *netdev)
 {
 #define E1000_REGS_LEN 32
-        return E1000_REGS_LEN * sizeof(uint32_t);
+        return E1000_REGS_LEN * sizeof(u32);
 }
 
 static void
@@ -384,10 +384,10 @@ e1000_get_regs(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t *regs_buff = p;
-        uint16_t phy_data;
+        u32 *regs_buff = p;
+        u16 phy_data;
 
-        memset(p, 0, E1000_REGS_LEN * sizeof(uint32_t));
+        memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 
         regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
 
@@ -412,44 +412,44 @@ e1000_get_regs(struct net_device *netdev,
                                     IGP01E1000_PHY_AGC_A);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[13] = (uint32_t)phy_data; /* cable length */
+                regs_buff[13] = (u32)phy_data; /* cable length */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
                                     IGP01E1000_PHY_AGC_B);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[14] = (uint32_t)phy_data; /* cable length */
+                regs_buff[14] = (u32)phy_data; /* cable length */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
                                     IGP01E1000_PHY_AGC_C);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[15] = (uint32_t)phy_data; /* cable length */
+                regs_buff[15] = (u32)phy_data; /* cable length */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
                                     IGP01E1000_PHY_AGC_D);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[16] = (uint32_t)phy_data; /* cable length */
+                regs_buff[16] = (u32)phy_data; /* cable length */
                 regs_buff[17] = 0; /* extended 10bt distance (not needed) */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[18] = (uint32_t)phy_data; /* cable polarity */
+                regs_buff[18] = (u32)phy_data; /* cable polarity */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
                                     IGP01E1000_PHY_PCS_INIT_REG);
                 e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &
                                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
-                regs_buff[19] = (uint32_t)phy_data; /* cable polarity */
+                regs_buff[19] = (u32)phy_data; /* cable polarity */
                 regs_buff[20] = 0; /* polarity correction enabled (always) */
                 regs_buff[22] = 0; /* phy receive errors (unavailable) */
                 regs_buff[23] = regs_buff[18]; /* mdix mode */
                 e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
         } else {
                 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
-                regs_buff[13] = (uint32_t)phy_data; /* cable length */
+                regs_buff[13] = (u32)phy_data; /* cable length */
                 regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
                 regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
                 regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
                 e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
-                regs_buff[17] = (uint32_t)phy_data; /* extended 10bt distance */
+                regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
                 regs_buff[18] = regs_buff[13]; /* cable polarity */
                 regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
                 regs_buff[20] = regs_buff[17]; /* polarity correction */
@@ -459,7 +459,7 @@ e1000_get_regs(struct net_device *netdev,
         }
         regs_buff[21] = adapter->phy_stats.idle_errors;  /* phy idle errors */
         e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
-        regs_buff[24] = (uint32_t)phy_data;  /* phy local receiver status */
+        regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
         regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
         if (hw->mac_type >= e1000_82540 &&
             hw->mac_type < e1000_82571 &&
@@ -477,14 +477,14 @@ e1000_get_eeprom_len(struct net_device *netdev)
 
 static int
 e1000_get_eeprom(struct net_device *netdev,
-                      struct ethtool_eeprom *eeprom, uint8_t *bytes)
+                      struct ethtool_eeprom *eeprom, u8 *bytes)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        uint16_t *eeprom_buff;
+        u16 *eeprom_buff;
         int first_word, last_word;
         int ret_val = 0;
-        uint16_t i;
+        u16 i;
 
         if (eeprom->len == 0)
                 return -EINVAL;
@@ -494,7 +494,7 @@ e1000_get_eeprom(struct net_device *netdev,
         first_word = eeprom->offset >> 1;
         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 
-        eeprom_buff = kmalloc(sizeof(uint16_t) *
+        eeprom_buff = kmalloc(sizeof(u16) *
                         (last_word - first_word + 1), GFP_KERNEL);
         if (!eeprom_buff)
                 return -ENOMEM;
@@ -514,7 +514,7 @@ e1000_get_eeprom(struct net_device *netdev,
         for (i = 0; i < last_word - first_word + 1; i++)
                 le16_to_cpus(&eeprom_buff[i]);
 
-        memcpy(bytes, (uint8_t *)eeprom_buff + (eeprom->offset & 1),
+        memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
                         eeprom->len);
         kfree(eeprom_buff);
 
@@ -523,14 +523,14 @@ e1000_get_eeprom(struct net_device *netdev,
 
 static int
 e1000_set_eeprom(struct net_device *netdev,
-                      struct ethtool_eeprom *eeprom, uint8_t *bytes)
+                      struct ethtool_eeprom *eeprom, u8 *bytes)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        uint16_t *eeprom_buff;
+        u16 *eeprom_buff;
         void *ptr;
         int max_len, first_word, last_word, ret_val = 0;
-        uint16_t i;
+        u16 i;
 
         if (eeprom->len == 0)
                 return -EOPNOTSUPP;
@@ -590,7 +590,7 @@ e1000_get_drvinfo(struct net_device *netdev,
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         char firmware_version[32];
-        uint16_t eeprom_data;
+        u16 eeprom_data;
 
         strncpy(drvinfo->driver,  e1000_driver_name, 32);
         strncpy(drvinfo->version, e1000_driver_version, 32);
@@ -674,13 +674,13 @@ e1000_set_ringparam(struct net_device *netdev,
         adapter->tx_ring = txdr;
         adapter->rx_ring = rxdr;
 
-        rxdr->count = max(ring->rx_pending,(uint32_t)E1000_MIN_RXD);
-        rxdr->count = min(rxdr->count,(uint32_t)(mac_type < e1000_82544 ?
+        rxdr->count = max(ring->rx_pending,(u32)E1000_MIN_RXD);
+        rxdr->count = min(rxdr->count,(u32)(mac_type < e1000_82544 ?
                 E1000_MAX_RXD : E1000_MAX_82544_RXD));
         rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
 
-        txdr->count = max(ring->tx_pending,(uint32_t)E1000_MIN_TXD);
-        txdr->count = min(txdr->count,(uint32_t)(mac_type < e1000_82544 ?
+        txdr->count = max(ring->tx_pending,(u32)E1000_MIN_TXD);
+        txdr->count = min(txdr->count,(u32)(mac_type < e1000_82544 ?
                 E1000_MAX_TXD : E1000_MAX_82544_TXD));
         txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
 
@@ -728,13 +728,13 @@ err_setup:
         return err;
 }
 
-static bool reg_pattern_test(struct e1000_adapter *adapter, uint64_t *data,
-                             int reg, uint32_t mask, uint32_t write)
+static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
+                             int reg, u32 mask, u32 write)
 {
-        static const uint32_t test[] =
+        static const u32 test[] =
                 {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
-        uint8_t __iomem *address = adapter->hw.hw_addr + reg;
-        uint32_t read;
+        u8 __iomem *address = adapter->hw.hw_addr + reg;
+        u32 read;
         int i;
 
         for (i = 0; i < ARRAY_SIZE(test); i++) {
@@ -751,11 +751,11 @@ static bool reg_pattern_test(struct e1000_adapter *adapter, uint64_t *data,
         return false;
 }
 
-static bool reg_set_and_check(struct e1000_adapter *adapter, uint64_t *data,
-                              int reg, uint32_t mask, uint32_t write)
+static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
+                              int reg, u32 mask, u32 write)
 {
-        uint8_t __iomem *address = adapter->hw.hw_addr + reg;
-        uint32_t read;
+        u8 __iomem *address = adapter->hw.hw_addr + reg;
+        u32 read;
 
         writel(write & mask, address);
         read = readl(address);
@@ -788,10 +788,10 @@ static bool reg_set_and_check(struct e1000_adapter *adapter, uint64_t *data,
         } while (0)
 
 static int
-e1000_reg_test(struct e1000_adapter *adapter, uint64_t *data)
+e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
 {
-        uint32_t value, before, after;
-        uint32_t i, toggle;
+        u32 value, before, after;
+        u32 i, toggle;
 
         /* The status register is Read Only, so a write should fail.
          * Some bits that get toggled are ignored.
@@ -884,11 +884,11 @@ e1000_reg_test(struct e1000_adapter *adapter, uint64_t *data)
 }
 
 static int
-e1000_eeprom_test(struct e1000_adapter *adapter, uint64_t *data)
+e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
 {
-        uint16_t temp;
-        uint16_t checksum = 0;
-        uint16_t i;
+        u16 temp;
+        u16 checksum = 0;
+        u16 i;
 
         *data = 0;
         /* Read and add up the contents of the EEPROM */
@@ -901,7 +901,7 @@ e1000_eeprom_test(struct e1000_adapter *adapter, uint64_t *data)
         }
 
         /* If Checksum is not Correct return error else test passed */
-        if ((checksum != (uint16_t) EEPROM_SUM) && !(*data))
+        if ((checksum != (u16) EEPROM_SUM) && !(*data))
                 *data = 2;
 
         return *data;
@@ -919,12 +919,12 @@ e1000_test_intr(int irq, void *data)
 }
 
 static int
-e1000_intr_test(struct e1000_adapter *adapter, uint64_t *data)
+e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 {
         struct net_device *netdev = adapter->netdev;
-        uint32_t mask, i = 0;
+        u32 mask, i = 0;
         bool shared_int = true;
-        uint32_t irq = adapter->pdev->irq;
+        u32 irq = adapter->pdev->irq;
 
         *data = 0;
 
@@ -1070,7 +1070,7 @@ e1000_setup_desc_rings(struct e1000_adapter *adapter)
         struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
         struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
         struct pci_dev *pdev = adapter->pdev;
-        uint32_t rctl;
+        u32 rctl;
         int i, ret_val;
 
         /* Setup Tx descriptor ring and Tx buffers */
@@ -1096,8 +1096,8 @@ e1000_setup_desc_rings(struct e1000_adapter *adapter)
         txdr->next_to_use = txdr->next_to_clean = 0;
 
         E1000_WRITE_REG(&adapter->hw, TDBAL,
-                        ((uint64_t) txdr->dma & 0x00000000FFFFFFFF));
-        E1000_WRITE_REG(&adapter->hw, TDBAH, ((uint64_t) txdr->dma >> 32));
+                        ((u64) txdr->dma & 0x00000000FFFFFFFF));
+        E1000_WRITE_REG(&adapter->hw, TDBAH, ((u64) txdr->dma >> 32));
         E1000_WRITE_REG(&adapter->hw, TDLEN,
                         txdr->count * sizeof(struct e1000_tx_desc));
         E1000_WRITE_REG(&adapter->hw, TDH, 0);
@@ -1153,8 +1153,8 @@ e1000_setup_desc_rings(struct e1000_adapter *adapter)
         rctl = E1000_READ_REG(&adapter->hw, RCTL);
         E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
         E1000_WRITE_REG(&adapter->hw, RDBAL,
-                        ((uint64_t) rxdr->dma & 0xFFFFFFFF));
-        E1000_WRITE_REG(&adapter->hw, RDBAH, ((uint64_t) rxdr->dma >> 32));
+                        ((u64) rxdr->dma & 0xFFFFFFFF));
+        E1000_WRITE_REG(&adapter->hw, RDBAH, ((u64) rxdr->dma >> 32));
         E1000_WRITE_REG(&adapter->hw, RDLEN, rxdr->size);
         E1000_WRITE_REG(&adapter->hw, RDH, 0);
         E1000_WRITE_REG(&adapter->hw, RDT, 0);
@@ -1202,7 +1202,7 @@ e1000_phy_disable_receiver(struct e1000_adapter *adapter)
 static void
 e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
 {
-        uint16_t phy_reg;
+        u16 phy_reg;
 
         /* Because we reset the PHY above, we need to re-force TX_CLK in the
          * Extended PHY Specific Control Register to 25MHz clock.  This
@@ -1226,8 +1226,8 @@ e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
 static int
 e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
 {
-        uint32_t ctrl_reg;
-        uint16_t phy_reg;
+        u32 ctrl_reg;
+        u16 phy_reg;
 
         /* Setup the Device Control Register for PHY loopback test. */
 
@@ -1293,8 +1293,8 @@ e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
 static int
 e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
 {
-        uint32_t ctrl_reg = 0;
-        uint32_t stat_reg = 0;
+        u32 ctrl_reg = 0;
+        u32 stat_reg = 0;
 
         adapter->hw.autoneg = false;
 
@@ -1363,8 +1363,8 @@ e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
 static int
 e1000_set_phy_loopback(struct e1000_adapter *adapter)
 {
-        uint16_t phy_reg = 0;
-        uint16_t count = 0;
+        u16 phy_reg = 0;
+        u16 count = 0;
 
         switch (adapter->hw.mac_type) {
         case e1000_82543:
@@ -1416,7 +1416,7 @@ static int
 e1000_setup_loopback_test(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t rctl;
+        u32 rctl;
 
         if (hw->media_type == e1000_media_type_fiber ||
             hw->media_type == e1000_media_type_internal_serdes) {
@@ -1451,8 +1451,8 @@ static void
 e1000_loopback_cleanup(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
-        uint32_t rctl;
-        uint16_t phy_reg;
+        u32 rctl;
+        u16 phy_reg;
 
         rctl = E1000_READ_REG(hw, RCTL);
         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
@@ -1578,7 +1578,7 @@ e1000_run_loopback_test(struct e1000_adapter *adapter)
 }
 
 static int
-e1000_loopback_test(struct e1000_adapter *adapter, uint64_t *data)
+e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
 {
         /* PHY loopback cannot be performed if SoL/IDER
          * sessions are active */
@@ -1603,7 +1603,7 @@ out:
 }
 
 static int
-e1000_link_test(struct e1000_adapter *adapter, uint64_t *data)
+e1000_link_test(struct e1000_adapter *adapter, u64 *data)
 {
         *data = 0;
         if (adapter->hw.media_type == e1000_media_type_internal_serdes) {
@@ -1647,7 +1647,7 @@ e1000_get_sset_count(struct net_device *netdev, int sset)
 
 static void
 e1000_diag_test(struct net_device *netdev,
-                   struct ethtool_test *eth_test, uint64_t *data)
+                   struct ethtool_test *eth_test, u64 *data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         bool if_running = netif_running(netdev);
@@ -1657,9 +1657,9 @@ e1000_diag_test(struct net_device *netdev,
                 /* Offline tests */
 
                 /* save speed, duplex, autoneg settings */
-                uint16_t autoneg_advertised = adapter->hw.autoneg_advertised;
-                uint8_t forced_speed_duplex = adapter->hw.forced_speed_duplex;
-                uint8_t autoneg = adapter->hw.autoneg;
+                u16 autoneg_advertised = adapter->hw.autoneg_advertised;
+                u8 forced_speed_duplex = adapter->hw.forced_speed_duplex;
+                u8 autoneg = adapter->hw.autoneg;
 
                 DPRINTK(HW, INFO, "offline testing starting\n");
 
@@ -1877,7 +1877,7 @@ e1000_led_blink_callback(unsigned long data)
 }
 
 static int
-e1000_phys_id(struct net_device *netdev, uint32_t data)
+e1000_phys_id(struct net_device *netdev, u32 data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
 
@@ -1927,7 +1927,7 @@ e1000_nway_reset(struct net_device *netdev)
 
 static void
 e1000_get_ethtool_stats(struct net_device *netdev,
-                struct ethtool_stats *stats, uint64_t *data)
+                struct ethtool_stats *stats, u64 *data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         int i;
@@ -1936,15 +1936,15 @@ e1000_get_ethtool_stats(struct net_device *netdev,
         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
                 char *p = (char *)adapter+e1000_gstrings_stats[i].stat_offset;
                 data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
-                        sizeof(uint64_t)) ? *(uint64_t *)p : *(uint32_t *)p;
+                        sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
         }
 /*      BUG_ON(i != E1000_STATS_LEN); */
 }
 
 static void
-e1000_get_strings(struct net_device *netdev, uint32_t stringset, uint8_t *data)
+e1000_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 {
-        uint8_t *p = data;
+        u8 *p = data;
         int i;
 
         switch (stringset) {