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

qcacld-3.0: Use policy manager frequency APIs

Browse Source 
For 6GHz support and to remove channel number ambiguity use policy
manager APIs updated for frequency in other modules. This change
covers following APIs:

policy_mgr_allow_concurrency
policy_mgr_nan_sap_pre_enable_conc_check
policy_mgr_allow_concurrency_csa
policy_mgr_current_connections_update
policy_mgr_incr_connection_count_utfw
policy_mgr_update_connection_info_utfw
policy_mgr_get_channel_from_scan_result
policy_mgr_update_and_wait_for_connection_update
policy_mgr_get_sap_mandatory_channel
policy_mgr_checkn_update_hw_mode_single_mac_mode

Change-Id: I162c2b90a58539194907c5ecd6915eafecc635cc
CRs-fixed: 2545099
This commit is contained in:
Manikandan Mohan
2019-08-14 17:42:22 -07:00
committed by nshrivas
parent 7fdb02592b
commit 282c4b6f66
13 changed files with 136 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
components/cmn_services/policy_mgr/inc/wlan_policy_mgr_api.h
View File

@@ -717,21 +717,12 @@ bool policy_mgr_is_any_dfs_beaconing_session_present(
* concurrency combination including the new connection is * concurrency combination including the new connection is
* allowed or not based on the HW capability * allowed or not based on the HW capability
* *
* Return: True/False * Return: True/False based on concurrency support
*/ */
bool policy_mgr_allow_concurrency_int(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode,
uint32_t ch_freq,
enum hw_mode_bandwidth bw);
static inline
bool policy_mgr_allow_concurrency(struct wlan_objmgr_psoc *psoc, bool policy_mgr_allow_concurrency(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode, enum policy_mgr_con_mode mode,
uint8_t channel, enum hw_mode_bandwidth bw) uint32_t ch_freq,
{ enum hw_mode_bandwidth bw);
return policy_mgr_allow_concurrency_int(psoc, mode,
wlan_chan_to_freq(channel), bw);
}
/** /**
* policy_mgr_nan_sap_pre_enable_conc_check() - Check if NAN+SAP SCC is * policy_mgr_nan_sap_pre_enable_conc_check() - Check if NAN+SAP SCC is
@@ -743,18 +734,9 @@ bool policy_mgr_allow_concurrency(struct wlan_objmgr_psoc *psoc,
* Return: True if allowed else false * Return: True if allowed else false
*/ */
bool bool
policy_mgr_nan_sap_pre_enable_conc_check_int(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode,
uint32_t ch_freq);
static inline bool
policy_mgr_nan_sap_pre_enable_conc_check(struct wlan_objmgr_psoc *psoc, policy_mgr_nan_sap_pre_enable_conc_check(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode, enum policy_mgr_con_mode mode,
uint8_t ch) uint32_t ch_freq);
{
return policy_mgr_nan_sap_pre_enable_conc_check_int(psoc, mode,
wlan_chan_to_freq(
ch));
}
/** /**
* policy_mgr_allow_concurrency_csa() - Check for allowed concurrency * policy_mgr_allow_concurrency_csa() - Check for allowed concurrency
@@ -778,25 +760,11 @@ policy_mgr_nan_sap_pre_enable_conc_check(struct wlan_objmgr_psoc *psoc,
* *
* Return: True/False * Return: True/False
*/ */
bool policy_mgr_allow_concurrency_csa_int(struct wlan_objmgr_psoc *psoc, bool
enum policy_mgr_con_mode mode, policy_mgr_allow_concurrency_csa(struct wlan_objmgr_psoc *psoc,
uint32_t ch_freq, enum policy_mgr_con_mode mode,
uint32_t vdev_id, uint32_t ch_freq, uint32_t vdev_id,
bool forced, bool forced, enum sap_csa_reason_code reason);
enum sap_csa_reason_code reason);
static inline
bool policy_mgr_allow_concurrency_csa(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode,
uint8_t channel,
uint32_t vdev_id,
bool forced,
enum sap_csa_reason_code reason)
{
return policy_mgr_allow_concurrency_csa_int(psoc, mode,
wlan_chan_to_freq(channel),
vdev_id, forced, reason);
}
/** /**
* policy_mgr_get_first_connection_pcl_table_index() - provides the * policy_mgr_get_first_connection_pcl_table_index() - provides the
@@ -927,20 +895,10 @@ QDF_STATUS policy_mgr_decr_connection_count(struct wlan_objmgr_psoc *psoc,
* Return: QDF_STATUS enum * Return: QDF_STATUS enum
*/ */
QDF_STATUS QDF_STATUS
policy_mgr_current_connections_update_int(struct wlan_objmgr_psoc *psoc,
uint32_t session_id,
uint32_t ch_freq,
enum policy_mgr_conn_update_reason);
static inline QDF_STATUS
policy_mgr_current_connections_update(struct wlan_objmgr_psoc *psoc, policy_mgr_current_connections_update(struct wlan_objmgr_psoc *psoc,
uint32_t session_id, uint8_t channel, uint32_t session_id, uint32_t ch_freq,
enum policy_mgr_conn_update_reason reason) enum policy_mgr_conn_update_reason);
{
return policy_mgr_current_connections_update_int(psoc, session_id,
wlan_chan_to_freq(
channel), reason);
}
/** /**
* policy_mgr_is_dbs_allowed_for_concurrency() - If dbs is allowed for current * policy_mgr_is_dbs_allowed_for_concurrency() - If dbs is allowed for current
* concurreny * concurreny
@@ -1025,27 +983,13 @@ struct policy_mgr_conc_connection_info *policy_mgr_get_conn_info(
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS QDF_STATUS
policy_mgr_incr_connection_count_utfw_int(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, uint32_t tx_streams,
uint32_t rx_streams,
uint32_t chain_mask, uint32_t type,
uint32_t sub_type,
uint32_t ch_freq, uint32_t mac_id);
static inline QDF_STATUS
policy_mgr_incr_connection_count_utfw(struct wlan_objmgr_psoc *psoc, policy_mgr_incr_connection_count_utfw(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, uint32_t tx_streams, uint32_t vdev_id, uint32_t tx_streams,
uint32_t rx_streams, uint32_t chain_mask, uint32_t rx_streams,
uint32_t type, uint32_t sub_type, uint32_t chain_mask, uint32_t type,
uint32_t channelid, uint32_t mac_id) uint32_t sub_type,
{ uint32_t ch_freq, uint32_t mac_id);
return policy_mgr_incr_connection_count_utfw_int(psoc, vdev_id,
tx_streams, rx_streams,
chain_mask, type,
sub_type,
wlan_chan_to_freq(
channelid), mac_id);
}
/** /**
* policy_mgr_update_connection_info_utfw() - updates the * policy_mgr_update_connection_info_utfw() - updates the
* existing connection in the current connections list * existing connection in the current connections list
@@ -1065,30 +1009,13 @@ policy_mgr_incr_connection_count_utfw(struct wlan_objmgr_psoc *psoc,
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS QDF_STATUS
policy_mgr_update_connection_info_utfw_int(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id,
uint32_t tx_streams,
uint32_t rx_streams,
uint32_t chain_mask, uint32_t type,
uint32_t sub_type,
uint32_t ch_freq, uint32_t mac_id);
static inline QDF_STATUS
policy_mgr_update_connection_info_utfw(struct wlan_objmgr_psoc *psoc, policy_mgr_update_connection_info_utfw(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, uint32_t tx_streams, uint32_t vdev_id,
uint32_t tx_streams,
uint32_t rx_streams, uint32_t rx_streams,
uint32_t chain_mask, uint32_t type, uint32_t chain_mask, uint32_t type,
uint32_t sub_type, uint32_t sub_type,
uint32_t channelid, uint32_t mac_id) uint32_t ch_freq, uint32_t mac_id);
{
return policy_mgr_update_connection_info_utfw_int(psoc, vdev_id,
tx_streams,
rx_streams,
chain_mask, type,
sub_type,
wlan_chan_to_freq(
channelid), mac_id);
}
/** /**
* policy_mgr_decr_connection_count_utfw() - remove the old * policy_mgr_decr_connection_count_utfw() - remove the old
@@ -1561,22 +1488,10 @@ bool policy_mgr_map_concurrency_mode(enum QDF_OPMODE *old_mode,
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS QDF_STATUS
policy_mgr_get_channel_from_scan_result_int(struct wlan_objmgr_psoc *psoc,
void *roam_profile,
uint32_t *ch_freq);
static inline QDF_STATUS
policy_mgr_get_channel_from_scan_result(struct wlan_objmgr_psoc *psoc, policy_mgr_get_channel_from_scan_result(struct wlan_objmgr_psoc *psoc,
void *roam_profile, uint8_t *channel) void *roam_profile,
{ uint32_t *ch_freq);
uint32_t ch_freq;
QDF_STATUS status;
status = policy_mgr_get_channel_from_scan_result_int(psoc, roam_profile,
&ch_freq);
*channel = wlan_freq_to_chan(ch_freq);
return status;
}
/** /**
* policy_mgr_mode_specific_num_open_sessions() - to get number of open sessions * policy_mgr_mode_specific_num_open_sessions() - to get number of open sessions
* for a specific mode * for a specific mode
@@ -1796,20 +1711,10 @@ QDF_STATUS policy_mgr_modify_sap_pcl_based_on_mandatory_channel(
* *
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS policy_mgr_update_and_wait_for_connection_update_int( QDF_STATUS policy_mgr_update_and_wait_for_connection_update(
struct wlan_objmgr_psoc *psoc, uint8_t session_id, struct wlan_objmgr_psoc *psoc, uint8_t session_id,
uint32_t ch_freq, enum policy_mgr_conn_update_reason reason); uint32_t ch_freq, enum policy_mgr_conn_update_reason reason);
static inline QDF_STATUS policy_mgr_update_and_wait_for_connection_update(
struct wlan_objmgr_psoc *psoc, uint8_t session_id,
uint8_t channel, enum policy_mgr_conn_update_reason reason)
{
return
policy_mgr_update_and_wait_for_connection_update_int(psoc, session_id,
wlan_chan_to_freq(
channel), reason);
}
/** /**
* policy_mgr_is_sap_mandatory_channel_set() - Checks if SAP * policy_mgr_is_sap_mandatory_channel_set() - Checks if SAP
* mandatory channel is set * mandatory channel is set
@@ -1892,20 +1797,8 @@ QDF_STATUS policy_mgr_get_nss_for_vdev(struct wlan_objmgr_psoc *psoc,
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS QDF_STATUS
policy_mgr_get_sap_mandatory_channel_int(struct wlan_objmgr_psoc *psoc,
uint32_t *ch_freq);
static inline QDF_STATUS
policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc, policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
uint16_t *chan) uint32_t *ch_freq);
{
uint32_t ch_freq;
QDF_STATUS status;
status = policy_mgr_get_sap_mandatory_channel_int(psoc, &ch_freq);
*chan = wlan_freq_to_chan(ch_freq);
return status;
}
/** /**
* policy_mgr_set_sap_mandatory_channels() - Set the mandatory channel for SAP * policy_mgr_set_sap_mandatory_channels() - Set the mandatory channel for SAP
@@ -2133,15 +2026,8 @@ bool policy_mgr_is_hw_mode_change_after_vdev_up(struct wlan_objmgr_psoc *psoc);
* *
* Return: None * Return: None
*/ */
void policy_mgr_checkn_update_hw_mode_single_mac_mode_int(
struct wlan_objmgr_psoc *psoc, uint32_t ch_freq);
static inline
void policy_mgr_checkn_update_hw_mode_single_mac_mode( void policy_mgr_checkn_update_hw_mode_single_mac_mode(
struct wlan_objmgr_psoc *psoc, uint8_t channel) struct wlan_objmgr_psoc *psoc, uint32_t ch_freq);
{
policy_mgr_checkn_update_hw_mode_single_mac_mode_int(
psoc, wlan_chan_to_freq(channel));
}
/** /**
* policy_mgr_dump_connection_status_info() - Dump the concurrency information * policy_mgr_dump_connection_status_info() - Dump the concurrency information

29
components/cmn_services/policy_mgr/src/wlan_policy_mgr_action.c
View File

@@ -369,7 +369,7 @@ QDF_STATUS policy_mgr_update_connection_info(struct wlan_objmgr_psoc *psoc,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
QDF_STATUS policy_mgr_update_and_wait_for_connection_update_int( QDF_STATUS policy_mgr_update_and_wait_for_connection_update(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
uint8_t session_id, uint8_t session_id,
uint32_t ch_freq, uint32_t ch_freq,
@@ -384,7 +384,7 @@ QDF_STATUS policy_mgr_update_and_wait_for_connection_update_int(
if (QDF_IS_STATUS_ERROR(status)) if (QDF_IS_STATUS_ERROR(status))
policy_mgr_err("clearing event failed"); policy_mgr_err("clearing event failed");
status = policy_mgr_current_connections_update_int( status = policy_mgr_current_connections_update(
psoc, session_id, ch_freq, reason); psoc, session_id, ch_freq, reason);
if (QDF_STATUS_E_FAILURE == status) { if (QDF_STATUS_E_FAILURE == status) {
policy_mgr_err("connections update failed"); policy_mgr_err("connections update failed");
@@ -888,11 +888,10 @@ policy_mgr_get_next_action(struct wlan_objmgr_psoc *psoc,
} }
QDF_STATUS QDF_STATUS
policy_mgr_current_connections_update_int(struct wlan_objmgr_psoc *psoc, policy_mgr_current_connections_update(struct wlan_objmgr_psoc *psoc,
uint32_t session_id, uint32_t session_id, uint32_t ch_freq,
uint32_t ch_freq, enum policy_mgr_conn_update_reason
enum policy_mgr_conn_update_reason reason)
reason)
{ {
enum policy_mgr_conc_next_action next_action = PM_NOP; enum policy_mgr_conc_next_action next_action = PM_NOP;
QDF_STATUS status; QDF_STATUS status;
@@ -1227,8 +1226,8 @@ policy_mgr_handle_conc_multiport(struct wlan_objmgr_psoc *psoc,
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
policy_mgr_err("clearing event failed"); policy_mgr_err("clearing event failed");
status = policy_mgr_current_connections_update_int(psoc, session_id, status = policy_mgr_current_connections_update(psoc, session_id,
ch_freq, reason); ch_freq, reason);
if (QDF_STATUS_E_FAILURE == status) { if (QDF_STATUS_E_FAILURE == status) {
policy_mgr_err("connections update failed"); policy_mgr_err("connections update failed");
return status; return status;
@@ -1526,9 +1525,9 @@ bool policy_mgr_nan_sap_scc_on_unsafe_ch_chk_int(struct wlan_objmgr_psoc *psoc,
} }
bool bool
policy_mgr_nan_sap_pre_enable_conc_check_int(struct wlan_objmgr_psoc *psoc, policy_mgr_nan_sap_pre_enable_conc_check(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode, enum policy_mgr_con_mode mode,
uint32_t ch_freq) uint32_t ch_freq)
{ {
struct policy_mgr_psoc_priv_obj *pm_ctx; struct policy_mgr_psoc_priv_obj *pm_ctx;
uint32_t sap_freq, nan_2g_freq, nan_5g_freq; uint32_t sap_freq, nan_2g_freq, nan_5g_freq;
@@ -2402,7 +2401,7 @@ chk_opportunistic_timer:
return status; return status;
} }
void policy_mgr_checkn_update_hw_mode_single_mac_mode_int( void policy_mgr_checkn_update_hw_mode_single_mac_mode(
struct wlan_objmgr_psoc *psoc, uint32_t ch_freq) struct wlan_objmgr_psoc *psoc, uint32_t ch_freq)
{ {
uint8_t i; uint8_t i;
@@ -2559,7 +2558,7 @@ ret_value:
} }
#ifdef MPC_UT_FRAMEWORK #ifdef MPC_UT_FRAMEWORK
QDF_STATUS policy_mgr_update_connection_info_utfw_int( QDF_STATUS policy_mgr_update_connection_info_utfw(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams, uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams,
uint32_t chain_mask, uint32_t type, uint32_t sub_type, uint32_t chain_mask, uint32_t type, uint32_t sub_type,
@@ -2601,7 +2600,7 @@ QDF_STATUS policy_mgr_update_connection_info_utfw_int(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
QDF_STATUS policy_mgr_incr_connection_count_utfw_int( QDF_STATUS policy_mgr_incr_connection_count_utfw(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams, uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams,
uint32_t chain_mask, uint32_t type, uint32_t sub_type, uint32_t chain_mask, uint32_t type, uint32_t sub_type,

34
components/cmn_services/policy_mgr/src/wlan_policy_mgr_get_set_utils.c
View File

@@ -2380,10 +2380,10 @@ done:
return status; return status;
} }
bool policy_mgr_allow_concurrency_int(struct wlan_objmgr_psoc *psoc, bool policy_mgr_allow_concurrency(struct wlan_objmgr_psoc *psoc,
enum policy_mgr_con_mode mode, enum policy_mgr_con_mode mode,
uint32_t ch_freq, uint32_t ch_freq,
enum hw_mode_bandwidth bw) enum hw_mode_bandwidth bw)
{ {
QDF_STATUS status; QDF_STATUS status;
struct policy_mgr_pcl_list pcl; struct policy_mgr_pcl_list pcl;
@@ -2410,12 +2410,11 @@ bool policy_mgr_allow_concurrency_int(struct wlan_objmgr_psoc *psoc,
return allowed; return allowed;
} }
bool policy_mgr_allow_concurrency_csa_int(struct wlan_objmgr_psoc *psoc, bool
enum policy_mgr_con_mode mode, policy_mgr_allow_concurrency_csa(struct wlan_objmgr_psoc *psoc,
uint32_t ch_freq, enum policy_mgr_con_mode mode,
uint32_t vdev_id, uint32_t ch_freq, uint32_t vdev_id,
bool forced, bool forced, enum sap_csa_reason_code reason)
enum sap_csa_reason_code reason)
{ {
bool allow = false; bool allow = false;
struct policy_mgr_conc_connection_info struct policy_mgr_conc_connection_info
@@ -2468,8 +2467,8 @@ bool policy_mgr_allow_concurrency_csa_int(struct wlan_objmgr_psoc *psoc,
policy_mgr_store_and_del_conn_info_by_vdev_id( policy_mgr_store_and_del_conn_info_by_vdev_id(
psoc, vdev_id, info, &num_cxn_del); psoc, vdev_id, info, &num_cxn_del);
allow = policy_mgr_allow_concurrency_int(psoc, mode, ch_freq, allow = policy_mgr_allow_concurrency(psoc, mode, ch_freq,
HW_MODE_20_MHZ); HW_MODE_20_MHZ);
/* Restore the connection entry */ /* Restore the connection entry */
if (num_cxn_del > 0) if (num_cxn_del > 0)
policy_mgr_restore_deleted_conn_info(psoc, info, num_cxn_del); policy_mgr_restore_deleted_conn_info(psoc, info, num_cxn_del);
@@ -2516,7 +2515,7 @@ uint32_t policy_mgr_get_concurrency_mode(struct wlan_objmgr_psoc *psoc)
* *
* Return: QDF_STATUS * Return: QDF_STATUS
*/ */
QDF_STATUS policy_mgr_get_channel_from_scan_result_int( QDF_STATUS policy_mgr_get_channel_from_scan_result(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
void *roam_profile, uint32_t *ch_freq) void *roam_profile, uint32_t *ch_freq)
{ {
@@ -2608,7 +2607,7 @@ uint32_t policy_mgr_search_and_check_for_session_conc(
} else } else
return ch_freq; return ch_freq;
status = policy_mgr_get_channel_from_scan_result_int( status = policy_mgr_get_channel_from_scan_result(
psoc, roam_profile, &ch_freq); psoc, roam_profile, &ch_freq);
if (QDF_STATUS_SUCCESS != status || ch_freq == 0) { if (QDF_STATUS_SUCCESS != status || ch_freq == 0) {
policy_mgr_err("%s error %d %d", policy_mgr_err("%s error %d %d",
@@ -2617,8 +2616,8 @@ uint32_t policy_mgr_search_and_check_for_session_conc(
} }
/* Take care of 160MHz and 80+80Mhz later */ /* Take care of 160MHz and 80+80Mhz later */
ret = policy_mgr_allow_concurrency_int(psoc, mode, ch_freq, ret = policy_mgr_allow_concurrency(psoc, mode, ch_freq,
HW_MODE_20_MHZ); HW_MODE_20_MHZ);
if (false == ret) { if (false == ret) {
policy_mgr_err("Connection failed due to conc check fail"); policy_mgr_err("Connection failed due to conc check fail");
return 0; return 0;
@@ -2727,8 +2726,7 @@ bool policy_mgr_check_for_session_conc(struct wlan_objmgr_psoc *psoc,
} }
/* Take care of 160MHz and 80+80Mhz later */ /* Take care of 160MHz and 80+80Mhz later */
ret = policy_mgr_allow_concurrency_int(psoc, mode, ch_freq, ret = policy_mgr_allow_concurrency(psoc, mode, ch_freq, HW_MODE_20_MHZ);
HW_MODE_20_MHZ);
if (false == ret) { if (false == ret) {
policy_mgr_err("Connection failed due to conc check fail"); policy_mgr_err("Connection failed due to conc check fail");
return 0; return 0;

3
components/cmn_services/policy_mgr/src/wlan_policy_mgr_pcl.c
View File

@@ -2265,8 +2265,7 @@ QDF_STATUS policy_mgr_modify_sap_pcl_based_on_mandatory_channel(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
QDF_STATUS policy_mgr_get_sap_mandatory_channel_int( QDF_STATUS policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_psoc *psoc,
uint32_t *ch_freq) uint32_t *ch_freq)
{ {
QDF_STATUS status; QDF_STATUS status;

19
components/nan/core/src/nan_main.c
View File

@@ -584,9 +584,9 @@ static QDF_STATUS nan_handle_confirm(
return status; return status;
} }
status = policy_mgr_current_connections_update(psoc, status = policy_mgr_current_connections_update(
vdev_id, channel, psoc, vdev_id, wlan_chan_to_freq(channel),
POLICY_MGR_UPDATE_REASON_NDP_UPDATE); POLICY_MGR_UPDATE_REASON_NDP_UPDATE);
if (QDF_STATUS_E_FAILURE == status) { if (QDF_STATUS_E_FAILURE == status) {
nan_err("connections update failed!!"); nan_err("connections update failed!!");
return status; return status;
@@ -1042,7 +1042,8 @@ bool nan_is_enable_allowed(struct wlan_objmgr_psoc *psoc, uint8_t nan_chan)
} }
return (NAN_DISC_DISABLED == nan_get_discovery_state(psoc) && return (NAN_DISC_DISABLED == nan_get_discovery_state(psoc) &&
policy_mgr_allow_concurrency(psoc, PM_NAN_DISC_MODE, nan_chan, policy_mgr_allow_concurrency(psoc, PM_NAN_DISC_MODE,
wlan_chan_to_freq(nan_chan),
HW_MODE_20_MHZ)); HW_MODE_20_MHZ));
} }
@@ -1089,8 +1090,8 @@ QDF_STATUS nan_discovery_pre_enable(struct wlan_objmgr_psoc *psoc,
goto pre_enable_failure; goto pre_enable_failure;
} }
if (!policy_mgr_nan_sap_pre_enable_conc_check(psoc, PM_NAN_DISC_MODE, if (!policy_mgr_nan_sap_pre_enable_conc_check(
nan_social_channel)) { psoc, PM_NAN_DISC_MODE, wlan_chan_to_freq(nan_social_channel))) {
nan_debug("NAN not enabled due to concurrency constraints"); nan_debug("NAN not enabled due to concurrency constraints");
status = QDF_STATUS_E_INVAL; status = QDF_STATUS_E_INVAL;
goto pre_enable_failure; goto pre_enable_failure;
@@ -1106,9 +1107,9 @@ QDF_STATUS nan_discovery_pre_enable(struct wlan_objmgr_psoc *psoc,
vdev_id = wlan_vdev_get_id(vdev); vdev_id = wlan_vdev_get_id(vdev);
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
status = policy_mgr_update_and_wait_for_connection_update(psoc, vdev_id, status = policy_mgr_update_and_wait_for_connection_update(
nan_social_channel, psoc, vdev_id, wlan_chan_to_freq(nan_social_channel),
POLICY_MGR_UPDATE_REASON_NAN_DISCOVERY); POLICY_MGR_UPDATE_REASON_NAN_DISCOVERY);
if (QDF_IS_STATUS_ERROR(status)) { if (QDF_IS_STATUS_ERROR(status)) {
nan_err("Failed to set or wait for HW mode change"); nan_err("Failed to set or wait for HW mode change");
goto pre_enable_failure; goto pre_enable_failure;

36
core/hdd/src/wlan_hdd_cfg80211.c
View File

@@ -9775,7 +9775,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
int ret = 0; int ret = 0;
enum policy_mgr_con_mode intf_mode; enum policy_mgr_con_mode intf_mode;
struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_MAX + 1]; struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_MAX + 1];
uint32_t channel_hint; uint32_t ch_freq, channel_hint;
hdd_enter_dev(ndev); hdd_enter_dev(ndev);
@@ -9809,12 +9809,12 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
return -EINVAL; return -EINVAL;
} }
channel_hint = cds_freq_to_chan(nla_get_u32(tb ch_freq = nla_get_u32(tb[
[QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_FREQ])); QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_FREQ]);
channel_hint = cds_freq_to_chan(ch_freq);
/* check pcl table */ /* check pcl table */
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, intf_mode, if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, intf_mode,
channel_hint, HW_MODE_20_MHZ)) { ch_freq, HW_MODE_20_MHZ)) {
hdd_err("Set channel hint failed due to concurrency check"); hdd_err("Set channel hint failed due to concurrency check");
return -EINVAL; return -EINVAL;
} }
@@ -17613,6 +17613,7 @@ bool wlan_hdd_handle_sap_sta_dfs_conc(struct hdd_adapter *adapter,
struct hdd_hostapd_state *hostapd_state; struct hdd_hostapd_state *hostapd_state;
uint8_t channel = 0; uint8_t channel = 0;
QDF_STATUS status; QDF_STATUS status;
uint32_t ch_freq;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (!hdd_ctx) { if (!hdd_ctx) {
@@ -17658,8 +17659,9 @@ bool wlan_hdd_handle_sap_sta_dfs_conc(struct hdd_adapter *adapter,
* find out by looking in to scan cache where sta is going to * find out by looking in to scan cache where sta is going to
* connect by passing its roam_profile. * connect by passing its roam_profile.
*/ */
status = policy_mgr_get_channel_from_scan_result(hdd_ctx->psoc, status = policy_mgr_get_channel_from_scan_result(
roam_profile, &channel); hdd_ctx->psoc, roam_profile, &ch_freq);
channel = wlan_freq_to_chan(ch_freq);
/* /*
* If the STA's channel is 2.4 GHz, then set pcl with only 2.4 GHz * If the STA's channel is 2.4 GHz, then set pcl with only 2.4 GHz
@@ -19507,8 +19509,10 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
/* Disable NAN Discovery if enabled */ /* Disable NAN Discovery if enabled */
ucfg_nan_disable_concurrency(hdd_ctx->psoc); ucfg_nan_disable_concurrency(hdd_ctx->psoc);
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, if (!policy_mgr_allow_concurrency(
PM_IBSS_MODE, channelNum, HW_MODE_20_MHZ)) { hdd_ctx->psoc, PM_IBSS_MODE,
wlan_reg_chan_to_freq(hdd_ctx->pdev, channelNum),
HW_MODE_20_MHZ)) {
hdd_err("This concurrency combination is not allowed"); hdd_err("This concurrency combination is not allowed");
return -ECONNREFUSED; return -ECONNREFUSED;
} }
@@ -19517,9 +19521,10 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("qdf_reset_connection_update failed status: %d", status); hdd_err("qdf_reset_connection_update failed status: %d", status);
status = policy_mgr_current_connections_update(hdd_ctx->psoc, status = policy_mgr_current_connections_update(
adapter->vdev_id, channelNum, hdd_ctx->psoc, adapter->vdev_id,
POLICY_MGR_UPDATE_REASON_JOIN_IBSS); wlan_reg_chan_to_freq(hdd_ctx->pdev, channelNum),
POLICY_MGR_UPDATE_REASON_JOIN_IBSS);
if (QDF_STATUS_E_FAILURE == status) { if (QDF_STATUS_E_FAILURE == status) {
hdd_err("connections update failed!!"); hdd_err("connections update failed!!");
return -EINVAL; return -EINVAL;
@@ -20396,7 +20401,7 @@ static int __wlan_hdd_cfg80211_connect(struct wiphy *wiphy,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
policy_mgr_convert_device_mode_to_qdf_type( policy_mgr_convert_device_mode_to_qdf_type(
adapter->device_mode), adapter->device_mode),
req->channel->hw_value, HW_MODE_20_MHZ)) { req->channel->center_freq, HW_MODE_20_MHZ)) {
hdd_warn("This concurrency combination is not allowed"); hdd_warn("This concurrency combination is not allowed");
status = -ECONNREFUSED; status = -ECONNREFUSED;
goto con_chk_failed; goto con_chk_failed;
@@ -22680,8 +22685,9 @@ int wlan_hdd_change_hw_mode_for_given_chnl(struct hdd_adapter *adapter,
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("clearing event failed"); hdd_err("clearing event failed");
status = policy_mgr_current_connections_update(hdd_ctx->psoc, status = policy_mgr_current_connections_update(
adapter->vdev_id, channel, reason); hdd_ctx->psoc, adapter->vdev_id,
wlan_chan_to_freq(channel), reason);
switch (status) { switch (status) {
case QDF_STATUS_E_FAILURE: case QDF_STATUS_E_FAILURE:
/* /*

24
core/hdd/src/wlan_hdd_conc_ut.c
View File

@@ -705,10 +705,10 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */ /* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type, &sub_type); wlan_hdd_map_subtypes_hdd_wma(&dummy_type, &sub_type);
/* add first connection as STA */ /* add first connection as STA */
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc, policy_mgr_incr_connection_count_utfw(
vdevid, tx_stream, hdd_ctx->psoc, vdevid, tx_stream,
rx_stream, chain_mask, type, dummy_type, rx_stream, chain_mask, type, dummy_type,
channel_id, mac_id); wlan_chan_to_freq(channel_id), mac_id);
/* validate one connection is created or no */ /* validate one connection is created or no */
if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) { if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) {
hdd_err("Test failed - No. of connection is not 1"); hdd_err("Test failed - No. of connection is not 1");
@@ -811,9 +811,10 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */ /* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type_1, &sub_type_1); wlan_hdd_map_subtypes_hdd_wma(&dummy_type_1, &sub_type_1);
/* add first connection as STA */ /* add first connection as STA */
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc, policy_mgr_incr_connection_count_utfw(
vdevid_1, tx_stream_1, rx_stream_1, chain_mask_1, hdd_ctx->psoc, vdevid_1, tx_stream_1, rx_stream_1,
type_1, dummy_type_1, channel_id_1, mac_id_1); chain_mask_1, type_1, dummy_type_1,
wlan_chan_to_freq(channel_id_1), mac_id_1);
/* validate one connection is created or no */ /* validate one connection is created or no */
if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) { if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) {
hdd_err("Test fail - No. of connection not 1"); hdd_err("Test fail - No. of connection not 1");
@@ -826,10 +827,11 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */ /* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type_2, wlan_hdd_map_subtypes_hdd_wma(&dummy_type_2,
&sub_type_2); &sub_type_2);
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc, policy_mgr_incr_connection_count_utfw(
vdevid_2, tx_stream_2, rx_stream_2, hdd_ctx->psoc, vdevid_2, tx_stream_2,
chain_mask_2, type_2, rx_stream_2, chain_mask_2, type_2,
dummy_type_2, channel_id_2, mac_id_2); dummy_type_2,
wlan_chan_to_freq(channel_id_2), mac_id_2);
/* validate two connections are created or no */ /* validate two connections are created or no */
if (policy_mgr_get_connection_count(hdd_ctx->psoc) if (policy_mgr_get_connection_count(hdd_ctx->psoc)
!= 2) { != 2) {

17
core/hdd/src/wlan_hdd_hostapd.c
View File

@@ -2987,7 +2987,7 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel,
hdd_ctx->psoc, hdd_ctx->psoc,
policy_mgr_convert_device_mode_to_qdf_type( policy_mgr_convert_device_mode_to_qdf_type(
adapter->device_mode), adapter->device_mode),
target_channel, wlan_chan_to_freq(target_channel),
adapter->vdev_id, adapter->vdev_id,
forced, forced,
sap_ctx->csa_reason)) { sap_ctx->csa_reason)) {
@@ -6323,15 +6323,15 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
/* NDI + SAP not supported */ /* NDI + SAP not supported */
ucfg_nan_check_and_disable_unsupported_ndi(hdd_ctx->psoc, true); ucfg_nan_check_and_disable_unsupported_ndi(hdd_ctx->psoc, true);
if (!policy_mgr_nan_sap_pre_enable_conc_check(hdd_ctx->psoc, if (!policy_mgr_nan_sap_pre_enable_conc_check(
PM_SAP_MODE, channel)) hdd_ctx->psoc, PM_SAP_MODE, wlan_chan_to_freq(channel)))
hdd_debug("NAN disabled due to concurrency constraints"); hdd_debug("NAN disabled due to concurrency constraints");
/* check if concurrency is allowed */ /* check if concurrency is allowed */
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
policy_mgr_convert_device_mode_to_qdf_type( policy_mgr_convert_device_mode_to_qdf_type(
adapter->device_mode), adapter->device_mode),
channel, wlan_chan_to_freq(channel),
channel_width)) { channel_width)) {
hdd_err("Connection failed due to concurrency check failure"); hdd_err("Connection failed due to concurrency check failure");
return -EINVAL; return -EINVAL;
@@ -6354,15 +6354,16 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
* back to single MAC 2x2 (if initial was 2x2). * back to single MAC 2x2 (if initial was 2x2).
*/ */
policy_mgr_checkn_update_hw_mode_single_mac_mode(hdd_ctx->psoc, policy_mgr_checkn_update_hw_mode_single_mac_mode(
channel); hdd_ctx->psoc, wlan_chan_to_freq(channel));
if (status != QDF_STATUS_SUCCESS) { if (status != QDF_STATUS_SUCCESS) {
hdd_err("Failed to stop DBS opportunistic timer"); hdd_err("Failed to stop DBS opportunistic timer");
return -EINVAL; return -EINVAL;
} }
status = policy_mgr_current_connections_update(hdd_ctx->psoc, status = policy_mgr_current_connections_update(
adapter->vdev_id, channel, hdd_ctx->psoc, adapter->vdev_id,
wlan_chan_to_freq(channel),
POLICY_MGR_UPDATE_REASON_START_AP); POLICY_MGR_UPDATE_REASON_START_AP);
if (status == QDF_STATUS_E_FAILURE) { if (status == QDF_STATUS_E_FAILURE) {
hdd_err("ERROR: connections update failed!!"); hdd_err("ERROR: connections update failed!!");

7
core/hdd/src/wlan_hdd_sap_cond_chan_switch.c
View File

@@ -330,10 +330,9 @@ static int __wlan_hdd_request_pre_cac(struct hdd_context *hdd_ctx,
* connection update should result in DBS mode * connection update should result in DBS mode
*/ */
status = policy_mgr_update_and_wait_for_connection_update( status = policy_mgr_update_and_wait_for_connection_update(
hdd_ctx->psoc, hdd_ctx->psoc, ap_adapter->vdev_id,
ap_adapter->vdev_id, wlan_chan_to_freq(pre_cac_chan),
pre_cac_chan, POLICY_MGR_UPDATE_REASON_PRE_CAC);
POLICY_MGR_UPDATE_REASON_PRE_CAC);
if (QDF_IS_STATUS_ERROR(status)) { if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("error in moving to DBS mode"); hdd_err("error in moving to DBS mode");
goto stop_close_pre_cac_adapter; goto stop_close_pre_cac_adapter;

15
core/hdd/src/wlan_hdd_wext.c
View File

@@ -7563,9 +7563,11 @@ static int iw_get_policy_manager_ut_ops(struct hdd_context *hdd_ctx,
hdd_err("Invalid input params received for the IOCTL"); hdd_err("Invalid input params received for the IOCTL");
return 0; return 0;
} }
policy_mgr_update_connection_info_utfw(hdd_ctx->psoc, policy_mgr_update_connection_info_utfw(
hdd_ctx->psoc,
apps_args[0], apps_args[1], apps_args[2], apps_args[3], apps_args[0], apps_args[1], apps_args[2], apps_args[3],
apps_args[4], apps_args[5], apps_args[6], apps_args[7]); apps_args[4], apps_args[5],
wlan_chan_to_freq(apps_args[6]), apps_args[7]);
} }
break; break;
@@ -7624,8 +7626,8 @@ static int iw_get_policy_manager_ut_ops(struct hdd_context *hdd_ctx,
return 0; return 0;
} }
policy_mgr_current_connections_update( policy_mgr_current_connections_update(
hdd_ctx->psoc, hdd_ctx->psoc, adapter->vdev_id,
adapter->vdev_id, apps_args[0], wlan_chan_to_freq(apps_args[0]),
POLICY_MGR_UPDATE_REASON_UT); POLICY_MGR_UPDATE_REASON_UT);
} }
break; break;
@@ -7640,8 +7642,9 @@ static int iw_get_policy_manager_ut_ops(struct hdd_context *hdd_ctx,
hdd_err("Invalid input params received for the IOCTL"); hdd_err("Invalid input params received for the IOCTL");
return 0; return 0;
} }
allow = policy_mgr_allow_concurrency(hdd_ctx->psoc, allow = policy_mgr_allow_concurrency(
apps_args[0], apps_args[1], apps_args[2]); hdd_ctx->psoc, apps_args[0],
wlan_chan_to_freq(apps_args[1]), apps_args[2]);
hdd_debug("allow %d {0 = don't allow, 1 = allow}", allow); hdd_debug("allow %d {0 = don't allow, 1 = allow}", allow);
} }
break; break;

