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-15 01:01:56 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Add support to improve coex logging

Browse source 
Add support to get the various Coex data from the debugfs.
This commit adds the support to get the various coex data:
            * COEX STATE
            * COEX DPWB STATE
            * COEX TDM STATE
            * COEX IDRX STATE
            * COEX ANTENNA SHARING STATE
The specific state information can be read via the debugfs.
Example to read the COEX STATE logging:
            sm6150:/ # cat /sys/kernel/debug/wlan/mws_coex_state
                    vdev_id = 0
                    coex_scheme_bitmap =  0
                    active_conflict_count = 0
                    potential_conflict_count = 0
                    chavd_group0_bitmap = 0
                    chavd_group1_bitmap = 0
                    chavd_group2_bitmap = 0
                    chavd_group3_bitmap = 0

Change-Id: I92272ad7edf44df22730ac0fa992d876840ba632
CRs-Fixed: 2413943
This commit is contained in:
Arun Kumar Khandavalli 2019-03-11 15:32:19 +05:30 • committed by nshrivas
commit deda5a812c
14 changed files with 1244 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Kbuild
View file

@ -86,6 +86,9 @@ HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_debugfs_csr.o
HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_debugfs_connect.o
HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_debugfs_offload.o
HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_debugfs_roam.o
ifeq ($(CONFIG_WLAN_MWS_INFO_DEBUGFS), y)
HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_debugfs_coex.o
endif
endif
ifeq ($(CONFIG_WLAN_CONV_SPECTRAL_ENABLE),y)
@ -1669,6 +1672,9 @@ endif
ifeq ($(CONFIG_QCACLD_FEATURE_FW_STATE), y)
WMA_OBJS += $(WMA_SRC_DIR)/wma_fw_state.o
endif
ifeq ($(CONFIG_WLAN_MWS_INFO_DEBUGFS), y)
WMA_OBJS += $(WMA_SRC_DIR)/wma_coex.o
endif
############## PLD ##########
PLD_DIR := core/pld
PLD_INC_DIR := $(PLD_DIR)/inc
@ -2074,6 +2080,8 @@ cppflags-$(CONFIG_FEATURE_ROAM_DEBUG) += -DFEATURE_ROAM_DEBUG
cppflags-$(CONFIG_WLAN_POWER_DEBUGFS) += -DWLAN_POWER_DEBUGFS
cppflags-$(CONFIG_WLAN_MWS_INFO_DEBUGFS) += -DWLAN_MWS_INFO_DEBUGFS
# Enable object manager reference count debug infrastructure
cppflags-$(CONFIG_WLAN_OBJMGR_DEBUG) += -DWLAN_OBJMGR_DEBUG
cppflags-$(CONFIG_WLAN_OBJMGR_DEBUG) += -DWLAN_OBJMGR_REF_ID_DEBUG

2
configs/default_defconfig
View file

@ -373,6 +373,8 @@ ifeq ($(CONFIG_DEBUG_FS), y)
CONFIG_WLAN_DEBUGFS := y
CONFIG_WLAN_POWER_DEBUGFS := y
CONFIG_WLAN_MWS_INFO_DEBUGFS := y
endif
# Feature flags which are not (currently) configurable via Kconfig

49
core/hdd/inc/wlan_hdd_debugfs_coex.h Normal file
View file

@ -0,0 +1,49 @@
/*
* Copyright (c) 2019 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WLAN_HDD_DEBUGFS_COEX_H
#define _WLAN_HDD_DEBUGFS_COEX_H
#ifdef WLAN_MWS_INFO_DEBUGFS
/**
* hdd_debugfs_mws_coex_info_init() - MWS coex initialization
* @hdd_ctx: Pointer to the hdd_ctx
*
* This function is called to initialize the coex debugfs.
* Return: None
*/
void hdd_debugfs_mws_coex_info_init(struct hdd_context *hdd_ctx);
/**
* hdd_debugfs_mws_coex_info_deinit() - MWS coex deintialization
* @hdd_ctx: Pointer to the hdd_ctx
*
* This function is called to deinitialize the coex debugfs.
* Return: None
*/
void hdd_debugfs_mws_coex_info_deinit(struct hdd_context *hdd_ctx);
#else
static inline void hdd_debugfs_mws_coex_info_init(struct hdd_context *hdd_ctx)
{
}
static inline void hdd_debugfs_mws_coex_info_deinit(struct hdd_context *hdd_ctx)
{
}
#endif
#endif

668
core/hdd/src/wlan_hdd_debugfs_coex.c Normal file
View file

