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-12 15:49:17 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Remove old rso path code [PART 4]

Browse source 
Since new rso ROAM_OFFLOAD_V1 path is enabled, remove
the old rso path code for hdd/sme/lim related files.

Change-Id: I9bb470cb2af0cc940f9c5dd70942eac0cdd83eb5
CRs-Fixed: 2809268
This commit is contained in:
hqu 2020-10-30 21:14:06 +08:00 • committed by snandini
commit 934f810d33
13 changed files with 7 additions and 829 deletions
Download patch file Download diff file Expand all files Collapse all files

98
core/hdd/src/wlan_hdd_cfg80211.c
View file

@ -4811,13 +4811,8 @@ hdd_send_roam_triggers_to_sme(struct hdd_context *hdd_ctx,
status = ucfg_cm_update_roam_scan_scheme_bitmap(hdd_ctx->psoc,
vdev_id, 0);
#ifdef ROAM_OFFLOAD_V1
status = ucfg_cm_rso_set_roam_trigger(hdd_ctx->pdev, vdev_id,
&triggers);
#else
/* temp change, This will be removed with ROAM_OFFLOAD_V1 enabled */
status = sme_set_roam_triggers(hdd_ctx->mac_handle, &triggers);
#endif
if (QDF_IS_STATUS_ERROR(status))
hdd_err("Failed to set roam control trigger bitmap");
@ -13390,7 +13385,6 @@ void wlan_hdd_rso_cmd_status_cb(hdd_handle_t hdd_handle,
complete(&adapter->lfr_fw_status.disable_lfr_event);
}
#ifdef ROAM_OFFLOAD_V1
/**
* __wlan_hdd_cfg80211_set_fast_roaming() - enable/disable roaming
* @wiphy: Pointer to wireless phy
@ -13482,98 +13476,6 @@ static int __wlan_hdd_cfg80211_set_fast_roaming(struct wiphy *wiphy,
hdd_exit();
return ret;
}
#else
/**
* __wlan_hdd_cfg80211_set_fast_roaming() - enable/disable roaming
* @wiphy: Pointer to wireless phy
* @wdev: Pointer to wireless device
* @data: Pointer to data
* @data_len: Length of @data
*
* This function is used to enable/disable roaming using vendor commands
*
* Return: 0 on success, negative errno on failure
*/
static int __wlan_hdd_cfg80211_set_fast_roaming(struct wiphy *wiphy,
struct wireless_dev *wdev,
const void *data, int data_len)
{
struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
struct net_device *dev = wdev->netdev;
struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_MAX + 1];
uint32_t is_fast_roam_enabled;
int ret;
QDF_STATUS qdf_status;
unsigned long rc;
struct hdd_station_ctx *hdd_sta_ctx =
WLAN_HDD_GET_STATION_CTX_PTR(adapter);
mac_handle_t mac_handle;
hdd_enter_dev(dev);
ret = wlan_hdd_validate_context(hdd_ctx);
if (0 != ret)
return ret;
if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
hdd_err("Command not allowed in FTM mode");
return -EINVAL;
}
ret = wlan_cfg80211_nla_parse(tb,
QCA_WLAN_VENDOR_ATTR_MAX, data, data_len,
qca_wlan_vendor_attr);
if (ret) {
hdd_err("Invalid ATTR");
return -EINVAL;
}
/* Parse and fetch Enable flag */
if (!tb[QCA_WLAN_VENDOR_ATTR_ROAMING_POLICY]) {
hdd_err("attr enable failed");
return -EINVAL;
}
is_fast_roam_enabled = nla_get_u32(
tb[QCA_WLAN_VENDOR_ATTR_ROAMING_POLICY]);
hdd_debug("isFastRoamEnabled %d", is_fast_roam_enabled);
/* Update roaming */
mac_handle = hdd_ctx->mac_handle;
qdf_status = sme_config_fast_roaming(mac_handle, adapter->vdev_id,
is_fast_roam_enabled);
if (qdf_status != QDF_STATUS_SUCCESS)
hdd_err("sme_config_fast_roaming failed with status=%d",
qdf_status);
ret = qdf_status_to_os_return(qdf_status);
if (eConnectionState_Associated == hdd_sta_ctx->conn_info.conn_state &&
QDF_IS_STATUS_SUCCESS(qdf_status) && !is_fast_roam_enabled) {
INIT_COMPLETION(adapter->lfr_fw_status.disable_lfr_event);
/*
* wait only for LFR disable in fw as LFR enable
* is always success
*/
rc = wait_for_completion_timeout(
&adapter->lfr_fw_status.disable_lfr_event,
msecs_to_jiffies(WAIT_TIME_RSO_CMD_STATUS));
if (!rc) {
hdd_err("Timed out waiting for RSO CMD status");
return -ETIMEDOUT;
}
if (!adapter->lfr_fw_status.is_disabled) {
hdd_err("Roam disable attempt in FW fails");
return -EBUSY;
}
}
hdd_exit();
return ret;
}
#endif
/**
* wlan_hdd_cfg80211_set_fast_roaming() - enable/disable roaming

9
core/hdd/src/wlan_hdd_ioctl.c
View file

@ -780,19 +780,12 @@ static int hdd_parse_reassoc(struct hdd_adapter *adapter, const char *command,
return ret;
}
#ifdef ROAM_OFFLOAD_V1
static inline
void hdd_abort_roam_scan(struct hdd_context *hdd_ctx, uint8_t vdev_id)
{
ucfg_cm_abort_roam_scan(hdd_ctx->pdev, vdev_id);
}
#else
static inline
void hdd_abort_roam_scan(struct hdd_context *hdd_ctx, uint8_t vdev_id)
{
sme_abort_roam_scan(hdd_ctx->mac_handle, vdev_id);
}
#endif
/**
* hdd_sendactionframe() - send a userspace-supplied action frame
* @adapter: Adapter upon which the command was received

106
core/hdd/src/wlan_hdd_main.c
View file

@ -5678,7 +5678,6 @@ hdd_vdev_destroy_procedure:
return errno;
}
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
{
struct hdd_station_ctx *sta_ctx = &adapter->session.station;
@ -5786,111 +5785,6 @@ error_init_txrx:
return status;
}
#else
QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
{
struct hdd_station_ctx *sta_ctx = &adapter->session.station;
struct hdd_context *hdd_ctx;
QDF_STATUS status;
int ret_val;
mac_handle_t mac_handle;
bool bval = false;
uint8_t enable_sifs_burst = 0;
uint32_t fine_time_meas_cap = 0, roam_triggers;
hdd_ctx = WLAN_HDD_GET_CTX(adapter);
mac_handle = hdd_ctx->mac_handle;
sme_set_curr_device_mode(mac_handle, adapter->device_mode);
status = ucfg_mlme_get_vht_enable2x2(hdd_ctx->psoc, &bval);
if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("unable to get vht_enable2x2");
sme_set_pdev_ht_vht_ies(mac_handle, bval);
sme_set_vdev_ies_per_band(mac_handle, adapter->vdev_id,
adapter->device_mode);
hdd_roam_profile_init(adapter);
hdd_register_wext(adapter->dev);
hdd_conn_set_connection_state(adapter, eConnectionState_NotConnected);
sme_roam_reset_configs(mac_handle, adapter->vdev_id);
/* set fast roaming capability in sme session */
status = sme_config_fast_roaming(mac_handle, adapter->vdev_id,
true);
/* Set the default operation channel freq*/
sta_ctx->conn_info.chan_freq = hdd_ctx->config->operating_chan_freq;
/* Make the default Auth Type as OPEN */
sta_ctx->conn_info.auth_type = eCSR_AUTH_TYPE_OPEN_SYSTEM;
status = hdd_init_tx_rx(adapter);
if (QDF_STATUS_SUCCESS != status) {
hdd_err("hdd_init_tx_rx() failed, status code %08d [x%08x]",
status, status);
goto error_init_txrx;
}
set_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
status = hdd_wmm_adapter_init(adapter);
if (QDF_STATUS_SUCCESS != status) {
hdd_err("hdd_wmm_adapter_init() failed, status code %08d [x%08x]",
status, status);
goto error_wmm_init;
}
set_bit(WMM_INIT_DONE, &adapter->event_flags);
status = ucfg_get_enable_sifs_burst(hdd_ctx->psoc, &enable_sifs_burst);
if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("Failed to get sifs burst value, use default");
ret_val = sme_cli_set_command(adapter->vdev_id,
WMI_PDEV_PARAM_BURST_ENABLE,
enable_sifs_burst,
PDEV_CMD);
if (ret_val)
hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed %d", ret_val);
hdd_set_netdev_flags(adapter);
/* rcpi info initialization */
qdf_mem_zero(&adapter->rcpi, sizeof(adapter->rcpi));
if (adapter->device_mode == QDF_STA_MODE) {
roam_triggers = ucfg_mlme_get_roaming_triggers(hdd_ctx->psoc);
mlme_set_roam_trigger_bitmap(hdd_ctx->psoc, adapter->vdev_id,
roam_triggers);
wlan_cm_roam_disable_vendor_btm(hdd_ctx->psoc,
adapter->vdev_id);
ucfg_mlme_get_fine_time_meas_cap(hdd_ctx->psoc,
&fine_time_meas_cap);
sme_cli_set_command(
adapter->vdev_id,
WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_RESPONDER_ROLE,
(bool)(fine_time_meas_cap & WMI_FW_STA_RTT_RESPR),
VDEV_CMD);
sme_cli_set_command(
adapter->vdev_id,
WMI_VDEV_PARAM_ENABLE_DISABLE_RTT_INITIATOR_ROLE,
(bool)(fine_time_meas_cap & WMI_FW_STA_RTT_INITR),
VDEV_CMD);
}
return QDF_STATUS_SUCCESS;
error_wmm_init:
clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
hdd_deinit_tx_rx(adapter);
error_init_txrx:
hdd_unregister_wext(adapter->dev);
QDF_BUG(!hdd_vdev_destroy(adapter));
return status;
}
#endif
static char *net_dev_ref_debug_string_from_id(wlan_net_dev_ref_dbgid dbgid)
{

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

@ -2314,9 +2314,6 @@ struct roam_offload_scan_req {
struct scoring_param score_params;
#ifdef WLAN_FEATURE_FILS_SK
bool is_fils_connection;
#ifndef ROAM_OFFLOAD_V1
struct roam_fils_params roam_fils_params;
#endif
#endif
uint32_t btm_offload_config;
uint32_t btm_solicited_timeout;

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

@ -212,9 +212,7 @@ enum eWniMsgTypes {
eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE = SIR_SME_MSG_TYPES_BEGIN + 130,
eWNI_SME_DEFAULT_SCAN_IE = SIR_SME_MSG_TYPES_BEGIN + 131,
eWNI_SME_ROAM_INVOKE = SIR_SME_MSG_TYPES_BEGIN + 132,
#ifndef ROAM_OFFLOAD_V1
eWNI_SME_ROAM_SCAN_OFFLOAD_REQ = SIR_SME_MSG_TYPES_BEGIN + 133,
#endif
/* 133 unused */
eWNI_SME_LOST_LINK_INFO_IND = SIR_SME_MSG_TYPES_BEGIN + 134,
eWNI_SME_DEL_ALL_TDLS_PEERS = SIR_SME_MSG_TYPES_BEGIN + 135,
eWNI_SME_RSO_CMD_STATUS_IND = SIR_SME_MSG_TYPES_BEGIN + 136,
@ -240,18 +238,13 @@ enum eWniMsgTypes {
eWNI_SME_ANTENNA_ISOLATION_RSP = SIR_SME_MSG_TYPES_BEGIN + 155,
eWNI_SME_MON_DEINIT_SESSION = SIR_SME_MSG_TYPES_BEGIN + 156,
eWNI_SME_VDEV_DELETE_RSP = SIR_SME_MSG_TYPES_BEGIN + 157,
#ifndef ROAM_OFFLOAD_V1
eWNI_SME_ROAM_INIT_PARAM = SIR_SME_MSG_TYPES_BEGIN + 158,
eWNI_SME_ROAM_SEND_PER_REQ = SIR_SME_MSG_TYPES_BEGIN + 159,
#endif
/* 158, 159 unused */
eWNI_SME_GET_ROAM_SCAN_CH_LIST_EVENT =
SIR_SME_MSG_TYPES_BEGIN + 160,
eWNI_SME_MONITOR_MODE_VDEV_UP = SIR_SME_MSG_TYPES_BEGIN + 161,
eWNI_SME_UPDATE_SESSION_EDCA_TXQ_PARAMS = SIR_SME_MSG_TYPES_BEGIN + 162,
eWNI_SME_ROAM_SEND_SET_PCL_REQ = SIR_SME_MSG_TYPES_BEGIN + 163,
#ifndef ROAM_OFFLOAD_V1
eWNI_SME_ROAM_DISABLE_CFG = SIR_SME_MSG_TYPES_BEGIN + 164,
#endif
/* 164 unused */
eWNI_SME_TWT_ADD_DIALOG_EVENT = SIR_SME_MSG_TYPES_BEGIN + 165,
eWNI_SME_TWT_DEL_DIALOG_EVENT = SIR_SME_MSG_TYPES_BEGIN + 166,
eWNI_SME_TWT_PAUSE_DIALOG_EVENT = SIR_SME_MSG_TYPES_BEGIN + 167,

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

@ -358,10 +358,8 @@ enum halmsgtype {
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 136) is unused */
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 137) is unused */
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 138) is unused */
#ifndef ROAM_OFFLOAD_V1
SIR_HAL_ROAM_SCAN_OFFLOAD_REQ = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 138),
#endif
SIR_HAL_ROAM_PRE_AUTH_STATUS_IND = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 139),
SIR_HAL_TRAFFIC_STATS_IND = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 141),
@ -597,10 +595,8 @@ enum halmsgtype {
SIR_HAL_SET_WOW_PULSE_CMD = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 369),
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 370) is unused */
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 371) is unused */
#ifndef ROAM_OFFLOAD_V1
SIR_HAL_SET_PER_ROAM_CONFIG_CMD = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 371),
#endif
SIR_HAL_RX_CHN_STATUS_EVENT = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 372),
SIR_HAL_GET_RCPI_REQ = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 373),
@ -611,13 +607,8 @@ enum halmsgtype {
#endif
SIR_HAL_SET_DBS_SCAN_SEL_PARAMS = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 379),
#ifndef ROAM_OFFLOAD_V1
SIR_HAL_INIT_ROAM_OFFLOAD_PARAM = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 380),
SIR_HAL_INIT_ROAM_DISABLE_CFG = (SIR_HAL_ITC_MSG_TYPES_BEGIN + 381),
#endif
/*
* Unused SIR_HAL_ITC_MSG_TYPES_BEGIN + 382 to
* Unused SIR_HAL_ITC_MSG_TYPES_BEGIN + 380 to
* SIR_HAL_ITC_MSG_TYPES_BEGIN + 387
*/

