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

qcacld-3.0: Adapt wma layer with common wmi layer

Browse Source 
Modify wmi layer API calls with respect to new common wmi layer.
Register all wmi service events using standard wmi event register API.
Remove TLV formation of common API from wma layer.
Pass rx scheduling context of wmi events during event registration.

CRs-Fixed: 976998
Change-Id: Id490db96c28778ec371dd633d43dfa002c08c16a
This commit is contained in:
Govind Singh
2016-03-08 15:12:14 +05:30
parent 3c443556a9
commit d76a5b05cb
13 changed files with 809 additions and 1293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
core/utils/fwlog/dbglog_host.c
View File

@@ -79,11 +79,6 @@ module_dbg_print mod_print[WLAN_MODULE_ID_MAX];
A_UINT32 dbglog_process_type = DBGLOG_PROCESS_NET_RAW;
A_STATUS
wmi_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
A_UINT32 val, A_UINT32 *module_id_bitmap,
A_UINT32 bitmap_len);
const char *dbglog_get_module_str(A_UINT32 module_id)
{
switch (module_id) {
@@ -1284,7 +1279,7 @@ int dbglog_module_log_enable(wmi_unified_t wmi_handle, A_UINT32 mod_id,
/* set it to ERROR level */
WMI_DBGLOG_SET_LOG_LEVEL(val, DBGLOG_ERR);
}
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
wma_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
val, NULL, 0);
return 0;
@@ -1300,7 +1295,7 @@ int dbglog_vap_log_enable(wmi_unified_t wmi_handle, A_UINT16 vap_id,
return -EINVAL;
}
wmi_config_debug_module_cmd(wmi_handle,
wma_config_debug_module_cmd(wmi_handle,
isenable ? WMI_DEBUG_LOG_PARAM_VDEV_ENABLE :
WMI_DEBUG_LOG_PARAM_VDEV_DISABLE, vap_id,
NULL, 0);
@@ -1321,7 +1316,7 @@ int dbglog_set_log_lvl(wmi_unified_t wmi_handle, DBGLOG_LOG_LVL log_lvl)
WMI_DBGLOG_SET_MODULE_ID(val, WMI_DEBUG_LOG_MODULE_ALL);
WMI_DBGLOG_SET_LOG_LEVEL(val, log_lvl);
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
wma_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
val, NULL, 0);
return 0;
@@ -1333,75 +1328,17 @@ int dbglog_set_mod_log_lvl(wmi_unified_t wmi_handle, A_UINT32 mod_log_lvl)
/* set the global module level to log_lvl */
WMI_DBGLOG_SET_MODULE_ID(val, (mod_log_lvl / 10));
WMI_DBGLOG_SET_LOG_LEVEL(val, (mod_log_lvl % 10));
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
wma_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL,
val, NULL, 0);
return 0;
}
A_STATUS
wmi_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
A_UINT32 val, A_UINT32 *module_id_bitmap,
A_UINT32 bitmap_len)
{
wmi_buf_t buf;
wmi_debug_log_config_cmd_fixed_param *configmsg;
A_STATUS status = A_OK;
int i;
int len;
int8_t *buf_ptr;
int32_t *module_id_bitmap_array; /* Used to fomr the second tlv */
ASSERT(bitmap_len < MAX_MODULE_ID_BITMAP_WORDS);
/* Allocate size for 2 tlvs - including tlv hdr space for second tlv */
len = sizeof(wmi_debug_log_config_cmd_fixed_param) + WMI_TLV_HDR_SIZE +
(sizeof(int32_t) * MAX_MODULE_ID_BITMAP_WORDS);
buf = wmi_buf_alloc(wmi_handle, len);
if (buf == NULL)
return A_NO_MEMORY;
configmsg =
(wmi_debug_log_config_cmd_fixed_param *) (wmi_buf_data(buf));
buf_ptr = (int8_t *) configmsg;
WMITLV_SET_HDR(&configmsg->tlv_header,
WMITLV_TAG_STRUC_wmi_debug_log_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_debug_log_config_cmd_fixed_param));
configmsg->dbg_log_param = param;
configmsg->value = val;
/* Filling in the data part of second tlv -- should follow first tlv _ WMI_TLV_HDR_SIZE */
module_id_bitmap_array = (A_UINT32 *) (buf_ptr +
sizeof
(wmi_debug_log_config_cmd_fixed_param)
+ WMI_TLV_HDR_SIZE);
WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param),
WMITLV_TAG_ARRAY_UINT32,
sizeof(A_UINT32) * MAX_MODULE_ID_BITMAP_WORDS);
if (module_id_bitmap) {
for (i = 0; i < bitmap_len; ++i) {
module_id_bitmap_array[i] = module_id_bitmap[i];
}
}
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("wmi_dbg_cfg_send: param 0x%x val 0x%x \n ", param,
val));
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_DBGLOG_CFG_CMDID);
if (status != A_OK)
qdf_nbuf_free(buf);
return status;
}
void
dbglog_set_vap_enable_bitmap(wmi_unified_t wmi_handle,
A_UINT32 vap_enable_bitmap)
{
wmi_config_debug_module_cmd(wmi_handle,
wma_config_debug_module_cmd(wmi_handle,
WMI_DEBUG_LOG_PARAM_VDEV_ENABLE_BITMAP,
vap_enable_bitmap, NULL, 0);
}
@@ -1410,7 +1347,7 @@ void
dbglog_set_mod_enable_bitmap(wmi_unified_t wmi_handle, A_UINT32 log_level,
A_UINT32 *mod_enable_bitmap, A_UINT32 bitmap_len)
{
wmi_config_debug_module_cmd(wmi_handle,
wma_config_debug_module_cmd(wmi_handle,
WMI_DEBUG_LOG_PARAM_MOD_ENABLE_BITMAP,
log_level, mod_enable_bitmap, bitmap_len);
}
@@ -4408,20 +4345,23 @@ int dbglog_init(wmi_unified_t wmi_handle)
res =
wmi_unified_register_event_handler(wmi_handle,
WMI_DEBUG_MESG_EVENTID,
dbglog_parse_debug_logs);
dbglog_parse_debug_logs,
WMA_RX_WORK_CTX);
if (res != 0)
return res;
/* Register handler for FW diag events */
res = wmi_unified_register_event_handler(wmi_handle,
WMI_DIAG_DATA_CONTAINER_EVENTID,
fw_diag_data_event_handler);
fw_diag_data_event_handler,
WMA_RX_SERIALIZER_CTX);
if (res != 0)
return res;
/* Register handler for new FW diag Event, LOG, MSG combined */
res = wmi_unified_register_event_handler(wmi_handle, WMI_DIAG_EVENTID,
diag_fw_handler);
diag_fw_handler,
WMA_RX_SERIALIZER_CTX);
if (res != 0)
return res;

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

@@ -114,6 +114,7 @@
#define ALIGNED_WORD_SIZE 4
#define WLAN_HAL_MSG_TYPE_MAX_ENUM_SIZE 0x7FFF
#define WMA_WILDCARD_PDEV_ID 0x0
/* Prefix used by scan req ids generated on the host */
#define WMA_HOST_SCAN_REQID_PREFIX 0xA000
@@ -452,6 +453,18 @@ enum wma_tdls_peer_reason {
};
#endif /* FEATURE_WLAN_TDLS */
/**
* enum wma_rx_exec_ctx - wma rx execution context
* @WMA_RX_WORK_CTX: work queue context execution
* @WMA_RX_TASKLET_CTX: tasklet context execution
* @WMA_RX_SERIALIZER_CTX: MC thread context execution
*
*/
enum wma_rx_exec_ctx {
WMA_RX_WORK_CTX,
WMA_RX_TASKLET_CTX,
WMA_RX_SERIALIZER_CTX
};
/**
* struct wma_mem_chunk - memory chunks
* @vaddr: virtual address
@@ -1916,8 +1929,7 @@ typedef struct {
void *evt_buf;
} wma_process_fw_event_params;
int wma_process_fw_event_handler(struct wmi_unified *wmi_handle,
wmi_buf_t evt_buf);
int wma_process_fw_event_handler(void *ctx, void *ev, uint8_t rx_ctx);
A_UINT32 e_csr_auth_type_to_rsn_authmode(eCsrAuthType authtype,
eCsrEncryptionType encr);
@@ -1971,7 +1983,7 @@ QDF_STATUS wma_get_scan_id(uint32_t *scan_id);
QDF_STATUS wma_send_soc_set_dual_mac_config(tp_wma_handle wma_handle,
struct sir_dual_mac_config *msg);
int wma_crash_inject(tp_wma_handle wma_handle, uint32_t type,
QDF_STATUS wma_crash_inject(tp_wma_handle wma_handle, uint32_t type,
uint32_t delay_time_ms);
struct wma_target_req *wma_fill_vdev_req(tp_wma_handle wma,
@@ -1997,7 +2009,10 @@ int wma_mgmt_tx_completion_handler(void *handle, uint8_t *cmpl_event_params,
uint32_t len);
void wma_set_dfs_region(tp_wma_handle wma, uint8_t dfs_region);
uint32_t wma_get_vht_ch_width(void);
QDF_STATUS
wma_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
A_UINT32 val, A_UINT32 *module_id_bitmap,
A_UINT32 bitmap_len);
#ifdef FEATURE_LFR_SUBNET_DETECTION
QDF_STATUS wma_set_gateway_params(tp_wma_handle wma,
struct gateway_param_update_req *req);

15
core/wma/inc/wma_api.h
View File

@@ -92,11 +92,11 @@ QDF_STATUS wma_wmi_service_close(void *cds_context);
QDF_STATUS wma_wmi_work_close(void *cds_context);
void wma_rx_ready_event(WMA_HANDLE handle, void *ev);
int wma_rx_ready_event(void *handle, uint8_t *ev, uint32_t len);
void wma_rx_service_ready_event(WMA_HANDLE handle, void *ev);
int wma_rx_service_ready_event(void *handle, uint8_t *ev, uint32_t len);
void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *ev);
int wma_rx_service_ready_ext_event(void *handle, uint8_t *ev, uint32_t len);
void wma_setneedshutdown(void *cds_context);
@@ -120,10 +120,10 @@ QDF_STATUS wma_get_wcnss_software_version(void *p_cds_gctx,
int wma_runtime_suspend(void);
int wma_runtime_resume(void);
int wma_bus_suspend(void);
int wma_suspend_target(WMA_HANDLE handle, int disable_target_intr);
QDF_STATUS wma_suspend_target(WMA_HANDLE handle, int disable_target_intr);
void wma_target_suspend_acknowledge(void *context);
int wma_bus_resume(void);
int wma_resume_target(WMA_HANDLE handle);
QDF_STATUS wma_resume_target(WMA_HANDLE handle);
QDF_STATUS wma_disable_wow_in_fw(WMA_HANDLE handle);
QDF_STATUS wma_disable_d0wow_in_fw(WMA_HANDLE handle);
bool wma_is_wow_mode_selected(WMA_HANDLE handle);
@@ -131,8 +131,9 @@ QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle);
QDF_STATUS wma_enable_d0wow_in_fw(WMA_HANDLE handle);
bool wma_check_scan_in_progress(WMA_HANDLE handle);
void wma_set_peer_authorized_cb(void *wma_ctx, wma_peer_authorized_fp auth_cb);
int wma_set_peer_param(void *wma_ctx, uint8_t *peer_addr, uint32_t param_id,
uint32_t param_value, uint32_t vdev_id);
QDF_STATUS wma_set_peer_param(void *wma_ctx, uint8_t *peer_addr,
uint32_t param_id,
uint32_t param_value, uint32_t vdev_id);
#ifdef NOT_YET
QDF_STATUS wma_update_channel_list(WMA_HANDLE handle, void *scan_chan_info);
#endif

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

@@ -532,10 +532,6 @@ static inline uint8_t *wma_find_bssid_by_vdev_id(tp_wma_handle wma,
void *wma_find_vdev_by_bssid(tp_wma_handle wma, uint8_t *bssid,
uint8_t *vdev_id);
int wma_unified_vdev_create_send(wmi_unified_t wmi_handle, uint8_t if_id,
uint32_t type, uint32_t subtype,
uint8_t macaddr[IEEE80211_ADDR_LEN]);
QDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
struct del_sta_self_params *pdel_sta_self_req_param,
uint8_t generateRsp);
@@ -543,15 +539,9 @@ QDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len);
int wmi_unified_vdev_set_param_send(wmi_unified_t wmi_handle, uint32_t if_id,
QDF_STATUS wma_vdev_set_param(wmi_unified_t wmi_handle, uint32_t if_id,
uint32_t param_id, uint32_t param_value);
int32_t wmi_unified_peer_flush_tids_send(wmi_unified_t wmi,
uint8_t peer_addr
[IEEE80211_ADDR_LEN],
uint32_t peer_tid_bitmap,
uint8_t vdev_id);
void wma_remove_peer(tp_wma_handle wma, uint8_t *bssid,
uint8_t vdev_id, ol_txrx_peer_handle peer,
bool roam_synch_in_progress);
@@ -590,16 +580,10 @@ void wma_remove_vdev_req(tp_wma_handle wma, uint8_t vdev_id,
void wma_add_bss(tp_wma_handle wma, tpAddBssParams params);
int wmi_unified_vdev_up_send(wmi_unified_t wmi,
uint8_t vdev_id, uint16_t aid,
uint8_t bssid[IEEE80211_ADDR_LEN]);
void wma_add_sta(tp_wma_handle wma, tpAddStaParams add_sta);
void wma_delete_sta(tp_wma_handle wma, tpDeleteStaParams del_sta);
int32_t wmi_unified_vdev_stop_send(wmi_unified_t wmi, uint8_t vdev_id);
void wma_delete_bss(tp_wma_handle wma, tpDeleteBssParams params);
int32_t wma_find_vdev_by_type(tp_wma_handle wma, int32_t type);
@@ -693,14 +677,14 @@ void wma_hidden_ssid_vdev_restart(tp_wma_handle wma_handle,
void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req);
int32_t wmi_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
QDF_STATUS wma_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
uint32_t vdev_id, uint32_t param,
uint32_t value);
QDF_STATUS
wma_set_ibss_pwrsave_params(tp_wma_handle wma, uint8_t vdev_id);
int32_t wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
QDF_STATUS wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
uint8_t *peer_addr, uint8_t uapsd_value,
uint8_t max_sp);
@@ -713,9 +697,6 @@ void wma_set_tx_power(WMA_HANDLE handle,
void wma_set_max_tx_power(WMA_HANDLE handle,
tMaxTxPowerParams *tx_pwr_params);
int32_t wmi_unified_set_sta_ps(wmi_unified_t wmi_handle,
uint32_t vdev_id, uint8_t val);
void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req);
void wma_enable_uapsd_mode(tp_wma_handle wma, tpEnableUapsdParams ps_req);
@@ -880,9 +861,6 @@ int32_t wma_txrx_fw_stats_reset(tp_wma_handle wma_handle,
int32_t wma_set_txrx_fw_stats_level(tp_wma_handle wma_handle,
uint8_t vdev_id, uint32_t value);
int wmi_crash_inject(wmi_unified_t wmi_handle, uint32_t type,
uint32_t delay_time_ms);
void wma_get_stats_req(WMA_HANDLE handle,
tAniGetPEStatsReq *get_stats_param);
@@ -917,11 +895,6 @@ WLAN_PHY_MODE wma_chan_to_mode(u8 chan, phy_ch_width chan_width,
QDF_STATUS wma_get_link_speed(WMA_HANDLE handle, tSirLinkSpeedInfo *pLinkSpeed);
#ifdef FEATURE_GREEN_AP
int32_t wmi_unified_pdev_green_ap_ps_enable_cmd(wmi_unified_t wmi_handle,
uint32_t value);
#endif
int wma_profile_data_report_event_handler(void *handle, uint8_t *event_buf,
uint32_t len);
@@ -932,7 +905,7 @@ void wma_wow_tx_complete(void *wma);
int wmi_unified_nat_keepalive_enable(tp_wma_handle wma, uint8_t vdev_id);
int wmi_unified_csa_offload_enable(tp_wma_handle wma, uint8_t vdev_id);
int wma_unified_csa_offload_enable(tp_wma_handle wma, uint8_t vdev_id);
#ifdef WLAN_FEATURE_NAN
int wma_nan_rsp_event_handler(void *handle, uint8_t *event_buf, uint32_t len);
@@ -1104,7 +1077,7 @@ QDF_STATUS wma_process_ch_avoid_update_req(tp_wma_handle wma_handle,
ch_avoid_update_req);
#endif
int wma_suspend_target(WMA_HANDLE handle, int disable_target_intr);
QDF_STATUS wma_suspend_target(WMA_HANDLE handle, int disable_target_intr);
#ifdef FEATURE_WLAN_TDLS

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

@@ -788,7 +788,7 @@ int32_t wmi_unified_send_txbf(tp_wma_handle wma, tpAddStaParams params)
WMA_LOGD("txbf_en.sutxbfee %d txbf_en.mutxbfee %d, sutxbfer %d",
txbf_en.sutxbfee, txbf_en.mutxbfee, txbf_en.sutxbfer);
return wmi_unified_vdev_set_param_send(wma->wmi_handle,
return wma_vdev_set_param(wma->wmi_handle,
params->smesessionId,
WMI_VDEV_PARAM_TXBF,
*((A_UINT8 *) &txbf_en));
@@ -1403,6 +1403,7 @@ QDF_STATUS wma_process_rate_update_indicate(tp_wma_handle wma,
uint8_t rate = 0;
uint32_t short_gi;
struct wma_txrx_node *intr = wma->interfaces;
QDF_STATUS status;
/* Get the vdev id */
pdev = wma_find_vdev_by_addr(wma, pRateUpdateParams->bssid.bytes,
@@ -1449,20 +1450,20 @@ QDF_STATUS wma_process_rate_update_indicate(tp_wma_handle wma,
qdf_mem_free(pRateUpdateParams);
return ret;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
status = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_SGI, short_gi);
if (ret) {
WMA_LOGE("%s: Failed to Set WMI_VDEV_PARAM_SGI (%d), ret = %d",
__func__, short_gi, ret);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s: Failed to Set WMI_VDEV_PARAM_SGI (%d), status = %d",
__func__, short_gi, status);
qdf_mem_free(pRateUpdateParams);
return QDF_STATUS_E_FAILURE;
return status;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
status = wma_vdev_set_param(wma->wmi_handle,
vdev_id, paramId, rate);
qdf_mem_free(pRateUpdateParams);
if (ret) {
WMA_LOGE("%s: Failed to Set rate, ret = %d", __func__, ret);
return QDF_STATUS_E_FAILURE;
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s: Failed to Set rate, status = %d", __func__, status);
return status;
}
return QDF_STATUS_SUCCESS;
@@ -2965,6 +2966,7 @@ void wma_tx_abort(uint8_t vdev_id)
tp_wma_handle wma;
uint32_t peer_tid_bitmap = PEER_ALL_TID_BITMASK;
struct wma_txrx_node *iface;
struct peer_flush_params param = {0};
wma = cds_get_context(QDF_MODULE_ID_WMA);
if (NULL == wma) {
@@ -2984,8 +2986,10 @@ void wma_tx_abort(uint8_t vdev_id)
/* Flush all TIDs except MGMT TID for this peer in Target */
peer_tid_bitmap &= ~(0x1 << WMI_MGMT_TID);
param.peer_tid_bitmap = peer_tid_bitmap;
param.vdev_id = vdev_id;
wmi_unified_peer_flush_tids_send(wma->wmi_handle, iface->bssid,
peer_tid_bitmap, vdev_id);
&param);
}
#if defined(FEATURE_LRO)

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

