qcacld-3.0: umac: Remove logs for qdf_mem_malloc() checks

qdf_mem_malloc() function already takes care of logging the
caller function name and line number in case of any allocation error.
Hence there is no need to add the error log again.

Getting rid of these unnecessary logs reduces driver memory footprint.

Change-Id: I9f97967870b3bd05355e21b68a77230b920eeb0a
CRs-Fixed: 2781932

core/mac/src/pe/lim/lim_process_sme_req_messages.c

@@ -121,7 +121,6 @@ static QDF_STATUS lim_process_set_hw_mode(struct mac_context *mac, uint32_t *msg
 
 	req_msg = qdf_mem_malloc(len);
 	if (!req_msg) {
-		pe_debug("failed to allocate memory");
 		status = QDF_STATUS_E_NOMEM;
 		goto fail;
 	}
@@ -190,7 +189,6 @@ static QDF_STATUS lim_process_set_dual_mac_cfg_req(struct mac_context *mac,
 
 	req_msg = qdf_mem_malloc(len);
 	if (!req_msg) {
-		pe_debug("failed to allocate memory");
 		status = QDF_STATUS_E_NOMEM;
 		goto fail;
 	}
@@ -256,7 +254,6 @@ static QDF_STATUS lim_process_set_antenna_mode_req(struct mac_context *mac,
 
 	req_msg = qdf_mem_malloc(sizeof(*req_msg));
 	if (!req_msg) {
-		pe_debug("failed to allocate memory");
 		status = QDF_STATUS_E_NOMEM;
 		goto fail;
 	}
@@ -5670,10 +5667,8 @@ static void lim_nss_update_rsp(struct mac_context *mac_ctx,
 	QDF_STATUS qdf_status;
 
 	nss_rsp = qdf_mem_malloc(sizeof(*nss_rsp));
-	if (!nss_rsp) {
-		pe_err("AllocateMemory failed for nss_rsp");
+	if (!nss_rsp)
 		return;
-	}
 
 	nss_rsp->vdev_id = vdev_id;
 	nss_rsp->status = status;

core/mac/src/pe/lim/lim_send_management_frames.c

@@ -1169,10 +1169,9 @@ static QDF_STATUS lim_assoc_rsp_tx_complete(
 	}
 
 	lim_assoc_ind = qdf_mem_malloc(sizeof(tLimMlmAssocInd));
-	if (!lim_assoc_ind) {
-		pe_err("lim assoc ind is NULL");
+	if (!lim_assoc_ind)
 		goto free_assoc_req;
-	}
+
 	if (!lim_fill_lim_assoc_ind_params(lim_assoc_ind, mac_ctx,
 					   sta_ds, session_entry)) {
 		pe_err("lim assoc ind fill error");
@@ -1180,10 +1179,9 @@ static QDF_STATUS lim_assoc_rsp_tx_complete(
 	}
 
 	sme_assoc_ind = qdf_mem_malloc(sizeof(struct assoc_ind));
-	if (!sme_assoc_ind) {
-		pe_err("sme assoc ind is NULL");
+	if (!sme_assoc_ind)
 		goto lim_assoc_ind;
-	}
+
 	sme_assoc_ind->messageType = eWNI_SME_ASSOC_IND_UPPER_LAYER;
 	lim_fill_sme_assoc_ind_params(
 				mac_ctx, lim_assoc_ind,
@@ -5523,10 +5521,8 @@ lim_handle_sae_auth_retry(struct mac_context *mac_ctx, uint8_t vdev_id,
 		lim_sae_auth_cleanup_retry(mac_ctx, vdev_id);
 
 	sae_retry->sae_auth.data = qdf_mem_malloc(frame_len);
-	if (!sae_retry->sae_auth.data) {
-		pe_err("failed to alloc memory for sae auth");
+	if (!sae_retry->sae_auth.data)
 		return;
-	}
 
 	pe_debug("SAE auth frame queued vdev_id %d seq_num %d",
 		 vdev_id, mac_ctx->mgmtSeqNum);

core/mac/src/pe/rrm/rrm_api.c

@@ -988,9 +988,7 @@ rrm_process_beacon_report_xmit(struct mac_context *mac_ctx,
 		}
 
 		report = qdf_mem_malloc(MAX_BEACON_REPORTS * sizeof(*report));
-
 		if (!report) {
-			pe_err("RRM Report is NULL, allocation failed");
 			status = QDF_STATUS_E_NOMEM;
 			goto end;
 		}

core/mac/src/pe/sch/sch_api.c

@@ -216,10 +216,8 @@ uint32_t lim_send_probe_rsp_template_to_hal(struct mac_context *mac,
 		*/
 		addIeWoP2pIe = qdf_mem_malloc(pe_session->add_ie_params.
 						probeRespDataLen);
-		if (!addIeWoP2pIe) {
-			pe_err("FAILED to alloc memory when removing P2P IE");
+		if (!addIeWoP2pIe)
 			return QDF_STATUS_E_NOMEM;
-		}
 
 		retStatus = lim_remove_p2p_ie_from_add_ie(mac, pe_session,
 					addIeWoP2pIe, &addnIELenWoP2pIe);
@@ -232,7 +230,6 @@ uint32_t lim_send_probe_rsp_template_to_hal(struct mac_context *mac,
 		/*need to check the data length */
 		addIE = qdf_mem_malloc(addnIELenWoP2pIe);
 		if (!addIE) {
-			pe_err("Unable to get WNI_CFG_PROBE_RSP_ADDNIE_DATA1 length");
 			qdf_mem_free(addIeWoP2pIe);
 			return QDF_STATUS_E_NOMEM;
 		}
@@ -399,10 +396,8 @@ int sch_gen_timing_advert_frame(struct mac_context *mac_ctx, tSirMacAddr self_ad
 
 	buf_size = sizeof(tSirMacMgmtHdr) + payload_size;
 	*buf = qdf_mem_malloc(buf_size);
-	if (!*buf) {
-		pe_err("Cannot allocate memory");
+	if (!*buf)
 		return QDF_STATUS_E_FAILURE;
-	}
 
 	payload_size = 0;
 	status = dot11f_pack_timing_advertisement_frame(mac_ctx, &frame,

core/sap/src/sap_module.c

@@ -212,7 +212,6 @@ struct sap_context *sap_create_ctx(void)
 	struct sap_context *sap_ctx;
 	QDF_STATUS status;
 
-	/* dynamically allocate the sap_ctx */
 	sap_ctx = qdf_mem_malloc(sizeof(*sap_ctx));
 	if (!sap_ctx)
 		return NULL;

core/sme/src/common/sme_api.c

@@ -1445,6 +1445,7 @@ static QDF_STATUS sme_extended_change_channel_ind(struct mac_context *mac_ctx,
 	roam_info = qdf_mem_malloc(sizeof(*roam_info));
 	if (!roam_info)
 		return QDF_STATUS_E_NOMEM;
+
 	session_id = ext_chan_ind->session_id;
 	roam_info->target_chan_freq = ext_chan_ind->new_chan_freq;
 	roam_status = eCSR_ROAM_EXT_CHG_CHNL_IND;
@@ -9464,10 +9465,8 @@ QDF_STATUS sme_ap_disable_intra_bss_fwd(mac_handle_t mac_handle,
 
 	/* Prepare the request to send to SME. */
 	pSapDisableIntraFwd = qdf_mem_malloc(sizeof(tDisableIntraBssFwd));
-	if (!pSapDisableIntraFwd) {
-		sme_err("Memory Allocation Failure!!!");
+	if (!pSapDisableIntraFwd)
 		return QDF_STATUS_E_NOMEM;
-	}
 
 	pSapDisableIntraFwd->sessionId = sessionId;
 	pSapDisableIntraFwd->disableintrabssfwd = disablefwd;
@@ -9985,6 +9984,7 @@ sme_ext_scan_get_capabilities(mac_handle_t mac_handle,
 	bodyptr = qdf_mem_malloc(sizeof(*bodyptr));
 	if (!bodyptr)
 		return QDF_STATUS_E_NOMEM;
+
 	*bodyptr = *params;
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10021,6 +10021,7 @@ sme_ext_scan_start(mac_handle_t mac_handle,
 	bodyptr = qdf_mem_malloc(sizeof(*bodyptr));
 	if (!bodyptr)
 		return QDF_STATUS_E_NOMEM;
+
 	*bodyptr = *params;
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10056,6 +10057,7 @@ QDF_STATUS sme_ext_scan_stop(mac_handle_t mac_handle,
 	bodyptr = qdf_mem_malloc(sizeof(*bodyptr));
 	if (!bodyptr)
 		return QDF_STATUS_E_NOMEM;
+
 	*bodyptr = *params;
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10235,6 +10237,7 @@ sme_get_cached_results(mac_handle_t mac_handle,
 	bodyptr = qdf_mem_malloc(sizeof(*bodyptr));
 	if (!bodyptr)
 		return QDF_STATUS_E_NOMEM;
+
 	*bodyptr = *params;
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10276,6 +10279,7 @@ QDF_STATUS sme_set_epno_list(mac_handle_t mac_handle,
 	req_msg = qdf_mem_malloc(len);
 	if (!req_msg)
 		return QDF_STATUS_E_NOMEM;
+
 	qdf_mem_copy(req_msg, params, len);
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10317,6 +10321,7 @@ QDF_STATUS sme_set_passpoint_list(mac_handle_t mac_handle,
 	req_msg = qdf_mem_malloc(len);
 	if (!req_msg)
 		return QDF_STATUS_E_NOMEM;
+
 	qdf_mem_copy(req_msg, params, len);
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -10355,6 +10360,7 @@ QDF_STATUS sme_reset_passpoint_list(mac_handle_t mac_handle,
 	req_msg = qdf_mem_malloc(sizeof(*req_msg));
 	if (!req_msg)
 		return QDF_STATUS_E_NOMEM;
+
 	*req_msg = *params;
 
 	status = sme_acquire_global_lock(&mac->sme);
@@ -11951,7 +11957,6 @@ int sme_config_action_tx_in_tb_ppdu(mac_handle_t mac_handle, uint8_t session_id,
 	}
 
 	cfg_msg = qdf_mem_malloc(sizeof(*cfg_msg));
-
 	if (!cfg_msg)
 		return -EIO;
 
@@ -16187,10 +16192,8 @@ sme_get_mws_coex_info(mac_handle_t mac_handle, uint32_t vdev_id,
 	struct sir_get_mws_coex_info *req;
 
 	req = qdf_mem_malloc(sizeof(*req));
-	if (!req) {
-		sme_err("Failed allocate memory for MWS coex info req");
+	if (!req)
 		return QDF_STATUS_E_NOMEM;
-	}
 
 	req->vdev_id = vdev_id;
 	req->cmd_id  = cmd_id;
@@ -16399,6 +16402,7 @@ QDF_STATUS sme_set_roam_triggers(mac_handle_t mac_handle,
 	roam_trigger_data = qdf_mem_malloc(sizeof(*roam_trigger_data));
 	if (!roam_trigger_data)
 		return QDF_STATUS_E_NOMEM;
+
 	*roam_trigger_data = *triggers;
 
 	status = sme_acquire_global_lock(&mac->sme);

core/sme/src/csr/csr_api_roam.c

@@ -10026,10 +10026,9 @@ QDF_STATUS csr_continue_lfr2_connect(struct mac_context *mac,
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 
 	roam_info = qdf_mem_malloc(sizeof(*roam_info));
-	if (!roam_info) {
-		sme_err("malloc failed");
+	if (!roam_info)
 		return QDF_STATUS_E_NOMEM;
-	}
+
 	scan_handle_roam_ap =
 		mac->roam.neighborRoamInfo[session_id].scan_res_lfr2_roam_ap;
 	if (!scan_handle_roam_ap) {
@@ -10470,7 +10469,6 @@ void csr_roam_joined_state_msg_processor(struct mac_context *mac, void *msg_buf)
 
 		roam_info = qdf_mem_malloc(sizeof(*roam_info));
 		if (!roam_info) {
-			sme_err("roam_info not allocated");
 			if (pUpperLayerAssocCnf->ies)
 				qdf_mem_free(pUpperLayerAssocCnf->ies);
 			return;

core/sme/src/csr/csr_api_scan.c

@@ -2599,10 +2599,8 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 		return;
 
 	filter = qdf_mem_malloc(sizeof(*filter));
-	if (!filter) {
-		sme_err("filter is NULL");
+	if (!filter)
 		return;
-	}
 
 	status = csr_fill_filter_from_vdev_crypto(mac_ctx, filter, sessionId);
 	if (QDF_IS_STATUS_ERROR(status)) {

core/wma/src/wma_dev_if.c

@@ -536,6 +536,7 @@ static QDF_STATUS wma_self_peer_remove(tp_wma_handle wma_handle,
 			qdf_status = QDF_STATUS_E_NOMEM;
 			goto error;
 		}
+
 		sta_self_wmi_rsp->self_sta_param = del_vdev_req;
 		msg = wma_fill_hold_req(wma_handle, vdev_id,
 					WMA_DELETE_STA_REQ,
@@ -1488,17 +1489,14 @@ QDF_STATUS wma_peer_unmap_conf_cb(uint8_t vdev_id,
 		peer_unmap_conf_req = qdf_mem_malloc(sizeof(
 					struct send_peer_unmap_conf_params));
 
-		if (!peer_unmap_conf_req) {
-			wma_err("peer_unmap_conf_req memory alloc failed");
+		if (!peer_unmap_conf_req)
 			return QDF_STATUS_E_NOMEM;
-		}
 
 		peer_unmap_conf_req->vdev_id = vdev_id;
 		peer_unmap_conf_req->peer_id_cnt = peer_id_cnt;
 		peer_unmap_conf_req->peer_id_list =  qdf_mem_malloc(
 					sizeof(uint16_t) * peer_id_cnt);
 		if (!peer_unmap_conf_req->peer_id_list) {
-			wma_err("peer_id_list memory alloc failed");
 			qdf_mem_free(peer_unmap_conf_req);
 			peer_unmap_conf_req = NULL;
 			return QDF_STATUS_E_NOMEM;
@@ -2196,11 +2194,8 @@ __wma_handle_vdev_stop_rsp(struct vdev_stop_response *resp_event)
 	}
 
 	vdev_stop_resp = qdf_mem_malloc(sizeof(*vdev_stop_resp));
-	if (!vdev_stop_resp) {
-		wma_err("Failed to alloc vdev_stop_resp for vdev id %d",
-			resp_event->vdev_id);
+	if (!vdev_stop_resp)
 		return QDF_STATUS_E_NOMEM;
-	}
 
 	if (vdev_stop_type == WMA_DELETE_BSS_HO_FAIL_REQ) {
 		status = wma_remove_peer(wma, bssid.bytes,
@@ -3078,10 +3073,9 @@ void wma_hold_req_timer(void *data)
 			wma_trigger_recovery_assert_on_fw_timeout(
 			  SIR_HAL_PDEV_SET_HW_MODE,
 			  QDF_MAC_HW_MODE_CHANGE_TIMEOUT);
-		if (!params) {
-			wma_err("Failed to allocate memory for params");
+		if (!params)
 			goto timer_destroy;
-		}
+
 		params->status = SET_HW_MODE_STATUS_ECANCELED;
 		params->cfgd_hw_mode_index = 0;
 		params->num_vdev_mac_entries = 0;
@@ -3097,10 +3091,8 @@ void wma_hold_req_timer(void *data)
 			wma_trigger_recovery_assert_on_fw_timeout(
 				SIR_HAL_PDEV_DUAL_MAC_CFG_REQ,
 				QDF_MAC_HW_MODE_CONFIG_TIMEOUT);
-		if (!resp) {
-			wma_err("Failed to allocate memory for resp");
+		if (!resp)
 			goto timer_destroy;
-		}
 
 		resp->status = SET_HW_MODE_STATUS_ECANCELED;
 		wma_send_msg_high_priority(wma, SIR_HAL_PDEV_MAC_CFG_RESP,
@@ -3445,6 +3437,7 @@ static QDF_STATUS wma_update_iface_params(tp_wma_handle wma,
 	iface->addBssStaContext = qdf_mem_malloc(sizeof(tAddStaParams));
 	if (!iface->addBssStaContext)
 		return QDF_STATUS_E_RESOURCES;
+
 	*iface->addBssStaContext = add_bss->staContext;
 	/* Save parameters later needed by WMA_ADD_STA_REQ */
 	iface->rmfEnabled = add_bss->rmfEnabled;
@@ -4003,7 +3996,7 @@ static void wma_add_tdls_sta(tp_wma_handle wma, tpAddStaParams add_sta)
 			  QDF_MAC_ADDR_REF(add_sta->staMac));
 
 		peer_state = qdf_mem_malloc(sizeof(*peer_state));
-	if (!peer_state) {
+		if (!peer_state) {
 			add_sta->status = QDF_STATUS_E_NOMEM;
 			goto send_rsp;
 		}
@@ -4690,10 +4683,9 @@ void wma_delete_bss_ho_fail(tp_wma_handle wma, uint8_t vdev_id)
 
 fail_del_bss_ho_fail:
 	vdev_stop_resp = qdf_mem_malloc(sizeof(*vdev_stop_resp));
-	if (!vdev_stop_resp) {
-		wma_err("Failed to alloc del bss resp ");
+	if (!vdev_stop_resp)
 		return;
-	}
+
 	vdev_stop_resp->vdev_id = vdev_id;
 	vdev_stop_resp->status = status;
 	wma_send_msg_high_priority(wma, WMA_DELETE_BSS_HO_FAIL_RSP,
@@ -4867,10 +4859,9 @@ detach_peer:
 
 out:
 	params = qdf_mem_malloc(sizeof(*params));
-	if (!params) {
-		wma_err("vdev id %d : failed to alloc del bss resp", vdev_id);
+	if (!params)
 		return;
-	}
+
 	params->vdev_id = vdev_id;
 	params->status = status;
 	wma_send_msg_high_priority(wma, WMA_DELETE_BSS_RSP, params, 0);

core/wma/src/wma_features.c

@@ -245,10 +245,8 @@ void wma_get_rx_retry_cnt(struct mac_context *mac, uint8_t vdev_id,
 	QDF_STATUS status;
 
 	peer_stats = qdf_mem_malloc(sizeof(*peer_stats));
-	if (!peer_stats) {
-		wma_err("Failed to allocate memory for peer stats");
+	if (!peer_stats)
 		return;
-	}
 
 	status = cdp_host_get_peer_stats(cds_get_context(QDF_MODULE_ID_SOC),
 					 vdev_id, mac_addr, peer_stats);
@@ -2931,6 +2929,7 @@ QDF_STATUS wma_process_tsm_stats_req(tp_wma_handle wma_handler,
 		qdf_mem_free(pTsmStatsMsg);
 		return QDF_STATUS_E_NOMEM;
 	}
+
 	qdf_copy_macaddr(&pTsmRspParams->bssid, &pStats->bssId);
 	pTsmRspParams->rc = QDF_STATUS_E_FAILURE;
 	pTsmRspParams->tsmStatsReq = pStats;

core/wma/src/wma_scan_roam.c

@@ -3497,10 +3497,8 @@ int wma_roam_scan_chan_list_event_handler(WMA_HANDLE handle,
 
 	resp = qdf_mem_malloc(sizeof(struct roam_scan_ch_resp) +
 		num_ch * sizeof(param_buf->channel_list[0]));
-	if (!resp) {
-		wma_err_rl("Failed to alloc resp message");
+	if (!resp)
 		return -EINVAL;
-	}
 
 	resp->chan_list = (uint32_t *)(resp + 1);
 	resp->vdev_id = vdev_id;
@@ -5752,7 +5750,6 @@ int wma_passpoint_match_event_handler(void *handle,
 	}
 
 	dest_match = qdf_mem_malloc(sizeof(*dest_match) + buf_len);
-
 	if (!dest_match)
 		return -EINVAL;
 

core/wma/src/wma_utils.c

@@ -1714,7 +1714,6 @@ static int wma_unified_link_peer_stats_event_handler(void *handle,
 		     &fixed_param->num_peers, peer_stats_size);
 	dp_stats = qdf_mem_malloc(sizeof(*dp_stats));
 	if (!dp_stats) {
-		wma_err("dp stats allocation failed");
 		qdf_mem_free(link_stats_results);
 		return -ENOMEM;
 	}
@@ -3618,10 +3617,8 @@ QDF_STATUS wma_get_roam_scan_ch(wmi_unified_t wmi_handle,
 	if (QDF_IS_STATUS_SUCCESS(status))
 		return status;
 	roam_ch = qdf_mem_malloc(sizeof(struct roam_scan_ch_resp));
-	if (!roam_ch) {
-		wma_err("Failed to alloc resp");
+	if (!roam_ch)
 		return QDF_STATUS_E_INVAL;
-	}
 
 	roam_ch->command_resp = 1;
 	roam_ch->num_channels = 0;