/** @file hostsa_init.c
|
*
|
* @brief This file defines the initialize /free APIs for authenticator and supplicant.
|
*
|
* Copyright (C) 2014-2017, Marvell International Ltd.
|
*
|
* This software file (the "File") is distributed by Marvell International
|
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
|
* (the "License"). You may use, redistribute and/or modify this File in
|
* accordance with the terms and conditions of the License, a copy of which
|
* is available by writing to the Free Software Foundation, Inc.,
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
|
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
|
*
|
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
|
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
|
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
|
* this warranty disclaimer.
|
*/
|
|
/******************************************************
|
Change log:
|
03/07/2014: Initial version
|
******************************************************/
|
#include "mlan.h"
|
#ifdef STA_SUPPORT
|
#include "mlan_join.h"
|
#endif
|
#include "mlan_ioctl.h"
|
#include "mlan_util.h"
|
#include "mlan_fw.h"
|
#include "mlan_main.h"
|
#include "mlan_init.h"
|
#include "mlan_wmm.h"
|
#include "hostsa_def.h"
|
|
#include "authenticator_api.h"
|
|
/*********************
|
Local Variables
|
*********************/
|
|
/*********************
|
Global Variables
|
*********************/
|
|
/*********************
|
Local Functions
|
*********************/
|
|
/*********************
|
Global Functions
|
*********************/
|
|
/*********************
|
Utility Handler
|
*********************/
|
|
/**
|
* @brief alloc mlan buffer
|
*
|
* @param pmlan_adapter A void pointer
|
* @param data_len request buffer len
|
* @param head_room head room len
|
* @param malloc_flag flag for mlan buffer
|
|
* @return pointer to mlan buffer
|
*/
|
pmlan_buffer
|
hostsa_alloc_mlan_buffer(t_void *pmlan_adapter,
|
t_u32 data_len, t_u32 head_room, t_u32 malloc_flag)
|
{
|
mlan_adapter *pmadapter = (mlan_adapter *)pmlan_adapter;
|
pmlan_buffer newbuf = MNULL;
|
|
newbuf = wlan_alloc_mlan_buffer(pmadapter, data_len, head_room,
|
malloc_flag);
|
|
return newbuf;
|
}
|
|
/**
|
* @brief free mlan buffer
|
*
|
* @param pmlan_adapter A void pointer
|
* @param pmbuf a pointer to mlan buffer
|
*
|
* @return
|
*/
|
void
|
hostsa_free_mlan_buffer(t_void *pmlan_adapter, mlan_buffer *pmbuf)
|
{
|
mlan_adapter *pmadapter = (mlan_adapter *)pmlan_adapter;
|
|
ENTER();
|
|
wlan_free_mlan_buffer(pmadapter, pmbuf);
|
|
LEAVE();
|
}
|
|
/**
|
* @brief send packet
|
*
|
* @param pmlan_private A void pointer
|
* @param pmbuf a pointer to mlan buffer
|
* @param frameLen paket len
|
*
|
* @return
|
*/
|
void
|
hostsa_tx_packet(t_void *pmlan_private, pmlan_buffer pmbuf, t_u16 frameLen)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
|
ENTER();
|
|
pmbuf->bss_index = pmpriv->bss_index;
|
pmbuf->data_len = frameLen;
|
|
wlan_add_buf_bypass_txqueue(pmadapter, pmbuf);
|
wlan_recv_event(pmpriv, MLAN_EVENT_ID_DRV_DEFER_HANDLING, MNULL);
|
|
LEAVE();
|
}
|
|
/**
|
* @brief set key to fw
|
*
|
* @param pmlan_private A void pointer
|
* @param encrypt_key key structure
|
*
|
* @return
|
*/
|
void
|
wlan_set_encrypt_key(t_void *pmlan_private, mlan_ds_encrypt_key *encrypt_key)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
if (!encrypt_key->key_len) {
|
PRINTM(MCMND, "Skip set key with key_len = 0\n");
|
LEAVE();
|
return;
|
}
|
|
ret = wlan_prepare_cmd(priv,
|
HostCmd_CMD_802_11_KEY_MATERIAL,
|
HostCmd_ACT_GEN_SET,
|
KEY_INFO_ENABLED, MNULL, encrypt_key);
|
|
if (ret == MLAN_STATUS_SUCCESS)
|
wlan_recv_event(priv, MLAN_EVENT_ID_DRV_DEFER_HANDLING, MNULL);
|
|
LEAVE();
|
|
}
|
|
/**
|
* @brief clear key to fw
|
*
|
* @param pmlan_private A void pointer
|
*
|
* @return
|
*/
|
void
|
wlan_clr_encrypt_key(t_void *pmlan_private)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
mlan_ds_encrypt_key encrypt_key;
|
|
ENTER();
|
|
memset(priv->adapter, &encrypt_key, 0, sizeof(mlan_ds_encrypt_key));
|
encrypt_key.key_disable = MTRUE;
|
encrypt_key.key_flags = KEY_FLAG_REMOVE_KEY;
|
|
ret = wlan_prepare_cmd(priv,
|
HostCmd_CMD_802_11_KEY_MATERIAL,
|
HostCmd_ACT_GEN_SET,
|
KEY_INFO_ENABLED, MNULL, &encrypt_key);
|
|
if (ret == MLAN_STATUS_SUCCESS)
|
wlan_recv_event(priv, MLAN_EVENT_ID_DRV_DEFER_HANDLING, MNULL);
|
|
LEAVE();
|
|
}
|
|
/**
|
* @brief send deauth frame
|
*
|
* @param pmlan_private A void pointer
|
* @param addr destination mac address
|
* @param reason deauth reason
|
*
|
* @return
|
*/
|
void
|
hostsa_SendDeauth(t_void *pmlan_private, t_u8 *addr, t_u16 reason)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
mlan_deauth_param deauth;
|
|
ENTER();
|
|
memcpy(pmadapter, deauth.mac_addr, addr, MLAN_MAC_ADDR_LENGTH);
|
deauth.reason_code = reason;
|
|
ret = wlan_prepare_cmd(pmpriv,
|
HOST_CMD_APCMD_STA_DEAUTH,
|
HostCmd_ACT_GEN_SET,
|
0, MNULL, (t_void *)&deauth);
|
if (ret == MLAN_STATUS_SUCCESS)
|
wlan_recv_event(pmpriv, MLAN_EVENT_ID_DRV_DEFER_HANDLING,
|
MNULL);
|
|
LEAVE();
|
}
|
|
/**
|
* @brief deauth all connected stations
|
*
|
* @param pmlan_private A void pointer
|
* @param reason deauth reason
|
*
|
* @return
|
*/
|
void
|
ApDisAssocAllSta(void *pmlan_private, t_u16 reason)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
sta_node *sta_ptr;
|
|
ENTER();
|
|
sta_ptr = (sta_node *)util_peek_list(pmadapter->pmoal_handle,
|
&pmpriv->sta_list,
|
pmadapter->callbacks.
|
moal_spin_lock,
|
pmadapter->callbacks.
|
moal_spin_unlock);
|
|
if (!sta_ptr) {
|
LEAVE();
|
return;
|
}
|
|
while (sta_ptr != (sta_node *)&pmpriv->sta_list) {
|
hostsa_SendDeauth((t_void *)pmpriv, sta_ptr->mac_addr, reason);
|
sta_ptr = sta_ptr->pnext;
|
}
|
|
LEAVE();
|
}
|
|
/**
|
* @brief get station entry
|
*
|
* @param pmlan_private A void pointer
|
* @param mac pointer to station mac address
|
* @param ppconPtr pointer to pointer to connection
|
*
|
* @return
|
*/
|
void
|
Hostsa_get_station_entry(t_void *pmlan_private, t_u8 *mac, t_void **ppconPtr)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
sta_node *sta_ptr = MNULL;
|
|
ENTER();
|
|
sta_ptr = wlan_get_station_entry(priv, mac);
|
if (sta_ptr)
|
*ppconPtr = sta_ptr->cm_connectioninfo;
|
else
|
*ppconPtr = MNULL;
|
|
LEAVE();
|
}
|
|
/**
|
* @brief find a connection
|
*
|
* @param pmlan_private A void pointer
|
* @param ppconPtr a pointer to pointer to connection
|
* @param ppsta_node a pointer to pointer to sta node
|
*
|
* @return
|
*/
|
void
|
Hostsa_find_connection(t_void *pmlan_private, t_void **ppconPtr,
|
t_void **ppsta_node)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
sta_node *sta_ptr = MNULL;
|
|
ENTER();
|
|
sta_ptr = (sta_node *)util_peek_list(priv->adapter->pmoal_handle,
|
&priv->sta_list,
|
priv->adapter->callbacks.
|
moal_spin_lock,
|
priv->adapter->callbacks.
|
moal_spin_unlock);
|
|
if (!sta_ptr) {
|
LEAVE();
|
return;
|
}
|
|
*ppsta_node = (t_void *)sta_ptr;
|
*ppconPtr = sta_ptr->cm_connectioninfo;
|
|
LEAVE();
|
}
|
|
/**
|
* @brief find next connection
|
*
|
* @param pmlan_private A void pointer
|
* @param ppconPtr a pointer to pointer to connection
|
* @param ppsta_node a pointer to pointer to sta node
|
*
|
* @return
|
*/
|
void
|
Hostsa_find_next_connection(t_void *pmlan_private, t_void **ppconPtr,
|
t_void **ppsta_node)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
sta_node *sta_ptr = (sta_node *)*ppsta_node;
|
|
ENTER();
|
if (sta_ptr != (sta_node *)&priv->sta_list)
|
sta_ptr = sta_ptr->pnext;
|
|
*ppsta_node = MNULL;
|
*ppconPtr = MNULL;
|
if ((sta_ptr != MNULL) && (sta_ptr != (sta_node *)&priv->sta_list)) {
|
*ppsta_node = (t_void *)sta_ptr;
|
*ppconPtr = sta_ptr->cm_connectioninfo;
|
}
|
LEAVE();
|
}
|
|
/**
|
* @brief set management ie for beacon or probe response
|
*
|
* @param pmlan_private A void pointer
|
* @param pbuf ie buf
|
* @param len ie len
|
* @param clearIE clear ie
|
*
|
* @return
|
*/
|
void
|
Hostsa_set_mgmt_ie(t_void *pmlan_private, t_u8 *pbuf, t_u16 len, t_u8 clearIE)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = priv->adapter;
|
mlan_ioctl_req *pioctl_req = MNULL;
|
mlan_ds_misc_cfg *pds_misc_cfg = MNULL;
|
custom_ie *pmgmt_ie = MNULL;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
if (pmadapter == MNULL) {
|
LEAVE();
|
return;
|
}
|
|
/* allocate buffer for mlan_ioctl_req and mlan_ds_misc_cfg */
|
/* FYI - will be freed as part of cmd_response handler */
|
ret = pmadapter->callbacks.moal_malloc(pmadapter->pmoal_handle,
|
sizeof(mlan_ioctl_req) +
|
sizeof(mlan_ds_misc_cfg),
|
MLAN_MEM_DEF,
|
(t_u8 **)&pioctl_req);
|
if ((ret != MLAN_STATUS_SUCCESS) || !pioctl_req) {
|
PRINTM(MERROR, "%s(): Could not allocate ioctl req\n",
|
__func__);
|
LEAVE();
|
return;
|
}
|
pds_misc_cfg = (mlan_ds_misc_cfg *)((t_u8 *)pioctl_req +
|
sizeof(mlan_ioctl_req));
|
|
/* prepare mlan_ioctl_req */
|
memset(pmadapter, pioctl_req, 0x00, sizeof(mlan_ioctl_req));
|
pioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
pioctl_req->action = MLAN_ACT_SET;
|
pioctl_req->bss_index = priv->bss_index;
|
pioctl_req->pbuf = (t_u8 *)pds_misc_cfg;
|
pioctl_req->buf_len = sizeof(mlan_ds_misc_cfg);
|
|
/* prepare mlan_ds_misc_cfg */
|
memset(pmadapter, pds_misc_cfg, 0x00, sizeof(mlan_ds_misc_cfg));
|
pds_misc_cfg->sub_command = MLAN_OID_MISC_CUSTOM_IE;
|
pds_misc_cfg->param.cust_ie.type = TLV_TYPE_MGMT_IE;
|
pds_misc_cfg->param.cust_ie.len = (sizeof(custom_ie) - MAX_IE_SIZE);
|
|
/* configure custom_ie api settings */
|
pmgmt_ie = (custom_ie *)&pds_misc_cfg->param.cust_ie.ie_data_list[0];
|
pmgmt_ie->ie_index = 0xffff; /* Auto index */
|
pmgmt_ie->ie_length = len;
|
pmgmt_ie->mgmt_subtype_mask = MBIT(8) | MBIT(5); /* add IE for BEACON | PROBE_RSP */
|
if (clearIE)
|
pmgmt_ie->mgmt_subtype_mask = 0;
|
memcpy(pmadapter, pmgmt_ie->ie_buffer, pbuf, len);
|
|
pds_misc_cfg->param.cust_ie.len += pmgmt_ie->ie_length;
|
|
DBG_HEXDUMP(MCMD_D, "authenticator: RSN or WPA IE",
|
(t_u8 *)pmgmt_ie, pds_misc_cfg->param.cust_ie.len);
|
|
ret = wlan_misc_ioctl_custom_ie_list(pmadapter, pioctl_req, MFALSE);
|
|
if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING) {
|
PRINTM(MERROR,
|
"%s(): Could not set IE for priv=%p [priv_bss_idx=%d]!\n",
|
__func__, priv, priv->bss_index);
|
/* TODO: how to handle this error case?? ignore & continue? */
|
}
|
/* free ioctl buffer memory before we leave */
|
pmadapter->callbacks.moal_mfree(pmadapter->pmoal_handle,
|
(t_u8 *)pioctl_req);
|
|
}
|
|
t_void
|
StaControlledPortOpen(t_void *pmlan_private)
|
{
|
mlan_private *priv = (mlan_private *)pmlan_private;
|
|
PRINTM(MERROR, "StaControlledPortOpen\n");
|
if (priv->port_ctrl_mode == MTRUE) {
|
PRINTM(MINFO, "PORT_REL: port_status = OPEN\n");
|
priv->port_open = MTRUE;
|
}
|
priv->adapter->scan_block = MFALSE;
|
wlan_recv_event(priv, MLAN_EVENT_ID_FW_PORT_RELEASE, MNULL);
|
}
|
|
void
|
hostsa_StaSendDeauth(t_void *pmlan_private, t_u8 *addr, t_u16 reason)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
mlan_deauth_param deauth;
|
|
ENTER();
|
|
memcpy(pmadapter, deauth.mac_addr, addr, MLAN_MAC_ADDR_LENGTH);
|
deauth.reason_code = reason;
|
|
ret = wlan_prepare_cmd(pmpriv,
|
HostCmd_CMD_802_11_DEAUTHENTICATE,
|
HostCmd_ACT_GEN_SET,
|
0, MNULL, (t_void *)&deauth);
|
if (ret == MLAN_STATUS_SUCCESS)
|
wlan_recv_event(pmpriv, MLAN_EVENT_ID_DRV_DEFER_HANDLING,
|
MNULL);
|
|
LEAVE();
|
}
|
|
t_u8
|
Hostsa_get_bss_role(t_void *pmlan_private)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
|
return GET_BSS_ROLE(pmpriv);
|
}
|
|
t_u8
|
Hostsa_get_intf_hr_len(t_void *pmlan_private)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
|
return pmpriv->intf_hr_len;
|
}
|
|
/**
|
* @brief send event to moal to notice that 4 way handshake complete
|
*
|
* @param pmlan_private A void pointer
|
* @param addr pointer to station mac address
|
*
|
* @return
|
*/
|
t_void
|
Hostsa_sendEventRsnConnect(t_void *pmlan_private, t_u8 *addr)
|
{
|
mlan_private *pmpriv = (mlan_private *)pmlan_private;
|
mlan_adapter *pmadapter = pmpriv->adapter;
|
t_u8 *event_buf = MNULL, *pos = MNULL;
|
t_u32 event_cause = 0;
|
mlan_event *pevent = MNULL;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
ret = pmadapter->callbacks.moal_malloc(pmadapter->pmoal_handle,
|
MAX_EVENT_SIZE, MLAN_MEM_DEF,
|
&event_buf);
|
if ((ret != MLAN_STATUS_SUCCESS) || !event_buf) {
|
PRINTM(MERROR, "Could not allocate buffer for event buf\n");
|
goto done;
|
}
|
pevent = (pmlan_event)event_buf;
|
memset(pmadapter, event_buf, 0, MAX_EVENT_SIZE);
|
|
pevent->event_id = MLAN_EVENT_ID_DRV_PASSTHRU;
|
pevent->bss_index = pmpriv->bss_index;
|
event_cause = wlan_cpu_to_le32(0x51); /*MICRO_AP_EV_ID_RSN_CONNECT */
|
memcpy(pmadapter, (t_u8 *)pevent->event_buf,
|
(t_u8 *)&event_cause, sizeof(event_cause));
|
pos = pevent->event_buf + sizeof(event_cause) + 2; /*reserved 2 byte */
|
memcpy(pmadapter, (t_u8 *)pos, addr, MLAN_MAC_ADDR_LENGTH);
|
|
pevent->event_len = MLAN_MAC_ADDR_LENGTH + sizeof(event_cause) + 2;
|
wlan_recv_event(pmpriv, MLAN_EVENT_ID_DRV_PASSTHRU, event_buf);
|
|
done:
|
if (event_buf)
|
pmadapter->callbacks.moal_mfree(pmadapter->pmoal_handle,
|
event_buf);
|
|
LEAVE();
|
}
|
|
/**
|
* @brief This function initializes callbacks that hostsa interface uses.
|
*
|
* @param pmpriv A pointer to mlan_private structure
|
* @param putil_fns A pointer to hostsa_util_fns structure
|
* @param pmlan_fns A pointer to hostsa_mlan_fns structure
|
*
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
*/
|
static t_void
|
hostsa_mlan_callbacks(IN pmlan_private pmpriv,
|
IN hostsa_util_fns *putil_fns,
|
IN hostsa_mlan_fns *pmlan_fns)
|
{
|
pmlan_adapter pmadapter = pmpriv->adapter;
|
pmlan_callbacks pcb = &pmadapter->callbacks;
|
|
putil_fns->pmoal_handle = pmadapter->pmoal_handle;
|
putil_fns->moal_malloc = pcb->moal_malloc;
|
putil_fns->moal_mfree = pcb->moal_mfree;
|
putil_fns->moal_memset = pcb->moal_memset;
|
putil_fns->moal_memcpy = pcb->moal_memcpy;
|
putil_fns->moal_memmove = pcb->moal_memmove;
|
putil_fns->moal_memcmp = pcb->moal_memcmp;
|
putil_fns->moal_udelay = pcb->moal_udelay;
|
putil_fns->moal_get_system_time = pcb->moal_get_system_time;
|
putil_fns->moal_init_timer = pcb->moal_init_timer;
|
putil_fns->moal_free_timer = pcb->moal_free_timer;
|
putil_fns->moal_start_timer = pcb->moal_start_timer;
|
putil_fns->moal_stop_timer = pcb->moal_stop_timer;
|
putil_fns->moal_init_lock = pcb->moal_init_lock;
|
putil_fns->moal_free_lock = pcb->moal_free_lock;
|
putil_fns->moal_spin_lock = pcb->moal_spin_lock;
|
putil_fns->moal_spin_unlock = pcb->moal_spin_unlock;
|
putil_fns->moal_print = pcb->moal_print;
|
putil_fns->moal_print_netintf = pcb->moal_print_netintf;
|
|
pmlan_fns->pmlan_private = pmpriv;
|
pmlan_fns->pmlan_adapter = pmpriv->adapter;
|
pmlan_fns->bss_index = pmpriv->bss_index;
|
pmlan_fns->bss_type = pmpriv->bss_type;
|
#if 0
|
pmlan_fns->mlan_add_buf_txqueue = mlan_add_buf_txqueue;
|
pmlan_fns->mlan_select_wmm_queue = mlan_select_wmm_queue;
|
pmlan_fns->mlan_write_data_complete = mlan_write_data_complete;
|
#endif
|
pmlan_fns->hostsa_alloc_mlan_buffer = hostsa_alloc_mlan_buffer;
|
pmlan_fns->hostsa_tx_packet = hostsa_tx_packet;
|
pmlan_fns->hostsa_set_encrypt_key = wlan_set_encrypt_key;
|
pmlan_fns->hostsa_clr_encrypt_key = wlan_clr_encrypt_key;
|
pmlan_fns->hostsa_SendDeauth = hostsa_SendDeauth;
|
pmlan_fns->Hostsa_DisAssocAllSta = ApDisAssocAllSta;
|
pmlan_fns->hostsa_free_mlan_buffer = hostsa_free_mlan_buffer;
|
pmlan_fns->Hostsa_get_station_entry = Hostsa_get_station_entry;
|
pmlan_fns->Hostsa_set_mgmt_ie = Hostsa_set_mgmt_ie;
|
pmlan_fns->Hostsa_find_connection = Hostsa_find_connection;
|
pmlan_fns->Hostsa_find_next_connection = Hostsa_find_next_connection;
|
pmlan_fns->Hostsa_StaControlledPortOpen = StaControlledPortOpen;
|
pmlan_fns->hostsa_StaSendDeauth = hostsa_StaSendDeauth;
|
pmlan_fns->Hostsa_get_bss_role = Hostsa_get_bss_role;
|
pmlan_fns->Hostsa_get_intf_hr_len = Hostsa_get_intf_hr_len;
|
pmlan_fns->Hostsa_sendEventRsnConnect = Hostsa_sendEventRsnConnect;
|
};
|
|
/**
|
* @brief Init hostsa data
|
*
|
* @param pmpriv A pointer to mlan_private structure
|
*
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
*/
|
mlan_status
|
hostsa_init(pmlan_private pmpriv)
|
{
|
hostsa_util_fns util_fns;
|
hostsa_mlan_fns mlan_fns;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
hostsa_mlan_callbacks(pmpriv, &util_fns, &mlan_fns);
|
ret = supplicant_authenticator_init(&pmpriv->psapriv, &util_fns,
|
&mlan_fns, pmpriv->curr_addr);
|
|
LEAVE();
|
return ret;
|
}
|
|
/**
|
* @brief Cleanup hostsa data
|
*
|
* @param pmpriv A pointer to mlan_private structure
|
*
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
*/
|
mlan_status
|
hostsa_cleanup(pmlan_private pmpriv)
|
{
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
supplicant_authenticator_free(pmpriv->psapriv);
|
|
LEAVE();
|
return ret;
|
}
|