15
core/mac/src/pe/include/lim_process_fils.h
View file

@ -217,21 +217,6 @@ bool lim_verify_fils_params_assoc_rsp(struct mac_context *mac_ctx,
struct pe_session *session_entry,
tpSirAssocRsp assoc_rsp,
tLimMlmAssocCnf * assoc_cnf);
#ifndef ROAM_OFFLOAD_V1
/**
* lim_update_fils_rik() - API to update FILS RIK in RSO
* @pe_session: PE Session
* @req_buffer: Pointer to RSO request
*
* This API is used to calculate(if required) RIK and fill
* the same in RSO request to fw.
*
* Return: None
*/
void lim_update_fils_rik(struct pe_session *pe_session,
struct roam_offload_scan_req *req_buffer);
#endif
#else
static inline bool lim_process_fils_auth_frame2(struct mac_context *mac_ctx,
struct pe_session *pe_session, tSirMacAuthFrameBody *rx_auth_frm_body)

57
core/mac/src/pe/lim/lim_process_fils.c
View file

@ -2184,61 +2184,4 @@ QDF_STATUS aead_decrypt_assoc_rsp(struct mac_context *mac_ctx,
(*n_frame) -= AES_BLOCK_SIZE;
return status;
}
#ifndef ROAM_OFFLOAD_V1
void lim_update_fils_rik(struct pe_session *pe_session,
struct roam_offload_scan_req *req_buffer)
{
struct pe_fils_session *pe_fils_info = pe_session->fils_info;
struct roam_fils_params *roam_fils_params =
&req_buffer->roam_fils_params;
/*
* If it is first connection, LIM session entries will not be
* set with FILS. However in RSO, CSR filled the RRK, realm
* info and is_fils_connection to true in req_buffer, RIK
* can be created with RRK and send all the FILS info to fw
*/
if ((!lim_is_fils_connection(pe_session) ||
!pe_fils_info) && (req_buffer->is_fils_connection)) {
if (roam_fils_params->rrk_length > WLAN_FILS_MAX_RRK_LENGTH) {
if (lim_is_fils_connection(pe_session))
pe_debug("FILS rrk len(%d) max (%d)",
roam_fils_params->rrk_length,
WLAN_FILS_MAX_RRK_LENGTH);
return;
}
wlan_crypto_create_fils_rik(roam_fils_params->rrk,
roam_fils_params->rrk_length,
roam_fils_params->rik,
&roam_fils_params->rik_length);
pe_debug("Fils created rik len %d",
roam_fils_params->rik_length);
return;
}
if (!pe_fils_info) {
pe_debug("No FILS info available in the session");
return;
}
if (pe_fils_info->fils_rik_len > WLAN_FILS_MAX_RIK_LENGTH ||
!pe_fils_info->fils_rik) {
if (pe_fils_info->fils_rik)
pe_debug("Fils rik len(%d) max %d",
pe_fils_info->fils_rik_len,
WLAN_FILS_MAX_RIK_LENGTH);
return;
}
roam_fils_params->rik_length = pe_fils_info->fils_rik_len;
qdf_mem_copy(roam_fils_params->rik, pe_fils_info->fils_rik,
roam_fils_params->rik_length);
qdf_mem_copy(roam_fils_params->fils_ft, pe_fils_info->fils_ft,
pe_fils_info->fils_ft_len);
roam_fils_params->fils_ft_len = pe_fils_info->fils_ft_len;
pe_debug("fils rik len %d ft-len:%d", roam_fils_params->rik_length,
pe_fils_info->fils_ft_len);
}
#endif
#endif

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