@ -0,0 +1,668 @@
/*
* Copyright (c) 2019 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: wlan_hdd_debugfs_coex.c
*
* This file currently supports the following debugfs:
* Get the following information coex information
* COEX STATE
* COEX DPWB STATE
* COEX TDM STATE
* COEX IDRX STATE
* COEX ANTENNA SHARING STATE
*
* Example to read the COEX STATE logging:
* sm6150:/ # cat /sys/kernel/debug/wlan/mws_coex_state
*/
#include <wlan_hdd_includes.h>
#include <wlan_osif_request_manager.h>
#include <wlan_hdd_debugfs_coex.h>
#include "wmi_unified.h"
#include "wmi_unified_param.h"
#include "osif_sync.h"
#define MWS_DEBUGFS_PERMS (QDF_FILE_USR_READ | \
QDF_FILE_GRP_READ | \
QDF_FILE_OTH_READ)
/* wait time for mws coex info in milliseconds */
#define WLAN_WAIT_TIME_MWS_COEX_INFO 800
struct mws_coex_state_priv {
struct mws_coex_state coex_state;
};
struct mws_coex_dpwb_state_priv {
struct mws_coex_dpwb_state dpwb_state;
};
struct mws_coex_tdm_state_priv {
struct mws_coex_tdm_state tdm_state;
};
struct mws_coex_idrx_state_priv {
struct mws_coex_idrx_state idrx_state;
};
struct mws_antenna_sharing_info_priv {
struct mws_antenna_sharing_info antenna_sharing;
};
static void hdd_debugfs_mws_coex_info_cb(void *coex_info_data, void *context,
wmi_mws_coex_cmd_id cmd_id)
{
struct osif_request *request = NULL;
struct mws_coex_state_priv *coex_priv;
struct mws_coex_dpwb_state_priv *dpwb_priv;
struct mws_coex_tdm_state_priv *tdm_priv;
struct mws_coex_idrx_state_priv *idrx_priv;
struct mws_antenna_sharing_info_priv *antenna_priv;
if (!coex_info_data) {
hdd_err("data is null");
return;
}
request = osif_request_get(context);
if (!request) {
hdd_err("obselete request");
return;
}
switch (cmd_id) {
case WMI_MWS_COEX_STATE:
coex_priv = osif_request_priv(request);
qdf_mem_copy(&coex_priv->coex_state, coex_info_data,
sizeof(struct mws_coex_state));
break;
case WMI_MWS_COEX_DPWB_STATE:
dpwb_priv = osif_request_priv(request);
qdf_mem_copy(&dpwb_priv->dpwb_state, coex_info_data,
sizeof(struct mws_coex_dpwb_state));
break;
case WMI_MWS_COEX_TDM_STATE:
tdm_priv = osif_request_priv(request);
qdf_mem_copy(&tdm_priv->tdm_state, coex_info_data,
sizeof(struct mws_coex_tdm_state));
break;
case WMI_MWS_COEX_IDRX_STATE:
idrx_priv = osif_request_priv(request);
qdf_mem_copy(&idrx_priv->idrx_state, coex_info_data,
sizeof(struct mws_coex_idrx_state));
break;
case WMI_MWS_COEX_ANTENNA_SHARING_STATE:
antenna_priv = osif_request_priv(request);
qdf_mem_copy(&antenna_priv->antenna_sharing, coex_info_data,
sizeof(struct mws_antenna_sharing_info));
break;
}
osif_request_complete(request);
osif_request_put(request);
}
static QDF_STATUS __hdd_debugfs_mws_coex_state_read(struct hdd_context *hdd_ctx,
qdf_debugfs_file_t file)
{
struct hdd_adapter *adapter;
QDF_STATUS status;
int rc;
struct osif_request *request;
struct mws_coex_state *coex_state;
struct mws_coex_state_priv *priv;
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_MWS_COEX_INFO,
};
void *cookie;
adapter = hdd_get_first_valid_adapter(hdd_ctx);
if (!adapter) {
hdd_err("Failed to get adapter");
return QDF_STATUS_E_INVAL;
}
if (!test_bit(DEVICE_IFACE_OPENED, &adapter->event_flags)) {
hdd_err("Interface is not enabled");
return QDF_STATUS_E_INVAL;
}
if (file->index > 0)
return QDF_STATUS_SUCCESS;
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = osif_request_cookie(request);
status = sme_get_mws_coex_info(hdd_ctx->mac_handle,
adapter->vdev_id, WMI_MWS_COEX_STATE,
hdd_debugfs_mws_coex_info_cb, cookie);
if (QDF_IS_STATUS_ERROR(status)) {
rc = qdf_status_to_os_return(status);
goto exit;
}
rc = osif_request_wait_for_response(request);
if (rc) {
qdf_debugfs_printf(file, "Timedout while retrieving MWS coex state");
rc = -ETIMEDOUT;
goto exit;
}
priv = osif_request_priv(request);
coex_state = &priv->coex_state;
qdf_debugfs_printf(file, "vdev_id = %u\n"
"coex_scheme_bitmap = %u\n"
"active_conflict_count = %u\n"
"potential_conflict_count = %u\n"
"chavd_group0_bitmap = %u\n"
"chavd_group1_bitmap = %u\n"
"chavd_group2_bitmap = %u\n"
"chavd_group3_bitmap = %u\n",
coex_state->vdev_id,
coex_state->coex_scheme_bitmap,
coex_state->active_conflict_count,
coex_state->potential_conflict_count,
coex_state->chavd_group0_bitmap,
coex_state->chavd_group1_bitmap,
coex_state->chavd_group2_bitmap,
coex_state->chavd_group3_bitmap);
exit:
osif_request_put(request);
return qdf_status_from_os_return(rc);
}
static QDF_STATUS hdd_debugfs_mws_coex_state_read(qdf_debugfs_file_t file,
void *arg)
{
struct osif_psoc_sync *psoc_sync;
struct hdd_context *hdd_ctx = arg;
int ret;
QDF_STATUS status;
ret = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
if (ret)
return qdf_status_from_os_return(ret);
status = __hdd_debugfs_mws_coex_state_read(hdd_ctx, file);
osif_psoc_sync_op_stop(psoc_sync);
return qdf_status_from_os_return(ret);
}
static QDF_STATUS __hdd_debugfs_mws_coex_dpwb_read(struct hdd_context *hdd_ctx,
qdf_debugfs_file_t file)
{
struct hdd_adapter *adapter;
QDF_STATUS status;
int rc;
struct osif_request *request;
struct mws_coex_dpwb_state *dpwb_state;
struct mws_coex_dpwb_state_priv *dpwb_priv;
static const struct osif_request_params params = {
.priv_size = sizeof(*dpwb_priv),
.timeout_ms = WLAN_WAIT_TIME_MWS_COEX_INFO,
};
void *cookie;
adapter = hdd_get_first_valid_adapter(hdd_ctx);
if (!adapter) {
hdd_err("Failed to get adapter");
return QDF_STATUS_E_INVAL;
}
if (!test_bit(DEVICE_IFACE_OPENED, &adapter->event_flags)) {
hdd_err("Interface is not enabled");
return QDF_STATUS_E_INVAL;
}
if (file->index > 0)
return QDF_STATUS_SUCCESS;
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = osif_request_cookie(request);
status = sme_get_mws_coex_info(hdd_ctx->mac_handle,
adapter->vdev_id,
WMI_MWS_COEX_DPWB_STATE,
hdd_debugfs_mws_coex_info_cb, cookie);
if (QDF_IS_STATUS_ERROR(status)) {
rc = qdf_status_to_os_return(status);
goto exit;
}
rc = osif_request_wait_for_response(request);
if (rc) {
qdf_debugfs_printf(file, "Timedout while retrieving MWS coex dpwb state");
rc = -ETIMEDOUT;
goto exit;
}
dpwb_priv = osif_request_priv(request);
dpwb_state = &dpwb_priv->dpwb_state;
qdf_debugfs_printf(file, "vdev_id = %u\n"
"current_dpwb_state = %d\n"
"pnp1_value = %d\n"
"lte_dutycycle = %d\n"
"sinr_wlan_on = %d\n"
"bler_count = %u\n"
"block_count = %u\n"
"wlan_rssi_level = %u\n"
"wlan_rssi = %d\n"
"is_tdm_running = %u\n",
dpwb_state->vdev_id,
dpwb_state->current_dpwb_state,
dpwb_state->pnp1_value,
dpwb_state->lte_dutycycle,
dpwb_state->sinr_wlan_on,
dpwb_state->sinr_wlan_off,
dpwb_state->bler_count,
dpwb_state->block_count,
dpwb_state->wlan_rssi_level,
dpwb_state->wlan_rssi,
dpwb_state->is_tdm_running);
exit:
osif_request_put(request);
return qdf_status_from_os_return(rc);
}
static QDF_STATUS hdd_debugfs_mws_coex_dpwb_read(qdf_debugfs_file_t file,
void *arg)
{
struct osif_psoc_sync *psoc_sync;
struct hdd_context *hdd_ctx = arg;
int ret;
QDF_STATUS status;
ret = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
if (ret)
return qdf_status_from_os_return(ret);
status = __hdd_debugfs_mws_coex_dpwb_read(hdd_ctx, file);
osif_psoc_sync_op_stop(psoc_sync);
return qdf_status_from_os_return(ret);
}
static QDF_STATUS __hdd_debugfs_mws_tdm_state_read(struct hdd_context *hdd_ctx,
qdf_debugfs_file_t file)
{
struct hdd_adapter *adapter;
QDF_STATUS status;
int rc;
struct mws_coex_tdm_state *tdm_state;
struct mws_coex_tdm_state_priv *tdm_priv;
struct osif_request *request;
static const struct osif_request_params params = {
.priv_size = sizeof(*tdm_priv),
.timeout_ms = WLAN_WAIT_TIME_MWS_COEX_INFO,
};
void *cookie;
adapter = hdd_get_first_valid_adapter(hdd_ctx);
if (!adapter) {
hdd_err("Failed to get adapter");
return QDF_STATUS_E_INVAL;
}
if (!test_bit(DEVICE_IFACE_OPENED, &adapter->event_flags)) {
hdd_err("Interface is not enabled");
return QDF_STATUS_E_INVAL;
}
if (file->index > 0)
return QDF_STATUS_SUCCESS;
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = osif_request_cookie(request);
status = sme_get_mws_coex_info(hdd_ctx->mac_handle,
adapter->vdev_id, WMI_MWS_COEX_TDM_STATE,
hdd_debugfs_mws_coex_info_cb, cookie);
if (QDF_IS_STATUS_ERROR(status)) {
rc = qdf_status_to_os_return(status);
goto exit;
}
rc = osif_request_wait_for_response(request);
if (rc) {
qdf_debugfs_printf(file, "Timedout while retrieving MWS coex tdm state");
rc = -ETIMEDOUT;
goto exit;
}
tdm_priv = osif_request_priv(request);
tdm_state = &tdm_priv->tdm_state;
qdf_debugfs_printf(file, "vdev_id = %u\n"
"tdm_policy_bitmap = %u\n"
"tdm_sf_bitmap = %u\n",
tdm_state->vdev_id,
tdm_state->tdm_policy_bitmap,
tdm_state->tdm_sf_bitmap);
exit:
osif_request_put(request);
return qdf_status_from_os_return(rc);
}
static QDF_STATUS hdd_debugfs_mws_tdm_state_read(qdf_debugfs_file_t file,
void *arg)
{
struct osif_psoc_sync *psoc_sync;
struct hdd_context *hdd_ctx = arg;
int ret;
QDF_STATUS status;
ret = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
if (ret)
return qdf_status_from_os_return(ret);
status = __hdd_debugfs_mws_tdm_state_read(hdd_ctx, file);
osif_psoc_sync_op_stop(psoc_sync);
return qdf_status_from_os_return(ret);
}
static QDF_STATUS __hdd_debugfs_mws_coex_idrx_read(struct hdd_context *hdd_ctx,
qdf_debugfs_file_t file)
{
struct hdd_adapter *adapter;
QDF_STATUS status;
int rc;
struct osif_request *request;
struct mws_coex_idrx_state_priv *idrx_priv;
struct mws_coex_idrx_state *idrx_state;
static const struct osif_request_params params = {
.priv_size = sizeof(*idrx_priv),
.timeout_ms = WLAN_WAIT_TIME_MWS_COEX_INFO,
};
void *cookie;
adapter = hdd_get_first_valid_adapter(hdd_ctx);
if (!adapter) {
hdd_err("Failed to get adapter");
return QDF_STATUS_E_INVAL;
}
if (!test_bit(DEVICE_IFACE_OPENED, &adapter->event_flags)) {
hdd_err("Interface is not enabled");
return QDF_STATUS_E_INVAL;
}
if (file->index > 0)
return QDF_STATUS_SUCCESS;
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = osif_request_cookie(request);
status = sme_get_mws_coex_info(hdd_ctx->mac_handle,
adapter->vdev_id,
WMI_MWS_COEX_IDRX_STATE,
hdd_debugfs_mws_coex_info_cb, cookie);
if (QDF_IS_STATUS_ERROR(status)) {
rc = qdf_status_to_os_return(status);
goto exit;
}
rc = osif_request_wait_for_response(request);
if (rc) {
qdf_debugfs_printf(file, "Timedout while retrieving MWS coex idrx state");
rc = -ETIMEDOUT;
goto exit;
}
idrx_priv = osif_request_priv(request);
idrx_state = &idrx_priv->idrx_state;
qdf_debugfs_printf(file, "vdev_id = %u\n"
"sub0_techid = %u\n"
"sub0_policy = %u\n"
"sub0_is_link_critical = %u\n"
"sub0_static_power = %u\n"
"sub0_rssi = %d\n"
"sub0_techid = %d\n"
"sub0_policy = %d\n"
"sub0_is_link_critical = %d\n"
"sub0_static_power = %u\n"
"sub0_rssi = %d\n",
idrx_state->vdev_id,
idrx_state->sub0_techid,
idrx_state->sub0_policy,
idrx_state->sub0_is_link_critical,
idrx_state->sub0_static_power,
idrx_state->sub0_rssi,
idrx_state->sub1_techid,
idrx_state->sub1_policy,
idrx_state->sub1_is_link_critical,
idrx_state->sub1_static_power,
idrx_state->sub1_rssi);
exit:
osif_request_put(request);
return qdf_status_from_os_return(rc);
}
static QDF_STATUS hdd_debugfs_mws_coex_idrx_read(qdf_debugfs_file_t file,
void *arg)
{
struct osif_psoc_sync *psoc_sync;
struct hdd_context *hdd_ctx = arg;
int ret;
QDF_STATUS status;
ret = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
if (ret)
return qdf_status_from_os_return(ret);
status = __hdd_debugfs_mws_coex_idrx_read(hdd_ctx, file);
osif_psoc_sync_op_stop(psoc_sync);
return qdf_status_from_os_return(ret);
}
static QDF_STATUS __hdd_debugfs_mws_antenna_sharing_read(struct hdd_context
*hdd_ctx,
qdf_debugfs_file_t
file)
{
struct hdd_adapter *adapter;
QDF_STATUS status;
int rc;
struct mws_antenna_sharing_info *antenna_sharing;
struct mws_antenna_sharing_info_priv *antenna_priv;
struct osif_request *request;
static const struct osif_request_params params = {
.priv_size = sizeof(*antenna_priv),
.timeout_ms = WLAN_WAIT_TIME_MWS_COEX_INFO,
};
void *cookie;
adapter = hdd_get_first_valid_adapter(hdd_ctx);
if (!adapter) {
hdd_err("Failed to get adapter");
return QDF_STATUS_E_INVAL;
}
if (!test_bit(DEVICE_IFACE_OPENED, &adapter->event_flags)) {
hdd_err("Interface is not enabled");
return QDF_STATUS_E_INVAL;
}
if (file->index > 0)
return QDF_STATUS_SUCCESS;
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = osif_request_cookie(request);
status = sme_get_mws_coex_info(hdd_ctx->mac_handle,
adapter->vdev_id,
WMI_MWS_COEX_ANTENNA_SHARING_STATE,
hdd_debugfs_mws_coex_info_cb, cookie);
if (QDF_IS_STATUS_ERROR(status)) {
rc = qdf_status_to_os_return(status);
goto exit;
}
rc = osif_request_wait_for_response(request);
if (rc) {
qdf_debugfs_printf(file, "Timedout while retrieving MWS coex antenna sharing state");
rc = -ETIMEDOUT;
goto exit;
}
antenna_priv = osif_request_priv(request);
antenna_sharing = &antenna_priv->antenna_sharing;
qdf_debugfs_printf(file, "vdev_id = %u\n"
"coex_flags = %u\n"
"coex_config = %u\n"
"tx_chain_mask = %u\n"
"rx_chain_mask = %u\n"
"rx_nss = %u\n"
"force_mrc = %u\n"
"rssi_type = %u\n"
"chain0_rssi = %d\n"
"chain1_rssi = %d\n"
"combined_rssi = %d\n"
"imbalance = %u\n"
"mrc_threshold = %d\n"
"grant_duration = %u\n",
antenna_sharing->vdev_id,
antenna_sharing->coex_flags,
antenna_sharing->coex_config,
antenna_sharing->tx_chain_mask,
antenna_sharing->rx_chain_mask,
antenna_sharing->rx_nss,
antenna_sharing->force_mrc,
antenna_sharing->rssi_type,
antenna_sharing->chain0_rssi,
antenna_sharing->chain1_rssi,
antenna_sharing->combined_rssi,
antenna_sharing->imbalance,
antenna_sharing->mrc_threshold,
antenna_sharing->grant_duration);
exit:
osif_request_put(request);
return qdf_status_from_os_return(rc);
}
static QDF_STATUS hdd_debugfs_mws_antenna_sharing_read(qdf_debugfs_file_t file,
void *arg)
{
struct osif_psoc_sync *psoc_sync;
struct hdd_context *hdd_ctx = arg;
int ret;
QDF_STATUS status;
ret = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
if (ret)
return qdf_status_from_os_return(ret);
status = __hdd_debugfs_mws_antenna_sharing_read(hdd_ctx, file);
osif_psoc_sync_op_stop(psoc_sync);
return qdf_status_from_os_return(ret);
}
static struct qdf_debugfs_fops hdd_mws_debugfs_coex_state_fops = {
.show = hdd_debugfs_mws_coex_state_read,
};
static struct qdf_debugfs_fops hdd_mws_debugfs_fops_coex_dpwb_fops = {
.show = hdd_debugfs_mws_coex_dpwb_read,
};
static struct qdf_debugfs_fops hdd_mws_debugfs_tdm_state_fpos = {
.show = hdd_debugfs_mws_tdm_state_read,
};
static struct qdf_debugfs_fops hdd_mws_debugfs_idrx_state_fpos = {
.show = hdd_debugfs_mws_coex_idrx_read,
};
static struct qdf_debugfs_fops hdd_mws_debugfs_antenna_sharing_fpos = {
.show = hdd_debugfs_mws_antenna_sharing_read,
};
void hdd_debugfs_mws_coex_info_init(struct hdd_context *hdd_ctx)
{
hdd_mws_debugfs_coex_state_fops.priv = hdd_ctx;
hdd_mws_debugfs_fops_coex_dpwb_fops.priv = hdd_ctx;
hdd_mws_debugfs_tdm_state_fpos.priv = hdd_ctx;
hdd_mws_debugfs_idrx_state_fpos.priv = hdd_ctx;
hdd_mws_debugfs_antenna_sharing_fpos.priv = hdd_ctx;
if (!qdf_debugfs_create_file("mws_coex_state", MWS_DEBUGFS_PERMS,
NULL, &hdd_mws_debugfs_coex_state_fops))
hdd_err("Failed to create the mws coex state file");
if (!qdf_debugfs_create_file("mws_coex_dpwb_state", MWS_DEBUGFS_PERMS,
NULL,
&hdd_mws_debugfs_fops_coex_dpwb_fops))
hdd_err("Failed to create the mws coex dpwb file");
if (!qdf_debugfs_create_file("mws_coex_tdm_state", MWS_DEBUGFS_PERMS,
NULL, &hdd_mws_debugfs_tdm_state_fpos))
hdd_err("Failed to create the mws coex tdm file");
if (!qdf_debugfs_create_file("mws_coex_idrx", MWS_DEBUGFS_PERMS,
NULL, &hdd_mws_debugfs_idrx_state_fpos))
hdd_err("Failed to create the mws coex idrx file");
if (!qdf_debugfs_create_file("mws_coex_antenna_sharing",
MWS_DEBUGFS_PERMS,
NULL,
&hdd_mws_debugfs_antenna_sharing_fpos))
hdd_err("Failed to create the mws coex antenna sharing file");
}
void hdd_debugfs_mws_coex_info_deinit(struct hdd_context *hdd_ctx)
{
/**
* Coex info dosent have a directory it is removed as part of qdf remove
*/
}

