qcacld-3.0: Cleanup unused vdev request hold framework

With vdev operations moved to target if from the wma, the vdev
request hold framework is not used.

Thus remove the unused functions and structures

Change-Id: I6e609735ad0bdc8b929cfffa6f13915f0ad6823d
CRs-Fixed: 2523104

core/wma/inc/wma.h

@@ -732,9 +732,7 @@ struct roam_synch_frame_ind {
  * @ns_offload_req: cached ns offload request
  * @rcpi_req: rcpi request
  * @in_bmps: Whether bmps for this interface has been enabled
- * @vdev_start_wakelock: wakelock to protect vdev start op with firmware
  * @vdev_set_key_wakelock: wakelock to protect vdev set key op with firmware
- * @vdev_start_runtime_wakelock: runtime pm wakelock for vdev start
  * @vdev_set_key_runtime_wakelock: runtime pm wakelock for set key
  * @channel: channel
  * @roam_offload_enabled: is roam offload enable/disable
@@ -801,9 +799,7 @@ struct wma_txrx_node {
 	bool in_bmps;
 	struct beacon_filter_param beacon_filter;
 	bool beacon_filter_enabled;
-	qdf_wake_lock_t vdev_start_wakelock;
 	qdf_wake_lock_t vdev_set_key_wakelock;
-	qdf_runtime_lock_t vdev_start_runtime_wakelock;
 	qdf_runtime_lock_t vdev_set_key_runtime_wakelock;
 	struct roam_synch_frame_ind roam_synch_frame_ind;
 	bool is_waiting_for_key;
@@ -916,8 +912,6 @@ struct wma_wlm_stats_data {
  * @scan_id: scan id
  * @interfaces: txrx nodes(per vdev)
  * @pdevconfig: pdev related configrations
- * @vdev_resp_queue: vdev response queue
- * @vdev_respq_lock: vdev response queue lock
  * @wma_hold_req_queue: Queue use to serialize requests to firmware
  * @wma_hold_req_q_lock: Mutex for @wma_hold_req_queue
  * @vht_supp_mcs: VHT supported MCS
@@ -1048,8 +1042,6 @@ typedef struct {
 	uint32_t scan_id;
 	struct wma_txrx_node *interfaces;
 	pdev_cli_config_t pdevconfig;
-	qdf_list_t vdev_resp_queue;
-	qdf_spinlock_t vdev_respq_lock;
 	qdf_list_t wma_hold_req_queue;
 	qdf_spinlock_t wma_hold_req_q_lock;
 	uint32_t vht_supp_mcs;
@@ -1659,10 +1651,6 @@ QDF_STATUS wma_send_pdev_set_dual_mac_config(tp_wma_handle wma_handle,
 QDF_STATUS wma_send_pdev_set_antenna_mode(tp_wma_handle wma_handle,
 		struct sir_antenna_mode_param *msg);
 
-struct wma_target_req *wma_fill_vdev_req(tp_wma_handle wma,
-					 uint8_t vdev_id,
-					 uint32_t msg_type, uint8_t type,
-					 void *params, uint32_t timeout);
 struct wma_target_req *wma_fill_hold_req(tp_wma_handle wma,
 				    uint8_t vdev_id, uint32_t msg_type,
 				    uint8_t type, void *params,
@@ -1671,9 +1659,6 @@ struct wma_target_req *wma_fill_hold_req(tp_wma_handle wma,
 QDF_STATUS wma_vdev_start(tp_wma_handle wma,
 			  struct wma_vdev_start_req *req, bool isRestart);
 
-void wma_remove_vdev_req(tp_wma_handle wma, uint8_t vdev_id,
-				uint8_t type);
-
 int wma_mgmt_tx_completion_handler(void *handle, uint8_t *cmpl_event_params,
 				   uint32_t len);
 int wma_mgmt_tx_bundle_completion_handler(void *handle,

core/wma/inc/wma_internal.h

@@ -638,22 +638,12 @@ __wma_handle_vdev_stop_rsp(struct vdev_stop_response *resp_event);
 QDF_STATUS wma_vdev_start(tp_wma_handle wma, struct wma_vdev_start_req *req,
 			  bool isRestart);
 
-void wma_vdev_resp_timer(void *data);
-
-struct wma_target_req *wma_fill_vdev_req(tp_wma_handle wma,
-						uint8_t vdev_id,
-						uint32_t msg_type, uint8_t type,
-						void *params, uint32_t timeout);
-
 void wma_hold_req_timer(void *data);
 struct wma_target_req *wma_fill_hold_req(tp_wma_handle wma,
 				    uint8_t vdev_id, uint32_t msg_type,
 				    uint8_t type, void *params,
 				    uint32_t timeout);
 
-void wma_remove_vdev_req(tp_wma_handle wma, uint8_t vdev_id,
-				uint8_t type);
-
 void wma_add_bss(tp_wma_handle wma, struct bss_params *params);
 
 void wma_add_sta(tp_wma_handle wma, tpAddStaParams add_sta);

core/wma/src/wma_dev_if.c

@@ -372,130 +372,6 @@ static struct wma_target_req *wma_find_remove_req_msgtype(tp_wma_handle wma,
 	return req_msg;
 }
 
-/**
- * wma_find_vdev_req_on_timer_expiry() - find target request by address
- * @wma: wma handle
- * @req: pointer to the target request
- *
- * On timer expiry, the pointer to the req message is received from the
- * timer callback. Lookup the vdev_resp_queue for the request with the
- * same address and return success if found.
- *
- * Return: QDF_STATUS
- */
-static
-QDF_STATUS wma_find_vdev_req_on_timer_expiry(tp_wma_handle wma,
-					     struct wma_target_req *req)
-{
-	struct wma_target_req *req_msg = NULL;
-	bool found = false;
-	qdf_list_node_t *cur_node = NULL, *next_node = NULL;
-	QDF_STATUS status;
-
-	qdf_spin_lock_bh(&wma->vdev_respq_lock);
-	if (QDF_STATUS_SUCCESS != qdf_list_peek_front(&wma->vdev_resp_queue,
-						      &next_node)) {
-		qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-		WMA_LOGD(FL("unable to find req from vdev resp queue for %pK"),
-			 req);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	do {
-		cur_node = next_node;
-		req_msg = qdf_container_of(cur_node, struct wma_target_req,
-					   node);
-		if (req_msg != req)
-			continue;
-
-		found = true;
-		status = qdf_list_remove_node(&wma->vdev_resp_queue,
-					      cur_node);
-		if (QDF_STATUS_SUCCESS != status) {
-			qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-			WMA_LOGD(FL("Failed to target req for %pK"), req);
-			return QDF_STATUS_E_FAILURE;
-		}
-		break;
-	} while (QDF_STATUS_SUCCESS  ==
-		 qdf_list_peek_next(&wma->vdev_resp_queue,
-				    cur_node, &next_node));
-
-	qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-	if (!found) {
-		WMA_LOGD(FL("target request not found for req %pK"),
-			 req);
-		return QDF_STATUS_E_INVAL;
-	}
-
-	WMA_LOGD(FL("target request found for vdev id: %d type %d msg %d"),
-		 req_msg->vdev_id, req_msg->type, req_msg->msg_type);
-	return QDF_STATUS_SUCCESS;
-}
-
-/**
- * wma_find_vdev_req() - find target request for vdev id
- * @wma: wma handle
- * @vdev_id: vdev id
- * @type: request type
- * @remove_req_from_list: flag to indicate remove req or not.
- *
- * Return: return target request if found or NULL.
- */
-static struct wma_target_req *wma_find_vdev_req(tp_wma_handle wma,
-						uint8_t vdev_id, uint8_t type,
-						bool remove_req_from_list)
-{
-	struct wma_target_req *req_msg = NULL;
-	bool found = false;
-	qdf_list_node_t *node1 = NULL, *node2 = NULL;
-	QDF_STATUS status;
-
-	qdf_spin_lock_bh(&wma->vdev_respq_lock);
-	if (QDF_STATUS_SUCCESS != qdf_list_peek_front(&wma->vdev_resp_queue,
-						      &node2)) {
-		qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-		WMA_LOGD(FL("unable to get target req from vdev resp queue vdev_id: %d type: %d"),
-				vdev_id, type);
-		return NULL;
-	}
-
-	do {
-		node1 = node2;
-		req_msg = qdf_container_of(node1, struct wma_target_req, node);
-		if (req_msg->vdev_id != vdev_id)
-			continue;
-		if (req_msg->type != type)
-			continue;
-
-		found = true;
-		if (remove_req_from_list) {
-			status = qdf_list_remove_node(&wma->vdev_resp_queue,
-					node1);
-			if (QDF_STATUS_SUCCESS != status) {
-				qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-				WMA_LOGD(FL(
-				"Failed to target req for vdev_id %d type %d"),
-						vdev_id, type);
-				return NULL;
-			}
-		}
-		break;
-	} while (QDF_STATUS_SUCCESS  ==
-			qdf_list_peek_next(&wma->vdev_resp_queue,
-					   node1, &node2));
-
-	qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-	if (!found) {
-		WMA_LOGD(FL("target request not found for vdev_id %d type %d"),
-			 vdev_id, type);
-		return NULL;
-	}
-	WMA_LOGD(FL("target request found for vdev id: %d type %d msg %d"),
-		 vdev_id, type, req_msg->msg_type);
-	return req_msg;
-}
-
 /**
  * wma_send_vdev_del_resp() - send vdev del resp to Upper layer
  * @param: params of del vdev response
@@ -1975,23 +1851,6 @@ err:
 	return QDF_STATUS_E_FAILURE;
 }
 
-/**
- * wma_cleanup_target_req_param() - free param memory of target request
- * @tgt_req: target request params
- *
- * Return: none
- */
-static void wma_cleanup_target_req_param(struct wma_target_req *tgt_req)
-{
-	WMA_LOGE("%s: Free target req user_data msg_type:%d", __func__,
-		 tgt_req->msg_type);
-	if (tgt_req->msg_type == WMA_CHNL_SWITCH_REQ ||
-	   tgt_req->msg_type == WMA_ADD_BSS_REQ) {
-		qdf_mem_free(tgt_req->user_data);
-		tgt_req->user_data = NULL;
-	}
-}
-
 /**
  * wma_remove_bss_peer() - remove BSS peer
  * @wma: pointer to WMA handle
@@ -3523,198 +3382,6 @@ void wma_remove_req(tp_wma_handle wma, uint8_t vdev_id,
 	qdf_mem_free(req_msg);
 }
 
-/**
- * wma_handle_channel_switch_req_timeout() - handle channel switch req timeout
- * @wma: wma handler
- * @tgt_req: target req
- *
- * Return: none
- */
-static void
-wma_handle_channel_switch_req_timeout(tp_wma_handle wma,
-				      struct wma_target_req *req)
-{
-	struct wma_txrx_node *iface;
-	tpSwitchChannelParams params = (tpSwitchChannelParams)req->user_data;
-
-	params->status = QDF_STATUS_E_TIMEOUT;
-	WMA_LOGA("%s: WMA_SWITCH_CHANNEL_REQ timedout", __func__);
-
-	/*
-	 * Trigger host crash if the flag is set or if the timeout
-	 * is not due to fw down
-	 */
-	if (wma_crash_on_fw_timeout(wma->fw_timeout_crash))
-		wma_trigger_recovery_assert_on_fw_timeout(
-			WMA_CHNL_SWITCH_REQ);
-
-	iface = &wma->interfaces[req->vdev_id];
-	mlme_set_chan_switch_in_progress(iface->vdev, false);
-
-	wma_send_msg_high_priority(wma, WMA_SWITCH_CHANNEL_RSP,
-				   (void *)params, 0);
-}
-
-/**
- * wma_handle_cadd_bss_req_timeout() - handle add bss req timeout
- * @wma: wma handler
- * @req: target req
- *
- * Return: none
- */
-static void
-wma_handle_add_bss_req_timeout(tp_wma_handle wma, struct wma_target_req *req)
-{
-	struct wma_txrx_node *iface;
-	struct bss_params *params = (struct bss_params *)req->user_data;
-
-	params->status = QDF_STATUS_E_TIMEOUT;
-	WMA_LOGA("%s: WMA_ADD_BSS_REQ timedout", __func__);
-	WMA_LOGD("%s: bssid %pM vdev_id %d", __func__, params->bssId,
-		 req->vdev_id);
-
-	if (wma_crash_on_fw_timeout(wma->fw_timeout_crash))
-		wma_trigger_recovery_assert_on_fw_timeout(WMA_ADD_BSS_REQ);
-
-	iface = &wma->interfaces[req->vdev_id];
-	wlan_vdev_mlme_sm_deliver_evt(iface->vdev,
-				      WLAN_VDEV_SM_EV_DOWN,
-				      sizeof(*params), params);
-}
-
-/**
- * wma_vdev_resp_timer() - wma response timeout function
- * @data: target request params
- *
- * Return: none
- */
-void wma_vdev_resp_timer(void *data)
-{
-	tp_wma_handle wma;
-	struct wma_target_req *tgt_req = (struct wma_target_req *)data;
-	struct cdp_pdev *pdev;
-	QDF_STATUS qdf_status;
-#ifdef FEATURE_AP_MCC_CH_AVOIDANCE
-	struct mac_context *mac_ctx;
-#endif /* FEATURE_AP_MCC_CH_AVOIDANCE */
-
-	wma = cds_get_context(QDF_MODULE_ID_WMA);
-
-	if (!wma) {
-		WMA_LOGE("%s: Failed to get wma", __func__);
-		wma_cleanup_target_req_param(tgt_req);
-		goto free_tgt_req;
-	}
-
-	qdf_status = wma_find_vdev_req_on_timer_expiry(wma, tgt_req);
-
-	if (QDF_IS_STATUS_ERROR(qdf_status)) {
-		/*
-		 * if find request failed, then firmware rsp should have
-		 * consumed the buffer. Do not free.
-		 */
-		WMA_LOGD("%s: Failed to lookup request message - %pK",
-			 __func__, tgt_req);
-		return;
-	}
-	WMA_LOGA("%s: request %d is timed out for vdev_id - %d", __func__,
-		 tgt_req->msg_type, tgt_req->vdev_id);
-
-	pdev = cds_get_context(QDF_MODULE_ID_TXRX);
-
-	if (!pdev) {
-		WMA_LOGE("%s: Failed to get pdev", __func__);
-		wma_cleanup_target_req_param(tgt_req);
-		qdf_mc_timer_stop(&tgt_req->event_timeout);
-		goto free_tgt_req;
-	}
-
-#ifdef FEATURE_AP_MCC_CH_AVOIDANCE
-	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
-	if (!mac_ctx) {
-		WMA_LOGE("%s: Failed to get mac_ctx", __func__);
-		wma_cleanup_target_req_param(tgt_req);
-		goto free_tgt_req;
-	}
-#endif /* FEATURE_AP_MCC_CH_AVOIDANCE */
-
-	if (tgt_req->msg_type == WMA_CHNL_SWITCH_REQ) {
-
-		wma_handle_channel_switch_req_timeout(wma, tgt_req);
-	} else if (tgt_req->msg_type == WMA_ADD_BSS_REQ) {
-
-		wma_handle_add_bss_req_timeout(wma, tgt_req);
-	}
-free_tgt_req:
-	qdf_mc_timer_destroy(&tgt_req->event_timeout);
-	qdf_mem_free(tgt_req);
-}
-
-/**
- * wma_fill_vdev_req() - fill vdev request
- * @wma: wma handle
- * @msg_type: message type
- * @type: request type
- * @params: request params
- * @timeout: timeout value
- *
- * Return: wma_target_req ptr
- */
-struct wma_target_req *wma_fill_vdev_req(tp_wma_handle wma,
-					 uint8_t vdev_id,
-					 uint32_t msg_type, uint8_t type,
-					 void *params, uint32_t timeout)
-{
-	struct wma_target_req *req;
-	QDF_STATUS status;
-
-	req = qdf_mem_malloc(sizeof(*req));
-	if (!req)
-		return NULL;
-
-	WMA_LOGD("%s: vdev_id %d msg %d", __func__, vdev_id, msg_type);
-	qdf_spin_lock_bh(&wma->vdev_respq_lock);
-	req->vdev_id = vdev_id;
-	req->msg_type = msg_type;
-	req->type = type;
-	req->user_data = params;
-	status = qdf_list_insert_back(&wma->vdev_resp_queue, &req->node);
-	if (QDF_STATUS_SUCCESS != status) {
-		qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-		WMA_LOGE(FL("Failed add request in queue for vdev_id %d type %d"),
-			 vdev_id, type);
-		qdf_mem_free(req);
-		return NULL;
-	}
-	qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-	qdf_mc_timer_init(&req->event_timeout, QDF_TIMER_TYPE_SW,
-			  wma_vdev_resp_timer, req);
-	qdf_mc_timer_start(&req->event_timeout, timeout);
-	return req;
-}
-
-/**
- * wma_remove_vdev_req() - remove vdev request
- * @wma: wma handle
- * @vdev_id: vdev id
- * @type: type
- *
- * Return: none
- */
-void wma_remove_vdev_req(tp_wma_handle wma, uint8_t vdev_id,
-				uint8_t type)
-{
-	struct wma_target_req *req_msg;
-
-	req_msg = wma_find_vdev_req(wma, vdev_id, type, true);
-	if (!req_msg)
-		return;
-
-	qdf_mc_timer_stop(&req_msg->event_timeout);
-	qdf_mc_timer_destroy(&req_msg->event_timeout);
-	qdf_mem_free(req_msg);
-}
-
 /**
  * wma_vdev_set_bss_params() - BSS set params functions
  * @wma: wma handle

core/wma/src/wma_main.c

@@ -1909,38 +1909,6 @@ static uint8_t wma_init_max_no_of_peers(tp_wma_handle wma_handle,
 	return max_no_of_peers;
 }
 
-/**
- * wma_cleanup_vdev_resp_queue() - cleanup vdev response queue
- * @wma: wma handle
- *
- * Return: none
- */
-static void wma_cleanup_vdev_resp_queue(tp_wma_handle wma)
-{
-	struct wma_target_req *req_msg = NULL;
-	qdf_list_node_t *node1 = NULL;
-
-	qdf_spin_lock_bh(&wma->vdev_respq_lock);
-	if (!qdf_list_size(&wma->vdev_resp_queue)) {
-		qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-		WMA_LOGD(FL("request queue maybe empty"));
-		return;
-	}
-
-	WMA_LOGD(FL("Cleaning up vdev resp queue"));
-
-	/* peek front, and then cleanup it in wma_vdev_resp_timer */
-	while (qdf_list_peek_front(&wma->vdev_resp_queue, &node1) ==
-				   QDF_STATUS_SUCCESS) {
-		req_msg = qdf_container_of(node1, struct wma_target_req, node);
-		qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-		qdf_mc_timer_stop(&req_msg->event_timeout);
-		wma_vdev_resp_timer(req_msg);
-		qdf_spin_lock_bh(&wma->vdev_respq_lock);
-	}
-	qdf_spin_unlock_bh(&wma->vdev_respq_lock);
-}
-
 /**
  * wma_cleanup_hold_req() - cleanup hold request queue
  * @wma: wma handle
@@ -1987,7 +1955,6 @@ wma_cleanup_vdev_resp_and_hold_req(struct scheduler_msg *msg)
 		return QDF_STATUS_E_INVAL;
 	}
 
-	wma_cleanup_vdev_resp_queue(msg->bodyptr);
 	wma_cleanup_hold_req(msg->bodyptr);
 
 	return QDF_STATUS_SUCCESS;
@@ -2862,8 +2829,6 @@ static int wma_unified_phyerr_rx_event_handler(void *handle,
 
 void wma_vdev_init(struct wma_txrx_node *vdev)
 {
-	qdf_wake_lock_create(&vdev->vdev_start_wakelock, "vdev_start");
-	qdf_runtime_lock_init(&vdev->vdev_start_runtime_wakelock);
 	qdf_wake_lock_create(&vdev->vdev_set_key_wakelock, "vdev_set_key");
 	qdf_runtime_lock_init(&vdev->vdev_set_key_runtime_wakelock);
 	vdev->is_waiting_for_key = false;
@@ -2946,8 +2911,6 @@ void wma_vdev_deinit(struct wma_txrx_node *vdev)
 
 	qdf_runtime_lock_deinit(&vdev->vdev_set_key_runtime_wakelock);
 	qdf_wake_lock_destroy(&vdev->vdev_set_key_wakelock);
-	qdf_runtime_lock_deinit(&vdev->vdev_start_runtime_wakelock);
-	qdf_wake_lock_destroy(&vdev->vdev_start_wakelock);
 	vdev->is_waiting_for_key = false;
 }
 
@@ -3387,9 +3350,6 @@ QDF_STATUS wma_open(struct wlan_objmgr_psoc *psoc,
 		goto err_event_init;
 	}
 
-	qdf_list_create(&wma_handle->vdev_resp_queue,
-		      MAX_ENTRY_VDEV_RESP_QUEUE);
-	qdf_spinlock_create(&wma_handle->vdev_respq_lock);
 	qdf_list_create(&wma_handle->wma_hold_req_queue,
 		      MAX_ENTRY_HOLD_REQ_QUEUE);
 	qdf_spinlock_create(&wma_handle->wma_hold_req_q_lock);
@@ -3668,7 +3628,6 @@ err_dbglog_init:
 	qdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
 	qdf_runtime_lock_deinit(&wma_handle->sap_prevent_runtime_pm_lock);
 	qdf_runtime_lock_deinit(&wma_handle->wmi_cmd_rsp_runtime_lock);
-	qdf_spinlock_destroy(&wma_handle->vdev_respq_lock);
 	qdf_spinlock_destroy(&wma_handle->wma_hold_req_q_lock);
 err_event_init:
 	wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
@@ -4742,12 +4701,10 @@ QDF_STATUS wma_close(void)
 	qdf_event_destroy(&wma_handle->recovery_event);
 	qdf_event_destroy(&wma_handle->tx_frm_download_comp_event);
 	qdf_event_destroy(&wma_handle->tx_queue_empty_event);
-	wma_cleanup_vdev_resp_queue(wma_handle);
 	wma_cleanup_hold_req(wma_handle);
 	qdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
 	qdf_runtime_lock_deinit(&wma_handle->sap_prevent_runtime_pm_lock);
 	qdf_runtime_lock_deinit(&wma_handle->wmi_cmd_rsp_runtime_lock);
-	qdf_spinlock_destroy(&wma_handle->vdev_respq_lock);
 	qdf_spinlock_destroy(&wma_handle->wma_hold_req_q_lock);
 
 	if (wma_handle->pGetRssiReq) {

core/wma/src/wma_utils.c

@@ -3698,8 +3698,6 @@ QDF_STATUS wma_send_vdev_up_to_fw(t_wma_handle *wma,
 	vdev = &wma->interfaces[params->vdev_id];
 
 	status = wmi_unified_vdev_up_send(wma->wmi_handle, bssid, params);
-	qdf_runtime_pm_allow_suspend(&vdev->vdev_start_runtime_wakelock);
-	wma_release_wakelock(&vdev->vdev_start_wakelock);
 
 	return status;
 }
@@ -3725,7 +3723,6 @@ QDF_STATUS wma_send_vdev_down_to_fw(t_wma_handle *wma, uint8_t vdev_id)
 	wma->interfaces[vdev_id].roaming_in_progress = false;
 
 	status = vdev_mgr_down_send(vdev_mlme);
-	qdf_runtime_pm_allow_suspend(&iface->vdev_start_runtime_wakelock);
 
 	return status;
 }