@ -1762,12 +1762,6 @@ static void lim_process_messages(struct mac_context *mac_ctx,
case eWNI_SME_ROAM_INVOKE:
/* fall through */
case eWNI_SME_ROAM_SEND_SET_PCL_REQ:
#ifndef ROAM_OFFLOAD_V1
case eWNI_SME_ROAM_INIT_PARAM:
case eWNI_SME_ROAM_DISABLE_CFG:
case eWNI_SME_ROAM_SEND_PER_REQ:
case eWNI_SME_ROAM_SCAN_OFFLOAD_REQ:
#endif
case eWNI_SME_SET_ADDBA_ACCEPT:
case eWNI_SME_UPDATE_EDCA_PROFILE:
case WNI_SME_UPDATE_MU_EDCA_PARAMS:

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

@ -3909,133 +3909,7 @@ lim_send_vdev_restart(struct mac_context *mac,
vdev_mgr_start_send(mlme_obj, true);
}
#ifndef ROAM_OFFLOAD_V1
/**
* __lim_process_roam_scan_offload_req() - Process Roam scan offload from csr
* @mac_ctx: Pointer to Global MAC structure
* @msg_buf: Pointer to SME message buffer
*
* Return: None
*/
static void __lim_process_roam_scan_offload_req(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
struct pe_session *pe_session;
struct scheduler_msg wma_msg = {0};
QDF_STATUS status;
struct roam_offload_scan_req *req_buffer;
uint16_t local_ie_len;
uint8_t *local_ie_buf;
req_buffer = (struct roam_offload_scan_req *)msg_buf;
pe_session = pe_find_session_by_vdev_id(mac_ctx,
req_buffer->sessionId);
local_ie_buf = qdf_mem_malloc(MAX_DEFAULT_SCAN_IE_LEN);
if (!local_ie_buf) {
qdf_mem_zero(req_buffer, sizeof(*req_buffer));
qdf_mem_free(req_buffer);
return;
}
local_ie_len = req_buffer->assoc_ie.length;
/* Update ext cap IE if present */
if (local_ie_len &&
!lim_update_ext_cap_ie(mac_ctx, req_buffer->assoc_ie.addIEdata,
local_ie_buf, &local_ie_len, pe_session)) {
if (local_ie_len <
QDF_ARRAY_SIZE(req_buffer->assoc_ie.addIEdata)) {
req_buffer->assoc_ie.length = local_ie_len;
qdf_mem_copy(req_buffer->assoc_ie.addIEdata,
local_ie_buf, local_ie_len);
}
}
qdf_mem_free(local_ie_buf);
if (pe_session)
lim_update_fils_rik(pe_session, req_buffer);
wma_msg.type = WMA_ROAM_SCAN_OFFLOAD_REQ;
wma_msg.bodyptr = req_buffer;
status = wma_post_ctrl_msg(mac_ctx, &wma_msg);
if (QDF_STATUS_SUCCESS != status) {
pe_err("Posting WMA_ROAM_SCAN_OFFLOAD_REQ failed");
qdf_mem_zero(req_buffer, sizeof(*req_buffer));
qdf_mem_free(req_buffer);
}
}
#else
static inline void
__lim_process_roam_scan_offload_req(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{}
#endif
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
#ifndef ROAM_OFFLOAD_V1
/**
* lim_send_roam_offload_init() - Process Roam offload flag from csr
* @mac_ctx: Pointer to Global MAC structure
* @msg_buf: Pointer to SME message buffer
*
* Return: None
*/
static void lim_send_roam_offload_init(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
struct scheduler_msg wma_msg = {0};
QDF_STATUS status;
wma_msg.type = WMA_ROAM_INIT_PARAM;
wma_msg.bodyptr = msg_buf;
status = wma_post_ctrl_msg(mac_ctx, &wma_msg);
if (QDF_STATUS_SUCCESS != status) {
pe_err("Posting WMA_ROAM_INIT_PARAM failed");
qdf_mem_free(msg_buf);
}
}
static void lim_send_roam_disable_cfg(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
struct scheduler_msg wma_msg = {0};
QDF_STATUS status;
wma_msg.type = WMA_ROAM_DISABLE_CFG;
wma_msg.bodyptr = msg_buf;
status = wma_post_ctrl_msg(mac_ctx, &wma_msg);
if (QDF_STATUS_SUCCESS != status) {
pe_err("Posting WMA_ROAM_DISABLE_CFG failed");
qdf_mem_free(msg_buf);
}
}
/**
* lim_send_roam_per_command() - Process roam send PER command from csr
* @mac_ctx: Pointer to Global MAC structure
* @msg_buf: Pointer to SME message buffer
*
* Return: None
*/
static void lim_send_roam_per_command(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
struct scheduler_msg wma_msg = {0};
QDF_STATUS status;
wma_msg.type = WMA_SET_PER_ROAM_CONFIG_CMD;
wma_msg.bodyptr = msg_buf;
status = wma_post_ctrl_msg(mac_ctx, &wma_msg);
if (QDF_STATUS_SUCCESS != status) {
pe_err("Posting WMA_ROAM_INIT_PARAM failed");
qdf_mem_free(msg_buf);
}
}
#endif
/**
* lim_send_roam_set_pcl() - Process Roam offload flag from csr
* @mac_ctx: Pointer to Global MAC structure
@ -4059,25 +3933,6 @@ static void lim_send_roam_set_pcl(struct mac_context *mac_ctx,
}
}
#else
#ifndef ROAM_OFFLOAD_V1
static void lim_send_roam_offload_init(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
qdf_mem_free(msg_buf);
}
static void lim_send_roam_per_command(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
qdf_mem_free(msg_buf);
}
static void lim_send_roam_disable_cfg(struct mac_context *mac_ctx,
uint32_t *msg_buf)
{
qdf_mem_free(msg_buf);
}
#endif
static inline void lim_send_roam_set_pcl(struct mac_context *mac_ctx,
struct set_pcl_req *msg_buf)
{
@ -5155,24 +5010,6 @@ bool lim_process_sme_req_messages(struct mac_context *mac,
lim_send_roam_set_pcl(mac, (struct set_pcl_req *)msg_buf);
bufConsumed = false;
break;
#ifndef ROAM_OFFLOAD_V1
case eWNI_SME_ROAM_SCAN_OFFLOAD_REQ:
__lim_process_roam_scan_offload_req(mac, msg_buf);
bufConsumed = false;
break;
case eWNI_SME_ROAM_INIT_PARAM:
lim_send_roam_offload_init(mac, msg_buf);
bufConsumed = false;
break;
case eWNI_SME_ROAM_DISABLE_CFG:
lim_send_roam_disable_cfg(mac, msg_buf);
bufConsumed = false;
break;
case eWNI_SME_ROAM_SEND_PER_REQ:
lim_send_roam_per_command(mac, msg_buf);
bufConsumed = false;
break;
#endif
case eWNI_SME_ROAM_INVOKE:
lim_process_roam_invoke(mac, msg_buf);
bufConsumed = false;

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

@ -351,10 +351,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
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);
#ifndef ROAM_OFFLOAD_V1
CASE_RETURN_STRING(eWNI_SME_ROAM_SCAN_OFFLOAD_REQ);
CASE_RETURN_STRING(eWNI_SME_ROAM_INIT_PARAM);
#endif
CASE_RETURN_STRING(eWNI_SME_LOST_LINK_INFO_IND);
CASE_RETURN_STRING(eWNI_SME_GET_PEER_INFO_EXT_IND);
CASE_RETURN_STRING(eWNI_SME_RSO_CMD_STATUS_IND);
@ -453,9 +449,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
CASE_RETURN_STRING(WMA_MSG_TYPES_END);
CASE_RETURN_STRING(WMA_AGGR_QOS_REQ);
CASE_RETURN_STRING(WMA_AGGR_QOS_RSP);
#ifndef ROAM_OFFLOAD_V1
CASE_RETURN_STRING(WMA_ROAM_SCAN_OFFLOAD_REQ);
#endif
CASE_RETURN_STRING(WMA_ROAM_PRE_AUTH_STATUS);
#ifdef WLAN_FEATURE_PACKET_FILTERING
CASE_RETURN_STRING(WMA_8023_MULTICAST_LIST_REQ);
@ -613,9 +606,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
CASE_RETURN_STRING(WMA_SET_RSSI_MONITOR_REQ);
CASE_RETURN_STRING(WMA_SET_WISA_PARAMS);
CASE_RETURN_STRING(WMA_SET_WOW_PULSE_CMD);
#ifndef ROAM_OFFLOAD_V1
CASE_RETURN_STRING(WMA_SET_PER_ROAM_CONFIG_CMD);
#endif
CASE_RETURN_STRING(WMA_GET_RCPI_REQ);
CASE_RETURN_STRING(WMA_SET_DBS_SCAN_SEL_CONF_PARAMS);
CASE_RETURN_STRING(WMA_GET_ROAM_SCAN_STATS);

8
core/sme/inc/sme_api.h
View file

@ -964,10 +964,6 @@ QDF_STATUS sme_update_is_fast_roam_ini_feature_enabled(mac_handle_t mac_handle,
const bool
isFastRoamIniFeatureEnabled);
#ifndef ROAM_OFFLOAD_V1
QDF_STATUS sme_config_fast_roaming(mac_handle_t mac_handle, uint8_t session_id,
const bool is_fast_roam_enabled);
#endif
QDF_STATUS sme_stop_roaming(mac_handle_t mac_handle, uint8_t sessionId,
uint8_t reason,
enum wlan_cm_rso_control_requestor requestor);
@ -1615,10 +1611,6 @@ QDF_STATUS sme_ext_scan_register_callback(mac_handle_t mac_handle,
}
#endif /* FEATURE_WLAN_EXTSCAN */
#ifndef ROAM_OFFLOAD_V1
QDF_STATUS sme_abort_roam_scan(mac_handle_t mac_handle, uint8_t sessionId);
#endif
/**
* sme_get_vht_ch_width() - SME API to get the max supported FW chan width
*

333
core/sme/src/common/sme_api.c
View file

@ -109,7 +109,6 @@ QDF_STATUS sme_release_global_lock(struct sme_context *sme)
return qdf_mutex_release(&sme->sme_global_lock);
}
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS cm_roam_acquire_lock(void)
{
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_SME);
@ -129,7 +128,6 @@ QDF_STATUS cm_roam_release_lock(void)
return sme_release_global_lock(&mac->sme);
}
#endif
struct mac_context *sme_get_mac_context(void)
{
@ -6467,83 +6465,6 @@ QDF_STATUS sme_update_is_fast_roam_ini_feature_enabled(mac_handle_t mac_handle,
return QDF_STATUS_SUCCESS;
}
#ifndef ROAM_OFFLOAD_V1
/**
* sme_config_fast_roaming() - enable/disable LFR support at runtime
* @mac_handle - The handle returned by macOpen.
* @session_id - Session Identifier
* @is_fast_roam_enabled - flag to enable/disable roaming
*
* When Supplicant issues enabled/disable fast roaming on the basis
* of the Bssid modification in network block (e.g. AutoJoin mode N/W block)
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_config_fast_roaming(mac_handle_t mac_handle, uint8_t session_id,
const bool is_fast_roam_enabled)
{
struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
enum roam_offload_state state;
QDF_STATUS status;
bool supplicant_disabled_roaming;
uint32_t set_val = 0;
enum roam_offload_state cur_state;
/*
* supplicant_disabled_roaming flag is altered when supplicant sends
* vendor command to enable/disable roaming after association.
*
* This request from wpa_supplicant will be skipped in this function
* if roaming is disabled using driver command or INI and
* supplicant_disabled_roaming flag remains set. So make sure to set
* supplicant_disabled_roaming flag as per wpa_supplicant even if roam
* request from wpa_supplicant ignored.
*/
if (!mac_ctx->mlme_cfg->lfr.lfr_enabled) {
sme_debug("ROAM: Fast roam is disabled through ini");
if (!is_fast_roam_enabled)
return QDF_STATUS_SUCCESS;
return QDF_STATUS_E_FAILURE;
}
cur_state = mlme_get_roam_state(mac_ctx->psoc, session_id);
if (cur_state == WLAN_ROAM_INIT) {
if (!is_fast_roam_enabled)
set_val =
WMI_VDEV_ROAM_11KV_CTRL_DISABLE_FW_TRIGGER_ROAMING;
status = csr_send_roam_disable_cfg_msg(mac_ctx, session_id,
set_val);
if (!QDF_IS_STATUS_SUCCESS(status)) {
sme_err("ROAM: update fast roaming failed, status: %d",
status);
}
}
mac_ctx->mlme_cfg->sta.usr_disabled_roaming = !is_fast_roam_enabled;
supplicant_disabled_roaming =
mlme_get_supplicant_disabled_roaming(mac_ctx->psoc,
session_id);
if (!is_fast_roam_enabled && supplicant_disabled_roaming) {
sme_debug("ROAM: RSO disabled by wpa supplicant already");
return QDF_STATUS_E_ALREADY;
}
mlme_set_supplicant_disabled_roaming(mac_ctx->psoc, session_id,
!is_fast_roam_enabled);
state = (is_fast_roam_enabled) ?
WLAN_ROAM_RSO_ENABLED : WLAN_ROAM_RSO_STOPPED;
status = csr_post_roam_state_change(mac_ctx, session_id, state,
REASON_SUPPLICANT_DISABLED_ROAMING);
if (!QDF_IS_STATUS_SUCCESS(status)) {
sme_err("ROAM: update fast roaming failed. status: %d", status);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
#endif
#ifdef FEATURE_WLAN_ESE
int sme_add_key_krk(mac_handle_t mac_handle, uint8_t session_id,
const uint8_t *key, const int key_len)
@ -6601,7 +6522,6 @@ int sme_add_key_btk(mac_handle_t mac_handle, uint8_t session_id,
}
#endif
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS sme_stop_roaming(mac_handle_t mac_handle, uint8_t vdev_id,
uint8_t reason,
enum wlan_cm_rso_control_requestor requestor)
@ -6655,137 +6575,6 @@ bool sme_roaming_in_progress(mac_handle_t mac_handle, uint8_t vdev_id)
return wlan_cm_roaming_in_progress(mac->pdev, vdev_id);
}
#else
/**
* sme_stop_roaming() - Stop roaming for a given sessionId
* This is a synchronous call
*
* @mac_handle - The handle returned by mac_open
* @sessionId - Session Identifier
*
* Return QDF_STATUS_SUCCESS on success
* Other status on failure
*/
QDF_STATUS sme_stop_roaming(mac_handle_t mac_handle, uint8_t session_id,
uint8_t reason,
enum wlan_cm_rso_control_requestor requestor)
{
QDF_STATUS status;
struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
struct csr_roam_session *session;
session = CSR_GET_SESSION(mac_ctx, session_id);
if (!session) {
sme_err("ROAM: incorrect vdev ID %d", session_id);
return QDF_STATUS_E_FAILURE;
}
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_IS_STATUS_ERROR(status)) {
sme_err("Failed to acquire global SME lock!");
return status;
}
if (reason == REASON_DRIVER_DISABLED && requestor)
mlme_set_operations_bitmap(mac_ctx->psoc, session_id,
requestor, false);
status = csr_post_roam_state_change(mac_ctx, session_id,
WLAN_ROAM_RSO_STOPPED,
REASON_DRIVER_DISABLED);
sme_release_global_lock(&mac_ctx->sme);
return status;
}
QDF_STATUS sme_abort_roaming(mac_handle_t mac_handle, uint8_t vdev_id)
{
struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
QDF_STATUS status;
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_IS_STATUS_ERROR(status)) {
sme_err("Failed to acquire global SME lock!");
return status;
}
if (MLME_IS_ROAM_SYNCH_IN_PROGRESS(mac_ctx->psoc, vdev_id) ||
sme_neighbor_middle_of_roaming(mac_handle, vdev_id)) {
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_BUSY;
}
/* RSO stop cmd will be issued with global SME lock held to avoid
* any racing conditions with wma/csr layer
*/
sme_stop_roaming(mac_handle, vdev_id, REASON_DRIVER_DISABLED,
RSO_INVALID_REQUESTOR);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_SUCCESS;
}
/*
* sme_start_roaming() - Start roaming for a given sessionId
* This is a synchronous call
*
* mac_handle - The handle returned by mac_open
* sessionId - Session Identifier
* Return QDF_STATUS_SUCCESS on success
* Other status on failure
*/
QDF_STATUS sme_start_roaming(mac_handle_t mac_handle, uint8_t sessionId,
uint8_t reason,
enum wlan_cm_rso_control_requestor requestor)
{
struct mac_context *mac = MAC_CONTEXT(mac_handle);
QDF_STATUS status = QDF_STATUS_SUCCESS;
if (reason == REASON_DRIVER_ENABLED && requestor) {
mlme_set_operations_bitmap(mac->psoc, sessionId, requestor,
true);
}
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_ERROR(status))
return QDF_STATUS_E_FAILURE;
status = csr_post_roam_state_change(mac, sessionId,
WLAN_ROAM_RSO_ENABLED,
REASON_DRIVER_ENABLED);
sme_release_global_lock(&mac->sme);
return status;
}
bool sme_roaming_in_progress(mac_handle_t mac_handle, uint8_t vdev_id)
{
struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
QDF_STATUS status;
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_IS_STATUS_ERROR(status)) {
sme_err("Failed to acquire global SME lock!");
return false;
}
if (MLME_IS_ROAM_SYNCH_IN_PROGRESS(mac_ctx->psoc, vdev_id) ||
MLME_IS_ROAMING_IN_PROG(mac_ctx->psoc, vdev_id) ||
mlme_is_roam_invoke_in_progress(mac_ctx->psoc, vdev_id) ||
sme_neighbor_middle_of_roaming(mac_handle, vdev_id)) {
sme_release_global_lock(&mac_ctx->sme);
return true;
}
sme_release_global_lock(&mac_ctx->sme);
return false;
}
#endif
/*
* sme_set_roam_opportunistic_scan_threshold_diff() -
* Update Opportunistic Scan threshold diff
@ -9930,37 +9719,6 @@ QDF_STATUS sme_update_dsc_pto_up_mapping(mac_handle_t mac_handle,
return status;
}
#ifndef ROAM_OFFLOAD_V1
/*
* sme_abort_roam_scan() -
* API to abort current roam scan cycle by roam scan offload module.
*
* mac_handle - The handle returned by mac_open.
* sessionId - Session Identifier
* Return QDF_STATUS
*/
QDF_STATUS sme_abort_roam_scan(mac_handle_t mac_handle, uint8_t sessionId)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
if (mac->mlme_cfg->lfr.roam_scan_offload_enabled) {
/* acquire the lock for the sme object */
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_SUCCESS(status)) {
csr_roam_offload_scan(mac, sessionId,
ROAM_SCAN_OFFLOAD_ABORT_SCAN,
REASON_ROAM_ABORT_ROAM_SCAN);
/* release the lock for the sme object */
sme_release_global_lock(&mac->sme);
}
}
return status;
}
#endif
QDF_STATUS sme_get_valid_channels_by_band(mac_handle_t mac_handle,
uint8_t wifi_band,
uint32_t *valid_chan_list,
@ -16589,97 +16347,6 @@ void sme_chan_to_freq_list(
wlan_reg_chan_to_freq(pdev, (uint32_t)chan_list[count]);
}
#ifndef ROAM_OFFLOAD_V1
static QDF_STATUS sme_enable_roaming(struct mac_context *mac, uint32_t vdev_id,
bool enable)
{
struct csr_roam_session *session = CSR_GET_SESSION(mac, vdev_id);
QDF_STATUS status;
uint8_t reason = REASON_SUPPLICANT_DE_INIT_ROAMING;
if (!session) {
sme_err("Roam session is NULL for vdev %d", vdev_id);
return QDF_STATUS_E_FAILURE;
}
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_ERROR(status))
return status;
if (enable)
reason = REASON_SUPPLICANT_INIT_ROAMING;
csr_post_roam_state_change(
mac, vdev_id,
enable ? WLAN_ROAM_RSO_ENABLED : WLAN_ROAM_DEINIT,
reason);
sme_release_global_lock(&mac->sme);
return QDF_STATUS_SUCCESS;
}
static inline
QDF_STATUS sme_rso_init_deinit(struct mac_context *mac,
struct wlan_roam_triggers *triggers)
{
QDF_STATUS status;
if (!triggers->trigger_bitmap)
status = sme_enable_roaming(mac, triggers->vdev_id,
false);
else
status = sme_enable_roaming(mac, triggers->vdev_id,
true);
return status;
}
QDF_STATUS sme_set_roam_triggers(mac_handle_t mac_handle,
struct wlan_roam_triggers *triggers)
{
QDF_STATUS status;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
struct wlan_roam_triggers *roam_trigger_data;
mlme_set_roam_trigger_bitmap(mac->psoc, triggers->vdev_id,
triggers->trigger_bitmap);
status = sme_rso_init_deinit(mac, triggers);
if (QDF_IS_STATUS_ERROR(status))
return status;
/* per contract must make a copy of the params when messaging */
roam_trigger_data = qdf_mem_malloc(sizeof(*roam_trigger_data));
if (!roam_trigger_data)
return QDF_STATUS_E_NOMEM;
*roam_trigger_data = *triggers;
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(roam_trigger_data);
return status;
}
/* Serialize the req through MC thread */
message.bodyptr = roam_trigger_data;
message.type = SIR_HAL_SET_ROAM_TRIGGERS;
status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
sme_release_global_lock(&mac->sme);
if (QDF_IS_STATUS_ERROR(status)) {
sme_err("failed to post ROAM_TRIGGERS msg");
qdf_mem_free(roam_trigger_data);
}
return status;
}
#endif
QDF_STATUS
sme_send_vendor_btm_params(mac_handle_t mac_handle, uint8_t vdev_id)
{