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

qcacld-3.0: Port modulated dtim and override listen interval

Browse Source 
Port modulated dtim and override listen interval to PMO from
WMA.

Change-Id: Id965dd8ee0fbddfa563335fd2fe225dcd20cd162
CRs-Fixed: 2252788
This commit is contained in:
Nachiket Kukade
2018-06-01 22:53:06 +05:30
committed by nshrivas
parent 0368d66a73
commit 4b7c8e03c7
13 changed files with 259 additions and 635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
components/pmo/core/inc/wlan_pmo_priv.h
View File

@@ -109,8 +109,10 @@ struct wlan_pmo_ctx {
* @p2plo_in_progress: true when p2plo_in_progress in progress else false * @p2plo_in_progress: true when p2plo_in_progress in progress else false
* @dtim_period: dtim period for vdev * @dtim_period: dtim period for vdev
* @beacon_interval: vdev beacon interval * @beacon_interval: vdev beacon interval
* @alt_modulated_dtim_enabled:dynamic modulated dtim enabled * @dyn_modulated_dtim: dynamically configured modulated dtim value
* @dyn_modulated_dtim_enabled: if dynamically modulated dtim is set or not
* @dtim_policy: tells vdev beacon dtim policy * @dtim_policy: tells vdev beacon dtim policy
* @dyn_listen_interval: dynamically user configured listen interval
* @pmo_vdev_lock: spin lock for pmo vdev priv ctx * @pmo_vdev_lock: spin lock for pmo vdev priv ctx
*/ */
struct pmo_vdev_priv_obj { struct pmo_vdev_priv_obj {
@@ -131,8 +133,10 @@ struct pmo_vdev_priv_obj {
bool p2plo_in_progress; bool p2plo_in_progress;
uint8_t dtim_period; uint8_t dtim_period;
uint8_t beacon_interval; uint8_t beacon_interval;
bool alt_modulated_dtim_enable; uint32_t dyn_modulated_dtim;
bool dyn_modulated_dtim_enabled;
uint32_t dtim_policy; uint32_t dtim_policy;
uint32_t dyn_listen_interval;
qdf_spinlock_t pmo_vdev_lock; qdf_spinlock_t pmo_vdev_lock;
}; };

43
components/pmo/core/inc/wlan_pmo_suspend_resume.h
View File

@@ -140,25 +140,6 @@ QDF_STATUS pmo_core_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
QDF_STATUS pmo_core_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc, QDF_STATUS pmo_core_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type); enum qdf_suspend_type type);
/**
* pmo_core_update_alt_modulated_dtim_enable() - update alt modulatate dtim
* @vdev: objmgr vdev handle
* @value: true when alt modulated dtim enable else false
*
* Return: None
*/
static inline
void pmo_core_update_alt_modulated_dtim_enable(struct wlan_objmgr_vdev *vdev,
bool value)
{
struct pmo_vdev_priv_obj *vdev_ctx;
vdev_ctx = pmo_vdev_get_priv(vdev);
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
vdev_ctx->alt_modulated_dtim_enable = value;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
}
/** /**
* pmo_core_vdev_set_dtim_policy() - Set vdev beacon dtim policy * pmo_core_vdev_set_dtim_policy() - Set vdev beacon dtim policy
* @vdev: objmgr vdev handle * @vdev: objmgr vdev handle
@@ -388,6 +369,30 @@ void pmo_core_psoc_target_suspend_acknowledge(void *context, bool wow_nack);
*/ */
void pmo_core_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc); void pmo_core_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc);
/**
* pmo_core_config_listen_interval() - function to dynamically configure
* listen interval
* @vdev: objmgr vdev
* @listen_interval: new listen interval passed by user
*
* This function allows user to configure listen interval dynamically
*
* Return: QDF_STATUS
*/
QDF_STATUS pmo_core_config_listen_interval(struct wlan_objmgr_vdev *vdev,
uint32_t listen_interval);
/**
* pmo_core_config_modulated_dtim() - function to configure modulated dtim
* @vdev: objmgr vdev handle
* @mod_dtim: New modulated dtim value passed by user
*
* This function configures the modulated dtim in firmware
*
* Return: QDF_STATUS
*/
QDF_STATUS pmo_core_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim);
#endif /* WLAN_POWER_MANAGEMENT_OFFLOAD */ #endif /* WLAN_POWER_MANAGEMENT_OFFLOAD */
#endif /* end of _WLAN_PMO_SUSPEND_RESUME_H_ */ #endif /* end of _WLAN_PMO_SUSPEND_RESUME_H_ */

184
components/pmo/core/src/wlan_pmo_suspend_resume.c
View File

