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-10 22:40:54 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Remove unused CSA code for non offload

Browse source 
CSA is offloaded in all chipset and thus the non-offload
version can be removed.

Change-Id: I9f84195ef962c69668843cfc50631757a8960fee
CRs-Fixed: 2658860
This commit is contained in:
Abhinav Kumar 2020-04-07 18:05:02 +05:30 • committed by nshrivas
commit 8f5c55f368
14 changed files with 10 additions and 462 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -281,7 +281,6 @@ typedef struct sLimTimers {
/* Update OLBC Cache Timer */
TX_TIMER gLimUpdateOlbcCacheTimer;
TX_TIMER gLimChannelSwitchTimer;
TX_TIMER gLimFTPreAuthRspTimer;
TX_TIMER gLimPeriodicJoinProbeReqTimer;

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

@ -702,7 +702,6 @@ struct sir_cfg_action_frm_tb_ppdu {
#define SIR_LIM_CNF_WAIT_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x17)
/* currently unused (SIR_LIM_TIMEOUT_MSG_START + 0x18) */
#define SIR_LIM_UPDATE_OLBC_CACHEL_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x19)
#define SIR_LIM_CHANNEL_SWITCH_TIMEOUT (SIR_LIM_TIMEOUT_MSG_START + 0x1A)
#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)

208
core/mac/src/pe/lim/lim_process_action_frame.c
View file

@ -80,7 +80,6 @@ void lim_stop_tx_and_switch_channel(struct mac_context *mac, uint8_t sessionId)
return;
}
mac->lim.lim_timers.gLimChannelSwitchTimer.sessionId = sessionId;
status = policy_mgr_check_and_set_hw_mode_for_channel_switch(mac->psoc,
pe_session->smeSessionId,
pe_session->gLimChannelSwitch.sw_target_freq,
@ -107,209 +106,9 @@ void lim_stop_tx_and_switch_channel(struct mac_context *mac, uint8_t sessionId)
pe_info("Channel change will continue after HW mode change");
return;
}
/* change the channel immediately only if
* the channel switch count is 0
*/
if (pe_session->gLimChannelSwitch.switchCount == 0) {
lim_process_channel_switch_timeout(mac);
return;
}
MTRACE(mac_trace
(mac, TRACE_CODE_TIMER_ACTIVATE, sessionId,
eLIM_CHANNEL_SWITCH_TIMER));
if (tx_timer_activate(&mac->lim.lim_timers.gLimChannelSwitchTimer) !=
TX_SUCCESS) {
pe_err("tx_timer_activate failed");
}
return;
}
lim_process_channel_switch(mac, pe_session->smeSessionId);
/**------------------------------------------------------------
\fn lim_start_channel_switch
\brief Switches the channel if switch count == 0, otherwise
starts the timer for channel switch and stops BG scan
and heartbeat timer tempororily.
\param mac
\param pe_session
\return NONE
------------------------------------------------------------*/
QDF_STATUS lim_start_channel_switch(struct mac_context *mac,
struct pe_session *pe_session)
{
pe_debug("Starting the channel switch");
/*If channel switch is already running and it is on a different session, just return */
/*This need to be removed for MCC */
if ((lim_is_chan_switch_running(mac) &&
pe_session->gLimSpecMgmt.dot11hChanSwState !=
eLIM_11H_CHANSW_RUNNING) || pe_session->csaOffloadEnable) {
pe_warn("Ignoring channel switch on session: %d",
pe_session->peSessionId);
return QDF_STATUS_SUCCESS;
}
/* Deactivate and change reconfigure the timeout value */
/* lim_deactivate_and_change_timer(mac, eLIM_CHANNEL_SWITCH_TIMER); */
MTRACE(mac_trace
(mac, TRACE_CODE_TIMER_DEACTIVATE, pe_session->peSessionId,
eLIM_CHANNEL_SWITCH_TIMER));
if (tx_timer_deactivate(&mac->lim.lim_timers.gLimChannelSwitchTimer) !=
QDF_STATUS_SUCCESS) {
pe_err("tx_timer_deactivate failed!");
return QDF_STATUS_E_FAILURE;
}
if (tx_timer_change(&mac->lim.lim_timers.gLimChannelSwitchTimer,
pe_session->gLimChannelSwitch.switchTimeoutValue,
0) != TX_SUCCESS) {
pe_err("tx_timer_change failed");
return QDF_STATUS_E_FAILURE;
}
/* Prepare for 11h channel switch */
lim_prepare_for11h_channel_switch(mac, pe_session);
/** Dont add any more statements here as we posted finish scan request
* to HAL, wait till we get the response
*/
return QDF_STATUS_SUCCESS;
}
/**
* __lim_process_channel_switch_action_frame() - to process channel switch
* @mac_ctx: Pointer to Global MAC structure
* @rx_pkt_info: A pointer to packet info structure
*
* This routine will be called to process channel switch action frame
*
* Return: None
*/
static void __lim_process_channel_switch_action_frame(struct mac_context *mac_ctx,
uint8_t *rx_pkt_info, struct pe_session *session)
{
tpSirMacMgmtHdr mac_hdr;
uint8_t *body_ptr;
tDot11fChannelSwitch *chnl_switch_frame;
uint16_t bcn_period;
uint32_t val, frame_len, status;
tLimChannelSwitchInfo *ch_switch_params;
struct sDot11fIEWiderBWChanSwitchAnn *wbw_chnlswitch_ie = NULL;
struct sLimWiderBWChannelSwitch *lim_wbw_chnlswitch_info = NULL;
struct sDot11fIEsec_chan_offset_ele *sec_chnl_offset = NULL;
mac_hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
body_ptr = WMA_GET_RX_MPDU_DATA(rx_pkt_info);
frame_len = WMA_GET_RX_PAYLOAD_LEN(rx_pkt_info);
pe_debug("Received Channel switch action frame");
if (!session->lim11hEnable)
return;
chnl_switch_frame = qdf_mem_malloc(sizeof(*chnl_switch_frame));
if (!chnl_switch_frame)
return;
/* Unpack channel switch frame */
status = dot11f_unpack_channel_switch(mac_ctx, body_ptr, frame_len,
chnl_switch_frame, false);
if (DOT11F_FAILED(status)) {
pe_err("Failed to unpack and parse (0x%08x, %d bytes)",
status, frame_len);
qdf_mem_free(chnl_switch_frame);
return;
} else if (DOT11F_WARNED(status)) {
pe_warn("warning: unpack 11h-CHANSW Req(0x%08x, %d bytes)",
status, frame_len);
}
if (qdf_mem_cmp((uint8_t *) &session->bssId,
(uint8_t *) &mac_hdr->sa, sizeof(tSirMacAddr))) {
pe_warn("Rcvd action frame not from our BSS, dropping");
qdf_mem_free(chnl_switch_frame);
return;
}
/* copy the beacon interval from session */
val = session->beaconParams.beaconInterval;
ch_switch_params = &session->gLimChannelSwitch;
bcn_period = (uint16_t)val;
ch_switch_params->primaryChannel =
chnl_switch_frame->ChanSwitchAnn.newChannel;
ch_switch_params->sw_target_freq = wlan_reg_legacy_chan_to_freq
(mac_ctx->pdev,
chnl_switch_frame->ChanSwitchAnn.newChannel);
ch_switch_params->switchCount =
chnl_switch_frame->ChanSwitchAnn.switchCount;
ch_switch_params->switchTimeoutValue =
SYS_MS_TO_TICKS(bcn_period) *
session->gLimChannelSwitch.switchCount;
ch_switch_params->switchMode =
chnl_switch_frame->ChanSwitchAnn.switchMode;
/* Only primary channel switch element is present */
ch_switch_params->state = eLIM_CHANNEL_SWITCH_PRIMARY_ONLY;
ch_switch_params->ch_width = CH_WIDTH_20MHZ;
if (chnl_switch_frame->WiderBWChanSwitchAnn.present
&& session->vhtCapability) {
wbw_chnlswitch_ie = &chnl_switch_frame->WiderBWChanSwitchAnn;
session->gLimWiderBWChannelSwitch.newChanWidth =
wbw_chnlswitch_ie->newChanWidth;
session->gLimWiderBWChannelSwitch.newCenterChanFreq0 =
wbw_chnlswitch_ie->newCenterChanFreq0;
session->gLimWiderBWChannelSwitch.newCenterChanFreq1 =
wbw_chnlswitch_ie->newCenterChanFreq1;
}
pe_debug("Rcv Chnl Swtch Frame: Timeout in %d ticks",
session->gLimChannelSwitch.switchTimeoutValue);
if (session->htSupportedChannelWidthSet) {
sec_chnl_offset = &chnl_switch_frame->sec_chan_offset_ele;
if (sec_chnl_offset->secondaryChannelOffset ==
PHY_DOUBLE_CHANNEL_LOW_PRIMARY) {
ch_switch_params->state =
eLIM_CHANNEL_SWITCH_PRIMARY_AND_SECONDARY;
ch_switch_params->ch_width = CH_WIDTH_40MHZ;
ch_switch_params->ch_center_freq_seg0 =
ch_switch_params->primaryChannel + 2;
} else if (sec_chnl_offset->secondaryChannelOffset ==
PHY_DOUBLE_CHANNEL_HIGH_PRIMARY) {
ch_switch_params->state =
eLIM_CHANNEL_SWITCH_PRIMARY_AND_SECONDARY;
ch_switch_params->ch_width = CH_WIDTH_40MHZ;
ch_switch_params->ch_center_freq_seg0 =
ch_switch_params->primaryChannel - 2;
}
if (session->vhtCapability &&
chnl_switch_frame->WiderBWChanSwitchAnn.present) {
wbw_chnlswitch_ie =
&chnl_switch_frame->WiderBWChanSwitchAnn;
ch_switch_params->ch_width =
wbw_chnlswitch_ie->newChanWidth + 1;
lim_wbw_chnlswitch_info =
&session->gLimWiderBWChannelSwitch;
ch_switch_params->ch_center_freq_seg0 =
lim_wbw_chnlswitch_info->newCenterChanFreq0;
ch_switch_params->ch_center_freq_seg1 =
lim_wbw_chnlswitch_info->newCenterChanFreq1;
}
}
if (CH_WIDTH_20MHZ == ch_switch_params->ch_width) {
session->htSupportedChannelWidthSet =
WNI_CFG_CHANNEL_BONDING_MODE_DISABLE;
session->htRecommendedTxWidthSet =
session->htSupportedChannelWidthSet;
}
if (QDF_STATUS_SUCCESS != lim_start_channel_switch(mac_ctx, session))
pe_err("Could not start channel switch");
qdf_mem_free(chnl_switch_frame);
return;
}
@ -1850,11 +1649,6 @@ void lim_process_action_frame(struct mac_context *mac_ctx,
rx_pkt_info, session);
break;
#endif
case ACTION_SPCT_CHL_SWITCH:
if (LIM_IS_STA_ROLE(session))
__lim_process_channel_switch_action_frame(
mac_ctx, rx_pkt_info, session);
break;
default:
pe_warn("Spectrum mgmt action id: %d not handled",
action_hdr->actionID);

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

