/** @file mlan_sta_ioctl.c * * @brief This file contains the functions for station ioctl. * * * Copyright 2008-2022 NXP * * NXP CONFIDENTIAL * The source code contained or described herein and all documents related to * the source code (Materials) are owned by NXP, its * suppliers and/or its licensors. Title to the Materials remains with NXP, * its suppliers and/or its licensors. The Materials contain * trade secrets and proprietary and confidential information of NXP, its * suppliers and/or its licensors. The Materials are protected by worldwide * copyright and trade secret laws and treaty provisions. No part of the * Materials may be used, copied, reproduced, modified, published, uploaded, * posted, transmitted, distributed, or disclosed in any way without NXP's * prior express written permission. * * No license under any patent, copyright, trade secret or other intellectual * property right is granted to or conferred upon you by disclosure or delivery * of the Materials, either expressly, by implication, inducement, estoppel or * otherwise. Any license under such intellectual property rights must be * express and approved by NXP in writing. * * Alternatively, this software may be distributed under the terms of GPL v2. * SPDX-License-Identifier: GPL-2.0 * * */ /****************************************************** Change log: 10/21/2008: initial version ******************************************************/ #include "mlan.h" #include "mlan_join.h" #include "mlan_util.h" #include "mlan_fw.h" #include "mlan_main.h" #include "mlan_wmm.h" #include "mlan_11n.h" #include "mlan_11ac.h" #include "mlan_11ax.h" #include "mlan_11h.h" #ifdef DRV_EMBEDDED_SUPPLICANT #include "authenticator_api.h" #endif /******************************************************** Local Variables ********************************************************/ /******************************************************** Global Variables ********************************************************/ /******************************************************** Local Functions ********************************************************/ /** * @brief Get signal information * * @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_get_info_signal(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); if (pioctl_req != MNULL) { pmpriv = pmadapter->priv[pioctl_req->bss_index]; } else { PRINTM(MERROR, "MLAN IOCTL information is not present\n"); ret = MLAN_STATUS_FAILURE; goto exit; } /* Check information buffer length of MLAN IOCTL */ if (pioctl_req->buf_len < sizeof(mlan_ds_get_signal)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_get_signal); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } /* Signal info can be obtained only if connected */ if (pmpriv->media_connected == MFALSE) { PRINTM(MINFO, "Can not get signal in disconnected state\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_RSSI_INFO, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Get signal information * * @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_get_info_signal_ext(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_get_info *info = MNULL; ENTER(); if (pioctl_req != MNULL) { pmpriv = pmadapter->priv[pioctl_req->bss_index]; } else { PRINTM(MERROR, "MLAN IOCTL information is not present\n"); ret = MLAN_STATUS_FAILURE; goto exit; } info = (mlan_ds_get_info *)pioctl_req->pbuf; /* Check information buffer length of MLAN IOCTL */ if (pioctl_req->buf_len < sizeof(mlan_ds_get_info)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_get_info); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_RSSI_INFO_EXT, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, (t_void *)info); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Get statistics information * * @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_get_info_stats(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); if (pioctl_req != MNULL) { pmpriv = pmadapter->priv[pioctl_req->bss_index]; } else { PRINTM(MERROR, "MLAN IOCTL information is not present\n"); ret = MLAN_STATUS_FAILURE; goto exit; } /* Check information buffer length of MLAN IOCTL */ if (pioctl_req->buf_len < sizeof(mlan_ds_get_stats)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_get_stats); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_GET_LOG, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Get sta channel information * * @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_bss_ioctl_get_chan_info(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); if (pioctl_req != MNULL) { pmpriv = pmadapter->priv[pioctl_req->bss_index]; } else { PRINTM(MERROR, "MLAN IOCTL information is not present\n"); ret = MLAN_STATUS_FAILURE; goto exit; } /* Check information buffer length of MLAN IOCTL */ if (pioctl_req->buf_len < sizeof(chan_band_info)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(chan_band_info); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_STA_CONFIGURE, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Get BSS information * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_get_info_bss_info(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_get_info *info; BSSDescriptor_t *pbss_desc; t_s32 tbl_idx = 0; ENTER(); /* Get current BSS info */ pbss_desc = &pmpriv->curr_bss_params.bss_descriptor; info = (mlan_ds_get_info *)pioctl_req->pbuf; /* BSS mode */ info->param.bss_info.bss_mode = pmpriv->bss_mode; /* SSID */ memcpy_ext(pmadapter, &info->param.bss_info.ssid, &pbss_desc->ssid, sizeof(mlan_802_11_ssid), sizeof(mlan_802_11_ssid)); /* BSSID */ memcpy_ext(pmadapter, &info->param.bss_info.bssid, &pbss_desc->mac_address, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); /* Channel */ info->param.bss_info.bss_chan = pbss_desc->channel; /* Beacon interval */ info->param.bss_info.beacon_interval = pbss_desc->beacon_period; /* Band */ info->param.bss_info.bss_band = (t_u8)pbss_desc->bss_band; /* Region code */ info->param.bss_info.region_code = pmadapter->region_code; /* Scan table index if connected */ info->param.bss_info.scan_table_idx = 0; info->param.bss_info.scan_block = pmadapter->scan_block; if (pmpriv->media_connected == MTRUE) { tbl_idx = wlan_find_ssid_in_list(pmpriv, &pbss_desc->ssid, pbss_desc->mac_address, pmpriv->bss_mode); if (tbl_idx >= 0) info->param.bss_info.scan_table_idx = tbl_idx; } /* Connection status */ info->param.bss_info.media_connected = pmpriv->media_connected; /* Radio status */ info->param.bss_info.radio_on = pmadapter->radio_on; /* Tx power information */ info->param.bss_info.max_power_level = pmpriv->max_tx_power_level; info->param.bss_info.min_power_level = pmpriv->min_tx_power_level; /* AdHoc state */ info->param.bss_info.adhoc_state = pmpriv->adhoc_state; /* Last beacon NF */ info->param.bss_info.bcn_nf_last = pmpriv->bcn_nf_last; /* wep status */ if (pmpriv->sec_info.wep_status == Wlan802_11WEPEnabled) info->param.bss_info.wep_status = MTRUE; else info->param.bss_info.wep_status = MFALSE; info->param.bss_info.is_hs_configured = pmadapter->is_hs_configured; info->param.bss_info.is_deep_sleep = pmadapter->is_deep_sleep; /* Capability Info */ info->param.bss_info.capability_info = 0; memcpy_ext(pmadapter, &info->param.bss_info.capability_info, &pbss_desc->cap_info, sizeof(info->param.bss_info.capability_info), sizeof(info->param.bss_info.capability_info)); memset(pmadapter, &info->param.bss_info.ext_cap, 0, sizeof(ExtCap_t)); if (pbss_desc->pext_cap) { memcpy_ext(pmadapter, &info->param.bss_info.ext_cap, (t_u8 *)pbss_desc->pext_cap + sizeof(IEEEtypes_Header_t), pbss_desc->pext_cap->ieee_hdr.len, sizeof(info->param.bss_info.ext_cap)); } /* Listen Interval */ info->param.bss_info.listen_interval = pmpriv->listen_interval; /* Association ID */ info->param.bss_info.assoc_id = (t_u16)((IEEEtypes_AssocRsp_t *)pmpriv->assoc_rsp_buf)->a_id; /* AP/Peer supported rates */ memset(pmadapter, info->param.bss_info.peer_supp_rates, 0, sizeof(info->param.bss_info.peer_supp_rates)); memcpy_ext(pmadapter, info->param.bss_info.peer_supp_rates, pbss_desc->supported_rates, sizeof(pbss_desc->supported_rates), sizeof(info->param.bss_info.peer_supp_rates)); if (pbss_desc->pmd_ie) { info->param.bss_info.mdid = pbss_desc->pmd_ie->mdid; info->param.bss_info.ft_cap = pbss_desc->pmd_ie->ft_cap; } pioctl_req->data_read_written = sizeof(mlan_bss_info) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Get information handler * * @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_get_info_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_get_info *pget_info = MNULL; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); pget_info = (mlan_ds_get_info *)pioctl_req->pbuf; switch (pget_info->sub_command) { case MLAN_OID_GET_STATS: status = wlan_get_info_stats(pmadapter, pioctl_req); break; case MLAN_OID_GET_SIGNAL: status = wlan_get_info_signal(pmadapter, pioctl_req); break; case MLAN_OID_GET_SIGNAL_EXT: status = wlan_get_info_signal_ext(pmadapter, pioctl_req); break; case MLAN_OID_GET_FW_INFO: pioctl_req->data_read_written = sizeof(mlan_fw_info) + MLAN_SUB_COMMAND_SIZE; pget_info->param.fw_info.fw_ver = pmadapter->fw_release_number; pget_info->param.fw_info.hotfix_version = pmadapter->fw_hotfix_ver; pget_info->param.fw_info.tx_buf_size = pmadapter->tx_buf_size; memcpy_ext(pmadapter, &pget_info->param.fw_info.mac_addr, pmpriv->curr_addr, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); pget_info->param.fw_info.fw_bands = pmadapter->fw_bands; pget_info->param.fw_info.region_code = pmadapter->region_code; if (pmadapter->otp_region && pmadapter->otp_region->force_reg) pget_info->param.fw_info.force_reg = MTRUE; else pget_info->param.fw_info.force_reg = MFALSE; pget_info->param.fw_info.ecsa_enable = pmadapter->ecsa_enable; pget_info->param.fw_info.getlog_enable = pmadapter->getlog_enable; pget_info->param.fw_info.hw_dev_mcs_support = pmadapter->hw_dev_mcs_support; pget_info->param.fw_info.hw_dot_11n_dev_cap = pmadapter->hw_dot_11n_dev_cap; pget_info->param.fw_info.usr_dev_mcs_support = pmpriv->usr_dev_mcs_support; if (IS_FW_SUPPORT_NO_80MHZ(pmadapter)) pget_info->param.fw_info.prohibit_80mhz = MTRUE; else pget_info->param.fw_info.prohibit_80mhz = MFALSE; pget_info->param.fw_info.hw_dot_11ac_mcs_support = pmadapter->hw_dot_11ac_mcs_support; pget_info->param.fw_info.hw_dot_11ac_dev_cap = pmadapter->hw_dot_11ac_dev_cap; pget_info->param.fw_info.usr_dot_11ac_dev_cap_bg = pmpriv->usr_dot_11ac_dev_cap_bg; pget_info->param.fw_info.usr_dot_11ac_mcs_support = pmpriv->usr_dot_11ac_mcs_support; pget_info->param.fw_info.usr_dot_11ac_dev_cap_a = pmpriv->usr_dot_11ac_dev_cap_a; pget_info->param.fw_info.hw_hecap_len = pmadapter->hw_hecap_len; pget_info->param.fw_info.hw_2g_hecap_len = pmadapter->hw_2g_hecap_len; memcpy_ext(pmadapter, pget_info->param.fw_info.hw_he_cap, pmadapter->hw_he_cap, pmadapter->hw_hecap_len, sizeof(pget_info->param.fw_info.hw_he_cap)); memcpy_ext(pmadapter, pget_info->param.fw_info.hw_2g_he_cap, pmadapter->hw_2g_he_cap, pmadapter->hw_2g_hecap_len, sizeof(pget_info->param.fw_info.hw_2g_he_cap)); pget_info->param.fw_info.fw_supplicant_support = IS_FW_SUPPORT_SUPPLICANT(pmadapter) ? 0x01 : 0x00; pget_info->param.fw_info.antinfo = pmadapter->antinfo; pget_info->param.fw_info.max_ap_assoc_sta = pmadapter->max_sta_conn; pget_info->param.fw_info.fw_roaming_support = (pmadapter->fw_cap_info & FW_ROAMING_SUPPORT) ? 0x01 : 0x00; pget_info->param.fw_info.fw_beacon_prot = IS_FW_SUPPORT_BEACON_PROT(pmadapter) ? 0x01 : 0x00; break; case MLAN_OID_GET_BSS_INFO: status = wlan_get_info_bss_info(pmadapter, pioctl_req); break; case MLAN_OID_GET_DEBUG_INFO: status = wlan_get_info_debug_info(pmadapter, pioctl_req); break; case MLAN_OID_GET_VER_EXT: status = wlan_get_info_ver_ext(pmadapter, pioctl_req); break; case MLAN_OID_LINK_STATS: status = wlan_ioctl_link_statistic(pmpriv, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Set/Get SNMP MIB handler * * @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_snmp_mib_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; t_u16 cmd_action = 0; t_u16 cmd_oid = 0; mlan_ds_snmp_mib *mib = MNULL; t_u32 value = 0; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_snmp_mib)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_snmp_mib); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } mib = (mlan_ds_snmp_mib *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else cmd_action = HostCmd_ACT_GEN_GET; switch (mib->sub_command) { case MLAN_OID_SNMP_MIB_RTS_THRESHOLD: value = mib->param.rts_threshold; cmd_oid = RtsThresh_i; break; case MLAN_OID_SNMP_MIB_FRAG_THRESHOLD: value = mib->param.frag_threshold; cmd_oid = FragThresh_i; break; case MLAN_OID_SNMP_MIB_RETRY_COUNT: value = mib->param.retry_count; cmd_oid = ShortRetryLim_i; break; case MLAN_OID_SNMP_MIB_DTIM_PERIOD: value = mib->param.dtim_period; cmd_oid = DtimPeriod_i; break; case MLAN_OID_SNMP_MIB_SIGNALEXT_ENABLE: value = mib->param.signalext_enable; cmd_oid = SignalextEnable_i; break; case MLAN_OID_SNMP_MIB_CHAN_TRACK: if (!IS_FW_SUPPORT_CHAN_TRACK(pmadapter)) { goto exit; } value = mib->param.chan_track; cmd_oid = ChanTrackParam_i; break; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SNMP_MIB, cmd_action, cmd_oid, (t_void *)pioctl_req, &value); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Radio command handler * * @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_radio_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_radio_cfg *radio_cfg = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_radio_cfg)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_radio_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } radio_cfg = (mlan_ds_radio_cfg *)pioctl_req->pbuf; switch (radio_cfg->sub_command) { case MLAN_OID_RADIO_CTRL: status = wlan_radio_ioctl_radio_ctl(pmadapter, pioctl_req); break; case MLAN_OID_BAND_CFG: status = wlan_radio_ioctl_band_cfg(pmadapter, pioctl_req); break; case MLAN_OID_ANT_CFG: status = wlan_radio_ioctl_ant_cfg(pmadapter, pioctl_req); break; case MLAN_OID_REMAIN_CHAN_CFG: status = wlan_radio_ioctl_remain_chan_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MIMO_SWITCH: status = wlan_radio_ioctl_mimo_switch_cfg(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @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_bss_ioctl_mac_address(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_bss *bss = MNULL; t_u16 cmd_action; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { cmd_action = HostCmd_ACT_GEN_GET; } else { cmd_action = HostCmd_ACT_GEN_SET; memcpy_ext(pmadapter, pmpriv->curr_addr, &bss->param.mac_addr, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_MAC_ADDRESS, cmd_action, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set multicast list * * @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_bss_ioctl_set_multicast_list(pmlan_adapter pmadapter, 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 old_pkt_filter; ENTER(); old_pkt_filter = pmpriv->curr_pkt_filter; bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } pioctl_req->data_read_written = sizeof(mlan_multicast_list) + MLAN_SUB_COMMAND_SIZE; if (bss->param.multicast_list.mode == MLAN_PROMISC_MODE) { PRINTM(MINFO, "Enable Promiscuous mode\n"); pmpriv->curr_pkt_filter |= HostCmd_ACT_MAC_PROMISCUOUS_ENABLE; pmpriv->curr_pkt_filter &= ~HostCmd_ACT_MAC_ALL_MULTICAST_ENABLE; } else { /* Multicast */ pmpriv->curr_pkt_filter &= ~HostCmd_ACT_MAC_PROMISCUOUS_ENABLE; if (bss->param.multicast_list.mode == MLAN_ALL_MULTI_MODE) { PRINTM(MINFO, "Enabling All Multicast!\n"); pmpriv->curr_pkt_filter |= HostCmd_ACT_MAC_ALL_MULTICAST_ENABLE; } else { pmpriv->curr_pkt_filter &= ~HostCmd_ACT_MAC_ALL_MULTICAST_ENABLE; if (bss->param.multicast_list.num_multicast_addr) { PRINTM(MINFO, "Set multicast list=%d\n", bss->param.multicast_list .num_multicast_addr); /* Set multicast addresses to firmware */ if (old_pkt_filter == pmpriv->curr_pkt_filter) { /* Send request to firmware */ ret = wlan_prepare_cmd( pmpriv, HostCmd_CMD_MAC_MULTICAST_ADR, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &bss->param.multicast_list); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } else { /* Send request to firmware */ ret = wlan_prepare_cmd( pmpriv, HostCmd_CMD_MAC_MULTICAST_ADR, HostCmd_ACT_GEN_SET, 0, MNULL, &bss->param.multicast_list); } if (ret) goto exit; } } } PRINTM(MINFO, "old_pkt_filter=0x%x, curr_pkt_filter=0x%x\n", old_pkt_filter, pmpriv->curr_pkt_filter); if (old_pkt_filter != pmpriv->curr_pkt_filter) { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_MAC_CONTROL, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &pmpriv->curr_pkt_filter); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } exit: LEAVE(); return ret; } /** * @brief Get channel list * * @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_bss_ioctl_get_channel_list(pmlan_adapter pmadapter, 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; chan_freq_power_t *cfp; t_u32 i, j; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action != MLAN_ACT_GET) { pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; LEAVE(); return MLAN_STATUS_FAILURE; } if ((wlan_11d_is_enabled(pmpriv) && pmpriv->media_connected == MTRUE) && ((pmpriv->bss_mode == MLAN_BSS_MODE_INFRA) || (pmpriv->bss_mode == MLAN_BSS_MODE_IBSS && pmpriv->adhoc_state != ADHOC_STARTED))) { t_u8 chan_no; t_u16 band; parsed_region_chan_11d_t *parsed_region_chan = MNULL; parsed_region_chan_11d_t region_chan; BSSDescriptor_t *pbss_desc = &pmpriv->curr_bss_params.bss_descriptor; memset(pmadapter, ®ion_chan, 0, sizeof(parsed_region_chan_11d_t)); /*If country IE is present in the associated AP then return the channel list from country IE else return it from the learning table*/ if (wlan_11d_parse_domain_info( pmadapter, &pbss_desc->country_info, pbss_desc->bss_band, ®ion_chan) == MLAN_STATUS_SUCCESS) { parsed_region_chan = ®ion_chan; } else { parsed_region_chan = &pmadapter->parsed_region_chan; } PRINTM(MINFO, "no_of_chan=%d\n", parsed_region_chan->no_of_chan); for (i = 0; (bss->param.chanlist.num_of_chan < MLAN_MAX_CHANNEL_NUM) && (i < parsed_region_chan->no_of_chan); i++) { chan_no = parsed_region_chan->chan_pwr[i].chan; band = parsed_region_chan->chan_pwr[i].band; PRINTM(MINFO, "band=%d, chan_no=%d\n", band, chan_no); bss->param.chanlist.cf[bss->param.chanlist.num_of_chan] .channel = (t_u32)chan_no; bss->param.chanlist.cf[bss->param.chanlist.num_of_chan] .freq = (t_u32)wlan_11d_chan_2_freq( pmadapter, chan_no, band); bss->param.chanlist.num_of_chan++; } } else { for (j = 0; (bss->param.chanlist.num_of_chan < MLAN_MAX_CHANNEL_NUM) && (j < MAX_REGION_CHANNEL_NUM); j++) { cfp = pmadapter->region_channel[j].pcfp; for (i = 0; (bss->param.chanlist.num_of_chan < MLAN_MAX_CHANNEL_NUM) && pmadapter->region_channel[j].valid && cfp && (i < pmadapter->region_channel[j].num_cfp); i++) { bss->param.chanlist .cf[bss->param.chanlist.num_of_chan] .channel = (t_u32)cfp->channel; bss->param.chanlist .cf[bss->param.chanlist.num_of_chan] .freq = (t_u32)cfp->freq; bss->param.chanlist.num_of_chan++; cfp++; } } } PRINTM(MINFO, "num of channel=%d\n", bss->param.chanlist.num_of_chan); LEAVE(); return ret; } /** Highest channel used in 2.4GHz band */ #define MAX_CHANNEL_BAND_B (14) /** Highest frequency used in 2.4GHz band */ #define MAX_FREQUENCY_BAND_B (2484) /** * @brief Set/Get BSS channel * * @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_bss_ioctl_channel(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = MNULL; mlan_ds_bss *bss = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; chan_freq_power_t *cfp = MNULL; ENTER(); if ((pioctl_req == MNULL) || (pioctl_req->pbuf == MNULL)) { PRINTM(MERROR, "Request buffer not found!\n"); LEAVE(); return MLAN_STATUS_FAILURE; } pmpriv = pmadapter->priv[pioctl_req->bss_index]; bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { cfp = wlan_find_cfp_by_band_and_channel( pmadapter, pmpriv->curr_bss_params.band, (t_u16)pmpriv->curr_bss_params.bss_descriptor.channel); if (cfp) { bss->param.bss_chan.channel = cfp->channel; bss->param.bss_chan.freq = cfp->freq; } else { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; } pioctl_req->data_read_written = sizeof(chan_freq) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } if (!bss->param.bss_chan.channel && !bss->param.bss_chan.freq) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_FAILURE; } if (pmadapter->adhoc_start_band & BAND_A) pmadapter->adhoc_start_band = BAND_G | BAND_B; if (bss->param.bss_chan.channel) { if (bss->param.bss_chan.channel <= MAX_CHANNEL_BAND_B) cfp = wlan_find_cfp_by_band_and_channel( pmadapter, BAND_B, (t_u16)bss->param.bss_chan.channel); if (!cfp) { cfp = wlan_find_cfp_by_band_and_channel( pmadapter, BAND_A, (t_u16)bss->param.bss_chan.channel); if (cfp) { pmadapter->adhoc_start_band = BAND_A; } } } else { if (bss->param.bss_chan.freq <= MAX_FREQUENCY_BAND_B) cfp = wlan_find_cfp_by_band_and_freq( pmadapter, BAND_B, bss->param.bss_chan.freq); if (!cfp) { cfp = wlan_find_cfp_by_band_and_freq( pmadapter, BAND_A, bss->param.bss_chan.freq); if (cfp) { pmadapter->adhoc_start_band = BAND_A; } } } if (!cfp || !cfp->channel) { PRINTM(MERROR, "Invalid channel/freq\n"); if (pioctl_req) pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_FAILURE; } pmpriv->adhoc_channel = (t_u8)cfp->channel; pmpriv->intf_state_11h.adhoc_auto_sel_chan = MFALSE; bss->param.bss_chan.channel = cfp->channel; bss->param.bss_chan.freq = cfp->freq; LEAVE(); return ret; } /** * @brief Set/Get BSS mode * * @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_bss_ioctl_mode(pmlan_adapter pmadapter, 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; bss = (mlan_ds_bss *)pioctl_req->pbuf; ENTER(); if (pioctl_req->action == MLAN_ACT_GET) { bss->param.bss_mode = pmpriv->bss_mode; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; goto exit; } if ((pmpriv->bss_mode == bss->param.bss_mode) || (bss->param.bss_mode == MLAN_BSS_MODE_AUTO)) { PRINTM(MINFO, "Already set to required mode! No change!\n"); pmpriv->bss_mode = bss->param.bss_mode; goto exit; } if (pmpriv->bss_mode != MLAN_BSS_MODE_AUTO) ret = wlan_disconnect(pmpriv, MNULL, MNULL); else ret = wlan_disconnect(pmpriv, pioctl_req, MNULL); if (pmpriv->sec_info.authentication_mode != MLAN_AUTH_MODE_AUTO) pmpriv->sec_info.authentication_mode = MLAN_AUTH_MODE_OPEN; pmpriv->bss_mode = bss->param.bss_mode; if (pmpriv->bss_mode == MLAN_BSS_MODE_INFRA) pmpriv->port_ctrl_mode = MTRUE; else pmpriv->port_ctrl_mode = MFALSE; if (pmpriv->bss_mode != MLAN_BSS_MODE_AUTO) { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_SET_BSS_MODE, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } exit: LEAVE(); return ret; } /** * @brief Start 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_bss_ioctl_start(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_bss *bss = (mlan_ds_bss *)pioctl_req->pbuf; t_s32 i = -1; t_u8 zero_mac[] = {0, 0, 0, 0, 0, 0}; ENTER(); if (pmadapter->enable_net_mon == CHANNEL_SPEC_SNIFFER_MODE) { PRINTM(MINFO, "Association is blocked in Channel Specified Network Monitor mode...\n"); LEAVE(); return MLAN_STATUS_FAILURE; } /* Before ASSOC REQ, If "port ctrl" mode is enabled, * move the port to CLOSED state */ if (pmpriv->port_ctrl_mode == MTRUE) { PRINTM(MINFO, "bss_ioctl_start(): port_state=CLOSED\n"); pmpriv->prior_port_status = pmpriv->port_open; pmpriv->port_open = MFALSE; } pmadapter->scan_block = MFALSE; if (pmpriv->bss_mode == MLAN_BSS_MODE_INFRA) { if (!bss->param.ssid_bssid.idx || bss->param.ssid_bssid.idx > pmadapter->num_in_scan_table) { /* Search for the requested SSID in the scan table */ if (bss->param.ssid_bssid.ssid.ssid_len) { if (memcmp(pmadapter, &bss->param.ssid_bssid.bssid, zero_mac, sizeof(zero_mac))) i = wlan_find_ssid_in_list( pmpriv, &bss->param.ssid_bssid.ssid, (t_u8 *)&bss->param.ssid_bssid .bssid, MLAN_BSS_MODE_INFRA); else i = wlan_find_ssid_in_list( pmpriv, &bss->param.ssid_bssid.ssid, MNULL, MLAN_BSS_MODE_INFRA); } else { i = wlan_find_bssid_in_list( pmpriv, (t_u8 *)&bss->param.ssid_bssid.bssid, MLAN_BSS_MODE_INFRA); } } else { /* use bsslist index number to assoicate */ i = wlan_is_network_compatible( pmpriv, bss->param.ssid_bssid.idx - 1, pmpriv->bss_mode); } if (i >= 0) { /* block if upper-layer tries to reconnect before new * scan */ if (wlan_11h_get_csa_closed_channel(pmpriv) == (t_u8)pmadapter->pscan_table[i].channel) { PRINTM(MINFO, "Attempt to reconnect on csa_closed_chan(%d)\n", pmadapter->pscan_table[i].channel); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto start_ssid_done; } PRINTM(MINFO, "SSID found in scan list ... associating...\n"); pmpriv->curr_bss_params.host_mlme = bss->param.ssid_bssid.host_mlme; memcpy_ext(pmpriv->adapter, &pmpriv->curr_bss_params.prev_bssid, &bss->param.ssid_bssid.prev_bssid, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); /* Clear any past association response stored for * application retrieval */ pmpriv->assoc_rsp_size = 0; pmpriv->curr_chan_flags = bss->param.ssid_bssid.channel_flags; if (IS_FW_SUPPORT_NO_80MHZ(pmadapter)) pmpriv->curr_chan_flags |= CHAN_FLAGS_NO_80MHZ; ret = wlan_associate(pmpriv, pioctl_req, &pmadapter->pscan_table[i]); if (ret) goto start_ssid_done; } else { /* i >= 0 */ PRINTM(MERROR, "SSID not found in scan list: ssid=%s, " MACSTR ", idx=%d\n", bss->param.ssid_bssid.ssid.ssid, MAC2STR(bss->param.ssid_bssid.bssid), (int)bss->param.ssid_bssid.idx); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto start_ssid_done; } } else { /* Adhoc mode */ /* If the requested SSID matches current SSID, return */ if (bss->param.ssid_bssid.ssid.ssid_len && (!wlan_ssid_cmp(pmadapter, &pmpriv->curr_bss_params.bss_descriptor.ssid, &bss->param.ssid_bssid.ssid))) { ret = MLAN_STATUS_SUCCESS; goto start_ssid_done; } /* Exit Adhoc mode first */ PRINTM(MINFO, "Sending Adhoc Stop\n"); ret = wlan_disconnect(pmpriv, MNULL, MNULL); if (ret) goto start_ssid_done; pmpriv->adhoc_is_link_sensed = MFALSE; if (!bss->param.ssid_bssid.idx || bss->param.ssid_bssid.idx > pmadapter->num_in_scan_table) { /* Search for the requested network in the scan table */ if (bss->param.ssid_bssid.ssid.ssid_len) { i = wlan_find_ssid_in_list( pmpriv, &bss->param.ssid_bssid.ssid, MNULL, MLAN_BSS_MODE_IBSS); } else { i = wlan_find_bssid_in_list( pmpriv, (t_u8 *)&bss->param.ssid_bssid.bssid, MLAN_BSS_MODE_IBSS); } } else { /* use bsslist index number to assoicate */ i = wlan_is_network_compatible( pmpriv, bss->param.ssid_bssid.idx - 1, pmpriv->bss_mode); } if (i >= 0) { PRINTM(MINFO, "Network found in scan list ... joining ...\n"); pmpriv->curr_chan_flags = bss->param.ssid_bssid.channel_flags; ret = wlan_adhoc_join(pmpriv, pioctl_req, &pmadapter->pscan_table[i]); if (ret) goto start_ssid_done; } else { /* i >= 0 */ PRINTM(MINFO, "Network not found in the list, " "creating adhoc with ssid = %s\n", bss->param.ssid_bssid.ssid.ssid); pmpriv->curr_chan_flags = bss->param.ssid_bssid.channel_flags; ret = wlan_adhoc_start(pmpriv, pioctl_req, &bss->param.ssid_bssid.ssid); if (ret) goto start_ssid_done; } } if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; start_ssid_done: 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_SUCCESS/MLAN_STATUS_PENDING --success, * otherwise fail */ static mlan_status wlan_bss_ioctl_stop(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_bss *bss = (mlan_ds_bss *)pioctl_req->pbuf; ENTER(); ret = wlan_disconnect(pmpriv, pioctl_req, &bss->param.deauth_param); LEAVE(); return ret; } /** * @brief Set/Get IBSS channel * * @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_bss_ioctl_ibss_channel(pmlan_adapter pmadapter, 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; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { if (pmpriv->media_connected == MFALSE) { bss->param.bss_chan.channel = pmpriv->adhoc_channel; goto exit; } cmd_action = HostCmd_ACT_GEN_GET; } else { cmd_action = HostCmd_ACT_GEN_SET; pmpriv->adhoc_channel = (t_u8)bss->param.bss_chan.channel; pmpriv->intf_state_11h.adhoc_auto_sel_chan = MFALSE; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_RF_CHANNEL, cmd_action, 0, (t_void *)pioctl_req, &bss->param.bss_chan.channel); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Set/Get Listen Interval * * @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_bss_ioctl_listen_interval(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_bss *bss = MNULL; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) bss->param.listen_interval = pmpriv->listen_interval; else pmpriv->listen_interval = bss->param.listen_interval; LEAVE(); return MLAN_STATUS_SUCCESS; } /* * @brief Set/Get beacon interval * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_bss_ioctl_beacon_interval(pmlan_adapter pmadapter, 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; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { bss->param.bcn_interval = pmpriv->beacon_period; if (pmpriv->media_connected == MTRUE) bss->param.bcn_interval = pmpriv->curr_bss_params.bss_descriptor .beacon_period; } else pmpriv->beacon_period = (t_u16)bss->param.bcn_interval; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Set/Get ATIM window * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_bss_ioctl_atim_window(pmlan_adapter pmadapter, 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; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { bss->param.atim_window = pmpriv->atim_window; if (pmpriv->media_connected == MTRUE) bss->param.atim_window = pmpriv->curr_bss_params.bss_descriptor .atim_window; } else pmpriv->atim_window = (t_u16)bss->param.atim_window; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Query embe * * @param priv A pointer to mlan_private structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS -- success, otherwise fail */ static mlan_status wlan_query_passphrase(mlan_private *priv, pmlan_ioctl_req pioctl_req) { mlan_adapter *pmadapter = priv->adapter; pmlan_callbacks pcb = &pmadapter->callbacks; mlan_ds_bss *bss = MNULL; mlan_ssid_bssid *ssid_bssid = MNULL; mlan_ds_sec_cfg *sec = MNULL; mlan_ds_passphrase *sec_pp; int i = 0; BSSDescriptor_t *pbss_desc; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; ssid_bssid = &bss->param.ssid_bssid; ret = pcb->moal_malloc(pmadapter->pmoal_handle, sizeof(mlan_ds_sec_cfg), MLAN_MEM_DEF, (t_u8 **)&sec); if (ret || !sec) { PRINTM(MERROR, "Could not allocate sec!\n"); LEAVE(); return ret; } memset(pmadapter, sec, 0, sizeof(mlan_ds_sec_cfg)); sec_pp = (mlan_ds_passphrase *)&sec->param.passphrase; sec_pp->psk_type = MLAN_PSK_QUERY; if (ssid_bssid->ssid.ssid_len == 0) { i = wlan_find_bssid_in_list(priv, (t_u8 *)&ssid_bssid->bssid, MLAN_BSS_MODE_AUTO); if (i >= 0) { pbss_desc = &pmadapter->pscan_table[i]; memcpy_ext(pmadapter, (t_u8 *)&sec_pp->ssid, &pbss_desc->ssid, sizeof(mlan_802_11_ssid), sizeof(mlan_802_11_ssid)); } else memcpy_ext(pmadapter, (t_u8 *)&sec_pp->bssid, &ssid_bssid->bssid, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); } else { memcpy_ext(pmadapter, (t_u8 *)&sec_pp->ssid, &ssid_bssid->ssid, sizeof(mlan_802_11_ssid), sizeof(mlan_802_11_ssid)); } /* Send request to firmware */ ret = wlan_prepare_cmd(priv, HostCmd_CMD_SUPPLICANT_PMK, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, (t_void *)sec); if (sec) pcb->moal_mfree(pmadapter->pmoal_handle, (t_u8 *)sec); LEAVE(); return ret; } /** * @brief Search for a BSS * * @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_bss_ioctl_find_bss(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; #ifdef DRV_EMBEDDED_SUPPLICANT mlan_ds_bss *bss = MNULL; mlan_ssid_bssid *ssid_bssid = MNULL; #endif ENTER(); if (pmpriv->ewpa_query) { if (wlan_query_passphrase(pmpriv, pioctl_req) == MLAN_STATUS_SUCCESS) { PRINTM(MINFO, "Find BSS ioctl: query passphrase\n"); LEAVE(); return MLAN_STATUS_PENDING; } } #ifdef DRV_EMBEDDED_SUPPLICANT if (!IS_FW_SUPPORT_SUPPLICANT(pmpriv->adapter)) { bss = (mlan_ds_bss *)pioctl_req->pbuf; ssid_bssid = &bss->param.ssid_bssid; supplicantQueryPassphraseAndEnable(pmpriv->psapriv, (t_u8 *)ssid_bssid); } #endif ret = wlan_find_bss(pmpriv, pioctl_req); LEAVE(); return ret; } /** * @brief Search for a BSS * * @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_bss_ioctl_find_bssid(pmlan_adapter pmadapter, 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; int i = 0; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; i = wlan_find_bssid_in_list(pmpriv, (t_u8 *)&bss->param.bssid, MLAN_BSS_MODE_AUTO); if (i < 0) { PRINTM(MCMND, "Can not find bssid " MACSTR "\n", MAC2STR((t_u8 *)&bss->param.bssid)); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_FAILURE; } PRINTM(MCMND, "Find bssid " MACSTR "\n", MAC2STR((t_u8 *)&bss->param.bssid)); LEAVE(); return ret; } /** * @brief Check if BSS channel is valid for Station's region * * @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_bss_ioctl_bss_11d_check_channel(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_bss *bss = MNULL; mlan_ssid_bssid *ssid_bssid = MNULL; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; ssid_bssid = &bss->param.ssid_bssid; PRINTM(MINFO, "ssid: %s idx:%d\n", ssid_bssid->ssid.ssid, ssid_bssid->idx); PRINTM(MINFO, "band:%d channel:%d\n", (t_u8)ssid_bssid->bss_band, (t_u32)ssid_bssid->channel); /* check if this channel is supported in the region */ if (!wlan_find_cfp_by_band_and_channel(pmadapter, ssid_bssid->bss_band, (t_u32)ssid_bssid->channel)) { PRINTM(MERROR, "Unsupported Channel for region 0x%x\n", pmadapter->region_code); ret = MLAN_STATUS_FAILURE; } LEAVE(); return ret; } /** * @brief BSS command handler * * @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_bss_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_bss *bss = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_bss)) { PRINTM(MWARN, "MLAN bss IOCTL length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_bss); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } bss = (mlan_ds_bss *)pioctl_req->pbuf; switch (bss->sub_command) { case MLAN_OID_BSS_START: status = wlan_bss_ioctl_start(pmadapter, pioctl_req); break; case MLAN_OID_BSS_STOP: status = wlan_bss_ioctl_stop(pmadapter, pioctl_req); break; case MLAN_OID_BSS_MODE: status = wlan_bss_ioctl_mode(pmadapter, pioctl_req); break; case MLAN_OID_BSS_CHANNEL: status = wlan_bss_ioctl_channel(pmadapter, pioctl_req); break; case MLAN_OID_BSS_CHANNEL_LIST: status = wlan_bss_ioctl_get_channel_list(pmadapter, pioctl_req); break; case MLAN_OID_BSS_MAC_ADDR: status = wlan_bss_ioctl_mac_address(pmadapter, pioctl_req); break; case MLAN_OID_BSS_MULTICAST_LIST: status = wlan_bss_ioctl_set_multicast_list(pmadapter, pioctl_req); break; case MLAN_OID_BSS_FIND_BSS: status = wlan_bss_ioctl_find_bss(pmadapter, pioctl_req); break; case MLAN_OID_BSS_FIND_BSSID: status = wlan_bss_ioctl_find_bssid(pmadapter, pioctl_req); break; case MLAN_OID_IBSS_BCN_INTERVAL: status = wlan_bss_ioctl_beacon_interval(pmadapter, pioctl_req); break; case MLAN_OID_IBSS_ATIM_WINDOW: status = wlan_bss_ioctl_atim_window(pmadapter, pioctl_req); break; case MLAN_OID_IBSS_CHANNEL: status = wlan_bss_ioctl_ibss_channel(pmadapter, pioctl_req); break; #if defined(STA_SUPPORT) && defined(UAP_SUPPORT) case MLAN_OID_BSS_ROLE: util_enqueue_list_tail(pmadapter->pmoal_handle, &pmadapter->ioctl_pending_q, (pmlan_linked_list)pioctl_req, pmadapter->callbacks.moal_spin_lock, pmadapter->callbacks.moal_spin_unlock); pmadapter->pending_ioctl = MTRUE; status = MLAN_STATUS_PENDING; break; #endif #ifdef WIFI_DIRECT_SUPPORT case MLAN_OID_WIFI_DIRECT_MODE: status = wlan_bss_ioctl_wifi_direct_mode(pmadapter, pioctl_req); break; #endif case MLAN_OID_BSS_LISTEN_INTERVAL: status = wlan_bss_ioctl_listen_interval(pmadapter, pioctl_req); break; case MLAN_OID_BSS_REMOVE: status = wlan_bss_ioctl_bss_remove(pmadapter, pioctl_req); break; case MLAN_OID_BSS_11D_CHECK_CHANNEL: status = wlan_bss_ioctl_bss_11d_check_channel(pmadapter, pioctl_req); break; case MLAN_OID_BSS_CHAN_INFO: status = wlan_bss_ioctl_get_chan_info(pmadapter, pioctl_req); break; default: status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Get supported rates * * @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_rate_ioctl_get_supported_rate(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_rate *rate = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); if (pioctl_req->action != MLAN_ACT_GET) { pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; LEAVE(); return MLAN_STATUS_FAILURE; } rate = (mlan_ds_rate *)pioctl_req->pbuf; if (rate->param.rate_band_cfg.config_bands && rate->param.rate_band_cfg.bss_mode) wlan_get_active_data_rates( pmpriv, rate->param.rate_band_cfg.bss_mode, rate->param.rate_band_cfg.config_bands, rate->param.rates); else wlan_get_active_data_rates(pmpriv, pmpriv->bss_mode, (pmpriv->bss_mode == MLAN_BSS_MODE_INFRA) ? pmpriv->config_bands : pmadapter->adhoc_start_band, rate->param.rates); pioctl_req->data_read_written = MLAN_SUPPORTED_RATES + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Rate command handler * * @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_rate_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_rate *rate = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_rate)) { PRINTM(MWARN, "MLAN bss IOCTL length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_rate); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } rate = (mlan_ds_rate *)pioctl_req->pbuf; switch (rate->sub_command) { case MLAN_OID_RATE_CFG: status = wlan_rate_ioctl_cfg(pmadapter, pioctl_req); break; case MLAN_OID_GET_DATA_RATE: status = wlan_rate_ioctl_get_data_rate(pmadapter, pioctl_req); break; case MLAN_OID_SUPPORTED_RATES: status = wlan_rate_ioctl_get_supported_rate(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Get Tx power configuration * * @param pmadapter A pointer to mlan_adapter structure * @param cmd_no Firmware command number used to retrieve power values * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_PENDING --success, otherwise fail */ static mlan_status wlan_power_ioctl_get_power(pmlan_adapter pmadapter, t_u16 cmd_no, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, cmd_no, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set Tx power configuration * * @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_power_ioctl_set_power(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_power_cfg *power = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; HostCmd_DS_TXPWR_CFG *txp_cfg = MNULL; MrvlTypes_Power_Group_t *pg_tlv = MNULL; Power_Group_t *pg = MNULL; pmlan_callbacks pcb = &pmadapter->callbacks; t_u8 *buf = MNULL; t_s8 dbm = 0; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); power = (mlan_ds_power_cfg *)pioctl_req->pbuf; if (!power->param.power_cfg.is_power_auto) { dbm = (t_s8)power->param.power_cfg.power_level; if ((dbm < pmpriv->min_tx_power_level) || (dbm > pmpriv->max_tx_power_level)) { PRINTM(MERROR, "The set txpower value %d dBm is out of range (%d dBm-%d dBm)!\n", dbm, pmpriv->min_tx_power_level, pmpriv->max_tx_power_level); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } } ret = pcb->moal_malloc(pmadapter->pmoal_handle, MRVDRV_SIZE_OF_CMD_BUFFER, MLAN_MEM_DEF, &buf); if (ret != MLAN_STATUS_SUCCESS || buf == MNULL) { PRINTM(MERROR, "ALLOC_CMD_BUF: Failed to allocate command buffer\n"); pioctl_req->status_code = MLAN_ERROR_NO_MEM; ret = MLAN_STATUS_FAILURE; goto exit; } memset(pmadapter, buf, 0, MRVDRV_SIZE_OF_CMD_BUFFER); txp_cfg = (HostCmd_DS_TXPWR_CFG *)buf; txp_cfg->action = HostCmd_ACT_GEN_SET; if (!power->param.power_cfg.is_power_auto) { txp_cfg->mode = 1; pg_tlv = (MrvlTypes_Power_Group_t *)(buf + sizeof(HostCmd_DS_TXPWR_CFG)); pg_tlv->type = TLV_TYPE_POWER_GROUP; pg_tlv->length = 4 * sizeof(Power_Group_t); pg = (Power_Group_t *)(buf + sizeof(HostCmd_DS_TXPWR_CFG) + sizeof(MrvlTypes_Power_Group_t)); /* Power group for modulation class HR/DSSS */ pg->first_rate_code = 0x00; pg->last_rate_code = 0x03; pg->modulation_class = MOD_CLASS_HR_DSSS; pg->power_step = 0; pg->power_min = (t_s8)dbm; pg->power_max = (t_s8)dbm; pg++; /* Power group for modulation class OFDM */ pg->first_rate_code = 0x00; pg->last_rate_code = 0x07; pg->modulation_class = MOD_CLASS_OFDM; pg->power_step = 0; pg->power_min = (t_s8)dbm; pg->power_max = (t_s8)dbm; pg++; /* Power group for modulation class HTBW20 */ pg->first_rate_code = 0x00; pg->last_rate_code = 0x20; pg->modulation_class = MOD_CLASS_HT; pg->power_step = 0; pg->power_min = (t_s8)dbm; pg->power_max = (t_s8)dbm; pg->ht_bandwidth = HT_BW_20; pg++; /* Power group for modulation class HTBW40 */ pg->first_rate_code = 0x00; pg->last_rate_code = 0x20; pg->modulation_class = MOD_CLASS_HT; pg->power_step = 0; pg->power_min = (t_s8)dbm; pg->power_max = (t_s8)dbm; pg->ht_bandwidth = HT_BW_40; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_TXPWR_CFG, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, buf); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; if (buf) pcb->moal_mfree(pmadapter->pmoal_handle, buf); exit: LEAVE(); return ret; } /** * @brief Set extended power configuration * * @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_power_ioctl_set_power_ext(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_power_cfg *power = MNULL; pmlan_callbacks pcb = &pmadapter->callbacks; t_u8 *buf = MNULL; HostCmd_DS_TXPWR_CFG *txp_cfg = MNULL; MrvlTypes_Power_Group_t *pg_tlv = MNULL; Power_Group_t *pg = MNULL; mlan_power_group *pwr_grp = MNULL; ENTER(); power = (mlan_ds_power_cfg *)pioctl_req->pbuf; ret = pcb->moal_malloc(pmadapter->pmoal_handle, MRVDRV_SIZE_OF_CMD_BUFFER, MLAN_MEM_DEF, &buf); if (ret != MLAN_STATUS_SUCCESS || buf == MNULL) { PRINTM(MERROR, "ALLOC_CMD_BUF: Failed to allocate command buffer\n"); pioctl_req->status_code = MLAN_ERROR_NO_MEM; ret = MLAN_STATUS_FAILURE; goto exit; } memset(pmadapter, buf, 0, MRVDRV_SIZE_OF_CMD_BUFFER); txp_cfg = (HostCmd_DS_TXPWR_CFG *)buf; txp_cfg->action = HostCmd_ACT_GEN_SET; pwr_grp = &power->param.power_ext.power_group[0]; if (pwr_grp->rate_format == TX_PWR_CFG_AUTO_CTRL_OFF) txp_cfg->mode = 0; else { txp_cfg->mode = 1; pg_tlv = (MrvlTypes_Power_Group_t *)(buf + sizeof(HostCmd_DS_TXPWR_CFG)); pg_tlv->type = TLV_TYPE_POWER_GROUP; pg_tlv->length = sizeof(Power_Group_t); pg = (Power_Group_t *)(buf + sizeof(HostCmd_DS_TXPWR_CFG) + sizeof(MrvlTypes_Power_Group_t)); pg->ht_bandwidth = pwr_grp->bandwidth; pg->power_min = (t_s8)pwr_grp->power_min; pg->power_max = (t_s8)pwr_grp->power_max; pg->power_step = (t_s8)pwr_grp->power_step; if (pwr_grp->rate_format == MLAN_RATE_FORMAT_LG) { if (pwr_grp->first_rate_ind <= MLAN_RATE_INDEX_HRDSSS3) { pg->modulation_class = MOD_CLASS_HR_DSSS; } else { pg->modulation_class = MOD_CLASS_OFDM; pwr_grp->first_rate_ind -= MLAN_RATE_INDEX_OFDM0; pwr_grp->last_rate_ind -= MLAN_RATE_INDEX_OFDM0; } pg->first_rate_code = (t_u8)pwr_grp->first_rate_ind; pg->last_rate_code = (t_u8)pwr_grp->last_rate_ind; } else if (pwr_grp->rate_format == MLAN_RATE_FORMAT_HT) { pg->modulation_class = MOD_CLASS_HT; pg->first_rate_code = (t_u8)pwr_grp->first_rate_ind; pg->last_rate_code = (t_u8)pwr_grp->last_rate_ind; } else if (pwr_grp->rate_format == MLAN_RATE_FORMAT_VHT) { pg->modulation_class = MOD_CLASS_VHT; pg->first_rate_code = (t_u8)((pwr_grp->first_rate_ind & 0xF) | ((pwr_grp->nss - 1) << 4)); pg->last_rate_code = (t_u8)((pwr_grp->last_rate_ind & 0xF) | ((pwr_grp->nss - 1) << 4)); } else { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; } } if (ret == MLAN_STATUS_FAILURE) { if (buf) pcb->moal_mfree(pmadapter->pmoal_handle, buf); goto exit; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_TXPWR_CFG, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, buf); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; if (buf) pcb->moal_mfree(pmadapter->pmoal_handle, buf); exit: LEAVE(); return ret; } /** * @brief Power configuration command handler * * @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_power_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_power_cfg *power = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_power_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_power_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } power = (mlan_ds_power_cfg *)pioctl_req->pbuf; switch (power->sub_command) { case MLAN_OID_POWER_CFG: if (pioctl_req->action == MLAN_ACT_GET) status = wlan_power_ioctl_get_power( pmadapter, HostCmd_CMD_TXPWR_CFG, pioctl_req); else status = wlan_power_ioctl_set_power(pmadapter, pioctl_req); break; case MLAN_OID_POWER_CFG_EXT: if (pioctl_req->action == MLAN_ACT_GET) status = wlan_power_ioctl_get_power( pmadapter, HostCmd_CMD_TXPWR_CFG, pioctl_req); else status = wlan_power_ioctl_set_power_ext(pmadapter, pioctl_req); break; case MLAN_OID_POWER_LOW_POWER_MODE: status = wlan_power_ioctl_set_get_lpm(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Set power save configurations * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * @param ps_mode Power save mode * * @return MLAN_STATUS_PENDING --success, otherwise fail */ static mlan_status wlan_pm_ioctl_ps_mode(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req, t_u16 ps_mode) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; t_u16 sub_cmd; ENTER(); if (pioctl_req->action == MLAN_ACT_SET) { sub_cmd = (pmadapter->ps_mode == Wlan802_11PowerModePSP) ? EN_AUTO_PS : DIS_AUTO_PS; ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, sub_cmd, BITMAP_STA_PS, (t_void *)pioctl_req, MNULL); if ((ret == MLAN_STATUS_SUCCESS) && (sub_cmd == DIS_AUTO_PS)) { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, GET_PS, 0, MNULL, MNULL); } } else { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, GET_PS, 0, (t_void *)pioctl_req, MNULL); } if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set/Get Inactivity timeout extend * * @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_pm_ioctl_inactivity_timeout(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_pm_cfg *pmcfg = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; t_u16 cmd_action = 0; ENTER(); pmcfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; cmd_action = HostCmd_ACT_GEN_GET; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_INACTIVITY_TIMEOUT_EXT, cmd_action, 0, (t_void *)pioctl_req, (t_void *)&pmcfg->param.inactivity_to); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Enable/Disable Auto Deep Sleep * * @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_set_auto_deep_sleep(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private pmpriv = (pmlan_private)pmadapter->priv[pioctl_req->bss_index]; mlan_ds_auto_ds auto_ds; t_u32 mode; ENTER(); if (((mlan_ds_pm_cfg *)pioctl_req->pbuf) ->param.auto_deep_sleep.auto_ds == DEEP_SLEEP_ON) { auto_ds.auto_ds = DEEP_SLEEP_ON; PRINTM(MINFO, "Auto Deep Sleep: on\n"); mode = EN_AUTO_PS; } else { auto_ds.auto_ds = DEEP_SLEEP_OFF; PRINTM(MINFO, "Auto Deep Sleep: off\n"); mode = DIS_AUTO_PS; } if (((mlan_ds_pm_cfg *)pioctl_req->pbuf)->param.auto_deep_sleep.idletime) auto_ds.idletime = ((mlan_ds_pm_cfg *)pioctl_req->pbuf) ->param.auto_deep_sleep.idletime; else auto_ds.idletime = pmadapter->idle_time; /* note: the command could be queued and executed later if there is command in progress. */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, (t_u16)mode, BITMAP_AUTO_DS, (t_void *)pioctl_req, &auto_ds); if (ret) { LEAVE(); return ret; } ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set/Get sleep period * * @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_set_get_sleep_pd(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_pm_cfg *pm_cfg = MNULL; t_u16 cmd_action = 0, sleep_pd = 0; ENTER(); pm_cfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; cmd_action = HostCmd_ACT_GEN_GET; if (pioctl_req->action == MLAN_ACT_SET) { cmd_action = HostCmd_ACT_GEN_SET; sleep_pd = (t_u16)pm_cfg->param.sleep_period; } ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SLEEP_PERIOD, cmd_action, 0, (t_void *)pioctl_req, &sleep_pd); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set/Get PS configuration parameter * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_set_get_ps_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_pm_cfg *pm_cfg = MNULL; ENTER(); pm_cfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { pm_cfg->param.ps_cfg.ps_null_interval = (t_u32)pmadapter->null_pkt_interval; pm_cfg->param.ps_cfg.multiple_dtim_interval = (t_u32)pmadapter->multiple_dtim; pm_cfg->param.ps_cfg.listen_interval = (t_u32)pmadapter->local_listen_interval; pm_cfg->param.ps_cfg.bcn_miss_timeout = (t_u32)pmadapter->bcn_miss_time_out; pm_cfg->param.ps_cfg.delay_to_ps = (t_u32)pmadapter->delay_to_ps; pm_cfg->param.ps_cfg.ps_mode = (t_u32)pmadapter->enhanced_ps_mode; } else { if (pm_cfg->param.ps_cfg.ps_null_interval) pmadapter->null_pkt_interval = (t_u16)pm_cfg->param.ps_cfg.ps_null_interval; else pm_cfg->param.ps_cfg.ps_null_interval = (t_u32)pmadapter->null_pkt_interval; if (pm_cfg->param.ps_cfg.multiple_dtim_interval) pmadapter->multiple_dtim = (t_u16)pm_cfg->param.ps_cfg .multiple_dtim_interval; else pm_cfg->param.ps_cfg.multiple_dtim_interval = (t_u32)pmadapter->multiple_dtim; if (((t_s32)pm_cfg->param.ps_cfg.listen_interval) == MRVDRV_LISTEN_INTERVAL_DISABLE) pmadapter->local_listen_interval = 0; else if (pm_cfg->param.ps_cfg.listen_interval) pmadapter->local_listen_interval = (t_u16)pm_cfg->param.ps_cfg.listen_interval; else pm_cfg->param.ps_cfg.listen_interval = (t_u32)pmadapter->local_listen_interval; if (pm_cfg->param.ps_cfg.bcn_miss_timeout) pmadapter->bcn_miss_time_out = (t_u16)pm_cfg->param.ps_cfg.bcn_miss_timeout; else pm_cfg->param.ps_cfg.bcn_miss_timeout = (t_u32)pmadapter->bcn_miss_time_out; if (pm_cfg->param.ps_cfg.delay_to_ps != DELAY_TO_PS_UNCHANGED) pmadapter->delay_to_ps = (t_u16)pm_cfg->param.ps_cfg.delay_to_ps; else pm_cfg->param.ps_cfg.delay_to_ps = (t_u32)pmadapter->delay_to_ps; if (pm_cfg->param.ps_cfg.ps_mode) pmadapter->enhanced_ps_mode = (t_u16)pm_cfg->param.ps_cfg.ps_mode; else pm_cfg->param.ps_cfg.ps_mode = (t_u32)pmadapter->enhanced_ps_mode; } pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Set/Get PS configuration parameter * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_set_get_bcn_timeout(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_pm_cfg *pm_cfg = MNULL; ENTER(); pm_cfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; /* Send command to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_PS_MODE_ENH, EN_AUTO_PS, BITMAP_BCN_TMO, (t_void *)pioctl_req, &pm_cfg->param.bcn_timeout); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Get/Set the sleep parameters * * @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_set_get_sleep_params(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_pm_cfg *pm_cfg = MNULL; t_u16 cmd_action = 0; ENTER(); pm_cfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; cmd_action = HostCmd_ACT_GEN_GET; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; /* Send command to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SLEEP_PARAMS, cmd_action, 0, (t_void *)pioctl_req, &pm_cfg->param.sleep_params); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief config management frame wakeup filter * * @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_config_mgmt_filter(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_pm_cfg *pm_cfg = MNULL; int i = 0; ENTER(); memset(pmadapter, pmadapter->mgmt_filter, 0, sizeof(mlan_mgmt_frame_wakeup) * MAX_MGMT_FRAME_FILTER); pm_cfg = (mlan_ds_pm_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) { for (i = 0; i < MAX_MGMT_FRAME_FILTER; i++) if (!pm_cfg->param.mgmt_filter[i].type) break; memcpy_ext(pmadapter, (t_u8 *)pmadapter->mgmt_filter, (t_u8 *)pm_cfg->param.mgmt_filter, (i + 1) * sizeof(mlan_mgmt_frame_wakeup), sizeof(pmadapter->mgmt_filter)); } else if (pioctl_req->action == MLAN_ACT_GET) PRINTM(MERROR, "Get not support\n"); LEAVE(); return ret; } /** * @brief Power save command handler * * @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_pm_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_pm_cfg *pm = MNULL; 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; switch (pm->sub_command) { case MLAN_OID_PM_CFG_IEEE_PS: switch (pioctl_req->action) { case MLAN_ACT_SET: /**Block ieee power save disable command when bt coex * enable*/ if (pmadapter->coex_scan && !pm->param.ps_mode) break; if (pm->param.ps_mode) pmadapter->ps_mode = Wlan802_11PowerModePSP; else pmadapter->ps_mode = Wlan802_11PowerModeCAM; status = wlan_pm_ioctl_ps_mode(pmadapter, pioctl_req, pmadapter->ps_mode); break; case MLAN_ACT_GET: status = wlan_pm_ioctl_ps_mode(pmadapter, pioctl_req, pmadapter->ps_mode); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } break; case MLAN_OID_PM_CFG_HS_CFG: status = wlan_pm_ioctl_hscfg(pmadapter, pioctl_req); break; case MLAN_OID_PM_CFG_INACTIVITY_TO: status = wlan_pm_ioctl_inactivity_timeout(pmadapter, pioctl_req); break; case MLAN_OID_PM_CFG_DEEP_SLEEP: switch (pioctl_req->action) { case MLAN_ACT_SET: if (pmadapter->is_deep_sleep && pm->param.auto_deep_sleep.auto_ds == DEEP_SLEEP_ON) { PRINTM(MMSG, "Station already in enhanced deep sleep mode\n"); status = MLAN_STATUS_FAILURE; break; } else if (!pmadapter->is_deep_sleep && pm->param.auto_deep_sleep.auto_ds == DEEP_SLEEP_OFF) { PRINTM(MMSG, "Station already not in enhanced deep sleep mode\n"); status = MLAN_STATUS_FAILURE; break; } status = wlan_set_auto_deep_sleep(pmadapter, pioctl_req); break; case MLAN_ACT_GET: if (pmadapter->is_deep_sleep) { pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_ON; pm->param.auto_deep_sleep.idletime = pmadapter->idle_time; } else pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_OFF; break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } break; case MLAN_OID_PM_CFG_PS_CFG: status = wlan_set_get_ps_cfg(pmadapter, pioctl_req); break; case MLAN_OID_PM_CFG_SLEEP_PD: status = wlan_set_get_sleep_pd(pmadapter, pioctl_req); break; case MLAN_OID_PM_CFG_SLEEP_PARAMS: status = wlan_set_get_sleep_params(pmadapter, pioctl_req); break; case MLAN_OID_PM_INFO: status = wlan_get_pm_info(pmadapter, pioctl_req); break; case MLAN_OID_PM_HS_WAKEUP_REASON: status = wlan_get_hs_wakeup_reason(pmadapter, pioctl_req); break; case MLAN_OID_PM_MGMT_FILTER: status = wlan_config_mgmt_filter(pmadapter, pioctl_req); break; case MLAN_OID_PM_CFG_BCN_TIMEOUT: status = wlan_set_get_bcn_timeout(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Set/Get WPA IE * * @param priv A pointer to mlan_private structure * @param ie_data_ptr A pointer to IE * @param ie_len Length of the IE * * @return MLAN_STATUS_SUCCESS --success, otherwise fail */ static mlan_status wlan_set_wpa_ie_helper(mlan_private *priv, t_u8 *ie_data_ptr, t_u16 ie_len) { ENTER(); if (ie_len) { if (ie_len > sizeof(priv->wpa_ie)) { PRINTM(MERROR, "failed to copy, WPA IE is too big\n"); LEAVE(); return MLAN_STATUS_FAILURE; } memcpy_ext(priv->adapter, priv->wpa_ie, ie_data_ptr, ie_len, sizeof(priv->wpa_ie)); priv->wpa_ie_len = (t_u8)ie_len; PRINTM(MIOCTL, "Set Wpa_ie_len=%d IE=%#x\n", priv->wpa_ie_len, priv->wpa_ie[0]); DBG_HEXDUMP(MCMD_D, "Wpa_ie", priv->wpa_ie, priv->wpa_ie_len); if (priv->wpa_ie[0] == WPA_IE) { priv->sec_info.wpa_enabled = MTRUE; } else if (priv->wpa_ie[0] == RSN_IE) { priv->sec_info.wpa2_enabled = MTRUE; } else { priv->sec_info.wpa_enabled = MFALSE; priv->sec_info.wpa2_enabled = MFALSE; } } else { memset(priv->adapter, priv->wpa_ie, 0, sizeof(priv->wpa_ie)); priv->wpa_ie_len = 0; PRINTM(MINFO, "Reset Wpa_ie_len=%d IE=%#x\n", priv->wpa_ie_len, priv->wpa_ie[0]); priv->sec_info.wpa_enabled = MFALSE; priv->sec_info.wpa2_enabled = MFALSE; } LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Set OSEN IE * * @param priv A pointer to mlan_private structure * @param ie_data_ptr A pointer to IE * @param ie_len Length of the IE * * @return MLAN_STATUS_SUCCESS --success, otherwise fail */ static mlan_status wlan_set_osen_ie(mlan_private *priv, t_u8 *ie_data_ptr, t_u16 ie_len) { ENTER(); if (ie_len) { if (ie_len > sizeof(priv->osen_ie)) { PRINTM(MWARN, "failed to copy, WAPI IE is too big\n"); LEAVE(); return MLAN_STATUS_FAILURE; } memcpy_ext(priv->adapter, priv->osen_ie, ie_data_ptr, ie_len, sizeof(priv->osen_ie)); priv->osen_ie_len = (t_u8)ie_len; PRINTM(MIOCTL, "Set osen_ie_len=%d IE=%#x\n", priv->osen_ie_len, priv->osen_ie[0]); DBG_HEXDUMP(MCMD_D, "osen_ie", priv->osen_ie, priv->osen_ie_len); priv->sec_info.osen_enabled = MTRUE; } else { memset(priv->adapter, priv->osen_ie, 0, sizeof(priv->osen_ie)); priv->osen_ie_len = (t_u8)ie_len; PRINTM(MINFO, "Reset osen_ie_len=%d IE=%#x\n", priv->osen_ie_len, priv->osen_ie[0]); priv->sec_info.osen_enabled = MFALSE; } LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Set WAPI IE * * @param priv A pointer to mlan_private structure * @param ie_data_ptr A pointer to IE * @param ie_len Length of the IE * * @return MLAN_STATUS_SUCCESS --success, otherwise fail */ static mlan_status wlan_set_wapi_ie(mlan_private *priv, t_u8 *ie_data_ptr, t_u16 ie_len) { ENTER(); if (ie_len) { if (ie_len > sizeof(priv->wapi_ie)) { PRINTM(MWARN, "failed to copy, WAPI IE is too big\n"); LEAVE(); return MLAN_STATUS_FAILURE; } memcpy_ext(priv->adapter, priv->wapi_ie, ie_data_ptr, ie_len, sizeof(priv->wapi_ie)); priv->wapi_ie_len = (t_u8)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 = (t_u8)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; } LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Set/Get WAPI status * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_sec_ioctl_wapi_enable(pmlan_adapter pmadapter, 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_GET) { if (pmpriv->wapi_ie_len) sec->param.wapi_enabled = MTRUE; else sec->param.wapi_enabled = MFALSE; } else { if (sec->param.wapi_enabled == MFALSE) wlan_set_wapi_ie(pmpriv, MNULL, 0); } pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Set WAPI key * * @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_sec_ioctl_set_wapi_key(pmlan_adapter pmadapter, 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; 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 Set/Get Port Control status * * @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_sec_ioctl_port_ctrl_enable(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_sec_cfg *sec = MNULL; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) { if (pmpriv->port_ctrl_mode) sec->param.port_ctrl_enabled = MTRUE; else sec->param.port_ctrl_enabled = MFALSE; } else { if (sec->param.port_ctrl_enabled) { pmpriv->port_ctrl_mode = MTRUE; pmpriv->port_open = MFALSE; } else { if (pmpriv->port_ctrl_mode == MTRUE) { pmpriv->port_ctrl_mode = MFALSE; /* Cleanup the bypass TX queue */ wlan_cleanup_bypass_txq(pmpriv); } } } PRINTM(MINFO, "port_ctrl: port_ctrl_mode=%d port_open=%d\n", pmpriv->port_ctrl_mode, pmpriv->port_open); LEAVE(); return ret; } /** * @brief Set/Get authentication mode * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_sec_ioctl_auth_mode(pmlan_adapter pmadapter, 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_GET) sec->param.auth_mode = pmpriv->sec_info.authentication_mode; else pmpriv->sec_info.authentication_mode = sec->param.auth_mode; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Set/Get encryption mode * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_sec_ioctl_encrypt_mode(pmlan_adapter pmadapter, 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_GET) sec->param.encrypt_mode = pmpriv->sec_info.encryption_mode; else pmpriv->sec_info.encryption_mode = sec->param.encrypt_mode; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Get Random charactor * * @param pmadapter A pointer to mlan_adapter structure * * @return random charactor */ static t_u8 wlan_get_random_charactor(pmlan_adapter pmadapter) { t_u32 sec, usec; t_u8 ch = 0; ENTER(); pmadapter->callbacks.moal_get_system_time(pmadapter->pmoal_handle, &sec, &usec); sec = (sec & 0xFFFF) + (sec >> 16); usec = (usec & 0xFFFF) + (usec >> 16); ch = (((sec << 16) + usec) % 26) + 'a'; LEAVE(); return ch; } /** * @brief Set/Get WPA status * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_sec_ioctl_wpa_enable(pmlan_adapter pmadapter, 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_GET) { if (pmpriv->wpa_ie_len) sec->param.wpa_enabled = MTRUE; else sec->param.wpa_enabled = MFALSE; } else { if (sec->param.wpa_enabled == MFALSE) wlan_set_wpa_ie_helper(pmpriv, MNULL, 0); } pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Set WEP keys * * @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_sec_ioctl_set_wep_key(pmlan_adapter pmadapter, 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; mrvl_wep_key_t *pwep_key = MNULL; int index; int i = 0; ENTER(); if (pmpriv->wep_key_curr_index >= MRVL_NUM_WEP_KEY) pmpriv->wep_key_curr_index = 0; pwep_key = &pmpriv->wep_key[pmpriv->wep_key_curr_index]; sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; if (sec->param.encrypt_key.key_index == MLAN_KEY_INDEX_DEFAULT) { index = pmpriv->wep_key_curr_index; sec->param.encrypt_key.key_index = index; } else { if (sec->param.encrypt_key.key_index >= MRVL_NUM_WEP_KEY) { if ((sec->param.encrypt_key.key_remove == MTRUE) && (sec->param.encrypt_key.key_index <= 5)) { /* call firmware remove key */ ret = wlan_prepare_cmd( pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &sec->param.encrypt_key); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; goto exit; } PRINTM(MERROR, "Key_index is invalid\n"); ret = MLAN_STATUS_FAILURE; goto exit; } index = sec->param.encrypt_key.key_index; } if ((sec->param.encrypt_key.key_disable == MTRUE) || (sec->param.encrypt_key.key_remove == MTRUE)) { pmpriv->sec_info.wep_status = Wlan802_11WEPDisabled; /* remove key */ if (sec->param.encrypt_key.key_remove == MTRUE) { memset(pmadapter, &pmpriv->wep_key[index], 0, sizeof(mrvl_wep_key_t)); /* call firmware remove key */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_SET, 0, MNULL, &sec->param.encrypt_key); if (ret) goto exit; } } else { if (sec->param.encrypt_key.key_len) { if ((sec->param.encrypt_key.key_len != WEP_104_BIT_LEN) && (sec->param.encrypt_key.key_len != WEP_40_BIT_LEN)) { PRINTM(MERROR, "Invalid wep key len=%d\n", sec->param.encrypt_key.key_len); /* We will use random key to clear the key * buffer in FW */ if (sec->param.encrypt_key.key_len < WEP_40_BIT_LEN) sec->param.encrypt_key.key_len = WEP_40_BIT_LEN; else sec->param.encrypt_key.key_len = WEP_104_BIT_LEN; for (i = 0; i < (int)sec->param.encrypt_key.key_len; i++) sec->param.encrypt_key.key_material[i] = wlan_get_random_charactor( pmadapter); } pwep_key = &pmpriv->wep_key[index]; /* Cleanup */ memset(pmadapter, pwep_key, 0, sizeof(mrvl_wep_key_t)); /* Copy the key in the driver */ memcpy_ext(pmadapter, pwep_key->key_material, sec->param.encrypt_key.key_material, sec->param.encrypt_key.key_len, MRVL_KEY_BUFFER_SIZE_IN_BYTE); pwep_key->key_index = index; pwep_key->key_length = sec->param.encrypt_key.key_len; if (pmpriv->sec_info.wep_status != Wlan802_11WEPEnabled) { /* * The status is set as Key Absent * so as to make sure we display the * keys when iwlist mlanX key is used */ pmpriv->sec_info.wep_status = Wlan802_11WEPKeyAbsent; } } if (sec->param.encrypt_key.is_current_wep_key == MTRUE) { /* Copy the required key as the current key */ pwep_key = &pmpriv->wep_key[index]; if (!pwep_key->key_length) { if (pmpriv->sec_info.wpa_enabled || pmpriv->sec_info.wpa2_enabled || pmpriv->sec_info.wapi_enabled) { ret = MLAN_STATUS_SUCCESS; goto exit; } PRINTM(MERROR, "Key %d not set,so cannot enable it\n", index); pioctl_req->status_code = MLAN_ERROR_CMD_RESP_FAIL; ret = MLAN_STATUS_FAILURE; goto exit; } pmpriv->wep_key_curr_index = (t_u16)index; pmpriv->sec_info.wep_status = Wlan802_11WEPEnabled; } if (sec->param.encrypt_key.key_flags && pwep_key->key_length) { pmpriv->wep_key_curr_index = (t_u16)index; // Only do this if the key is an xmit key. If the key // is a group key, we might be in wpa/wep mixed mode in // which case we don't want to set wep_status = // Wlan802_11WEPEnabled because that enables WEP at the // MAC controller level and WPA stops working properly. if (sec->param.encrypt_key.key_flags & KEY_FLAG_SET_TX_KEY) { pmpriv->sec_info.wep_status = Wlan802_11WEPEnabled; } } } if (pmpriv->sec_info.wep_status == Wlan802_11WEPEnabled) pmpriv->curr_pkt_filter |= HostCmd_ACT_MAC_WEP_ENABLE; else pmpriv->curr_pkt_filter &= ~HostCmd_ACT_MAC_WEP_ENABLE; /* Send request to firmware */ if (pmpriv->sec_info.wep_status == Wlan802_11WEPEnabled && pwep_key->key_length) { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_MAC_CONTROL, HostCmd_ACT_GEN_SET, 0, MNULL, &pmpriv->curr_pkt_filter); if (ret) goto exit; if (!sec->param.encrypt_key.key_len) { sec->param.encrypt_key.key_index = pwep_key->key_index; sec->param.encrypt_key.key_len = pwep_key->key_length; memcpy_ext(pmadapter, sec->param.encrypt_key.key_material, pwep_key->key_material, sec->param.encrypt_key.key_len, MLAN_MAX_KEY_LENGTH); } ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &sec->param.encrypt_key); } else { if (pwep_key->key_length) { if (!sec->param.encrypt_key.key_len) { sec->param.encrypt_key.key_index = pwep_key->key_index; sec->param.encrypt_key.key_len = pwep_key->key_length; memcpy_ext(pmadapter, sec->param.encrypt_key.key_material, pwep_key->key_material, sec->param.encrypt_key.key_len, MLAN_MAX_KEY_LENGTH); } ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_SET, 0, MNULL, &sec->param.encrypt_key); if (ret) goto exit; } ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_MAC_CONTROL, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &pmpriv->curr_pkt_filter); } if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Set WPA key * * @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_sec_ioctl_set_wpa_key(pmlan_adapter pmadapter, 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; /* Current driver only supports key length of up to 32 bytes */ if (sec->param.encrypt_key.key_len > MLAN_MAX_KEY_LENGTH) { PRINTM(MERROR, "Key length is incorrect\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, &sec->param.encrypt_key); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Get security keys * * @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_sec_ioctl_get_key(pmlan_adapter pmadapter, 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; int index; ENTER(); sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; if (pmpriv->wep_key_curr_index >= MRVL_NUM_WEP_KEY) pmpriv->wep_key_curr_index = 0; if ((pmpriv->sec_info.wep_status == Wlan802_11WEPEnabled) || (pmpriv->sec_info.wep_status == Wlan802_11WEPKeyAbsent) || pmpriv->sec_info.ewpa_enabled || pmpriv->sec_info.wpa_enabled || pmpriv->sec_info.wpa2_enabled) { sec->param.encrypt_key.key_disable = MFALSE; } else { sec->param.encrypt_key.key_disable = MTRUE; } if (sec->param.encrypt_key.key_index == MLAN_KEY_INDEX_DEFAULT) { if ((pmpriv->wep_key[pmpriv->wep_key_curr_index].key_length) && (pmpriv->sec_info.wep_status == Wlan802_11WEPEnabled)) { index = pmpriv->wep_key_curr_index; sec->param.encrypt_key.key_index = pmpriv->wep_key[index].key_index; memcpy_ext(pmadapter, sec->param.encrypt_key.key_material, pmpriv->wep_key[index].key_material, pmpriv->wep_key[index].key_length, MLAN_MAX_KEY_LENGTH); sec->param.encrypt_key.key_len = MIN(MLAN_MAX_KEY_LENGTH, pmpriv->wep_key[index].key_length); } else if ((pmpriv->sec_info.wpa_enabled) || (pmpriv->sec_info.ewpa_enabled) || (pmpriv->sec_info.wpa2_enabled) || (pmpriv->sec_info.wapi_enabled)) { /* Return WPA enabled */ sec->param.encrypt_key.key_disable = MFALSE; memcpy_ext(pmadapter, sec->param.encrypt_key.key_material, pmpriv->aes_key.key_material, pmpriv->aes_key.key_len, MLAN_MAX_KEY_LENGTH); sec->param.encrypt_key.key_len = MIN( MLAN_MAX_KEY_LENGTH, pmpriv->aes_key.key_len); } else { sec->param.encrypt_key.key_disable = MTRUE; } } else { index = sec->param.encrypt_key.key_index; if (pmpriv->wep_key[index].key_length) { sec->param.encrypt_key.key_index = pmpriv->wep_key[index].key_index; memcpy_ext(pmadapter, sec->param.encrypt_key.key_material, pmpriv->wep_key[index].key_material, pmpriv->wep_key[index].key_length, MLAN_MAX_KEY_LENGTH); sec->param.encrypt_key.key_len = MIN(MLAN_MAX_KEY_LENGTH, pmpriv->wep_key[index].key_length); } else if ((pmpriv->sec_info.wpa_enabled) || (pmpriv->sec_info.ewpa_enabled) || (pmpriv->sec_info.wpa2_enabled) || (pmpriv->sec_info.wapi_enabled)) { /* Return WPA enabled */ sec->param.encrypt_key.key_disable = MFALSE; } else { sec->param.encrypt_key.key_disable = MTRUE; } } LEAVE(); return ret; } /** * @brief Set security key(s) * * @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_sec_ioctl_encrypt_key(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_sec_cfg *sec = MNULL; ENTER(); sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) { if (sec->param.encrypt_key.is_wapi_key) status = wlan_sec_ioctl_set_wapi_key(pmadapter, pioctl_req); else if (sec->param.encrypt_key.key_len > MAX_WEP_KEY_SIZE) status = wlan_sec_ioctl_set_wpa_key(pmadapter, pioctl_req); else status = wlan_sec_ioctl_set_wep_key(pmadapter, pioctl_req); } else { status = wlan_sec_ioctl_get_key(pmadapter, pioctl_req); } LEAVE(); return status; } /** * @brief Query Encrpyt key * * @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_sec_ioctl_query_key(pmlan_adapter pmadapter, 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; /* Current driver only supports get PTK/GTK */ if (pmpriv->port_open && (pmpriv->sec_info.wpa_enabled || pmpriv->sec_info.wpa2_enabled || pmpriv->sec_info.wapi_enabled)) { /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_KEY_MATERIAL, HostCmd_ACT_GEN_GET, KEY_INFO_ENABLED, (t_void *)pioctl_req, &sec->param.encrypt_key); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } LEAVE(); return ret; } /** * @brief Set/Get esupplicant status * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_sec_ioctl_ewpa_enable(pmlan_adapter pmadapter, 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_GET) { sec->param.ewpa_enabled = pmpriv->sec_info.ewpa_enabled; } else { pmpriv->sec_info.ewpa_enabled = (t_u8)sec->param.ewpa_enabled; PRINTM(MINFO, "Set: ewpa_enabled = %d\n", (int)pmpriv->sec_info.ewpa_enabled); } pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Get esupplicant 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_sec_ioctl_esupp_mode(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; t_u16 cmd_action = 0; mlan_ds_sec_cfg *sec = MNULL; ENTER(); sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) { cmd_action = HostCmd_ACT_GEN_SET; if (pmpriv->media_connected == MTRUE) { PRINTM(MERROR, "Cannot set esupplicant mode configuration while connected.\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } if (!sec->param.esupp_mode.rsn_mode || (sec->param.esupp_mode.rsn_mode & RSN_TYPE_VALID_BITS) != sec->param.esupp_mode.rsn_mode) { PRINTM(MERROR, "Invalid RSN mode\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } if (!sec->param.esupp_mode.act_paircipher || (sec->param.esupp_mode.act_paircipher & EMBED_CIPHER_VALID_BITS) != sec->param.esupp_mode.act_paircipher) { PRINTM(MERROR, "Invalid pairwise cipher\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } if (!sec->param.esupp_mode.act_groupcipher || (sec->param.esupp_mode.act_groupcipher & EMBED_CIPHER_VALID_BITS) != sec->param.esupp_mode.act_groupcipher) { PRINTM(MERROR, "Invalid group cipher\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } } else { cmd_action = HostCmd_ACT_GEN_GET_CURRENT; } /* Send request to firmware */ if (sec) { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_SUPPLICANT_PROFILE, cmd_action, 0, (t_void *)pioctl_req, &sec->param.esupp_mode); } else { ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_SUPPLICANT_PROFILE, cmd_action, 0, (t_void *)pioctl_req, MNULL); } if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Security configuration handler * * @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_sec_cfg_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_sec_cfg *sec = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_sec_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_sec_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } sec = (mlan_ds_sec_cfg *)pioctl_req->pbuf; switch (sec->sub_command) { case MLAN_OID_SEC_CFG_AUTH_MODE: status = wlan_sec_ioctl_auth_mode(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_ENCRYPT_MODE: status = wlan_sec_ioctl_encrypt_mode(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_WPA_ENABLED: status = wlan_sec_ioctl_wpa_enable(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_WAPI_ENABLED: status = wlan_sec_ioctl_wapi_enable(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_PORT_CTRL_ENABLED: status = wlan_sec_ioctl_port_ctrl_enable(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_ENCRYPT_KEY: status = wlan_sec_ioctl_encrypt_key(pmadapter, pioctl_req); break; case MLAN_OID_SEC_QUERY_KEY: status = wlan_sec_ioctl_query_key(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_PASSPHRASE: status = wlan_sec_ioctl_passphrase(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_EWPA_ENABLED: status = wlan_sec_ioctl_ewpa_enable(pmadapter, pioctl_req); break; case MLAN_OID_SEC_CFG_ESUPP_MODE: status = wlan_sec_ioctl_esupp_mode(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Append/Reset IE buffer. * * Pass an opaque block of data, expected to be IEEE IEs, to the driver * for eventual passthrough to the firmware in an associate/join * (and potentially start) command. This function is the main body * for both wlan_set_gen_ie_ioctl and wlan_set_gen_ie * * Data is appended to an existing buffer and then wrapped in a passthrough * TLV in the command API to the firmware. The firmware treats the data * as a transparent passthrough to the transmitted management frame. * * @param priv A pointer to mlan_private structure * @param ie_data_ptr A pointer to iwreq structure * @param ie_len Length of the IE or IE block passed in ie_data_ptr * * @return MLAN_STATUS_SUCCESS --success, otherwise fail */ static int wlan_set_gen_ie_helper(mlan_private *priv, t_u8 *ie_data_ptr, t_u16 ie_len) { mlan_status ret = MLAN_STATUS_SUCCESS; IEEEtypes_VendorHeader_t *pvendor_ie; const t_u8 wpa_oui[] = {0x00, 0x50, 0xf2, 0x01}; const t_u8 wps_oui[] = {0x00, 0x50, 0xf2, 0x04}; const t_u8 osen_oui[] = {0x50, 0x6f, 0x9a, 0x12}; t_u8 i = 0, temp[12] = {0}; ENTER(); /* If the passed length is zero, reset the buffer */ if (!ie_len) { priv->gen_ie_buf_len = 0; priv->wps.session_enable = MFALSE; wlan_set_wpa_ie_helper(priv, MNULL, 0); wlan_set_wapi_ie(priv, MNULL, 0); wlan_set_osen_ie(priv, MNULL, 0); } else if (!ie_data_ptr) { /* MNULL check */ ret = MLAN_STATUS_FAILURE; } else { pvendor_ie = (IEEEtypes_VendorHeader_t *)ie_data_ptr; if (pvendor_ie->element_id == EXT_CAPABILITY) { memcpy_ext(priv->adapter, temp, &priv->ext_cap, sizeof(priv->ext_cap), sizeof(temp)); for (i = 0; i < MIN(sizeof(priv->ext_cap), pvendor_ie->len); i++) temp[i] |= ie_data_ptr[2 + i]; memcpy_ext(priv->adapter, &priv->ext_cap, temp, sizeof(temp), sizeof(priv->ext_cap)); } else /* Test to see if it is a WPA IE, if not, then it is a gen IE*/ if (((pvendor_ie->element_id == WPA_IE) && (!memcmp(priv->adapter, pvendor_ie->oui, wpa_oui, sizeof(wpa_oui)))) || (pvendor_ie->element_id == RSN_IE)) { /* IE is a WPA/WPA2 IE so call set_wpa function */ ret = wlan_set_wpa_ie_helper(priv, ie_data_ptr, ie_len); priv->wps.session_enable = MFALSE; } else if (pvendor_ie->element_id == WAPI_IE) { /* IE is a WAPI IE so call set_wapi function */ ret = wlan_set_wapi_ie(priv, ie_data_ptr, ie_len); } else if ((pvendor_ie->element_id == VENDOR_SPECIFIC_221) && (!memcmp(priv->adapter, pvendor_ie->oui, osen_oui, sizeof(osen_oui)))) { /* IE is a OSEN IE so call set_osen function */ ret = wlan_set_osen_ie(priv, ie_data_ptr, ie_len); } else if ((pvendor_ie->element_id == WPS_IE) && (priv->wps.session_enable == MFALSE) && (!memcmp(priv->adapter, pvendor_ie->oui, wps_oui, sizeof(wps_oui)))) { /* * Discard first two byte (Element ID and Length) * because they are not needed in the case of setting * WPS_IE */ if (pvendor_ie->len > 4) { memcpy_ext(priv->adapter, (t_u8 *)&priv->wps.wps_ie, ie_data_ptr, ie_len, sizeof(IEEEtypes_VendorSpecific_t)); HEXDUMP("wps_ie", (t_u8 *)&priv->wps.wps_ie, priv->wps.wps_ie.vend_hdr.len + 2); } else { /* Only wps oui exist, reset driver wps buffer */ memset(priv->adapter, (t_u8 *)&priv->wps.wps_ie, 0x00, sizeof(priv->wps.wps_ie)); PRINTM(MINFO, "wps_ie cleared\n"); } } else { /* * Verify that the passed length is not larger than * the available space remaining in the buffer */ if (ie_len < (sizeof(priv->gen_ie_buf) - priv->gen_ie_buf_len)) { /* Test to see if it is a WPS IE, if so, enable * wps session flag */ pvendor_ie = (IEEEtypes_VendorHeader_t *)ie_data_ptr; if ((pvendor_ie->element_id == WPS_IE) && (!memcmp(priv->adapter, pvendor_ie->oui, wps_oui, sizeof(wps_oui)))) { priv->wps.session_enable = MTRUE; PRINTM(MINFO, "WPS Session Enabled.\n"); } /* Append the passed data to the end of * the genIeBuffer */ memcpy_ext(priv->adapter, priv->gen_ie_buf + priv->gen_ie_buf_len, ie_data_ptr, ie_len, MRVDRV_GENIE_BUF_SIZE - priv->gen_ie_buf_len); /* Increment the stored buffer length by * the size passed */ priv->gen_ie_buf_len += ie_len; } else { /* Passed data does not fit in the * remaining buffer space */ ret = MLAN_STATUS_FAILURE; } } } /* Return MLAN_STATUS_SUCCESS, or MLAN_STATUS_FAILURE for error case */ LEAVE(); return ret; } /** * @brief Set/Get WWS 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_misc_ioctl_wws_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_misc_cfg *misc_cfg = MNULL; t_u16 cmd_action = 0; t_u32 enable = 0; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_misc_cfg)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_misc_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_RESOURCE; goto exit; } misc_cfg = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else cmd_action = HostCmd_ACT_GEN_GET; enable = misc_cfg->param.wws_cfg; /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SNMP_MIB, cmd_action, WwsMode_i, (t_void *)pioctl_req, &enable); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; exit: LEAVE(); return ret; } /** * @brief Set/Get 11D status * * @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_11d_cfg_ioctl_enable(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_11d_cfg *pcfg_11d = MNULL; ENTER(); pcfg_11d = (mlan_ds_11d_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) { if (pmpriv->media_connected == MTRUE) { PRINTM(MIOCTL, "11D setting cannot be changed while interface is active.\n"); ret = MLAN_STATUS_FAILURE; goto done; } PRINTM(MINFO, "11D: 11dcfg SET=%d\n", pcfg_11d->param.enable_11d); /* Compare with current settings */ if (pmpriv->state_11d.user_enable_11d != pcfg_11d->param.enable_11d) { ret = wlan_11d_enable( pmpriv, pioctl_req, (state_11d_t)pcfg_11d->param.enable_11d); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } else { PRINTM(MINFO, "11D: same as current setting, do nothing\n"); } } else { pcfg_11d->param.enable_11d = (t_u32)pmpriv->state_11d.user_enable_11d; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; PRINTM(MINFO, "11D: 11dcfg GET=%d\n", pcfg_11d->param.enable_11d); } done: LEAVE(); return ret; } /** * @brief Clear 11D chan table * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_11d_clr_chan_table(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); if (pioctl_req->action == MLAN_ACT_SET) { PRINTM(MINFO, "11D: 11dclrtbl SET\n"); if (wlan_11d_clear_parsedtable(pmpriv) == MLAN_STATUS_SUCCESS) PRINTM(MINFO, "11D: cleared parsed_region_chan (now no_of_chan=%d)\n", pmadapter->parsed_region_chan.no_of_chan); } LEAVE(); return ret; } /** * @brief 11D configuration handler * * @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_11d_cfg_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_11d_cfg *pcfg_11d = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_11d_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_11d_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; status = MLAN_STATUS_RESOURCE; goto exit; } pcfg_11d = (mlan_ds_11d_cfg *)pioctl_req->pbuf; switch (pcfg_11d->sub_command) { case MLAN_OID_11D_CFG_ENABLE: status = wlan_11d_cfg_ioctl_enable(pmadapter, pioctl_req); break; case MLAN_OID_11D_CLR_CHAN_TABLE: status = wlan_11d_clr_chan_table(pmadapter, pioctl_req); break; case MLAN_OID_11D_DOMAIN_INFO_EXT: status = wlan_11d_cfg_domain_info(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } exit: LEAVE(); return status; } /** * @brief WPS configuration handler * * @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_wps_cfg_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_wps_cfg *pwps = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_wps_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_wps_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } pwps = (mlan_ds_wps_cfg *)pioctl_req->pbuf; switch (pwps->sub_command) { case MLAN_OID_WPS_CFG_SESSION: if (pioctl_req->action == MLAN_ACT_SET) { if (pwps->param.wps_session == MLAN_WPS_CFG_SESSION_START) pmpriv->wps.session_enable = MTRUE; else pmpriv->wps.session_enable = MFALSE; } else { pwps->param.wps_session = (t_u32)pmpriv->wps.session_enable; pioctl_req->data_read_written = sizeof(t_u32); PRINTM(MINFO, "wpscfg GET=%d\n", pwps->param.wps_session); } break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief register memory access handler * * @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_reg_mem_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_reg_mem *reg_mem = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_reg_mem)) { PRINTM(MWARN, "MLAN REG_MEM IOCTL length is too short\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_reg_mem); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } reg_mem = (mlan_ds_reg_mem *)pioctl_req->pbuf; switch (reg_mem->sub_command) { case MLAN_OID_REG_RW: status = wlan_reg_mem_ioctl_reg_rw(pmadapter, pioctl_req); break; case MLAN_OID_EEPROM_RD: status = wlan_reg_mem_ioctl_read_eeprom(pmadapter, pioctl_req); break; case MLAN_OID_MEM_RW: status = wlan_reg_mem_ioctl_mem_rw(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief 802.11h ad-hoc start channel check * * @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_11h_channel_check_req(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = MNULL; mlan_status ret = MLAN_STATUS_FAILURE; t_u8 chan_width = CHAN_BW_20MHZ; Band_Config_t bandcfg; ENTER(); if (pioctl_req != MNULL) { pmpriv = pmadapter->priv[pioctl_req->bss_index]; } else { PRINTM(MERROR, "MLAN IOCTL information is not present\n"); LEAVE(); return MLAN_STATUS_FAILURE; } memset(pmadapter, &bandcfg, 0, sizeof(Band_Config_t)); pmpriv->adhoc_state = ADHOC_STARTING; if ((pmadapter->adhoc_start_band & BAND_A)) { if (pmpriv->intf_state_11h.adhoc_auto_sel_chan) pmpriv->adhoc_channel = wlan_11h_get_adhoc_start_channel(pmpriv); /* * Check if the region and channel requires a channel * availability check. */ if (wlan_11h_radar_detect_required(pmpriv, pmpriv->adhoc_channel) && !wlan_11h_is_channel_under_nop(pmadapter, pmpriv->adhoc_channel)) { /* * Radar detection is required for this channel, make * sure 11h is activated in the firmware */ ret = wlan_11h_activate(pmpriv, MNULL, MTRUE); ret = wlan_11h_config_master_radar_det(pmpriv, MTRUE); ret = wlan_11h_check_update_radar_det_state(pmpriv); /* Check for radar on the channel */ if ((pmadapter->chan_bandwidth == CHANNEL_BW_40MHZ_ABOVE) || (pmadapter->chan_bandwidth == CHANNEL_BW_40MHZ_BELOW)) { chan_width = CHAN_BW_40MHZ; if (pmadapter->chanrpt_param_bandcfg) { bandcfg.chan2Offset = pmadapter->chan_bandwidth; } } else if (pmadapter->chan_bandwidth == CHANNEL_BW_80MHZ) chan_width = CHAN_BW_80MHZ; if (pmadapter->chanrpt_param_bandcfg) { bandcfg.chanWidth = chan_width; bandcfg.chanBand = BAND_5GHZ; } else { *((t_u8 *)&bandcfg) = chan_width; } ret = wlan_11h_issue_radar_detect(pmpriv, pioctl_req, pmpriv->adhoc_channel, bandcfg); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; } } LEAVE(); return ret; } /** * @brief 802.11h set/get local power constraint * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS */ static mlan_status wlan_11h_ioctl_local_power_constraint(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_11h_cfg *ds_11hcfg = MNULL; t_s8 *plocalpower = &pmadapter->state_11h.usr_def_power_constraint; ENTER(); ds_11hcfg = (mlan_ds_11h_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) ds_11hcfg->param.usr_local_power_constraint = *plocalpower; else *plocalpower = ds_11hcfg->param.usr_local_power_constraint; LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief 11h configuration handler * * @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_11h_cfg_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_11h_cfg *ds_11hcfg = MNULL; ENTER(); if (pioctl_req->buf_len < sizeof(mlan_ds_11h_cfg)) { PRINTM(MWARN, "MLAN 11H IOCTL length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_11h_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } ds_11hcfg = (mlan_ds_11h_cfg *)pioctl_req->pbuf; switch (ds_11hcfg->sub_command) { case MLAN_OID_11H_CHANNEL_CHECK: status = wlan_11h_channel_check_req(pmadapter, pioctl_req); break; case MLAN_OID_11H_LOCAL_POWER_CONSTRAINT: status = wlan_11h_ioctl_local_power_constraint(pmadapter, pioctl_req); break; case MLAN_OID_11H_DFS_TESTING: status = wlan_11h_ioctl_dfs_testing(pmadapter, pioctl_req); break; case MLAN_OID_11H_DFS_W53_CFG: status = wlan_11h_ioctl_dfs_w53_cfg(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Set/Get generic IE * * @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_misc_ioctl_gen_ie(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; switch (misc->param.gen_ie.type) { case MLAN_IE_TYPE_GEN_IE: if (pioctl_req->action == MLAN_ACT_GET) { misc->param.gen_ie.len = pmpriv->wpa_ie_len; memcpy_ext(pmadapter, misc->param.gen_ie.ie_data, pmpriv->wpa_ie, misc->param.gen_ie.len, MAX_IE_SIZE); } else { wlan_set_gen_ie_helper(pmpriv, misc->param.gen_ie.ie_data, (t_u16)misc->param.gen_ie.len); } break; case MLAN_IE_TYPE_ARP_FILTER: memset(pmadapter, pmadapter->arp_filter, 0, sizeof(pmadapter->arp_filter)); if (misc->param.gen_ie.len > ARP_FILTER_MAX_BUF_SIZE) { pmadapter->arp_filter_size = 0; PRINTM(MERROR, "Invalid ARP Filter Size\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; } else if (misc->param.gen_ie.len <= sizeof(MrvlIEtypesHeader_t)) { pmadapter->arp_filter_size = 0; PRINTM(MINFO, "Clear ARP filter\n"); } else { memcpy_ext(pmadapter, pmadapter->arp_filter, misc->param.gen_ie.ie_data, misc->param.gen_ie.len, ARP_FILTER_MAX_BUF_SIZE); pmadapter->arp_filter_size = misc->param.gen_ie.len; HEXDUMP("ArpFilter", pmadapter->arp_filter, pmadapter->arp_filter_size); } break; default: PRINTM(MERROR, "Invalid IE type\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; } pioctl_req->data_read_written = sizeof(mlan_ds_misc_gen_ie) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return ret; } /** * @brief Perform warm reset * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_PENDING --success, MLAN_STATUS_FAILURE */ mlan_status wlan_misc_ioctl_warm_reset(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_callbacks pcb = &pmadapter->callbacks; pmlan_buffer pmbuf; t_s32 i = 0; mlan_ds_misc_cfg *misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; ENTER(); mlan_block_rx_process(pmadapter, MTRUE); /* Cancel all pending commands and complete ioctls */ if (misc->param.fw_reload) wlan_cancel_all_pending_cmd(pmadapter, MTRUE); /** Init all the head nodes and free all the locks here */ for (i = 0; i < pmadapter->priv_num; i++) wlan_free_priv(pmadapter->priv[i]); while ((pmbuf = (pmlan_buffer)util_dequeue_list( pmadapter->pmoal_handle, &pmadapter->rx_data_queue, pcb->moal_spin_lock, pcb->moal_spin_unlock))) { pmadapter->ops.data_complete(pmadapter, pmbuf, MLAN_STATUS_FAILURE); } pmadapter->rx_pkts_queued = 0; /* Initialize adapter structure */ wlan_init_adapter(pmadapter); pmadapter->hw_status = WlanHardwareStatusInitializing; /* Initialize private structures */ for (i = 0; i < pmadapter->priv_num; i++) { if (pmadapter->priv[i]) wlan_init_priv(pmadapter->priv[i]); } mlan_block_rx_process(pmadapter, MFALSE); if (misc->param.fw_reload != MTRUE) { /* Restart the firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_FUNC_SHUTDOWN, HostCmd_ACT_GEN_SET, 0, MNULL, MNULL); if (ret) goto done; } /* Issue firmware initialize commands for first BSS, * for other interfaces it will be called after getting * the last init command response of previous interface */ pmpriv = wlan_get_priv(pmadapter, MLAN_BSS_ROLE_ANY); if (!pmpriv) { ret = MLAN_STATUS_FAILURE; LEAVE(); return ret; } ret = wlan_adapter_get_hw_spec(pmpriv->adapter); if (ret == MLAN_STATUS_FAILURE) { LEAVE(); return ret; } ret = pmpriv->ops.init_cmd(pmpriv, MTRUE); if (ret == MLAN_STATUS_FAILURE) { LEAVE(); return ret; } if (ret == MLAN_STATUS_PENDING) pmadapter->pwarm_reset_ioctl_req = pioctl_req; done: LEAVE(); return ret; } #ifdef SDIO /** * @brief Reconfigure SDIO multiport aggregation parameters * * @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_misc_ioctl_sdio_mpa_ctrl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; mlan_ds_misc_sdio_mpa_ctrl *mpa_ctrl = MNULL; ENTER(); mpa_ctrl = &misc->param.mpa_ctrl; if (pioctl_req->action == MLAN_ACT_SET) { if (pmpriv->media_connected == MTRUE) { PRINTM(MMSG, "SDIO MPA CTRL: not allowed in connected state\n"); pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; ret = MLAN_STATUS_FAILURE; goto exit; } if (mpa_ctrl->tx_enable > 1) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } if (mpa_ctrl->rx_enable > 1) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } if (mpa_ctrl->tx_max_ports > SDIO_MP_AGGR_DEF_PKT_LIMIT) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } if (mpa_ctrl->rx_max_ports > SDIO_MP_AGGR_DEF_PKT_LIMIT) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto exit; } if (mpa_ctrl->tx_buf_size || mpa_ctrl->rx_buf_size) { wlan_free_sdio_mpa_buffers(pmadapter); if (mpa_ctrl->tx_buf_size > 0) pmadapter->pcard_sd->mpa_tx.buf_size = mpa_ctrl->tx_buf_size; if (mpa_ctrl->rx_buf_size > 0) pmadapter->pcard_sd->mpa_rx.buf_size = mpa_ctrl->rx_buf_size; if (wlan_alloc_sdio_mpa_buffers( pmadapter, pmadapter->pcard_sd->mpa_tx.buf_size, pmadapter->pcard_sd->mpa_rx.buf_size) != MLAN_STATUS_SUCCESS) { PRINTM(MERROR, "Failed to allocate sdio mp-a buffers\n"); pioctl_req->status_code = MLAN_ERROR_NO_MEM; ret = MLAN_STATUS_FAILURE; goto exit; } } if (mpa_ctrl->tx_max_ports > 0) pmadapter->pcard_sd->mpa_tx.pkt_aggr_limit = mpa_ctrl->tx_max_ports; if (mpa_ctrl->rx_max_ports > 0) pmadapter->pcard_sd->mpa_rx.pkt_aggr_limit = mpa_ctrl->rx_max_ports; pmadapter->pcard_sd->mpa_tx.enabled = (t_u8)mpa_ctrl->tx_enable; pmadapter->pcard_sd->mpa_rx.enabled = (t_u8)mpa_ctrl->rx_enable; } else { mpa_ctrl->tx_enable = (t_u16)pmadapter->pcard_sd->mpa_tx.enabled; mpa_ctrl->rx_enable = (t_u16)pmadapter->pcard_sd->mpa_rx.enabled; mpa_ctrl->tx_buf_size = (t_u16)pmadapter->pcard_sd->mpa_tx.buf_size; mpa_ctrl->rx_buf_size = (t_u16)pmadapter->pcard_sd->mpa_rx.buf_size; mpa_ctrl->tx_max_ports = (t_u16)pmadapter->pcard_sd->mpa_tx.pkt_aggr_limit; mpa_ctrl->rx_max_ports = (t_u16)pmadapter->pcard_sd->mpa_rx.pkt_aggr_limit; } exit: LEAVE(); return ret; } #endif /** * @brief Set/Get system clock configuration * * @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_misc_ioctl_sysclock(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; t_u16 cmd_action = 0; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_GET) cmd_action = HostCmd_ACT_GEN_GET; else cmd_action = HostCmd_ACT_GEN_SET; /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_ECL_SYSTEM_CLOCK_CONFIG, cmd_action, 0, (t_void *)pioctl_req, (t_void *)&misc->param.sys_clock); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Get the associate response * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_misc_ioctl_get_assoc_rsp(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_misc_cfg *misc = MNULL; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if ((pioctl_req->action == MLAN_ACT_GET) && pmpriv->assoc_rsp_size) { memcpy_ext(pmadapter, misc->param.assoc_resp.assoc_resp_buf, pmpriv->assoc_rsp_buf, pmpriv->assoc_rsp_size, ASSOC_RSP_BUF_SIZE); misc->param.assoc_resp.assoc_resp_len = MIN(ASSOC_RSP_BUF_SIZE, pmpriv->assoc_rsp_size); } LEAVE(); return ret; } /** * @brief Get the associate request IEs * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_misc_ioctl_get_assoc_req(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_misc_cfg *misc = MNULL; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if ((pioctl_req->action == MLAN_ACT_GET) && pmpriv->assoc_req_size) { memcpy_ext(pmadapter, misc->param.assoc_req.assoc_req_buf, pmpriv->assoc_req_buf, pmpriv->assoc_req_size, ASSOC_RSP_BUF_SIZE); misc->param.assoc_req.assoc_req_len = MIN(ASSOC_RSP_BUF_SIZE, pmpriv->assoc_req_size); } LEAVE(); return ret; } /** * @brief Send function softreset 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 */ static mlan_status wlan_misc_ioctl_soft_reset(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); /* Send command to firmware */ 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 Get the thermal reading * * @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_misc_ioctl_thermal(pmlan_adapter pmadapter, 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->buf_len < sizeof(mlan_ds_misc_cfg)) { PRINTM(MWARN, "MLAN IOCTL information buffer length is too short.\n"); pioctl_req->data_read_written = 0; pioctl_req->buf_len_needed = sizeof(mlan_ds_misc_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } if (pioctl_req->action == MLAN_ACT_SET) { PRINTM(MERROR, "Thermal reading setting is not allowed!\n"); LEAVE(); return MLAN_STATUS_FAILURE; } else { cmd_action = HostCmd_ACT_GEN_GET; } /* Send command to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SNMP_MIB, cmd_action, Thermal_i, (t_void *)pioctl_req, MNULL); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Get/Set subscribe event * * @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_misc_ioctl_subscribe_evt(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; ENTER(); misc = (mlan_ds_misc_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 command to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_802_11_SUBSCRIBE_EVENT, cmd_action, 0, (t_void *)pioctl_req, &misc->param.subscribe_event); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Set ARP filter based on IP address * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * @param ipv4_addr ipv4 Address * * @return MLAN_STATUS_PENDING --success, otherwise fail */ static mlan_status wlan_ipaddr_arp_filter(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req, t_u32 ipv4_addr) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_callbacks pcb = &pmadapter->callbacks; t_u8 *buf; arpfilter_header *arpfilter = MNULL; filter_entry *entry = MNULL; t_u32 len; ENTER(); pcb->moal_malloc(pmadapter->pmoal_handle, MRVDRV_SIZE_OF_CMD_BUFFER, MLAN_MEM_DEF, &buf); if (!buf) { ret = MLAN_STATUS_FAILURE; goto done; } /* Construct the ARP filter TLV */ arpfilter = (arpfilter_header *)buf; arpfilter->type = wlan_cpu_to_le16(TLV_TYPE_ARP_FILTER); if (ipv4_addr) { arpfilter->len = wlan_cpu_to_le16(sizeof(filter_entry) * 3); entry = (filter_entry *)(buf + sizeof(arpfilter_header)); entry->addr_type = wlan_cpu_to_le16(ADDR_TYPE_BROADCAST); entry->eth_type = wlan_cpu_to_le16(ETHER_TYPE_ARP); entry->ipv4_addr = wlan_cpu_to_le32(ipv4_addr); entry++; entry->addr_type = wlan_cpu_to_le16(ADDR_TYPE_UNICAST); entry->eth_type = wlan_cpu_to_le16(ETHER_TYPE_ANY); entry->ipv4_addr = wlan_cpu_to_le32(IPV4_ADDR_ANY); entry++; entry->addr_type = wlan_cpu_to_le16(ADDR_TYPE_MULTICAST); entry->eth_type = wlan_cpu_to_le16(ETHER_TYPE_ANY); entry->ipv4_addr = wlan_cpu_to_le32(IPV4_ADDR_ANY); } else arpfilter->len = 0; /* Update the total length */ len = sizeof(arpfilter_header) + wlan_le16_to_cpu(arpfilter->len); memset(pmadapter, pmadapter->arp_filter, 0, sizeof(pmadapter->arp_filter)); if (len > ARP_FILTER_MAX_BUF_SIZE) { pmadapter->arp_filter_size = 0; PRINTM(MERROR, "Invalid ARP Filter Size\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; } else if (len <= sizeof(MrvlIEtypesHeader_t)) { pmadapter->arp_filter_size = 0; PRINTM(MINFO, "Clear ARP filter\n"); } else { memcpy_ext(pmadapter, pmadapter->arp_filter, buf, len, ARP_FILTER_MAX_BUF_SIZE); pmadapter->arp_filter_size = len; HEXDUMP("ArpFilter", pmadapter->arp_filter, pmadapter->arp_filter_size); } done: if (buf) pcb->moal_mfree(pmadapter->pmoal_handle, buf); LEAVE(); return ret; } /** * @brief MEF configuration * * @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_misc_ioctl_mef_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_mef_cfg *mef_cfg = &((mlan_ds_misc_cfg *)pioctl_req->pbuf)->param.mef_cfg; pmlan_callbacks pcb = &pmadapter->callbacks; HostCmd_DS_GEN *hostcmd_hdr; HostCmd_DS_MEF_CFG *mefcmd; mlan_ds_misc_cmd *hostcmd = MNULL; t_u32 buf_len = 0; t_u8 *buf, *filter; t_u8 fltr_buf[] = {0x02, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x5e, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x41, 0x06, 0x00, 0x00, 0x00, 0x01, 0xff, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x41, 0x45, 0x01, 0x00, 0x00, 0x00, 0x01, 0x33, 0x33, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x41, 0x45}; ENTER(); /* GET operation */ if (pioctl_req->action == MLAN_ACT_GET) { /* TODO: need to store for get operation */ goto done; } ret = pcb->moal_malloc(pmadapter->pmoal_handle, sizeof(mlan_ds_misc_cmd), MLAN_MEM_DEF, (t_u8 **)&hostcmd); if (ret != MLAN_STATUS_SUCCESS || hostcmd == MNULL) { PRINTM(MERROR, "Failed to allocate hostcmd buffer\n"); pioctl_req->status_code = MLAN_ERROR_NO_MEM; ret = MLAN_STATUS_FAILURE; goto done; } memset(pmpriv->adapter, hostcmd, 0, sizeof(mlan_ds_misc_cmd)); buf = hostcmd->cmd; /* Prepare hostcmd buffer */ hostcmd_hdr = (HostCmd_DS_GEN *)(buf); hostcmd_hdr->command = wlan_cpu_to_le16(HostCmd_CMD_MEF_CFG); mefcmd = (HostCmd_DS_MEF_CFG *)(buf + S_DS_GEN); buf_len = S_DS_GEN; switch (mef_cfg->sub_id) { case MEF_CFG_DISABLE: PRINTM(MINFO, "Disable MEF\n"); mefcmd->criteria = wlan_cpu_to_le32(0); mefcmd->nentries = wlan_cpu_to_le16(0); buf_len += sizeof(HostCmd_DS_MEF_CFG); break; case MEF_CFG_RX_FILTER_ENABLE: PRINTM(MINFO, "Enable Rx filter\n"); mefcmd->criteria = wlan_cpu_to_le32((MBIT(3) | MBIT(0))); mefcmd->nentries = wlan_cpu_to_le16(1); buf_len += sizeof(HostCmd_DS_MEF_CFG); filter = buf + buf_len; memcpy_ext(pmpriv->adapter, filter, fltr_buf, sizeof(fltr_buf), MRVDRV_SIZE_OF_CMD_BUFFER - buf_len); buf_len += sizeof(fltr_buf); break; case MEF_CFG_AUTO_ARP_RESP: PRINTM(MINFO, "Enable auto ARP response\n"); /* TODO */ break; case MEF_CFG_HOSTCMD: PRINTM(MINFO, "MEF hostcmd from MOAL\n"); filter = buf + buf_len; memcpy_ext(pmpriv->adapter, filter, mef_cfg->param.cmd_buf.cmd, mef_cfg->param.cmd_buf.len, MRVDRV_SIZE_OF_CMD_BUFFER - buf_len); buf_len += mef_cfg->param.cmd_buf.len; break; default: PRINTM(MERROR, "Invalid sub ID parameter\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; break; } hostcmd_hdr->size = wlan_cpu_to_le16(buf_len); hostcmd->len = buf_len; /* Send command to firmware */ ret = wlan_prepare_cmd(pmpriv, 0, 0, 0, (t_void *)pioctl_req, (t_void *)hostcmd); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; done: if (hostcmd) pcb->moal_mfree(pmadapter->pmoal_handle, (t_u8 *)hostcmd); LEAVE(); return ret; } /** * @brief ipaddr configuration * * @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_misc_ioctl_ipaddr_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; mlan_status ret = MLAN_STATUS_SUCCESS; t_u32 ipv4_addr[MAX_IPADDR] = {0}; int i = 0; ENTER(); /* GET operation */ if (pioctl_req->action == MLAN_ACT_GET) { memcpy_ext(pmadapter, misc->param.ipaddr_cfg.ip_addr, pmpriv->ip_addr, IPADDR_LEN, IPADDR_LEN); misc->param.ipaddr_cfg.op_code = pmpriv->op_code; goto done; } /* only one IP is supported in current firmware */ for (i = 0; i < (int)misc->param.ipaddr_cfg.ip_addr_num; i++) { memcpy_ext(pmadapter, &ipv4_addr[i], misc->param.ipaddr_cfg.ip_addr[i], sizeof(t_u32), sizeof(t_u32)); } if (misc->param.ipaddr_cfg.op_code != MLAN_IPADDR_OP_IP_REMOVE && !misc->param.ipaddr_cfg.ip_addr_num) { PRINTM(MERROR, "Invalid IPv4 address\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; } if (misc->param.ipaddr_cfg.op_code & MLAN_IPADDR_OP_ARP_FILTER) ret = wlan_ipaddr_arp_filter(pmadapter, pioctl_req, ipv4_addr[0]); else if (pmpriv->op_code & MLAN_IPADDR_OP_ARP_FILTER) ret = wlan_ipaddr_arp_filter(pmadapter, pioctl_req, 0); if (ret == MLAN_STATUS_FAILURE) goto done; /* Save the values in MLAN */ if (pioctl_req->action == MLAN_ACT_SET) { pmpriv->op_code = misc->param.ipaddr_cfg.op_code; memcpy_ext(pmadapter, pmpriv->ip_addr, misc->param.ipaddr_cfg.ip_addr, IPADDR_LEN, IPADDR_LEN); } done: LEAVE(); return ret; } /** * @brief CFP code configuration * * @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_misc_ioctl_cfp_code_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; mlan_ds_misc_cfp_code *cfp_code = MNULL; t_u32 region_bg = 0; t_u32 region_a = 0; int i; ENTER(); cfp_code = &misc->param.cfp_code; if (pioctl_req->action == MLAN_ACT_SET) { if (pmadapter->otp_region && pmadapter->otp_region->force_reg) { PRINTM(MERROR, "ForceRegionRule is set in the on-chip OTP" "memory\n"); ret = MLAN_STATUS_FAILURE; goto done; } /* Save the values in MLAN */ if (!cfp_code->cfp_code_bg) cfp_code->cfp_code_bg = pmadapter->cfp_code_bg; for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) { /* Use the region code to search for the index */ if (cfp_code->cfp_code_bg == region_code_index[i]) { region_bg = cfp_code->cfp_code_bg; break; } } if (!cfp_code->cfp_code_a) cfp_code->cfp_code_a = pmadapter->cfp_code_a; for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) { /* Use the region code to search for the index */ if (cfp_code->cfp_code_a == region_code_index[i]) { region_a = cfp_code->cfp_code_a; break; } } if (!region_a) { for (i = 0; i < MRVDRV_MAX_CFP_CODE_A; i++) { /* Use the CFP code to search for the index */ if (cfp_code->cfp_code_a == cfp_code_index_a[i]) break; } if (i >= MRVDRV_MAX_CFP_CODE_A) { PRINTM(MERROR, "CFP Code not identified for A\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; } } pmadapter->cfp_code_bg = (t_u8)cfp_code->cfp_code_bg; pmadapter->cfp_code_a = (t_u8)cfp_code->cfp_code_a; if (region_bg && region_a && (region_bg == region_a)) pmadapter->region_code = pmadapter->cfp_code_a; else pmadapter->region_code = 0; if (wlan_set_regiontable(pmpriv, (t_u8)pmadapter->region_code, pmadapter->config_bands | pmadapter->adhoc_start_band)) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; } } else { /* GET operation */ cfp_code->cfp_code_bg = pmadapter->cfp_code_bg; cfp_code->cfp_code_a = pmadapter->cfp_code_a; } done: LEAVE(); return ret; } /** * @brief This function sets up country code and downloads CMD to FW * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_misc_ioctl_country_code(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_country_code *country_code = MNULL; mlan_ds_misc_cfg *cfg_misc = MNULL; t_u8 cfp_bg = 0, cfp_a = 0; ENTER(); cfg_misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; country_code = &cfg_misc->param.country_code; if (pioctl_req->action == MLAN_ACT_SET) { if (pmadapter->otp_region && pmadapter->otp_region->force_reg) { PRINTM(MERROR, "ForceRegionRule is set in the on-chip OTP" "memory\n"); ret = MLAN_STATUS_FAILURE; goto done; } /* Update region code and table based on country code */ if (wlan_misc_country_2_cfp_table_code( pmadapter, country_code->country_code, &cfp_bg, &cfp_a)) { PRINTM(MERROR, "Country code not found!\n"); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; } pmadapter->cfp_code_bg = cfp_bg; pmadapter->cfp_code_a = cfp_a; if (cfp_a) pmadapter->region_code = cfp_a; else if (cfp_bg) pmadapter->region_code = cfp_bg; else pmadapter->region_code = 0; if (wlan_set_regiontable(pmpriv, pmadapter->region_code, pmadapter->config_bands | pmadapter->adhoc_start_band)) { pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; ret = MLAN_STATUS_FAILURE; goto done; } memcpy_ext(pmadapter, pmadapter->country_code, country_code->country_code, COUNTRY_CODE_LEN, COUNTRY_CODE_LEN); } else { /* GET operation */ memcpy_ext(pmadapter, country_code->country_code, pmadapter->country_code, COUNTRY_CODE_LEN, COUNTRY_CODE_LEN); } done: LEAVE(); return ret; } /** * @brief Configure MFPC and MFPR for management frame protection * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_misc_pmfcfg(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_misc_cfg *cfg_misc = MNULL; mlan_ds_misc_pmfcfg *pmfcfg; cfg_misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; pmfcfg = &cfg_misc->param.pmfcfg; if (pioctl_req->action == MLAN_ACT_SET) { pmpriv->pmfcfg.mfpc = pmfcfg->mfpc; pmpriv->pmfcfg.mfpr = pmfcfg->mfpr; } else { /* GET operation */ pmfcfg->mfpc = pmpriv->pmfcfg.mfpc; pmfcfg->mfpr = pmpriv->pmfcfg.mfpr; } LEAVE(); return ret; } /** * @brief HW ARB Cfg * * @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_arb_cfg(pmlan_adapter pmadapter, 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_ARB_CONFIG, cmd_action, 0, (t_void *)pioctl_req, &(pmisc->param.arb_cfg)); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Save tp accounting command configurations. * * @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_tp_state(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_ds_misc_cfg *pmisc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); pmadapter->tp_state_on = pmisc->param.tp_state.on; pmadapter->tp_state_drop_point = pmisc->param.tp_state.drop_point; LEAVE(); return ret; } static mlan_status wlan_misc_ioctl_ips_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; cmd_action = HostCmd_ACT_GEN_SET; /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_IPS_CONFIG, cmd_action, 0, (t_void *)pioctl_req, &misc->param.ips_ctrl); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief IPv6 Router Advertisement offload configuration * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ mlan_status wlan_misc_ioctl_ipv6_ra_offload(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else if (pioctl_req->action == MLAN_ACT_GET) cmd_action = HostCmd_ACT_GEN_GET; ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_IPV6_RA_OFFLOAD_CFG, cmd_action, 0, (t_void *)pioctl_req, &misc->param.ipv6_ra_offload); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Gtk Rekey Offload * * @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_misc_ioctl_gtk_rekey_offload(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_ds_misc_cfg *misc_cfg = MNULL; t_u16 cmd_action = 0; mlan_private *pmpriv = pmadapter->priv[pioctl_req->bss_index]; ENTER(); misc_cfg = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else if (pioctl_req->action == MLAN_ACT_CLEAR) cmd_action = HostCmd_ACT_GEN_REMOVE; else cmd_action = HostCmd_ACT_GEN_GET; if (!pmpriv->wpa_is_gtk_set) { /* Store the gtk rekey data if it has already set gtk */ memcpy_ext(pmadapter, &pmpriv->gtk_rekey, &misc_cfg->param.gtk_rekey, sizeof(mlan_ds_misc_gtk_rekey_data), sizeof(mlan_ds_misc_gtk_rekey_data)); LEAVE(); return ret; } /* Send request to firmware if it hasn't set gtk yet */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG, cmd_action, 0, (t_void *)pioctl_req, &misc_cfg->param.gtk_rekey); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief enable/disable roam offload in firmware * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_misc_roam_offload(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (!(pmadapter->fw_cap_info & FW_ROAMING_SUPPORT)) { PRINTM(MERROR, "Firmware roaming not support\n"); LEAVE(); return MLAN_STATUS_FAILURE; } if (!IS_FW_SUPPORT_SUPPLICANT(pmadapter)) { PRINTM(MERROR, "Embedded supplicant do not enable\n"); LEAVE(); return MLAN_STATUS_FAILURE; } if ((misc->param.roam_offload.config_mode == ROAM_OFFLOAD_ENABLE) && misc->param.roam_offload.userset_passphrase) { pmpriv->adapter->userset_passphrase = misc->param.roam_offload.userset_passphrase; if (!misc->param.roam_offload.enable) { LEAVE(); return MLAN_STATUS_SUCCESS; } } if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else { PRINTM(MERROR, "Unsupported cmd_action\n"); LEAVE(); return MLAN_STATUS_FAILURE; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_ROAM_OFFLOAD, cmd_action, 0, (t_void *)pioctl_req, &misc->param.roam_offload); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief set roam offload aplist to firmware * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_misc_roam_offload_aplist(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else { PRINTM(MERROR, "Unsupported cmd_action\n"); LEAVE(); return MLAN_STATUS_FAILURE; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_ROAM_OFFLOAD, cmd_action, 0, (t_void *)pioctl_req, &misc->param.roam_offload); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief cloud keep alive * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req Pointer to the IOCTL request buffer * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_misc_cloud_keep_alive(pmlan_adapter pmadapter, mlan_ioctl_req *pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_ds_misc_cfg *misc = MNULL; t_u16 cmd_action = 0; mlan_status ret = MLAN_STATUS_SUCCESS; ENTER(); misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; if (pioctl_req->action == MLAN_ACT_SET) cmd_action = HostCmd_ACT_GEN_SET; else if (pioctl_req->action == MLAN_ACT_GET) { cmd_action = HostCmd_ACT_GEN_GET; } else if (pioctl_req->action == MLAN_ACT_RESET) { cmd_action = HostCmd_ACT_GEN_RESET; } else { cmd_action = HostCmd_ACT_GEN_REMOVE; } /* Send request to firmware */ ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_AUTO_TX, cmd_action, OID_CLOUD_KEEP_ALIVE, (t_void *)pioctl_req, &misc->param.keep_alive); if (ret == MLAN_STATUS_SUCCESS) ret = MLAN_STATUS_PENDING; LEAVE(); return ret; } /** * @brief Miscellaneous configuration handler * * @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_misc_cfg_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_misc_cfg *misc = MNULL; ENTER(); if ((pioctl_req == MNULL) || (pioctl_req->pbuf == MNULL)) { PRINTM(MERROR, "Request buffer not found!\n"); LEAVE(); return MLAN_STATUS_FAILURE; } if (pioctl_req->buf_len < sizeof(mlan_ds_misc_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_misc_cfg); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_RESOURCE; } misc = (mlan_ds_misc_cfg *)pioctl_req->pbuf; switch (misc->sub_command) { case MLAN_OID_MISC_GEN_IE: status = wlan_misc_ioctl_gen_ie(pmadapter, pioctl_req); break; case MLAN_OID_MISC_REGION: status = wlan_misc_ioctl_region(pmadapter, pioctl_req); break; case MLAN_OID_MISC_WARM_RESET: PRINTM(MCMND, "Request WARM RESET\n"); util_enqueue_list_tail(pmadapter->pmoal_handle, &pmadapter->ioctl_pending_q, (pmlan_linked_list)pioctl_req, pmadapter->callbacks.moal_spin_lock, pmadapter->callbacks.moal_spin_unlock); pmadapter->pending_ioctl = MTRUE; status = MLAN_STATUS_PENDING; break; #ifdef SDIO case MLAN_OID_MISC_SDIO_MPA_CTRL: status = wlan_misc_ioctl_sdio_mpa_ctrl(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_HOST_CMD: status = wlan_misc_ioctl_host_cmd(pmadapter, pioctl_req); break; case MLAN_OID_MISC_SYS_CLOCK: status = wlan_misc_ioctl_sysclock(pmadapter, pioctl_req); break; case MLAN_OID_MISC_WWS: status = wlan_misc_ioctl_wws_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ASSOC_RSP: status = wlan_misc_ioctl_get_assoc_rsp(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ASSOC_REQ: status = wlan_misc_ioctl_get_assoc_req(pmadapter, pioctl_req); break; case MLAN_OID_MISC_INIT_SHUTDOWN: status = wlan_misc_ioctl_init_shutdown(pmadapter, pioctl_req); break; case MLAN_OID_MISC_SOFT_RESET: status = wlan_misc_ioctl_soft_reset(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CUSTOM_IE: status = wlan_misc_ioctl_custom_ie_list(pmadapter, pioctl_req, MTRUE); break; case MLAN_OID_MISC_TDLS_CONFIG: status = wlan_misc_ioctl_tdls_config(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TDLS_OPER: status = wlan_misc_ioctl_tdls_oper(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_TDLS_IES: status = wlan_misc_ioctl_tdls_get_ies(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TDLS_CS_CHANNEL: status = wlan_misc_ioctl_tdls_cs_channel(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TDLS_IDLE_TIME: status = wlan_misc_ioctl_tdls_idle_time(pmadapter, pioctl_req); break; case MLAN_OID_MISC_NET_MONITOR: status = wlan_misc_ioctl_net_monitor(pmadapter, pioctl_req); break; case MLAN_OID_MISC_MAC_CONTROL: status = wlan_misc_ioctl_mac_control(pmadapter, pioctl_req); break; case MLAN_OID_MISC_MEF_CFG: status = wlan_misc_ioctl_mef_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RX_MGMT_IND: status = wlan_reg_rx_mgmt_ind(pmadapter, pioctl_req); break; #ifdef DEBUG_LEVEL1 case MLAN_OID_MISC_DRVDBG: status = wlan_set_drvdbg(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_IP_ADDR: status = wlan_misc_ioctl_ipaddr_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CFP_CODE: status = wlan_misc_ioctl_cfp_code_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_COUNTRY_CODE: status = wlan_misc_ioctl_country_code(pmadapter, pioctl_req); break; case MLAN_OID_MISC_THERMAL: status = wlan_misc_ioctl_thermal(pmadapter, pioctl_req); break; case MLAN_OID_MISC_SUBSCRIBE_EVENT: status = wlan_misc_ioctl_subscribe_evt(pmadapter, pioctl_req); break; case MLAN_OID_MISC_HOTSPOT_CFG: status = wlan_misc_hotspot_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_OTP_USER_DATA: status = wlan_misc_otp_user_data(pmadapter, pioctl_req); break; #ifdef USB case MLAN_OID_MISC_USB_AGGR_CTRL: status = wlan_misc_ioctl_usb_aggr_ctrl(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_AGGR_CTRL: status = wlan_misc_ioctl_aggr_ctrl(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TXCONTROL: status = wlan_misc_ioctl_txcontrol(pmadapter, pioctl_req); break; #ifdef STA_SUPPORT case MLAN_OID_MISC_EXT_CAP_CFG: status = wlan_misc_ext_capa_cfg(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_PMFCFG: status = wlan_misc_pmfcfg(pmadapter, pioctl_req); break; #ifdef RX_PACKET_COALESCE case MLAN_OID_MISC_RX_PACKET_COALESCE: status = wlan_misc_ioctl_rx_pkt_coalesce_config(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_LOW_PWR_MODE: status = wlan_misc_ioctl_low_pwr_mode(pmadapter, pioctl_req); break; case MLAN_OID_MISC_PMIC_CFG: status = wlan_misc_ioctl_pmic_configure(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CWMODE_CTRL: status = wlan_misc_ioctl_cwmode_ctrl(pmadapter, pioctl_req); break; case MLAN_OID_MISC_MEF_FLT_CFG: status = wlan_misc_ioctl_mef_flt_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_DFS_REAPTER_MODE: status = wlan_misc_ioctl_dfs_repeater_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_COALESCE_CFG: status = wlan_misc_ioctl_coalesce_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_SENSOR_TEMP: status = wlan_misc_ioctl_get_sensor_temp(pmadapter, pioctl_req); break; case MLAN_OID_MISC_OPER_CLASS: status = wlan_misc_ioctl_oper_class(pmadapter, pioctl_req); break; case MLAN_OID_MISC_OPER_CLASS_CHECK: status = wlan_misc_ioctl_operclass_validation(pmadapter, pioctl_req); break; case MLAN_OID_MISC_IPV6_RA_OFFLOAD: status = wlan_misc_ioctl_ipv6_ra_offload(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GTK_REKEY_OFFLOAD: status = wlan_misc_ioctl_gtk_rekey_offload(pmadapter, pioctl_req); break; case MLAN_OID_MISC_IND_RST_CFG: status = wlan_misc_ioctl_ind_rst_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_MC_AGGR_CFG: status = wlan_misc_ioctl_mc_aggr_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CH_LOAD: status = wlan_misc_ioctl_ch_load(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_TSF: status = wlan_misc_ioctl_get_tsf(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ROAM_OFFLOAD: status = wlan_misc_roam_offload(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ROAM_OFFLOAD_APLIST: status = wlan_misc_roam_offload_aplist(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_CHAN_REGION_CFG: status = wlan_misc_chan_reg_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CLOUD_KEEP_ALIVE: status = wlan_misc_cloud_keep_alive(pmadapter, pioctl_req); break; case MLAN_OID_MISC_DYN_BW: status = wlan_misc_ioctl_dyn_bw(pmadapter, pioctl_req); break; case MLAN_OID_MISC_FW_DUMP_EVENT: status = wlan_misc_ioctl_fw_dump_event(pmadapter, pioctl_req); break; case MLAN_OID_MISC_PER_PKT_CFG: status = wlan_misc_per_pkt_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ROBUSTCOEX: status = wlan_misc_robustcoex(pmadapter, pioctl_req); break; case MLAN_OID_MISC_DMCS_CONFIG: status = wlan_misc_dmcs_config(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_TX_RX_HISTOGRAM: status = wlan_get_tx_rx_histogram(pmadapter, pioctl_req); break; case MLAN_OID_MISC_BOOT_SLEEP: status = wlan_misc_bootsleep(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CFP_INFO: status = wlan_get_cfpinfo(pmadapter, pioctl_req); break; #if defined(PCIE) case MLAN_OID_MISC_SSU: if (pmadapter->ssu_buf) status = MLAN_STATUS_FAILURE; else status = wlan_misc_ssu(pmadapter, pioctl_req); break; #endif case MLAN_OID_MISC_CSI: status = wlan_misc_csi(pmadapter, pioctl_req); break; case MLAN_OID_MISC_HAL_PHY_CFG: status = wlan_misc_hal_phy_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GPIO_TSF_LATCH: status = wlan_misc_gpio_tsf_latch_config(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_TSF_INFO: status = wlan_misc_get_tsf_info(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RX_ABORT_CFG: status = wlan_misc_ioctl_rxabortcfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RX_ABORT_CFG_EXT: status = wlan_misc_ioctl_rxabortcfg_ext(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TX_AMPDU_PROT_MODE: status = wlan_misc_ioctl_tx_ampdu_prot_mode(pmadapter, pioctl_req); break; case MLAN_OID_MISC_DOT11MC_UNASSOC_FTM_CFG: status = wlan_misc_ioctl_dot11mc_unassoc_ftm_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RATE_ADAPT_CFG: status = wlan_misc_ioctl_rate_adapt_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_CCK_DESENSE_CFG: status = wlan_misc_ioctl_cck_desense_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_REGIONPWR_CFG: status = wlan_get_rgchnpwr_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_GET_CHAN_TRPC_CFG: status = wlan_get_chan_trpc_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RF_TEST_GENERIC: case MLAN_OID_MISC_RF_TEST_TX_CONT: case MLAN_OID_MISC_RF_TEST_TX_FRAME: case MLAN_OID_MISC_RF_TEST_HE_POWER: status = wlan_misc_ioctl_rf_test_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_ARB_CONFIG: status = wlan_misc_ioctl_arb_cfg(pmadapter, pioctl_req); break; case MLAN_OID_MISC_RANGE_EXT: status = wlan_misc_ioctl_range_ext(pmadapter, pioctl_req); break; case MLAN_OID_MISC_TP_STATE: status = wlan_misc_ioctl_tp_state(pmadapter, pioctl_req); break; case MLAN_OID_MISC_IPS_CFG: status = wlan_misc_ioctl_ips_cfg(pmadapter, pioctl_req); break; default: if (pioctl_req) pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; } /** * @brief Set/Get scan configuration parameter * * @param pmadapter A pointer to mlan_adapter structure * @param pioctl_req A pointer to ioctl request buffer * @param action Set/Get * * @return MLAN_STATUS_SUCCESS --success */ static mlan_status wlan_set_get_scan_cfg(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req, t_u32 action) { mlan_ds_scan *scan = MNULL; ENTER(); scan = (mlan_ds_scan *)pioctl_req->pbuf; if (action == MLAN_ACT_SET) { if (scan->param.scan_cfg.scan_type) pmadapter->scan_type = (t_u8)scan->param.scan_cfg.scan_type; if (scan->param.scan_cfg.scan_mode) pmadapter->scan_mode = scan->param.scan_cfg.scan_mode; if (scan->param.scan_cfg.scan_probe) pmadapter->scan_probes = (t_u16)scan->param.scan_cfg.scan_probe; if (scan->param.scan_cfg.scan_time.specific_scan_time) pmadapter->specific_scan_time = (t_u16)scan->param.scan_cfg.scan_time .specific_scan_time; if (scan->param.scan_cfg.scan_time.active_scan_time) pmadapter->active_scan_time = (t_u16)scan->param.scan_cfg.scan_time .active_scan_time; if (scan->param.scan_cfg.scan_time.passive_scan_time) pmadapter->passive_scan_time = (t_u16)scan->param.scan_cfg.scan_time .passive_scan_time; if (scan->param.scan_cfg.passive_to_active_scan) pmadapter->passive_to_active_scan = scan->param.scan_cfg.passive_to_active_scan; if (scan->param.scan_cfg.ext_scan) pmadapter->ext_scan = scan->param.scan_cfg.ext_scan - 1; pmadapter->scan_chan_gap = scan->param.scan_cfg.scan_chan_gap; } scan->param.scan_cfg.scan_type = (t_u32)pmadapter->scan_type; scan->param.scan_cfg.scan_mode = pmadapter->scan_mode; scan->param.scan_cfg.scan_probe = (t_u32)pmadapter->scan_probes; scan->param.scan_cfg.scan_time.specific_scan_time = (t_u32)pmadapter->specific_scan_time; scan->param.scan_cfg.scan_time.active_scan_time = (t_u32)pmadapter->active_scan_time; scan->param.scan_cfg.scan_time.passive_scan_time = (t_u32)pmadapter->passive_scan_time; scan->param.scan_cfg.passive_to_active_scan = pmadapter->passive_to_active_scan; scan->param.scan_cfg.ext_scan = pmadapter->ext_scan + 1; scan->param.scan_cfg.scan_chan_gap = pmadapter->scan_chan_gap; pioctl_req->data_read_written = sizeof(t_u32) + MLAN_SUB_COMMAND_SIZE; LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Set/Get scan * * @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_scan_ioctl(pmlan_adapter pmadapter, pmlan_ioctl_req pioctl_req) { pmlan_private pmpriv = pmadapter->priv[pioctl_req->bss_index]; mlan_status status = MLAN_STATUS_SUCCESS; mlan_ds_scan *pscan; ENTER(); pscan = (mlan_ds_scan *)pioctl_req->pbuf; if (pscan->sub_command == MLAN_OID_SCAN_CONFIG || pscan->sub_command == MLAN_OID_SCAN_BGSCAN_CONFIG) goto start_config; if (pmadapter->scan_processing && pioctl_req->action == MLAN_ACT_SET && pscan->sub_command != MLAN_OID_SCAN_CANCEL) { PRINTM(MINFO, "Scan already in process...\n"); LEAVE(); return status; } if (pmadapter->enable_net_mon == CHANNEL_SPEC_SNIFFER_MODE) { PRINTM(MINFO, "Scan is blocked in Channel Specified Network Monitor mode...\n"); LEAVE(); return MLAN_STATUS_FAILURE; } if (pmadapter->scan_block && pioctl_req->action == MLAN_ACT_SET) { PRINTM(MERROR, "Scan is blocked during association...\n"); LEAVE(); return MLAN_STATUS_FAILURE; } start_config: /* Set scan */ if (pioctl_req->action == MLAN_ACT_SET) { switch (pscan->sub_command) { case MLAN_OID_SCAN_NORMAL: status = wlan_scan_networks(pmpriv, pioctl_req, MNULL); break; case MLAN_OID_SCAN_SPECIFIC_SSID: status = wlan_scan_specific_ssid( pmpriv, pioctl_req, &pscan->param.scan_req.scan_ssid); break; case MLAN_OID_SCAN_USER_CONFIG: status = wlan_scan_networks( pmpriv, pioctl_req, (wlan_user_scan_cfg *) pscan->param.user_scan.scan_cfg_buf); break; case MLAN_OID_SCAN_CONFIG: status = wlan_set_get_scan_cfg(pmadapter, pioctl_req, MLAN_ACT_SET); break; case MLAN_OID_SCAN_CANCEL: status = wlan_cancel_pending_scan_cmd(pmadapter, pioctl_req); break; case MLAN_OID_SCAN_TABLE_FLUSH: status = wlan_flush_scan_table(pmadapter); break; case MLAN_OID_SCAN_BGSCAN_CONFIG: /* Send request to firmware */ status = wlan_prepare_cmd( pmpriv, HostCmd_CMD_802_11_BG_SCAN_CONFIG, HostCmd_ACT_GEN_SET, 0, (t_void *)pioctl_req, pscan->param.user_scan.scan_cfg_buf); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } if ((status == MLAN_STATUS_SUCCESS) && (pscan->sub_command != MLAN_OID_SCAN_TABLE_FLUSH) && (pscan->sub_command != MLAN_OID_SCAN_CANCEL) && (pscan->sub_command != MLAN_OID_SCAN_CONFIG)) { PRINTM(MINFO, "wlan_scan_ioctl: return MLAN_STATUS_PENDING\n"); status = MLAN_STATUS_PENDING; } } /* Get scan */ else { if (pscan->sub_command == MLAN_OID_SCAN_CONFIG) { status = wlan_set_get_scan_cfg(pmadapter, pioctl_req, MLAN_ACT_GET); } else if (pscan->sub_command == MLAN_OID_SCAN_GET_CURRENT_BSS) { pscan->param.scan_resp.num_in_scan_table = pmadapter->num_in_scan_table; pscan->param.scan_resp.pscan_table = (t_u8 *)&pmpriv->curr_bss_params.bss_descriptor; pioctl_req->data_read_written = sizeof(mlan_scan_resp) + MLAN_SUB_COMMAND_SIZE; } else { if (pmadapter->bgscan_reported) { pmadapter->bgscan_reported = MFALSE; /* Clear the previous scan result */ memset(pmadapter, pmadapter->pscan_table, 0x00, sizeof(BSSDescriptor_t) * MRVDRV_MAX_BSSID_LIST); pmadapter->num_in_scan_table = 0; pmadapter->pbcn_buf_end = pmadapter->bcn_buf; status = wlan_prepare_cmd( pmpriv, HostCmd_CMD_802_11_BG_SCAN_QUERY, HostCmd_ACT_GEN_GET, 0, (t_void *)pioctl_req, MNULL); if (status == MLAN_STATUS_SUCCESS) { PRINTM(MINFO, "wlan_scan_ioctl: return MLAN_STATUS_PENDING\n"); status = MLAN_STATUS_PENDING; } } else { pscan->param.scan_resp.pscan_table = (t_u8 *)pmadapter->pscan_table; pscan->param.scan_resp.num_in_scan_table = pmadapter->num_in_scan_table; pscan->param.scan_resp.age_in_secs = pmadapter->age_in_secs; pioctl_req->data_read_written = sizeof(mlan_scan_resp) + MLAN_SUB_COMMAND_SIZE; pscan->param.scan_resp.pchan_stats = (t_u8 *)pmadapter->pchan_stats; pscan->param.scan_resp.num_in_chan_stats = pmadapter->num_in_chan_stats; } } } LEAVE(); return status; } /******************************************************** Global Functions ********************************************************/ /** * @brief Set ewpa mode * * @param priv A pointer to mlan_private structure * @param psec_pp A pointer to mlan_ds_passphrase structure * * @return MLAN_STATUS_SUCCESS */ mlan_status wlan_set_ewpa_mode(mlan_private *priv, mlan_ds_passphrase *psec_pp) { ENTER(); if ((psec_pp->psk_type == MLAN_PSK_PASSPHRASE && psec_pp->psk.passphrase.passphrase_len > 0) || (psec_pp->psk_type == MLAN_PSK_PMK)) priv->sec_info.ewpa_enabled = MTRUE; else priv->sec_info.ewpa_enabled = MFALSE; PRINTM(MINFO, "Set ewpa mode = %d\n", priv->sec_info.ewpa_enabled); LEAVE(); return MLAN_STATUS_SUCCESS; } /** * @brief Search for a BSS * * @param pmpriv A pointer to mlan_private structure * @param pioctl_req A pointer to ioctl request buffer * * @return MLAN_STATUS_SUCCESS --success, otherwise * fail */ mlan_status wlan_find_bss(mlan_private *pmpriv, pmlan_ioctl_req pioctl_req) { mlan_adapter *pmadapter = pmpriv->adapter; mlan_ds_bss *bss = MNULL; mlan_status ret = MLAN_STATUS_SUCCESS; t_u8 zero_mac[] = {0, 0, 0, 0, 0, 0}; t_u8 mac[MLAN_MAC_ADDR_LENGTH]; int i = 0; BSSDescriptor_t *pbss_desc = MNULL; ENTER(); bss = (mlan_ds_bss *)pioctl_req->pbuf; if (memcmp(pmadapter, &bss->param.ssid_bssid.bssid, zero_mac, sizeof(zero_mac))) { if (bss->param.ssid_bssid.ssid.ssid_len) /* ssid & bssid */ i = wlan_find_ssid_in_list( pmpriv, &bss->param.ssid_bssid.ssid, (t_u8 *)&bss->param.ssid_bssid.bssid, pmpriv->bss_mode); else i = wlan_find_bssid_in_list( pmpriv, (t_u8 *)&bss->param.ssid_bssid.bssid, pmpriv->bss_mode); if (i < 0) { memcpy_ext(pmadapter, mac, &bss->param.ssid_bssid.bssid, sizeof(mac), MLAN_MAC_ADDR_LENGTH); PRINTM(MIOCTL, "Can not find bssid " MACSTR "\n", MAC2STR(mac)); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_FAILURE; } pbss_desc = &pmadapter->pscan_table[i]; memcpy_ext(pmadapter, &bss->param.ssid_bssid.ssid, &pbss_desc->ssid, sizeof(mlan_802_11_ssid), sizeof(mlan_802_11_ssid)); bss->param.ssid_bssid.rssi = pbss_desc->rssi; bss->param.ssid_bssid.channel = (t_u16)pbss_desc->channel; bss->param.ssid_bssid.bss_band = pbss_desc->bss_band; /* index in bss list,start from 1 */ bss->param.ssid_bssid.idx = i + 1; } else if (bss->param.ssid_bssid.ssid.ssid_len) { i = wlan_find_ssid_in_list(pmpriv, &bss->param.ssid_bssid.ssid, MNULL, pmpriv->bss_mode); if (i < 0) { PRINTM(MIOCTL, "Can not find ssid %s\n", bss->param.ssid_bssid.ssid.ssid); pioctl_req->status_code = MLAN_ERROR_INVALID_PARAMETER; LEAVE(); return MLAN_STATUS_FAILURE; } pbss_desc = &pmadapter->pscan_table[i]; memcpy_ext(pmadapter, (t_u8 *)&bss->param.ssid_bssid.bssid, (t_u8 *)&pbss_desc->mac_address, MLAN_MAC_ADDR_LENGTH, MLAN_MAC_ADDR_LENGTH); bss->param.ssid_bssid.rssi = pbss_desc->rssi; bss->param.ssid_bssid.channel = (t_u16)pbss_desc->channel; bss->param.ssid_bssid.bss_band = pbss_desc->bss_band; /* index in bss list, start from 1 */ bss->param.ssid_bssid.idx = i + 1; } else { ret = wlan_find_best_network(pmpriv, &bss->param.ssid_bssid); } if (pbss_desc) { /**if rsn do not have ft akm, don't set ft cap and ft md*/ if (pbss_desc->pmd_ie && wlan_ft_akm_is_used(pmpriv, (t_u8 *)pbss_desc->prsn_ie)) { bss->param.ssid_bssid.ft_md = pbss_desc->pmd_ie->mdid; bss->param.ssid_bssid.ft_cap = pbss_desc->pmd_ie->ft_cap; } } LEAVE(); return ret; } /** * @brief MLAN station ioctl handler * * @param adapter 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 */ mlan_status wlan_ops_sta_ioctl(t_void *adapter, pmlan_ioctl_req pioctl_req) { pmlan_adapter pmadapter = (pmlan_adapter)adapter; mlan_status status = MLAN_STATUS_SUCCESS; ENTER(); switch (pioctl_req->req_id) { case MLAN_IOCTL_SCAN: status = wlan_scan_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_BSS: status = wlan_bss_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_RADIO_CFG: status = wlan_radio_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_SNMP_MIB: status = wlan_snmp_mib_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_GET_INFO: status = wlan_get_info_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_SEC_CFG: status = wlan_sec_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_RATE: status = wlan_rate_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_POWER_CFG: status = wlan_power_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_PM_CFG: status = wlan_pm_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_WMM_CFG: status = wlan_wmm_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_WPS_CFG: status = wlan_wps_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_11N_CFG: status = wlan_11n_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_11D_CFG: status = wlan_11d_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_REG_MEM: status = wlan_reg_mem_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_MISC_CFG: status = wlan_misc_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_11H_CFG: status = wlan_11h_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_11AC_CFG: status = wlan_11ac_cfg_ioctl(pmadapter, pioctl_req); break; case MLAN_IOCTL_11AX_CFG: status = wlan_11ax_cfg_ioctl(pmadapter, pioctl_req); break; default: pioctl_req->status_code = MLAN_ERROR_IOCTL_INVALID; status = MLAN_STATUS_FAILURE; break; } LEAVE(); return status; }