qcacld-3.0: Converge release csr command operation using single API

Current driver is using different wrapper APIs to release the csr
command buffer which doesn't make sense.

Converge those wrapper API and call them from csr_release_command
API to make it simple to understand.

Change-Id: I55da6ed74a634a3ac7769cdd6cbd099b8e92b5a1
CRs-Fixed: 2005532

core/sme/src/common/sme_api.c

@@ -907,7 +907,7 @@ sme_process_cmd:
 		if (!QDF_IS_STATUS_SUCCESS(status)
 		    && csr_ll_remove_entry(&pMac->sme.smeCmdActiveList,
 				&pCommand->Link, LL_ACCESS_LOCK))
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		break;
 	case eSmeCommandWmStatusChange:
 		csr_ll_unlock(&pMac->sme.smeCmdActiveList);
@@ -919,7 +919,7 @@ sme_process_cmd:
 		if (!QDF_IS_STATUS_SUCCESS(status)
 		    && csr_ll_remove_entry(&pMac->sme.smeCmdActiveList,
 				&pCommand->Link, LL_ACCESS_LOCK)) {
-			csr_release_command_set_key(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 		break;
 	case eSmeCommandNdpInitiatorRequest:
@@ -951,7 +951,11 @@ sme_process_cmd:
 		break;
 	case eSmeCommandRemainOnChannel:
 		csr_ll_unlock(&pMac->sme.smeCmdActiveList);
-		p2p_process_remain_on_channel_cmd(pMac, pCommand);
+		status = p2p_process_remain_on_channel_cmd(pMac, pCommand);
+		if (!QDF_IS_STATUS_SUCCESS(status)
+		    && csr_ll_remove_entry(&pMac->sme.smeCmdActiveList,
+				&pCommand->Link, LL_ACCESS_LOCK))
+			csr_release_command(pMac, pCommand);
 		break;
 	/*
 	 * Treat standby differently here because caller may not be able

core/sme/src/csr/csr_api_roam.c

@@ -1273,7 +1273,6 @@ static QDF_STATUS csr_roam_free_connected_info(tpAniSirGlobal pMac,
 void csr_release_command_roam(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 {
 	csr_reinit_roam_cmd(pMac, pCommand);
-	csr_release_command(pMac, pCommand);
 }
 
 void csr_release_command_scan(tpAniSirGlobal pMac, tSmeCmd *pCommand)
@@ -1281,13 +1280,11 @@ void csr_release_command_scan(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 	qdf_mc_timer_stop(&pCommand->u.scanCmd.csr_scan_timer);
 	qdf_mc_timer_destroy(&pCommand->u.scanCmd.csr_scan_timer);
 	csr_reinit_scan_cmd(pMac, pCommand);
-	csr_release_command(pMac, pCommand);
 }
 
 void csr_release_command_wm_status_change(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 {
 	csr_reinit_wm_status_change_cmd(pMac, pCommand);
-	csr_release_command(pMac, pCommand);
 }
 
 void csr_reinit_set_key_cmd(tpAniSirGlobal pMac, tSmeCmd *pCommand)
@@ -1298,7 +1295,6 @@ void csr_reinit_set_key_cmd(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 void csr_release_command_set_key(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 {
 	csr_reinit_set_key_cmd(pMac, pCommand);
-	csr_release_command(pMac, pCommand);
 }
 
 /**
@@ -1309,30 +1305,18 @@ void csr_release_command_set_key(tpAniSirGlobal pMac, tSmeCmd *pCommand)
  *
  * Return: None
  */
-void csr_release_roc_req_cmd(tpAniSirGlobal mac_ctx, uint8_t session_id)
-{
-	tListElem *entry;
-	tSmeCmd *cmd = NULL;
-
-	entry = csr_ll_peek_head(&mac_ctx->sme.smeCmdActiveList,
-			LL_ACCESS_LOCK);
-	if (entry) {
-		cmd = GET_BASE_ADDR(entry, tSmeCmd, Link);
-		if (eSmeCommandRemainOnChannel == cmd->command) {
-			remainOnChanCallback callback =
-				cmd->u.remainChlCmd.callback;
-			/* process the msg */
-			if (callback)
-				callback(mac_ctx,
-					cmd->u.remainChlCmd.callbackCtx, 0,
-					cmd->u.remainChlCmd.scan_id);
-			sms_log(mac_ctx, LOGE,
-				FL("Remove RoC Request from Active Cmd List"));
-			/* Put this cmd back on the available command list */
-			if (csr_ll_remove_entry(&mac_ctx->sme.smeCmdActiveList,
-						entry, LL_ACCESS_LOCK))
-				csr_release_command(mac_ctx, cmd);
-		}
+void csr_release_roc_req_cmd(tpAniSirGlobal mac_ctx, tSmeCmd *sme_cmd)
+{
+	if (eSmeCommandRemainOnChannel == sme_cmd->command) {
+		remainOnChanCallback callback =
+			sme_cmd->u.remainChlCmd.callback;
+		/* process the msg */
+		if (callback)
+			callback(mac_ctx,
+				 sme_cmd->u.remainChlCmd.callbackCtx, 0,
+				 sme_cmd->u.remainChlCmd.scan_id);
+		sms_log(mac_ctx, LOGE,
+			FL("Remove RoC Request from Active Cmd List"));
 	}
 }
 
@@ -1353,38 +1337,14 @@ void csr_abort_command(tpAniSirGlobal pMac, tSmeCmd *pCommand, bool fStopping)
 				csr_scan_call_callback(pMac, pCommand,
 						       eCSR_SCAN_ABORT);
 			}
-			csr_release_command_scan(pMac, pCommand);
-			break;
-		case eSmeCommandRoam:
-			csr_release_command_roam(pMac, pCommand);
-			break;
-
-		case eSmeCommandWmStatusChange:
-			csr_release_command_wm_status_change(pMac, pCommand);
-			break;
-
-		case eSmeCommandSetKey:
-			csr_release_command_set_key(pMac, pCommand);
-			break;
-
-		case eSmeCommandNdpInitiatorRequest:
-			csr_release_ndp_initiator_req(pMac, pCommand);
-			break;
-
-		case eSmeCommandNdpResponderRequest:
-			csr_release_ndp_responder_req(pMac, pCommand);
-			break;
-
-		case eSmeCommandNdpDataEndInitiatorRequest:
-			csr_release_ndp_data_end_req(pMac, pCommand);
 			break;
 
 		default:
 			sms_log(pMac, LOGW, " CSR abort standard command %d",
 				pCommand->command);
-			csr_release_command(pMac, pCommand);
 			break;
 		}
+		csr_release_command(pMac, pCommand);
 	}
 }
 