@@ -211,86 +211,6 @@ enum wlan_op_mode wma_get_txrx_vdev_type(uint32_t type)
return vdev_type;
}
/**
* wma_unified_vdev_create_send() - send VDEV create command to fw
* @wmi_handle: wmi handle
* @if_id: vdev id
* @type: vdev type
* @subtype: vdev subtype
* @macaddr: vdev mac address
*
* Return: 0 for success or error code
*/
int wma_unified_vdev_create_send(wmi_unified_t wmi_handle, uint8_t if_id,
uint32_t type, uint32_t subtype,
uint8_t macaddr[IEEE80211_ADDR_LEN])
{
wmi_vdev_create_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
int ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGP("%s:wmi_buf_alloc failed", __FUNCTION__);
return -ENOMEM;
}
cmd = (wmi_vdev_create_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_create_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_vdev_create_cmd_fixed_param));
cmd->vdev_id = if_id;
cmd->vdev_type = type;
cmd->vdev_subtype = subtype;
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
WMA_LOGE("%s: ID = %d VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x",
__func__, if_id,
macaddr[0], macaddr[1], macaddr[2],
macaddr[3], macaddr[4], macaddr[5]);
ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_CREATE_CMDID);
if (ret != EOK) {
WMA_LOGE("Failed to send WMI_VDEV_CREATE_CMDID");
wmi_buf_free(buf);
}
return ret;
}
/**
* wma_unified_vdev_delete_send() - send VDEV delete command to fw
* @wmi_handle: wmi handle
* @if_id: vdev id
*
* Return: 0 for success or error code
*/
static int wma_unified_vdev_delete_send(wmi_unified_t wmi_handle, uint8_t if_id)
{
wmi_vdev_delete_cmd_fixed_param *cmd;
wmi_buf_t buf;
int ret;
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
WMA_LOGP("%s:wmi_buf_alloc failed", __FUNCTION__);
return -ENOMEM;
}
cmd = (wmi_vdev_delete_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_delete_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_vdev_delete_cmd_fixed_param));
cmd->vdev_id = if_id;
ret = wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_vdev_delete_cmd_fixed_param),
WMI_VDEV_DELETE_CMDID);
if (ret != EOK) {
WMA_LOGE("Failed to send WMI_VDEV_DELETE_CMDID");
wmi_buf_free(buf);
}
return ret;
}
/**
* wma_find_req() - find target request for vdev id
* @wma: wma handle
@@ -606,9 +526,9 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
struct wma_target_req *msg = NULL;
cds_msg_t sme_msg = { 0 };
if (wma_unified_vdev_delete_send(wma_handle->wmi_handle, vdev_id)) {
status = wmi_unified_vdev_delete_send(wma_handle->wmi_handle, vdev_id);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("Unable to remove an interface");
status = QDF_STATUS_E_FAILURE;
goto out;
}
@@ -720,45 +640,6 @@ QDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
return status;
}
/**
* wmi_unified_peer_delete_send() - send PEER delete command to fw
* @wmi: wmi handle
* @peer_addr: peer mac addr
* @vdev_id: vdev id
*
* Return: 0 for success or error code
*/
static int32_t wmi_unified_peer_delete_send(wmi_unified_t wmi,
uint8_t
peer_addr[IEEE80211_ADDR_LEN],
uint8_t vdev_id)
{
wmi_peer_delete_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_peer_delete_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_delete_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_delete_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->vdev_id = vdev_id;
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) {
WMA_LOGP("%s: Failed to send peer delete command", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
WMA_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id);
return 0;
}
/**
* wma_vdev_start_rsp() - send vdev start response to upper layer
* @wma: wma handle
@@ -905,6 +786,9 @@ int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
wmi_vdev_start_response_event_fixed_param *resp_event;
struct wma_target_req *req_msg;
struct wma_txrx_node *iface;
struct vdev_up_params param = {0};
QDF_STATUS status;
#ifdef FEATURE_AP_MCC_CH_AVOIDANCE
tpAniSirGlobal mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
if (NULL == mac_ctx) {
@@ -957,9 +841,12 @@ int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
WMA_LOGE("%s: vdev restart event recevied for hidden ssid set using IOCTL",
__func__);
param.vdev_id = resp_event->vdev_id;
param.assoc_id = 0;
if (wmi_unified_vdev_up_send
(wma->wmi_handle, resp_event->vdev_id, 0,
wma->interfaces[resp_event->vdev_id].bssid) < 0) {
(wma->wmi_handle,
wma->interfaces[resp_event->vdev_id].bssid,
&param) != QDF_STATUS_SUCCESS) {
WMA_LOGE("%s : failed to send vdev up", __func__);
return -EEXIST;
}
@@ -1007,10 +894,12 @@ int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
params->status = resp_event->status;
if (resp_event->resp_type == WMI_VDEV_RESTART_RESP_EVENT &&
(iface->type == WMI_VDEV_TYPE_STA)) {
if (wmi_unified_vdev_up_send(wma->wmi_handle,
resp_event->vdev_id,
iface->aid,
iface->bssid)) {
param.vdev_id = resp_event->vdev_id;
param.assoc_id = iface->aid;
status = wmi_unified_vdev_up_send(wma->wmi_handle,
iface->bssid,
&param);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s:vdev_up failed vdev_id %d",
__func__, resp_event->vdev_id);
wma->interfaces[resp_event->vdev_id].vdev_up =
@@ -1028,9 +917,11 @@ int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
IEEE80211_ADDR_LEN);
wma_vdev_start_rsp(wma, bssParams, resp_event);
} else if (req_msg->msg_type == WMA_OCB_SET_CONFIG_CMD) {
param.vdev_id = resp_event->vdev_id;
param.assoc_id = iface->aid;
if (wmi_unified_vdev_up_send(wma->wmi_handle,
resp_event->vdev_id, iface->aid,
iface->bssid) < 0) {
iface->bssid,
&param) != QDF_STATUS_SUCCESS) {
WMA_LOGE(FL("failed to send vdev up"));
return -EEXIST;
}
@@ -1050,86 +941,24 @@ int wma_vdev_start_resp_handler(void *handle, uint8_t *cmd_param_info,
}
/**
* wmi_unified_vdev_set_param_send() - set per vdev params in fw
* wma_vdev_set_param() - set per vdev params in fw
* @wmi_handle: wmi handle
* @if_if: vdev id
* @param_id: parameter id
* @param_value: parameter value
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int
wmi_unified_vdev_set_param_send(wmi_unified_t wmi_handle, uint32_t if_id,
QDF_STATUS
wma_vdev_set_param(wmi_unified_t wmi_handle, uint32_t if_id,
uint32_t param_id, uint32_t param_value)
{
int ret;
wmi_vdev_set_param_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint16_t len = sizeof(*cmd);
struct vdev_set_params param = {0};
param.if_id = if_id;
param.param_id = param_id;
param.param_value = param_value;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_vdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_set_param_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_vdev_set_param_cmd_fixed_param));
cmd->vdev_id = if_id;
cmd->param_id = param_id;
cmd->param_value = param_value;
WMA_LOGD("Setting vdev %d param = %x, value = %u",
if_id, param_id, param_value);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_SET_PARAM_CMDID);
if (ret < 0) {
WMA_LOGE("Failed to send set param command ret = %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw
* @wmi: wmi handle
* @peer_addr: peer mac address
* @peer_tid_bitmap: peer tid bitmap
* @vdev_id: vdev id
*
* Return: 0 for sucess or error code
*/
int32_t wmi_unified_peer_flush_tids_send(wmi_unified_t wmi,
uint8_t peer_addr[IEEE80211_ADDR_LEN],
uint32_t peer_tid_bitmap,
uint8_t vdev_id)
{
wmi_peer_flush_tids_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_peer_flush_tids_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_flush_tids_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_flush_tids_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->peer_tid_bitmap = peer_tid_bitmap;
cmd->vdev_id = vdev_id;
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) {
WMA_LOGP("%s: Failed to send flush tid command", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
WMA_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id);
return 0;
return wmi_unified_vdev_set_param_send(wmi_handle, &param);
}
/**
@@ -1153,39 +982,24 @@ void wma_set_peer_authorized_cb(void *wma_ctx, wma_peer_authorized_fp auth_cb)
* @param_value: parameter value
* @vdev_id: vdev id
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int wma_set_peer_param(void *wma_ctx, uint8_t *peer_addr, uint32_t param_id,
uint32_t param_value, uint32_t vdev_id)
QDF_STATUS wma_set_peer_param(void *wma_ctx, uint8_t *peer_addr,
uint32_t param_id, uint32_t param_value,
uint32_t vdev_id)
{
tp_wma_handle wma_handle = (tp_wma_handle) wma_ctx;
wmi_peer_set_param_cmd_fixed_param *cmd;
wmi_buf_t buf;
struct peer_set_params param = {0};
int err;
buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
if (!buf) {
WMA_LOGE("Failed to allocate buffer to send set_param cmd");
return -ENOMEM;
}
cmd = (wmi_peer_set_param_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_set_param_cmd_fixed_param));
cmd->vdev_id = vdev_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->param_id = param_id;
cmd->param_value = param_value;
err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
sizeof(wmi_peer_set_param_cmd_fixed_param),
WMI_PEER_SET_PARAM_CMDID);
if (err) {
WMA_LOGE("Failed to send set_param cmd");
qdf_mem_free(buf);
return -EIO;
}
return 0;
param.vdev_id = vdev_id;
param.param_value = param_value;
param.param_id = param_id;
err = wmi_set_peer_param_send(wma_handle->wmi_handle, peer_addr,
&param);
return err;
}
/**
@@ -1205,6 +1019,8 @@ void wma_remove_peer(tp_wma_handle wma, uint8_t *bssid,
#define PEER_ALL_TID_BITMASK 0xffffffff
uint32_t peer_tid_bitmap = PEER_ALL_TID_BITMASK;
uint8_t *peer_addr = bssid;
struct peer_flush_params param = {0};
if (!wma->interfaces[vdev_id].peer_count) {
WMA_LOGE("%s: Can't remove peer with peer_addr %pM vdevid %d peer_count %d",
__func__, bssid, vdev_id,
@@ -1221,8 +1037,10 @@ void wma_remove_peer(tp_wma_handle wma, uint8_t *bssid,
return;
/* Flush all TIDs except MGMT TID for this peer in Target */
peer_tid_bitmap &= ~(0x1 << WMI_MGMT_TID);
param.peer_tid_bitmap = peer_tid_bitmap;
param.vdev_id = vdev_id;
wmi_unified_peer_flush_tids_send(wma->wmi_handle, bssid,
peer_tid_bitmap, vdev_id);
&param);
if ((peer) && (wma_is_vdev_in_ibss_mode(wma, vdev_id))) {
WMA_LOGD("%s: bssid %pM peer->mac_addr %pM", __func__,
@@ -1234,46 +1052,6 @@ void wma_remove_peer(tp_wma_handle wma, uint8_t *bssid,
#undef PEER_ALL_TID_BITMASK
}
/**
* wmi_unified_peer_create_send() - send peer create command to fw
* @wmi: wmi handle
* @peer_addr: peer mac address
* @peer_type: peer type
* @vdev_id: vdev id
*
* Return: 0 for success or error code
*/
static int wmi_unified_peer_create_send(wmi_unified_t wmi,
const uint8_t *peer_addr,
uint32_t peer_type, uint32_t vdev_id)
{
wmi_peer_create_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_peer_create_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_create_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_create_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->peer_type = peer_type;
cmd->vdev_id = vdev_id;
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CREATE_CMDID)) {
WMA_LOGP("%s: failed to send WMI_PEER_CREATE_CMDID", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
WMA_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id);
return 0;
}
/**
* wma_create_peer() - send peer create command to fw
* @wma: wma handle
@@ -1293,6 +1071,7 @@ QDF_STATUS wma_create_peer(tp_wma_handle wma, ol_txrx_pdev_handle pdev,
bool roam_synch_in_progress)
{
ol_txrx_peer_handle peer;
struct peer_create_params param = {0};
if (++wma->interfaces[vdev_id].peer_count >
wma->wlan_resource_config.num_peers) {
@@ -1312,8 +1091,11 @@ QDF_STATUS wma_create_peer(tp_wma_handle wma, ol_txrx_pdev_handle pdev,
wma->interfaces[vdev_id].peer_count);
return QDF_STATUS_SUCCESS;
}
if (wmi_unified_peer_create_send(wma->wmi_handle, peer_addr,
peer_type, vdev_id) < 0) {
param.peer_addr = peer_addr;
param.peer_type = peer_type;
param.vdev_id = vdev_id;
if (wmi_unified_peer_create_send(wma->wmi_handle,
&param) != QDF_STATUS_SUCCESS) {
WMA_LOGP("%s : Unable to create peer in Target", __func__);
ol_txrx_peer_detach(peer);
goto err;
@@ -1344,38 +1126,6 @@ err:
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_unified_vdev_down_send() - send vdev down command to fw
* @wmi: wmi handle
* @vdev_id: vdev id
*
* Return: 0 for success or error code
*/
static int wmi_unified_vdev_down_send(wmi_unified_t wmi, uint8_t vdev_id)
{
wmi_vdev_down_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s : wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_vdev_down_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_down_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_down_cmd_fixed_param));
cmd->vdev_id = vdev_id;
if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_DOWN_CMDID)) {
WMA_LOGP("%s: Failed to send vdev down", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
WMA_LOGE("%s: vdev_id %d", __func__, vdev_id);
return 0;
}
#ifdef QCA_IBSS_SUPPORT
/**
@@ -1753,8 +1503,9 @@ int wma_vdev_stop_resp_handler(void *handle, uint8_t *cmd_param_info,
peer, false);
}
if (wmi_unified_vdev_down_send
(wma->wmi_handle, resp_event->vdev_id) < 0) {
if (wmi_unified_vdev_down_send(wma->wmi_handle,
resp_event->vdev_id) !=
QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to send vdev down cmd: vdev %d",
resp_event->vdev_id);
} else {
@@ -1841,24 +1592,27 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
uint32_t cfg_val;
uint16_t val16;
int ret;
QDF_STATUS ret;
tSirMacHTCapabilityInfo *phtCapInfo;
cds_msg_t sme_msg = { 0 };
struct vdev_create_params params = { 0 };
if (NULL == mac) {
WMA_LOGE("%s: Failed to get mac", __func__);
goto end;
}
params.if_id = self_sta_req->session_id;
params.type = self_sta_req->type;
params.subtype = self_sta_req->sub_type;
/* Create a vdev in target */
if (wma_unified_vdev_create_send(wma_handle->wmi_handle,
self_sta_req->session_id,
self_sta_req->type,
self_sta_req->sub_type,
self_sta_req->self_mac_addr)) {
status = wmi_unified_vdev_create_send(wma_handle->wmi_handle,
self_sta_req->self_mac_addr,
&params);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGP("%s: Unable to add an interface for ath_dev",
__func__);
status = QDF_STATUS_E_RESOURCES;
goto end;
}
@@ -1866,7 +1620,7 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if (wlan_op_mode_unknown == txrx_vdev_type) {
WMA_LOGE("Failed to get txrx vdev type");
wma_unified_vdev_delete_send(wma_handle->wmi_handle,
wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
self_sta_req->session_id);
goto end;
}
@@ -1883,7 +1637,7 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if (NULL == txrx_vdev_handle) {
WMA_LOGP("%s: ol_txrx_vdev_attach failed", __func__);
status = QDF_STATUS_E_FAILURE;
wma_unified_vdev_delete_send(wma_handle->wmi_handle,
wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
self_sta_req->session_id);
goto end;
}
@@ -1958,32 +1712,32 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("%s: Failed to create peer", __func__);
status = QDF_STATUS_E_FAILURE;
wma_unified_vdev_delete_send(wma_handle->wmi_handle,
wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
self_sta_req->session_id);
}
}
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_MCC_RTSCTS_PROTECTION_ENABLE,
mac->roam.configParam.mcc_rts_cts_prot_enable);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI VDEV MCC_RTSCTS_PROTECTION_ENABLE");
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_MCC_BROADCAST_PROBE_ENABLE,
mac->roam.configParam.mcc_bcast_prob_resp_enable);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI VDEV MCC_BROADCAST_PROBE_ENABLE");
if (wlan_cfg_get_int(mac, WNI_CFG_RTS_THRESHOLD,
&cfg_val) == eSIR_SUCCESS) {
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_RTS_THRESHOLD,
cfg_val);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI_VDEV_PARAM_RTS_THRESHOLD");
} else {
WMA_LOGE("Failed to get value for WNI_CFG_RTS_THRESHOLD, leaving unchanged");
@@ -1991,11 +1745,11 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if (wlan_cfg_get_int(mac, WNI_CFG_FRAGMENTATION_THRESHOLD,
&cfg_val) == eSIR_SUCCESS) {
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
cfg_val);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD");
} else {
WMA_LOGE("Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD, leaving unchanged");
@@ -2004,11 +1758,11 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if (wlan_cfg_get_int(mac, WNI_CFG_HT_CAP_INFO, &cfg_val) == eSIR_SUCCESS) {
val16 = (uint16_t) cfg_val;
phtCapInfo = (tSirMacHTCapabilityInfo *) &cfg_val;
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_TX_STBC,
phtCapInfo->txSTBC);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI_VDEV_PARAM_TX_STBC");
} else {
WMA_LOGE("Failed to get value of HT_CAP, TX STBC unchanged");
@@ -2017,11 +1771,13 @@ ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
if ((self_sta_req->type == WMI_VDEV_TYPE_STA) &&
(self_sta_req->sub_type == 0)) {
wma_handle->roam_offload_enabled = true;
wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
self_sta_req->session_id,
WMI_VDEV_PARAM_ROAM_FW_OFFLOAD,
(WMI_ROAM_FW_OFFLOAD_ENABLE_FLAG |
WMI_ROAM_BMISS_FINAL_SCAN_ENABLE_FLAG));
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set WMI_VDEV_PARAM_ROAM_FW_OFFLOAD");
}
/* Initialize BMISS parameters */
@@ -2761,7 +2517,7 @@ void wma_vdev_resp_timer(void *data)
}
if (wmi_unified_vdev_down_send(wma->wmi_handle,
tgt_req->vdev_id) < 0) {
tgt_req->vdev_id) != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to send vdev down cmd: vdev %d",
tgt_req->vdev_id);
} else {
@@ -2995,37 +2751,37 @@ wma_vdev_set_bss_params(tp_wma_handle wma, int vdev_id,
uint8_t dtimPeriod, uint8_t shortSlotTimeSupported,
uint8_t llbCoexist, int8_t maxTxPower)
{
int ret;
QDF_STATUS ret;
uint32_t slot_time;
struct wma_txrx_node *intr = wma->interfaces;
/* Beacon Interval setting */
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_BEACON_INTERVAL,
beaconInterval);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("failed to set WMI_VDEV_PARAM_BEACON_INTERVAL");
ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle, vdev_id,
&intr[vdev_id].config.gtx_info);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("failed to set WMI_VDEV_PARAM_DTIM_PERIOD");
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_DTIM_PERIOD,
dtimPeriod);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("failed to set WMI_VDEV_PARAM_DTIM_PERIOD");
if (!maxTxPower) {
WMA_LOGW("Setting Tx power limit to 0");
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TX_PWRLIMIT,
maxTxPower);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("failed to set WMI_VDEV_PARAM_TX_PWRLIMIT");
else
intr[vdev_id].max_tx_power = maxTxPower;
@@ -3036,10 +2792,10 @@ wma_vdev_set_bss_params(tp_wma_handle wma, int vdev_id,
else
slot_time = WMI_VDEV_SLOT_TIME_LONG;
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_SLOT_TIME,
slot_time);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("failed to set WMI_VDEV_PARAM_SLOT_TIME");
/* Initialize protection mode in case of coexistence */
@@ -3063,8 +2819,9 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
uint8_t vdev_id, peer_id;
QDF_STATUS status;
int8_t maxTxPower;
struct pdev_params param = {0};
#ifdef WLAN_FEATURE_11W
int ret = 0;
QDF_STATUS ret;
#endif /* WLAN_FEATURE_11W */
struct sir_hw_mode_params hw_mode = {0};
@@ -3128,9 +2885,11 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
* when 802.11w PMF is enabled for hw encr/decr
* use hw MFP Qos bits 0x10
*/
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_PMF_QOS, true);
if (ret) {
param.param_id = WMI_PDEV_PARAM_PMF_QOS;
param.param_value = true;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&param, WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("%s: Failed to set QOS MFP/PMF (%d)",
__func__, ret);
} else {
@@ -3365,11 +3124,11 @@ static void wma_add_bss_ibss_mode(tp_wma_handle wma, tpAddBssParams add_bss)
WMA_LOGD("%s: vdev start request for IBSS sent to target", __func__);
/* Initialize protection mode to no protection */
if (wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_PROTECTION_MODE,
IEEE80211_PROT_NONE)) {
status = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_PROTECTION_MODE,
IEEE80211_PROT_NONE);
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to initialize protection mode");
}
return;
@@ -3399,12 +3158,12 @@ static void wma_add_bss_sta_mode(tp_wma_handle wma, tpAddBssParams add_bss)
ol_txrx_peer_handle peer;
QDF_STATUS status;
struct wma_txrx_node *iface;
int ret = 0;
int pps_val = 0;
bool roam_synch_in_progress = false;
tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
struct sir_hw_mode_params hw_mode = {0};
bool peer_assoc_sent = false;
struct pdev_params param = {0};
if (NULL == pMac) {
WMA_LOGE("%s: Unable to get PE context", __func__);
@@ -3596,14 +3355,14 @@ static void wma_add_bss_sta_mode(tp_wma_handle wma, tpAddBssParams add_bss)
((pMac->
enable5gEBT << 31) & 0xffff0000) | (PKT_PWR_SAVE_5G_EBT &
0xffff);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
status = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_PACKET_POWERSAVE,
pps_val);
if (ret)
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to send wmi packet power save cmd");
else
WMA_LOGD("Sent PKT_PWR_SAVE_5G_EBT cmd to target, val = %x, ret = %d",
pps_val, ret);
WMA_LOGD("Sent PKT_PWR_SAVE_5G_EBT cmd to target, val = %x, status = %d",
pps_val, status);
wmi_unified_send_peer_assoc(wma, add_bss->nwType,
&add_bss->staContext);
@@ -3612,12 +3371,14 @@ static void wma_add_bss_sta_mode(tp_wma_handle wma, tpAddBssParams add_bss)
if (add_bss->rmfEnabled) {
/* when 802.11w PMF is enabled for hw encr/decr
use hw MFP Qos bits 0x10 */
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_PMF_QOS,
true);
if (ret) {
param.param_id = WMI_PDEV_PARAM_PMF_QOS;
param.param_value = true;
status = wmi_unified_pdev_param_send(wma->wmi_handle,
&param,
WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s: Failed to set QOS MFP/PMF (%d)",
__func__, ret);
__func__, status);
} else {
WMA_LOGI("%s: QOS MFP/PMF set to %d",
__func__, true);
@@ -3724,46 +3485,6 @@ void wma_add_bss(tp_wma_handle wma, tpAddBssParams params)
}
}
/**
* wmi_unified_vdev_up_send() - send vdev up command in fw
* @wmi: wmi handle
* @vdev_id: vdev id
* @aid: association ID
* @bssid: bssid
*
* Return: 0 for success or error code
*/
int wmi_unified_vdev_up_send(wmi_unified_t wmi,
uint8_t vdev_id, uint16_t aid,
uint8_t bssid[IEEE80211_ADDR_LEN])
{
wmi_vdev_up_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMA_LOGD("%s: VDEV_UP", __func__);
WMA_LOGD("%s: vdev_id %d aid %d bssid %pM", __func__,
vdev_id, aid, bssid);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_vdev_up_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_up_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_up_cmd_fixed_param));
cmd->vdev_id = vdev_id;
cmd->vdev_assoc_id = aid;
WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid, &cmd->vdev_bssid);
if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_UP_CMDID)) {
WMA_LOGP("%s: Failed to send vdev up command", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
return 0;
}
/**
* wma_add_sta_req_ap_mode() - process add sta request in ap mode
* @wma: wma handle
@@ -3783,6 +3504,7 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
struct wma_txrx_node *iface = NULL;
struct wma_target_req *msg;
bool peer_assoc_cnf = false;
struct pdev_params param;
pdev = cds_get_context(QDF_MODULE_ID_TXRX);
@@ -3915,11 +3637,13 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
* when 802.11w PMF is enabled for hw encr/decr
* use hw MFP Qos bits 0x10
*/
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_PMF_QOS, true);
if (ret) {
param.param_id = WMI_PDEV_PARAM_PMF_QOS;
param.param_value = true;
status = wmi_unified_pdev_param_send(wma->wmi_handle,
&param, WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s: Failed to set QOS MFP/PMF (%d)",
__func__, ret);
__func__, status);
} else {
WMA_LOGI("%s: QOS MFP/PMF set to %d", __func__, true);
}
@@ -3927,10 +3651,10 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
#endif /* WLAN_FEATURE_11W */
if (add_sta->uAPSD) {
ret = wma_set_ap_peer_uapsd(wma, add_sta->smesessionId,
status = wma_set_ap_peer_uapsd(wma, add_sta->smesessionId,
add_sta->staMac,
add_sta->uAPSD, add_sta->maxSPLen);
if (ret) {
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("Failed to set peer uapsd param for %pM",
add_sta->staMac);
add_sta->status = QDF_STATUS_E_FAILURE;
@@ -4124,6 +3848,8 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
int ret = 0;
struct wma_target_req *msg;
bool peer_assoc_cnf = false;
struct vdev_up_params param = {0};
struct pdev_params pdev_param = {0};
#ifdef FEATURE_WLAN_TDLS
if (STA_ENTRY_TDLS_PEER == params->staType) {
@@ -4233,12 +3959,14 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
if (params->rmfEnabled) {
/* when 802.11w PMF is enabled for hw encr/decr
use hw MFP Qos bits 0x10 */
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_PMF_QOS,
true);
if (ret) {
pdev_param.param_id = WMI_PDEV_PARAM_PMF_QOS;
pdev_param.param_value = true;
status = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdev_param,
WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s: Failed to set QOS MFP/PMF (%d)",
__func__, ret);
__func__, status);
} else {
WMA_LOGI("%s: QOS MFP/PMF set to %d",
__func__, true);
@@ -4269,7 +3997,7 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
WMI_SERVICE_CSA_OFFLOAD)) {
params->csaOffloadEnable = 1;
if (wmi_unified_csa_offload_enable(wma, params->smesessionId) <
if (wma_unified_csa_offload_enable(wma, params->smesessionId) <
0) {
WMA_LOGE("Unable to enable CSA offload for vdev_id:%d",
params->smesessionId);
@@ -4285,8 +4013,10 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
}
}
if (wmi_unified_vdev_up_send(wma->wmi_handle, params->smesessionId,
params->assocId, params->bssId) < 0) {
param.vdev_id = params->smesessionId;
param.assoc_id = params->assocId;
if (wmi_unified_vdev_up_send(wma->wmi_handle, params->bssId,
&param) != QDF_STATUS_SUCCESS) {
WMA_LOGP("%s: Failed to send vdev up cmd: vdev %d bssid %pM",
__func__, params->smesessionId, params->bssId);
status = QDF_STATUS_E_FAILURE;
@@ -4592,37 +4322,6 @@ void wma_delete_sta(tp_wma_handle wma, tpDeleteStaParams del_sta)
}
}
/**
* wmi_unified_vdev_stop_send() - send vdev stop command to fw
* @wmi: wmi handle
* @vdev_id: vdev id
*
* Return: 0 for success or erro code
*/
int32_t wmi_unified_vdev_stop_send(wmi_unified_t wmi, uint8_t vdev_id)
{
wmi_vdev_stop_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf) {
WMA_LOGP("%s : wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_vdev_stop_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_stop_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_stop_cmd_fixed_param));
cmd->vdev_id = vdev_id;
if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_STOP_CMDID)) {
WMA_LOGP("%s: Failed to send vdev stop command", __func__);
qdf_nbuf_free(buf);
return -EIO;
}
return 0;
}
/**
* wma_delete_bss() - process delete bss request from upper layer
* @wma: wma handle

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

@@ -1079,15 +1079,16 @@ void wma_setup_egap_support(struct wma_tgt_cfg *tgt_cfg, WMA_HANDLE handle)
void wma_register_egap_event_handle(WMA_HANDLE handle)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
int status;
QDF_STATUS status;
if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
WMI_SERVICE_EGAP)) {
status = wmi_unified_register_event_handler(
wma_handle->wmi_handle,
WMI_AP_PS_EGAP_INFO_EVENTID,
wma_egap_info_status_event);
if (status) {
wma_egap_info_status_event,
WMA_RX_SERIALIZER_CTX);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("Failed to register Enhance Green AP event");
wma_handle->egap_support = false;
} else {
@@ -1097,45 +1098,6 @@ void wma_register_egap_event_handle(WMA_HANDLE handle)
} else
wma_handle->egap_support = false;
}
/**
* wmi_unified_pdev_green_ap_ps_enable_cmd() - enable green ap powersave command
* @wmi_handle: wmi handle
* @value: value
*
* Return: 0 for success or error code
*/
int32_t wmi_unified_pdev_green_ap_ps_enable_cmd(wmi_unified_t wmi_handle,
uint32_t value)
{
wmi_pdev_green_ap_ps_enable_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMA_LOGD("Set Green AP PS val %d", value);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGP("%s: Green AP PS Mem Alloc Failed", __func__);
return -ENOMEM;
}
cmd = (wmi_pdev_green_ap_ps_enable_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_green_ap_ps_enable_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_green_ap_ps_enable_cmd_fixed_param));
cmd->reserved0 = 0;
cmd->enable = value;
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID)) {
WMA_LOGE("Set Green AP PS param Failed val %d", value);
qdf_nbuf_free(buf);
return -EIO;
}
return 0;
}
#endif /* FEATURE_GREEN_AP */
/**
@@ -1450,13 +1412,13 @@ int wmi_unified_nat_keepalive_enable(tp_wma_handle wma, uint8_t vdev_id)
}
/**
* wmi_unified_csa_offload_enable() - sen CSA offload enable command
* wma_unified_csa_offload_enable() - sen CSA offload enable command
* @wma: wma handle
* @vdev_id: vdev id
*
* Return: 0 for success or error code
*/
int wmi_unified_csa_offload_enable(tp_wma_handle wma, uint8_t vdev_id)
int wma_unified_csa_offload_enable(tp_wma_handle wma, uint8_t vdev_id)
{
wmi_csa_offload_enable_cmd_fixed_param *cmd;
wmi_buf_t buf;
@@ -2375,16 +2337,18 @@ void wma_register_dfs_event_handler(tp_wma_handle wma_handle)
WMA_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
__func__);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PHYERR_EVENTID,
wma_unified_phyerr_rx_event_handler);
WMI_PHYERR_EVENTID,
wma_unified_phyerr_rx_event_handler,
WMA_RX_WORK_CTX);
WMA_LOGD("%s: WMI_PHYERR_EVENTID event handler registered",
__func__);
} else {
WMA_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
__func__);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_DFS_RADAR_EVENTID,
wma_unified_dfs_radar_rx_event_handler);
WMI_DFS_RADAR_EVENTID,
wma_unified_dfs_radar_rx_event_handler,
WMA_RX_WORK_CTX);
WMA_LOGD("%s:WMI_DFS_RADAR_EVENTID event handler registered",
__func__);
}
@@ -2554,7 +2518,7 @@ QDF_STATUS wma_pktlog_wmi_send_cmd(WMA_HANDLE handle,
WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_pktlog_disable_cmd_fixed_param));
disable_cmd->reserved0 = 0;
disable_cmd->pdev_id = 0;
if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
WMI_PDEV_PKTLOG_DISABLE_CMDID)) {
WMA_LOGE("failed to send pktlog disable cmdid");
@@ -3537,13 +3501,12 @@ void wma_enable_disable_wakeup_event(WMA_HANDLE handle,
QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle)
{
tp_wma_handle wma = handle;
wmi_wow_enable_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
int ret;
struct hif_opaque_softc *scn;
int host_credits;
int wmi_pending_cmds;
struct wow_cmd_params param = {0};
#ifdef CONFIG_CNSS
tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
@@ -3553,29 +3516,6 @@ QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle)
}
#endif /* CONFIG_CNSS */
len = sizeof(wmi_wow_enable_cmd_fixed_param);
buf = wmi_buf_alloc(wma->wmi_handle, len);
if (!buf) {
WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_wow_enable_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_wow_enable_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_wow_enable_cmd_fixed_param));
cmd->enable = true;
if (htc_can_suspend_link(wma->htc_handle))
cmd->pause_iface_config = WOW_IFACE_PAUSE_ENABLED;
else
cmd->pause_iface_config = WOW_IFACE_PAUSE_DISABLED;
WMA_LOGI("suspend type: %s",
cmd->pause_iface_config == WOW_IFACE_PAUSE_ENABLED ?
"WOW_IFACE_PAUSE_ENABLED" : "WOW_IFACE_PAUSE_DISABLED");
qdf_event_reset(&wma->target_suspend);
wma->wow_nack = 0;
@@ -3594,8 +3534,10 @@ QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle)
#endif
}
ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
WMI_WOW_ENABLE_CMDID);
param.enable = true;
param.can_suspend_link = hif_can_suspend_link(wma->htc_handle);
ret = wmi_unified_wow_enable_send(wma->wmi_handle, &param,
WMA_WILDCARD_PDEV_ID);
if (ret) {
WMA_LOGE("Failed to enable wow in fw");
goto error;
@@ -3665,7 +3607,6 @@ QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle)
return QDF_STATUS_SUCCESS;
error:
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
@@ -6288,6 +6229,7 @@ void wma_send_regdomain_info_to_fw(uint32_t reg_dmn, uint16_t regdmn2G,
tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
int32_t cck_mask_val = 0;
int ret = 0;
struct pdev_params pdev_param = {0};
if (NULL == wma) {
WMA_LOGE("%s: wma context is NULL", __func__);
@@ -6323,9 +6265,12 @@ void wma_send_regdomain_info_to_fw(uint32_t reg_dmn, uint16_t regdmn2G,
cck_mask_val = 1;
cck_mask_val |= (wma->self_gen_frm_pwr << 16);
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_TX_CHAIN_MASK_CCK,
cck_mask_val);
pdev_param.param_id = WMI_PDEV_PARAM_TX_CHAIN_MASK_CCK;
pdev_param.param_value = cck_mask_val;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdev_param,
WMA_WILDCARD_PDEV_ID);
if (ret)
WMA_LOGE("failed to set PDEV tx_chain_mask_cck %d",
ret);
@@ -6526,58 +6471,37 @@ int wma_bus_resume(void)
* @handle: wma handle
* @disable_target_intr: disable target interrupt
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int wma_suspend_target(WMA_HANDLE handle, int disable_target_intr)
QDF_STATUS wma_suspend_target(WMA_HANDLE handle, int disable_target_intr)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
wmi_pdev_suspend_cmd_fixed_param *cmd;
wmi_buf_t wmibuf;
uint32_t len = sizeof(*cmd);
struct hif_opaque_softc *scn;
int ret;
QDF_STATUS status;
struct suspend_params param = {0};
#ifdef CONFIG_CNSS
tpAniSirGlobal pmac = cds_get_context(QDF_MODULE_ID_PE);
#endif
if (!wma_handle || !wma_handle->wmi_handle) {
WMA_LOGE("WMA is closed. can not issue suspend cmd");
return -EINVAL;
return QDF_STATUS_E_INVAL;
}
#ifdef CONFIG_CNSS
if (NULL == pmac) {
WMA_LOGE("%s: Unable to get PE context", __func__);
return -EINVAL;
return QDF_STATUS_E_INVAL;
}
#endif
/*
* send the comand to Target to ignore the
* PCIE reset so as to ensure that Host and target
* states are in sync
*/
wmibuf = wmi_buf_alloc(wma_handle->wmi_handle, len);
if (wmibuf == NULL)
return -ENOMEM;
cmd = (wmi_pdev_suspend_cmd_fixed_param *) wmi_buf_data(wmibuf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_suspend_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_suspend_cmd_fixed_param));
if (disable_target_intr) {
cmd->suspend_opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
} else {
cmd->suspend_opt = WMI_PDEV_SUSPEND;
}
qdf_event_reset(&wma_handle->target_suspend);
ret = wmi_unified_cmd_send(wma_handle->wmi_handle, wmibuf, len,
WMI_PDEV_SUSPEND_CMDID);
if (ret < 0) {
qdf_nbuf_free(wmibuf);
return ret;
}
param.disable_target_intr = disable_target_intr;
status = wmi_unified_suspend_send(wma_handle->wmi_handle,
&param,
WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(status))
return status;
wmi_set_target_suspend(wma_handle->wmi_handle, true);
@@ -6597,7 +6521,7 @@ int wma_suspend_target(WMA_HANDLE handle, int disable_target_intr)
WMA_LOGE("%s: LOGP is in progress, ignore!", __func__);
}
#endif
return -EFAULT;
return QDF_STATUS_E_FAULT;
}
scn = cds_get_context(QDF_MODULE_ID_HIF);
@@ -6605,10 +6529,10 @@ int wma_suspend_target(WMA_HANDLE handle, int disable_target_intr)
if (scn == NULL) {
WMA_LOGE("%s: Failed to get HIF context", __func__);
QDF_ASSERT(0);
return -EFAULT;
return QDF_STATUS_E_FAULT;
}
return 0;
return QDF_STATUS_SUCCESS;
}
/**
@@ -6639,40 +6563,26 @@ void wma_target_suspend_acknowledge(void *context)
* wma_resume_target() - resume target
* @handle: wma handle
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int wma_resume_target(WMA_HANDLE handle)
QDF_STATUS wma_resume_target(WMA_HANDLE handle)
{
int ret;
tp_wma_handle wma = (tp_wma_handle) handle;
wmi_buf_t wmibuf;
wmi_pdev_resume_cmd_fixed_param *cmd;
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
#ifdef CONFIG_CNSS
tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
if (NULL == pMac) {
WMA_LOGE("%s: Unable to get PE context", __func__);
return -EINVAL;
return QDF_STATUS_E_INVAL;
}
#endif /* CONFIG_CNSS */
wmibuf = wmi_buf_alloc(wma->wmi_handle, sizeof(*cmd));
if (wmibuf == NULL) {
return -ENOMEM;
}
cmd = (wmi_pdev_resume_cmd_fixed_param *) wmi_buf_data(wmibuf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_resume_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_resume_cmd_fixed_param));
cmd->reserved0 = 0;
qdf_event_reset(&wma->wma_resume_event);
ret = wmi_unified_cmd_send(wma->wmi_handle, wmibuf, sizeof(*cmd),
WMI_PDEV_RESUME_CMDID);
if (ret != EOK) {
qdf_status = wmi_unified_resume_send(wma->wmi_handle,
WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(qdf_status))
WMA_LOGE("Failed to send WMI_PDEV_RESUME_CMDID command");
wmi_buf_free(wmibuf);
}
qdf_status = qdf_wait_single_event(&(wma->wma_resume_event),
WMA_RESUME_TIMEOUT);

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

