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

qcacmn: Replace WMI_LOGD() with wmi_debug()

Browse Source 
Replace WMI_LOGD() with wmi_debug().

Change-Id: I9c69cabfd84882fa1daff6e219de5f2643e7d214
CRs-Fixed: 2774563
This commit is contained in:
Srinivas Girigowda
2020-09-14 14:31:07 -07:00
committed by snandini
parent 8c756066a7
commit cdf81dddd3
13 changed files with 307 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
wmi/src/wmi_unified.c
View File

@@ -1681,7 +1681,7 @@ static uint8_t *wmi_id_to_name(uint32_t wmi_command)
static inline void wmi_log_cmd_id(uint32_t cmd_id, uint32_t tag)
{
WMI_LOGD("Send WMI command:%s command_id:%d htc_tag:%d",
wmi_debug("Send WMI command:%s command_id:%d htc_tag:%d",
wmi_id_to_name(cmd_id), cmd_id, tag);
}
@@ -3109,7 +3109,7 @@ static void wmi_htc_log_pkt(void *ctx, HTC_PACKET *htc_pkt)
cmd_id = WMI_GET_FIELD(qdf_nbuf_data(wmi_cmd_buf), WMI_CMD_HDR,
COMMANDID);
WMI_LOGD("WMI command from HTC packet: %s, ID: %d\n",
wmi_debug("WMI command from HTC packet: %s, ID: %d",
wmi_id_to_name(cmd_id), cmd_id);
}
#else

2
wmi/src/wmi_unified_apf_tlv.c
View File

@@ -35,7 +35,7 @@ QDF_STATUS wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
wmi_bpf_set_vdev_active_mode_cmd_fixed_param *cmd;
wmi_buf_t buf;
WMI_LOGD("Sending WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID(%u, %d, %d)",
wmi_debug("Sending WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID(%u, %d, %d)",
vdev_id, ucast_mode, mcast_bcast_mode);
/* allocate command buffer */

6
wmi/src/wmi_unified_concurrency_tlv.c
View File

@@ -173,10 +173,8 @@ static QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(
uint32_t chan1_freq = adapter_1_chan_freq;
uint32_t chan2_freq = adapter_2_chan_freq;
WMI_LOGD("%s: freq1:%dMHz, Quota1:%dms, "
"freq2:%dMHz, Quota2:%dms", __func__,
chan1_freq, quota_chan1, chan2_freq,
quota_chan2);
wmi_debug("freq1:%dMHz, Quota1:%dms, freq2:%dMHz, Quota2:%dms",
chan1_freq, quota_chan1, chan2_freq, quota_chan2);
/*
* Perform sanity check on time quota values provided.

2
wmi/src/wmi_unified_cp_stats_tlv.c
View File

@@ -54,7 +54,7 @@ send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
WMI_LOGD("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
wmi_debug("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
cmd->stats_id, cmd->vdev_id, cmd->pdev_id);
wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);

8
wmi/src/wmi_unified_dbr_tlv.c
View File

@@ -65,11 +65,11 @@ static QDF_STATUS send_dbr_cfg_cmd_tlv(wmi_unified_t wmi_handle,
cmd->num_resp_per_event = cfg->num_resp_per_event;
cmd->event_timeout_ms = cfg->event_timeout_ms;
WMI_LOGD("%s: wmi_dma_ring_cfg_req_fixed_param pdev id %d mod id %d"
wmi_debug("wmi_dma_ring_cfg_req_fixed_param pdev id %d mod id %d"
"base paddr lo %x base paddr hi %x head idx paddr lo %x"
"head idx paddr hi %x tail idx paddr lo %x"
"tail idx addr hi %x num elems %d buf size %d num resp %d"
"event timeout %d", __func__, cmd->pdev_id,
"event timeout %d", cmd->pdev_id,
cmd->mod_id, cmd->base_paddr_lo, cmd->base_paddr_hi,
cmd->head_idx_paddr_lo, cmd->head_idx_paddr_hi,
cmd->tail_idx_paddr_lo, cmd->tail_idx_paddr_hi,
@@ -134,7 +134,7 @@ static QDF_STATUS extract_dbr_buf_release_fixed_tlv(wmi_unified_t wmi_handle,
param->mod_id = ev->mod_id;
param->num_buf_release_entry = ev->num_buf_release_entry;
param->num_meta_data_entry = ev->num_meta_data_entry;
WMI_LOGD("%s:pdev id %d mod id %d num buf release entry %d", __func__,
wmi_debug("pdev id %d mod id %d num buf release entry %d",
param->pdev_id, param->mod_id, param->num_buf_release_entry);
return QDF_STATUS_SUCCESS;
@@ -157,7 +157,7 @@ static QDF_STATUS extract_dbr_buf_release_entry_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: paddr_lo[%d] = %x", __func__, idx, entry->paddr_lo);
wmi_debug("paddr_lo[%d] = %x", idx, entry->paddr_lo);
param->paddr_lo = entry->paddr_lo;
param->paddr_hi = entry->paddr_hi;

38
wmi/src/wmi_unified_extscan_tlv.c
View File

@@ -101,13 +101,13 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
WMITLV_GET_STRUCT_TLVLEN(
wmi_passpoint_config_cmd_fixed_param));
cmd->id = req->networks[i].id;
WMI_LOGD("%s: network id: %u", __func__, cmd->id);
wmi_debug("network id: %u", cmd->id);
qdf_mem_copy(cmd->realm, req->networks[i].realm,
strlen(req->networks[i].realm) + 1);
WMI_LOGD("%s: realm: %s", __func__, cmd->realm);
wmi_debug("realm: %s", cmd->realm);
for (j = 0; j < PASSPOINT_ROAMING_CONSORTIUM_ID_NUM; j++) {
bytes = (uint8_t *) &req->networks[i].roaming_consortium_ids[j];
WMI_LOGD("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
wmi_debug("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
j, bytes[0], bytes[1], bytes[2], bytes[3],
bytes[4], bytes[5], bytes[6], bytes[7]);
@@ -117,7 +117,7 @@ static QDF_STATUS send_set_passpoint_network_list_cmd_tlv
}
qdf_mem_copy(cmd->plmn, req->networks[i].plmn,
PASSPOINT_PLMN_ID_LEN);
WMI_LOGD("%s: plmn: %02x:%02x:%02x", __func__,
wmi_debug("plmn: %02x:%02x:%02x",
cmd->plmn[0], cmd->plmn[1], cmd->plmn[2]);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -191,7 +191,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
cmd->no_of_ssids = QDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
WMI_LOGD("SSID count: %d flags: %d",
wmi_debug("SSID count: %d flags: %d",
cmd->no_of_ssids, cmd->flags);
/* Fill nlo_config only when num_networks are non zero */
@@ -214,7 +214,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
req->networks[i].ssid.ssid,
nlo_list[i].ssid.ssid.ssid_len);
WMI_LOGD("index: %d ssid: %.*s len: %d", i,
wmi_debug("index: %d ssid: %.*s len: %d", i,
nlo_list[i].ssid.ssid.ssid_len,
(char *) nlo_list[i].ssid.ssid.ssid,
nlo_list[i].ssid.ssid.ssid_len);
@@ -223,14 +223,14 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
nlo_list[i].bcast_nw_type.valid = true;
nlo_list[i].bcast_nw_type.bcast_nw_type =
req->networks[i].flags;
WMI_LOGD("PNO flags (%u)",
wmi_debug("PNO flags: %u",
nlo_list[i].bcast_nw_type.bcast_nw_type);
/* Copy auth bit field */
nlo_list[i].auth_type.valid = true;
nlo_list[i].auth_type.auth_type =
req->networks[i].auth_bit_field;
WMI_LOGD("Auth bit field (%u)",
wmi_debug("Auth bit field: %u",
nlo_list[i].auth_type.auth_type);
}
@@ -273,7 +273,7 @@ static QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("set ePNO list request sent successfully for vdev %d",
wmi_debug("set ePNO list request sent successfully for vdev %d",
req->vdev_id);
return ret;
@@ -498,8 +498,7 @@ static QDF_STATUS wmi_get_buf_extscan_change_monitor_cmd
WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
&dest_chglist->bssid);
WMI_LOGD("%s: min_rssi %d", __func__,
dest_chglist->lower_rssi_limit);
wmi_debug("min_rssi: %d", dest_chglist->lower_rssi_limit);
dest_chglist++;
src_ap++;
}
@@ -711,8 +710,8 @@ QDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle,
src_bucket++;
}
WMI_LOGD("%s: Total buckets: %d total #of channels is %d",
__func__, nbuckets, nchannels);
wmi_debug("Total buckets: %d total #of channels is %d",
nbuckets, nchannels);
len += nchannels * sizeof(wmi_extscan_bucket_channel);
/* Allocate the memory */
*buf = wmi_buf_alloc(wmi_handle, len);
@@ -1026,8 +1025,8 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
cmd->lost_ap_scan_count = params->lost_ap_sample_size;
cmd->first_entry_index = index;
WMI_LOGD("%s: vdev id:%d total_entries: %d num_entries: %d lost_ap_sample_size: %d",
__func__, cmd->vdev_id, cmd->total_entries,
wmi_debug("vdev id:%d total_entries: %d num_entries: %d lost_ap_sample_size: %d",
cmd->vdev_id, cmd->total_entries,
cmd->num_entries_in_page,
cmd->lost_ap_scan_count);
@@ -1051,12 +1050,11 @@ static QDF_STATUS send_extscan_start_hotlist_monitor_cmd_tlv
WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
&dest_hotlist->bssid);
WMI_LOGD("%s:channel:%d min_rssi %d",
__func__, dest_hotlist->channel,
wmi_debug("channel:%d min_rssi %d",
dest_hotlist->channel,
dest_hotlist->min_rssi);
WMI_LOGD
("%s: bssid mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
__func__, dest_hotlist->bssid.mac_addr31to0,
wmi_debug("bssid mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
dest_hotlist->bssid.mac_addr31to0,
dest_hotlist->bssid.mac_addr47to32);
dest_hotlist++;
src_ap++;

2
wmi/src/wmi_unified_fwol_tlv.c
View File

@@ -130,7 +130,7 @@ extract_get_elna_bypass_resp_tlv(struct wmi_unified *wmi_handle, void *resp_buf,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("Get elna bypass %d from vdev %d", evt->en_dis, evt->vdev_id);
wmi_debug("Get elna bypass %d from vdev %d", evt->en_dis, evt->vdev_id);
resp->vdev_id = evt->vdev_id;
resp->en_dis = evt->en_dis;

44
wmi/src/wmi_unified_nan_tlv.c
View File

@@ -186,7 +186,7 @@ static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle,
WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param));
cmd->data_len = nan_data_len;
WMI_LOGD("%s: nan data len value is %u", __func__, nan_data_len);
wmi_debug("nan data len value is %u", nan_data_len);
buf_ptr += sizeof(wmi_nan_cmd_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned);
@@ -323,7 +323,7 @@ static QDF_STATUS send_terminate_all_ndps_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t len;
QDF_STATUS status;
WMI_LOGD(FL("Enter"));
wmi_debug("Enter");
len = sizeof(*cmd);
wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -445,16 +445,16 @@ static QDF_STATUS nan_ndp_initiator_req_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(tcp_ip_param->ipv6_intf_addr,
ndp_req->ipv6_addr, WMI_NDP_IPV6_INTF_ADDR_LEN);
}
WMI_LOGD("IPv6 addr present: %d, addr: %pI6",
wmi_debug("IPv6 addr present: %d, addr: %pI6",
ndp_req->is_ipv6_addr_present, ndp_req->ipv6_addr);
WMI_LOGD("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
wmi_debug("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
cmd->vdev_id, cmd->transaction_id, cmd->service_instance_id,
ch_tlv->mhz, cmd->ndp_channel_cfg, cmd->nan_csid,
cmd->peer_discovery_mac_addr.mac_addr31to0,
cmd->peer_discovery_mac_addr.mac_addr47to32);
WMI_LOGD("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
cmd->ndp_cfg_len, cmd->ndp_app_info_len, cmd->nan_pmk_len,
cmd->nan_passphrase_len, cmd->nan_servicename_len);
@@ -482,7 +482,7 @@ static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle,
uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len;
vdev_id = wlan_vdev_get_id(req->vdev);
WMI_LOGD("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d",
wmi_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d",
vdev_id, req->transaction_id,
req->ndp_rsp,
req->ndp_instance_id,
@@ -575,7 +575,7 @@ static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle,
tcp_ip_param->transport_protocol = req->protocol;
}
WMI_LOGD("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d",
req->ndp_config.ndp_cfg_len, req->ndp_info.ndp_app_info_len,
cmd->nan_pmk_len, cmd->nan_passphrase_len,
cmd->nan_servicename_len);
@@ -789,7 +789,7 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr,
rsp->peer_discovery_mac_addr.bytes);
WMI_LOGD("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d service_instance %d, ndp_instance %d, role %d, policy %d csid: %d, scid_len: %d, peer_addr: "QDF_MAC_ADDR_FMT", peer_disc_addr: "QDF_MAC_ADDR_FMT" ndp_cfg - %d bytes ndp_app_info - %d bytes",
wmi_debug("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d service_instance %d, ndp_instance %d, role %d, policy %d csid: %d, scid_len: %d, peer_addr: "QDF_MAC_ADDR_FMT", peer_disc_addr: "QDF_MAC_ADDR_FMT" ndp_cfg - %d bytes ndp_app_info - %d bytes",
WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id,
fixed_params->service_instance_id,
fixed_params->ndp_instance_id, fixed_params->self_ndp_role,
@@ -834,7 +834,7 @@ static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle,
WMI_NDP_IPV6_INTF_ADDR_LEN);
}
}
WMI_LOGD(FL("IPv6 addr present: %d, addr: %pI6"),
wmi_debug("IPv6 addr present: %d, addr: %pI6",
rsp->is_ipv6_addr_present, rsp->ipv6_addr);
return QDF_STATUS_SUCCESS;
@@ -853,7 +853,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) data;
fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param;
WMI_LOGD("WMI_NDP_CONFIRM_EVENTID(0x%X) received. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d num_ch: %d",
wmi_debug("WMI_NDP_CONFIRM_EVENTID(0x%X) received. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d num_ch: %d",
WMI_NDP_CONFIRM_EVENTID, fixed_params->vdev_id,
fixed_params->ndp_instance_id, fixed_params->rsp_code,
fixed_params->reason_code,
@@ -873,7 +873,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("ndp_cfg - %d bytes, ndp_app_info - %d bytes",
wmi_debug("ndp_cfg - %d bytes, ndp_app_info - %d bytes",
fixed_params->ndp_cfg_len, fixed_params->ndp_app_info_len);
if (fixed_params->ndp_cfg_len >
@@ -942,11 +942,11 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
ch_mode);
if (ndi_dbs) {
rsp->ch[i].mac_id = event->ndp_channel_info[i].mac_id;
WMI_LOGD("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
rsp->ch[i].freq, rsp->ch[i].ch_width,
rsp->ch[i].nss, rsp->ch[i].mac_id);
} else {
WMI_LOGD("Freq: %d, ch_mode: %d, nss: %d",
wmi_debug("Freq: %d, ch_mode: %d, nss: %d",
rsp->ch[i].freq, rsp->ch[i].ch_width,
rsp->ch[i].nss);
}
@@ -973,7 +973,7 @@ static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle,
event->ndp_transport_ip_param->transport_protocol;
}
}
WMI_LOGD("IPv6 addr present: %d, addr: %pI6 port: %d present: %d protocol: %d present: %d",
wmi_debug("IPv6 addr present: %d, addr: %pI6 port: %d present: %d protocol: %d present: %d",
rsp->is_ipv6_addr_present, rsp->ipv6_addr, rsp->port,
rsp->is_port_present, rsp->protocol, rsp->is_protocol_present);
@@ -1003,7 +1003,7 @@ static QDF_STATUS extract_ndp_responder_rsp_tlv(wmi_unified_t wmi_handle,
rsp->create_peer = fixed_params->create_peer;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
rsp->peer_mac_addr.bytes);
WMI_LOGD("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT",transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d",
wmi_debug("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT",transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d",
WMI_NDP_RESPONDER_RSP_EVENTID, fixed_params->vdev_id,
QDF_MAC_ADDR_REF(rsp->peer_mac_addr.bytes),
rsp->transaction_id,
@@ -1020,7 +1020,7 @@ static QDF_STATUS extract_ndp_end_rsp_tlv(wmi_unified_t wmi_handle,
event = (WMI_NDP_END_RSP_EVENTID_param_tlvs *) data;
fixed_params = (wmi_ndp_end_rsp_event_fixed_param *)event->fixed_param;
WMI_LOGD("WMI_NDP_END_RSP_EVENTID(0x%X) received. transaction_id: %d, rsp_status: %d, reason_code: %d",
wmi_debug("WMI_NDP_END_RSP_EVENTID(0x%X) received. transaction_id: %d, rsp_status: %d, reason_code: %d",
WMI_NDP_END_RSP_EVENTID, fixed_params->transaction_id,
fixed_params->rsp_status, fixed_params->reason_code);
@@ -1053,7 +1053,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("number of ndp instances = %d",
wmi_debug("number of ndp instances = %d",
event->num_ndp_end_indication_list);
if (event->num_ndp_end_indication_list > ((UINT_MAX - sizeof(**rsp))/
@@ -1073,7 +1073,7 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,
for (i = 0; i < (*rsp)->num_ndp_ids; i++) {
WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr,
peer_addr.bytes);
WMI_LOGD("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ",
wmi_debug("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ",
i, ind[i].type, ind[i].reason_code,
ind[i].ndp_instance_id,
ind[i].num_active_ndps_on_peer);
@@ -1104,7 +1104,7 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
event = (WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *)data;
fixed_params = event->fixed_param;
WMI_LOGD(FL("flags: %d, num_ch: %d, num_ndp_instances: %d"),
wmi_debug("flags: %d, num_ch: %d, num_ndp_instances: %d",
fixed_params->flags, fixed_params->num_channels,
fixed_params->num_ndp_instances);
@@ -1169,18 +1169,18 @@ static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
ch_mode);
if (ndi_dbs) {
ind->ch[i].mac_id = event->ndp_channel_info[i].mac_id;
WMI_LOGD(FL("Freq: %d, ch_mode: %d, nss: %d mac_id: %d"),
wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d",
ind->ch[i].freq, ind->ch[i].ch_width,
ind->ch[i].nss, ind->ch[i].mac_id);
} else {
WMI_LOGD(FL("Freq: %d, ch_mode: %d, nss: %d"),
wmi_debug("Freq: %d, ch_mode: %d, nss: %d",
ind->ch[i].freq, ind->ch[i].ch_width,
ind->ch[i].nss);
}
}
for (i = 0; i < fixed_params->num_ndp_instances; i++)
WMI_LOGD(FL("instance_id[%d]: %d"),
wmi_debug("instance_id[%d]: %d",
i, event->ndp_instance_list[i]);
return QDF_STATUS_SUCCESS;

27
wmi/src/wmi_unified_p2p_tlv.c
View File

@@ -39,7 +39,6 @@ static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
QDF_STATUS status;
uint32_t duration;
WMI_LOGD("%s: Enter", __func__);
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
@@ -84,7 +83,6 @@ static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
}
end:
WMI_LOGD("%s: Exit", __func__);
return status;
}
@@ -102,7 +100,6 @@ static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_t buf;
QDF_STATUS status;
WMI_LOGD("%s: Enter", __func__);
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
status = QDF_STATUS_E_FAILURE;
@@ -130,7 +127,6 @@ static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
}
end:
WMI_LOGD("%s: Exit", __func__);
return status;
}
@@ -188,8 +184,7 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("%s:index %u, opps_ps %u, ct_window %u, num_descriptors = %u",
__func__,
wmi_debug("index %u, opps_ps %u, ct_window %u, num_descriptors = %u",
param->index, param->opps_ps, param->ct_window,
param->num_desc);
for (i = 0; i < param->num_desc; i++) {
@@ -202,8 +197,8 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
wmi_noa_info->noa_descriptors[i].interval;
param->noa_desc[i].start_time =
wmi_noa_info->noa_descriptors[i].start_time;
WMI_LOGD("%s:NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u",
__func__, i, param->noa_desc[i].type_count,
wmi_debug("NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u",
i, param->noa_desc[i].type_count,
param->noa_desc[i].duration,
param->noa_desc[i].interval,
param->noa_desc[i].start_time);
@@ -249,7 +244,7 @@ send_set_mac_addr_rx_filter_cmd_tlv(wmi_unified_t wmi_handle,
cmd->enable = 1;
else
cmd->enable = 0;
WMI_LOGD("set random mac rx vdev %d freq %d set %d "QDF_MAC_ADDR_FMT,
wmi_debug("set random mac rx vdev %d freq %d set %d "QDF_MAC_ADDR_FMT,
param->vdev_id, param->freq, param->set,
QDF_MAC_ADDR_REF(param->mac));
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -312,7 +307,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("%s: vdev_id:%d", __func__, param->vdev_id);
wmi_debug("vdev_id: %d", param->vdev_id);
device_types_len_aligned =
qdf_roundup(param->dev_types_len,
@@ -359,7 +354,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(buf_ptr, param->probe_resp_tmplt,
param->probe_resp_len);
WMI_LOGD("%s: Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d", __func__,
wmi_debug("Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d",
cmd->channel, cmd->period, cmd->interval, cmd->count);
wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_START_CMDID, cmd->vdev_id, 0);
@@ -372,7 +367,7 @@ static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
return status;
}
WMI_LOGD("%s: Successfully sent WMI_P2P_LO_START", __func__);
wmi_debug("Successfully sent WMI_P2P_LO_START");
return QDF_STATUS_SUCCESS;
}
@@ -392,7 +387,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
int32_t len;
QDF_STATUS status;
WMI_LOGD("%s: vdev_id:%d", __func__, vdev_id);
wmi_debug("vdev_id: %d", vdev_id);
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
@@ -407,7 +402,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = vdev_id;
WMI_LOGD("%s: Sending WMI_P2P_LO_STOP command", __func__);
wmi_debug("Sending WMI_P2P_LO_STOP command");
wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle,
@@ -419,7 +414,7 @@ static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
return status;
}
WMI_LOGD("%s: Successfully sent WMI_P2P_LO_STOP", __func__);
wmi_debug("Successfully sent WMI_P2P_LO_STOP");
return QDF_STATUS_SUCCESS;
}
@@ -455,7 +450,7 @@ static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv(
lo_param = param_tlvs->fixed_param;
param->vdev_id = lo_param->vdev_id;
param->reason_code = lo_param->reason;
WMI_LOGD("%s: vdev_id:%d, reason:%d", __func__,
wmi_debug("vdev_id:%d, reason:%d",
param->vdev_id, param->reason_code);
return QDF_STATUS_SUCCESS;

51
wmi/src/wmi_unified_pmo_tlv.c
View File

@@ -141,7 +141,7 @@ static QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(&(cmd->event_bitmaps[0]), bitmap, sizeof(uint32_t) *
WMI_WOW_MAX_EVENT_BM_LEN);
WMI_LOGD("Wakeup pattern 0x%x%x%x%x %s in fw", cmd->event_bitmaps[0],
wmi_debug("Wakeup pattern 0x%x%x%x%x %s in fw", cmd->event_bitmaps[0],
cmd->event_bitmaps[1], cmd->event_bitmaps[2],
cmd->event_bitmaps[3], enable ? "enabled" : "disabled");
@@ -240,15 +240,15 @@ static QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
bitmap_pattern->pattern_id = ptrn_id;
WMI_LOGD("vdev: %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
wmi_debug("vdev: %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
bitmap_pattern->pattern_offset, user);
WMI_LOGD("Pattern : ");
wmi_debug("Pattern: ");
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
&bitmap_pattern->patternbuf[0],
bitmap_pattern->pattern_len);
WMI_LOGD("Mask : ");
wmi_debug("Mask: ");
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
&bitmap_pattern->bitmaskbuf[0],
bitmap_pattern->pattern_len);
@@ -323,7 +323,7 @@ static void fill_arp_offload_params_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(&arp_tuple->target_ipaddr,
offload_req->host_ipv4_addr,
WMI_IPV4_ADDR_LEN);
WMI_LOGD("ARPOffload IP4 address: %pI4",
wmi_debug("ARPOffload IP4 address: %pI4",
offload_req->host_ipv4_addr);
}
*buf_ptr += sizeof(WMI_ARP_OFFLOAD_TUPLE);
@@ -375,7 +375,7 @@ static void fill_ns_offload_params_tlv(wmi_unified_t wmi_handle,
ns_tuple->flags |=
WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
}
WMI_LOGD("Index %d NS solicitedIp %pI6, targetIp %pI6",
wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
i, &ns_req->self_ipv6_addr[i],
&ns_req->target_ipv6_addr[i]);
@@ -444,7 +444,7 @@ static void fill_nsoffload_ext_tlv(wmi_unified_t wmi_handle,
ns_tuple->flags |=
WMI_NSOFF_FLAGS_IS_IPV6_ANYCAST;
}
WMI_LOGD("Index %d NS solicitedIp %pI6, targetIp %pI6",
wmi_debug("Index %d NS solicitedIp %pI6, targetIp %pI6",
i, &ns_req->self_ipv6_addr[i],
&ns_req->target_ipv6_addr[i]);
@@ -541,7 +541,7 @@ static QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = vdev_id;
cmd->num_ns_ext_tuples = num_ns_ext_tuples;
WMI_LOGD("ARP NS Offload vdev_id: %d", cmd->vdev_id);
wmi_debug("ARP NS Offload vdev_id: %d", cmd->vdev_id);
buf_ptr += sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param);
fill_ns_offload_params_tlv(wmi_handle, ns_offload_req, &buf_ptr);
@@ -596,7 +596,7 @@ static QDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = vdev_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(multicast_addr.bytes, &cmd->mcastbdcastaddr);
WMI_LOGD("Action:%d; vdev_id:%d; clearList:%d; MCBC MAC Addr: "QDF_MAC_ADDR_FMT,
wmi_debug("Action:%d; vdev_id:%d; clearList:%d; MCBC MAC Addr: "QDF_MAC_ADDR_FMT,
cmd->action, vdev_id, clearList,
QDF_MAC_ADDR_REF(multicast_addr.bytes));
@@ -719,7 +719,7 @@ static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
else
cmd->hw_filter_bitmap = req->mode_bitmap;
WMI_LOGD("Send %s hw filter mode: 0x%X for vdev id %d",
wmi_debug("Send %s hw filter mode: 0x%X for vdev id %d",
req->enable ? "enable" : "disable", req->mode_bitmap,
req->vdev_id);
@@ -781,8 +781,6 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
QDF_STATUS status = QDF_STATUS_SUCCESS;
WMI_LOGD("%s Enter", __func__);
len = sizeof(*cmd);
if (params->is_fils_connection)
@@ -819,7 +817,8 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
if (params->is_fils_connection)
fill_fils_tlv_params(cmd, vdev_id, params);
WMI_LOGD("VDEVID: %d, GTK_FLAGS: x%x kek len %d", vdev_id, cmd->flags, params->kek_len);
wmi_debug("VDEVID: %d, GTK_FLAGS: x%x kek len %d",
vdev_id, cmd->flags, params->kek_len);
/* send the wmi command */
wmi_mtrace(WMI_GTK_OFFLOAD_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -830,7 +829,6 @@ QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
}
out:
WMI_LOGD("%s Exit", __func__);
return status;
}
@@ -920,8 +918,8 @@ QDF_STATUS send_enable_enhance_multicast_offload_tlv(
cmd->vdev_id = vdev_id;
cmd->enable = ((action == 0) ? ENHANCED_MCAST_FILTER_DISABLED :
ENHANCED_MCAST_FILTER_ENABLED);
WMI_LOGD("%s: config enhance multicast offload action %d for vdev %d",
__func__, action, vdev_id);
wmi_debug("config enhance multicast offload action %d for vdev %d",
action, vdev_id);
wmi_mtrace(WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle, buf,
sizeof(*cmd), WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID);
@@ -1053,7 +1051,7 @@ static QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
*((uint32_t *) buf_ptr) = rate_limit_interval;
WMI_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
wmi_debug("send RA rate limit [%d] to fw vdev = %d",
rate_limit_interval, vdev_id);
wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
@@ -1597,8 +1595,7 @@ QDF_STATUS wmi_unified_cmd_send_chk(struct wmi_unified *wmi_handle,
wmi_buf_t buf,
uint32_t buflen, uint32_t cmd_id)
{
WMI_LOGD("%s: Send WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID over QMI",
__func__);
wmi_debug("Send WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID over QMI");
return wmi_unified_cmd_send_over_qmi(wmi_handle, buf,
buflen, cmd_id);
}
@@ -1727,8 +1724,8 @@ static QDF_STATUS send_wow_timer_pattern_cmd_tlv(wmi_unified_t wmi_handle,
buf_ptr += WMI_TLV_HDR_SIZE;
*((uint32_t *) buf_ptr) = 0;
WMI_LOGD("%s: send wake timer pattern with time[%d] to fw vdev = %d",
__func__, time, vdev_id);
wmi_debug("send wake timer pattern with time[%d] to fw vdev = %d",
time, vdev_id);
wmi_mtrace(WMI_WOW_ADD_WAKE_PATTERN_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1775,8 +1772,8 @@ static QDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
cmd->type = params->type;
cmd->wakeup_pin_num = params->wakeup_pin_num;
WMI_LOGD("%s: vdev_id %d type %d Wakeup_pin_num %x",
__func__, cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
wmi_debug("vdev_id %d type %d Wakeup_pin_num %x",
cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
wmi_mtrace(WMI_EXTWOW_ENABLE_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1844,14 +1841,14 @@ static QDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_hand
cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
WMI_LOGD("%s: vdev_id %d gateway_mac "QDF_MAC_ADDR_FMT" "
wmi_debug("vdev_id %d gateway_mac "QDF_MAC_ADDR_FMT" "
"rc4_key %.16s rc4_key_len %u "
"ip_id %x ip_device_ip %x ip_server_ip %x "
"tcp_src_port %u tcp_dst_port %u tcp_seq %u "
"tcp_ack_seq %u keepalive_init %u keepalive_min %u "
"keepalive_max %u keepalive_inc %u "
"tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
__func__, cmd->vdev_id,
cmd->vdev_id,
QDF_MAC_ADDR_REF(appType2Params->gateway_mac.bytes),
cmd->rc4_key, cmd->rc4_key_len,
cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
@@ -1910,10 +1907,10 @@ static QDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(cmd->passwd, app_type1_params->password, 16);
cmd->passwd_len = app_type1_params->pass_length;
WMI_LOGD("%s: vdev_id %d wakee_mac_addr "QDF_MAC_ADDR_FMT" "
wmi_debug("vdev_id %d wakee_mac_addr "QDF_MAC_ADDR_FMT" "
"identification_id %.8s id_length %u "
"password %.16s pass_length %u",
__func__, cmd->vdev_id,
cmd->vdev_id,
QDF_MAC_ADDR_REF(app_type1_params->wakee_mac_addr.bytes),
cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);

102
wmi/src/wmi_unified_sta_tlv.c
View File

@@ -61,7 +61,7 @@ static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
cmd->sa_query_max_retry_count = max_retries;
cmd->sa_query_retry_interval = retry_interval;
WMI_LOGD(FL("STA sa query: vdev_id:%d interval:%u retry count:%d"),
wmi_debug("STA sa query: vdev_id:%d interval:%u retry count:%d",
vdev_id, retry_interval, max_retries);
wmi_mtrace(WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID, cmd->vdev_id, 0);
@@ -72,7 +72,7 @@ static QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD(FL("Exit :"));
wmi_debug("Exit");
return 0;
}
@@ -96,7 +96,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
int len;
QDF_STATUS ret;
WMI_LOGD("%s: Enter", __func__);
wmi_debug("Enter");
len = sizeof(*cmd) + sizeof(*arp_rsp);
buf = wmi_buf_alloc(wmi_handle, len);
@@ -113,7 +113,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
cmd->interval = params->timeperiod;
cmd->enable = (params->timeperiod) ? 1 : 0;
cmd->vdev_id = params->vdev_id;
WMI_LOGD("Keep Alive: vdev_id:%d interval:%u method:%d",
wmi_debug("Keep Alive: vdev_id:%d interval:%u method:%d",
params->vdev_id, params->timeperiod, params->method);
arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd));
WMITLV_SET_HDR(&arp_rsp->tlv_header,
@@ -142,7 +142,7 @@ send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_free(buf);
}
WMI_LOGD("%s: Exit", __func__);
wmi_debug("Exit");
return ret;
}
@@ -184,7 +184,7 @@ static QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32
cmd->gtxTPCMin = gtx_info->gtx_tpcmin;
cmd->gtxBWMask = gtx_info->gtx_bwmask;
WMI_LOGD("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
wmi_debug("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \
gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1],
cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin,
@@ -418,7 +418,7 @@ static QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
break;
default:
WMI_LOGD("%s: invalid profiling command", __func__);
wmi_debug("Invalid profiling command: %u", cmd);
break;
}
@@ -438,7 +438,7 @@ static QDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
wmi_debug("vdev_id: %d", vdev_id);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
@@ -518,7 +518,7 @@ static uint8_t tdls_get_wmi_offchannel_mode(uint8_t tdls_sw_mode)
break;
default:
WMI_LOGD(FL("unknown tdls_sw_mode %d"), tdls_sw_mode);
wmi_debug("unknown tdls_sw_mode: %d", tdls_sw_mode);
off_chan_mode = WMI_TDLS_DISABLE_OFFCHANNEL;
}
return off_chan_mode;
@@ -551,7 +551,7 @@ static uint8_t tdls_get_wmi_offchannel_bw(uint16_t tdls_off_ch_bw_offset)
off_chan_bw = WMI_TDLS_OFFCHAN_160MHZ;
break;
default:
WMI_LOGD(FL("unknown tdls offchannel bw offset %d"),
wmi_debug("unknown tdls offchannel bw offset: %d",
tdls_off_ch_bw_offset);
off_chan_bw = WMI_TDLS_OFFCHAN_20MHZ;
}
@@ -598,14 +598,13 @@ static QDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle,
chan_switch_params->tdls_off_ch_bw_offset);
cmd->offchan_oper_class = chan_switch_params->oper_class;
WMI_LOGD(FL("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x"),
wmi_debug("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
cmd->peer_macaddr.mac_addr31to0,
cmd->peer_macaddr.mac_addr47to32);
WMI_LOGD(FL(
"vdev_id: %d, off channel mode: %d, off channel Num: %d, "
wmi_debug("vdev_id: %d, off channel mode: %d, off channel Num: %d, "
"off channel frequency: %u off channel offset: 0x%x, "
" is_peer_responder: %d, operating class: %d"),
"is_peer_responder: %d, operating class: %d",
cmd->vdev_id,
cmd->offchan_mode,
cmd->offchan_num,
@@ -674,7 +673,7 @@ send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
cmd->tdls_discovery_wake_timeout =
tdls_param->tdls_discovery_wake_timeout;
WMI_LOGD("%s: vdev %d tdls_state: %d, state: %d, "
wmi_debug("vdev %d tdls_state: %d, state: %d, "
"notification_interval_ms: %d, "
"tx_discovery_threshold: %d, "
"tx_teardown_threshold: %d, "
@@ -689,7 +688,7 @@ send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
"teardown_notification_ms: %d, "
"tdls_peer_kickout_threshold: %d, "
"tdls_discovery_wake_timeout: %d",
__func__,tdls_param->vdev_id, tdls_state, cmd->state,
tdls_param->vdev_id, tdls_state, cmd->state,
cmd->notification_interval_ms,
cmd->tx_discovery_threshold,
cmd->tx_teardown_threshold,
@@ -761,10 +760,10 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
cmd->peer_state = peer_state->peer_state;
WMI_LOGD("%s: vdev_id: %d, peermac: "QDF_MAC_ADDR_FMT", "
wmi_debug("vdev_id: %d, peermac: "QDF_MAC_ADDR_FMT", "
"peer_macaddr.mac_addr31to0: 0x%x, "
"peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
__func__, cmd->vdev_id,
cmd->vdev_id,
QDF_MAC_ADDR_REF(peer_state->peer_macaddr),
cmd->peer_macaddr.mac_addr31to0,
cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
@@ -799,7 +798,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
peer_cap->peer_chan_len = in_peer_cap->peer_chanlen;
peer_cap->peer_operclass_len = in_peer_cap->peer_oper_classlen;
WMI_LOGD("peer_operclass_len: %d", peer_cap->peer_operclass_len);
wmi_debug("peer_operclass_len: %d", peer_cap->peer_operclass_len);
for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
peer_cap->peer_operclass[i] = in_peer_cap->peer_oper_class[i];
}
@@ -812,12 +811,11 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
peer_cap->pref_offchan_num = in_peer_cap->pref_off_channum;
peer_cap->pref_offchan_bw = in_peer_cap->pref_off_chan_bandwidth;
WMI_LOGD
("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
wmi_debug("peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
"peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: "
"%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:"
" %d, pref_offchan_bw: %d, pref_offchan_freq: %u",
__func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
peer_cap->peer_qos, peer_cap->buff_sta_support,
peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
@@ -842,7 +840,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
chan_info->band_center_freq1 = chan_info->mhz;
chan_info->band_center_freq2 = 0;
WMI_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
wmi_debug("chan[%d] = %u", i, chan_info->mhz);
if (in_chan_info->dfs_set) {
WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
@@ -858,7 +856,7 @@ send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
WMI_SET_CHANNEL_MAX_TX_POWER(chan_info, in_chan_info->pwr);
WMI_SET_CHANNEL_REG_POWER(chan_info, in_chan_info->pwr);
WMI_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
wmi_debug("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
in_chan_info->pwr);
chan_info++;
@@ -969,8 +967,8 @@ static QDF_STATUS extract_vdev_tdls_ev_param_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
};
WMI_LOGD("%s: tdls event, peer: "QDF_MAC_ADDR_FMT", type: 0x%x, reason: %d, vdev: %d",
__func__, QDF_MAC_ADDR_REF(param->peermac.bytes),
wmi_debug("tdls event, peer: "QDF_MAC_ADDR_FMT", type: 0x%x, reason: %d, vdev: %d",
QDF_MAC_ADDR_REF(param->peermac.bytes),
param->message_type,
param->peer_reason, param->vdev_id);
@@ -1034,7 +1032,7 @@ static QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
cmd->ie_len = ie_info->length;
cmd->band = ie_info->band;
WMI_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
wmi_debug("IE:%d of size:%d sent for vdev:%d", ie_info->ie_id,
ie_info->length, ie_info->vdev_id);
buf_ptr += sizeof(*cmd);
@@ -1172,7 +1170,7 @@ send_reject_ap_list_cmd_tlv(wmi_unified_t wmi_handle,
if (!buf)
return QDF_STATUS_E_NOMEM;
WMI_LOGD("num of reject BSSIDs %d", num_of_reject_bssid);
wmi_debug("num of reject BSSIDs %d", num_of_reject_bssid);
buf_ptr = (uint8_t *)wmi_buf_data(buf);
chan_list_fp = (wmi_pdev_dsm_filter_fixed_param *)buf_ptr;
@@ -1266,7 +1264,7 @@ static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle,
cmd->commit_limits = sar_limit_params->commit_limits;
cmd->num_limit_rows = sar_limit_params->num_limit_rows;
WMI_LOGD("no of sar rows = %d, len = %d",
wmi_debug("no of sar rows = %d, len = %d",
sar_limit_params->num_limit_rows, len);
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
@@ -1289,7 +1287,7 @@ static QDF_STATUS send_sar_limit_cmd_tlv(wmi_unified_t wmi_handle,
wmi_sar_rows_list->limit_value = sar_rows_list->limit_value;
wmi_sar_rows_list->validity_bitmap =
sar_rows_list->validity_bitmap;
WMI_LOGD("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d",
wmi_debug("row %d, band_id = %d, chain_id = %d, mod_id = %d, limit_value = %d, validity_bitmap = %d",
i, wmi_sar_rows_list->band_id,
wmi_sar_rows_list->chain_id,
wmi_sar_rows_list->mod_id,
@@ -1319,7 +1317,7 @@ static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
uint32_t len;
QDF_STATUS status;
WMI_LOGD(FL("Enter"));
wmi_debug("Enter");
len = sizeof(*cmd);
wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -1344,7 +1342,7 @@ static QDF_STATUS get_sar_limit_cmd_tlv(wmi_unified_t wmi_handle)
wmi_buf_free(wmi_buf);
}
WMI_LOGD(FL("Exit"));
wmi_debug("Exit");
return status;
}
@@ -1451,7 +1449,7 @@ static QDF_STATUS extract_sar_limit_event_tlv(wmi_unified_t wmi_handle,
row_in = param_buf->sar_get_limits;
if (!row_in) {
WMI_LOGD("sar_get_limits is NULL");
wmi_debug("sar_get_limits is NULL");
} else {
row_out = &event->sar_limit_row[0];
for (row = 0; row < event->num_limit_rows; row++) {
@@ -1575,8 +1573,7 @@ static QDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
cmd->vdev_id = vdev_id;
cmd->ac = ac;
WMI_LOGD("Delts vdev:%d, ac:%d, %s:%d",
cmd->vdev_id, cmd->ac, __func__, __LINE__);
wmi_debug("Delts vdev:%d, ac:%d", cmd->vdev_id, cmd->ac);
wmi_mtrace(WMI_VDEV_WMM_DELTS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_WMM_DELTS_CMDID)) {
@@ -1635,8 +1632,8 @@ static QDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle,
cmd->medium_time_us =
aggr_qos_rsp_msg->tspec[i].mediumTime * 32;
cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
WMI_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
__func__, __LINE__, cmd->vdev_id, cmd->ac,
wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
cmd->vdev_id, cmd->ac,
cmd->medium_time_us, cmd->downgrade_type);
wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1682,9 +1679,9 @@ static QDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle,
cmd->ac = msg->tspec.tsinfo.traffic.userPrio;
cmd->medium_time_us = msg->tspec.mediumTime * 32;
cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
WMI_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
wmi_debug("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d",
cmd->vdev_id, cmd->ac, cmd->medium_time_us,
cmd->downgrade_type, __func__, __LINE__);
cmd->downgrade_type);
wmi_mtrace(WMI_VDEV_WMM_ADDTS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_WMM_ADDTS_CMDID)) {
@@ -1747,10 +1744,10 @@ static QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, pattern->ucPattern, ptrn_len);
for (j = 0; j < pattern->ucPtrnSize; j++)
WMI_LOGD("%s: Add Ptrn: %02x", __func__, buf_ptr[j] & 0xff);
wmi_debug("Add Ptrn: %02x", buf_ptr[j] & 0xff);
WMI_LOGD("%s: Add ptrn id: %d vdev_id: %d",
__func__, cmd->pattern_id, cmd->vdev_id);
wmi_debug("Add ptrn id: %d vdev_id: %d",
cmd->pattern_id, cmd->vdev_id);
wmi_mtrace(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
@@ -1795,8 +1792,8 @@ static QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(
/* Pass the pattern id to delete for the corresponding vdev id */
cmd->vdev_id = vdev_id;
cmd->pattern_id = pattern_id;
WMI_LOGD("%s: Del ptrn id: %d vdev_id: %d",
__func__, cmd->pattern_id, cmd->vdev_id);
wmi_debug("Del ptrn id: %d vdev_id: %d",
cmd->pattern_id, cmd->vdev_id);
wmi_mtrace(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
@@ -1824,8 +1821,8 @@ static QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd;
int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param);
WMI_LOGD("%s: Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
__func__, timer_val);
wmi_debug("Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
timer_val);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
@@ -2035,8 +2032,8 @@ QDF_STATUS send_pdev_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle,
WMI_HOST_PDEV_ID_SOC);
cmd->concurrent_scan_config_bits = msg->scan_config;
cmd->fw_mode_config_bits = msg->fw_mode_config;
WMI_LOGD("%s: scan_config:%x fw_mode_config:%x",
__func__, msg->scan_config, msg->fw_mode_config);
wmi_debug("scan_config:%x fw_mode_config:%x",
msg->scan_config, msg->fw_mode_config);
wmi_mtrace(WMI_PDEV_SET_MAC_CONFIG_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2226,7 +2223,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
wmi_set_arp->pkt_type = req_buf->pkt_type;
wmi_set_arp->ipv4 = req_buf->ip_addr;
WMI_LOGD("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u",
wmi_debug("NUD Stats: vdev_id %u set_clr %u pkt_type:%u ipv4 %u",
wmi_set_arp->vdev_id, wmi_set_arp->set_clr,
wmi_set_arp->pkt_type, wmi_set_arp->ipv4);
@@ -2254,7 +2251,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
wmi_set_connect_stats->tcp_dst_port = req_buf->tcp_dst_port;
wmi_set_connect_stats->icmp_ipv4 = req_buf->icmp_ipv4;
WMI_LOGD("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u",
wmi_debug("Connectivity Stats: pkt_type_bitmap %u tcp_src_port:%u tcp_dst_port %u icmp_ipv4 %u",
wmi_set_connect_stats->pkt_type_bitmap,
wmi_set_connect_stats->tcp_src_port,
wmi_set_connect_stats->tcp_dst_port,
@@ -2270,7 +2267,7 @@ static QDF_STATUS send_set_arp_stats_req_cmd_tlv(wmi_unified_t wmi_handle,
goto error;
}
WMI_LOGD(FL("set arp stats flag=%d, vdev=%d"),
wmi_debug("set arp stats flag=%d, vdev=%d",
req_buf->flag, req_buf->vdev_id);
return QDF_STATUS_SUCCESS;
error:
@@ -2386,8 +2383,7 @@ static QDF_STATUS send_peer_unmap_conf_cmd_tlv(wmi_unified_t wmi,
for (i = 0; i < peer_id_cnt; i++)
peer_ids[i] = peer_id_list[i];
WMI_LOGD("%s: vdev_id %d peer_id_cnt %d", __func__,
vdev_id, peer_id_cnt);
wmi_debug("vdev_id %d peer_id_cnt %d", vdev_id, peer_id_cnt);
wmi_mtrace(WMI_PEER_UNMAP_RESPONSE_CMDID, vdev_id, 0);
status = wmi_unified_cmd_send(wmi, buf, len,
WMI_PEER_UNMAP_RESPONSE_CMDID);

269
wmi/src/wmi_unified_tlv.c
View File

@@ -762,15 +762,15 @@ static QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
cmd->num_cfg_txrx_streams = num_bands;
copy_vdev_create_pdev_id(wmi_handle, cmd, param);
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
WMI_LOGD("%s: ID = %d[pdev:%d] VAP Addr = "QDF_MAC_ADDR_FMT,
__func__, param->vdev_id, cmd->pdev_id,
wmi_debug("ID = %d[pdev:%d] VAP Addr = "QDF_MAC_ADDR_FMT,
param->vdev_id, cmd->pdev_id,
QDF_MAC_ADDR_REF(macaddr));
buf_ptr = (uint8_t *)cmd + sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
(num_bands * sizeof(wmi_vdev_txrx_streams)));
buf_ptr += WMI_TLV_HDR_SIZE;
WMI_LOGD("%s: type %d, subtype %d, nss_2g %d, nss_5g %d", __func__,
wmi_debug("type %d, subtype %d, nss_2g %d, nss_5g %d",
param->type, param->subtype,
param->nss_2g, param->nss_5g);
txrx_streams = (wmi_vdev_txrx_streams *)buf_ptr;
@@ -830,7 +830,7 @@ static QDF_STATUS send_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle,
wmi_err("Failed to send WMI_VDEV_DELETE_CMDID");
wmi_buf_free(buf);
}
WMI_LOGD("%s:vdev id = %d", __func__, if_id);
wmi_debug("vdev id = %d", if_id);
return ret;
}
@@ -886,7 +886,7 @@ send_vdev_nss_chain_params_cmd_tlv(wmi_unified_t wmi_handle,
wmi_err("Failed to send WMI_VDEV_CHAINMASK_CONFIG_CMDID");
wmi_buf_free(buf);
}
WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
wmi_debug("vdev_id %d", vdev_id);
return ret;
}
@@ -920,7 +920,7 @@ static QDF_STATUS send_vdev_stop_cmd_tlv(wmi_unified_t wmi,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s:vdev id = %d", __func__, vdev_id);
wmi_debug("vdev id = %d", vdev_id);
return 0;
}
@@ -953,7 +953,7 @@ static QDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
wmi_debug("vdev_id %d", vdev_id);
return 0;
}
@@ -1131,8 +1131,8 @@ static QDF_STATUS send_peer_flush_tids_cmd_tlv(wmi_unified_t wmi,
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->peer_tid_bitmap = param->peer_tid_bitmap;
cmd->vdev_id = param->vdev_id;
WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d and peer bitmap %d",
__func__, QDF_MAC_ADDR_REF(peer_addr), param->vdev_id,
wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d and peer bitmap %d",
QDF_MAC_ADDR_REF(peer_addr), param->vdev_id,
param->peer_tid_bitmap);
wmi_mtrace(WMI_PEER_FLUSH_TIDS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) {
@@ -1171,8 +1171,8 @@ static QDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi,
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
cmd->vdev_id = vdev_id;
WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
__func__, QDF_MAC_ADDR_REF(peer_addr), vdev_id);
wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
QDF_MAC_ADDR_REF(peer_addr), vdev_id);
wmi_mtrace(WMI_PEER_DELETE_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) {
wmi_err("Failed to send peer delete command");
@@ -1210,7 +1210,7 @@ static QDF_STATUS send_peer_delete_all_cmd_tlv(
(wmi_vdev_delete_all_peer_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
WMI_LOGD("%s: vdev_id %d", __func__, cmd->vdev_id);
wmi_debug("vdev_id %d", cmd->vdev_id);
wmi_mtrace(WMI_VDEV_DELETE_ALL_PEER_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi, buf, len,
WMI_VDEV_DELETE_ALL_PEER_CMDID)) {
@@ -1282,8 +1282,8 @@ static QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
cmd->param_id = param_id;
cmd->param_value = param->param_value;
WMI_LOGD("%s: vdev_id %d peer_mac: "QDF_MAC_ADDR_FMT" param_id: %u param_value: %x",
__func__, cmd->vdev_id,
wmi_debug("vdev_id %d peer_mac: "QDF_MAC_ADDR_FMT" param_id: %u param_value: %x",
cmd->vdev_id,
QDF_MAC_ADDR_REF(peer_addr), param->param_id,
cmd->param_value);
@@ -1316,9 +1316,8 @@ static QDF_STATUS send_vdev_up_cmd_tlv(wmi_unified_t wmi,
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMI_LOGD("%s: VDEV_UP", __func__);
WMI_LOGD("%s: vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT,
__func__,
wmi_debug("VDEV_UP");
wmi_debug("vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT,
params->vdev_id, params->assoc_id, QDF_MAC_ADDR_REF(bssid));
buf = wmi_buf_alloc(wmi, len);
if (!buf)
@@ -1379,8 +1378,8 @@ static QDF_STATUS send_peer_create_cmd_tlv(wmi_unified_t wmi,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
__func__, QDF_MAC_ADDR_REF(param->peer_addr),
wmi_debug("peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d",
QDF_MAC_ADDR_REF(param->peer_addr),
param->vdev_id);
return 0;
@@ -1428,8 +1427,7 @@ QDF_STATUS send_peer_rx_reorder_queue_setup_cmd_tlv(wmi_unified_t wmi,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid %d",
__func__,
wmi_debug("peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid %d",
QDF_MAC_ADDR_REF(param->peer_macaddr),
param->vdev_id, param->tid);
@@ -1473,8 +1471,7 @@ QDF_STATUS send_peer_rx_reorder_queue_remove_cmd_tlv(wmi_unified_t wmi,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid_map %d",
__func__,
wmi_debug("peer_macaddr "QDF_MAC_ADDR_FMT" vdev_id %d, tid_map %d",
QDF_MAC_ADDR_REF(param->peer_macaddr),
param->vdev_id, param->peer_tid_bitmap);
@@ -1497,7 +1494,7 @@ static QDF_STATUS send_green_ap_ps_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMI_LOGD("Set Green AP PS val %d", value);
wmi_debug("Set Green AP PS val %d", value);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
@@ -1577,13 +1574,13 @@ send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle,
segHdrInfo.segmentInfo = segInfo;
segHdrInfo.pad = 0;
WMI_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
wmi_debug("segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
" segHdrInfo.segmentInfo = %d",
__func__, segHdrInfo.len, segHdrInfo.msgref,
segHdrInfo.len, segHdrInfo.msgref,
segHdrInfo.segmentInfo);
WMI_LOGD("%s:total_bytes %d segNumber %d totalSegments %d"
"chunk len %d", __func__, total_bytes, segNumber,
wmi_debug("total_bytes %d segNumber %d totalSegments %d"
" chunk len %d", total_bytes, segNumber,
numSegments, chunk_len);
segNumber++;
@@ -1673,7 +1670,7 @@ send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
mac_id);
cmd->param_id = pdev_param;
cmd->param_value = param->param_value;
WMI_LOGD("Setting pdev param = %x, value = %u", param->param_id,
wmi_debug("Setting pdev param = %x, value = %u", param->param_id,
param->param_value);
wmi_mtrace(WMI_PDEV_SET_PARAM_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -1721,7 +1718,7 @@ static QDF_STATUS send_pdev_set_hw_mode_cmd_tlv(wmi_unified_t wmi_handle,
wmi_handle,
WMI_HOST_PDEV_ID_SOC);
cmd->hw_mode_index = hw_mode_index;
WMI_LOGD("%s: HW mode index:%d", __func__, cmd->hw_mode_index);
wmi_debug("HW mode index:%d", cmd->hw_mode_index);
wmi_mtrace(WMI_PDEV_SET_HW_MODE_CMDID, NO_SESSION, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2101,7 +2098,7 @@ static QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = param->vdev_id;
cmd->param_id = vdev_param;
cmd->param_value = param->param_value;
WMI_LOGD("Setting vdev %d param = %x, value = %u",
wmi_debug("Setting vdev %d param = %x, value = %u",
cmd->vdev_id, cmd->param_id, cmd->param_value);
wmi_mtrace(WMI_VDEV_SET_PARAM_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -2293,7 +2290,7 @@ static void send_time_stamp_sync_cmd_tlv(wmi_unified_t wmi_handle)
* wont exceed 27 bit
*/
time_stamp->time_stamp_high = 0;
WMI_LOGD(FL("WMA --> DBGLOG_TIME_STAMP_SYNC_CMDID mode %d time_stamp low %d high %d"),
wmi_debug("WMA --> DBGLOG_TIME_STAMP_SYNC_CMDID mode %d time_stamp low %d high %d",
time_stamp->mode, time_stamp->time_stamp_low,
time_stamp->time_stamp_high);
@@ -2653,7 +2650,7 @@ static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
he_mcs->rx_mcs_set = param->peer_he_rx_mcs_set[i];
he_mcs->tx_mcs_set = param->peer_he_tx_mcs_set[i];
WMI_LOGD("%s:HE idx %d RxMCSmap %x TxMCSmap %x ", __func__,
wmi_debug("HE idx %d RxMCSmap %x TxMCSmap %x ",
i, he_mcs->rx_mcs_set, he_mcs->tx_mcs_set);
buf_ptr += sizeof(wmi_he_rate_set);
}
@@ -2663,22 +2660,22 @@ static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
== WMI_HOST_HE_INVALID_MCSNSSMAP ||
param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]
== WMI_HOST_HE_INVALID_MCSNSSMAP)) {
WMI_LOGD("param->peer_he_tx_mcs_set[160MHz]=%x",
wmi_debug("param->peer_he_tx_mcs_set[160MHz]=%x",
param->peer_he_tx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]);
WMI_LOGD("param->peer_he_rx_mcs_set[160MHz]=%x",
wmi_debug("param->peer_he_rx_mcs_set[160MHz]=%x",
param->peer_he_rx_mcs_set[WMI_HOST_HE_TXRX_MCS_NSS_IDX_160]);
WMI_LOGD("peer_mac="QDF_MAC_ADDR_FMT,
wmi_debug("peer_mac="QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(param->peer_mac));
}
WMI_LOGD("%s: vdev_id %d associd %d peer_flags %x rate_caps %x "
wmi_debug("vdev_id %d associd %d peer_flags %x rate_caps %x "
"peer_caps %x listen_intval %d ht_caps %x max_mpdu %d "
"nss %d phymode %d peer_mpdu_density %d "
"cmd->peer_vht_caps %x "
"HE cap_info %x ops %x "
"HE cap_info_ext %x "
"HE phy %x %x %x "
"peer_bw_rxnss_override %x", __func__,
"peer_bw_rxnss_override %x",
cmd->vdev_id, cmd->peer_associd, cmd->peer_flags,
cmd->peer_rate_caps, cmd->peer_caps,
cmd->peer_listen_intval, cmd->peer_ht_caps,
@@ -3223,7 +3220,7 @@ static QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
WMITLV_GET_STRUCT_TLVLEN
(wmi_scan_chan_list_cmd_fixed_param));
WMI_LOGD("no of channels = %d, len = %d", num_send_chans, len);
wmi_debug("no of channels = %d, len = %d", num_send_chans, len);
if (num_sends)
cmd->flags |= APPEND_TO_EXISTING_CHAN_LIST;
@@ -3653,8 +3650,7 @@ static QDF_STATUS send_modem_power_state_cmd_tlv(wmi_unified_t wmi_handle,
WMITLV_GET_STRUCT_TLVLEN
(wmi_modem_power_state_cmd_param));
cmd->modem_power_state = param_value;
WMI_LOGD("%s: Setting cmd->modem_power_state = %u", __func__,
param_value);
wmi_debug("Setting cmd->modem_power_state = %u", param_value);
wmi_mtrace(WMI_MODEM_POWER_STATE_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_MODEM_POWER_STATE_CMDID);
@@ -3681,7 +3677,7 @@ static QDF_STATUS send_set_sta_ps_mode_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMI_LOGD("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
wmi_debug("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
@@ -3735,7 +3731,7 @@ static QDF_STATUS send_idle_roam_monitor_cmd_tlv(wmi_unified_t wmi_handle,
cmd->idle_trigger_monitor = (val ? WMI_IDLE_TRIGGER_MONITOR_ON :
WMI_IDLE_TRIGGER_MONITOR_OFF);
WMI_LOGD("val:%d", cmd->idle_trigger_monitor);
wmi_debug("val: %d", cmd->idle_trigger_monitor);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_IDLE_TRIGGER_MONITOR_CMDID)) {
@@ -3796,7 +3792,7 @@ static QDF_STATUS send_set_mimops_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("Setting vdev %d value = %u", vdev_id, value);
wmi_debug("Setting vdev %d value = %u", vdev_id, value);
wmi_mtrace(WMI_STA_SMPS_FORCE_MODE_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -3840,7 +3836,7 @@ static QDF_STATUS send_set_smps_params_cmd_tlv(wmi_unified_t wmi_handle, uint8_t
cmd->param =
(value >> WMI_SMPS_PARAM_VALUE_S) & WMI_SMPS_MASK_UPPER_3BITS;
WMI_LOGD("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
wmi_debug("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
cmd->param);
wmi_mtrace(WMI_STA_SMPS_PARAM_CMDID, cmd->vdev_id, 0);
@@ -4122,7 +4118,7 @@ static QDF_STATUS send_lro_config_cmd_tlv(wmi_unified_t wmi_handle,
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
pdev_id);
WMI_LOGD("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x, pdev_id: %d",
wmi_debug("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x, pdev_id: %d",
cmd->lro_enable, cmd->tcp_flag_u32, cmd->pdev_id);
wmi_mtrace(WMI_LRO_CONFIG_CMDID, NO_SESSION, 0);
@@ -4284,7 +4280,7 @@ static QDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t *buf_ptr;
QDF_STATUS ret;
WMI_LOGD(FL("Send probe response template for vdev %d"), vdev_id);
wmi_debug("Send probe response template for vdev %d", vdev_id);
tmpl_len = probe_rsp_info->prb_rsp_template_len;
tmpl_len_aligned = roundup(tmpl_len, sizeof(uint32_t));
@@ -4502,7 +4498,7 @@ static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, p2p_ie, ie_len);
WMI_LOGD("%s: Sending WMI_P2P_GO_SET_BEACON_IE", __func__);
wmi_debug("Sending WMI_P2P_GO_SET_BEACON_IE");
wmi_mtrace(WMI_P2P_GO_SET_BEACON_IE, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle,
@@ -4513,7 +4509,7 @@ static QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_free(wmi_buf);
}
WMI_LOGD("%s: Successfully sent WMI_P2P_GO_SET_BEACON_IE", __func__);
wmi_debug("Successfully sent WMI_P2P_GO_SET_BEACON_IE");
return ret;
}
@@ -4554,8 +4550,7 @@ static QDF_STATUS send_scan_probe_setoui_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_zero(oui_buf, sizeof(cmd->prob_req_oui));
*oui_buf = psetoui->oui[0] << 16 | psetoui->oui[1] << 8
| psetoui->oui[2];
WMI_LOGD("%s: wmi:oui received from hdd %08x", __func__,
cmd->prob_req_oui);
wmi_debug("wmi:oui received from hdd %08x", cmd->prob_req_oui);
cmd->vdev_id = psetoui->vdev_id;
cmd->flags = WMI_SCAN_PROBE_OUI_SPOOFED_MAC_IN_PROBE_REQ;
@@ -4611,7 +4606,7 @@ static QDF_STATUS send_ipa_offload_control_cmd_tlv(wmi_unified_t wmi_handle,
if (!wmi_buf)
return QDF_STATUS_E_NOMEM;
WMI_LOGD("%s: offload_type=%d, enable=%d", __func__,
wmi_debug("offload_type=%d, enable=%d",
ipa_offload->offload_type, ipa_offload->enable);
buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf);
@@ -4725,7 +4720,7 @@ static void wmi_set_pno_channel_prediction(uint8_t *buf_ptr,
pno->channel_prediction_full_scan;
#endif
buf_ptr += sizeof(nlo_channel_prediction_cfg);
WMI_LOGD("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d",
wmi_debug("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d",
channel_prediction_cfg->enable,
channel_prediction_cfg->top_k_num,
channel_prediction_cfg->stationary_threshold,
@@ -4829,7 +4824,7 @@ static QDF_STATUS send_nlo_mawc_cmd_tlv(wmi_unified_t wmi_handle,
wmi_nlo_mawc_params->exp_backoff_ratio = params->exp_backoff_ratio;
wmi_nlo_mawc_params->init_scan_interval = params->init_scan_interval;
wmi_nlo_mawc_params->max_scan_interval = params->max_scan_interval;
WMI_LOGD(FL("MAWC NLO en=%d, vdev=%d, ratio=%d, SCAN init=%d, max=%d"),
wmi_debug("MAWC NLO en=%d, vdev=%d, ratio=%d, SCAN init=%d, max=%d",
wmi_nlo_mawc_params->enable, wmi_nlo_mawc_params->vdev_id,
wmi_nlo_mawc_params->exp_backoff_ratio,
wmi_nlo_mawc_params->init_scan_interval,
@@ -5102,11 +5097,11 @@ static QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
WMI_CHAR_ARRAY_TO_MAC_ADDR(clear_req->peer_macaddr.bytes,
&cmd->peer_macaddr);
WMI_LOGD("LINK_LAYER_STATS - Clear Request Params");
WMI_LOGD("StopReq: %d", cmd->stop_stats_collection_req);
WMI_LOGD("Vdev Id: %d", cmd->vdev_id);
WMI_LOGD("Clear Stat Mask: %d", cmd->stats_clear_req_mask);
WMI_LOGD("Peer MAC Addr: "QDF_MAC_ADDR_FMT,
wmi_debug("LINK_LAYER_STATS - Clear Request Params");
wmi_debug("StopReq: %d Vdev Id: %d Clear Stat Mask: %d"
" Peer MAC Addr: "QDF_MAC_ADDR_FMT,
cmd->stop_stats_collection_req,
cmd->vdev_id, cmd->stats_clear_req_mask,
QDF_MAC_ADDR_REF(clear_req->peer_macaddr.bytes));
wmi_mtrace(WMI_CLEAR_LINK_STATS_CMDID, cmd->vdev_id, 0);
@@ -5118,7 +5113,7 @@ static QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("Clear Link Layer Stats request sent successfully");
wmi_debug("Clear Link Layer Stats request sent successfully");
return QDF_STATUS_SUCCESS;
}
@@ -5157,7 +5152,7 @@ static QDF_STATUS send_process_ll_stats_set_cmd_tlv(wmi_unified_t wmi_handle,
cmd->aggressive_statistics_gathering =
set_req->aggressive_statistics_gathering;
WMI_LOGD("LINK_LAYER_STATS - Start/Set Params MPDU Size Thresh : %d Aggressive Gather: %d",
wmi_debug("LINK_LAYER_STATS - Start/Set Params MPDU Size Thresh : %d Aggressive Gather: %d",
cmd->mpdu_size_threshold,
cmd->aggressive_statistics_gathering);
@@ -5211,7 +5206,7 @@ static QDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle,
WMI_CHAR_ARRAY_TO_MAC_ADDR(get_req->peer_macaddr.bytes,
&cmd->peer_macaddr);
WMI_LOGD("LINK_LAYER_STATS - Get Request Params Request ID: %u Stats Type: %0x Vdev ID: %d Peer MAC Addr: "QDF_MAC_ADDR_FMT,
wmi_debug("LINK_LAYER_STATS - Get Request Params Request ID: %u Stats Type: %0x Vdev ID: %d Peer MAC Addr: "QDF_MAC_ADDR_FMT,
cmd->request_id, cmd->stats_type, cmd->vdev_id,
QDF_MAC_ADDR_REF(get_req->peer_macaddr.bytes));
@@ -5257,7 +5252,7 @@ static QDF_STATUS send_congestion_cmd_tlv(wmi_unified_t wmi_handle,
cmd->stats_id = WMI_REQUEST_CONGESTION_STAT;
cmd->vdev_id = vdev_id;
WMI_LOGD("STATS REQ VDEV_ID:%d stats_id %d -->",
wmi_debug("STATS REQ VDEV_ID:%d stats_id %d -->",
cmd->vdev_id, cmd->stats_id);
wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);
@@ -5433,7 +5428,7 @@ static QDF_STATUS send_csa_offload_enable_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
wmi_debug("vdev_id %d", vdev_id);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
@@ -5529,7 +5524,7 @@ static QDF_STATUS send_start_11d_scan_cmd_tlv(wmi_unified_t wmi_handle,
cmd->scan_period_msec = start_11d_scan->scan_period_msec;
cmd->start_interval_msec = start_11d_scan->start_interval_msec;
WMI_LOGD("vdev %d sending 11D scan start req", cmd->vdev_id);
wmi_debug("vdev %d sending 11D scan start req", cmd->vdev_id);
wmi_mtrace(WMI_11D_SCAN_START_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -5574,7 +5569,7 @@ static QDF_STATUS send_stop_11d_scan_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = stop_11d_scan->vdev_id;
WMI_LOGD("vdev %d sending 11D scan stop req", cmd->vdev_id);
wmi_debug("vdev %d sending 11D scan stop req", cmd->vdev_id);
wmi_mtrace(WMI_11D_SCAN_STOP_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -5616,8 +5611,7 @@ static QDF_STATUS send_start_oem_data_cmd_tlv(wmi_unified_t wmi_handle,
qdf_mem_copy(cmd, data,
data_len);
WMI_LOGD(FL("Sending OEM Data Request to target, data len %d"),
data_len);
wmi_debug("Sending OEM Data Request to target, data len %d", data_len);
wmi_mtrace(WMI_OEM_REQ_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf,
@@ -5737,8 +5731,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
if (false == dfs_phyerr_filter_offload) {
WMI_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
__func__);
wmi_debug("Phyerror Filtering offload is Disabled in ini");
len = sizeof(*disable_phyerr_offload_cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
@@ -5767,11 +5760,9 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success",
__func__);
wmi_debug("WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success");
} else {
WMI_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
__func__);
wmi_debug("Phyerror Filtering offload is Enabled in ini");
len = sizeof(*enable_phyerr_offload_cmd);
buf = wmi_buf_alloc(wmi_handle, len);
@@ -5801,8 +5792,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success",
__func__);
wmi_debug("WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success");
}
return QDF_STATUS_SUCCESS;
@@ -5888,7 +5878,7 @@ static QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle,
}
break;
default:
WMI_LOGD("%s: invalid PKTLOG command", __func__);
wmi_debug("Invalid PKTLOG command: %d", CMD_ID);
break;
}
@@ -5940,8 +5930,8 @@ static QDF_STATUS send_stats_ext_req_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = preq->vdev_id;
cmd->data_len = preq->request_data_len;
WMI_LOGD("%s: The data len value is %u and vdev id set is %u ",
__func__, preq->request_data_len, preq->vdev_id);
wmi_debug("The data len value is %u and vdev id set is %u",
preq->request_data_len, preq->vdev_id);
buf_ptr += sizeof(wmi_req_stats_ext_cmd_fixed_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->data_len);
@@ -5999,8 +5989,7 @@ send_process_dhcpserver_offload_cmd_tlv(wmi_unified_t wmi_handle,
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("Set dhcp server offload to vdevId %d",
params->vdev_id);
wmi_debug("Set dhcp server offload to vdevId %d", params->vdev_id);
return status;
}
@@ -6154,7 +6143,7 @@ static QDF_STATUS send_vdev_set_custom_aggr_size_cmd_tlv(
cmd->rx_aggr_size = param->rx_aggr_size;
copy_custom_aggr_bitmap(param, cmd);
WMI_LOGD("Set custom aggr: vdev id=0x%X, tx aggr size=0x%X "
wmi_debug("Set custom aggr: vdev id=0x%X, tx aggr size=0x%X "
"rx_aggr_size=0x%X access category=0x%X, agg_type=0x%X "
"tx_aggr_size_disable=0x%X, rx_aggr_size_disable=0x%X "
"tx_ac_enable=0x%X",
@@ -6240,7 +6229,7 @@ static QDF_STATUS send_vdev_set_qdepth_thresh_cmd_tlv(wmi_unified_t wmi_handle,
param->update_params[i].msduq_update_mask;
cmd_update->qdepth_thresh_value =
param->update_params[i].qdepth_thresh_value;
WMI_LOGD("Set QDepth Threshold: vdev=0x%X pdev=0x%X, tid=0x%X "
wmi_debug("Set QDepth Threshold: vdev=0x%X pdev=0x%X, tid=0x%X "
"mac_addr_upper4=%X, mac_addr_lower2:%X,"
" update mask=0x%X thresh val=0x%X",
cmd->vdev_id, cmd->pdev_id, cmd_update->tid_num,
@@ -6726,7 +6715,7 @@ extract_pdev_sscan_fw_cmd_fixed_param_tlv(
ev->pdev_id);
param->smode = ev->spectral_scan_mode;
param->num_fft_bin_index = param_buf->num_fft_bin_index;
WMI_LOGD("%s:pdev id %u scan mode %u num_fft_bin_index %u", __func__,
wmi_debug("pdev id %u scan mode %u num_fft_bin_index %u",
param->pdev_id, param->smode, param->num_fft_bin_index);
return QDF_STATUS_SUCCESS;
@@ -6759,11 +6748,9 @@ extract_pdev_sscan_fft_bin_index_tlv(
param->start_5mhz + 1;
param->is_valid = true;
WMI_LOGD("%s:start_pri80 %u, num_pri80 %u", __func__,
param->start_pri80, param->num_pri80);
WMI_LOGD("%s:start_sec80 %u, num_sec80 %u", __func__,
param->start_sec80, param->num_sec80);
WMI_LOGD("%s:start_5mhz %u, num_5mhz %u", __func__,
wmi_debug("start_pri80: %u num_pri80: %u start_sec80: %u num_sec80: %u start_5mhz: %u, num_5mhz: %u",
param->start_pri80, param->num_pri80,
param->start_sec80, param->num_sec80,
param->start_5mhz, param->num_5mhz);
return QDF_STATUS_SUCCESS;
@@ -7339,9 +7326,8 @@ static QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle,
* Error: Our host version and the given firmware version
* are incompatible.
**/
WMI_LOGD("%s: Error: Incompatible WMI version."
wmi_debug("Error: Incompatible WMI version."
"Host: %d,%d,0x%x 0x%x 0x%x 0x%x, FW: %d,%d,0x%x 0x%x 0x%x 0x%x",
__func__,
WMI_VER_GET_MAJOR(wmi_handle->final_abi_vers.
abi_version_0),
WMI_VER_GET_MINOR(wmi_handle->final_abi_vers.
@@ -7418,8 +7404,7 @@ static QDF_STATUS send_log_supported_evt_cmd_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("%s: num_of_diag_events_logs=%d",
__func__, num_of_diag_events_logs);
wmi_debug("num_of_diag_events_logs=%d", num_of_diag_events_logs);
/* Free any previous allocation */
if (wmi_handle->events_logs_list) {
@@ -7522,8 +7507,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
count = 0;
if (!wmi_handle->events_logs_list) {
WMI_LOGD("%s: Not received event/log list from FW, yet",
__func__);
wmi_debug("Not received event/log list from FW, yet");
return QDF_STATUS_E_NOMEM;
}
/* total_len stores the number of events where BITS 17 and 18 are set.
@@ -7565,7 +7549,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
else
log_level = 0;
WMI_LOGD("%s: Length:%d, Log_level:%d", __func__, total_len, log_level);
wmi_debug("Length: %d Log_level: %d", total_len, log_level);
for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) {
uint32_t val = wmi_handle->events_logs_list[i];
if ((WMI_DIAG_FREQUENCY_GET(val)) &&
@@ -7577,7 +7561,7 @@ static QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
WMI_DIAG_TYPE_GET(val));
WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[count],
log_level);
WMI_LOGD("%s: Idx:%d, val:%x", __func__, i, val);
wmi_debug("Idx:%d, val:%x", i, val);
count++;
}
}
@@ -7630,7 +7614,7 @@ static QDF_STATUS send_flush_logs_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
wmi_buf_free(buf);
return QDF_STATUS_E_INVAL;
}
WMI_LOGD("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW");
wmi_debug("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW");
return ret;
}
@@ -7761,7 +7745,7 @@ send_encrypt_decrypt_send_cmd_tlv(wmi_unified_t wmi_handle,
QDF_STATUS ret;
uint32_t len;
WMI_LOGD(FL("Send encrypt decrypt cmd"));
wmi_debug("Send encrypt decrypt cmd");
len = sizeof(*cmd) +
encrypt_decrypt_params->data_len +
@@ -8357,8 +8341,8 @@ QDF_STATUS send_adfs_ch_cfg_cmd_tlv(wmi_unified_t wmi_handle,
cmd->chan_width = param->chan_width;
cmd->min_duration_ms = param->min_duration_ms;
cmd->max_duration_ms = param->max_duration_ms;
WMI_LOGD("%s:cmd->vdev_id: %d ,cmd->ocac_mode: %d cmd->center_freq: %d",
__func__, cmd->vdev_id, cmd->ocac_mode,
wmi_debug("cmd->vdev_id: %d ,cmd->ocac_mode: %d cmd->center_freq: %d",
cmd->vdev_id, cmd->ocac_mode,
cmd->center_freq);
wmi_mtrace(WMI_VDEV_ADFS_CH_CFG_CMDID, NO_SESSION, 0);
@@ -9190,7 +9174,7 @@ static QDF_STATUS extract_cca_stats_tlv(wmi_unified_t wmi_handle,
out_buff->vdev_id = congestion_stats->vdev_id;
out_buff->congestion = congestion_stats->congestion;
WMI_LOGD("%s: cca stats event processed", __func__);
wmi_debug("cca stats event processed");
return QDF_STATUS_SUCCESS;
}
#endif /* QCA_SUPPORT_CP_STATS */
@@ -9298,7 +9282,7 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
ev->wmi_service_segment_bitmap,
(WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t)));
WMI_LOGD("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x",
wmi_debug("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x",
soc->wmi_ext_service_bitmap[0], soc->wmi_ext_service_bitmap[1],
soc->wmi_ext_service_bitmap[2], soc->wmi_ext_service_bitmap[3]);
@@ -9308,7 +9292,7 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
(WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t)));
if (!param_buf->wmi_service_ext_bitmap) {
WMI_LOGD("wmi_service_ext_bitmap not available");
wmi_debug("wmi_service_ext_bitmap not available");
return QDF_STATUS_SUCCESS;
}
@@ -9326,7 +9310,7 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf,
sizeof(uint32_t)));
for (i = 0; i < param_buf->num_wmi_service_ext_bitmap; i++) {
WMI_LOGD("wmi_ext2_service_bitmap %u:0x%x",
wmi_debug("wmi_ext2_service_bitmap %u:0x%x",
i, soc->wmi_ext2_service_bitmap[i]);
}
@@ -9419,7 +9403,7 @@ static inline uint32_t convert_wireless_modes_tlv(uint32_t target_wireless_mode)
uint32_t wireless_modes = 0;
WMI_LOGD("Target wireless mode: 0x%x", target_wireless_mode);
wmi_debug("Target wireless mode: 0x%x", target_wireless_mode);
if (target_wireless_mode & REGDMN_MODE_11A)
wireless_modes |= WMI_HOST_REGDMN_MODE_11A;
@@ -9504,7 +9488,7 @@ static uint32_t convert_phybitmap_tlv(uint32_t target_phybitmap)
{
uint32_t phybitmap = 0;
WMI_LOGD("Target phybitmap: 0x%x", target_phybitmap);
wmi_debug("Target phybitmap: 0x%x", target_phybitmap);
if (target_phybitmap & WMI_REGULATORY_PHYMODE_NO11A)
phybitmap |= REGULATORY_PHYMODE_NO11A;
@@ -9532,7 +9516,7 @@ static inline uint32_t convert_wireless_modes_ext_tlv(
{
uint32_t wireless_modes_ext = 0;
WMI_LOGD("Target wireless mode: 0x%x", target_wireless_modes_ext);
wmi_debug("Target wireless mode: 0x%x", target_wireless_modes_ext);
if (target_wireless_modes_ext & REGDMN_MODE_U32_11AXG_HE20)
wireless_modes_ext |= WMI_HOST_REGDMN_MODE_11AXG_HE20;
@@ -10249,7 +10233,7 @@ extract_vdev_prb_fils_stats_tlv(wmi_unified_t wmi_handle,
ev->unsolicited_prb_succ_cnt;
vdev_stats->unsolicited_prb_fail_cnt =
ev->unsolicited_prb_fail_cnt;
WMI_LOGD("vdev: %d, fd_s: %d, fd_f: %d, prb_s: %d, prb_f: %d",
wmi_debug("vdev: %d, fd_s: %d, fd_f: %d, prb_s: %d, prb_f: %d",
ev->vdev_id, ev->fd_succ_cnt, ev->fd_fail_cnt,
ev->unsolicited_prb_succ_cnt,
ev->unsolicited_prb_fail_cnt);
@@ -11531,7 +11515,7 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
wmi_regulatory_rule_struct *wmi_reg_rule;
uint32_t num_2g_reg_rules, num_5g_reg_rules;
WMI_LOGD("processing regulatory channel list");
wmi_debug("processing regulatory channel list");
param_buf = (WMI_REG_CHAN_LIST_CC_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
@@ -11596,15 +11580,15 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
reg_info->min_bw_5g = chan_list_event_hdr->min_bw_5g;
reg_info->max_bw_5g = chan_list_event_hdr->max_bw_5g;
WMI_LOGD(FL("num_phys = %u and phy_id = %u"),
wmi_debug("num_phys = %u and phy_id = %u",
reg_info->num_phy, reg_info->phy_id);
WMI_LOGD("%s:cc %s dfs %d BW: min_2g %d max_2g %d min_5g %d max_5g %d",
__func__, reg_info->alpha2, reg_info->dfs_region,
wmi_debug("cc %s dfs %d BW: min_2g %d max_2g %d min_5g %d max_5g %d",
reg_info->alpha2, reg_info->dfs_region,
reg_info->min_bw_2g, reg_info->max_bw_2g,
reg_info->min_bw_5g, reg_info->max_bw_5g);
WMI_LOGD("%s: num_2g_reg_rules %d num_5g_reg_rules %d", __func__,
wmi_debug("num_2g_reg_rules %d num_5g_reg_rules %d",
num_2g_reg_rules, num_5g_reg_rules);
wmi_reg_rule =
(wmi_regulatory_rule_struct *)((uint8_t *)chan_list_event_hdr
@@ -11617,7 +11601,7 @@ static QDF_STATUS extract_reg_chan_list_update_event_tlv(
reg_info->reg_rules_5g_ptr = create_reg_rules_from_wmi(num_5g_reg_rules,
wmi_reg_rule);
WMI_LOGD("processed regulatory channel list");
wmi_debug("processed regulatory channel list");
return QDF_STATUS_SUCCESS;
}
@@ -11641,7 +11625,7 @@ static QDF_STATUS extract_reg_11d_new_country_event_tlv(
&reg_11d_country_event->new_alpha2, REG_ALPHA2_LEN);
reg_11d_country->alpha2[REG_ALPHA2_LEN] = '\0';
WMI_LOGD("processed 11d country event, new cc %s",
wmi_debug("processed 11d country event, new cc %s",
reg_11d_country->alpha2);
return QDF_STATUS_SUCCESS;
@@ -11680,7 +11664,7 @@ static QDF_STATUS extract_reg_ch_avoid_event_tlv(
CH_AVOID_MAX_RANGE) ? CH_AVOID_MAX_RANGE :
afr_fixed_param->num_freq_ranges;
WMI_LOGD("Channel avoid event received with %d ranges",
wmi_debug("Channel avoid event received with %d ranges",
num_freq_ranges);
ch_avoid_ind->ch_avoid_range_cnt = num_freq_ranges;
@@ -11691,7 +11675,7 @@ static QDF_STATUS extract_reg_ch_avoid_event_tlv(
afr_desc->start_freq;
ch_avoid_ind->avoid_freq_range[freq_range_idx].end_freq =
afr_desc->end_freq;
WMI_LOGD("range %d tlv id %u, start freq %u, end freq %u",
wmi_debug("range %d tlv id %u, start freq %u, end freq %u",
freq_range_idx, afr_desc->tlv_header,
afr_desc->start_freq, afr_desc->end_freq);
afr_desc++;
@@ -11726,7 +11710,7 @@ static QDF_STATUS extract_dfs_cac_complete_event_tlv(wmi_unified_t wmi_handle,
cac_event = param_tlvs->fixed_param;
*vdev_id = cac_event->vdev_id;
WMI_LOGD("processed cac complete event vdev %d", *vdev_id);
wmi_debug("processed cac complete event vdev %d", *vdev_id);
return QDF_STATUS_SUCCESS;
}
@@ -11766,7 +11750,7 @@ extract_dfs_ocac_complete_event_tlv(wmi_unified_t wmi_handle,
param->center_freq2 = ocac_complete_status->center_freq2;
param->ocac_status = ocac_complete_status->status;
param->chan_width = ocac_complete_status->chan_width;
WMI_LOGD("processed ocac complete event vdev %d"
wmi_debug("processed ocac complete event vdev %d"
" agile chan %d %d width %d status %d",
param->vdev_id,
param->center_freq1,
@@ -11949,7 +11933,7 @@ static QDF_STATUS send_get_rcpi_cmd_tlv(wmi_unified_t wmi_handle,
cmd->measurement_type = WMI_RCPI_MEASUREMENT_TYPE_AVG_MGMT;
break;
}
WMI_LOGD("RCPI REQ VDEV_ID:%d-->", cmd->vdev_id);
wmi_debug("RCPI REQ VDEV_ID:%d-->", cmd->vdev_id);
wmi_mtrace(WMI_REQUEST_RCPI_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_REQUEST_RCPI_CMDID)) {
@@ -12112,7 +12096,7 @@ static QDF_STATUS send_set_country_cmd_tlv(wmi_unified_t wmi_handle,
cmd->pdev_id = wmi_handle->ops->convert_host_pdev_id_to_target(
wmi_handle,
pdev_id);
WMI_LOGD("setting current country to %s and target pdev_id = %u",
wmi_debug("setting current country to %s and target pdev_id = %u",
params->country, cmd->pdev_id);
qdf_mem_copy((uint8_t *)&cmd->new_alpha2, params->country, 3);
@@ -12313,7 +12297,7 @@ send_roam_scan_stats_cmd_tlv(wmi_unified_t wmi_handle,
cmd->vdev_id = params->vdev_id;
WMI_LOGD(FL("Roam Scan Stats Req vdev_id: %u"), cmd->vdev_id);
wmi_debug("Roam Scan Stats Req vdev_id: %u", cmd->vdev_id);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_REQUEST_ROAM_SCAN_STATS_CMDID)) {
wmi_err("Failed to send WMI_REQUEST_ROAM_SCAN_STATS_CMDID");
@@ -12658,20 +12642,20 @@ static QDF_STATUS extract_comb_phyerr_tlv(wmi_unified_t wmi_handle,
param_tlvs = (WMI_PHYERR_EVENTID_param_tlvs *)evt_buf;
if (!param_tlvs) {
WMI_LOGD("%s: Received null data from FW", __func__);
wmi_debug("Received null data from FW");
return QDF_STATUS_E_FAILURE;
}
pe_hdr = param_tlvs->hdr;
if (!pe_hdr) {
WMI_LOGD("%s: Received Data PE Header is NULL", __func__);
wmi_debug("Received Data PE Header is NULL");
return QDF_STATUS_E_FAILURE;
}
/* Ensure it's at least the size of the header */
if (datalen < sizeof(*pe_hdr)) {
WMI_LOGD("%s: Expected minimum size %zu, received %d",
__func__, sizeof(*pe_hdr), datalen);
wmi_debug("Expected minimum size %zu, received %d",
sizeof(*pe_hdr), datalen);
return QDF_STATUS_E_FAILURE;
}
@@ -12682,7 +12666,7 @@ static QDF_STATUS extract_comb_phyerr_tlv(wmi_unified_t wmi_handle,
phyerr->bufp = param_tlvs->bufp;
if (pe_hdr->buf_len > param_tlvs->num_bufp) {
WMI_LOGD("Invalid buf_len %d, num_bufp %d",
wmi_debug("Invalid buf_len %d, num_bufp %d",
pe_hdr->buf_len, param_tlvs->num_bufp);
return QDF_STATUS_E_FAILURE;
}
@@ -12718,8 +12702,8 @@ static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle,
if (n < datalen) {
if ((datalen - n) < sizeof(ev->hdr)) {
WMI_LOGD("%s: Not enough space. len=%d, n=%d, hdr=%zu",
__func__, datalen, n, sizeof(ev->hdr));
wmi_debug("Not enough space. len=%d, n=%d, hdr=%zu",
datalen, n, sizeof(ev->hdr));
return QDF_STATUS_E_FAILURE;
}
@@ -12741,14 +12725,13 @@ static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle,
* If "int" is 64 bits then this becomes a moot point.
*/
if (ev->hdr.buf_len > PHYERROR_MAX_BUFFER_LENGTH) {
WMI_LOGD("%s: buf_len is garbage 0x%x",
__func__, ev->hdr.buf_len);
wmi_debug("buf_len is garbage 0x%x", ev->hdr.buf_len);
return QDF_STATUS_E_FAILURE;
}
if ((n + ev->hdr.buf_len) > datalen) {
WMI_LOGD("%s: len exceeds n=%d, buf_len=%d, datalen=%d",
__func__, n, ev->hdr.buf_len, datalen);
wmi_debug("len exceeds n=%d, buf_len=%d, datalen=%d",
n, ev->hdr.buf_len, datalen);
return QDF_STATUS_E_FAILURE;
}
@@ -12899,10 +12882,10 @@ static QDF_STATUS send_obss_color_collision_cfg_cmd_tlv(
return QDF_STATUS_E_FAILURE;
}
WMI_LOGD("%s: evt_type: %d vdev id: %d current_bss_color: %d\n"
"detection_period_ms: %d scan_period_ms: %d\n"
wmi_debug("evt_type: %d vdev id: %d current_bss_color: %d "
"detection_period_ms: %d scan_period_ms: %d "
"free_slot_expiry_timer_ms: %d",
__func__, cmd->evt_type, cmd->vdev_id, cmd->current_bss_color,
cmd->evt_type, cmd->vdev_id, cmd->current_bss_color,
cmd->detection_period_ms, cmd->scan_period_ms,
cmd->free_slot_expiry_time_ms);
@@ -13006,8 +12989,8 @@ send_vdev_fils_enable_cmd_send(struct wmi_unified *wmi_handle,
cmd->fd_period = param->fd_period;
if (param->send_prb_rsp_frame)
cmd->flags |= WMI_FILS_FLAGS_BITMAP_BCAST_PROBE_RSP;
WMI_LOGD("%s: vdev id: %d fd_period: %d cmd->Flags %d",
__func__, cmd->vdev_id, cmd->fd_period, cmd->flags);
wmi_debug("vdev id: %d fd_period: %d cmd->Flags %d",
cmd->vdev_id, cmd->fd_period, cmd->flags);
wmi_mtrace(WMI_ENABLE_FILS_CMDID, cmd->vdev_id, cmd->fd_period);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_ENABLE_FILS_CMDID)) {
@@ -13177,7 +13160,7 @@ static QDF_STATUS send_ani_level_cmd_tlv(wmi_unified_t wmi_handle,
chan_list = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE);
for (i = 0; i < num_freqs; i++) {
chan_list[i] = freqs[i];
WMI_LOGD("Requesting ANI for channel[%d]", chan_list[i]);
wmi_debug("Requesting ANI for channel[%d]", chan_list[i]);
}
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
@@ -13504,7 +13487,7 @@ extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf,
if (!param_buf || !param_buf->roam_neighbor_report_info ||
!param_buf->num_roam_neighbor_report_info ||
idx >= param_buf->num_roam_neighbor_report_info) {
WMI_LOGD("%s: Invalid 1kv param buf", __func__);
wmi_debug("Invalid 1kv param buf");
return QDF_STATUS_E_FAILURE;
}
@@ -13521,8 +13504,8 @@ extract_roam_11kv_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf,
return QDF_STATUS_SUCCESS;
if (!param_buf->roam_neighbor_report_chan_info) {
WMI_LOGD("%s: 11kv channel present, but TLV is NULL num_freq:%d",
__func__, dst->num_freq);
wmi_debug("11kv channel present, but TLV is NULL num_freq:%d",
dst->num_freq);
dst->num_freq = 0;
/* return success as its optional tlv and we can print neighbor
* report received info

10
wmi/src/wmi_unified_twt_tlv.c
View File

@@ -705,7 +705,7 @@ extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle,
ev->pdev_id);
params->num_sessions = param_buf->num_twt_sessions;
WMI_LOGD("pdev_id=%d, num of TWT sessions=%d",
wmi_debug("pdev_id=%d, num of TWT sessions=%d",
params->pdev_id, params->num_sessions);
return QDF_STATUS_SUCCESS;
@@ -760,12 +760,10 @@ extract_twt_session_stats_event_data(wmi_unified_t wmi_handle,
session->sp_offset_us = twt_session->sp_offset_us;
session->sp_tsf_us_lo = twt_session->sp_tsf_us_lo;
session->sp_tsf_us_hi = twt_session->sp_tsf_us_hi;
WMI_LOGD("type=%d,id=%d,bcast=%d,trig=%d",
wmi_debug("type=%d id=%d bcast=%d trig=%d announ=%d diagid=%d wake_dur=%ul wake_int=%ul offset=%ul",
session->event_type, session->flow_id,
session->bcast, session->trig);
WMI_LOGD("announ=%d,diagid=%d,wake_dur=%ul",
session->announ, session->dialog_id, session->wake_dura_us);
WMI_LOGD("wake_int=%ul,offset=%ul",
session->bcast, session->trig,
session->announ, session->dialog_id, session->wake_dura_us,
session->wake_intvl_us, session->sp_offset_us);
return QDF_STATUS_SUCCESS;