A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-18 10:42:19 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge "qcacld-3.0: Remove legacy P2P codes in MAC" into wlan-cld3.driver.lnx.2.0-dev

Browse source
This commit is contained in:
CNSS_WLAN Service 2017-10-19 17:35:10 -07:00 • committed by Gerrit - the friendly Code Review server
commit 4bf2e0e624
13 changed files with 3 additions and 805 deletions
Download patch file Download diff file Expand all files Collapse all files

9
core/mac/inc/ani_global.h
View file

@ -48,7 +48,6 @@
#include "sme_rrm_internal.h"
#include "rrm_global.h"
#include "p2p_api.h"
#include <lim_ft_defs.h>
#include "wlan_objmgr_psoc_obj.h"
@ -318,8 +317,6 @@ typedef struct sLimTimers {
#ifdef FEATURE_WLAN_ESE
TX_TIMER gLimEseTsmTimer;
#endif
TX_TIMER gLimRemainOnChannelTimer;
TX_TIMER gLimPeriodicJoinProbeReqTimer;
TX_TIMER gLimDisassocAckTimer;
TX_TIMER gLimDeauthAckTimer;
@ -916,11 +913,6 @@ typedef struct sAniSirGlobal {
struct csr_roamstruct roam;
tRrmContext rrm;
#ifdef WLAN_FEATURE_CONCURRENT_P2P
tp2pContext p2pContext[MAX_NO_OF_P2P_SESSIONS];
#else
tp2pContext p2pContext;
#endif
uint8_t isCoalesingInIBSSAllowed;
@ -953,7 +945,6 @@ typedef struct sAniSirGlobal {
/* Based on INI parameter */
uint32_t dual_mac_feature_disable;
sir_mgmt_frame_ind_callback mgmt_frame_ind_cb;
sir_p2p_ack_ind_callback p2p_ack_ind_cb;
bool first_scan_done;
int8_t first_scan_bucket_threshold;
enum auth_tx_ack_status auth_ack_status;

17
core/mac/inc/sir_api.h
View file

@ -2881,21 +2881,6 @@ struct sir_sme_mgmt_frame_cb_req {
sir_mgmt_frame_ind_callback callback;
};
typedef void (*sir_p2p_ack_ind_callback)(uint32_t session_id,
bool tx_completion_status);
/**
* struct sir_p2p_ack_ind_cb_req - Register a p2p ack ind callback req
* @message_type: message id
* @length: msg length
* @callback: callback for p2p ack indication
*/
struct sir_sme_p2p_ack_ind_cb_req {
uint16_t message_type;
uint16_t length;
sir_p2p_ack_ind_callback callback;
};
#ifdef WLAN_FEATURE_11W
typedef struct sSirSmeUnprotMgmtFrameInd {
uint8_t sessionId;
@ -3731,13 +3716,11 @@ typedef struct sAniHandoffReq {
* shows the purpose of scan.
*
* @USER_SCAN_REQUESTOR_ID: Normal scan request from supplicant to HDD/SME.
* @ROC_SCAN_REQUESTOR_ID: Remain on channel usage for P2P action frames.
* @PREAUTH_REQUESTOR_ID: Used by LIM for preauth operation.
*
*/
#define USER_SCAN_REQUESTOR_ID 0xA000
#define ROC_SCAN_REQUESTOR_ID 0xB000
#define PREAUTH_REQUESTOR_ID 0xC000
typedef struct sSirScanOffloadReq {

8
core/mac/inc/wni_api.h
View file

@ -98,12 +98,6 @@ enum eWniMsgTypes {
eWNI_SME_UPPER_LAYER_ASSOC_CNF,
eWNI_SME_SESSION_UPDATE_PARAM,
eWNI_SME_CHNG_MCC_BEACON_INTERVAL,
eWNI_SME_REMAIN_ON_CHANNEL_REQ,
eWNI_SME_REMAIN_ON_CHN_RSP,
eWNI_SME_REMAIN_ON_CHN_RDY_IND,
eWNI_SME_SEND_ACTION_FRAME_IND,
eWNI_SME_ABORT_REMAIN_ON_CHAN_IND,
eWNI_SME_UPDATE_NOA,
eWNI_SME_CLEAR_DFS_CHANNEL_LIST,
eWNI_SME_GET_SNR_REQ,
@ -220,7 +214,6 @@ enum eWniMsgTypes {
eWNI_SME_DCC_STATS_EVENT,
eWNI_SME_SET_DUAL_MAC_CFG_REQ,
eWNI_SME_SET_DUAL_MAC_CFG_RESP,
eWNI_SME_ROC_CMD,
eWNI_SME_SET_THERMAL_LEVEL_IND,
eWNI_SME_SET_IE_REQ,
eWNI_SME_EXT_CHANGE_CHANNEL,
@ -244,7 +237,6 @@ enum eWniMsgTypes {
eWNI_SME_NDP_END_RSP,
eWNI_SME_NDP_PEER_DEPARTED_IND,
eWNI_SME_NDP_END_IND,
eWNI_SME_REGISTER_P2P_ACK_CB,
eWNI_SME_SEND_DISASSOC_FRAME,
eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE,
eWNI_SME_DEFAULT_SCAN_IE,

1
core/mac/src/include/sir_params.h
View file

@ -720,7 +720,6 @@ typedef struct sSirMbMsgP2p {
#define SIR_LIM_WPS_OVERLAP_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x1D)
#define SIR_LIM_FT_PREAUTH_RSP_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x1E)
#define SIR_LIM_REMAIN_CHN_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x1F)
#define SIR_LIM_INSERT_SINGLESHOT_NOA_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x20)
#define SIR_LIM_BEACON_GEN_IND (SIR_LIM_TIMEOUT_MSG_START + 0x23)

3
core/mac/src/pe/lim/lim_assoc_utils.h
View file

@ -45,6 +45,9 @@
#include "lim_types.h"
#define SIZE_OF_NOA_DESCRIPTOR 13
#define MAX_NOA_PERIOD_IN_MICROSECS 3000000
uint32_t lim_cmp_ssid(tSirMacSSid *, tpPESession);
uint8_t lim_compare_capabilities(tpAniSirGlobal,
tSirAssocReq *,

649
core/mac/src/pe/lim/lim_p2p.c
View file

@ -55,98 +55,10 @@
#include "lim_types.h"
#include "wlan_utility.h"
#define PROBE_RSP_IE_OFFSET 36
#define BSSID_OFFSET 16
#define ADDR2_OFFSET 10
#define ACTION_OFFSET 24
/* A DFS channel can be ACTIVE for max 9000 msec, from the last
received Beacon/Prpbe Resp. */
#define MAX_TIME_TO_BE_ACTIVE_CHANNEL 9000
void lim_exit_remain_on_channel(tpAniSirGlobal pMac, QDF_STATUS status,
uint32_t *data, tpPESession psessionEntry);
extern tSirRetStatus lim_set_link_state(tpAniSirGlobal pMac, tSirLinkState state,
tSirMacAddr bssId, tSirMacAddr selfMacAddr,
tpSetLinkStateCallback callback,
void *callbackArg);
/*------------------------------------------------------------------
*
* Below function is called if hdd requests a remain on channel.
*
*------------------------------------------------------------------*/
static QDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
tSirRemainOnChnReq *
pRemOnChnReq)
{
tSirScanOffloadReq *pScanOffloadReq;
struct scheduler_msg msg = {0};
tSirRetStatus rc = eSIR_SUCCESS;
pScanOffloadReq = qdf_mem_malloc(sizeof(tSirScanOffloadReq));
if (NULL == pScanOffloadReq) {
pe_err("Memory allocation failed for pScanOffloadReq");
return QDF_STATUS_E_NOMEM;
}
msg.type = WMA_START_SCAN_OFFLOAD_REQ;
msg.bodyptr = pScanOffloadReq;
msg.bodyval = 0;
qdf_copy_macaddr(&pScanOffloadReq->selfMacAddr,
&pRemOnChnReq->selfMacAddr);
qdf_set_macaddr_broadcast(&pScanOffloadReq->bssId);
pScanOffloadReq->scanType = eSIR_PASSIVE_SCAN;
pScanOffloadReq->p2pScanType = P2P_SCAN_TYPE_LISTEN;
pScanOffloadReq->minChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->maxChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->sessionId = pRemOnChnReq->sessionId;
pScanOffloadReq->channelList.numChannels = 1;
pScanOffloadReq->channelList.channelNumber[0] = pRemOnChnReq->chnNum;
pScanOffloadReq->scan_id = pRemOnChnReq->scan_id;
pScanOffloadReq->scan_requestor_id = ROC_SCAN_REQUESTOR_ID;
pe_debug("Req-rem-on-channel: duration: %u session: %hu chan: %hu",
pRemOnChnReq->duration, pRemOnChnReq->sessionId,
pRemOnChnReq->chnNum);
rc = wma_post_ctrl_msg(pMac, &msg);
if (rc != eSIR_SUCCESS) {
pe_err("wma_post_ctrl_msg() return failure: %u", rc);
qdf_mem_free(pScanOffloadReq);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/*------------------------------------------------------------------
*
* Remain on channel req handler. Initiate the INIT_SCAN, CHN_CHANGE
* and SET_LINK Request from SME, chnNum and duration to remain on channel.
*
*------------------------------------------------------------------*/
int lim_process_remain_on_chnl_req(tpAniSirGlobal pMac, uint32_t *pMsg)
{
tSirRemainOnChnReq *msgbuff = (tSirRemainOnChnReq *) pMsg;
QDF_STATUS status;
pMac->lim.gpLimRemainOnChanReq = msgbuff;
status = lim_send_hal_req_remain_on_chan_offload(pMac, msgbuff);
if (status != QDF_STATUS_SUCCESS) {
/* Post the meessage to Sme */
lim_send_sme_rsp(pMac, eWNI_SME_REMAIN_ON_CHN_RSP,
eSIR_SME_HAL_SEND_MESSAGE_FAIL,
msgbuff->sessionId,
msgbuff->scan_id);
qdf_mem_free(pMac->lim.gpLimRemainOnChanReq);
pMac->lim.gpLimRemainOnChanReq = NULL;
}
return false;
}
/*------------------------------------------------------------------
*
* lim Insert NOA timer timeout callback - when timer fires, deactivate it and send
@ -209,162 +121,6 @@ void lim_convert_active_channel_to_passive_channel(tpAniSirGlobal pMac)
}
/**
* lim_process_remain_on_chn_timeout() - ROC timeout handler
*
* @mac_ctx: MAC context
*
* limchannelchange callback, on success channel change, set the
* link_state to LISTEN
*
* Return: NULL
*/
void lim_process_remain_on_chn_timeout(tpAniSirGlobal mac_ctx)
{
tpPESession session;
tSirMacAddr null_bssid = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
TX_TIMER *roc_timer;
roc_timer = &mac_ctx->lim.limTimers.gLimRemainOnChannelTimer;
/*
* Timer might get extended while Sending Action Frame
* In that case don't process Channel Timeout
*/
if (tx_timer_running(roc_timer)) {
pe_err("already timer is running and not processing ");
return;
}
lim_deactivate_and_change_timer(mac_ctx, eLIM_REMAIN_CHN_TIMER);
if (NULL == mac_ctx->lim.gpLimRemainOnChanReq) {
pe_err("No Remain on channel pending");
return;
}
/* get the previous valid LINK state */
if (lim_set_link_state(mac_ctx, eSIR_LINK_IDLE_STATE, null_bssid,
mac_ctx->lim.gSelfMacAddr, NULL, NULL) != eSIR_SUCCESS) {
pe_err("Unable to change link state");
return;
}
if (mac_ctx->lim.gLimMlmState != eLIM_MLM_P2P_LISTEN_STATE) {
lim_remain_on_chn_rsp(mac_ctx, QDF_STATUS_SUCCESS, NULL);
} else {
session = pe_find_session_by_session_id(mac_ctx,
roc_timer->sessionId);
/* get the session */
if (session == NULL) {
pe_err("Session Does not exist sessionID: %d",
roc_timer->sessionId);
goto error;
}
lim_exit_remain_on_channel(mac_ctx, QDF_STATUS_SUCCESS, NULL,
session);
return;
error:
lim_remain_on_chn_rsp(mac_ctx, QDF_STATUS_E_FAILURE, NULL);
}
return;
}
/*------------------------------------------------------------------
*
* limchannelchange callback, on success channel change, set the link_state
* to LISTEN
*
*------------------------------------------------------------------*/
void lim_exit_remain_on_channel(tpAniSirGlobal pMac, QDF_STATUS status,
uint32_t *data, tpPESession psessionEntry)
{
if (status != QDF_STATUS_SUCCESS) {
pe_err("Remain on Channel Failed");
goto error;
}
/* Set the resume channel to Any valid channel (invalid). */
/* This will instruct HAL to set it to any previous valid channel. */
pe_set_resume_channel(pMac, 0, 0);
lim_remain_on_chn_rsp(pMac, QDF_STATUS_SUCCESS, NULL);
return;
error:
lim_remain_on_chn_rsp(pMac, QDF_STATUS_E_FAILURE, NULL);
return;
}
/*------------------------------------------------------------------
*
* Send remain on channel respone: Success/ Failure
*
*------------------------------------------------------------------*/
void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, QDF_STATUS status, uint32_t *data)
{
tpPESession psessionEntry;
uint8_t sessionId;
tSirRemainOnChnReq *MsgRemainonChannel = pMac->lim.gpLimRemainOnChanReq;
tSirMacAddr nullBssid = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
if (NULL == MsgRemainonChannel) {
pe_err("%s: No Pointer for Remain on Channel Req", __func__);
return;
}
/* Incase of the Remain on Channel Failure Case */
/* Cleanup Everything */
if (QDF_STATUS_E_FAILURE == status) {
/* Deactivate Remain on Channel Timer */
lim_deactivate_and_change_timer(pMac, eLIM_REMAIN_CHN_TIMER);
/* Set the Link State to Idle */
/* get the previous valid LINK state */
if (lim_set_link_state(pMac, eSIR_LINK_IDLE_STATE, nullBssid,
pMac->lim.gSelfMacAddr, NULL,
NULL) != eSIR_SUCCESS) {
pe_err("Unable to change link state");
}
pMac->lim.gLimSystemInScanLearnMode = 0;
pMac->lim.gLimHalScanState = eLIM_HAL_IDLE_SCAN_STATE;
SET_LIM_PROCESS_DEFD_MESGS(pMac, true);
}
/* delete the session */
psessionEntry = pe_find_session_by_bssid(pMac,
MsgRemainonChannel->
selfMacAddr.bytes,
&sessionId);
if (psessionEntry != NULL) {
if (LIM_IS_P2P_DEVICE_ROLE(psessionEntry)) {
pe_delete_session(pMac, psessionEntry);
}
}
/* Post the meessage to Sme */
if (QDF_IS_STATUS_SUCCESS(status))
lim_send_sme_rsp(pMac, eWNI_SME_REMAIN_ON_CHN_RSP,
eSIR_SME_SUCCESS,
MsgRemainonChannel->sessionId,
0);
else
lim_send_sme_rsp(pMac, eWNI_SME_REMAIN_ON_CHN_RSP,
eSIR_SME_REFUSED,
MsgRemainonChannel->sessionId,
0);
qdf_mem_free(pMac->lim.gpLimRemainOnChanReq);
pMac->lim.gpLimRemainOnChanReq = NULL;
pMac->lim.gLimMlmState = pMac->lim.gLimPrevMlmState;
/* If remain on channel timer expired and action frame is pending then
* indicaiton confirmation with status failure */
if (pMac->lim.mgmtFrameSessionId != 0xff)
lim_p2p_action_cnf(pMac, NULL, false, NULL);
return;
}
/*------------------------------------------------------------------
*
* Indicate the Mgmt Frame received to SME to HDD callback
@ -403,408 +159,3 @@ void lim_send_sme_mgmt_frame_ind(tpAniSirGlobal pMac, uint8_t frameType,
qdf_mem_free(pSirSmeMgmtFrame);
return;
}
QDF_STATUS lim_p2p_action_cnf(void *context, qdf_nbuf_t buf,
uint32_t tx_status, void *params)
{
QDF_STATUS status;
uint32_t mgmt_frame_sessionId;
bool tx_complete_ack = (tx_status) ? true : false;
tpAniSirGlobal pMac = (tpAniSirGlobal)context;
status = pe_acquire_global_lock(&pMac->lim);
if (QDF_IS_STATUS_SUCCESS(status)) {
mgmt_frame_sessionId = pMac->lim.mgmtFrameSessionId;
pMac->lim.mgmtFrameSessionId = 0xff;
pe_release_global_lock(&pMac->lim);
if (mgmt_frame_sessionId != 0xff) {
/*
* The session entry might be invalid(0xff)
* action confirmation received after
* remain on channel timer expired.
*/
pe_debug("mgmt_frame_sessionId: %d",
mgmt_frame_sessionId);
if (pMac->p2p_ack_ind_cb)
pMac->p2p_ack_ind_cb(mgmt_frame_sessionId,
tx_complete_ack);
}
}
if (buf)
qdf_nbuf_free(buf);
return status;
}
/**
* lim_tx_action_frame() - Handles action frame transmission request
* @mac_ctx: Pointer to mac context
* @mb_msg: message sent from SME
* @msg_len: Message length
* @packet: network buffer for TX
* @frame: frame buffer
*
* This function processes the action frame transmission request and
* posts message to WMA.
*
* Return: NULL
*/
static void lim_tx_action_frame(tpAniSirGlobal mac_ctx,
tSirMbMsgP2p *mb_msg, uint32_t msg_len, void *packet, uint8_t *frame)
{
uint8_t tx_flag = 0;
tpSirMacFrameCtl fc = (tpSirMacFrameCtl) mb_msg->data;
QDF_STATUS qdf_status;
uint8_t sme_session_id = 0;
uint16_t channel_freq;
sme_session_id = mb_msg->sessionId;
channel_freq = mb_msg->channel_freq;
/*
* Use BD rate 2 for all P2P related frames. As these frames
* need to go at OFDM rates. And BD rate2 we configured at 6Mbps.
*/
tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
mac_ctx->lim.mgmtFrameSessionId = sme_session_id;
if ((SIR_MAC_MGMT_PROBE_RSP == fc->subType) ||
(mb_msg->noack)) {
qdf_status = wma_tx_frame(mac_ctx, packet, (uint16_t) msg_len,
TXRX_FRM_802_11_MGMT,
ANI_TXDIR_TODS, 7, lim_tx_complete,
frame, tx_flag, sme_session_id,
channel_freq, RATEID_DEFAULT);
if (!mb_msg->noack)
lim_p2p_action_cnf(mac_ctx, packet,
(QDF_IS_STATUS_SUCCESS(qdf_status)) ?
true : false, NULL);
mac_ctx->lim.mgmtFrameSessionId = 0xff;
} else {
qdf_status =
wma_tx_frameWithTxComplete(mac_ctx, packet,
(uint16_t) msg_len,
TXRX_FRM_802_11_MGMT,
ANI_TXDIR_TODS, 7, lim_tx_complete,
frame, lim_p2p_action_cnf, tx_flag,
sme_session_id, false,
channel_freq, RATEID_DEFAULT);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
pe_err("couldn't send action frame");
lim_p2p_action_cnf(mac_ctx, packet, false, NULL);
mac_ctx->lim.mgmtFrameSessionId = 0xff;
} else {
mac_ctx->lim.mgmtFrameSessionId = mb_msg->sessionId;
pe_debug("lim.actionFrameSessionId: %u",
mac_ctx->lim.mgmtFrameSessionId);
}
}
return;
}
#ifdef WLAN_FEATURE_11W
static void lim_check_rmf_and_set_protected(tpAniSirGlobal mac_ctx,
tSirMbMsgP2p *mb_msg, uint8_t *frame)
{
uint8_t session_id = 0;
tpPESession session_entry;
tpSirMacMgmtHdr mac_hdr;
tpSirMacActionFrameHdr action_hdr;
tpSirMacFrameCtl fc = (tpSirMacFrameCtl) mb_msg->data;
action_hdr = (tpSirMacActionFrameHdr)
(frame + sizeof(tSirMacMgmtHdr));
mac_hdr = (tpSirMacMgmtHdr) frame;
session_entry = pe_find_session_by_bssid(mac_ctx,
(uint8_t *) mb_msg->data + BSSID_OFFSET,
&session_id);
/*
* Check for session corresponding to ADDR2 as supplicant
* is filling ADDR2 with BSSID
*/
if (!session_entry) {
session_entry = pe_find_session_by_bssid(mac_ctx,
(uint8_t *) mb_msg->data + ADDR2_OFFSET,
&session_id);
}
/*
* Setting Protected bit only for Robust Action Frames
* This has to be based on the current Connection with the
* station. lim_set_protected_bit API will set the protected
* bit if connection is PMF
*/
if (session_entry && (SIR_MAC_MGMT_ACTION == fc->subType) &&
session_entry->limRmfEnabled &&
(!lim_is_group_addr(mac_hdr->da)) &&
lim_is_robust_mgmt_action_frame(action_hdr->category))
lim_set_protected_bit(mac_ctx, session_entry,
mac_hdr->da, mac_hdr);
}
#else
static inline void lim_check_rmf_and_set_protected(tpAniSirGlobal mac_ctx,
tSirMbMsgP2p *mb_msg, uint8_t *frame)
{
}
#endif
/* function to parse IEs withing P2P IE */
static const uint8_t *lim_parse_p2p_ie(const uint8_t *ie, int len, uint8_t eid)
{
int left = len;
const uint8_t *ptr = ie;
uint8_t elem_id, size_of_len_field = 0;
uint16_t elem_len;
/* IE should be at least len(eid + len) = 3 */
while (left >= 3) {
elem_id = ptr[0];
if (elem_id == SIR_P2P_NOA_ATTR) {
elem_len = ((uint16_t) ptr[1]) | (ptr[2] << 8);
size_of_len_field = 2;
} else {
elem_len = ptr[1];
size_of_len_field = 1;
}
left -= (size_of_len_field + 1);
if (elem_len > left) {
pe_err("Invalid IEs eid: %d elem_len: %d left: %d",
eid, elem_len, left);
return NULL;
}
if (elem_id == eid)
return ptr;
left -= elem_len;
ptr += (elem_len + (size_of_len_field + 1));
}
return NULL;
}
/**
* lim_send_p2p_action_frame() - Process action frame request
* @mac_ctx: Pointer to mac context
* @msg: message sent from SME
*
* This function processes the action frame request sent from the
* SME and generates the ACTION frame.
*
* Return: NULL
*/
void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
tSirMbMsgP2p *mb_msg = (tSirMbMsgP2p *) msg->bodyptr;
uint32_t msg_len;
uint8_t *frame;
void *packet;
QDF_STATUS qdf_status;
tpSirMacFrameCtl fc = (tpSirMacFrameCtl) mb_msg->data;
uint8_t noa_len = 0;
uint8_t noa_stream[SIR_MAX_NOA_ATTR_LEN + (2 * SIR_P2P_IE_HEADER_LEN)];
uint8_t orig_len = 0;
uint8_t *p2p_ie = NULL;
tpPESession session_entry = NULL;
const uint8_t *presence_noa_attr = NULL;
uint8_t *tmp_p2p_ie = NULL;
uint16_t remain_len = 0;
uint8_t sme_session_id = 0;
msg_len = mb_msg->msgLen - sizeof(tSirMbMsgP2p);
pe_debug("sending fc->type: %d fc->subType: %d",
fc->type, fc->subType);
if ((!mac_ctx->lim.gpLimRemainOnChanReq) && (0 != mb_msg->wait)) {
pe_err("RemainOnChannel is not running");
mac_ctx->lim.mgmtFrameSessionId = mb_msg->sessionId;
lim_p2p_action_cnf(mac_ctx, NULL, false, NULL);
mac_ctx->lim.mgmtFrameSessionId = 0xff;
return;
}
sme_session_id = mb_msg->sessionId;
if ((SIR_MAC_MGMT_FRAME == fc->type) &&
(SIR_MAC_MGMT_PROBE_RSP == fc->subType)) {
/* get proper offset for Probe RSP */
p2p_ie = (uint8_t *)limGetP2pIEPtr(mac_ctx,
(uint8_t *) mb_msg->data +
PROBE_RSP_IE_OFFSET,
msg_len - PROBE_RSP_IE_OFFSET);
while ((NULL != p2p_ie)
&& (SIR_MAC_MAX_IE_LENGTH == p2p_ie[1])) {
remain_len =
msg_len - (p2p_ie -
(uint8_t *) mb_msg->data);
if (remain_len > 2) {
tmp_p2p_ie = (uint8_t *)limGetP2pIEPtr(mac_ctx,
p2p_ie + SIR_MAC_MAX_IE_LENGTH + 2,
remain_len);
}
if (tmp_p2p_ie) {
p2p_ie = (uint8_t *)tmp_p2p_ie;
tmp_p2p_ie = NULL;
} else {
break;
}
} /* end of while */
} else if ((SIR_MAC_MGMT_FRAME == fc->type) &&
(SIR_MAC_MGMT_ACTION == fc->subType) &&
(SIR_MAC_ACTION_VENDOR_SPECIFIC_CATEGORY ==
*((uint8_t *) mb_msg->data + ACTION_OFFSET))) {
tpSirMacP2PActionFrameHdr action_hdr =
(tpSirMacP2PActionFrameHdr) ((uint8_t *)
mb_msg->data + ACTION_OFFSET);
if ((!qdf_mem_cmp(action_hdr->Oui, SIR_MAC_P2P_OUI,
SIR_MAC_P2P_OUI_SIZE)) &&
(SIR_MAC_ACTION_P2P_SUBTYPE_PRESENCE_RSP ==
action_hdr->OuiSubType)) {
/* In case of Presence RSP response */
p2p_ie = (uint8_t *)limGetP2pIEPtr(mac_ctx,
(uint8_t *)mb_msg->data +
ACTION_OFFSET +
sizeof(tSirMacP2PActionFrameHdr),
(msg_len - ACTION_OFFSET
- sizeof(tSirMacP2PActionFrameHdr)));
if (NULL != p2p_ie) {
/* extract the presence of NoA attribute inside
* P2P IE */
presence_noa_attr = lim_parse_p2p_ie(
p2p_ie + SIR_P2P_IE_HEADER_LEN,
p2p_ie[1], SIR_P2P_NOA_ATTR);
}
}
}
if ((SIR_MAC_MGMT_FRAME == fc->type) &&
(SIR_MAC_MGMT_PROBE_RSP == fc->subType ||
SIR_MAC_MGMT_ACTION == fc->subType) && p2p_ie != NULL) {
/* get NoA attribute stream P2P IE */
noa_len =
lim_get_noa_attr_stream(mac_ctx, noa_stream,
session_entry);
/* need to append NoA attribute in P2P IE */
if (noa_len > 0) {
orig_len = p2p_ie[1];
/* if Presence Rsp has NoAttr */
if (presence_noa_attr) {
uint16_t noa_len =
presence_noa_attr[1] |
(presence_noa_attr[2] << 8);
/*One byte for attribute, 2bytes for length */
orig_len -= (noa_len + 1 + 2);
/* remove those bytes to copy */
msg_len -= (noa_len + 1 + 2);
/* remove NoA from original Len */
p2p_ie[1] = orig_len;
}
if ((p2p_ie[1] + (uint16_t) noa_len) >
SIR_MAC_MAX_IE_LENGTH) {
/*
* Form the new NoA Byte array in multiple
* P2P IEs
*/
noa_len =
lim_get_noa_attr_stream_in_mult_p2p_ies
(mac_ctx, noa_stream, noa_len,
((p2p_ie[1] + (uint16_t)noa_len)
- SIR_MAC_MAX_IE_LENGTH));
p2p_ie[1] = SIR_MAC_MAX_IE_LENGTH;
} else {
/* increment the length of P2P IE */
p2p_ie[1] += noa_len;
}
msg_len += noa_len;
pe_debug("noa_len: %d orig_len: %d p2p_ie: %pK msg_len: %d nBytesToCopy: %zu ",
noa_len, orig_len, p2p_ie, msg_len,
((p2p_ie + orig_len + 2) -
(uint8_t *) mb_msg->data));
}
}
if (SIR_MAC_MGMT_PROBE_RSP == fc->subType)
lim_set_ht_caps(mac_ctx, session_entry,
(uint8_t *) mb_msg->data + PROBE_RSP_IE_OFFSET,
msg_len - PROBE_RSP_IE_OFFSET);
/* Ok-- try to allocate some memory: */
qdf_status = cds_packet_alloc((uint16_t) msg_len, (void **)&frame,
(void **)&packet);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
pe_err("Failed to allocate: %d bytes for a Probe Request",
msg_len);
return;
}
/* Paranoia: */
qdf_mem_set(frame, msg_len, 0);
/*
* Add sequence number to action frames
* Frames are handed over in .11 format by supplicant already
*/
lim_populate_p2p_mac_header(mac_ctx, (uint8_t *) mb_msg->data);
if ((noa_len > 0)
&& (noa_len < (SIR_MAX_NOA_ATTR_LEN + SIR_P2P_IE_HEADER_LEN))) {
/* Add 2 bytes for length and Arribute field */
uint32_t nBytesToCopy = ((p2p_ie + orig_len + 2) -
(uint8_t *) mb_msg->data);
qdf_mem_copy(frame, mb_msg->data, nBytesToCopy);
qdf_mem_copy((frame + nBytesToCopy), noa_stream, noa_len);
qdf_mem_copy((frame + nBytesToCopy + noa_len),
mb_msg->data + nBytesToCopy,
msg_len - nBytesToCopy - noa_len);
} else {
qdf_mem_copy(frame, mb_msg->data, msg_len);
}
lim_check_rmf_and_set_protected(mac_ctx, mb_msg, frame);
lim_tx_action_frame(mac_ctx, mb_msg, msg_len, packet, frame);
return;
}
/* Power Save Related Functions */
tSirRetStatus __lim_process_sme_no_a_update(tpAniSirGlobal pMac, uint32_t *pMsgBuf)
{
tpP2pPsConfig pNoA;
tpP2pPsParams pMsgNoA;
struct scheduler_msg msg = {0};
pNoA = (tpP2pPsConfig) pMsgBuf;
pMsgNoA = qdf_mem_malloc(sizeof(tP2pPsConfig));
if (NULL == pMsgNoA) {
pe_err("Unable to allocate memory during NoA Update");
return eSIR_MEM_ALLOC_FAILED;
}
pMsgNoA->opp_ps = pNoA->opp_ps;
pMsgNoA->ctWindow = pNoA->ctWindow;
pMsgNoA->duration = pNoA->duration;
pMsgNoA->interval = pNoA->interval;
pMsgNoA->count = pNoA->count;
pMsgNoA->single_noa_duration = pNoA->single_noa_duration;
pMsgNoA->psSelection = pNoA->psSelection;
pMsgNoA->sessionId = pNoA->sessionid;
msg.type = WMA_SET_P2P_GO_NOA_REQ;
msg.reserved = 0;
msg.bodyptr = pMsgNoA;
msg.bodyval = 0;
if (eSIR_SUCCESS != wma_post_ctrl_msg(pMac, &msg)) {
pe_err("halPostMsgApi failed");
return eSIR_FAILURE;
}
return eSIR_SUCCESS;
} /*** end __limProcessSmeGoNegReq() ***/

17
core/mac/src/pe/lim/lim_process_message_queue.c
View file

@ -1270,7 +1270,6 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
tSirTdlsInd *tdls_ind = NULL;
tpDphHashNode sta_ds = NULL;
#endif
tSirMbMsgP2p *p2p_msg = NULL;
tSirSetActiveModeSetBncFilterReq *bcn_filter_req = NULL;
if (ANI_DRIVER_TYPE(mac_ctx) == QDF_DRIVER_TYPE_MFG) {
@ -1398,7 +1397,6 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
}
break;
case eWNI_SME_SCAN_REQ:
case eWNI_SME_REMAIN_ON_CHANNEL_REQ:
case eWNI_SME_DISASSOC_REQ:
case eWNI_SME_DEAUTH_REQ:
#ifdef FEATURE_WLAN_TDLS
@ -1458,7 +1456,6 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
case eWNI_SME_FT_PRE_AUTH_REQ:
case eWNI_SME_FT_AGGR_QOS_REQ:
case eWNI_SME_REGISTER_MGMT_FRAME_REQ:
case eWNI_SME_UPDATE_NOA:
case eWNI_SME_CLEAR_DFS_CHANNEL_LIST:
case eWNI_SME_GET_STATISTICS_REQ:
#ifdef FEATURE_WLAN_ESE
@ -1470,22 +1467,9 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
case eWNI_SME_NDP_INITIATOR_REQ:
case eWNI_SME_NDP_RESPONDER_REQ:
case eWNI_SME_NDP_END_REQ:
case eWNI_SME_REGISTER_P2P_ACK_CB:
/* These messages are from HDD.No need to respond to HDD */
lim_process_normal_hdd_msg(mac_ctx, msg, false);
break;
case eWNI_SME_SEND_ACTION_FRAME_IND:
lim_send_p2p_action_frame(mac_ctx, msg);
qdf_mem_free(msg->bodyptr);
msg->bodyptr = NULL;
break;
case eWNI_SME_ABORT_REMAIN_ON_CHAN_IND:
p2p_msg = (tSirMbMsgP2p *) msg->bodyptr;
lim_process_abort_scan_ind(mac_ctx, p2p_msg->sessionId,
p2p_msg->scan_id, ROC_SCAN_REQUESTOR_ID);
qdf_mem_free(msg->bodyptr);
msg->bodyptr = NULL;
break;
case eWNI_SME_MON_INIT_SESSION:
lim_mon_init_session(mac_ctx, msg->bodyptr);
qdf_mem_free(msg->bodyptr);
@ -1627,7 +1611,6 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
case SIR_LIM_ASSOC_FAIL_TIMEOUT:
case SIR_LIM_REASSOC_FAIL_TIMEOUT:
case SIR_LIM_FT_PREAUTH_RSP_TIMEOUT:
case SIR_LIM_REMAIN_CHN_TIMEOUT:
case SIR_LIM_INSERT_SINGLESHOT_NOA_TIMEOUT:
case SIR_LIM_DISASSOC_ACK_TIMEOUT:
case SIR_LIM_DEAUTH_ACK_TIMEOUT:

3
core/mac/src/pe/lim/lim_process_mlm_req_messages.c
View file

@ -133,9 +133,6 @@ void lim_process_mlm_req_messages(tpAniSirGlobal mac_ctx,
case SIR_LIM_FT_PREAUTH_RSP_TIMEOUT:
lim_process_ft_preauth_rsp_timeout(mac_ctx);
break;
case SIR_LIM_REMAIN_CHN_TIMEOUT:
lim_process_remain_on_chn_timeout(mac_ctx);
break;
case SIR_LIM_INSERT_SINGLESHOT_NOA_TIMEOUT:
lim_process_insert_single_shot_noa_timeout(mac_ctx);
break;

49
core/mac/src/pe/lim/lim_process_sme_req_messages.c
View file

@ -4444,8 +4444,6 @@ static void __lim_deregister_deferred_sme_req_after_noa_start(tpAniSirGlobal pMa
*/
void lim_process_regd_defd_sme_req_after_noa_start(tpAniSirGlobal mac_ctx)
{
bool buf_consumed = true;
pe_debug("Process defd sme req %d",
mac_ctx->lim.gDeferMsgTypeForNOA);
@ -4460,17 +4458,6 @@ void lim_process_regd_defd_sme_req_after_noa_start(tpAniSirGlobal mac_ctx)
__lim_process_sme_scan_req(mac_ctx,
mac_ctx->lim.gpDefdSmeMsgForNOA);
break;
case eWNI_SME_REMAIN_ON_CHANNEL_REQ:
buf_consumed = lim_process_remain_on_chnl_req(mac_ctx,
mac_ctx->lim.gpDefdSmeMsgForNOA);
/*
* lim_process_remain_on_chnl_req doesnt want us to free
* the buffer since it is freed in lim_remain_on_chn_rsp.
* this change is to avoid "double free"
*/
if (false == buf_consumed)
mac_ctx->lim.gpDefdSmeMsgForNOA = NULL;
break;
case eWNI_SME_JOIN_REQ:
__lim_process_sme_join_req(mac_ctx,
mac_ctx->lim.gpDefdSmeMsgForNOA);
@ -4507,32 +4494,6 @@ __lim_process_sme_reset_ap_caps_change(tpAniSirGlobal pMac, uint32_t *pMsgBuf)
return;
}
/**
* lim_register_p2p_ack_ind_cb() - Save the p2p ack indication callback.
* @mac_ctx: Mac pointer
* @msg_buf: Msg pointer containing the callback
*
* This function is used to save the p2p ack indication callback in PE.
*
* Return: None
*/
static void lim_register_p2p_ack_ind_cb(tpAniSirGlobal mac_ctx,
uint32_t *msg_buf)
{
struct sir_sme_p2p_ack_ind_cb_req *sme_req =
(struct sir_sme_p2p_ack_ind_cb_req *)msg_buf;
if (NULL == msg_buf) {
pe_err("msg_buf is null");
return;
}
if (sme_req->callback)
mac_ctx->p2p_ack_ind_cb =
sme_req->callback;
else
pe_err("sme_req->callback is null");
}
/**
* lim_register_mgmt_frame_ind_cb() - Save the Management frame
* indication callback in PE.
@ -4930,13 +4891,6 @@ bool lim_process_sme_req_messages(tpAniSirGlobal pMac,
__lim_process_sme_scan_req(pMac, pMsgBuf);
break;
case eWNI_SME_REMAIN_ON_CHANNEL_REQ:
bufConsumed = lim_process_remain_on_chnl_req(pMac, pMsgBuf);
break;
case eWNI_SME_UPDATE_NOA:
__lim_process_sme_no_a_update(pMac, pMsgBuf);
break;
case eWNI_SME_CLEAR_DFS_CHANNEL_LIST:
__lim_process_clear_dfs_channel_list(pMac, pMsg);
break;
@ -5115,9 +5069,6 @@ bool lim_process_sme_req_messages(tpAniSirGlobal pMac,
case eWNI_SME_NDP_RESPONDER_REQ:
lim_handle_ndp_request_message(pMac, pMsg);
break;
case eWNI_SME_REGISTER_P2P_ACK_CB:
lim_register_p2p_ack_ind_cb(pMac, pMsgBuf);
break;
case eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE:
lim_process_sme_update_access_policy_vendor_ie(pMac, pMsgBuf);
break;

35
core/mac/src/pe/lim/lim_timer_utils.c
View file

@ -309,15 +309,6 @@ uint32_t lim_create_timers(tpAniSirGlobal pMac)
pe_err("Cannot create update OLBC cache tmr");
goto err_timer;
}
cfgValue = 1000;
cfgValue = SYS_MS_TO_TICKS(cfgValue);
if (tx_timer_create(pMac, &pMac->lim.limTimers.gLimRemainOnChannelTimer,
"FT PREAUTH RSP TIMEOUT",
lim_timer_handler, SIR_LIM_REMAIN_CHN_TIMEOUT,
cfgValue, 0, TX_NO_ACTIVATE) != TX_SUCCESS) {
pe_err("could not create Join failure timer");
goto err_timer;
}
cfgValue = 1000;
cfgValue = SYS_MS_TO_TICKS(cfgValue);
@ -371,7 +362,6 @@ err_timer:
lim_delete_timers_host_roam(pMac);
tx_timer_delete(&pMac->lim.limTimers.gLimDeauthAckTimer);
tx_timer_delete(&pMac->lim.limTimers.gLimDisassocAckTimer);
tx_timer_delete(&pMac->lim.limTimers.gLimRemainOnChannelTimer);
tx_timer_delete(&pMac->lim.limTimers.gLimUpdateOlbcCacheTimer);
while (((int32_t)-- i) >= 0) {
tx_timer_delete(&pMac->lim.limTimers.gpLimCnfWaitTimer[i]);
@ -838,31 +828,6 @@ void lim_deactivate_and_change_timer(tpAniSirGlobal pMac, uint32_t timerId)
case eLIM_LEARN_DURATION_TIMER:
break;
case eLIM_REMAIN_CHN_TIMER:
if (tx_timer_deactivate
(&pMac->lim.limTimers.gLimRemainOnChannelTimer) !=
TX_SUCCESS) {
/**
** Could not deactivate Join Failure
** timer. Log error.
**/
pe_err("Unable to deactivate Remain on Chn timer");
return;
}
val = 1000;
val = SYS_MS_TO_TICKS(val);
if (tx_timer_change
(&pMac->lim.limTimers.gLimRemainOnChannelTimer, val,
0) != TX_SUCCESS) {
/**
* Could not change Join Failure
* timer. Log error.
*/
pe_err("Unable to change timer");
return;
}
break;
case eLIM_CONVERT_ACTIVE_CHANNEL_TO_PASSIVE:
if (tx_timer_deactivate
(&pMac->lim.limTimers.gLimActiveToPassiveChannelTimer) !=

1
core/mac/src/pe/lim/lim_types.h
View file

@ -873,7 +873,6 @@ void lim_process_remain_on_chn_timeout(tpAniSirGlobal pMac);
void lim_process_insert_single_shot_noa_timeout(tpAniSirGlobal pMac);
void lim_convert_active_channel_to_passive_channel(tpAniSirGlobal pMac);
void lim_send_p2p_action_frame(tpAniSirGlobal pMac, struct scheduler_msg *pMsg);
tSirRetStatus __lim_process_sme_no_a_update(tpAniSirGlobal pMac, uint32_t *pMsgBuf);
void lim_process_regd_defd_sme_req_after_noa_start(tpAniSirGlobal pMac);
void lim_process_disassoc_ack_timeout(tpAniSirGlobal pMac);

6
core/mac/src/pe/lim/lim_utils.c
View file

@ -602,9 +602,6 @@ void lim_deactivate_timers(tpAniSirGlobal mac_ctx)
tx_timer_deactivate(&lim_timer->gLimUpdateOlbcCacheTimer);
tx_timer_deactivate(&lim_timer->gLimPreAuthClnupTimer);
/* Deactivate remain on channel timer */
tx_timer_deactivate(&lim_timer->gLimRemainOnChannelTimer);
tx_timer_deactivate(&lim_timer->gLimDisassocAckTimer);
tx_timer_deactivate(&lim_timer->gLimDeauthAckTimer);
@ -686,9 +683,6 @@ void lim_cleanup_mlm(tpAniSirGlobal mac_ctx)
tx_timer_delete(&lim_timer->gLimUpdateOlbcCacheTimer);
tx_timer_delete(&lim_timer->gLimPreAuthClnupTimer);
/* Delete remain on channel timer */
tx_timer_delete(&lim_timer->gLimRemainOnChannelTimer);
tx_timer_delete(&lim_timer->gLimDisassocAckTimer);
tx_timer_delete(&lim_timer->gLimDeauthAckTimer);

10
core/mac/src/sys/legacy/src/utils/src/mac_trace.c
View file

@ -274,12 +274,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_UPPER_LAYER_ASSOC_CNF);
CASE_RETURN_STRING(eWNI_SME_SESSION_UPDATE_PARAM);
CASE_RETURN_STRING(eWNI_SME_CHNG_MCC_BEACON_INTERVAL);
CASE_RETURN_STRING(eWNI_SME_REMAIN_ON_CHANNEL_REQ);
CASE_RETURN_STRING(eWNI_SME_REMAIN_ON_CHN_RSP);
CASE_RETURN_STRING(eWNI_SME_REMAIN_ON_CHN_RDY_IND);
CASE_RETURN_STRING(eWNI_SME_SEND_ACTION_FRAME_IND);
CASE_RETURN_STRING(eWNI_SME_ABORT_REMAIN_ON_CHAN_IND);
CASE_RETURN_STRING(eWNI_SME_UPDATE_NOA);
CASE_RETURN_STRING(eWNI_SME_CLEAR_DFS_CHANNEL_LIST);
CASE_RETURN_STRING(eWNI_SME_GET_SNR_REQ);
CASE_RETURN_STRING(eWNI_SME_LINK_STATUS_IND);
@ -381,7 +375,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_DCC_STATS_EVENT);
CASE_RETURN_STRING(eWNI_SME_SET_DUAL_MAC_CFG_REQ);
CASE_RETURN_STRING(eWNI_SME_SET_DUAL_MAC_CFG_RESP);
CASE_RETURN_STRING(eWNI_SME_ROC_CMD);
CASE_RETURN_STRING(eWNI_SME_SET_IE_REQ);
CASE_RETURN_STRING(eWNI_SME_FW_DUMP_IND);
CASE_RETURN_STRING(eWNI_SME_EXT_CHANGE_CHANNEL);
@ -403,7 +396,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_NDP_END_RSP);
CASE_RETURN_STRING(eWNI_SME_NDP_PEER_DEPARTED_IND);
CASE_RETURN_STRING(eWNI_SME_NDP_END_IND);
CASE_RETURN_STRING(eWNI_SME_REGISTER_P2P_ACK_CB);
CASE_RETURN_STRING(eWNI_SME_SEND_DISASSOC_FRAME);
CASE_RETURN_STRING(eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE);
CASE_RETURN_STRING(eWNI_SME_DEFAULT_SCAN_IE);
@ -510,7 +502,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
#endif /* WLAN_NS_OFFLOAD */
CASE_RETURN_STRING(WMA_ADD_STA_SELF_REQ);
CASE_RETURN_STRING(WMA_DEL_STA_SELF_REQ);
CASE_RETURN_STRING(WMA_SET_P2P_GO_NOA_REQ);
CASE_RETURN_STRING(WMA_WLAN_SUSPEND_IND);
CASE_RETURN_STRING(WMA_WLAN_RESUME_REQ);
#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
@ -743,7 +734,6 @@ uint8_t *mac_trace_get_lim_msg_string(uint16_t lim_msg)
CASE_RETURN_STRING(SIR_LIM_QUIET_BSS_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_WPS_OVERLAP_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_FT_PREAUTH_RSP_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_REMAIN_CHN_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_INSERT_SINGLESHOT_NOA_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_CONVERT_ACTIVE_CHANNEL_TO_PASSIVE);
CASE_RETURN_STRING(SIR_LIM_BEACON_GEN_IND);