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

qcacld-3.0: Rename some ucfg APIs of PMO

Browse Source 
To keep names of PMO ucfg APIs consistent, change some of them from
"pmo_ucfg_xxx" to "ucfg_pmo_xxx".

Change-Id: I77165be8c5c408c3f91f84a477c15be1c6ea15e8
CRs-Fixed: 2334109
This commit is contained in:
Wu Gao
2018-10-16 17:22:56 +08:00
committed by nshrivas
parent 53f51e7c9b
commit d7dd6e4157
15 changed files with 381 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@@ -106,80 +106,85 @@ bool ucfg_pmo_is_vdev_supports_offload(struct wlan_objmgr_vdev *vdev)
return pmo_core_is_vdev_supports_offload(vdev);
}
void pmo_ucfg_enable_wakeup_event(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, WOW_WAKE_EVENT_TYPE wow_event)
void ucfg_pmo_enable_wakeup_event(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id,
WOW_WAKE_EVENT_TYPE wow_event)
{
pmo_core_enable_wakeup_event(psoc, vdev_id, wow_event);
}
void pmo_ucfg_disable_wakeup_event(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, WOW_WAKE_EVENT_TYPE wow_event)
void ucfg_pmo_disable_wakeup_event(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id,
WOW_WAKE_EVENT_TYPE wow_event)
{
pmo_core_disable_wakeup_event(psoc, vdev_id, wow_event);
}
QDF_STATUS pmo_ucfg_cache_arp_offload_req(struct pmo_arp_req *arp_req)
QDF_STATUS ucfg_pmo_cache_arp_offload_req(struct pmo_arp_req *arp_req)
{
return pmo_core_cache_arp_offload_req(arp_req);
}
QDF_STATUS pmo_ucfg_flush_arp_offload_req(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_flush_arp_offload_req(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_flush_arp_offload_req(vdev);
}
QDF_STATUS pmo_ucfg_enable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
QDF_STATUS ucfg_pmo_enable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
{
return pmo_core_enable_arp_offload_in_fwr(vdev, trigger);
}
QDF_STATUS pmo_ucfg_disable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
QDF_STATUS
ucfg_pmo_disable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
{
return pmo_core_disable_arp_offload_in_fwr(vdev, trigger);
}
QDF_STATUS
pmo_ucfg_get_arp_offload_params(struct wlan_objmgr_vdev *vdev,
ucfg_pmo_get_arp_offload_params(struct wlan_objmgr_vdev *vdev,
struct pmo_arp_offload_params *params)
{
return pmo_core_get_arp_offload_params(vdev, params);
}
#ifdef WLAN_NS_OFFLOAD
QDF_STATUS pmo_ucfg_cache_ns_offload_req(struct pmo_ns_req *ns_req)
QDF_STATUS ucfg_pmo_cache_ns_offload_req(struct pmo_ns_req *ns_req)
{
return pmo_core_cache_ns_offload_req(ns_req);
}
QDF_STATUS pmo_ucfg_flush_ns_offload_req(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_flush_ns_offload_req(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_flush_ns_offload_req(vdev);
}
QDF_STATUS pmo_ucfg_enable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
QDF_STATUS
ucfg_pmo_enable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
{
return pmo_core_enable_ns_offload_in_fwr(vdev, trigger);
}
QDF_STATUS pmo_ucfg_disable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
QDF_STATUS
ucfg_pmo_disable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
enum pmo_offload_trigger trigger)
{
return pmo_core_disable_ns_offload_in_fwr(vdev, trigger);
}
#endif /* WLAN_NS_OFFLOAD */
QDF_STATUS
pmo_ucfg_get_ns_offload_params(struct wlan_objmgr_vdev *vdev,
ucfg_pmo_get_ns_offload_params(struct wlan_objmgr_vdev *vdev,
struct pmo_ns_offload_params *params)
{
return pmo_core_get_ns_offload_params(vdev, params);
}
enum pmo_ns_addr_scope
pmo_ucfg_ns_addr_scope(uint32_t ipv6_scope)
ucfg_pmo_ns_addr_scope(uint32_t ipv6_scope)
{
switch (ipv6_scope) {
case IPV6_ADDR_SCOPE_NODELOCAL:
@@ -197,19 +202,19 @@ pmo_ucfg_ns_addr_scope(uint32_t ipv6_scope)
return PMO_NS_ADDR_SCOPE_INVALID;
}
QDF_STATUS pmo_ucfg_cache_mc_addr_list(
QDF_STATUS ucfg_pmo_cache_mc_addr_list(
struct pmo_mc_addr_list_params *mc_list_config)
{
return pmo_core_cache_mc_addr_list(mc_list_config);
}
QDF_STATUS pmo_ucfg_flush_mc_addr_list(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id)
QDF_STATUS ucfg_pmo_flush_mc_addr_list(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id)
{
return pmo_core_flush_mc_addr_list(psoc, vdev_id);
}
QDF_STATUS pmo_ucfg_enable_mc_addr_filtering_in_fwr(
QDF_STATUS ucfg_pmo_enable_mc_addr_filtering_in_fwr(
struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id,
enum pmo_offload_trigger trigger)
@@ -218,7 +223,7 @@ QDF_STATUS pmo_ucfg_enable_mc_addr_filtering_in_fwr(
vdev_id, trigger);
}
QDF_STATUS pmo_ucfg_disable_mc_addr_filtering_in_fwr(
QDF_STATUS ucfg_pmo_disable_mc_addr_filtering_in_fwr(
struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id,
enum pmo_offload_trigger trigger)
@@ -227,36 +232,37 @@ QDF_STATUS pmo_ucfg_disable_mc_addr_filtering_in_fwr(
vdev_id, trigger);
}
uint8_t pmo_ucfg_max_mc_addr_supported(struct wlan_objmgr_psoc *psoc)
uint8_t ucfg_pmo_max_mc_addr_supported(struct wlan_objmgr_psoc *psoc)
{
return pmo_core_max_mc_addr_supported(psoc);
}
QDF_STATUS
pmo_ucfg_get_mc_addr_list(struct wlan_objmgr_psoc *psoc,
ucfg_pmo_get_mc_addr_list(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id,
struct pmo_mc_addr_list *mc_list_req)
{
return pmo_core_get_mc_addr_list(psoc, vdev_id, mc_list_req);
}
QDF_STATUS pmo_ucfg_cache_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
struct pmo_gtk_req *gtk_req)
QDF_STATUS
ucfg_pmo_cache_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
struct pmo_gtk_req *gtk_req)
{
return pmo_core_cache_gtk_offload_req(vdev, gtk_req);
}
QDF_STATUS pmo_ucfg_flush_gtk_offload_req(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_flush_gtk_offload_req(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_flush_gtk_offload_req(vdev);
}
QDF_STATUS pmo_ucfg_enable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_enable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_enable_gtk_offload_in_fwr(vdev);
}
QDF_STATUS pmo_ucfg_disable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_disable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_disable_gtk_offload_in_fwr(vdev);
}
@@ -278,14 +284,16 @@ uint32_t ucfg_pmo_get_num_packet_filters(struct wlan_objmgr_psoc *psoc)
return pmo_get_num_packet_filters(psoc);
}
QDF_STATUS pmo_ucfg_set_pkt_filter(struct wlan_objmgr_psoc *psoc,
struct pmo_rcv_pkt_fltr_cfg *pmo_set_pkt_fltr_req,
uint8_t vdev_id)
QDF_STATUS
ucfg_pmo_set_pkt_filter(struct wlan_objmgr_psoc *psoc,
struct pmo_rcv_pkt_fltr_cfg *pmo_set_pkt_fltr_req,
uint8_t vdev_id)
{
return pmo_core_set_pkt_filter(psoc, pmo_set_pkt_fltr_req, vdev_id);
}
QDF_STATUS pmo_ucfg_clear_pkt_filter(struct wlan_objmgr_psoc *psoc,
QDF_STATUS ucfg_pmo_clear_pkt_filter(
struct wlan_objmgr_psoc *psoc,
struct pmo_rcv_pkt_fltr_clear_param *pmo_clr_pkt_fltr_param,
uint8_t vdev_id)
{
@@ -294,167 +302,175 @@ QDF_STATUS pmo_ucfg_clear_pkt_filter(struct wlan_objmgr_psoc *psoc,
}
#endif
QDF_STATUS pmo_ucfg_get_gtk_rsp(struct wlan_objmgr_vdev *vdev,
struct pmo_gtk_rsp_req *gtk_rsp_req)
QDF_STATUS ucfg_pmo_get_gtk_rsp(struct wlan_objmgr_vdev *vdev,
struct pmo_gtk_rsp_req *gtk_rsp_req)
{
return pmo_core_get_gtk_rsp(vdev, gtk_rsp_req);
}
void pmo_ucfg_update_extscan_in_progress(struct wlan_objmgr_vdev *vdev,
bool value)
void ucfg_pmo_update_extscan_in_progress(struct wlan_objmgr_vdev *vdev,
bool value)
{
pmo_core_update_extscan_in_progress(vdev, value);
}
void pmo_ucfg_update_p2plo_in_progress(struct wlan_objmgr_vdev *vdev,
bool value)
void ucfg_pmo_update_p2plo_in_progress(struct wlan_objmgr_vdev *vdev,
bool value)
{
pmo_core_update_p2plo_in_progress(vdev, value);
}
QDF_STATUS pmo_ucfg_lphb_config_req(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_req *lphb_req, void *lphb_cb_ctx,
pmo_lphb_callback callback)
QDF_STATUS ucfg_pmo_lphb_config_req(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_req *lphb_req,
void *lphb_cb_ctx,
pmo_lphb_callback callback)
{
return pmo_core_lphb_config_req(psoc, lphb_req, lphb_cb_ctx, callback);
}
void pmo_ucfg_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc,
uint8_t value)
void ucfg_pmo_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc,
uint8_t value)
{
pmo_core_psoc_update_power_save_mode(psoc, value);
}
void pmo_ucfg_psoc_update_dp_handle(struct wlan_objmgr_psoc *psoc,
void *dp_handle)
void ucfg_pmo_psoc_update_dp_handle(struct wlan_objmgr_psoc *psoc,
void *dp_handle)
{
pmo_core_psoc_update_dp_handle(psoc, dp_handle);
}
void pmo_ucfg_psoc_update_htc_handle(struct wlan_objmgr_psoc *psoc,
void *htc_handle)
void ucfg_pmo_psoc_update_htc_handle(struct wlan_objmgr_psoc *psoc,
void *htc_handle)
{
pmo_core_psoc_update_htc_handle(psoc, htc_handle);
}
void pmo_ucfg_psoc_set_hif_handle(struct wlan_objmgr_psoc *psoc,
void *hif_handle)
void ucfg_pmo_psoc_set_hif_handle(struct wlan_objmgr_psoc *psoc,
void *hif_handle)
{
pmo_core_psoc_set_hif_handle(psoc, hif_handle);
}
void pmo_ucfg_psoc_set_txrx_handle(struct wlan_objmgr_psoc *psoc,
void *txrx_handle)
void ucfg_pmo_psoc_set_txrx_handle(struct wlan_objmgr_psoc *psoc,
void *txrx_handle)
{
pmo_core_psoc_set_txrx_handle(psoc, txrx_handle);
}
void pmo_ucfg_psoc_handle_initial_wake_up(void *cb_ctx)
void ucfg_pmo_psoc_handle_initial_wake_up(void *cb_ctx)
{
return pmo_core_psoc_handle_initial_wake_up(cb_ctx);
}
QDF_STATUS pmo_ucfg_psoc_user_space_suspend_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
QDF_STATUS
ucfg_pmo_psoc_user_space_suspend_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
{
return pmo_core_psoc_user_space_suspend_req(psoc, type);
}
QDF_STATUS pmo_ucfg_psoc_user_space_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
QDF_STATUS
ucfg_pmo_psoc_user_space_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
{
return pmo_core_psoc_user_space_resume_req(psoc, type);
}
QDF_STATUS pmo_ucfg_psoc_bus_suspend_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type,
struct pmo_wow_enable_params *wow_params)
QDF_STATUS
ucfg_pmo_psoc_bus_suspend_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type,
struct pmo_wow_enable_params *wow_params)
{
return pmo_core_psoc_bus_suspend_req(psoc, type, wow_params);
}
#ifdef FEATURE_RUNTIME_PM
QDF_STATUS pmo_ucfg_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
QDF_STATUS ucfg_pmo_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
pmo_pld_auto_suspend_cb pld_cb)
{
return pmo_core_psoc_bus_runtime_suspend(psoc, pld_cb);
}
QDF_STATUS pmo_ucfg_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
QDF_STATUS ucfg_pmo_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
pmo_pld_auto_suspend_cb pld_cb)
{
return pmo_core_psoc_bus_runtime_resume(psoc, pld_cb);
}
#endif
QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
int disable_target_intr)
QDF_STATUS
ucfg_pmo_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
int disable_target_intr)
{
return pmo_core_psoc_suspend_target(psoc, disable_target_intr);
}
QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn)
QDF_STATUS
ucfg_pmo_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn)
{
return pmo_core_add_wow_user_pattern(vdev, ptrn);
}
QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id)
QDF_STATUS
ucfg_pmo_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id)
{
return pmo_core_del_wow_user_pattern(vdev, pattern_id);
}
QDF_STATUS pmo_ucfg_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
QDF_STATUS
ucfg_pmo_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
{
return pmo_core_psoc_bus_resume_req(psoc, type);
}
bool pmo_ucfg_get_wow_bus_suspend(struct wlan_objmgr_psoc *psoc)
bool ucfg_pmo_get_wow_bus_suspend(struct wlan_objmgr_psoc *psoc)
{
return pmo_core_get_wow_bus_suspend(psoc);
}
int pmo_ucfg_psoc_is_target_wake_up_received(struct wlan_objmgr_psoc *psoc)
int ucfg_pmo_psoc_is_target_wake_up_received(struct wlan_objmgr_psoc *psoc)
{
return pmo_core_psoc_is_target_wake_up_received(psoc);
}
int pmo_ucfg_psoc_clear_target_wake_up(struct wlan_objmgr_psoc *psoc)
int ucfg_pmo_psoc_clear_target_wake_up(struct wlan_objmgr_psoc *psoc)
{
return pmo_core_psoc_clear_target_wake_up(psoc);
}
void pmo_ucfg_psoc_target_suspend_acknowledge(void *context, bool wow_nack)
void ucfg_pmo_psoc_target_suspend_acknowledge(void *context, bool wow_nack)
{
pmo_core_psoc_target_suspend_acknowledge(context, wow_nack);
}
void pmo_ucfg_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc)
void ucfg_pmo_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc)
{
pmo_core_psoc_wakeup_host_event_received(psoc);
}
QDF_STATUS pmo_ucfg_enable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_enable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
{
return pmo_core_enable_hw_filter_in_fwr(vdev);
}
QDF_STATUS pmo_ucfg_disable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
QDF_STATUS ucfg_pmo_disable_hw_filter_in_fwr(struct wlan_objmgr_vdev *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)
QDF_STATUS ucfg_pmo_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)
QDF_STATUS ucfg_pmo_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
uint32_t mod_dtim)
{
return pmo_core_config_modulated_dtim(vdev, mod_dtim);
}