3
core/hdd/src/wlan_hdd_main.c
View file

@ -161,6 +161,7 @@
#include "wlan_green_ap_ucfg_api.h"
#include <wlan_p2p_ucfg_api.h>
#include <target_type.h>
#include <wlan_hdd_debugfs_coex.h>
#ifdef MODULE
#define WLAN_MODULE_NAME module_name(THIS_MODULE)
@ -7286,6 +7287,7 @@ void hdd_wlan_exit(struct hdd_context *hdd_ctx)
hdd_enter();
hdd_debugfs_mws_coex_info_deinit(hdd_ctx);
hdd_psoc_idle_timer_stop(hdd_ctx);
hdd_unregister_notifiers(hdd_ctx);
@ -11889,6 +11891,7 @@ int hdd_wlan_startup(struct hdd_context *hdd_ctx)
ucfg_mlme_is_imps_enabled(hdd_ctx->psoc, &is_imps_enabled);
hdd_set_idle_ps_config(hdd_ctx, is_imps_enabled);
hdd_debugfs_mws_coex_info_init(hdd_ctx);
hdd_exit();

12
core/mac/inc/sir_api.h
View file

@ -5886,4 +5886,16 @@ struct sir_md_evt {
uint32_t status;
};
#endif /* WLAN_FEATURE_MOTION_DETECTION */
#ifdef WLAN_MWS_INFO_DEBUGFS
/**
* struct sir_get_mws_coex_info - Get MWS coex info
* @vdev_id: vdev id
* @cmd_id: wmi mws-coex command IDs
*/
struct sir_get_mws_coex_info {
uint32_t vdev_id;
uint32_t cmd_id;
};
#endif /* WLAN_MWS_INFO_DEBUGFS */
#endif /* __SIR_API_H */