7
core/sap/src/sap_fsm.c
View File

@@ -814,10 +814,9 @@ validation_done:
*/ */
qdf_status = qdf_status =
policy_mgr_update_and_wait_for_connection_update( policy_mgr_update_and_wait_for_connection_update(
mac_ctx->psoc, mac_ctx->psoc, sap_context->sessionId,
sap_context->sessionId, sap_context->chan_freq,
sap_ch, POLICY_MGR_UPDATE_REASON_START_AP);
POLICY_MGR_UPDATE_REASON_START_AP);
if (QDF_IS_STATUS_ERROR(qdf_status)) if (QDF_IS_STATUS_ERROR(qdf_status))
return qdf_status; return qdf_status;
} }

7
core/sme/src/csr/csr_api_scan.c
View File

@@ -1170,9 +1170,10 @@ static void csr_handle_nxt_cmd(struct mac_context *mac_ctx,
csr_scan_handle_search_for_ssid_failure(mac_ctx, session_id); csr_scan_handle_search_for_ssid_failure(mac_ctx, session_id);
break; break;
case eCsrNextCheckAllowConc: case eCsrNextCheckAllowConc:
ret = policy_mgr_current_connections_update(mac_ctx->psoc, ret = policy_mgr_current_connections_update(
session_id, chan, mac_ctx->psoc, session_id,
POLICY_MGR_UPDATE_REASON_HIDDEN_STA); wlan_chan_to_freq(chan),
POLICY_MGR_UPDATE_REASON_HIDDEN_STA);
sme_debug("chan: %d session: %d status: %d", sme_debug("chan: %d session: %d status: %d",
chan, session_id, ret); chan, session_id, ret);

14
core/sme/src/csr/csr_util.c
View File

@@ -1026,6 +1026,7 @@ uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx,
uint16_t sap_cfreq = 0; uint16_t sap_cfreq = 0;
uint16_t sap_lfreq, sap_hfreq, intf_lfreq, intf_hfreq, sap_cch = 0; uint16_t sap_lfreq, sap_hfreq, intf_lfreq, intf_hfreq, sap_cch = 0;
QDF_STATUS status; QDF_STATUS status;
uint32_t intf_ch_freq;
sme_debug("sap_ch: %d sap_phymode: %d", sap_ch, sap_phymode); sme_debug("sap_ch: %d sap_phymode: %d", sap_ch, sap_phymode);
@@ -1125,22 +1126,23 @@ uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx,
QDF_MCC_TO_SCC_WITH_PREFERRED_BAND) QDF_MCC_TO_SCC_WITH_PREFERRED_BAND)
intf_ch = 0; intf_ch = 0;
} else if (cc_switch_mode == } else if (cc_switch_mode ==
QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL) { QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL) {
status = status = policy_mgr_get_sap_mandatory_channel(
policy_mgr_get_sap_mandatory_channel( mac_ctx->psoc,
mac_ctx->psoc, &intf_ch_freq);
&intf_ch);
if (QDF_IS_STATUS_ERROR(status)) if (QDF_IS_STATUS_ERROR(status))
sme_err("no mandatory channel"); sme_err("no mandatory channel");
intf_ch = wlan_freq_to_chan(intf_ch_freq);
} }
} else if ((intf_ch == sap_ch) && (cc_switch_mode == } else if ((intf_ch == sap_ch) && (cc_switch_mode ==
QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)) { QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)) {
if (cds_chan_to_band(intf_ch) == CDS_BAND_2GHZ) { if (cds_chan_to_band(intf_ch) == CDS_BAND_2GHZ) {
status = status =
policy_mgr_get_sap_mandatory_channel( policy_mgr_get_sap_mandatory_channel(
mac_ctx->psoc, &intf_ch); mac_ctx->psoc, &intf_ch_freq);
if (QDF_IS_STATUS_ERROR(status)) if (QDF_IS_STATUS_ERROR(status))
sme_err("no mandatory channel"); sme_err("no mandatory channel");
intf_ch = wlan_freq_to_chan(intf_ch_freq);
} }
} }