@@ -214,6 +214,26 @@ static void pmo_core_set_vdev_suspend_dtim(struct wlan_objmgr_psoc *psoc,
} }
} }
/*
* pmo_is_listen_interval_user_set() - Check if listen interval is configured
* by user or not
* @vdev_ctx: PMO vdev private object
*
* Return: true if listen interval is user configured else false
*/
static inline
bool pmo_is_listen_interval_user_set(struct pmo_vdev_priv_obj *vdev_ctx)
{
bool retval;
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
retval = vdev_ctx->dyn_modulated_dtim_enabled
|| vdev_ctx->dyn_listen_interval;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
return retval;
}
/** /**
* pmo_core_set_suspend_dtim() - set suspend dtim * pmo_core_set_suspend_dtim() - set suspend dtim
* @psoc: objmgr psoc handle * @psoc: objmgr psoc handle
@@ -225,9 +245,17 @@ static void pmo_core_set_suspend_dtim(struct wlan_objmgr_psoc *psoc)
uint8_t vdev_id; uint8_t vdev_id;
struct wlan_objmgr_vdev *vdev; struct wlan_objmgr_vdev *vdev;
struct pmo_vdev_priv_obj *vdev_ctx; struct pmo_vdev_priv_obj *vdev_ctx;
bool alt_mdtim_enabled; struct pmo_psoc_priv_obj *psoc_ctx;
bool li_offload_support = false;
QDF_STATUS status; QDF_STATUS status;
pmo_psoc_with_ctx(psoc, psoc_ctx) {
li_offload_support = psoc_ctx->caps.li_offload;
}
if (li_offload_support)
pmo_debug("listen interval offload support is enabled");
/* Iterate through VDEV list */ /* Iterate through VDEV list */
for (vdev_id = 0; vdev_id < WLAN_UMAC_PSOC_MAX_VDEVS; vdev_id++) { for (vdev_id = 0; vdev_id < WLAN_UMAC_PSOC_MAX_VDEVS; vdev_id++) {
vdev = pmo_psoc_get_vdev(psoc, vdev_id); vdev = pmo_psoc_get_vdev(psoc, vdev_id);
@@ -239,11 +267,8 @@ static void pmo_core_set_suspend_dtim(struct wlan_objmgr_psoc *psoc)
continue; continue;
vdev_ctx = pmo_vdev_get_priv(vdev); vdev_ctx = pmo_vdev_get_priv(vdev);
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock); if (!pmo_is_listen_interval_user_set(vdev_ctx)
alt_mdtim_enabled = vdev_ctx->alt_modulated_dtim_enable; && !li_offload_support)
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
if (!alt_mdtim_enabled)
pmo_core_set_vdev_suspend_dtim(psoc, vdev, vdev_ctx); pmo_core_set_vdev_suspend_dtim(psoc, vdev, vdev_ctx);
pmo_vdev_put_ref(vdev); pmo_vdev_put_ref(vdev);
@@ -482,9 +507,17 @@ static void pmo_core_set_resume_dtim(struct wlan_objmgr_psoc *psoc)
uint8_t vdev_id; uint8_t vdev_id;
struct wlan_objmgr_vdev *vdev; struct wlan_objmgr_vdev *vdev;
struct pmo_vdev_priv_obj *vdev_ctx; struct pmo_vdev_priv_obj *vdev_ctx;
bool alt_mdtim_enabled; struct pmo_psoc_priv_obj *psoc_ctx;
bool li_offload_support = false;
QDF_STATUS status; QDF_STATUS status;
pmo_psoc_with_ctx(psoc, psoc_ctx) {
li_offload_support = psoc_ctx->caps.li_offload;
}
if (li_offload_support)
pmo_debug("listen interval offload support is enabled");
/* Iterate through VDEV list */ /* Iterate through VDEV list */
for (vdev_id = 0; vdev_id < WLAN_UMAC_PSOC_MAX_VDEVS; vdev_id++) { for (vdev_id = 0; vdev_id < WLAN_UMAC_PSOC_MAX_VDEVS; vdev_id++) {
vdev = pmo_psoc_get_vdev(psoc, vdev_id); vdev = pmo_psoc_get_vdev(psoc, vdev_id);
@@ -496,13 +529,9 @@ static void pmo_core_set_resume_dtim(struct wlan_objmgr_psoc *psoc)
continue; continue;
vdev_ctx = pmo_vdev_get_priv(vdev); vdev_ctx = pmo_vdev_get_priv(vdev);
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock); if (!pmo_is_listen_interval_user_set(vdev_ctx)
alt_mdtim_enabled = vdev_ctx->alt_modulated_dtim_enable; && !li_offload_support)
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
if (!alt_mdtim_enabled)
pmo_core_set_vdev_resume_dtim(psoc, vdev, vdev_ctx); pmo_core_set_vdev_resume_dtim(psoc, vdev, vdev_ctx);
pmo_vdev_put_ref(vdev); pmo_vdev_put_ref(vdev);
} }
} }
@@ -1270,3 +1299,132 @@ out:
pmo_exit(); pmo_exit();
} }
QDF_STATUS pmo_core_config_listen_interval(struct wlan_objmgr_vdev *vdev,
uint32_t new_li)
{
uint32_t listen_interval;
QDF_STATUS status;
struct pmo_vdev_priv_obj *vdev_ctx;
struct pmo_psoc_priv_obj *psoc_ctx;
uint8_t vdev_id;
pmo_enter();
status = pmo_vdev_get_ref(vdev);
if (QDF_IS_STATUS_ERROR(status))
goto out;
vdev_ctx = pmo_vdev_get_priv(vdev);
vdev_id = pmo_vdev_get_id(vdev);
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
if (vdev_ctx->dyn_listen_interval == new_li) {
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
status = QDF_STATUS_SUCCESS;
pmo_debug("Listen Interval(%d) already set for vdev id %d",
new_li, vdev_id);
goto dec_ref;
}
vdev_ctx->dyn_listen_interval = new_li;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
listen_interval = new_li ? new_li : PMO_DEFAULT_LISTEN_INTERVAL;
if (!new_li) {
/* Configure default LI as we do on resume */
pmo_psoc_with_ctx(pmo_vdev_get_psoc(vdev), psoc_ctx) {
if (psoc_ctx->get_cfg_int &&
(QDF_STATUS_SUCCESS != psoc_ctx->get_cfg_int(
PMO_CFG_LISTEN_INTERVAL,
&listen_interval))) {
pmo_err("Failed to get listen interval");
}
}
}
pmo_debug("Set Listen Interval %d for vdevId %d", listen_interval,
vdev_id);
status = pmo_tgt_vdev_update_param_req(vdev,
pmo_vdev_param_listen_interval,
listen_interval);
if (QDF_IS_STATUS_ERROR(status)) {
/* even it fails continue fwr will take default LI */
pmo_err("Failed to Set Listen Interval");
}
/* Set it to Normal DTIM */
status = pmo_tgt_vdev_update_param_req(vdev,
pmo_vdev_param_dtim_policy,
pmo_normal_dtim);
if (QDF_IS_STATUS_ERROR(status)) {
pmo_err("Failed to set Normal DTIM for vdev id %d", vdev_id);
} else {
pmo_debug("Set DTIM Policy to Normal for vdev id %d", vdev_id);
pmo_core_vdev_set_dtim_policy(vdev, pmo_normal_dtim);
}
dec_ref:
pmo_vdev_put_ref(vdev);
out:
pmo_exit();
return status;
}
QDF_STATUS pmo_core_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim)
{
struct pmo_vdev_priv_obj *vdev_ctx;
bool prev_dtim_enabled;
uint32_t listen_interval;
QDF_STATUS status;
uint8_t vdev_id;
pmo_enter();
status = pmo_vdev_get_ref(vdev);
if (status != QDF_STATUS_SUCCESS)
goto out;
vdev_id = pmo_vdev_get_id(vdev);
vdev_ctx = pmo_vdev_get_priv(vdev);
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
vdev_ctx->dyn_modulated_dtim = mod_dtim;
prev_dtim_enabled = vdev_ctx->dyn_modulated_dtim_enabled;
vdev_ctx->dyn_modulated_dtim_enabled = mod_dtim != 1;
listen_interval = vdev_ctx->dyn_modulated_dtim *
pmo_core_get_vdev_dtim_period(vdev);
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
if (prev_dtim_enabled || mod_dtim != 1) {
status = pmo_tgt_vdev_update_param_req(vdev,
pmo_vdev_param_listen_interval,
listen_interval);
if (QDF_IS_STATUS_ERROR(status))
/* even it fails continue fwr will take default LI */
pmo_err("Failed to set Listen Interval for vdev id %d",
vdev_id);
else
pmo_debug("Set Listen Interval %d for vdev id %d",
listen_interval, vdev_id);
status = pmo_tgt_vdev_update_param_req(vdev,
pmo_vdev_param_dtim_policy,
pmo_normal_dtim);
if (QDF_IS_STATUS_ERROR(status)) {
pmo_err("Failed to set Normal DTIM for vdev id %d",
vdev_id);
} else {
pmo_debug("Set DTIM Policy to Normal for vdev id %d",
vdev_id);
pmo_core_vdev_set_dtim_policy(vdev, pmo_normal_dtim);
}
}
pmo_vdev_put_ref(vdev);
out:
pmo_exit();
return status;
}