4
core/mac/src/include/sir_params.h
View file

@ -405,7 +405,9 @@ struct sir_cfg_action_frm_tb_ppdu {
#define SIR_HAL_PDEV_SET_PCL_TO_FW (SIR_HAL_ITC_MSG_TYPES_BEGIN + 161)
/* 162 unused */
#ifdef WLAN_MWS_INFO_DEBUGFS
#define SIR_HAL_GET_MWS_COEX_INFO_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 162)
#endif /* WLAN_MWS_INFO_DEBUGFS */
#define SIR_HAL_CLI_SET_CMD (SIR_HAL_ITC_MSG_TYPES_BEGIN + 163)
#ifndef REMOVE_PKT_LOG

22
core/sme/inc/sme_api.h
View file

@ -43,6 +43,7 @@
#include "scheduler_api.h"
#include "wlan_serialization_legacy_api.h"
#include <qca_vendor.h>
#include "wmi_unified.h"
/*--------------------------------------------------------------------------
Preprocessor definitions and constants
@ -3426,4 +3427,25 @@ QDF_STATUS sme_update_hidden_ssid_status_cb(mac_handle_t mac_handle,
*/
QDF_STATUS sme_update_owe_info(struct mac_context *mac,
struct assoc_ind *assoc_ind);
#ifdef WLAN_MWS_INFO_DEBUGFS
/**
* sme_get_mws_coex_info() - SME API to get the coex information
* @mac_handle: mac handler
* @vdev_id: Vdev_id
* @cmd_id: enum mws_coex_cmdid which information is needed.
* @callback_fn: Callback function
* @context: callback context
*
* Return: QDF_STATUS
*/
QDF_STATUS
sme_get_mws_coex_info(mac_handle_t mac_handle, uint32_t vdev_id,
uint32_t cmd_id, void (*callback_fn)(void *coex_info_data,
void *context,
wmi_mws_coex_cmd_id
cmd_id),
void *context);
#endif /* WLAN_MWS_INFO_DEBUGFS */
#endif /* #if !defined( __SME_API_H ) */

7
core/sme/inc/sme_internal.h
View file

@ -36,6 +36,7 @@
#include "host_diag_core_event.h"
#include "csr_link_list.h"
#include "sme_power_save.h"
#include "wmi_unified.h"
struct wmi_twt_enable_complete_event_param;
/*--------------------------------------------------------------------------
@ -356,6 +357,12 @@ struct sme_context {
#endif /* WLAN_FEATURE_MOTION_DETECTION */
/* hidden ssid rsp callback */
hidden_ssid_cb hidden_ssid_cb;
#ifdef WLAN_MWS_INFO_DEBUGFS
void *mws_coex_info_ctx;
void (*mws_coex_info_state_resp_callback)(void *coex_info_data,
void *context,
wmi_mws_coex_cmd_id cmd_id);
#endif /* WLAN_MWS_INFO_DEBUGFS */
};

