qcacmn: Optimize logs in scan path

Remove redundant logs and optimize the logs in scan path.

Change-Id: I59c59db012f5e9526752d45303e44f2a27f91ec6
CRs-Fixed: 2612629

os_if/linux/scan/src/wlan_cfg80211_scan.c

@@ -414,10 +414,8 @@ int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_vdev *vdev,
 		status = wlan_abort_scan(pdev,
 				wlan_objmgr_pdev_get_pdev_id(pdev),
 				INVAL_VDEV_ID, INVAL_SCAN_ID, true);
-		if (QDF_IS_STATUS_ERROR(status)) {
-			osif_err("aborting the existing scan is unsuccessful");
+		if (QDF_IS_STATUS_ERROR(status))
 			return -EBUSY;
-		}
 	}
 
 	req = qdf_mem_malloc(sizeof(*req));
@@ -719,8 +717,6 @@ static QDF_STATUS wlan_scan_request_dequeue(
 	struct pdev_osif_priv *osif_ctx;
 	struct osif_scan_pdev *scan_priv;
 
-	osif_debug("Dequeue Scan id: %d", scan_id);
-
 	if ((!source) || (!req)) {
 		osif_err("source or request is NULL");
 		return QDF_STATUS_E_NULL_VALUE;
@@ -765,7 +761,7 @@ static QDF_STATUS wlan_scan_request_dequeue(
 				return QDF_STATUS_SUCCESS;
 			} else {
 				qdf_mutex_release(&scan_priv->scan_req_q_lock);
-				osif_err("Failed to remove node scan id %d, pending scans %d",
+				osif_err("Failed to remove scan id %d, pending scans %d",
 					 scan_id,
 					 qdf_list_size(&scan_priv->scan_req_q));
 				return status;
@@ -774,7 +770,7 @@ static QDF_STATUS wlan_scan_request_dequeue(
 	} while (QDF_STATUS_SUCCESS ==
 		qdf_list_peek_next(&scan_priv->scan_req_q, node, &next_node));
 	qdf_mutex_release(&scan_priv->scan_req_q_lock);
-	osif_err("Failed to find scan id %d", scan_id);
+	osif_debug("Failed to find scan id %d", scan_id);
 
 	return status;
 }
@@ -983,8 +979,8 @@ static void wlan_cfg80211_scan_done_callback(
 	if (!util_is_scan_completed(event, &success))
 		return;
 
-	osif_debug("scan ID = %d vdev id = %d, event type %s(%d) reason = %s(%d)",
-		   scan_id, event->vdev_id,
+	osif_debug("vdev %d, scan id %d type %s(%d) reason %s(%d)",
+		   event->vdev_id, scan_id,
 		   util_scan_get_ev_type_name(event->type), event->type,
 		   util_scan_get_ev_reason_name(event->reason),
 		   event->reason);
@@ -1303,6 +1299,10 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 		osif_err("Invalid psoc object");
 		return -EINVAL;
 	}
+	opmode = wlan_vdev_mlme_get_opmode(vdev);
+
+	osif_debug("%s(vdev%d): mode %d", request->wdev->netdev->name,
+		   wlan_vdev_get_id(vdev), opmode);
 
 	/* Get NL global context from objmgr*/
 	osif_priv = wlan_pdev_get_ospriv(pdev);
@@ -1318,7 +1318,7 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 	 */
 	if (!wlan_cfg80211_allow_simultaneous_scan(psoc) &&
 	    !qdf_list_empty(&osif_priv->osif_scan->scan_req_q) &&
-	    wlan_vdev_mlme_get_opmode(vdev) != QDF_SAP_MODE) {
+	    opmode != QDF_SAP_MODE) {
 		osif_err("Simultaneous scan disabled, reject scan");
 		return -EBUSY;
 	}
@@ -1370,7 +1370,7 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 		req->scan_req.num_ssids = request->n_ssids;
 
 		if (req->scan_req.num_ssids > WLAN_SCAN_MAX_NUM_SSID) {
-			osif_info("number of ssid received %d is greater than MAX %d so copy only MAX nuber of SSIDs",
+			osif_info("number of ssid %d greater than MAX %d",
 				  req->scan_req.num_ssids,
 				  WLAN_SCAN_MAX_NUM_SSID);
 			req->scan_req.num_ssids = WLAN_SCAN_MAX_NUM_SSID;
@@ -1385,11 +1385,8 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 			qdf_mem_copy(pssid->ssid,
 				     &request->ssids[j].ssid[0],
 				     pssid->length);
-			osif_info("SSID number %d: %.*s", j, pssid->length,
-				  pssid->ssid);
 		}
 	}
-	opmode = wlan_vdev_mlme_get_opmode(vdev);
 	if (request->ssids ||
 	   (opmode == QDF_P2P_GO_MODE) || (opmode == QDF_P2P_DEVICE_MODE))
 		req->scan_req.scan_f_passive = false;
@@ -1449,9 +1446,6 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 		qdf_set_macaddr_broadcast(&req->scan_req.bssid_list[0]);
 
 	if (request->n_channels) {
-		uint32_t buff_len = (request->n_channels * 5) + 1;
-		char *chl = qdf_mem_malloc(buff_len);
-		int len = 0;
 #ifdef WLAN_POLICY_MGR_ENABLE
 		bool ap_or_go_present =
 			policy_mgr_mode_specific_connection_count(
@@ -1459,10 +1453,6 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 			     policy_mgr_mode_specific_connection_count(
 			     psoc, PM_P2P_GO_MODE, NULL);
 #endif
-		if (!chl) {
-			ret = -ENOMEM;
-			goto err;
-		}
 		for (i = 0; i < request->n_channels; i++) {
 			c_freq = request->channels[i]->center_freq;
 			if (wlan_reg_is_dsrc_freq(c_freq))
@@ -1476,8 +1466,6 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 
 				if (QDF_IS_STATUS_ERROR(qdf_status)) {
 					osif_err("DNBS check failed");
-					qdf_mem_free(chl);
-					chl = NULL;
 					ret = -EINVAL;
 					goto err;
 				}
@@ -1485,8 +1473,6 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 					continue;
 			}
 #endif
-			len += snprintf(chl + len, buff_len - len, "%d ",
-					c_freq);
 			req->scan_req.chan_list.chan[num_chan].freq = c_freq;
 			band = util_scan_scm_freq_to_band(c_freq);
 			if (band == WLAN_BAND_2_4_GHZ)
@@ -1499,10 +1485,6 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 			if (num_chan >= NUM_CHANNELS)
 				break;
 		}
-		osif_info("Channel-List: %s", chl);
-		qdf_mem_free(chl);
-		chl = NULL;
-		osif_info("No. of Scan Channels: %d", num_chan);
 	}
 	if (!num_chan) {
 		osif_err("Received zero non-dsrc channels");
@@ -1579,7 +1561,7 @@ int wlan_cfg80211_scan(struct wlan_objmgr_vdev *vdev,
 
 	qdf_status = ucfg_scan_start(req);
 	if (QDF_IS_STATUS_ERROR(qdf_status)) {
-		osif_err("ucfg_scan_start returned error %d", qdf_status);
+		osif_err("scan req failed with error %d", qdf_status);
 		if (qdf_status == QDF_STATUS_E_RESOURCES)
 			osif_err("HO is in progress.So defer the scan by informing busy");
 		wlan_scan_request_dequeue(pdev, scan_id, &request,
@@ -1690,7 +1672,6 @@ QDF_STATUS wlan_abort_scan(struct wlan_objmgr_pdev *pdev,
 				vdev_id, WLAN_OSIF_ID);
 
 	if (!vdev) {
-		osif_err("Failed get vdev");
 		qdf_mem_free(req);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -1707,6 +1688,10 @@ QDF_STATUS wlan_abort_scan(struct wlan_objmgr_pdev *pdev,
 	else
 		req->cancel_req.req_type = WLAN_SCAN_CANCEL_VDEV_ALL;
 
+	osif_debug("Type %d Vdev %d pdev %d scan id %d sync %d",
+		   req->cancel_req.req_type, req->cancel_req.vdev_id,
+		   req->cancel_req.pdev_id, req->cancel_req.scan_id, sync);
+
 	if (sync)
 		status = ucfg_scan_cancel_sync(req);
 	else

umac/scan/core/src/wlan_scan_bss_score.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -828,24 +828,25 @@ int scm_calculate_bss_score(struct wlan_objmgr_psoc *psoc,
 					    prorated_pcnt, sta_nss);
 	score += nss_score;
 
-	scm_debug("Self Cap: HT %d VHT %d HE %d VHT_24Ghz %d BF cap %d cb_mode_24g %d cb_mode_5G %d NSS %d",
-		  score_config->ht_cap, score_config->vht_cap,
-		  score_config->he_cap,  score_config->vht_24G_cap,
-		  score_config->beamformee_cap, score_config->cb_mode_24G,
-		  score_config->cb_mode_5G, sta_nss);
-
-	scm_debug("Candidate (BSSID: %pM freq %d) Cap:: rssi=%d HT=%d VHT=%d HE %d su beamformer %d phymode=%d  air time fraction %d qbss load %d cong_pct %d NSS %d",
-		  entry->bssid.bytes, entry->channel.chan_freq,
-		  entry->rssi_raw, util_scan_entry_htcap(entry) ? 1 : 0,
-		  util_scan_entry_vhtcap(entry) ? 1 : 0,
-		  util_scan_entry_hecap(entry) ? 1 : 0, ap_su_beam_former,
-		  entry->phy_mode, entry->air_time_fraction,
-		  entry->qbss_chan_load, congestion_pct, entry->nss);
-
-	scm_debug("Candidate Scores : prorated_pcnt %d rssi %d pcl %d ht %d vht %d he %d beamformee %d bw %d band %d congestion %d nss %d oce wan %d TOTAL score %d",
-		  prorated_pcnt, rssi_score, pcl_score, ht_score, vht_score,
-		  he_score, beamformee_score, bandwidth_score, band_score,
-		  congestion_score, nss_score, oce_wan_score, score);
+	scm_nofl_debug("Self: HT %d VHT %d HE %d VHT_24Ghz %d BF cap %d cb_mode_24g %d cb_mode_5G %d NSS %d",
+		       score_config->ht_cap, score_config->vht_cap,
+		       score_config->he_cap,  score_config->vht_24G_cap,
+		       score_config->beamformee_cap, score_config->cb_mode_24G,
+		       score_config->cb_mode_5G, sta_nss);
+
+	scm_nofl_debug("Candidate(%pM freq %d): rssi %d HT %d VHT %d HE %d su bfer %d phy %d  air time frac %d qbss %d cong_pct %d NSS %d",
+		       entry->bssid.bytes, entry->channel.chan_freq,
+		       entry->rssi_raw, util_scan_entry_htcap(entry) ? 1 : 0,
+		       util_scan_entry_vhtcap(entry) ? 1 : 0,
+		       util_scan_entry_hecap(entry) ? 1 : 0, ap_su_beam_former,
+		       entry->phy_mode, entry->air_time_fraction,
+		       entry->qbss_chan_load, congestion_pct, entry->nss);
+
+	scm_nofl_debug("Scores: prorated_pcnt %d rssi %d pcl %d ht %d vht %d he %d bfee %d bw %d band %d congestion %d nss %d oce wan %d TOTAL %d",
+		       prorated_pcnt, rssi_score, pcl_score, ht_score,
+		       vht_score, he_score, beamformee_score, bandwidth_score,
+		       band_score, congestion_score, nss_score, oce_wan_score,
+		       score);
 
 	entry->bss_score = score;
 	return score;

umac/scan/core/src/wlan_scan_cache_db.c

@@ -883,13 +883,13 @@ static QDF_STATUS scm_add_update_entry(struct wlan_objmgr_psoc *psoc,
 					  &dup_node);
 
 	security_type = scan_params->security_type;
-	scm_nofl_debug("Received %s: BSSID: %pM tsf_delta %u Seq %d ssid: %.*s rssi: %d snr %d freq %d phy_mode %d hidden %d chan_mismatch %d %s%s%s%s pdev %d",
+	scm_nofl_debug("Received %s: %pM \"%.*s\" freq %d rssi %d tsf_delta %u seq %d snr %d phy %d hidden %d mismatch %d %s%s%s%s pdev %d",
 		       (scan_params->frm_subtype == MGMT_SUBTYPE_PROBE_RESP) ?
-		       "Probe Rsp" : "Beacon", scan_params->bssid.bytes,
-		       scan_params->tsf_delta, scan_params->seq_num,
+		       "prb rsp" : "bcn", scan_params->bssid.bytes,
 		       scan_params->ssid.length, scan_params->ssid.ssid,
-		       scan_params->rssi_raw, scan_params->snr,
-		       scan_params->channel.chan_freq, scan_params->phy_mode,
+		       scan_params->channel.chan_freq, scan_params->rssi_raw,
+		       scan_params->tsf_delta, scan_params->seq_num,
+		       scan_params->snr, scan_params->phy_mode,
 		       scan_params->is_hidden_ssid,
 		       scan_params->channel_mismatch,
 		       security_type & SCAN_SECURITY_TYPE_WPA ? "[WPA]" : "",
@@ -1018,10 +1018,11 @@ QDF_STATUS __scm_handle_bcn_probe(struct scan_bcn_probe_event *bcn)
 
 		if (scan_obj->drop_bcn_on_chan_mismatch &&
 		    scan_entry->channel_mismatch) {
-			scm_debug("Drop frame, as channel mismatch Received for from BSSID: %pM Seq Num: %d freq %d RSSI %d",
-				  scan_entry->bssid.bytes, scan_entry->seq_num,
-				  scan_entry->channel.chan_freq,
-				  scan_entry->rssi_raw);
+			scm_nofl_debug("Drop frame for chan mismatch %pM Seq Num: %d freq %d RSSI %d",
+				       scan_entry->bssid.bytes,
+				       scan_entry->seq_num,
+				       scan_entry->channel.chan_freq,
+				       scan_entry->rssi_raw);
 			util_scan_free_cache_entry(scan_entry);
 			qdf_mem_free(scan_node);
 			continue;

umac/scan/core/src/wlan_scan_manager.c

@@ -58,8 +58,6 @@ scm_scan_free_scan_request_mem(struct scan_start_request *req)
 		QDF_ASSERT(0);
 		return QDF_STATUS_E_FAILURE;
 	}
-	scm_debug("freed scan request: 0x%pK, scan_id: %d, requester: %d",
-		  req, req->scan_req.scan_id, req->scan_req.scan_req_id);
 	/* Free vendor(extra) ie */
 	ie = req->scan_req.extraie.ptr;
 	if (ie) {
@@ -167,10 +165,6 @@ static void scm_scan_post_event(struct wlan_objmgr_vdev *vdev,
 	cb_handlers = &(pdev_ev_handler->cb_handlers[0]);
 	requesters = scan->requesters;
 
-	scm_debug("vdev: %d, type: %d, reason: %d, freq: %d, req: %d, scanid: %d",
-		  event->vdev_id, event->type, event->reason, event->chan_freq,
-		  event->requester, event->scan_id);
-
 	listeners = qdf_mem_malloc_atomic(sizeof(*listeners));
 	if (!listeners) {
 		scm_warn("couldn't allocate listeners list");
@@ -197,11 +191,8 @@ static void scm_scan_post_event(struct wlan_objmgr_vdev *vdev,
 	qdf_spin_unlock_bh(&scan->lock);
 
 	/* notify all interested handlers */
-	for (i = 0; i < listeners->count; i++) {
-		scm_debug("func: 0x%pK, arg: 0x%pK",
-			listeners->cb[i].func, listeners->cb[i].arg);
+	for (i = 0; i < listeners->count; i++)
 		listeners->cb[i].func(vdev, event, listeners->cb[i].arg);
-	}
 	qdf_mem_free(listeners);
 }
 
@@ -331,10 +322,6 @@ scm_scan_serialize_callback(struct wlan_serialization_command *cmd,
 	}
 
 	req = cmd->umac_cmd;
-	scm_debug("reason:%d, reqid:%d, scanid:%d, vdevid:%d, vdev:0x%pK",
-		reason, req->scan_req.scan_req_id, req->scan_req.scan_id,
-		req->scan_req.vdev_id, req->vdev);
-
 	if (!req->vdev) {
 		scm_err("NULL vdev. req:0x%pK, reason:%d\n", req, reason);
 		QDF_ASSERT(0);
@@ -451,13 +438,12 @@ scm_update_dbs_scan_ctrl_ext_flag(struct scan_start_request *req)
 	psoc = wlan_vdev_get_psoc(req->vdev);
 
 	if (!policy_mgr_is_dbs_scan_allowed(psoc)) {
-		scm_debug("dbs disabled, going for non-dbs scan");
 		scan_dbs_policy = SCAN_DBS_POLICY_FORCE_NONDBS;
 		goto end;
 	}
 
 	if (!wlan_scan_cfg_honour_nl_scan_policy_flags(psoc)) {
-		scm_debug("nl scan policy flags not honoured, goto end");
+		scm_debug_rl("nl scan policy flags not honoured, goto end");
 		goto end;
 	}
 
@@ -477,8 +463,6 @@ end:
 	req->scan_req.scan_ctrl_flags_ext |=
 		((scan_dbs_policy << SCAN_FLAG_EXT_DBS_SCAN_POLICY_BIT)
 		 & SCAN_FLAG_EXT_DBS_SCAN_POLICY_MASK);
-	scm_debug("scan_ctrl_flags_ext: 0x%x",
-		  req->scan_req.scan_ctrl_flags_ext);
 }
 
 /**
@@ -913,9 +897,6 @@ scm_update_6ghz_channel_list(struct wlan_objmgr_vdev *vdev,
 		}
 		qdf_mem_free(chan_list_6g);
 	}
-	scm_debug("Number of channels to scan %d", num_scan_channels);
-	for (i = 0; i < num_scan_channels; i++)
-		scm_debug("channels to scan %d", chan_list->chan[i].freq);
 end:
 	chan_list->num_chan = num_scan_channels;
 }
@@ -1122,10 +1103,14 @@ scm_update_channel_list(struct scan_start_request *req,
 
 		freq = req->scan_req.chan_list.chan[i].freq;
 		if (skip_dfs_ch &&
-		    wlan_reg_chan_has_dfs_attribute_for_freq(pdev, freq))
+		    wlan_reg_chan_has_dfs_attribute_for_freq(pdev, freq)) {
+			scm_nofl_debug("Skip DFS freq %d", freq);
 			continue;
-		if (utils_dfs_is_freq_in_nol(pdev, freq))
+		}
+		if (utils_dfs_is_freq_in_nol(pdev, freq)) {
+			scm_nofl_debug("Skip NOL freq %d", freq);
 			continue;
+		}
 
 		req->scan_req.chan_list.chan[num_scan_channels++] =
 			req->scan_req.chan_list.chan[i];
@@ -1270,15 +1255,50 @@ scm_scan_req_update_params(struct wlan_objmgr_vdev *vdev,
 
 	scm_update_channel_list(req, scan_obj);
 	scm_update_rnr_info(req);
-	scm_debug("dwell time: active %d, passive %d, repeat_probe_time %d n_probes %d flags_ext %x, wide_bw_scan: %d priority: %d",
-		  req->scan_req.dwell_time_active,
-		  req->scan_req.dwell_time_passive,
-		  req->scan_req.repeat_probe_time, req->scan_req.n_probes,
-		  req->scan_req.scan_ctrl_flags_ext,
-		  req->scan_req.scan_f_wide_band,
-		  req->scan_req.scan_priority);
 }
 
+static inline void scm_print_scan_req_info(struct scan_req_params *req)
+{
+	uint32_t buff_len;
+	char *chan_buff;
+	uint32_t len = 0;
+	uint8_t idx;
+	struct chan_list *chan_lst;
+
+	scm_nofl_debug("Scan start: scan id %d vdev %d Dwell time: act %d pass %d act_2G %d act_6G %d pass_6G %d, probe time %d n_probes %d flags %x ext_flag %x events %x policy %d wide_bw %d pri %d",
+		       req->scan_id, req->vdev_id, req->dwell_time_active,
+		       req->dwell_time_passive, req->dwell_time_active_2g,
+		       req->dwell_time_active_6g, req->dwell_time_passive_6g,
+		       req->repeat_probe_time, req->n_probes, req->scan_flags,
+		       req->scan_ctrl_flags_ext, req->scan_events,
+		       req->scan_policy_type, req->scan_f_wide_band,
+		       req->scan_priority);
+
+	for (idx = 0; idx < req->num_ssids; idx++)
+		scm_nofl_debug("SSID[%d]: %.*s", idx, req->ssid[idx].length,
+			       req->ssid[idx].ssid);
+
+	chan_lst  = &req->chan_list;
+
+	if (!chan_lst->num_chan)
+		return;
+	/*
+	 * Buffer of (num channl * 5) + 1  to consider the 4 char freq and
+	 * 1 space after it for each channel and 1 to end the string with NULL.
+	 */
+	buff_len = (chan_lst->num_chan * 5) + 1;
+	chan_buff = qdf_mem_malloc(buff_len);
+	if (!chan_buff)
+		return;
+
+	for (idx = 0; idx < chan_lst->num_chan; idx++)
+		len += snprintf(chan_buff + len, buff_len - len, "%d ",
+					chan_lst->chan[idx].freq);
+
+	scm_nofl_debug("Freq list[%d]: %s", chan_lst->num_chan, chan_buff);
+
+	qdf_mem_free(chan_buff);
+}
 QDF_STATUS
 scm_scan_start_req(struct scheduler_msg *msg)
 {
@@ -1287,7 +1307,7 @@ scm_scan_start_req(struct scheduler_msg *msg)
 	struct scan_start_request *req = NULL;
 	struct wlan_scan_obj *scan_obj;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	uint8_t idx;
+
 
 	if (!msg) {
 		scm_err("msg received is NULL");
@@ -1316,21 +1336,14 @@ scm_scan_start_req(struct scheduler_msg *msg)
 	}
 
 	scm_scan_req_update_params(req->vdev, req, scan_obj);
+	scm_print_scan_req_info(&req->scan_req);
 
 	if (!req->scan_req.chan_list.num_chan) {
-		scm_err("Scan Aborted, 0 channel to scan");
+		scm_info("Reject 0 channel Scan");
 		status = QDF_STATUS_E_NULL_VALUE;
 		goto err;
 	}
 
-	scm_info("request to scan %d channels",
-		 req->scan_req.chan_list.num_chan);
-
-	for (idx = 0; idx < req->scan_req.chan_list.num_chan; idx++)
-		scm_debug("chan[%d]: freq:%d, phymode:%d", idx,
-			  req->scan_req.chan_list.chan[idx].freq,
-			  req->scan_req.chan_list.chan[idx].phymode);
-
 	cmd.cmd_type = WLAN_SER_CMD_SCAN;
 	cmd.cmd_id = req->scan_req.scan_id;
 	cmd.cmd_cb = scm_scan_serialize_callback;
@@ -1344,17 +1357,11 @@ scm_scan_start_req(struct scheduler_msg *msg)
 	if (scan_obj->disable_timeout)
 		cmd.cmd_timeout_duration = 0;
 
-	scm_debug("req: 0x%pK, reqid: %d, scanid: %d, vdevid: %d",
-		  req, req->scan_req.scan_req_id, req->scan_req.scan_id,
-		  req->scan_req.vdev_id);
-
 	qdf_mtrace(QDF_MODULE_ID_SCAN, QDF_MODULE_ID_SERIALIZATION,
 		   WLAN_SER_CMD_SCAN, req->vdev->vdev_objmgr.vdev_id,
 		   req->scan_req.scan_id);
 
 	ser_cmd_status = wlan_serialization_request(&cmd);
-	scm_debug("wlan_serialization_request status:%d", ser_cmd_status);
-
 	switch (ser_cmd_status) {
 	case WLAN_SER_CMD_PENDING:
 		/* command moved to pending list.Do nothing */
@@ -1362,13 +1369,8 @@ scm_scan_start_req(struct scheduler_msg *msg)
 	case WLAN_SER_CMD_ACTIVE:
 		/* command moved to active list. Do nothing */
 		break;
-	case WLAN_SER_CMD_DENIED_LIST_FULL:
-	case WLAN_SER_CMD_DENIED_RULES_FAILED:
-	case WLAN_SER_CMD_DENIED_UNSPECIFIED:
-		goto err;
 	default:
-		QDF_ASSERT(0);
-		status = QDF_STATUS_E_INVAL;
+		scm_debug("ser cmd status %d", ser_cmd_status);
 		goto err;
 	}
 
@@ -1677,8 +1679,7 @@ scm_scan_event_handler(struct scheduler_msg *msg)
 
 	if (scan_start_req->scan_req.scan_req_id != event->requester) {
 		scm_err("req ID mismatch, scan_req_id:%d, event_req_id:%d",
-				scan_start_req->scan_req.scan_req_id,
-				event->requester);
+			scan_start_req->scan_req.scan_req_id, event->requester);
 		goto exit;
 	}
 
@@ -1714,6 +1715,7 @@ QDF_STATUS scm_scan_event_flush_callback(struct scheduler_msg *msg)
 {
 	struct wlan_objmgr_vdev *vdev;
 	struct scan_event_info *event_info;
+	struct scan_event *event;
 
 	if (!msg || !msg->bodyptr) {
 		scm_err("msg or msg->bodyptr is NULL");
@@ -1722,6 +1724,11 @@ QDF_STATUS scm_scan_event_flush_callback(struct scheduler_msg *msg)
 
 	event_info = msg->bodyptr;
 	vdev = event_info->vdev;
+	event = &event_info->event;
+
+	scm_debug("Flush scan event vdev %d type %d reason %d freq: %d req %d scanid %d",
+		  event->vdev_id, event->type, event->reason, event->chan_freq,
+		  event->requester, event->scan_id);
 
 	/* free event info memory */
 	qdf_mem_free(event_info);

umac/scan/dispatcher/src/wlan_scan_tgt_api.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -228,9 +228,6 @@ tgt_scan_event_handler(struct wlan_objmgr_psoc *psoc,
 		scm_err("psoc: 0x%pK, event_info: 0x%pK", psoc, event_info);
 		return QDF_STATUS_E_NULL_VALUE;
 	}
-	scm_debug("vdev: %d, type: %d, reason: %d, freq: %d, req: %d, scanid: %d",
-		  vdev_id, event->type, event->reason, event->chan_freq,
-		  event->requester, event->scan_id);
 
 	event_info->vdev =
 		wlan_objmgr_get_vdev_by_id_from_psoc(psoc,

umac/scan/dispatcher/src/wlan_scan_ucfg_api.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -443,15 +443,11 @@ ucfg_scan_start(struct scan_start_request *req)
 	}
 
 	if (!scm_is_scan_allowed(req->vdev)) {
-		scm_err("scan disabled, rejecting the scan req");
+		scm_err_rl("scan disabled, rejecting the scan req");
 		scm_scan_free_scan_request_mem(req);
 		return QDF_STATUS_E_AGAIN;
 	}
 
-	scm_debug("reqid: %d, scanid: %d, vdevid: %d",
-		  req->scan_req.scan_req_id, req->scan_req.scan_id,
-		  req->scan_req.vdev_id);
-
 	/* Try to get vdev reference. Return if reference could
 	 * not be taken. Reference will be released once scan
 	 * request handling completes along with free of @req.
@@ -647,9 +643,6 @@ ucfg_scan_cancel(struct scan_cancel_request *req)
 			qdf_mem_free(req);
 		return QDF_STATUS_E_NULL_VALUE;
 	}
-	scm_debug("reqid: %d, scanid: %d, vdevid: %d, type: %d",
-		  req->cancel_req.requester, req->cancel_req.scan_id,
-		  req->cancel_req.vdev_id, req->cancel_req.req_type);
 
 	status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_SCAN_ID);
 	if (QDF_IS_STATUS_ERROR(status)) {
@@ -1332,28 +1325,23 @@ ucfg_scan_init_chanlist_params(struct scan_start_request *req,
 		reg_chan_list = qdf_mem_malloc_atomic(NUM_CHANNELS *
 				sizeof(struct regulatory_channel));
 		if (!reg_chan_list) {
-			scm_err("Couldn't allocate reg_chan_list memory");
 			status = QDF_STATUS_E_NOMEM;
 			goto end;
 		}
 		scan_freqs =
 			qdf_mem_malloc_atomic(sizeof(uint32_t) * max_chans);
 		if (!scan_freqs) {
-			scm_err("Couldn't allocate scan_freqs memory");
 			status = QDF_STATUS_E_NOMEM;
 			goto end;
 		}
 		status = ucfg_reg_get_current_chan_list(pdev, reg_chan_list);
-		if (QDF_IS_STATUS_ERROR(status)) {
-			scm_err("Couldn't get current chan list");
+		if (QDF_IS_STATUS_ERROR(status))
 			goto end;
-		}
+
 		status = wlan_reg_get_freq_range(pdev, &low_2g,
 				&high_2g, &low_5g, &high_5g);
-		if (QDF_IS_STATUS_ERROR(status)) {
-			scm_err("Couldn't get frequency range");
+		if (QDF_IS_STATUS_ERROR(status))
 			goto end;
-		}
 
 		for (idx = 0, num_chans = 0;
 			(idx < NUM_CHANNELS && num_chans < max_chans); idx++)
@@ -1374,7 +1362,7 @@ ucfg_scan_init_chanlist_params(struct scan_start_request *req,
 		goto end;
 	}
 	if (!chan_list) {
-		scm_err("null chan_list while num_chans: %d", num_chans);
+		scm_info("null chan_list while num_chans: %d", num_chans);
 		status = QDF_STATUS_E_NULL_VALUE;
 		goto end;
 	}
@@ -1403,10 +1391,6 @@ ucfg_scan_init_chanlist_params(struct scan_start_request *req,
 		else
 			req->scan_req.chan_list.chan[idx].phymode =
 				SCAN_PHY_MODE_11A;
-
-		scm_debug("chan[%d]: freq:%d, phymode:%d", idx,
-			req->scan_req.chan_list.chan[idx].freq,
-			req->scan_req.chan_list.chan[idx].phymode);
 	}
 
 end:

wmi/src/wmi_unified_tlv.c

@@ -2966,18 +2966,6 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
 	cmd->n_probes = params->n_probes;
 	cmd->scan_ctrl_flags_ext = params->scan_ctrl_flags_ext;
 
-	WMI_LOGD("%s scan_ctrl_flags_ext = %x, n_probe %d burst_dur %d",
-		 __func__,
-		 cmd->scan_ctrl_flags_ext,
-		 cmd->n_probes,
-		 cmd->burst_duration);
-	WMI_LOGD("active: %d, passive: %d, active_2g %d, active_6g %d, passive_6g: %d",
-		 cmd->dwell_time_active,
-		 cmd->dwell_time_passive,
-		 cmd->dwell_time_active_2g,
-		 cmd->dwell_time_active_6ghz,
-		 cmd->dwell_time_passive_6ghz);
-
 	if (params->scan_random.randomize)
 		wmi_copy_scan_random_mac(params->scan_random.mac_addr,
 					 params->scan_random.mac_mask,