@@ -3310,7 +3270,7 @@ static void csr_roam_remove_duplicate_cmd_from_list(tpAniSirGlobal mac_ctx,
 		csr_roam_call_callback(mac_ctx, dup_cmd->sessionId, NULL,
 				dup_cmd->u.roamCmd.roamId,
 				eCSR_ROAM_CANCELLED, eCSR_ROAM_RESULT_NONE);
-		csr_release_command_roam(mac_ctx, dup_cmd);
+		csr_release_command(mac_ctx, dup_cmd);
 	}
 	csr_ll_close(&local_list);
 }
@@ -3709,7 +3669,7 @@ QDF_STATUS csr_roam_issue_disassociate_sta_cmd(tpAniSirGlobal pMac,
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL(" fail to send message status = %d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	} while (0);
 
@@ -3751,7 +3711,7 @@ QDF_STATUS csr_roam_issue_deauth_sta_cmd(tpAniSirGlobal pMac,
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL(" fail to send message status = %d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	} while (0);
 
@@ -5651,7 +5611,7 @@ static QDF_STATUS csr_roam_trigger_reassociate(tpAniSirGlobal mac_ctx,
 			if (!QDF_IS_STATUS_SUCCESS(status)) {
 				sms_log(mac_ctx, LOGE, FL("failed status %d"),
 					status);
-				csr_release_command_roam(mac_ctx, cmd);
+				csr_release_command(mac_ctx, cmd);
 			}
 
 			qdf_mem_free(pIes);
@@ -5838,7 +5798,7 @@ void csr_roam_complete(tpAniSirGlobal pMac, eCsrRoamCompleteResult Result,
 				if (csr_ll_remove_entry
 					    (&pMac->sme.smeCmdActiveList, pEntry,
 					    LL_ACCESS_LOCK)) {
-					csr_release_command_roam(pMac, pCommand);
+					csr_release_command(pMac, pCommand);
 				} else {
 					sms_log(pMac, LOGE,
 						" **********csr_roam_complete fail to release command reason %d",
@@ -7589,7 +7549,7 @@ QDF_STATUS csr_roam_issue_connect(tpAniSirGlobal pMac, uint32_t sessionId,
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL(" fail to send message status = %d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	}
 
@@ -7649,7 +7609,7 @@ QDF_STATUS csr_roam_issue_reassoc(tpAniSirGlobal pMac, uint32_t sessionId,
 				FL(" fail to send message status = %d"), status);
 			csr_roam_completion(pMac, sessionId, NULL, pCommand,
 					    eCSR_ROAM_RESULT_FAILURE, false);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	}
 	return status;
@@ -7681,7 +7641,7 @@ QDF_STATUS csr_dequeue_roam_command(tpAniSirGlobal pMac, eCsrRoamReason reason,
 			if (csr_ll_remove_entry
 				    (&pMac->sme.smeCmdActiveList, pEntry,
 				    LL_ACCESS_LOCK)) {
-				csr_release_command_roam(pMac, pCommand);
+				csr_release_command(pMac, pCommand);
 			}
 		} else {
 			sms_log(pMac, LOGE, FL("Command = %d, Reason = %d "),
@@ -8271,7 +8231,7 @@ QDF_STATUS csr_roam_issue_disassociate_cmd(tpAniSirGlobal pMac, uint32_t session
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL(" fail to send message status = %d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	} while (0);
 	return status;
@@ -8297,7 +8257,7 @@ QDF_STATUS csr_roam_issue_stop_bss_cmd(tpAniSirGlobal pMac, uint32_t sessionId,
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL(" fail to send message status = %d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	} else {
 		sms_log(pMac, LOGE, FL(" fail to get command buffer"));
@@ -9195,7 +9155,7 @@ csr_dequeue_command(tpAniSirGlobal mac_ctx)
 		cmd->u.roamCmd.fReleaseProfile = false;
 	}
 	if (fRemoveCmd)
-		csr_release_command_roam(mac_ctx, cmd);
+		csr_release_command(mac_ctx, cmd);
 	else
 		sms_log(mac_ctx, LOGE, FL("fail to remove cmd reason %d"),
 			cmd->u.roamCmd.roamReason);
@@ -9968,7 +9928,7 @@ static QDF_STATUS csr_roam_issue_set_key_command(tpAniSirGlobal pMac,
 	 * KRK key.
 	 */
 	if (false == enqueue_cmd)
-		csr_release_command_set_key(pMac, pCommand);
+		csr_release_command(pMac, pCommand);
 
 	return status;
 }
@@ -10299,7 +10259,7 @@ bool csr_roam_issue_wm_status_change(tpAniSirGlobal pMac, uint32_t sessionId,
 			fCommandQueued = true;
 		} else {
 			sms_log(pMac, LOGE, FL(" fail to send message "));
-			csr_release_command_wm_status_change(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 
 		/* AP has issued Dissac/Deauth, Set the operating mode value to configured value */
@@ -11372,7 +11332,7 @@ csr_roam_chk_lnk_set_ctx_rsp(tpAniSirGlobal mac_ctx, tSirSmeRsp *msg_ptr)
 remove_entry_n_process_pending:
 	if (csr_ll_remove_entry(&mac_ctx->sme.smeCmdActiveList, entry,
 				LL_ACCESS_LOCK))
-		csr_release_command_set_key(mac_ctx, cmd);
+		csr_release_command(mac_ctx, cmd);
 
 process_pending_n_exit:
 	sme_process_pending_queue(mac_ctx);
@@ -11917,7 +11877,7 @@ static void csr_roam_wm_status_change_complete(tpAniSirGlobal pMac,
 			if (csr_ll_remove_entry
 				    (&pMac->sme.smeCmdActiveList, pEntry,
 				    LL_ACCESS_LOCK)) {
-				csr_release_command_wm_status_change(pMac, pCommand);
+				csr_release_command(pMac, pCommand);
 			} else {
 				sms_log(pMac, LOGE,
 					" ******csr_roam_wm_status_change_complete fail to release command");
@@ -18334,12 +18294,50 @@ tSmeCmd *csr_get_command_buffer(tpAniSirGlobal pMac)
 	return pCmd;
 }
 
+static void csr_free_cmd_memory(tpAniSirGlobal pMac, tSmeCmd *pCommand)
+{
+	if (!pCommand) {
+		return;
+	}
+	switch (pCommand->command) {
+	case eSmeCommandScan:
+		csr_release_command_scan(pMac, pCommand);
+		break;
+	case eSmeCommandRoam:
+		csr_release_command_roam(pMac, pCommand);
+		break;
+	case eSmeCommandWmStatusChange:
+		csr_release_command_wm_status_change(pMac, pCommand);
+		break;
+	case eSmeCommandSetKey:
+		csr_release_command_set_key(pMac, pCommand);
+		break;
+	case eSmeCommandNdpInitiatorRequest:
+		csr_release_ndp_initiator_req(pMac, pCommand);
+		break;
+	case eSmeCommandNdpResponderRequest:
+		csr_release_ndp_responder_req(pMac, pCommand);
+		break;
+	case eSmeCommandNdpDataEndInitiatorRequest:
+		csr_release_ndp_data_end_req(pMac, pCommand);
+		break;
+	case eSmeCommandRemainOnChannel:
+		csr_release_roc_req_cmd(pMac, pCommand);
+		break;
+	default:
+		break;
+	}
+}
+
 void csr_release_command(tpAniSirGlobal pMac, tSmeCmd *pCommand)
 {
 	if (pMac->roam.sPendingCommands > 0) {
-		/* All command allocated through csr_get_command_buffer need to */
-		/* decrement the pending count when releasing. */
+		/*
+		 * All command allocated through csr_get_command_buffer
+		 * need to decrement the pending count when releasing
+		 */
 		pMac->roam.sPendingCommands--;
+		csr_free_cmd_memory(pMac, pCommand);
 		sme_release_command(pMac, pCommand);
 	} else {
 		sms_log(pMac, LOGE, FL("no pending commands"));

core/sme/src/csr/csr_api_scan.c

@@ -644,7 +644,7 @@ release_cmd:
 			sessionId, status, scan_cmd->u.scanCmd.reason,
 			scan_req->SSIDs.numOfSSIDs, scan_req->p2pSearch,
 			scan_cmd->u.scanCmd.scanID);
-		csr_release_command_scan(pMac, scan_cmd);
+		csr_release_command(pMac, scan_cmd);
 	}
 
 	return status;
@@ -954,7 +954,7 @@ release_lost_link1_cmd:
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		sms_log(mac_ctx, LOGW, FL("failed with status %d"), status);
 		if (cmd)
-			csr_release_command_scan(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 		status = csr_scan_handle_failed_lostlink1(mac_ctx, session_id);
 	}
 	return status;
@@ -1083,7 +1083,7 @@ release_lost_link2_cmd:
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		sms_log(mac_ctx, LOGW, FL("failed with status %d"), status);
 		if (cmd)
-			csr_release_command_scan(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 		status = csr_scan_handle_failed_lostlink2(mac_ctx, session_id);
 	}
 	return status;
@@ -1138,7 +1138,7 @@ csr_scan_request_lost_link3(tpAniSirGlobal mac_ctx, uint32_t session_id)
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		sms_log(mac_ctx, LOGW, FL("failed with status %d"), status);
 		if (cmd)
-			csr_release_command_scan(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 	}
 
 	return status;
@@ -6075,7 +6075,7 @@ bool csr_scan_remove_fresh_scan_command(tpAniSirGlobal pMac, uint8_t sessionId)
 				pCommand->u.scanCmd.pContext, sessionId,
 				pCommand->u.scanCmd.scanID, eCSR_SCAN_ABORT);
 		}
-		csr_release_command_scan(pMac, pCommand);
+		csr_release_command(pMac, pCommand);
 	}
 	csr_ll_close(&localList);
 
@@ -6101,7 +6101,7 @@ void csr_release_scan_command(tpAniSirGlobal pMac, tSmeCmd *pCommand,
 			pCommand->u.scanCmd.scanID);
 		return;
 	}
-	csr_release_command_scan(pMac, pCommand);
+	csr_release_command(pMac, pCommand);
 }
 
 QDF_STATUS csr_scan_get_pmkid_candidate_list(tpAniSirGlobal pMac,
@@ -6463,7 +6463,7 @@ error:
 		sms_log(mac_ctx, LOGE,
 			FL(" failed to iniate scan with status = %d"), status);
 		if (scan_cmd)
-			csr_release_command_scan(mac_ctx, scan_cmd);
+			csr_release_command(mac_ctx, scan_cmd);
 		if (notify)
 			csr_roam_call_callback(mac_ctx, session_id, NULL,
 					roam_id, eCSR_ROAM_FAILED,

core/sme/src/csr/csr_host_scan_roam.c

@@ -118,7 +118,7 @@ QDF_STATUS csr_roam_issue_reassociate_cmd(tpAniSirGlobal pMac,
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			sms_log(pMac, LOGE,
 				FL("fail to send message status=%d"), status);
-			csr_release_command_roam(pMac, pCommand);
+			csr_release_command(pMac, pCommand);
 		}
 	} while (0);
 

core/sme/src/csr/csr_inside_api.h

@@ -208,7 +208,7 @@ bool csr_scan_complete(tpAniSirGlobal pMac, tSirSmeScanRsp *pScanRsp);
 void csr_release_command_roam(tpAniSirGlobal pMac, tSmeCmd *pCommand);
 void csr_release_command_scan(tpAniSirGlobal pMac, tSmeCmd *pCommand);
 void csr_release_command_wm_status_change(tpAniSirGlobal pMac, tSmeCmd *pCommand);
-extern void csr_release_roc_req_cmd(tpAniSirGlobal mac_ctx, uint8_t session_id);
+void csr_release_roc_req_cmd(tpAniSirGlobal mac_ctx, tSmeCmd *pCommand);
 
 bool csr_is_duplicate_bss_description(tpAniSirGlobal pMac,
 				      tSirBssDescription *pSirBssDesc1,

core/sme/src/nan/nan_datapath_api.c

@@ -113,7 +113,7 @@ QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
 		cmd->u.initiator_req.ndp_info.ndp_app_info =
 			qdf_mem_malloc(req_params->ndp_info.ndp_app_info_len);
 		if (NULL == cmd->u.initiator_req.ndp_info.ndp_app_info) {
-			csr_release_ndp_initiator_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -126,7 +126,7 @@ QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
 		cmd->u.initiator_req.ndp_config.ndp_cfg =
 			qdf_mem_malloc(req_params->ndp_config.ndp_cfg_len);
 		if (NULL == cmd->u.initiator_req.ndp_config.ndp_cfg) {
-			csr_release_ndp_initiator_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -139,7 +139,7 @@ QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
 		cmd->u.initiator_req.pmk.pmk =
 			qdf_mem_malloc(req_params->pmk.pmk_len);
 		if (NULL == cmd->u.initiator_req.pmk.pmk) {
-			csr_release_ndp_initiator_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -151,7 +151,7 @@ QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
 	if (QDF_STATUS_SUCCESS != status) {
 		sms_log(mac_ctx, LOGE, FL("SME enqueue failed, status:%d"),
 			status);
-		csr_release_ndp_initiator_req(mac_ctx, cmd);
+		csr_release_command(mac_ctx, cmd);
 	}
 
 	sme_release_global_lock(&mac_ctx->sme);
@@ -205,7 +205,7 @@ QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
 		cmd->u.responder_req.ndp_info.ndp_app_info =
 			qdf_mem_malloc(req_params->ndp_info.ndp_app_info_len);
 		if (NULL == cmd->u.responder_req.ndp_info.ndp_app_info) {
-			csr_release_ndp_responder_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -218,7 +218,7 @@ QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
 		cmd->u.responder_req.ndp_config.ndp_cfg =
 			qdf_mem_malloc(req_params->ndp_config.ndp_cfg_len);
 		if (NULL == cmd->u.responder_req.ndp_config.ndp_cfg) {
-			csr_release_ndp_responder_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -231,7 +231,7 @@ QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
 		cmd->u.responder_req.pmk.pmk =
 			qdf_mem_malloc(req_params->pmk.pmk_len);
 		if (NULL == cmd->u.responder_req.pmk.pmk) {
-			csr_release_ndp_responder_req(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -243,7 +243,7 @@ QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
 	if (QDF_STATUS_SUCCESS != status) {
 		sms_log(mac_ctx, LOGE,
 			FL("SME enqueue failed, status:%d"), status);
-		csr_release_ndp_responder_req(mac_ctx, cmd);
+		csr_release_command(mac_ctx, cmd);
 	}
 
 	sme_release_global_lock(&mac_ctx->sme);
@@ -285,7 +285,7 @@ QDF_STATUS sme_ndp_end_req_handler(tHalHandle hal, struct ndp_end_req *req)
 	cmd->u.data_end_req = qdf_mem_malloc(sizeof(*req) +
 				(req->num_ndp_instances * sizeof(uint32_t)));
 	if (NULL == cmd->u.data_end_req) {
-			csr_release_command_roam(mac_ctx, cmd);
+			csr_release_command(mac_ctx, cmd);
 			sme_release_global_lock(&mac_ctx->sme);
 			return QDF_STATUS_E_NOMEM;
 	}
@@ -301,7 +301,7 @@ QDF_STATUS sme_ndp_end_req_handler(tHalHandle hal, struct ndp_end_req *req)
 		sms_log(mac_ctx, LOGE, FL("SME enqueue failed, status:%d"),
 			status);
 		ret = QDF_STATUS_E_FAILURE;
-		csr_release_ndp_data_end_req(mac_ctx, cmd);
+		csr_release_command(mac_ctx, cmd);
 	}
 
 	sme_release_global_lock(&mac_ctx->sme);
@@ -794,7 +794,6 @@ void sme_ndp_msg_processor(tpAniSirGlobal mac_ctx, struct scheduler_msg *msg)
 void csr_release_ndp_initiator_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
 {
 	csr_free_ndp_initiator_req(cmd);
-	csr_release_command(mac_ctx, cmd);
 }
 
 /**
@@ -808,7 +807,6 @@ void csr_release_ndp_initiator_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
 void csr_release_ndp_responder_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
 {
 	csr_free_ndp_responder_req(cmd);
-	csr_release_command(mac_ctx, cmd);
 }
 
 /**
@@ -823,5 +821,4 @@ void csr_release_ndp_data_end_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
 {
 	qdf_mem_free(cmd->u.data_end_req);
 	cmd->u.data_end_req = NULL;
-	csr_release_command(mac_ctx, cmd);
 }

core/sme/src/p2p/p2p_api.c

@@ -51,14 +51,14 @@ QDF_STATUS p2p_process_remain_on_channel_cmd(tpAniSirGlobal pMac,
 	if (!pSession) {
 		sms_log(pMac, LOGE, FL("  session %d not found "),
 			p2pRemainonChn->sessionId);
-		goto error;
+		return status;
 	}
 
 	if (!pSession->sessionActive) {
 		sms_log(pMac, LOGE,
 			FL("  session %d is invalid or listen is disabled "),
 			p2pRemainonChn->sessionId);
-		goto error;
+		return status;
 	}
 	len = sizeof(tSirRemainOnChnReq) + pMac->p2pContext.probeRspIeLength;
 
@@ -66,34 +66,30 @@ QDF_STATUS p2p_process_remain_on_channel_cmd(tpAniSirGlobal pMac,
 		/*In coming len for Msg is more then 16bit value */
 		sms_log(pMac, LOGE, FL("  Message length is very large, %d"),
 			len);
-		goto error;
+		return status;
 	}
 
 	pMsg = qdf_mem_malloc(len);
 	if (NULL == pMsg)
-		goto error;
-	else {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "%s call",
-			  __func__);
-		pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;
-		pMsg->length = (uint16_t) len;
-		qdf_copy_macaddr(&pMsg->selfMacAddr, &pSession->selfMacAddr);
-		pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;
-		pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;
-		pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;
-		pMsg->sessionId = p2pRemainonChn->sessionId;
-		pMsg->isProbeRequestAllowed =
-			p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;
-		pMsg->scan_id = p2pRemainonChn->u.remainChlCmd.scan_id;
-		if (pMac->p2pContext.probeRspIeLength)
-			qdf_mem_copy((void *)pMsg->probeRspIe,
-				     (void *)pMac->p2pContext.probeRspIe,
-				     pMac->p2pContext.probeRspIeLength);
-		status = umac_send_mb_message_to_mac(pMsg);
-	}
-error:
-	if (QDF_STATUS_E_FAILURE == status)
-		csr_release_roc_req_cmd(pMac, p2pRemainonChn->sessionId);
+		return status;
+	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "%s call",
+		  __func__);
+	pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;
+	pMsg->length = (uint16_t) len;
+	qdf_copy_macaddr(&pMsg->selfMacAddr, &pSession->selfMacAddr);
+	pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;
+	pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;
+	pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;
+	pMsg->sessionId = p2pRemainonChn->sessionId;
+	pMsg->isProbeRequestAllowed =
+		p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;
+	pMsg->scan_id = p2pRemainonChn->u.remainChlCmd.scan_id;
+	if (pMac->p2pContext.probeRspIeLength)
+		qdf_mem_copy((void *)pMsg->probeRspIe,
+			     (void *)pMac->p2pContext.probeRspIe,
+			     pMac->p2pContext.probeRspIeLength);
+	status = umac_send_mb_message_to_mac(pMsg);
+
 	return status;
 }