staging: wilc1000: rename u8RemainOnChan_pendingreq of struct host_if_drv

[firefly-linux-kernel-4.4.55.git] / drivers / staging / wilc1000 / wilc_sdio.c

diff --git a/drivers/staging/wilc1000/wilc_sdio.c b/drivers/staging/wilc1000/wilc_sdio.c
index 5a18148a593e3f2b6416138b6fee4a95bc6b78cc..300c571e4e2d17d876e757a0e5c433b77cd2ae44 100644 (file)
--- a/drivers/staging/wilc1000/wilc_sdio.c
+++ b/drivers/staging/wilc1000/wilc_sdio.c
@@ -7,6 +7,7 @@
 /*  */
 /* //////////////////////////////////////////////////////////////////////////// */
 
+#include <linux/string.h>
 #include "wilc_wlan_if.h"
 #include "wilc_wlan.h"
 
@@ -14,8 +15,7 @@
 
 typedef struct {
        void *os_context;
-       wilc_wlan_os_func_t os_func;
-       uint32_t block_size;
+       u32 block_size;
        int (*sdio_cmd52)(sdio_cmd52_t *);
        int (*sdio_cmd53)(sdio_cmd53_t *);
        int (*sdio_set_max_speed)(void);
@@ -29,10 +29,9 @@ typedef struct {
 static wilc_sdio_t g_sdio;
 
 #ifdef WILC_SDIO_IRQ_GPIO
-static int sdio_write_reg(uint32_t addr, uint32_t data);
-static int sdio_read_reg(uint32_t addr, uint32_t *data);
+static int sdio_write_reg(u32 addr, u32 data);
+static int sdio_read_reg(u32 addr, u32 *data);
 #endif
-extern unsigned int int_clrd;
 
 /********************************************
  *
@@ -40,7 +39,7 @@ extern unsigned int int_clrd;
  *
  ********************************************/
 
-static int sdio_set_func0_csa_address(uint32_t adr)
+static int sdio_set_func0_csa_address(u32 adr)
 {
        sdio_cmd52_t cmd;
 
@@ -51,21 +50,21 @@ static int sdio_set_func0_csa_address(uint32_t adr)
        cmd.function = 0;
        cmd.raw = 0;
        cmd.address = 0x10c;
-       cmd.data = (uint8_t)adr;
+       cmd.data = (u8)adr;
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x10c data...\n");
                goto _fail_;
        }
 
        cmd.address = 0x10d;
-       cmd.data = (uint8_t)(adr >> 8);
+       cmd.data = (u8)(adr >> 8);
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x10d data...\n");
                goto _fail_;
        }
 
        cmd.address = 0x10e;
-       cmd.data = (uint8_t)(adr >> 16);
+       cmd.data = (u8)(adr >> 16);
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x10e data...\n");
                goto _fail_;
@@ -76,29 +75,7 @@ _fail_:
        return 0;
 }
 
-static int sdio_set_func0_csa_address_byte0(uint32_t adr)
-{
-       sdio_cmd52_t cmd;
-
-       /**
-        *      Review: BIG ENDIAN
-        **/
-       cmd.read_write = 1;
-       cmd.function = 0;
-       cmd.raw = 0;
-       cmd.address = 0x10c;
-       cmd.data = (uint8_t)adr;
-       if (!g_sdio.sdio_cmd52(&cmd)) {
-               g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x10c data...\n");
-               goto _fail_;
-       }
-
-       return 1;
-_fail_:
-       return 0;
-}
-
-static int sdio_set_func0_block_size(uint32_t block_size)
+static int sdio_set_func0_block_size(u32 block_size)
 {
        sdio_cmd52_t cmd;
 
@@ -106,14 +83,14 @@ static int sdio_set_func0_block_size(uint32_t block_size)
        cmd.function = 0;
        cmd.raw = 0;
        cmd.address = 0x10;
-       cmd.data = (uint8_t)block_size;
+       cmd.data = (u8)block_size;
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x10 data...\n");
                goto _fail_;
        }
 
        cmd.address = 0x11;
-       cmd.data = (uint8_t)(block_size >> 8);
+       cmd.data = (u8)(block_size >> 8);
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x11 data...\n");
                goto _fail_;
@@ -130,7 +107,7 @@ _fail_:
  *
  ********************************************/
 
-static int sdio_set_func1_block_size(uint32_t block_size)
+static int sdio_set_func1_block_size(u32 block_size)
 {
        sdio_cmd52_t cmd;
 
@@ -138,13 +115,13 @@ static int sdio_set_func1_block_size(uint32_t block_size)
        cmd.function = 0;
        cmd.raw = 0;
        cmd.address = 0x110;
-       cmd.data = (uint8_t)block_size;
+       cmd.data = (u8)block_size;
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x110 data...\n");
                goto _fail_;
        }
        cmd.address = 0x111;
