Staging: brcm80211: brcmfmac: s/uint8/u8/
authorGreg Kroah-Hartman <gregkh@suse.de>
Tue, 5 Oct 2010 17:11:12 +0000 (10:11 -0700)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 5 Oct 2010 17:11:12 +0000 (10:11 -0700)
Replace uint8 with u8, the correct kernel type to be using here.

Cc: Brett Rudley <brudley@broadcom.com>
Cc: Henry Ptasinski <henryp@broadcom.com>
Cc: Nohee Ko <noheek@broadcom.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
12 files changed:
drivers/staging/brcm80211/brcmfmac/bcmsdh.c
drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.c
drivers/staging/brcm80211/brcmfmac/bcmutils.c
drivers/staging/brcm80211/brcmfmac/dhd.h
drivers/staging/brcm80211/brcmfmac/dhd_cdc.c
drivers/staging/brcm80211/brcmfmac/dhd_common.c
drivers/staging/brcm80211/brcmfmac/dhd_linux.c
drivers/staging/brcm80211/brcmfmac/dhd_proto.h
drivers/staging/brcm80211/brcmfmac/dhd_sdio.c
drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c
drivers/staging/brcm80211/brcmfmac/wl_cfg80211.h
drivers/staging/brcm80211/brcmfmac/wl_iw.c

index 88078f72e7399b334d79643b0e3e84d89118b705..fec8890c4f99a439d36aae05f016467277d8e8a5 100644 (file)
@@ -181,14 +181,14 @@ int bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
        return BCME_UNSUPPORTED;
 }
 
-uint8 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
+u8 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
        int32 retry = 0;
 #endif
-       uint8 data = 0;
+       u8 data = 0;
 
        if (!bcmsdh)
                bcmsdh = l_bcmsdh;
@@ -202,7 +202,7 @@ uint8 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
 #endif
                status =
                    sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,
-                                  (uint8 *) &data);
+                                  (u8 *) &data);
 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
        } while (!SDIOH_API_SUCCESS(status)
                 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
@@ -210,14 +210,14 @@ uint8 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
        if (err)
                *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 
-       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n",
+       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
                     __func__, fnc_num, addr, data));
 
        return data;
 }
 
 void
-bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, uint8 data, int *err)
+bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, u8 data, int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
@@ -237,7 +237,7 @@ bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, uint8 data, int *err)
 #endif
                status =
                    sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,
-                                   (uint8 *) &data);
+                                   (u8 *) &data);
 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
        } while (!SDIOH_API_SUCCESS(status)
                 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
@@ -245,7 +245,7 @@ bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, uint8 data, int *err)
        if (err)
                *err = SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR;
 
-       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n",
+       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
                     __func__, fnc_num, addr, data));
 }
 
@@ -296,13 +296,13 @@ bcmsdh_cfg_write_word(void *sdh, uint fnc_num, uint32 addr, uint32 data,
                     __func__, fnc_num, addr, data));
 }
 
-int bcmsdh_cis_read(void *sdh, uint func, uint8 * cis, uint length)
+int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
 
-       uint8 *tmp_buf, *tmp_ptr;
-       uint8 *ptr;
+       u8 *tmp_buf, *tmp_ptr;
+       u8 *ptr;
        bool ascii = func & ~0xf;
        func &= 0x7;
 
