A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-08 21:22:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Add wma handler for vdev delete and peer delete responses

Browse source 
- Add handler for the vdev delete and peer delete response at WMA.
- As part of timeout handler, assert if the response is not
  received in 3 seconds.

Change-Id: I7b20254013266414174f686e1f3918822adc65d8
CRs-fixed: 960173
This commit is contained in:
Sandeep Puligilla 2016-01-05 12:18:02 -08:00 • committed by Akash Patel
commit 19ddda272c
6 changed files with 431 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

4
core/utils/host_diag_log/inc/host_diag_core_event.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
* Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -332,6 +332,7 @@ enum wifi_connectivity_events {
* @WIFI_POWER_EVENT_WAKELOCK_PNO: PNO feature related
* @WIFI_POWER_EVENT_WAKELOCK_DEL_STA: Deletion of a station
* @WIFI_POWER_EVENT_WAKELOCK_DFS: DFS related wakelocks
* @WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP: Firmware response
* @WIFI_POWER_EVENT_WAKELOCK_MISC: Miscellaneous wakelocks
*
* Indicates the reason for which the wakelock was taken/released
@ -353,6 +354,7 @@ enum wake_lock_reason {
WIFI_POWER_EVENT_WAKELOCK_PNO,
WIFI_POWER_EVENT_WAKELOCK_DEL_STA,
WIFI_POWER_EVENT_WAKELOCK_DFS,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP,
WIFI_POWER_EVENT_WAKELOCK_MISC,
};

10
core/wma/inc/wma.h
View file

@ -243,6 +243,11 @@
#define WMA_PEER_ASSOC_CNF_START 0x01
#define WMA_PEER_ASSOC_TIMEOUT (3000) /* 3 seconds */
#define WMA_DELETE_STA_RSP_START 0x02
#define WMA_DELETE_STA_TIMEOUT (6000) /* 6 seconds */
#define WMA_DEL_P2P_SELF_STA_RSP_START 0x03
#define WMA_VDEV_START_REQUEST_TIMEOUT (3000) /* 3 seconds */
#define WMA_VDEV_STOP_REQUEST_TIMEOUT (3000) /* 3 seconds */
@ -300,6 +305,7 @@
#define WMA_AUTO_SHUTDOWN_WAKE_LOCK_DURATION (5 * 1000) /* in msec */
#endif
#define WMA_BMISS_EVENT_WAKE_LOCK_DURATION (4 * 1000) /* in msec */
#define WMA_FW_RSP_EVENT_WAKE_LOCK_DURATION (3 * 1000) /* in msec */
#define WMA_TXMIC_LEN 8
#define WMA_RXMIC_LEN 8
@ -1188,6 +1194,8 @@ struct wmi_init_cmd {
* handle of other modules.
* @saved_wmi_init_cmd: Saved WMI INIT command
* @service_ready_ext_evt: Wait event for service ready ext
* @wmi_cmd_rsp_wake_lock: wmi command response wake lock
* @wmi_cmd_rsp_runtime_lock: wmi command response bus lock
*/
typedef struct {
void *wmi_handle;
@ -1373,6 +1381,8 @@ typedef struct {
CDF_STATUS (*pe_roam_synch_cb)(tpAniSirGlobal mac,
roam_offload_synch_ind *roam_synch_data,
tpSirBssDescription bss_desc_ptr);
cdf_wake_lock_t wmi_cmd_rsp_wake_lock;
cdf_runtime_lock_t wmi_cmd_rsp_runtime_lock;
} t_wma_handle, *tp_wma_handle;
/**

10
core/wma/inc/wma_if.h
View file

@ -1287,6 +1287,16 @@ struct del_sta_self_params {
uint32_t status;
};
/**
* struct del_sta_self_rsp_params - Del Sta Self response params
* @self_sta_param: sta params
* @generate_rsp: generate response to upper layers
*/
struct del_sta_self_rsp_params {
struct del_sta_self_params *self_sta_param;
uint8_t generate_rsp;
};
/**
* struct tP2pPsParams - P2P powersave related params
* @opp_ps: opportunistic power save

6
core/wma/inc/wma_internal.h
View file

@ -1169,5 +1169,11 @@ CDF_STATUS wma_process_set_ie_info(tp_wma_handle wma,
struct vdev_ie_info *ie_info);
int wma_peer_assoc_conf_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len);
int wma_vdev_delete_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len);
int wma_peer_delete_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len);
void wma_remove_req(tp_wma_handle wma, uint8_t vdev_id,
uint8_t type);
#endif

489
core/wma/src/wma_dev_if.c
View file

@ -297,6 +297,9 @@ static int wma_unified_vdev_delete_send(wmi_unified_t wmi_handle, uint8_t if_id)
* @vdev_id: vdev id
* @type: request type
*
* Find target request for given vdev id & type of request.
* Remove that request from active list.
*
* Return: return target request if found or NULL.
*/
static struct wma_target_req *wma_find_req(tp_wma_handle wma,
@ -349,6 +352,68 @@ static struct wma_target_req *wma_find_req(tp_wma_handle wma,
return req_msg;
}
/**
* wma_find_remove_req_msgtype() - find and remove request for vdev id
* @wma: wma handle
* @vdev_id: vdev id
* @msg_type: message request type
*
* Find target request for given vdev id & sub type of request.
* Remove the same from active list.
*
* Return: Success if request found, failure other wise
*/
static struct wma_target_req *wma_find_remove_req_msgtype(tp_wma_handle wma,
uint8_t vdev_id, uint32_t msg_type)
{
struct wma_target_req *req_msg = NULL;
bool found = false;
cdf_list_node_t *node1 = NULL, *node2 = NULL;
CDF_STATUS status;
cdf_spin_lock_bh(&wma->wma_hold_req_q_lock);
if (CDF_STATUS_SUCCESS != cdf_list_peek_front(&wma->wma_hold_req_queue,
&node2)) {
cdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
WMA_LOGE(FL("unable to get msg node from request queue"));
return NULL;
}
do {
node1 = node2;
req_msg = cdf_container_of(node1, struct wma_target_req, node);
if (req_msg->vdev_id != vdev_id)
continue;
if (req_msg->msg_type != msg_type)
continue;
found = true;
status = cdf_list_remove_node(&wma->wma_hold_req_queue, node1);
if (CDF_STATUS_SUCCESS != status) {
cdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
WMA_LOGD(FL("Failed to remove request. vdev_id %d type %d"),
vdev_id, msg_type);
return NULL;
}
break;
} while (CDF_STATUS_SUCCESS ==
cdf_list_peek_next(&wma->wma_hold_req_queue, node1,
&node2));
cdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
if (!found) {
WMA_LOGE(FL("target request not found for vdev_id %d type %d"),
vdev_id, msg_type);
return NULL;
}
WMA_LOGD(FL("target request found for vdev id: %d type %d"),
vdev_id, msg_type);
return req_msg;
}
/**
* wma_find_vdev_req() - find target request for vdev id
* @wma: wma handle
@ -428,21 +493,24 @@ void wma_vdev_detach_callback(void *ctx)
return;
}
param = (struct del_sta_self_params *) iface->del_staself_req;
WMA_LOGD("%s: sending eWNI_SME_DEL_STA_SELF_RSP for vdev %d",
WMA_LOGE("%s: sending eWNI_SME_DEL_STA_SELF_RSP for vdev %d",
__func__, param->session_id);
req_msg = wma_find_vdev_req(wma, param->session_id,
WMA_TARGET_REQ_TYPE_VDEV_DEL);
if (req_msg) {
WMA_LOGD("%s: Found vdev request for vdev id %d",
__func__, param->session_id);
cdf_mc_timer_stop(&req_msg->event_timeout);
cdf_mc_timer_destroy(&req_msg->event_timeout);
cdf_mem_free(req_msg);
if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS)) {
req_msg = wma_find_vdev_req(wma, param->session_id,
WMA_TARGET_REQ_TYPE_VDEV_DEL);
if (req_msg) {
WMA_LOGD("%s: Found vdev request for vdev id %d",
__func__, param->session_id);
cdf_mc_timer_stop(&req_msg->event_timeout);
cdf_mc_timer_destroy(&req_msg->event_timeout);
cdf_mem_free(req_msg);
}
}
if (iface->addBssStaContext)
cdf_mem_free(iface->addBssStaContext);
#if defined WLAN_FEATURE_VOWIFI_11R
if (iface->staKeyParams)
cdf_mem_free(iface->staKeyParams);
@ -460,6 +528,150 @@ void wma_vdev_detach_callback(void *ctx)
}
}
/**
* wma_self_peer_remove() - Self peer remove handler
* @wma: wma handle
* @del_sta_self_req_param: vdev id
* @generate_vdev_rsp: request type
*
* Return: success if peer delete command sent to firmware, else failure.
*/
static CDF_STATUS wma_self_peer_remove(tp_wma_handle wma_handle,
struct del_sta_self_params *del_sta_self_req_param,
uint8_t generate_vdev_rsp)
{
ol_txrx_peer_handle peer;
ol_txrx_pdev_handle pdev;
uint8_t peer_id;
uint8_t vdev_id = del_sta_self_req_param->session_id;
struct wma_target_req *msg = NULL;
struct del_sta_self_rsp_params *sta_self_wmi_rsp;
WMA_LOGE("P2P Device: removing self peer %pM",
del_sta_self_req_param->self_mac_addr);
pdev = cds_get_context(CDF_MODULE_ID_TXRX);
if (NULL == pdev) {
WMA_LOGE("%s: Failed to get pdev", __func__);
return CDF_STATUS_E_FAULT;
}
peer = ol_txrx_find_peer_by_addr(pdev,
del_sta_self_req_param->self_mac_addr,
&peer_id);
if (!peer) {
WMA_LOGE("%s Failed to find peer %pM", __func__,
del_sta_self_req_param->self_mac_addr);
return CDF_STATUS_SUCCESS;
}
wma_remove_peer(wma_handle,
del_sta_self_req_param->self_mac_addr,
vdev_id, peer, false);
if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS)) {
sta_self_wmi_rsp =
cdf_mem_malloc(sizeof(struct del_sta_self_rsp_params));
if (sta_self_wmi_rsp == NULL) {
WMA_LOGP(FL("Failed to allocate memory"));
return CDF_STATUS_E_NOMEM;
}
sta_self_wmi_rsp->self_sta_param = del_sta_self_req_param;
sta_self_wmi_rsp->generate_rsp = generate_vdev_rsp;
msg = wma_fill_hold_req(wma_handle, vdev_id,
WMA_DELETE_STA_REQ,
WMA_DEL_P2P_SELF_STA_RSP_START,
sta_self_wmi_rsp,
WMA_DELETE_STA_TIMEOUT);
if (!msg) {
WMA_LOGP(FL("Failed to allocate request for vdev_id %d"),
vdev_id);
wma_remove_req(wma_handle, vdev_id,
WMA_DEL_P2P_SELF_STA_RSP_START);
return CDF_STATUS_E_FAILURE;
}
}
return CDF_STATUS_SUCCESS;
}
static CDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
struct del_sta_self_params *del_sta_self_req_param,
uint8_t generate_rsp)
{
CDF_STATUS status = CDF_STATUS_SUCCESS;
uint8_t vdev_id = del_sta_self_req_param->session_id;
struct wma_txrx_node *iface = &wma_handle->interfaces[vdev_id];
struct wma_target_req *msg = NULL;
cds_msg_t sme_msg = { 0 };
if (wma_unified_vdev_delete_send(wma_handle->wmi_handle, vdev_id)) {
WMA_LOGE("Unable to remove an interface");
status = CDF_STATUS_E_FAILURE;
goto out;
}
WMA_LOGE("vdev_id:%hu vdev_hdl:%p", vdev_id, iface->handle);
if (!generate_rsp) {
WMA_LOGE("Call txrx detach w/o callback for vdev %d", vdev_id);
ol_txrx_vdev_detach(iface->handle, NULL, NULL);
goto out;
}
iface->del_staself_req = del_sta_self_req_param;
msg = wma_fill_vdev_req(wma_handle, vdev_id, WMA_DEL_STA_SELF_REQ,
WMA_TARGET_REQ_TYPE_VDEV_DEL, iface, 6000);
if (!msg) {
WMA_LOGE("%s: Failed to fill vdev request for vdev_id %d",
__func__, vdev_id);
status = CDF_STATUS_E_NOMEM;
goto out;
}
/* Acquire wake lock only when you expect a response from firmware */
if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS)) {
cdf_wake_lock_timeout_acquire(
&wma_handle->wmi_cmd_rsp_wake_lock,
WMA_FW_RSP_EVENT_WAKE_LOCK_DURATION,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP);
cdf_runtime_pm_prevent_suspend(
wma_handle->wmi_cmd_rsp_runtime_lock);
}
WMA_LOGD("Call txrx detach with callback for vdev %d", vdev_id);
ol_txrx_vdev_detach(iface->handle, NULL, NULL);
/*
* send the response immediately if WMI_SERVICE_SYNC_DELETE_CMDS
* service is not supported by firmware
*/
if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS))
wma_vdev_detach_callback(iface);
return status;
out:
if (iface->addBssStaContext)
cdf_mem_free(iface->addBssStaContext);
#if defined WLAN_FEATURE_VOWIFI_11R
if (iface->staKeyParams)
cdf_mem_free(iface->staKeyParams);
#endif /* WLAN_FEATURE_VOWIFI_11R */
cdf_mem_zero(iface, sizeof(*iface));
del_sta_self_req_param->status = status;
if (generate_rsp) {
sme_msg.type = eWNI_SME_DEL_STA_SELF_RSP;
sme_msg.bodyptr = del_sta_self_req_param;
sme_msg.bodyval = 0;
status = cds_mq_post_message(CDF_MODULE_ID_SME, &sme_msg);
if (!CDF_IS_STATUS_SUCCESS(status)) {
WMA_LOGE("Failed to post eWNI_SME_DEL_STA_SELF_RSP");
cdf_mem_free(del_sta_self_req_param);
}
}
return status;
}
/**
* wma_vdev_detach() - send vdev delete command to fw
* @wma_handle: wma handle
@ -473,38 +685,9 @@ CDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
uint8_t generateRsp)
{
CDF_STATUS status = CDF_STATUS_SUCCESS;
ol_txrx_peer_handle peer;
ol_txrx_pdev_handle pdev;
uint8_t peer_id;
uint8_t vdev_id = pdel_sta_self_req_param->session_id;
struct wma_txrx_node *iface = &wma_handle->interfaces[vdev_id];
struct wma_target_req *msg;
cds_msg_t sme_msg = { 0 };
if ((iface->type == WMI_VDEV_TYPE_AP) &&
(iface->sub_type == WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE)) {
WMA_LOGA("P2P Device: removing self peer %pM",
pdel_sta_self_req_param->self_mac_addr);
pdev = cds_get_context(CDF_MODULE_ID_TXRX);
if (NULL == pdev) {
WMA_LOGE("%s: Failed to get pdev", __func__);
return CDF_STATUS_E_FAULT;
}
peer = ol_txrx_find_peer_by_addr(pdev,
pdel_sta_self_req_param->self_mac_addr,
&peer_id);
if (!peer) {
WMA_LOGE("%s Failed to find peer %pM", __func__,
pdel_sta_self_req_param->self_mac_addr);
}
wma_remove_peer(wma_handle,
pdel_sta_self_req_param->self_mac_addr,
vdev_id, peer, false);
}
if (cdf_atomic_read(&iface->bss_status) == WMA_BSS_STATUS_STARTED) {
WMA_LOGA("BSS is not yet stopped. Defering vdev(vdev id %x) deletion",
vdev_id);
@ -520,54 +703,20 @@ CDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
return status;
}
/* remove the interface from ath_dev */
if (wma_unified_vdev_delete_send(wma_handle->wmi_handle, vdev_id)) {
WMA_LOGE("Unable to remove an interface for ath_dev.");
status = CDF_STATUS_E_FAILURE;
goto out;
/* P2P Device */
if ((iface->type == WMI_VDEV_TYPE_AP) &&
(iface->sub_type == WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE)) {
wma_self_peer_remove(wma_handle, pdel_sta_self_req_param,
generateRsp);
if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS))
status = wma_handle_vdev_detach(wma_handle,
pdel_sta_self_req_param, generateRsp);
} else { /* other than P2P */
status = wma_handle_vdev_detach(wma_handle,
pdel_sta_self_req_param, generateRsp);
}
WMA_LOGD("vdev_id:%hu vdev_hdl:%p", vdev_id, iface->handle);
if (!generateRsp) {
WMA_LOGE("Call txrx detach w/o callback for vdev %d", vdev_id);
ol_txrx_vdev_detach(iface->handle, NULL, NULL);
goto out;
}
iface->del_staself_req = pdel_sta_self_req_param;
msg = wma_fill_vdev_req(wma_handle, vdev_id, WMA_DEL_STA_SELF_REQ,
WMA_TARGET_REQ_TYPE_VDEV_DEL, iface, 2000);
if (!msg) {
WMA_LOGE("%s: Failed to fill vdev request for vdev_id %d",
__func__, vdev_id);
status = CDF_STATUS_E_NOMEM;
goto out;
}
WMA_LOGD("Call txrx detach with callback for vdev %d", vdev_id);
ol_txrx_vdev_detach(iface->handle, NULL, NULL);
wma_vdev_detach_callback(iface);
return status;
out:
if (iface->addBssStaContext)
cdf_mem_free(iface->addBssStaContext);
#if defined WLAN_FEATURE_VOWIFI_11R
if (iface->staKeyParams)
cdf_mem_free(iface->staKeyParams);
#endif /* WLAN_FEATURE_VOWIFI_11R */
cdf_mem_zero(iface, sizeof(*iface));
pdel_sta_self_req_param->status = status;
if (generateRsp) {
sme_msg.type = eWNI_SME_DEL_STA_SELF_RSP;
sme_msg.bodyptr = pdel_sta_self_req_param;
sme_msg.bodyval = 0;
status = cds_mq_post_message(CDF_MODULE_ID_SME, &sme_msg);
if (!CDF_IS_STATUS_SUCCESS(status)) {
WMA_LOGE("Failed to post eWNI_SME_ADD_STA_SELF_RSP");
cdf_mem_free(pdel_sta_self_req_param);
}
}
return status;
}
@ -2275,6 +2424,123 @@ free_req_msg:
return status;
}
/**
* wma_vdev_delete_handler() - vdev delete response handler
* @handle: wma handle
* @cmd_param_info: event buffer
* @len: buffer length
*
* Return: 0 for success or error code
*/
int wma_vdev_delete_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len)
{
tp_wma_handle wma = (tp_wma_handle) handle;
WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_delete_cmd_fixed_param *event;
struct wma_target_req *req_msg;
int status = 0;
param_buf = (WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *)cmd_param_info;
if (!param_buf) {
WMA_LOGE("Invalid vdev delete event buffer");
return -EINVAL;
}
event = (wmi_vdev_delete_cmd_fixed_param *)param_buf->fixed_param;
if (!event) {
WMA_LOGE("Invalid vdev delete event buffer");
return -EINVAL;
}
WMA_LOGE("%s Vdev delete resp vdev id %d", __func__, event->vdev_id);
req_msg = wma_find_vdev_req(wma, event->vdev_id,
WMA_TARGET_REQ_TYPE_VDEV_DEL);
if (!req_msg) {
WMA_LOGD(FL("Vdev delete resp is not handled! vdev id %d"),
event->vdev_id);
return -EINVAL;
}
cdf_wake_lock_release(&wma->wmi_cmd_rsp_wake_lock,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP);
cdf_runtime_pm_allow_suspend(wma->wmi_cmd_rsp_runtime_lock);
/* Send response to upper layers */
wma_vdev_detach_callback(req_msg->user_data);
cdf_mc_timer_stop(&req_msg->event_timeout);
cdf_mc_timer_destroy(&req_msg->event_timeout);
cdf_mem_free(req_msg);
return status;
}
/**
* wma_peer_delete_handler() - peer delete response handler
* @handle: wma handle
* @cmd_param_info: event buffer
* @len: buffer length
*
* Return: 0 for success or error code
*/
int wma_peer_delete_handler(void *handle, uint8_t *cmd_param_info,
uint32_t len)
{
tp_wma_handle wma = (tp_wma_handle) handle;
WMI_PEER_DELETE_RESP_EVENTID_param_tlvs *param_buf;
wmi_peer_delete_cmd_fixed_param *event;
struct wma_target_req *req_msg;
tDeleteStaParams *del_sta;
uint8_t macaddr[IEEE80211_ADDR_LEN];
int status = 0;
param_buf = (WMI_PEER_DELETE_RESP_EVENTID_param_tlvs *)cmd_param_info;
if (!param_buf) {
WMA_LOGE("Invalid vdev delete event buffer");
return -EINVAL;
}
event = (wmi_peer_delete_cmd_fixed_param *)param_buf->fixed_param;
if (!event) {
WMA_LOGE("Invalid vdev delete event buffer");
return -EINVAL;
}
WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, macaddr);
WMA_LOGE(FL("Peer Delete Response, vdev %d Peer %pM"),
event->vdev_id, macaddr);
req_msg = wma_find_remove_req_msgtype(wma, event->vdev_id,
WMA_DELETE_STA_REQ);
if (!req_msg) {
WMA_LOGD("Peer Delete response is not handled");
return -EINVAL;
}
cdf_wake_lock_release(&wma->wmi_cmd_rsp_wake_lock,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP);
cdf_runtime_pm_allow_suspend(wma->wmi_cmd_rsp_runtime_lock);
/* Cleanup timeout handler */
cdf_mc_timer_stop(&req_msg->event_timeout);
cdf_mc_timer_destroy(&req_msg->event_timeout);
if (req_msg->type == WMA_DELETE_STA_RSP_START) {
del_sta = req_msg->user_data;
if (del_sta->respReqd) {
WMA_LOGD(FL("Sending peer del rsp to umac"));
wma_send_msg(wma, WMA_DELETE_STA_RSP,
(void *)del_sta, CDF_STATUS_SUCCESS);
}
} else if (req_msg->type == WMA_DEL_P2P_SELF_STA_RSP_START) {
struct del_sta_self_rsp_params *data;
data = (struct del_sta_self_rsp_params *)req_msg->user_data;
WMA_LOGD(FL("Calling vdev detach handler"));
wma_handle_vdev_detach(wma, data->self_sta_param,
data->generate_rsp);
cdf_mem_free(data);
}
cdf_mem_free(req_msg);
return status;
}
/**
* wma_hold_req_timer() - wma hold request timeout function
* @data: target request params
@ -2310,6 +2576,24 @@ void wma_hold_req_timer(void *data)
WMA_LOGD(FL("Sending add sta rsp to umac (mac:%pM, status:%d)"),
params->staMac, params->status);
wma_send_msg(wma, WMA_ADD_STA_RSP, (void *)params, 0);
} else if ((tgt_req->msg_type == WMA_DELETE_STA_REQ) &&
(tgt_req->type == WMA_DELETE_STA_RSP_START)) {
tpDeleteStaParams params =
(tpDeleteStaParams) tgt_req->user_data;
params->status = CDF_STATUS_E_TIMEOUT;
WMA_LOGE(FL("WMA_DEL_STA_REQ timed out"));
WMA_LOGP(FL("Sending del sta rsp to umac (mac:%pM, status:%d)"),
params->staMac, params->status);
/*
* Assert in development build only.
* Send response in production builds.
*/
CDF_ASSERT(0);
wma_send_msg(wma, WMA_DELETE_STA_RSP, (void *)params, 0);
} else if ((tgt_req->msg_type == WMA_DELETE_STA_REQ) &&
(tgt_req->type == WMA_DEL_P2P_SELF_STA_RSP_START)) {
WMA_LOGA(FL("wma delete sta p2p request timed out"));
CDF_ASSERT(0);
}
free_tgt_req:
cdf_mc_timer_destroy(&tgt_req->event_timeout);
@ -2342,6 +2626,7 @@ struct wma_target_req *wma_fill_hold_req(tp_wma_handle wma,
}
WMA_LOGE(FL("vdev_id %d msg %d type %d"), vdev_id, msg_type, type);
req->vdev_id = vdev_id;
req->msg_type = msg_type;
req->type = type;
@ -2532,7 +2817,15 @@ void wma_vdev_resp_timer(void *data)
struct del_sta_self_params *params =
(struct del_sta_self_params *) iface->del_staself_req;
if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS)) {
cdf_wake_lock_release(&wma->wmi_cmd_rsp_wake_lock,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP);
cdf_runtime_pm_allow_suspend(
wma->wmi_cmd_rsp_runtime_lock);
}
params->status = CDF_STATUS_E_TIMEOUT;
WMA_LOGA("%s: WMA_DEL_STA_SELF_REQ timedout", __func__);
sme_msg.type = eWNI_SME_DEL_STA_SELF_RSP;
sme_msg.bodyptr = iface->del_staself_req;
@ -4056,6 +4349,7 @@ static void wma_delete_sta_req_ap_mode(tp_wma_handle wma,
{
ol_txrx_pdev_handle pdev;
struct ol_txrx_peer_t *peer;
struct wma_target_req *msg;
pdev = cds_get_context(CDF_MODULE_ID_TXRX);
@ -4077,6 +4371,31 @@ static void wma_delete_sta_req_ap_mode(tp_wma_handle wma,
false);
del_sta->status = CDF_STATUS_SUCCESS;
if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
WMI_SERVICE_SYNC_DELETE_CMDS)) {
msg = wma_fill_hold_req(wma, del_sta->smesessionId,
WMA_DELETE_STA_REQ,
WMA_DELETE_STA_RSP_START, del_sta,
WMA_DELETE_STA_TIMEOUT);
if (!msg) {
WMA_LOGP(FL("Failed to allocate request. vdev_id %d"),
del_sta->smesessionId);
wma_remove_req(wma, del_sta->smesessionId,
WMA_DELETE_STA_RSP_START);
del_sta->status = CDF_STATUS_E_NOMEM;
goto send_del_rsp;
}
/*
* Acquire wake lock and bus lock till
* firmware sends the response
*/
cdf_wake_lock_timeout_acquire(&wma->wmi_cmd_rsp_wake_lock,
WMA_FW_RSP_EVENT_WAKE_LOCK_DURATION,
WIFI_POWER_EVENT_WAKELOCK_WMI_CMD_RSP);
cdf_runtime_pm_prevent_suspend(wma->wmi_cmd_rsp_runtime_lock);
return;
}
send_del_rsp:
if (del_sta->respReqd) {
WMA_LOGD("%s: Sending del rsp to umac (status: %d)",

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

@ -1937,14 +1937,26 @@ CDF_STATUS wma_open(void *cds_context,
WMI_RSSI_BREACH_EVENTID,
wma_rssi_breached_event_handler);
cdf_wake_lock_init(&wma_handle->wmi_cmd_rsp_wake_lock,
"wlan_fw_rsp_wakelock");
wma_handle->wmi_cmd_rsp_runtime_lock =
cdf_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);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_VDEV_DELETE_RESP_EVENTID,
wma_vdev_delete_handler);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
WMI_PEER_DELETE_RESP_EVENTID,
wma_peer_delete_handler);
return CDF_STATUS_SUCCESS;
err_dbglog_init:
cdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
cdf_runtime_lock_deinit(wma_handle->wmi_cmd_rsp_runtime_lock);
cdf_spinlock_destroy(&wma_handle->vdev_respq_lock);
cdf_spinlock_destroy(&wma_handle->wma_hold_req_q_lock);
err_event_init:
@ -3094,6 +3106,8 @@ CDF_STATUS wma_close(void *cds_ctx)
cdf_event_destroy(&wma_handle->recovery_event);
wma_cleanup_vdev_resp(wma_handle);
wma_cleanup_hold_req(wma_handle);
cdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
cdf_runtime_lock_deinit(wma_handle->wmi_cmd_rsp_runtime_lock);
for (idx = 0; idx < wma_handle->num_mem_chunks; ++idx) {
cdf_os_mem_free_consistent(wma_handle->cdf_dev,
wma_handle->mem_chunks[idx].len,