| /* |
| * Copyright (c) 2012-2016 The Linux Foundation. All rights reserved. |
| * |
| * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| * |
| * |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all |
| * copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* |
| * This file was originally distributed by Qualcomm Atheros, Inc. |
| * under proprietary terms before Copyright ownership was assigned |
| * to the Linux Foundation. |
| */ |
| |
| #include "wni_api.h" |
| #include "wni_cfg.h" |
| #include "cfg_api.h" |
| #include "sir_api.h" |
| #include "sch_api.h" |
| #include "utils_api.h" |
| #include "lim_utils.h" |
| #include "lim_assoc_utils.h" |
| #include "lim_security_utils.h" |
| #include "lim_ser_des_utils.h" |
| #include "lim_timer_utils.h" |
| #include "lim_send_messages.h" |
| #include "lim_admit_control.h" |
| #include "lim_send_messages.h" |
| #include "lim_ibss_peer_mgmt.h" |
| #include "lim_ft.h" |
| #include "lim_ft_defs.h" |
| #include "lim_session.h" |
| #include "lim_session_utils.h" |
| #include "rrm_api.h" |
| #include "wma_types.h" |
| #include "cds_utils.h" |
| #include "lim_types.h" |
| #include "cds_concurrency.h" |
| #include "nan_datapath.h" |
| |
| #define MAX_SUPPORTED_PEERS_WEP 16 |
| |
| void lim_process_mlm_join_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_auth_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_start_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_assoc_ind(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_assoc_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_reassoc_ind(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_set_keys_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_disassoc_ind(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_disassoc_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_deauth_ind(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_deauth_cnf(tpAniSirGlobal, uint32_t *); |
| void lim_process_mlm_purge_sta_ind(tpAniSirGlobal, uint32_t *); |
| void lim_get_session_info(tpAniSirGlobal pMac, uint8_t *, uint8_t *, |
| uint16_t *); |
| /** |
| * lim_process_mlm_rsp_messages() |
| * |
| ***FUNCTION: |
| * This function is called to processes various MLM response (CNF/IND |
| * messages from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param msgType Indicates the MLM message type |
| * @param *pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void |
| lim_process_mlm_rsp_messages(tpAniSirGlobal pMac, uint32_t msgType, |
| uint32_t *pMsgBuf) |
| { |
| |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| MTRACE(mac_trace(pMac, TRACE_CODE_TX_LIM_MSG, 0, msgType)); |
| switch (msgType) { |
| case LIM_MLM_AUTH_CNF: |
| lim_process_mlm_auth_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_ASSOC_CNF: |
| lim_process_mlm_assoc_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_START_CNF: |
| lim_process_mlm_start_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_JOIN_CNF: |
| lim_process_mlm_join_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_ASSOC_IND: |
| lim_process_mlm_assoc_ind(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_REASSOC_CNF: |
| lim_process_mlm_reassoc_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_DISASSOC_CNF: |
| lim_process_mlm_disassoc_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_DISASSOC_IND: |
| lim_process_mlm_disassoc_ind(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_PURGE_STA_IND: |
| lim_process_mlm_purge_sta_ind(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_DEAUTH_CNF: |
| lim_process_mlm_deauth_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_DEAUTH_IND: |
| lim_process_mlm_deauth_ind(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_SETKEYS_CNF: |
| lim_process_mlm_set_keys_cnf(pMac, pMsgBuf); |
| break; |
| case LIM_MLM_TSPEC_CNF: |
| break; |
| default: |
| break; |
| } /* switch (msgType) */ |
| return; |
| } /*** end lim_process_mlm_rsp_messages() ***/ |
| |
| /** |
| * lim_process_mlm_start_cnf() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_START_CNF |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_start_cnf(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| tpPESession psessionEntry = NULL; |
| tLimMlmStartCnf *pLimMlmStartCnf; |
| uint8_t smesessionId; |
| uint16_t smetransactionId; |
| uint8_t channelId; |
| uint8_t send_bcon_ind = false; |
| |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| pLimMlmStartCnf = (tLimMlmStartCnf *) pMsgBuf; |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pLimMlmStartCnf->sessionId); |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL( |
| "Session does Not exist with given sessionId "));) |
| return; |
| } |
| smesessionId = psessionEntry->smeSessionId; |
| smetransactionId = psessionEntry->transactionId; |
| |
| if (psessionEntry->limSmeState != eLIM_SME_WT_START_BSS_STATE) { |
| /* |
| * Should not have received Start confirm from MLM |
| * in other states. Log error. |
| */ |
| PELOGE(lim_log(pMac, LOGE, FL |
| ("received unexpected MLM_START_CNF in state %X"), |
| psessionEntry->limSmeState);) |
| return; |
| } |
| if (((tLimMlmStartCnf *) pMsgBuf)->resultCode == eSIR_SME_SUCCESS) { |
| |
| /* |
| * Update global SME state so that Beacon Generation |
| * module starts writing Beacon frames into TFP's |
| * Beacon file register. |
| */ |
| psessionEntry->limSmeState = eLIM_SME_NORMAL_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_SME_STATE, psessionEntry->peSessionId, |
| psessionEntry->limSmeState)); |
| if (psessionEntry->bssType == eSIR_INFRA_AP_MODE) |
| lim_log(pMac, LOG1, |
| FL("*** Started BSS in INFRA AP SIDE***")); |
| else if (psessionEntry->bssType == eSIR_NDI_MODE) |
| lim_log(pMac, LOG1, |
| FL("*** Started BSS in NDI mode ***")); |
| else |
| lim_log(pMac, LOG1, FL("*** Started BSS ***")); |
| } else { |
| /* Start BSS is a failure */ |
| pe_delete_session(pMac, psessionEntry); |
| psessionEntry = NULL; |
| PELOGE(lim_log(pMac, LOGE, FL("Start BSS Failed "));) |
| } |
| /* Send response to Host */ |
| lim_send_sme_start_bss_rsp(pMac, eWNI_SME_START_BSS_RSP, |
| ((tLimMlmStartCnf *)pMsgBuf)->resultCode, |
| psessionEntry, smesessionId, smetransactionId); |
| if ((psessionEntry != NULL) && |
| (((tLimMlmStartCnf *) pMsgBuf)->resultCode == |
| eSIR_SME_SUCCESS)) { |
| channelId = psessionEntry->pLimStartBssReq->channelId; |
| |
| /* We should start beacon transmission only if the channel |
| * on which we are operating is non-DFS until the channel |
| * availability check is done. The PE will receive an explicit |
| * request from upper layers to start the beacon transmission |
| */ |
| |
| if (!(LIM_IS_IBSS_ROLE(psessionEntry) || |
| (LIM_IS_AP_ROLE(psessionEntry)))) |
| return; |
| if (psessionEntry->ch_width == CH_WIDTH_160MHZ) { |
| send_bcon_ind = false; |
| } else if (psessionEntry->ch_width == CH_WIDTH_80P80MHZ) { |
| if ((cds_get_channel_state(channelId) != |
| CHANNEL_STATE_DFS) && |
| (cds_get_channel_state(psessionEntry-> |
| ch_center_freq_seg1 - |
| SIR_80MHZ_START_CENTER_CH_DIFF) != |
| CHANNEL_STATE_DFS)) |
| send_bcon_ind = true; |
| } else { |
| if (cds_get_channel_state(channelId) != |
| CHANNEL_STATE_DFS) |
| send_bcon_ind = true; |
| } |
| if (send_bcon_ind) { |
| /* Configure beacon and send beacons to HAL */ |
| QDF_TRACE(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_INFO, |
| FL("Start Beacon with ssid %s Ch %d"), |
| psessionEntry->ssId.ssId, |
| psessionEntry->currentOperChannel); |
| lim_send_beacon_ind(pMac, psessionEntry); |
| } |
| } |
| } |
| |
| /*** end lim_process_mlm_start_cnf() ***/ |
| |
| /** |
| * lim_process_mlm_join_cnf() - Processes join confirmation |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: A pointer to the MLM message buffer |
| * |
| * This Function handles the join confirmation message |
| * LIM_MLM_JOIN_CNF. |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_join_cnf(tpAniSirGlobal mac_ctx, |
| uint32_t *msg) |
| { |
| tSirResultCodes result_code; |
| tLimMlmJoinCnf *join_cnf; |
| tpPESession session_entry; |
| |
| join_cnf = (tLimMlmJoinCnf *) msg; |
| session_entry = pe_find_session_by_session_id(mac_ctx, |
| join_cnf->sessionId); |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, FL("SessionId:%d does not exist"), |
| join_cnf->sessionId); |
| return; |
| } |
| |
| if (session_entry->limSmeState != eLIM_SME_WT_JOIN_STATE) { |
| lim_log(mac_ctx, LOGE, |
| FL("received unexpected MLM_JOIN_CNF in state %X"), |
| session_entry->limSmeState); |
| return; |
| } |
| |
| result_code = ((tLimMlmJoinCnf *) msg)->resultCode; |
| /* Process Join confirm from MLM */ |
| if (result_code == eSIR_SME_SUCCESS) { |
| lim_log(mac_ctx, LOG1, FL("***SessionId:%d Joined ESS ***"), |
| join_cnf->sessionId); |
| /* Setup hardware upfront */ |
| if (lim_sta_send_add_bss_pre_assoc(mac_ctx, false, |
| session_entry) == eSIR_SUCCESS) |
| return; |
| else |
| result_code = eSIR_SME_REFUSED; |
| } |
| |
| /* Join failure */ |
| session_entry->limSmeState = eLIM_SME_JOIN_FAILURE_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| /* Send Join response to Host */ |
| lim_handle_sme_join_result(mac_ctx, result_code, |
| ((tLimMlmJoinCnf *) msg)->protStatusCode, session_entry); |
| return; |
| } |
| |
| /** |
| * lim_send_mlm_assoc_req() - Association request will be processed |
| * mac_ctx: Pointer to Global MAC structure |
| * session_entry: Pointer to session etnry |
| * |
| * This function is sends ASSOC request MLM message to MLM State machine. |
| * ASSOC request packet would be by picking parameters from psessionEntry |
| * automatically based on the current state of MLM state machine. |
| * ASSUMPTIONS: |
| * this function is called in middle of connection state machine and is |
| * expected to be called after auth cnf has been received or after ASSOC rsp |
| * with TRY_AGAIN_LATER was received and required time has elapsed after that. |
| * |
| * Return: None |
| */ |
| |
| static void lim_send_mlm_assoc_req(tpAniSirGlobal mac_ctx, |
| tpPESession session_entry) |
| { |
| tLimMlmAssocReq *assoc_req; |
| uint32_t val; |
| uint16_t caps; |
| uint32_t tele_bcn = 0; |
| tpSirMacCapabilityInfo cap_info; |
| |
| /* Successful MAC based authentication. Trigger Association with BSS */ |
| lim_log(mac_ctx, LOG1, FL("SessionId:%d Authenticated with BSS"), |
| session_entry->peSessionId); |
| |
| if (NULL == session_entry->pLimJoinReq) { |
| lim_log(mac_ctx, LOGE, FL("Join Request is NULL.")); |
| /* No need to Assert. JOIN timeout will handle this error */ |
| return; |
| } |
| |
| assoc_req = qdf_mem_malloc(sizeof(tLimMlmAssocReq)); |
| if (NULL == assoc_req) { |
| lim_log(mac_ctx, LOGP, |
| FL("call to AllocateMemory failed for mlmAssocReq")); |
| return; |
| } |
| val = sizeof(tSirMacAddr); |
| sir_copy_mac_addr(assoc_req->peerMacAddr, session_entry->bssId); |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_ASSOCIATION_FAILURE_TIMEOUT, |
| (uint32_t *) &assoc_req->assocFailureTimeout) |
| != eSIR_SUCCESS) { |
| /* Could not get AssocFailureTimeout value from CFG.*/ |
| lim_log(mac_ctx, LOGP, |
| FL("could not retrieve AssocFailureTimeout value")); |
| } |
| |
| if (cfg_get_capability_info(mac_ctx, &caps, session_entry) |
| != eSIR_SUCCESS) |
| /* Could not get Capabilities value from CFG.*/ |
| lim_log(mac_ctx, LOGP, |
| FL("could not retrieve Capabilities value")); |
| |
| /* Clear spectrum management bit if AP doesn't support it */ |
| if (!(session_entry->pLimJoinReq->bssDescription.capabilityInfo & |
| LIM_SPECTRUM_MANAGEMENT_BIT_MASK)) |
| /* |
| * AP doesn't support spectrum management |
| * clear spectrum management bit |
| */ |
| caps &= (~LIM_SPECTRUM_MANAGEMENT_BIT_MASK); |
| |
| /* |
| * RM capability should be independent of AP's capabilities |
| * Refer 8.4.1.4 Capability Information field in 802.11-2012 |
| * Do not modify it. |
| */ |
| |
| /* Clear short preamble bit if AP does not support it */ |
| if (!(session_entry->pLimJoinReq->bssDescription.capabilityInfo & |
| (LIM_SHORT_PREAMBLE_BIT_MASK))) { |
| caps &= (~LIM_SHORT_PREAMBLE_BIT_MASK); |
| lim_log(mac_ctx, LOG1, |
| FL("Clearing short preamble:no AP support")); |
| } |
| |
| /* Clear immediate block ack bit if AP does not support it */ |
| if (!(session_entry->pLimJoinReq->bssDescription.capabilityInfo & |
| (LIM_IMMEDIATE_BLOCK_ACK_MASK))) { |
| caps &= (~LIM_IMMEDIATE_BLOCK_ACK_MASK); |
| lim_log(mac_ctx, LOG1, |
| FL("Clearing Immed Blk Ack:no AP support")); |
| } |
| |
| assoc_req->capabilityInfo = caps; |
| cap_info = ((tpSirMacCapabilityInfo) &assoc_req->capabilityInfo); |
| lim_log(mac_ctx, LOG3, FL("Capabilities to be used in AssocReq=0x%X," |
| "privacy bit=%x shortSlotTime %x"), caps, |
| cap_info->privacy, |
| cap_info->shortSlotTime); |
| |
| /* |
| * If telescopic beaconing is enabled, set listen interval to |
| * WNI_CFG_TELE_BCN_MAX_LI |
| */ |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_TELE_BCN_WAKEUP_EN, &tele_bcn) |
| != eSIR_SUCCESS) |
| lim_log(mac_ctx, LOGP, |
| FL("Couldn't get WNI_CFG_TELE_BCN_WAKEUP_EN")); |
| |
| val = WNI_CFG_LISTEN_INTERVAL_STADEF; |
| if (tele_bcn) { |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_TELE_BCN_MAX_LI, &val) != |
| eSIR_SUCCESS) |
| /* |
| * Could not get ListenInterval value |
| * from CFG. Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("could not retrieve ListenInterval")); |
| } else { |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_LISTEN_INTERVAL, |
| &val) != eSIR_SUCCESS) |
| /* |
| * Could not get ListenInterval value |
| * from CFG. Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("could not retrieve ListenInterval")); |
| } |
| #ifdef FEATURE_WLAN_DIAG_SUPPORT |
| lim_diag_event_report(mac_ctx, WLAN_PE_DIAG_ASSOC_REQ_EVENT, |
| session_entry, eSIR_SUCCESS, eSIR_SUCCESS); |
| #endif |
| assoc_req->listenInterval = (uint16_t) val; |
| /* Update PE session ID */ |
| assoc_req->sessionId = session_entry->peSessionId; |
| session_entry->limPrevSmeState = session_entry->limSmeState; |
| session_entry->limSmeState = eLIM_SME_WT_ASSOC_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, session_entry->limSmeState)); |
| lim_post_mlm_message(mac_ctx, LIM_MLM_ASSOC_REQ, |
| (uint32_t *) assoc_req); |
| } |
| |
| #ifdef WLAN_FEATURE_11W |
| /** |
| * lim_pmf_comeback_timer_callback() -PMF callback handler |
| * @context: Timer context |
| * |
| * This function is called to processes the PMF comeback |
| * callback |
| * |
| * Return: None |
| */ |
| void lim_pmf_comeback_timer_callback(void *context) |
| { |
| tComebackTimerInfo *info = (tComebackTimerInfo *) context; |
| tpAniSirGlobal mac_ctx = info->pMac; |
| tpPESession psessionEntry = &mac_ctx->lim.gpSession[info->sessionID]; |
| |
| lim_log(mac_ctx, LOGE, |
| FL("comeback later timer expired. sending MLM ASSOC req")); |
| /* set MLM state such that ASSOC REQ packet will be sent out */ |
| psessionEntry->limPrevMlmState = info->limPrevMlmState; |
| psessionEntry->limMlmState = info->limMlmState; |
| lim_send_mlm_assoc_req(mac_ctx, psessionEntry); |
| } |
| #endif /* WLAN_FEATURE_11W */ |
| |
| /** |
| * lim_process_mlm_auth_cnf()-Process Auth confirmation |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: A pointer to the MLM message buffer |
| * |
| * This function is called to processes MLM_AUTH_CNF |
| * message from MLM State machine. |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_auth_cnf(tpAniSirGlobal mac_ctx, uint32_t *msg) |
| { |
| tAniAuthType auth_type, auth_mode; |
| tLimMlmAuthReq *auth_req; |
| tLimMlmAuthCnf *auth_cnf; |
| tpPESession session_entry; |
| |
| if (msg == NULL) { |
| lim_log(mac_ctx, LOGE, FL("Buffer is Pointing to NULL")); |
| return; |
| } |
| auth_cnf = (tLimMlmAuthCnf *) msg; |
| session_entry = pe_find_session_by_session_id(mac_ctx, |
| auth_cnf->sessionId); |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, FL("SessionId:%d session doesn't exist"), |
| auth_cnf->sessionId); |
| return; |
| } |
| |
| if ((session_entry->limSmeState != eLIM_SME_WT_AUTH_STATE && |
| session_entry->limSmeState != eLIM_SME_WT_PRE_AUTH_STATE) || |
| LIM_IS_AP_ROLE(session_entry)) { |
| /** |
| * Should not have received AUTH confirm |
| * from MLM in other states or on AP. |
| * Log error |
| */ |
| lim_log(mac_ctx, LOGE, |
| FL("SessionId:%d received MLM_AUTH_CNF in state %X"), |
| session_entry->peSessionId, session_entry->limSmeState); |
| return; |
| } |
| |
| if (auth_cnf->resultCode == eSIR_SME_SUCCESS) { |
| if (session_entry->limSmeState == eLIM_SME_WT_AUTH_STATE) { |
| lim_send_mlm_assoc_req(mac_ctx, session_entry); |
| } else { |
| /* |
| * Successful Pre-authentication. Send |
| * Pre-auth response to host |
| */ |
| session_entry->limSmeState = |
| session_entry->limPrevSmeState; |
| MTRACE(mac_trace |
| (mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| } |
| /* Return for success case */ |
| return; |
| } |
| /* |
| * Failure case handle: |
| * Process AUTH confirm from MLM |
| */ |
| if (session_entry->limSmeState == eLIM_SME_WT_AUTH_STATE) { |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_AUTHENTICATION_TYPE, |
| (uint32_t *) &auth_type) != eSIR_SUCCESS) { |
| /* |
| * Could not get AuthType value from CFG. |
| * Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("Fail to retrieve AuthType value")); |
| } |
| } else { |
| auth_type = mac_ctx->lim.gLimPreAuthType; |
| } |
| |
| if ((auth_type == eSIR_AUTO_SWITCH) && |
| (auth_cnf->authType == eSIR_SHARED_KEY) && |
| ((eSIR_MAC_AUTH_ALGO_NOT_SUPPORTED_STATUS == |
| auth_cnf->protStatusCode) || |
| (auth_cnf->resultCode == eSIR_SME_AUTH_TIMEOUT_RESULT_CODE))) { |
| /* |
| * When shared authentication fails with reason |
| * code "13" and authType set to 'auto switch', |
| * Try with open Authentication |
| */ |
| auth_mode = eSIR_OPEN_SYSTEM; |
| /* Trigger MAC based Authentication */ |
| auth_req = qdf_mem_malloc(sizeof(tLimMlmAuthReq)); |
| if (NULL == auth_req) { |
| /* Log error */ |
| lim_log(mac_ctx, LOGP, |
| FL("mlmAuthReq :Memory alloc failed ")); |
| return; |
| } |
| if (session_entry->limSmeState == |
| eLIM_SME_WT_AUTH_STATE) { |
| sir_copy_mac_addr(auth_req->peerMacAddr, |
| session_entry->bssId); |
| } else { |
| qdf_mem_copy((uint8_t *)&auth_req->peerMacAddr, |
| (uint8_t *)&mac_ctx->lim.gLimPreAuthPeerAddr, |
| sizeof(tSirMacAddr)); |
| } |
| auth_req->authType = auth_mode; |
| /* Update PE session Id */ |
| auth_req->sessionId = auth_cnf->sessionId; |
| if (wlan_cfg_get_int(mac_ctx, |
| WNI_CFG_AUTHENTICATE_FAILURE_TIMEOUT, |
| (uint32_t *) &auth_req->authFailureTimeout) |
| != eSIR_SUCCESS) { |
| /* |
| * Could not get AuthFailureTimeout value from CFG. |
| * Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("Fail:retrieve AuthFailureTimeout ")); |
| } |
| lim_post_mlm_message(mac_ctx, LIM_MLM_AUTH_REQ, |
| (uint32_t *) auth_req); |
| return; |
| } else { |
| /* MAC based authentication failure */ |
| if (session_entry->limSmeState == |
| eLIM_SME_WT_AUTH_STATE) { |
| lim_log(mac_ctx, LOGE, |
| FL("Auth Failure occurred.")); |
| session_entry->limSmeState = |
| eLIM_SME_JOIN_FAILURE_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| session_entry->limMlmState = |
| eLIM_MLM_IDLE_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, |
| session_entry->limMlmState)); |
| /* |
| * Need to send Join response with |
| * auth failure to Host. |
| */ |
| lim_handle_sme_join_result(mac_ctx, |
| auth_cnf->resultCode, |
| auth_cnf->protStatusCode, |
| session_entry); |
| } else { |
| /* |
| * Pre-authentication failure. |
| * Send Pre-auth failure response to host |
| */ |
| session_entry->limSmeState = |
| session_entry->limPrevSmeState; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| } |
| } |
| } |
| |
| /** |
| * lim_process_mlm_assoc_cnf() - Process association confirmation |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: A pointer to the MLM message buffer |
| * |
| * This function is called to processes MLM_ASSOC_CNF |
| * message from MLM State machine. |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_assoc_cnf(tpAniSirGlobal mac_ctx, |
| uint32_t *msg) |
| { |
| tpPESession session_entry; |
| tLimMlmAssocCnf *assoc_cnf; |
| |
| if (msg == NULL) { |
| lim_log(mac_ctx, LOGE, FL("Buffer is Pointing to NULL")); |
| return; |
| } |
| assoc_cnf = (tLimMlmAssocCnf *) msg; |
| session_entry = pe_find_session_by_session_id(mac_ctx, |
| assoc_cnf->sessionId); |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, |
| FL("SessionId:%d Session does not exist"), |
| assoc_cnf->sessionId); |
| return; |
| } |
| if (session_entry->limSmeState != eLIM_SME_WT_ASSOC_STATE || |
| LIM_IS_AP_ROLE(session_entry)) { |
| /* |
| * Should not have received Assocication confirm |
| * from MLM in other states OR on AP. |
| * Log error |
| */ |
| lim_log(mac_ctx, LOGE, |
| FL("SessionId:%d Received MLM_ASSOC_CNF in state %X"), |
| session_entry->peSessionId, session_entry->limSmeState); |
| return; |
| } |
| if (((tLimMlmAssocCnf *) msg)->resultCode != eSIR_SME_SUCCESS) { |
| /* Association failure */ |
| lim_log(mac_ctx, LOG1, FL("SessionId:%d Association failure resultCode: %d limSmeState:%d"), |
| session_entry->peSessionId, |
| ((tLimMlmAssocCnf *) msg)->resultCode, |
| session_entry->limSmeState); |
| |
| /* If driver gets deauth when its waiting for ADD_STA_RSP then |
| * we need to do DEL_STA followed by DEL_BSS. So based on below |
| * reason-code here we decide whether to do only DEL_BSS or |
| * DEL_STA + DEL_BSS. |
| */ |
| if (((tLimMlmAssocCnf *) msg)->resultCode != |
| eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA) |
| session_entry->limSmeState = |
| eLIM_SME_JOIN_FAILURE_STATE; |
| |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, mac_ctx->lim.gLimSmeState)); |
| /* |
| * Need to send Join response with |
| * Association failure to Host. |
| */ |
| lim_handle_sme_join_result(mac_ctx, |
| ((tLimMlmAssocCnf *) msg)->resultCode, |
| ((tLimMlmAssocCnf *) msg)->protStatusCode, |
| session_entry); |
| } else { |
| /* Successful Association */ |
| lim_log(mac_ctx, LOG1, FL("SessionId:%d Associated with BSS"), |
| session_entry->peSessionId); |
| session_entry->limSmeState = eLIM_SME_LINK_EST_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| /** |
| * Need to send Join response with |
| * Association success to Host. |
| */ |
| lim_handle_sme_join_result(mac_ctx, |
| ((tLimMlmAssocCnf *) msg)->resultCode, |
| ((tLimMlmAssocCnf *) msg)->protStatusCode, |
| session_entry); |
| } |
| } |
| |
| /** |
| * lim_fill_assoc_ind_params() - Initialize association indication |
| * mac_ctx: Pointer to Global MAC structure |
| * assoc_ind: PE association indication structure |
| * sme_assoc_ind: SME association indication |
| * session_entry: PE session entry |
| * |
| * This function is called to initialzie the association |
| * indication strucutre to process association indication. |
| * |
| * Return: None |
| */ |
| |
| static void |
| lim_fill_assoc_ind_params(tpAniSirGlobal mac_ctx, |
| tpLimMlmAssocInd assoc_ind, tSirSmeAssocInd *sme_assoc_ind, |
| tpPESession session_entry) |
| { |
| sme_assoc_ind->length = sizeof(tSirSmeAssocInd); |
| sme_assoc_ind->sessionId = session_entry->smeSessionId; |
| |
| /* Required for indicating the frames to upper layer */ |
| sme_assoc_ind->assocReqLength = assoc_ind->assocReqLength; |
| sme_assoc_ind->assocReqPtr = assoc_ind->assocReqPtr; |
| |
| sme_assoc_ind->beaconPtr = session_entry->beacon; |
| sme_assoc_ind->beaconLength = session_entry->bcnLen; |
| |
| /* Fill in peerMacAddr */ |
| qdf_mem_copy(sme_assoc_ind->peerMacAddr, assoc_ind->peerMacAddr, |
| sizeof(tSirMacAddr)); |
| |
| /* Fill in aid */ |
| sme_assoc_ind->aid = assoc_ind->aid; |
| /* Fill in bssId */ |
| qdf_mem_copy(sme_assoc_ind->bssId, session_entry->bssId, |
| sizeof(tSirMacAddr)); |
| /* Fill in authType */ |
| sme_assoc_ind->authType = assoc_ind->authType; |
| /* Fill in ssId */ |
| qdf_mem_copy((uint8_t *) &sme_assoc_ind->ssId, |
| (uint8_t *) &(assoc_ind->ssId), assoc_ind->ssId.length + 1); |
| sme_assoc_ind->rsnIE.length = assoc_ind->rsnIE.length; |
| qdf_mem_copy((uint8_t *) &sme_assoc_ind->rsnIE.rsnIEdata, |
| (uint8_t *) &(assoc_ind->rsnIE.rsnIEdata), |
| assoc_ind->rsnIE.length); |
| |
| #ifdef FEATURE_WLAN_WAPI |
| sme_assoc_ind->wapiIE.length = assoc_ind->wapiIE.length; |
| qdf_mem_copy((uint8_t *) &sme_assoc_ind->wapiIE.wapiIEdata, |
| (uint8_t *) &(assoc_ind->wapiIE.wapiIEdata), |
| assoc_ind->wapiIE.length); |
| #endif |
| sme_assoc_ind->addIE.length = assoc_ind->addIE.length; |
| qdf_mem_copy((uint8_t *) &sme_assoc_ind->addIE.addIEdata, |
| (uint8_t *) &(assoc_ind->addIE.addIEdata), |
| assoc_ind->addIE.length); |
| |
| /* Copy the new TITAN capabilities */ |
| sme_assoc_ind->spectrumMgtIndicator = assoc_ind->spectrumMgtIndicator; |
| if (assoc_ind->spectrumMgtIndicator == eSIR_TRUE) { |
| sme_assoc_ind->powerCap.minTxPower = |
| assoc_ind->powerCap.minTxPower; |
| sme_assoc_ind->powerCap.maxTxPower = |
| assoc_ind->powerCap.maxTxPower; |
| sme_assoc_ind->supportedChannels.numChnl = |
| assoc_ind->supportedChannels.numChnl; |
| qdf_mem_copy((uint8_t *) &sme_assoc_ind->supportedChannels. |
| channelList, |
| (uint8_t *) &(assoc_ind->supportedChannels.channelList), |
| assoc_ind->supportedChannels.numChnl); |
| } |
| qdf_mem_copy(&sme_assoc_ind->chan_info, &assoc_ind->chan_info, |
| sizeof(tSirSmeChanInfo)); |
| /* Fill in WmmInfo */ |
| sme_assoc_ind->wmmEnabledSta = assoc_ind->WmmStaInfoPresent; |
| } |
| |
| /** |
| * lim_process_mlm_assoc_ind() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_ASSOC_IND |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_assoc_ind(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| uint32_t len; |
| tSirMsgQ msgQ; |
| tSirSmeAssocInd *pSirSmeAssocInd; |
| tpDphHashNode pStaDs = 0; |
| tpPESession psessionEntry; |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| ((tpLimMlmAssocInd) pMsgBuf)-> |
| sessionId); |
| if (psessionEntry == NULL) { |
| lim_log(pMac, LOGE, |
| FL("Session Does not exist for given sessionId")); |
| return; |
| } |
| /* / Inform Host of STA association */ |
| len = sizeof(tSirSmeAssocInd); |
| pSirSmeAssocInd = qdf_mem_malloc(len); |
| if (NULL == pSirSmeAssocInd) { |
| /* Log error */ |
| lim_log(pMac, LOGP, |
| FL |
| ("call to AllocateMemory failed for eWNI_SME_ASSOC_IND")); |
| return; |
| } |
| |
| pSirSmeAssocInd->messageType = eWNI_SME_ASSOC_IND; |
| lim_fill_assoc_ind_params(pMac, (tpLimMlmAssocInd) pMsgBuf, pSirSmeAssocInd, |
| psessionEntry); |
| msgQ.type = eWNI_SME_ASSOC_IND; |
| msgQ.bodyptr = pSirSmeAssocInd; |
| msgQ.bodyval = 0; |
| pStaDs = dph_get_hash_entry(pMac, |
| ((tpLimMlmAssocInd) pMsgBuf)->aid, |
| &psessionEntry->dph.dphHashTable); |
| if (!pStaDs) { /* good time to panic... */ |
| lim_log(pMac, LOGE, |
| FL |
| ("MLM AssocInd: Station context no longer valid (aid %d)"), |
| ((tpLimMlmAssocInd) pMsgBuf)->aid); |
| qdf_mem_free(pSirSmeAssocInd); |
| |
| return; |
| } |
| pSirSmeAssocInd->staId = pStaDs->staIndex; |
| pSirSmeAssocInd->reassocReq = pStaDs->mlmStaContext.subType; |
| pSirSmeAssocInd->timingMeasCap = pStaDs->timingMeasCap; |
| MTRACE(mac_trace(pMac, TRACE_CODE_TX_SME_MSG, |
| psessionEntry->peSessionId, msgQ.type)); |
| #ifdef FEATURE_WLAN_DIAG_SUPPORT_LIM /* FEATURE_WLAN_DIAG_SUPPORT */ |
| lim_diag_event_report(pMac, WLAN_PE_DIAG_ASSOC_IND_EVENT, psessionEntry, 0, |
| 0); |
| #endif /* FEATURE_WLAN_DIAG_SUPPORT */ |
| lim_sys_process_mmh_msg_api(pMac, &msgQ, ePROT); |
| |
| PELOG1(lim_log(pMac, LOG1, |
| FL |
| ("Create CNF_WAIT_TIMER after received LIM_MLM_ASSOC_IND")); |
| ) |
| /* |
| ** turn on a timer to detect the loss of ASSOC CNF |
| **/ |
| lim_activate_cnf_timer(pMac, |
| (uint16_t) ((tpLimMlmAssocInd) pMsgBuf)->aid, |
| psessionEntry); |
| |
| } /*** end lim_process_mlm_assoc_ind() ***/ |
| |
| /** |
| * lim_process_mlm_disassoc_ind() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_DISASSOC_IND |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_disassoc_ind(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| tLimMlmDisassocInd *pMlmDisassocInd; |
| tpPESession psessionEntry; |
| pMlmDisassocInd = (tLimMlmDisassocInd *) pMsgBuf; |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pMlmDisassocInd->sessionId); |
| if (psessionEntry == NULL) { |
| lim_log(pMac, LOGP, |
| FL("Session Does not exist for given sessionID")); |
| return; |
| } |
| switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) { |
| case eLIM_STA_IN_IBSS_ROLE: |
| break; |
| case eLIM_STA_ROLE: |
| psessionEntry->limSmeState = eLIM_SME_WT_DISASSOC_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_SME_STATE, psessionEntry->peSessionId, |
| psessionEntry->limSmeState)); |
| break; |
| default: /* eLIM_AP_ROLE */ |
| PELOG1(lim_log(pMac, LOG1, |
| FL("*** Peer staId=%d Disassociated ***"), |
| pMlmDisassocInd->aid); |
| ) |
| /* Send SME_DISASOC_IND after Polaris cleanup */ |
| /* (after receiving LIM_MLM_PURGE_STA_IND) */ |
| break; |
| } /* end switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) */ |
| } /*** end lim_process_mlm_disassoc_ind() ***/ |
| |
| /** |
| * lim_process_mlm_disassoc_cnf() - Processes disassociation |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: A pointer to the MLM message buffer |
| * |
| * This function is called to processes MLM_DISASSOC_CNF |
| * message from MLM State machine. |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_disassoc_cnf(tpAniSirGlobal mac_ctx, |
| uint32_t *msg) |
| { |
| tSirResultCodes result_code; |
| tLimMlmDisassocCnf *disassoc_cnf; |
| tpPESession session_entry; |
| disassoc_cnf = (tLimMlmDisassocCnf *) msg; |
| |
| session_entry = |
| pe_find_session_by_session_id(mac_ctx, disassoc_cnf->sessionId); |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, |
| FL("session Does not exist for given session Id")); |
| return; |
| } |
| result_code = (tSirResultCodes)(disassoc_cnf->disassocTrigger == |
| eLIM_LINK_MONITORING_DISASSOC) ? |
| eSIR_SME_LOST_LINK_WITH_PEER_RESULT_CODE : |
| disassoc_cnf->resultCode; |
| if (LIM_IS_STA_ROLE(session_entry)) { |
| /* Disassociate Confirm from MLM */ |
| if ((session_entry->limSmeState != eLIM_SME_WT_DISASSOC_STATE) |
| && (session_entry->limSmeState != |
| eLIM_SME_WT_DEAUTH_STATE)) { |
| /* |
| * Should not have received |
| * Disassocate confirm |
| * from MLM in other states.Log error |
| */ |
| lim_log(mac_ctx, LOGE, |
| FL("received MLM_DISASSOC_CNF in state %X"), |
| session_entry->limSmeState); |
| return; |
| } |
| if (mac_ctx->lim.gLimRspReqd) |
| mac_ctx->lim.gLimRspReqd = false; |
| if (disassoc_cnf->disassocTrigger == |
| eLIM_PROMISCUOUS_MODE_DISASSOC) { |
| if (disassoc_cnf->resultCode != eSIR_SME_SUCCESS) |
| session_entry->limSmeState = |
| session_entry->limPrevSmeState; |
| else |
| session_entry->limSmeState = |
| eLIM_SME_OFFLINE_STATE; |
| MTRACE(mac_trace |
| (mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| } else { |
| if (disassoc_cnf->resultCode != eSIR_SME_SUCCESS) |
| session_entry->limSmeState = |
| session_entry->limPrevSmeState; |
| else |
| session_entry->limSmeState = |
| eLIM_SME_IDLE_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| lim_send_sme_disassoc_ntf(mac_ctx, |
| disassoc_cnf->peerMacAddr, result_code, |
| disassoc_cnf->disassocTrigger, |
| disassoc_cnf->aid, session_entry->smeSessionId, |
| session_entry->transactionId, session_entry); |
| } |
| } else if (LIM_IS_AP_ROLE(session_entry)) { |
| lim_send_sme_disassoc_ntf(mac_ctx, disassoc_cnf->peerMacAddr, |
| result_code, disassoc_cnf->disassocTrigger, |
| disassoc_cnf->aid, session_entry->smeSessionId, |
| session_entry->transactionId, session_entry); |
| } |
| } |
| |
| /** |
| * lim_process_mlm_deauth_ind() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_DEAUTH_IND |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_deauth_ind(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| tLimMlmDeauthInd *pMlmDeauthInd; |
| tpPESession psessionEntry; |
| uint8_t sessionId; |
| pMlmDeauthInd = (tLimMlmDeauthInd *) pMsgBuf; |
| psessionEntry = pe_find_session_by_bssid(pMac, |
| pMlmDeauthInd->peerMacAddr, &sessionId); |
| if (psessionEntry == NULL) { |
| lim_log(pMac, LOGE, |
| FL("session does not exist for Addr:" MAC_ADDRESS_STR), |
| MAC_ADDR_ARRAY(pMlmDeauthInd->peerMacAddr)); |
| return; |
| } |
| switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) { |
| case eLIM_STA_IN_IBSS_ROLE: |
| break; |
| case eLIM_STA_ROLE: |
| psessionEntry->limSmeState = eLIM_SME_WT_DEAUTH_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_SME_STATE, psessionEntry->peSessionId, |
| psessionEntry->limSmeState)); |
| |
| default: /* eLIM_AP_ROLE */ |
| { |
| PELOG1(lim_log(pMac, LOG1, |
| FL |
| ("*** Received Deauthentication from staId=%d ***"), |
| pMlmDeauthInd->aid); |
| ) |
| } |
| /* Send SME_DEAUTH_IND after Polaris cleanup */ |
| /* (after receiving LIM_MLM_PURGE_STA_IND) */ |
| break; |
| } /* end switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) */ |
| } /*** end lim_process_mlm_deauth_ind() ***/ |
| |
| /** |
| * lim_process_mlm_deauth_cnf() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_DEAUTH_CNF |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_deauth_cnf(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| uint16_t aid; |
| tSirResultCodes resultCode; |
| tLimMlmDeauthCnf *pMlmDeauthCnf; |
| tpPESession psessionEntry; |
| |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| pMlmDeauthCnf = (tLimMlmDeauthCnf *) pMsgBuf; |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pMlmDeauthCnf->sessionId); |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("session does not exist for given session Id ")); |
| ) |
| return; |
| } |
| |
| resultCode = (tSirResultCodes) |
| (pMlmDeauthCnf->deauthTrigger == |
| eLIM_LINK_MONITORING_DEAUTH) ? |
| eSIR_SME_LOST_LINK_WITH_PEER_RESULT_CODE : |
| pMlmDeauthCnf->resultCode; |
| aid = LIM_IS_AP_ROLE(psessionEntry) ? pMlmDeauthCnf->aid : 1; |
| if (LIM_IS_STA_ROLE(psessionEntry)) { |
| /* Deauth Confirm from MLM */ |
| if ((psessionEntry->limSmeState != eLIM_SME_WT_DISASSOC_STATE) |
| && psessionEntry->limSmeState != |
| eLIM_SME_WT_DEAUTH_STATE) { |
| /** |
| * Should not have received Deauth confirm |
| * from MLM in other states. |
| * Log error |
| */ |
| PELOGE(lim_log(pMac, LOGE, |
| FL |
| ("received unexpected MLM_DEAUTH_CNF in state %X"), |
| psessionEntry->limSmeState);) |
| return; |
| } |
| if (pMlmDeauthCnf->resultCode == eSIR_SME_SUCCESS) { |
| psessionEntry->limSmeState = eLIM_SME_IDLE_STATE; |
| PELOG1(lim_log(pMac, LOG1, |
| FL("*** Deauthenticated with BSS ***"));) |
| } else |
| psessionEntry->limSmeState = |
| psessionEntry->limPrevSmeState; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_SME_STATE, psessionEntry->peSessionId, |
| psessionEntry->limSmeState)); |
| |
| if (pMac->lim.gLimRspReqd) |
| pMac->lim.gLimRspReqd = false; |
| } |
| /* On STA or on BASIC AP, send SME_DEAUTH_RSP to host */ |
| lim_send_sme_deauth_ntf(pMac, pMlmDeauthCnf->peer_macaddr.bytes, |
| resultCode, |
| pMlmDeauthCnf->deauthTrigger, |
| aid, psessionEntry->smeSessionId, |
| psessionEntry->transactionId); |
| } /*** end lim_process_mlm_deauth_cnf() ***/ |
| |
| /** |
| * lim_process_mlm_purge_sta_ind() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_PURGE_STA_IND |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_purge_sta_ind(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| tSirResultCodes resultCode; |
| tpLimMlmPurgeStaInd pMlmPurgeStaInd; |
| tpPESession psessionEntry; |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| pMlmPurgeStaInd = (tpLimMlmPurgeStaInd) pMsgBuf; |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pMlmPurgeStaInd->sessionId); |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("session does not exist for given bssId")); |
| ) |
| return; |
| } |
| /* Purge STA indication from MLM */ |
| resultCode = (tSirResultCodes) pMlmPurgeStaInd->reasonCode; |
| switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) { |
| case eLIM_STA_IN_IBSS_ROLE: |
| break; |
| case eLIM_STA_ROLE: |
| default: /* eLIM_AP_ROLE */ |
| if (LIM_IS_STA_ROLE(psessionEntry) && |
| (psessionEntry->limSmeState != |
| eLIM_SME_WT_DISASSOC_STATE) && |
| (psessionEntry->limSmeState != eLIM_SME_WT_DEAUTH_STATE)) { |
| /** |
| * Should not have received |
| * Purge STA indication |
| * from MLM in other states. |
| * Log error |
| */ |
| PELOGE(lim_log(pMac, LOGE, |
| FL |
| ("received unexpected MLM_PURGE_STA_IND in state %X"), |
| psessionEntry->limSmeState); |
| ) |
| break; |
| } |
| PELOG1(lim_log(pMac, LOG1, |
| FL("*** Cleanup completed for staId=%d ***"), |
| pMlmPurgeStaInd->aid); |
| ) |
| if (LIM_IS_STA_ROLE(psessionEntry)) { |
| psessionEntry->limSmeState = eLIM_SME_IDLE_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_SME_STATE, |
| psessionEntry->peSessionId, |
| psessionEntry->limSmeState)); |
| |
| } |
| if (pMlmPurgeStaInd->purgeTrigger == eLIM_PEER_ENTITY_DEAUTH) { |
| lim_send_sme_deauth_ntf(pMac, |
| pMlmPurgeStaInd->peerMacAddr, |
| resultCode, |
| pMlmPurgeStaInd->purgeTrigger, |
| pMlmPurgeStaInd->aid, |
| psessionEntry->smeSessionId, |
| psessionEntry->transactionId); |
| } else |
| lim_send_sme_disassoc_ntf(pMac, |
| pMlmPurgeStaInd->peerMacAddr, |
| resultCode, |
| pMlmPurgeStaInd->purgeTrigger, |
| pMlmPurgeStaInd->aid, |
| psessionEntry->smeSessionId, |
| psessionEntry->transactionId, |
| psessionEntry); |
| } /* end switch (GET_LIM_SYSTEM_ROLE(psessionEntry)) */ |
| } /*** end lim_process_mlm_purge_sta_ind() ***/ |
| |
| /** |
| * lim_process_mlm_set_keys_cnf() |
| * |
| ***FUNCTION: |
| * This function is called to processes MLM_SETKEYS_CNF |
| * message from MLM State machine. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param pMsgBuf A pointer to the MLM message buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_set_keys_cnf(tpAniSirGlobal pMac, uint32_t *pMsgBuf) |
| { |
| /* Prepare and send SME_SETCONTEXT_RSP message */ |
| tLimMlmSetKeysCnf *pMlmSetKeysCnf; |
| tpPESession psessionEntry; |
| uint16_t aid; |
| tpDphHashNode sta_ds; |
| |
| if (pMsgBuf == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("Buffer is Pointing to NULL"));) |
| return; |
| } |
| pMlmSetKeysCnf = (tLimMlmSetKeysCnf *) pMsgBuf; |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pMlmSetKeysCnf->sessionId); |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("session does not exist for given sessionId ")); |
| ) |
| return; |
| } |
| psessionEntry->is_key_installed = 0; |
| lim_log(pMac, LOG1, |
| FL("Received MLM_SETKEYS_CNF with resultCode = %d"), |
| pMlmSetKeysCnf->resultCode); |
| /* if the status is success keys are installed in the |
| * Firmware so we can set the protection bit |
| */ |
| if (eSIR_SME_SUCCESS == pMlmSetKeysCnf->resultCode) { |
| if (pMlmSetKeysCnf->key_len_nonzero) |
| psessionEntry->is_key_installed = 1; |
| if (LIM_IS_AP_ROLE(psessionEntry)) { |
| sta_ds = dph_lookup_hash_entry(pMac, |
| pMlmSetKeysCnf->peer_macaddr.bytes, |
| &aid, &psessionEntry->dph.dphHashTable); |
| if (sta_ds != NULL && pMlmSetKeysCnf->key_len_nonzero) |
| sta_ds->is_key_installed = 1; |
| } |
| } |
| lim_log(pMac, LOG1, |
| FL("is_key_installed = %d"), |
| psessionEntry->is_key_installed); |
| |
| lim_send_sme_set_context_rsp(pMac, |
| pMlmSetKeysCnf->peer_macaddr, |
| 1, |
| (tSirResultCodes) pMlmSetKeysCnf->resultCode, |
| psessionEntry, psessionEntry->smeSessionId, |
| psessionEntry->transactionId); |
| } /*** end lim_process_mlm_set_keys_cnf() ***/ |
| |
| /** |
| * lim_handle_sme_join_result() - Handles sme join result |
| * @mac_ctx: Pointer to Global MAC structure |
| * @result_code: Failure code to be sent |
| * @prot_status_code : Protocol status code |
| * @session_entry: PE session handle |
| * |
| * This function is called to process join/auth/assoc failures |
| * upon receiving MLM_JOIN/AUTH/ASSOC_CNF with a failure code or |
| * MLM_ASSOC_CNF with a success code in case of STA role and |
| * MLM_JOIN_CNF with success in case of STA in IBSS role. |
| * |
| * Return: None |
| */ |
| void lim_handle_sme_join_result(tpAniSirGlobal mac_ctx, |
| tSirResultCodes result_code, uint16_t prot_status_code, |
| tpPESession session_entry) |
| { |
| tpDphHashNode sta_ds = NULL; |
| uint8_t sme_session_id; |
| uint16_t sme_trans_id; |
| |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, FL("psessionEntry is NULL ")); |
| return; |
| } |
| sme_session_id = session_entry->smeSessionId; |
| sme_trans_id = session_entry->transactionId; |
| /* |
| * When associations is failed , delete the session created |
| * and pass NULL to limsendsmeJoinReassocRsp() |
| */ |
| if (result_code != eSIR_SME_SUCCESS) { |
| sta_ds = |
| dph_get_hash_entry(mac_ctx, DPH_STA_HASH_INDEX_PEER, |
| &session_entry->dph.dphHashTable); |
| if (sta_ds != NULL) { |
| sta_ds->mlmStaContext.disassocReason = |
| eSIR_MAC_UNSPEC_FAILURE_REASON; |
| sta_ds->mlmStaContext.cleanupTrigger = |
| eLIM_JOIN_FAILURE; |
| sta_ds->mlmStaContext.resultCode = result_code; |
| sta_ds->mlmStaContext.protStatusCode = prot_status_code; |
| /* |
| * FIX_ME: at the end of lim_cleanup_rx_path, |
| * make sure PE is sending eWNI_SME_JOIN_RSP |
| * to SME |
| */ |
| lim_cleanup_rx_path(mac_ctx, sta_ds, session_entry); |
| qdf_mem_free(session_entry->pLimJoinReq); |
| session_entry->pLimJoinReq = NULL; |
| /* Cleanup if add bss failed */ |
| if (session_entry->add_bss_failed) { |
| dph_delete_hash_entry(mac_ctx, |
| sta_ds->staAddr, sta_ds->assocId, |
| &session_entry->dph.dphHashTable); |
| goto error; |
| } |
| return; |
| } |
| qdf_mem_free(session_entry->pLimJoinReq); |
| session_entry->pLimJoinReq = NULL; |
| } |
| error: |
| /* Delete the session if JOIN failure occurred. */ |
| if (result_code != eSIR_SME_SUCCESS) { |
| if (lim_set_link_state |
| (mac_ctx, eSIR_LINK_DOWN_STATE, |
| session_entry->bssId, |
| session_entry->selfMacAddr, NULL, |
| NULL) != eSIR_SUCCESS) |
| lim_log(mac_ctx, LOGE, |
| FL("Failed to set the LinkState.")); |
| pe_delete_session(mac_ctx, session_entry); |
| session_entry = NULL; |
| } |
| |
| lim_send_sme_join_reassoc_rsp(mac_ctx, eWNI_SME_JOIN_RSP, result_code, |
| prot_status_code, session_entry, sme_session_id, sme_trans_id); |
| } |
| |
| /** |
| * lim_process_mlm_add_sta_rsp() |
| * |
| ***FUNCTION: |
| * This function is called to process a WMA_ADD_STA_RSP from HAL. |
| * Upon receipt of this message from HAL, MLME - |
| * > Determines the "state" in which this message was received |
| * > Forwards it to the appropriate callback |
| * |
| ***ASSUMPTIONS: |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param tSirMsgQ The MsgQ header, which contains the response buffer |
| * |
| * @return None |
| */ |
| void lim_process_mlm_add_sta_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| /* we need to process the deferred message since the initiating req. there might be nested request. */ |
| /* in the case of nested request the new request initiated from the response will take care of resetting */ |
| /* the deffered flag. */ |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, true); |
| if (LIM_IS_AP_ROLE(psessionEntry)) { |
| lim_process_ap_mlm_add_sta_rsp(pMac, limMsgQ, psessionEntry); |
| return; |
| } |
| lim_process_sta_mlm_add_sta_rsp(pMac, limMsgQ, psessionEntry); |
| } |
| |
| /** |
| * lim_process_sta_mlm_add_sta_rsp () - Process add sta response |
| * @mac_ctx: Pointer to mac context |
| * @msg: tpSirMsgQan Message structure |
| * @session_entry: PE session entry |
| * |
| * Process ADD STA response sent from WMA and posts results |
| * to SME. |
| * |
| * Return: Null |
| */ |
| |
| void lim_process_sta_mlm_add_sta_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg, tpPESession session_entry) |
| { |
| tLimMlmAssocCnf mlm_assoc_cnf; |
| tpDphHashNode sta_ds; |
| uint32_t msg_type = LIM_MLM_ASSOC_CNF; |
| tpAddStaParams add_sta_params = (tpAddStaParams) msg->bodyptr; |
| tpPESession ft_session = NULL; |
| uint8_t ft_session_id; |
| |
| if (NULL == add_sta_params) { |
| lim_log(mac_ctx, LOGE, FL("Encountered NULL Pointer")); |
| return; |
| } |
| |
| if (session_entry->limSmeState == eLIM_SME_WT_REASSOC_STATE) |
| msg_type = LIM_MLM_REASSOC_CNF; |
| |
| if (true == session_entry->fDeauthReceived) { |
| lim_log(mac_ctx, LOGE, |
| FL("Received Deauth frame in ADD_STA_RESP state")); |
| if (QDF_STATUS_SUCCESS == add_sta_params->status) { |
| lim_log(mac_ctx, LOGE, |
| FL("ADD_STA success, send update result code with eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA staIdx: %d limMlmState: %d"), |
| add_sta_params->staIdx, |
| session_entry->limMlmState); |
| |
| if (session_entry->limSmeState == |
| eLIM_SME_WT_REASSOC_STATE) |
| msg_type = LIM_MLM_REASSOC_CNF; |
| /* |
| * We are sending result code |
| * eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA which |
| * will trigger proper cleanup (DEL_STA/DEL_BSS both |
| * required) in either assoc cnf or reassoc cnf handler. |
| */ |
| mlm_assoc_cnf.resultCode = |
| eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA; |
| mlm_assoc_cnf.protStatusCode = |
| eSIR_MAC_UNSPEC_FAILURE_STATUS; |
| session_entry->staId = add_sta_params->staIdx; |
| goto end; |
| } |
| } |
| |
| if (QDF_STATUS_SUCCESS == add_sta_params->status) { |
| if (eLIM_MLM_WT_ADD_STA_RSP_STATE != |
| session_entry->limMlmState) { |
| lim_log(mac_ctx, LOGE, |
| FL("Received WMA_ADD_STA_RSP in state %X"), |
| session_entry->limMlmState); |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_REFUSED; |
| goto end; |
| } |
| if (session_entry->limSmeState == eLIM_SME_WT_REASSOC_STATE) { |
| /* check if we have keys(PTK)to install in case of 11r */ |
| tpftPEContext ft_ctx = &session_entry->ftPEContext; |
| ft_session = pe_find_session_by_bssid(mac_ctx, |
| session_entry->limReAssocbssId, &ft_session_id); |
| if (ft_session != NULL && |
| ft_ctx->PreAuthKeyInfo.extSetStaKeyParamValid |
| == true) { |
| tpLimMlmSetKeysReq pMlmStaKeys = |
| &ft_ctx->PreAuthKeyInfo.extSetStaKeyParam; |
| lim_send_set_sta_key_req(mac_ctx, pMlmStaKeys, |
| 0, 0, ft_session, false); |
| ft_ctx->PreAuthKeyInfo.extSetStaKeyParamValid = |
| false; |
| } |
| } |
| /* |
| * Update the DPH Hash Entry for this STA |
| * with proper state info |
| */ |
| sta_ds = |
| dph_get_hash_entry(mac_ctx, DPH_STA_HASH_INDEX_PEER, |
| &session_entry->dph.dphHashTable); |
| if (NULL != sta_ds) { |
| sta_ds->mlmStaContext.mlmState = |
| eLIM_MLM_LINK_ESTABLISHED_STATE; |
| sta_ds->nss = add_sta_params->nss; |
| } else |
| lim_log(mac_ctx, LOGW, |
| FL("Fail to get DPH Hash Entry for AID - %d"), |
| DPH_STA_HASH_INDEX_PEER); |
| session_entry->limMlmState = eLIM_MLM_LINK_ESTABLISHED_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, |
| session_entry->limMlmState)); |
| /* |
| * Storing the self StaIndex(Generated by HAL) in |
| * session context, instead of storing it in DPH Hash |
| * entry for Self STA. |
| * DPH entry for the self STA stores the sta index for |
| * the BSS entry to which the STA is associated |
| */ |
| session_entry->staId = add_sta_params->staIdx; |
| |
| #ifdef WLAN_DEBUG |
| mac_ctx->lim.gLimNumLinkEsts++; |
| #endif |
| #ifdef FEATURE_WLAN_TDLS |
| /* initialize TDLS peer related data */ |
| lim_init_tdls_data(mac_ctx, session_entry); |
| #endif |
| /* |
| * Return Assoc confirm to SME with success |
| * FIXME - Need the correct ASSOC RSP code to |
| * be passed in here |
| */ |
| mlm_assoc_cnf.resultCode = (tSirResultCodes) eSIR_SME_SUCCESS; |
| } else { |
| lim_log(mac_ctx, LOGE, FL("ADD_STA failed!")); |
| if (session_entry->limSmeState == eLIM_SME_WT_REASSOC_STATE) |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_FT_REASSOC_FAILURE; |
| else |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_REFUSED; |
| mlm_assoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS; |
| } |
| end: |
| if (NULL != msg->bodyptr) { |
| qdf_mem_free(add_sta_params); |
| msg->bodyptr = NULL; |
| } |
| /* Updating PE session Id */ |
| mlm_assoc_cnf.sessionId = session_entry->peSessionId; |
| lim_post_sme_message(mac_ctx, msg_type, (uint32_t *) &mlm_assoc_cnf); |
| if (true == session_entry->fDeauthReceived) |
| session_entry->fDeauthReceived = false; |
| return; |
| } |
| |
| void lim_process_mlm_del_bss_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| /* we need to process the deferred message since the initiating req. there might be nested request. */ |
| /* in the case of nested request the new request initiated from the response will take care of resetting */ |
| /* the deffered flag. */ |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, true); |
| pMac->sys.gSysFrameCount[SIR_MAC_MGMT_FRAME][SIR_MAC_MGMT_DEAUTH] = 0; |
| |
| if (LIM_IS_AP_ROLE(psessionEntry) && |
| (psessionEntry->statypeForBss == STA_ENTRY_SELF)) { |
| lim_process_ap_mlm_del_bss_rsp(pMac, limMsgQ, psessionEntry); |
| return; |
| } |
| lim_process_sta_mlm_del_bss_rsp(pMac, limMsgQ, psessionEntry); |
| |
| #ifdef WLAN_FEATURE_11W |
| if (psessionEntry->limRmfEnabled) { |
| if (eSIR_SUCCESS != |
| lim_send_exclude_unencrypt_ind(pMac, true, psessionEntry)) { |
| lim_log(pMac, LOGE, |
| FL |
| ("Could not send down Exclude Unencrypted Indication!")); |
| } |
| } |
| #endif |
| } |
| |
| void lim_process_sta_mlm_del_bss_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| tpDeleteBssParams pDelBssParams = (tpDeleteBssParams) limMsgQ->bodyptr; |
| tpDphHashNode pStaDs = |
| dph_get_hash_entry(pMac, DPH_STA_HASH_INDEX_PEER, |
| &psessionEntry->dph.dphHashTable); |
| tSirResultCodes statusCode = eSIR_SME_SUCCESS; |
| |
| if (NULL == pDelBssParams) { |
| lim_log(pMac, LOGE, FL("Invalid body pointer in message")); |
| goto end; |
| } |
| if (QDF_STATUS_SUCCESS == pDelBssParams->status) { |
| PELOGW(lim_log(pMac, LOGW, |
| FL("STA received the DEL_BSS_RSP for BSSID: %X."), |
| pDelBssParams->bssIdx); |
| ) |
| if (lim_set_link_state |
| (pMac, eSIR_LINK_IDLE_STATE, psessionEntry->bssId, |
| psessionEntry->selfMacAddr, NULL, |
| NULL) != eSIR_SUCCESS) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("Failure in setting link state to IDLE")); |
| ) |
| statusCode = eSIR_SME_REFUSED; |
| goto end; |
| } |
| if (pStaDs == NULL) { |
| lim_log(pMac, LOGE, FL("DPH Entry for STA 1 missing.")); |
| statusCode = eSIR_SME_REFUSED; |
| goto end; |
| } |
| if (eLIM_MLM_WT_DEL_BSS_RSP_STATE != |
| pStaDs->mlmStaContext.mlmState) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL |
| ("Received unexpected WMA_DEL_BSS_RSP in state %X"), |
| pStaDs->mlmStaContext.mlmState); |
| ) |
| statusCode = eSIR_SME_REFUSED; |
| goto end; |
| } |
| PELOG1(lim_log |
| (pMac, LOG1, FL("STA AssocID %d MAC "), pStaDs->assocId); |
| lim_print_mac_addr(pMac, pStaDs->staAddr, LOG1); |
| ) |
| } else { |
| lim_log(pMac, LOGE, FL("DEL BSS failed!")); |
| statusCode = eSIR_SME_STOP_BSS_FAILURE; |
| } |
| end: |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pDelBssParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| if (pStaDs == NULL) |
| return; |
| if ((LIM_IS_STA_ROLE(psessionEntry)) && |
| (psessionEntry->limSmeState != |
| eLIM_SME_WT_DISASSOC_STATE && |
| psessionEntry->limSmeState != |
| eLIM_SME_WT_DEAUTH_STATE) && |
| pStaDs->mlmStaContext.cleanupTrigger != |
| eLIM_JOIN_FAILURE) { |
| /** The Case where the DelBss is invoked from |
| * context of other than normal DisAssoc / Deauth OR |
| * as part of Join Failure. |
| */ |
| lim_handle_del_bss_in_re_assoc_context(pMac, pStaDs, psessionEntry); |
| return; |
| } |
| lim_prepare_and_send_del_sta_cnf(pMac, pStaDs, statusCode, psessionEntry); |
| return; |
| } |
| |
| void lim_process_ap_mlm_del_bss_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| tSirResultCodes rc = eSIR_SME_SUCCESS; |
| tSirRetStatus status; |
| tpDeleteBssParams pDelBss = (tpDeleteBssParams) limMsgQ->bodyptr; |
| tSirMacAddr nullBssid = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; |
| |
| if (psessionEntry == NULL) { |
| lim_log(pMac, LOGE, FL("Session entry passed is NULL")); |
| if (pDelBss != NULL) { |
| qdf_mem_free(pDelBss); |
| limMsgQ->bodyptr = NULL; |
| } |
| return; |
| } |
| |
| if (pDelBss == NULL) { |
| PELOGE(lim_log(pMac, LOGE, FL("BSS: DEL_BSS_RSP with no body!"));) |
| rc = eSIR_SME_REFUSED; |
| goto end; |
| } |
| pMac->lim.gLimMlmState = eLIM_MLM_IDLE_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_MLM_STATE, NO_SESSION, |
| pMac->lim.gLimMlmState)); |
| |
| if (eLIM_MLM_WT_DEL_BSS_RSP_STATE != psessionEntry->limMlmState) { |
| lim_log(pMac, LOGE, |
| FL("Received unexpected WMA_DEL_BSS_RSP in state %X"), |
| psessionEntry->limMlmState); |
| rc = eSIR_SME_REFUSED; |
| goto end; |
| } |
| if (pDelBss->status != QDF_STATUS_SUCCESS) { |
| lim_log(pMac, LOGE, FL("BSS: DEL_BSS_RSP error (%x) Bss %d "), |
| pDelBss->status, pDelBss->bssIdx); |
| rc = eSIR_SME_STOP_BSS_FAILURE; |
| goto end; |
| } |
| status = lim_set_link_state(pMac, eSIR_LINK_IDLE_STATE, nullBssid, |
| psessionEntry->selfMacAddr, NULL, NULL); |
| if (status != eSIR_SUCCESS) { |
| rc = eSIR_SME_REFUSED; |
| goto end; |
| } |
| /** Softmac may send all the buffered packets right after resuming the transmission hence |
| * to occupy the medium during non channel occupancy period. So resume the transmission after |
| * HAL gives back the response. |
| */ |
| dph_hash_table_class_init(pMac, &psessionEntry->dph.dphHashTable); |
| lim_delete_pre_auth_list(pMac); |
| /* Initialize number of associated stations during cleanup */ |
| psessionEntry->gLimNumOfCurrentSTAs = 0; |
| end: |
| lim_send_sme_rsp(pMac, eWNI_SME_STOP_BSS_RSP, rc, |
| psessionEntry->smeSessionId, |
| psessionEntry->transactionId); |
| pe_delete_session(pMac, psessionEntry); |
| |
| if (pDelBss != NULL) { |
| qdf_mem_free(pDelBss); |
| limMsgQ->bodyptr = NULL; |
| } |
| } |
| |
| /** |
| * lim_process_mlm_del_sta_rsp() - Process DEL STA response |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: The MsgQ header, which contains the response buffer |
| * |
| * This function is called to process a WMA_DEL_STA_RSP from |
| * WMA Upon receipt of this message from FW. |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_del_sta_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg) |
| { |
| /* |
| * we need to process the deferred message since the |
| * initiating req. there might be nested request |
| * in the case of nested request the new request |
| * initiated from the response will take care of resetting |
| * the deffered flag. |
| */ |
| tpPESession session_entry; |
| tpDeleteStaParams del_sta_params; |
| del_sta_params = (tpDeleteStaParams) msg->bodyptr; |
| if (NULL == del_sta_params) { |
| lim_log(mac_ctx, LOGE, |
| FL("null pointer del_sta_params msg")); |
| return; |
| } |
| SET_LIM_PROCESS_DEFD_MESGS(mac_ctx, true); |
| |
| session_entry = pe_find_session_by_session_id(mac_ctx, |
| del_sta_params->sessionId); |
| if (NULL == session_entry) { |
| lim_log(mac_ctx, LOGP, FL("Session Doesn't exist: %d"), |
| del_sta_params->sessionId); |
| qdf_mem_free(del_sta_params); |
| msg->bodyptr = NULL; |
| return; |
| } |
| |
| if (LIM_IS_AP_ROLE(session_entry)) { |
| lim_process_ap_mlm_del_sta_rsp(mac_ctx, msg, |
| session_entry); |
| return; |
| } |
| if (LIM_IS_NDI_ROLE(session_entry)) { |
| lim_process_ndi_del_sta_rsp(mac_ctx, msg, session_entry); |
| return; |
| } |
| lim_process_sta_mlm_del_sta_rsp(mac_ctx, msg, session_entry); |
| } |
| |
| /** |
| * lim_process_ap_mlm_del_sta_rsp() - Process WMA_DEL_STA_RSP |
| * @mac_ctx: Global pointer to MAC context |
| * @msg: Received message |
| * @session_entry: Session entry |
| * |
| * Process WMA_DEL_STA_RSP for AP role |
| * |
| * Retunrn: None |
| */ |
| void lim_process_ap_mlm_del_sta_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg, |
| tpPESession session_entry) |
| { |
| tpDeleteStaParams del_sta_params = (tpDeleteStaParams) msg->bodyptr; |
| tpDphHashNode sta_ds; |
| tSirResultCodes status_code = eSIR_SME_SUCCESS; |
| |
| if (msg->bodyptr == NULL) { |
| lim_log(mac_ctx, LOGE, FL("msg->bodyptr NULL")); |
| return; |
| } |
| |
| sta_ds = dph_get_hash_entry(mac_ctx, del_sta_params->assocId, |
| &session_entry->dph.dphHashTable); |
| if (sta_ds == NULL) { |
| lim_log(mac_ctx, LOGE, FL("DPH Entry for STA %X missing."), |
| del_sta_params->assocId); |
| status_code = eSIR_SME_REFUSED; |
| qdf_mem_free(del_sta_params); |
| msg->bodyptr = NULL; |
| return; |
| } |
| lim_log(mac_ctx, LOG1, FL("Received del Sta Rsp in StaD MlmState : %d"), |
| sta_ds->mlmStaContext.mlmState); |
| if (QDF_STATUS_SUCCESS != del_sta_params->status) { |
| lim_log(mac_ctx, LOGW, FL("DEL STA failed!")); |
| status_code = eSIR_SME_REFUSED; |
| goto end; |
| } |
| |
| lim_log(mac_ctx, LOGW, |
| FL("AP received the DEL_STA_RSP for assocID: %X."), |
| del_sta_params->assocId); |
| if ((eLIM_MLM_WT_DEL_STA_RSP_STATE != sta_ds->mlmStaContext.mlmState) && |
| (eLIM_MLM_WT_ASSOC_DEL_STA_RSP_STATE != |
| sta_ds->mlmStaContext.mlmState)) { |
| lim_log(mac_ctx, LOGE, |
| FL("Received unexpected WMA_DEL_STA_RSP in state %s for staId %d assocId %d "), |
| lim_mlm_state_str(sta_ds->mlmStaContext.mlmState), |
| sta_ds->staIndex, sta_ds->assocId); |
| status_code = eSIR_SME_REFUSED; |
| goto end; |
| } |
| |
| lim_log(mac_ctx, LOG1, FL("Deleted STA AssocID %d staId %d MAC "), |
| sta_ds->assocId, sta_ds->staIndex); |
| lim_print_mac_addr(mac_ctx, sta_ds->staAddr, LOG1); |
| if (eLIM_MLM_WT_ASSOC_DEL_STA_RSP_STATE == |
| sta_ds->mlmStaContext.mlmState) { |
| qdf_mem_free(del_sta_params); |
| msg->bodyptr = NULL; |
| if (lim_add_sta(mac_ctx, sta_ds, false, session_entry) != |
| eSIR_SUCCESS) { |
| lim_log(mac_ctx, LOGE, FL("could not Add STA with assocId=%d"), |
| sta_ds->assocId); |
| /* |
| * delete the TS if it has already been added. |
| * send the response with error status. |
| */ |
| if (sta_ds->qos.addtsPresent) { |
| tpLimTspecInfo pTspecInfo; |
| if (eSIR_SUCCESS == |
| lim_tspec_find_by_assoc_id(mac_ctx, |
| sta_ds->assocId, |
| &sta_ds->qos.addts.tspec, |
| &mac_ctx->lim.tspecInfo[0], |
| &pTspecInfo)) { |
| lim_admit_control_delete_ts(mac_ctx, |
| sta_ds->assocId, |
| &sta_ds->qos.addts.tspec.tsinfo, |
| NULL, |
| &pTspecInfo->idx); |
| } |
| } |
| lim_reject_association(mac_ctx, sta_ds->staAddr, |
| sta_ds->mlmStaContext.subType, true, |
| sta_ds->mlmStaContext.authType, sta_ds->assocId, |
| true, |
| (tSirResultCodes)eSIR_MAC_UNSPEC_FAILURE_STATUS, |
| session_entry); |
| } |
| return; |
| } |
| end: |
| qdf_mem_free(del_sta_params); |
| msg->bodyptr = NULL; |
| if (eLIM_MLM_WT_ASSOC_DEL_STA_RSP_STATE != |
| sta_ds->mlmStaContext.mlmState) { |
| lim_prepare_and_send_del_sta_cnf(mac_ctx, sta_ds, status_code, |
| session_entry); |
| } |
| return; |
| } |
| |
| void lim_process_sta_mlm_del_sta_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| tSirResultCodes statusCode = eSIR_SME_SUCCESS; |
| tpDeleteStaParams pDelStaParams = (tpDeleteStaParams) limMsgQ->bodyptr; |
| tpDphHashNode pStaDs = NULL; |
| if (NULL == pDelStaParams) { |
| lim_log(pMac, LOGE, FL("Encountered NULL Pointer")); |
| goto end; |
| } |
| lim_log(pMac, LOG1, FL("Del STA RSP received. Status:%d AssocID:%d"), |
| pDelStaParams->status, pDelStaParams->assocId); |
| |
| if (QDF_STATUS_SUCCESS != pDelStaParams->status) |
| lim_log(pMac, LOGE, FL( |
| "Del STA failed! Status:%d, proceeding with Del BSS"), |
| pDelStaParams->status); |
| |
| pStaDs = dph_get_hash_entry(pMac, DPH_STA_HASH_INDEX_PEER, |
| &psessionEntry->dph.dphHashTable); |
| if (pStaDs == NULL) { |
| lim_log(pMac, LOGE, FL("DPH Entry for STA %X missing."), |
| pDelStaParams->assocId); |
| statusCode = eSIR_SME_REFUSED; |
| goto end; |
| } |
| if (eLIM_MLM_WT_DEL_STA_RSP_STATE != psessionEntry->limMlmState) { |
| lim_log(pMac, LOGE, FL( |
| "Received unexpected WDA_DELETE_STA_RSP in state %s"), |
| lim_mlm_state_str(psessionEntry->limMlmState)); |
| statusCode = eSIR_SME_REFUSED; |
| goto end; |
| } |
| lim_log(pMac, LOG1, FL("STA AssocID %d MAC "), pStaDs->assocId); |
| lim_print_mac_addr(pMac, pStaDs->staAddr, LOG1); |
| /* |
| * we must complete all cleanup related to delSta before |
| * calling limDelBSS. |
| */ |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pDelStaParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| /* Proceed to do DelBSS even if DelSta resulted in failure */ |
| statusCode = (tSirResultCodes)lim_del_bss(pMac, pStaDs, 0, |
| psessionEntry); |
| return; |
| end: |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pDelStaParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| return; |
| } |
| |
| void lim_process_ap_mlm_add_sta_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| tpAddStaParams pAddStaParams = (tpAddStaParams) limMsgQ->bodyptr; |
| tpDphHashNode pStaDs = NULL; |
| |
| if (NULL == pAddStaParams) { |
| lim_log(pMac, LOGE, FL("Invalid body pointer in message")); |
| goto end; |
| } |
| |
| pStaDs = |
| dph_get_hash_entry(pMac, pAddStaParams->assocId, |
| &psessionEntry->dph.dphHashTable); |
| if (pStaDs == NULL) { |
| /* TODO: any response to be sent out here ? */ |
| lim_log(pMac, LOGE, FL("DPH Entry for STA %X missing."), |
| pAddStaParams->assocId); |
| goto end; |
| } |
| /* */ |
| /* TODO & FIXME_GEN4 */ |
| /* Need to inspect tSirMsgQ.reserved for a valid Dialog token! */ |
| /* */ |
| /* TODO: any check for pMac->lim.gLimMlmState ? */ |
| if (eLIM_MLM_WT_ADD_STA_RSP_STATE != pStaDs->mlmStaContext.mlmState) { |
| /* TODO: any response to be sent out here ? */ |
| lim_log(pMac, LOGE, |
| FL("Received unexpected WMA_ADD_STA_RSP in state %X"), |
| pStaDs->mlmStaContext.mlmState); |
| goto end; |
| } |
| if (QDF_STATUS_SUCCESS != pAddStaParams->status) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("Error! rcvd delSta rsp from HAL with status %d"), |
| pAddStaParams->status); |
| ) |
| lim_reject_association(pMac, pStaDs->staAddr, |
| pStaDs->mlmStaContext.subType, |
| true, pStaDs->mlmStaContext.authType, |
| pStaDs->assocId, true, |
| (tSirResultCodes) |
| eSIR_MAC_UNSPEC_FAILURE_STATUS, |
| psessionEntry); |
| goto end; |
| } |
| pStaDs->bssId = pAddStaParams->bssIdx; |
| pStaDs->staIndex = pAddStaParams->staIdx; |
| pStaDs->nss = pAddStaParams->nss; |
| /* if the AssocRsp frame is not acknowledged, then keep alive timer will take care of the state */ |
| pStaDs->valid = 1; |
| pStaDs->mlmStaContext.mlmState = eLIM_MLM_WT_ASSOC_CNF_STATE; |
| lim_log(pMac, LOG1, |
| FL("AddStaRsp Success.STA AssocID %d staId %d MAC "), |
| pStaDs->assocId, pStaDs->staIndex); |
| lim_print_mac_addr(pMac, pStaDs->staAddr, LOG1); |
| |
| /* For BTAMP-AP, the flow sequence shall be: |
| * 1) PE sends eWNI_SME_ASSOC_IND to SME |
| * 2) PE receives eWNI_SME_ASSOC_CNF from SME |
| * 3) BTAMP-AP sends Re/Association Response to BTAMP-STA |
| */ |
| lim_send_mlm_assoc_ind(pMac, pStaDs, psessionEntry); |
| /* fall though to reclaim the original Add STA Response message */ |
| end: |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pAddStaParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| return; |
| } |
| |
| /** |
| * lim_process_ap_mlm_add_bss_rsp() |
| * |
| ***FUNCTION: |
| * This function is called to process a WMA_ADD_BSS_RSP from HAL. |
| * Upon receipt of this message from HAL, MLME - |
| * > Validates the result of WMA_ADD_BSS_REQ |
| * > Init other remaining LIM variables |
| * > Init the AID pool, for that BSSID |
| * > Init the Pre-AUTH list, for that BSSID |
| * > Create LIM timers, specific to that BSSID |
| * > Init DPH related parameters that are specific to that BSSID |
| * > TODO - When do we do the actual change channel? |
| * |
| ***LOGIC: |
| * SME sends eWNI_SME_START_BSS_REQ to LIM |
| * LIM sends LIM_MLM_START_REQ to MLME |
| * MLME sends WMA_ADD_BSS_REQ to HAL |
| * HAL responds with WMA_ADD_BSS_RSP to MLME |
| * MLME responds with LIM_MLM_START_CNF to LIM |
| * LIM responds with eWNI_SME_START_BSS_RSP to SME |
| * |
| ***ASSUMPTIONS: |
| * tSirMsgQ.body is allocated by MLME during lim_process_mlm_start_req |
| * tSirMsgQ.body will now be freed by this routine |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param tSirMsgQ The MsgQ header, which contains the response buffer |
| * |
| * @return None |
| */ |
| static void lim_process_ap_mlm_add_bss_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ) |
| { |
| tLimMlmStartCnf mlmStartCnf; |
| tpPESession psessionEntry; |
| uint8_t isWepEnabled = false; |
| tpAddBssParams pAddBssParams = (tpAddBssParams) limMsgQ->bodyptr; |
| if (NULL == pAddBssParams) { |
| lim_log(pMac, LOGE, FL("Encountered NULL Pointer")); |
| goto end; |
| } |
| /* TBD: free the memory before returning, do it for all places where lookup fails. */ |
| psessionEntry = pe_find_session_by_session_id(pMac, |
| pAddBssParams->sessionId); |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log |
| (pMac, LOGE, |
| FL("session does not exist for given sessionId")); |
| ) |
| if (NULL != pAddBssParams) { |
| qdf_mem_free(pAddBssParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| return; |
| } |
| /* Update PE session Id */ |
| mlmStartCnf.sessionId = pAddBssParams->sessionId; |
| if (QDF_STATUS_SUCCESS == pAddBssParams->status) { |
| PELOG2(lim_log |
| (pMac, LOG2, |
| FL("WMA_ADD_BSS_RSP returned with QDF_STATUS_SUCCESS")); |
| ) |
| if (lim_set_link_state |
| (pMac, eSIR_LINK_AP_STATE, psessionEntry->bssId, |
| psessionEntry->selfMacAddr, NULL, |
| NULL) != eSIR_SUCCESS) |
| goto end; |
| /* Set MLME state */ |
| psessionEntry->limMlmState = eLIM_MLM_BSS_STARTED_STATE; |
| psessionEntry->chainMask = pAddBssParams->chainMask; |
| psessionEntry->smpsMode = pAddBssParams->smpsMode; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_MLM_STATE, psessionEntry->peSessionId, |
| psessionEntry->limMlmState)); |
| if (eSIR_IBSS_MODE == pAddBssParams->bssType) { |
| /** IBSS is 'active' when we receive |
| * Beacon frames from other STAs that are part of same IBSS. |
| * Mark internal state as inactive until then. |
| */ |
| psessionEntry->limIbssActive = false; |
| psessionEntry->statypeForBss = STA_ENTRY_PEER; /* to know session created for self/peer */ |
| limResetHBPktCount(psessionEntry); |
| } |
| psessionEntry->bssIdx = (uint8_t) pAddBssParams->bssIdx; |
| |
| psessionEntry->limSystemRole = eLIM_STA_IN_IBSS_ROLE; |
| |
| if (eSIR_INFRA_AP_MODE == pAddBssParams->bssType) |
| psessionEntry->limSystemRole = eLIM_AP_ROLE; |
| else |
| psessionEntry->limSystemRole = eLIM_STA_IN_IBSS_ROLE; |
| sch_edca_profile_update(pMac, psessionEntry); |
| lim_init_pre_auth_list(pMac); |
| /* Check the SAP security configuration.If configured to |
| * WEP then max clients supported is 16 |
| */ |
| if (psessionEntry->privacy) { |
| if ((psessionEntry->gStartBssRSNIe.present) |
| || (psessionEntry->gStartBssWPAIe.present)) |
| lim_log(pMac, LOG1, |
| FL("WPA/WPA2 SAP configuration")); |
| else { |
| if (pMac->lim.gLimAssocStaLimit > |
| MAX_SUPPORTED_PEERS_WEP) { |
| lim_log(pMac, LOG1, |
| FL("WEP SAP Configuration")); |
| pMac->lim.gLimAssocStaLimit = |
| MAX_SUPPORTED_PEERS_WEP; |
| isWepEnabled = true; |
| } |
| } |
| } |
| lim_init_peer_idxpool(pMac, psessionEntry); |
| |
| /* Start OLBC timer */ |
| if (tx_timer_activate |
| (&pMac->lim.limTimers.gLimUpdateOlbcCacheTimer) != |
| TX_SUCCESS) { |
| lim_log(pMac, LOGE, FL("tx_timer_activate failed")); |
| } |
| |
| /* Apply previously set configuration at HW */ |
| lim_apply_configuration(pMac, psessionEntry); |
| |
| /* In lim_apply_configuration gLimAssocStaLimit is assigned from cfg. |
| * So update the value to 16 in case SoftAP is configured in WEP. |
| */ |
| if ((pMac->lim.gLimAssocStaLimit > MAX_SUPPORTED_PEERS_WEP) |
| && (isWepEnabled)) |
| pMac->lim.gLimAssocStaLimit = MAX_SUPPORTED_PEERS_WEP; |
| psessionEntry->staId = pAddBssParams->staContext.staIdx; |
| mlmStartCnf.resultCode = eSIR_SME_SUCCESS; |
| } else { |
| lim_log(pMac, LOGE, FL("WMA_ADD_BSS_REQ failed with status %d"), |
| pAddBssParams->status); |
| mlmStartCnf.resultCode = eSIR_SME_HAL_SEND_MESSAGE_FAIL; |
| } |
| lim_post_sme_message(pMac, LIM_MLM_START_CNF, (uint32_t *) &mlmStartCnf); |
| end: |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pAddBssParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| } |
| |
| /** |
| * lim_process_ibss_mlm_add_bss_rsp() |
| * |
| ***FUNCTION: |
| * This function is called to process a WMA_ADD_BSS_RSP from HAL. |
| * Upon receipt of this message from HAL, MLME - |
| * > Validates the result of WMA_ADD_BSS_REQ |
| * > Init other remaining LIM variables |
| * > Init the AID pool, for that BSSID |
| * > Init the Pre-AUTH list, for that BSSID |
| * > Create LIM timers, specific to that BSSID |
| * > Init DPH related parameters that are specific to that BSSID |
| * > TODO - When do we do the actual change channel? |
| * |
| ***LOGIC: |
| * SME sends eWNI_SME_START_BSS_REQ to LIM |
| * LIM sends LIM_MLM_START_REQ to MLME |
| * MLME sends WMA_ADD_BSS_REQ to HAL |
| * HAL responds with WMA_ADD_BSS_RSP to MLME |
| * MLME responds with LIM_MLM_START_CNF to LIM |
| * LIM responds with eWNI_SME_START_BSS_RSP to SME |
| * |
| ***ASSUMPTIONS: |
| * tSirMsgQ.body is allocated by MLME during lim_process_mlm_start_req |
| * tSirMsgQ.body will now be freed by this routine |
| * |
| ***NOTE: |
| * |
| * @param pMac Pointer to Global MAC structure |
| * @param tSirMsgQ The MsgQ header, which contains the response buffer |
| * |
| * @return None |
| */ |
| static void |
| lim_process_ibss_mlm_add_bss_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsgQ, |
| tpPESession psessionEntry) |
| { |
| tLimMlmStartCnf mlmStartCnf; |
| tpAddBssParams pAddBssParams = (tpAddBssParams) limMsgQ->bodyptr; |
| |
| if (NULL == pAddBssParams) { |
| lim_log(pMac, LOGE, FL("Invalid body pointer in message")); |
| goto end; |
| } |
| if (QDF_STATUS_SUCCESS == pAddBssParams->status) { |
| PELOG1(lim_log |
| (pMac, LOG1, |
| FL("WMA_ADD_BSS_RSP returned with QDF_STATUS_SUCCESS")); |
| ) |
| if (lim_set_link_state |
| (pMac, eSIR_LINK_IBSS_STATE, psessionEntry->bssId, |
| psessionEntry->selfMacAddr, NULL, |
| NULL) != eSIR_SUCCESS) |
| goto end; |
| /* Set MLME state */ |
| psessionEntry->limMlmState = eLIM_MLM_BSS_STARTED_STATE; |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_MLM_STATE, psessionEntry->peSessionId, |
| psessionEntry->limMlmState)); |
| /** IBSS is 'active' when we receive |
| * Beacon frames from other STAs that are part of same IBSS. |
| * Mark internal state as inactive until then. |
| */ |
| psessionEntry->limIbssActive = false; |
| limResetHBPktCount(psessionEntry); |
| psessionEntry->bssIdx = (uint8_t) pAddBssParams->bssIdx; |
| psessionEntry->limSystemRole = eLIM_STA_IN_IBSS_ROLE; |
| psessionEntry->statypeForBss = STA_ENTRY_SELF; |
| sch_edca_profile_update(pMac, psessionEntry); |
| if (0 == psessionEntry->freePeerIdxHead) |
| lim_init_peer_idxpool(pMac, psessionEntry); |
| |
| /* Apply previously set configuration at HW */ |
| lim_apply_configuration(pMac, psessionEntry); |
| psessionEntry->staId = pAddBssParams->staContext.staIdx; |
| mlmStartCnf.resultCode = eSIR_SME_SUCCESS; |
| /* If ADD BSS was issued as part of IBSS coalescing, don't send the message to SME, as that is internal to LIM */ |
| if (true == pMac->lim.gLimIbssCoalescingHappened) { |
| lim_ibss_add_bss_rsp_when_coalescing(pMac, limMsgQ->bodyptr, |
| psessionEntry); |
| goto end; |
| } |
| } else { |
| lim_log(pMac, LOGE, FL("WMA_ADD_BSS_REQ failed with status %d"), |
| pAddBssParams->status); |
| mlmStartCnf.resultCode = eSIR_SME_HAL_SEND_MESSAGE_FAIL; |
| } |
| /* Send this message to SME, when ADD_BSS is initiated by SME */ |
| /* If ADD_BSS is done as part of coalescing, this won't happen. */ |
| /* Update PE session Id */ |
| mlmStartCnf.sessionId = psessionEntry->peSessionId; |
| lim_post_sme_message(pMac, LIM_MLM_START_CNF, (uint32_t *) &mlmStartCnf); |
| end: |
| if (0 != limMsgQ->bodyptr) { |
| qdf_mem_free(pAddBssParams); |
| limMsgQ->bodyptr = NULL; |
| } |
| } |
| |
| /** |
| * csr_neighbor_roam_handoff_req_hdlr - Processes handoff request |
| * @mac_ctx: Pointer to mac context |
| * @msg: message sent to HDD |
| * @session_entry: PE session handle |
| * |
| * This function is called to process a WMA_ADD_BSS_RSP from HAL. |
| * Upon receipt of this message from HAL if the state is pre assoc. |
| * |
| * Return: Null |
| */ |
| static void |
| lim_process_sta_add_bss_rsp_pre_assoc(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg, tpPESession session_entry) |
| { |
| tpAddBssParams pAddBssParams = (tpAddBssParams) msg->bodyptr; |
| tAniAuthType cfgAuthType, authMode; |
| tLimMlmAuthReq *pMlmAuthReq; |
| tpDphHashNode pStaDs = NULL; |
| |
| if (NULL == pAddBssParams) { |
| lim_log(mac_ctx, LOGE, FL("Invalid body pointer in message")); |
| goto joinFailure; |
| } |
| if (QDF_STATUS_SUCCESS == pAddBssParams->status) { |
| pStaDs = dph_add_hash_entry(mac_ctx, |
| pAddBssParams->staContext.staMac, |
| DPH_STA_HASH_INDEX_PEER, |
| &session_entry->dph.dphHashTable); |
| if (pStaDs == NULL) { |
| /* Could not add hash table entry */ |
| lim_log(mac_ctx, LOGE, |
| FL("could not add hash entry at DPH for ")); |
| lim_print_mac_addr(mac_ctx, |
| pAddBssParams->staContext.staMac, LOGE); |
| goto joinFailure; |
| } |
| session_entry->bssIdx = (uint8_t) pAddBssParams->bssIdx; |
| /* Success, handle below */ |
| pStaDs->bssId = pAddBssParams->bssIdx; |
| /* STA Index(genr by HAL) for the BSS entry is stored here */ |
| pStaDs->staIndex = pAddBssParams->staContext.staIdx; |
| /* Trigger Authentication with AP */ |
| if (wlan_cfg_get_int(mac_ctx, WNI_CFG_AUTHENTICATION_TYPE, |
| (uint32_t *) &cfgAuthType) != eSIR_SUCCESS) { |
| /* |
| * Could not get AuthType from CFG. |
| * Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("could not retrieve AuthType")); |
| } |
| /* Try shared Authentication first */ |
| if (cfgAuthType == eSIR_AUTO_SWITCH) |
| authMode = eSIR_SHARED_KEY; |
| else |
| authMode = cfgAuthType; |
| |
| /* Trigger MAC based Authentication */ |
| pMlmAuthReq = qdf_mem_malloc(sizeof(tLimMlmAuthReq)); |
| if (NULL == pMlmAuthReq) { |
| lim_log(mac_ctx, LOGP, |
| FL("Allocate Memory failed for mlmAuthReq")); |
| return; |
| } |
| sir_copy_mac_addr(pMlmAuthReq->peerMacAddr, |
| session_entry->bssId); |
| |
| pMlmAuthReq->authType = authMode; |
| if (wlan_cfg_get_int(mac_ctx, |
| WNI_CFG_AUTHENTICATE_FAILURE_TIMEOUT, |
| (uint32_t *) &pMlmAuthReq->authFailureTimeout) |
| != eSIR_SUCCESS) { |
| /* |
| * Could not get AuthFailureTimeout |
| * value from CFG. Log error. |
| */ |
| lim_log(mac_ctx, LOGP, |
| FL("Fail: retrieve AuthFailureTimeout value")); |
| } |
| session_entry->limMlmState = eLIM_MLM_JOINED_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, eLIM_MLM_JOINED_STATE)); |
| pMlmAuthReq->sessionId = session_entry->peSessionId; |
| session_entry->limPrevSmeState = session_entry->limSmeState; |
| session_entry->limSmeState = eLIM_SME_WT_AUTH_STATE; |
| /* remember staId in case of assoc timeout/failure handling */ |
| session_entry->staId = pAddBssParams->staContext.staIdx; |
| |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| lim_log(mac_ctx, LOG1, |
| FL("SessionId:%d lim_post_mlm_message " |
| "LIM_MLM_AUTH_REQ with limSmeState:%d"), |
| session_entry->peSessionId, session_entry->limSmeState); |
| lim_post_mlm_message(mac_ctx, LIM_MLM_AUTH_REQ, |
| (uint32_t *) pMlmAuthReq); |
| return; |
| } |
| |
| joinFailure: |
| { |
| session_entry->limSmeState = eLIM_SME_JOIN_FAILURE_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_SME_STATE, |
| session_entry->peSessionId, |
| session_entry->limSmeState)); |
| |
| /* Send Join response to Host */ |
| lim_handle_sme_join_result(mac_ctx, eSIR_SME_REFUSED, |
| eSIR_MAC_UNSPEC_FAILURE_STATUS, session_entry); |
| } |
| |
| } |
| |
| /** |
| * lim_process_sta_mlm_add_bss_rsp() - Process ADD BSS response |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: The MsgQ header, which contains the response buffer |
| * |
| * This function is called to process a WMA_ADD_BSS_RSP from HAL. |
| * Upon receipt of this message from HAL, MLME - |
| * > Validates the result of WMA_ADD_BSS_REQ |
| * > Now, send an ADD_STA to HAL and ADD the "local" STA itself |
| * |
| * MLME had sent WMA_ADD_BSS_REQ to HAL |
| * HAL responded with WMA_ADD_BSS_RSP to MLME |
| * MLME now sends WMA_ADD_STA_REQ to HAL |
| * ASSUMPTIONS: |
| * tSirMsgQ.body is allocated by MLME during lim_process_mlm_join_req |
| * tSirMsgQ.body will now be freed by this routine |
| * |
| * Return: None |
| */ |
| static void |
| lim_process_sta_mlm_add_bss_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg, tpPESession session_entry) |
| { |
| tpAddBssParams add_bss_params = (tpAddBssParams) msg->bodyptr; |
| tLimMlmAssocCnf mlm_assoc_cnf; |
| uint32_t msg_type = LIM_MLM_ASSOC_CNF; |
| uint32_t sub_type = LIM_ASSOC; |
| tpDphHashNode sta_ds = NULL; |
| uint16_t sta_idx = STA_INVALID_IDX; |
| uint8_t update_sta = false; |
| mlm_assoc_cnf.resultCode = eSIR_SME_SUCCESS; |
| |
| if (eLIM_MLM_WT_ADD_BSS_RSP_PREASSOC_STATE == |
| session_entry->limMlmState) { |
| lim_log(mac_ctx, LOG1, |
| "SessionId:%d lim_process_sta_add_bss_rsp_pre_assoc", |
| session_entry->peSessionId); |
| lim_process_sta_add_bss_rsp_pre_assoc(mac_ctx, msg, |
| session_entry); |
| goto end; |
| } |
| if (eLIM_MLM_WT_ADD_BSS_RSP_REASSOC_STATE == session_entry->limMlmState |
| || (eLIM_MLM_WT_ADD_BSS_RSP_FT_REASSOC_STATE == |
| session_entry->limMlmState)) { |
| msg_type = LIM_MLM_REASSOC_CNF; |
| sub_type = LIM_REASSOC; |
| /* |
| * If Reassoc is happening for the same BSS, then |
| * use the existing StaId and indicate to HAL to update |
| * the existing STA entry. |
| * If Reassoc is happening for the new BSS, then |
| * old BSS and STA entry would have been already deleted |
| * before PE tries to add BSS for the new BSS, so set the |
| * updateSta to false and pass INVALID STA Index. |
| */ |
| if (sir_compare_mac_addr(session_entry->bssId, |
| session_entry->limReAssocbssId)) { |
| sta_idx = session_entry->staId; |
| update_sta = true; |
| } |
| } |
| |
| if (add_bss_params == 0) |
| goto end; |
| #ifdef WLAN_FEATURE_ROAM_OFFLOAD |
| if (session_entry->bRoamSynchInProgress) |
| QDF_TRACE(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG, |
| "LFR3:lim_process_sta_mlm_add_bss_rsp"); |
| #endif |
| |
| if (QDF_STATUS_SUCCESS == add_bss_params->status) { |
| if (eLIM_MLM_WT_ADD_BSS_RSP_FT_REASSOC_STATE == |
| session_entry->limMlmState) { |
| lim_log(mac_ctx, LOG1, FL("Mlm=%d %d"), |
| session_entry->limMlmState, |
| eLIM_MLM_WT_ADD_BSS_RSP_REASSOC_STATE); |
| lim_process_sta_mlm_add_bss_rsp_ft(mac_ctx, msg, |
| session_entry); |
| goto end; |
| } |
| |
| /* Set MLME state */ |
| session_entry->limMlmState = eLIM_MLM_WT_ADD_STA_RSP_STATE; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, |
| session_entry->limMlmState)); |
| /* to know the session started for self or for peer */ |
| session_entry->statypeForBss = STA_ENTRY_PEER; |
| /* Now, send WMA_ADD_STA_REQ */ |
| lim_log(mac_ctx, LOGW, |
| FL("SessionId:%d On STA: ADD_BSS was successful"), |
| session_entry->peSessionId); |
| sta_ds = |
| dph_get_hash_entry(mac_ctx, DPH_STA_HASH_INDEX_PEER, |
| &session_entry->dph.dphHashTable); |
| if (sta_ds == NULL) { |
| lim_log(mac_ctx, LOGE, |
| FL("Session:%d Fail to add Self Entry for STA"), |
| session_entry->peSessionId); |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_REFUSED; |
| } else { |
| session_entry->bssIdx = |
| (uint8_t) add_bss_params->bssIdx; |
| /* Success, handle below */ |
| sta_ds->bssId = add_bss_params->bssIdx; |
| /* |
| * STA Index(genr by HAL) for the BSS |
| * entry is stored here |
| */ |
| sta_ds->staIndex = add_bss_params->staContext.staIdx; |
| sta_ds->ucUcastSig = |
| add_bss_params->staContext.ucUcastSig; |
| sta_ds->ucBcastSig = |
| add_bss_params->staContext.ucBcastSig; |
| /* Downgrade the EDCA parameters if needed */ |
| lim_set_active_edca_params(mac_ctx, |
| session_entry->gLimEdcaParams, session_entry); |
| lim_send_edca_params(mac_ctx, |
| session_entry->gLimEdcaParamsActive, |
| sta_ds->bssId); |
| rrm_cache_mgmt_tx_power(mac_ctx, |
| add_bss_params->txMgmtPower, session_entry); |
| if (lim_add_sta_self(mac_ctx, sta_idx, update_sta, |
| session_entry) != eSIR_SUCCESS) { |
| /* Add STA context at HW */ |
| lim_log(mac_ctx, LOGE, |
| FL("Session:%d could not Add Self" |
| "Entry for the station"), |
| session_entry->peSessionId); |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_REFUSED; |
| } |
| } |
| } else { |
| lim_log(mac_ctx, LOGP, FL("SessionId:%d ADD_BSS failed!"), |
| session_entry->peSessionId); |
| mlm_assoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS; |
| /* Return Assoc confirm to SME with failure */ |
| if (eLIM_MLM_WT_ADD_BSS_RSP_FT_REASSOC_STATE == |
| session_entry->limMlmState) |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_FT_REASSOC_FAILURE; |
| else |
| mlm_assoc_cnf.resultCode = |
| (tSirResultCodes) eSIR_SME_REFUSED; |
| session_entry->add_bss_failed = true; |
| } |
| |
| if (mlm_assoc_cnf.resultCode != eSIR_SME_SUCCESS) { |
| session_entry->limMlmState = eLIM_MLM_IDLE_STATE; |
| if (lim_set_link_state(mac_ctx, eSIR_LINK_IDLE_STATE, |
| session_entry->bssId, |
| session_entry->selfMacAddr, |
| NULL, NULL) != eSIR_SUCCESS) |
| lim_log(mac_ctx, LOGE, FL("Failed to set the LinkState")); |
| /* Update PE session Id */ |
| mlm_assoc_cnf.sessionId = session_entry->peSessionId; |
| lim_post_sme_message(mac_ctx, msg_type, |
| (uint32_t *) &mlm_assoc_cnf); |
| } |
| end: |
| if (0 != msg->bodyptr) { |
| qdf_mem_free(add_bss_params); |
| msg->bodyptr = NULL; |
| } |
| } |
| |
| /** |
| * lim_process_mlm_add_bss_rsp() - Processes ADD BSS Response |
| * |
| * @mac_ctx - Pointer to Global MAC structure |
| * @msg - The MsgQ header, which contains the response buffer |
| * |
| * This function is called to process a WMA_ADD_BSS_RSP from HAL. |
| * Upon receipt of this message from HAL, MLME - |
| * Determines the "state" in which this message was received |
| * Forwards it to the appropriate callback |
| * |
| *LOGIC: |
| * WMA_ADD_BSS_RSP can be received by MLME while the LIM is |
| * in the following two states: |
| * 1) As AP, LIM state = eLIM_SME_WT_START_BSS_STATE |
| * 2) As STA, LIM state = eLIM_SME_WT_JOIN_STATE |
| * Based on these two states, this API will determine where to |
| * route the message to |
| * |
| * Return None |
| */ |
| void lim_process_mlm_add_bss_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg) |
| { |
| tLimMlmStartCnf mlm_start_cnf; |
| tpPESession session_entry; |
| tpAddBssParams add_bss_param = (tpAddBssParams) (msg->bodyptr); |
| tSirBssType bss_type; |
| |
| if (NULL == add_bss_param) { |
| lim_log(mac_ctx, LOGE, FL("Encountered NULL Pointer")); |
| return; |
| } |
| |
| /* |
| * we need to process the deferred message since the |
| * initiating req.there might be nested request. |
| * in the case of nested request the new request initiated |
| * from the response will take care of resetting the deffered |
| * flag. |
| */ |
| SET_LIM_PROCESS_DEFD_MESGS(mac_ctx, true); |
| /* Validate SME/LIM/MLME state */ |
| session_entry = pe_find_session_by_session_id(mac_ctx, |
| add_bss_param->sessionId); |
| if (session_entry == NULL) { |
| lim_log(mac_ctx, LOGE, FL("SessionId:%d Session Doesn't exist"), |
| add_bss_param->sessionId); |
| if (NULL != add_bss_param) { |
| qdf_mem_free(add_bss_param); |
| msg->bodyptr = NULL; |
| } |
| return; |
| } |
| |
| bss_type = session_entry->bssType; |
| /* update PE session Id */ |
| mlm_start_cnf.sessionId = session_entry->peSessionId; |
| if (eSIR_IBSS_MODE == bss_type) { |
| lim_process_ibss_mlm_add_bss_rsp(mac_ctx, msg, session_entry); |
| } else if (eSIR_NDI_MODE == session_entry->bssType) { |
| lim_process_ndi_mlm_add_bss_rsp(mac_ctx, msg, session_entry); |
| } else { |
| if (eLIM_SME_WT_START_BSS_STATE == session_entry->limSmeState) { |
| if (eLIM_MLM_WT_ADD_BSS_RSP_STATE != |
| session_entry->limMlmState) { |
| /* Mesg received from HAL in Invalid state! */ |
| lim_log(mac_ctx, LOGE, |
| FL("SessionId:%d Received " |
| " WMA_ADD_BSS_RSP in state %X"), |
| session_entry->peSessionId, |
| session_entry->limMlmState); |
| mlm_start_cnf.resultCode = |
| eSIR_SME_BSS_ALREADY_STARTED_OR_JOINED; |
| if (0 != msg->bodyptr) { |
| qdf_mem_free(add_bss_param); |
| msg->bodyptr = NULL; |
| } |
| lim_post_sme_message(mac_ctx, LIM_MLM_START_CNF, |
| (uint32_t *) &mlm_start_cnf); |
| } else |
| lim_process_ap_mlm_add_bss_rsp(mac_ctx, msg); |
| } else { |
| /* Called while processing assoc response */ |
| lim_process_sta_mlm_add_bss_rsp(mac_ctx, msg, |
| session_entry); |
| } |
| } |
| |
| #ifdef WLAN_FEATURE_11W |
| if (session_entry->limRmfEnabled) { |
| if (eSIR_SUCCESS != |
| lim_send_exclude_unencrypt_ind(mac_ctx, false, |
| session_entry)) { |
| lim_log(mac_ctx, LOGE, |
| FL("Failed to send Exclude Unencrypted Ind.")); |
| } |
| } |
| #endif |
| } |
| |
| /** |
| * lim_process_mlm_set_sta_key_rsp() - Process STA key response |
| * |
| * @mac_ctx: Pointer to Global MAC structure |
| * @msg: The MsgQ header, which contains the response buffer |
| * |
| * This function is called to process the following two |
| * messages from HAL: |
| * 1) WMA_SET_BSSKEY_RSP |
| * 2) WMA_SET_STAKEY_RSP |
| * 3) WMA_SET_STA_BCASTKEY_RSP |
| * Upon receipt of this message from HAL, |
| * MLME - |
| * > Determines the "state" in which this message was received |
| * > Forwards it to the appropriate callback |
| * LOGIC: |
| * WMA_SET_BSSKEY_RSP/WMA_SET_STAKEY_RSP can be |
| * received by MLME while in the following state: |
| * MLME state = eLIM_MLM_WT_SET_BSS_KEY_STATE --OR-- |
| * MLME state = eLIM_MLM_WT_SET_STA_KEY_STATE --OR-- |
| * MLME state = eLIM_MLM_WT_SET_STA_BCASTKEY_STATE |
| * Based on this state, this API will determine where to |
| * route the message to |
| * Assumption: |
| * ONLY the MLME state is being taken into account for now. |
| * This is because, it appears that the handling of the |
| * SETKEYS REQ is handled symmetrically on both the AP & STA |
| * |
| * Return: None |
| */ |
| void lim_process_mlm_set_sta_key_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg) |
| { |
| uint8_t resp_reqd = 1; |
| tLimMlmSetKeysCnf mlm_set_key_cnf; |
| uint8_t session_id = 0; |
| tpPESession session_entry; |
| uint16_t key_len; |
| uint16_t result_status; |
| |
| SET_LIM_PROCESS_DEFD_MESGS(mac_ctx, true); |
| qdf_mem_set((void *)&mlm_set_key_cnf, sizeof(tLimMlmSetKeysCnf), 0); |
| if (NULL == msg->bodyptr) { |
| PELOGE(lim_log(mac_ctx, LOGE, FL("msg bodyptr is NULL"));) |
| return; |
| } |
| session_id = ((tpSetStaKeyParams) msg->bodyptr)->sessionId; |
| session_entry = pe_find_session_by_session_id(mac_ctx, session_id); |
| if (session_entry == NULL) { |
| PELOGE(lim_log(mac_ctx, LOGE, |
| FL("session does not exist for given session_id"));) |
| qdf_mem_free(msg->bodyptr); |
| msg->bodyptr = NULL; |
| return; |
| } |
| if (eLIM_MLM_WT_SET_STA_KEY_STATE != session_entry->limMlmState) { |
| /* Mesg received from HAL in Invalid state! */ |
| lim_log(mac_ctx, LOGE, |
| FL("Received unexpected [Mesg Id - %d] in state %X"), |
| msg->type, session_entry->limMlmState); |
| /* There's not much that MLME can do at this stage... */ |
| resp_reqd = 0; |
| } else { |
| mlm_set_key_cnf.resultCode = |
| (uint16_t)(((tpSetStaKeyParams) msg->bodyptr)->status); |
| } |
| |
| result_status = (uint16_t)(((tpSetStaKeyParams) msg->bodyptr)->status); |
| key_len = ((tpSetStaKeyParams)msg->bodyptr)->key[0].keyLength; |
| |
| if (result_status == eSIR_SME_SUCCESS && key_len) |
| mlm_set_key_cnf.key_len_nonzero = true; |
| else |
| mlm_set_key_cnf.key_len_nonzero = false; |
| |
| |
| qdf_mem_free(msg->bodyptr); |
| msg->bodyptr = NULL; |
| /* Restore MLME state */ |
| session_entry->limMlmState = session_entry->limPrevMlmState; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, session_entry->limMlmState)); |
| if (resp_reqd) { |
| tpLimMlmSetKeysReq lpLimMlmSetKeysReq = |
| (tpLimMlmSetKeysReq) mac_ctx->lim.gpLimMlmSetKeysReq; |
| /* Prepare and Send LIM_MLM_SETKEYS_CNF */ |
| if (NULL != lpLimMlmSetKeysReq) { |
| qdf_copy_macaddr(&mlm_set_key_cnf.peer_macaddr, |
| &lpLimMlmSetKeysReq->peer_macaddr); |
| /* |
| * Free the buffer cached for the global |
| * mac_ctx->lim.gpLimMlmSetKeysReq |
| */ |
| qdf_mem_free(mac_ctx->lim.gpLimMlmSetKeysReq); |
| mac_ctx->lim.gpLimMlmSetKeysReq = NULL; |
| } |
| mlm_set_key_cnf.sessionId = session_id; |
| lim_post_sme_message(mac_ctx, LIM_MLM_SETKEYS_CNF, |
| (uint32_t *) &mlm_set_key_cnf); |
| } |
| } |
| |
| /** |
| * lim_process_mlm_set_bss_key_rsp() - handles BSS key |
| * |
| * @mac_ctx: A pointer to Global MAC structure |
| * @msg: Message from SME |
| * |
| * This function processes BSS key response and updates |
| * PE status accordingly. |
| * |
| * Return: NULL |
| */ |
| void lim_process_mlm_set_bss_key_rsp(tpAniSirGlobal mac_ctx, |
| tpSirMsgQ msg) |
| { |
| tLimMlmSetKeysCnf set_key_cnf; |
| uint16_t result_status; |
| uint8_t session_id = 0; |
| tpPESession session_entry; |
| tpLimMlmSetKeysReq set_key_req; |
| uint16_t key_len; |
| |
| SET_LIM_PROCESS_DEFD_MESGS(mac_ctx, true); |
| qdf_mem_set((void *)&set_key_cnf, sizeof(tLimMlmSetKeysCnf), 0); |
| if (NULL == msg->bodyptr) { |
| PELOGE(lim_log(mac_ctx, LOGE, FL("msg bodyptr is null"));) |
| return; |
| } |
| session_id = ((tpSetBssKeyParams) msg->bodyptr)->sessionId; |
| session_entry = pe_find_session_by_session_id(mac_ctx, session_id); |
| if (session_entry == NULL) { |
| PELOGE(lim_log(mac_ctx, LOGE, |
| FL("session does not exist for given sessionId [%d]"), |
| session_id);) |
| qdf_mem_free(msg->bodyptr); |
| msg->bodyptr = NULL; |
| return; |
| } |
| if (eLIM_MLM_WT_SET_BSS_KEY_STATE == session_entry->limMlmState) { |
| result_status = |
| (uint16_t)(((tpSetBssKeyParams)msg->bodyptr)->status); |
| key_len = ((tpSetBssKeyParams)msg->bodyptr)->key[0].keyLength; |
| } else { |
| /* |
| * BCAST key also uses tpSetStaKeyParams. |
| * Done this way for readabilty. |
| */ |
| result_status = |
| (uint16_t)(((tpSetStaKeyParams)msg->bodyptr)->status); |
| key_len = ((tpSetStaKeyParams)msg->bodyptr)->key[0].keyLength; |
| } |
| |
| if (result_status == eSIR_SME_SUCCESS && key_len) |
| set_key_cnf.key_len_nonzero = true; |
| else |
| set_key_cnf.key_len_nonzero = false; |
| |
| /* Validate MLME state */ |
| if (eLIM_MLM_WT_SET_BSS_KEY_STATE != session_entry->limMlmState && |
| eLIM_MLM_WT_SET_STA_BCASTKEY_STATE != |
| session_entry->limMlmState) { |
| /* Msg received from HAL in Invalid state! */ |
| lim_log(mac_ctx, LOGE, |
| FL("Received unexpected [Mesg Id - %d] in state %X"), |
| msg->type, session_entry->limMlmState); |
| } else { |
| set_key_cnf.resultCode = result_status; |
| } |
| |
| qdf_mem_free(msg->bodyptr); |
| msg->bodyptr = NULL; |
| /* Restore MLME state */ |
| session_entry->limMlmState = session_entry->limPrevMlmState; |
| |
| MTRACE(mac_trace |
| (mac_ctx, TRACE_CODE_MLM_STATE, session_entry->peSessionId, |
| session_entry->limMlmState)); |
| set_key_req = |
| (tpLimMlmSetKeysReq) mac_ctx->lim.gpLimMlmSetKeysReq; |
| set_key_cnf.sessionId = session_id; |
| |
| /* Prepare and Send LIM_MLM_SETKEYS_CNF */ |
| if (NULL != set_key_req) { |
| qdf_copy_macaddr(&set_key_cnf.peer_macaddr, |
| &set_key_req->peer_macaddr); |
| /* |
| * Free the buffer cached for the |
| * global mac_ctx->lim.gpLimMlmSetKeysReq |
| */ |
| qdf_mem_free(mac_ctx->lim.gpLimMlmSetKeysReq); |
| mac_ctx->lim.gpLimMlmSetKeysReq = NULL; |
| } |
| lim_post_sme_message(mac_ctx, LIM_MLM_SETKEYS_CNF, |
| (uint32_t *) &set_key_cnf); |
| } |
| |
| /** |
| * lim_process_switch_channel_re_assoc_req() |
| * |
| ***FUNCTION: |
| * This function is called to send the reassoc req mgmt frame after the |
| * switchChannelRsp message is received from HAL. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * NA |
| * |
| ***NOTE: |
| * NA |
| * |
| * @param pMac - Pointer to Global MAC structure. |
| * @param psessionEntry - session related information. |
| * @param status - channel switch success/failure. |
| * |
| * @return None |
| */ |
| static void lim_process_switch_channel_re_assoc_req(tpAniSirGlobal pMac, |
| tpPESession psessionEntry, |
| QDF_STATUS status) |
| { |
| tLimMlmReassocCnf mlmReassocCnf; |
| tLimMlmReassocReq *pMlmReassocReq; |
| pMlmReassocReq = |
| (tLimMlmReassocReq *) (psessionEntry->pLimMlmReassocReq); |
| if (pMlmReassocReq == NULL) { |
| lim_log(pMac, LOGP, |
| FL |
| ("pLimMlmReassocReq does not exist for given switchChanSession")); |
| mlmReassocCnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE; |
| goto end; |
| } |
| |
| if (status != QDF_STATUS_SUCCESS) { |
| PELOGE(lim_log(pMac, LOGE, FL("Change channel failed!!"));) |
| mlmReassocCnf.resultCode = eSIR_SME_CHANNEL_SWITCH_FAIL; |
| goto end; |
| } |
| /* / Start reassociation failure timer */ |
| MTRACE(mac_trace |
| (pMac, TRACE_CODE_TIMER_ACTIVATE, psessionEntry->peSessionId, |
| eLIM_REASSOC_FAIL_TIMER)); |
| if (tx_timer_activate(&pMac->lim.limTimers.gLimReassocFailureTimer) |
| != TX_SUCCESS) { |
| /* / Could not start reassoc failure timer. */ |
| /* Log error */ |
| lim_log(pMac, LOGP, |
| FL("could not start Reassociation failure timer")); |
| /* Return Reassoc confirm with */ |
| /* Resources Unavailable */ |
| mlmReassocCnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE; |
| goto end; |
| } |
| /* / Prepare and send Reassociation request frame */ |
| lim_send_reassoc_req_mgmt_frame(pMac, pMlmReassocReq, psessionEntry); |
| return; |
| end: |
| /* Free up buffer allocated for reassocReq */ |
| if (pMlmReassocReq != NULL) { |
| /* Update PE session Id */ |
| mlmReassocCnf.sessionId = pMlmReassocReq->sessionId; |
| qdf_mem_free(pMlmReassocReq); |
| psessionEntry->pLimMlmReassocReq = NULL; |
| } else { |
| mlmReassocCnf.sessionId = 0; |
| } |
| |
| mlmReassocCnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS; |
| /* Update PE sessio Id */ |
| mlmReassocCnf.sessionId = psessionEntry->peSessionId; |
| |
| lim_post_sme_message(pMac, LIM_MLM_REASSOC_CNF, |
| (uint32_t *) &mlmReassocCnf); |
| } |
| |
| |
| /** |
| * lim_process_switch_channel_join_req() -Initiates probe request |
| * |
| * @mac_ctx - A pointer to Global MAC structure |
| * @sessionEntry - session related information. |
| * @status - channel switch success/failure |
| * |
| * This function is called to send the probe req mgmt frame |
| * after the switchChannelRsp message is received from HAL. |
| * |
| * Return None |
| */ |
| static void lim_process_switch_channel_join_req( |
| tpAniSirGlobal mac_ctx, tpPESession session_entry, |
| QDF_STATUS status) |
| { |
| tSirMacSSid ssId; |
| tLimMlmJoinCnf join_cnf; |
| if (status != QDF_STATUS_SUCCESS) { |
| PELOGE(lim_log(mac_ctx, LOGE, FL("Change channel failed!!"));) |
| goto error; |
| } |
| |
| if ((NULL == session_entry) || (NULL == session_entry->pLimMlmJoinReq) |
| || (NULL == session_entry->pLimJoinReq)) { |
| PELOGE(lim_log(mac_ctx, LOGE, FL("invalid pointer!!"));) |
| goto error; |
| } |
| |
| session_entry->limPrevMlmState = session_entry->limMlmState; |
| session_entry->limMlmState = eLIM_MLM_WT_JOIN_BEACON_STATE; |
| lim_log(mac_ctx, LOG1, |
| FL("Sessionid %d prev lim state %d new lim state %d " |
| "systemrole = %d"), session_entry->peSessionId, |
| session_entry->limPrevMlmState, |
| session_entry->limMlmState, GET_LIM_SYSTEM_ROLE(session_entry)); |
| |
| /* Apply previously set configuration at HW */ |
| lim_apply_configuration(mac_ctx, session_entry); |
| |
| /* |
| * If sendDeauthBeforeCon is enabled, Send Deauth first to AP if last |
| * disconnection was caused by HB failure. |
| */ |
| if (mac_ctx->roam.configParam.sendDeauthBeforeCon) { |
| int apCount; |
| |
| for (apCount = 0; apCount < 2; apCount++) { |
| |
| if (!qdf_mem_cmp(session_entry->pLimMlmJoinReq->bssDescription.bssId, |
| mac_ctx->lim.gLimHeartBeatApMac[apCount], sizeof(tSirMacAddr))) { |
| |
| lim_log(mac_ctx, LOGE, FL("Index %d Sessionid: %d Send deauth on " |
| "channel %d to BSSID: "MAC_ADDRESS_STR), apCount, |
| session_entry->peSessionId, session_entry->currentOperChannel, |
| MAC_ADDR_ARRAY(session_entry->pLimMlmJoinReq->bssDescription. |
| bssId)); |
| |
| lim_send_deauth_mgmt_frame(mac_ctx, eSIR_MAC_UNSPEC_FAILURE_REASON, |
| session_entry->pLimMlmJoinReq->bssDescription.bssId, |
| session_entry, false); |
| |
| qdf_mem_zero(mac_ctx->lim.gLimHeartBeatApMac[apCount], |
| sizeof(tSirMacAddr)); |
| break; |
| } |
| } |
| } |
| |
| /* Wait for Beacon to announce join success */ |
| qdf_mem_copy(ssId.ssId, |
| session_entry->ssId.ssId, session_entry->ssId.length); |
| ssId.length = session_entry->ssId.length; |
| |
| lim_deactivate_and_change_timer(mac_ctx, |
| eLIM_PERIODIC_JOIN_PROBE_REQ_TIMER); |
| |
| /* assign appropriate sessionId to the timer object */ |
| mac_ctx->lim.limTimers.gLimPeriodicJoinProbeReqTimer.sessionId = |
| session_entry->peSessionId; |
| lim_log(mac_ctx, LOG1, |
| FL("Sessionid: %d Send Probe req on channel %d ssid:%.*s " |
| "BSSID: " MAC_ADDRESS_STR), session_entry->peSessionId, |
| session_entry->currentOperChannel, ssId.length, ssId.ssId, |
| MAC_ADDR_ARRAY( |
| session_entry->pLimMlmJoinReq->bssDescription.bssId)); |
| |
| /* |
| * We need to wait for probe response, so start join |
| * timeout timer.This timer will be deactivated once |
| * we receive probe response. |
| */ |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_TIMER_ACTIVATE, |
| session_entry->peSessionId, eLIM_JOIN_FAIL_TIMER)); |
| if (tx_timer_activate(&mac_ctx->lim.limTimers.gLimJoinFailureTimer) != |
| TX_SUCCESS) { |
| lim_log(mac_ctx, LOGP, |
| FL("couldn't activate Join failure timer")); |
| session_entry->limMlmState = session_entry->limPrevMlmState; |
| MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE, |
| session_entry->peSessionId, |
| mac_ctx->lim.gLimMlmState)); |
| goto error; |
| } |
| /* include additional IE if there is */ |
| lim_send_probe_req_mgmt_frame(mac_ctx, &ssId, |
| session_entry->pLimMlmJoinReq->bssDescription.bssId, |
| session_entry->currentOperChannel, session_entry->selfMacAddr, |
| session_entry->dot11mode, |
| session_entry->pLimJoinReq->addIEScan.length, |
| session_entry->pLimJoinReq->addIEScan.addIEdata); |
| |
| if (session_entry->pePersona == QDF_P2P_CLIENT_MODE) { |
| /* Activate Join Periodic Probe Req timer */ |
| if (tx_timer_activate |
| (&mac_ctx->lim.limTimers.gLimPeriodicJoinProbeReqTimer) |
| != TX_SUCCESS) { |
| lim_log(mac_ctx, LOGP, |
| FL("Periodic JoinReq timer activate failed")); |
| goto error; |
| } |
| } |
| return; |
| error: |
| if (NULL != session_entry) { |
| if (session_entry->pLimMlmJoinReq) { |
| qdf_mem_free(session_entry->pLimMlmJoinReq); |
| session_entry->pLimMlmJoinReq = NULL; |
| } |
| if (session_entry->pLimJoinReq) { |
| qdf_mem_free(session_entry->pLimJoinReq); |
| session_entry->pLimJoinReq = NULL; |
| } |
| join_cnf.sessionId = session_entry->peSessionId; |
| } else { |
| join_cnf.sessionId = 0; |
| } |
| join_cnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE; |
| join_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS; |
| lim_post_sme_message(mac_ctx, LIM_MLM_JOIN_CNF, (uint32_t *)&join_cnf); |
| } |
| |
| /** |
| * lim_process_switch_channel_rsp() |
| * |
| ***FUNCTION: |
| * This function is called to process switchChannelRsp message from HAL. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * NA |
| * |
| ***NOTE: |
| * NA |
| * |
| * @param pMac - Pointer to Global MAC structure |
| * @param body - message body. |
| * |
| * @return None |
| */ |
| void lim_process_switch_channel_rsp(tpAniSirGlobal pMac, void *body) |
| { |
| tpSwitchChannelParams pChnlParams = NULL; |
| QDF_STATUS status; |
| uint16_t channelChangeReasonCode; |
| uint8_t peSessionId; |
| tpPESession psessionEntry; |
| /* we need to process the deferred message since the initiating req. there might be nested request. */ |
| /* in the case of nested request the new request initiated from the response will take care of resetting */ |
| /* the deffered flag. */ |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, true); |
| pChnlParams = (tpSwitchChannelParams) body; |
| status = pChnlParams->status; |
| peSessionId = pChnlParams->peSessionId; |
| |
| psessionEntry = pe_find_session_by_session_id(pMac, peSessionId); |
| if (psessionEntry == NULL) { |
| lim_log(pMac, LOGP, |
| FL("session does not exist for given sessionId")); |
| return; |
| } |
| /* HAL fills in the tx power used for mgmt frames in this field. */ |
| /* Store this value to use in TPC report IE. */ |
| rrm_cache_mgmt_tx_power(pMac, pChnlParams->txMgmtPower, psessionEntry); |
| channelChangeReasonCode = psessionEntry->channelChangeReasonCode; |
| /* initialize it back to invalid id */ |
| psessionEntry->chainMask = pChnlParams->chainMask; |
| psessionEntry->smpsMode = pChnlParams->smpsMode; |
| psessionEntry->channelChangeReasonCode = 0xBAD; |
| lim_log(pMac, LOG1, FL("channelChangeReasonCode %d"), |
| channelChangeReasonCode); |
| switch (channelChangeReasonCode) { |
| case LIM_SWITCH_CHANNEL_REASSOC: |
| lim_process_switch_channel_re_assoc_req(pMac, psessionEntry, status); |
| break; |
| case LIM_SWITCH_CHANNEL_JOIN: |
| lim_process_switch_channel_join_req(pMac, psessionEntry, status); |
| break; |
| |
| case LIM_SWITCH_CHANNEL_OPERATION: |
| /* |
| * The above code should also use the callback. |
| * mechanism below, there is scope for cleanup here. |
| * THat way all this response handler does is call the call back |
| * We can get rid of the reason code here. |
| */ |
| if (pMac->lim.gpchangeChannelCallback) { |
| PELOG1(lim_log |
| (pMac, LOG1, |
| "Channel changed hence invoke registered call back"); |
| ) |
| pMac->lim.gpchangeChannelCallback(pMac, status, |
| pMac->lim. |
| gpchangeChannelData, |
| psessionEntry); |
| } |
| /* If MCC upgrade/DBS downgrade happended during channel switch, |
| * the policy manager connection table needs to be updated. |
| */ |
| cds_update_connection_info(psessionEntry->smeSessionId); |
| if (psessionEntry->pePersona == QDF_P2P_CLIENT_MODE) { |
| lim_log(pMac, LOG1, |
| FL("Send p2p operating channel change conf action frame once first beacon is received on new channel")); |
| psessionEntry->send_p2p_conf_frame = true; |
| } |
| break; |
| case LIM_SWITCH_CHANNEL_SAP_DFS: |
| { |
| /* Note: This event code specific to SAP mode |
| * When SAP session issues channel change as performing |
| * DFS, we will come here. Other sessions, for e.g. P2P |
| * will have to define their own event code and channel |
| * switch handler. This is required since the SME may |
| * require completely different information for P2P unlike |
| * SAP. |
| */ |
| lim_send_sme_ap_channel_switch_resp(pMac, psessionEntry, |
| pChnlParams); |
| /* If MCC upgrade/DBS downgrade happended during channel switch, |
| * the policy manager connection table needs to be updated. |
| */ |
| cds_update_connection_info(psessionEntry->smeSessionId); |
| cds_set_do_hw_mode_change_flag(true); |
| } |
| break; |
| default: |
| break; |
| } |
| qdf_mem_free(body); |
| } |
| |
| void lim_send_beacon_ind(tpAniSirGlobal pMac, tpPESession psessionEntry) |
| { |
| tBeaconGenParams *pBeaconGenParams = NULL; |
| tSirMsgQ limMsg; |
| /** Allocate the Memory for Beacon Pre Message and for Stations in PoweSave*/ |
| if (psessionEntry == NULL) { |
| PELOGE(lim_log(pMac, LOGE, |
| FL("Error:Unable to get the PESessionEntry")); |
| ) |
| return; |
| } |
| pBeaconGenParams = qdf_mem_malloc(sizeof(*pBeaconGenParams)); |
| if (NULL == pBeaconGenParams) { |
| PELOGE(lim_log(pMac, LOGP, |
| FL |
| ("Unable to allocate memory during sending beaconPreMessage")); |
| ) |
| return; |
| } |
| qdf_mem_copy((void *)pBeaconGenParams->bssId, |
| (void *)psessionEntry->bssId, QDF_MAC_ADDR_SIZE); |
| limMsg.bodyptr = pBeaconGenParams; |
| sch_process_pre_beacon_ind(pMac, &limMsg); |
| return; |
| } |
| |
| #ifdef FEATURE_WLAN_SCAN_PNO |
| /** |
| * lim_send_sme_scan_cache_updated_ind() |
| * |
| ***FUNCTION: |
| * This function is used to post WMA_SME_SCAN_CACHE_UPDATED message to WMA. |
| * This message is the indication to WMA that all scan cache results |
| * are updated from LIM to SME. Mainly used only in PNO offload case. |
| * |
| ***LOGIC: |
| * |
| ***ASSUMPTIONS: |
| * This function should be called after posting scan cache results to SME. |
| * |
| ***NOTE: |
| * NA |
| * |
| * @return None |
| */ |
| static void lim_send_sme_scan_cache_updated_ind(uint8_t sessionId) |
| { |
| cds_msg_t msg; |
| |
| msg.type = WMA_SME_SCAN_CACHE_UPDATED; |
| msg.reserved = 0; |
| msg.bodyptr = NULL; |
| msg.bodyval = sessionId; |
| |
| if (!QDF_IS_STATUS_SUCCESS |
| (cds_mq_post_message(QDF_MODULE_ID_WMA, &msg))) |
| QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR, |
| "%s: Not able to post WMA_SME_SCAN_CACHE_UPDATED message to WMA", |
| __func__); |
| } |
| #endif |
| |
| static void lim_send_scan_offload_complete(tpAniSirGlobal pMac, |
| tSirScanOffloadEvent *pScanEvent) |
| { |
| |
| pMac->lim.gLimRspReqd = false; |
| lim_send_sme_scan_rsp(pMac, pScanEvent->reasonCode, |
| pScanEvent->sessionId, 0, pScanEvent->scanId); |
| #ifdef FEATURE_WLAN_SCAN_PNO |
| lim_send_sme_scan_cache_updated_ind(pScanEvent->sessionId); |
| #endif |
| } |
| |
| void lim_process_rx_scan_event(tpAniSirGlobal pMac, void *buf) |
| { |
| tSirScanOffloadEvent *pScanEvent = (tSirScanOffloadEvent *) buf; |
| |
| switch (pScanEvent->event) { |
| case SIR_SCAN_EVENT_STARTED: |
| break; |
| case SIR_SCAN_EVENT_START_FAILED: |
| case SIR_SCAN_EVENT_COMPLETED: |
| if (ROC_SCAN_REQUESTOR_ID == pScanEvent->requestor) { |
| lim_send_sme_roc_rsp(pMac, eWNI_SME_REMAIN_ON_CHN_RSP, |
| QDF_STATUS_SUCCESS, |
| pScanEvent->sessionId, |
| pScanEvent->scanId); |
| qdf_mem_free(pMac->lim.gpLimRemainOnChanReq); |
| pMac->lim.gpLimRemainOnChanReq = NULL; |
| /* |
| * If remain on channel timer expired and action frame |
| * is pending then indicate confirmation with status |
| * failure. |
| */ |
| if (pMac->lim.mgmtFrameSessionId != 0xff) { |
| lim_p2p_action_cnf(pMac, false); |
| pMac->lim.mgmtFrameSessionId = 0xff; |
| } |
| } else if (PREAUTH_REQUESTOR_ID == pScanEvent->requestor) { |
| lim_preauth_scan_event_handler(pMac, pScanEvent->event, |
| pScanEvent->sessionId, |
| pScanEvent->scanId); |
| } else { |
| lim_send_scan_offload_complete(pMac, pScanEvent); |
| } |
| break; |
| case SIR_SCAN_EVENT_FOREIGN_CHANNEL: |
| if (ROC_SCAN_REQUESTOR_ID == pScanEvent->requestor) { |
| /*Send Ready on channel indication to SME */ |
| if (pMac->lim.gpLimRemainOnChanReq) { |
| lim_send_sme_roc_rsp(pMac, |
| eWNI_SME_REMAIN_ON_CHN_RDY_IND, |
| QDF_STATUS_SUCCESS, |
| pScanEvent->sessionId, |
| pScanEvent->scanId); |
| } else { |
| lim_log(pMac, LOGE, |
| FL("gpLimRemainOnChanReq is NULL")); |
| } |
| } else if (PREAUTH_REQUESTOR_ID == pScanEvent->requestor) { |
| lim_preauth_scan_event_handler(pMac, pScanEvent->event, |
| pScanEvent->sessionId, |
| pScanEvent->scanId); |
| } |
| break; |
| case SIR_SCAN_EVENT_BSS_CHANNEL: |
| case SIR_SCAN_EVENT_DEQUEUED: |
| case SIR_SCAN_EVENT_PREEMPTED: |
| default: |
| QDF_TRACE(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG, |
| "Received unhandled scan event %u", |
| pScanEvent->event); |
| } |
| qdf_mem_free(buf); |
| } |