@@ -65,10 +65,7 @@
#endif /* REMOVE_PKT_LOG */
#include "dbglog_host.h"
/* FIXME: Inclusion of .c looks odd
* but this is how it is in internal codebase
*/
#include "wmi_version_whitelist.c"
#include "wmi_version_whitelist.h"
#include "csr_api.h"
#include "ol_fw.h"
@@ -748,46 +745,6 @@ static int32_t wma_set_priv_cfg(tp_wma_handle wma_handle,
return ret;
}
/**
* wmi_unified_pdev_set_param() - set pdev parameters
* @wmi_handle: wmi handle
* @param_id: parameter id
* @param_value: parameter value
*
* Return: 0 on success, errno on failure
*/
int
wmi_unified_pdev_set_param(wmi_unified_t wmi_handle, WMI_PDEV_PARAM param_id,
uint32_t param_value)
{
int ret;
wmi_pdev_set_param_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint16_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (wmi_pdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_param_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_set_param_cmd_fixed_param));
cmd->reserved0 = 0;
cmd->param_id = param_id;
cmd->param_value = param_value;
WMA_LOGD("Setting pdev param = %x, value = %u", param_id, param_value);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_PARAM_CMDID);
if (ret != EOK) {
WMA_LOGE("Failed to send set param command ret = %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* wma_set_modulated_dtim() - function to configure modulated dtim
* @wma: wma handle
@@ -805,7 +762,7 @@ static void wma_set_modulated_dtim(tp_wma_handle wma,
&wma->interfaces[vdev_id];
bool prev_dtim_enabled;
uint32_t listen_interval;
int ret;
QDF_STATUS ret;
iface->alt_modulated_dtim = privcmd->param_value;
@@ -822,20 +779,20 @@ static void wma_set_modulated_dtim(tp_wma_handle wma,
listen_interval = iface->alt_modulated_dtim
* iface->dtimPeriod;
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
listen_interval);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
/* Even if it fails, continue */
WMA_LOGW("Failed to set listen interval %d",
listen_interval);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_DTIM_POLICY ,
NORMAL_DTIM);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to Set to Normal DTIM policy");
}
}
@@ -851,10 +808,12 @@ static void wma_set_modulated_dtim(tp_wma_handle wma,
static void wma_process_cli_set_cmd(tp_wma_handle wma,
wma_cli_set_cmd_t *privcmd)
{
int ret = 0, vid = privcmd->param_vdev_id, pps_val = 0;
int vid = privcmd->param_vdev_id, pps_val = 0;
QDF_STATUS ret;
struct wma_txrx_node *intr = wma->interfaces;
tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
struct qpower_params *qparams = &intr[vid].config.qpower_params;
struct pdev_params pdev_param;
WMA_LOGD("wmihandle %p", wma->wmi_handle);
@@ -877,12 +836,12 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
case VDEV_CMD:
WMA_LOGD("vdev id %d pid %d pval %d", privcmd->param_vdev_id,
privcmd->param_id, privcmd->param_value);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
privcmd->param_id,
privcmd->param_value);
if (ret) {
WMA_LOGE("wmi_unified_vdev_set_param_send failed ret %d",
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("wma_vdev_set_param failed ret %d",
ret);
return;
}
@@ -895,11 +854,13 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
wma_update_txrx_chainmask(wma->num_rf_chains,
&privcmd->param_value);
}
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
privcmd->param_id,
privcmd->param_value);
if (ret) {
WMA_LOGE("wmi_unified_vdev_set_param_send failed ret %d",
pdev_param.param_id = privcmd->param_id;
pdev_param.param_value = privcmd->param_value;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdev_param,
WMA_WILDCARD_PDEV_ID);
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("wma_vdev_set_param failed ret %d",
ret);
return;
}
@@ -953,7 +914,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
htc_dump(wma->htc_handle, WD_DUMP, false);
break;
case GEN_PARAM_CRASH_INJECT:
ret = wmi_crash_inject(wma->wmi_handle,
ret = wma_crash_inject(wma,
privcmd->param_value,
privcmd->param_sec_value);
break;
@@ -1078,17 +1039,16 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
ret);
break;
#ifdef FEATURE_GREEN_AP
case WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID:
/* Set the Green AP */
ret = wmi_unified_pdev_green_ap_ps_enable_cmd
(wma->wmi_handle, privcmd->param_value);
ret = wmi_unified_green_ap_ps_send
(wma->wmi_handle, privcmd->param_value,
WMA_WILDCARD_PDEV_ID);
if (ret) {
WMA_LOGE("Set GreenAP Failed val %d",
privcmd->param_value);
}
break;
#endif /* FEATURE_GREEN_AP */
default:
WMA_LOGE("Invalid param id 0x%x", privcmd->param_id);
@@ -1174,7 +1134,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
WMA_LOGD("QPOWER CLI CMD:Ps Poll Cnt val %d",
privcmd->param_value);
/* Set the QPower Ps Poll Count */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vid, WMI_STA_PS_PARAM_QPOWER_PSPOLL_COUNT,
privcmd->param_value);
if (ret) {
@@ -1188,7 +1148,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
WMA_LOGD("QPOWER CLI CMD:Max Tx Before wake val %d",
privcmd->param_value);
/* Set the QPower Max Tx Before Wake */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vid, WMI_STA_PS_PARAM_QPOWER_MAX_TX_BEFORE_WAKE,
privcmd->param_value);
if (ret) {
@@ -1203,7 +1163,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
WMA_LOGD("QPOWER CLI CMD:Ps Poll Wake Inv val %d",
privcmd->param_value);
/* Set the QPower Spec Ps Poll Wake Inv */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vid, WMI_STA_PS_PARAM_QPOWER_SPEC_PSPOLL_WAKE_INTERVAL,
privcmd->param_value);
if (ret) {
@@ -1218,7 +1178,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
WMA_LOGD("QPOWER CLI CMD:Spec NoData Ps Poll val %d",
privcmd->param_value);
/* Set the QPower Spec NoData PsPoll */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vid, WMI_STA_PS_PARAM_QPOWER_SPEC_MAX_SPEC_NODATA_PSPOLL,
privcmd->param_value);
if (ret) {
@@ -1301,7 +1261,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
privcmd->param_vdev_id,
&intr[vid].config.gtx_info);
if (ret) {
WMA_LOGE("wmi_unified_vdev_set_param_send"
WMA_LOGE("wma_vdev_set_param"
" failed ret %d", ret);
return;
}
@@ -1445,7 +1405,7 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
break;
}
} else if (5 == privcmd->param_vp_dev) {
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
privcmd->param_vdev_id,
WMI_VDEV_PARAM_PACKET_POWERSAVE,
pps_val);
@@ -1475,16 +1435,33 @@ static int wma_process_fw_event(tp_wma_handle wma,
return 0;
}
/**
* wmi_process_fw_event_tasklet_ctx() - process in tasklet context
* @ctx: handle to wmi
* @ev: wmi event buffer
*
* Event process by below function will be in tasket context,
* need to use this method only for time sensitive functions.
*
* Return: none
*/
static int wma_process_fw_event_tasklet_ctx(void *ctx, void *ev)
{
wmi_process_fw_event(ctx, ev);
return 0;
}
/**
* wma_process_fw_event_handler() - common event handler to serialize
* event processing through mc_thread
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @ctx: wmi context
* @ev: event buffer
* @rx_ctx: rx execution context
*
* Return: 0 on success, errno on failure
*/
int wma_process_fw_event_handler(struct wmi_unified *wmi_handle,
wmi_buf_t evt_buf)
static int wma_process_fw_event_mc_thread_ctx(void *ctx, void *ev)
{
wma_process_fw_event_params *params_buf;
cds_msg_t cds_msg = { 0 };
@@ -1492,12 +1469,12 @@ int wma_process_fw_event_handler(struct wmi_unified *wmi_handle,
params_buf = qdf_mem_malloc(sizeof(wma_process_fw_event_params));
if (!params_buf) {
WMA_LOGE("%s: Failed alloc memory for params_buf", __func__);
qdf_nbuf_free(evt_buf);
qdf_nbuf_free(ev);
return -ENOMEM;
}
params_buf->wmi_handle = wmi_handle;
params_buf->evt_buf = evt_buf;
params_buf->wmi_handle = (struct wmi_unified *)ctx;
params_buf->evt_buf = (wmi_buf_t *)ev;
cds_msg.type = WMA_PROCESS_FW_EVENT;
cds_msg.bodyptr = params_buf;
@@ -1507,7 +1484,7 @@ int wma_process_fw_event_handler(struct wmi_unified *wmi_handle,
cds_mq_post_message(CDS_MQ_ID_WMA, &cds_msg)) {
WMA_LOGP("%s: Failed to post WMA_PROCESS_FW_EVENT msg",
__func__);
qdf_nbuf_free(evt_buf);
qdf_nbuf_free(ev);
qdf_mem_free(params_buf);
return -EFAULT;
}
@@ -1516,6 +1493,31 @@ int wma_process_fw_event_handler(struct wmi_unified *wmi_handle,
}
/**
* wma_process_fw_event_handler() - common event handler to serialize
* event processing through mc_thread
* @ctx: wmi context
* @ev: event buffer
* @rx_ctx: rx execution context
*
* Return: 0 on success, errno on failure
*/
int wma_process_fw_event_handler(void *ctx, void *ev, uint8_t rx_ctx)
{
int err = 0;
if (rx_ctx == WMA_RX_SERIALIZER_CTX) {
err = wma_process_fw_event_mc_thread_ctx(ctx, ev);
} else if (rx_ctx == WMA_RX_TASKLET_CTX) {
wma_process_fw_event_tasklet_ctx(ctx, ev);
} else {
WMA_LOGE("%s: invalid wmi event execution context", __func__);
qdf_nbuf_free(ev);
}
return err;
}
#ifdef QCA_LL_TX_FLOW_CONTROL_V2
/**
* ol_cfg_set_flow_control_parameters() - set flow control parameters
@@ -1597,6 +1599,9 @@ QDF_STATUS wma_open(void *cds_context,
void *wmi_handle;
QDF_STATUS qdf_status;
struct txrx_pdev_cfg_param_t olCfg = { 0 };
struct wmi_rx_ops ops;
bool use_cookie = false;
WMA_LOGD("%s: Enter", __func__);
@@ -1632,9 +1637,11 @@ QDF_STATUS wma_open(void *cds_context,
qdf_wake_lock_create(&wma_handle->wow_wake_lock, "wlan_wow_wl");
}
/* Attach mc_thread context processing function */
ops.wma_process_fw_event_handler_cbk = wma_process_fw_event_handler;
/* attach the wmi */
wmi_handle = wmi_unified_attach(wma_handle,
wma_process_fw_event_handler);
wmi_handle = wmi_unified_attach(wma_handle, NULL,
WMI_TLV_TARGET, use_cookie, &ops);
if (!wmi_handle) {
WMA_LOGP("%s: failed to attach WMI", __func__);
qdf_status = QDF_STATUS_E_NOMEM;
@@ -1642,7 +1649,18 @@ QDF_STATUS wma_open(void *cds_context,
}
WMA_LOGA("WMA --> wmi_unified_attach - success");
wmi_unified_register_event_handler(wmi_handle,
WMI_SERVICE_READY_EVENTID,
wma_rx_service_ready_event,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wmi_handle,
WMI_SERVICE_READY_EXT_EVENTID,
wma_rx_service_ready_ext_event,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wmi_handle,
WMI_READY_EVENTID,
wma_rx_ready_event,
WMA_RX_SERIALIZER_CTX);
/* Save the WMI & HTC handle */
wma_handle->wmi_handle = wmi_handle;
wma_handle->htc_handle = htc_handle;
@@ -1763,12 +1781,14 @@ QDF_STATUS wma_open(void *cds_context,
wma_handle->max_bssid);
/* Register the debug print event handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_DEBUG_PRINT_EVENTID,
wma_unified_debug_print_event_handler);
WMI_DEBUG_PRINT_EVENTID,
wma_unified_debug_print_event_handler,
WMA_RX_SERIALIZER_CTX);
/* Register profiling event Handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_WLAN_PROFILE_DATA_EVENTID,
wma_profile_data_report_event_handler);
wma_profile_data_report_event_handler,
WMA_RX_SERIALIZER_CTX);
wma_handle->tgt_cfg_update_cb = tgt_cfg_cb;
wma_handle->dfs_radar_indication_cb = radar_ind_cb;
@@ -1845,43 +1865,52 @@ QDF_STATUS wma_open(void *cds_context,
/* Register vdev start response event handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_VDEV_START_RESP_EVENTID,
wma_vdev_start_resp_handler);
wma_vdev_start_resp_handler,
WMA_RX_SERIALIZER_CTX);
/* Register vdev stop response event handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_VDEV_STOPPED_EVENTID,
wma_vdev_stop_resp_handler);
wma_vdev_stop_resp_handler,
WMA_RX_SERIALIZER_CTX);
/* register for STA kickout function */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_STA_KICKOUT_EVENTID,
wma_peer_sta_kickout_event_handler);
wma_peer_sta_kickout_event_handler,
WMA_RX_SERIALIZER_CTX);
/* register for stats response event */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_UPDATE_STATS_EVENTID,
wma_stats_event_handler);
wma_stats_event_handler,
WMA_RX_SERIALIZER_CTX);
/* register for linkspeed response event */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_ESTIMATED_LINKSPEED_EVENTID,
wma_link_speed_event_handler);
wma_link_speed_event_handler,
WMA_RX_SERIALIZER_CTX);
#ifdef FEATURE_OEM_DATA_SUPPORT
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OEM_CAPABILITY_EVENTID,
wma_oem_capability_event_callback);
wma_oem_capability_event_callback,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OEM_MEASUREMENT_REPORT_EVENTID,
wma_oem_measurement_report_event_callback);
WMI_OEM_MEASUREMENT_REPORT_EVENTID,
wma_oem_measurement_report_event_callback,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OEM_ERROR_REPORT_EVENTID,
wma_oem_error_report_event_callback);
wma_oem_error_report_event_callback,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OEM_RESPONSE_EVENTID,
wma_oem_data_response_handler);
wma_oem_data_response_handler,
WMA_RX_SERIALIZER_CTX);
#endif /* FEATURE_OEM_DATA_SUPPORT */
/*
* Register appropriate DFS phyerr event handler for
@@ -1893,18 +1922,21 @@ QDF_STATUS wma_open(void *cds_context,
/* Register peer change event handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_STATE_EVENTID,
wma_peer_state_change_event_handler);
wma_peer_state_change_event_handler,
WMA_RX_WORK_CTX);
/* Register beacon tx complete event id. The event is required
* for sending channel switch announcement frames
*/
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OFFLOAD_BCN_TX_STATUS_EVENTID,
wma_unified_bcntx_status_event_handler);
WMI_OFFLOAD_BCN_TX_STATUS_EVENTID,
wma_unified_bcntx_status_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_UPDATE_VDEV_RATE_STATS_EVENTID,
wma_link_status_event_handler);
wma_link_status_event_handler,
WMA_RX_SERIALIZER_CTX);
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
/* Register event handler for processing Link Layer Stats
* response from the FW
@@ -1919,7 +1951,8 @@ QDF_STATUS wma_open(void *cds_context,
*/
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_UPDATE_FW_MEM_DUMP_EVENTID,
wma_fw_mem_dump_event_handler);
wma_fw_mem_dump_event_handler,
WMA_RX_SERIALIZER_CTX);
/* Firmware debug log */
qdf_status = dbglog_init(wma_handle->wmi_handle);
@@ -1956,25 +1989,29 @@ QDF_STATUS wma_open(void *cds_context,
#ifdef FEATURE_WLAN_TDLS
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_TDLS_PEER_EVENTID,
wma_tdls_event_handler);
wma_tdls_event_handler,
WMA_RX_SERIALIZER_CTX);
#endif /* FEATURE_WLAN_TDLS */
/* register for install key completion event */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID,
wma_vdev_install_key_complete_event_handler);
WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID,
wma_vdev_install_key_complete_event_handler,
WMA_RX_SERIALIZER_CTX);
#ifdef WLAN_FEATURE_NAN
/* register for nan response event */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_NAN_EVENTID,
wma_nan_rsp_event_handler);
wma_nan_rsp_event_handler,
WMA_RX_SERIALIZER_CTX);
#endif /* WLAN_FEATURE_NAN */
#ifdef WLAN_FEATURE_STATS_EXT
/* register for extended stats event */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_STATS_EXT_EVENTID,
wma_stats_ext_event_handler);
wma_stats_ext_event_handler,
WMA_RX_SERIALIZER_CTX);
#endif /* WLAN_FEATURE_STATS_EXT */
#ifdef FEATURE_WLAN_EXTSCAN
wma_register_extscan_event_handler(wma_handle);
@@ -1985,27 +2022,32 @@ QDF_STATUS wma_open(void *cds_context,
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_ROAM_SYNCH_EVENTID,
wma_roam_synch_event_handler);
wma_roam_synch_event_handler,
WMA_RX_SERIALIZER_CTX);
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_RSSI_BREACH_EVENTID,
wma_rssi_breached_event_handler);
wma_rssi_breached_event_handler,
WMA_RX_SERIALIZER_CTX);
qdf_wake_lock_create(&wma_handle->wmi_cmd_rsp_wake_lock,
"wlan_fw_rsp_wakelock");
"wlan_fw_rsp_wakelock");
wma_handle->wmi_cmd_rsp_runtime_lock =
qdf_runtime_lock_init("wlan_fw_rsp_runtime_lock");
/* Register peer assoc conf event handler */
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_ASSOC_CONF_EVENTID,
wma_peer_assoc_conf_handler);
wma_peer_assoc_conf_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_VDEV_DELETE_RESP_EVENTID,
wma_vdev_delete_handler);
wma_vdev_delete_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_DELETE_RESP_EVENTID,
wma_peer_delete_handler);
wma_peer_delete_handler,
WMA_RX_SERIALIZER_CTX);
return QDF_STATUS_SUCCESS;
err_dbglog_init:
@@ -2638,7 +2680,8 @@ QDF_STATUS wma_start(void *cds_ctx)
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_SCAN_EVENTID,
wma_scan_event_callback);
wma_scan_event_callback,
WMA_RX_SERIALIZER_CTX);
if (0 != status) {
WMA_LOGP("%s: Failed to register scan callback", __func__);
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2647,7 +2690,8 @@ QDF_STATUS wma_start(void *cds_ctx)
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_ROAM_EVENTID,
wma_roam_event_callback);
wma_roam_event_callback,
WMA_RX_WORK_CTX);
if (0 != status) {
WMA_LOGP("%s: Failed to register Roam callback", __func__);
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2656,7 +2700,8 @@ QDF_STATUS wma_start(void *cds_ctx)
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_WOW_WAKEUP_HOST_EVENTID,
wma_wow_wakeup_host_event);
wma_wow_wakeup_host_event,
WMA_RX_TASKLET_CTX);
if (status) {
WMA_LOGP("%s: Failed to register wow wakeup host event handler",
__func__);
@@ -2666,7 +2711,8 @@ QDF_STATUS wma_start(void *cds_ctx)
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PDEV_RESUME_EVENTID,
wma_pdev_resume_event_handler);
wma_pdev_resume_event_handler,
WMA_RX_TASKLET_CTX);
if (status) {
WMA_LOGP("%s: Failed to register PDEV resume event handler",
__func__);
@@ -2681,8 +2727,9 @@ QDF_STATUS wma_start(void *cds_ctx)
WMA_LOGD("FW supports pno offload, registering nlo match handler");
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_NLO_MATCH_EVENTID,
wma_nlo_match_evt_handler);
WMI_NLO_MATCH_EVENTID,
wma_nlo_match_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register nlo match event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2690,8 +2737,9 @@ QDF_STATUS wma_start(void *cds_ctx)
}
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_NLO_SCAN_COMPLETE_EVENTID,
wma_nlo_scan_cmp_evt_handler);
WMI_NLO_SCAN_COMPLETE_EVENTID,
wma_nlo_scan_cmp_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register nlo scan comp event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2703,16 +2751,18 @@ QDF_STATUS wma_start(void *cds_ctx)
#if defined(QCA_LL_LEGACY_TX_FLOW_CONTROL) || defined(QCA_LL_TX_FLOW_CONTROL_V2)
WMA_LOGE("MCC TX Pause Event Handler register");
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_TX_PAUSE_EVENTID,
wma_mcc_vdev_tx_pause_evt_handler);
WMI_TX_PAUSE_EVENTID,
wma_mcc_vdev_tx_pause_evt_handler,
WMA_RX_TASKLET_CTX);
#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
#ifdef FEATURE_WLAN_CH_AVOID
WMA_LOGD("Registering channel to avoid handler");
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_WLAN_FREQ_AVOID_EVENTID,
wma_channel_avoid_evt_handler);
WMI_WLAN_FREQ_AVOID_EVENTID,
wma_channel_avoid_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register channel to avoid event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2722,8 +2772,9 @@ QDF_STATUS wma_start(void *cds_ctx)
#ifdef FEATURE_WLAN_AUTO_SHUTDOWN
WMA_LOGD("Registering auto shutdown handler");
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_HOST_AUTO_SHUTDOWN_EVENTID,
wma_auto_shutdown_event_handler);
WMI_HOST_AUTO_SHUTDOWN_EVENTID,
wma_auto_shutdown_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register WMI Auto shutdown event handler");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2731,8 +2782,9 @@ QDF_STATUS wma_start(void *cds_ctx)
}
#endif /* FEATURE_WLAN_AUTO_SHUTDOWN */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_THERMAL_MGMT_EVENTID,
wma_thermal_mgmt_evt_handler);
WMI_THERMAL_MGMT_EVENTID,
wma_thermal_mgmt_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register thermal mitigation event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2775,8 +2827,9 @@ QDF_STATUS wma_start(void *cds_ctx)
/* Initialize the get temperature event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PDEV_TEMPERATURE_EVENTID,
wma_pdev_temperature_evt_handler);
WMI_PDEV_TEMPERATURE_EVENTID,
wma_pdev_temperature_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register get_temperature event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2786,7 +2839,8 @@ QDF_STATUS wma_start(void *cds_ctx)
/* Initialize the log flush complete event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_DEBUG_MESG_FLUSH_COMPLETE_EVENTID,
wma_flush_complete_evt_handler);
wma_flush_complete_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register log flush complete event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2796,7 +2850,8 @@ QDF_STATUS wma_start(void *cds_ctx)
/* Initialize the WMI_SOC_SET_HW_MODE_RESP_EVENTID event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_SOC_SET_HW_MODE_RESP_EVENTID,
wma_soc_set_hw_mode_resp_evt_handler);
wma_soc_set_hw_mode_resp_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register set hw mode resp event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2806,7 +2861,8 @@ QDF_STATUS wma_start(void *cds_ctx)
/* Initialize the WMI_SOC_HW_MODE_TRANSITION_EVENTID event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_SOC_HW_MODE_TRANSITION_EVENTID,
wma_soc_hw_mode_transition_evt_handler);
wma_soc_hw_mode_transition_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register hw mode transition event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -2816,7 +2872,8 @@ QDF_STATUS wma_start(void *cds_ctx)
/* Initialize the set dual mac configuration event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_SOC_SET_DUAL_MAC_CONFIG_RESP_EVENTID,
wma_soc_set_dual_mode_config_resp_evt_handler);
wma_soc_set_dual_mode_config_resp_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register hw mode transition event cb");
qdf_status = QDF_STATUS_E_FAILURE;
@@ -3800,7 +3857,8 @@ done:
*
* Return: none
*/
void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
uint32_t length)
{
wmi_buf_t buf;
uint32_t len;
@@ -3817,13 +3875,13 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) cmd_param_info;
if (!(handle && param_buf)) {
WMA_LOGP("%s: Invalid arguments", __func__);
return;
return -EINVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
WMA_LOGP("%s: Invalid buffer", __func__);
return;
return -EINVAL;
}
WMA_LOGA("WMA <-- WMI_SERVICE_READY_EVENTID");
@@ -3906,10 +3964,11 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
/* SWBA event handler for beacon transmission */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_HOST_SWBA_EVENTID,
wma_beacon_swba_handler);
wma_beacon_swba_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register swba beacon event cb");
return;
return -EINVAL;
}
#ifdef WLAN_FEATURE_LPSS
wma_handle->lpss_support =
@@ -3930,11 +3989,12 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
WMA_LOGD("%s: FW support CSA offload capability", __func__);
status =
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_CSA_HANDLING_EVENTID,
wma_csa_offload_handler);
WMI_CSA_HANDLING_EVENTID,
wma_csa_offload_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register CSA offload event cb");
return;
return -EINVAL;
}
}
@@ -3944,7 +4004,7 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
status = wmi_desc_pool_init(wma_handle, WMI_DESC_POOL_MAX);
if (status) {
WMA_LOGE("Failed to initialize wmi descriptor pool");
return;
return -EINVAL;
}
/*
* Register Tx completion event handler for MGMT Tx over WMI
@@ -3953,10 +4013,11 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
status = wmi_unified_register_event_handler(
wma_handle->wmi_handle,
WMI_MGMT_TX_COMPLETION_EVENTID,
wma_mgmt_tx_completion_handler);
wma_mgmt_tx_completion_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register MGMT over WMI completion handler");
return;
return -EINVAL;
}
} else {
@@ -3967,29 +4028,32 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
WMI_SERVICE_GTK_OFFLOAD)) {
status =
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_GTK_OFFLOAD_STATUS_EVENTID,
wma_gtk_offload_status_event);
WMI_GTK_OFFLOAD_STATUS_EVENTID,
wma_gtk_offload_status_event,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register GTK offload event cb");
return;
return -EINVAL;
}
}
#endif /* WLAN_FEATURE_GTK_OFFLOAD */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_P2P_NOA_EVENTID,
wma_p2p_noa_event_handler);
wma_p2p_noa_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register WMI_P2P_NOA_EVENTID callback");
return;
return -EINVAL;
}
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_TBTTOFFSET_UPDATE_EVENTID,
wma_tbttoffset_update_event_handler);
WMI_TBTTOFFSET_UPDATE_EVENTID,
wma_tbttoffset_update_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE
("Failed to register WMI_TBTTOFFSET_UPDATE_EVENTID callback");
return;
return -EINVAL;
}
/* register the Enhanced Green AP event handler */
@@ -3998,10 +4062,11 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
/* Initialize the log supported event handler */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID,
wma_log_supported_evt_handler);
wma_log_supported_evt_handler,
WMA_RX_SERIALIZER_CTX);
if (status != QDF_STATUS_SUCCESS) {
WMA_LOGE("Failed to register log supported event cb");
return;
return -EINVAL;
}
qdf_mem_copy(target_cap.wmi_service_bitmap,
@@ -4017,7 +4082,7 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
buf = wma_setup_wmi_init_msg(wma_handle, ev, param_buf, &len);
if (!buf) {
WMA_LOGE("Failed to setup buffer for wma init command");
return;
return -EINVAL;
}
/* A host, which supports WMI_SERVICE_READY_EXT_EVENTID, would need to
@@ -4036,7 +4101,7 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
if (status != EOK) {
WMA_LOGE("Failed to send WMI_INIT_CMDID command");
wmi_buf_free(buf);
return;
return -EINVAL;
}
} else {
/* Need to save and send the WMI INIT command only after
@@ -4055,16 +4120,20 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
WMA_LOGA("%s: WMA waiting for WMI_SERVICE_READY_EXT_EVENTID",
__func__);
}
return 0;
}
/**
* wma_rx_service_ready_ext_event() - evt handler for sevice ready ext event.
* @handle: wma handle
* @event: params of the service ready extended event
* @length: param length
*
* Return: none
*/
void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
int wma_rx_service_ready_ext_event(void *handle, uint8_t *event,
uint32_t length)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf;
@@ -4076,26 +4145,26 @@ void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
if (!wma_handle) {
WMA_LOGP("%s: Invalid WMA handle", __func__);
return;
return -EINVAL;
}
param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event;
if (!param_buf) {
WMA_LOGP("%s: Invalid event", __func__);
return;
return -EINVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
WMA_LOGP("%s: Invalid buffer", __func__);
return;
return -EINVAL;
}
WMA_LOGA("WMA <-- WMI_SERVICE_READY_EXT_EVENTID");
if (!wma_handle->saved_wmi_init_cmd.buf) {
WMA_LOGP("Service ready ext event w/o WMI_SERVICE_EXT_MSG!");
return;
return -EINVAL;
}
WMA_LOGA("%s: Defaults: scan config:%x FW mode config:%x",
@@ -4105,7 +4174,7 @@ void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
ret = qdf_mc_timer_stop(&wma_handle->service_ready_ext_timer);
if (!QDF_IS_STATUS_SUCCESS(ret)) {
WMA_LOGP("Failed to stop the service ready ext timer");
return;
return -EINVAL;
}
WMA_LOGA("WMA --> WMI_INIT_CMDID");
@@ -4126,6 +4195,8 @@ void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
wma_init_scan_fw_mode_config(wma_handle,
ev->default_conc_scan_config_bits,
ev->default_fw_config_bits);
return 0;
}
/**
@@ -4133,10 +4204,12 @@ void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
* wmi rx ready event.
* @handle: wma handle
* @cmd_param_info: command params info
* @length: param length
*
* Return: none
*/
void wma_rx_ready_event(WMA_HANDLE handle, void *cmd_param_info)
int wma_rx_ready_event(void *handle, uint8_t *cmd_param_info,
uint32_t length)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
WMI_READY_EVENTID_param_tlvs *param_buf = NULL;
@@ -4148,7 +4221,7 @@ void wma_rx_ready_event(WMA_HANDLE handle, void *cmd_param_info)
if (!(wma_handle && param_buf)) {
WMA_LOGP("%s: Invalid arguments", __func__);
QDF_ASSERT(0);
return;
return -EINVAL;
}
WMA_LOGA("WMA <-- WMI_READY_EVENTID");
@@ -4206,6 +4279,8 @@ void wma_rx_ready_event(WMA_HANDLE handle, void *cmd_param_info)
qdf_event_set(&wma_handle->wma_ready_event);
WMA_LOGD("Exit");
return 0;
}
/**
@@ -4345,7 +4420,7 @@ QDF_STATUS wma_set_ppsconfig(uint8_t vdev_id, uint16_t pps_param,
pkt_pwr_save_config:
WMA_LOGD("vdev_id:%d val:0x%x pps_val:0x%x", vdev_id,
val, pps_val);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_PACKET_POWERSAVE,
pps_val);
break;
@@ -4424,18 +4499,18 @@ QDF_STATUS wma_process_set_miracast(tp_wma_handle wma, uint32_t *miracast_val)
static QDF_STATUS wma_config_stats_factor(tp_wma_handle wma,
struct sir_stats_avg_factor *avg_factor)
{
int ret;
QDF_STATUS ret;
if (NULL == wma || NULL == avg_factor) {
WMA_LOGE("%s: Invalid input of stats avg factor", __func__);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
avg_factor->vdev_id,
WMI_VDEV_PARAM_STATS_AVG_FACTOR,
avg_factor->stats_avg_factor);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE(" failed to set avg_factor for vdev_id %d",
avg_factor->vdev_id);
}
@@ -4459,18 +4534,18 @@ static QDF_STATUS wma_config_stats_factor(tp_wma_handle wma,
static QDF_STATUS wma_config_guard_time(tp_wma_handle wma,
struct sir_guard_time_request *guard_time)
{
int ret;
QDF_STATUS ret;
if (NULL == wma || NULL == guard_time) {
WMA_LOGE("%s: Invalid input of guard time", __func__);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
guard_time->vdev_id,
WMI_VDEV_PARAM_RX_LEAK_WINDOW,
guard_time->guard_time);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE(" failed to set guard time for vdev_id %d",
guard_time->vdev_id);
}
@@ -5635,13 +5710,18 @@ QDF_STATUS wma_send_soc_set_dual_mac_config(tp_wma_handle wma_handle,
* This function will send a command to FW in order to simulate different
* kinds of FW crashes.
*
* Return: 0 for success or reasons for failure
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int wma_crash_inject(tp_wma_handle wma_handle, uint32_t type,
QDF_STATUS wma_crash_inject(tp_wma_handle wma_handle, uint32_t type,
uint32_t delay_time_ms)
{
return wmi_crash_inject(wma_handle->wmi_handle, type, delay_time_ms);
struct crash_inject param;
param.type = type;
param.delay_time_ms = delay_time_ms;
return wmi_crash_inject(wma_handle->wmi_handle, &param);
}
#if defined(FEATURE_LRO)
/**
* wma_lro_init() - sends LRO configuration to FW

79
core/wma/src/wma_mgmt.c
View File

@@ -566,6 +566,7 @@ void wma_set_sap_keepalive(tp_wma_handle wma, uint8_t vdev_id)
{
uint32_t min_inactive_time, max_inactive_time, max_unresponsive_time;
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
QDF_STATUS status;
if (NULL == mac) {
WMA_LOGE("%s: Failed to get mac", __func__);
@@ -577,19 +578,25 @@ void wma_set_sap_keepalive(tp_wma_handle wma, uint8_t vdev_id)
min_inactive_time = max_inactive_time / 2;
if (wmi_unified_vdev_set_param_send(wma->wmi_handle,
vdev_id, WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
min_inactive_time))
status = wma_vdev_set_param(wma->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS,
min_inactive_time);
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to Set AP MIN IDLE INACTIVE TIME");
if (wmi_unified_vdev_set_param_send(wma->wmi_handle,
vdev_id, WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
max_inactive_time))
status = wma_vdev_set_param(wma->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS,
max_inactive_time);
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to Set AP MAX IDLE INACTIVE TIME");
if (wmi_unified_vdev_set_param_send(wma->wmi_handle,
vdev_id, WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
max_unresponsive_time))
status = wma_vdev_set_param(wma->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS,
max_unresponsive_time);
if (QDF_IS_STATUS_ERROR(status))
WMA_LOGE("Failed to Set MAX UNRESPONSIVE TIME");
WMA_LOGD("%s:vdev_id:%d min_inactive_time: %u max_inactive_time: %u"
@@ -1061,7 +1068,7 @@ int32_t wmi_unified_send_peer_assoc(tp_wma_handle wma,
#ifdef FEATURE_WLAN_WAPI
if (params->encryptType == eSIR_ED_WPI) {
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
params->smesessionId,
WMI_VDEV_PARAM_DROP_UNENCRY,
false);
@@ -1228,16 +1235,16 @@ int wmi_unified_vdev_set_gtx_cfg_send(wmi_unified_t wmi_handle, uint32_t if_id,
void wma_update_protection_mode(tp_wma_handle wma, uint8_t vdev_id,
uint8_t llbcoexist)
{
int ret;
QDF_STATUS ret;
enum ieee80211_protmode prot_mode;
prot_mode = llbcoexist ? IEEE80211_PROT_CTSONLY : IEEE80211_PROT_NONE;
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_PROTECTION_MODE,
prot_mode);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to send wmi protection mode cmd");
else
WMA_LOGD("Updated protection mode %d to target", prot_mode);
@@ -1255,13 +1262,13 @@ static void
wma_update_beacon_interval(tp_wma_handle wma, uint8_t vdev_id,
uint16_t beaconInterval)
{
int ret;
QDF_STATUS ret;
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_BEACON_INTERVAL,
beaconInterval);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to update beacon interval");
else
WMA_LOGI("Updated beacon interval %d for vdev %d",
@@ -1311,7 +1318,7 @@ void wma_update_cfg_params(tp_wma_handle wma, tSirMsgQ *cfgParam)
uint8_t vdev_id;
uint32_t param_id;
uint32_t cfg_val;
int ret;
QDF_STATUS ret;
/* get mac to acess CFG data base */
struct sAniSirGlobal *pmac;
@@ -1343,10 +1350,10 @@ void wma_update_cfg_params(tp_wma_handle wma, tSirMsgQ *cfgParam)
for (vdev_id = 0; vdev_id < wma->max_bssid; vdev_id++) {
if (wma->interfaces[vdev_id].handle != 0) {
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle,
ret = wma_vdev_set_param(wma->wmi_handle,
vdev_id, param_id,
cfg_val);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Update cfg params failed for vdevId %d",
vdev_id);
}
@@ -1739,6 +1746,7 @@ void wma_adjust_ibss_heart_beat_timer(tp_wma_handle wma,
int16_t new_peer_num;
uint16_t new_timer_value_sec;
uint32_t new_timer_value_ms;
QDF_STATUS status;
if (peer_num_delta != 1 && peer_num_delta != -1) {
WMA_LOGE("Invalid peer_num_delta value %d", peer_num_delta);
@@ -1784,9 +1792,10 @@ void wma_adjust_ibss_heart_beat_timer(tp_wma_handle wma,
new_timer_value_ms = ((uint32_t) new_timer_value_sec) * 1000;
if (wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IBSS_MAX_BCN_LOST_MS,
new_timer_value_ms)) {
status = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IBSS_MAX_BCN_LOST_MS,
new_timer_value_ms);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("Failed to set IBSS link monitoring timer value");
return;
}
@@ -2568,6 +2577,7 @@ void wma_send_beacon(tp_wma_handle wma, tpSendbeaconParams bcn_info)
QDF_STATUS status;
uint8_t *p2p_ie;
tpAniBeaconStruct beacon;
struct vdev_up_params param = {0};
beacon = (tpAniBeaconStruct) (bcn_info->beacon);
vdev = wma_find_vdev_by_addr(wma, beacon->macHdr.sa, &vdev_id);
@@ -2604,8 +2614,12 @@ void wma_send_beacon(tp_wma_handle wma, tpSendbeaconParams bcn_info)
return;
}
if (!wma->interfaces[vdev_id].vdev_up) {
if (wmi_unified_vdev_up_send(wma->wmi_handle, vdev_id, 0,
bcn_info->bssId) < 0) {
param.vdev_id = vdev_id;
param.assoc_id = 0;
status = wmi_unified_vdev_up_send(wma->wmi_handle,
bcn_info->bssId,
&param);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("%s : failed to send vdev up", __func__);
return;
}
@@ -2813,7 +2827,7 @@ void wma_process_update_userpos(tp_wma_handle wma_handle,
QDF_STATUS wma_set_htconfig(uint8_t vdev_id, uint16_t ht_capab, int value)
{
tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
int ret = -EIO;
QDF_STATUS ret = QDF_STATUS_E_FAILURE;
if (NULL == wma) {
WMA_LOGE("%s: Failed to get wma", __func__);
@@ -2822,17 +2836,17 @@ QDF_STATUS wma_set_htconfig(uint8_t vdev_id, uint16_t ht_capab, int value)
switch (ht_capab) {
case WNI_CFG_HT_CAP_INFO_ADVANCE_CODING:
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LDPC,
value);
break;
case WNI_CFG_HT_CAP_INFO_TX_STBC:
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TX_STBC,
value);
break;
case WNI_CFG_HT_CAP_INFO_RX_STBC:
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_RX_STBC,
value);
break;
@@ -2840,16 +2854,16 @@ QDF_STATUS wma_set_htconfig(uint8_t vdev_id, uint16_t ht_capab, int value)
case WNI_CFG_HT_CAP_INFO_SHORT_GI_40MHZ:
WMA_LOGE("%s: ht_capab = %d, value = %d", __func__, ht_capab,
value);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_SGI, value);
if (ret == 0)
if (ret == QDF_STATUS_SUCCESS)
wma->interfaces[vdev_id].config.shortgi = value;
break;
default:
WMA_LOGE("%s:INVALID HT CONFIG", __func__);
}
return (ret) ? QDF_STATUS_E_FAILURE : QDF_STATUS_SUCCESS;
return ret;
}
/**
@@ -3380,7 +3394,8 @@ QDF_STATUS wma_register_mgmt_frm_client(
if (wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_MGMT_RX_EVENTID,
wma_mgmt_rx_process) != 0) {
wma_mgmt_rx_process,
WMA_RX_WORK_CTX) != 0) {
WMA_LOGE("Failed to register rx mgmt handler with wmi");
return QDF_STATUS_E_FAILURE;
}

15
core/wma/src/wma_ocb.c
View File

@@ -1087,34 +1087,39 @@ int wma_ocb_register_event_handlers(tp_wma_handle wma_handle)
/* Initialize the members in WMA used by wma_ocb */
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_OCB_SET_CONFIG_RESP_EVENTID,
wma_ocb_set_config_event_handler);
wma_ocb_set_config_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status)
return status;
status = wmi_unified_register_event_handler(
wma_handle->wmi_handle,
WMI_OCB_GET_TSF_TIMER_RESP_EVENTID,
wma_ocb_get_tsf_timer_resp_event_handler);
wma_ocb_get_tsf_timer_resp_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status)
return status;
status = wmi_unified_register_event_handler(
wma_handle->wmi_handle,
WMI_DCC_GET_STATS_RESP_EVENTID,
wma_dcc_get_stats_resp_event_handler);
wma_dcc_get_stats_resp_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status)
return status;
status = wmi_unified_register_event_handler(
wma_handle->wmi_handle,
WMI_DCC_UPDATE_NDL_RESP_EVENTID,
wma_dcc_update_ndl_resp_event_handler);
wma_dcc_update_ndl_resp_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status)
return status;
status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_DCC_STATS_EVENTID,
wma_dcc_stats_event_handler);
wma_dcc_stats_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status)
return status;

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

