A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-09 05:39:54 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Introduce hdd_contex.psoc

Browse source 
The name 'hdd_psoc' is misleading, since it is not actually an HDD psoc
context. Rather, it is the Object Manager psoc context. Rename hdd_psoc
to psoc for consistency, and to make room for HDD to have its own psoc
context.

As a first step towards this large renaming, introduce a union in
hdd_context such that such both names can exist during the transition
period.

Change-Id: I9971c478c0d1dc111bb20a7cd6614f73ffb0b15d
CRs-Fixed: 2315990
This commit is contained in:
Dustin Brown 2018-09-11 16:03:05 -07:00 • committed by nshrivas
commit 76cd293220
8 changed files with 104 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

6
core/hdd/inc/wlan_hdd_main.h
View file

@ -1702,11 +1702,15 @@ struct hdd_cache_channels {
/**
* struct hdd_context - hdd shared driver and psoc/device context
* @psoc: object manager psoc context
* @pdev: object manager pdev context
* @g_event_flags: a bitmap of hdd_driver_flags
*/
struct hdd_context {
struct wlan_objmgr_psoc *hdd_psoc;
union {
struct wlan_objmgr_psoc *psoc;
struct wlan_objmgr_psoc *hdd_psoc;
};
struct wlan_objmgr_pdev *pdev;
mac_handle_t mac_handle;
struct wiphy *wiphy;

8
core/hdd/src/wlan_hdd_active_tos.c
View file

@ -111,22 +111,22 @@ hdd_set_limit_off_chan_for_tos(struct hdd_adapter *adapter,
if (adapter->active_ac & HDD_AC_VO_BIT) {
max_off_chan_time =
limit_off_chan_tbl[TOS_VO][HDD_DWELL_TIME_INDX];
policy_mgr_set_cur_conc_system_pref(hdd_ctx->hdd_psoc,
policy_mgr_set_cur_conc_system_pref(hdd_ctx->psoc,
PM_LATENCY);
} else if (adapter->active_ac & HDD_AC_VI_BIT) {
max_off_chan_time =
limit_off_chan_tbl[TOS_VI][HDD_DWELL_TIME_INDX];
policy_mgr_set_cur_conc_system_pref(hdd_ctx->hdd_psoc,
policy_mgr_set_cur_conc_system_pref(hdd_ctx->psoc,
PM_LATENCY);
} else {
/*ignore this command if only BE/BK is active */
is_tos_active = false;
policy_mgr_set_cur_conc_system_pref(hdd_ctx->hdd_psoc,
policy_mgr_set_cur_conc_system_pref(hdd_ctx->psoc,
hdd_ctx->config->conc_system_pref);
}
} else {
/* No active tos */
policy_mgr_set_cur_conc_system_pref(hdd_ctx->hdd_psoc,
policy_mgr_set_cur_conc_system_pref(hdd_ctx->psoc,
hdd_ctx->config->conc_system_pref);
}

34
core/hdd/src/wlan_hdd_assoc.c
View file

@ -1352,7 +1352,7 @@ static void hdd_send_association_event(struct net_device *dev,
}
if (!hdd_is_roam_sync_in_progress(pCsrRoamInfo)) {
policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
policy_mgr_incr_active_session(hdd_ctx->psoc,
adapter->device_mode, adapter->session_id);
hdd_green_ap_start_state_mc(hdd_ctx,
adapter->device_mode, true);
@ -1433,7 +1433,7 @@ static void hdd_send_association_event(struct net_device *dev,
#endif
} else if (eConnectionState_IbssConnected == /* IBss Associated */
sta_ctx->conn_info.connState) {
policy_mgr_update_connection_info(hdd_ctx->hdd_psoc,
policy_mgr_update_connection_info(hdd_ctx->psoc,
adapter->session_id);
memcpy(wrqu.ap_addr.sa_data, sta_ctx->conn_info.bssId.bytes,
ETH_ALEN);
@ -1442,7 +1442,7 @@ static void hdd_send_association_event(struct net_device *dev,
} else { /* Not Associated */
hdd_debug("wlan: disconnected");
memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
adapter->device_mode, adapter->session_id);
hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
false);
@ -1870,7 +1870,7 @@ static QDF_STATUS hdd_dis_connect_handler(struct hdd_adapter *adapter,
wlan_hdd_clear_link_layer_stats(adapter);
hdd_debug("check for SAP restart");
policy_mgr_check_concurrent_intf_and_restart_sap(hdd_ctx->hdd_psoc);
policy_mgr_check_concurrent_intf_and_restart_sap(hdd_ctx->psoc);
adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
/* Unblock anyone waiting for disconnect to complete */
@ -1884,7 +1884,7 @@ static QDF_STATUS hdd_dis_connect_handler(struct hdd_adapter *adapter,
hdd_print_bss_info(sta_ctx);
if (policy_mgr_is_sta_active_connection_exists(hdd_ctx->hdd_psoc))
if (policy_mgr_is_sta_active_connection_exists(hdd_ctx->psoc))
sme_enable_roaming_on_connected_sta(mac_handle);
return status;
@ -2321,7 +2321,7 @@ 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)) {
policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
adapter->device_mode, adapter->session_id);
hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
false);
@ -2811,7 +2811,7 @@ hdd_association_completion_handler(struct hdd_adapter *adapter,
/* Indicate 'connect' status to user space */
hdd_send_association_event(dev, roam_info);
if (policy_mgr_is_mcc_in_24G(hdd_ctx->hdd_psoc)) {
if (policy_mgr_is_mcc_in_24G(hdd_ctx->psoc)) {
if (hdd_ctx->miracast_value)
wlan_hdd_set_mas(adapter,
hdd_ctx->miracast_value);
@ -2879,7 +2879,7 @@ hdd_association_completion_handler(struct hdd_adapter *adapter,
#endif
hdd_debug("check if STA chan ok for DNBS");
if (policy_mgr_is_chan_ok_for_dnbs(hdd_ctx->hdd_psoc,
if (policy_mgr_is_chan_ok_for_dnbs(hdd_ctx->psoc,
sta_ctx->conn_info.operationChannel,
&ok)) {
hdd_err("Unable to check DNBS eligibility for chan:%d",
@ -3045,7 +3045,7 @@ hdd_association_completion_handler(struct hdd_adapter *adapter,
if (!hdd_is_roam_sync_in_progress
(roam_info)) {
policy_mgr_decr_session_set_pcl(
hdd_ctx->hdd_psoc,
hdd_ctx->psoc,
adapter->device_mode,
adapter->session_id);
hdd_green_ap_start_state_mc(
@ -3286,15 +3286,15 @@ hdd_association_completion_handler(struct hdd_adapter *adapter,
#endif
hdd_debug("check for SAP restart");
policy_mgr_check_concurrent_intf_and_restart_sap(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (roam_info->pBssDesc)
policy_mgr_checkn_update_hw_mode_single_mac_mode
(hdd_ctx->hdd_psoc,
(hdd_ctx->psoc,
roam_info->pBssDesc->channelId);
} else {
bool connect_timeout = false;
/* do we need to change the HW mode */
policy_mgr_check_n_start_opportunistic_timer(hdd_ctx->hdd_psoc);
policy_mgr_check_n_start_opportunistic_timer(hdd_ctx->psoc);
if (roam_info && roam_info->is_fils_connection &&
eCSR_ROAM_RESULT_SCAN_FOR_SSID_FAILURE == roamResult)
qdf_copy_macaddr(&roam_info->bssid,
@ -3554,13 +3554,13 @@ static void hdd_roam_ibss_indication_handler(struct hdd_adapter *adapter,
bss);
}
if (eCSR_ROAM_RESULT_IBSS_STARTED == roamResult) {
policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
policy_mgr_incr_active_session(hdd_ctx->psoc,
adapter->device_mode, adapter->session_id);
hdd_green_ap_start_state_mc(hdd_ctx,
adapter->device_mode, true);
} else if (eCSR_ROAM_RESULT_IBSS_JOIN_SUCCESS == roamResult ||
eCSR_ROAM_RESULT_IBSS_COALESCED == roamResult) {
policy_mgr_update_connection_info(hdd_ctx->hdd_psoc,
policy_mgr_update_connection_info(hdd_ctx->psoc,
adapter->session_id);
}
break;
@ -4552,9 +4552,9 @@ static void hdd_roam_channel_switch_handler(struct hdd_adapter *adapter,
hdd_err("channel change notification failed");
hdd_debug("check for SAP restart");
policy_mgr_check_concurrent_intf_and_restart_sap(hdd_ctx->hdd_psoc);
policy_mgr_check_concurrent_intf_and_restart_sap(hdd_ctx->psoc);
status = policy_mgr_set_hw_mode_on_channel_switch(hdd_ctx->hdd_psoc,
status = policy_mgr_set_hw_mode_on_channel_switch(hdd_ctx->psoc,
adapter->session_id);
if (QDF_IS_STATUS_ERROR(status))
hdd_debug("set hw mode change not done");
@ -4888,7 +4888,7 @@ hdd_sme_roam_callback(void *pContext, struct csr_roam_info *roam_info,
hdd_napi_serialize(1);
hdd_set_connection_in_progress(true);
hdd_set_roaming_in_progress(true);
policy_mgr_restart_opportunistic_timer(hdd_ctx->hdd_psoc, true);
policy_mgr_restart_opportunistic_timer(hdd_ctx->psoc, true);
break;
case eCSR_ROAM_ABORT:
hdd_debug("Firmware aborted roaming operation, previous connection is still valid");

10
core/hdd/src/wlan_hdd_cfg.c
View file

@ -6090,7 +6090,7 @@ static void hdd_set_fine_time_meas_cap(struct hdd_context *hdd_ctx)
/* Make sure only supported capabilities are enabled in INI */
capability &= CFG_FINE_TIME_MEAS_CAPABILITY_MAX;
ucfg_wifi_pos_set_ftm_cap(hdd_ctx->hdd_psoc, capability);
ucfg_wifi_pos_set_ftm_cap(hdd_ctx->psoc, capability);
hdd_debug("fine time meas capability - INI: %04x Enabled: %04x",
config->fine_time_meas_cap,
@ -6648,7 +6648,7 @@ QDF_STATUS hdd_set_policy_mgr_user_cfg(struct hdd_context *hdd_ctx)
hdd_ctx->config->sta_sap_scc_on_lte_coex_chan;
user_cfg->dbs_selection_policy = hdd_ctx->config->dbs_selection_policy;
user_cfg->vdev_priority_list = hdd_ctx->config->vdev_priority_list;
status = policy_mgr_set_user_cfg(hdd_ctx->hdd_psoc, user_cfg);
status = policy_mgr_set_user_cfg(hdd_ctx->psoc, user_cfg);
qdf_mem_free(user_cfg);
return status;
@ -7134,7 +7134,7 @@ QDF_STATUS hdd_set_sme_config(struct hdd_context *hdd_ctx)
hdd_ctx->config->min_delay_btw_roam_scans;
smeConfig->csrConfig.roam_trigger_reason_bitmask =
hdd_ctx->config->roam_trigger_reason_bitmask;
status = ucfg_mlme_get_ignore_peer_ht_mode(hdd_ctx->hdd_psoc,
status = ucfg_mlme_get_ignore_peer_ht_mode(hdd_ctx->psoc,
&ignore_peer_ht_mode);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("Get ignore_peer_ht_mode failed");
@ -7492,7 +7492,7 @@ QDF_STATUS hdd_update_nss(struct hdd_adapter *adapter, uint8_t nss)
hdd_err("Could not pass on WNI_CFG_VHT_TX_HIGHEST_SUPPORTED_DATA_RATE to CFG");
}
qdf_status = ucfg_mlme_get_ht_cap_info(hdd_ctx->hdd_psoc, &ht_cap_info);
qdf_status = ucfg_mlme_get_ht_cap_info(hdd_ctx->psoc, &ht_cap_info);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
hdd_err("Failed to get HT Cap info");
status = false;
@ -7506,7 +7506,7 @@ QDF_STATUS hdd_update_nss(struct hdd_adapter *adapter, uint8_t nss)
ht_cap_info.tx_stbc = val32;
}
qdf_status = ucfg_mlme_set_ht_cap_info(hdd_ctx->hdd_psoc, ht_cap_info);
qdf_status = ucfg_mlme_set_ht_cap_info(hdd_ctx->psoc, ht_cap_info);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
status = false;
hdd_err("Could not set the HT_CAP_INFO");

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

@ -755,7 +755,7 @@ static int __wlan_hdd_cfg80211_get_tdls_capabilities(struct wiphy *wiphy,
goto fail;
}
if ((cfg_tdls_get_support_enable(hdd_ctx->hdd_psoc, &tdls_support) ==
if ((cfg_tdls_get_support_enable(hdd_ctx->psoc, &tdls_support) ==
QDF_STATUS_SUCCESS) && tdls_support) {
hdd_debug("TDLS feature not Enabled or Not supported in FW");
if (nla_put_u32(skb, PARAM_MAX_TDLS_SESSION, 0) ||
@ -764,13 +764,13 @@ static int __wlan_hdd_cfg80211_get_tdls_capabilities(struct wiphy *wiphy,
goto fail;
}
} else {
cfg_tdls_get_external_control(hdd_ctx->hdd_psoc,
cfg_tdls_get_external_control(hdd_ctx->psoc,
&tdls_external_control);
cfg_tdls_get_sleep_sta_enable(hdd_ctx->hdd_psoc,
cfg_tdls_get_sleep_sta_enable(hdd_ctx->psoc,
&tdls_sleep_sta_enable);
cfg_tdls_get_buffer_sta_enable(hdd_ctx->hdd_psoc,
cfg_tdls_get_buffer_sta_enable(hdd_ctx->psoc,
&tdls_buffer_sta);
cfg_tdls_get_off_channel_enable(hdd_ctx->hdd_psoc,
cfg_tdls_get_off_channel_enable(hdd_ctx->psoc,
&tdls_off_channel);
set = set | WIFI_TDLS_SUPPORT;
set = set | (tdls_external_control ?
@ -1576,7 +1576,7 @@ int wlan_hdd_sap_cfg_dfs_override(struct hdd_adapter *adapter)
* channel secondary AP should always follow primary APs channel
*/
if (!policy_mgr_concurrent_beaconing_sessions_running(
hdd_ctx->hdd_psoc))
hdd_ctx->psoc))
return 0;
con_sap_adapter = hdd_get_con_sap_adapter(adapter, true);
@ -1776,7 +1776,7 @@ int wlan_hdd_cfg80211_start_acs(struct hdd_adapter *adapter)
* then PCL would include only channels from the other
* frequency band on which no connections are active
*/
if ((policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) == 2) &&
if ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 2) &&
(sap_config->acs_cfg.band == QCA_ACS_MODE_IEEE80211ANY)) {
struct policy_mgr_conc_connection_info *conc_connection_info;
uint32_t i;
@ -2140,7 +2140,7 @@ static int wlan_hdd_sap_get_valid_channellist(struct hdd_adapter *adapter,
sap_config = &adapter->session.ap.sap_config;
status =
policy_mgr_get_valid_chans(hdd_ctx->hdd_psoc,
policy_mgr_get_valid_chans(hdd_ctx->psoc,
tmp_chan_list,
&chan_count);
if (QDF_IS_STATUS_ERROR(status)) {
@ -2203,7 +2203,7 @@ int hdd_cfg80211_update_acs_config(struct hdd_adapter *adapter,
* then PCL would include only channels from the other
* frequency band on which no connections are active
*/
if ((policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) == 2) &&
if ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 2) &&
(sap_config->acs_cfg.band == QCA_ACS_MODE_IEEE80211ANY)) {
struct policy_mgr_conc_connection_info *conc_connection_info;
@ -2657,7 +2657,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 */
qdf_status = policy_mgr_get_pcl(hdd_ctx->hdd_psoc, PM_SAP_MODE,
qdf_status = policy_mgr_get_pcl(hdd_ctx->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,
@ -2677,7 +2677,7 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
}
if (hw_mode == QCA_ACS_MODE_IEEE80211ANY)
policy_mgr_trim_acs_channel_list(hdd_ctx->hdd_psoc,
policy_mgr_trim_acs_channel_list(hdd_ctx->psoc,
sap_config->acs_cfg.ch_list,
&sap_config->acs_cfg.ch_list_count);
@ -2737,7 +2737,7 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
hdd_debug("%d ", sap_config->acs_cfg.ch_list[i]);
}
conc_channel = policy_mgr_mode_specific_get_channel(hdd_ctx->hdd_psoc,
conc_channel = policy_mgr_mode_specific_get_channel(hdd_ctx->psoc,
PM_STA_MODE);
if (hdd_ctx->config->external_acs_policy ==
HDD_EXTERNAL_ACS_PCL_MANDATORY) {
@ -3046,7 +3046,7 @@ __wlan_hdd_cfg80211_get_supported_features(struct wiphy *wiphy,
/* HOTSPOT is a supplicant feature, enable it by default */
fset |= WIFI_FEATURE_HOTSPOT;
if (ucfg_extscan_get_enable(hdd_ctx->hdd_psoc) &&
if (ucfg_extscan_get_enable(hdd_ctx->psoc) &&
sme_is_feature_supported_by_fw(EXTENDED_SCAN)) {
hdd_debug("EXTScan is supported by firmware");
fset |= WIFI_FEATURE_EXTSCAN | WIFI_FEATURE_HAL_EPNO;
@ -3069,13 +3069,13 @@ __wlan_hdd_cfg80211_get_supported_features(struct wiphy *wiphy,
#endif
fset |= WIFI_FEATURE_ADDITIONAL_STA;
#ifdef FEATURE_WLAN_TDLS
cfg_tdls_get_support_enable(hdd_ctx->hdd_psoc, &bvalue);
cfg_tdls_get_support_enable(hdd_ctx->psoc, &bvalue);
if ((bvalue) && sme_is_feature_supported_by_fw(TDLS)) {
hdd_debug("TDLS is supported by firmware");
fset |= WIFI_FEATURE_TDLS;
}
cfg_tdls_get_off_channel_enable(hdd_ctx->hdd_psoc, &bvalue);
cfg_tdls_get_off_channel_enable(hdd_ctx->psoc, &bvalue);
if (sme_is_feature_supported_by_fw(TDLS) &&
bvalue && sme_is_feature_supported_by_fw(TDLS_OFF_CHANNEL)) {
hdd_debug("TDLS off-channel is supported by firmware");
@ -3331,7 +3331,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 (policy_mgr_is_scan_simultaneous_capable(hdd_ctx->hdd_psoc))
if (policy_mgr_is_scan_simultaneous_capable(hdd_ctx->psoc))
wlan_hdd_cfg80211_set_feature(feature_flags,
QCA_WLAN_VENDOR_FEATURE_OFFCHANNEL_SIMULTANEOUS);
@ -3368,7 +3368,7 @@ __wlan_hdd_cfg80211_get_features(struct wiphy *wiphy,
sizeof(feature_flags), feature_flags))
goto nla_put_failure;
ret = policy_mgr_get_dbs_hw_modes(hdd_ctx->hdd_psoc,
ret = policy_mgr_get_dbs_hw_modes(hdd_ctx->psoc,
&one_by_one_dbs, &two_by_two_dbs);
if (QDF_STATUS_SUCCESS == ret) {
if (one_by_one_dbs)
@ -5238,7 +5238,7 @@ static int wlan_hdd_handle_restrict_offchan_config(struct hdd_adapter *adapter,
wlan_vdev_mlme_cap_set(adapter->vdev,
WLAN_VDEV_C_RESTRICT_OFFCHAN);
wlan_vdev_obj_unlock(adapter->vdev);
chan = policy_mgr_get_channel(hdd_ctx->hdd_psoc, pmode,
chan = policy_mgr_get_channel(hdd_ctx->psoc, pmode,
&vdev_id);
if (!chan ||
wlan_hdd_send_avoid_freq_for_dnbs(hdd_ctx, chan)) {
@ -5521,7 +5521,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
sme_update_fine_time_measurement_capab(mac_handle,
adapter->session_id,
hdd_ctx->config->fine_time_meas_cap);
ucfg_wifi_pos_set_ftm_cap(hdd_ctx->hdd_psoc,
ucfg_wifi_pos_set_ftm_cap(hdd_ctx->psoc,
hdd_ctx->config->fine_time_meas_cap);
hdd_debug("FTM capability: user value: 0x%x, target value: 0x%x, final value: 0x%x",
ftm_capab, hdd_ctx->fine_time_meas_cap_target,
@ -7269,7 +7269,7 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
hdd_debug("Userspace requested pref freq list");
status = policy_mgr_get_pcl(hdd_ctx->hdd_psoc,
status = policy_mgr_get_pcl(hdd_ctx->psoc,
intf_mode, pcl, &pcl_len,
weight_list, QDF_ARRAY_SIZE(weight_list));
if (status != QDF_STATUS_SUCCESS) {
@ -7407,7 +7407,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 (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc, intf_mode,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc, intf_mode,
channel_hint, HW_MODE_20_MHZ)) {
hdd_err("Set channel hint failed due to concurrency check");
return -EINVAL;
@ -8227,7 +8227,7 @@ __wlan_hdd_cfg80211_sap_configuration_set(struct wiphy *wiphy,
}
status = policy_mgr_set_sap_mandatory_channels(
hdd_ctx->hdd_psoc, chans, freq_len);
hdd_ctx->psoc, chans, freq_len);
if (QDF_IS_STATUS_ERROR(status))
return -EINVAL;
}
@ -8456,7 +8456,7 @@ nla_put_failure:
#ifdef QCA_SUPPORT_CP_STATS
static int wlan_hdd_process_wake_lock_stats(struct hdd_context *hdd_ctx)
{
return wlan_cfg80211_mc_cp_stats_get_wakelock_stats(hdd_ctx->hdd_psoc,
return wlan_cfg80211_mc_cp_stats_get_wakelock_stats(hdd_ctx->psoc,
hdd_ctx->wiphy);
}
#else
@ -10711,7 +10711,7 @@ void hdd_bt_activity_cb(hdd_handle_t hdd_handle, uint32_t bt_activity)
else
return;
ucfg_scan_set_bt_activity(hdd_ctx->hdd_psoc, hdd_ctx->bt_a2dp_active);
ucfg_scan_set_bt_activity(hdd_ctx->psoc, hdd_ctx->bt_a2dp_active);
hdd_debug("a2dp_active: %d vo_active: %d", hdd_ctx->bt_a2dp_active,
hdd_ctx->bt_vo_active);
}
@ -11034,7 +11034,7 @@ int wlan_hdd_send_mode_change_event(void)
if (0 != err)
return err;
conn_count = policy_mgr_get_connection_info(hdd_ctx->hdd_psoc, info);
conn_count = policy_mgr_get_connection_info(hdd_ctx->psoc, info);
if (!conn_count)
return -EINVAL;
@ -12313,7 +12313,7 @@ static void wlan_hdd_update_ht_cap(struct hdd_context *hdd_ctx)
struct mlme_ht_capabilities_info ht_cap_info = {0};
QDF_STATUS status;
status = ucfg_mlme_get_ht_cap_info(hdd_ctx->hdd_psoc, &ht_cap_info);
status = ucfg_mlme_get_ht_cap_info(hdd_ctx->psoc, &ht_cap_info);
if (QDF_STATUS_SUCCESS != status)
hdd_err("could not get HT capability info");
@ -12934,7 +12934,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
return -EINVAL;
}
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
wlan_hdd_convert_nl_iftype_to_hdd_type(type),
0, HW_MODE_20_MHZ)) {
hdd_debug("This concurrency combination is not allowed");
@ -12945,7 +12945,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
wdev = ndev->ieee80211_ptr;
/* Reset the current device mode bit mask */
policy_mgr_clear_concurrency_mode(hdd_ctx->hdd_psoc,
policy_mgr_clear_concurrency_mode(hdd_ctx->psoc,
adapter->device_mode);
if (!(adapter->device_mode == QDF_P2P_DEVICE_MODE &&
@ -13093,7 +13093,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
}
done:
/* Set bitmask based on updated value */
policy_mgr_set_concurrency_mode(hdd_ctx->hdd_psoc,
policy_mgr_set_concurrency_mode(hdd_ctx->psoc,
adapter->device_mode);
hdd_lpass_notify_mode_change(adapter);
@ -14538,7 +14538,7 @@ 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
* connect by passing its roam_profile.
*/
status = policy_mgr_get_channel_from_scan_result(hdd_ctx->hdd_psoc,
status = policy_mgr_get_channel_from_scan_result(hdd_ctx->psoc,
roam_profile, &channel);
/*
@ -14557,9 +14557,9 @@ bool wlan_hdd_handle_sap_sta_dfs_conc(struct hdd_adapter *adapter,
* for 3port MCC scenario.
*/
if (!channel || wlan_reg_is_dfs_ch(hdd_ctx->pdev, channel) ||
!policy_mgr_is_safe_channel(hdd_ctx->hdd_psoc, channel))
!policy_mgr_is_safe_channel(hdd_ctx->psoc, channel))
channel = policy_mgr_get_nondfs_preferred_channel(
hdd_ctx->hdd_psoc, PM_SAP_MODE, true);
hdd_ctx->psoc, PM_SAP_MODE, true);
hostapd_state = WLAN_HDD_GET_HOSTAP_STATE_PTR(ap_adapter);
qdf_event_reset(&hostapd_state->qdf_event);
@ -14696,11 +14696,11 @@ static int wlan_hdd_cfg80211_connect_start(struct hdd_adapter *adapter,
* Else set connect_in_progress as true and proceed.
*/
policy_mgr_restart_opportunistic_timer(
hdd_ctx->hdd_psoc, false);
hdd_ctx->psoc, false);
if (policy_mgr_is_hw_mode_change_in_progress(
hdd_ctx->hdd_psoc)) {
hdd_ctx->psoc)) {
qdf_status = policy_mgr_wait_for_connection_update(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
hdd_err("qdf wait for event failed!!");
status = -EINVAL;
@ -14872,7 +14872,7 @@ static int wlan_hdd_cfg80211_connect_start(struct hdd_adapter *adapter,
adapter->scan_info.scan_add_ie.length;
}
if ((policy_mgr_is_hw_dbs_capable(hdd_ctx->hdd_psoc) == true)
if ((policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc) == true)
&& (false == wlan_hdd_handle_sap_sta_dfs_conc(adapter,
roam_profile))) {
hdd_err("sap-sta conc will fail, can't allow sta");
@ -14962,16 +14962,16 @@ static int wlan_hdd_cfg80211_connect_start(struct hdd_adapter *adapter,
roam_profile->ChannelInfo.numOfChannels = 0;
if ((QDF_STA_MODE == adapter->device_mode)
&& policy_mgr_is_current_hwmode_dbs(hdd_ctx->hdd_psoc)
&& policy_mgr_is_current_hwmode_dbs(hdd_ctx->psoc)
&& !policy_mgr_is_hw_dbs_2x2_capable(
hdd_ctx->hdd_psoc)) {
hdd_ctx->psoc)) {
policy_mgr_get_channel_from_scan_result(
hdd_ctx->hdd_psoc,
hdd_ctx->psoc,
roam_profile, &channel);
hdd_info("Move to single MAC mode(optimization) if applicable");
if (channel)
policy_mgr_checkn_update_hw_mode_single_mac_mode(
hdd_ctx->hdd_psoc, channel);
hdd_ctx->psoc, channel);
}
} else {
@ -16573,7 +16573,7 @@ static int __wlan_hdd_cfg80211_connect(struct wiphy *wiphy,
bool ok = false;
if (req->channel->hw_value && policy_mgr_is_chan_ok_for_dnbs(
hdd_ctx->hdd_psoc,
hdd_ctx->psoc,
req->channel->hw_value,
&ok)) {
hdd_warn("Unable to get channel:%d eligibility for DNBS",
@ -16605,7 +16605,7 @@ static int __wlan_hdd_cfg80211_connect(struct wiphy *wiphy,
return -EINVAL;
}
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
policy_mgr_convert_device_mode_to_qdf_type(
adapter->device_mode),
req->channel->hw_value, HW_MODE_20_MHZ)) {
@ -16614,7 +16614,7 @@ static int __wlan_hdd_cfg80211_connect(struct wiphy *wiphy,
goto con_chk_failed;
}
} else {
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
policy_mgr_convert_device_mode_to_qdf_type(
adapter->device_mode), 0, HW_MODE_20_MHZ)) {
hdd_warn("This concurrency combination is not allowed");
@ -17176,17 +17176,17 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
}
}
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
PM_IBSS_MODE, channelNum, HW_MODE_20_MHZ)) {
hdd_err("This concurrency combination is not allowed");
return -ECONNREFUSED;
}
status = policy_mgr_reset_connection_update(hdd_ctx->hdd_psoc);
status = policy_mgr_reset_connection_update(hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("qdf_reset_connection_update failed status: %d", status);
status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc,
status = policy_mgr_current_connections_update(hdd_ctx->psoc,
adapter->session_id, channelNum,
POLICY_MGR_UPDATE_REASON_JOIN_IBSS);
if (QDF_STATUS_E_FAILURE == status) {
@ -17196,7 +17196,7 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
if (QDF_STATUS_SUCCESS == status) {
status = policy_mgr_wait_for_connection_update(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("qdf wait for event failed!!");
return -EINVAL;
@ -18791,7 +18791,7 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
qdf_mem_zero(hb_params, sizeof(*hb_params));
qdf_mem_copy(hb_params, buf, buf_len);
status = pmo_ucfg_lphb_config_req(hdd_ctx->hdd_psoc,
status = pmo_ucfg_lphb_config_req(hdd_ctx->psoc,
hb_params, (void *)hdd_ctx,
wlan_hdd_cfg80211_lphb_ind_handler);
if (status != QDF_STATUS_SUCCESS)
@ -19045,11 +19045,11 @@ int wlan_hdd_change_hw_mode_for_given_chnl(struct hdd_adapter *adapter,
if (0 != wlan_hdd_validate_context(hdd_ctx))
return -EINVAL;
status = policy_mgr_reset_connection_update(hdd_ctx->hdd_psoc);
status = policy_mgr_reset_connection_update(hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("clearing event failed");
status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc,
status = policy_mgr_current_connections_update(hdd_ctx->psoc,
adapter->session_id, channel, reason);
switch (status) {
case QDF_STATUS_E_FAILURE:
@ -19066,7 +19066,7 @@ int wlan_hdd_change_hw_mode_for_given_chnl(struct hdd_adapter *adapter,
* triggered and wait for it to finish.
*/
status = policy_mgr_wait_for_connection_update(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("ERROR: qdf wait for event failed!!");
return -EINVAL;

40
core/hdd/src/wlan_hdd_conc_ut.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2015-2018 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -211,7 +211,7 @@ void fill_report(struct hdd_context *hdd_ctx, char *title,
report[report_idx].status = status;
snprintf(report[report_idx].dbs_value,
MAX_ALLOWED_CHAR_IN_REPORT, "%s",
policy_mgr_is_hw_dbs_capable(hdd_ctx->hdd_psoc)
policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc)
? "enable" : "disable");
snprintf(report[report_idx].system_conf,
MAX_ALLOWED_CHAR_IN_REPORT, "%s",
@ -631,7 +631,7 @@ void wlan_hdd_one_connection_scenario(struct hdd_context *hdd_ctx)
sme_cbacks.sme_get_valid_channels = sme_get_valid_channels;
sme_cbacks.sme_get_nss_for_vdev = sme_get_vdev_type_nss;
/* flush the entire table first */
ret = policy_mgr_psoc_enable(hdd_ctx->hdd_psoc);
ret = policy_mgr_psoc_enable(hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(ret)) {
hdd_err("Policy manager initialization failed");
return;
@ -639,7 +639,7 @@ void wlan_hdd_one_connection_scenario(struct hdd_context *hdd_ctx)
for (sub_type = 0; sub_type < PM_MAX_NUM_OF_MODE; sub_type++) {
/* validate one connection is created or no */
if (policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) != 0) {
if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 0) {
hdd_err("Test failed - No. of connection is not 0");
return;
}
@ -649,7 +649,7 @@ void wlan_hdd_one_connection_scenario(struct hdd_context *hdd_ctx)
sub_type, system_pref);
/* check PCL value for second connection is correct or no */
policy_mgr_get_pcl(hdd_ctx->hdd_psoc, sub_type, pcl, &pcl_len,
policy_mgr_get_pcl(hdd_ctx->psoc, sub_type, pcl, &pcl_len,
weight_list, QDF_ARRAY_SIZE(weight_list));
status = wlan_hdd_validate_pcl(hdd_ctx,
pcl_type, pcl, pcl_len, 0, 0,
@ -691,7 +691,7 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
sme_cbacks.sme_get_valid_channels = sme_get_valid_channels;
sme_cbacks.sme_get_nss_for_vdev = sme_get_vdev_type_nss;
/* flush the entire table first */
ret = policy_mgr_psoc_enable(hdd_ctx->hdd_psoc);
ret = policy_mgr_psoc_enable(hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(ret)) {
hdd_err("Policy manager initialization failed");
return;
@ -700,12 +700,12 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type, &sub_type);
/* add first connection as STA */
policy_mgr_incr_connection_count_utfw(hdd_ctx->hdd_psoc,
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc,
vdevid, tx_stream,
rx_stream, chain_mask, type, dummy_type,
channel_id, mac_id);
/* validate one connection is created or no */
if (policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) != 1) {
if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) {
hdd_err("Test failed - No. of connection is not 1");
return;
}
@ -714,7 +714,7 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
/* get the PCL value & check the channels accordingly */
second_index =
policy_mgr_get_second_connection_pcl_table_index(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (PM_MAX_ONE_CONNECTION_MODE == second_index) {
/* not valid combination*/
hdd_err("couldn't find index for 2nd connection pcl table");
@ -726,9 +726,9 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
pcl_type = policy_mgr_get_pcl_from_second_conn_table(
second_index, next_sub_type, system_pref,
policy_mgr_is_hw_dbs_capable(
hdd_ctx->hdd_psoc));
hdd_ctx->psoc));
/* check PCL for second connection is correct or no */
policy_mgr_get_pcl(hdd_ctx->hdd_psoc,
policy_mgr_get_pcl(hdd_ctx->psoc,
next_sub_type, pcl, &pcl_len,
weight_list, QDF_ARRAY_SIZE(weight_list));
status = wlan_hdd_validate_pcl(hdd_ctx,
@ -797,7 +797,7 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
sme_cbacks.sme_get_valid_channels = sme_get_valid_channels;
sme_cbacks.sme_get_nss_for_vdev = sme_get_vdev_type_nss;
/* flush the entire table first */
ret = policy_mgr_psoc_enable(hdd_ctx->hdd_psoc);
ret = policy_mgr_psoc_enable(hdd_ctx->psoc);
if (!QDF_IS_STATUS_SUCCESS(ret)) {
hdd_err("Policy manager initialization failed");
return;
@ -806,11 +806,11 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type_1, &sub_type_1);
/* add first connection as STA */
policy_mgr_incr_connection_count_utfw(hdd_ctx->hdd_psoc,
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc,
vdevid_1, tx_stream_1, rx_stream_1, chain_mask_1,
type_1, dummy_type_1, channel_id_1, mac_id_1);
/* validate one connection is created or no */
if (policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) != 1) {
if (policy_mgr_get_connection_count(hdd_ctx->psoc) != 1) {
hdd_err("Test fail - No. of connection not 1");
return;
}
@ -821,12 +821,12 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
/* sub_type mapping between HDD and WMA are different */
wlan_hdd_map_subtypes_hdd_wma(&dummy_type_2,
&sub_type_2);
policy_mgr_incr_connection_count_utfw(hdd_ctx->hdd_psoc,
policy_mgr_incr_connection_count_utfw(hdd_ctx->psoc,
vdevid_2, tx_stream_2, rx_stream_2,
chain_mask_2, type_2,
dummy_type_2, channel_id_2, mac_id_2);
/* validate two connections are created or no */
if (policy_mgr_get_connection_count(hdd_ctx->hdd_psoc)
if (policy_mgr_get_connection_count(hdd_ctx->psoc)
!= 2) {
hdd_err("Test fail - No. connection not 2");
return;
@ -835,7 +835,7 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
while (next_sub_type < PM_MAX_NUM_OF_MODE) {
third_index =
policy_mgr_get_third_connection_pcl_table_index(
hdd_ctx->hdd_psoc);
hdd_ctx->psoc);
if (PM_MAX_TWO_CONNECTION_MODE ==
third_index) {
/* not valid combination */
@ -849,8 +849,8 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
third_index, next_sub_type,
system_pref,
policy_mgr_is_hw_dbs_capable(
hdd_ctx->hdd_psoc));
policy_mgr_get_pcl(hdd_ctx->hdd_psoc,
hdd_ctx->psoc));
policy_mgr_get_pcl(hdd_ctx->psoc,
next_sub_type,
pcl, &pcl_len,
weight_list,
@ -872,7 +872,7 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
next_sub_type++;
}
/* remove entry to make a room for next iteration */
policy_mgr_decr_connection_count(hdd_ctx->hdd_psoc,
policy_mgr_decr_connection_count(hdd_ctx->psoc,
vdevid_2);
}
next_sub_type = PM_STA_MODE;

2
core/hdd/src/wlan_hdd_debugfs_offload.c
View file

@ -69,7 +69,7 @@ wlan_hdd_mc_addr_list_info_debugfs(struct hdd_context *hdd_ctx,
return length;
}
status = pmo_ucfg_get_mc_addr_list(hdd_ctx->hdd_psoc,
status = pmo_ucfg_get_mc_addr_list(hdd_ctx->psoc,
adapter->session_id,
&mc_addr_list);
if (!QDF_IS_STATUS_SUCCESS(status)) {

2
core/hdd/src/wlan_hdd_disa.c
View file

@ -383,7 +383,7 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
cookie = osif_request_cookie(request);
qdf_status = ucfg_disa_encrypt_decrypt_req(hdd_ctx->hdd_psoc,
qdf_status = ucfg_disa_encrypt_decrypt_req(hdd_ctx->psoc,
&context->request,
hdd_encrypt_decrypt_msg_cb,
cookie);