samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Optimize logs in scan path

Browse Source 
Remove redundant logs and optimize the logs in scan path.

Change-Id: I59c59db012f5e9526752d45303e44f2a27f91ec6
CRs-Fixed: 2612629
This commit is contained in:
Abhishek Singh
2020-01-30 14:00:02 +05:30
committed by nshrivas
parent 2339b27eef
commit daaeeb218a
7 changed files with 112 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
os_if/linux/scan/src/wlan_cfg80211_scan.c
View File

@@ -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

35
umac/scan/core/src/wlan_scan_bss_score.c
View File

@@ -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_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_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_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_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("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;

19
umac/scan/core/src/wlan_scan_cache_db.c
View File

@@ -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;

115
umac/scan/core/src/wlan_scan_manager.c
View File

@@ -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);

5
umac/scan/dispatcher/src/wlan_scan_tgt_api.c
View File

@@ -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,

28
umac/scan/dispatcher/src/wlan_scan_ucfg_api.c
View File

@@ -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:

12
wmi/src/wmi_unified_tlv.c
View File

@@ -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,