/**
* @brief Set/Get AP config
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_bss_ioctl_config(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u16 cmd_action = 0;
ENTER();
if (pioctl_req->action == MLAN_ACT_SET)
cmd_action = HostCmd_ACT_GEN_SET;
else
cmd_action = HostCmd_ACT_GEN_GET;
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv, HOST_CMD_APCMD_SYS_CONFIGURE,
cmd_action, 0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief This function enable/disable 11D
*
* @param pmpriv A pointer to mlan_private structure
* @param pioctl_buf A pointer to MLAN IOCTL Request buffer
* @param flag 11D status
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_11d_enable(mlan_private * pmpriv, t_void * pioctl_buf, state_11d_t flag)
{
mlan_adapter *pmadapter = pmpriv->adapter;
wlan_802_11d_state_t *state = &pmadapter->state_11d;
mlan_status ret = MLAN_STATUS_SUCCESS;
state_11d_t enable = flag;
ENTER();
memset(pmadapter, &pmadapter->parsed_region_chan, 0,
sizeof(parsed_region_chan_11d_t));
/* Send cmd to FW to enable/disable 11D function */
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_SNMP_MIB,
HostCmd_ACT_GEN_SET,
Dot11D_i, (t_void *) pioctl_buf, &enable);
if (ret) {
if (flag)
PRINTM(MERROR, "11D: Failed to enable 11D\n");
else
PRINTM(MERROR, "11D: Failed to disable 11D\n");
} else {
state->enable_11d = flag;
/* Set user enable flag if called from ioctl */
if (pioctl_buf)
state->user_enable_11d = flag;
}
LEAVE();
return ret;
}
/**
* @brief This function enable/disable 11D
*
* @param pmpriv A pointer to mlan_private structure
* @param pioctl_buf A pointer to MLAN IOCTL Request buffer
* @param flag 11D status
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_11d_enable(mlan_private * pmpriv, t_void * pioctl_buf, state_11d_t flag)
{
#ifdef STA_SUPPORT
mlan_adapter *pmadapter = pmpriv->adapter;
#endif
mlan_status ret = MLAN_STATUS_SUCCESS;
state_11d_t enable = flag;
ENTER();
/* Send cmd to FW to enable/disable 11D function */
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_SNMP_MIB,
HostCmd_ACT_GEN_SET,
Dot11D_i, (t_void *) pioctl_buf, &enable);
if (ret) {
PRINTM(MERROR, "11D: Failed to %s 11D\n",
(flag) ? "enable" : "disable");
}
#ifdef STA_SUPPORT
else {
/* clear parsed table regardless of flag */
memset(pmadapter, &(pmadapter->parsed_region_chan), 0,
sizeof(parsed_region_chan_11d_t));
}
#endif
LEAVE();
return ret;
}
/**
* @brief send host cmd
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
mlan_status
wlan_misc_ioctl_host_cmd(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_num];
mlan_ds_misc_cfg *misc = MNULL;
ENTER();
misc = (mlan_ds_misc_cfg *) pioctl_req->pbuf;
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv,
0,
0,
0,
(t_void *) pioctl_req,
(t_void *) & misc->param.hostcmd);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief This function will send a block ack to given tid/ra
*
* @param priv A pointer to mlan_private
* @param tid TID to send the ADDBA
* @param peer_mac MAC address to send the ADDBA
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
int
wlan_send_addba(mlan_private * priv, int tid, t_u8 * peer_mac)
{
HostCmd_DS_11N_ADDBA_REQ add_ba_req;
static t_u8 dialog_tok;
mlan_status ret;
ENTER();
PRINTM(MCMND, "Send addba: TID %d\n", tid);
DBG_HEXDUMP(MCMD_D, "Send addba RA", peer_mac, MLAN_MAC_ADDR_LENGTH);
add_ba_req.block_ack_param_set = (t_u16) ((tid << BLOCKACKPARAM_TID_POS) |
(priv->add_ba_param.tx_win_size
<< BLOCKACKPARAM_WINSIZE_POS) |
IMMEDIATE_BLOCK_ACK);
add_ba_req.block_ack_tmo = (t_u16) priv->add_ba_param.timeout;
++dialog_tok;
if (dialog_tok == 0)
dialog_tok = 1;
add_ba_req.dialog_token = dialog_tok;
memcpy(priv->adapter, &add_ba_req.peer_mac_addr, peer_mac,
MLAN_MAC_ADDR_LENGTH);
/* We don't wait for the response of this command */
ret = wlan_prepare_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ,
0, 0, MNULL, &add_ba_req);
LEAVE();
return ret;
}
/**
* @brief Set/Get MAC address
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_bss_ioctl_mac_address(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_ds_bss *bss = MNULL;
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u16 cmd_action = 0;
ENTER();
bss = (mlan_ds_bss *) pioctl_req->pbuf;
if (pioctl_req->action == MLAN_ACT_SET) {
memcpy(pmadapter, pmpriv->curr_addr, &bss->param.mac_addr,
MLAN_MAC_ADDR_LENGTH);
cmd_action = HostCmd_ACT_GEN_SET;
} else
cmd_action = HostCmd_ACT_GEN_GET;
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv, HOST_CMD_APCMD_SYS_CONFIGURE,
cmd_action, 0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Send function init/shutdown command to firmware
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
mlan_status
wlan_misc_ioctl_init_shutdown(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_num];
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_ds_misc_cfg *misc_cfg = MNULL;
t_u16 cmd;
ENTER();
misc_cfg = (mlan_ds_misc_cfg *) pioctl_req->pbuf;
if (misc_cfg->param.func_init_shutdown == MLAN_FUNC_INIT)
cmd = HostCmd_CMD_FUNC_INIT;
else if (misc_cfg->param.func_init_shutdown == MLAN_FUNC_SHUTDOWN)
cmd = HostCmd_CMD_FUNC_SHUTDOWN;
else {
PRINTM(MERROR, "Unsupported parameter\n");
ret = MLAN_STATUS_FAILURE;
goto exit;
}
/* Send command to firmware */
ret = wlan_prepare_cmd(pmpriv,
cmd,
HostCmd_ACT_GEN_SET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
exit:
LEAVE();
return ret;
}
/**
* @brief Set encrypt key
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_sec_ioctl_set_encrypt_key(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_ds_sec_cfg *sec = MNULL;
ENTER();
sec = (mlan_ds_sec_cfg *) pioctl_req->pbuf;
if (pioctl_req->action != MLAN_ACT_SET) {
pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID;
LEAVE();
return MLAN_STATUS_FAILURE;
}
if (!sec->param.encrypt_key.key_len) {
PRINTM(MCMND, "Skip set key with key_len = 0\n");
LEAVE();
return ret;
}
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_KEY_MATERIAL,
HostCmd_ACT_GEN_SET,
KEY_INFO_ENABLED,
(t_void *) pioctl_req, &sec->param.encrypt_key);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Issue CMD to UAP firmware to get current beacon and dtim periods
*
* @param pmpriv A pointer to mlan_private structure
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
mlan_status
wlan_uap_get_beacon_dtim(IN pmlan_private pmpriv)
{
t_u8 tlv_buffer[sizeof(MrvlIEtypes_beacon_period_t) +
sizeof(MrvlIEtypes_dtim_period_t)];
MrvlIEtypes_beacon_period_t *ptlv_beacon_pd;
MrvlIEtypes_dtim_period_t *ptlv_dtim_pd;
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
memset(pmpriv->adapter, &tlv_buffer, 0, sizeof(tlv_buffer));
ptlv_beacon_pd = (MrvlIEtypes_beacon_period_t *) tlv_buffer;
ptlv_beacon_pd->header.type = TLV_TYPE_UAP_BEACON_PERIOD;
ptlv_beacon_pd->header.len = sizeof(MrvlIEtypes_beacon_period_t)
- sizeof(MrvlIEtypesHeader_t);
ptlv_dtim_pd = (MrvlIEtypes_dtim_period_t *) (tlv_buffer
+
sizeof
(MrvlIEtypes_beacon_period_t));
ptlv_dtim_pd->header.type = TLV_TYPE_UAP_DTIM_PERIOD;
ptlv_dtim_pd->header.len = sizeof(MrvlIEtypes_dtim_period_t)
- sizeof(MrvlIEtypesHeader_t);
ret = wlan_prepare_cmd(pmpriv, HOST_CMD_APCMD_SYS_CONFIGURE,
HostCmd_ACT_GEN_GET, 0, MNULL, tlv_buffer);
LEAVE();
return ret;
}
/**
* @brief Set the local power constraint in the firmware
*
* Construct and send a CMD_802_11_TPC_INFO command with the local power
* constraint.
*
* @param priv Private driver information structure
* @param channel Channel to which the power constraint applies
* @param power_constraint Power constraint to be applied on the channel
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static int
wlan_11h_set_local_power_constraint(mlan_private * priv,
t_u8 channel, t_u8 power_constraint)
{
int ret = MLAN_STATUS_SUCCESS;
wlan_11h_tpc_info_param_t tpc_info_param;
ENTER();
tpc_info_param.chan = channel;
tpc_info_param.power_constraint = power_constraint;
PRINTM(MINFO, "11h: Set Local Constraint = %d\n",
tpc_info_param.power_constraint);
ret = wlan_prepare_cmd(priv, HostCmd_CMD_802_11_TPC_INFO,
HostCmd_ACT_GEN_SET, 0, 0, &tpc_info_param);
if (ret) {
PRINTM(MINFO, "11h: Err: Send TPC_INFO CMD: %d\n", ret);
ret = MLAN_STATUS_FAILURE;
}
LEAVE();
return ret;
}
/**
* @brief Enable or Disable the 11h extensions in the firmware
*
* @param priv Private driver information structure
* @param flag Enable 11h if MTRUE, disable otherwise
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
int
wlan_11h_activate(mlan_private * priv, t_u32 flag)
{
wlan_11h_state_t *pstate_11h = &priv->adapter->state_11h;
int enable = flag ? 1 : 0;
int ret = MLAN_STATUS_SUCCESS;
ENTER();
/*
* Send cmd to FW to enable/disable 11h function in firmware
*/
ret = wlan_prepare_cmd(priv,
HostCmd_CMD_802_11_SNMP_MIB,
HostCmd_ACT_GEN_SET, Dot11H_i, MNULL, &enable);
if (ret)
ret = MLAN_STATUS_FAILURE;
else
/* Set boolean flag in driver 11h state */
pstate_11h->is_11h_active = flag;
PRINTM(MINFO, "11h: %s\n", enable ? "Activate" : "Deactivate");
LEAVE();
return ret;
}
/**
* @brief Set encrypt key
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
static mlan_status
wlan_uap_sec_ioctl_set_encrypt_key(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_num];
mlan_ds_sec_cfg *sec = MNULL;
ENTER();
sec = (mlan_ds_sec_cfg *) pioctl_req->pbuf;
if (pioctl_req->action != MLAN_ACT_SET) {
LEAVE();
return MLAN_STATUS_FAILURE;
}
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_KEY_MATERIAL,
HostCmd_ACT_GEN_SET,
KEY_INFO_ENABLED,
(t_void *) pioctl_req, &sec->param.encrypt_key);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief This function disables Host Sleep.
*
* @param priv A pointer to wlan_private
* @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE
*/
int
wlan_disable_hs(wlan_private * priv)
{
wlan_adapter *Adapter = priv->adapter;
HostCmd_DS_802_11_HOST_SLEEP_CFG hscfg;
int ret = WLAN_STATUS_SUCCESS;
ENTER();
if (Adapter->HS_Activated) {
hscfg.conditions = HOST_SLEEP_CFG_CANCEL;
hscfg.gpio = Adapter->HSCfg.gpio;
hscfg.gap = Adapter->HSCfg.gap;
ret = wlan_prepare_cmd(priv,
HostCmd_CMD_802_11_HOST_SLEEP_CFG,
0, HostCmd_OPTION_WAITFORRSP, 0, &hscfg);
} else {
PRINTM(MSG,
"wlan_disable_hs: already de-activated:%d, %d, %d, %d, %d\n",
Adapter->MediaConnectStatus, Adapter->PSState,
Adapter->bWakeupDevRequired, Adapter->WakeupTries,
Adapter->HS_Activated);
}
LEAVE();
return ret;
}
/**
* @brief This function reconfigure the tx buf size in firmware.
*
* @param pmpriv A pointer to mlan_private structure
* @param pbss_desc BSSDescriptor_t from the scan table to assoc
*
* @return N/A
*/
void
wlan_cfg_tx_buf(mlan_private * pmpriv, BSSDescriptor_t * pbss_desc)
{
t_u16 max_amsdu = MLAN_TX_DATA_BUF_SIZE_2K;
t_u16 tx_buf = 0;
t_u16 curr_tx_buf_size = 0;
ENTER();
if (pbss_desc->pht_cap) {
if (GETHT_MAXAMSDU(pbss_desc->pht_cap->ht_cap.ht_cap_info))
max_amsdu = MLAN_TX_DATA_BUF_SIZE_8K;
else
max_amsdu = MLAN_TX_DATA_BUF_SIZE_4K;
}
tx_buf = MIN(pmpriv->adapter->max_tx_buf_size, max_amsdu);
PRINTM(MINFO, "max_amsdu=%d, maxTxBuf=%d\n", max_amsdu,
pmpriv->adapter->max_tx_buf_size);
if (pmpriv->adapter->curr_tx_buf_size <= MLAN_TX_DATA_BUF_SIZE_2K)
curr_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_2K;
else if (pmpriv->adapter->curr_tx_buf_size <= MLAN_TX_DATA_BUF_SIZE_4K)
curr_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_4K;
else if (pmpriv->adapter->curr_tx_buf_size <= MLAN_TX_DATA_BUF_SIZE_8K)
curr_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_8K;
if (curr_tx_buf_size != tx_buf) {
wlan_prepare_cmd(pmpriv, HostCmd_CMD_RECONFIGURE_TX_BUFF,
HostCmd_ACT_GEN_SET, 0, MNULL, &tx_buf);
}
LEAVE();
return;
}
/**
* @brief Set/get 11n configuration
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
static mlan_status
wlan_11n_ioctl_httxcfg(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_num];
mlan_ds_11n_cfg *cfg = MNULL;
t_u16 cmd_action = 0;
ENTER();
cfg = (mlan_ds_11n_cfg *) pioctl_req->pbuf;
if (pioctl_req->action == MLAN_ACT_SET)
cmd_action = HostCmd_ACT_GEN_SET;
else
cmd_action = HostCmd_ACT_GEN_GET;
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_11N_CFG,
cmd_action,
0,
(t_void *) pioctl_req,
(t_void *) & cfg->param.tx_cfg);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief This function will delete a block ack to given tid/ra
*
* @param priv A pointer to mlan_private
* @param tid TID to send the ADDBA
* @param peer_mac MAC address to send the ADDBA
* @param initiator MTRUE if we have initiated ADDBA, MFALSE otherwise
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
int
wlan_send_delba(mlan_private * priv, int tid, t_u8 * peer_mac, int initiator)
{
HostCmd_DS_11N_DELBA delba;
mlan_status ret;
ENTER();
memset(priv->adapter, &delba, 0, sizeof(delba));
delba.del_ba_param_set = (tid << DELBA_TID_POS);
if (initiator)
DELBA_INITIATOR(delba.del_ba_param_set);
else
DELBA_RECIPIENT(delba.del_ba_param_set);
memcpy(priv->adapter, &delba.peer_mac_addr, peer_mac, MLAN_MAC_ADDR_LENGTH);
/* We don't wait for the response of this command */
ret = wlan_prepare_cmd(priv, HostCmd_CMD_11N_DELBA,
HostCmd_ACT_GEN_SET, 0, MNULL, &delba);
LEAVE();
return ret;
}
/**
* @brief Tx data pause
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_misc_ioctl_txdatapause(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_ds_misc_cfg *pmisc = (mlan_ds_misc_cfg *) pioctl_req->pbuf;
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u16 cmd_action = 0;
ENTER();
if (pioctl_req->action == MLAN_ACT_SET)
cmd_action = HostCmd_ACT_GEN_SET;
else
cmd_action = HostCmd_ACT_GEN_GET;
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_CFG_TX_DATA_PAUSE,
cmd_action,
0,
(t_void *) pioctl_req, &(pmisc->param.tx_datapause));
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief This function cleans module
*
* @return n/a
*/
static void
wlan_cleanup_module(void)
{
wlan_private *priv = wlanpriv;
wlan_adapter *Adapter = NULL;
ENTER();
if (OS_ACQ_SEMAPHORE_BLOCK(&AddRemoveCardSem))
goto exit_sem_err;
if (!priv || !priv->adapter)
goto exit;
Adapter = priv->adapter;
/* Exit deep sleep */
wlan_exit_deep_sleep_timeout(priv);
if (Adapter->MediaConnectStatus == WlanMediaStateConnected)
wlan_disconnect(priv);
wlan_prepare_cmd(priv, HostCmd_CMD_FUNC_SHUTDOWN,
0, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT,
0, NULL);
/* Disable interrupts on the card */
sbi_disable_host_int(priv);
exit:
OS_REL_SEMAPHORE(&AddRemoveCardSem);
exit_sem_err:
sbi_unregister();
LEAVE();
}
/**
* @brief This function issues commands to initialize firmware
*
* @param priv A pointer to mlan_private structure
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_set_sdio_gpio_int(IN pmlan_private priv)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_adapter pmadapter = priv->adapter;
HostCmd_DS_SDIO_GPIO_INT_CONFIG sdio_int_cfg;
ENTER();
if (pmadapter->int_mode == INT_MODE_GPIO) {
PRINTM(MINFO, "SDIO_GPIO_INT_CONFIG: interrupt mode is GPIO\n");
sdio_int_cfg.action = HostCmd_ACT_GEN_SET;
sdio_int_cfg.gpio_pin = pmadapter->gpio_pin;
sdio_int_cfg.gpio_int_edge = INT_FALLING_EDGE;
sdio_int_cfg.gpio_pulse_width = DELAY_1_US;
ret = wlan_prepare_cmd(priv, HostCmd_CMD_SDIO_GPIO_INT_CONFIG,
HostCmd_ACT_GEN_SET, 0, MNULL,
&sdio_int_cfg);
if (ret) {
PRINTM(MERROR,
"SDIO_GPIO_INT_CONFIG: send command fail\n");
ret = MLAN_STATUS_FAILURE;
}
} else {
PRINTM(MINFO, "SDIO_GPIO_INT_CONFIG: interrupt mode is SDIO\n");
}
LEAVE();
return ret;
}
/**
* @brief This function sets the MAC address to firmware.
*
* @param dev A pointer to wlan_private structure
* @param addr MAC address to set
* @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE
*/
static int
wlan_set_mac_address(struct net_device *dev, void *addr)
{
int ret = WLAN_STATUS_SUCCESS;
wlan_private *priv = (wlan_private *) netdev_priv(dev);
wlan_adapter *Adapter = priv->adapter;
struct sockaddr *pHwAddr = (struct sockaddr *) addr;
ENTER();
memset(Adapter->CurrentAddr, 0, ETH_ALEN);
/* dev->dev_addr is 8 bytes */
HEXDUMP("dev->dev_addr:", dev->dev_addr, ETH_ALEN);
HEXDUMP("addr:", pHwAddr->sa_data, ETH_ALEN);
memcpy(Adapter->CurrentAddr, pHwAddr->sa_data, ETH_ALEN);
ret = wlan_prepare_cmd(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
HostCmd_ACT_GEN_SET,
HostCmd_OPTION_WAITFORRSP, 0, NULL);
if (ret) {
PRINTM(INFO, "set mac address failed\n");
ret = WLAN_STATUS_FAILURE;
goto done;
}
HEXDUMP("Adapter->MacAddr:", Adapter->CurrentAddr, ETH_ALEN);
memcpy(dev->dev_addr, Adapter->CurrentAddr, ETH_ALEN);
done:
LEAVE();
return ret;
}
/**
* @brief Set/Get Power mode
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_pm_ioctl_mode(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_ds_pm_cfg *pm = MNULL;
mlan_status ret = MLAN_STATUS_SUCCESS;
t_u16 cmd_action = 0;
t_u32 cmd_oid = 0;
ENTER();
pm = (mlan_ds_pm_cfg *) pioctl_req->pbuf;
if (pioctl_req->action == MLAN_ACT_SET) {
if (pm->param.ps_mgmt.ps_mode == PS_MODE_INACTIVITY) {
cmd_action = EN_AUTO_PS;
cmd_oid = BITMAP_UAP_INACT_PS;
} else if (pm->param.ps_mgmt.ps_mode == PS_MODE_PERIODIC_DTIM) {
cmd_action = EN_AUTO_PS;
cmd_oid = BITMAP_UAP_DTIM_PS;
} else {
cmd_action = DIS_AUTO_PS;
cmd_oid = BITMAP_UAP_INACT_PS | BITMAP_UAP_DTIM_PS;
}
} else {
cmd_action = GET_PS;
cmd_oid = BITMAP_UAP_INACT_PS | BITMAP_UAP_DTIM_PS;
}
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_PS_MODE_ENH,
cmd_action, cmd_oid, (t_void *) pioctl_req,
(t_void *) & pm->param.ps_mgmt);
if ((ret == MLAN_STATUS_SUCCESS) &&
(pioctl_req->action == MLAN_ACT_SET) &&
(cmd_action == DIS_AUTO_PS)) {
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_PS_MODE_ENH, GET_PS,
0, MNULL, MNULL);
}
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Set Host Sleep configurations
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
static mlan_status
wlan_uap_pm_ioctl_deepsleep(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_num];
mlan_ds_pm_cfg *pm = MNULL;
mlan_ds_auto_ds auto_ds;
t_u32 mode;
ENTER();
if (pioctl_req->buf_len < sizeof(mlan_ds_pm_cfg)) {
PRINTM(MWARN, "MLAN bss IOCTL length is too short.\n");
pioctl_req->data_read_written = 0;
pioctl_req->buf_len_needed = sizeof(mlan_ds_pm_cfg);
LEAVE();
return MLAN_STATUS_RESOURCE;
}
pm = (mlan_ds_pm_cfg *) pioctl_req->pbuf;
if (pioctl_req->action == MLAN_ACT_GET) {
if (pmadapter->is_deep_sleep)
pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_ON;
else
pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_OFF;
} else {
if (((mlan_ds_pm_cfg *) pioctl_req->pbuf)->param.auto_deep_sleep.
auto_ds == DEEP_SLEEP_ON) {
auto_ds.auto_ds = DEEP_SLEEP_ON;
mode = EN_AUTO_PS;
PRINTM(MINFO, "Auto Deep Sleep: on\n");
} else {
mode = DIS_AUTO_PS;
auto_ds.auto_ds = DEEP_SLEEP_OFF;
PRINTM(MINFO, "Auto Deep Sleep: off\n");
}
auto_ds.idletime =
((mlan_ds_pm_cfg *) pioctl_req->pbuf)->param.auto_deep_sleep.
idletime;
ret =
wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, mode,
BITMAP_AUTO_DS, (t_void *) pioctl_req, &auto_ds);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
}
LEAVE();
return ret;
}
/**
* @brief Issue CMD to UAP firmware to get current channel
*
* @param pmpriv A pointer to mlan_private structure
*
* @return MLAN_STATUS_SUCCESS --success, otherwise fail
*/
mlan_status
wlan_uap_get_channel(IN pmlan_private pmpriv)
{
MrvlIEtypes_channel_band_t tlv_chan_band;
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
memset(pmpriv->adapter, &tlv_chan_band, 0, sizeof(tlv_chan_band));
tlv_chan_band.header.type = TLV_TYPE_UAP_CHAN_BAND_CONFIG;
tlv_chan_band.header.len = sizeof(MrvlIEtypes_channel_band_t)
- sizeof(MrvlIEtypesHeader_t);
ret = wlan_prepare_cmd(pmpriv, HOST_CMD_APCMD_SYS_CONFIGURE,
HostCmd_ACT_GEN_GET, 0, MNULL, &tlv_chan_band);
LEAVE();
return ret;
}
/**
* @brief This function sets domain info to FW
*
* @param pmpriv A pointer to mlan_private structure
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
static mlan_status
wlan_11d_set_domain_info(mlan_private * pmpriv)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
/* Send cmd to FW to set domain info */
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11D_DOMAIN_INFO,
HostCmd_ACT_GEN_SET, 0, MNULL, MNULL);
if (ret)
PRINTM(MERROR, "11D: Failed to download domain Info\n");
LEAVE();
return ret;
}
/**
* @brief Get Uap statistics
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_get_stats(IN pmlan_adapter pmadapter, IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index];
ENTER();
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_802_11_SNMP_MIB,
HostCmd_ACT_GEN_GET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Set WAPI IE
*
* @param priv A pointer to mlan_private structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_set_wapi_ie(mlan_private * priv, pmlan_ioctl_req pioctl_req)
{
mlan_ds_misc_cfg *misc = MNULL;
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
misc = (mlan_ds_misc_cfg *) pioctl_req->pbuf;
if (misc->param.gen_ie.len) {
if (misc->param.gen_ie.len > sizeof(priv->wapi_ie)) {
PRINTM(MWARN, "failed to copy WAPI IE, too big \n");
pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER;
LEAVE();
return MLAN_STATUS_FAILURE;
}
memcpy(priv->adapter, priv->wapi_ie, misc->param.gen_ie.ie_data,
misc->param.gen_ie.len);
priv->wapi_ie_len = misc->param.gen_ie.len;
PRINTM(MIOCTL, "Set wapi_ie_len=%d IE=%#x\n", priv->wapi_ie_len,
priv->wapi_ie[0]);
DBG_HEXDUMP(MCMD_D, "wapi_ie", priv->wapi_ie,
priv->wapi_ie_len);
if (priv->wapi_ie[0] == WAPI_IE)
priv->sec_info.wapi_enabled = MTRUE;
} else {
memset(priv->adapter, priv->wapi_ie, 0, sizeof(priv->wapi_ie));
priv->wapi_ie_len = misc->param.gen_ie.len;
PRINTM(MINFO, "Reset wapi_ie_len=%d IE=%#x\n",
priv->wapi_ie_len, priv->wapi_ie[0]);
priv->sec_info.wapi_enabled = MFALSE;
}
/* Send request to firmware */
ret = wlan_prepare_cmd(priv, HOST_CMD_APCMD_SYS_CONFIGURE,
HostCmd_ACT_GEN_SET, 0, (t_void *) pioctl_req,
MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief soft_reset
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_misc_ioctl_soft_reset(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
ret = wlan_prepare_cmd(pmpriv,
HostCmd_CMD_SOFT_RESET,
HostCmd_ACT_GEN_SET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Stop BSS
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_bss_ioctl_stop(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index];
ENTER();
ret = wlan_prepare_cmd(pmpriv,
HOST_CMD_APCMD_BSS_STOP,
HostCmd_ACT_GEN_SET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief reset BSS
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_bss_ioctl_reset(IN pmlan_adapter pmadapter,
IN pmlan_ioctl_req pioctl_req)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index];
t_u8 i = 0;
ENTER();
/*
* Reset any uap private parameters here
*/
for (i = 0; i < pmadapter->max_mgmt_ie_index; i++) {
memset(pmadapter, &pmpriv->mgmt_ie[i], 0, sizeof(custom_ie));
}
pmpriv->add_ba_param.timeout = MLAN_DEFAULT_BLOCK_ACK_TIMEOUT;
pmpriv->add_ba_param.tx_win_size = MLAN_UAP_AMPDU_DEF_TXWINSIZE;
pmpriv->add_ba_param.rx_win_size = MLAN_UAP_AMPDU_DEF_RXWINSIZE;
for (i = 0; i < MAX_NUM_TID; i++) {
pmpriv->aggr_prio_tbl[i].ampdu_user = tos_to_tid_inv[i];
pmpriv->aggr_prio_tbl[i].amsdu = BA_STREAM_NOT_ALLOWED;
pmpriv->addba_reject[i] = ADDBA_RSP_STATUS_ACCEPT;
}
pmpriv->aggr_prio_tbl[6].ampdu_user =
pmpriv->aggr_prio_tbl[7].ampdu_user = BA_STREAM_NOT_ALLOWED;
/* hs_configured, hs_activated are reset by main loop */
pmadapter->hs_cfg.conditions = HOST_SLEEP_DEF_COND;
pmadapter->hs_cfg.gpio = HOST_SLEEP_DEF_GPIO;
pmadapter->hs_cfg.gap = HOST_SLEEP_DEF_GAP;
ret = wlan_prepare_cmd(pmpriv,
HOST_CMD_APCMD_SYS_RESET,
HostCmd_ACT_GEN_SET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
/**
* @brief Get station list
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pioctl_req A pointer to ioctl request buffer
*
* @return MLAN_STATUS_PENDING --success, otherwise fail
*/
static mlan_status
wlan_uap_get_sta_list(IN pmlan_adapter pmadapter, IN pmlan_ioctl_req pioctl_req)
{
pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index];
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
/* Send request to firmware */
ret = wlan_prepare_cmd(pmpriv,
HOST_CMD_APCMD_STA_LIST,
HostCmd_ACT_GEN_GET,
0, (t_void *) pioctl_req, MNULL);
if (ret == MLAN_STATUS_SUCCESS)
ret = MLAN_STATUS_PENDING;
LEAVE();
return ret;
}