47
core/sme/src/common/sme_api.c
View file

@ -15351,3 +15351,50 @@ QDF_STATUS sme_update_owe_info(struct mac_context *mac,
return status;
}
#ifdef WLAN_MWS_INFO_DEBUGFS
QDF_STATUS
sme_get_mws_coex_info(mac_handle_t mac_handle, uint32_t vdev_id,
uint32_t cmd_id, void (*callback_fn)(void *coex_info_data,
void *context,
wmi_mws_coex_cmd_id
cmd_id),
void *context)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg msg = {0};
struct sir_get_mws_coex_info *req;
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
sme_err("Failed allocate memory for MWS coex info req");
return QDF_STATUS_E_NOMEM;
}
req->vdev_id = vdev_id;
req->cmd_id = cmd_id;
mac->sme.mws_coex_info_state_resp_callback = callback_fn;
mac->sme.mws_coex_info_ctx = context;
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_SUCCESS(status)) {
msg.bodyptr = req;
msg.type = WMA_GET_MWS_COEX_INFO_REQ;
status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&msg);
sme_release_global_lock(&mac->sme);
if (!QDF_IS_STATUS_SUCCESS(status)) {
sme_err("post MWS coex info req failed");
status = QDF_STATUS_E_FAILURE;
qdf_mem_free(req);
}
} else {
sme_err("sme_acquire_global_lock failed");
qdf_mem_free(req);
}
return status;
}
#endif /* WLAN_MWS_INFO_DEBUGFS */

