samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
efb25bf9db08fe81fb0c49dd9d26e443b2361c5e
android_kernel_samsung_sm86…/wmi_unified_ap_tlv.c
Sathish Kumar efb25bf9db qcacmn: Featurize WMI APIs and TLVs that are specific to WIN 
In the existing converged component, WMI TLV APIs are implemented in
a generic manner without proper featurization. All the APIs exposed
outside of WMI are implemented in wmi_unified_api.c and all the APIs
forming the CMD or extracting the EVT is implemented in wmi_unified_tlv.c.

Since WIN and MCL have a unified WMI layer in the converged component and
there are features within WIN and MCL that are not common, there exists a
good number of WMI APIs which are specific to WIN but compiled by MCL and
vice-versa. Due to this inadvertent problem, there is a chunk of code and
memory used up by WIN and MCL for features that are not used in their
products.

Featurize WMI APIs and TLVs that are specific to WIN
- Air Time Fareness (ATF)
- Direct Buffer Rx (DBR)
- Smart Antenna (SMART_ANT)
- Generic WIN specific WMI (AP)

Change-Id: I7b27c8993da04c9e9651a9682de370daaa40d187
CRs-Fixed: 2320273
2018-10-05 02:14:04 -07:00

2545 lines
77 KiB
C
Raw Blame History

