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 old rso path code [PART 5]

Browse Source 
Since new rso ROAM_OFFLOAD_V1 path is enabled, remove
the old rso path code for cm/wmi roam related files.

Change-Id: Iec350f032c3e037204f560199d4a6e258ac02688
CRs-Fixed: 2810145
This commit is contained in:
hqu
2020-11-02 15:45:09 +08:00
committed by snandini
parent 0837cb4583
commit ad188263dd
13 changed files with 0 additions and 1193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
components/target_if/connection_mgr/src/target_if_cm_roam_offload.c
View File

@@ -27,7 +27,6 @@
#include "wlan_crypto_global_api.h" #include "wlan_crypto_global_api.h"
#include "wlan_mlme_main.h" #include "wlan_mlme_main.h"
#if defined(WLAN_FEATURE_ROAM_OFFLOAD) || defined(ROAM_OFFLOAD_V1)
static struct wmi_unified static struct wmi_unified
*target_if_cm_roam_get_wmi_handle_from_vdev(struct wlan_objmgr_vdev *vdev) *target_if_cm_roam_get_wmi_handle_from_vdev(struct wlan_objmgr_vdev *vdev)
{ {
@@ -48,7 +47,6 @@ static struct wmi_unified
return wmi_handle; return wmi_handle;
} }
#endif
#ifdef WLAN_FEATURE_ROAM_OFFLOAD #ifdef WLAN_FEATURE_ROAM_OFFLOAD
/** /**
@@ -87,7 +85,6 @@ target_if_cm_roam_register_lfr3_ops(struct wlan_cm_roam_tx_ops *tx_ops)
{} {}
#endif #endif
#ifdef ROAM_OFFLOAD_V1
/** /**
* target_if_is_vdev_valid - vdev id is valid or not * target_if_is_vdev_valid - vdev id is valid or not
* @vdev_id: vdev id * @vdev_id: vdev id
@@ -1295,12 +1292,6 @@ target_if_cm_roam_register_rso_req_ops(struct wlan_cm_roam_tx_ops *tx_ops)
tx_ops->send_roam_disable_config = tx_ops->send_roam_disable_config =
target_if_cm_roam_send_disable_config; target_if_cm_roam_send_disable_config;
} }
#else
static void
target_if_cm_roam_register_rso_req_ops(struct wlan_cm_roam_tx_ops *tx_ops)
{
}
#endif
QDF_STATUS target_if_cm_roam_register_tx_ops(struct wlan_cm_roam_tx_ops *tx_ops) QDF_STATUS target_if_cm_roam_register_tx_ops(struct wlan_cm_roam_tx_ops *tx_ops)
{ {

2
components/umac/mlme/connection_mgr/core/src/wlan_cm_roam_offload.h
View File

@@ -114,7 +114,6 @@ QDF_STATUS
cm_roam_send_disable_config(struct wlan_objmgr_psoc *psoc, cm_roam_send_disable_config(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, uint8_t cfg); uint8_t vdev_id, uint8_t cfg);
#ifdef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(WLAN_FEATURE_FILS_SK) #if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(WLAN_FEATURE_FILS_SK)
QDF_STATUS cm_roam_scan_offload_add_fils_params( QDF_STATUS cm_roam_scan_offload_add_fils_params(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
@@ -130,5 +129,4 @@ QDF_STATUS cm_roam_scan_offload_add_fils_params(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#endif /* FEATURE_ROAM_OFFLOAD && WLAN_FEATURE_FILS_SK */ #endif /* FEATURE_ROAM_OFFLOAD && WLAN_FEATURE_FILS_SK */
#endif /* ROAM_OFFLOAD_V1 */
#endif /* _WLAN_CM_ROAM_OFFLOAD_H_ */ #endif /* _WLAN_CM_ROAM_OFFLOAD_H_ */

10
components/umac/mlme/connection_mgr/dispatcher/inc/wlan_cm_roam_api.h
View File

@@ -31,7 +31,6 @@
/* Default value of reason code */ /* Default value of reason code */
#define DISABLE_VENDOR_BTM_CONFIG 2 #define DISABLE_VENDOR_BTM_CONFIG 2
#ifdef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
/** /**
* wlan_cm_enable_roaming_on_connected_sta() - Enable roaming on other connected * wlan_cm_enable_roaming_on_connected_sta() - Enable roaming on other connected
@@ -327,15 +326,6 @@ QDF_STATUS
wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
enum roam_cfg_param roam_cfg_type, enum roam_cfg_param roam_cfg_type,
struct cm_roam_values_copy *src_config); struct cm_roam_values_copy *src_config);
#else
static inline QDF_STATUS
wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
enum roam_cfg_param roam_cfg_type,
struct cm_roam_values_copy *src_config)
{
return QDF_STATUS_SUCCESS;
}
#endif
#ifdef WLAN_FEATURE_FILS_SK #ifdef WLAN_FEATURE_FILS_SK
/** /**

7
components/umac/mlme/connection_mgr/dispatcher/inc/wlan_cm_roam_public_struct.h
View File

@@ -646,7 +646,6 @@ struct wlan_per_roam_config_req {
struct wlan_per_roam_config per_config; struct wlan_per_roam_config per_config;
}; };
#ifdef ROAM_OFFLOAD_V1
#define NOISE_FLOOR_DBM_DEFAULT (-96) #define NOISE_FLOOR_DBM_DEFAULT (-96)
#define RSSI_MIN_VALUE (-128) #define RSSI_MIN_VALUE (-128)
#define RSSI_MAX_VALUE (127) #define RSSI_MAX_VALUE (127)
@@ -1051,7 +1050,6 @@ struct wlan_roam_scan_channel_list {
uint32_t chan_freq_list[ROAM_MAX_CHANNELS]; uint32_t chan_freq_list[ROAM_MAX_CHANNELS];
uint8_t chan_cache_type; uint8_t chan_cache_type;
}; };
#endif
/** /**
* struct wlan_roam_rssi_change_params - RSSI change parameters to be sent over * struct wlan_roam_rssi_change_params - RSSI change parameters to be sent over
@@ -1069,7 +1067,6 @@ struct wlan_roam_rssi_change_params {
int32_t rssi_change_thresh; int32_t rssi_change_thresh;
}; };
#ifdef ROAM_OFFLOAD_V1
/** /**
* struct wlan_roam_start_config - structure containing parameters for * struct wlan_roam_start_config - structure containing parameters for
* roam start config * roam start config
@@ -1165,8 +1162,6 @@ struct wlan_roam_update_config {
struct wlan_roam_triggers roam_triggers; struct wlan_roam_triggers roam_triggers;
}; };
#endif
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
/** /**
* enum roam_offload_state - Roaming module state for each STA vdev. * enum roam_offload_state - Roaming module state for each STA vdev.
@@ -1274,7 +1269,6 @@ struct set_pcl_req {
struct wlan_cm_roam_tx_ops { struct wlan_cm_roam_tx_ops {
QDF_STATUS (*send_vdev_set_pcl_cmd)(struct wlan_objmgr_vdev *vdev, QDF_STATUS (*send_vdev_set_pcl_cmd)(struct wlan_objmgr_vdev *vdev,
struct set_pcl_req *req); struct set_pcl_req *req);
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS (*send_roam_offload_init_req)( QDF_STATUS (*send_roam_offload_init_req)(
struct wlan_objmgr_vdev *vdev, struct wlan_objmgr_vdev *vdev,
struct wlan_roam_offload_init_params *params); struct wlan_roam_offload_init_params *params);
@@ -1295,7 +1289,6 @@ struct wlan_cm_roam_tx_ops {
struct wlan_roam_triggers *req); struct wlan_roam_triggers *req);
QDF_STATUS (*send_roam_disable_config)(struct wlan_objmgr_vdev *vdev, QDF_STATUS (*send_roam_disable_config)(struct wlan_objmgr_vdev *vdev,
struct roam_disable_cfg *req); struct roam_disable_cfg *req);
#endif
}; };
/** /**

3
components/umac/mlme/connection_mgr/dispatcher/inc/wlan_cm_roam_ucfg_api.h
View File

@@ -25,8 +25,6 @@
#include "wlan_cm_roam_api.h" #include "wlan_cm_roam_api.h"
#ifdef ROAM_OFFLOAD_V1
/** /**
* ucfg_user_space_enable_disable_rso() - Enable/Disable Roam Scan offload * ucfg_user_space_enable_disable_rso() - Enable/Disable Roam Scan offload
* to firmware. * to firmware.
@@ -155,4 +153,3 @@ ucfg_cm_update_roam_scan_scheme_bitmap(struct wlan_objmgr_psoc *psoc,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#endif #endif
#endif

2
components/umac/mlme/connection_mgr/dispatcher/inc/wlan_cm_tgt_if_tx_api.h
View File

@@ -45,7 +45,6 @@ wlan_cm_roam_send_set_vdev_pcl(struct wlan_objmgr_psoc *psoc,
} }
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */ #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
#ifdef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
/** /**
* wlan_cm_tgt_send_roam_offload_init() - Send WMI_VDEV_PARAM_ROAM_FW_OFFLOAD * wlan_cm_tgt_send_roam_offload_init() - Send WMI_VDEV_PARAM_ROAM_FW_OFFLOAD
@@ -142,5 +141,4 @@ QDF_STATUS wlan_cm_tgt_send_roam_triggers(struct wlan_objmgr_psoc *psoc,
QDF_STATUS wlan_cm_tgt_send_roam_disable_config(struct wlan_objmgr_psoc *psoc, QDF_STATUS wlan_cm_tgt_send_roam_disable_config(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, uint8_t vdev_id,
struct roam_disable_cfg *req); struct roam_disable_cfg *req);
#endif
#endif /* CM_TGT_IF_TX_API_H__ */ #endif /* CM_TGT_IF_TX_API_H__ */