34
core/wma/inc/wma_coex.h Normal file
View file

@ -0,0 +1,34 @@
/*
* Copyright (c) 2019 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WLAN_HDD_DEBUGFS_COEX_H
#define _WLAN_HDD_DEBUGFS_COEX_H
#include <wma.h>
#include "sme_api.h"
#ifdef WLAN_MWS_INFO_DEBUGFS
void wma_get_mws_coex_info_req(tp_wma_handle wma_handle,
struct sir_get_mws_coex_info *req);
void wma_register_mws_coex_events(tp_wma_handle wma_handle);
#else
static void wma_register_mws_coex_events(tp_wma_handle wma_handle)
{
}
#endif
#endif

4
core/wma/inc/wma_types.h
View file

@ -456,6 +456,10 @@
#define WMA_SET_THERMAL_MGMT SIR_HAL_SET_THERMAL_MGMT
#endif /* FW_THERMAL_THROTTLE_SUPPORT */
#ifdef WLAN_MWS_INFO_DEBUGFS
#define WMA_GET_MWS_COEX_INFO_REQ SIR_HAL_GET_MWS_COEX_INFO_REQ
#endif
/* Bit 6 will be used to control BD rate for Management frames */
#define HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME 0x40

377
core/wma/src/wma_coex.c Normal file
View file