2
components/pmo/dispatcher/inc/wlan_pmo_common_public_struct.h
View File

@@ -322,12 +322,14 @@ struct pmo_psoc_cfg {
* @unified_wow: Firmware supports "interface pause" flag in WoW command. * @unified_wow: Firmware supports "interface pause" flag in WoW command.
* This allows both D0-WoW (bus up) and Non-D0-WoW (bus down) to use one * This allows both D0-WoW (bus up) and Non-D0-WoW (bus down) to use one
* unified command * unified command
* @li_offload: Firmware has listen interval offload support
*/ */
struct pmo_device_caps { struct pmo_device_caps {
bool apf; bool apf;
bool arp_ns_offload; bool arp_ns_offload;
bool packet_filter; bool packet_filter;
bool unified_wow; bool unified_wow;
bool li_offload;
}; };
#endif /* end of _WLAN_PMO_COMMONP_STRUCT_H_ */ #endif /* end of _WLAN_PMO_COMMONP_STRUCT_H_ */

55
components/pmo/dispatcher/inc/wlan_pmo_ucfg_api.h
View File

@@ -425,16 +425,6 @@ QDF_STATUS pmo_ucfg_lphb_config_req(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_req *lphb_req, void *lphb_cb_ctx, struct pmo_lphb_req *lphb_req, void *lphb_cb_ctx,
pmo_lphb_callback callback); pmo_lphb_callback callback);
/**
* pmo_ucfg_update_alt_modulated_dtim_enable() - update alt modulatate dtim
* @vdev: objmgr vdev handle
* @value: true for alt_modulated_dtim enable else false
*
* Return: QDF status
*/
void pmo_ucfg_update_alt_modulated_dtim_enable(struct wlan_objmgr_vdev *vdev,
bool value);
/** /**
* pmo_ucfg_psoc_update_power_save_mode() - update power save mode * pmo_ucfg_psoc_update_power_save_mode() - update power save mode
* @vdev: objmgr vdev handle * @vdev: objmgr vdev handle
@@ -619,6 +609,30 @@ void pmo_ucfg_psoc_target_suspend_acknowledge(void *context, bool wow_nack);
* Return: None * Return: None
*/ */
void pmo_ucfg_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc); void pmo_ucfg_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc);
/**
* pmo_ucfg_config_listen_interval() - function to configure listen interval
* @vdev: objmgr vdev
* @listen_interval: new listen interval passed by user
*
* This function allows user to configure listen interval dynamically
*
* Return: QDF_STATUS
*/
QDF_STATUS pmo_ucfg_config_listen_interval(struct wlan_objmgr_vdev *vdev,
uint32_t listen_interval);
/**
* pmo_ucfg_config_modulated_dtim() - function to configure modulated dtim
* @vdev: objmgr vdev handle
* @param_value: New modulated dtim value passed by user
*
* This function configures the modulated dtim in firmware
*
* Return: QDF_STATUS
*/
QDF_STATUS pmo_ucfg_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim);
#else #else
static inline uint32_t static inline uint32_t
ucfg_pmo_get_apf_instruction_size(struct wlan_objmgr_psoc *psoc) ucfg_pmo_get_apf_instruction_size(struct wlan_objmgr_psoc *psoc)
@@ -866,13 +880,6 @@ pmo_ucfg_lphb_config_req(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
static inline void
pmo_ucfg_update_alt_modulated_dtim_enable(
struct wlan_objmgr_vdev *vdev,
bool value)
{
}
static inline void static inline void
pmo_ucfg_psoc_update_power_save_mode( pmo_ucfg_psoc_update_power_save_mode(
struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_psoc *psoc,
@@ -1046,6 +1053,20 @@ pmo_ucfg_enhanced_mc_filter_disable(struct wlan_objmgr_vdev *vdev)
{ {
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
static inline QDF_STATUS
pmo_ucfg_config_listen_interval(struct wlan_objmgr_vdev *vdev,
uint32_t listen_interval)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS
pmo_ucfg_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim)
{
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_POWER_MANAGEMENT_OFFLOAD */ #endif /* WLAN_POWER_MANAGEMENT_OFFLOAD */
#endif /* end of _WLAN_PMO_UCFG_API_H_ */ #endif /* end of _WLAN_PMO_UCFG_API_H_ */

17
components/pmo/dispatcher/src/wlan_pmo_ucfg_api.c
View File

@@ -255,12 +255,6 @@ QDF_STATUS pmo_ucfg_lphb_config_req(struct wlan_objmgr_psoc *psoc,
return pmo_core_lphb_config_req(psoc, lphb_req, lphb_cb_ctx, callback); return pmo_core_lphb_config_req(psoc, lphb_req, lphb_cb_ctx, callback);
} }
void pmo_ucfg_update_alt_modulated_dtim_enable(struct wlan_objmgr_vdev *vdev,
bool value)
{
pmo_core_update_alt_modulated_dtim_enable(vdev, value);
}
void pmo_ucfg_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc, void pmo_ucfg_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc,
uint8_t value) uint8_t value)
{ {
@@ -389,4 +383,15 @@ QDF_STATUS pmo_ucfg_disable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
return pmo_core_disable_hw_filter_in_fwr(vdev); return pmo_core_disable_hw_filter_in_fwr(vdev);
} }
QDF_STATUS pmo_ucfg_config_listen_interval(struct wlan_objmgr_vdev *vdev,
uint32_t listen_interval)
{
return pmo_core_config_listen_interval(vdev, listen_interval);
}
QDF_STATUS pmo_ucfg_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim)
{
return pmo_core_config_modulated_dtim(vdev, mod_dtim);
}

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

@@ -6707,10 +6707,8 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
modulated_dtim = nla_get_u32( modulated_dtim = nla_get_u32(
tb[QCA_WLAN_VENDOR_ATTR_CONFIG_MODULATED_DTIM]); tb[QCA_WLAN_VENDOR_ATTR_CONFIG_MODULATED_DTIM]);
status = sme_configure_modulated_dtim(hdd_ctx->hHal, status = pmo_ucfg_config_modulated_dtim(adapter->hdd_vdev,
adapter->session_id, modulated_dtim);
modulated_dtim);
if (QDF_STATUS_SUCCESS != status) if (QDF_STATUS_SUCCESS != status)
ret_val = -EPERM; ret_val = -EPERM;
} }
@@ -6719,10 +6717,8 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
override_li = nla_get_u32( override_li = nla_get_u32(
tb[QCA_WLAN_VENDOR_ATTR_CONFIG_LISTEN_INTERVAL]); tb[QCA_WLAN_VENDOR_ATTR_CONFIG_LISTEN_INTERVAL]);
status = sme_override_listen_interval(hdd_ctx->hHal, status = pmo_ucfg_config_listen_interval(adapter->hdd_vdev,
adapter->session_id, override_li);
override_li);
if (status != QDF_STATUS_SUCCESS) if (status != QDF_STATUS_SUCCESS)
ret_val = -EPERM; ret_val = -EPERM;
} }

