/** * @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; }