24
core/cds/src/cds_api.c
View File

@@ -536,8 +536,8 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
htcInfo.pContext = ol_ctx;
htcInfo.TargetFailure = ol_target_failure;
htcInfo.TargetSendSuspendComplete =
pmo_ucfg_psoc_target_suspend_acknowledge;
htcInfo.target_initial_wakeup_cb = pmo_ucfg_psoc_handle_initial_wake_up;
ucfg_pmo_psoc_target_suspend_acknowledge;
htcInfo.target_initial_wakeup_cb = ucfg_pmo_psoc_handle_initial_wake_up;
htcInfo.target_psoc = (void *)psoc;
qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
@@ -550,7 +550,7 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
status = QDF_STATUS_E_FAILURE;
goto err_bmi_close;
}
pmo_ucfg_psoc_update_htc_handle(psoc, (void *)gp_cds_context->htc_ctx);
ucfg_pmo_psoc_update_htc_handle(psoc, (void *)gp_cds_context->htc_ctx);
status = bmi_done(ol_ctx);
if (QDF_IS_STATUS_ERROR(status)) {
@@ -618,7 +618,7 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
}
wlan_psoc_set_dp_handle(psoc, gp_cds_context->dp_soc);
pmo_ucfg_psoc_update_dp_handle(psoc, gp_cds_context->dp_soc);
ucfg_pmo_psoc_update_dp_handle(psoc, gp_cds_context->dp_soc);
ucfg_ocb_update_dp_handle(psoc, gp_cds_context->dp_soc);
cds_set_ac_specs_params(cds_cfg);
@@ -667,7 +667,7 @@ err_soc_detach:
gp_cds_context->dp_soc = NULL;
ucfg_ocb_update_dp_handle(psoc, NULL);
pmo_ucfg_psoc_update_dp_handle(psoc, NULL);
ucfg_pmo_psoc_update_dp_handle(psoc, NULL);
wlan_psoc_set_dp_handle(psoc, NULL);
err_wma_close:
@@ -679,7 +679,7 @@ err_htc_close:
if (gp_cds_context->htc_ctx) {
htc_destroy(gp_cds_context->htc_ctx);
gp_cds_context->htc_ctx = NULL;
pmo_ucfg_psoc_update_htc_handle(psoc, NULL);
ucfg_pmo_psoc_update_htc_handle(psoc, NULL);
}
err_bmi_close:
@@ -732,7 +732,7 @@ QDF_STATUS cds_dp_open(struct wlan_objmgr_psoc *psoc)
if (!QDF_IS_STATUS_SUCCESS(qdf_status))
goto pdev_detach;
pmo_ucfg_psoc_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
ucfg_pmo_psoc_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
ucfg_ocb_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
cds_debug("CDS successfully Opened");
@@ -1003,7 +1003,7 @@ static inline void cds_suspend_target(tp_wma_handle wma_handle)
{
QDF_STATUS status;
/* Suspend the target and disable interrupt */
status = pmo_ucfg_psoc_suspend_target(wma_handle->psoc, 0);
status = ucfg_pmo_psoc_suspend_target(wma_handle->psoc, 0);
if (status)
cds_err("Failed to suspend target, status = %d", status);
}
@@ -1012,7 +1012,7 @@ static inline void cds_suspend_target(tp_wma_handle wma_handle)
{
QDF_STATUS status;
/* Suspend the target and disable interrupt */
status = pmo_ucfg_psoc_suspend_target(wma_handle->psoc, 1);
status = ucfg_pmo_psoc_suspend_target(wma_handle->psoc, 1);
if (status)
cds_err("Failed to suspend target, status = %d", status);
}
@@ -1106,7 +1106,7 @@ QDF_STATUS cds_close(struct wlan_objmgr_psoc *psoc)
if (gp_cds_context->htc_ctx) {
htc_destroy(gp_cds_context->htc_ctx);
pmo_ucfg_psoc_update_htc_handle(psoc, NULL);
ucfg_pmo_psoc_update_htc_handle(psoc, NULL);
gp_cds_context->htc_ctx = NULL;
}
@@ -1125,7 +1125,7 @@ QDF_STATUS cds_close(struct wlan_objmgr_psoc *psoc)
gp_cds_context->mac_context = NULL;
cdp_soc_detach(gp_cds_context->dp_soc);
pmo_ucfg_psoc_update_dp_handle(psoc, NULL);
ucfg_pmo_psoc_update_dp_handle(psoc, NULL);
wlan_psoc_set_dp_handle(psoc, NULL);
cds_shutdown_notifier_purge();
@@ -1173,7 +1173,7 @@ QDF_STATUS cds_dp_close(struct wlan_objmgr_psoc *psoc)
(struct cdp_pdev *)ctx, 1);
cds_set_context(QDF_MODULE_ID_TXRX, NULL);
pmo_ucfg_psoc_set_txrx_handle(psoc, NULL);
ucfg_pmo_psoc_set_txrx_handle(psoc, NULL);
return QDF_STATUS_SUCCESS;
}