6
core/sme/inc/sme_api.h
View File

@@ -1033,12 +1033,6 @@ QDF_STATUS sme_set_miracast(tHalHandle hal, uint8_t filter_type);
QDF_STATUS sme_ext_change_channel(tHalHandle hHal, uint32_t channel, QDF_STATUS sme_ext_change_channel(tHalHandle hHal, uint32_t channel,
uint8_t session_id); uint8_t session_id);
QDF_STATUS sme_configure_modulated_dtim(tHalHandle hal, uint8_t session_id,
uint32_t modulated_dtim);
QDF_STATUS sme_override_listen_interval(tHalHandle h_hal, uint8_t session_id,
uint32_t override_li);
QDF_STATUS sme_configure_stats_avg_factor(tHalHandle hal, uint8_t session_id, QDF_STATUS sme_configure_stats_avg_factor(tHalHandle hal, uint8_t session_id,
uint16_t stats_avg_factor); uint16_t stats_avg_factor);

114
core/sme/src/common/sme_api.c
View File

@@ -12530,120 +12530,6 @@ QDF_STATUS sme_configure_guard_time(tHalHandle hal, uint8_t session_id,
return status; return status;
} }
/**
* sme_configure_modulated_dtim() - function to configure modulated dtim
* @h_hal: SME API to enable/disable modulated DTIM instantaneously
* @session_id: session ID
* @modulated_dtim: modulated dtim value
*
* This function configures the modulated dtim in firmware
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_configure_modulated_dtim(tHalHandle h_hal, uint8_t session_id,
uint32_t modulated_dtim)
{
struct scheduler_msg msg = {0};
QDF_STATUS status = QDF_STATUS_SUCCESS;
tpAniSirGlobal mac = PMAC_STRUCT(h_hal);
wma_cli_set_cmd_t *iwcmd;
iwcmd = qdf_mem_malloc(sizeof(*iwcmd));
if (NULL == iwcmd) {
QDF_TRACE(QDF_MODULE_ID_SME,
QDF_TRACE_LEVEL_FATAL,
"%s: qdf_mem_malloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
status = sme_acquire_global_lock(&mac->sme);
if (QDF_STATUS_SUCCESS == status) {
iwcmd->param_value = modulated_dtim;
iwcmd->param_vdev_id = session_id;
iwcmd->param_id = GEN_PARAM_MODULATED_DTIM;
iwcmd->param_vp_dev = GEN_CMD;
msg.type = WMA_CLI_SET_CMD;
msg.reserved = 0;
msg.bodyptr = (void *)iwcmd;
if (!QDF_IS_STATUS_SUCCESS(
scheduler_post_msg(QDF_MODULE_ID_WMA, &msg))) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
"%s: Not able to post GEN_PARAM_DYNAMIC_DTIM to WMA!",
__func__);
qdf_mem_free(iwcmd);
status = QDF_STATUS_E_FAILURE;
}
sme_release_global_lock(&mac->sme);
} else {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
"%s: sme_acquire_global_lock error!",
__func__);
qdf_mem_free(iwcmd);
}
return status;
}
/**
* sme_override_listen_interval() - function to override static LI
* @h_hal: SME API to override listen interval
* @session_id: session ID
* @override_li: new LI value passed by user
*
* This function override (enable/disable) static a.k.a ini based LI
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_override_listen_interval(tHalHandle h_hal, uint8_t session_id,
uint32_t override_li)
{
struct scheduler_msg msg = {0};
QDF_STATUS status = QDF_STATUS_SUCCESS;
tpAniSirGlobal mac = PMAC_STRUCT(h_hal);
wma_cli_set_cmd_t *iwcmd;
iwcmd = qdf_mem_malloc(sizeof(*iwcmd));
if (!iwcmd) {
QDF_TRACE(QDF_MODULE_ID_SME,
QDF_TRACE_LEVEL_FATAL,
"%s: qdf_mem_malloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
status = sme_acquire_global_lock(&mac->sme);
if (status == QDF_STATUS_SUCCESS) {
iwcmd->param_value = override_li;
iwcmd->param_vdev_id = session_id;
iwcmd->param_id = GEN_PARAM_LISTEN_INTERVAL;
iwcmd->param_vp_dev = GEN_CMD;
msg.type = WMA_CLI_SET_CMD;
msg.reserved = 0;
msg.bodyptr = (void *)iwcmd;
if (!QDF_IS_STATUS_SUCCESS(
scheduler_post_msg(QDF_MODULE_ID_WMA, &msg))) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
"%s: Can't post GEN_PARAM_LISTEN_INTERVAL",
__func__);
qdf_mem_free(iwcmd);
status = QDF_STATUS_E_FAILURE;
}
sme_release_global_lock(&mac->sme);
} else {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
"%s: sme_acquire_global_lock error!",
__func__);
qdf_mem_free(iwcmd);
}
return status;
}
/* /*
* sme_wifi_start_logger() - Send the start/stop logging command to WMA * sme_wifi_start_logger() - Send the start/stop logging command to WMA
* to either start/stop logging * to either start/stop logging

4
core/wma/inc/wma.h
View File

@@ -1020,7 +1020,6 @@ struct roam_synch_frame_ind {
* @plink_status_req: link status request * @plink_status_req: link status request
* @psnr_req: snr request * @psnr_req: snr request
* @delay_before_vdev_stop: delay * @delay_before_vdev_stop: delay
* @override_li: dynamically user configured listen interval
* @tx_streams: number of tx streams can be used by the vdev * @tx_streams: number of tx streams can be used by the vdev
* @rx_streams: number of rx streams can be used by the vdev * @rx_streams: number of rx streams can be used by the vdev
* @chain_mask: chain mask can be used by the vdev * @chain_mask: chain mask can be used by the vdev
@@ -1096,9 +1095,6 @@ struct wma_txrx_node {
#ifdef FEATURE_WLAN_EXTSCAN #ifdef FEATURE_WLAN_EXTSCAN
bool extscan_in_progress; bool extscan_in_progress;
#endif #endif
uint32_t alt_modulated_dtim;
bool alt_modulated_dtim_enabled;
uint32_t override_li;
uint32_t tx_streams; uint32_t tx_streams;
uint32_t rx_streams; uint32_t rx_streams;
uint32_t chain_mask; uint32_t chain_mask;

4
core/wma/inc/wma_internal.h
View File

@@ -698,10 +698,6 @@ QDF_STATUS wma_notify_modem_power_state(void *wma_ptr,
QDF_STATUS wma_set_smps_params(tp_wma_handle wma, uint8_t vdev_id, QDF_STATUS wma_set_smps_params(tp_wma_handle wma, uint8_t vdev_id,
int value); int value);
void wma_set_suspend_dtim(tp_wma_handle wma);
void wma_set_resume_dtim(tp_wma_handle wma);
/* /*
* wma_data.c functions declarations * wma_data.c functions declarations
*/ */

