samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Derivar 0
Código Questões Pedidos de integração Operações Pacotes Planeamentos Lançamentos Wiki Trabalho

qcacld-3.0: HDD change for policy manager restructuring part 1

Ver a proveniência 
Modify HDD code to cope with the policy manager moving to host
common.

CRs-Fixed: 2009818
Change-Id: I6972216f56abdaa28c012449926f640074d4acb5
Este cometimento está contido em:
Tushnim Bhattacharyya
2017-03-09 13:03:31 -08:00
cometido por Sandeep Puligilla
ascendente 9e81b4ca94
cometimento 8716158e35
5 ficheiros modificados com 116 adições e 102 eliminações
Descarregar ficheiro patch Descarregar ficheiro diff Expandir todos os ficheiros Colapsar todos os ficheiros

16
core/hdd/inc/wlan_hdd_conc_ut.h
Ver ficheiro

@@ -31,20 +31,21 @@
/* Include files */
#include "wlan_hdd_main.h"
#include "cds_concurrency.h"
#include "wlan_policy_mgr_api.h"
#ifdef MPC_UT_FRAMEWORK
void clean_report(hdd_context_t *hdd_ctx);
void fill_report(hdd_context_t *hdd_ctx, char *title,
uint32_t first_persona, uint32_t second_persona, uint32_t third_persona,
uint32_t chnl_1st_conn, uint32_t chnl_2nd_conn, uint32_t chnl_3rd_conn,
bool status, enum cds_pcl_type pcl_type, char *reason, uint8_t *pcl);
bool status, enum policy_mgr_pcl_type pcl_type, char *reason,
uint8_t *pcl);
void print_report(hdd_context_t *hdd_ctx);
void wlan_hdd_one_connection_scenario(hdd_context_t *hdd_ctx);
void wlan_hdd_two_connections_scenario(hdd_context_t *hdd_ctx,
uint8_t first_chnl, enum cds_chain_mode first_chain_mask);
uint8_t first_chnl, enum policy_mgr_chain_mode first_chain_mask);
void wlan_hdd_three_connections_scenario(hdd_context_t *hdd_ctx,
uint8_t first_chnl, uint8_t second_chnl,
enum cds_chain_mode chain_mask, uint8_t use_same_mac);
enum policy_mgr_chain_mode chain_mask, uint8_t use_same_mac);
#else
static inline void clean_report(hdd_context_t *hdd_ctx)
{
@@ -53,7 +54,8 @@ static inline void clean_report(hdd_context_t *hdd_ctx)
static inline void fill_report(hdd_context_t *hdd_ctx, char *title,
uint32_t first_persona, uint32_t second_persona, uint32_t third_persona,
uint32_t chnl_1st_conn, uint32_t chnl_2nd_conn, uint32_t chnl_3rd_conn,
bool status, enum cds_pcl_type pcl_type, char *reason, uint8_t *pcl)
bool status, enum policy_mgr_pcl_type pcl_type, char *reason,
uint8_t *pcl)
{
}
@@ -66,13 +68,13 @@ static inline void wlan_hdd_one_connection_scenario(hdd_context_t *hdd_ctx)
}
static inline void wlan_hdd_two_connections_scenario(hdd_context_t *hdd_ctx,
uint8_t first_chnl, enum cds_chain_mode first_chain_mask)
uint8_t first_chnl, enum policy_mgr_chain_mode first_chain_mask)
{
}
static inline void wlan_hdd_three_connections_scenario(hdd_context_t *hdd_ctx,
uint8_t first_chnl, uint8_t second_chnl,
enum cds_chain_mode chain_mask, uint8_t use_same_mac)
enum policy_mgr_chain_mode chain_mask, uint8_t use_same_mac)
{
}
#endif

15
core/hdd/inc/wlan_hdd_main.h
Ver ficheiro

@@ -278,21 +278,6 @@
#define SCAN_REJECT_THRESHOLD_TIME 300000 /* Time is in msec, equal to 5 mins */
/*
* @eHDD_SCAN_REJECT_DEFAULT: default value
* @eHDD_CONNECTION_IN_PROGRESS: connection is in progress
* @eHDD_REASSOC_IN_PROGRESS: reassociation is in progress
* @eHDD_EAPOL_IN_PROGRESS: STA/P2P-CLI is in middle of EAPOL/WPS exchange
* @eHDD_SAP_EAPOL_IN_PROGRESS: SAP/P2P-GO is in middle of EAPOL/WPS exchange
*/
enum scan_reject_states {
eHDD_SCAN_REJECT_DEFAULT = 0,
eHDD_CONNECTION_IN_PROGRESS,
eHDD_REASSOC_IN_PROGRESS,
eHDD_EAPOL_IN_PROGRESS,
eHDD_SAP_EAPOL_IN_PROGRESS,
};
/* Default Psoc id */
#define DEFAULT_PSOC_ID 1