2
core/hdd/src/wlan_hdd_assoc.c
View File

@@ -1854,7 +1854,7 @@ static QDF_STATUS hdd_dis_connect_handler(struct hdd_adapter *adapter,
eConnectionState_NotConnected);
hdd_set_roaming_in_progress(false);
}
pmo_ucfg_flush_gtk_offload_req(adapter->vdev);
ucfg_pmo_flush_gtk_offload_req(adapter->vdev);
if ((QDF_STA_MODE == adapter->device_mode) ||
(QDF_P2P_CLIENT_MODE == adapter->device_mode)) {

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

@@ -4821,7 +4821,7 @@ void wlan_hdd_save_gtk_offload_params(struct hdd_adapter *adapter,
for (i = 0; i < 8; i++)
buf[7 - i] = replay_ctr[i];
status = pmo_ucfg_cache_gtk_offload_req(adapter->vdev, gtk_req);
status = ucfg_pmo_cache_gtk_offload_req(adapter->vdev, gtk_req);
if (status != QDF_STATUS_SUCCESS)
hdd_err("Failed to cache GTK Offload");
@@ -5590,7 +5590,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
modulated_dtim = nla_get_u32(
tb[QCA_WLAN_VENDOR_ATTR_CONFIG_MODULATED_DTIM]);
status = pmo_ucfg_config_modulated_dtim(adapter->vdev,
status = ucfg_pmo_config_modulated_dtim(adapter->vdev,
modulated_dtim);
if (QDF_STATUS_SUCCESS != status)
ret_val = -EPERM;
@@ -5606,7 +5606,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
return -EINVAL;
}
status = pmo_ucfg_config_listen_interval(adapter->vdev,
status = ucfg_pmo_config_listen_interval(adapter->vdev,
override_li);
if (status != QDF_STATUS_SUCCESS)
ret_val = -EPERM;
@@ -14944,7 +14944,7 @@ static int wlan_hdd_cfg80211_connect_start(struct hdd_adapter *adapter,
}
}
#endif
pmo_ucfg_flush_gtk_offload_req(adapter->vdev);
ucfg_pmo_flush_gtk_offload_req(adapter->vdev);
roam_profile->csrPersona = adapter->device_mode;
if (operatingChannel) {
@@ -18638,7 +18638,7 @@ int __wlan_hdd_cfg80211_set_rekey_data(struct wiphy *wiphy,
wlan_hdd_copy_gtk_kek(gtk_req, data);
qdf_mem_copy(gtk_req->kck, data->kck, NL80211_KCK_LEN);
gtk_req->is_fils_connection = hdd_is_fils_connection(adapter);
status = pmo_ucfg_cache_gtk_offload_req(adapter->vdev, gtk_req);
status = ucfg_pmo_cache_gtk_offload_req(adapter->vdev, gtk_req);
if (status != QDF_STATUS_SUCCESS) {
hdd_err("Failed to cache GTK Offload");
result = qdf_status_to_os_return(status);
@@ -18948,9 +18948,10 @@ 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->psoc,
status = ucfg_pmo_lphb_config_req(
hdd_ctx->psoc,
hb_params, (void *)hdd_ctx,
wlan_hdd_cfg80211_lphb_ind_handler);
wlan_hdd_cfg80211_lphb_ind_handler);
if (status != QDF_STATUS_SUCCESS)
hdd_err("LPHB Config Fail, disable");

6
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->psoc,
status = ucfg_pmo_get_mc_addr_list(hdd_ctx->psoc,
adapter->session_id,
&mc_addr_list);
if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -142,7 +142,7 @@ wlan_hdd_arp_offload_info_debugfs(struct hdd_context *hdd_ctx,
struct pmo_arp_offload_params info = {0};
QDF_STATUS status;
status = pmo_ucfg_get_arp_offload_params(adapter->vdev,
status = ucfg_pmo_get_arp_offload_params(adapter->vdev,
&info);
if (!QDF_IS_STATUS_SUCCESS(status)) {
ret_val = scnprintf(buf, buf_avail_len,
@@ -232,7 +232,7 @@ wlan_hdd_ns_offload_info_debugfs(struct hdd_context *hdd_ctx,
QDF_STATUS status;
uint32_t i;
status = pmo_ucfg_get_ns_offload_params(adapter->vdev,
status = ucfg_pmo_get_ns_offload_params(adapter->vdev,
&info);
if (!QDF_IS_STATUS_SUCCESS(status)) {
ret = scnprintf(buf, buf_avail_len,

20
core/hdd/src/wlan_hdd_driver_ops.c
View File

@@ -263,7 +263,7 @@ int hdd_hif_open(struct device *dev, void *bdev, const struct hif_bus_id *bid,
hif_set_ce_service_max_yield_time(hif_ctx,
hdd_ctx->config->ce_service_max_yield_time);
pmo_ucfg_psoc_set_hif_handle(hdd_ctx->psoc, hif_ctx);
ucfg_pmo_psoc_set_hif_handle(hdd_ctx->psoc, hif_ctx);
hif_set_ce_service_max_rx_ind_flush(hif_ctx,
hdd_ctx->config->ce_service_max_rx_ind_flush);
return 0;
@@ -291,7 +291,7 @@ void hdd_hif_close(struct hdd_context *hdd_ctx, void *hif_ctx)
hdd_deinit_cds_hif_context();
hif_close(hif_ctx);
pmo_ucfg_psoc_set_hif_handle(hdd_ctx->psoc, NULL);
ucfg_pmo_psoc_set_hif_handle(hdd_ctx->psoc, NULL);
}
/**
@@ -808,7 +808,7 @@ static int __wlan_hdd_bus_suspend(struct wow_enable_params wow_params)
goto resume_cdp;
}
status = pmo_ucfg_psoc_bus_suspend_req(hdd_ctx->psoc,
status = ucfg_pmo_psoc_bus_suspend_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND,
&pmo_params);
err = qdf_status_to_os_return(status);
@@ -827,7 +827,7 @@ static int __wlan_hdd_bus_suspend(struct wow_enable_params wow_params)
return 0;
resume_pmo:
status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->psoc,
status = ucfg_pmo_psoc_bus_resume_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
QDF_BUG(QDF_IS_STATUS_SUCCESS(status));
@@ -906,7 +906,7 @@ static int __wlan_hdd_bus_suspend_noirq(void)
if (errno)
goto done;
errno = pmo_ucfg_psoc_is_target_wake_up_received(hdd_ctx->psoc);
errno = ucfg_pmo_psoc_is_target_wake_up_received(hdd_ctx->psoc);
if (errno == -EAGAIN) {
hdd_err("Firmware attempting wakeup, try again");
wlan_hdd_inc_suspend_stats(hdd_ctx,
@@ -998,8 +998,8 @@ static int __wlan_hdd_bus_resume(void)
goto out;
}
qdf_status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
qdf_status = ucfg_pmo_psoc_bus_resume_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
status = qdf_status_to_os_return(qdf_status);
if (status) {
hdd_err("Failed pmo bus resume");
@@ -1080,7 +1080,7 @@ static int __wlan_hdd_bus_resume_noirq(void)
if (NULL == hif_ctx)
return -EINVAL;
qdf_status = pmo_ucfg_psoc_clear_target_wake_up(hdd_ctx->psoc);
qdf_status = ucfg_pmo_psoc_clear_target_wake_up(hdd_ctx->psoc);
QDF_BUG(!qdf_status);
status = hif_bus_resume_noirq(hif_ctx);
@@ -1178,7 +1178,7 @@ static int __wlan_hdd_runtime_suspend(struct device *dev)
return -EBUSY;
}
status = pmo_ucfg_psoc_bus_runtime_suspend(hdd_ctx->psoc,
status = ucfg_pmo_psoc_bus_runtime_suspend(hdd_ctx->psoc,
hdd_pld_runtime_suspend_cb);
err = qdf_status_to_os_return(status);
@@ -1246,7 +1246,7 @@ static int __wlan_hdd_runtime_resume(struct device *dev)
return 0;
}
status = pmo_ucfg_psoc_bus_runtime_resume(hdd_ctx->psoc,
status = ucfg_pmo_psoc_bus_runtime_resume(hdd_ctx->psoc,
hdd_pld_runtime_resume_cb);
if (status != QDF_STATUS_SUCCESS)
hdd_err("PMO Runtime resume failed: %d", status);

8
core/hdd/src/wlan_hdd_main.c
View File

@@ -3411,9 +3411,9 @@ static void __hdd_set_multicast_list(struct net_device *dev)
pmo_mc_list_change_notify);
} else {
mc_count = netdev_mc_count(dev);
if (mc_count > pmo_ucfg_max_mc_addr_supported(psoc)) {
if (mc_count > ucfg_pmo_max_mc_addr_supported(psoc)) {
hdd_debug("Exceeded max MC filter addresses (%d). Allowing all MC frames by disabling MC address filtering",
pmo_ucfg_max_mc_addr_supported(psoc));
ucfg_pmo_max_mc_addr_supported(psoc));
hdd_disable_and_flush_mc_addr_list(adapter,
pmo_mc_list_change_notify);
goto free_req;
@@ -3749,9 +3749,9 @@ int hdd_vdev_ready(struct hdd_adapter *adapter)
return qdf_status_to_os_return(status);
if (wma_capability_enhanced_mcast_filter())
status = pmo_ucfg_enhanced_mc_filter_enable(adapter->vdev);
status = ucfg_pmo_enhanced_mc_filter_enable(adapter->vdev);
else
status = pmo_ucfg_enhanced_mc_filter_disable(adapter->vdev);
status = ucfg_pmo_enhanced_mc_filter_disable(adapter->vdev);
return qdf_status_to_os_return(status);
}

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

@@ -212,10 +212,11 @@ int wlan_hdd_set_filter(struct hdd_context *hdd_ctx,
request->params_data[i].data_mask[5]);
}
if (QDF_STATUS_SUCCESS !=
pmo_ucfg_set_pkt_filter(hdd_ctx->psoc,
pmo_set_pkt_fltr_req,
sessionId)) {
status= ucfg_pmo_set_pkt_filter(hdd_ctx->psoc,
pmo_set_pkt_fltr_req,
sessionId);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("Failure to execute Set Filter");
status = QDF_STATUS_E_INVAL;
goto out;
@@ -235,10 +236,10 @@ int wlan_hdd_set_filter(struct hdd_context *hdd_ctx,
}
pmo_clr_pkt_fltr_param->filter_id = request->filter_id;
if (QDF_STATUS_SUCCESS !=
pmo_ucfg_clear_pkt_filter(hdd_ctx->psoc,
pmo_clr_pkt_fltr_param,
sessionId)) {
status = ucfg_pmo_clear_pkt_filter(hdd_ctx->psoc,
pmo_clr_pkt_fltr_param,
sessionId);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("Failure to execute Clear Filter");
status = QDF_STATUS_E_INVAL;
goto out;

46
core/hdd/src/wlan_hdd_power.c
View File

@@ -136,7 +136,7 @@ static void hdd_enable_gtk_offload(struct hdd_adapter *adapter)
{
QDF_STATUS status;
status = pmo_ucfg_enable_gtk_offload_in_fwr(adapter->vdev);
status = ucfg_pmo_enable_gtk_offload_in_fwr(adapter->vdev);
if (status != QDF_STATUS_SUCCESS)
hdd_info("Failed to enable gtk offload");
}
@@ -160,14 +160,14 @@ static void hdd_disable_gtk_offload(struct hdd_adapter *adapter)
/* Passing as void* as PMO does not know legacy HDD adapter type */
gtk_rsp_request.callback_context = (void *)adapter;
status = pmo_ucfg_get_gtk_rsp(adapter->vdev, &gtk_rsp_request);
status = ucfg_pmo_get_gtk_rsp(adapter->vdev, &gtk_rsp_request);
if (status != QDF_STATUS_SUCCESS) {
hdd_err("Failed to send get gtk rsp status:%d", status);
return;
}
hdd_debug("send get_gtk_rsp successful");
status = pmo_ucfg_disable_gtk_offload_in_fwr(adapter->vdev);
status = ucfg_pmo_disable_gtk_offload_in_fwr(adapter->vdev);
if (status != QDF_STATUS_SUCCESS)
hdd_info("Failed to disable gtk offload");
}
@@ -279,7 +279,7 @@ static int hdd_fill_ipv6_uc_addr(struct inet6_dev *idev,
qdf_mem_copy(ipv6_uc_addr[*count], &ifa->addr.s6_addr,
sizeof(ifa->addr.s6_addr));
ipv6addr_type[*count] = PMO_IPV6_ADDR_UC_TYPE;
scope_array[*count] = pmo_ucfg_ns_addr_scope(scope);
scope_array[*count] = ucfg_pmo_ns_addr_scope(scope);
hdd_debug("Index %d scope = %s UC-Address: %pI6",
*count, (scope == IPV6_ADDR_SCOPE_LINKLOCAL) ?
"LINK LOCAL" : "GLOBAL", ipv6_uc_addr[*count]);
@@ -329,7 +329,7 @@ static int hdd_fill_ipv6_ac_addr(struct inet6_dev *idev,
qdf_mem_copy(ipv6_ac_addr[*count], &ifaca->aca_addr,
sizeof(ifaca->aca_addr));
ipv6addr_type[*count] = PMO_IPV6_ADDR_AC_TYPE;
scope_array[*count] = pmo_ucfg_ns_addr_scope(scope);
scope_array[*count] = ucfg_pmo_ns_addr_scope(scope);
hdd_debug("Index %d scope = %s AC-Address: %pI6",
*count, (scope == IPV6_ADDR_SCOPE_LINKLOCAL) ?
"LINK LOCAL" : "GLOBAL", ipv6_ac_addr[*count]);
@@ -397,14 +397,14 @@ void hdd_enable_ns_offload(struct hdd_adapter *adapter,
}
/* cache ns request */
status = pmo_ucfg_cache_ns_offload_req(ns_req);
status = ucfg_pmo_cache_ns_offload_req(ns_req);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("Failed to cache ns request; status:%d", status);
goto free_req;
}
/* enable ns request */
status = pmo_ucfg_enable_ns_offload_in_fwr(adapter->vdev, trigger);
status = ucfg_pmo_enable_ns_offload_in_fwr(adapter->vdev, trigger);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("Failed to enable ns offload; status:%d", status);
goto free_req;
@@ -425,13 +425,13 @@ void hdd_disable_ns_offload(struct hdd_adapter *adapter,
QDF_STATUS status;
hdd_enter();
status = pmo_ucfg_flush_ns_offload_req(adapter->vdev);
status = ucfg_pmo_flush_ns_offload_req(adapter->vdev);
if (status != QDF_STATUS_SUCCESS) {
hdd_err("Failed to flush NS Offload");
goto out;
}
status = pmo_ucfg_disable_ns_offload_in_fwr(adapter->vdev, trigger);
status = ucfg_pmo_disable_ns_offload_in_fwr(adapter->vdev, trigger);
if (status != QDF_STATUS_SUCCESS)
hdd_err("Failed to disable NS Offload");
else
@@ -491,7 +491,7 @@ static void hdd_enable_hw_filter(struct hdd_adapter *adapter)
hdd_enter();
status = pmo_ucfg_enable_hw_filter_in_fwr(adapter->vdev);
status = ucfg_pmo_enable_hw_filter_in_fwr(adapter->vdev);
if (status != QDF_STATUS_SUCCESS)
hdd_info("Failed to enable hardware filter");
@@ -504,7 +504,7 @@ static void hdd_disable_hw_filter(struct hdd_adapter *adapter)
hdd_enter();
status = pmo_ucfg_disable_hw_filter_in_fwr(adapter->vdev);
status = ucfg_pmo_disable_hw_filter_in_fwr(adapter->vdev);
if (status != QDF_STATUS_SUCCESS)
hdd_info("Failed to disable hardware filter");
@@ -886,13 +886,13 @@ void hdd_enable_arp_offload(struct hdd_adapter *adapter,
arp_req->ipv4_addr = (uint32_t)ifa->ifa_local;
status = pmo_ucfg_cache_arp_offload_req(arp_req);
status = ucfg_pmo_cache_arp_offload_req(arp_req);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("failed to cache arp offload req; status:%d", status);
goto free_req;
}
status = pmo_ucfg_enable_arp_offload_in_fwr(adapter->vdev, trigger);
status = ucfg_pmo_enable_arp_offload_in_fwr(adapter->vdev, trigger);
if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("failed arp offload config in fw; status:%d", status);
goto free_req;
@@ -913,13 +913,13 @@ void hdd_disable_arp_offload(struct hdd_adapter *adapter,
QDF_STATUS status;
hdd_enter();
status = pmo_ucfg_flush_arp_offload_req(adapter->vdev);
status = ucfg_pmo_flush_arp_offload_req(adapter->vdev);
if (status != QDF_STATUS_SUCCESS) {
hdd_err("Failed to flush arp Offload");
goto out;
}
status = pmo_ucfg_disable_arp_offload_in_fwr(adapter->vdev,
status = ucfg_pmo_disable_arp_offload_in_fwr(adapter->vdev,
trigger);
if (status == QDF_STATUS_SUCCESS)
hdd_wlan_offload_event(PMO_IPV4_ARP_REPLY_OFFLOAD,
@@ -944,7 +944,7 @@ void hdd_enable_mc_addr_filtering(struct hdd_adapter *adapter,
if (!hdd_adapter_is_connected_sta(adapter))
goto out;
status = pmo_ucfg_enable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
status = ucfg_pmo_enable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
adapter->session_id,
trigger);
if (QDF_IS_STATUS_ERROR(status))
@@ -968,7 +968,7 @@ void hdd_disable_mc_addr_filtering(struct hdd_adapter *adapter,
if (!hdd_adapter_is_connected_sta(adapter))
goto out;
status = pmo_ucfg_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
status = ucfg_pmo_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
adapter->session_id,
trigger);
if (QDF_IS_STATUS_ERROR(status))
@@ -983,7 +983,7 @@ int hdd_cache_mc_addr_list(struct pmo_mc_addr_list_params *mc_list_config)
QDF_STATUS status;
hdd_enter();
status = pmo_ucfg_cache_mc_addr_list(mc_list_config);
status = ucfg_pmo_cache_mc_addr_list(mc_list_config);
hdd_exit();
return qdf_status_to_os_return(status);
@@ -1001,14 +1001,14 @@ void hdd_disable_and_flush_mc_addr_list(struct hdd_adapter *adapter,
goto flush_mc_list;
/* disable mc list first because the mc list is cached in PMO */
status = pmo_ucfg_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
status = ucfg_pmo_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
adapter->session_id,
trigger);
if (QDF_IS_STATUS_ERROR(status))
hdd_err("failed to disable mc list; status:%d", status);
flush_mc_list:
status = pmo_ucfg_flush_mc_addr_list(hdd_ctx->psoc,
status = ucfg_pmo_flush_mc_addr_list(hdd_ctx->psoc,
adapter->session_id);
if (QDF_IS_STATUS_ERROR(status))
hdd_err("failed to flush mc list; status:%d", status);
@@ -1087,8 +1087,8 @@ hdd_suspend_wlan(void)
hdd_update_conn_state_mask(adapter, &conn_state_mask);
}
status = pmo_ucfg_psoc_user_space_suspend_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
status = ucfg_pmo_psoc_user_space_suspend_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
if (status != QDF_STATUS_SUCCESS)
return -EAGAIN;
@@ -1146,7 +1146,7 @@ static int hdd_resume_wlan(void)
}
ucfg_ipa_resume(hdd_ctx->pdev);
status = pmo_ucfg_psoc_user_space_resume_req(hdd_ctx->psoc,
status = ucfg_pmo_psoc_user_space_resume_req(hdd_ctx->psoc,
QDF_SYSTEM_SUSPEND);
if (QDF_IS_STATUS_ERROR(status))
return qdf_status_to_os_return(status);

8
core/hdd/src/wlan_hdd_wowl.c
View File

@@ -221,7 +221,7 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
localPattern.session_id = sessionId;
/* Register the pattern downstream */
status = pmo_ucfg_add_wow_user_pattern(
status = ucfg_pmo_add_wow_user_pattern(
adapter->vdev, &localPattern);
if (QDF_IS_STATUS_ERROR(status)) {
/* Add failed, so invalidate the local storage */
@@ -281,7 +281,7 @@ bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
if (!patternFound)
return false;
status = pmo_ucfg_del_wow_user_pattern(adapter->vdev, id);
status = ucfg_pmo_del_wow_user_pattern(adapter->vdev, id);
if (QDF_IS_STATUS_ERROR(status))
return false;
@@ -388,7 +388,7 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
}
/* Register the pattern downstream */
qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
qdf_ret_status = ucfg_pmo_add_wow_user_pattern(
adapter->vdev, &localPattern);
if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
hdd_err("pmo_wow_user_pattern failed with error code (%d).",
@@ -435,7 +435,7 @@ bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
return false;
}
qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
qdf_ret_status = ucfg_pmo_del_wow_user_pattern(
adapter->vdev, pattern_idx);
if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
hdd_err("sme_wowl_del_bcast_pattern failed with error code (%d).",

2
core/wma/src/wma_data.c
View File

@@ -1525,7 +1525,7 @@ int wma_mcc_vdev_tx_pause_evt_handler(void *handle, uint8_t *event,
return -EINVAL;
}
if (pmo_ucfg_get_wow_bus_suspend(wma->psoc)) {
if (ucfg_pmo_get_wow_bus_suspend(wma->psoc)) {
WMA_LOGD(" Suspend is in progress: Pause/Unpause Tx is NoOp");
return 0;
}

2
core/wma/src/wma_dev_if.c
View File

@@ -3968,7 +3968,7 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
goto send_fail_resp;
}
if (SAP_WPS_DISABLED == add_bss->wps_state)
pmo_ucfg_disable_wakeup_event(wma->psoc, vdev_id,
ucfg_pmo_disable_wakeup_event(wma->psoc, vdev_id,
WOW_PROBE_REQ_WPS_IE_EVENT);
wma_set_bss_rate_flags(wma, vdev_id, add_bss);
status = wma_create_peer(wma, pdev, vdev, add_bss->bssId,

6
core/wma/src/wma_features.c
View File

@@ -2960,7 +2960,7 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event, uint32_t len)
wma_wake_event_log_reason(wma, wake_info);
pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
wma_print_wow_stats(wma, wake_info);
/* split based on payload type */
@@ -3005,7 +3005,7 @@ int wma_d0_wow_disable_ack_event(void *handle, uint8_t *event, uint32_t len)
resp_data = param_buf->fixed_param;
pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
WMA_LOGD("Received D0-WOW disable ACK");
@@ -3032,7 +3032,7 @@ int wma_pdev_resume_event_handler(void *handle, uint8_t *event, uint32_t len)
WMA_LOGA("Received PDEV resume event");
pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
return 0;
}

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

@@ -1956,7 +1956,7 @@ static void wma_shutdown_notifier_cb(void *priv)
QDF_STATUS status;
qdf_event_set(&wma_handle->wma_resume_event);
pmo_ucfg_psoc_wakeup_host_event_received(wma_handle->psoc);
ucfg_pmo_psoc_wakeup_host_event_received(wma_handle->psoc);
wmi_stop(wma_handle->wmi_handle);
msg.bodyptr = priv;