@ -1881,9 +1881,6 @@ static void lim_process_messages(struct mac_context *mac_ctx,
/* Does not receive CNF or dummy packet */
lim_handle_cnf_wait_timeout(mac_ctx, (uint16_t) msg->bodyval);
break;
case SIR_LIM_CHANNEL_SWITCH_TIMEOUT:
lim_process_channel_switch_timeout(mac_ctx);
break;
case SIR_LIM_UPDATE_OLBC_CACHEL_TIMEOUT:
lim_handle_update_olbc_cache(mac_ctx);
break;

21
core/mac/src/pe/lim/lim_process_probe_rsp_frame.c
View file

@ -210,27 +210,6 @@ lim_process_probe_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_Packet_info
probe_rsp->chan_freq,
session_entry);
}
if (LIM_IS_STA_ROLE(session_entry) &&
!wma_is_csa_offload_enabled()) {
if (probe_rsp->channelSwitchPresent) {
/*
* on receiving channel switch announcement
* from AP, delete all TDLS peers before
* leaving BSS and proceed for channel switch
*/
lim_update_tdls_set_state_for_fw(session_entry,
false);
lim_delete_tdls_peers(mac_ctx, session_entry);
lim_update_channel_switch(mac_ctx,
probe_rsp,
session_entry);
} else if (session_entry->gLimSpecMgmt.dot11hChanSwState
== eLIM_11H_CHANSW_RUNNING) {
lim_cancel_dot11h_channel_switch(
mac_ctx, session_entry);
}
}
/*
* Now Process EDCA Parameters, if EDCAParamSet
* count is different.

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

@ -6182,7 +6182,7 @@ void lim_send_csa_restart_req(struct mac_context *mac_ctx, uint8_t vdev_id)
void lim_continue_sta_csa_req(struct mac_context *mac_ctx, uint8_t vdev_id)
{
pe_info("Continue CSA for STA vdev id %d", vdev_id);
lim_process_channel_switch_timeout(mac_ctx);
lim_process_channel_switch(mac_ctx, vdev_id);
}
void lim_add_roam_blacklist_ap(struct mac_context *mac_ctx,

19
core/mac/src/pe/lim/lim_session_utils.c
View file

@ -32,25 +32,6 @@
#include "lim_session_utils.h"
#include "lim_utils.h"
/**
* lim_is_chan_switch_running() - check if channel switch is happening
* @mac_ctx: Global MAC context.
*
* Return: 1 - if channel switch is happening on any session.
* 0 - if channel switch is not happening.
**/
uint8_t lim_is_chan_switch_running(struct mac_context *mac_ctx)
{
uint8_t i;
for (i = 0; i < mac_ctx->lim.maxBssId; i++)
if (mac_ctx->lim.gpSession[i].valid &&
mac_ctx->lim.gpSession[i].gLimSpecMgmt.dot11hChanSwState
== eLIM_11H_CHANSW_RUNNING)
return 1;
return 0;
}
/**
* lim_is_in_mcc() - check if device is in MCC
* @mac_ctx: Global MAC context.

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

@ -19,7 +19,6 @@
#if !defined(__LIM_SESSION_UTILS_H)
#define __LIM_SESSION_UTILS_H
uint8_t lim_is_chan_switch_running(struct mac_context *mac);
uint8_t lim_is_in_mcc(struct mac_context *mac);
uint8_t pe_get_current_stas_count(struct mac_context *mac);

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

@ -33,8 +33,6 @@
#include "wlan_mlme_public_struct.h"
#include <lim_api.h>
/* channel Switch Timer in ticks */
#define LIM_CHANNEL_SWITCH_TIMER_TICKS 1
/* Lim Quite timer in ticks */
#define LIM_QUIET_TIMER_TICKS 100
/* Lim Quite BSS timer interval in ticks */
@ -55,15 +53,6 @@
static bool lim_create_non_ap_timers(struct mac_context *mac)
{
uint32_t cfgValue;
/* Create Channel Switch Timer */
if (tx_timer_create(mac, &mac->lim.lim_timers.gLimChannelSwitchTimer,
"CHANNEL SWITCH TIMER",
lim_channel_switch_timer_handler, 0,
LIM_CHANNEL_SWITCH_TIMER_TICKS,
0, TX_NO_ACTIVATE) != TX_SUCCESS) {
pe_err("failed to create Ch Switch timer");
return false;
}
cfgValue = SYS_MS_TO_TICKS(
mac->mlme_cfg->timeouts.join_failure_timeout);
@ -273,7 +262,6 @@ err_timer:
tx_timer_delete(&mac->lim.lim_timers.gLimJoinFailureTimer);
tx_timer_delete(&mac->lim.lim_timers.gLimPeriodicJoinProbeReqTimer);
tx_timer_delete(&mac->lim.lim_timers.g_lim_periodic_auth_retry_timer);
tx_timer_delete(&mac->lim.lim_timers.gLimChannelSwitchTimer);
tx_timer_delete(&mac->lim.lim_timers.sae_auth_timer);
if (mac->lim.gLimPreAuthTimerTable.pTable) {
@ -917,17 +905,3 @@ void lim_cnf_wait_tmer_handler(void *pMacGlobal, uint32_t param)
pe_err("posting to LIM failed, reason: %d", status_code);
}
void lim_channel_switch_timer_handler(void *pMacGlobal, uint32_t param)
{
struct scheduler_msg msg = {0};
struct mac_context *mac = (struct mac_context *) pMacGlobal;
pe_debug("ChannelSwitch Timer expired. Posting msg to LIM");
msg.type = SIR_LIM_CHANNEL_SWITCH_TIMEOUT;
msg.bodyval = (uint32_t) param;
msg.bodyptr = NULL;
lim_post_msg_api(mac, &msg);
}

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

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2014, 2016-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2011-2014, 2016-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -73,5 +73,4 @@ void lim_activate_cnf_timer(struct mac_context *, uint16_t, struct pe_session *)
void lim_activate_auth_rsp_timer(struct mac_context *, tLimPreAuthNode *);
void lim_update_olbc_cache_timer_handler(void *, uint32_t);
void lim_addts_response_timer_handler(void *, uint32_t);
void lim_channel_switch_timer_handler(void *, uint32_t);
#endif /* __LIM_TIMER_UTILS_H */

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

@ -477,9 +477,6 @@ void lim_deactivate_timers(struct mac_context *mac_ctx)
lim_deactivate_timers_host_roam(mac_ctx);
/* Deactivate channel switch timer. */
tx_timer_deactivate(&lim_timer->gLimChannelSwitchTimer);
/* Deactivate addts response timer. */
tx_timer_deactivate(&lim_timer->gLimAddtsRspTimer);
@ -566,8 +563,6 @@ void lim_cleanup_mlm(struct mac_context *mac_ctx)
lim_deactivate_timers(mac_ctx);
lim_delete_timers_host_roam(mac_ctx);
/* Delete channel switch timer. */
tx_timer_delete(&lim_timer->gLimChannelSwitchTimer);
/* Delete addts response timer. */
tx_timer_delete(&lim_timer->gLimAddtsRspTimer);
@ -1871,9 +1866,7 @@ static void __lim_process_channel_switch_timeout(struct pe_session *pe_session)
(pe_session->limSmeState != eLIM_SME_WT_DISASSOC_STATE) &&
(pe_session->limSmeState != eLIM_SME_WT_DEAUTH_STATE)) {
pe_err("Invalid channel! Disconnect");
lim_tear_down_link_with_ap(mac,
mac->lim.lim_timers.
gLimChannelSwitchTimer.sessionId,
lim_tear_down_link_with_ap(mac, pe_session->peSessionId,
eSIR_MAC_UNSUPPORTED_CHANNEL_CSA,
eLIM_LINK_MONITORING_DISASSOC);
return;
@ -1931,16 +1924,14 @@ void lim_disconnect_complete(struct pe_session *session, bool del_bss)
}
}
void lim_process_channel_switch_timeout(struct mac_context *mac_ctx)
void lim_process_channel_switch(struct mac_context *mac_ctx, uint8_t vdev_id)
{
struct pe_session *session_entry;
QDF_STATUS status;
session_entry = pe_find_session_by_session_id(
mac_ctx,
mac_ctx->lim.lim_timers.gLimChannelSwitchTimer.sessionId);
session_entry = pe_find_session_by_vdev_id(mac_ctx, vdev_id);
if (!session_entry) {
pe_err("Session does not exist for given sessionID");
pe_err("Session does not exist for given vdev_id %d", vdev_id);
return;
}
@ -1955,144 +1946,6 @@ void lim_process_channel_switch_timeout(struct mac_context *mac_ctx)
mlme_set_chan_switch_in_progress(session_entry->vdev, false);
}
/**
* lim_update_channel_switch() - This Function updates channel switch
* @mac_ctx: pointer to Global MAC structure
* @beacon: pointer to tpSirProbeRespBeacon
* @psessionentry: pointer to struct pe_session *
*
* This function is invoked whenever Station receives
* either 802.11h channel switch IE or airgo proprietary
* channel switch IE.
*
* Return: none
*/
void
lim_update_channel_switch(struct mac_context *mac_ctx,
tpSirProbeRespBeacon beacon,
struct pe_session *psession_entry)
{
uint16_t beacon_period;
tDot11fIEChanSwitchAnn *chnl_switch;
tLimChannelSwitchInfo *ch_switch_params;
tDot11fIEWiderBWChanSwitchAnn *widerchnl_switch;
beacon_period = psession_entry->beaconParams.beaconInterval;
/* 802.11h standard channel switch IE */
chnl_switch = &(beacon->channelSwitchIE);
ch_switch_params = &psession_entry->gLimChannelSwitch;
ch_switch_params->primaryChannel =
chnl_switch->newChannel;
ch_switch_params->sw_target_freq =
wlan_reg_legacy_chan_to_freq(mac_ctx->pdev,
chnl_switch->newChannel);
ch_switch_params->switchCount = chnl_switch->switchCount;
ch_switch_params->switchTimeoutValue =
SYS_MS_TO_TICKS(beacon_period) * (chnl_switch->switchCount);
ch_switch_params->switchMode = chnl_switch->switchMode;
widerchnl_switch = &(beacon->WiderBWChanSwitchAnn);
if (beacon->WiderBWChanSwitchAnnPresent) {
psession_entry->gLimWiderBWChannelSwitch.newChanWidth =
widerchnl_switch->newChanWidth;
psession_entry->gLimWiderBWChannelSwitch.newCenterChanFreq0 =
widerchnl_switch->newCenterChanFreq0;
psession_entry->gLimWiderBWChannelSwitch.newCenterChanFreq1 =
widerchnl_switch->newCenterChanFreq1;
}
/* Only primary channel switch element is present */
ch_switch_params->state =
eLIM_CHANNEL_SWITCH_PRIMARY_ONLY;
ch_switch_params->ch_width = CH_WIDTH_20MHZ;
/*
* Do not bother to look and operate on extended channel switch element
* if our own channel-bonding state is not enabled
*/
if (psession_entry->htSupportedChannelWidthSet &&
beacon->sec_chan_offset_present) {
if (beacon->sec_chan_offset.secondaryChannelOffset ==
PHY_DOUBLE_CHANNEL_LOW_PRIMARY) {
ch_switch_params->state =
eLIM_CHANNEL_SWITCH_PRIMARY_AND_SECONDARY;
ch_switch_params->ch_width = CH_WIDTH_40MHZ;
ch_switch_params->ch_center_freq_seg0 =
ch_switch_params->primaryChannel + 2;
} else if (beacon->sec_chan_offset.secondaryChannelOffset ==
PHY_DOUBLE_CHANNEL_HIGH_PRIMARY) {
ch_switch_params->state =
eLIM_CHANNEL_SWITCH_PRIMARY_AND_SECONDARY;
ch_switch_params->ch_width = CH_WIDTH_40MHZ;
ch_switch_params->ch_center_freq_seg0 =
ch_switch_params->primaryChannel - 2;
}
if (psession_entry->vhtCapability &&
beacon->WiderBWChanSwitchAnnPresent) {
ch_switch_params->ch_width =
widerchnl_switch->newChanWidth + 1;
ch_switch_params->ch_center_freq_seg0 =
psession_entry->gLimWiderBWChannelSwitch.
newCenterChanFreq0;
ch_switch_params->ch_center_freq_seg1 =
psession_entry->gLimWiderBWChannelSwitch.
newCenterChanFreq1;
}
}
if (QDF_STATUS_SUCCESS != lim_start_channel_switch(mac_ctx, psession_entry))
pe_warn("Could not start Channel Switch");
pe_debug("session: %d primary chl: %d freq %d ch_width: %d count: %d (%d ticks)",
psession_entry->peSessionId,
psession_entry->gLimChannelSwitch.primaryChannel,
psession_entry->gLimChannelSwitch.sw_target_freq,
psession_entry->gLimChannelSwitch.ch_width,
psession_entry->gLimChannelSwitch.switchCount,
psession_entry->gLimChannelSwitch.switchTimeoutValue);
return;
}
/**
* lim_cancel_dot11h_channel_switch
*
***FUNCTION:
* This function is called when STA does not send updated channel-swith IE
* after indicating channel-switch start. This will cancel the channel-swith
* timer which is already running.
*
***LOGIC:
*
***ASSUMPTIONS:
*
***NOTE:
*
* @param mac - Pointer to Global MAC structure
*
* @return None
*/
void lim_cancel_dot11h_channel_switch(struct mac_context *mac,
struct pe_session *pe_session)
{
if (!LIM_IS_STA_ROLE(pe_session))
return;
pe_debug("Received a beacon without channel switch IE");
MTRACE(mac_trace
(mac, TRACE_CODE_TIMER_DEACTIVATE,
pe_session->peSessionId, eLIM_CHANNEL_SWITCH_TIMER));
if (tx_timer_deactivate(&mac->lim.lim_timers.gLimChannelSwitchTimer) !=
QDF_STATUS_SUCCESS) {
pe_err("tx_timer_deactivate failed!");
}
/* We need to restore pre-channelSwitch state on the STA */
if (lim_restore_pre_channel_switch_state(mac, pe_session) !=
QDF_STATUS_SUCCESS) {
pe_err("LIM: Could not restore pre-channelSwitch (11h) state, resetting the system");
}
}
/** ------------------------------------------------------------------------ **/
/**
* keep track of the number of ANI peers associated in the BSS

11
core/mac/src/pe/lim/lim_utils.h
View file

@ -318,16 +318,13 @@ uint8_t lim_is_null_ssid(tSirMacSSid *pSsid);
void lim_stop_tx_and_switch_channel(struct mac_context *mac, uint8_t sessionId);
/**
* lim_process_channel_switch_timeout() - Process chanel switch timeout
* lim_process_channel_switch() - Process chanel switch
* @mac: pointer to Global MAC structure
* @vdev_id: Vdev on which CSA is happening
*
* Return: none
*/
void lim_process_channel_switch_timeout(struct mac_context *);
QDF_STATUS lim_start_channel_switch(struct mac_context *mac,
struct pe_session *pe_session);
void lim_update_channel_switch(struct mac_context *, tpSirProbeRespBeacon,
struct pe_session *pe_session);
void lim_process_channel_switch(struct mac_context *mac, uint8_t vdev_id);
/**
* lim_switch_primary_channel() - switch primary channel of session
@ -373,8 +370,6 @@ void lim_update_sta_run_time_ht_capability(struct mac_context *mac,
void lim_update_sta_run_time_ht_info(struct mac_context *mac,
tDot11fIEHTInfo *pRcvdHTInfo,
struct pe_session *pe_session);
void lim_cancel_dot11h_channel_switch(struct mac_context *mac,
struct pe_session *pe_session);
/**
* lim_is_channel_valid_for_channel_switch - check channel valid for switching

20
core/mac/src/pe/sch/sch_beacon_process.c
View file

@ -828,26 +828,6 @@ static void __sch_beacon_process_for_session(struct mac_context *mac_ctx,
lim_update_sta_run_time_ht_switch_chnl_params(mac_ctx,
&bcn->HTInfo, session);
if ((LIM_IS_STA_ROLE(session) && !wma_is_csa_offload_enabled())
|| LIM_IS_IBSS_ROLE(session)) {
/* Channel Switch information element updated */
if (bcn->channelSwitchPresent) {
/*
* on receiving channel switch announcement from AP,
* delete all TDLS peers before leaving BSS and proceed
* for channel switch
*/
if (LIM_IS_STA_ROLE(session)) {
lim_update_tdls_set_state_for_fw(session,
false);
lim_delete_tdls_peers(mac_ctx, session);
}
lim_update_channel_switch(mac_ctx, bcn, session);
} else if (session->gLimSpecMgmt.dot11hChanSwState ==
eLIM_11H_CHANSW_RUNNING) {
lim_cancel_dot11h_channel_switch(mac_ctx, session);
}
}
if (LIM_IS_STA_ROLE(session)
|| LIM_IS_IBSS_ROLE(session))
sch_bcn_process_sta_ibss(mac_ctx, bcn,

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

@ -653,7 +653,6 @@ uint8_t *mac_trace_get_lim_msg_string(uint16_t lim_msg)
CASE_RETURN_STRING(SIR_LIM_LINK_TEST_DURATION_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_CNF_WAIT_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_UPDATE_OLBC_CACHEL_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_CHANNEL_SWITCH_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_WPS_OVERLAP_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_FT_PREAUTH_RSP_TIMEOUT);
CASE_RETURN_STRING(SIR_LIM_BEACON_GEN_IND);