@@ -70,14 +70,14 @@
#include "wma_internal.h"
/**
* wmi_unified_modem_power_state() - set modem power state to fw
* wma_unified_modem_power_state() - set modem power state to fw
* @wmi_handle: wmi handle
* @param_value: parameter value
*
* Return: 0 for success or error code
*/
static int
wmi_unified_modem_power_state(wmi_unified_t wmi_handle, uint32_t param_value)
wma_unified_modem_power_state(wmi_unified_t wmi_handle, uint32_t param_value)
{
int ret;
wmi_modem_power_state_cmd_param *cmd;
@@ -107,59 +107,42 @@ wmi_unified_modem_power_state(wmi_unified_t wmi_handle, uint32_t param_value)
}
/**
* wmi_unified_set_sta_ps_param() - set sta power save parameter to fw
* wma_unified_set_sta_ps_param() - set sta power save parameter to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @param: param
* @value: parameter value
*
* Return: 0 for success or error code.
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int32_t wmi_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
QDF_STATUS wma_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
uint32_t vdev_id, uint32_t param,
uint32_t value)
{
wmi_sta_powersave_param_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
tp_wma_handle wma;
struct wma_txrx_node *iface;
struct sta_ps_params sta_ps_param = {0};
QDF_STATUS status;
wma = cds_get_context(QDF_MODULE_ID_WMA);
if (NULL == wma) {
WMA_LOGE("%s: wma is NULL", __func__);
return -EIO;
return QDF_STATUS_E_FAILURE;
}
iface = &wma->interfaces[vdev_id];
WMA_LOGD("Set Sta Ps param vdevId %d Param %d val %d",
vdev_id, param, value);
iface = &wma->interfaces[vdev_id];
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGP("%s: Set Sta Ps param Mem Alloc Failed", __func__);
return -ENOMEM;
}
cmd = (wmi_sta_powersave_param_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_sta_powersave_param_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_sta_powersave_param_cmd_fixed_param));
cmd->vdev_id = vdev_id;
cmd->param = param;
cmd->value = value;
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_STA_POWERSAVE_PARAM_CMDID)) {
WMA_LOGE("Set Sta Ps param Failed vdevId %d Param %d val %d",
vdev_id, param, value);
qdf_nbuf_free(buf);
return -EIO;
}
sta_ps_param.vdev_id = vdev_id;
sta_ps_param.param = param;
sta_ps_param.value = value;
status = wmi_unified_sta_ps_cmd_send(wmi_handle, &sta_ps_param);
if (QDF_IS_STATUS_ERROR(status))
return status;
/* Store the PS Status */
iface->ps_enabled = value ? true : false;
return 0;
return status;
}
#ifdef QCA_IBSS_SUPPORT
@@ -173,75 +156,75 @@ int32_t wmi_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
QDF_STATUS
wma_set_ibss_pwrsave_params(tp_wma_handle wma, uint8_t vdev_id)
{
int ret;
QDF_STATUS ret;
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_ATIM_WINDOW_LENGTH,
wma->wma_ibss_power_save_params.atimWindowLength);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed to set WMI_VDEV_PARAM_ATIM_WINDOW_LENGTH ret = %d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED,
wma->wma_ibss_power_save_params.isPowerSaveAllowed);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED,
wma->wma_ibss_power_save_params.isPowerCollapseAllowed);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED,
wma->wma_ibss_power_save_params.isAwakeonTxRxEnabled);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_INACTIVITY_CNT,
wma->wma_ibss_power_save_params.inactivityCount);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_INACTIVITY_CNT ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS,
wma->wma_ibss_power_save_params.txSPEndInactivityTime);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IBSS_PS_WARMUP_TIME_SECS,
wma->wma_ibss_power_save_params.ibssPsWarmupTime);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed, set WMI_VDEV_PARAM_IBSS_PS_WARMUP_TIME_SECS ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_IBSS_PS_1RX_CHAIN_IN_ATIM_WINDOW_ENABLE,
wma->wma_ibss_power_save_params.ibssPs1RxChainInAtimEnable);
if (ret < 0) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed to set IBSS_PS_1RX_CHAIN_IN_ATIM_WINDOW_ENABLE ret=%d",
ret);
return QDF_STATUS_E_FAILURE;
@@ -251,49 +234,6 @@ wma_set_ibss_pwrsave_params(tp_wma_handle wma, uint8_t vdev_id)
}
#endif /* QCA_IBSS_SUPPORT */
/**
* wmi_unified_set_ap_ps_param() - set ap powersave parameters
* @wma_ctx: wma context
* @vdev_id: vdev id
* @peer_addr: peer mac address
* @param: parameter
* @value: prameter value
*
* Return: 0 for success or error code
*/
static int32_t wmi_unified_set_ap_ps_param(void *wma_ctx, uint32_t vdev_id,
uint8_t *peer_addr, uint32_t param,
uint32_t value)
{
tp_wma_handle wma_handle = (tp_wma_handle) wma_ctx;
wmi_ap_ps_peer_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t err;
buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
if (!buf) {
WMA_LOGE("Failed to allocate buffer to send set_ap_ps_param cmd");
return -ENOMEM;
}
cmd = (wmi_ap_ps_peer_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ap_ps_peer_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_ap_ps_peer_cmd_fixed_param));
cmd->vdev_id = vdev_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->param = param;
cmd->value = value;
err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
sizeof(*cmd), WMI_AP_PS_PEER_PARAM_CMDID);
if (err) {
WMA_LOGE("Failed to send set_ap_ps_param cmd");
qdf_mem_free(buf);
return -EIO;
}
return 0;
}
/**
* wma_set_ap_peer_uapsd() - set powersave parameters in ap mode to fw
* @wma: wma handle
@@ -302,15 +242,16 @@ static int32_t wmi_unified_set_ap_ps_param(void *wma_ctx, uint32_t vdev_id,
* @uapsd_value: uapsd value
* @max_sp: maximum service period
*
* Return: 0 for success or error code.
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int32_t wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
QDF_STATUS wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
uint8_t *peer_addr, uint8_t uapsd_value,
uint8_t max_sp)
{
uint32_t uapsd = 0;
uint32_t max_sp_len = 0;
int32_t ret = 0;
QDF_STATUS ret;
struct ap_ps_params param = {0};
if (uapsd_value & UAPSD_VO_ENABLED) {
uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
@@ -349,11 +290,12 @@ int32_t wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
WMA_LOGD("Set WMI_AP_PS_PEER_PARAM_UAPSD 0x%x for %pM",
uapsd, peer_addr);
ret = wmi_unified_set_ap_ps_param(wma, vdev_id,
peer_addr,
WMI_AP_PS_PEER_PARAM_UAPSD, uapsd);
if (ret) {
param.vdev_id = vdev_id;
param.param = WMI_AP_PS_PEER_PARAM_UAPSD;
param.value = uapsd;
ret = wmi_unified_ap_ps_cmd_send(wma->wmi_handle, peer_addr,
&param);
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed to set WMI_AP_PS_PEER_PARAM_UAPSD for %pM",
peer_addr);
return ret;
@@ -362,16 +304,18 @@ int32_t wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
WMA_LOGD("Set WMI_AP_PS_PEER_PARAM_MAX_SP 0x%x for %pM",
max_sp_len, peer_addr);
ret = wmi_unified_set_ap_ps_param(wma, vdev_id,
peer_addr,
WMI_AP_PS_PEER_PARAM_MAX_SP,
max_sp_len);
if (ret) {
param.vdev_id = vdev_id;
param.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
param.value = max_sp_len;
ret = wmi_unified_ap_ps_cmd_send(wma->wmi_handle, peer_addr,
&param);
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Failed to set WMI_AP_PS_PEER_PARAM_MAX_SP for %pM",
peer_addr);
return ret;
}
return 0;
return QDF_STATUS_SUCCESS;
}
/**
@@ -412,7 +356,7 @@ void wma_set_tx_power(WMA_HANDLE handle,
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
uint8_t vdev_id;
int ret = -1;
QDF_STATUS ret = QDF_STATUS_E_FAILURE;
void *pdev;
if (tx_pwr_params->dev_mode == QDF_SAP_MODE ||
@@ -459,20 +403,20 @@ void wma_set_tx_power(WMA_HANDLE handle,
/* tx_power changed, Push the tx_power to FW */
WMA_LOGW("%s: Set TX power limit [WMI_VDEV_PARAM_TX_PWRLIMIT] to %d",
__func__, tx_pwr_params->power);
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
ret = wma_vdev_set_param(wma_handle->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_TX_PWRLIMIT,
tx_pwr_params->power);
if (ret == 0)
if (ret == QDF_STATUS_SUCCESS)
wma_handle->interfaces[vdev_id].tx_power =
tx_pwr_params->power;
} else {
/* no tx_power change */
ret = 0;
ret = QDF_STATUS_SUCCESS;
}
end:
qdf_mem_free(tx_pwr_params);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to set vdev param WMI_VDEV_PARAM_TX_PWRLIMIT");
}
@@ -488,7 +432,7 @@ void wma_set_max_tx_power(WMA_HANDLE handle,
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
uint8_t vdev_id;
int ret = -1;
QDF_STATUS ret = QDF_STATUS_E_FAILURE;
void *pdev;
int8_t prev_max_power;
@@ -515,28 +459,28 @@ void wma_set_max_tx_power(WMA_HANDLE handle,
if (wma_handle->interfaces[vdev_id].max_tx_power ==
tx_pwr_params->power) {
ret = 0;
ret = QDF_STATUS_SUCCESS;
goto end;
}
prev_max_power = wma_handle->interfaces[vdev_id].max_tx_power;
wma_handle->interfaces[vdev_id].max_tx_power = tx_pwr_params->power;
if (wma_handle->interfaces[vdev_id].max_tx_power == 0) {
ret = 0;
ret = QDF_STATUS_SUCCESS;
goto end;
}
WMA_LOGW("Set MAX TX power limit [WMI_VDEV_PARAM_TX_PWRLIMIT] to %d",
wma_handle->interfaces[vdev_id].max_tx_power);
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma_handle->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TX_PWRLIMIT,
wma_handle->interfaces[vdev_id].max_tx_power);
if (ret == 0)
if (ret == QDF_STATUS_SUCCESS)
wma_handle->interfaces[vdev_id].tx_power =
wma_handle->interfaces[vdev_id].max_tx_power;
else
wma_handle->interfaces[vdev_id].max_tx_power = prev_max_power;
end:
qdf_mem_free(tx_pwr_params);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("%s: Failed to set vdev param WMI_VDEV_PARAM_TX_PWRLIMIT",
__func__);
}
@@ -628,14 +572,14 @@ static inline uint32_t wma_get_uapsd_mask(tpUapsd_Params uapsd_params)
* @enable: enable/disable
* @qpower_config: qpower configuration
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static int32_t wma_set_force_sleep(tp_wma_handle wma,
static QDF_STATUS wma_set_force_sleep(tp_wma_handle wma,
uint32_t vdev_id,
uint8_t enable,
enum powersave_qpower_mode qpower_config)
{
int32_t ret;
QDF_STATUS ret;
uint32_t cfg_data_val = 0;
/* get mac to acess CFG data base */
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
@@ -649,7 +593,7 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
if (NULL == mac) {
WMA_LOGE("%s: Unable to get PE context", __func__);
return -ENOMEM;
return QDF_STATUS_E_NOMEM;
}
/* Set Tx/Rx Data InActivity Timeout */
@@ -701,21 +645,21 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
* QPower is enabled by default in Firmware
* So Disable QPower explicitly
*/
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_ENABLE_QPOWER,
qpower_config);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable QPower Failed vdevId %d", vdev_id);
return ret;
}
WMA_LOGD("QPower Disabled vdevId %d", vdev_id);
/* Set the Wake Policy to WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_RX_WAKE_POLICY,
rx_wake_policy);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Setting wake policy Failed vdevId %d", vdev_id);
return ret;
}
@@ -723,11 +667,11 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
rx_wake_policy, vdev_id);
/* Set the Tx Wake Threshold */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD,
tx_wake_threshold);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Setting TxWake Threshold vdevId %d", vdev_id);
return ret;
}
@@ -735,11 +679,11 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
tx_wake_threshold, vdev_id);
/* Set the Ps Poll Count */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_PSPOLL_COUNT,
pspoll_count);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Set Ps Poll Count Failed vdevId %d ps poll cnt %d",
vdev_id, pspoll_count);
return ret;
@@ -748,11 +692,11 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
vdev_id, pspoll_count);
/* Set the Tx/Rx InActivity */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_INACTIVITY_TIME,
inactivity_time);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Setting Tx/Rx InActivity Failed vdevId %d InAct %d",
vdev_id, inactivity_time);
return ret;
@@ -763,7 +707,7 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
/* Enable Sta Mode Power save */
ret = wmi_unified_set_sta_ps(wma->wmi_handle, vdev_id, true);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Sta Mode Ps Failed vdevId %d", vdev_id);
return ret;
}
@@ -776,16 +720,17 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
cfg_data_val = POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
cfg_data_val);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d", vdev_id);
}
WMA_LOGD("Set Listen Interval vdevId %d Listen Intv %d",
vdev_id, cfg_data_val);
return 0;
return QDF_STATUS_SUCCESS;
}
/**
@@ -794,12 +739,12 @@ static int32_t wma_set_force_sleep(tp_wma_handle wma,
* @vdev_id: vdev id
* @enable: value
*
* Return: 0 for success or error code.
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
QDF_STATUS wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
uint8_t enable)
{
int32_t ret;
QDF_STATUS ret;
uint32_t cfg_data_val = 0;
/* get mac to acess CFG data base */
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
@@ -810,7 +755,7 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
if (NULL == mac) {
WMA_LOGE("%s: Unable to get PE context", __func__);
return -ENOMEM;
return QDF_STATUS_E_NOMEM;
}
/* Get Configured Ps Poll Count */
@@ -824,21 +769,21 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
}
/* Enable QPower */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_ENABLE_QPOWER, 1);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable QPower Failed vdevId %d", vdev_id);
return ret;
}
WMA_LOGD("QPower Enabled vdevId %d", vdev_id);
/* Set the Wake Policy to WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_RX_WAKE_POLICY,
WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Setting wake policy to pspoll/uapsd Failed vdevId %d",
vdev_id);
return ret;
@@ -847,11 +792,11 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
if (enable) {
/* Set the Tx Wake Threshold */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD,
WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Setting TxWake Threshold vdevId %d", vdev_id);
return ret;
}
@@ -860,11 +805,11 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
}
/* Set the QPower Ps Poll Count */
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_QPOWER_PSPOLL_COUNT,
pspoll_count);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Set QPower Ps Poll Count Failed vdevId %d ps poll cnt %d",
vdev_id, pspoll_count);
return ret;
@@ -875,7 +820,7 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
/* Enable Sta Mode Power save */
ret = wmi_unified_set_sta_ps(wma->wmi_handle, vdev_id, true);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Sta Mode Ps Failed vdevId %d", vdev_id);
return ret;
}
@@ -888,16 +833,17 @@ int32_t wma_set_qpower_force_sleep(tp_wma_handle wma, uint32_t vdev_id,
cfg_data_val = POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
cfg_data_val);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d", vdev_id);
}
WMA_LOGD("Set Listen Interval vdevId %d Listen Intv %d",
vdev_id, cfg_data_val);
return 0;
return QDF_STATUS_SUCCESS;
}
/**
@@ -947,25 +893,26 @@ static enum powersave_qpower_mode wma_get_qpower_config(tp_wma_handle wma)
void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req)
{
uint32_t vdev_id = ps_req->sessionid;
int32_t ret;
QDF_STATUS ret;
enum powersave_qpower_mode qpower_config = wma_get_qpower_config(wma);
struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
if (!iface->handle) {
WMA_LOGE("vdev id %d is not active", vdev_id);
return;
}
if (eSIR_ADDON_NOTHING == ps_req->psSetting) {
WMA_LOGD("Enable Sta Mode Ps vdevId %d", vdev_id);
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_UAPSD, 0);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Set Uapsd param 0 Failed vdevId %d", vdev_id);
return;
}
ret = wma_set_force_sleep(wma, vdev_id, false,
qpower_config);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Sta Ps Failed vdevId %d", vdev_id);
return;
}
@@ -976,11 +923,11 @@ void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req)
if (uapsd_val != iface->uapsd_cached_val) {
WMA_LOGD("Enable Uapsd vdevId %d Mask %d",
vdev_id, uapsd_val);
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vdev_id,
WMI_STA_PS_PARAM_UAPSD,
uapsd_val);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Uapsd Failed vdevId %d",
vdev_id);
return;
@@ -996,7 +943,7 @@ void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req)
ret = wma_set_force_sleep(wma, vdev_id, true,
qpower_config);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Forced Sleep Failed vdevId %d",
vdev_id);
return;
@@ -1014,14 +961,14 @@ void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req)
*/
void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req)
{
int32_t ret;
QDF_STATUS ret;
uint32_t vdev_id = ps_req->sessionid;
WMA_LOGD("Disable Sta Mode Ps vdevId %d", vdev_id);
/* Disable Sta Mode Power save */
ret = wmi_unified_set_sta_ps(wma->wmi_handle, vdev_id, false);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Sta Mode Ps Failed vdevId %d", vdev_id);
return;
}
@@ -1029,9 +976,9 @@ void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req)
/* Disable UAPSD incase if additional Req came */
if (eSIR_ADDON_DISABLE_UAPSD == ps_req->psSetting) {
WMA_LOGD("Disable Uapsd vdevId %d", vdev_id);
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_UAPSD, 0);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Uapsd Failed vdevId %d", vdev_id);
/*
* Even this fails we can proceed as success
@@ -1050,14 +997,14 @@ void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req)
*/
void wma_enable_uapsd_mode(tp_wma_handle wma, tpEnableUapsdParams ps_req)
{
int32_t ret;
QDF_STATUS ret;
uint32_t vdev_id = ps_req->sessionid;
uint32_t uapsd_val = 0;
enum powersave_qpower_mode qpower_config = wma_get_qpower_config(wma);
/* Disable Sta Mode Power save */
ret = wmi_unified_set_sta_ps(wma->wmi_handle, vdev_id, false);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Sta Mode Ps Failed vdevId %d", vdev_id);
return;
}
@@ -1065,9 +1012,9 @@ void wma_enable_uapsd_mode(tp_wma_handle wma, tpEnableUapsdParams ps_req)
uapsd_val = wma_get_uapsd_mask(&ps_req->uapsdParams);
WMA_LOGD("Enable Uapsd vdevId %d Mask %d", vdev_id, uapsd_val);
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_UAPSD, uapsd_val);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Uapsd Failed vdevId %d", vdev_id);
return;
}
@@ -1075,7 +1022,7 @@ void wma_enable_uapsd_mode(tp_wma_handle wma, tpEnableUapsdParams ps_req)
WMA_LOGD("Enable Forced Sleep vdevId %d", vdev_id);
ret = wma_set_force_sleep(wma, vdev_id, true,
qpower_config);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Enable Forced Sleep Failed vdevId %d", vdev_id);
return;
}
@@ -1092,7 +1039,7 @@ void wma_enable_uapsd_mode(tp_wma_handle wma, tpEnableUapsdParams ps_req)
void wma_disable_uapsd_mode(tp_wma_handle wma,
tpDisableUapsdParams ps_req)
{
int32_t ret;
QDF_STATUS ret;
uint32_t vdev_id = ps_req->sessionid;
enum powersave_qpower_mode qpower_config = wma_get_qpower_config(wma);
@@ -1100,14 +1047,14 @@ void wma_disable_uapsd_mode(tp_wma_handle wma,
/* Disable Sta Mode Power save */
ret = wmi_unified_set_sta_ps(wma->wmi_handle, vdev_id, false);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Sta Mode Ps Failed vdevId %d", vdev_id);
return;
}
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_UAPSD, 0);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Uapsd Failed vdevId %d", vdev_id);
return;
}
@@ -1115,14 +1062,14 @@ void wma_disable_uapsd_mode(tp_wma_handle wma,
/* Re enable Sta Mode Powersave with proper configuration */
ret = wma_set_force_sleep(wma, vdev_id, false,
qpower_config);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
WMA_LOGE("Disable Forced Sleep Failed vdevId %d", vdev_id);
return;
}
}
/**
* wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command
* wma_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command
* @wmi_handle: wma handle
* @vdevid: vdev id
* @peer_addr: peer mac address
@@ -1138,7 +1085,7 @@ void wma_disable_uapsd_mode(tp_wma_handle wma,
* Return: 0 for success or error code.
*/
int32_t
wmi_unified_set_sta_uapsd_auto_trig_cmd(wmi_unified_t wmi_handle,
wma_unified_set_sta_uapsd_auto_trig_cmd(wmi_unified_t wmi_handle,
uint32_t vdevid,
uint8_t peer_addr[IEEE80211_ADDR_LEN],
uint8_t *autoTriggerparam,
@@ -1244,7 +1191,7 @@ QDF_STATUS wma_trigger_uapsd_params(tp_wma_handle wma_handle, uint32_t vdev_id,
uapsd_trigger_param.delay_interval =
trigger_uapsd_params->delay_interval;
ret = wmi_unified_set_sta_uapsd_auto_trig_cmd(wma_handle->wmi_handle,
ret = wma_unified_set_sta_uapsd_auto_trig_cmd(wma_handle->wmi_handle,
vdev_id, wma_handle->interfaces[vdev_id].bssid,
(uint8_t *) (&uapsd_trigger_param), 1);
if (ret) {
@@ -1313,7 +1260,7 @@ QDF_STATUS wma_disable_uapsd_per_ac(tp_wma_handle wma_handle,
uapsd_trigger_param.suspend_interval = 0;
uapsd_trigger_param.delay_interval = 0;
ret = wmi_unified_set_sta_uapsd_auto_trig_cmd(wma_handle->wmi_handle,
ret = wma_unified_set_sta_uapsd_auto_trig_cmd(wma_handle->wmi_handle,
vdev_id, wma_handle->interfaces[vdev_id].bssid,
(uint8_t *)(&uapsd_trigger_param), 1);
if (ret) {
@@ -1322,7 +1269,7 @@ QDF_STATUS wma_disable_uapsd_per_ac(tp_wma_handle wma_handle,
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_set_sta_ps_param(wma_handle->wmi_handle, vdev_id,
ret = wma_unified_set_sta_ps_param(wma_handle->wmi_handle, vdev_id,
WMI_STA_PS_PARAM_UAPSD,
iface->uapsd_cached_val);
if (ret) {
@@ -1427,6 +1374,7 @@ QDF_STATUS wma_process_tx_power_limits(WMA_HANDLE handle,
int32_t ret = 0;
uint32_t txpower_params2g = 0;
uint32_t txpower_params5g = 0;
struct pdev_params pdevparam;
if (!wma || !wma->wmi_handle) {
WMA_LOGE("%s: WMA is closed, can not issue tx power limit",
@@ -1446,16 +1394,20 @@ QDF_STATUS wma_process_tx_power_limits(WMA_HANDLE handle,
WMA_LOGD("%s: txpower2g: %x txpower5g: %x",
__func__, txpower_params2g, txpower_params5g);
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_TXPOWER_LIMIT2G,
txpower_params2g);
pdevparam.param_id = WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
pdevparam.param_value = txpower_params2g;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdevparam,
WMA_WILDCARD_PDEV_ID);
if (ret) {
WMA_LOGE("%s: Failed to set txpower 2g (%d)", __func__, ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_TXPOWER_LIMIT5G,
txpower_params5g);
pdevparam.param_id = WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
pdevparam.param_value = txpower_params5g;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdevparam,
WMA_WILDCARD_PDEV_ID);
if (ret) {
WMA_LOGE("%s: Failed to set txpower 5g (%d)", __func__, ret);
return QDF_STATUS_E_FAILURE;
@@ -1976,7 +1928,7 @@ QDF_STATUS wma_notify_modem_power_state(void *wma_ptr,
WMA_LOGD("%s: WMA notify Modem Power State %d", __func__, pReq->param);
ret = wmi_unified_modem_power_state(wma->wmi_handle, pReq->param);
ret = wma_unified_modem_power_state(wma->wmi_handle, pReq->param);
if (ret) {
WMA_LOGE("%s: Fail to notify Modem Power State %d",
__func__, pReq->param);
@@ -1998,13 +1950,17 @@ QDF_STATUS wma_set_idle_ps_config(void *wma_ptr, uint32_t idle_ps)
{
int32_t ret;
tp_wma_handle wma = (tp_wma_handle) wma_ptr;
struct pdev_params pdevparam;
WMA_LOGD("WMA Set Idle Ps Config [1:set 0:clear] val %d", idle_ps);
/* Set Idle Mode Power Save Config */
ret = wmi_unified_pdev_set_param(wma->wmi_handle,
WMI_PDEV_PARAM_IDLE_PS_CONFIG,
idle_ps);
pdevparam.param_id = WMI_PDEV_PARAM_IDLE_PS_CONFIG;
pdevparam.param_value = idle_ps;
ret = wmi_unified_pdev_param_send(wma->wmi_handle,
&pdevparam,
WMA_WILDCARD_PDEV_ID);
if (ret) {
WMA_LOGE("Fail to Set Idle Ps Config %d", idle_ps);
return QDF_STATUS_E_FAILURE;
@@ -2074,7 +2030,7 @@ static void wma_set_vdev_suspend_dtim(tp_wma_handle wma, uint8_t vdev_id)
if ((iface->type == WMI_VDEV_TYPE_STA) &&
(iface->ps_enabled == true) &&
(iface->dtimPeriod != 0)) {
int32_t ret;
QDF_STATUS ret;
uint32_t listen_interval;
uint32_t max_mod_dtim;
@@ -2105,10 +2061,10 @@ static void wma_set_vdev_suspend_dtim(tp_wma_handle wma, uint8_t vdev_id)
return;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
listen_interval);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d",
vdev_id);
@@ -2119,20 +2075,20 @@ static void wma_set_vdev_suspend_dtim(tp_wma_handle wma, uint8_t vdev_id)
if (qpower_config) {
WMA_LOGD("disable Qpower in suspend mode!");
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vdev_id,
WMI_STA_PS_ENABLE_QPOWER,
0);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to disable Qpower in suspend mode!");
iface->ps_enabled = true;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_DTIM_POLICY,
NORMAL_DTIM);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to Set to Normal DTIM vdevId %d",
vdev_id);
@@ -2180,7 +2136,7 @@ static void wma_set_vdev_resume_dtim(tp_wma_handle wma, uint8_t vdev_id)
if ((iface->type == WMI_VDEV_TYPE_STA) &&
(iface->ps_enabled == true) &&
(iface->dtim_policy == NORMAL_DTIM)) {
int32_t ret;
QDF_STATUS ret;
uint32_t cfg_data_val = 0;
/* get mac to acess CFG data base */
struct sAniSirGlobal *mac = cds_get_context(QDF_MODULE_ID_PE);
@@ -2194,10 +2150,10 @@ static void wma_set_vdev_resume_dtim(tp_wma_handle wma, uint8_t vdev_id)
cfg_data_val = POWERSAVE_DEFAULT_LISTEN_INTERVAL;
}
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_LISTEN_INTERVAL,
cfg_data_val);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
/* Even it fails continue Fw will take default LI */
WMA_LOGE("Failed to Set Listen Interval vdevId %d",
vdev_id);
@@ -2206,10 +2162,10 @@ static void wma_set_vdev_resume_dtim(tp_wma_handle wma, uint8_t vdev_id)
WMA_LOGD("Set Listen Interval vdevId %d Listen Intv %d",
vdev_id, cfg_data_val);
ret = wmi_unified_vdev_set_param_send(wma->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_DTIM_POLICY,
STICK_DTIM);
if (ret) {
if (QDF_IS_STATUS_ERROR(ret)) {
/* Set it back to Stick DTIM */
WMA_LOGE("Failed to Set to Stick DTIM vdevId %d",
vdev_id);
@@ -2219,11 +2175,11 @@ static void wma_set_vdev_resume_dtim(tp_wma_handle wma, uint8_t vdev_id)
if (qpower_config) {
WMA_LOGD("enable Qpower in resume mode!");
ret = wmi_unified_set_sta_ps_param(wma->wmi_handle,
ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
vdev_id,
WMI_STA_PS_ENABLE_QPOWER,
1);
if (ret)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Failed to enable Qpower in resume mode!");
}
}
@@ -2261,9 +2217,10 @@ void wma_set_resume_dtim(tp_wma_handle wma)
*/
QDF_STATUS wma_set_tx_power_scale(uint8_t vdev_id, int value)
{
int ret = QDF_STATUS_SUCCESS;
QDF_STATUS ret = QDF_STATUS_SUCCESS;
tp_wma_handle wma_handle =
(tp_wma_handle)cds_get_context(QDF_MODULE_ID_WMA);
if (NULL == wma_handle) {
WMA_LOGE("%s: wma_handle is NULL", __func__);
return QDF_STATUS_E_FAILURE;
@@ -2274,9 +2231,9 @@ QDF_STATUS wma_set_tx_power_scale(uint8_t vdev_id, int value)
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma_handle->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TXPOWER_SCALE, value);
if (ret != 0)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Set tx power scale failed");
return ret;
@@ -2291,9 +2248,10 @@ QDF_STATUS wma_set_tx_power_scale(uint8_t vdev_id, int value)
*/
QDF_STATUS wma_set_tx_power_scale_decr_db(uint8_t vdev_id, int value)
{
int ret = QDF_STATUS_SUCCESS;
QDF_STATUS ret = QDF_STATUS_SUCCESS;
tp_wma_handle wma_handle =
(tp_wma_handle)cds_get_context(QDF_MODULE_ID_WMA);
if (NULL == wma_handle) {
WMA_LOGE("%s: wma_handle is NULL", __func__);
return QDF_STATUS_E_FAILURE;
@@ -2304,9 +2262,9 @@ QDF_STATUS wma_set_tx_power_scale_decr_db(uint8_t vdev_id, int value)
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle, vdev_id,
ret = wma_vdev_set_param(wma_handle->wmi_handle, vdev_id,
WMI_VDEV_PARAM_TXPOWER_SCALE_DECR_DB, value);
if (ret != 0)
if (QDF_IS_STATUS_ERROR(ret))
WMA_LOGE("Decrease tx power value failed");
return ret;

69
core/wma/src/wma_scan_roam.c
View File

@@ -2021,32 +2021,32 @@ QDF_STATUS wma_roam_scan_bmiss_cnt(tp_wma_handle wma_handle,
A_INT32 first_bcnt,
A_UINT32 final_bcnt, uint32_t vdev_id)
{
int status = 0;
QDF_STATUS status;
WMA_LOGI("%s: first_bcnt=%d, final_bcnt=%d", __func__, first_bcnt,
final_bcnt);
status = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
status = wma_vdev_set_param(wma_handle->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_BMISS_FIRST_BCNT,
first_bcnt);
if (status != EOK) {
WMA_LOGE("wmi_unified_vdev_set_param_send WMI_VDEV_PARAM_BMISS_FIRST_BCNT returned Error %d",
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("wma_vdev_set_param WMI_VDEV_PARAM_BMISS_FIRST_BCNT returned Error %d",
status);
return QDF_STATUS_E_FAILURE;
return status;
}
status = wmi_unified_vdev_set_param_send(wma_handle->wmi_handle,
status = wma_vdev_set_param(wma_handle->wmi_handle,
vdev_id,
WMI_VDEV_PARAM_BMISS_FINAL_BCNT,
final_bcnt);
if (status != EOK) {
WMA_LOGE("wmi_unified_vdev_set_param_send WMI_VDEV_PARAM_BMISS_FINAL_BCNT returned Error %d",
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("wma_vdev_set_param WMI_VDEV_PARAM_BMISS_FINAL_BCNT returned Error %d",
status);
return QDF_STATUS_E_FAILURE;
return status;
}
return QDF_STATUS_SUCCESS;
return status;
}
/**
@@ -4121,39 +4121,48 @@ void wma_register_extscan_event_handler(tp_wma_handle wma_handle)
}
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_START_STOP_EVENTID,
wma_extscan_start_stop_event_handler);
wma_extscan_start_stop_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_CAPABILITIES_EVENTID,
wma_extscan_capabilities_event_handler);
WMI_EXTSCAN_CAPABILITIES_EVENTID,
wma_extscan_capabilities_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_HOTLIST_MATCH_EVENTID,
wma_extscan_hotlist_match_event_handler);
WMI_EXTSCAN_HOTLIST_MATCH_EVENTID,
wma_extscan_hotlist_match_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID,
wma_extscan_change_results_event_handler);
WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID,
wma_extscan_change_results_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_OPERATION_EVENTID,
wma_extscan_operations_event_handler);
WMI_EXTSCAN_OPERATION_EVENTID,
wma_extscan_operations_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_TABLE_USAGE_EVENTID,
wma_extscan_table_usage_event_handler);
WMI_EXTSCAN_TABLE_USAGE_EVENTID,
wma_extscan_table_usage_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_CACHED_RESULTS_EVENTID,
wma_extscan_cached_results_event_handler);
WMI_EXTSCAN_CACHED_RESULTS_EVENTID,
wma_extscan_cached_results_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PASSPOINT_MATCH_EVENTID,
wma_passpoint_match_event_handler);
wma_passpoint_match_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_EXTSCAN_HOTLIST_SSID_MATCH_EVENTID,
wma_extscan_hotlist_ssid_match_event_handler);
wma_extscan_hotlist_ssid_match_event_handler,
WMA_RX_SERIALIZER_CTX);
return;
}
@@ -6040,6 +6049,7 @@ QDF_STATUS wma_ipa_offload_enable_disable(tp_wma_handle wma,
ol_txrx_vdev_handle vdev;
struct txrx_pdev_cfg_t *cfg;
int32_t intra_bss_fwd = 0;
QDF_STATUS status;
if (!wma || !wma->wmi_handle) {
WMA_LOGE("%s: WMA is closed, can not issue cmd",
@@ -6109,14 +6119,15 @@ QDF_STATUS wma_ipa_offload_enable_disable(tp_wma_handle wma,
}
/* Disable/enable WMI_VDEV_PARAM_INTRA_BSS_FWD */
if (wmi_unified_vdev_set_param_send(wma->wmi_handle,
status = wma_vdev_set_param(wma->wmi_handle,
ipa_offload->vdev_id, WMI_VDEV_PARAM_INTRA_BSS_FWD,
intra_bss_fwd)) {
intra_bss_fwd);
if (QDF_IS_STATUS_ERROR(status)) {
WMA_LOGE("Failed to disable WMI_VDEV_PARAM_INTRA_BSS_FWD");
return QDF_STATUS_E_FAILURE;
return status;
}
return QDF_STATUS_SUCCESS;
return status;
}
/** wma_set_epno_network_list() - set epno network list

189
core/wma/src/wma_utils.c
View File

@@ -69,7 +69,7 @@
#include "dfs.h"
#include "wma_internal.h"
#include "cds_concurrency.h"
#include "wmi_unified_param.h"
#include "linux/ieee80211.h"
/* MCS Based rate table */
@@ -764,14 +764,17 @@ void wma_register_ll_stats_event_handler(tp_wma_handle wma_handle)
}
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_IFACE_LINK_STATS_EVENTID,
wma_unified_link_iface_stats_event_handler);
WMI_IFACE_LINK_STATS_EVENTID,
wma_unified_link_iface_stats_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_LINK_STATS_EVENTID,
wma_unified_link_peer_stats_event_handler);
WMI_PEER_LINK_STATS_EVENTID,
wma_unified_link_peer_stats_event_handler,
WMA_RX_SERIALIZER_CTX);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_RADIO_LINK_STATS_EVENTID,
wma_unified_link_radio_stats_event_handler);
WMI_RADIO_LINK_STATS_EVENTID,
wma_unified_link_radio_stats_event_handler,
WMA_RX_SERIALIZER_CTX);
return;
}
@@ -1952,46 +1955,6 @@ int32_t wma_set_txrx_fw_stats_level(tp_wma_handle wma_handle,
return 0;
}
/**
* wmi_crash_inject() - inject fw crash
* @wma_handle: wma handle
* @type: type
* @delay_time_ms: delay time in ms
*
* Return: 0 for success or return error
*/
int wmi_crash_inject(wmi_unified_t wmi_handle, uint32_t type,
uint32_t delay_time_ms)
{
int ret = 0;
WMI_FORCE_FW_HANG_CMD_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
wmi_buf_t buf;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
WMA_LOGE("%s: wmi_buf_alloc failed!", __func__);
return -ENOMEM;
}
cmd = (WMI_FORCE_FW_HANG_CMD_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_WMI_FORCE_FW_HANG_CMD_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(WMI_FORCE_FW_HANG_CMD_fixed_param));
cmd->type = type;
cmd->delay_time_ms = delay_time_ms;
ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_FORCE_FW_HANG_CMDID);
if (ret < 0) {
WMA_LOGE("%s: Failed to send set param command, ret = %d",
__func__, ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* wma_get_stats_rsp_buf() - fill get stats response buffer
* @get_stats_param: get stats parameters
@@ -2333,7 +2296,7 @@ static int
wma_process_utf_event(WMA_HANDLE handle, uint8_t *datap, uint32_t dataplen)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
SEG_HDR_INFO_STRUCT segHdrInfo;
struct seg_hdr_info segHdrInfo;
uint8_t totalNumOfSegments, currentSeq;
WMI_PDEV_UTF_EVENTID_param_tlvs *param_buf;
uint8_t *data;
@@ -2347,7 +2310,7 @@ wma_process_utf_event(WMA_HANDLE handle, uint8_t *datap, uint32_t dataplen)
data = param_buf->data;
datalen = param_buf->num_data;
segHdrInfo = *(SEG_HDR_INFO_STRUCT *) &(data[0]);
segHdrInfo = *(struct seg_hdr_info *) &(data[0]);
wma_handle->utf_event_info.currentSeq = (segHdrInfo.segmentInfo & 0xF);
@@ -2423,113 +2386,31 @@ void wma_utf_attach(tp_wma_handle wma_handle)
ret = wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PDEV_UTF_EVENTID,
wma_process_utf_event);
wma_process_utf_event,
WMA_RX_SERIALIZER_CTX);
if (ret)
WMA_LOGP("%s: Failed to register UTF event callback", __func__);
}
/**
* wmi_unified_pdev_utf_cmd() - send utf command to fw
* @wmi_handle: wmi handle
* @utf_payload: utf payload
* @len: length
*
* Return: 0 for success or error code
*/
static int
wmi_unified_pdev_utf_cmd(wmi_unified_t wmi_handle, uint8_t *utf_payload,
uint16_t len)
{
wmi_buf_t buf;
uint8_t *cmd;
int ret = 0;
static uint8_t msgref = 1;
uint8_t segNumber = 0, segInfo, numSegments;
uint16_t chunk_len, total_bytes;
uint8_t *bufpos;
SEG_HDR_INFO_STRUCT segHdrInfo;
bufpos = utf_payload;
total_bytes = len;
ASSERT(total_bytes / MAX_WMI_UTF_LEN ==
(uint8_t) (total_bytes / MAX_WMI_UTF_LEN));
numSegments = (uint8_t) (total_bytes / MAX_WMI_UTF_LEN);
if (len - (numSegments * MAX_WMI_UTF_LEN))
numSegments++;
while (len) {
if (len > MAX_WMI_UTF_LEN)
chunk_len = MAX_WMI_UTF_LEN; /* MAX messsage */
else
chunk_len = len;
buf = wmi_buf_alloc(wmi_handle,
(chunk_len + sizeof(segHdrInfo) +
WMI_TLV_HDR_SIZE));
if (!buf) {
WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
return -ENOMEM;
}
cmd = (uint8_t *) wmi_buf_data(buf);
segHdrInfo.len = total_bytes;
segHdrInfo.msgref = msgref;
segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF);
segHdrInfo.segmentInfo = segInfo;
segHdrInfo.pad = 0;
WMA_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
" segHdrInfo.segmentInfo = %d",
__func__, segHdrInfo.len, segHdrInfo.msgref,
segHdrInfo.segmentInfo);
WMA_LOGD("%s:total_bytes %d segNumber %d totalSegments %d"
"chunk len %d", __func__, total_bytes, segNumber,
numSegments, chunk_len);
segNumber++;
WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE,
(chunk_len + sizeof(segHdrInfo)));
cmd += WMI_TLV_HDR_SIZE;
memcpy(cmd, &segHdrInfo, sizeof(segHdrInfo)); /* 4 bytes */
memcpy(&cmd[sizeof(segHdrInfo)], bufpos, chunk_len);
ret = wmi_unified_cmd_send(wmi_handle, buf,
(chunk_len + sizeof(segHdrInfo) +
WMI_TLV_HDR_SIZE),
WMI_PDEV_UTF_CMDID);
if (ret != EOK) {
WMA_LOGE("Failed to send WMI_PDEV_UTF_CMDID command");
wmi_buf_free(buf);
break;
}
len -= chunk_len;
bufpos += chunk_len;
}
msgref++;
return ret;
}
/**
* wma_utf_cmd() - utf command
* @wma_handle: wma handle
* @data: data
* @len: length
*
* Return: 0 for success or error code
* Return: QDF_STATUS_SUCCESS for success or error code
*/
int wma_utf_cmd(tp_wma_handle wma_handle, uint8_t *data, uint16_t len)
QDF_STATUS wma_utf_cmd(tp_wma_handle wma_handle, uint8_t *data, uint16_t len)
{
struct pdev_utf_params param = {0};
wma_handle->utf_event_info.length = 0;
return wmi_unified_pdev_utf_cmd(wma_handle->wmi_handle, data, len);
param.utf_payload = data;
param.len = len;
return wmi_unified_pdev_utf_cmd_send(wma_handle->wmi_handle, &param,
WMA_WILDCARD_PDEV_ID);
}
/**
@@ -3636,3 +3517,27 @@ uint32_t wma_get_vht_ch_width(void)
return fw_ch_wd;
}
/**
* wma_config_debug_module_cmd - set debug log config
* @wmi_handle: wmi layer handle
* @param: debug log parameter
* @val: debug log value
* @module_id_bitmap: debug module id bitmap
* @bitmap_len: debug module bitmap length
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS
wma_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
A_UINT32 val, A_UINT32 *module_id_bitmap,
A_UINT32 bitmap_len)
{
struct dbglog_params dbg_param;
dbg_param.param = param;
dbg_param.val = val;
dbg_param.module_id_bitmap = module_id_bitmap;
dbg_param.bitmap_len = bitmap_len;
return wmi_unified_dbglog_cmd_send(wmi_handle, &dbg_param);
}