@ -0,0 +1,377 @@
/*
* Copyright (c) 2019 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <wma_coex.h>
#include <wma.h>
#include "wmi_unified.h"
/**
* wma_mws_coex_state_host_event_handler - Coex state Event Handler
* @handle: pointer to scn handle
* @event: Coex state event
* @len: Length of cmd
*
* Return: 0 on success, else error on failure
*/
static int wma_mws_coex_state_host_event_handler(void *handle, uint8_t *event,
uint32_t len)
{
WMI_VDEV_GET_MWS_COEX_STATE_EVENTID_param_tlvs *param_tlvs;
wmi_vdev_get_mws_coex_state_fixed_param *param_buf;
struct mws_coex_state coex_state;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
wma_debug("Enter");
param_tlvs =
(WMI_VDEV_GET_MWS_COEX_STATE_EVENTID_param_tlvs *)event;
if (!param_tlvs) {
wma_err("Invalid stats event");
return -EINVAL;
}
param_buf = param_tlvs->fixed_param;
if (!param_buf || !mac || !mac->sme.mws_coex_info_state_resp_callback) {
wma_debug("NULL mac ptr or HDD callback is null");
return -EINVAL;
}
if (!param_buf) {
wma_debug("NULL mws coes state event fixed param");
return -EINVAL;
}
coex_state.vdev_id = param_buf->vdev_id;
coex_state.coex_scheme_bitmap = param_buf->coex_scheme_bitmap;
coex_state.active_conflict_count = param_buf->active_conflict_count;
coex_state.potential_conflict_count =
param_buf->potential_conflict_count;
coex_state.chavd_group0_bitmap = param_buf->chavd_group0_bitmap;
coex_state.chavd_group1_bitmap = param_buf->chavd_group1_bitmap;
coex_state.chavd_group2_bitmap = param_buf->chavd_group2_bitmap;
coex_state.chavd_group3_bitmap = param_buf->chavd_group3_bitmap;
mac->sme.mws_coex_info_state_resp_callback(&coex_state,
mac->sme.mws_coex_info_ctx,
WMI_MWS_COEX_STATE);
wma_debug("vdev_id = %u coex_scheme_bitmap = %u active_conflict_count = %u potential_conflict_count = %u chavd_group0_bitmap = %u chavd_group1_bitmap = %u chavd_group2_bitmap = %u chavd_group3_bitmap = %u",
param_buf->vdev_id, param_buf->coex_scheme_bitmap,
param_buf->active_conflict_count,
param_buf->potential_conflict_count,
param_buf->chavd_group0_bitmap,
param_buf->chavd_group1_bitmap,
param_buf->chavd_group2_bitmap,
param_buf->chavd_group3_bitmap);
wma_debug("Exit");
return 0;
}
/**
* wma_mws_coex_state_dpwb_event_handler - DPWB state Event Handler
* @handle: handle to scn
* @event: DPWB state event
* @len: Length of cmd
*
* Return: 0 on success, else error on failure
*/
static int wma_mws_coex_state_dpwb_event_handler(void *handle, uint8_t *event,
uint32_t len)
{
WMI_VDEV_GET_MWS_COEX_DPWB_STATE_EVENTID_param_tlvs *param_tlvs;
wmi_vdev_get_mws_coex_dpwb_state_fixed_param *param_buf;
struct mws_coex_dpwb_state coex_dpwb;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
wma_debug("Enter");
param_tlvs =
(WMI_VDEV_GET_MWS_COEX_DPWB_STATE_EVENTID_param_tlvs *)event;
if (!param_tlvs) {
wma_err("Invalid coex mws event");
return -EINVAL;
}
param_buf = param_tlvs->fixed_param;
if (!param_buf || !mac || !mac->sme.mws_coex_info_state_resp_callback) {
wma_debug("NULL mac ptr or HDD callback is null");
return -EINVAL;
}
if (!param_buf) {
wma_err("NULL mws dpwb info event fixed param");
return -EINVAL;
}
coex_dpwb.vdev_id = param_buf->vdev_id;
coex_dpwb.current_dpwb_state = param_buf->current_dpwb_state;
coex_dpwb.pnp1_value = param_buf->pnp1_value;
coex_dpwb.lte_dutycycle = param_buf->lte_dutycycle;
coex_dpwb.sinr_wlan_on = param_buf->sinr_wlan_on;
coex_dpwb.sinr_wlan_off = param_buf->sinr_wlan_off;
coex_dpwb.bler_count = param_buf->bler_count;
coex_dpwb.block_count = param_buf->block_count;
coex_dpwb.wlan_rssi_level = param_buf->wlan_rssi_level;
coex_dpwb.wlan_rssi = param_buf->wlan_rssi;
coex_dpwb.is_tdm_running = param_buf->is_tdm_running;
mac->sme.mws_coex_info_state_resp_callback(&coex_dpwb,
mac->sme.mws_coex_info_ctx,
WMI_MWS_COEX_DPWB_STATE);
wma_debug("vdev_id = %u current_dpwb_state = %d pnp1_value = %d lte_dutycycle = %d sinr_wlan_on = %d sinr_wlan_off = %d bler_count = %u block_count = %u wlan_rssi_level = %u wlan_rssi = %d is_tdm_running = %u",
param_buf->vdev_id, param_buf->current_dpwb_state,
param_buf->pnp1_value,
param_buf->lte_dutycycle, param_buf->sinr_wlan_on,
param_buf->sinr_wlan_off, param_buf->bler_count,
param_buf->block_count, param_buf->wlan_rssi_level,
param_buf->wlan_rssi, param_buf->is_tdm_running);
wma_debug("Exit");
return 0;
}
/**
* wma_mws_coex_tdm_event_handler - TDM state Event Handler
* @handle: handle to scn
* @event: TDM state event
* @len: Length of cmd
*
* Return: 0 on success, else error on failure
*/
static int wma_mws_coex_tdm_event_handler(void *handle, uint8_t *event,
uint32_t len)
{
WMI_VDEV_GET_MWS_COEX_TDM_STATE_EVENTID_param_tlvs *param_tlvs;
wmi_vdev_get_mws_coex_tdm_state_fixed_param *param_buf;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
struct mws_coex_tdm_state coex_tdm;
wma_debug("Enter");
param_tlvs =
(WMI_VDEV_GET_MWS_COEX_TDM_STATE_EVENTID_param_tlvs *)event;
if (!param_tlvs) {
wma_err("Invalid MWS coex event");
return -EINVAL;
}
param_buf = param_tlvs->fixed_param;
if (!param_buf || !mac || !mac->sme.mws_coex_info_state_resp_callback) {
wma_debug("NULL mac ptr or HDD callback is null");
return -EINVAL;
}
if (!param_buf) {
wma_debug("NULL mws tdm info event fixed param");
return -EINVAL;
}
coex_tdm.vdev_id = param_buf->vdev_id;
coex_tdm.tdm_policy_bitmap = param_buf->tdm_policy_bitmap;
coex_tdm.tdm_sf_bitmap = param_buf->tdm_sf_bitmap;
mac->sme.mws_coex_info_state_resp_callback(&coex_tdm,
mac->sme.mws_coex_info_ctx,
WMI_MWS_COEX_TDM_STATE);
wma_debug("vdev_id = %u tdm_policy_bitmap = %u tdm_sf_bitmap = %u",
param_buf->vdev_id, param_buf->tdm_policy_bitmap,
param_buf->tdm_sf_bitmap);
wma_debug("Exit");
return 0;
}
/**
* wma_mws_coex_idrx_event_handler - IDRX state Event Handler
* @handle: handle to scn
* @event: IDRX state event
* @len: Length of cmd
*
* Return: 0 on success, else error on failure
*/
static int wma_mws_coex_idrx_event_handler(void *handle, uint8_t *event,
uint32_t len)
{
WMI_VDEV_GET_MWS_COEX_IDRX_STATE_EVENTID_param_tlvs *param_tlvs;
wmi_vdev_get_mws_coex_idrx_state_fixed_param *param_buf;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
struct mws_coex_idrx_state coex_idrx;
wma_debug("Enter");
param_tlvs =
(WMI_VDEV_GET_MWS_COEX_IDRX_STATE_EVENTID_param_tlvs *)event;
if (!param_tlvs) {
wma_err("Invalid stats event");
return -EINVAL;
}
param_buf = param_tlvs->fixed_param;
if (!param_buf || !mac || !mac->sme.mws_coex_info_state_resp_callback) {
wma_debug("NULL mac ptr or HDD callback is null");
return -EINVAL;
}
if (!param_buf) {
wma_debug("NULL MWS Coex event fixed param");
return -EINVAL;
}
coex_idrx.vdev_id = param_buf->vdev_id;
coex_idrx.sub0_techid = param_buf->sub0_techid;
coex_idrx.sub0_policy = param_buf->sub0_policy;
coex_idrx.sub0_is_link_critical = param_buf->sub0_is_link_critical;
coex_idrx.sub0_static_power = param_buf->sub0_static_power;
coex_idrx.sub0_rssi = param_buf->sub0_rssi;
coex_idrx.sub1_techid = param_buf->sub1_techid;
coex_idrx.sub1_policy = param_buf->sub1_policy;
coex_idrx.sub1_is_link_critical = param_buf->sub1_is_link_critical;
coex_idrx.sub1_static_power = param_buf->sub1_static_power;
coex_idrx.sub1_rssi = param_buf->sub1_rssi;
mac->sme.mws_coex_info_state_resp_callback(&coex_idrx,
mac->sme.mws_coex_info_ctx,
WMI_MWS_COEX_IDRX_STATE);
wma_debug("vdev_id = %u sub0_techid = %u sub0_policy = %u sub0_is_link_critical = %u sub0_static_power = %u sub0_rssi = %d sub1_techid = %d sub1_policy = %d sub1_is_link_critical = %d sub1_static_power = %u sub1_rssi= %d",
param_buf->vdev_id, param_buf->sub0_techid,
param_buf->sub0_policy, param_buf->sub0_is_link_critical,
param_buf->sub0_static_power, param_buf->sub0_rssi,
param_buf->sub1_techid, param_buf->sub1_policy,
param_buf->sub1_is_link_critical,
param_buf->sub1_static_power, param_buf->sub1_rssi);
wma_debug("EXIT");
return 0;
}
/**
* wma_mws_coex_antenna_sharing_event_handler - Antenna sharing Event Handler
* @handle: handle to scn
* @event: Antenna sharing state event
* @len: Length of cmd
*
* Return: 0 on success, else error on failure
*/
static int wma_mws_coex_antenna_sharing_event_handler(void *handle,
uint8_t *event,
uint32_t len)
{
WMI_VDEV_GET_MWS_COEX_ANTENNA_SHARING_STATE_EVENTID_param_tlvs
*param_tlvs =
(WMI_VDEV_GET_MWS_COEX_ANTENNA_SHARING_STATE_EVENTID_param_tlvs *)event;
wmi_vdev_get_mws_coex_antenna_sharing_state_fixed_param *param_buf;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
struct mws_antenna_sharing_info *antenna_sharing;
wma_debug("Enter");
if (!param_tlvs) {
wma_err("Invalid stats event");
return -EINVAL;
}
param_buf = param_tlvs->fixed_param;
if (!param_buf || !mac || !mac->sme.mws_coex_info_state_resp_callback) {
wma_debug("NULL mac ptr or HDD callback is null");
return -EINVAL;
}
if (!param_buf) {
wma_debug("NULL MWS event fixed param");
return -EINVAL;
}
antenna_sharing = qdf_mem_malloc(sizeof(*antenna_sharing));
if (!antenna_sharing)
return -ENOMEM;
antenna_sharing->vdev_id = param_buf->vdev_id;
antenna_sharing->coex_flags = param_buf->coex_flags;
antenna_sharing->coex_config = param_buf->coex_config;
antenna_sharing->tx_chain_mask = param_buf->tx_chain_mask;
antenna_sharing->rx_chain_mask = param_buf->rx_chain_mask;
antenna_sharing->rx_nss = param_buf->rx_nss;
antenna_sharing->force_mrc = param_buf->force_mrc;
antenna_sharing->rssi_type = param_buf->rssi_type;
antenna_sharing->chain0_rssi = param_buf->chain0_rssi;
antenna_sharing->chain1_rssi = param_buf->chain1_rssi;
antenna_sharing->combined_rssi = param_buf->combined_rssi;
antenna_sharing->imbalance = param_buf->imbalance;
antenna_sharing->mrc_threshold = param_buf->mrc_threshold;
antenna_sharing->grant_duration = param_buf->grant_duration;
mac->sme.mws_coex_info_state_resp_callback(antenna_sharing,
mac->sme.mws_coex_info_ctx,
WMI_MWS_COEX_ANTENNA_SHARING_STATE);
wma_debug("vdev_id = %u coex_flags = %u coex_config = %u tx_chain_mask = %u rx_chain_mask = %u rx_nss = %u force_mrc = %u rssi_type = %u chain0_rssi = %d chain1_rssi = %d chain0_rssi = %d imbalance = %u mrc_threshold = %d grant_duration = %u",
param_buf->vdev_id, param_buf->coex_flags,
param_buf->coex_config, param_buf->tx_chain_mask,
param_buf->rx_chain_mask,
param_buf->rx_nss, param_buf->force_mrc,
param_buf->rssi_type, param_buf->chain0_rssi,
param_buf->chain1_rssi, param_buf->combined_rssi,
param_buf->imbalance, param_buf->mrc_threshold,
param_buf->grant_duration);
qdf_mem_free(antenna_sharing);
wma_debug("EXIT");
return 0;
}
void wma_get_mws_coex_info_req(tp_wma_handle wma_handle,
struct sir_get_mws_coex_info *req)
{
QDF_STATUS status;
status = wmi_unified_send_mws_coex_req_cmd(wma_handle->wmi_handle,
req->vdev_id, req->cmd_id);
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to send mws coex info");
}
void wma_register_mws_coex_events(tp_wma_handle wma_handle)
{
if (!wma_handle) {
wma_err("wma_handle is NULL");
return;
}
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_vdev_get_mws_coex_state_eventid,
wma_mws_coex_state_host_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(
wma_handle->wmi_handle,
wmi_vdev_get_mws_coex_dpwb_state_eventid,
wma_mws_coex_state_dpwb_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(
wma_handle->wmi_handle,
wmi_vdev_get_mws_coex_tdm_state_eventid,
wma_mws_coex_tdm_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(
wma_handle->wmi_handle,
wmi_vdev_get_mws_coex_idrx_state_eventid,
wma_mws_coex_idrx_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(
wma_handle->wmi_handle,
wmi_vdev_get_mws_coex_antenna_sharing_state_eventid,
wma_mws_coex_antenna_sharing_event_handler,
WMA_RX_SERIALIZER_CTX);
}

9
core/wma/src/wma_main.c
View file

@ -96,6 +96,7 @@
#include "cfg_ucfg_api.h"
#include "init_cmd_api.h"
#include "nan_ucfg_api.h"
#include "wma_coex.h"
#define WMA_LOG_COMPLETION_TIMER 3000 /* 3 seconds */
#define WMI_TLV_HEADROOM 128
@ -3719,7 +3720,7 @@ QDF_STATUS wma_open(struct wlan_objmgr_psoc *psoc,
wma_register_apf_events(wma_handle);
wma_register_md_events(wma_handle);
wma_register_wlm_stats_events(wma_handle);
wma_register_mws_coex_events(wma_handle);
return QDF_STATUS_SUCCESS;
err_dbglog_init:
@ -9031,6 +9032,12 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
qdf_mem_free(msg->bodyptr);
break;
#endif /* FW_THERMAL_THROTTLE_SUPPORT */
#ifdef WLAN_MWS_INFO_DEBUGFS
case WMA_GET_MWS_COEX_INFO_REQ:
wma_get_mws_coex_info_req(wma_handle, msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
#endif
default:
WMA_LOGD("Unhandled WMA message of type %d", msg->type);
if (msg->bodyptr)