leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

staging: wilc1000: use proper namespace for macros in wilc_wlan_if.h header

Browse Source 
Rename the macros defined in wilc_wlan_if.h header to have clear
namespace. As convention used 'WILC_FW_' prefix for constants defined for
firmware and 'WILC_' prefix for driver constants.

Signed-off-by: Ajay Singh <ajay.kathat@microchip.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Ajay Singh 2018-11-12 05:45:20 +00:00 committed by Greg Kroah-Hartman
parent 00d54198a7
commit b997b84ffc
7 changed files with 138 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/staging/wilc1000/host_interface.c
View File

@ -684,7 +684,7 @@ static void handle_connect(struct work_struct *work)
cur_byte[conn_attr->ssid_len] = '\0';
}
cur_byte += MAX_SSID_LEN;
*(cur_byte++) = INFRASTRUCTURE;
*(cur_byte++) = WILC_FW_BSS_TYPE_INFRA;
if (conn_attr->ch >= 1 && conn_attr->ch <= 14) {
*(cur_byte++) = conn_attr->ch;
@ -2321,9 +2321,9 @@ static void handle_power_management(struct work_struct *work)
wid.id = WID_POWER_MANAGEMENT;
if (pm_param->enabled)
power_mode = MIN_FAST_PS;
power_mode = WILC_FW_MIN_FAST_PS;
else
power_mode = NO_POWERSAVE;
power_mode = WILC_FW_NO_POWERSAVE;
wid.val = &power_mode;
wid.size = sizeof(char);

32
drivers/staging/wilc1000/linux_wlan.c
View File

@ -338,7 +338,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_PC_TEST_MODE, c_val, 1, 0, 0))
goto fail;
c_val[0] = INFRASTRUCTURE;
c_val[0] = WILC_FW_BSS_TYPE_INFRA;
if (!wilc_wlan_cfg_set(vif, 0, WID_BSS_TYPE, c_val, 1, 0, 0))
goto fail;
@ -346,7 +346,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_TX_RATE, c_val, 1, 0, 0))
goto fail;
c_val[0] = G_MIXED_11B_2_MODE;
c_val[0] = WILC_FW_OPER_MODE_G_MIXED_11B_2;
if (!wilc_wlan_cfg_set(vif, 0, WID_11G_OPERATING_MODE, c_val, 1, 0,
0))
goto fail;
@ -355,19 +355,19 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_CHANNEL, c_val, 1, 0, 0))
goto fail;
c_val[0] = G_SHORT_PREAMBLE;
c_val[0] = WILC_FW_PREAMBLE_SHORT;
if (!wilc_wlan_cfg_set(vif, 0, WID_PREAMBLE, c_val, 1, 0, 0))
goto fail;
c_val[0] = AUTO_PROT;
c_val[0] = WILC_FW_11N_PROT_AUTO;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_PROT_MECH, c_val, 1, 0, 0))
goto fail;
c_val[0] = ACTIVE_SCAN;
c_val[0] = WILC_FW_ACTIVE_SCAN;
if (!wilc_wlan_cfg_set(vif, 0, WID_SCAN_TYPE, c_val, 1, 0, 0))
goto fail;
c_val[0] = SITE_SURVEY_OFF;
c_val[0] = WILC_FW_SITE_SURVEY_OFF;
if (!wilc_wlan_cfg_set(vif, 0, WID_SITE_SURVEY, c_val, 1, 0, 0))
goto fail;
@ -387,7 +387,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_QOS_ENABLE, c_val, 1, 0, 0))
goto fail;
c_val[0] = NO_POWERSAVE;
c_val[0] = WILC_FW_NO_POWERSAVE;
if (!wilc_wlan_cfg_set(vif, 0, WID_POWER_MANAGEMENT, c_val, 1, 0, 0))
goto fail;
@ -395,7 +395,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_11I_MODE, c_val, 1, 0, 0))
goto fail;
c_val[0] = OPEN_SYSTEM;
c_val[0] = WILC_FW_AUTH_OPEN_SYSTEM;
if (!wilc_wlan_cfg_set(vif, 0, WID_AUTH_TYPE, c_val, 1, 0, 0))
goto fail;
@ -429,7 +429,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_DTIM_PERIOD, c_val, 1, 0, 0))
goto fail;
c_val[0] = NORMAL_ACK;
c_val[0] = WILC_FW_ACK_POLICY_NORMAL;
if (!wilc_wlan_cfg_set(vif, 0, WID_ACK_POLICY, c_val, 1, 0, 0))
goto fail;
@ -452,7 +452,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_BEACON_INTERVAL, c_val, 2, 0, 0))
goto fail;
c_val[0] = REKEY_DISABLE;
c_val[0] = WILC_FW_REKEY_POLICY_DISABLE;
if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_POLICY, c_val, 1, 0, 0))
goto fail;
@ -470,7 +470,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
0))
goto fail;
c_val[0] = G_SELF_CTS_PROT;
c_val[0] = WILC_FW_ERP_PROT_SELF_CTS;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ERP_PROT_TYPE, c_val, 1, 0, 0))
goto fail;
@ -478,7 +478,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ENABLE, c_val, 1, 0, 0))
goto fail;
c_val[0] = HT_MIXED_MODE;
c_val[0] = WILC_FW_11N_OP_MODE_HT_MIXED;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OPERATING_MODE, c_val, 1, 0,
0))
goto fail;
@ -488,12 +488,12 @@ static int linux_wlan_init_test_config(struct net_device *dev,
0))
goto fail;
c_val[0] = DETECT_PROTECT_REPORT;
c_val[0] = WILC_FW_OBBS_NONHT_DETECT_PROTECT_REPORT;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OBSS_NONHT_DETECTION, c_val, 1,
0, 0))
goto fail;
c_val[0] = RTS_CTS_NONHT_PROT;
c_val[0] = WILC_FW_HT_PROT_RTS_CTS_NONHT;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_HT_PROT_TYPE, c_val, 1, 0, 0))
goto fail;
@ -502,7 +502,7 @@ static int linux_wlan_init_test_config(struct net_device *dev,
0))
goto fail;
c_val[0] = MIMO_MODE;
c_val[0] = WILC_FW_SMPS_MODE_MIMO;
if (!wilc_wlan_cfg_set(vif, 0, WID_11N_SMPS_MODE, c_val, 1, 0, 0))
goto fail;
@ -1070,7 +1070,7 @@ int wilc_netdev_init(struct wilc **wilc, struct device *dev, int io_type,
wl->io_type = io_type;
wl->hif_func = ops;
wl->enable_ps = true;
wl->chip_ps_state = CHIP_WAKEDUP;
wl->chip_ps_state = WILC_CHIP_WAKEDUP;
INIT_LIST_HEAD(&wl->txq_head.list);
INIT_LIST_HEAD(&wl->rxq_head.list);

3
drivers/staging/wilc1000/wilc_sdio.c
View File

@ -144,7 +144,8 @@ static int linux_sdio_probe(struct sdio_func *func,
}
dev_dbg(&func->dev, "Initializing netdev\n");
ret = wilc_netdev_init(&wilc, &func->dev, HIF_SDIO, &wilc_hif_sdio);
ret = wilc_netdev_init(&wilc, &func->dev, WILC_HIF_SDIO,
&wilc_hif_sdio);
if (ret) {
dev_err(&func->dev, "Couldn't initialize netdev\n");
kfree(sdio_priv);

2
drivers/staging/wilc1000/wilc_spi.c
View File

@ -120,7 +120,7 @@ static int wilc_bus_probe(struct spi_device *spi)
dev_err(&spi->dev, "failed to get the irq gpio\n");
}
ret = wilc_netdev_init(&wilc, NULL, HIF_SPI, &wilc_hif_spi);
ret = wilc_netdev_init(&wilc, NULL, WILC_HIF_SPI, &wilc_hif_spi);
if (ret) {
kfree(spi_priv);
return ret;

14
drivers/staging/wilc1000/wilc_wfi_cfgoperations.c
View File

@ -612,14 +612,14 @@ static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
&hidden_ntwk))
return -ENOMEM;
ret = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
ret = wilc_scan(vif, USER_SCAN, WILC_FW_ACTIVE_SCAN,
scan_ch_list,
request->n_channels,
(const u8 *)request->ie,
request->ie_len, cfg_scan_result,
(void *)priv, &hidden_ntwk);
} else {
ret = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
ret = wilc_scan(vif, USER_SCAN, WILC_FW_ACTIVE_SCAN,
scan_ch_list,
request->n_channels,
(const u8 *)request->ie,
@ -647,7 +647,7 @@ static int connect(struct wiphy *wiphy, struct net_device *dev,
u32 i;
u32 sel_bssi_idx = UINT_MAX;
u8 security = WILC_FW_SEC_NO;
enum authtype auth_type = ANY;
enum authtype auth_type = WILC_FW_AUTH_ANY;
u32 cipher_group;
vif->connecting = true;
@ -747,11 +747,11 @@ static int connect(struct wiphy *wiphy, struct net_device *dev,
switch (sme->auth_type) {
case NL80211_AUTHTYPE_OPEN_SYSTEM:
auth_type = OPEN_SYSTEM;
auth_type = WILC_FW_AUTH_OPEN_SYSTEM;
break;
case NL80211_AUTHTYPE_SHARED_KEY:
auth_type = SHARED_KEY;
auth_type = WILC_FW_AUTH_SHARED_KEY;
break;
default:
@ -760,7 +760,7 @@ static int connect(struct wiphy *wiphy, struct net_device *dev,
if (sme->crypto.n_akm_suites) {
if (sme->crypto.akm_suites[0] == WLAN_AKM_SUITE_8021X)
auth_type = IEEE8021;
auth_type = WILC_FW_AUTH_IEEE8021;
}
curr_channel = nw_info->ch;
@ -909,7 +909,7 @@ static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
ret = wilc_add_wep_key_bss_ap(vif, params->key,
params->key_len,
key_index, mode,
OPEN_SYSTEM);
WILC_FW_AUTH_OPEN_SYSTEM);
break;
}
if (memcmp(params->key, priv->wep_key[key_index],

88
drivers/staging/wilc1000/wilc_wlan.c
View File

@ -17,13 +17,13 @@ static inline bool is_wilc1000(u32 id)
static inline void acquire_bus(struct wilc *wilc, enum bus_acquire acquire)
{
mutex_lock(&wilc->hif_cs);
if (acquire == ACQUIRE_AND_WAKEUP)
if (acquire == WILC_BUS_ACQUIRE_AND_WAKEUP)
chip_wakeup(wilc);
}
static inline void release_bus(struct wilc *wilc, enum bus_release release)
{
if (release == RELEASE_ALLOW_SLEEP)
if (release == WILC_BUS_RELEASE_ALLOW_SLEEP)
chip_allow_sleep(wilc);
mutex_unlock(&wilc->hif_cs);
}
@ -399,7 +399,7 @@ void chip_wakeup(struct wilc *wilc)
{
u32 reg, clk_status_reg;
if ((wilc->io_type & 0x1) == HIF_SPI) {
if ((wilc->io_type & 0x1) == WILC_HIF_SPI) {
do {
wilc->hif_func->hif_read_reg(wilc, 1, &reg);
wilc->hif_func->hif_write_reg(wilc, 1, reg | BIT(1));
@ -410,7 +410,7 @@ void chip_wakeup(struct wilc *wilc)
wilc_get_chipid(wilc, true);
} while (wilc_get_chipid(wilc, true) == 0);
} while (wilc_get_chipid(wilc, true) == 0);
} else if ((wilc->io_type & 0x1) == HIF_SDIO) {
} else if ((wilc->io_type & 0x1) == WILC_HIF_SDIO) {
wilc->hif_func->hif_write_reg(wilc, 0xfa, 1);
usleep_range(200, 400);
wilc->hif_func->hif_read_reg(wilc, 0xf0, &reg);
@ -433,7 +433,7 @@ void chip_wakeup(struct wilc *wilc)
} while ((clk_status_reg & 0x1) == 0);
}
if (wilc->chip_ps_state == CHIP_SLEEPING_MANUAL) {
if (wilc->chip_ps_state == WILC_CHIP_SLEEPING_MANUAL) {
if (wilc_get_chipid(wilc, false) < 0x1002b0) {
u32 val32;
@ -446,37 +446,37 @@ void chip_wakeup(struct wilc *wilc)
wilc->hif_func->hif_write_reg(wilc, 0x1e9c, val32);
}
}
wilc->chip_ps_state = CHIP_WAKEDUP;
wilc->chip_ps_state = WILC_CHIP_WAKEDUP;
}
EXPORT_SYMBOL_GPL(chip_wakeup);
void wilc_chip_sleep_manually(struct wilc *wilc)
{
if (wilc->chip_ps_state != CHIP_WAKEDUP)
if (wilc->chip_ps_state != WILC_CHIP_WAKEDUP)
return;
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
chip_allow_sleep(wilc);
wilc->hif_func->hif_write_reg(wilc, 0x10a8, 1);
wilc->chip_ps_state = CHIP_SLEEPING_MANUAL;
release_bus(wilc, RELEASE_ONLY);
wilc->chip_ps_state = WILC_CHIP_SLEEPING_MANUAL;
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
}
EXPORT_SYMBOL_GPL(wilc_chip_sleep_manually);
void host_wakeup_notify(struct wilc *wilc)
{
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
wilc->hif_func->hif_write_reg(wilc, 0x10b0, 1);
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
}
EXPORT_SYMBOL_GPL(host_wakeup_notify);
void host_sleep_notify(struct wilc *wilc)
{
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
wilc->hif_func->hif_write_reg(wilc, 0x10ac, 1);
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
}
EXPORT_SYMBOL_GPL(host_sleep_notify);
@ -541,7 +541,7 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
goto out;
vmm_table[i] = 0x0;
acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
acquire_bus(wilc, WILC_BUS_ACQUIRE_AND_WAKEUP);
counter = 0;
func = wilc->hif_func;
do {
@ -584,7 +584,7 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
entries = ((reg >> 3) & 0x3f);
break;
}
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
} while (--timeout);
if (timeout <= 0) {
ret = func->hif_write_reg(wilc, WILC_HOST_VMM_CTL, 0x0);
@ -615,7 +615,7 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
goto out_release_bus;
}
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
offset = 0;
i = 0;
@ -667,7 +667,7 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
kfree(tqe);
} while (--entries);
acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
acquire_bus(wilc, WILC_BUS_ACQUIRE_AND_WAKEUP);
ret = func->hif_clear_int_ext(wilc, ENABLE_TX_VMM);
if (!ret)
@ -676,7 +676,7 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
ret = func->hif_block_tx_ext(wilc, 0, txb, offset);
out_release_bus:
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
out:
mutex_unlock(&wilc->txq_add_to_head_cs);
@ -775,7 +775,7 @@ static void wilc_pllupdate_isr_ext(struct wilc *wilc, u32 int_stats)
wilc->hif_func->hif_clear_int_ext(wilc, PLL_INT_CLR);
if (wilc->io_type == HIF_SDIO)
if (wilc->io_type == WILC_HIF_SDIO)
mdelay(WILC_PLL_TO_SDIO);
else
mdelay(WILC_PLL_TO_SPI);
@ -835,7 +835,7 @@ void wilc_handle_isr(struct wilc *wilc)
{
u32 int_status;
acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
acquire_bus(wilc, WILC_BUS_ACQUIRE_AND_WAKEUP);
wilc->hif_func->hif_read_int(wilc, &int_status);
if (int_status & PLL_INT_EXT)
@ -850,7 +850,7 @@ void wilc_handle_isr(struct wilc *wilc)
if (!(int_status & (ALL_INT_EXT)))
wilc_unknown_isr_ext(wilc);
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
}
EXPORT_SYMBOL_GPL(wilc_handle_isr);
@ -874,7 +874,7 @@ int wilc_wlan_firmware_download(struct wilc *wilc, const u8 *buffer,
memcpy(&size, &buffer[offset + 4], 4);
le32_to_cpus(&addr);
le32_to_cpus(&size);
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
offset += 8;
while (((int)size) && (offset < buffer_size)) {
if (size <= blksz)
@ -892,7 +892,7 @@ int wilc_wlan_firmware_download(struct wilc *wilc, const u8 *buffer,
offset += size2;
size -= size2;
}
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
if (!ret) {
ret = -EIO;
@ -913,20 +913,20 @@ int wilc_wlan_start(struct wilc *wilc)
int ret;
u32 chipid;
if (wilc->io_type == HIF_SDIO) {
if (wilc->io_type == WILC_HIF_SDIO) {
reg = 0;
reg |= BIT(3);
} else if (wilc->io_type == HIF_SPI) {
} else if (wilc->io_type == WILC_HIF_SPI) {
reg = 1;
}
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
ret = wilc->hif_func->hif_write_reg(wilc, WILC_VMM_CORE_CFG, reg);
if (!ret) {
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
return -EIO;
}
reg = 0;
if (wilc->io_type == HIF_SDIO && wilc->dev_irq_num)
if (wilc->io_type == WILC_HIF_SDIO && wilc->dev_irq_num)
reg |= WILC_HAVE_SDIO_IRQ_GPIO;
#ifdef WILC_DISABLE_PMU
@ -954,7 +954,7 @@ int wilc_wlan_start(struct wilc *wilc)
ret = wilc->hif_func->hif_write_reg(wilc, WILC_GP_REG_1, reg);
if (!ret) {
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
return -EIO;
}
@ -962,7 +962,7 @@ int wilc_wlan_start(struct wilc *wilc)
ret = wilc->hif_func->hif_read_reg(wilc, 0x1000, &chipid);
if (!ret) {
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
return -EIO;
}
@ -976,7 +976,7 @@ int wilc_wlan_start(struct wilc *wilc)
reg |= BIT(10);
ret = wilc->hif_func->hif_write_reg(wilc, WILC_GLB_RESET_0, reg);
wilc->hif_func->hif_read_reg(wilc, WILC_GLB_RESET_0, &reg);
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
return (ret < 0) ? ret : 0;
}
@ -987,18 +987,18 @@ int wilc_wlan_stop(struct wilc *wilc)
int ret;
u8 timeout = 10;
acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
acquire_bus(wilc, WILC_BUS_ACQUIRE_AND_WAKEUP);
ret = wilc->hif_func->hif_read_reg(wilc, WILC_GLB_RESET_0, &reg);
if (!ret) {
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
return ret;
}
reg &= ~BIT(10);
ret = wilc->hif_func->hif_write_reg(wilc, WILC_GLB_RESET_0, reg);
if (!ret) {
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
return ret;
}
@ -1006,7 +1006,7 @@ int wilc_wlan_stop(struct wilc *wilc)
ret = wilc->hif_func->hif_read_reg(wilc,
WILC_GLB_RESET_0, &reg);
if (!ret) {
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
return ret;
}
@ -1021,7 +1021,7 @@ int wilc_wlan_stop(struct wilc *wilc)
WILC_GLB_RESET_0,
&reg);
if (!ret) {
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
return ret;
}
break;
@ -1036,7 +1036,7 @@ int wilc_wlan_stop(struct wilc *wilc)
ret = wilc->hif_func->hif_write_reg(wilc, WILC_GLB_RESET_0, reg);
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
return ret;
}
@ -1072,18 +1072,18 @@ void wilc_wlan_cleanup(struct net_device *dev)
kfree(wilc->tx_buffer);
wilc->tx_buffer = NULL;
acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
acquire_bus(wilc, WILC_BUS_ACQUIRE_AND_WAKEUP);
ret = wilc->hif_func->hif_read_reg(wilc, WILC_GP_REG_0, &reg);
if (!ret)
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
ret = wilc->hif_func->hif_write_reg(wilc, WILC_GP_REG_0,
(reg | ABORT_INT));
if (!ret)
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, WILC_BUS_RELEASE_ALLOW_SLEEP);
wilc->hif_func->hif_deinit(NULL);
}
@ -1245,7 +1245,7 @@ static u32 init_chip(struct net_device *dev)
struct wilc_vif *vif = netdev_priv(dev);
struct wilc *wilc = vif->wilc;
acquire_bus(wilc, ACQUIRE_ONLY);
acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY);
chipid = wilc_get_chipid(wilc, true);
@ -1268,7 +1268,7 @@ static u32 init_chip(struct net_device *dev)
}
}
release_bus(wilc, RELEASE_ONLY);
release_bus(wilc, WILC_BUS_RELEASE_ONLY);
return ret;
}

