自学教程：C++ wlan_prepare_cmd函数代码示例

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