/*
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* 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 <osdep.h>
#include "wmi.h"
#include "wmi_unified_priv.h"
#include "wmi_unified_ap_api.h"
#include <wlan_utility.h>
/**
* send_peer_add_wds_entry_cmd_tlv() - send peer add command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: 0 for success or error code
*/
static QDF_STATUS send_peer_add_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_add_wds_entry_params *param)
{
wmi_peer_add_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_peer_add_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_add_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_add_wds_entry_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
cmd->flags = (param->flags & WMI_HOST_WDS_FLAG_STATIC) ?
WMI_WDS_FLAG_STATIC : 0;
cmd->vdev_id = param->vdev_id;
wmi_mtrace(WMI_PEER_ADD_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
return wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_ADD_WDS_ENTRY_CMDID);
}
/**
* send_peer_del_wds_entry_cmd_tlv() - send peer delete command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: 0 for success or error code
*/
static QDF_STATUS send_peer_del_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_del_wds_entry_params *param)
{
wmi_peer_remove_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_peer_remove_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_remove_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_remove_wds_entry_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
cmd->vdev_id = param->vdev_id;
wmi_mtrace(WMI_PEER_REMOVE_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
return wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_REMOVE_WDS_ENTRY_CMDID);
}
/**
* send_peer_update_wds_entry_cmd_tlv() - send peer update command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: 0 for success or error code
*/
static QDF_STATUS send_peer_update_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_update_wds_entry_params *param)
{
wmi_peer_update_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
/* wmi_buf_alloc returns zeroed command buffer */
cmd = (wmi_peer_update_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_update_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_update_wds_entry_cmd_fixed_param));
cmd->flags = (param->flags & WMI_HOST_WDS_FLAG_STATIC) ? WMI_WDS_FLAG_STATIC : 0;
cmd->vdev_id = param->vdev_id;
if (param->wds_macaddr)
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->wds_macaddr,
&cmd->wds_macaddr);
if (param->peer_macaddr)
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_macaddr,
&cmd->peer_macaddr);
wmi_mtrace(WMI_PEER_UPDATE_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
return wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_UPDATE_WDS_ENTRY_CMDID);
}
/**
* send_pdev_get_tpc_config_cmd_tlv() - send get tpc config command to fw
* @wmi_handle: wmi handle
* @param: pointer to get tpc config params
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_pdev_get_tpc_config_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t param)
{
wmi_pdev_get_tpc_config_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(wmi_pdev_get_tpc_config_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_pdev_get_tpc_config_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_get_tpc_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_get_tpc_config_cmd_fixed_param));
cmd->param = param;
wmi_mtrace(WMI_PDEV_GET_TPC_CONFIG_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_GET_TPC_CONFIG_CMDID)) {
WMI_LOGE("Send pdev get tpc config cmd failed");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s:send success", __func__);
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle,
struct beacon_params *param)
{
QDF_STATUS ret;
wmi_bcn_send_from_host_cmd_fixed_param *cmd;
wmi_buf_t wmi_buf;
qdf_dma_addr_t dma_addr;
uint32_t dtim_flag = 0;
wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!wmi_buf) {
WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
if (param->is_dtim_count_zero) {
dtim_flag |= WMI_BCN_SEND_DTIM_ZERO;
if (param->is_bitctl_reqd) {
/* deliver CAB traffic in next DTIM beacon */
dtim_flag |= WMI_BCN_SEND_DTIM_BITCTL_SET;
}
}
cmd = (wmi_bcn_send_from_host_cmd_fixed_param *)wmi_buf_data(wmi_buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_bcn_send_from_host_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->data_len = qdf_nbuf_len(param->wbuf);
cmd->frame_ctrl = param->frame_ctrl;
cmd->dtim_flag = dtim_flag;
dma_addr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
cmd->frag_ptr_lo = qdf_get_lower_32_bits(dma_addr);
#if defined(HTT_PADDR64)
cmd->frag_ptr_hi = qdf_get_upper_32_bits(dma_addr) & 0x1F;
#endif
cmd->bcn_antenna = param->bcn_txant;
wmi_mtrace(WMI_PDEV_SEND_BCN_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle,
wmi_buf, sizeof(*cmd), WMI_PDEV_SEND_BCN_CMDID);
if (ret != QDF_STATUS_SUCCESS) {
WMI_LOGE("%s: Failed to send bcn: %d", __func__, ret);
wmi_buf_free(wmi_buf);
}
return ret;
}
/**
* send_set_ctl_table_cmd_tlv() - send ctl table cmd to fw
* @wmi_handle: wmi handle
* @param: pointer to hold ctl table param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS
send_set_ctl_table_cmd_tlv(wmi_unified_t wmi_handle,
struct ctl_table_params *param)
{
uint16_t len, ctl_tlv_len;
uint8_t *buf_ptr;
wmi_buf_t buf;
wmi_pdev_set_ctl_table_cmd_fixed_param *cmd;
uint32_t *ctl_array;
if (!param->ctl_array)
return QDF_STATUS_E_FAILURE;
ctl_tlv_len = WMI_TLV_HDR_SIZE +
roundup(param->ctl_cmd_len, sizeof(uint32_t));
len = sizeof(*cmd) + ctl_tlv_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = wmi_buf_data(buf);
qdf_mem_zero(buf_ptr, len);
cmd = (wmi_pdev_set_ctl_table_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_ctl_table_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_set_ctl_table_cmd_fixed_param));
cmd->ctl_len = param->ctl_cmd_len;
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
param->pdev_id);
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
(cmd->ctl_len));
buf_ptr += WMI_TLV_HDR_SIZE;
ctl_array = (uint32_t *)buf_ptr;
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&ctl_array[0], &param->ctl_band,
sizeof(param->ctl_band));
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&ctl_array[1], param->ctl_array,
param->ctl_cmd_len -
sizeof(param->ctl_band));
wmi_mtrace(WMI_PDEV_SET_CTL_TABLE_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_CTL_TABLE_CMDID)) {
WMI_LOGE("%s:Failed to send command", __func__);
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_set_mimogain_table_cmd_tlv() - send mimogain table cmd to fw
* @wmi_handle: wmi handle
* @param: pointer to hold mimogain table param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS
send_set_mimogain_table_cmd_tlv(wmi_unified_t wmi_handle,
struct mimogain_table_params *param)
{
uint16_t len, table_tlv_len;
wmi_buf_t buf;
uint8_t *buf_ptr;
wmi_pdev_set_mimogain_table_cmd_fixed_param *cmd;
uint32_t *gain_table;
if (!param->array_gain)
return QDF_STATUS_E_FAILURE;
/* len must be multiple of a single array gain table */
if (param->tbl_len %
((WMI_HOST_TX_NUM_CHAIN-1) * WMI_HOST_TPC_REGINDEX_MAX *
WMI_HOST_ARRAY_GAIN_NUM_STREAMS) != 0) {
WMI_LOGE("Array gain table len not correct");
return QDF_STATUS_E_FAILURE;
}
table_tlv_len = WMI_TLV_HDR_SIZE +
roundup(param->tbl_len, sizeof(uint32_t));
len = sizeof(*cmd) + table_tlv_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = wmi_buf_data(buf);
qdf_mem_zero(buf_ptr, len);
cmd = (wmi_pdev_set_mimogain_table_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_mimogain_table_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_set_mimogain_table_cmd_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
param->pdev_id);
WMI_MIMOGAIN_ARRAY_GAIN_LEN_SET(cmd->mimogain_info, param->tbl_len);
WMI_MIMOGAIN_MULTI_CHAIN_BYPASS_SET(cmd->mimogain_info,
param->multichain_gain_bypass);
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
(param->tbl_len));
buf_ptr += WMI_TLV_HDR_SIZE;
gain_table = (uint32_t *)buf_ptr;
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(gain_table,
param->array_gain,
param->tbl_len);
wmi_mtrace(WMI_PDEV_SET_MIMOGAIN_TABLE_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_MIMOGAIN_TABLE_CMDID)) {
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* enum packet_power_tlv_flags: target defined
* packet power rate flags for TLV
* @WMI_TLV_FLAG_ONE_CHAIN: one chain
* @WMI_TLV_FLAG_TWO_CHAIN: two chain
* @WMI_TLV_FLAG_THREE_CHAIN: three chain
* @WMI_TLV_FLAG_FOUR_CHAIN: four chain
* @WMI_TLV_FLAG_FIVE_CHAIN: five chain
* @WMI_TLV_FLAG_SIX_CHAIN: six chain
* @WMI_TLV_FLAG_SEVEN_CHAIN: seven chain
* @WMI_TLV_FLAG_EIGHT_CHAIN:eight chain
* @WMI_TLV_FLAG_STBC: STBC is set
* @WMI_TLV_FLAG_40MHZ: 40MHz chan width
* @WMI_TLV_FLAG_80MHZ: 80MHz chan width
* @WMI_TLV_FLAG_160MHZ: 160MHz chan width
* @WMI_TLV_FLAG_TXBF: Tx Bf enabled
* @WMI_TLV_FLAG_RTSENA: RTS enabled
* @WMI_TLV_FLAG_CTSENA: CTS enabled
* @WMI_TLV_FLAG_LDPC: LDPC is set
* @WMI_TLV_FLAG_SGI: Short gaurd interval
* @WMI_TLV_FLAG_SU: SU Data
* @WMI_TLV_FLAG_DL_MU_MIMO_AC: DL AC MU data
* @WMI_TLV_FLAG_DL_MU_MIMO_AX: DL AX MU data
* @WMI_TLV_FLAG_DL_OFDMA: DL OFDMA data
* @WMI_TLV_FLAG_UL_OFDMA: UL OFDMA data
* @WMI_TLV_FLAG_UL_MU_MIMO: UL MU data
*
* @WMI_TLV_FLAG_BW_MASK: bandwidth mask
* @WMI_TLV_FLAG_BW_SHIFT: bandwidth shift
* @WMI_TLV_FLAG_SU_MU_OFDMA_MASK: su/mu/ofdma mask
* @WMI_TLV_FLAG_SU_MU_OFDMA_shift: su/mu/ofdma shift
*/
enum packet_power_tlv_flags {
WMI_TLV_FLAG_ONE_CHAIN = 0x00000001,
WMI_TLV_FLAG_TWO_CHAIN = 0x00000003,
WMI_TLV_FLAG_THREE_CHAIN = 0x00000007,
WMI_TLV_FLAG_FOUR_CHAIN = 0x0000000F,
WMI_TLV_FLAG_FIVE_CHAIN = 0x0000001F,
WMI_TLV_FLAG_SIX_CHAIN = 0x0000003F,
WMI_TLV_FLAG_SEVEN_CHAIN = 0x0000007F,
WMI_TLV_FLAG_EIGHT_CHAIN = 0x0000008F,
WMI_TLV_FLAG_STBC = 0x00000100,
WMI_TLV_FLAG_40MHZ = 0x00000200,
WMI_TLV_FLAG_80MHZ = 0x00000300,
WMI_TLV_FLAG_160MHZ = 0x00000400,
WMI_TLV_FLAG_TXBF = 0x00000800,
WMI_TLV_FLAG_RTSENA = 0x00001000,
WMI_TLV_FLAG_CTSENA = 0x00002000,
WMI_TLV_FLAG_LDPC = 0x00004000,
WMI_TLV_FLAG_SGI = 0x00008000,
WMI_TLV_FLAG_SU = 0x00100000,
WMI_TLV_FLAG_DL_MU_MIMO_AC = 0x00200000,
WMI_TLV_FLAG_DL_MU_MIMO_AX = 0x00300000,
WMI_TLV_FLAG_DL_OFDMA = 0x00400000,
WMI_TLV_FLAG_UL_OFDMA = 0x00500000,
WMI_TLV_FLAG_UL_MU_MIMO = 0x00600000,
WMI_TLV_FLAG_CHAIN_MASK = 0xff,
WMI_TLV_FLAG_BW_MASK = 0x3,
WMI_TLV_FLAG_BW_SHIFT = 9,
WMI_TLV_FLAG_SU_MU_OFDMA_MASK = 0x7,
WMI_TLV_FLAG_SU_MU_OFDMA_SHIFT = 20,
};
/**
* convert_to_power_info_rate_flags() - convert packet_power_info_params
* to FW understandable format
* @param: pointer to hold packet power info param
*
* @return FW understandable 32 bit rate flags
*/
static uint32_t
convert_to_power_info_rate_flags(struct packet_power_info_params *param)
{
uint32_t rateflags = 0;
if (param->chainmask)
rateflags |=
(param->chainmask & WMI_TLV_FLAG_CHAIN_MASK);
if (param->chan_width)
rateflags |=
((param->chan_width & WMI_TLV_FLAG_BW_MASK)
<< WMI_TLV_FLAG_BW_SHIFT);
if (param->su_mu_ofdma)
rateflags |=
((param->su_mu_ofdma & WMI_TLV_FLAG_SU_MU_OFDMA_MASK)
<< WMI_TLV_FLAG_SU_MU_OFDMA_SHIFT);
if (param->rate_flags & WMI_HOST_FLAG_STBC)
rateflags |= WMI_TLV_FLAG_STBC;
if (param->rate_flags & WMI_HOST_FLAG_LDPC)
rateflags |= WMI_TLV_FLAG_LDPC;
if (param->rate_flags & WMI_HOST_FLAG_TXBF)
rateflags |= WMI_TLV_FLAG_TXBF;
if (param->rate_flags & WMI_HOST_FLAG_RTSENA)
rateflags |= WMI_TLV_FLAG_RTSENA;
if (param->rate_flags & WMI_HOST_FLAG_CTSENA)
rateflags |= WMI_TLV_FLAG_CTSENA;
if (param->rate_flags & WMI_HOST_FLAG_SGI)
rateflags |= WMI_TLV_FLAG_SGI;
return rateflags;
}
/**
* send_packet_power_info_get_cmd_tlv() - send request to get packet power
* info to fw
* @wmi_handle: wmi handle
* @param: pointer to hold packet power info param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS
send_packet_power_info_get_cmd_tlv(wmi_unified_t wmi_handle,
struct packet_power_info_params *param)
{
wmi_pdev_get_tpc_cmd_fixed_param *cmd;
wmi_buf_t wmibuf;
uint8_t *buf_ptr;
u_int32_t len = sizeof(wmi_pdev_get_tpc_cmd_fixed_param);
wmibuf = wmi_buf_alloc(wmi_handle, len);
if (wmibuf == NULL)
return QDF_STATUS_E_NOMEM;
buf_ptr = (uint8_t *)wmi_buf_data(wmibuf);
cmd = (wmi_pdev_get_tpc_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_get_tpc_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_get_tpc_cmd_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
param->pdev_id);
cmd->rate_flags = convert_to_power_info_rate_flags(param);
cmd->nss = param->nss;
cmd->preamble = param->preamble;
cmd->hw_rate = param->hw_rate;
WMI_LOGI("%s[%d] commandID %d, wmi_pdev_get_tpc_cmd=0x%x,"
"rate_flags: 0x%x, nss: %d, preamble: %d, hw_rate: %d",
__func__, __LINE__, WMI_PDEV_GET_TPC_CMDID, *((u_int32_t *)cmd),
cmd->rate_flags, cmd->nss, cmd->preamble, cmd->hw_rate);
wmi_mtrace(WMI_PDEV_GET_TPC_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, wmibuf, len,
WMI_PDEV_GET_TPC_CMDID)) {
WMI_LOGE(FL("Failed to get tpc command"));
wmi_buf_free(wmibuf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_vdev_config_ratemask_cmd_tlv() - config ratemask param in fw
* @wmi_handle: wmi handle
* @param: pointer to hold config ratemask params
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS send_vdev_config_ratemask_cmd_tlv(wmi_unified_t wmi_handle,
struct config_ratemask_params *param)
{
wmi_vdev_config_ratemask_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_vdev_config_ratemask_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_config_ratemask_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_vdev_config_ratemask_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->type = param->type;
cmd->mask_lower32 = param->lower32;
cmd->mask_higher32 = param->higher32;
cmd->mask_lower32_2 = param->lower32_2;
WMI_LOGI("Setting vdev ratemask vdev id = 0x%X, type = 0x%X"
"mask_l32 = 0x%X mask_h32 = 0x%X mask_l32_2 = 0x%X",
param->vdev_id, param->type, param->lower32,
param->higher32, param->lower32_2);
wmi_mtrace(WMI_VDEV_RATEMASK_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_RATEMASK_CMDID)) {
WMI_LOGE("Seting vdev ratemask failed");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_vdev_set_neighbour_rx_cmd_tlv() - set neighbour rx param in fw
* @wmi_handle: wmi handle
* @macaddr: vdev mac address
* @param: pointer to hold neigbour rx param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS send_vdev_set_neighbour_rx_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t macaddr[IEEE80211_ADDR_LEN],
struct set_neighbour_rx_params *param)
{
wmi_vdev_filter_nrp_config_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_vdev_filter_nrp_config_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_filter_nrp_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_vdev_filter_nrp_config_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->bssid_idx = param->idx;
cmd->action = param->action;
cmd->type = param->type;
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
cmd->flag = 0;
wmi_mtrace(WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID)) {
WMI_LOGE("Failed to set neighbour rx param");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_nf_dbr_dbm_info_get_cmd_tlv() - send request to get nf to fw
* @wmi_handle: wmi handle
* @mac_id: radio context
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_nf_dbr_dbm_info_get_cmd_tlv(wmi_unified_t wmi_handle, uint8_t mac_id)
{
wmi_buf_t buf;
QDF_STATUS ret;
wmi_pdev_get_nfcal_power_fixed_param *cmd;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (buf == NULL)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_pdev_get_nfcal_power_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_get_nfcal_power_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_get_nfcal_power_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(mac_id);
wmi_mtrace(WMI_PDEV_GET_NFCAL_POWER_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_GET_NFCAL_POWER_CMDID);
if (ret != 0) {
WMI_LOGE("Sending get nfcal power cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_set_ht_ie_cmd_tlv() - send ht ie command to fw
* @wmi_handle: wmi handle
* @param: pointer to ht ie param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_set_ht_ie_cmd_tlv(wmi_unified_t wmi_handle,
struct ht_ie_params *param)
{
wmi_pdev_set_ht_ie_cmd_fixed_param *cmd;
wmi_buf_t buf;
QDF_STATUS ret;
int32_t len;
uint8_t *buf_ptr;
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
roundup(param->ie_len, sizeof(uint32_t));
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_pdev_set_ht_ie_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_ht_ie_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_set_ht_ie_cmd_fixed_param));
cmd->reserved0 = 0;
cmd->ie_len = param->ie_len;
cmd->tx_streams = param->tx_streams;
cmd->rx_streams = param->rx_streams;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->ie_len);
buf_ptr += WMI_TLV_HDR_SIZE;
if (param->ie_len)
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(buf_ptr, param->ie_data,
cmd->ie_len);
wmi_mtrace(WMI_PDEV_SET_HT_CAP_IE_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_HT_CAP_IE_CMDID);
if (ret != 0) {
WMI_LOGE("Sending set ht ie cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_set_vht_ie_cmd_tlv() - send vht ie command to fw
* @wmi_handle: wmi handle
* @param: pointer to vht ie param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_set_vht_ie_cmd_tlv(wmi_unified_t wmi_handle,
struct vht_ie_params *param)
{
wmi_pdev_set_vht_ie_cmd_fixed_param *cmd;
wmi_buf_t buf;
QDF_STATUS ret;
int32_t len;
uint8_t *buf_ptr;
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
roundup(param->ie_len, sizeof(uint32_t));
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_pdev_set_vht_ie_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_vht_ie_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_set_vht_ie_cmd_fixed_param));
cmd->reserved0 = 0;
cmd->ie_len = param->ie_len;
cmd->tx_streams = param->tx_streams;
cmd->rx_streams = param->rx_streams;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->ie_len);
buf_ptr += WMI_TLV_HDR_SIZE;
if (param->ie_len)
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(buf_ptr, param->ie_data,
cmd->ie_len);
wmi_mtrace(WMI_PDEV_SET_VHT_CAP_IE_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_VHT_CAP_IE_CMDID);
if (ret != 0) {
WMI_LOGE("Sending set vht ie cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_set_quiet_mode_cmd_tlv() - send set quiet mode command to fw
* @wmi_handle: wmi handle
* @param: pointer to quiet mode params
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_set_quiet_mode_cmd_tlv(wmi_unified_t wmi_handle,
struct set_quiet_mode_params *param)
{
wmi_pdev_set_quiet_cmd_fixed_param *quiet_cmd;
wmi_buf_t buf;
QDF_STATUS ret;
int32_t len;
len = sizeof(*quiet_cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
quiet_cmd = (wmi_pdev_set_quiet_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&quiet_cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_quiet_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_set_quiet_cmd_fixed_param));
quiet_cmd = (wmi_pdev_set_quiet_cmd_fixed_param *)wmi_buf_data(buf);
quiet_cmd->enabled = param->enabled;
quiet_cmd->period = (param->period)*(param->intval);
quiet_cmd->duration = param->duration;
quiet_cmd->next_start = param->offset;
quiet_cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
WMI_HOST_PDEV_ID_SOC);
wmi_mtrace(WMI_PDEV_SET_QUIET_MODE_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_QUIET_MODE_CMDID);
if (ret != 0) {
WMI_LOGE("Sending set quiet cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_bcn_offload_control_cmd_tlv - send beacon ofload control cmd to fw
* @wmi_handle: wmi handle
* @bcn_ctrl_param: pointer to bcn_offload_control param
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static
QDF_STATUS send_bcn_offload_control_cmd_tlv(wmi_unified_t wmi_handle,
struct bcn_offload_control *bcn_ctrl_param)
{
wmi_buf_t buf;
wmi_bcn_offload_ctrl_cmd_fixed_param *cmd;
QDF_STATUS ret;
uint32_t len;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_bcn_offload_ctrl_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bcn_offload_ctrl_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_bcn_offload_ctrl_cmd_fixed_param));
cmd->vdev_id = bcn_ctrl_param->vdev_id;
switch (bcn_ctrl_param->bcn_ctrl_op) {
case BCN_OFFLD_CTRL_TX_DISABLE:
cmd->bcn_ctrl_op = WMI_BEACON_CTRL_TX_DISABLE;
break;
case BCN_OFFLD_CTRL_TX_ENABLE:
cmd->bcn_ctrl_op = WMI_BEACON_CTRL_TX_ENABLE;
break;
case BCN_OFFLD_CTRL_SWBA_DISABLE:
cmd->bcn_ctrl_op = WMI_BEACON_CTRL_SWBA_EVENT_DISABLE;
break;
case BCN_OFFLD_CTRL_SWBA_ENABLE:
cmd->bcn_ctrl_op = WMI_BEACON_CTRL_SWBA_EVENT_ENABLE;
break;
default:
WMI_LOGE("WMI_BCN_OFFLOAD_CTRL_CMDID unknown CTRL Operation %d",
bcn_ctrl_param->bcn_ctrl_op);
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
break;
}
wmi_mtrace(WMI_BCN_OFFLOAD_CTRL_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_BCN_OFFLOAD_CTRL_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
WMI_LOGE("WMI_BCN_OFFLOAD_CTRL_CMDID send returned Error %d",
ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* extract_tbttoffset_num_vdevs_tlv() - extract tbtt offset num vdev
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param num_vdevs: Pointer to hold num vdev
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_tbttoffset_num_vdevs_tlv(void *wmi_hdl,
void *evt_buf, uint32_t *num_vdevs)
{
WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
uint32_t vdev_map;
param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
qdf_print("Invalid tbtt update ext event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_event = param_buf->fixed_param;
vdev_map = tbtt_offset_event->vdev_map;
*num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
return QDF_STATUS_SUCCESS;
}
/**
* extract_ext_tbttoffset_num_vdevs_tlv() - extract ext tbtt offset num vdev
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param num_vdevs: Pointer to hold num vdev
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_ext_tbttoffset_num_vdevs_tlv(void *wmi_hdl,
void *evt_buf, uint32_t *num_vdevs)
{
WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_ext_event_fixed_param *tbtt_offset_ext_event;
param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
qdf_print("Invalid tbtt update ext event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_ext_event = param_buf->fixed_param;
*num_vdevs = tbtt_offset_ext_event->num_vdevs;
return QDF_STATUS_SUCCESS;
}
/**
* extract_tbttoffset_update_params_tlv() - extract tbtt offset param
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param idx: Index referring to a vdev
* @param tbtt_param: Pointer to tbttoffset event param
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_tbttoffset_update_params_tlv(void *wmi_hdl,
void *evt_buf, uint8_t idx,
struct tbttoffset_params *tbtt_param)
{
WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
uint32_t vdev_map;
param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
qdf_print("Invalid tbtt update event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_event = param_buf->fixed_param;
vdev_map = tbtt_offset_event->vdev_map;
tbtt_param->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
if (tbtt_param->vdev_id == WLAN_INVALID_VDEV_ID)
return QDF_STATUS_E_INVAL;
tbtt_param->tbttoffset =
param_buf->tbttoffset_list[tbtt_param->vdev_id];
return QDF_STATUS_SUCCESS;
}
/**
* extract_ext_tbttoffset_update_params_tlv() - extract ext tbtt offset param
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param idx: Index referring to a vdev
* @param tbtt_param: Pointer to tbttoffset event param
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_ext_tbttoffset_update_params_tlv(void *wmi_hdl,
void *evt_buf, uint8_t idx,
struct tbttoffset_params *tbtt_param)
{
WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_info *tbtt_offset_info;
param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
qdf_print("Invalid tbtt update event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_info = &param_buf->tbtt_offset_info[idx];
tbtt_param->vdev_id = tbtt_offset_info->vdev_id;
tbtt_param->tbttoffset = tbtt_offset_info->tbttoffset;
return QDF_STATUS_SUCCESS;
}
/**
* extract_swba_num_vdevs_tlv() - extract swba num vdevs from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param num_vdevs: Pointer to hold num vdevs
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_swba_num_vdevs_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t *num_vdevs)
{
WMI_HOST_SWBA_EVENTID_param_tlvs *param_buf;
wmi_host_swba_event_fixed_param *swba_event;
uint32_t vdev_map;
param_buf = (WMI_HOST_SWBA_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid swba event buffer");
return QDF_STATUS_E_INVAL;
}
swba_event = param_buf->fixed_param;
*num_vdevs = swba_event->num_vdevs;
if (!(*num_vdevs)) {
vdev_map = swba_event->vdev_map;
*num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_swba_tim_info_tlv() - extract swba tim info from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param idx: Index to bcn info
* @param tim_info: Pointer to hold tim info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_swba_tim_info_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t idx, wmi_host_tim_info *tim_info)
{
WMI_HOST_SWBA_EVENTID_param_tlvs *param_buf;
wmi_tim_info *tim_info_ev;
param_buf = (WMI_HOST_SWBA_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid swba event buffer");
return QDF_STATUS_E_INVAL;
}
tim_info_ev = &param_buf->tim_info[idx];
tim_info->tim_len = tim_info_ev->tim_len;
tim_info->tim_mcast = tim_info_ev->tim_mcast;
qdf_mem_copy(tim_info->tim_bitmap, tim_info_ev->tim_bitmap,
(sizeof(uint32_t) * WMI_TIM_BITMAP_ARRAY_SIZE));
tim_info->tim_changed = tim_info_ev->tim_changed;
tim_info->tim_num_ps_pending = tim_info_ev->tim_num_ps_pending;
tim_info->vdev_id = tim_info_ev->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_swba_noa_info_tlv() - extract swba NoA information from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param idx: Index to bcn info
* @param p2p_desc: Pointer to hold p2p NoA info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_swba_noa_info_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t idx, wmi_host_p2p_noa_info *p2p_desc)
{
WMI_HOST_SWBA_EVENTID_param_tlvs *param_buf;
wmi_p2p_noa_info *p2p_noa_info;
uint8_t i = 0;
param_buf = (WMI_HOST_SWBA_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid swba event buffer");
return QDF_STATUS_E_INVAL;
}
p2p_noa_info = &param_buf->p2p_noa_info[idx];
p2p_desc->modified = false;
p2p_desc->num_descriptors = 0;
if (WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(p2p_noa_info)) {
p2p_desc->modified = true;
p2p_desc->index =
(uint8_t) WMI_UNIFIED_NOA_ATTR_INDEX_GET(p2p_noa_info);
p2p_desc->oppPS =
(uint8_t) WMI_UNIFIED_NOA_ATTR_OPP_PS_GET(p2p_noa_info);
p2p_desc->ctwindow =
(uint8_t) WMI_UNIFIED_NOA_ATTR_CTWIN_GET(p2p_noa_info);
p2p_desc->num_descriptors =
(uint8_t) WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET
(p2p_noa_info);
for (i = 0; i < p2p_desc->num_descriptors; i++) {
p2p_desc->noa_descriptors[i].type_count =
(uint8_t) p2p_noa_info->noa_descriptors[i].
type_count;
p2p_desc->noa_descriptors[i].duration =
p2p_noa_info->noa_descriptors[i].duration;
p2p_desc->noa_descriptors[i].interval =
p2p_noa_info->noa_descriptors[i].interval;
p2p_desc->noa_descriptors[i].start_time =
p2p_noa_info->noa_descriptors[i].start_time;
}
p2p_desc->vdev_id = p2p_noa_info->vdev_id;
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_offchan_data_tx_compl_param_tlv() -
* extract Offchan data tx completion event params
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold offchan data TX completion params
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_offchan_data_tx_compl_param_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_offchan_data_tx_compl_event *param)
{
WMI_OFFCHAN_DATA_TX_COMPLETION_EVENTID_param_tlvs *param_buf;
wmi_offchan_data_tx_compl_event_fixed_param *cmpl_params;
param_buf = (WMI_OFFCHAN_DATA_TX_COMPLETION_EVENTID_param_tlvs *)
evt_buf;
if (!param_buf) {
WMI_LOGE("%s: Invalid offchan data Tx compl event", __func__);
return QDF_STATUS_E_INVAL;
}
cmpl_params = param_buf->fixed_param;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
cmpl_params->pdev_id);
param->desc_id = cmpl_params->desc_id;
param->status = cmpl_params->status;
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_csa_switch_count_status_tlv() - extract pdev csa switch count
* status tlv
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold csa switch count status event param
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_pdev_csa_switch_count_status_tlv(
wmi_unified_t wmi_handle,
void *evt_buf,
struct pdev_csa_switch_count_status *param)
{
WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID_param_tlvs *param_buf;
wmi_pdev_csa_switch_count_status_event_fixed_param *csa_status;
param_buf = (WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID_param_tlvs *)
evt_buf;
if (!param_buf) {
WMI_LOGE("%s: Invalid CSA status event", __func__);
return QDF_STATUS_E_INVAL;
}
csa_status = param_buf->fixed_param;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
csa_status->pdev_id);
param->current_switch_count = csa_status->current_switch_count;
param->num_vdevs = csa_status->num_vdevs;
param->vdev_ids = param_buf->vdev_ids;
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_tpc_config_ev_param_tlv() - extract pdev tpc configuration
* param from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold tpc configuration
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_pdev_tpc_config_ev_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_pdev_tpc_config_event *param)
{
wmi_pdev_tpc_config_event_fixed_param *event =
(wmi_pdev_tpc_config_event_fixed_param *)evt_buf;
if (!event) {
WMI_LOGE("Invalid event buffer");
return QDF_STATUS_E_INVAL;
}
param->pdev_id = event->pdev_id;
param->regDomain = event->regDomain;
param->chanFreq = event->chanFreq;
param->phyMode = event->phyMode;
param->twiceAntennaReduction = event->twiceAntennaReduction;
param->twiceAntennaGain = event->twiceAntennaGain;
param->twiceMaxRDPower = event->twiceMaxRDPower;
param->powerLimit = event->powerLimit;
param->rateMax = event->rateMax;
param->numTxChain = event->numTxChain;
param->ctl = event->ctl;
param->flags = event->flags;
qdf_mem_copy(param->maxRegAllowedPower, event->maxRegAllowedPower,
sizeof(param->maxRegAllowedPower));
qdf_mem_copy(param->maxRegAllowedPowerAGCDD,
event->maxRegAllowedPowerAGCDD,
sizeof(param->maxRegAllowedPowerAGCDD));
qdf_mem_copy(param->maxRegAllowedPowerAGSTBC,
event->maxRegAllowedPowerAGSTBC,
sizeof(param->maxRegAllowedPowerAGSTBC));
qdf_mem_copy(param->maxRegAllowedPowerAGTXBF,
event->maxRegAllowedPowerAGTXBF,
sizeof(param->maxRegAllowedPowerAGTXBF));
WMI_LOGD("%s:extract success", __func__);
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_sta_kickout_ev_tlv() - extract peer sta kickout event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param ev: Pointer to hold peer param
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_peer_sta_kickout_ev_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_peer_sta_kickout_event *ev)
{
WMI_PEER_STA_KICKOUT_EVENTID_param_tlvs *param_buf = NULL;
wmi_peer_sta_kickout_event_fixed_param *kickout_event = NULL;
param_buf = (WMI_PEER_STA_KICKOUT_EVENTID_param_tlvs *) evt_buf;
kickout_event = param_buf->fixed_param;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&kickout_event->peer_macaddr,
ev->peer_macaddr);
ev->reason = kickout_event->reason;
ev->rssi = kickout_event->rssi;
return QDF_STATUS_SUCCESS;
}
/**
* send_multiple_vdev_restart_req_cmd_tlv() - send multiple vdev restart req
* @wmi_handle: wmi handle
* @param: wmi multiple vdev restart req param
*
* Send WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
static QDF_STATUS send_multiple_vdev_restart_req_cmd_tlv(
wmi_unified_t wmi_handle,
struct multiple_vdev_restart_params *param)
{
wmi_buf_t buf;
QDF_STATUS qdf_status;
wmi_pdev_multiple_vdev_restart_request_cmd_fixed_param *cmd;
int i;
uint8_t *buf_ptr;
uint32_t *vdev_ids;
wmi_channel *chan_info;
struct channel_param *tchan_info;
uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
len += sizeof(wmi_channel);
if (param->num_vdevs)
len += sizeof(uint32_t) * param->num_vdevs;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("Failed to allocate memory");
qdf_status = QDF_STATUS_E_NOMEM;
goto end;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_pdev_multiple_vdev_restart_request_cmd_fixed_param *)
buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_multiple_vdev_restart_request_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_multiple_vdev_restart_request_cmd_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
param->pdev_id);
cmd->requestor_id = param->requestor_id;
cmd->disable_hw_ack = param->disable_hw_ack;
cmd->cac_duration_ms = param->cac_duration_ms;
cmd->num_vdevs = param->num_vdevs;
WMI_LOGI("%s:cmd->pdev_id: %d ,cmd->requestor_id: %d ,"
"cmd->disable_hw_ack: %d , cmd->cac_duration_ms:%d ,"
" cmd->num_vdevs: %d ",
__func__, cmd->pdev_id, cmd->requestor_id,
cmd->disable_hw_ack, cmd->cac_duration_ms, cmd->num_vdevs);
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_ARRAY_UINT32,
sizeof(uint32_t) * param->num_vdevs);
vdev_ids = (uint32_t *)(buf_ptr + WMI_TLV_HDR_SIZE);
for (i = 0; i < param->num_vdevs; i++)
vdev_ids[i] = param->vdev_ids[i];
buf_ptr += (sizeof(uint32_t) * param->num_vdevs) + WMI_TLV_HDR_SIZE;
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_STRUC_wmi_channel,
WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
chan_info = (wmi_channel *)buf_ptr;
tchan_info = &(param->ch_param);
chan_info->mhz = tchan_info->mhz;
chan_info->band_center_freq1 = tchan_info->cfreq1;
chan_info->band_center_freq2 = tchan_info->cfreq2;
if (tchan_info->is_chan_passive)
WMI_SET_CHANNEL_FLAG(chan_info,
WMI_CHAN_FLAG_PASSIVE);
if (tchan_info->dfs_set)
WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_DFS);
if (tchan_info->allow_vht)
WMI_SET_CHANNEL_FLAG(chan_info,
WMI_CHAN_FLAG_ALLOW_VHT);
else if (tchan_info->allow_ht)
WMI_SET_CHANNEL_FLAG(chan_info,
WMI_CHAN_FLAG_ALLOW_HT);
WMI_SET_CHANNEL_MODE(chan_info, tchan_info->phy_mode);
WMI_SET_CHANNEL_MIN_POWER(chan_info, tchan_info->minpower);
WMI_SET_CHANNEL_MAX_POWER(chan_info, tchan_info->maxpower);
WMI_SET_CHANNEL_REG_POWER(chan_info, tchan_info->maxregpower);
WMI_SET_CHANNEL_ANTENNA_MAX(chan_info, tchan_info->antennamax);
WMI_SET_CHANNEL_REG_CLASSID(chan_info, tchan_info->reg_class_id);
WMI_SET_CHANNEL_MAX_TX_POWER(chan_info, tchan_info->maxregpower);
WMI_LOGI("%s:tchan_info->is_chan_passive: %d ,"
"tchan_info->dfs_set : %d ,tchan_info->allow_vht:%d ,"
"tchan_info->allow_ht: %d ,tchan_info->antennamax: %d ,"
"tchan_info->phy_mode: %d ,tchan_info->minpower: %d,"
"tchan_info->maxpower: %d ,tchan_info->maxregpower: %d ,"
"tchan_info->reg_class_id: %d ,"
"tchan_info->maxregpower : %d ", __func__,
tchan_info->is_chan_passive, tchan_info->dfs_set,
tchan_info->allow_vht, tchan_info->allow_ht,
tchan_info->antennamax, tchan_info->phy_mode,
tchan_info->minpower, tchan_info->maxpower,
tchan_info->maxregpower, tchan_info->reg_class_id,
tchan_info->maxregpower);
wmi_mtrace(WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID, NO_SESSION, 0);
qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID);
if (QDF_IS_STATUS_ERROR(qdf_status)) {
WMI_LOGE("%s: Failed to send", __func__);
wmi_buf_free(buf);
}
end:
return qdf_status;
}
/**
* extract_dcs_interference_type_tlv() - extract dcs interference type
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold dcs interference param
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_dcs_interference_type_tlv(
wmi_unified_t wmi_handle,
void *evt_buf, struct wmi_host_dcs_interference_param *param)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *) evt_buf;
if (!param_buf)
return QDF_STATUS_E_INVAL;
param->interference_type = param_buf->fixed_param->interference_type;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
param_buf->fixed_param->pdev_id);
return QDF_STATUS_SUCCESS;
}
/*
* extract_dcs_cw_int_tlv() - extract dcs cw interference from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param cw_int: Pointer to hold cw interference
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_dcs_cw_int_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_ath_dcs_cw_int *cw_int)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
wlan_dcs_cw_int *ev;
param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *) evt_buf;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = param_buf->cw_int;
cw_int->channel = ev->channel;
return QDF_STATUS_SUCCESS;
}
/**
* extract_dcs_im_tgt_stats_tlv() - extract dcs im target stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param wlan_stat: Pointer to hold wlan stats
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_dcs_im_tgt_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_dcs_im_tgt_stats_t *wlan_stat)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
wlan_dcs_im_tgt_stats_t *ev;
param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *) evt_buf;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = param_buf->wlan_stat;
wlan_stat->reg_tsf32 = ev->reg_tsf32;
wlan_stat->last_ack_rssi = ev->last_ack_rssi;
wlan_stat->tx_waste_time = ev->tx_waste_time;
wlan_stat->rx_time = ev->rx_time;
wlan_stat->phyerr_cnt = ev->phyerr_cnt;
wlan_stat->mib_stats.listen_time = ev->listen_time;
wlan_stat->mib_stats.reg_tx_frame_cnt = ev->reg_tx_frame_cnt;
wlan_stat->mib_stats.reg_rx_frame_cnt = ev->reg_rx_frame_cnt;
wlan_stat->mib_stats.reg_rxclr_cnt = ev->reg_rxclr_cnt;
wlan_stat->mib_stats.reg_cycle_cnt = ev->reg_cycle_cnt;
wlan_stat->mib_stats.reg_rxclr_ext_cnt = ev->reg_rxclr_ext_cnt;
wlan_stat->mib_stats.reg_ofdm_phyerr_cnt = ev->reg_ofdm_phyerr_cnt;
wlan_stat->mib_stats.reg_cck_phyerr_cnt = ev->reg_cck_phyerr_cnt;
wlan_stat->chan_nf = ev->chan_nf;
wlan_stat->my_bss_rx_cycle_count = ev->my_bss_rx_cycle_count;
return QDF_STATUS_SUCCESS;
}
/*
* extract_peer_delete_response_event_tlv() - extract peer delete response event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param vdev_id: Pointer to hold vdev_id
* @param mac_addr: Pointer to hold peer mac address
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_peer_delete_response_event_tlv(wmi_unified_t wmi_hdl,
void *evt_buf, struct wmi_host_peer_delete_response_event *param)
{
WMI_PEER_DELETE_RESP_EVENTID_param_tlvs *param_buf;
wmi_peer_delete_resp_event_fixed_param *ev;
param_buf = (WMI_PEER_DELETE_RESP_EVENTID_param_tlvs *)evt_buf;
ev = (wmi_peer_delete_resp_event_fixed_param *) param_buf->fixed_param;
if (!ev) {
WMI_LOGE("%s: Invalid peer_delete response", __func__);
return QDF_STATUS_E_FAILURE;
}
param->vdev_id = ev->vdev_id;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr,
&param->mac_address.bytes[0]);
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_tpc_ev_param_tlv() - extract tpc param from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold tpc param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS extract_pdev_tpc_ev_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_pdev_tpc_event *param)
{
WMI_PDEV_TPC_EVENTID_param_tlvs *param_buf;
wmi_pdev_tpc_event_fixed_param *event;
param_buf = (WMI_PDEV_TPC_EVENTID_param_tlvs *)evt_buf;
event = (wmi_pdev_tpc_event_fixed_param *)param_buf->fixed_param;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
event->pdev_id);
qdf_mem_copy(param->tpc, param_buf->tpc, sizeof(param->tpc));
return QDF_STATUS_SUCCESS;
}
/**
* extract_nfcal_power_ev_param_tlv() - extract noise floor calibration
* power param from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold nf cal power param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
extract_nfcal_power_ev_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_pdev_nfcal_power_all_channels_event *param)
{
WMI_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID_param_tlvs *param_buf;
wmi_pdev_nfcal_power_all_channels_event_fixed_param *event;
wmi_pdev_nfcal_power_all_channels_nfdBr *ch_nfdbr;
wmi_pdev_nfcal_power_all_channels_nfdBm *ch_nfdbm;
wmi_pdev_nfcal_power_all_channels_freqNum *ch_freqnum;
uint32_t i;
param_buf =
(WMI_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID_param_tlvs *)evt_buf;
event = param_buf->fixed_param;
ch_nfdbr = param_buf->nfdbr;
ch_nfdbm = param_buf->nfdbm;
ch_freqnum = param_buf->freqnum;
WMI_LOGD("pdev_id[%x], num_nfdbr[%d], num_nfdbm[%d] num_freqnum[%d]",
event->pdev_id, param_buf->num_nfdbr,
param_buf->num_nfdbm, param_buf->num_freqnum);
if (param_buf->num_nfdbr >
WMI_HOST_RXG_CAL_CHAN_MAX * WMI_HOST_MAX_NUM_CHAINS) {
WMI_LOGE("invalid number of nfdBr");
return QDF_STATUS_E_FAILURE;
}
if (param_buf->num_nfdbm >
WMI_HOST_RXG_CAL_CHAN_MAX * WMI_HOST_MAX_NUM_CHAINS) {
WMI_LOGE("invalid number of nfdBm");
return QDF_STATUS_E_FAILURE;
}
if (param_buf->num_freqnum > WMI_HOST_RXG_CAL_CHAN_MAX) {
WMI_LOGE("invalid number of freqNum");
return QDF_STATUS_E_FAILURE;
}
for (i = 0; i < param_buf->num_nfdbr; i++) {
param->nfdbr[i] = (int8_t)ch_nfdbr->nfdBr;
param->nfdbm[i] = (int8_t)ch_nfdbm->nfdBm;
ch_nfdbr++;
ch_nfdbm++;
}
for (i = 0; i < param_buf->num_freqnum; i++) {
param->freqnum[i] = ch_freqnum->freqNum;
ch_freqnum++;
}
param->pdev_id = wmi_handle->ops->
convert_pdev_id_target_to_host(event->pdev_id);
return QDF_STATUS_SUCCESS;
}
#ifdef BIG_ENDIAN_HOST
/**
* wds_addr_ev_conv_data_be() - LE to BE conversion of wds addr event
* @param data_len - data length
* @param data - pointer to data
*
* Return: QDF_STATUS - success or error status
*/
static QDF_STATUS wds_addr_ev_conv_data_be(uint16_t data_len, uint8_t *ev)
{
uint8_t *datap = (uint8_t *)ev;
int i;
/* Skip swapping the first word */
datap += sizeof(uint32_t);
for (i = 0; i < ((data_len / sizeof(uint32_t))-1);
i++, datap += sizeof(uint32_t)) {
*(uint32_t *)datap = qdf_le32_to_cpu(*(uint32_t *)datap);
}
return QDF_STATUS_SUCCESS;
}
#else
/**
* wds_addr_ev_conv_data_be() - Dummy operation for LE platforms
* @param data_len - data length
* @param data - pointer to data
*
* Return: QDF_STATUS - success or error status
*/
static QDF_STATUS wds_addr_ev_conv_data_be(uint32_t data_len, uint8_t *ev)
{
return QDF_STATUS_SUCCESS;
}
#endif
/**
* extract_wds_addr_event_tlv() - extract wds address from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param wds_ev: Pointer to hold wds address
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS extract_wds_addr_event_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
uint16_t len, wds_addr_event_t *wds_ev)
{
WMI_WDS_PEER_EVENTID_param_tlvs *param_buf;
wmi_wds_addr_event_fixed_param *ev;
int i;
param_buf = (WMI_WDS_PEER_EVENTID_param_tlvs *)evt_buf;
ev = (wmi_wds_addr_event_fixed_param *)param_buf->fixed_param;
if (wds_addr_ev_conv_data_be(len, (uint8_t *)ev) != QDF_STATUS_SUCCESS)
return QDF_STATUS_E_FAILURE;
qdf_mem_copy(wds_ev->event_type, ev->event_type,
sizeof(wds_ev->event_type));
for (i = 0; i < 4; i++) {
wds_ev->peer_mac[i] =
((u_int8_t *)&(ev->peer_mac.mac_addr31to0))[i];
wds_ev->dest_mac[i] =
((u_int8_t *)&(ev->dest_mac.mac_addr31to0))[i];
}
for (i = 0; i < 2; i++) {
wds_ev->peer_mac[4+i] =
((u_int8_t *)&(ev->peer_mac.mac_addr47to32))[i];
wds_ev->dest_mac[4+i] =
((u_int8_t *)&(ev->dest_mac.mac_addr47to32))[i];
}
wds_ev->vdev_id = ev->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_sta_ps_statechange_ev_tlv() - extract peer sta ps state
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param ev: Pointer to hold peer param and ps state
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS extract_peer_sta_ps_statechange_ev_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_peer_sta_ps_statechange_event *ev)
{
WMI_PEER_STA_PS_STATECHG_EVENTID_param_tlvs *param_buf;
wmi_peer_sta_ps_statechange_event_fixed_param *event;
param_buf = (WMI_PEER_STA_PS_STATECHG_EVENTID_param_tlvs *)evt_buf;
event = (wmi_peer_sta_ps_statechange_event_fixed_param *)
param_buf->fixed_param;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, ev->peer_macaddr);
ev->peer_ps_state = event->peer_ps_state;
return QDF_STATUS_SUCCESS;
}
/**
* extract_inst_rssi_stats_event_tlv() - extract inst rssi stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param inst_rssi_resp: Pointer to hold inst rssi response
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS extract_inst_rssi_stats_event_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_inst_stats_resp *inst_rssi_resp)
{
WMI_INST_RSSI_STATS_EVENTID_param_tlvs *param_buf;
wmi_inst_rssi_stats_resp_fixed_param *event;
param_buf = (WMI_INST_RSSI_STATS_EVENTID_param_tlvs *)evt_buf;
event = (wmi_inst_rssi_stats_resp_fixed_param *)param_buf->fixed_param;
qdf_mem_copy(&(inst_rssi_resp->peer_macaddr),
&(event->peer_macaddr), sizeof(wmi_mac_addr));
inst_rssi_resp->iRSSI = event->iRSSI;
return QDF_STATUS_SUCCESS;
}
/**
* send_pdev_caldata_version_check_cmd_tlv() - send caldata check cmd to fw
* @wmi_handle: wmi handle
* @param: reserved param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_pdev_caldata_version_check_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t param)
{
wmi_pdev_check_cal_version_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(wmi_pdev_check_cal_version_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_pdev_check_cal_version_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_check_cal_version_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_check_cal_version_cmd_fixed_param));
cmd->pdev_id = param; /* set to 0x0 as expected from FW */
wmi_mtrace(WMI_PDEV_CHECK_CAL_VERSION_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_CHECK_CAL_VERSION_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_caldata_version_check_ev_param_tlv() - extract caldata from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold peer caldata version data
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_pdev_caldata_version_check_ev_param_tlv(
wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_pdev_check_cal_version_event *param)
{
WMI_PDEV_CHECK_CAL_VERSION_EVENTID_param_tlvs *param_tlvs;
wmi_pdev_check_cal_version_event_fixed_param *event;
param_tlvs = (WMI_PDEV_CHECK_CAL_VERSION_EVENTID_param_tlvs *) evt_buf;
if (!param_tlvs) {
WMI_LOGE("invalid cal version event buf");
return QDF_STATUS_E_FAILURE;
}
event = param_tlvs->fixed_param;
if (event->board_mcn_detail[WMI_BOARD_MCN_STRING_MAX_SIZE] != '\0')
event->board_mcn_detail[WMI_BOARD_MCN_STRING_MAX_SIZE] = '\0';
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(param->board_mcn_detail,
event->board_mcn_detail, WMI_BOARD_MCN_STRING_BUF_SIZE);
param->software_cal_version = event->software_cal_version;
param->board_cal_version = event->board_cal_version;
param->cal_ok = event->cal_status;
return QDF_STATUS_SUCCESS;
}
#ifdef WLAN_SUPPORT_FILS
/**
* send_vdev_fils_enable_cmd_tlv() - enable/Disable FD Frame command to fw
* @wmi_handle: wmi handle
* @param: pointer to hold FILS discovery enable param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE on failure
*/
static QDF_STATUS
send_vdev_fils_enable_cmd_tlv(wmi_unified_t wmi_handle,
struct config_fils_params *param)
{
wmi_enable_fils_cmd_fixed_param *cmd;
wmi_buf_t buf;
QDF_STATUS status;
uint32_t len = sizeof(wmi_enable_fils_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_enable_fils_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_enable_fils_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_enable_fils_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->fd_period = param->fd_period;
WMI_LOGI("Setting FD period to %d vdev id : %d",
param->fd_period, param->vdev_id);
wmi_mtrace(WMI_ENABLE_FILS_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_ENABLE_FILS_CMDID);
if (status != QDF_STATUS_SUCCESS) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_swfda_vdev_id_tlv() - extract swfda vdev id from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @vdev_id: pointer to hold vdev id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_INVAL on failure
*/
static QDF_STATUS
extract_swfda_vdev_id_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t *vdev_id)
{
WMI_HOST_SWFDA_EVENTID_param_tlvs *param_buf;
wmi_host_swfda_event_fixed_param *swfda_event;
param_buf = (WMI_HOST_SWFDA_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid swfda event buffer");
return QDF_STATUS_E_INVAL;
}
swfda_event = param_buf->fixed_param;
*vdev_id = swfda_event->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* send_fils_discovery_send_cmd_tlv() - WMI FILS Discovery send function
* @wmi_handle: wmi handle
* @param: pointer to hold FD send cmd parameter
*
* Return : QDF_STATUS_SUCCESS on success and QDF_STATUS_E_NOMEM on failure.
*/
static QDF_STATUS
send_fils_discovery_send_cmd_tlv(wmi_unified_t wmi_handle,
struct fd_params *param)
{
QDF_STATUS ret;
wmi_fd_send_from_host_cmd_fixed_param *cmd;
wmi_buf_t wmi_buf;
qdf_dma_addr_t dma_addr;
wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!wmi_buf) {
WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_fd_send_from_host_cmd_fixed_param *)wmi_buf_data(wmi_buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_fd_send_from_host_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_fd_send_from_host_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->data_len = qdf_nbuf_len(param->wbuf);
dma_addr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
qdf_dmaaddr_to_32s(dma_addr, &cmd->frag_ptr_lo, &cmd->frag_ptr_hi);
cmd->frame_ctrl = param->frame_ctrl;
wmi_mtrace(WMI_PDEV_SEND_FD_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
WMI_PDEV_SEND_FD_CMDID);
if (ret != QDF_STATUS_SUCCESS) {
WMI_LOGE("%s: Failed to send fils discovery frame: %d",
__func__, ret);
wmi_buf_free(wmi_buf);
}
return ret;
}
#endif /* WLAN_SUPPORT_FILS */
/**
* send_set_qboost_param_cmd_tlv() - send set qboost command to fw
* @wmi_handle: wmi handle
* @param: pointer to qboost params
* @macaddr: vdev mac address
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS
send_set_qboost_param_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t macaddr[IEEE80211_ADDR_LEN],
struct set_qboost_params *param)
{
WMI_QBOOST_CFG_CMD_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
QDF_STATUS ret;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (WMI_QBOOST_CFG_CMD_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_WMI_QBOOST_CFG_CMD_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
WMI_QBOOST_CFG_CMD_fixed_param));
cmd->vdev_id = param->vdev_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
cmd->qb_enable = param->value;
wmi_mtrace(WMI_QBOOST_CFG_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_QBOOST_CFG_CMDID);
if (ret != 0) {
WMI_LOGE("Setting qboost cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_gpio_config_cmd_tlv() - send gpio config to fw
* @wmi_handle: wmi handle
* @param: pointer to hold gpio config param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_gpio_config_cmd_tlv(wmi_unified_t wmi_handle,
struct gpio_config_params *param)
{
wmi_gpio_config_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
QDF_STATUS ret;
len = sizeof(*cmd);
/* Sanity Checks */
if (param->pull_type > WMI_GPIO_PULL_DOWN ||
param->intr_mode > WMI_GPIO_INTTYPE_LEVEL_HIGH) {
return QDF_STATUS_E_FAILURE;
}
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_gpio_config_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_gpio_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_gpio_config_cmd_fixed_param));
cmd->gpio_num = param->gpio_num;
cmd->input = param->input;
cmd->pull_type = param->pull_type;
cmd->intr_mode = param->intr_mode;
wmi_mtrace(WMI_GPIO_CONFIG_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_GPIO_CONFIG_CMDID);
if (ret != 0) {
WMI_LOGE("Sending GPIO config cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_gpio_output_cmd_tlv() - send gpio output to fw
* @wmi_handle: wmi handle
* @param: pointer to hold gpio output param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_gpio_output_cmd_tlv(wmi_unified_t wmi_handle,
struct gpio_output_params *param)
{
wmi_gpio_output_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
QDF_STATUS ret;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_gpio_output_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_gpio_output_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_gpio_output_cmd_fixed_param));
cmd->gpio_num = param->gpio_num;
cmd->set = param->set;
wmi_mtrace(WMI_GPIO_OUTPUT_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_GPIO_OUTPUT_CMDID);
if (ret != 0) {
WMI_LOGE("Sending GPIO output cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_mcast_group_update_cmd_tlv() - send mcast group update cmd to fw
* @wmi_handle: wmi handle
* @param: pointer to hold mcast update param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_mcast_group_update_cmd_tlv(wmi_unified_t wmi_handle,
struct mcast_group_update_params *param)
{
wmi_peer_mcast_group_cmd_fixed_param *cmd;
wmi_buf_t buf;
QDF_STATUS ret;
int32_t len;
int offset = 0;
static char dummymask[4] = { 0xFF, 0xFF, 0xFF, 0xFF};
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_peer_mcast_group_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_mcast_group_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_peer_mcast_group_cmd_fixed_param));
/* confirm the buffer is 4-byte aligned */
QDF_ASSERT((((size_t) cmd) & 0x3) == 0);
qdf_mem_zero(cmd, sizeof(*cmd));
cmd->vdev_id = param->vap_id;
/* construct the message assuming our endianness matches the target */
cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_ACTION_M &
(param->action << WMI_PEER_MCAST_GROUP_FLAG_ACTION_S);
cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_WILDCARD_M &
(param->wildcard << WMI_PEER_MCAST_GROUP_FLAG_WILDCARD_S);
if (param->is_action_delete)
cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_DELETEALL_M;
if (param->is_mcast_addr_len)
cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_IPV6_M;
if (param->is_filter_mode_snoop)
cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_SRC_FILTER_EXCLUDE_M;
/* unicast address spec only applies for non-wildcard cases */
if (!param->wildcard && param->ucast_mac_addr) {
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->ucast_mac_addr,
&cmd->ucast_mac_addr);
}
if (param->mcast_ip_addr) {
QDF_ASSERT(param->mcast_ip_addr_bytes <=
sizeof(cmd->mcast_ip_addr));
offset = sizeof(cmd->mcast_ip_addr) -
param->mcast_ip_addr_bytes;
qdf_mem_copy(((uint8_t *)&cmd->mcast_ip_addr) + offset,
param->mcast_ip_addr,
param->mcast_ip_addr_bytes);
}
if (!param->mask)
param->mask = &dummymask[0];
qdf_mem_copy(((uint8_t *)&cmd->mcast_ip_mask) + offset,
param->mask,
param->mcast_ip_addr_bytes);
if (param->srcs && param->nsrcs) {
cmd->num_filter_addr = param->nsrcs;
QDF_ASSERT((param->nsrcs * param->mcast_ip_addr_bytes) <=
sizeof(cmd->filter_addr));
qdf_mem_copy(((uint8_t *) &cmd->filter_addr), param->srcs,
param->nsrcs * param->mcast_ip_addr_bytes);
}
wmi_mtrace(WMI_PEER_MCAST_GROUP_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_MCAST_GROUP_CMDID);
if (ret != QDF_STATUS_SUCCESS) {
WMI_LOGE("%s : WMI Failed", __func__);
wmi_buf_free(buf);
}
return ret;
}
/**
* send_pdev_qvit_cmd_tlv() - send qvit command to fw
* @wmi_handle: wmi handle
* @param: pointer to pdev_qvit_params
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_pdev_qvit_cmd_tlv(wmi_unified_t wmi_handle,
struct pdev_qvit_params *param)
{
wmi_buf_t buf;
QDF_STATUS ret = QDF_STATUS_E_INVAL;
uint8_t *cmd;
static uint8_t msgref = 1;
uint8_t segnumber = 0, seginfo, numsegments;
uint16_t chunk_len, total_bytes;
uint8_t *bufpos;
QVIT_SEG_HDR_INFO_STRUCT seghdrinfo;
bufpos = param->utf_payload;
total_bytes = param->len;
ASSERT(total_bytes / MAX_WMI_QVIT_LEN ==
(uint8_t) (total_bytes / MAX_WMI_QVIT_LEN));
numsegments = (uint8_t) (total_bytes / MAX_WMI_QVIT_LEN);
if (param->len - (numsegments * MAX_WMI_QVIT_LEN))
numsegments++;
while (param->len) {
if (param->len > MAX_WMI_QVIT_LEN)
chunk_len = MAX_WMI_QVIT_LEN; /* MAX message */
else
chunk_len = param->len;
buf = wmi_buf_alloc(wmi_handle,
(chunk_len + sizeof(seghdrinfo) +
WMI_TLV_HDR_SIZE));
if (!buf) {
WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (uint8_t *) wmi_buf_data(buf);
seghdrinfo.len = total_bytes;
seghdrinfo.msgref = msgref;
seginfo = ((numsegments << 4) & 0xF0) | (segnumber & 0xF);
seghdrinfo.segmentInfo = seginfo;
segnumber++;
WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE,
(chunk_len + sizeof(seghdrinfo)));
cmd += WMI_TLV_HDR_SIZE;
qdf_mem_copy(cmd, &seghdrinfo, sizeof(seghdrinfo));
qdf_mem_copy(&cmd[sizeof(seghdrinfo)], bufpos, chunk_len);
wmi_mtrace(WMI_PDEV_QVIT_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf,
(chunk_len + sizeof(seghdrinfo) +
WMI_TLV_HDR_SIZE),
WMI_PDEV_QVIT_CMDID);
if (ret != 0) {
WMI_LOGE("Failed to send WMI_PDEV_QVIT_CMDID command");
wmi_buf_free(buf);
break;
}
param->len -= chunk_len;
bufpos += chunk_len;
}
msgref++;
return ret;
}
/**
* send_wmm_update_cmd_tlv() - send wmm update command to fw
* @wmi_handle: wmi handle
* @param: pointer to wmm update param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_wmm_update_cmd_tlv(wmi_unified_t wmi_handle,
struct wmm_update_params *param)
{
wmi_pdev_set_wmm_params_cmd_fixed_param *cmd;
wmi_wmm_params *wmm_param;
wmi_buf_t buf;
QDF_STATUS ret;
int32_t len;
int ac = 0;
struct wmi_host_wmeParams *wmep;
uint8_t *buf_ptr;
len = sizeof(*cmd) + (WME_NUM_AC * sizeof(*wmm_param));
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = (uint8_t *) wmi_buf_data(buf);
cmd = (wmi_pdev_set_wmm_params_cmd_fixed_param *) buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_wmm_params_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_set_wmm_params_cmd_fixed_param));
cmd->reserved0 = WMI_HOST_PDEV_ID_SOC;
buf_ptr += sizeof(wmi_pdev_set_wmm_params_cmd_fixed_param);
for (ac = 0; ac < WME_NUM_AC; ac++) {
wmep = &param->wmep_array[ac];
wmm_param = (wmi_wmm_params *)buf_ptr;
WMITLV_SET_HDR(&wmm_param->tlv_header,
WMITLV_TAG_STRUC_wmi_wmm_params,
WMITLV_GET_STRUCT_TLVLEN(wmi_wmm_params));
wmm_param->aifs = wmep->wmep_aifsn;
wmm_param->cwmin = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
wmm_param->cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
wmm_param->txoplimit = ATH_TXOP_TO_US(wmep->wmep_txopLimit);
wmm_param->acm = wmep->wmep_acm;
wmm_param->no_ack = wmep->wmep_noackPolicy;
buf_ptr += sizeof(wmi_wmm_params);
}
wmi_mtrace(WMI_PDEV_SET_WMM_PARAMS_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_WMM_PARAMS_CMDID);
if (ret != 0) {
WMI_LOGE("Sending WMM update CMD failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* extract_vdev_start_resp_tlv() - extract vdev start response
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param vdev_rsp: Pointer to hold vdev response
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_vdev_start_resp_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_vdev_start_resp *vdev_rsp)
{
WMI_VDEV_START_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_start_response_event_fixed_param *ev;
param_buf = (WMI_VDEV_START_RESP_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
qdf_print("Invalid start response event buffer");
return QDF_STATUS_E_INVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
qdf_print("Invalid start response event buffer");
return QDF_STATUS_E_INVAL;
}
qdf_mem_zero(vdev_rsp, sizeof(*vdev_rsp));
vdev_rsp->vdev_id = ev->vdev_id;
vdev_rsp->requestor_id = ev->requestor_id;
switch (ev->resp_type) {
case WMI_VDEV_START_RESP_EVENT:
vdev_rsp->resp_type = WMI_HOST_VDEV_START_RESP_EVENT;
break;
case WMI_VDEV_RESTART_RESP_EVENT:
vdev_rsp->resp_type = WMI_HOST_VDEV_RESTART_RESP_EVENT;
break;
default:
qdf_print("Invalid start response event buffer");
break;
};
vdev_rsp->status = ev->status;
vdev_rsp->chain_mask = ev->chain_mask;
vdev_rsp->smps_mode = ev->smps_mode;
vdev_rsp->mac_id = ev->mac_id;
vdev_rsp->cfgd_tx_streams = ev->cfgd_tx_streams;
vdev_rsp->cfgd_rx_streams = ev->cfgd_rx_streams;
return QDF_STATUS_SUCCESS;
}
/**
* extract_vdev_delete_resp_tlv() - extract vdev delete response
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param delete_rsp: Pointer to hold vdev delete response
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_vdev_delete_resp_tlv(wmi_unified_t wmi_handle,
void *evt_buf, struct wmi_host_vdev_delete_resp *delete_rsp)
{
WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_delete_resp_event_fixed_param *ev;
param_buf = (WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid vdev delete response event buffer");
return QDF_STATUS_E_INVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
WMI_LOGE("Invalid vdev delete response event");
return QDF_STATUS_E_INVAL;
}
qdf_mem_zero(delete_rsp, sizeof(*delete_rsp));
delete_rsp->vdev_id = ev->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_vdev_stopped_param_tlv() - extract vdev stop param from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param vdev_id: Pointer to hold vdev identifier
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_vdev_stopped_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t *vdev_id)
{
WMI_VDEV_STOPPED_EVENTID_param_tlvs *param_buf;
wmi_vdev_stopped_event_fixed_param *resp_event;
param_buf = (WMI_VDEV_STOPPED_EVENTID_param_tlvs *) evt_buf;
if (!param_buf) {
WMI_LOGE("Invalid event buffer");
return QDF_STATUS_E_INVAL;
}
resp_event = param_buf->fixed_param;
*vdev_id = resp_event->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_mgmt_tx_compl_param_tlv() - extract MGMT tx completion event params
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold MGMT TX completion params
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_mgmt_tx_compl_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_mgmt_tx_compl_event *param)
{
WMI_MGMT_TX_COMPLETION_EVENTID_param_tlvs *param_buf;
wmi_mgmt_tx_compl_event_fixed_param *cmpl_params;
param_buf = (WMI_MGMT_TX_COMPLETION_EVENTID_param_tlvs *)
evt_buf;
if (!param_buf) {
WMI_LOGE("%s: Invalid mgmt Tx completion event", __func__);
return QDF_STATUS_E_INVAL;
}
cmpl_params = param_buf->fixed_param;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
cmpl_params->pdev_id);
param->desc_id = cmpl_params->desc_id;
param->status = cmpl_params->status;
param->ppdu_id = cmpl_params->ppdu_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_chan_info_event_tlv() - extract chan information from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param chan_info: Pointer to hold chan information
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_chan_info_event_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_chan_info_event *chan_info)
{
WMI_CHAN_INFO_EVENTID_param_tlvs *param_buf;
wmi_chan_info_event_fixed_param *ev;
param_buf = (WMI_CHAN_INFO_EVENTID_param_tlvs *) evt_buf;
ev = (wmi_chan_info_event_fixed_param *) param_buf->fixed_param;
if (!ev) {
WMI_LOGE("%s: Failed to allocmemory", __func__);
return QDF_STATUS_E_FAILURE;
}
chan_info->err_code = ev->err_code;
chan_info->freq = ev->freq;
chan_info->cmd_flags = ev->cmd_flags;
chan_info->noise_floor = ev->noise_floor;
chan_info->rx_clear_count = ev->rx_clear_count;
chan_info->cycle_count = ev->cycle_count;
chan_info->tx_frame_cnt = ev->tx_frame_cnt;
chan_info->mac_clk_mhz = ev->mac_clk_mhz;
chan_info->pdev_id = wlan_get_pdev_id_from_vdev_id(
(struct wlan_objmgr_psoc *)wmi_handle->soc->wmi_psoc,
ev->vdev_id, WLAN_SCAN_ID);
chan_info->chan_tx_pwr_range = ev->chan_tx_pwr_range;
chan_info->chan_tx_pwr_tp = ev->chan_tx_pwr_tp;
chan_info->my_bss_rx_cycle_count = ev->my_bss_rx_cycle_count;
chan_info->rx_11b_mode_data_duration = ev->rx_11b_mode_data_duration;
chan_info->tx_frame_cnt = ev->tx_frame_cnt;
chan_info->rx_frame_count = ev->rx_frame_count;
chan_info->mac_clk_mhz = ev->mac_clk_mhz;
chan_info->vdev_id = ev->vdev_id;
return QDF_STATUS_SUCCESS;
}
/**
* extract_channel_hopping_event_tlv() - extract channel hopping param
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param ch_hopping: Pointer to hold channel hopping param
*
* @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/
static QDF_STATUS extract_channel_hopping_event_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_pdev_channel_hopping_event *ch_hopping)
{
WMI_PDEV_CHANNEL_HOPPING_EVENTID_param_tlvs *param_buf;
wmi_pdev_channel_hopping_event_fixed_param *event;
param_buf = (WMI_PDEV_CHANNEL_HOPPING_EVENTID_param_tlvs *)evt_buf;
event = (wmi_pdev_channel_hopping_event_fixed_param *)
param_buf->fixed_param;
ch_hopping->noise_floor_report_iter = event->noise_floor_report_iter;
ch_hopping->noise_floor_total_iter = event->noise_floor_total_iter;
ch_hopping->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
event->pdev_id);
return QDF_STATUS_SUCCESS;
}
void wmi_ap_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_peer_add_wds_entry_cmd = send_peer_add_wds_entry_cmd_tlv;
ops->send_peer_del_wds_entry_cmd = send_peer_del_wds_entry_cmd_tlv;
ops->send_peer_update_wds_entry_cmd =
send_peer_update_wds_entry_cmd_tlv;
ops->send_pdev_get_tpc_config_cmd = send_pdev_get_tpc_config_cmd_tlv;
ops->send_beacon_send_cmd = send_beacon_send_cmd_tlv;
ops->send_set_ctl_table_cmd = send_set_ctl_table_cmd_tlv;
ops->send_set_mimogain_table_cmd = send_set_mimogain_table_cmd_tlv;
ops->send_packet_power_info_get_cmd =
send_packet_power_info_get_cmd_tlv;
ops->send_vdev_config_ratemask_cmd = send_vdev_config_ratemask_cmd_tlv;
ops->send_vdev_set_neighbour_rx_cmd =
send_vdev_set_neighbour_rx_cmd_tlv;
ops->send_nf_dbr_dbm_info_get_cmd = send_nf_dbr_dbm_info_get_cmd_tlv;
ops->send_set_ht_ie_cmd = send_set_ht_ie_cmd_tlv;
ops->send_set_vht_ie_cmd = send_set_vht_ie_cmd_tlv;
ops->send_set_quiet_mode_cmd = send_set_quiet_mode_cmd_tlv;
ops->send_bcn_offload_control_cmd = send_bcn_offload_control_cmd_tlv;
ops->extract_tbttoffset_update_params =
extract_tbttoffset_update_params_tlv;
ops->extract_ext_tbttoffset_update_params =
extract_ext_tbttoffset_update_params_tlv;
ops->extract_tbttoffset_num_vdevs =
extract_tbttoffset_num_vdevs_tlv;
ops->extract_ext_tbttoffset_num_vdevs =
extract_ext_tbttoffset_num_vdevs_tlv;
ops->extract_swba_num_vdevs = extract_swba_num_vdevs_tlv;
ops->extract_swba_tim_info = extract_swba_tim_info_tlv;
ops->extract_swba_noa_info = extract_swba_noa_info_tlv;
ops->extract_offchan_data_tx_compl_param =
extract_offchan_data_tx_compl_param_tlv;
ops->extract_peer_sta_kickout_ev = extract_peer_sta_kickout_ev_tlv;
ops->send_multiple_vdev_restart_req_cmd =
send_multiple_vdev_restart_req_cmd_tlv;
ops->extract_dcs_interference_type = extract_dcs_interference_type_tlv;
ops->extract_dcs_cw_int = extract_dcs_cw_int_tlv;
ops->extract_dcs_im_tgt_stats = extract_dcs_im_tgt_stats_tlv;
ops->extract_peer_delete_response_event =
extract_peer_delete_response_event_tlv;
ops->extract_pdev_csa_switch_count_status =
extract_pdev_csa_switch_count_status_tlv;
ops->extract_pdev_tpc_ev_param = extract_pdev_tpc_ev_param_tlv;
ops->extract_pdev_tpc_config_ev_param =
extract_pdev_tpc_config_ev_param_tlv;
ops->extract_nfcal_power_ev_param = extract_nfcal_power_ev_param_tlv;
ops->extract_wds_addr_event = extract_wds_addr_event_tlv;
ops->extract_peer_sta_ps_statechange_ev =
extract_peer_sta_ps_statechange_ev_tlv;
ops->extract_inst_rssi_stats_event = extract_inst_rssi_stats_event_tlv;
ops->send_pdev_caldata_version_check_cmd =
send_pdev_caldata_version_check_cmd_tlv;
ops->extract_pdev_caldata_version_check_ev_param =
extract_pdev_caldata_version_check_ev_param_tlv;
#ifdef WLAN_SUPPORT_FILS
ops->send_vdev_fils_enable_cmd = send_vdev_fils_enable_cmd_tlv;
ops->extract_swfda_vdev_id = extract_swfda_vdev_id_tlv;
ops->send_fils_discovery_send_cmd = send_fils_discovery_send_cmd_tlv;
#endif /* WLAN_SUPPORT_FILS */
ops->send_set_qboost_param_cmd = send_set_qboost_param_cmd_tlv;
ops->send_gpio_config_cmd = send_gpio_config_cmd_tlv;
ops->send_gpio_output_cmd = send_gpio_output_cmd_tlv;
ops->send_mcast_group_update_cmd = send_mcast_group_update_cmd_tlv;
ops->send_pdev_qvit_cmd = send_pdev_qvit_cmd_tlv;
ops->send_wmm_update_cmd = send_wmm_update_cmd_tlv;
ops->extract_vdev_start_resp = extract_vdev_start_resp_tlv;
ops->extract_vdev_delete_resp = extract_vdev_delete_resp_tlv;
ops->extract_vdev_stopped_param = extract_vdev_stopped_param_tlv;
ops->extract_mgmt_tx_compl_param = extract_mgmt_tx_compl_param_tlv;
ops->extract_chan_info_event = extract_chan_info_event_tlv;
ops->extract_channel_hopping_event = extract_channel_hopping_event_tlv;
}
Reference in New Issue View Git Blame Copy Permalink