samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Remove deprecated code in MAC layer

Browse Source 
Remove deprecated code because of CRYPTO_SET_KEY_CONVERGED cleanup
in MAC layer.

Change-Id: I65bc90b457cdd642d64d6ab0e6829856ee93e472
CRs-fixed: 2593528
This commit is contained in:
Yue Ma
2019-12-23 16:39:30 -08:00
committed by nshrivas
parent 34321601a6
commit e63f42fb57
14 changed files with 9 additions and 748 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/mac/inc/wni_api.h
View File

@@ -41,7 +41,6 @@ enum eWniMsgTypes {
eWNI_SME_SYS_READY_IND = SIR_SME_MSG_TYPES_BEGIN + 1, eWNI_SME_SYS_READY_IND = SIR_SME_MSG_TYPES_BEGIN + 1,
eWNI_SME_JOIN_REQ = SIR_SME_MSG_TYPES_BEGIN + 2, eWNI_SME_JOIN_REQ = SIR_SME_MSG_TYPES_BEGIN + 2,
eWNI_SME_JOIN_RSP = SIR_SME_MSG_TYPES_BEGIN + 3, eWNI_SME_JOIN_RSP = SIR_SME_MSG_TYPES_BEGIN + 3,
eWNI_SME_SETCONTEXT_REQ = SIR_SME_MSG_TYPES_BEGIN + 4,
eWNI_SME_SETCONTEXT_RSP = SIR_SME_MSG_TYPES_BEGIN + 5, eWNI_SME_SETCONTEXT_RSP = SIR_SME_MSG_TYPES_BEGIN + 5,
eWNI_SME_REASSOC_REQ = SIR_SME_MSG_TYPES_BEGIN + 6, eWNI_SME_REASSOC_REQ = SIR_SME_MSG_TYPES_BEGIN + 6,
eWNI_SME_REASSOC_RSP = SIR_SME_MSG_TYPES_BEGIN + 7, eWNI_SME_REASSOC_RSP = SIR_SME_MSG_TYPES_BEGIN + 7,
@@ -93,7 +92,6 @@ enum eWniMsgTypes {
eWNI_SME_FT_PRE_AUTH_REQ = SIR_SME_MSG_TYPES_BEGIN + 49, eWNI_SME_FT_PRE_AUTH_REQ = SIR_SME_MSG_TYPES_BEGIN + 49,
eWNI_SME_FT_PRE_AUTH_RSP = SIR_SME_MSG_TYPES_BEGIN + 50, eWNI_SME_FT_PRE_AUTH_RSP = SIR_SME_MSG_TYPES_BEGIN + 50,
eWNI_SME_FT_UPDATE_KEY = SIR_SME_MSG_TYPES_BEGIN + 51,
eWNI_SME_FT_AGGR_QOS_REQ = SIR_SME_MSG_TYPES_BEGIN + 52, eWNI_SME_FT_AGGR_QOS_REQ = SIR_SME_MSG_TYPES_BEGIN + 52,
eWNI_SME_FT_AGGR_QOS_RSP = SIR_SME_MSG_TYPES_BEGIN + 53, eWNI_SME_FT_AGGR_QOS_RSP = SIR_SME_MSG_TYPES_BEGIN + 53,

5
core/mac/src/include/sir_params.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -221,9 +221,7 @@ struct sir_cfg_action_frm_tb_ppdu {
*/ */
#define SIR_HAL_SEND_BEACON_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 17) #define SIR_HAL_SEND_BEACON_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 17)
#define SIR_HAL_SET_BSSKEY_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 18)
#define SIR_HAL_SET_BSSKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 19) #define SIR_HAL_SET_BSSKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 19)
#define SIR_HAL_SET_STAKEY_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 20)
#define SIR_HAL_SET_STAKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 21) #define SIR_HAL_SET_STAKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 21)
#define SIR_HAL_UPDATE_EDCA_PROFILE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 22) #define SIR_HAL_UPDATE_EDCA_PROFILE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 22)
@@ -249,7 +247,6 @@ struct sir_cfg_action_frm_tb_ppdu {
* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 57) are unused * (SIR_HAL_ITC_MSG_TYPES_BEGIN + 57) are unused
*/ */
#define SIR_HAL_SET_STA_BCASTKEY_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 58)
#define SIR_HAL_SET_STA_BCASTKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 59) #define SIR_HAL_SET_STA_BCASTKEY_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 59)
#define SIR_HAL_ADD_TS_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 60) #define SIR_HAL_ADD_TS_RSP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 60)
#define SIR_HAL_DPU_MIC_ERROR (SIR_HAL_ITC_MSG_TYPES_BEGIN + 61) #define SIR_HAL_DPU_MIC_ERROR (SIR_HAL_ITC_MSG_TYPES_BEGIN + 61)

3
core/mac/src/pe/include/lim_ft.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -170,7 +170,6 @@ static inline void lim_ft_prepare_add_bss_req(struct mac_context *mac,
{} {}
#endif #endif
bool lim_process_ft_update_key(struct mac_context *mac, uint32_t *msg_buf);
QDF_STATUS lim_process_ft_aggr_qos_req(struct mac_context *mac, QDF_STATUS lim_process_ft_aggr_qos_req(struct mac_context *mac,
uint32_t *msg_buf); uint32_t *msg_buf);
void lim_process_ft_aggr_qos_rsp(struct mac_context *mac, void lim_process_ft_aggr_qos_rsp(struct mac_context *mac,

91
core/mac/src/pe/lim/lim_ft.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -685,95 +685,6 @@ void lim_fill_ft_session(struct mac_context *mac,
} }
#endif #endif
/*------------------------------------------------------------------
*
* This function is called to process the update key request from SME
*
*------------------------------------------------------------------*/
bool lim_process_ft_update_key(struct mac_context *mac, uint32_t *msg_buf)
{
struct bss_params *pAddBssParams;
tSirFTUpdateKeyInfo *pKeyInfo;
struct pe_session *pe_session;
uint8_t sessionId;
/* Sanity Check */
if (!mac || !msg_buf)
return false;
pKeyInfo = (tSirFTUpdateKeyInfo *)msg_buf;
pe_session = pe_find_session_by_bssid(mac, pKeyInfo->bssid.bytes,
&sessionId);
if (!pe_session) {
pe_err("%s: Unable to find session for the following bssid",
__func__);
lim_print_mac_addr(mac, pKeyInfo->bssid.bytes, LOGE);
return false;
}
/* Nothing to be done if the session is not in STA mode */
if (!LIM_IS_STA_ROLE(pe_session)) {
pe_err("pe_session is not in STA mode");
return false;
}
if (!pe_session->ftPEContext.pAddBssReq) {
/* AddBss Req is NULL, save the keys to configure them later. */
tpLimMlmSetKeysReq pMlmSetKeysReq =
&pe_session->ftPEContext.PreAuthKeyInfo.
extSetStaKeyParam;
qdf_mem_zero(pMlmSetKeysReq, sizeof(tLimMlmSetKeysReq));
qdf_copy_macaddr(&pMlmSetKeysReq->peer_macaddr,
&pKeyInfo->bssid);
pMlmSetKeysReq->sessionId = pe_session->peSessionId;
pMlmSetKeysReq->vdev_id = pe_session->vdev_id;
pMlmSetKeysReq->edType = pKeyInfo->keyMaterial.edType;
pMlmSetKeysReq->numKeys = pKeyInfo->keyMaterial.numKeys;
qdf_mem_copy((uint8_t *) &pMlmSetKeysReq->key,
(uint8_t *) &pKeyInfo->keyMaterial.key,
sizeof(tSirKeys));
pe_session->ftPEContext.PreAuthKeyInfo.
extSetStaKeyParamValid = true;
if (!pe_session->ftPEContext.pAddStaReq) {
pe_err("pAddStaReq is NULL");
lim_send_set_sta_key_req(mac, pMlmSetKeysReq, 0,
pe_session, false);
pe_session->ftPEContext.PreAuthKeyInfo.
extSetStaKeyParamValid = false;
}
} else {
pAddBssParams = pe_session->ftPEContext.pAddBssReq;
/* Store the key information in the ADD BSS parameters */
pAddBssParams->extSetStaKeyParamValid = 1;
pAddBssParams->extSetStaKeyParam.encType =
pKeyInfo->keyMaterial.edType;
qdf_mem_copy((uint8_t *) &pAddBssParams->extSetStaKeyParam.key,
(uint8_t *) &pKeyInfo->keyMaterial.key,
sizeof(tSirKeys));
pAddBssParams->extSetStaKeyParam.singleTidRc =
(uint8_t)mac->mlme_cfg->sta.single_tid;
pe_debug("Key valid: %d keyLength: %d",
pAddBssParams->extSetStaKeyParamValid,
pAddBssParams->extSetStaKeyParam.key[0].keyLength);
pe_debug("BSSID: " QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(pKeyInfo->bssid.bytes));
qdf_copy_macaddr(&pAddBssParams->extSetStaKeyParam.peer_macaddr,
&pKeyInfo->bssid);
pAddBssParams->extSetStaKeyParam.sendRsp = false;
}
return true;
}
static void static void
lim_ft_send_aggr_qos_rsp(struct mac_context *mac, uint8_t rspReqd, lim_ft_send_aggr_qos_rsp(struct mac_context *mac, uint8_t rspReqd,
struct aggr_add_ts_param *aggrQosRsp, struct aggr_add_ts_param *aggrQosRsp,

2
core/mac/src/pe/lim/lim_process_message_queue.c
View File

@@ -1721,7 +1721,6 @@ static void lim_process_messages(struct mac_context *mac_ctx,
case eWNI_SME_START_BSS_REQ: case eWNI_SME_START_BSS_REQ:
case eWNI_SME_STOP_BSS_REQ: case eWNI_SME_STOP_BSS_REQ:
case eWNI_SME_SWITCH_CHL_IND: case eWNI_SME_SWITCH_CHL_IND:
case eWNI_SME_SETCONTEXT_REQ:
case eWNI_SME_DISASSOC_CNF: case eWNI_SME_DISASSOC_CNF:
case eWNI_SME_DEAUTH_CNF: case eWNI_SME_DEAUTH_CNF:
case eWNI_SME_ASSOC_CNF: case eWNI_SME_ASSOC_CNF:
@@ -1734,7 +1733,6 @@ static void lim_process_messages(struct mac_context *mac_ctx,
#if defined FEATURE_WLAN_ESE #if defined FEATURE_WLAN_ESE
case eWNI_SME_ESE_ADJACENT_AP_REPORT: case eWNI_SME_ESE_ADJACENT_AP_REPORT:
#endif #endif
case eWNI_SME_FT_UPDATE_KEY:
case eWNI_SME_FT_PRE_AUTH_REQ: case eWNI_SME_FT_PRE_AUTH_REQ:
case eWNI_SME_FT_AGGR_QOS_REQ: case eWNI_SME_FT_AGGR_QOS_REQ:
case eWNI_SME_REGISTER_MGMT_FRAME_REQ: case eWNI_SME_REGISTER_MGMT_FRAME_REQ:

201
core/mac/src/pe/lim/lim_process_mlm_req_messages.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -47,7 +47,6 @@
static void lim_process_mlm_auth_req(struct mac_context *, uint32_t *); static void lim_process_mlm_auth_req(struct mac_context *, uint32_t *);
static void lim_process_mlm_assoc_req(struct mac_context *, uint32_t *); static void lim_process_mlm_assoc_req(struct mac_context *, uint32_t *);
static void lim_process_mlm_disassoc_req(struct mac_context *, uint32_t *); static void lim_process_mlm_disassoc_req(struct mac_context *, uint32_t *);
static void lim_process_mlm_set_keys_req(struct mac_context *, uint32_t *);
/* MLM Timeout event handler templates */ /* MLM Timeout event handler templates */
static void lim_process_auth_rsp_timeout(struct mac_context *, uint32_t); static void lim_process_auth_rsp_timeout(struct mac_context *, uint32_t);
@@ -127,9 +126,6 @@ void lim_process_mlm_req_messages(struct mac_context *mac_ctx,
case LIM_MLM_DISASSOC_REQ: case LIM_MLM_DISASSOC_REQ:
lim_process_mlm_disassoc_req(mac_ctx, msg->bodyptr); lim_process_mlm_disassoc_req(mac_ctx, msg->bodyptr);
break; break;
case LIM_MLM_SETKEYS_REQ:
lim_process_mlm_set_keys_req(mac_ctx, msg->bodyptr);
break;
case SIR_LIM_JOIN_FAIL_TIMEOUT: case SIR_LIM_JOIN_FAIL_TIMEOUT:
lim_process_join_failure_timeout(mac_ctx); lim_process_join_failure_timeout(mac_ctx);
break; break;
@@ -1558,201 +1554,6 @@ void lim_process_mlm_deauth_req(struct mac_context *mac_ctx, uint32_t *msg_buf)
(uint32_t *) msg_buf); (uint32_t *) msg_buf);
} }
/**
* lim_process_mlm_set_keys_req() - This function is called to process
* MLM_SETKEYS_REQ message from SME
*
* @mac_ctx: Pointer to Global MAC structure
* @msg_buf: A pointer to the MLM message buffer
*
* This function is called to process MLM_SETKEYS_REQ message from SME
*
* @Return: None
*/
static void
lim_process_mlm_set_keys_req(struct mac_context *mac_ctx, uint32_t *msg_buf)
{
uint16_t aid;
uint32_t default_key_id = 0;
struct qdf_mac_addr curr_bssid;
tpDphHashNode sta_ds;
tLimMlmSetKeysReq *mlm_set_keys_req;
tLimMlmSetKeysCnf mlm_set_keys_cnf;
struct pe_session *session;
if (!msg_buf) {
pe_err("Buffer is Pointing to NULL");
return;
}
mlm_set_keys_req = (tLimMlmSetKeysReq *) msg_buf;
if (mac_ctx->lim.gpLimMlmSetKeysReq) {
qdf_mem_zero(mac_ctx->lim.gpLimMlmSetKeysReq,
sizeof(*mlm_set_keys_req));
qdf_mem_free(mac_ctx->lim.gpLimMlmSetKeysReq);
mac_ctx->lim.gpLimMlmSetKeysReq = NULL;
}
/* Hold onto the SetKeys request parameters */
mac_ctx->lim.gpLimMlmSetKeysReq = (void *)mlm_set_keys_req;
session = pe_find_session_by_session_id(mac_ctx,
mlm_set_keys_req->sessionId);
if (!session) {
pe_err("session does not exist for given sessionId");
qdf_mem_zero(mlm_set_keys_req->key,
sizeof(mlm_set_keys_req->key));
mlm_set_keys_req->numKeys = 0;
qdf_mem_free(mlm_set_keys_req);
mac_ctx->lim.gpLimMlmSetKeysReq = NULL;
return;
}
pe_debug("Received MLM_SETKEYS_REQ with parameters:"
"AID [%d], ED Type [%d], # Keys [%d] & Peer MAC Addr - ",
mlm_set_keys_req->aid, mlm_set_keys_req->edType,
mlm_set_keys_req->numKeys);
lim_print_mac_addr(mac_ctx, mlm_set_keys_req->peer_macaddr.bytes, LOGD);
qdf_mem_copy(curr_bssid.bytes, session->bssId, QDF_MAC_ADDR_SIZE);
switch (GET_LIM_SYSTEM_ROLE(session)) {
case eLIM_STA_ROLE:
/*
* In case of TDLS, peerMac address need not be BssId. Skip this
* check if TDLS is enabled.
*/
#ifndef FEATURE_WLAN_TDLS
if ((!qdf_is_macaddr_broadcast(
&mlm_set_keys_req->peer_macaddr)) &&
(!qdf_is_macaddr_equal(&mlm_set_keys_req->peer_macaddr,
&curr_bssid))) {
pe_debug("Received MLM_SETKEYS_REQ with invalid BSSID"
QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(mlm_set_keys_req->
peer_macaddr.bytes));
/*
* Prepare and Send LIM_MLM_SETKEYS_CNF with error code
*/
mlm_set_keys_cnf.resultCode =
eSIR_SME_INVALID_PARAMETERS;
goto end;
}
#endif
break;
case eLIM_STA_IN_IBSS_ROLE:
/*
* update the IBSS PE session encrption type based on the
* key type
*/
session->encryptType = mlm_set_keys_req->edType;
break;
default:
break;
}
/*
* Use the "unicast" parameter to determine if the "Group Keys"
* are being set.
* mlm_set_keys_req->key.unicast = 0 -> Multicast/broadcast
* mlm_set_keys_req->key.unicast - 1 -> Unicast keys are being set
*/
if (qdf_is_macaddr_broadcast(&mlm_set_keys_req->peer_macaddr)) {
pe_debug("Trying to set Group Keys...%d",
mlm_set_keys_req->sessionId);
/*
* When trying to set Group Keys for any security mode other
* than WEP, use the STA Index corresponding to the AP...
*/
switch (mlm_set_keys_req->edType) {
case eSIR_ED_CCMP:
case eSIR_ED_GCMP:
case eSIR_ED_GCMP_256:
#ifdef WLAN_FEATURE_11W
case eSIR_ED_AES_128_CMAC:
case eSIR_ED_AES_GMAC_128:
case eSIR_ED_AES_GMAC_256:
#endif
break;
default:
break;
}
} else {
pe_debug("Trying to set Unicast Keys...");
/*
* Check if there exists a context for the
* peer entity for which keys need to be set.
*/
sta_ds = dph_lookup_hash_entry(mac_ctx,
mlm_set_keys_req->peer_macaddr.bytes, &aid,
&session->dph.dphHashTable);
if ((!sta_ds) ||
((sta_ds->mlmStaContext.mlmState !=
eLIM_MLM_LINK_ESTABLISHED_STATE) &&
!LIM_IS_AP_ROLE(session))) {
/*
* Received LIM_MLM_SETKEYS_REQ for STA that does not
* have context or in some transit state.
*/
pe_debug("Invalid MLM_SETKEYS_REQ, Addr = "
QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(mlm_set_keys_req->
peer_macaddr.bytes));
/* Prepare and Send LIM_MLM_SETKEYS_CNF */
mlm_set_keys_cnf.resultCode =
eSIR_SME_INVALID_PARAMETERS;
goto end;
}
}
if ((mlm_set_keys_req->numKeys == 0)
&& (mlm_set_keys_req->edType != eSIR_ED_NONE)) {
/*
* Broadcast/Multicast Keys (for WEP!!) are NOT sent
* via this interface!! This indicates to HAL that the WEP Keys
* need to be extracted from the CFG and applied to hardware
*/
default_key_id = 0xff;
} else if (mlm_set_keys_req->key[0].keyId &&
((mlm_set_keys_req->edType == eSIR_ED_WEP40) ||
(mlm_set_keys_req->edType == eSIR_ED_WEP104))) {
/*
* If the Key Id is non zero and encryption mode is WEP,
* the key index is coming from the upper layers so that key
* only need to be used as the default tx key, This is being
* used only in case of WEP mode in HAL
*/
default_key_id = mlm_set_keys_req->key[0].keyId;
} else {
default_key_id = 0;
}
pe_debug("Trying to set keys using default_key_id [%d] sta mac "
QDF_MAC_ADDR_STR, default_key_id,
QDF_MAC_ADDR_ARRAY(mlm_set_keys_req->peer_macaddr.bytes));
if (qdf_is_macaddr_broadcast(&mlm_set_keys_req->peer_macaddr)) {
session->limPrevMlmState = session->limMlmState;
session->limMlmState = eLIM_MLM_WT_SET_BSS_KEY_STATE;
MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE,
session->peSessionId, session->limMlmState));
pe_debug("Trying to set Group Keys...%d",
session->peSessionId);
/* Package WMA_SET_BSSKEY_REQ message parameters */
lim_send_set_bss_key_req(mac_ctx, mlm_set_keys_req, session);
return;
} else {
/*
* Package WMA_SET_STAKEY_REQ / WMA_SET_STA_BCASTKEY_REQ message
* parameters
*/
lim_send_set_sta_key_req(mac_ctx, mlm_set_keys_req,
(uint8_t) default_key_id, session,
true);
return;
}
end:
mlm_set_keys_cnf.sessionId = mlm_set_keys_req->sessionId;
lim_post_sme_set_keys_cnf(mac_ctx, mlm_set_keys_req, &mlm_set_keys_cnf);
}
void lim_process_join_failure_timeout(struct mac_context *mac_ctx) void lim_process_join_failure_timeout(struct mac_context *mac_ctx)
{ {
tLimMlmJoinCnf mlm_join_cnf; tLimMlmJoinCnf mlm_join_cnf;

19
core/mac/src/pe/lim/lim_process_mlm_rsp_messages.c
View File

@@ -1421,8 +1421,6 @@ void lim_process_sta_mlm_add_sta_rsp(struct mac_context *mac_ctx,
tpDphHashNode sta_ds; tpDphHashNode sta_ds;
uint32_t msg_type = LIM_MLM_ASSOC_CNF; uint32_t msg_type = LIM_MLM_ASSOC_CNF;
tpAddStaParams add_sta_params = (tpAddStaParams) msg->bodyptr; tpAddStaParams add_sta_params = (tpAddStaParams) msg->bodyptr;
struct pe_session *ft_session = NULL;
uint8_t ft_session_id;
if (!add_sta_params) { if (!add_sta_params) {
pe_err("Encountered NULL Pointer"); pe_err("Encountered NULL Pointer");
@@ -1465,23 +1463,6 @@ void lim_process_sta_mlm_add_sta_rsp(struct mac_context *mac_ctx,
(tSirResultCodes) eSIR_SME_REFUSED; (tSirResultCodes) eSIR_SME_REFUSED;
goto end; 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 &&
ft_ctx->PreAuthKeyInfo.extSetStaKeyParamValid
== true) {
tpLimMlmSetKeysReq pMlmStaKeys =
&ft_ctx->PreAuthKeyInfo.extSetStaKeyParam;
lim_send_set_sta_key_req(mac_ctx, pMlmStaKeys,
0, ft_session, false);
ft_ctx->PreAuthKeyInfo.extSetStaKeyParamValid =
false;
}
}
/* /*
* Update the DPH Hash Entry for this STA * Update the DPH Hash Entry for this STA
* with proper state info * with proper state info

150
core/mac/src/pe/lim/lim_process_sme_req_messages.c
View File

@@ -64,7 +64,6 @@ static bool __lim_process_sme_start_bss_req(struct mac_context *,
static void __lim_process_sme_disassoc_req(struct mac_context *, uint32_t *); static void __lim_process_sme_disassoc_req(struct mac_context *, uint32_t *);
static void __lim_process_sme_disassoc_cnf(struct mac_context *, uint32_t *); static void __lim_process_sme_disassoc_cnf(struct mac_context *, uint32_t *);
static void __lim_process_sme_deauth_req(struct mac_context *, uint32_t *); static void __lim_process_sme_deauth_req(struct mac_context *, uint32_t *);
static void __lim_process_sme_set_context_req(struct mac_context *, uint32_t *);
static bool __lim_process_sme_stop_bss_req(struct mac_context *, static bool __lim_process_sme_stop_bss_req(struct mac_context *,
struct scheduler_msg *pMsg); struct scheduler_msg *pMsg);
static void lim_process_sme_channel_change_request(struct mac_context *mac, static void lim_process_sme_channel_change_request(struct mac_context *mac,
@@ -2589,148 +2588,6 @@ send_deauth:
ret_code, deauth_trigger, 1, vdev_id); ret_code, deauth_trigger, 1, vdev_id);
} }
/**
* __lim_process_sme_set_context_req()
*
* @mac_ctx: Pointer to Global MAC structure
* @msg_buf: pointer to the SME message buffer
*
* This function is called to process SME_SETCONTEXT_REQ message
* from HDD or upper layer application.
*
* Return: None
*/
static void
__lim_process_sme_set_context_req(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
struct set_context_req *set_context_req;
tLimMlmSetKeysReq *mlm_set_key_req;
struct pe_session *session_entry;
uint8_t session_id; /* PE sessionID */
uint8_t vdev_id;
if (!msg_buf) {
pe_err("Buffer is Pointing to NULL");
return;
}
set_context_req = qdf_mem_malloc(sizeof(*set_context_req));
if (!set_context_req)
return;
qdf_mem_copy(set_context_req, msg_buf,
sizeof(*set_context_req));
qdf_mem_zero(msg_buf, sizeof(*set_context_req));
vdev_id = set_context_req->vdev_id;
if ((!lim_is_sme_set_context_req_valid(mac_ctx, set_context_req))) {
pe_warn("received invalid SME_SETCONTEXT_REQ message");
goto end;
}
if (set_context_req->keyMaterial.numKeys >
SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS) {
pe_err("numKeys:%d is more than SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS",
set_context_req->keyMaterial.numKeys);
lim_send_sme_set_context_rsp(mac_ctx,
set_context_req->peer_macaddr, 1,
eSIR_SME_INVALID_PARAMETERS, NULL,
vdev_id);
goto end;
}
session_entry = pe_find_session_by_bssid(mac_ctx,
set_context_req->bssid.bytes, &session_id);
if (!session_entry) {
pe_err("Session does not exist for given BSSID");
lim_send_sme_set_context_rsp(mac_ctx,
set_context_req->peer_macaddr, 1,
eSIR_SME_INVALID_PARAMETERS, NULL,
vdev_id);
goto end;
}
#ifdef FEATURE_WLAN_DIAG_SUPPORT_LIM /* FEATURE_WLAN_DIAG_SUPPORT */
lim_diag_event_report(mac_ctx, WLAN_PE_DIAG_SETCONTEXT_REQ_EVENT,
session_entry, 0, 0);
#endif /* FEATURE_WLAN_DIAG_SUPPORT */
if ((LIM_IS_STA_ROLE(session_entry) &&
(session_entry->limSmeState == eLIM_SME_LINK_EST_STATE)) ||
((LIM_IS_IBSS_ROLE(session_entry) ||
LIM_IS_AP_ROLE(session_entry)) &&
(session_entry->limSmeState == eLIM_SME_NORMAL_STATE))) {
/* Trigger MLM_SETKEYS_REQ */
mlm_set_key_req = qdf_mem_malloc(sizeof(tLimMlmSetKeysReq));
if (!mlm_set_key_req)
goto end;
mlm_set_key_req->edType = set_context_req->keyMaterial.edType;
mlm_set_key_req->numKeys =
set_context_req->keyMaterial.numKeys;
if (mlm_set_key_req->numKeys >
SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS) {
pe_err("no.of keys exceeded max num of default keys limit");
qdf_mem_free(mlm_set_key_req);
goto end;
}
qdf_copy_macaddr(&mlm_set_key_req->peer_macaddr,
&set_context_req->peer_macaddr);
qdf_mem_copy((uint8_t *) &mlm_set_key_req->key,
(uint8_t *) &set_context_req->keyMaterial.key,
sizeof(tSirKeys) *
(mlm_set_key_req->numKeys ? mlm_set_key_req->
numKeys : 1));
mlm_set_key_req->sessionId = session_id;
mlm_set_key_req->vdev_id = vdev_id;
pe_debug("received SETCONTEXT_REQ message sessionId=%d",
mlm_set_key_req->sessionId);
if (((set_context_req->keyMaterial.edType == eSIR_ED_WEP40) ||
(set_context_req->keyMaterial.edType == eSIR_ED_WEP104)) &&
LIM_IS_AP_ROLE(session_entry)) {
if (set_context_req->keyMaterial.key[0].keyLength) {
uint8_t key_id;
key_id =
set_context_req->keyMaterial.key[0].keyId;
qdf_mem_copy((uint8_t *)
&session_entry->WEPKeyMaterial[key_id],
(uint8_t *) &set_context_req->keyMaterial,
sizeof(tSirKeyMaterial));
} else {
uint32_t i;
for (i = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
i++) {
qdf_mem_copy((uint8_t *)
&mlm_set_key_req->key[i],
(uint8_t *)session_entry->WEPKeyMaterial[i].key,
sizeof(tSirKeys));
}
}
}
lim_post_mlm_message(mac_ctx, LIM_MLM_SETKEYS_REQ,
(uint32_t *) mlm_set_key_req);
} else {
pe_err("rcvd unexpected SME_SETCONTEXT_REQ for role %d, state=%X",
GET_LIM_SYSTEM_ROLE(session_entry),
session_entry->limSmeState);
lim_print_sme_state(mac_ctx, LOGE, session_entry->limSmeState);
lim_send_sme_set_context_rsp(mac_ctx,
set_context_req->peer_macaddr, 1,
eSIR_SME_UNEXPECTED_REQ_RESULT_CODE,
session_entry, vdev_id);
}
end:
qdf_mem_zero(set_context_req, sizeof(*set_context_req));
qdf_mem_free(set_context_req);
return;
}
/** /**
* __lim_counter_measures() * __lim_counter_measures()
* *
@@ -4761,10 +4618,6 @@ bool lim_process_sme_req_messages(struct mac_context *mac,
__lim_process_send_disassoc_frame(mac, msg_buf); __lim_process_send_disassoc_frame(mac, msg_buf);
break; break;
case eWNI_SME_SETCONTEXT_REQ:
__lim_process_sme_set_context_req(mac, msg_buf);
break;
case eWNI_SME_STOP_BSS_REQ: case eWNI_SME_STOP_BSS_REQ:
bufConsumed = __lim_process_sme_stop_bss_req(mac, pMsg); bufConsumed = __lim_process_sme_stop_bss_req(mac, pMsg);
break; break;
@@ -4835,9 +4688,6 @@ bool lim_process_sme_req_messages(struct mac_context *mac,
case eWNI_SME_FT_PRE_AUTH_REQ: case eWNI_SME_FT_PRE_AUTH_REQ:
bufConsumed = (bool) lim_process_ft_pre_auth_req(mac, pMsg); bufConsumed = (bool) lim_process_ft_pre_auth_req(mac, pMsg);
break; break;
case eWNI_SME_FT_UPDATE_KEY:
lim_process_ft_update_key(mac, msg_buf);
break;
case eWNI_SME_FT_AGGR_QOS_REQ: case eWNI_SME_FT_AGGR_QOS_REQ:
lim_process_ft_aggr_qos_req(mac, msg_buf); lim_process_ft_aggr_qos_req(mac, msg_buf);

260
core/mac/src/pe/lim/lim_security_utils.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -753,261 +753,3 @@ void lim_post_sme_set_keys_cnf(struct mac_context *mac,
lim_post_sme_message(mac, lim_post_sme_message(mac,
LIM_MLM_SETKEYS_CNF, (uint32_t *) mlmSetKeysCnf); LIM_MLM_SETKEYS_CNF, (uint32_t *) mlmSetKeysCnf);
} }
/**
* lim_send_set_bss_key_req()
*
***FUNCTION:
* This function is called from lim_process_mlm_set_keys_req(),
* when PE is trying to setup the Group Keys related
* to a specified encryption type
*
***LOGIC:
*
***ASSUMPTIONS:
* NA
*
***NOTE:
* NA
*
* @param mac Pointer to Global MAC structure
* @param pMlmSetKeysReq Pointer to MLM_SETKEYS_REQ buffer
* @return none
*/
void lim_send_set_bss_key_req(struct mac_context *mac,
tLimMlmSetKeysReq *pMlmSetKeysReq,
struct pe_session *pe_session)
{
struct scheduler_msg msgQ = {0};
tpSetBssKeyParams pSetBssKeyParams = NULL;
tLimMlmSetKeysCnf mlmSetKeysCnf;
QDF_STATUS retCode;
if (pMlmSetKeysReq->numKeys > SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS) {
pe_debug("numKeys = %d is more than SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS",
pMlmSetKeysReq->numKeys);
/* Respond to SME with error code */
mlmSetKeysCnf.resultCode = eSIR_SME_INVALID_PARAMETERS;
goto end;
}
/* Package WMA_SET_BSSKEY_REQ message parameters */
pSetBssKeyParams = qdf_mem_malloc(sizeof(tSetBssKeyParams));
if (!pSetBssKeyParams) {
/* Respond to SME with error code */
mlmSetKeysCnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE;
goto end;
}
/* Update the WMA_SET_BSSKEY_REQ parameters */
pSetBssKeyParams->encType = pMlmSetKeysReq->edType;
pSetBssKeyParams->singleTidRc =
(uint8_t)(mac->mlme_cfg->sta.single_tid);
pSetBssKeyParams->vdev_id = pMlmSetKeysReq->vdev_id;
if (pMlmSetKeysReq->key[0].keyId &&
((pMlmSetKeysReq->edType == eSIR_ED_WEP40) ||
(pMlmSetKeysReq->edType == eSIR_ED_WEP104))
) {
/* IF the key id is non-zero and encryption type is WEP, Send all the 4
* keys to HAL with filling the key at right index in pSetBssKeyParams->key. */
pSetBssKeyParams->numKeys = SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
qdf_mem_copy((uint8_t *) &pSetBssKeyParams->
key[pMlmSetKeysReq->key[0].keyId],
(uint8_t *) &pMlmSetKeysReq->key[0],
sizeof(pMlmSetKeysReq->key[0]));
} else {
pSetBssKeyParams->numKeys = pMlmSetKeysReq->numKeys;
qdf_mem_copy((uint8_t *) &pSetBssKeyParams->key,
(uint8_t *) &pMlmSetKeysReq->key,
sizeof(tSirKeys) * pMlmSetKeysReq->numKeys);
}
SET_LIM_PROCESS_DEFD_MESGS(mac, false);
msgQ.type = WMA_SET_BSSKEY_REQ;
msgQ.reserved = 0;
msgQ.bodyptr = pSetBssKeyParams;
msgQ.bodyval = 0;
pe_debug("Sending WMA_SET_BSSKEY_REQ...");
MTRACE(mac_trace_msg_tx(mac, pe_session->peSessionId, msgQ.type));
retCode = wma_post_ctrl_msg(mac, &msgQ);
if (QDF_STATUS_SUCCESS != retCode) {
pe_err("Posting SET_BSSKEY to HAL failed, reason=%X",
retCode);
/* Respond to SME with LIM_MLM_SETKEYS_CNF */
mlmSetKeysCnf.resultCode = eSIR_SME_HAL_SEND_MESSAGE_FAIL;
qdf_mem_zero(pSetBssKeyParams, sizeof(tSetBssKeyParams));
qdf_mem_free(pSetBssKeyParams);
} else
return; /* Continue after WMA_SET_BSSKEY_RSP... */
end:
lim_post_sme_set_keys_cnf(mac, pMlmSetKeysReq, &mlmSetKeysCnf);
}
/**
* @function : lim_send_set_sta_key_req()
*
* @brief : This function is called from lim_process_mlm_set_keys_req(),
* when PE is trying to setup the Unicast Keys related
* to a specified STA with specified encryption type
*
***LOGIC:
*
***ASSUMPTIONS:
* NA
*
***NOTE:
* NA
*
* @param mac Pointer to Global MAC structure
* @param pMlmSetKeysReq Pointer to MLM_SETKEYS_REQ buffer
* @param staIdx STA index for which the keys are being set
* @param defWEPIdx The default WEP key index [0..3]
* @return none
*/
void lim_send_set_sta_key_req(struct mac_context *mac,
tLimMlmSetKeysReq *pMlmSetKeysReq,
uint8_t defWEPIdx,
struct pe_session *pe_session, bool sendRsp)
{
struct scheduler_msg msgQ = {0};
tpSetStaKeyParams pSetStaKeyParams = NULL;
tLimMlmSetKeysCnf mlmSetKeysCnf;
QDF_STATUS retCode;
/* Package WMA_SET_STAKEY_REQ message parameters */
pSetStaKeyParams = qdf_mem_malloc(sizeof(tSetStaKeyParams));
if (!pSetStaKeyParams)
goto fail;
/* Update the WMA_SET_STAKEY_REQ parameters */
pSetStaKeyParams->encType = pMlmSetKeysReq->edType;
pSetStaKeyParams->singleTidRc =
(uint8_t)(mac->mlme_cfg->sta.single_tid);
/**
* For WEP - defWEPIdx indicates the default WEP
* Key to be used for TX
* For all others, there's just one key that can
* be used and hence it is assumed that
* defWEPIdx = 0 (from the caller)
*/
pSetStaKeyParams->defWEPIdx = defWEPIdx;
pSetStaKeyParams->vdev_id = pMlmSetKeysReq->vdev_id;
qdf_copy_macaddr(&pSetStaKeyParams->peer_macaddr,
&pMlmSetKeysReq->peer_macaddr);
if (sendRsp == true) {
/** Store the Previous MlmState*/
pe_session->limPrevMlmState = pe_session->limMlmState;
SET_LIM_PROCESS_DEFD_MESGS(mac, false);
}
if (LIM_IS_IBSS_ROLE(pe_session)
&& !pMlmSetKeysReq->key[0].unicast) {
if (sendRsp == true)
pe_session->limMlmState =
eLIM_MLM_WT_SET_STA_BCASTKEY_STATE;
msgQ.type = WMA_SET_STA_BCASTKEY_REQ;
} else {
if (sendRsp == true)
pe_session->limMlmState =
eLIM_MLM_WT_SET_STA_KEY_STATE;
msgQ.type = WMA_SET_STAKEY_REQ;
}
MTRACE(mac_trace
(mac, TRACE_CODE_MLM_STATE, pe_session->peSessionId,
pe_session->limMlmState));
/**
* In the Case of WEP_DYNAMIC, ED_TKIP and ED_CCMP
* the Key[0] contains the KEY, so just copy that alone,
* for the case of WEP_STATIC the hal gets the key from cfg
*/
switch (pMlmSetKeysReq->edType) {
case eSIR_ED_WEP40:
case eSIR_ED_WEP104:
/* FIXME! Is this OK? */
if (0 == pMlmSetKeysReq->numKeys) {
uint32_t i;
for (i = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++) {
qdf_mem_copy((uint8_t *) &pSetStaKeyParams->
key[i],
(uint8_t *) &pMlmSetKeysReq->
key[i], sizeof(tSirKeys));
}
pe_session->limMlmState =
eLIM_MLM_WT_SET_STA_KEY_STATE;
MTRACE(mac_trace
(mac, TRACE_CODE_MLM_STATE,
pe_session->peSessionId,
pe_session->limMlmState));
} else {
/*This case the keys are coming from upper layer so need to fill the
* key at the default wep key index and send to the HAL */
if (defWEPIdx < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS) {
qdf_mem_copy((uint8_t *) &pSetStaKeyParams->
key[defWEPIdx],
(uint8_t *) &pMlmSetKeysReq->
key[0],
sizeof(pMlmSetKeysReq->key[0]));
pMlmSetKeysReq->numKeys =
SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
} else {
pe_err("Wrong Key Index %d", defWEPIdx);
goto free_sta_key;
}
}
break;
case eSIR_ED_TKIP:
case eSIR_ED_CCMP:
case eSIR_ED_GCMP:
case eSIR_ED_GCMP_256:
#ifdef FEATURE_WLAN_WAPI
case eSIR_ED_WPI:
#endif
{
qdf_mem_copy((uint8_t *) &pSetStaKeyParams->key,
(uint8_t *) &pMlmSetKeysReq->key[0],
sizeof(tSirKeys));
}
break;
default:
break;
}
pSetStaKeyParams->sendRsp = sendRsp;
msgQ.reserved = 0;
msgQ.bodyptr = pSetStaKeyParams;
msgQ.bodyval = 0;
pe_debug("Sending WMA_SET_STAKEY_REQ...");
MTRACE(mac_trace_msg_tx(mac, pe_session->peSessionId, msgQ.type));
retCode = wma_post_ctrl_msg(mac, &msgQ);
if (QDF_STATUS_SUCCESS != retCode) {
pe_err("Posting SET_STAKEY to HAL failed, reason=%X",
retCode);
goto free_sta_key;
} else
return; /* Continue after WMA_SET_STAKEY_RSP... */
free_sta_key:
qdf_mem_zero(pSetStaKeyParams, sizeof(tSetStaKeyParams));
qdf_mem_free(pSetStaKeyParams);
fail:
/* Respond to SME with LIM_MLM_SETKEYS_CNF */
mlmSetKeysCnf.resultCode = eSIR_SME_HAL_SEND_MESSAGE_FAIL;
if (sendRsp == true)
lim_post_sme_set_keys_cnf(mac, pMlmSetKeysReq, &mlmSetKeysCnf);
}

6
core/mac/src/pe/lim/lim_security_utils.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011-2015, 2017-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2011-2015, 2017-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -73,10 +73,6 @@ void lim_encrypt_auth_frame(struct mac_context *, uint8_t, uint8_t *, uint8_t *,
uint8_t lim_decrypt_auth_frame(struct mac_context *, uint8_t *, uint8_t *, uint8_t lim_decrypt_auth_frame(struct mac_context *, uint8_t *, uint8_t *,
uint8_t *, uint32_t, uint16_t); uint8_t *, uint32_t, uint16_t);
void lim_send_set_bss_key_req(struct mac_context *, tLimMlmSetKeysReq *,
struct pe_session *);
void lim_send_set_sta_key_req(struct mac_context *, tLimMlmSetKeysReq *,
uint8_t, struct pe_session *, bool sendRsp);
void lim_post_sme_set_keys_cnf(struct mac_context *, tLimMlmSetKeysReq *, void lim_post_sme_set_keys_cnf(struct mac_context *, tLimMlmSetKeysReq *,
tLimMlmSetKeysCnf *); tLimMlmSetKeysCnf *);

3
core/mac/src/pe/lim/lim_types.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -74,7 +74,6 @@
#define LIM_MLM_TSPEC_REQ (LIM_MLM_MSG_START + 20) #define LIM_MLM_TSPEC_REQ (LIM_MLM_MSG_START + 20)
#define LIM_MLM_TSPEC_CNF (LIM_MLM_MSG_START + 21) #define LIM_MLM_TSPEC_CNF (LIM_MLM_MSG_START + 21)
#define LIM_MLM_TSPEC_IND (LIM_MLM_MSG_START + 22) #define LIM_MLM_TSPEC_IND (LIM_MLM_MSG_START + 22)
#define LIM_MLM_SETKEYS_REQ (LIM_MLM_MSG_START + 23)
#define LIM_MLM_SETKEYS_CNF (LIM_MLM_MSG_START + 24) #define LIM_MLM_SETKEYS_CNF (LIM_MLM_MSG_START + 24)
#define LIM_MLM_LINK_TEST_STOP_REQ (LIM_MLM_MSG_START + 30) #define LIM_MLM_LINK_TEST_STOP_REQ (LIM_MLM_MSG_START + 30)
#define LIM_MLM_PURGE_STA_IND (LIM_MLM_MSG_START + 31) #define LIM_MLM_PURGE_STA_IND (LIM_MLM_MSG_START + 31)

2
core/mac/src/pe/lim/lim_utils.c
View File

@@ -272,8 +272,6 @@ char *lim_msg_str(uint32_t msgType)
return "eWNI_SME_JOIN_REQ"; return "eWNI_SME_JOIN_REQ";
case eWNI_SME_JOIN_RSP: case eWNI_SME_JOIN_RSP:
return "eWNI_SME_JOIN_RSP"; return "eWNI_SME_JOIN_RSP";
case eWNI_SME_SETCONTEXT_REQ:
return "eWNI_SME_SETCONTEXT_REQ";
case eWNI_SME_SETCONTEXT_RSP: case eWNI_SME_SETCONTEXT_RSP:
return "eWNI_SME_SETCONTEXT_RSP"; return "eWNI_SME_SETCONTEXT_RSP";
case eWNI_SME_REASSOC_REQ: case eWNI_SME_REASSOC_REQ:

8
core/mac/src/sys/legacy/src/utils/src/mac_trace.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -216,7 +216,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_SYS_READY_IND); CASE_RETURN_STRING(eWNI_SME_SYS_READY_IND);
CASE_RETURN_STRING(eWNI_SME_JOIN_REQ); CASE_RETURN_STRING(eWNI_SME_JOIN_REQ);
CASE_RETURN_STRING(eWNI_SME_JOIN_RSP); CASE_RETURN_STRING(eWNI_SME_JOIN_RSP);
CASE_RETURN_STRING(eWNI_SME_SETCONTEXT_REQ);
CASE_RETURN_STRING(eWNI_SME_SETCONTEXT_RSP); CASE_RETURN_STRING(eWNI_SME_SETCONTEXT_RSP);
CASE_RETURN_STRING(eWNI_SME_REASSOC_REQ); CASE_RETURN_STRING(eWNI_SME_REASSOC_REQ);
CASE_RETURN_STRING(eWNI_SME_REASSOC_RSP); CASE_RETURN_STRING(eWNI_SME_REASSOC_RSP);
@@ -259,7 +258,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_RESP_XMIT_IND); CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_RESP_XMIT_IND);
CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_REQ); CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_REQ);
CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_RSP); CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_RSP);
CASE_RETURN_STRING(eWNI_SME_FT_UPDATE_KEY);
CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_REQ); CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_REQ);
CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_RSP); CASE_RETURN_STRING(eWNI_SME_FT_AGGR_QOS_RSP);
#if defined FEATURE_WLAN_ESE #if defined FEATURE_WLAN_ESE
@@ -396,9 +394,7 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
CASE_RETURN_STRING(WMA_DELETE_BSS_RSP); CASE_RETURN_STRING(WMA_DELETE_BSS_RSP);
CASE_RETURN_STRING(WMA_DELETE_BSS_HO_FAIL_RSP); CASE_RETURN_STRING(WMA_DELETE_BSS_HO_FAIL_RSP);
CASE_RETURN_STRING(WMA_SEND_BEACON_REQ); CASE_RETURN_STRING(WMA_SEND_BEACON_REQ);
CASE_RETURN_STRING(WMA_SET_BSSKEY_REQ);
CASE_RETURN_STRING(WMA_SET_BSSKEY_RSP); CASE_RETURN_STRING(WMA_SET_BSSKEY_RSP);
CASE_RETURN_STRING(WMA_SET_STAKEY_REQ);
CASE_RETURN_STRING(WMA_SET_STAKEY_RSP); CASE_RETURN_STRING(WMA_SET_STAKEY_RSP);
CASE_RETURN_STRING(WMA_UPDATE_EDCA_PROFILE_IND); CASE_RETURN_STRING(WMA_UPDATE_EDCA_PROFILE_IND);
@@ -416,7 +412,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
CASE_RETURN_STRING(WMA_IBSS_STA_ADD); CASE_RETURN_STRING(WMA_IBSS_STA_ADD);
CASE_RETURN_STRING(WMA_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND); CASE_RETURN_STRING(WMA_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND);
CASE_RETURN_STRING(WMA_SET_STA_BCASTKEY_REQ);
CASE_RETURN_STRING(WMA_SET_STA_BCASTKEY_RSP); CASE_RETURN_STRING(WMA_SET_STA_BCASTKEY_RSP);
CASE_RETURN_STRING(WMA_ADD_TS_RSP); CASE_RETURN_STRING(WMA_ADD_TS_RSP);
CASE_RETURN_STRING(WMA_DPU_MIC_ERROR); CASE_RETURN_STRING(WMA_DPU_MIC_ERROR);
@@ -691,7 +686,6 @@ uint8_t *mac_trace_get_lim_msg_string(uint16_t lim_msg)
CASE_RETURN_STRING(LIM_MLM_DEAUTH_IND); CASE_RETURN_STRING(LIM_MLM_DEAUTH_IND);
CASE_RETURN_STRING(LIM_MLM_TSPEC_REQ); CASE_RETURN_STRING(LIM_MLM_TSPEC_REQ);
CASE_RETURN_STRING(LIM_MLM_TSPEC_CNF); CASE_RETURN_STRING(LIM_MLM_TSPEC_CNF);
CASE_RETURN_STRING(LIM_MLM_SETKEYS_REQ);
CASE_RETURN_STRING(LIM_MLM_SETKEYS_CNF); CASE_RETURN_STRING(LIM_MLM_SETKEYS_CNF);
CASE_RETURN_STRING(LIM_MLM_LINK_TEST_STOP_REQ); CASE_RETURN_STRING(LIM_MLM_LINK_TEST_STOP_REQ);
CASE_RETURN_STRING(LIM_MLM_PURGE_STA_IND); CASE_RETURN_STRING(LIM_MLM_PURGE_STA_IND);