128
drivers/staging/wilc1000/wilc_wlan_if.h
View File

@ -15,8 +15,10 @@
*
********************************************/
#define HIF_SDIO (0)
#define HIF_SPI BIT(0)
enum {
WILC_HIF_SDIO = 0,
WILC_HIF_SPI = BIT(0)
};
/********************************************
*
@ -51,51 +53,51 @@ typedef void (*wilc_tx_complete_func_t)(void *, int);
#define MAX_RATES_SUPPORTED 12
enum bss_types {
INFRASTRUCTURE = 0,
INDEPENDENT,
AP,
WILC_FW_BSS_TYPE_INFRA = 0,
WILC_FW_BSS_TYPE_INDEPENDENT,
WILC_FW_BSS_TYPE_AP,
};
enum {
B_ONLY_MODE = 0, /* 1, 2 M, otherwise 5, 11 M */
G_ONLY_MODE, /* 6,12,24 otherwise 9,18,36,48,54 */
G_MIXED_11B_1_MODE, /* 1,2,5.5,11 otherwise all on */
G_MIXED_11B_2_MODE, /* 1,2,5,11,6,12,24 otherwise all on */
WILC_FW_OPER_MODE_B_ONLY = 0, /* 1, 2 M, otherwise 5, 11 M */
WILC_FW_OPER_MODE_G_ONLY, /* 6,12,24 otherwise 9,18,36,48,54 */
WILC_FW_OPER_MODE_G_MIXED_11B_1, /* 1,2,5.5,11 otherwise all on */
WILC_FW_OPER_MODE_G_MIXED_11B_2, /* 1,2,5,11,6,12,24 otherwise all on */
};
enum {
G_SHORT_PREAMBLE = 0, /* Short Preamble */
G_LONG_PREAMBLE = 1, /* Long Preamble */
G_AUTO_PREAMBLE = 2, /* Auto Preamble Selection */
WILC_FW_PREAMBLE_SHORT = 0, /* Short Preamble */
WILC_FW_PREAMBLE_LONG = 1, /* Long Preamble */
WILC_FW_PREAMBLE_AUTO = 2, /* Auto Preamble Selection */
};
enum {
PASSIVE_SCAN = 0,
ACTIVE_SCAN = 1,
WILC_FW_PASSIVE_SCAN = 0,
WILC_FW_ACTIVE_SCAN = 1,
};
enum {
NO_POWERSAVE = 0,
MIN_FAST_PS = 1,
MAX_FAST_PS = 2,
MIN_PSPOLL_PS = 3,
MAX_PSPOLL_PS = 4
WILC_FW_NO_POWERSAVE = 0,
WILC_FW_MIN_FAST_PS = 1,
WILC_FW_MAX_FAST_PS = 2,
WILC_FW_MIN_PSPOLL_PS = 3,
WILC_FW_MAX_PSPOLL_PS = 4
};
enum chip_ps_states {
CHIP_WAKEDUP = 0,
CHIP_SLEEPING_AUTO = 1,
CHIP_SLEEPING_MANUAL = 2
WILC_CHIP_WAKEDUP = 0,
WILC_CHIP_SLEEPING_AUTO = 1,
WILC_CHIP_SLEEPING_MANUAL = 2
};
enum bus_acquire {
ACQUIRE_ONLY = 0,
ACQUIRE_AND_WAKEUP = 1,
WILC_BUS_ACQUIRE_ONLY = 0,
WILC_BUS_ACQUIRE_AND_WAKEUP = 1,
};
enum bus_release {
RELEASE_ONLY = 0,
RELEASE_ALLOW_SLEEP = 1,
WILC_BUS_RELEASE_ONLY = 0,
WILC_BUS_RELEASE_ALLOW_SLEEP = 1,
};
enum {
@ -122,73 +124,73 @@ enum {
};
enum authtype {
OPEN_SYSTEM = 1,
SHARED_KEY = 2,
ANY = 3,
IEEE8021 = 5
WILC_FW_AUTH_OPEN_SYSTEM = 1,
WILC_FW_AUTH_SHARED_KEY = 2,
WILC_FW_AUTH_ANY = 3,
WILC_FW_AUTH_IEEE8021 = 5
};
enum site_survey {
SITE_SURVEY_1CH = 0,
SITE_SURVEY_ALL_CH = 1,
SITE_SURVEY_OFF = 2
WILC_FW_SITE_SURVEY_1CH = 0,
WILC_FW_SITE_SURVEY_ALL_CH = 1,
WILC_FW_SITE_SURVEY_OFF = 2
};
enum {
NORMAL_ACK = 0,
NO_ACK,
WILC_FW_ACK_POLICY_NORMAL = 0,
WILC_FW_ACK_NO_POLICY,
};
enum {
REKEY_DISABLE = 1,
REKEY_TIME_BASE,
REKEY_PKT_BASE,
REKEY_TIME_PKT_BASE
WILC_FW_REKEY_POLICY_DISABLE = 1,
WILC_FW_REKEY_POLICY_TIME_BASE,
WILC_FW_REKEY_POLICY_PKT_BASE,
WILC_FW_REKEY_POLICY_TIME_PKT_BASE
};
enum {
FILTER_NO = 0x00,
FILTER_AP_ONLY = 0x01,
FILTER_STA_ONLY = 0x02
WILC_FW_FILTER_NO = 0x00,
WILC_FW_FILTER_AP_ONLY = 0x01,
WILC_FW_FILTER_STA_ONLY = 0x02
};
enum {
AUTO_PROT = 0, /* Auto */
NO_PROT, /* Do not use any protection */
ERP_PROT, /* Protect all ERP frame exchanges */
HT_PROT, /* Protect all HT frame exchanges */
GF_PROT, /* Protect all GF frame exchanges */
WILC_FW_11N_PROT_AUTO = 0, /* Auto */
WILC_FW_11N_NO_PROT, /* Do not use any protection */
WILC_FW_11N_PROT_ERP, /* Protect all ERP frame exchanges */
WILC_FW_11N_PROT_HT, /* Protect all HT frame exchanges */
WILC_FW_11N_PROT_GF /* Protect all GF frame exchanges */
};
enum {
G_SELF_CTS_PROT,
G_RTS_CTS_PROT,
WILC_FW_ERP_PROT_SELF_CTS,
WILC_FW_ERP_PROT_RTS_CTS,
};
enum {
HT_MIXED_MODE = 1,
HT_ONLY_20MHZ_MODE,
HT_ONLY_20_40MHZ_MODE,
WILC_FW_11N_OP_MODE_HT_MIXED = 1,
WILC_FW_11N_OP_MODE_HT_ONLY_20MHZ,
WILC_FW_11N_OP_MODE_HT_ONLY_20_40MHZ,
};
enum {
NO_DETECT = 0,
DETECT_ONLY = 1,
DETECT_PROTECT = 2,
DETECT_PROTECT_REPORT = 3,
WILC_FW_OBBS_NONHT_NO_DETECT = 0,
WILC_FW_OBBS_NONHT_DETECT_ONLY = 1,
WILC_FW_OBBS_NONHT_DETECT_PROTECT = 2,
WILC_FW_OBBS_NONHT_DETECT_PROTECT_REPORT = 3,
};
enum {
RTS_CTS_NONHT_PROT = 0, /* RTS-CTS at non-HT rate */
FIRST_FRAME_NONHT_PROT, /* First frame at non-HT rate */
LSIG_TXOP_PROT, /* LSIG TXOP Protection */
FIRST_FRAME_MIXED_PROT, /* First frame at Mixed format */
WILC_FW_HT_PROT_RTS_CTS_NONHT = 0, /* RTS-CTS at non-HT rate */
WILC_FW_HT_PROT_FIRST_FRAME_NONHT, /* First frame at non-HT rate */
WILC_FW_HT_PROT_LSIG_TXOP, /* LSIG TXOP Protection */
WILC_FW_HT_PROT_FIRST_FRAME_MIXED, /* First frame at Mixed format */
};
enum {
STATIC_MODE = 1,
DYNAMIC_MODE = 2,
MIMO_MODE = 3, /* power save disable */
WILC_FW_SMPS_MODE_STATIC = 1,
WILC_FW_SMPS_MODE_DYNAMIC = 2,
WILC_FW_SMPS_MODE_MIMO = 3, /* power save disable */
};
enum wid_type {