4
components/umac/mlme/connection_mgr/dispatcher/src/wlan_cm_roam_api.c
View File

@@ -26,7 +26,6 @@
#include "wlan_policy_mgr_api.h" #include "wlan_policy_mgr_api.h"
#include <wmi_unified_priv.h> #include <wmi_unified_priv.h>
#ifdef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
QDF_STATUS QDF_STATUS
wlan_cm_enable_roaming_on_connected_sta(struct wlan_objmgr_pdev *pdev, wlan_cm_enable_roaming_on_connected_sta(struct wlan_objmgr_pdev *pdev,
@@ -229,7 +228,6 @@ QDF_STATUS wlan_cm_roam_stop_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
{ {
return cm_roam_stop_req(psoc, vdev_id, reason); return cm_roam_stop_req(psoc, vdev_id, reason);
} }
#endif
#ifdef WLAN_FEATURE_ROAM_OFFLOAD #ifdef WLAN_FEATURE_ROAM_OFFLOAD
QDF_STATUS QDF_STATUS
@@ -468,7 +466,6 @@ wlan_cm_roam_get_vendor_btm_params(struct wlan_objmgr_psoc *psoc,
} }
#endif #endif
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS wlan_cm_roam_cfg_get_value(struct wlan_objmgr_psoc *psoc, QDF_STATUS wlan_cm_roam_cfg_get_value(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, uint8_t vdev_id,
enum roam_cfg_param roam_cfg_type, enum roam_cfg_param roam_cfg_type,
@@ -560,7 +557,6 @@ wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
return status; return status;
} }
#endif
#ifdef WLAN_FEATURE_FILS_SK #ifdef WLAN_FEATURE_FILS_SK
QDF_STATUS wlan_cm_update_mlme_fils_connection_info( QDF_STATUS wlan_cm_update_mlme_fils_connection_info(

2
components/umac/mlme/connection_mgr/dispatcher/src/wlan_cm_roam_ucfg_api.c
View File

@@ -24,7 +24,6 @@
#include "wlan_cm_roam_ucfg_api.h" #include "wlan_cm_roam_ucfg_api.h"
#include "../../core/src/wlan_cm_roam_offload.h" #include "../../core/src/wlan_cm_roam_offload.h"
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS QDF_STATUS
ucfg_user_space_enable_disable_rso(struct wlan_objmgr_pdev *pdev, ucfg_user_space_enable_disable_rso(struct wlan_objmgr_pdev *pdev,
uint8_t vdev_id, uint8_t vdev_id,
@@ -114,4 +113,3 @@ QDF_STATUS ucfg_cm_abort_roam_scan(struct wlan_objmgr_pdev *pdev,
return status; return status;
} }
#endif

2
components/umac/mlme/connection_mgr/dispatcher/src/wlan_cm_tgt_if_tx_api.c
View File

@@ -156,7 +156,6 @@ end:
} }
#endif #endif
#ifdef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD) #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
QDF_STATUS wlan_cm_tgt_send_roam_offload_init(struct wlan_objmgr_psoc *psoc, QDF_STATUS wlan_cm_tgt_send_roam_offload_init(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, bool is_init) uint8_t vdev_id, bool is_init)
@@ -417,4 +416,3 @@ QDF_STATUS wlan_cm_tgt_send_roam_disable_config(struct wlan_objmgr_psoc *psoc,
return status; return status;
} }
#endif

84
components/wmi/inc/wmi_unified_roam_api.h
View File

@@ -58,7 +58,6 @@ wmi_unified_set_rssi_monitoring_cmd(wmi_unified_t wmi_handle,
struct rssi_monitor_param *req); struct rssi_monitor_param *req);
#endif #endif
#ifdef ROAM_OFFLOAD_V1
/** /**
* wmi_unified_roam_scan_offload_rssi_thresh_cmd() - set roam scan rssi * wmi_unified_roam_scan_offload_rssi_thresh_cmd() - set roam scan rssi
* parameters * parameters
@@ -85,34 +84,6 @@ QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(
*/ */
QDF_STATUS wmi_unified_roam_scan_offload_scan_period( QDF_STATUS wmi_unified_roam_scan_offload_scan_period(
wmi_unified_t wmi_handle, struct wlan_roam_scan_period_params *param); wmi_unified_t wmi_handle, struct wlan_roam_scan_period_params *param);
#else
/**
* wmi_unified_roam_scan_offload_rssi_thresh_cmd() - set roam scan rssi
* parameters
* @wmi_handle: wmi handle
* @roam_req: roam rssi related parameters
*
* This function reads the incoming @roam_req and fill in the destination
* WMI structure and send down the roam scan rssi configs down to the firmware
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(
wmi_unified_t wmi_handle,
struct roam_offload_scan_rssi_params *roam_req);
/**
* wmi_unified_roam_scan_offload_scan_period() - set roam offload scan period
* @wmi_handle: wmi handle
* @param: pointer to roam scan period params to be sent to fw
*
* Send WMI_ROAM_SCAN_PERIOD parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_roam_scan_offload_scan_period(
wmi_unified_t wmi_handle, struct roam_scan_period_params *param);
#endif
/** /**
* wmi_unified_roam_mawc_params_cmd() - configure roaming MAWC parameters * wmi_unified_roam_mawc_params_cmd() - configure roaming MAWC parameters
@@ -270,7 +241,6 @@ QDF_STATUS wmi_unified_vdev_set_pcl_cmd(wmi_unified_t wmi_handle,
struct set_pcl_cmd_params *params); struct set_pcl_cmd_params *params);
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */ #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
#ifdef ROAM_OFFLOAD_V1
/** /**
* wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters * wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -285,23 +255,6 @@ QDF_STATUS wmi_unified_vdev_set_pcl_cmd(wmi_unified_t wmi_handle,
QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd( QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
struct wlan_roam_scan_offload_params *rso_cfg); struct wlan_roam_scan_offload_params *rso_cfg);
#else
/**
* wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters
* @wmi_handle: wmi handle
* @scan_cmd_fp: scan related parameters
* @roam_req: roam related parameters
*
* This function reads the incoming @roam_req and fill in the destination
* WMI structure and send down the roam scan configs down to the firmware
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(
wmi_unified_t wmi_handle,
wmi_start_scan_cmd_fixed_param *scan_cmd_fp,
struct roam_offload_scan_params *roam_req);
#endif
/** /**
* wmi_unified_send_roam_scan_offload_ap_cmd() - set roam ap profile in fw * wmi_unified_send_roam_scan_offload_ap_cmd() - set roam ap profile in fw
@@ -330,7 +283,6 @@ QDF_STATUS wmi_unified_roam_scan_offload_cmd(wmi_unified_t wmi_handle,
uint32_t command, uint32_t command,
uint32_t vdev_id); uint32_t vdev_id);
#ifdef ROAM_OFFLOAD_V1
/** /**
* wmi_unified_roam_scan_offload_chan_list_cmd - Roam scan offload channel * wmi_unified_roam_scan_offload_chan_list_cmd - Roam scan offload channel
* list command * list command
@@ -357,42 +309,6 @@ QDF_STATUS
wmi_unified_roam_scan_offload_rssi_change_cmd( wmi_unified_roam_scan_offload_rssi_change_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
struct wlan_roam_rssi_change_params *params); struct wlan_roam_rssi_change_params *params);
#else
/**
* wmi_unified_roam_scan_offload_rssi_change_cmd() - set roam offload RSSI th
* @wmi_handle: wmi handle
* @rssi_change_thresh: RSSI Change threshold
* @vdev_id: vdev id
*
* Send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_roam_scan_offload_rssi_change_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id,
int32_t rssi_change_thresh,
uint32_t hirssi_delay_btw_scans);
/**
* wmi_unified_roam_scan_offload_chan_list_cmd() - set roam offload channel list
* @wmi_handle: wmi handle
* @chan_count: channel count
* @chan_list: channel list
* @list_type: list type
* @vdev_id: vdev id
*
* Set roam offload channel list.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_roam_scan_offload_chan_list_cmd(wmi_unified_t wmi_handle,
uint8_t chan_count,
uint32_t *chan_list,
uint8_t list_type,
uint32_t vdev_id);
#endif
/** /**
* wmi_unified_set_per_roam_config() - set PER roam config in FW * wmi_unified_set_per_roam_config() - set PER roam config in FW

96
components/wmi/inc/wmi_unified_roam_param.h
View File

@@ -64,102 +64,6 @@ struct rssi_monitor_param {
bool control; bool control;
}; };
#ifndef ROAM_OFFLOAD_V1
/**
* struct roam_offload_scan_rssi_params - structure containing
* parameters for roam offload scan based on RSSI
* @rssi_thresh: rssi threshold
* @rssi_thresh_diff: difference in rssi threshold
* @hi_rssi_scan_max_count: 5G scan max count
* @hi_rssi_scan_rssi_delta: 5G scan rssi change threshold value
* @hi_rssi_scan_rssi_ub: 5G scan upper bound
* @raise_rssi_thresh_5g: flag to determine penalty and boost thresholds
* @vdev_id: vdev id
* @penalty_threshold_5g: RSSI threshold below which 5GHz RSSI is penalized
* @boost_threshold_5g: RSSI threshold above which 5GHz RSSI is favored
* @raise_factor_5g: factor by which 5GHz RSSI is boosted
* @drop_factor_5g: factor by which 5GHz RSSI is penalized
* @max_raise_rssi_5g: maximum boost that can be applied to a 5GHz RSSI
* @max_drop_rssi_5g: maximum penalty that can be applied to a 5GHz RSSI
* @good_rssi_threshold: RSSI below which roam is kicked in by background
* scan although rssi is still good
* @roam_earlystop_thres_min: Minimum RSSI threshold value for early stop,
* unit is dB above NF
* @roam_earlystop_thres_max: Maximum RSSI threshold value for early stop,
* unit is dB above NF
* @dense_rssi_thresh_offset: dense roam RSSI threshold difference
* @dense_min_aps_cnt: dense roam minimum APs
* @initial_dense_status: dense status detected by host
* @traffic_threshold: dense roam RSSI threshold
* @bg_scan_bad_rssi_thresh: Bad RSSI threshold to perform bg scan
* @roam_bad_rssi_thresh_offset_2g: Offset from Bad RSSI threshold for 2G
* to 5G Roam
* @bg_scan_client_bitmap: Bitmap used to identify the client scans to snoop
* @roam_data_rssi_threshold_triggers: triggers of bad data RSSI threshold to
* roam
* @roam_data_rssi_threshold: Bad data RSSI threshold to roam
* @rx_data_inactivity_time: Rx duration to check data RSSI
* @flags: Flags for Background Roaming
* Bit 0 : BG roaming enabled when we connect to 2G AP only and roaming
* to 5G AP only.
* Bit 1-31: Reserved
*/
struct roam_offload_scan_rssi_params {
int8_t rssi_thresh;
uint8_t rssi_thresh_diff;
uint32_t hi_rssi_scan_max_count;
uint32_t hi_rssi_scan_rssi_delta;
int32_t hi_rssi_scan_rssi_ub;
int raise_rssi_thresh_5g;
uint8_t vdev_id;
uint32_t penalty_threshold_5g;
uint32_t boost_threshold_5g;
uint8_t raise_factor_5g;
uint8_t drop_factor_5g;
int max_raise_rssi_5g;
int max_drop_rssi_5g;
uint32_t good_rssi_threshold;
uint32_t roam_earlystop_thres_min;
uint32_t roam_earlystop_thres_max;
int dense_rssi_thresh_offset;
int dense_min_aps_cnt;
int initial_dense_status;
int traffic_threshold;
int32_t rssi_thresh_offset_5g;
int8_t bg_scan_bad_rssi_thresh;
uint8_t roam_bad_rssi_thresh_offset_2g;
uint32_t bg_scan_client_bitmap;
uint32_t roam_data_rssi_threshold_triggers;
int32_t roam_data_rssi_threshold;
uint32_t rx_data_inactivity_time;
uint32_t flags;
};
/**
* struct roam_scan_period_params - Roam scan period parameters
* @vdev_id: Vdev for which the scan period parameters are sent
* @scan_period: Opportunistic scan runs on a timer for scan_period
* @scan_age: Duration after which the scan entries are to be aged out
* @roam_scan_inactivity_time: inactivity monitoring time in ms for which the
* device is considered to be inactive
* @roam_inactive_data_packet_count: Maximum allowed data packets count during
* roam_scan_inactivity_time.
* @roam_scan_period_after_inactivity: Roam scan period in ms after device is
* in inactive state.
* @full_scan_period: Full scan period is the idle period in seconds
* between two successive full channel roam scans.
*/
struct roam_scan_period_params {
uint32_t vdev_id;
uint32_t scan_period;
uint32_t scan_age;
uint32_t roam_scan_inactivity_time;
uint32_t roam_inactive_data_packet_count;
uint32_t roam_scan_period_after_inactivity;
uint32_t full_scan_period;
};
#endif
#define WMI_CFG_VALID_CHANNEL_LIST_LEN 100 #define WMI_CFG_VALID_CHANNEL_LIST_LEN 100
/* Occupied channel list remains static */ /* Occupied channel list remains static */
#define WMI_CHANNEL_LIST_STATIC 1 #define WMI_CHANNEL_LIST_STATIC 1

