Staging: brcm80211: s/int32/s32/

[pandora-kernel.git] / drivers / staging / brcm80211 / brcmfmac / bcmsdh.c

diff --git a/drivers/staging/brcm80211/brcmfmac/bcmsdh.c b/drivers/staging/brcm80211/brcmfmac/bcmsdh.c
index d5ec20e..13e62c4 100644 (file)
--- a/drivers/staging/brcm80211/brcmfmac/bcmsdh.c
+++ b/drivers/staging/brcm80211/brcmfmac/bcmsdh.c
@@ -36,14 +36,14 @@ const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;
 struct bcmsdh_info {
        bool init_success;      /* underlying driver successfully attached */
        void *sdioh;            /* handler for sdioh */
-       uint32 vendevid;        /* Target Vendor and Device ID on SD bus */
+       u32 vendevid;   /* Target Vendor and Device ID on SD bus */
        osl_t *osh;
        bool regfail;           /* Save status of last
                                 reg_read/reg_write call */
-       uint32 sbwad;           /* Save backplane window address */
+       u32 sbwad;              /* Save backplane window address */
 };
 /* local copy of bcm sd handler */
-bcmsdh_info_t *l_bcmsdh = NULL;
+bcmsdh_info_t *l_bcmsdh;
 
 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
 extern int sdioh_enable_hw_oob_intr(void *sdioh, bool enable);
@@ -58,8 +58,8 @@ bcmsdh_info_t *bcmsdh_attach(osl_t *osh, void *cfghdl, void **regsva, uint irq)
 {
        bcmsdh_info_t *bcmsdh;
 
-       if ((bcmsdh =
-            (bcmsdh_info_t *) MALLOC(osh, sizeof(bcmsdh_info_t))) == NULL) {
+       bcmsdh = (bcmsdh_info_t *) MALLOC(osh, sizeof(bcmsdh_info_t));
+       if (bcmsdh == NULL) {
                BCMSDH_ERROR(("bcmsdh_attach: out of memory, "
                        "malloced %d bytes\n", MALLOCED(osh)));
                return NULL;
@@ -69,7 +69,8 @@ bcmsdh_info_t *bcmsdh_attach(osl_t *osh, void *cfghdl, void **regsva, uint irq)
        /* save the handler locally */
        l_bcmsdh = bcmsdh;
 
-       if (!(bcmsdh->sdioh = sdioh_attach(osh, cfghdl, irq))) {
+       bcmsdh->sdioh = sdioh_attach(osh, cfghdl, irq);
+       if (!bcmsdh->sdioh) {
                bcmsdh_detach(osh, bcmsdh);
                return NULL;
        }
@@ -77,7 +78,7 @@ bcmsdh_info_t *bcmsdh_attach(osl_t *osh, void *cfghdl, void **regsva, uint irq)
        bcmsdh->osh = osh;
        bcmsdh->init_success = TRUE;
 
-       *regsva = (uint32 *) SI_ENUM_BASE;
+       *regsva = (u32 *) SI_ENUM_BASE;
 
        /* Report the BAR, to fix if needed */
        bcmsdh->sbwad = SI_ENUM_BASE;
@@ -180,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, u32 addr, int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
-       int32 retry = 0;
+       s32 retry = 0;
 #endif
-       uint8 data = 0;
+       u8 data = 0;
 
        if (!bcmsdh)
                bcmsdh = l_bcmsdh;
@@ -201,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));
@@ -209,19 +210,19 @@ 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, u32 addr, u8 data, int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
-       int32 retry = 0;
+       s32 retry = 0;
 #endif
 
        if (!bcmsdh)
@@ -236,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));
@@ -244,15 +245,15 @@ 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));
 }
 
-uint32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, uint32 addr, int *err)
+u32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
-       uint32 data = 0;
+       u32 data = 0;
 
        if (!bcmsdh)
                bcmsdh = l_bcmsdh;
@@ -266,14 +267,14 @@ uint32 bcmsdh_cfg_read_word(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, uint32data = 0x%x\n",
+       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
                     __func__, fnc_num, addr, data));
 
        return data;
 }
 
 void