126
core/wma/src/wma_main.c
View File

@@ -946,123 +946,6 @@ static void wma_set_dtim_period(tp_wma_handle wma,
iface->dtimPeriod = dtim_params->dtim_period; iface->dtimPeriod = dtim_params->dtim_period;
} }
/**
* wma_set_modulated_dtim() - function to configure modulated dtim
* @wma: wma handle
* @privcmd: structure containing parameters
*
* This function configures the modulated dtim in firmware
*
* Return: none
*/
static void wma_set_modulated_dtim(tp_wma_handle wma,
wma_cli_set_cmd_t *privcmd)
{
uint8_t vdev_id = privcmd->param_vdev_id;
struct wma_txrx_node *iface =
&wma->interfaces[vdev_id];
bool prev_dtim_enabled;
uint32_t listen_interval;
QDF_STATUS ret;
iface->alt_modulated_dtim = privcmd->param_value;
prev_dtim_enabled = iface->alt_modulated_dtim_enabled;
if (1 != privcmd->param_value)
iface->alt_modulated_dtim_enabled = true;
else
iface->alt_modulated_dtim_enabled = false;
if ((true == iface->alt_modulated_dtim_enabled) ||
(true == prev_dtim_enabled)) {
listen_interval = iface->alt_modulated_dtim
* iface->dtimPeriod;
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
listen_interval);
if (QDF_IS_STATUS_ERROR(ret))
/* Even if it fails, continue */
WMA_LOGW("Failed to set listen interval %d",
listen_interval);
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_DTIM_POLICY,
NORMAL_DTIM);
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to Set to Normal DTIM policy");
}
}
/**
* wma_override_listen_interval() - function to override static/ini based LI
* @wma: wma handle
* @privcmd: structure containing parameters
*
* This function override static/ini based LI in firmware
*
* Return: none
*/
static void wma_override_listen_interval(tp_wma_handle wma,
wma_cli_set_cmd_t *privcmd)
{
uint8_t vdev_id = privcmd->param_vdev_id;
struct wma_txrx_node *iface =
&wma->interfaces[vdev_id];
u32 old_override_li, new_override_li, listen_interval;
struct sAniSirGlobal *mac;
QDF_STATUS ret;
mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE(FL("Failed to get mac context"));
return;
}
old_override_li = iface->override_li;
new_override_li = privcmd->param_value;
iface->override_li = new_override_li;
if (new_override_li &&
(new_override_li != old_override_li)) {
listen_interval = new_override_li;
} else if (!new_override_li &&
(new_override_li != old_override_li)) {
/* Configure default LI as we do on resume */
ret = wlan_cfg_get_int(mac, WNI_CFG_LISTEN_INTERVAL,
&listen_interval);
if (ret != QDF_STATUS_SUCCESS) {
QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_ERROR,
"Failed to get value for listen interval");
listen_interval = POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
} else {
return;
}
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
listen_interval);
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d",
vdev_id);
}
WMA_LOGD("%s: Set Listen Interval vdevId %d Listen Intv %d",
__func__, vdev_id, listen_interval);
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_DTIM_POLICY,
NORMAL_DTIM);
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to Set to Normal DTIM policy");
}
/** /**
* wma_process_cli_set_cmd() - set parameters to fw * wma_process_cli_set_cmd() - set parameters to fw
@@ -1214,12 +1097,6 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
case GEN_PARAM_RESET_TSF_GPIO: case GEN_PARAM_RESET_TSF_GPIO:
ret = wma_reset_tsf_gpio(wma, privcmd->param_value); ret = wma_reset_tsf_gpio(wma, privcmd->param_value);
break; break;
case GEN_PARAM_MODULATED_DTIM:
wma_set_modulated_dtim(wma, privcmd);
break;
case GEN_PARAM_LISTEN_INTERVAL:
wma_override_listen_interval(wma, privcmd);
break;
default: default:
WMA_LOGE("Invalid param id 0x%x", WMA_LOGE("Invalid param id 0x%x",
privcmd->param_id); privcmd->param_id);
@@ -5654,6 +5531,9 @@ static void wma_set_pmo_caps(struct wlan_objmgr_psoc *psoc)
wma_is_service_enabled(wmi_service_packet_filter_offload); wma_is_service_enabled(wmi_service_packet_filter_offload);
caps.unified_wow = caps.unified_wow =
wma_is_service_enabled(wmi_service_unified_wow_capability); wma_is_service_enabled(wmi_service_unified_wow_capability);
caps.li_offload =
wma_is_service_enabled(
wmi_service_listen_interval_offload_support);
status = ucfg_pmo_psoc_set_caps(psoc, &caps); status = ucfg_pmo_psoc_set_caps(psoc, &caps);
if (QDF_IS_STATUS_ERROR(status)) if (QDF_IS_STATUS_ERROR(status))

319
core/wma/src/wma_power.c
View File

@@ -1690,325 +1690,6 @@ QDF_STATUS wma_set_smps_params(tp_wma_handle wma, uint8_t vdev_id,
return ret; return ret;
} }
/**
* wma_configure_vdev_suspend_params() - set suspend related parameters in fw
* @wma: wma handle
* @vdev_id: vdev id
*
* Return: none
*/
static void wma_configure_vdev_suspend_params(tp_wma_handle wma,
uint8_t vdev_id)
{
uint32_t cfg_data_val = 0;
struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
struct sAniSirGlobal *mac;
QDF_STATUS ret;
uint8_t ito_repeat_count_value = 0;
uint32_t inactivity_time;
if (iface->type != WMI_VDEV_TYPE_STA)
return;
mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE(FL("Failed to get mac context"));
return;
}
if (wlan_cfg_get_int(mac,
WNI_CFG_PS_WOW_DATA_INACTIVITY_TIMEOUT,
&cfg_data_val) != QDF_STATUS_SUCCESS) {
QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_ERROR,
"Can't get WNI_CFG_PS_WOW_DATA_INACTIVITY_TO");
cfg_data_val = WOW_POWERSAVE_DEFAULT_INACTIVITY_TIME;
}
WMA_LOGD("%s: Set inactivity_time for wow: %d", __func__,
cfg_data_val);
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_INACTIVITY_TIME, cfg_data_val);
if (ret)
WMA_LOGE("%s: Setting InActivity time Failed.",
__func__);
if (wlan_cfg_get_int(mac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
&inactivity_time) != QDF_STATUS_SUCCESS) {
QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_ERROR,
"Failed to get WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
inactivity_time = POWERSAVE_DEFAULT_INACTIVITY_TIME;
}
/*
* To keep ito repeat count same in wow mode as in non wow mode,
* modulating ito repeat count value.
*/
ito_repeat_count_value = (inactivity_time / cfg_data_val) *
wma->ito_repeat_count;
if (ito_repeat_count_value) {
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_MAX_RESET_ITO_COUNT_ON_TIM_NO_TXRX,
ito_repeat_count_value);
WMA_LOGD("%s: Setting ito_repeat_count_value %d.", __func__,
ito_repeat_count_value);
if (ret)
WMA_LOGE("%s: Setting ITO count failed.", __func__);
}
}
/**
* wma_set_vdev_suspend_dtim() - set suspend dtim parameters in fw
* @wma: wma handle
* @vdev_id: vdev id
*
* Return: none
*/
static void wma_set_vdev_suspend_dtim(tp_wma_handle wma, uint8_t vdev_id)
{
struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
uint32_t cfg_data_val = 0;
if ((iface->type == WMI_VDEV_TYPE_STA) &&
(iface->dtimPeriod != 0)) {
QDF_STATUS ret;
uint32_t listen_interval;
uint32_t max_mod_dtim;
uint32_t beacon_interval_mod;
/* get mac to access CFG data base */
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE(FL("Failed to get mac context"));
return;
}
if (wma->staDynamicDtim) {
listen_interval = wma->staDynamicDtim;
} else if ((wma->staModDtim) &&
(wma->staMaxLIModDtim)) {
/*
* When the system is in suspend
* (maximum beacon will be at 1s == 10)
* If maxModulatedDTIM ((MAX_LI_VAL = 10) / AP_DTIM)
* equal or larger than MDTIM
* (configured in WCNSS_qcom_cfg.ini)
* Set LI to MDTIM * AP_DTIM
* If Dtim = 2 and Mdtim = 2 then LI is 4
* Else
* Set LI to maxModulatedDTIM * AP_DTIM
*/
beacon_interval_mod = iface->beaconInterval / 100;
if (beacon_interval_mod == 0)
beacon_interval_mod = 1;
max_mod_dtim = wma->staMaxLIModDtim
/ (iface->dtimPeriod*beacon_interval_mod);
if (max_mod_dtim <= 0)
max_mod_dtim = 1;
if (max_mod_dtim >= wma->staModDtim) {
listen_interval =
(wma->staModDtim * iface->dtimPeriod);
} else {
listen_interval =
(max_mod_dtim * iface->dtimPeriod);
}
} else {
/* Set Listen Interval */
if ((wlan_cfg_get_int(mac, WNI_CFG_LISTEN_INTERVAL,
&cfg_data_val) != QDF_STATUS_SUCCESS)) {
QDF_TRACE(QDF_MODULE_ID_WMA,
QDF_TRACE_LEVEL_ERROR,
"Failed to listen interval");
cfg_data_val =
POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
listen_interval = cfg_data_val;
}
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
listen_interval);
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d",
vdev_id);
}
WMA_LOGD("%s: Set Listen Interval vdevId %d Listen Intv %d",
__func__, vdev_id, listen_interval);
iface->restore_dtim_setting = true;
}
}
/*
* wma_is_user_set_li_params() - Check LI related params are set by user or not
* @iface: wma vdev handle
*
* Return: 1 if true else 0
*/
static inline uint8_t wma_is_user_set_li_params(struct wma_txrx_node *iface)
{
return iface->alt_modulated_dtim_enabled || iface->override_li ? 1 : 0;
}
/**
* wma_set_suspend_dtim() - set suspend dtim
* @wma: wma handle
*
* Return: none
*/
void wma_set_suspend_dtim(tp_wma_handle wma)
{
uint8_t i;
bool li_offload_support = false;
if (NULL == wma) {
WMA_LOGE("%s: wma is NULL", __func__);
return;
}
if (WMI_SERVICE_EXT_IS_ENABLED(wma->wmi_service_bitmap,
wma->wmi_service_ext_bitmap,
WMI_SERVICE_LISTEN_INTERVAL_OFFLOAD_SUPPORT)) {
WMA_LOGD("%s: listen interval support is enabled", __func__);
li_offload_support = true;
}
for (i = 0; i < wma->max_bssid; i++) {
if (wma->interfaces[i].handle) {
if (!wma_is_user_set_li_params(&wma->interfaces[i]) &&
!li_offload_support)
wma_set_vdev_suspend_dtim(wma, i);
wma_configure_vdev_suspend_params(wma, i);
}
}
}
/**
* wma_configure_vdev_resume_params() - set resume related parameters in fw
* @wma: wma handle
* @vdev_id: vdev id
*
* Return: none
*/
static void wma_configure_vdev_resume_params(tp_wma_handle wma, uint8_t vdev_id)
{
struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
u_int32_t cfg_data_val;
struct sAniSirGlobal *mac;
QDF_STATUS ret;
if (iface->type != WMI_VDEV_TYPE_STA)
return;
mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE(FL("Failed to get mac context"));
return;
}
if (wlan_cfg_get_int(mac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
&cfg_data_val) != QDF_STATUS_SUCCESS) {
QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_ERROR,
"Failed to get WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
cfg_data_val = POWERSAVE_DEFAULT_INACTIVITY_TIME;
}
WMA_LOGD("%s: Setting InActivity time %d.", __func__, cfg_data_val);
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_INACTIVITY_TIME,
cfg_data_val);
if (ret)
WMA_LOGE("%s: Setting InActivity time Failed.",
__func__);
}
/**
* wma_set_vdev_resume_dtim() - set resume dtim parameters in fw
* @wma: wma handle
* @vdev_id: vdev id
*
* Return: none
*/
static void wma_set_vdev_resume_dtim(tp_wma_handle wma, uint8_t vdev_id)
{
struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
if ((iface->type == WMI_VDEV_TYPE_STA) &&
(iface->restore_dtim_setting)) {
QDF_STATUS ret;
uint32_t cfg_data_val = 0;
/* get mac to access CFG data base */
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE(FL("Failed to get mac context"));
return;
}
/* Set Listen Interval */
if ((wlan_cfg_get_int(mac, WNI_CFG_LISTEN_INTERVAL,
&cfg_data_val) != QDF_STATUS_SUCCESS)) {
QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_ERROR,
"Failed to get value for listen interval");
cfg_data_val = POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
cfg_data_val);
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d",
vdev_id);
}
WMA_LOGD("%s: Set Listen Interval vdevId %d Listen Intv %d",
__func__, vdev_id, cfg_data_val);
iface->restore_dtim_setting = false;
}
}
/**
* wma_set_resume_dtim() - set resume dtim
* @wma: wma handle
*
* Return: none
*/
void wma_set_resume_dtim(tp_wma_handle wma)
{
uint8_t i;
bool li_offload_support = false;
if (NULL == wma) {
WMA_LOGE("%s: wma is NULL", __func__);
return;
}
if (WMI_SERVICE_EXT_IS_ENABLED(wma->wmi_service_bitmap,
wma->wmi_service_ext_bitmap,
WMI_SERVICE_LISTEN_INTERVAL_OFFLOAD_SUPPORT)) {
WMA_LOGD("%s: listen interval support is enabled", __func__);
li_offload_support = true;
}
for (i = 0; i < wma->max_bssid; i++) {
if (wma->interfaces[i].handle) {
if (!wma_is_user_set_li_params(&wma->interfaces[i]) &&
!li_offload_support)
wma_set_vdev_resume_dtim(wma, i);
wma_configure_vdev_resume_params(wma, i);
}
}
}
/** /**
* wma_set_tx_power_scale() - set tx power scale * wma_set_tx_power_scale() - set tx power scale
* @vdev_id: vdev id * @vdev_id: vdev id