71
components/wmi/src/wmi_unified_roam_api.c
View File

@@ -46,7 +46,6 @@ wmi_unified_set_rssi_monitoring_cmd(wmi_unified_t wmi_handle,
} }
#endif /* FEATURE_RSSI_MONITOR */ #endif /* FEATURE_RSSI_MONITOR */
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd( QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
struct wlan_roam_offload_scan_rssi_params *roam_req) struct wlan_roam_offload_scan_rssi_params *roam_req)
@@ -69,29 +68,6 @@ wmi_unified_roam_scan_offload_scan_period(
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#else
QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(
wmi_unified_t wmi_handle,
struct roam_offload_scan_rssi_params *roam_req)
{
if (wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd)
return wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd(
wmi_handle, roam_req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_roam_scan_offload_scan_period(wmi_unified_t wmi_handle,
struct roam_scan_period_params *param)
{
if (wmi_handle->ops->send_roam_scan_offload_scan_period_cmd)
return wmi_handle->ops->send_roam_scan_offload_scan_period_cmd(
wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS wmi_unified_roam_mawc_params_cmd( QDF_STATUS wmi_unified_roam_mawc_params_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
@@ -209,7 +185,6 @@ QDF_STATUS wmi_unified_vdev_set_pcl_cmd(wmi_unified_t wmi_handle,
} }
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */ #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd( QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
struct wlan_roam_scan_offload_params *rso_cfg) struct wlan_roam_scan_offload_params *rso_cfg)
@@ -220,19 +195,6 @@ QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#else
QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(
wmi_unified_t wmi_handle,
wmi_start_scan_cmd_fixed_param *scan_cmd_fp,
struct roam_offload_scan_params *roam_req)
{
if (wmi_handle->ops->send_roam_scan_offload_mode_cmd)
return wmi_handle->ops->send_roam_scan_offload_mode_cmd(
wmi_handle, scan_cmd_fp, roam_req);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd( QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
@@ -257,7 +219,6 @@ QDF_STATUS wmi_unified_roam_scan_offload_cmd(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS QDF_STATUS
wmi_unified_roam_scan_offload_chan_list_cmd( wmi_unified_roam_scan_offload_chan_list_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
@@ -269,24 +230,7 @@ wmi_unified_roam_scan_offload_chan_list_cmd(
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#else
QDF_STATUS
wmi_unified_roam_scan_offload_chan_list_cmd(wmi_unified_t wmi_handle,
uint8_t chan_count,
uint32_t *chan_list,
uint8_t list_type,
uint32_t vdev_id)
{
if (wmi_handle->ops->send_roam_scan_offload_chan_list_cmd)
return wmi_handle->ops->send_roam_scan_offload_chan_list_cmd(
wmi_handle, chan_count, chan_list,
list_type, vdev_id);
return QDF_STATUS_E_FAILURE;
}
#endif
#ifdef ROAM_OFFLOAD_V1
QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd( QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
struct wlan_roam_rssi_change_params *params) struct wlan_roam_rssi_change_params *params)
@@ -297,21 +241,6 @@ QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd(
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#else
QDF_STATUS
wmi_unified_roam_scan_offload_rssi_change_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id,
int32_t rssi_change_thresh,
uint32_t hirssi_delay_btw_scans)
{
if (wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd)
return wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd(
wmi_handle, vdev_id, rssi_change_thresh,
hirssi_delay_btw_scans);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS QDF_STATUS
wmi_unified_set_per_roam_config(wmi_unified_t wmi_handle, wmi_unified_set_per_roam_config(wmi_unified_t wmi_handle,

901
components/wmi/src/wmi_unified_roam_tlv.c
View File

@@ -155,7 +155,6 @@ void wmi_rssi_monitor_attach_tlv(struct wmi_unified *wmi_handle)
} }
#endif /* FEATURE_RSSI_MONITOR */ #endif /* FEATURE_RSSI_MONITOR */
#ifdef ROAM_OFFLOAD_V1
/** /**
* send_roam_scan_offload_rssi_thresh_cmd_tlv() - set scan offload * send_roam_scan_offload_rssi_thresh_cmd_tlv() - set scan offload
* rssi threashold * rssi threashold
@@ -393,228 +392,6 @@ send_roam_scan_offload_scan_period_cmd_tlv(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#else
static QDF_STATUS send_roam_scan_offload_rssi_thresh_cmd_tlv(
wmi_unified_t wmi_handle,
struct roam_offload_scan_rssi_params *roam_req)
{
wmi_buf_t buf = NULL;
QDF_STATUS status;
int len;
uint8_t *buf_ptr;
wmi_roam_scan_rssi_threshold_fixed_param *rssi_threshold_fp;
wmi_roam_scan_extended_threshold_param *ext_thresholds = NULL;
wmi_roam_earlystop_rssi_thres_param *early_stop_thresholds = NULL;
wmi_roam_dense_thres_param *dense_thresholds = NULL;
wmi_roam_bg_scan_roaming_param *bg_scan_params = NULL;
wmi_roam_data_rssi_roaming_param *data_rssi_param = NULL;
len = sizeof(wmi_roam_scan_rssi_threshold_fixed_param);
len += WMI_TLV_HDR_SIZE; /* TLV for ext_thresholds*/
len += sizeof(wmi_roam_scan_extended_threshold_param);
len += WMI_TLV_HDR_SIZE;
len += sizeof(wmi_roam_earlystop_rssi_thres_param);
len += WMI_TLV_HDR_SIZE; /* TLV for dense thresholds*/
len += sizeof(wmi_roam_dense_thres_param);
len += WMI_TLV_HDR_SIZE; /* TLV for BG Scan*/
len += sizeof(wmi_roam_bg_scan_roaming_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
rssi_threshold_fp =
(wmi_roam_scan_rssi_threshold_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&rssi_threshold_fp->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_scan_rssi_threshold_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_scan_rssi_threshold_fixed_param));
/* fill in threshold values */
rssi_threshold_fp->vdev_id = roam_req->vdev_id;
rssi_threshold_fp->roam_scan_rssi_thresh = roam_req->rssi_thresh;
rssi_threshold_fp->roam_rssi_thresh_diff = roam_req->rssi_thresh_diff;
rssi_threshold_fp->hirssi_scan_max_count =
roam_req->hi_rssi_scan_max_count;
rssi_threshold_fp->hirssi_scan_delta =
roam_req->hi_rssi_scan_rssi_delta;
rssi_threshold_fp->hirssi_upper_bound = roam_req->hi_rssi_scan_rssi_ub;
rssi_threshold_fp->rssi_thresh_offset_5g =
roam_req->rssi_thresh_offset_5g;
buf_ptr += sizeof(wmi_roam_scan_rssi_threshold_fixed_param);
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_scan_extended_threshold_param));
buf_ptr += WMI_TLV_HDR_SIZE;
ext_thresholds = (wmi_roam_scan_extended_threshold_param *)buf_ptr;
ext_thresholds->penalty_threshold_5g = roam_req->penalty_threshold_5g;
if (roam_req->raise_rssi_thresh_5g >= WMI_NOISE_FLOOR_DBM_DEFAULT)
ext_thresholds->boost_threshold_5g =
roam_req->boost_threshold_5g;
ext_thresholds->boost_algorithm_5g =
WMI_ROAM_5G_BOOST_PENALIZE_ALGO_LINEAR;
ext_thresholds->boost_factor_5g = roam_req->raise_factor_5g;
ext_thresholds->penalty_algorithm_5g =
WMI_ROAM_5G_BOOST_PENALIZE_ALGO_LINEAR;
ext_thresholds->penalty_factor_5g = roam_req->drop_factor_5g;
ext_thresholds->max_boost_5g = roam_req->max_raise_rssi_5g;
ext_thresholds->max_penalty_5g = roam_req->max_drop_rssi_5g;
ext_thresholds->good_rssi_threshold = roam_req->good_rssi_threshold;
WMITLV_SET_HDR(&ext_thresholds->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_scan_extended_threshold_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_scan_extended_threshold_param));
buf_ptr += sizeof(wmi_roam_scan_extended_threshold_param);
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_earlystop_rssi_thres_param));
buf_ptr += WMI_TLV_HDR_SIZE;
early_stop_thresholds = (wmi_roam_earlystop_rssi_thres_param *)buf_ptr;
early_stop_thresholds->roam_earlystop_thres_min =
roam_req->roam_earlystop_thres_min;
early_stop_thresholds->roam_earlystop_thres_max =
roam_req->roam_earlystop_thres_max;
WMITLV_SET_HDR(&early_stop_thresholds->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_earlystop_rssi_thres_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_earlystop_rssi_thres_param));
buf_ptr += sizeof(wmi_roam_earlystop_rssi_thres_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_dense_thres_param));
buf_ptr += WMI_TLV_HDR_SIZE;
dense_thresholds = (wmi_roam_dense_thres_param *)buf_ptr;
dense_thresholds->roam_dense_rssi_thres_offset =
roam_req->dense_rssi_thresh_offset;
dense_thresholds->roam_dense_min_aps = roam_req->dense_min_aps_cnt;
dense_thresholds->roam_dense_traffic_thres =
roam_req->traffic_threshold;
dense_thresholds->roam_dense_status = roam_req->initial_dense_status;
WMITLV_SET_HDR(&dense_thresholds->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_dense_thres_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_roam_dense_thres_param));
buf_ptr += sizeof(wmi_roam_dense_thres_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_bg_scan_roaming_param));
buf_ptr += WMI_TLV_HDR_SIZE;
bg_scan_params = (wmi_roam_bg_scan_roaming_param *)buf_ptr;
bg_scan_params->roam_bg_scan_bad_rssi_thresh =
roam_req->bg_scan_bad_rssi_thresh;
bg_scan_params->roam_bg_scan_client_bitmap =
roam_req->bg_scan_client_bitmap;
bg_scan_params->bad_rssi_thresh_offset_2g =
roam_req->roam_bad_rssi_thresh_offset_2g;
bg_scan_params->flags = roam_req->flags;
WMITLV_SET_HDR(&bg_scan_params->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_bg_scan_roaming_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_bg_scan_roaming_param));
buf_ptr += sizeof(wmi_roam_bg_scan_roaming_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_data_rssi_roaming_param));
buf_ptr += WMI_TLV_HDR_SIZE;
data_rssi_param = (wmi_roam_data_rssi_roaming_param *)buf_ptr;
data_rssi_param->flags =
roam_req->roam_data_rssi_threshold_triggers;
data_rssi_param->roam_data_rssi_thres =
roam_req->roam_data_rssi_threshold;
data_rssi_param->rx_inactivity_ms =
roam_req->rx_data_inactivity_time;
WMITLV_SET_HDR(&data_rssi_param->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_data_rssi_roaming_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_data_rssi_roaming_param));
wmi_debug("Data rssi threshold: %d, triggers: 0x%x, rx time: %d",
data_rssi_param->roam_data_rssi_thres,
data_rssi_param->flags,
data_rssi_param->rx_inactivity_ms);
wmi_mtrace(WMI_ROAM_SCAN_RSSI_THRESHOLD, NO_SESSION, 0);
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_ROAM_SCAN_RSSI_THRESHOLD);
if (QDF_IS_STATUS_ERROR(status)) {
wmi_err("cmd WMI_ROAM_SCAN_RSSI_THRESHOLD returned Error %d",
status);
wmi_buf_free(buf);
}
return status;
}
/**
* send_roam_scan_offload_scan_period_cmd_tlv() - set roam offload scan period
* @wmi_handle: wmi handle
* @param: roam scan parameters to be sent to firmware
*
* Send WMI_ROAM_SCAN_PERIOD parameters to fw.
*
* Return: QDF status
*/
static QDF_STATUS
send_roam_scan_offload_scan_period_cmd_tlv(
wmi_unified_t wmi_handle,
struct roam_scan_period_params *param)
{
QDF_STATUS status;
wmi_buf_t buf = NULL;
int len;
uint8_t *buf_ptr;
wmi_roam_scan_period_fixed_param *scan_period_fp;
/* Send scan period values */
len = sizeof(wmi_roam_scan_period_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
scan_period_fp = (wmi_roam_scan_period_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&scan_period_fp->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_scan_period_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_scan_period_fixed_param));
/* fill in scan period values */
scan_period_fp->vdev_id = param->vdev_id;
scan_period_fp->roam_scan_period = param->scan_period;
scan_period_fp->roam_scan_age = param->scan_age;
scan_period_fp->inactivity_time_period =
param->roam_scan_inactivity_time;
scan_period_fp->roam_inactive_count =
param->roam_inactive_data_packet_count;
scan_period_fp->roam_scan_period_after_inactivity =
param->roam_scan_period_after_inactivity;
/* Firmware expects the full scan preriod in msec whereas host
* provides the same in seconds.
* Convert it to msec and send to firmware
*/
scan_period_fp->roam_full_scan_period = param->full_scan_period * 1000;
wmi_debug("roam_scan_period=%d, roam_scan_age=%d, full_scan_period= %u",
scan_period_fp->roam_scan_period,
scan_period_fp->roam_scan_age,
scan_period_fp->roam_full_scan_period);
wmi_debug("inactiviy time:%d inactive cnt:%d time after inactivity:%d",
scan_period_fp->inactivity_time_period,
scan_period_fp->roam_inactive_count,
scan_period_fp->roam_scan_period_after_inactivity);
wmi_mtrace(WMI_ROAM_SCAN_PERIOD, NO_SESSION, 0);
status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_ROAM_SCAN_PERIOD);
if (QDF_IS_STATUS_ERROR(status)) {
wmi_buf_free(buf);
return status;
}
return QDF_STATUS_SUCCESS;
}
#endif
static QDF_STATUS send_roam_mawc_params_cmd_tlv( static QDF_STATUS send_roam_mawc_params_cmd_tlv(
wmi_unified_t wmi_handle, wmi_unified_t wmi_handle,
@@ -1708,142 +1485,8 @@ extract_roam_initial_info_tlv(wmi_unified_t wmi_handle, void *evt_buf,
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */ #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
#ifndef ROAM_OFFLOAD_V1
#if defined(WLAN_FEATURE_FILS_SK) && defined(WLAN_FEATURE_ROAM_OFFLOAD)
/**
* wmi_add_fils_tlv() - Add FILS TLV to roam scan offload command
* @wmi_handle: wmi handle
* @roam_req: Roam scan offload params
* @buf_ptr: command buffer to send
* @fils_tlv_len: fils tlv length
*
* Return: Updated buffer pointer
*/
static uint8_t *wmi_add_fils_tlv(wmi_unified_t wmi_handle,
struct roam_offload_scan_params *roam_req,
uint8_t *buf_ptr, uint32_t fils_tlv_len)
{
wmi_roam_fils_offload_tlv_param *fils_tlv;
wmi_erp_info *erp_info;
struct roam_fils_params *roam_fils_params;
if (!roam_req->add_fils_tlv)
return buf_ptr;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(*fils_tlv));
buf_ptr += WMI_TLV_HDR_SIZE;
fils_tlv = (wmi_roam_fils_offload_tlv_param *)buf_ptr;
WMITLV_SET_HDR(&fils_tlv->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_fils_offload_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_fils_offload_tlv_param));
roam_fils_params = &roam_req->roam_fils_params;
erp_info = (wmi_erp_info *)(&fils_tlv->vdev_erp_info);
erp_info->username_length = roam_fils_params->username_length;
qdf_mem_copy(erp_info->username, roam_fils_params->username,
erp_info->username_length);
erp_info->next_erp_seq_num = roam_fils_params->next_erp_seq_num;
erp_info->rRk_length = roam_fils_params->rrk_length;
qdf_mem_copy(erp_info->rRk, roam_fils_params->rrk,
erp_info->rRk_length);
erp_info->rIk_length = roam_fils_params->rik_length;
qdf_mem_copy(erp_info->rIk, roam_fils_params->rik,
erp_info->rIk_length);
erp_info->realm_len = roam_fils_params->realm_len;
qdf_mem_copy(erp_info->realm, roam_fils_params->realm,
erp_info->realm_len);
buf_ptr += sizeof(*fils_tlv);
return buf_ptr;
}
#else
static inline uint8_t *wmi_add_fils_tlv(wmi_unified_t wmi_handle,
struct roam_offload_scan_params *roam_req,
uint8_t *buf_ptr, uint32_t fils_tlv_len)
{
return buf_ptr;
}
#endif
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
/**
* fill_roam_offload_11r_params() - Fill roam scan params to send it to fw
* @akm: Authentication key management type
* @roam_offload_11r: TLV to be filled with 11r params
* @roam_req: roam request param
*/
static void
fill_roam_offload_11r_params(uint32_t akm,
wmi_roam_11r_offload_tlv_param *roam_offload_11r,
struct roam_offload_scan_params *roam_req)
{
uint8_t *psk_msk, len;
if (akm == WMI_AUTH_FT_RSNA_FILS_SHA256 ||
akm == WMI_AUTH_FT_RSNA_FILS_SHA384) {
psk_msk = roam_req->roam_fils_params.fils_ft;
len = roam_req->roam_fils_params.fils_ft_len;
} else {
psk_msk = roam_req->psk_pmk;
len = roam_req->pmk_len;
}
/*
* For SHA384 based akm, the pmk length is 48 bytes. So fill
* first 32 bytes in roam_offload_11r->psk_msk and the remaining
* bytes in roam_offload_11r->psk_msk_ext buffer
*/
roam_offload_11r->psk_msk_len = len > ROAM_OFFLOAD_PSK_MSK_BYTES ?
ROAM_OFFLOAD_PSK_MSK_BYTES : len;
qdf_mem_copy(roam_offload_11r->psk_msk, psk_msk,
roam_offload_11r->psk_msk_len);
roam_offload_11r->psk_msk_ext_len = 0;
if (len > ROAM_OFFLOAD_PSK_MSK_BYTES) {
roam_offload_11r->psk_msk_ext_len =
len - roam_offload_11r->psk_msk_len;
qdf_mem_copy(roam_offload_11r->psk_msk_ext,
&psk_msk[roam_offload_11r->psk_msk_len],
roam_offload_11r->psk_msk_ext_len);
}
}
/**
* wmi_fill_sae_single_pmk_param() - Fill sae single pmk flag to indicate fw to
* use same PMKID for WPA3 SAE roaming.
* @params: roam request param
* @roam_offload_11i: pointer to 11i params
*
* Return: None
*/
static inline void
wmi_fill_sae_single_pmk_param(struct roam_offload_scan_params *params,
wmi_roam_11i_offload_tlv_param *roam_offload_11i)
{
if (params->is_sae_same_pmk)
roam_offload_11i->flags |=
1 << WMI_ROAM_OFFLOAD_FLAG_SAE_SAME_PMKID;
}
#else
static inline void
wmi_fill_sae_single_pmk_param(struct roam_offload_scan_params *params,
wmi_roam_11i_offload_tlv_param *roam_offload_11i)
{
}
#endif
#endif /* ROAM_OFFLOAD_V1 */
#define ROAM_OFFLOAD_PMK_EXT_BYTES 16 #define ROAM_OFFLOAD_PMK_EXT_BYTES 16
#ifdef ROAM_OFFLOAD_V1
#ifdef WLAN_FEATURE_ROAM_OFFLOAD #ifdef WLAN_FEATURE_ROAM_OFFLOAD
/** /**
* wmi_fill_roam_offload_11r_params() - Fill roam scan params to send it to fw * wmi_fill_roam_offload_11r_params() - Fill roam scan params to send it to fw
@@ -2546,418 +2189,6 @@ send_roam_scan_mode_cmd:
return status; return status;
} }
#else
/**
* send_roam_scan_offload_mode_cmd_tlv() - send roam scan mode request to fw
* @wmi_handle: wmi handle
* @scan_cmd_fp: start scan command ptr
* @roam_req: roam request param
*
* send WMI_ROAM_SCAN_MODE TLV to firmware. It has a piggyback
* of WMI_ROAM_SCAN_MODE.
*
* Return: QDF status
*/
static QDF_STATUS
send_roam_scan_offload_mode_cmd_tlv(wmi_unified_t wmi_handle,
wmi_start_scan_cmd_fixed_param *scan_cmd_fp,
struct roam_offload_scan_params *roam_req)
{
wmi_buf_t buf = NULL;
QDF_STATUS status;
int len;
uint8_t *buf_ptr;
wmi_roam_scan_mode_fixed_param *roam_scan_mode_fp;
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
int auth_mode = roam_req->auth_mode;
roam_offload_param *req_offload_params =
&roam_req->roam_offload_params;
wmi_roam_offload_tlv_param *roam_offload_params;
wmi_roam_11i_offload_tlv_param *roam_offload_11i;
wmi_roam_11r_offload_tlv_param *roam_offload_11r;
wmi_roam_ese_offload_tlv_param *roam_offload_ese;
wmi_tlv_buf_len_param *assoc_ies;
uint32_t fils_tlv_len = 0;
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
/* Need to create a buf with roam_scan command at
* front and piggyback with scan command */
len = sizeof(wmi_roam_scan_mode_fixed_param) +
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
(2 * WMI_TLV_HDR_SIZE) +
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
sizeof(wmi_start_scan_cmd_fixed_param);
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
wmi_debug("auth_mode = %d", auth_mode);
if (roam_req->is_roam_req_valid &&
roam_req->roam_offload_enabled) {
len += sizeof(wmi_roam_offload_tlv_param);
len += WMI_TLV_HDR_SIZE;
if ((auth_mode != WMI_AUTH_NONE) &&
((auth_mode != WMI_AUTH_OPEN) ||
(auth_mode == WMI_AUTH_OPEN &&
roam_req->mdid.mdie_present &&
roam_req->is_11r_assoc) ||
roam_req->is_ese_assoc)) {
len += WMI_TLV_HDR_SIZE;
if (roam_req->is_ese_assoc)
len += sizeof(wmi_roam_ese_offload_tlv_param);
else if ((auth_mode == WMI_AUTH_FT_RSNA) ||
(auth_mode == WMI_AUTH_FT_RSNA_PSK) ||
(auth_mode == WMI_AUTH_FT_RSNA_SAE) ||
(auth_mode ==
WMI_AUTH_FT_RSNA_SUITE_B_8021X_SHA384) ||
(auth_mode ==
WMI_AUTH_FT_RSNA_FILS_SHA256) ||
(auth_mode ==
WMI_AUTH_FT_RSNA_FILS_SHA384) ||
(auth_mode == WMI_AUTH_OPEN &&
roam_req->mdid.mdie_present &&
roam_req->is_11r_assoc))
len += sizeof(wmi_roam_11r_offload_tlv_param);
else
len += sizeof(wmi_roam_11i_offload_tlv_param);
} else {
len += WMI_TLV_HDR_SIZE;
}
len += (sizeof(*assoc_ies) + (2*WMI_TLV_HDR_SIZE)
+ roundup(roam_req->assoc_ie_length, sizeof(uint32_t)));
if (roam_req->add_fils_tlv) {
fils_tlv_len = sizeof(wmi_roam_fils_offload_tlv_param);
len += WMI_TLV_HDR_SIZE + fils_tlv_len;
}
} else {
if (roam_req->is_roam_req_valid)
wmi_debug("roam offload = %d",
roam_req->roam_offload_enabled);
len += (4 * WMI_TLV_HDR_SIZE);
}
if (roam_req->is_roam_req_valid && roam_req->roam_offload_enabled)
roam_req->mode |= WMI_ROAM_SCAN_MODE_ROAMOFFLOAD;
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
if (roam_req->mode ==
(WMI_ROAM_SCAN_MODE_NONE | WMI_ROAM_SCAN_MODE_ROAMOFFLOAD))
len = sizeof(wmi_roam_scan_mode_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
roam_scan_mode_fp = (wmi_roam_scan_mode_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&roam_scan_mode_fp->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_scan_mode_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_roam_scan_mode_fixed_param));
roam_scan_mode_fp->min_delay_roam_trigger_reason_bitmask =
roam_req->roam_trigger_reason_bitmask;
roam_scan_mode_fp->min_delay_btw_scans =
WMI_SEC_TO_MSEC(roam_req->min_delay_btw_roam_scans);
roam_scan_mode_fp->roam_scan_mode = roam_req->mode;
roam_scan_mode_fp->vdev_id = roam_req->vdev_id;
wmi_debug("roam scan mode: %d", roam_req->mode);
if (roam_req->mode ==
(WMI_ROAM_SCAN_MODE_NONE | WMI_ROAM_SCAN_MODE_ROAMOFFLOAD)) {
roam_scan_mode_fp->flags |=
WMI_ROAM_SCAN_MODE_FLAG_REPORT_STATUS;
goto send_roam_scan_mode_cmd;
}
/* Fill in scan parameters suitable for roaming scan */
buf_ptr += sizeof(wmi_roam_scan_mode_fixed_param);
qdf_mem_copy(buf_ptr, scan_cmd_fp,
sizeof(wmi_start_scan_cmd_fixed_param));
/* Ensure there is no additional IEs */
scan_cmd_fp->ie_len = 0;
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_start_scan_cmd_fixed_param));
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
buf_ptr += sizeof(wmi_start_scan_cmd_fixed_param);
if (roam_req->is_roam_req_valid && roam_req->roam_offload_enabled) {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_offload_tlv_param));
buf_ptr += WMI_TLV_HDR_SIZE;
roam_offload_params = (wmi_roam_offload_tlv_param *)buf_ptr;
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_STRUC_wmi_roam_offload_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_offload_tlv_param));
roam_offload_params->prefer_5g = roam_req->prefer_5ghz;
roam_offload_params->rssi_cat_gap = roam_req->roam_rssi_cat_gap;
roam_offload_params->select_5g_margin =
roam_req->select_5ghz_margin;
roam_offload_params->handoff_delay_for_rx =
req_offload_params->ho_delay_for_rx;
roam_offload_params->max_mlme_sw_retries =
req_offload_params->roam_preauth_retry_count;
roam_offload_params->no_ack_timeout =
req_offload_params->roam_preauth_no_ack_timeout;
roam_offload_params->reassoc_failure_timeout =
roam_req->reassoc_failure_timeout;
roam_offload_params->roam_candidate_validity_time =
roam_req->rct_validity_timer;
roam_offload_params->roam_to_current_bss_disable =
roam_req->disable_self_roam;
/* Fill the capabilities */
roam_offload_params->capability =
req_offload_params->capability;
roam_offload_params->ht_caps_info =
req_offload_params->ht_caps_info;
roam_offload_params->ampdu_param =
req_offload_params->ampdu_param;
roam_offload_params->ht_ext_cap =
req_offload_params->ht_ext_cap;
roam_offload_params->ht_txbf = req_offload_params->ht_txbf;
roam_offload_params->asel_cap = req_offload_params->asel_cap;
roam_offload_params->qos_caps = req_offload_params->qos_caps;
roam_offload_params->qos_enabled =
req_offload_params->qos_enabled;
roam_offload_params->wmm_caps = req_offload_params->wmm_caps;
qdf_mem_copy((uint8_t *)roam_offload_params->mcsset,
(uint8_t *)req_offload_params->mcsset,
ROAM_OFFLOAD_NUM_MCS_SET);
buf_ptr += sizeof(wmi_roam_offload_tlv_param);
/* The TLV's are in the order of 11i, 11R, ESE. Hence,
* they are filled in the same order.Depending on the
* authentication type, the other mode TLV's are nullified
* and only headers are filled.*/
if (auth_mode != WMI_AUTH_NONE &&
(auth_mode != WMI_AUTH_OPEN ||
roam_req->is_ese_assoc ||
(auth_mode == WMI_AUTH_OPEN &&
roam_req->mdid.mdie_present && roam_req->is_11r_assoc))) {
if (roam_req->is_ese_assoc) {
/* Fill the length of 11i, 11r TLV as 0 */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
/* Start filling the ESE TLV */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_ese_offload_tlv_param));
buf_ptr += WMI_TLV_HDR_SIZE;
roam_offload_ese =
(wmi_roam_ese_offload_tlv_param *)buf_ptr;
qdf_mem_copy(roam_offload_ese->krk,
roam_req->krk,
sizeof(roam_req->krk));
qdf_mem_copy(roam_offload_ese->btk,
roam_req->btk,
sizeof(roam_req->btk));
WMITLV_SET_HDR(&roam_offload_ese->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_ese_offload_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_ese_offload_tlv_param));
buf_ptr +=
sizeof(wmi_roam_ese_offload_tlv_param);
} else if (auth_mode == WMI_AUTH_FT_RSNA ||
auth_mode == WMI_AUTH_FT_RSNA_PSK ||
auth_mode == WMI_AUTH_FT_RSNA_SAE ||
(auth_mode ==
WMI_AUTH_FT_RSNA_SUITE_B_8021X_SHA384) ||
(auth_mode ==
WMI_AUTH_FT_RSNA_FILS_SHA256) ||
(auth_mode ==
WMI_AUTH_FT_RSNA_FILS_SHA384) ||
(auth_mode == WMI_AUTH_OPEN &&
roam_req->mdid.mdie_present &&
roam_req->is_11r_assoc)) {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
0);
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_11r_offload_tlv_param));
buf_ptr += WMI_TLV_HDR_SIZE;
roam_offload_11r =
(wmi_roam_11r_offload_tlv_param *)buf_ptr;
roam_offload_11r->r0kh_id_len =
roam_req->rokh_id_length;
qdf_mem_copy(roam_offload_11r->r0kh_id,
roam_req->rokh_id,
roam_offload_11r->r0kh_id_len);
fill_roam_offload_11r_params(auth_mode,
roam_offload_11r,
roam_req);
roam_offload_11r->mdie_present =
roam_req->mdid.mdie_present;
roam_offload_11r->mdid =
roam_req->mdid.mobility_domain;
roam_offload_11r->adaptive_11r =
roam_req->is_adaptive_11r;
roam_offload_11r->ft_im_for_deauth =
roam_req->enable_ft_im_roaming;
roam_offload_11r->ft_im_for_deauth =
roam_req->enable_ft_im_roaming;
if (auth_mode == WMI_AUTH_OPEN) {
/*
* If FT-Open ensure pmk length and
* r0khid len are zero
*/
roam_offload_11r->r0kh_id_len = 0;
roam_offload_11r->psk_msk_len = 0;
}
WMITLV_SET_HDR(&roam_offload_11r->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_11r_offload_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_11r_offload_tlv_param));
buf_ptr +=
sizeof(wmi_roam_11r_offload_tlv_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
wmi_debug("psk_msk_len = %d psk_msk_ext:%d",
roam_offload_11r->psk_msk_len,
roam_offload_11r->psk_msk_ext_len);
if (roam_offload_11r->psk_msk_len)
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI,
QDF_TRACE_LEVEL_DEBUG,
roam_offload_11r->psk_msk,
roam_offload_11r->psk_msk_len);
} else {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_roam_11i_offload_tlv_param));
buf_ptr += WMI_TLV_HDR_SIZE;
roam_offload_11i =
(wmi_roam_11i_offload_tlv_param *)buf_ptr;
if (roam_req->fw_okc) {
WMI_SET_ROAM_OFFLOAD_OKC_ENABLED
(roam_offload_11i->flags);
wmi_info("LFR3:OKC enabled");
} else {
WMI_SET_ROAM_OFFLOAD_OKC_DISABLED
(roam_offload_11i->flags);
wmi_info("LFR3:OKC disabled");
}
if (roam_req->fw_pmksa_cache) {
WMI_SET_ROAM_OFFLOAD_PMK_CACHE_ENABLED
(roam_offload_11i->flags);
wmi_info("LFR3:PMKSA caching enabled");
} else {
WMI_SET_ROAM_OFFLOAD_PMK_CACHE_DISABLED
(roam_offload_11i->flags);
wmi_info("LFR3:PMKSA caching disabled");
}
wmi_fill_sae_single_pmk_param(roam_req,
roam_offload_11i);
roam_offload_11i->pmk_len = roam_req->pmk_len >
ROAM_OFFLOAD_PMK_BYTES ?
ROAM_OFFLOAD_PMK_BYTES :
roam_req->pmk_len;
qdf_mem_copy(roam_offload_11i->pmk,
roam_req->psk_pmk,
roam_offload_11i->pmk_len);
roam_offload_11i->pmk_ext_len =
((roam_req->pmk_len >
ROAM_OFFLOAD_PMK_BYTES) &&
(auth_mode ==
WMI_AUTH_RSNA_SUITE_B_8021X_SHA384)) ?
ROAM_OFFLOAD_PMK_EXT_BYTES : 0;
qdf_mem_copy(roam_offload_11i->pmk_ext,
&roam_req->psk_pmk[
ROAM_OFFLOAD_PMK_BYTES],
roam_offload_11i->pmk_ext_len);
WMITLV_SET_HDR(&roam_offload_11i->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_11i_offload_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_11i_offload_tlv_param));
buf_ptr +=
sizeof(wmi_roam_11i_offload_tlv_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
0);
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
0);
buf_ptr += WMI_TLV_HDR_SIZE;
wmi_debug("pmk_len:%d pmk_ext_len:%d",
roam_offload_11i->pmk_len,
roam_offload_11i->pmk_ext_len);
}
} else {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
}
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(*assoc_ies));
buf_ptr += WMI_TLV_HDR_SIZE;
assoc_ies = (wmi_tlv_buf_len_param *)buf_ptr;
WMITLV_SET_HDR(&assoc_ies->tlv_header,
WMITLV_TAG_STRUC_wmi_tlv_buf_len_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_tlv_buf_len_param));
assoc_ies->buf_len = roam_req->assoc_ie_length;
buf_ptr += sizeof(*assoc_ies);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
roundup(assoc_ies->buf_len, sizeof(uint32_t)));
buf_ptr += WMI_TLV_HDR_SIZE;
if (assoc_ies->buf_len != 0)
qdf_mem_copy(buf_ptr, roam_req->assoc_ie,
assoc_ies->buf_len);
buf_ptr += qdf_roundup(assoc_ies->buf_len, sizeof(uint32_t));
buf_ptr = wmi_add_fils_tlv(wmi_handle, roam_req,
buf_ptr, fils_tlv_len);
} else {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
WMITLV_GET_STRUCT_TLVLEN(0));
buf_ptr += WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
WMITLV_GET_STRUCT_TLVLEN(0));
}
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
send_roam_scan_mode_cmd:
wmi_mtrace(WMI_ROAM_SCAN_MODE, NO_SESSION, 0);
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_ROAM_SCAN_MODE);
if (QDF_IS_STATUS_ERROR(status))
wmi_buf_free(buf);
return status;
}
#endif
/** /**
* convert_roam_trigger_reason() - Function to convert unified Roam trigger * convert_roam_trigger_reason() - Function to convert unified Roam trigger
@@ -3336,7 +2567,6 @@ error:
return status; return status;
} }
#ifdef ROAM_OFFLOAD_V1
/** /**
* send_roam_scan_offload_chan_list_cmd_tlv() - set roam offload channel list * send_roam_scan_offload_chan_list_cmd_tlv() - set roam offload channel list
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -3406,81 +2636,7 @@ error:
return status; return status;
} }
#else
/**
* send_roam_scan_offload_chan_list_cmd_tlv() - set roam offload channel list
* @wmi_handle: wmi handle
* @chan_count: channel count
* @chan_list: channel list
* @list_type: list type
* @vdev_id: vdev id
*
* Set roam offload channel list.
*
* Return: QDF status
*/
static QDF_STATUS
send_roam_scan_offload_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t chan_count,
uint32_t *chan_list,
uint8_t list_type, uint32_t vdev_id)
{
wmi_buf_t buf = NULL;
QDF_STATUS status;
int len, list_tlv_len;
int i;
uint8_t *buf_ptr;
wmi_roam_chan_list_fixed_param *chan_list_fp;
uint32_t *roam_chan_list_array;
/* Channel list is a table of 2 TLV's */
list_tlv_len = WMI_TLV_HDR_SIZE + chan_count * sizeof(uint32_t);
len = sizeof(wmi_roam_chan_list_fixed_param) + list_tlv_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
chan_list_fp = (wmi_roam_chan_list_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&chan_list_fp->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_chan_list_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_chan_list_fixed_param));
chan_list_fp->vdev_id = vdev_id;
chan_list_fp->num_chan = chan_count;
if (list_type == WMI_CHANNEL_LIST_STATIC) {
/* external app is controlling channel list */
chan_list_fp->chan_list_type =
WMI_ROAM_SCAN_CHAN_LIST_TYPE_STATIC;
} else {
/* umac supplied occupied channel list in LFR */
chan_list_fp->chan_list_type =
WMI_ROAM_SCAN_CHAN_LIST_TYPE_DYNAMIC;
}
buf_ptr += sizeof(wmi_roam_chan_list_fixed_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
(chan_list_fp->num_chan * sizeof(uint32_t)));
roam_chan_list_array = (uint32_t *)(buf_ptr + WMI_TLV_HDR_SIZE);
for (i = 0; ((i < chan_list_fp->num_chan) &&
(i < WMI_ROAM_MAX_CHANNELS)); i++)
roam_chan_list_array[i] = chan_list[i];
wmi_mtrace(WMI_ROAM_CHAN_LIST, NO_SESSION, 0);
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_ROAM_CHAN_LIST);
if (QDF_IS_STATUS_ERROR(status))
goto error;
return QDF_STATUS_SUCCESS;
error:
wmi_buf_free(buf);
return status;
}
#endif
#ifdef ROAM_OFFLOAD_V1
/** /**
* send_roam_scan_offload_rssi_change_cmd_tlv() - set roam offload RSSI th * send_roam_scan_offload_rssi_change_cmd_tlv() - set roam offload RSSI th
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -3541,63 +2697,6 @@ error:
return status; return status;
} }
#else
/**
* send_roam_scan_offload_rssi_change_cmd_tlv() - set roam offload RSSI th
* @wmi_handle: wmi handle
* @rssi_change_thresh: RSSI Change threshold
* @vdev_id: vdev id
*
* Send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD parameters to fw.
*
* Return: CDF status
*/
static QDF_STATUS
send_roam_scan_offload_rssi_change_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t vdev_id,
int32_t rssi_change_thresh,
uint32_t hirssi_delay_btw_scans)
{
wmi_buf_t buf = NULL;
QDF_STATUS status;
int len;
uint8_t *buf_ptr;
wmi_roam_scan_rssi_change_threshold_fixed_param *rssi_change_fp;
/* Send rssi change parameters */
len = sizeof(wmi_roam_scan_rssi_change_threshold_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
rssi_change_fp =
(wmi_roam_scan_rssi_change_threshold_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&rssi_change_fp->tlv_header,
WMITLV_TAG_STRUC_wmi_roam_scan_rssi_change_threshold_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_roam_scan_rssi_change_threshold_fixed_param));
/* fill in rssi change threshold (hysteresis) values */
rssi_change_fp->vdev_id = vdev_id;
rssi_change_fp->roam_scan_rssi_change_thresh = rssi_change_thresh;
rssi_change_fp->hirssi_delay_btw_scans = hirssi_delay_btw_scans;
wmi_mtrace(WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD, NO_SESSION, 0);
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD);
if (QDF_IS_STATUS_ERROR(status))
goto error;
wmi_nofl_debug("roam_scan_rssi_change_thresh %d hirssi_delay_btw_scans %d",
rssi_change_thresh, hirssi_delay_btw_scans);
return QDF_STATUS_SUCCESS;
error:
wmi_buf_free(buf);
return status;
}
#endif
/** /**
* send_per_roam_config_cmd_tlv() - set per roaming config to FW * send_per_roam_config_cmd_tlv() - set per roaming config to FW