-bcmsdh_cfg_write_word(void *sdh, uint fnc_num, uint32 addr, uint32 data,
+bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,
                      int *err)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -291,17 +292,17 @@ bcmsdh_cfg_write_word(void *sdh, uint fnc_num, uint32 addr, uint32 data,
        if (err)
                *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 
-       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint32data = 0x%x\n",
+       BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
                     __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;
 
@@ -317,7 +318,8 @@ 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. */
-               if ((tmp_buf = (uint8 *) MALLOC(bcmsdh->osh, length)) == NULL) {
+               tmp_buf = (u8 *) MALLOC(bcmsdh->osh, length);
+               if (tmp_buf == NULL) {
                        BCMSDH_ERROR(("%s: out of memory\n", __func__));
                        return BCME_NOMEM;
                }
@@ -334,7 +336,7 @@ int bcmsdh_cis_read(void *sdh, uint func, uint8 * cis, uint length)
        return SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR;
 }
 
-static int bcmsdhsdio_set_sbaddr_window(void *sdh, uint32 address)
+static int bcmsdhsdio_set_sbaddr_window(void *sdh, u32 address)
 {
        int err = 0;
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -351,11 +353,11 @@ static int bcmsdhsdio_set_sbaddr_window(void *sdh, uint32 address)
        return err;
 }
 
-uint32 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
+u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
-       uint32 word = 0;
+       u32 word = 0;
        uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 
        BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __func__, addr));
@@ -381,16 +383,16 @@ uint32 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
 
        bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 
-       BCMSDH_INFO(("uint32data = 0x%x\n", word));
+       BCMSDH_INFO(("u32data = 0x%x\n", word));
 
        /* 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):
+               case sizeof(u16):
                        return word & 0xffff;
-               case sizeof(uint32):
+               case sizeof(u32):
                        return word;
                default:
                        bcmsdh->regfail = TRUE;
@@ -404,7 +406,7 @@ uint32 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
        return 0xFFFFFFFF;
 }
 
-uint32 bcmsdh_reg_write(void *sdh, uint32 addr, uint size, uint32 data)
+u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
@@ -420,7 +422,8 @@ uint32 bcmsdh_reg_write(void *sdh, uint32 addr, uint size, uint32 data)
        ASSERT(bcmsdh->init_success);
 
        if (bar0 != bcmsdh->sbwad) {
-               if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
+               err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
+               if (err)
                        return err;
 
                bcmsdh->sbwad = bar0;
@@ -448,8 +451,8 @@ bool bcmsdh_regfail(void *sdh)
 }
 
 int
-bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
-               uint8 *buf, uint nbytes, void *pkt,
+bcmsdh_recv_buf(void *sdh, u32 addr, uint fn, uint flags,
+               u8 *buf, uint nbytes, void *pkt,
                bcmsdh_cmplt_fn_t complete, void *handle)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -471,7 +474,8 @@ bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
                return BCME_UNSUPPORTED;
 
        if (bar0 != bcmsdh->sbwad) {
-               if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
+               err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
+               if (err)
                        return err;
 
                bcmsdh->sbwad = bar0;
@@ -492,8 +496,8 @@ 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,
+bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags,
+               u8 *buf, uint nbytes, void *pkt,
                bcmsdh_cmplt_fn_t complete, void *handle)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -515,7 +519,8 @@ bcmsdh_send_buf(void *sdh, uint32 addr, uint fn, uint flags,
                return BCME_UNSUPPORTED;
 
        if (bar0 != bcmsdh->sbwad) {
-               if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
+               err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
+               if (err)
                        return err;
 
                bcmsdh->sbwad = bar0;
@@ -535,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, u32 addr, u8 *buf, uint nbytes)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
        SDIOH_API_RC status;
@@ -607,12 +612,12 @@ void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh)
 }
 
 /* Function to pass device-status bits to DHD. */
-uint32 bcmsdh_get_dstatus(void *sdh)
+u32 bcmsdh_get_dstatus(void *sdh)
 {
        return 0;
 }
 
-uint32 bcmsdh_cur_sbwad(void *sdh)
+u32 bcmsdh_cur_sbwad(void *sdh)
 {
        bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 
@@ -622,7 +627,7 @@ uint32 bcmsdh_cur_sbwad(void *sdh)
        return bcmsdh->sbwad;
 }
 
-void bcmsdh_chipinfo(void *sdh, uint32 chip, uint32 chiprev)
+void bcmsdh_chipinfo(void *sdh, u32 chip, u32 chiprev)
 {
        return;
 }