5
core/wma/inc/wma_types.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -129,9 +129,7 @@
#define WMA_ROAM_BLACLIST_MSG SIR_HAL_ROAM_BLACKLIST_MSG #define WMA_ROAM_BLACLIST_MSG SIR_HAL_ROAM_BLACKLIST_MSG
#define WMA_SEND_PEER_UNMAP_CONF SIR_HAL_SEND_PEER_UNMAP_CONF #define WMA_SEND_PEER_UNMAP_CONF SIR_HAL_SEND_PEER_UNMAP_CONF
#define WMA_SET_BSSKEY_REQ SIR_HAL_SET_BSSKEY_REQ
#define WMA_SET_BSSKEY_RSP SIR_HAL_SET_BSSKEY_RSP #define WMA_SET_BSSKEY_RSP SIR_HAL_SET_BSSKEY_RSP
#define WMA_SET_STAKEY_REQ SIR_HAL_SET_STAKEY_REQ
#define WMA_SET_STAKEY_RSP SIR_HAL_SET_STAKEY_RSP #define WMA_SET_STAKEY_RSP SIR_HAL_SET_STAKEY_RSP
#define WMA_UPDATE_EDCA_PROFILE_IND SIR_HAL_UPDATE_EDCA_PROFILE_IND #define WMA_UPDATE_EDCA_PROFILE_IND SIR_HAL_UPDATE_EDCA_PROFILE_IND
@@ -153,7 +151,6 @@
#define WMA_IBSS_STA_ADD SIR_HAL_IBSS_STA_ADD #define WMA_IBSS_STA_ADD SIR_HAL_IBSS_STA_ADD
#define WMA_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND SIR_HAL_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND #define WMA_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND SIR_HAL_TIMER_ADJUST_ADAPTIVE_THRESHOLD_IND
#define WMA_SET_LINK_STATE SIR_HAL_SET_LINK_STATE #define WMA_SET_LINK_STATE SIR_HAL_SET_LINK_STATE
#define WMA_SET_STA_BCASTKEY_REQ SIR_HAL_SET_STA_BCASTKEY_REQ
#define WMA_SET_STA_BCASTKEY_RSP SIR_HAL_SET_STA_BCASTKEY_RSP #define WMA_SET_STA_BCASTKEY_RSP SIR_HAL_SET_STA_BCASTKEY_RSP
#define WMA_ADD_TS_RSP SIR_HAL_ADD_TS_RSP #define WMA_ADD_TS_RSP SIR_HAL_ADD_TS_RSP
#define WMA_DPU_MIC_ERROR SIR_HAL_DPU_MIC_ERROR #define WMA_DPU_MIC_ERROR SIR_HAL_DPU_MIC_ERROR