-       cmd.data = (uint8_t)(block_size >> 8);
+       cmd.data = (u8)(block_size >> 8);
        if (!g_sdio.sdio_cmd52(&cmd)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed cmd52, set 0x111 data...\n");
                goto _fail_;
@@ -158,7 +135,7 @@ _fail_:
 static int sdio_clear_int(void)
 {
 #ifndef WILC_SDIO_IRQ_GPIO
-       /* uint32_t sts; */
+       /* u32 sts; */
        sdio_cmd52_t cmd;
 
        cmd.read_write = 0;
@@ -167,11 +144,10 @@ static int sdio_clear_int(void)
        cmd.address = 0x4;
        cmd.data = 0;
        g_sdio.sdio_cmd52(&cmd);
-       int_clrd++;
 
        return cmd.data;
 #else
-       uint32_t reg;
+       u32 reg;
 
        if (!sdio_read_reg(WILC_HOST_RX_CTRL_0, &reg)) {
                g_sdio.dPrint(N_ERR, "[wilc spi]: Failed read reg (%08x)...\n", WILC_HOST_RX_CTRL_0);
@@ -179,15 +155,14 @@ static int sdio_clear_int(void)
        }
        reg &= ~0x1;
        sdio_write_reg(WILC_HOST_RX_CTRL_0, reg);
-       int_clrd++;
        return 1;
 #endif
 
 }
 
-uint32_t sdio_xfer_cnt(void)
+u32 sdio_xfer_cnt(void)
 {
-       uint32_t cnt = 0;
+       u32 cnt = 0;
        sdio_cmd52_t cmd;
 
        cmd.read_write = 0;
@@ -246,7 +221,7 @@ _fail_:
        return 0;
 }
 
-static int sdio_write_reg(uint32_t addr, uint32_t data)
+static int sdio_write_reg(u32 addr, u32 data)
 {
 #ifdef BIG_ENDIAN
        data = BYTE_SWAP(data);
@@ -279,7 +254,7 @@ static int sdio_write_reg(uint32_t addr, uint32_t data)
                cmd.block_mode = 0;
                cmd.increment = 1;
                cmd.count = 4;
-               cmd.buffer = (uint8_t *)&data;
+               cmd.buffer = (u8 *)&data;
                cmd.block_size = g_sdio.block_size; /* johnny : prevent it from setting unexpected value */
 
                if (!g_sdio.sdio_cmd53(&cmd)) {
@@ -295,9 +270,9 @@ _fail_:
        return 0;
 }
 
-static int sdio_write(uint32_t addr, uint8_t *buf, uint32_t size)
+static int sdio_write(u32 addr, u8 *buf, u32 size)
 {
-       uint32_t block_size = g_sdio.block_size;
+       u32 block_size = g_sdio.block_size;
        sdio_cmd53_t cmd;
        int nblk, nleft;
 
@@ -379,7 +354,7 @@ _fail_:
        return 0;
 }
 
-static int sdio_read_reg(uint32_t addr, uint32_t *data)
+static int sdio_read_reg(u32 addr, u32 *data)
 {
        if ((addr >= 0xf0) && (addr <= 0xff)) {
                sdio_cmd52_t cmd;
@@ -405,7 +380,7 @@ static int sdio_read_reg(uint32_t addr, uint32_t *data)
                cmd.block_mode = 0;
                cmd.increment = 1;
                cmd.count = 4;
-               cmd.buffer = (uint8_t *)data;
+               cmd.buffer = (u8 *)data;
 
                cmd.block_size = g_sdio.block_size; /* johnny : prevent it from setting unexpected value */
 
@@ -426,9 +401,9 @@ _fail_:
        return 0;
 }
 
-static int sdio_read(uint32_t addr, uint8_t *buf, uint32_t size)
+static int sdio_read(u32 addr, u8 *buf, u32 size)
 {
-       uint32_t block_size = g_sdio.block_size;
+       u32 block_size = g_sdio.block_size;
        sdio_cmd53_t cmd;
        int nblk, nleft;
 
@@ -523,7 +498,7 @@ static int sdio_deinit(void *pv)
 
 static int sdio_sync(void)
 {
-       uint32_t reg;
+       u32 reg;
 
        /**
         *      Disable power sequencer
@@ -533,7 +508,7 @@ static int sdio_sync(void)
                return 0;
        }
 
-       reg &= ~(1 << 8);
+       reg &= ~BIT(8);
        if (!sdio_write_reg(WILC_MISC, reg)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed write misc reg...\n");
                return 0;
@@ -541,7 +516,7 @@ static int sdio_sync(void)
 
 #ifdef WILC_SDIO_IRQ_GPIO
        {
-               uint32_t reg;
+               u32 reg;
                int ret;
 
                /**
@@ -552,7 +527,7 @@ static int sdio_sync(void)
                        g_sdio.dPrint(N_ERR, "[wilc spi]: Failed read reg (%08x)...\n", WILC_PIN_MUX_0);
                        return 0;
                }
-               reg |= (1 << 8);
+               reg |= BIT(8);
                ret = sdio_write_reg(WILC_PIN_MUX_0, reg);
                if (!ret) {
                        g_sdio.dPrint(N_ERR, "[wilc spi]: Failed write reg (%08x)...\n", WILC_PIN_MUX_0);
@@ -567,7 +542,7 @@ static int sdio_sync(void)
                        g_sdio.dPrint(N_ERR, "[wilc spi]: Failed read reg (%08x)...\n", WILC_INTR_ENABLE);
                        return 0;
                }
-               reg |= (1 << 16);
+               reg |= BIT(16);
                ret = sdio_write_reg(WILC_INTR_ENABLE, reg);
                if (!ret) {
                        g_sdio.dPrint(N_ERR, "[wilc spi]: Failed write reg (%08x)...\n", WILC_INTR_ENABLE);
@@ -583,13 +558,12 @@ static int sdio_init(wilc_wlan_inp_t *inp, wilc_debug_func func)
 {
        sdio_cmd52_t cmd;
        int loop;
-       uint32_t chipid;
+       u32 chipid;
 
        memset(&g_sdio, 0, sizeof(wilc_sdio_t));
 
        g_sdio.dPrint = func;
        g_sdio.os_context = inp->os_context.os_private;
-       memcpy((void *)&g_sdio.os_func, (void *)&inp->os_func, sizeof(wilc_wlan_os_func_t));
 
        if (inp->io_func.io_init) {
                if (!inp->io_func.io_init(g_sdio.os_context)) {
@@ -715,10 +689,10 @@ static void sdio_set_default_speed(void)
        g_sdio.sdio_set_default_speed();
 }
 
-static int sdio_read_size(uint32_t *size)
+static int sdio_read_size(u32 *size)
 {
 
-       uint32_t tmp;
+       u32 tmp;
        sdio_cmd52_t cmd;
 
        /**
@@ -744,10 +718,10 @@ static int sdio_read_size(uint32_t *size)
        return 1;
 }
 
-static int sdio_read_int(uint32_t *int_status)
+static int sdio_read_int(u32 *int_status)
 {
 
-       uint32_t tmp;
+       u32 tmp;
        sdio_cmd52_t cmd;
 
        sdio_read_size(&tmp);
@@ -756,24 +730,22 @@ static int sdio_read_int(uint32_t *int_status)
         *      Read IRQ flags
         **/
 #ifndef WILC_SDIO_IRQ_GPIO
-       /* cmd.read_write = 0; */
        cmd.function = 1;
-       /* cmd.raw = 0; */
        cmd.address = 0x04;
        cmd.data = 0;
        g_sdio.sdio_cmd52(&cmd);
 
-       if (cmd.data & (1 << 0))
+       if (cmd.data & BIT(0))
                tmp |= INT_0;
-       if (cmd.data & (1 << 2))
+       if (cmd.data & BIT(2))
                tmp |= INT_1;
-       if (cmd.data & (1 << 3))
+       if (cmd.data & BIT(3))
                tmp |= INT_2;
-       if (cmd.data & (1 << 4))
+       if (cmd.data & BIT(4))
                tmp |= INT_3;
-       if (cmd.data & (1 << 5))
+       if (cmd.data & BIT(5))
                tmp |= INT_4;
-       if (cmd.data & (1 << 6))
+       if (cmd.data & BIT(6))
                tmp |= INT_5;
        {
                int i;
@@ -787,7 +759,7 @@ static int sdio_read_int(uint32_t *int_status)
        }
 #else
        {
-               uint32_t irq_flags;
+               u32 irq_flags;
 
                cmd.read_write = 0;
                cmd.function = 0;
@@ -806,18 +778,18 @@ static int sdio_read_int(uint32_t *int_status)
        return 1;
 }
 
-static int sdio_clear_int_ext(uint32_t val)
+static int sdio_clear_int_ext(u32 val)
 {
        int ret;
 
        if (g_sdio.has_thrpt_enh3) {
-               uint32_t reg;
+               u32 reg;
 
 #ifdef WILC_SDIO_IRQ_GPIO
                {
-                       uint32_t flags;
+                       u32 flags;
 
-                       flags = val & ((1 << MAX_NUN_INT_THRPT_ENH2) - 1);
+                       flags = val & (BIT(MAX_NUN_INT_THRPT_ENH2) - 1);
                        reg = flags;
                }
 #else
@@ -825,13 +797,13 @@ static int sdio_clear_int_ext(uint32_t val)
 #endif
                /* select VMM table 0 */
                if ((val & SEL_VMM_TBL0) == SEL_VMM_TBL0)
-                       reg |= (1 << 5);
+                       reg |= BIT(5);
                /* select VMM table 1 */
                if ((val & SEL_VMM_TBL1) == SEL_VMM_TBL1)
-                       reg |= (1 << 6);
+                       reg |= BIT(6);
                /* enable VMM */
                if ((val & EN_VMM) == EN_VMM)
-                       reg |= (1 << 7);
+                       reg |= BIT(7);
                if (reg) {
                        sdio_cmd52_t cmd;
 
@@ -853,9 +825,9 @@ static int sdio_clear_int_ext(uint32_t val)
                {
                        /* see below. has_thrpt_enh2 uses register 0xf8 to clear interrupts. */
                        /* Cannot clear multiple interrupts. Must clear each interrupt individually */
-                       uint32_t flags;
+                       u32 flags;
 
-                       flags = val & ((1 << MAX_NUM_INT) - 1);
+                       flags = val & (BIT(MAX_NUM_INT) - 1);
                        if (flags) {
                                int i;
 
@@ -868,7 +840,7 @@ static int sdio_clear_int_ext(uint32_t val)
                                                cmd.function = 0;
                                                cmd.raw = 0;
                                                cmd.address = 0xf8;
-                                               cmd.data = (1 << i);
+                                               cmd.data = BIT(i);
 
                                                ret = g_sdio.sdio_cmd52(&cmd);
                                                if (!ret) {
@@ -893,18 +865,18 @@ static int sdio_clear_int_ext(uint32_t val)
 #endif /* WILC_SDIO_IRQ_GPIO */
 
                {
-                       uint32_t vmm_ctl;
+                       u32 vmm_ctl;
 
                        vmm_ctl = 0;
                        /* select VMM table 0 */
                        if ((val & SEL_VMM_TBL0) == SEL_VMM_TBL0)
-                               vmm_ctl |= (1 << 0);
+                               vmm_ctl |= BIT(0);
                        /* select VMM table 1 */
                        if ((val & SEL_VMM_TBL1) == SEL_VMM_TBL1)
-                               vmm_ctl |= (1 << 1);
+                               vmm_ctl |= BIT(1);
                        /* enable VMM */
                        if ((val & EN_VMM) == EN_VMM)
-                               vmm_ctl |= (1 << 2);
+                               vmm_ctl |= BIT(2);
 
                        if (vmm_ctl) {
                                sdio_cmd52_t cmd;
@@ -930,7 +902,7 @@ _fail_:
 
 static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
 {
-       uint32_t reg;
+       u32 reg;
 
        if (nint > MAX_NUM_INT) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Too many interupts (%d)...\n", nint);
@@ -951,7 +923,7 @@ static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
                return 0;
        }
 
-       reg &= ~(1 << 8);
+       reg &= ~BIT(8);
        if (!sdio_write_reg(WILC_MISC, reg)) {
                g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed write misc reg...\n");
                return 0;
@@ -959,7 +931,7 @@ static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
 
 #ifdef WILC_SDIO_IRQ_GPIO
        {
-               uint32_t reg;
+               u32 reg;
                int ret, i;
 
                /**
@@ -970,7 +942,7 @@ static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
                        g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed read reg (%08x)...\n", WILC_PIN_MUX_0);
                        return 0;
                }
-               reg |= (1 << 8);
+               reg |= BIT(8);
                ret = sdio_write_reg(WILC_PIN_MUX_0, reg);
                if (!ret) {
                        g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed write reg (%08x)...\n", WILC_PIN_MUX_0);
@@ -987,7 +959,7 @@ static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
                }
 
                for (i = 0; (i < 5) && (nint > 0); i++, nint--)
-                       reg |= (1 << (27 + i));
+                       reg |= BIT((27 + i));
                ret = sdio_write_reg(WILC_INTR_ENABLE, reg);
                if (!ret) {
                        g_sdio.dPrint(N_ERR, "[wilc sdio]: Failed write reg (%08x)...\n", WILC_INTR_ENABLE);
@@ -1001,7 +973,7 @@ static int sdio_sync_ext(int nint /*  how mant interrupts to enable. */)
                        }
 
                        for (i = 0; (i < 3) && (nint > 0); i++, nint--)
-                               reg |= (1 << i);
+                               reg |= BIT(i);
 
                        ret = sdio_read_reg(WILC_INTR2_ENABLE, &reg);
                        if (!ret) {