54
core/hdd/src/wlan_hdd_assoc.c
Ver ficheiro

@@ -51,7 +51,7 @@
#include "wlan_hdd_lpass.h"
#include <wlan_logging_sock_svc.h>
#include <cds_sched.h>
#include "cds_concurrency.h"
#include "wlan_policy_mgr_api.h"
#include <cds_utils.h>
#include "sme_power_save_api.h"
#include "wlan_hdd_napi.h"
@@ -1215,8 +1215,8 @@ static void hdd_send_association_event(struct net_device *dev,
}
if (!hdd_is_roam_sync_in_progress(pCsrRoamInfo))
cds_incr_active_session(pAdapter->device_mode,
pAdapter->sessionId);
policy_mgr_incr_active_session(pHddCtx->hdd_psoc,
pAdapter->device_mode, pAdapter->sessionId);
memcpy(wrqu.ap_addr.sa_data, pCsrRoamInfo->pBssDesc->bssId,
sizeof(pCsrRoamInfo->pBssDesc->bssId));
@@ -1311,11 +1311,12 @@ static void hdd_send_association_event(struct net_device *dev,
#endif
} else if (eConnectionState_IbssConnected == /* IBss Associated */
pHddStaCtx->conn_info.connState) {
cds_update_connection_info(pAdapter->sessionId);
policy_mgr_update_connection_info(pHddCtx->hdd_psoc,
pAdapter->sessionId);
memcpy(wrqu.ap_addr.sa_data, pHddStaCtx->conn_info.bssId.bytes,
ETH_ALEN);
ETH_ALEN);
hdd_err("wlan: new IBSS connection to " MAC_ADDRESS_STR,
MAC_ADDR_ARRAY(pHddStaCtx->conn_info.bssId.bytes));
MAC_ADDR_ARRAY(pHddStaCtx->conn_info.bssId.bytes));
ret = hdd_objmgr_add_peer_object(pAdapter->hdd_vdev,
QDF_IBSS_MODE,
@@ -1332,8 +1333,8 @@ static void hdd_send_association_event(struct net_device *dev,
} else { /* Not Associated */
hdd_err("wlan: disconnected");
memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
cds_decr_session_set_pcl(pAdapter->device_mode,
pAdapter->sessionId);
policy_mgr_decr_session_set_pcl(pHddCtx->hdd_psoc,
pAdapter->device_mode, pAdapter->sessionId);
#ifdef FEATURE_WLAN_AUTO_SHUTDOWN
wlan_hdd_auto_shutdown_enable(pHddCtx, true);
@@ -1960,6 +1961,7 @@ static void hdd_send_re_assoc_event(struct net_device *dev,
uint8_t *final_req_ie = NULL;
tCsrRoamConnectedProfile roam_profile;
tHalHandle hal_handle = WLAN_HDD_GET_HAL_CTX(pAdapter);
hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
qdf_mem_zero(&roam_profile, sizeof(roam_profile));
@@ -2008,8 +2010,8 @@ static void hdd_send_re_assoc_event(struct net_device *dev,
* successful reassoc decrement the active session count here.
*/
if (!hdd_is_roam_sync_in_progress(pCsrRoamInfo))
cds_decr_session_set_pcl(pAdapter->device_mode,
pAdapter->sessionId);
policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
pAdapter->device_mode, pAdapter->sessionId);
/* Send the Assoc Resp, the supplicant needs this for initial Auth */
len = pCsrRoamInfo->nAssocRspLength - FT_ASSOC_RSP_IES_OFFSET;
@@ -2428,9 +2430,10 @@ static QDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
/* Indicate 'connect' status to user space */
hdd_send_association_event(dev, pRoamInfo);
if (cds_is_mcc_in_24G()) {
if (policy_mgr_is_mcc_in_24G(pHddCtx->hdd_psoc)) {
if (pHddCtx->miracast_value)
cds_set_mas(pAdapter, pHddCtx->miracast_value);
wlan_hdd_set_mas(pAdapter,
pHddCtx->miracast_value);
}
/* Initialize the Linkup event completion variable */
@@ -2494,7 +2497,8 @@ static QDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
#endif
hdd_info("check for SAP restart");
cds_check_concurrent_intf_and_restart_sap(pAdapter);
policy_mgr_check_concurrent_intf_and_restart_sap(
pHddCtx->hdd_psoc);
DPTRACE(qdf_dp_trace_mgmt_pkt(QDF_DP_TRACE_MGMT_PACKET_RECORD,
pAdapter->sessionId,
@@ -2619,9 +2623,10 @@ static QDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
*/
if (!hdd_is_roam_sync_in_progress
(pRoamInfo))
cds_decr_session_set_pcl
(pAdapter->device_mode,
pAdapter->sessionId);
policy_mgr_decr_session_set_pcl(
pHddCtx->hdd_psoc,
pAdapter->device_mode,
pAdapter->sessionId);
hdd_info("ft_carrier_on is %d, sending roamed indication",
ft_carrier_on);
chan =
@@ -3006,6 +3011,8 @@ static void hdd_roam_ibss_indication_handler(hdd_adapter_t *pAdapter,
eRoamCmdStatus roamStatus,
eCsrRoamResult roamResult)
{
hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
hdd_info("%s: id %d, status %d, result %d",
pAdapter->dev->name, roamId,
roamStatus, roamResult);
@@ -3102,11 +3109,12 @@ static void hdd_roam_ibss_indication_handler(hdd_adapter_t *pAdapter,
bss);
}
if (eCSR_ROAM_RESULT_IBSS_STARTED == roamResult) {
cds_incr_active_session(pAdapter->device_mode,
pAdapter->sessionId);
policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
pAdapter->device_mode, pAdapter->sessionId);
} else if (eCSR_ROAM_RESULT_IBSS_JOIN_SUCCESS == roamResult ||
eCSR_ROAM_RESULT_IBSS_COALESCED == roamResult) {
cds_update_connection_info(pAdapter->sessionId);
policy_mgr_update_connection_info(hdd_ctx->hdd_psoc,
pAdapter->sessionId);
}
break;
}
@@ -4665,6 +4673,7 @@ static void hdd_roam_channel_switch_handler(hdd_adapter_t *adapter,
struct wireless_dev *wdev = dev->ieee80211_ptr;
struct wiphy *wiphy = wdev->wiphy;
QDF_STATUS status;
hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
hdd_info("channel switch for session:%d to channel:%d",
adapter->sessionId, roam_info->chan_info.chan_id);
@@ -4689,7 +4698,8 @@ static void hdd_roam_channel_switch_handler(hdd_adapter_t *adapter,
if (QDF_IS_STATUS_ERROR(status))
hdd_err("channel change notification failed");
status = cds_set_hw_mode_on_channel_switch(adapter->sessionId);
status = policy_mgr_set_hw_mode_on_channel_switch(hdd_ctx->hdd_psoc,
adapter->sessionId);
if (QDF_IS_STATUS_ERROR(status))
hdd_info("set hw mode change not done");
}
@@ -4714,6 +4724,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
hdd_station_ctx_t *pHddStaCtx = NULL;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct cfg80211_bss *bss_status;
hdd_context_t *hdd_ctx;
hdd_info("CSR Callback: status= %d result= %d roamID=%d",
roamStatus, roamResult, roamId);
@@ -4726,6 +4737,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
pWextState = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
/* Omitting eCSR_ROAM_UPDATE_SCAN_RESULT as this is too frequent */
if (eCSR_ROAM_UPDATE_SCAN_RESULT != roamStatus)
@@ -5043,7 +5055,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
hdd_napi_serialize(1);
hdd_set_connection_in_progress(true);
hdd_set_roaming_in_progress(true);
cds_restart_opportunistic_timer(true);
policy_mgr_restart_opportunistic_timer(hdd_ctx->hdd_psoc, true);
break;
case eCSR_ROAM_ABORT:
hdd_info("Firmware aborted roaming operation, previous connection is still valid");

131
core/hdd/src/wlan_hdd_cfg80211.c
Ver ficheiro

@@ -88,7 +88,7 @@
#include "wlan_hdd_stats.h"
#endif
#include "cds_api.h"
#include "cds_concurrency.h"
#include "wlan_policy_mgr_api.h"
#include "qwlan_version.h"
#include "wlan_hdd_memdump.h"
@@ -1214,12 +1214,14 @@ int wlan_hdd_sap_cfg_dfs_override(hdd_adapter_t *adapter)
hdd_adapter_t *con_sap_adapter;
tsap_Config_t *sap_config, *con_sap_config;
int con_ch;
hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
/*
* Check if AP+AP case, once primary AP chooses a DFS
* channel secondary AP should always follow primary APs channel
*/
if (!cds_concurrent_beaconing_sessions_running())
if (!policy_mgr_concurrent_beaconing_sessions_running(
hdd_ctx->hdd_psoc))
return 0;
con_sap_adapter = hdd_get_con_sap_adapter(adapter, true);
@@ -2001,7 +2003,7 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
hdd_debug("get pcl for DO_ACS vendor command");
/* consult policy manager to get PCL */
status = cds_get_pcl(CDS_SAP_MODE,
status = policy_mgr_get_pcl(hdd_ctx->hdd_psoc, PM_SAP_MODE,
sap_config->acs_cfg.pcl_channels,
&sap_config->acs_cfg.pcl_ch_count,
sap_config->acs_cfg.pcl_channels_weight_list,
@@ -2690,7 +2692,7 @@ __wlan_hdd_cfg80211_get_features(struct wiphy *wiphy,
wlan_hdd_cfg80211_set_feature(feature_flags,
QCA_WLAN_VENDOR_FEATURE_SUPPORT_HW_MODE_ANY);
if (wma_is_scan_simultaneous_capable())
if (policy_mgr_is_scan_simultaneous_capable(hdd_ctx_ptr->hdd_psoc))
wlan_hdd_cfg80211_set_feature(feature_flags,
QCA_WLAN_VENDOR_FEATURE_OFFCHANNEL_SIMULTANEOUS);
@@ -2710,7 +2712,8 @@ __wlan_hdd_cfg80211_get_features(struct wiphy *wiphy,
sizeof(feature_flags), feature_flags))
goto nla_put_failure;
ret = wma_get_dbs_hw_modes(&one_by_one_dbs, &two_by_two_dbs);
ret = policy_mgr_get_dbs_hw_modes(hdd_ctx_ptr->hdd_psoc,
&one_by_one_dbs, &two_by_two_dbs);
if (QDF_STATUS_SUCCESS == ret) {
if (one_by_one_dbs)
dbs_capability = DRV_DBS_CAPABILITY_1X1;
@@ -5794,7 +5797,7 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
uint8_t pcl[QDF_MAX_NUM_CHAN], weight_list[QDF_MAX_NUM_CHAN];
uint32_t pcl_len = 0;
uint32_t freq_list[QDF_MAX_NUM_CHAN];
enum cds_con_mode intf_mode;
enum policy_mgr_con_mode intf_mode;
struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST_MAX + 1];
struct sk_buff *reply_skb;
@@ -5818,14 +5821,15 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
intf_mode = nla_get_u32(tb
[QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST_IFACE_TYPE]);
if (intf_mode < CDS_STA_MODE || intf_mode >= CDS_MAX_NUM_OF_MODE) {
if (intf_mode < PM_STA_MODE || intf_mode >= PM_MAX_NUM_OF_MODE) {
hdd_err("Invalid interface type");
return -EINVAL;
}
hdd_debug("Userspace requested pref freq list");
status = cds_get_pcl(intf_mode, pcl, &pcl_len,
status = policy_mgr_get_pcl(hdd_ctx->hdd_psoc,
intf_mode, pcl, &pcl_len,
weight_list, QDF_ARRAY_SIZE(weight_list));
if (status != QDF_STATUS_SUCCESS) {
hdd_err("Get pcl failed");
@@ -5914,7 +5918,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
hdd_adapter_t *adapter = WLAN_HDD_GET_PRIV_PTR(ndev);
hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
int ret = 0;
enum cds_con_mode intf_mode;
enum policy_mgr_con_mode intf_mode;
struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST_MAX + 1];
uint32_t channel_hint;
@@ -5938,7 +5942,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
intf_mode = nla_get_u32(tb
[QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_IFACE_TYPE]);
if (intf_mode < CDS_STA_MODE || intf_mode >= CDS_MAX_NUM_OF_MODE) {
if (intf_mode < PM_STA_MODE || intf_mode >= PM_MAX_NUM_OF_MODE) {
hdd_err("Invalid interface type");
return -EINVAL;
}
@@ -5952,7 +5956,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
[QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_FREQ]));
/* check pcl table */
if (!cds_allow_concurrency(intf_mode,
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc, intf_mode,
channel_hint, HW_MODE_20_MHZ)) {
hdd_err("Set channel hint failed due to concurrency check");
return -EINVAL;
@@ -5961,12 +5965,12 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
if (0 != wlan_hdd_check_remain_on_channel(adapter))
hdd_warn("Remain On Channel Pending");
ret = qdf_reset_connection_update();
ret = policy_mgr_reset_connection_update(hdd_ctx->hdd_psoc);
if (!QDF_IS_STATUS_SUCCESS(ret))
hdd_err("clearing event failed");
ret = cds_current_connections_update(adapter->sessionId,
channel_hint,
ret = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc,
adapter->sessionId, channel_hint,
SIR_UPDATE_REASON_SET_OPER_CHAN);
if (QDF_STATUS_E_FAILURE == ret) {
/* return in the failure case */
@@ -5981,7 +5985,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
* For any other return value it should be a pass
* through
*/
ret = qdf_wait_for_connection_update();
ret = policy_mgr_wait_for_connection_update(hdd_ctx->hdd_psoc);
if (!QDF_IS_STATUS_SUCCESS(ret)) {
hdd_err("ERROR: qdf wait for event failed!!");
return -EINVAL;
@@ -7365,12 +7369,13 @@ static int wlan_hdd_validate_and_get_pre_cac_ch(hdd_context_t *hdd_ctx,
* 6. But, we are in need of a DFS channel. So, going with the
* first channel from the valid channel list.
*/
status = cds_get_valid_chans(channel_list, &len);
status = policy_mgr_get_valid_chans(hdd_ctx->hdd_psoc,
channel_list, &len);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("Failed to get channel list");
return -EINVAL;
}
cds_update_with_safe_channel_list(channel_list, &len,
policy_mgr_update_with_safe_channel_list(channel_list, &len,
pcl_weights, weight_len);
ret = wlan_hdd_sap_get_nol(ap_adapter, nol, &nol_len);
for (i = 0; i < len; i++) {
@@ -7439,7 +7444,7 @@ int wlan_hdd_request_pre_cac(uint8_t channel)
if (0 != wlan_hdd_validate_context(hdd_ctx))
return -EINVAL;
if (cds_get_connection_count() > 1) {
if (policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) > 1) {
hdd_err("pre cac not allowed in concurrency");
return -EINVAL;
}
@@ -7593,7 +7598,8 @@ int wlan_hdd_request_pre_cac(uint8_t channel)
* Since current SAP is in 2.4GHz and pre CAC channel is in 5GHz, this
* connection update should result in DBS mode
*/
status = cds_update_and_wait_for_connection_update(
status = policy_mgr_update_and_wait_for_connection_update(
hdd_ctx->hdd_psoc,
ap_adapter->sessionId,
pre_cac_chan,
SIR_UPDATE_REASON_PRE_CAC);
@@ -8130,7 +8136,8 @@ __wlan_hdd_cfg80211_sap_configuration_set(struct wiphy *wiphy,
hdd_debug("freq[%d]=%d", i, freq[i]);
}
status = cds_set_sap_mandatory_channels(chans, freq_len);
status = policy_mgr_set_sap_mandatory_channels(
hdd_ctx->hdd_psoc, chans, freq_len);
if (QDF_IS_STATUS_ERROR(status))
return -EINVAL;
}
@@ -11097,7 +11104,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
return -EINVAL;
}
if (!cds_allow_concurrency(
if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
wlan_hdd_convert_nl_iftype_to_hdd_type(type),
0, HW_MODE_20_MHZ)) {
hdd_debug("This concurrency combination is not allowed");
@@ -11108,7 +11115,8 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
wdev = ndev->ieee80211_ptr;
/* Reset the current device mode bit mask */
cds_clear_concurrency_mode(pAdapter->device_mode);
policy_mgr_clear_concurrency_mode(pHddCtx->hdd_psoc,
pAdapter->device_mode);
hdd_update_tdls_ct_and_teardown_links(pHddCtx);
if ((pAdapter->device_mode == QDF_STA_MODE) ||
@@ -11244,7 +11252,8 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
}
done:
/* Set bitmask based on updated value */
cds_set_concurrency_mode(pAdapter->device_mode);
policy_mgr_set_concurrency_mode(pHddCtx->hdd_psoc,
pAdapter->device_mode);
hdd_lpass_notify_mode_change(pAdapter);
@@ -12873,7 +12882,7 @@ static bool wlan_hdd_handle_sap_sta_dfs_conc(hdd_adapter_t *adapter,
* find out by looking in to scan cache where sta is going to
* connect by passing its roam_profile.
*/
status = cds_get_channel_from_scan_result(adapter,
status = policy_mgr_get_channel_from_scan_result(hdd_ctx->hdd_psoc,
roam_profile, &channel);
/*
@@ -12892,8 +12901,8 @@ static bool wlan_hdd_handle_sap_sta_dfs_conc(hdd_adapter_t *adapter,
* scenario.
*/
if ((0 == channel) || CDS_IS_DFS_CH(channel))
channel = cds_get_nondfs_preferred_channel(CDS_SAP_MODE,
true);
channel = policy_mgr_get_nondfs_preferred_channel(
hdd_ctx->hdd_psoc, PM_SAP_MODE, true);
hostapd_state = WLAN_HDD_GET_HOSTAP_STATE_PTR(ap_adapter);
qdf_event_reset(&hostapd_state->qdf_event);
@@ -13003,7 +13012,7 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
goto ret_status;
}
if (true == cds_is_connection_in_progress(NULL, NULL)) {
if (true == hdd_is_connection_in_progress(NULL, NULL)) {
hdd_err("Connection refused: conn in progress");
status = -EINVAL;
goto ret_status;
@@ -13024,16 +13033,19 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
*
* Else set connect_in_progress as true and proceed.
*/
cds_restart_opportunistic_timer(false);
if (cds_is_hw_mode_change_in_progress()) {
status = qdf_wait_for_connection_update();
policy_mgr_restart_opportunistic_timer(
pHddCtx->hdd_psoc, false);
if (policy_mgr_is_hw_mode_change_in_progress(
pHddCtx->hdd_psoc)) {
status = policy_mgr_wait_for_connection_update(
pHddCtx->hdd_psoc);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("qdf wait for event failed!!");
status = -EINVAL;
goto ret_status;
}
}
cds_set_connection_in_progress(true);
hdd_set_connection_in_progress(true);
if (HDD_WMM_USER_MODE_NO_QOS ==
(WLAN_HDD_GET_CTX(pAdapter))->config->WmmMode) {
@@ -13197,8 +13209,8 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
pAdapter->scan_info.scanAddIE.length;
}
if ((wma_is_hw_dbs_capable() == true) &&
(false == wlan_hdd_handle_sap_sta_dfs_conc(pAdapter,
if ((policy_mgr_is_hw_dbs_capable(pHddCtx->hdd_psoc) == true)
&& (false == wlan_hdd_handle_sap_sta_dfs_conc(pAdapter,
pRoamProfile))) {
hdd_err("sap-sta conc will fail, can't allow sta");
hdd_conn_set_connection_state(pAdapter,
@@ -13273,20 +13285,22 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
}
/* Reset connect_in_progress */
cds_set_connection_in_progress(false);
hdd_set_connection_in_progress(false);
pRoamProfile->ChannelInfo.ChannelList = NULL;
pRoamProfile->ChannelInfo.numOfChannels = 0;
if ((QDF_STA_MODE == pAdapter->device_mode)
&& wma_is_current_hwmode_dbs() &&
!wma_is_hw_dbs_2x2_capable()) {
cds_get_channel_from_scan_result(pAdapter,
pRoamProfile, &channel);
&& policy_mgr_is_current_hwmode_dbs(pHddCtx->hdd_psoc)
&& !policy_mgr_is_hw_dbs_2x2_capable(
pHddCtx->hdd_psoc)) {
policy_mgr_get_channel_from_scan_result(
pHddCtx->hdd_psoc,
pRoamProfile, &channel);
hdd_info("Move to single MAC mode(optimization) if applicable");
if (channel)
cds_checkn_update_hw_mode_single_mac_mode
(channel);
policy_mgr_checkn_update_hw_mode_single_mac_mode(
pHddCtx->hdd_psoc, channel);
}
} else {
@@ -13297,7 +13311,7 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
conn_failure:
/* Reset connect_in_progress */
cds_set_connection_in_progress(false);
hdd_set_connection_in_progress(false);
ret_status:
EXIT();
@@ -14182,16 +14196,16 @@ static int __wlan_hdd_cfg80211_connect(struct wiphy *wiphy,
/* Check for max concurrent connections after doing disconnect if any */
if (req->channel) {
if (!cds_allow_concurrency(
cds_convert_device_mode_to_qdf_type(
if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
policy_mgr_convert_device_mode_to_qdf_type(
pAdapter->device_mode),
req->channel->hw_value, HW_MODE_20_MHZ)) {
hdd_err("This concurrency combination is not allowed");
return -ECONNREFUSED;
}
} else {
if (!cds_allow_concurrency(
cds_convert_device_mode_to_qdf_type(
if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
policy_mgr_convert_device_mode_to_qdf_type(
pAdapter->device_mode), 0, HW_MODE_20_MHZ)) {
hdd_err("This concurrency combination is not allowed");
return -ECONNREFUSED;
@@ -14725,18 +14739,18 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
}
}
if (!cds_allow_concurrency(CDS_IBSS_MODE, channelNum,
HW_MODE_20_MHZ)) {
if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
PM_IBSS_MODE, channelNum, HW_MODE_20_MHZ)) {
hdd_err("This concurrency combination is not allowed");
return -ECONNREFUSED;
}
status = qdf_reset_connection_update();
status = policy_mgr_reset_connection_update(pHddCtx->hdd_psoc);
if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("ERR: clear event failed");
status = cds_current_connections_update(pAdapter->sessionId,
channelNum,
status = policy_mgr_current_connections_update(pHddCtx->hdd_psoc,
pAdapter->sessionId, channelNum,
SIR_UPDATE_REASON_JOIN_IBSS);
if (QDF_STATUS_E_FAILURE == status) {
hdd_err("ERROR: connections update failed!!");
@@ -14744,7 +14758,8 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
}
if (QDF_STATUS_SUCCESS == status) {
status = qdf_wait_for_connection_update();
status = policy_mgr_wait_for_connection_update(
pHddCtx->hdd_psoc);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("ERROR: qdf wait for event failed!!");
return -EINVAL;
@@ -16537,25 +16552,25 @@ static int wlan_hdd_cfg80211_channel_switch(struct wiphy *wiphy,
*
* Return: cds_con_mode enum
*/
enum cds_con_mode wlan_hdd_convert_nl_iftype_to_hdd_type(
enum policy_mgr_con_mode wlan_hdd_convert_nl_iftype_to_hdd_type(
enum nl80211_iftype type)
{
enum cds_con_mode mode = CDS_MAX_NUM_OF_MODE;
enum policy_mgr_con_mode mode = PM_MAX_NUM_OF_MODE;
switch (type) {
case NL80211_IFTYPE_STATION:
mode = CDS_STA_MODE;
mode = PM_STA_MODE;
break;
case NL80211_IFTYPE_P2P_CLIENT:
mode = CDS_P2P_CLIENT_MODE;
mode = PM_P2P_CLIENT_MODE;
break;
case NL80211_IFTYPE_P2P_GO:
mode = CDS_P2P_GO_MODE;
mode = PM_P2P_GO_MODE;
break;
case NL80211_IFTYPE_AP:
mode = CDS_SAP_MODE;
mode = PM_SAP_MODE;
break;
case NL80211_IFTYPE_ADHOC:
mode = CDS_IBSS_MODE;
mode = PM_IBSS_MODE;
break;
default:
hdd_err("Unsupported interface type (%d)",

2
core/hdd/src/wlan_hdd_cfg80211.h
Ver ficheiro

@@ -328,7 +328,7 @@ int wlan_hdd_cfg80211_update_apies(hdd_adapter_t *adapter);
int wlan_hdd_request_pre_cac(uint8_t channel);
int wlan_hdd_sap_cfg_dfs_override(hdd_adapter_t *adapter);
enum cds_con_mode wlan_hdd_convert_nl_iftype_to_hdd_type(
enum policy_mgr_con_mode wlan_hdd_convert_nl_iftype_to_hdd_type(
enum nl80211_iftype type);
int wlan_hdd_disable_dfs_chan_scan(hdd_context_t *hdd_ctx,