@@ -318,7 +318,7 @@ int bcmsdh_cis_read(void *sdh, uint func, uint8 * cis, uint length)
        if (ascii) {
                /* Move binary bits to tmp and format them
                         into the provided buffer. */
-               tmp_buf = (uint8 *) MALLOC(bcmsdh->osh, length);
+               tmp_buf = (u8 *) MALLOC(bcmsdh->osh, length);
                if (tmp_buf == NULL) {
                        BCMSDH_ERROR(("%s: out of memory\n", __func__));
                        return BCME_NOMEM;
@@ -388,7 +388,7 @@ uint32 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
        /* if ok, return appropriately masked word */
        if (SDIOH_API_SUCCESS(status)) {
                switch (size) {
-               case sizeof(uint8):
+               case sizeof(u8):
                        return word & 0xff;
                case sizeof(uint16):
                        return word & 0xffff;
@@ -452,7 +452,7 @@ bool bcmsdh_regfail(void *sdh)
 
 int
 bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
-               uint8 *buf, uint nbytes, void *pkt,
+               u8 *buf, uint nbytes, void *pkt,
                bcmsdh_cmplt_fn_t complete, void *handle)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -497,7 +497,7 @@ bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
 
 int
 bcmsdh_send_buf(void *sdh, uint32 addr, uint fn, uint flags,
-               uint8 *buf, uint nbytes, void *pkt,
+               u8 *buf, uint nbytes, void *pkt,
                bcmsdh_cmplt_fn_t complete, void *handle)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -540,7 +540,7 @@ bcmsdh_send_buf(void *sdh, uint32 addr, uint fn, uint flags,
        return SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR;
 }
 
-int bcmsdh_rwdata(void *sdh, uint rw, uint32 addr, uint8 *buf, uint nbytes)
+int bcmsdh_rwdata(void *sdh, uint rw, uint32 addr, u8 *buf, uint nbytes)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
index ba990a54d9b8cf9f3a9b6392505073cc693279e0..9caf785cc468db96a2cb05abf562b541bdc30cea 100644 (file)
@@ -73,7 +73,7 @@ static int sdioh_sdmmc_card_enablefuncs(sdioh_info_t *sd)
 {
        int err_ret;
        uint32 fbraddr;
-       uint8 func;
+       u8 func;
 
        sd_trace(("%s\n", __func__));
 
@@ -204,7 +204,7 @@ extern SDIOH_API_RC sdioh_detach(osl_t *osh, sdioh_info_t *sd)
 
 extern SDIOH_API_RC sdioh_enable_func_intr(void)
 {
-       uint8 reg;
+       u8 reg;
        int err;
 
        if (gInstance->func[0]) {
@@ -238,7 +238,7 @@ extern SDIOH_API_RC sdioh_enable_func_intr(void)
 
 extern SDIOH_API_RC sdioh_disable_func_intr(void)
 {
-       uint8 reg;
+       u8 reg;
        int err;
 
        if (gInstance->func[0]) {
@@ -649,7 +649,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
        case IOV_GVAL(IOV_DEVREG):
                {
                        sdreg_t *sd_ptr = (sdreg_t *) params;
-                       uint8 data = 0;
+                       u8 data = 0;
 
                        if (sdioh_cfg_read
                            (si, sd_ptr->func, sd_ptr->offset, &data)) {
@@ -665,7 +665,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
        case IOV_SVAL(IOV_DEVREG):
                {
                        sdreg_t *sd_ptr = (sdreg_t *) params;
-                       uint8 data = (uint8) sd_ptr->value;
+                       u8 data = (u8) sd_ptr->value;
 
                        if (sdioh_cfg_write
                            (si, sd_ptr->func, sd_ptr->offset, &data)) {
@@ -689,7 +689,7 @@ exit:
 SDIOH_API_RC sdioh_enable_hw_oob_intr(sdioh_info_t *sd, bool enable)
 {
        SDIOH_API_RC status;
-       uint8 data;
+       u8 data;
 
        if (enable)
                data = 3;       /* enable hw oob interrupt */
@@ -703,7 +703,7 @@ SDIOH_API_RC sdioh_enable_hw_oob_intr(sdioh_info_t *sd, bool enable)
 #endif                         /* defined(OOB_INTR_ONLY) && defined(HW_OOB) */
 
 extern SDIOH_API_RC
-sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, uint32 addr, uint8 *data)
+sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, uint32 addr, u8 *data)
 {
        SDIOH_API_RC status;
        /* No lock needed since sdioh_request_byte does locking */
@@ -712,7 +712,7 @@ sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, uint32 addr, uint8 *data)
 }
 
 extern SDIOH_API_RC
-sdioh_cfg_write(sdioh_info_t *sd, uint fnc_num, uint32 addr, uint8 *data)
+sdioh_cfg_write(sdioh_info_t *sd, uint fnc_num, uint32 addr, u8 *data)
 {
        /* No lock needed since sdioh_request_byte does locking */
        SDIOH_API_RC status;
@@ -725,13 +725,13 @@ static int sdioh_sdmmc_get_cisaddr(sdioh_info_t *sd, uint32 regaddr)
        /* read 24 bits and return valid 17 bit addr */
        int i;
        uint32 scratch, regdata;
-       uint8 *ptr = (uint8 *)&scratch;
+       u8 *ptr = (u8 *)&scratch;
        for (i = 0; i < 3; i++) {
                if ((sdioh_sdmmc_card_regread(sd, 0, regaddr, 1, &regdata)) !=
                    SUCCESS)
                        sd_err(("%s: Can't read!\n", __func__));
 
-               *ptr++ = (uint8) regdata;
+               *ptr++ = (u8) regdata;
                regaddr++;
        }
 
@@ -742,12 +742,12 @@ static int sdioh_sdmmc_get_cisaddr(sdioh_info_t *sd, uint32 regaddr)
 }
 
 extern SDIOH_API_RC
-sdioh_cis_read(sdioh_info_t *sd, uint func, uint8 *cisd, uint32 length)
+sdioh_cis_read(sdioh_info_t *sd, uint func, u8 *cisd, uint32 length)
 {
        uint32 count;
        int offset;
        uint32 foo;
-       uint8 *cis = cisd;
+       u8 *cis = cisd;
 
        sd_trace(("%s: Func = %d\n", __func__, func));
 
@@ -768,7 +768,7 @@ sdioh_cis_read(sdioh_info_t *sd, uint func, uint8 *cisd, uint32 length)
                        return SDIOH_API_RC_FAIL;
                }
 
-               *cis = (uint8) (foo & 0xff);
+               *cis = (u8) (foo & 0xff);
                cis++;
        }
 
@@ -777,7 +777,7 @@ sdioh_cis_read(sdioh_info_t *sd, uint func, uint8 *cisd, uint32 length)
 
 extern SDIOH_API_RC
 sdioh_request_byte(sdioh_info_t *sd, uint rw, uint func, uint regaddr,
-                  uint8 *byte)
+                  u8 *byte)
 {
        int err_ret;
 
@@ -967,19 +967,19 @@ sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write, uint func,
 
                if ((write) && (!fifo)) {
                        err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
-                                                  ((uint8 *) PKTDATA(pnext)),
+                                                  ((u8 *) PKTDATA(pnext)),
                                                   pkt_len);
                } else if (write) {
                        err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
-                                                  ((uint8 *) PKTDATA(pnext)),
+                                                  ((u8 *) PKTDATA(pnext)),
                                                   pkt_len);
                } else if (fifo) {
                        err_ret = sdio_readsb(gInstance->func[func],
-                                             ((uint8 *) PKTDATA(pnext)),
+                                             ((u8 *) PKTDATA(pnext)),
                                              addr, pkt_len);
                } else {
                        err_ret = sdio_memcpy_fromio(gInstance->func[func],
-                                                    ((uint8 *) PKTDATA(pnext)),
+                                                    ((u8 *) PKTDATA(pnext)),
                                                     addr, pkt_len);
                }
 
@@ -1026,7 +1026,7 @@ sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write, uint func,
 extern SDIOH_API_RC
 sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write,
                     uint func, uint addr, uint reg_width, uint buflen_u,
-                    uint8 *buffer, void *pkt)
+                    u8 *buffer, void *pkt)
 {
        SDIOH_API_RC Status;
        void *mypkt = NULL;
@@ -1160,7 +1160,7 @@ sdioh_sdmmc_card_regread(sdioh_info_t *sd, int func, uint32 regaddr,
 {
 
        if ((func == 0) || (regsize == 1)) {
-               uint8 temp = 0;
+               u8 temp = 0;
 
                sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
                *data = temp;
@@ -1226,7 +1226,7 @@ sdioh_sdmmc_card_regwrite(sdioh_info_t *sd, int func, uint32 regaddr,
 {
 
        if ((func == 0) || (regsize == 1)) {
-               uint8 temp;
+               u8 temp;
 
                temp = data & 0xff;
                sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
index 7c06c7a8294b00e5beae147ce2053e995c648f77..0f4b3f3200a539efa96fcfb10c0241edf9c775ef 100644 (file)
@@ -158,7 +158,7 @@ void *pktq_penq(struct pktq *pq, int prec, void *p)
        pq->len++;
 
        if (pq->hi_prec < prec)
-               pq->hi_prec = (uint8) prec;
+               pq->hi_prec = (u8) prec;
 
        return p;
 }
@@ -185,7 +185,7 @@ void *pktq_penq_head(struct pktq *pq, int prec, void *p)
        pq->len++;
 
        if (pq->hi_prec < prec)
-               pq->hi_prec = (uint8) prec;
+               pq->hi_prec = (u8) prec;
 
        return p;
 }
@@ -878,11 +878,11 @@ uint pktsetprio(void *pkt, bool update_vtag)
 {
        struct ether_header *eh;
        struct ethervlan_header *evh;
-       uint8 *pktdata;
+       u8 *pktdata;
        int priority = 0;
        int rc = 0;
 
-       pktdata = (uint8 *) PKTDATA(pkt);
+       pktdata = (u8 *) PKTDATA(pkt);
        ASSERT(ISALIGNED((uintptr) pktdata, sizeof(uint16)));
 
        eh = (struct ether_header *)pktdata;
@@ -897,9 +897,9 @@ uint pktsetprio(void *pkt, bool update_vtag)
                vlan_prio = (int)(vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
 
                if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
-                       uint8 *ip_body =
+                       u8 *ip_body =
                            pktdata + sizeof(struct ethervlan_header);
-                       uint8 tos_tc = IP_TOS(ip_body);
+                       u8 tos_tc = IP_TOS(ip_body);
                        dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
                }
 
@@ -925,8 +925,8 @@ uint pktsetprio(void *pkt, bool update_vtag)
                        rc |= PKTPRIO_UPD;
                }
        } else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
-               uint8 *ip_body = pktdata + sizeof(struct ether_header);
-               uint8 tos_tc = IP_TOS(ip_body);
+               u8 *ip_body = pktdata + sizeof(struct ether_header);
+               u8 tos_tc = IP_TOS(ip_body);
                priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
                rc |= PKTPRIO_DSCP;
        }
@@ -1049,7 +1049,7 @@ int bcm_iovar_lencheck(const bcm_iovar_t *vi, void *arg, int len, bool set)
  * ****************************************************************************
  */
 
-STATIC const uint8 crc8_table[256] = {
+STATIC const u8 crc8_table[256] = {
        0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
        0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
        0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
@@ -1087,14 +1087,14 @@ STATIC const uint8 crc8_table[256] = {
 #define CRC_INNER_LOOP(n, c, x) \
        (c) = ((c) >> 8) ^ crc##n##_table[((c) ^ (x)) & 0xff]
 
-uint8 hndcrc8(uint8 *pdata,    /* pointer to array of data to process */
+u8 hndcrc8(u8 *pdata,  /* pointer to array of data to process */
              uint nbytes,      /* number of input data bytes to process */
-             uint8 crc         /* either CRC8_INIT_VALUE or previous
+             u8 crc            /* either CRC8_INIT_VALUE or previous
                                         return value */
     )
 {
        /* hard code the crc loop instead of using CRC_INNER_LOOP macro
-        * to avoid the undefined and unnecessary (uint8 >> 8) operation.
+        * to avoid the undefined and unnecessary (u8 >> 8) operation.
        */
        while (nbytes-- > 0)
                crc = crc8_table[(crc ^ *pdata++) & 0xff];
@@ -1159,7 +1159,7 @@ static const uint16 crc16_table[256] = {
        0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
 };
 
-uint16 hndcrc16(uint8 *pdata,  /* pointer to array of data to process */
+uint16 hndcrc16(u8 *pdata,     /* pointer to array of data to process */
                uint nbytes,    /* number of input data bytes to process */
                uint16 crc      /* either CRC16_INIT_VALUE or previous
                                 return value */
@@ -1237,19 +1237,19 @@ STATIC const uint32 crc32_table[256] = {
        0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
 };
 
-uint32 hndcrc32(uint8 *pdata,  /* pointer to array of data to process */
+uint32 hndcrc32(u8 *pdata,     /* pointer to array of data to process */
                uint nbytes,    /* number of input data bytes to process */
                uint32 crc      /* either CRC32_INIT_VALUE or previous
                                         return value */
 )
 {
-       uint8 *pend;
+       u8 *pend;
 #ifdef __mips__
-       uint8 tmp[4];
+       u8 tmp[4];
        ulong *tptr = (ulong *) tmp;
 
        /* in case the beginning of the buffer isn't aligned */
-       pend = (uint8 *) ((uint) (pdata + 3) & 0xfffffffc);
+       pend = (u8 *) ((uint) (pdata + 3) & 0xfffffffc);
        nbytes -= (pend - pdata);
        while (pdata < pend)
                CRC_INNER_LOOP(32, crc, *pdata++);
@@ -1286,7 +1286,7 @@ uint32 hndcrc32(uint8 *pdata,     /* pointer to array of data to process */
 void testcrc32(void)
 {
        uint j, k, l;
-       uint8 *buf;
+       u8 *buf;
        uint len[CNBUFS];
        uint32 crcr;
        uint32 crc32tv[CNBUFS] = {
@@ -1365,7 +1365,7 @@ bcm_tlv_t *bcm_parse_tlvs(void *buf, int buflen, uint key)
                if ((elt->id == key) && (totlen >= (len + 2)))
                        return elt;
 
-               elt = (bcm_tlv_t *) ((uint8 *) elt + (len + 2));
+               elt = (bcm_tlv_t *) ((u8 *) elt + (len + 2));
                totlen -= (len + 2);
        }
 
@@ -1399,7 +1399,7 @@ bcm_tlv_t *bcm_parse_ordered_tlvs(void *buf, int buflen, uint key)
                if ((id == key) && (totlen >= (len + 2)))
                        return elt;
 
-               elt = (bcm_tlv_t *) ((uint8 *) elt + (len + 2));
+               elt = (bcm_tlv_t *) ((u8 *) elt + (len + 2));
                totlen -= (len + 2);
        }
        return NULL;
@@ -1463,7 +1463,7 @@ int bcm_format_hex(char *str, const void *bytes, int len)
 {
        int i;
        char *p = str;
-       const uint8 *src = (const uint8 *)bytes;
+       const u8 *src = (const u8 *)bytes;
 
        for (i = 0; i < len; i++) {
                p += sprintf(p, "%02X", *src);
@@ -1613,7 +1613,7 @@ static const uint16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
 /* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
 };
 
-uint16 bcm_qdbm_to_mw(uint8 qdbm)
+uint16 bcm_qdbm_to_mw(u8 qdbm)
 {
        uint factor = 1;
        int idx = qdbm - QDBM_OFFSET;
@@ -1637,9 +1637,9 @@ uint16 bcm_qdbm_to_mw(uint8 qdbm)
        return (nqdBm_to_mW_map[idx] + factor / 2) / factor;
 }
 
-uint8 bcm_mw_to_qdbm(uint16 mw)
+u8 bcm_mw_to_qdbm(uint16 mw)
 {
-       uint8 qdbm;
+       u8 qdbm;
        int offset;
        uint mw_uint = mw;
        uint boundary;
@@ -1663,15 +1663,15 @@ uint8 bcm_mw_to_qdbm(uint16 mw)
                        break;
        }
 
-       qdbm += (uint8) offset;
+       qdbm += (u8) offset;
 
        return qdbm;
 }
 
-uint bcm_bitcount(uint8 *bitmap, uint length)
+uint bcm_bitcount(u8 *bitmap, uint length)
 {
        uint bitcount = 0, i;
-       uint8 tmp;
+       u8 tmp;
        for (i = 0; i < length; i++) {
                tmp = bitmap[i];
                while (tmp) {
@@ -1716,7 +1716,7 @@ int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...)
        return r;
 }
 
-void bcm_inc_bytes(uchar *num, int num_bytes, uint8 amount)
+void bcm_inc_bytes(uchar *num, int num_bytes, u8 amount)
 {
        int i;
 
@@ -1728,7 +1728,7 @@ void bcm_inc_bytes(uchar *num, int num_bytes, uint8 amount)
        }
 }
 
-int bcm_cmp_bytes(uchar *arg1, uchar *arg2, uint8 nbytes)
+int bcm_cmp_bytes(uchar *arg1, uchar *arg2, u8 nbytes)
 {
        int i;
 
index c09b4b7ceff3ff915898a5d8d2b9db7a7d111d43..81ccb8d6fe675bd94a4edea2094e191cb809d92a 100644 (file)
@@ -101,7 +101,7 @@ typedef struct dhd_pub {
        uint hdrlen;            /* Total DHD header length (proto + bus) */
        uint maxctl;            /* Max size rxctl request from proto to bus */
        uint rxsz;              /* Rx buffer size bus module should use */
-       uint8 wme_dp;           /* wme discard priority */
+       u8 wme_dp;              /* wme discard priority */
 
        /* Dongle media info */
        bool iswl;              /* Dongle-resident driver is wl */
@@ -153,7 +153,7 @@ typedef struct dhd_pub {
        char *pktfilter[100];
        int pktfilter_count;
 
-       uint8 country_code[WLC_CNTRY_BUF_SZ];
+       u8 country_code[WLC_CNTRY_BUF_SZ];
        char eventmask[WL_EVENTING_MASK_LEN];
 
 #if defined(CONFIG_HAS_WAKELOCK)
@@ -277,10 +277,10 @@ static inline void WAKE_LOCK_DESTROY(dhd_pub_t *dhdp, int index)
 }
 
 typedef struct dhd_if_event {
-       uint8 ifidx;
-       uint8 action;
-       uint8 flags;
-       uint8 bssidx;
+       u8 ifidx;
+       u8 action;
+       u8 flags;
+       u8 bssidx;
 } dhd_if_event_t;
 
 /*
@@ -348,7 +348,7 @@ extern void dhd_os_sdunlock_sndup_rxq(dhd_pub_t *pub);
 extern void dhd_os_sdlock_eventq(dhd_pub_t *pub);
 extern void dhd_os_sdunlock_eventq(dhd_pub_t *pub);
 #ifdef DHD_DEBUG
-extern int write_to_file(dhd_pub_t *dhd, uint8 *buf, int size);
+extern int write_to_file(dhd_pub_t *dhd, u8 *buf, int size);
 #endif                         /* DHD_DEBUG */
 #if defined(OOB_INTR_ONLY)
 extern int dhd_customer_oob_irq_map(unsigned long *irq_flags_ptr);
@@ -369,7 +369,7 @@ extern void dhd_timeout_start(dhd_timeout_t *tmo, uint usec);
 extern int dhd_timeout_expired(dhd_timeout_t *tmo);
 
 extern int dhd_ifname2idx(struct dhd_info *dhd, char *name);
-extern uint8 *dhd_bssidx2bssid(dhd_pub_t *dhd, int idx);
+extern u8 *dhd_bssidx2bssid(dhd_pub_t *dhd, int idx);
 extern int wl_host_event(struct dhd_info *dhd, int *idx, void *pktdata,
                         wl_event_msg_t *, void **data_ptr);
 extern void wl_event_to_host_order(wl_event_msg_t *evt);
@@ -377,7 +377,7 @@ extern void wl_event_to_host_order(wl_event_msg_t *evt);
 extern void dhd_common_init(void);
 
 extern int dhd_add_if(struct dhd_info *dhd, int ifidx, void *handle,
-                     char *name, uint8 *mac_addr, uint32 flags, uint8 bssidx);
+                     char *name, u8 *mac_addr, uint32 flags, u8 bssidx);
 extern void dhd_del_if(struct dhd_info *dhd, int ifidx);
 
 extern void dhd_vif_add(struct dhd_info *dhd, int ifidx, char *name);
@@ -393,7 +393,7 @@ extern int dhd_sendpkt(dhd_pub_t *dhdp, int ifidx, void *pkt);
 /* Send event to host */
 extern void dhd_sendup_event(dhd_pub_t *dhdp, wl_event_msg_t *event,
                             void *data);
-extern int dhd_bus_devreset(dhd_pub_t *dhdp, uint8 flag);
+extern int dhd_bus_devreset(dhd_pub_t *dhdp, u8 flag);
 extern uint dhd_bus_status(dhd_pub_t *dhdp);
 extern int dhd_bus_start(dhd_pub_t *dhdp);
 
index 46c03af1b1c62df51e62778cbc4717bfa2869e7f..93f31de60eb2473eefe77ed5bae98c078b840d69 100644 (file)
@@ -53,9 +53,9 @@ extern int dhd_preinit_ioctls(dhd_pub_t *dhd);
 
 typedef struct dhd_prot {
        uint16 reqid;
-       uint8 pending;
+       u8 pending;
        uint32 lastcmd;
-       uint8 bus_header[BUS_HEADER_LEN];
+       u8 bus_header[BUS_HEADER_LEN];
        cdc_ioctl_t msg;
        unsigned char buf[WLC_IOCTL_MAXLEN + ROUND_UP_MARGIN];
 } dhd_prot_t;
@@ -285,7 +285,7 @@ dhd_prot_ioctl(dhd_pub_t *dhd, int ifidx, wl_ioctl_t *ioc, void *buf, int len)
                slen = strlen("wme_dp") + 1;
                if (len >= (int)(slen + sizeof(int)))
                        bcopy(((char *)buf + slen), &val, sizeof(int));
-               dhd->wme_dp = (uint8) ltoh32(val);
+               dhd->wme_dp = (u8) ltoh32(val);
        }
 
        prot->pending = FALSE;
@@ -334,7 +334,7 @@ void dhd_prot_hdrpush(dhd_pub_t *dhd, int ifidx, void *pktbuf)
        BDC_SET_IF_IDX(h, ifidx);
 }
 
-bool dhd_proto_fcinfo(dhd_pub_t *dhd, void *pktbuf, uint8 * fcbits)
+bool dhd_proto_fcinfo(dhd_pub_t *dhd, void *pktbuf, u8 * fcbits)
 {
 #ifdef BDC
        struct bdc_header *h;
index 13d10891606b928acf68caf062421181e219de9d..69f997a452de99b9edf312ec581c8ca4cdde6722 100644 (file)
@@ -986,7 +986,7 @@ static int wl_pattern_atoh(char *src, char *dst)
                char num[3];
                strncpy(num, src, 2);
                num[2] = '\0';
-               dst[i] = (uint8) strtoul(num, NULL, 16);
+               dst[i] = (u8) strtoul(num, NULL, 16);
                src += 2;
        }
        return i;
index 0c165963632ff43fcc779340cea4223cd1b65a81..2d3e53e9e1007b122e7d6930ff080a77ef0a3e48 100644 (file)
@@ -212,7 +212,7 @@ typedef struct dhd_if {
        int idx;                /* iface idx in dongle */
        int state;              /* interface state */
        uint subunit;           /* subunit */
-       uint8 mac_addr[ETHER_ADDR_LEN]; /* assigned MAC address */
+       u8 mac_addr[ETHER_ADDR_LEN];    /* assigned MAC address */
        bool attached;          /* Delayed attachment when unset */
        bool txflowcontrol;     /* Per interface flow control indicator */
        char name[IFNAMSIZ + 1];        /* linux interface name */
@@ -1042,7 +1042,7 @@ int dhd_sendpkt(dhd_pub_t *dhdp, int ifidx, void *pktbuf)
 
        /* Update multicast statistic */
        if (PKTLEN(pktbuf) >= ETHER_ADDR_LEN) {
-               uint8 *pktdata = (uint8 *) PKTDATA(pktbuf);
+               u8 *pktdata = (u8 *) PKTDATA(pktbuf);
                struct ether_header *eh = (struct ether_header *)pktdata;
 
                if (ETHER_ISMULTI(eh->ether_dhost))
@@ -1849,7 +1849,7 @@ void dhd_osl_detach(osl_t *osh)
 
 int
 dhd_add_if(dhd_info_t *dhd, int ifidx, void *handle, char *name,
-          uint8 *mac_addr, uint32 flags, uint8 bssidx)
+          u8 *mac_addr, uint32 flags, u8 bssidx)
 {
        dhd_if_t *ifp;
 
@@ -2224,7 +2224,7 @@ int dhd_net_attach(dhd_pub_t *dhdp, int ifidx)
 {
        dhd_info_t *dhd = (dhd_info_t *) dhdp->info;
        struct net_device *net;
-       uint8 temp_addr[ETHER_ADDR_LEN] = {
+       u8 temp_addr[ETHER_ADDR_LEN] = {
                0x00, 0x90, 0x4c, 0x11, 0x22, 0x33};
 
        DHD_TRACE(("%s: ifidx %d\n", __func__, ifidx));
@@ -2795,7 +2795,7 @@ void dhd_wait_event_wakeup(dhd_pub_t *dhd)
        return;
 }
 
-int dhd_dev_reset(struct net_device *dev, uint8 flag)
+int dhd_dev_reset(struct net_device *dev, u8 flag)
 {
        dhd_info_t *dhd = *(dhd_info_t **)netdev_priv(dev);
 
@@ -2942,7 +2942,7 @@ int dhd_wait_pend8021x(struct net_device *dev)
 }
 
 #ifdef DHD_DEBUG
-int write_to_file(dhd_pub_t *dhd, uint8 *buf, int size)
+int write_to_file(dhd_pub_t *dhd, u8 *buf, int size)
 {
        int ret = 0;
        struct file *fp;
index f837663461c8821736e72a3b34d0f30cadf3a1f5..cc42fa4a9140a660d202d874c3d8b7525bf160b2 100644 (file)
@@ -46,7 +46,7 @@ extern int dhd_prot_init(dhd_pub_t *dhdp);
 /* Stop protocol: sync w/dongle state. */
 extern void dhd_prot_stop(dhd_pub_t *dhdp);
 
-extern bool dhd_proto_fcinfo(dhd_pub_t *dhd, void *pktbuf, uint8 *fcbits);
+extern bool dhd_proto_fcinfo(dhd_pub_t *dhd, void *pktbuf, u8 *fcbits);
 
 /* Add any protocol-specific data header.
  * Caller must reserve prot_hdrlen prepend space.
index b0ea91541be84155b3c96496d8a7fb5ad1445021..746bd081161f366cc805c5b8951c467e057f7c36 100644 (file)
@@ -154,7 +154,7 @@ typedef struct dhd_console {
        uint log_addr;          /* Log struct address (fixed) */
        hndrte_log_t log;       /* Log struct (host copy) */
        uint bufsize;           /* Size of log buffer */
-       uint8 *buf;             /* Log buffer (host copy) */
+       u8 *buf;                /* Log buffer (host copy) */
        uint last;              /* Last buffer read index */
 } dhd_console_t;
 #endif                         /* DHD_DEBUG */
@@ -191,28 +191,28 @@ typedef struct dhd_bus {
        uint roundup;           /* Max roundup limit */
 
        struct pktq txq;        /* Queue length used for flow-control */
-       uint8 flowcontrol;      /* per prio flow control bitmask */
-       uint8 tx_seq;           /* Transmit sequence number (next) */
-       uint8 tx_max;           /* Maximum transmit sequence allowed */
+       u8 flowcontrol; /* per prio flow control bitmask */
+       u8 tx_seq;              /* Transmit sequence number (next) */
+       u8 tx_max;              /* Maximum transmit sequence allowed */
 
-       uint8 hdrbuf[MAX_HDR_READ + DHD_SDALIGN];
-       uint8 *rxhdr;           /* Header of current rx frame (in hdrbuf) */
+       u8 hdrbuf[MAX_HDR_READ + DHD_SDALIGN];
+       u8 *rxhdr;              /* Header of current rx frame (in hdrbuf) */
        uint16 nextlen;         /* Next Read Len from last header */
-       uint8 rx_seq;           /* Receive sequence number (expected) */
+       u8 rx_seq;              /* Receive sequence number (expected) */
        bool rxskip;            /* Skip receive (awaiting NAK ACK) */
 
        void *glomd;            /* Packet containing glomming descriptor */
        void *glom;             /* Packet chain for glommed superframe */
        uint glomerr;           /* Glom packet read errors */
 
-       uint8 *rxbuf;           /* Buffer for receiving control packets */
+       u8 *rxbuf;              /* Buffer for receiving control packets */
        uint rxblen;            /* Allocated length of rxbuf */
-       uint8 *rxctl;           /* Aligned pointer into rxbuf */
-       uint8 *databuf;         /* Buffer for receiving big glom packet */
-       uint8 *dataptr;         /* Aligned pointer into databuf */
+       u8 *rxctl;              /* Aligned pointer into rxbuf */
+       u8 *databuf;            /* Buffer for receiving big glom packet */
+       u8 *dataptr;            /* Aligned pointer into databuf */
        uint rxlen;             /* Length of valid data in buffer */
 
-       uint8 sdpcm_ver;        /* Bus protocol reported by dongle */
+       u8 sdpcm_ver;   /* Bus protocol reported by dongle */
 
        bool intr;              /* Use interrupts */
        bool poll;              /* Use polling */
@@ -253,7 +253,7 @@ typedef struct dhd_bus {
 #ifdef SDTEST
        /* external loopback */
        bool ext_loop;
-       uint8 loopid;
+       u8 loopid;
 
        /* pktgen configuration */
        uint pktgen_freq;       /* Ticks between bursts */
@@ -294,7 +294,7 @@ typedef struct dhd_bus {
        uint f2txdata;          /* Number of f2 frame writes */
        uint f1regdata;         /* Number of f1 register accesses */
 
-       uint8 *ctrl_frame_buf;
+       u8 *ctrl_frame_buf;
        uint32 ctrl_frame_len;
        bool ctrl_frame_stat;
 } dhd_bus_t;
@@ -375,8 +375,8 @@ static bool dhd_readahead;
 
 /* To check if there's window offered */
 #define DATAOK(bus) \
-       (((uint8)(bus->tx_max - bus->tx_seq) != 0) && \
-       (((uint8)(bus->tx_max - bus->tx_seq) & 0x80) == 0))
+       (((u8)(bus->tx_max - bus->tx_seq) != 0) && \
+       (((u8)(bus->tx_max - bus->tx_seq) & 0x80) == 0))
 
 /* Macros to get register read/write status */
 /* NOTE: these assume a local dhdsdio_bus_t *bus! */
@@ -424,7 +424,7 @@ static void dhdsdio_sdtest_set(dhd_bus_t *bus, bool start);
 #endif
 
 #ifdef DHD_DEBUG
-static int dhdsdio_checkdied(dhd_bus_t *bus, uint8 *data, uint size);
+static int dhdsdio_checkdied(dhd_bus_t *bus, u8 *data, uint size);
 static int dhdsdio_mem_dump(dhd_bus_t *bus);
 #endif                         /* DHD_DEBUG  */
 static int dhdsdio_download_state(dhd_bus_t *bus, bool enter);
@@ -443,10 +443,10 @@ static uint process_nvram_vars(char *varbuf, uint len);
 
 static void dhd_dongle_setmemsize(struct dhd_bus *bus, int mem_size);
 static int dhd_bcmsdh_recv_buf(dhd_bus_t *bus, uint32 addr, uint fn,
-                              uint flags, uint8 *buf, uint nbytes, void *pkt,
+                              uint flags, u8 *buf, uint nbytes, void *pkt,
                               bcmsdh_cmplt_fn_t complete, void *handle);
 static int dhd_bcmsdh_send_buf(dhd_bus_t *bus, uint32 addr, uint fn,
-                              uint flags, uint8 *buf, uint nbytes, void *pkt,
+                              uint flags, u8 *buf, uint nbytes, void *pkt,
                               bcmsdh_cmplt_fn_t complete, void *handle);
 
 static bool dhdsdio_download_firmware(struct dhd_bus *bus, osl_t *osh,
@@ -489,7 +489,7 @@ static int dhdsdio_set_siaddr_window(dhd_bus_t *bus, uint32 address)
 static int dhdsdio_htclk(dhd_bus_t *bus, bool on, bool pendok)
 {
        int err;
-       uint8 clkctl, clkreq, devctl;
+       u8 clkctl, clkreq, devctl;
        bcmsdh_info_t *sdh;
 
        DHD_TRACE(("%s: Enter\n", __func__));
@@ -903,7 +903,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, void *pkt, uint chan, bool free_pkt)
 {
        int ret;
        osl_t *osh;
-       uint8 *frame;
+       u8 *frame;
        uint16 len, pad = 0;
        uint32 swheader;
        uint retries = 0;
@@ -921,7 +921,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, void *pkt, uint chan, bool free_pkt)
                goto done;
        }
 
-       frame = (uint8 *) PKTDATA(pkt);
+       frame = (u8 *) PKTDATA(pkt);
 
        /* Add alignment padding, allocate new packet if needed */
        pad = ((uintptr) frame % DHD_SDALIGN);
@@ -946,12 +946,12 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, void *pkt, uint chan, bool free_pkt)
                        /* free the pkt if canned one is not used */
                        free_pkt = TRUE;
                        pkt = new;
-                       frame = (uint8 *) PKTDATA(pkt);
+                       frame = (u8 *) PKTDATA(pkt);
                        ASSERT(((uintptr) frame % DHD_SDALIGN) == 0);
                        pad = 0;
                } else {
                        PKTPUSH(pkt, pad);
-                       frame = (uint8 *) PKTDATA(pkt);
+                       frame = (u8 *) PKTDATA(pkt);
 
                        ASSERT((pad + SDPCM_HDRLEN) <= (int)PKTLEN(pkt));
                        bzero(frame, pad + SDPCM_HDRLEN);
@@ -1029,7 +1029,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, void *pkt, uint chan, bool free_pkt)
                        bus->f1regdata++;
 
                        for (i = 0; i < 3; i++) {
-                               uint8 hi, lo;
+                               u8 hi, lo;
                                hi = bcmsdh_cfg_read(sdh, SDIO_FUNC_1,
                                                     SBSDIO_FUNC1_WFRAMEBCHI,
                                                     NULL);
@@ -1074,11 +1074,11 @@ int dhd_bus_txdata(struct dhd_bus *bus, void *pkt)
 #ifdef SDTEST
        /* Push the test header if doing loopback */
        if (bus->ext_loop) {
-               uint8 *data;
+               u8 *data;
                PKTPUSH(pkt, SDPCM_TEST_HDRLEN);
                data = PKTDATA(pkt);
                *data++ = SDPCM_TEST_ECHOREQ;
-               *data++ = (uint8) bus->loopid++;
+               *data++ = (u8) bus->loopid++;
                *data++ = (datalen >> 0);
                *data++ = (datalen >> 8);
                datalen += SDPCM_TEST_HDRLEN;
@@ -1167,7 +1167,7 @@ static uint dhdsdio_sendfromq(dhd_bus_t *bus, uint maxframes)
        int ret = 0, prec_out;
        uint cnt = 0;
        uint datalen;
-       uint8 tx_prec_map;
+       u8 tx_prec_map;
 
        dhd_pub_t *dhd = bus->dhd;
        sdpcmd_regs_t *regs = bus->regs;
@@ -1221,12 +1221,12 @@ static uint dhdsdio_sendfromq(dhd_bus_t *bus, uint maxframes)
 
 int dhd_bus_txctl(struct dhd_bus *bus, uchar *msg, uint msglen)
 {
-       uint8 *frame;
+       u8 *frame;
        uint16 len;
        uint32 swheader;
        uint retries = 0;
        bcmsdh_info_t *sdh = bus->sdh;
-       uint8 doff = 0;
+       u8 doff = 0;
        int ret = -1;
        int i;
 
@@ -1339,7 +1339,7 @@ int dhd_bus_txctl(struct dhd_bus *bus, uchar *msg, uint msglen)
                                bus->f1regdata++;
 
                                for (i = 0; i < 3; i++) {
-                                       uint8 hi, lo;
+                                       u8 hi, lo;
                                        hi = bcmsdh_cfg_read(sdh, SDIO_FUNC_1,
                                             SBSDIO_FUNC1_WFRAMEBCHI,
                                             NULL);
@@ -1636,7 +1636,7 @@ void dhd_bus_clearcounts(dhd_pub_t *dhdp)
 }
 
 #ifdef SDTEST
-static int dhdsdio_pktgen_get(dhd_bus_t *bus, uint8 *arg)
+static int dhdsdio_pktgen_get(dhd_bus_t *bus, u8 *arg)
 {
        dhd_pktgen_t pktgen;
 
@@ -1658,7 +1658,7 @@ static int dhdsdio_pktgen_get(dhd_bus_t *bus, uint8 *arg)
        return 0;
 }
 
-static int dhdsdio_pktgen_set(dhd_bus_t *bus, uint8 *arg)
+static int dhdsdio_pktgen_set(dhd_bus_t *bus, u8 *arg)
 {
        dhd_pktgen_t pktgen;
        uint oldcnt, oldmode;
@@ -1692,7 +1692,7 @@ static int dhdsdio_pktgen_set(dhd_bus_t *bus, uint8 *arg)
 #endif                         /* SDTEST */
 
 static int
-dhdsdio_membytes(dhd_bus_t *bus, bool write, uint32 address, uint8 *data,
+dhdsdio_membytes(dhd_bus_t *bus, bool write, uint32 address, u8 *data,
                 uint size)
 {
        int bcmerror = 0;
@@ -1759,7 +1759,7 @@ static int dhdsdio_readshared(dhd_bus_t *bus, sdpcm_shared_t *sh)
 
        /* Read last word in memory to determine address of
                         sdpcm_shared structure */
-       rv = dhdsdio_membytes(bus, FALSE, bus->ramsize - 4, (uint8 *)&addr, 4);
+       rv = dhdsdio_membytes(bus, FALSE, bus->ramsize - 4, (u8 *)&addr, 4);
        if (rv < 0)
                return rv;
 
@@ -1778,7 +1778,7 @@ static int dhdsdio_readshared(dhd_bus_t *bus, sdpcm_shared_t *sh)
        }
 
        /* Read hndrte_shared structure */
-       rv = dhdsdio_membytes(bus, FALSE, addr, (uint8 *) sh,
+       rv = dhdsdio_membytes(bus, FALSE, addr, (u8 *) sh,
                              sizeof(sdpcm_shared_t));
        if (rv < 0)
                return rv;
@@ -1803,7 +1803,7 @@ static int dhdsdio_readshared(dhd_bus_t *bus, sdpcm_shared_t *sh)
        return BCME_OK;
 }
 
-static int dhdsdio_checkdied(dhd_bus_t *bus, uint8 *data, uint size)
+static int dhdsdio_checkdied(dhd_bus_t *bus, u8 *data, uint size)
 {
        int bcmerror = 0;
        uint msize = 512;
@@ -1873,7 +1873,7 @@ static int dhdsdio_checkdied(dhd_bus_t *bus, uint8 *data, uint size)
                                str[0] = '\0';
                                bcmerror = dhdsdio_membytes(bus, FALSE,
                                                sdpcm_shared.assert_exp_addr,
-                                               (uint8 *) str, maxstrlen);
+                                               (u8 *) str, maxstrlen);
                                if (bcmerror < 0)
                                        goto done;
 
@@ -1885,7 +1885,7 @@ static int dhdsdio_checkdied(dhd_bus_t *bus, uint8 *data, uint size)
                                str[0] = '\0';
                                bcmerror = dhdsdio_membytes(bus, FALSE,
                                                sdpcm_shared.assert_file_addr,
-                                               (uint8 *) str, maxstrlen);
+                                               (u8 *) str, maxstrlen);
                                if (bcmerror < 0)
                                        goto done;
 
@@ -1899,7 +1899,7 @@ static int dhdsdio_checkdied(dhd_bus_t *bus, uint8 *data, uint size)
 
                if (sdpcm_shared.flags & SDPCM_SHARED_TRAP) {
                        bcmerror = dhdsdio_membytes(bus, FALSE,
-                                       sdpcm_shared.trap_addr, (uint8 *)&tr,
+                                       sdpcm_shared.trap_addr, (u8 *)&tr,
                                        sizeof(trap_t));
                        if (bcmerror < 0)
                                goto done;
@@ -1940,7 +1940,7 @@ static int dhdsdio_mem_dump(dhd_bus_t *bus)
        int size;               /* Full mem size */
        int start = 0;          /* Start address */
        int read_size = 0;      /* Read size of each iteration */
-       uint8 *buf = NULL, *databuf = NULL;
+       u8 *buf = NULL, *databuf = NULL;
 
        /* Get full mem size */
        size = bus->ramsize;
@@ -1986,7 +1986,7 @@ static int dhdsdio_mem_dump(dhd_bus_t *bus)
 static int dhdsdio_readconsole(dhd_bus_t *bus)
 {
        dhd_console_t *c = &bus->console;
-       uint8 line[CONSOLE_LINE_MAX], ch;
+       u8 line[CONSOLE_LINE_MAX], ch;
        uint32 n, idx, addr;
        int rv;
 
@@ -1996,7 +1996,7 @@ static int dhdsdio_readconsole(dhd_bus_t *bus)
 
        /* Read console log struct */
        addr = bus->console_addr + OFFSETOF(hndrte_cons_t, log);
-       rv = dhdsdio_membytes(bus, FALSE, addr, (uint8 *)&c->log,
+       rv = dhdsdio_membytes(bus, FALSE, addr, (u8 *)&c->log,
                                sizeof(c->log));
        if (rv < 0)
                return rv;
@@ -2210,7 +2210,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, uint32 actionid,
                {
                        uint32 address;
                        uint size, dsize;
-                       uint8 *data;
+                       u8 *data;
 
                        bool set = (actionid == IOV_SVAL(IOV_MEMBYTES));
 
@@ -2249,8 +2249,8 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, uint32 actionid,
 
                        /* Generate the actual data pointer */
                        data =
-                           set ? (uint8 *) params +
-                           2 * sizeof(int) : (uint8 *) arg;
+                           set ? (u8 *) params +
+                           2 * sizeof(int) : (u8 *) arg;
 
                        /* Call to do the transfer */
                        bcmerror =
@@ -2399,15 +2399,15 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, uint32 actionid,
 
                        bcmstrcat(arg, "\nFunc 0\n");
                        bcmsdh_cis_read(bus->sdh, 0x10,
-                                       (uint8 *) arg + strlen(arg),
+                                       (u8 *) arg + strlen(arg),
                                        SBSDIO_CIS_SIZE_LIMIT);
                        bcmstrcat(arg, "\nFunc 1\n");
                        bcmsdh_cis_read(bus->sdh, 0x11,
-                                       (uint8 *) arg + strlen(arg),
+                                       (u8 *) arg + strlen(arg),
                                        SBSDIO_CIS_SIZE_LIMIT);
                        bcmstrcat(arg, "\nFunc 2\n");
                        bcmsdh_cis_read(bus->sdh, 0x12,
-                                       (uint8 *) arg + strlen(arg),
+                                       (u8 *) arg + strlen(arg),
                                        SBSDIO_CIS_SIZE_LIMIT);
                        break;
                }
@@ -2477,7 +2477,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, uint32 actionid,
                ASSERT(bus->dhd->osh);
                /* ASSERT(bus->cl_devid); */
 
-               dhd_bus_devreset(bus->dhd, (uint8) bool_val);
+               dhd_bus_devreset(bus->dhd, (u8) bool_val);
 
                break;
 
@@ -2514,7 +2514,7 @@ static int dhdsdio_write_vars(dhd_bus_t *bus)
        int bcmerror = 0;
        uint32 varsize;
        uint32 varaddr;
-       uint8 *vbuffer;
+       u8 *vbuffer;
        uint32 varsizew;
 #ifdef DHD_DEBUG
        char *nvram_ularray;
@@ -2526,7 +2526,7 @@ static int dhdsdio_write_vars(dhd_bus_t *bus)
        varaddr = (bus->ramsize - 4) - varsize;
 
        if (bus->vars) {
-               vbuffer = (uint8 *) MALLOC(bus->dhd->osh, varsize);
+               vbuffer = (u8 *) MALLOC(bus->dhd->osh, varsize);
                if (!vbuffer)
                        return BCME_NOMEM;
 
@@ -2592,7 +2592,7 @@ static int dhdsdio_write_vars(dhd_bus_t *bus)
 
        /* Write the length token to the last word */
        bcmerror = dhdsdio_membytes(bus, TRUE, (bus->orig_ramsize - 4),
-                                   (uint8 *)&varsizew, 4);
+                                   (u8 *)&varsizew, 4);
 
        return bcmerror;
 }
@@ -2641,7 +2641,7 @@ static int dhdsdio_download_state(dhd_bus_t *bus, bool enter)
                if (bus->ramsize) {
                        uint32 zeros = 0;
                        dhdsdio_membytes(bus, TRUE, bus->ramsize - 4,
-                                        (uint8 *)&zeros, 4);
+                                        (u8 *)&zeros, 4);
                }
        } else {
                if (!(si_setcore(bus->sih, SOCRAM_CORE_ID, 0))) {
@@ -2824,7 +2824,7 @@ void dhd_bus_stop(struct dhd_bus *bus, bool enforce_mutex)
 {
        osl_t *osh = bus->dhd->osh;
        uint32 local_hostintmask;
-       uint8 saveclk;
+       u8 saveclk;
        uint retries;
        int err;
 
@@ -2900,9 +2900,9 @@ int dhd_bus_init(dhd_pub_t *dhdp, bool enforce_mutex)
        dhd_bus_t *bus = dhdp->bus;
        dhd_timeout_t tmo;
        uint retries = 0;
-       uint8 ready, enable;
+       u8 ready, enable;
        int err, ret = 0;
-       uint8 saveclk;
+       u8 saveclk;
 
        DHD_TRACE(("%s: Enter\n", __func__));
 
@@ -2963,7 +2963,7 @@ int dhd_bus_init(dhd_pub_t *dhdp, bool enforce_mutex)
                W_SDREG(bus->hostintmask, &bus->regs->hostintmask, retries);
 
                bcmsdh_cfg_write(bus->sdh, SDIO_FUNC_1, SBSDIO_WATERMARK,
-                                (uint8) watermark, &err);
+                                (u8) watermark, &err);
 
                /* Set bus state according to enable result */
                dhdp->busstate = DHD_BUS_DATA;
@@ -3010,7 +3010,7 @@ static void dhdsdio_rxfail(dhd_bus_t *bus, bool abort, bool rtx)
        sdpcmd_regs_t *regs = bus->regs;
        uint retries = 0;
        uint16 lastrbc;
-       uint8 hi, lo;
+       u8 hi, lo;
        int err;
 
        DHD_ERROR(("%s: %sterminate frame%s\n", __func__,
@@ -3068,7 +3068,7 @@ static void dhdsdio_rxfail(dhd_bus_t *bus, bool abort, bool rtx)
 }
 
 static void
-dhdsdio_read_control(dhd_bus_t *bus, uint8 *hdr, uint len, uint doff)
+dhdsdio_read_control(dhd_bus_t *bus, u8 *hdr, uint len, uint doff)
 {
        bcmsdh_info_t *sdh = bus->sdh;
        uint rdlen, pad;
@@ -3171,18 +3171,18 @@ done:
        dhd_os_ioctl_resp_wake(bus->dhd);
 }
 
-static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
+static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
 {
        uint16 dlen, totlen;
-       uint8 *dptr, num = 0;
+       u8 *dptr, num = 0;
 
        uint16 sublen, check;
        void *pfirst, *plast, *pnext, *save_pfirst;
        osl_t *osh = bus->dhd->osh;
 
        int errcode;
-       uint8 chan, seq, doff, sfdoff;
-       uint8 txmax;
+       u8 chan, seq, doff, sfdoff;
+       u8 txmax;
 
        int ifidx = 0;
        bool usechain = bus->use_rxchain;
@@ -3291,7 +3291,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                                __func__));
                        for (pnext = bus->glom; pnext; pnext = PKTNEXT(pnext)) {
                                DHD_GLOM(("    %p: %p len 0x%04x (%d)\n",
-                                         pnext, (uint8 *) PKTDATA(pnext),
+                                         pnext, (u8 *) PKTDATA(pnext),
                                          PKTLEN(pnext), PKTLEN(pnext)));
                        }
                }
@@ -3308,7 +3308,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                                                      bcmsdh_cur_sbwad
                                                      (bus->sdh), SDIO_FUNC_2,
                                                      F2SYNC,
-                                                     (uint8 *) PKTDATA(pfirst),
+                                                     (u8 *) PKTDATA(pfirst),
                                                      dlen, pfirst, NULL, NULL);
                } else if (bus->dataptr) {
                        errcode = dhd_bcmsdh_recv_buf(bus,
@@ -3360,7 +3360,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
 #endif
 
                /* Validate the superframe header */
-               dptr = (uint8 *) PKTDATA(pfirst);
+               dptr = (u8 *) PKTDATA(pfirst);
                sublen = ltoh16_ua(dptr);
                check = ltoh16_ua(dptr + sizeof(uint16));
 
@@ -3415,7 +3415,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                }
 
                /* Check window for sanity */
-               if ((uint8) (txmax - bus->tx_seq) > 0x40) {
+               if ((u8) (txmax - bus->tx_seq) > 0x40) {
                        DHD_ERROR(("%s: unlikely tx max %d with tx_seq %d\n",
                                __func__, txmax, bus->tx_seq));
                        txmax = bus->tx_seq + 2;
@@ -3429,7 +3429,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                /* Validate all the subframe headers */
                for (num = 0, pnext = pfirst; pnext && !errcode;
                     num++, pnext = PKTNEXT(pnext)) {
-                       dptr = (uint8 *) PKTDATA(pnext);
+                       dptr = (u8 *) PKTDATA(pnext);
                        dlen = (uint16) PKTLEN(pnext);
                        sublen = ltoh16_ua(dptr);
                        check = ltoh16_ua(dptr + sizeof(uint16));
@@ -3493,7 +3493,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                        pnext = PKTNEXT(pfirst);
                        PKTSETNEXT(pfirst, NULL);
 
-                       dptr = (uint8 *) PKTDATA(pfirst);
+                       dptr = (u8 *) PKTDATA(pfirst);
                        sublen = ltoh16_ua(dptr);
                        chan = SDPCM_PACKET_CHANNEL(&dptr[SDPCM_FRAMETAG_LEN]);
                        seq = SDPCM_PACKET_SEQUENCE(&dptr[SDPCM_FRAMETAG_LEN]);
@@ -3558,7 +3558,7 @@ static uint8 dhdsdio_rxglom(dhd_bus_t *bus, uint8 rxseq)
                                __func__, num, pfirst, PKTDATA(pfirst),
                                PKTLEN(pfirst), PKTNEXT(pfirst),
                                PKTLINK(pfirst)));
-                               prhex("", (uint8 *) PKTDATA(pfirst),
+                               prhex("", (u8 *) PKTDATA(pfirst),
                                      MIN(PKTLEN(pfirst), 32));
                        }
 #endif                         /* DHD_DEBUG */
@@ -3583,20 +3583,20 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
        bcmsdh_info_t *sdh = bus->sdh;
 
        uint16 len, check;      /* Extracted hardware header fields */
-       uint8 chan, seq, doff;  /* Extracted software header fields */
-       uint8 fcbits;           /* Extracted fcbits from software header */
-       uint8 delta;
+       u8 chan, seq, doff;     /* Extracted software header fields */
+       u8 fcbits;              /* Extracted fcbits from software header */
+       u8 delta;
 
        void *pkt;              /* Packet for event or data frames */
        uint16 pad;             /* Number of pad bytes to read */
        uint16 rdlen;           /* Total number of bytes to read */
-       uint8 rxseq;            /* Next sequence number to expect */
+       u8 rxseq;               /* Next sequence number to expect */
        uint rxleft = 0;        /* Remaining number of frames allowed */
        int sdret;              /* Return code from bcmsdh calls */
-       uint8 txmax;            /* Maximum tx sequence offered */
+       u8 txmax;               /* Maximum tx sequence offered */
        bool len_consistent;    /* Result of comparing readahead len and
                                         len from hw-hdr */
-       uint8 *rxbuf;
+       u8 *rxbuf;
        int ifidx = 0;
        uint rxcount = 0;       /* Total frames read */
 
@@ -3625,7 +3625,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
 
                /* Handle glomming separately */
                if (bus->glom || bus->glomd) {
-                       uint8 cnt;
+                       u8 cnt;
                        DHD_GLOM(("%s: calling rxglom: glomd %p, glom %p\n",
                                  __func__, bus->glomd, bus->glom));
                        cnt = dhdsdio_rxglom(bus, rxseq);
@@ -3733,7 +3733,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
 
                                ASSERT(!PKTLINK(pkt));
                                PKTALIGN(osh, pkt, rdlen, DHD_SDALIGN);
-                               rxbuf = (uint8 *) PKTDATA(pkt);
+                               rxbuf = (u8 *) PKTDATA(pkt);
                                /* Read the entire frame */
                                sdret =
                                    dhd_bcmsdh_recv_buf(bus,
@@ -3874,7 +3874,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                        }
 
                        /* Check window for sanity */
-                       if ((uint8) (txmax - bus->tx_seq) > 0x40) {
+                       if ((u8) (txmax - bus->tx_seq) > 0x40) {
                                DHD_ERROR(("%s: got unlikely tx max %d with "
                                        "tx_seq %d\n",
                                        __func__, txmax, bus->tx_seq));
@@ -4038,7 +4038,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                }
 
                /* Check window for sanity */
-               if ((uint8) (txmax - bus->tx_seq) > 0x40) {
+               if ((u8) (txmax - bus->tx_seq) > 0x40) {
                        DHD_ERROR(("%s: unlikely tx max %d with tx_seq %d\n",
                                __func__, txmax, bus->tx_seq));
                        txmax = bus->tx_seq + 2;
@@ -4107,7 +4107,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                /* Read the remaining frame data */
                sdret =
                    dhd_bcmsdh_recv_buf(bus, bcmsdh_cur_sbwad(sdh), SDIO_FUNC_2,
-                                       F2SYNC, ((uint8 *) PKTDATA(pkt)), rdlen,
+                                       F2SYNC, ((u8 *) PKTDATA(pkt)), rdlen,
                                        pkt, NULL, NULL);
                bus->f2rxdata++;
                ASSERT(sdret != BCME_PENDING);
@@ -4213,7 +4213,7 @@ static uint32 dhdsdio_hostmail(dhd_bus_t *bus)
        sdpcmd_regs_t *regs = bus->regs;
        uint32 intstatus = 0;
        uint32 hmb_data;
-       uint8 fcbits;
+       u8 fcbits;
        uint retries = 0;
 
        DHD_TRACE(("%s: Enter\n", __func__));
@@ -4304,7 +4304,7 @@ bool dhdsdio_dpc(dhd_bus_t *bus)
        /* If waiting for HTAVAIL, check status */
        if (bus->clkstate == CLK_PENDING) {
                int err;
-               uint8 clkctl, devctl = 0;
+               u8 clkctl, devctl = 0;
 
 #ifdef DHD_DEBUG
                /* Check for inconsistent device control */
@@ -4459,7 +4459,7 @@ clkwait:
 
                ret =
                    dhd_bcmsdh_send_buf(bus, bcmsdh_cur_sbwad(sdh), SDIO_FUNC_2,
-                                       F2SYNC, (uint8 *) bus->ctrl_frame_buf,
+                                       F2SYNC, (u8 *) bus->ctrl_frame_buf,
                                        (uint32) bus->ctrl_frame_len, NULL,
                                        NULL, NULL);
                ASSERT(ret != BCME_PENDING);
@@ -4479,7 +4479,7 @@ clkwait:
                        bus->f1regdata++;
 
                        for (i = 0; i < 3; i++) {
-                               uint8 hi, lo;
+                               u8 hi, lo;
                                hi = bcmsdh_cfg_read(sdh, SDIO_FUNC_1,
                                                     SBSDIO_FUNC1_WFRAMEBCHI,
                                                     NULL);
@@ -4626,7 +4626,7 @@ static void dhdsdio_pktgen_init(dhd_bus_t *bus)
 static void dhdsdio_pktgen(dhd_bus_t *bus)
 {
        void *pkt;
-       uint8 *data;
+       u8 *data;
        uint pktcount;
        uint fillbyte;
        osl_t *osh = bus->dhd->osh;
@@ -4666,23 +4666,23 @@ static void dhdsdio_pktgen(dhd_bus_t *bus)
                }
                PKTALIGN(osh, pkt, (len + SDPCM_HDRLEN + SDPCM_TEST_HDRLEN),
                         DHD_SDALIGN);
-               data = (uint8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+               data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
 
                /* Write test header cmd and extra based on mode */
                switch (bus->pktgen_mode) {
                case DHD_PKTGEN_ECHO:
                        *data++ = SDPCM_TEST_ECHOREQ;
-                       *data++ = (uint8) bus->pktgen_sent;
+                       *data++ = (u8) bus->pktgen_sent;
                        break;
 
                case DHD_PKTGEN_SEND:
                        *data++ = SDPCM_TEST_DISCARD;
-                       *data++ = (uint8) bus->pktgen_sent;
+                       *data++ = (u8) bus->pktgen_sent;
                        break;
 
                case DHD_PKTGEN_RXBURST:
                        *data++ = SDPCM_TEST_BURST;
-                       *data++ = (uint8) bus->pktgen_count;
+                       *data++ = (u8) bus->pktgen_count;
                        break;
 
                default:
@@ -4701,11 +4701,11 @@ static void dhdsdio_pktgen(dhd_bus_t *bus)
                         but who cares... */
                for (fillbyte = 0; fillbyte < len; fillbyte++)
                        *data++ =
-                           SDPCM_TEST_FILL(fillbyte, (uint8) bus->pktgen_sent);
+                           SDPCM_TEST_FILL(fillbyte, (u8) bus->pktgen_sent);
 
 #ifdef DHD_DEBUG
                if (DHD_BYTES_ON() && DHD_DATA_ON()) {
-                       data = (uint8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+                       data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
                        prhex("dhdsdio_pktgen: Tx Data", data,
                              PKTLEN(pkt) - SDPCM_HDRLEN);
                }
@@ -4733,7 +4733,7 @@ static void dhdsdio_pktgen(dhd_bus_t *bus)
 static void dhdsdio_sdtest_set(dhd_bus_t *bus, bool start)
 {
        void *pkt;
-       uint8 *data;
+       u8 *data;
        osl_t *osh = bus->dhd->osh;
 
        /* Allocate the packet */
@@ -4744,7 +4744,7 @@ static void dhdsdio_sdtest_set(dhd_bus_t *bus, bool start)
                return;
        }
        PKTALIGN(osh, pkt, (SDPCM_HDRLEN + SDPCM_TEST_HDRLEN), DHD_SDALIGN);
-       data = (uint8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+       data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
 
        /* Fill in the test header */
        *data++ = SDPCM_TEST_SEND;
@@ -4760,11 +4760,11 @@ static void dhdsdio_sdtest_set(dhd_bus_t *bus, bool start)
 static void dhdsdio_testrcv(dhd_bus_t *bus, void *pkt, uint seq)
 {
        osl_t *osh = bus->dhd->osh;
-       uint8 *data;
+       u8 *data;
        uint pktlen;
 
-       uint8 cmd;
-       uint8 extra;
+       u8 cmd;
+       u8 extra;
        uint16 len;
        uint16 offset;
 
@@ -4801,7 +4801,7 @@ static void dhdsdio_testrcv(dhd_bus_t *bus, void *pkt, uint seq)
        case SDPCM_TEST_ECHOREQ:
                /* Rx->Tx turnaround ok (even on NDIS w/current
                         implementation) */
-               *(uint8 *) (PKTDATA(pkt)) = SDPCM_TEST_ECHORSP;
+               *(u8 *) (PKTDATA(pkt)) = SDPCM_TEST_ECHORSP;
                if (dhdsdio_txpkt(bus, pkt, SDPCM_TEST_CHANNEL, TRUE) == 0) {
                        bus->pktgen_sent++;
                } else {
@@ -4884,7 +4884,7 @@ extern bool dhd_bus_watchdog(dhd_pub_t *dhdp)
                if (!bus->intr || (bus->intrcount == bus->lastintrs)) {
 
                        if (!bus->dpc_sched) {
-                               uint8 devpend;
+                               u8 devpend;
                                devpend = bcmsdh_cfg_read(bus->sdh, SDIO_FUNC_0,
                                                          SDIOD_CCCR_INTPEND,
                                                          NULL);
@@ -4982,20 +4982,20 @@ extern int dhd_bus_console_in(dhd_pub_t *dhdp, uchar *msg, uint msglen)
        /* Zero cbuf_index */
        addr = bus->console_addr + OFFSETOF(hndrte_cons_t, cbuf_idx);
        val = htol32(0);
-       rv = dhdsdio_membytes(bus, TRUE, addr, (uint8 *)&val, sizeof(val));
+       rv = dhdsdio_membytes(bus, TRUE, addr, (u8 *)&val, sizeof(val));
        if (rv < 0)
                goto done;
 
        /* Write message into cbuf */
        addr = bus->console_addr + OFFSETOF(hndrte_cons_t, cbuf);
-       rv = dhdsdio_membytes(bus, TRUE, addr, (uint8 *)msg, msglen);
+       rv = dhdsdio_membytes(bus, TRUE, addr, (u8 *)msg, msglen);
        if (rv < 0)
                goto done;
 
        /* Write length into vcons_in */
        addr = bus->console_addr + OFFSETOF(hndrte_cons_t, vcons_in);
        val = htol32(msglen);
-       rv = dhdsdio_membytes(bus, TRUE, addr, (uint8 *)&val, sizeof(val));
+       rv = dhdsdio_membytes(bus, TRUE, addr, (u8 *)&val, sizeof(val));
        if (rv < 0)
                goto done;
 
@@ -5019,7 +5019,7 @@ done:
 #endif                         /* DHD_DEBUG */
 
 #ifdef DHD_DEBUG
-static void dhd_dump_cis(uint fn, uint8 *cis)
+static void dhd_dump_cis(uint fn, u8 *cis)
 {
        uint byte, tag, tdata;
        DHD_INFO(("Function %d CIS:\n", fn));
@@ -5223,7 +5223,7 @@ static bool
 dhdsdio_probe_attach(struct dhd_bus *bus, osl_t *osh, void *sdh, void *regsva,
                     uint16 devid)
 {
-       uint8 clkctl = 0;
+       u8 clkctl = 0;
        int err = 0;
 
        bus->alp_only = TRUE;
@@ -5256,7 +5256,7 @@ dhdsdio_probe_attach(struct dhd_bus *bus, osl_t *osh, void *sdh, void *regsva,
 #ifdef DHD_DEBUG
        if (DHD_INFO_ON()) {
                uint fn, numfn;
-               uint8 *cis[SDIOD_MAX_IOFUNCS];
+               u8 *cis[SDIOD_MAX_IOFUNCS];
                int err = 0;
 
                numfn = bcmsdh_query_iofnum(sdh);
@@ -5364,7 +5364,7 @@ dhdsdio_probe_attach(struct dhd_bus *bus, osl_t *osh, void *sdh, void *regsva,
        pktq_init(&bus->txq, (PRIOMASK + 1), QLEN);
 
        /* Locate an appropriately-aligned portion of hdrbuf */
-       bus->rxhdr = (uint8 *) ROUNDUP((uintptr)&bus->hdrbuf[0], DHD_SDALIGN);
+       bus->rxhdr = (u8 *) ROUNDUP((uintptr)&bus->hdrbuf[0], DHD_SDALIGN);
 
        /* Set the poll and/or interrupt flags */
        bus->intr = (bool) dhd_intr;
@@ -5751,7 +5751,7 @@ static int dhdsdio_download_code_file(struct dhd_bus *bus, char *fw_path)
        int offset = 0;
        uint len;
        void *image = NULL;
-       uint8 *memblock = NULL, *memptr;
+       u8 *memblock = NULL, *memptr;
 
        DHD_INFO(("%s: download firmware %s\n", __func__, fw_path));
 
@@ -6011,7 +6011,7 @@ err:
 
 static int
 dhd_bcmsdh_recv_buf(dhd_bus_t *bus, uint32 addr, uint fn, uint flags,
-                   uint8 *buf, uint nbytes, void *pkt,
+                   u8 *buf, uint nbytes, void *pkt,
                    bcmsdh_cmplt_fn_t complete, void *handle)
 {
        int status;
@@ -6025,7 +6025,7 @@ dhd_bcmsdh_recv_buf(dhd_bus_t *bus, uint32 addr, uint fn, uint flags,
 
 static int
 dhd_bcmsdh_send_buf(dhd_bus_t *bus, uint32 addr, uint fn, uint flags,
-                   uint8 *buf, uint nbytes, void *pkt,
+                   u8 *buf, uint nbytes, void *pkt,
                    bcmsdh_cmplt_fn_t complete, void *handle)
 {
        return bcmsdh_send_buf
@@ -6054,7 +6054,7 @@ uint dhd_bus_hdrlen(struct dhd_bus *bus)
        return SDPCM_HDRLEN;
 }
 
-int dhd_bus_devreset(dhd_pub_t *dhdp, uint8 flag)
+int dhd_bus_devreset(dhd_pub_t *dhdp, u8 flag)
 {
        int bcmerror = 0;
        dhd_bus_t *bus;
index 1b23d84dfa9c56c35fa982ef57b8522ef5122265..641f568d811de451197246249ad18459c8f93d46 100644 (file)
@@ -73,14 +73,14 @@ static int32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
 static int32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
                                    struct net_device *dev);
 static int32 wl_cfg80211_get_station(struct wiphy *wiphy,
-                                    struct net_device *dev, uint8 *mac,
+                                    struct net_device *dev, u8 *mac,
                                     struct station_info *sinfo);
 static int32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
                                        struct net_device *dev, bool enabled,
                                        int32 timeout);
 static int32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
                                          struct net_device *dev,
-                                         const uint8 *addr,
+                                         const u8 *addr,
                                          const struct cfg80211_bitrate_mask
                                          *mask);
 static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
@@ -93,21 +93,21 @@ static int32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
 static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm);
 static int32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
                                            struct net_device *dev,
-                                           uint8 key_idx);
+                                           u8 key_idx);
 static int32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
-                                uint8 key_idx, const uint8 *mac_addr,
+                                u8 key_idx, const u8 *mac_addr,
                                 struct key_params *params);
 static int32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
-                                uint8 key_idx, const uint8 *mac_addr);
+                                u8 key_idx, const u8 *mac_addr);
 static int32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
-                                uint8 key_idx, const uint8 *mac_addr,
+                                u8 key_idx, const u8 *mac_addr,
                                 void *cookie, void (*callback) (void *cookie,
                                                                 struct
                                                                 key_params *
                                                                 params));
 static int32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
                                                 struct net_device *dev,
-                                                uint8 key_idx);
+                                                u8 key_idx);
 static int32 wl_cfg80211_resume(struct wiphy *wiphy);
 static int32 wl_cfg80211_suspend(struct wiphy *wiphy);
 static int32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
@@ -201,9 +201,9 @@ static int32 wl_get_assoc_ies(struct wl_priv *wl);
 ** information element utilities
 */
 static void wl_rst_ie(struct wl_priv *wl);
-static int32 wl_add_ie(struct wl_priv *wl, uint8 t, uint8 l, uint8 *v);
-static int32 wl_mrg_ie(struct wl_priv *wl, uint8 *ie_stream, uint16 ie_size);
-static int32 wl_cp_ie(struct wl_priv *wl, uint8 *dst, uint16 dst_size);
+static int32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
+static int32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, uint16 ie_size);
+static int32 wl_cp_ie(struct wl_priv *wl, u8 *dst, uint16 dst_size);
 static uint32 wl_get_ielen(struct wl_priv *wl);
 
 static int32 wl_mode_to_nl80211_iftype(int32 mode);
@@ -217,7 +217,7 @@ static int32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
 static int32 wl_update_bss_info(struct wl_priv *wl);
 
 static int32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
-                          uint8 key_idx, const uint8 *mac_addr,
+                          u8 key_idx, const u8 *mac_addr,
                           struct key_params *params);
 
 /*
@@ -264,7 +264,7 @@ static void wl_init_conf(struct wl_conf *conf);
 */
 #ifndef EMBEDDED_PLATFORM
 static int32 wl_dongle_mode(struct net_device *ndev, int32 iftype);
-static int32 wl_dongle_country(struct net_device *ndev, uint8 ccode);
+static int32 wl_dongle_country(struct net_device *ndev, u8 ccode);
 static int32 wl_dongle_up(struct net_device *ndev, uint32 up);
 static int32 wl_dongle_power(struct net_device *ndev, uint32 power_mode);
 static int32 wl_dongle_glom(struct net_device *ndev, uint32 glom,
@@ -1451,7 +1451,7 @@ static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm)
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        struct net_device *ndev = wl_to_ndev(wl);
        int32 txpwrdbm;
-       uint8 result;
+       u8 result;
        int32 err = 0;
 
        CHECK_SYS_UP();
@@ -1459,7 +1459,7 @@ static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm)
                WL_ERR(("error (%d)\n", err));
                return err;
        }
-       result = (uint8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
+       result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
        *dbm = (int32) bcm_qdbm_to_mw(result);
 
        return err;
@@ -1467,7 +1467,7 @@ static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm)
 
 static int32
 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
-                              uint8 key_idx)
+                              u8 key_idx)
 {
        uint32 index;
        int32 wsec;
@@ -1496,7 +1496,7 @@ wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
 
 static int32
 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
-             uint8 key_idx, const uint8 *mac_addr, struct key_params *params)
+             u8 key_idx, const u8 *mac_addr, struct key_params *params)
 {
        struct wl_wsec_key key;
        int32 err = 0;
@@ -1528,7 +1528,7 @@ wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
                memcpy(key.data, params->key, key.len);
 
                if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
-                       uint8 keybuf[8];
+                       u8 keybuf[8];
                        memcpy(keybuf, &key.data[24], sizeof(keybuf));
                        memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
                        memcpy(&key.data[16], keybuf, sizeof(keybuf));
@@ -1537,8 +1537,8 @@ wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
                /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
                if (params->seq && params->seq_len == 6) {
                        /* rx iv */
-                       uint8 *ivptr;
-                       ivptr = (uint8 *) params->seq;
+                       u8 *ivptr;
+                       ivptr = (u8 *) params->seq;
                        key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
                            (ivptr[3] << 8) | ivptr[2];
                        key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
@@ -1585,7 +1585,7 @@ wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
 
 static int32
 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
-                   uint8 key_idx, const uint8 *mac_addr,
+                   u8 key_idx, const u8 *mac_addr,
                    struct key_params *params)
 {
        struct wl_wsec_key key;
@@ -1668,7 +1668,7 @@ wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
 
 static int32
 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
-                   uint8 key_idx, const uint8 *mac_addr)
+                   u8 key_idx, const u8 *mac_addr)
 {
        struct wl_wsec_key key;
        int32 err = 0;
@@ -1722,7 +1722,7 @@ wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
 
 static int32
 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
-                   uint8 key_idx, const uint8 *mac_addr, void *cookie,
+                   u8 key_idx, const u8 *mac_addr, void *cookie,
                    void (*callback) (void *cookie, struct key_params * params))
 {
        struct key_params params;
@@ -1739,7 +1739,7 @@ wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
        key.index = key_idx;
        swap_key_to_BE(&key);
        memset(&params, 0, sizeof(params));
-       params.key_len = (uint8) MIN(DOT11_MAX_KEY_SIZE, key.len);
+       params.key_len = (u8) MIN(DOT11_MAX_KEY_SIZE, key.len);
        memcpy(params.key, key.data, params.key_len);
 
        if (unlikely
@@ -1778,7 +1778,7 @@ wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
 
 static int32
 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
-                                   struct net_device *dev, uint8 key_idx)
+                                   struct net_device *dev, u8 key_idx)
 {
        WL_INFO(("Not supported\n"));
        CHECK_SYS_UP();
@@ -1787,7 +1787,7 @@ wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
 
 static int32
 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
-                       uint8 *mac, struct station_info *sinfo)
+                       u8 *mac, struct station_info *sinfo)
 {
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        scb_val_t scb_val;
@@ -1880,7 +1880,7 @@ static __used uint32 wl_find_msb(uint16 bit16)
 
 static int32
 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
-                            const uint8 *addr,
+                            const u8 *addr,
                             const struct cfg80211_bitrate_mask *mask)
 {
        struct wl_rateset rateset;
@@ -2241,7 +2241,7 @@ static int32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
                return err;
        }
        notif_bss_info =
-           kzalloc(sizeof(*notif_bss_info) + sizeof(*mgmt) - sizeof(uint8) +
+           kzalloc(sizeof(*notif_bss_info) + sizeof(*mgmt) - sizeof(u8) +
                    WL_BSS_INFO_MAX, GFP_KERNEL);
        if (unlikely(!notif_bss_info)) {
                WL_ERR(("notif_bss_info alloc failed\n"));
@@ -2266,7 +2266,7 @@ static int32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
        wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
        wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
                  bi->rateset.rates);
-       wl_mrg_ie(wl, ((uint8 *) bi) + bi->ie_offset, bi->ie_length);
+       wl_mrg_ie(wl, ((u8 *) bi) + bi->ie_offset, bi->ie_length);
        wl_cp_ie(wl, mgmt->u.probe_resp.variable, WL_BSS_INFO_MAX -
                 offsetof(struct wl_cfg80211_bss_info, frame_buf));
        notif_bss_info->frame_len =
@@ -2519,7 +2519,7 @@ wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
        memcpy(&wl->bssid, &e->addr, ETHER_ADDR_LEN);
        wl_update_bss_info(wl);
        cfg80211_roamed(ndev,
-                       (uint8 *)&wl->bssid,
+                       (u8 *)&wl->bssid,
                        conn_info->req_ie, conn_info->req_ie_len,
                        conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
        WL_DBG(("Report roaming result\n"));
@@ -2541,7 +2541,7 @@ wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
        wl_update_bss_info(wl);
        if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
                cfg80211_connect_result(ndev,
-                                       (uint8 *)&wl->bssid,
+                                       (u8 *)&wl->bssid,
                                        conn_info->req_ie,
                                        conn_info->req_ie_len,
                                        conn_info->resp_ie,
@@ -2550,7 +2550,7 @@ wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
                WL_DBG(("Report connect result\n"));
        } else {
                cfg80211_roamed(ndev,
-                               (uint8 *)&wl->bssid,
+                               (u8 *)&wl->bssid,
                                conn_info->req_ie, conn_info->req_ie_len,
                                conn_info->resp_ie, conn_info->resp_ie_len,
                                GFP_KERNEL);
@@ -2574,7 +2574,7 @@ wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
        else
                key_type = NL80211_KEYTYPE_PAIRWISE;
 
-       cfg80211_michael_mic_failure(ndev, (uint8 *)&e->addr, key_type, -1,
+       cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
                                     NULL, GFP_KERNEL);
        rtnl_unlock();
 
@@ -3285,7 +3285,7 @@ static int32 wl_dongle_mode(struct net_device *ndev, int32 iftype)
 }
 
 #ifndef EMBEDDED_PLATFORM
-static int32 wl_dongle_country(struct net_device *ndev, uint8 ccode)
+static int32 wl_dongle_country(struct net_device *ndev, u8 ccode)
 {
 
        int32 err = 0;
@@ -3500,7 +3500,7 @@ static int32 wl_pattern_atoh(int8 *src, int8 *dst)
                char num[3];
                strncpy(num, src, 2);
                num[2] = '\0';
-               dst[i] = (uint8) strtoul(num, NULL, 16);
+               dst[i] = (u8) strtoul(num, NULL, 16);
                src += 2;
        }
        return i;
@@ -3819,7 +3819,7 @@ static void wl_rst_ie(struct wl_priv *wl)
        ie->offset = 0;
 }
 
-static int32 wl_add_ie(struct wl_priv *wl, uint8 t, uint8 l, uint8 *v)
+static int32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
 {
        struct wl_ie *ie = wl_to_ie(wl);
        int32 err = 0;
@@ -3836,7 +3836,7 @@ static int32 wl_add_ie(struct wl_priv *wl, uint8 t, uint8 l, uint8 *v)
        return err;
 }
 
-static int32 wl_mrg_ie(struct wl_priv *wl, uint8 *ie_stream, uint16 ie_size)
+static int32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, uint16 ie_size)
 {
        struct wl_ie *ie = wl_to_ie(wl);
        int32 err = 0;
@@ -3851,7 +3851,7 @@ static int32 wl_mrg_ie(struct wl_priv *wl, uint8 *ie_stream, uint16 ie_size)
        return err;
 }
 
-static int32 wl_cp_ie(struct wl_priv *wl, uint8 *dst, uint16 dst_size)
+static int32 wl_cp_ie(struct wl_priv *wl, u8 *dst, uint16 dst_size)
 {
        struct wl_ie *ie = wl_to_ie(wl);
        int32 err = 0;
index 3eeb423ca8b5c83dfbdca6319d6992d9c09cc05e..30421ce9bc6430f2ba8792b99b3e82566590fa64 100644 (file)
@@ -184,7 +184,7 @@ struct wl_cfg80211_bss_info {
        uint16 channel;
        int16 rssi;
        uint16 frame_len;
-       uint8 frame_buf[1];
+       u8 frame_buf[1];
 };
 
 /* basic structure of scan request */
@@ -195,7 +195,7 @@ struct wl_scan_req {
 /* basic structure of information element */
 struct wl_ie {
        uint16 offset;
-       uint8 buf[WL_TLV_INFO_MAX];
+       u8 buf[WL_TLV_INFO_MAX];
 };
 
 /* event queue for cfg80211 main event */
@@ -217,18 +217,18 @@ struct wl_security {
 
 /* ibss information for currently joined ibss network */
 struct wl_ibss {
-       uint8 beacon_interval;  /* in millisecond */
-       uint8 atim;             /* in millisecond */
+       u8 beacon_interval;     /* in millisecond */
+       u8 atim;                /* in millisecond */
        int8 join_only;
-       uint8 band;
-       uint8 channel;
+       u8 band;
+       u8 channel;
 };
 
 /* dongle profile */
 struct wl_profile {
        uint32 mode;
        struct wlc_ssid ssid;
-       uint8 bssid[ETHER_ADDR_LEN];
+       u8 bssid[ETHER_ADDR_LEN];
        struct wl_security sec;
        struct wl_ibss ibss;
        int32 band;
@@ -258,9 +258,9 @@ struct wl_iscan_ctrl {
 
 /* association inform */
 struct wl_connect_info {
-       uint8 *req_ie;
+       u8 *req_ie;
        int32 req_ie_len;
-       uint8 *resp_ie;
+       u8 *resp_ie;
        int32 resp_ie_len;
 };
 
@@ -329,9 +329,9 @@ struct wl_priv {
        bool dongle_up;         /* indicate whether dongle up or not */
        bool roam_on;           /* on/off switch for dongle self-roaming */
        bool scan_tried;        /* indicates if first scan attempted */
-       uint8 *ioctl_buf;       /* ioctl buffer */
-       uint8 *extra_buf;       /* maily to grab assoc information */
-       uint8 ci[0] __attribute__ ((__aligned__(NETDEV_ALIGN)));
+       u8 *ioctl_buf;  /* ioctl buffer */
+       u8 *extra_buf;  /* maily to grab assoc information */
+       u8 ci[0] __attribute__ ((__aligned__(NETDEV_ALIGN)));
 };
 
 #define wl_to_dev(w) (wiphy_dev(wl->wdev->wiphy))
index 4f1201e99927ef086519994daa8244379750b4b7..ed4ba03cfacda18d380300c08ff643742f6bbb76 100644 (file)
@@ -499,7 +499,7 @@ wl_iw_get_range(struct net_device *dev,
        int phytype;
        int bw_cap = 0, sgi_tx = 0, nmode = 0;
        channel_info_t ci;
-       uint8 nrate_list2copy = 0;
+       u8 nrate_list2copy = 0;
        uint16 nrate_list[4][8] = { {13, 26, 39, 52, 78, 104, 117, 130},
        {14, 29, 43, 58, 87, 116, 130, 144},
        {27, 54, 81, 108, 162, 216, 243, 270},
@@ -1407,10 +1407,10 @@ wl_iw_iscan_set_scan(struct net_device *dev,
 #endif                         /* WL_IW_USE_ISCAN */
 
 #if WIRELESS_EXT > 17
-static bool ie_is_wpa_ie(uint8 **wpaie, uint8 **tlvs, int *tlvs_len)
+static bool ie_is_wpa_ie(u8 **wpaie, u8 **tlvs, int *tlvs_len)
 {
 
-       uint8 *ie = *wpaie;
+       u8 *ie = *wpaie;
 
        if ((ie[1] >= 6) &&
            !bcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x01"), 4)) {
@@ -1423,10 +1423,10 @@ static bool ie_is_wpa_ie(uint8 **wpaie, uint8 **tlvs, int *tlvs_len)
        return FALSE;
 }
 
-static bool ie_is_wps_ie(uint8 **wpsie, uint8 **tlvs, int *tlvs_len)
+static bool ie_is_wps_ie(u8 **wpsie, u8 **tlvs, int *tlvs_len)
 {
 
-       uint8 *ie = *wpsie;
+       u8 *ie = *wpsie;
 
        if ((ie[1] >= 4) &&
            !bcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x04"), 4)) {
@@ -1451,7 +1451,7 @@ wl_iw_handle_scanresults_ies(char **event_p, char *end,
        event = *event_p;
        if (bi->ie_length) {
                bcm_tlv_t *ie;
-               uint8 *ptr = ((uint8 *) bi) + sizeof(wl_bss_info_t);
+               u8 *ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
                int ptr_len = bi->ie_length;
 
 #ifdef BCMWPA2
@@ -1463,11 +1463,11 @@ wl_iw_handle_scanresults_ies(char **event_p, char *end,
                            IWE_STREAM_ADD_POINT(info, event, end, &iwe,
                                                 (char *)ie);
                }
-               ptr = ((uint8 *) bi) + sizeof(wl_bss_info_t);
+               ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
 #endif
 
                while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
-                       if (ie_is_wps_ie(((uint8 **)&ie), &ptr, &ptr_len)) {
+                       if (ie_is_wps_ie(((u8 **)&ie), &ptr, &ptr_len)) {
                                iwe.cmd = IWEVGENIE;
                                iwe.u.data.length = ie->len + 2;
                                event =
@@ -1477,10 +1477,10 @@ wl_iw_handle_scanresults_ies(char **event_p, char *end,
                        }
                }
 
-               ptr = ((uint8 *) bi) + sizeof(wl_bss_info_t);
+               ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
                ptr_len = bi->ie_length;
                while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
-                       if (ie_is_wpa_ie(((uint8 **)&ie), &ptr, &ptr_len)) {
+                       if (ie_is_wpa_ie(((u8 **)&ie), &ptr, &ptr_len)) {
                                iwe.cmd = IWEVGENIE;
                                iwe.u.data.length = ie->len + 2;
                                event =
@@ -1743,7 +1743,7 @@ wl_iw_iscan_get_scan(struct net_device *dev,
        iscan_info_t *iscan = g_iscan;
        iscan_buf_t *p_buf;
        uint32 counter = 0;
-       uint8 channel;
+       u8 channel;
 
        WL_TRACE(("%s %s buflen_from_user %d:\n", dev->name, __func__,
                  dwrq->length));
@@ -2205,7 +2205,7 @@ wl_iw_get_txpow(struct net_device *dev,
                struct iw_param *vwrq, char *extra)
 {
        int error, disable, txpwrdbm;
-       uint8 result;
+       u8 result;
 
        WL_TRACE(("%s: SIOCGIWTXPOW\n", dev->name));
 
@@ -2218,7 +2218,7 @@ wl_iw_get_txpow(struct net_device *dev,
                return error;
 
        disable = dtoh32(disable);
-       result = (uint8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
+       result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
        vwrq->value = (int32) bcm_qdbm_to_mw(result);
        vwrq->fixed = 0;
        vwrq->disabled =
@@ -2585,7 +2585,7 @@ wl_iw_set_encodeext(struct net_device *dev,
                bcopy((void *)iwe->key, key.data, iwe->key_len);
 
                if (iwe->alg == IW_ENCODE_ALG_TKIP) {
-                       uint8 keybuf[8];
+                       u8 keybuf[8];
                        bcopy(&key.data[24], keybuf, sizeof(keybuf));
                        bcopy(&key.data[16], &key.data[24], sizeof(keybuf));
                        bcopy(keybuf, &key.data[16], sizeof(keybuf));
@@ -3508,7 +3508,7 @@ void wl_iw_event(struct net_device *dev, wl_event_msg_t *e, void *data)
                                cmd = IWEVPMKIDCAND;
                                pmkcandlist = data;
                                count =
-                                   ntoh32_ua((uint8 *) &
+                                   ntoh32_ua((u8 *) &
                                              pmkcandlist->npmkid_cand);
                                ASSERT(count >= 0);
                                wrqu.data.length = sizeof(struct iw_pmkid_cand);