A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-13 08:07:32 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: components: Change %pM/QDF_MAC_ADDR_STR/ARRAY to QDF_MAC_ADDR_FMT/REF

Browse source 
Change %pM/QDF_MAC_ADDR_STR/ARRAY to QDF_MAC_ADDR_FMT/REF.

CRs-Fixed: 2752355
Change-Id: I2d776be789df3e83e0c13211844b66d595498829
This commit is contained in:
Srinivas Girigowda 2020-08-10 17:07:00 -07:00 • committed by snandini
commit f375188704
17 changed files with 148 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

79
components/blacklist_mgr/core/src/wlan_blm_core.c
View file

@ -141,8 +141,9 @@ blm_update_ap_info(struct blm_reject_ap *blm_entry, struct blm_config *cfg,
if (!update_done)
return;
blm_debug("%pM Old %d Updated reject ap type = %x",
blm_entry->bssid.bytes, old_reject_ap_type,
blm_debug(QDF_MAC_ADDR_FMT" Old %d Updated reject ap type = %x",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes),
old_reject_ap_type,
blm_entry->reject_ap_type);
}
@ -162,7 +163,8 @@ blm_prune_old_entries_and_get_action(struct blm_reject_ap *blm_entry,
* then remove the entry from the reject ap list.
*/
if (!blm_entry->reject_ap_type) {
blm_debug("%pM cleared from list", blm_entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" cleared from list",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
qdf_list_remove_node(reject_ap_list, &blm_entry->node);
qdf_mem_free(blm_entry);
return CM_BLM_NO_ACTION;
@ -171,8 +173,8 @@ blm_prune_old_entries_and_get_action(struct blm_reject_ap *blm_entry,
if (BLM_IS_AP_IN_RSSI_REJECT_LIST(blm_entry) &&
!blm_entry->userspace_blacklist && !blm_entry->driver_blacklist &&
blm_entry->rssi_reject_params.original_timeout > MAX_BL_TIME) {
blm_info("Allow BSSID %pM as the retry delay is greater than %u ms, expected RSSI = %d, current RSSI = %d, retry delay = %u ms original timeout %u time added %lu source %d reason %d",
blm_entry->bssid.bytes, MAX_BL_TIME,
blm_info("Allow BSSID "QDF_MAC_ADDR_FMT" as the retry delay is greater than %u ms, expected RSSI = %d, current RSSI = %d, retry delay = %u ms original timeout %u time added %lu source %d reason %d",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes), MAX_BL_TIME,
blm_entry->rssi_reject_params.expected_rssi,
entry ? entry->rssi_raw : 0,
blm_entry->rssi_reject_params.retry_delay,
@ -181,22 +183,23 @@ blm_prune_old_entries_and_get_action(struct blm_reject_ap *blm_entry,
blm_entry->source, blm_entry->reject_ap_reason);
if (BLM_IS_AP_IN_AVOIDLIST(blm_entry)) {
blm_debug("%pM in avoid list, deprioritize it",
blm_entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" in avoid list, deprioritize it",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
return CM_BLM_AVOID;
}
return CM_BLM_NO_ACTION;
}
if (BLM_IS_AP_IN_BLACKLIST(blm_entry)) {
blm_debug("%pM in blacklist list, reject ap type %d removing from candidate list",
blm_entry->bssid.bytes, blm_entry->reject_ap_type);
blm_debug(QDF_MAC_ADDR_FMT" in blacklist list, reject ap type %d removing from candidate list",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes),
blm_entry->reject_ap_type);
return CM_BLM_REMOVE;
}
if (BLM_IS_AP_IN_AVOIDLIST(blm_entry)) {
blm_debug("%pM in avoid list, deprioritize it",
blm_entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" in avoid list, deprioritize it",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
return CM_BLM_AVOID;
}
@ -323,12 +326,12 @@ blm_handle_avoid_list(struct blm_reject_ap *entry,
entry->driver_blacklist = true;
entry->ap_timestamp.driver_blacklist_timestamp = cur_timestamp;
blm_debug("%pM moved to black list with counter %d",
entry->bssid.bytes, entry->bad_bssid_counter);
blm_debug(QDF_MAC_ADDR_FMT" moved to black list with counter %d",
QDF_MAC_ADDR_REF(entry->bssid.bytes), entry->bad_bssid_counter);
return;
}
blm_debug("Added %pM to avoid list type %d, counter %d reason %d updated reject reason %d source %d",
entry->bssid.bytes, ap_info->reject_ap_type,
blm_debug("Added "QDF_MAC_ADDR_FMT" to avoid list type %d, counter %d reason %d updated reject reason %d source %d",
QDF_MAC_ADDR_REF(entry->bssid.bytes), ap_info->reject_ap_type,
entry->bad_bssid_counter, ap_info->reject_reason,
entry->reject_ap_reason, entry->source);
@ -352,7 +355,8 @@ blm_handle_blacklist(struct blm_reject_ap *entry,
entry->source = ADDED_BY_DRIVER;
entry->blacklist_userspace = true;
blm_debug("%pM added to userspace blacklist", entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" added to userspace blacklist",
QDF_MAC_ADDR_REF(entry->bssid.bytes));
}
static void
@ -413,9 +417,10 @@ blm_handle_rssi_reject_list(struct blm_reject_ap *entry,
qdf_mc_timer_get_system_time();
entry->rssi_reject_params = ap_info->rssi_reject_params;
blm_update_rssi_reject_reason(entry, ap_info->reject_reason);
blm_info("%pM %s to rssi reject list, expected RSSI %d retry delay %u source %d original timeout %u received time %lu reject reason %d updated reason %d",
blm_info(QDF_MAC_ADDR_FMT" %s to rssi reject list, expected RSSI %d retry delay %u source %d original timeout %u received time %lu reject reason %d updated reason %d",
QDF_MAC_ADDR_REF(entry->bssid.bytes),
bssid_newly_added ? "ADDED" : "UPDATED",
entry->bssid.bytes, entry->rssi_reject_params.expected_rssi,
entry->rssi_reject_params.expected_rssi,
entry->rssi_reject_params.retry_delay,
entry->rssi_reject_params.source,
entry->rssi_reject_params.original_timeout,
@ -616,8 +621,9 @@ blm_try_delete_bssid_in_list(qdf_list_t *reject_ap_list,
if (oldest_blm_entry) {
/* Remove this entry to make space for the next entry */
blm_debug("Removed %pM, type = %d",
oldest_blm_entry->bssid.bytes, list_type);
blm_debug("Removed "QDF_MAC_ADDR_FMT", type = %d",
QDF_MAC_ADDR_REF(oldest_blm_entry->bssid.bytes),
list_type);
qdf_list_remove_node(reject_ap_list, &oldest_blm_entry->node);
qdf_mem_free(oldest_blm_entry);
return QDF_STATUS_SUCCESS;
@ -715,8 +721,8 @@ blm_fill_rssi_reject_params(struct blm_reject_ap *blm_entry,
blm_reject_list->received_time =
blm_entry->rssi_reject_params.received_time;
blm_reject_list->reject_reason = blm_get_rssi_reject_reason(blm_entry);
blm_debug("%pM source %d original timeout %u received time %lu reject reason %d",
blm_entry->bssid.bytes, blm_reject_list->source,
blm_debug(QDF_MAC_ADDR_FMT" source %d original timeout %u received time %lu reject reason %d",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes), blm_reject_list->source,
blm_reject_list->original_timeout,
blm_reject_list->received_time,
blm_reject_list->reject_reason);
@ -746,8 +752,8 @@ static void blm_fill_reject_list(qdf_list_t *reject_db_list,
blm_update_ap_info(blm_entry, cfg, NULL);
if (!blm_entry->reject_ap_type) {
blm_debug("%pM cleared from list",
blm_entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" cleared from list",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
qdf_list_remove_node(reject_db_list, &blm_entry->node);
qdf_mem_free(blm_entry);
cur_node = next_node;
@ -770,8 +776,9 @@ static void blm_fill_reject_list(qdf_list_t *reject_db_list,
blm_reject_list->reject_ap_type = reject_ap_type;
blm_reject_list->bssid = blm_entry->bssid;
(*num_of_reject_bssid)++;
blm_debug("Adding BSSID %pM of type %d retry delay %d expected RSSI %d, entries added = %d reject reason %d",
blm_entry->bssid.bytes, reject_ap_type,
blm_debug("Adding BSSID "QDF_MAC_ADDR_FMT" of type %d retry delay %d expected RSSI %d, entries added = %d reject reason %d",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes),
reject_ap_type,
reject_list[*num_of_reject_bssid -1].reject_duration,
blm_entry->rssi_reject_params.expected_rssi,
*num_of_reject_bssid,
@ -873,8 +880,8 @@ blm_add_bssid_to_reject_list(struct wlan_objmgr_pdev *pdev,
/* Update the AP info to the latest list first */
blm_update_ap_info(blm_entry, cfg, NULL);
if (!blm_entry->reject_ap_type) {
blm_debug("%pM cleared from list",
blm_entry->bssid.bytes);
blm_debug(QDF_MAC_ADDR_FMT" cleared from list",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
qdf_list_remove_node(&blm_ctx->reject_ap_list,
&blm_entry->node);
qdf_mem_free(blm_entry);
@ -950,13 +957,14 @@ blm_clear_userspace_blacklist_info(struct wlan_objmgr_pdev *pdev)
node);
if (IS_AP_IN_USERSPACE_BLACKLIST_ONLY(blm_entry)) {
blm_debug("removing bssid: %pM", blm_entry->bssid.bytes);
blm_debug("removing bssid: "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
qdf_list_remove_node(&blm_ctx->reject_ap_list,
&blm_entry->node);
qdf_mem_free(blm_entry);
} else if (BLM_IS_AP_BLACKLISTED_BY_USERSPACE(blm_entry)) {
blm_debug("Clearing userspace blacklist bit for %pM",
blm_entry->bssid.bytes);
blm_debug("Clearing userspace blacklist bit for "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
blm_entry->userspace_blacklist = false;
blm_entry->blacklist_userspace = false;
}
@ -1124,8 +1132,9 @@ blm_update_bssid_connect_params(struct wlan_objmgr_pdev *pdev,
if (!qdf_mem_cmp(blm_entry->bssid.bytes, bssid.bytes,
QDF_MAC_ADDR_SIZE)) {
blm_debug("%pM present in BLM reject list, updating connect info con_state = %d",
blm_entry->bssid.bytes, con_state);
blm_debug(QDF_MAC_ADDR_FMT" present in BLM reject list, updating connect info con_state = %d",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes),
con_state);
entry_found = true;
break;
}
@ -1167,8 +1176,8 @@ blm_update_bssid_connect_params(struct wlan_objmgr_pdev *pdev,
blm_debug("updated reject ap type %d ",
blm_entry->reject_ap_type);
if (!blm_entry->reject_ap_type) {
blm_debug("Bad Bssid timer expired/AP cleared from all blacklisting, removed %pM from list",
blm_entry->bssid.bytes);
blm_debug("Bad Bssid timer expired/AP cleared from all blacklisting, removed "QDF_MAC_ADDR_FMT" from list",
QDF_MAC_ADDR_REF(blm_entry->bssid.bytes));
qdf_list_remove_node(&blm_ctx->reject_ap_list,
&blm_entry->node);
qdf_mem_free(blm_entry);

19
components/cp_stats/dispatcher/src/wlan_cp_stats_mc_tgt_api.c
View file

@ -140,8 +140,8 @@ static void peer_rssi_iterator(struct wlan_objmgr_pdev *pdev,
struct peer_extd_stats *peer_extd_mc_stats;
if (WLAN_PEER_SELF == wlan_peer_get_peer_type(peer)) {
cp_stats_debug("ignore self peer: %pM",
wlan_peer_get_macaddr(peer));
cp_stats_debug("ignore self peer: "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(wlan_peer_get_macaddr(peer)));
return;
}
@ -213,7 +213,8 @@ tgt_mc_cp_stats_prepare_raw_peer_rssi(struct wlan_objmgr_psoc *psoc,
peer = wlan_objmgr_get_peer(psoc, last_req->pdev_id,
mac_addr, WLAN_CP_STATS_ID);
if (!peer) {
cp_stats_err("peer[%pM] is null", mac_addr);
cp_stats_err("peer["QDF_MAC_ADDR_FMT"] is null",
QDF_MAC_ADDR_REF(mac_addr));
goto end;
}
@ -346,8 +347,9 @@ tgt_mc_cp_stats_update_peer_stats(struct wlan_objmgr_psoc *psoc,
peer_mc_stats->rx_rate = peer_stats->rx_rate;
if (peer_stats->peer_rssi)
peer_mc_stats->peer_rssi = peer_stats->peer_rssi;
cp_stats_nofl_debug("PEER STATS: peer_mac=%pM, tx_rate=%u, rx_rate=%u, peer_rssi=%d",
peer_mc_stats->peer_macaddr, peer_mc_stats->tx_rate,
cp_stats_nofl_debug("PEER STATS: peer_mac="QDF_MAC_ADDR_FMT", tx_rate=%u, rx_rate=%u, peer_rssi=%d",
QDF_MAC_ADDR_REF(peer_mc_stats->peer_macaddr),
peer_mc_stats->tx_rate,
peer_mc_stats->rx_rate, peer_mc_stats->peer_rssi);
wlan_cp_stats_peer_obj_unlock(peer_cp_stats_priv);
@ -405,8 +407,8 @@ tgt_mc_cp_stats_update_peer_extd_stats(
peer_extended_stats->rx_mc_bc_cnt;
wlan_cp_stats_peer_obj_unlock(peer_cp_stats_priv);
cp_stats_debug("peer_mac=%pM, rx_mc_bc_cnt=%u",
peer_extended_stats->peer_macaddr,
cp_stats_debug("peer_mac="QDF_MAC_ADDR_FMT", rx_mc_bc_cnt=%u",
QDF_MAC_ADDR_REF(peer_extended_stats->peer_macaddr),
peer_extended_stats->rx_mc_bc_cnt);
end:
@ -704,7 +706,8 @@ static void tgt_mc_cp_stats_extract_vdev_summary_stats(
peer = wlan_objmgr_get_peer(psoc, last_req.pdev_id,
last_req.peer_mac_addr, WLAN_CP_STATS_ID);
if (!peer) {
cp_stats_debug("peer is null %pM", last_req.peer_mac_addr);
cp_stats_debug("peer is null "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(last_req.peer_mac_addr));
goto end;
}

4
components/cp_stats/dispatcher/src/wlan_cp_stats_mc_ucfg_api.c
View file

@ -118,8 +118,8 @@ ucfg_twt_get_single_peer_session_params(struct wlan_objmgr_psoc *psoc_obj,
dialog_id, params)) {
qdf_status = QDF_STATUS_SUCCESS;
} else {
qdf_err("No TWT session for " QDF_MAC_ADDR_STR " dialog_id %d",
QDF_MAC_ADDR_ARRAY(mac_addr), dialog_id);
qdf_err("No TWT session for " QDF_MAC_ADDR_FMT " dialog_id %d",
QDF_MAC_ADDR_REF(mac_addr), dialog_id);
}
wlan_cp_stats_peer_obj_unlock(peer_cp_stats_priv);

18
components/ipa/core/src/wlan_ipa_core.c
View file

@ -1330,8 +1330,8 @@ static bool wlan_ipa_uc_find_add_assoc_sta(struct wlan_ipa_priv *ipa_ctx,
}
}
if (sta_add && sta_found) {
ipa_err("STA already exist, cannot add: " QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(mac_addr));
ipa_err("STA already exist, cannot add: " QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(mac_addr));
return sta_found;
}
if (sta_add) {
@ -1347,7 +1347,7 @@ static bool wlan_ipa_uc_find_add_assoc_sta(struct wlan_ipa_priv *ipa_ctx,
}
if (!sta_add && !sta_found) {
ipa_info("STA does not exist, cannot delete: "
QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(mac_addr));
QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(mac_addr));
return sta_found;
}
if (!sta_add) {
@ -1930,8 +1930,8 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
struct wlan_objmgr_psoc *psoc;
struct wlan_objmgr_vdev *vdev;
ipa_debug("%s: EVT: %d, MAC: %pM, session_id: %u",
net_dev->name, type, mac_addr, session_id);
ipa_debug("%s: EVT: %d, MAC: "QDF_MAC_ADDR_FMT", session_id: %u",
net_dev->name, type, QDF_MAC_ADDR_REF(mac_addr), session_id);
if (type >= QDF_IPA_WLAN_EVENT_MAX)
return QDF_STATUS_E_INVAL;
@ -2316,9 +2316,9 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
if (wlan_ipa_uc_find_add_assoc_sta(ipa_ctx, true,
mac_addr)) {
qdf_mutex_release(&ipa_ctx->event_lock);
ipa_err("%s: STA found, addr: " QDF_MAC_ADDR_STR,
ipa_err("%s: STA found, addr: " QDF_MAC_ADDR_FMT,
net_dev->name,
QDF_MAC_ADDR_ARRAY(mac_addr));
QDF_MAC_ADDR_REF(mac_addr));
return QDF_STATUS_SUCCESS;
}
@ -2430,8 +2430,8 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
mac_addr)) {
qdf_mutex_release(&ipa_ctx->event_lock);
ipa_debug("%s: STA NOT found, not valid: "
QDF_MAC_ADDR_STR,
msg_ex->name, QDF_MAC_ADDR_ARRAY(mac_addr));
QDF_MAC_ADDR_FMT,
msg_ex->name, QDF_MAC_ADDR_REF(mac_addr));
return QDF_STATUS_SUCCESS;
}

8
components/ipa/core/src/wlan_ipa_stats.c
View file

@ -335,9 +335,9 @@ static void wlan_ipa_dump_ipa_ctx(struct wlan_ipa_priv *ipa_ctx)
QDF_TRACE(QDF_MODULE_ID_IPA, QDF_TRACE_LEVEL_INFO,
"\nassoc_stas_map ----");
for (i = 0; i < WLAN_IPA_MAX_STA_COUNT; i++) {
ipa_info("\n\t[%d]: is_reserved=%d mac: " QDF_MAC_ADDR_STR, i,
ipa_info("\n\t[%d]: is_reserved=%d mac: " QDF_MAC_ADDR_FMT, i,
ipa_ctx->assoc_stas_map[i].is_reserved,
QDF_MAC_ADDR_ARRAY(
QDF_MAC_ADDR_REF(
ipa_ctx->assoc_stas_map[i].mac_addr.bytes));
}
}
@ -537,9 +537,9 @@ static void wlan_ipa_print_session_info(struct wlan_ipa_priv *ipa_ctx)
qdf_list_peek_front(&ipa_ctx->pending_event,
(qdf_list_node_t **)&event);
while (event) {
ipa_info("PENDING EVENT[%d]: EVT:%s, MAC:%pM",
ipa_info("PENDING EVENT[%d]: EVT:%s, MAC:"QDF_MAC_ADDR_FMT,
i, wlan_ipa_wlan_event_to_str(event->type),
event->mac_addr);
QDF_MAC_ADDR_REF(event->mac_addr));
qdf_list_peek_next(&ipa_ctx->pending_event,
(qdf_list_node_t *)event,

8
components/mlme/core/src/wlan_mlme_main.c
View file

@ -133,7 +133,8 @@ QDF_STATUS mlme_get_peer_mic_len(struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
peer = wlan_objmgr_get_peer(psoc, pdev_id,
peer_mac, WLAN_LEGACY_MAC_ID);
if (!peer) {
mlme_legacy_debug("Peer of peer_mac %pM not found", peer_mac);
mlme_legacy_debug("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
QDF_MAC_ADDR_REF(peer_mac));
return QDF_STATUS_E_INVAL;
}
@ -150,8 +151,9 @@ QDF_STATUS mlme_get_peer_mic_len(struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
*mic_hdr_len = IEEE80211_CCMP_HEADERLEN;
*mic_len = IEEE80211_CCMP_MICLEN;
}
mlme_legacy_debug("peer %pM hdr_len %d mic_len %d key_cipher 0x%x",
peer_mac, *mic_hdr_len, *mic_len, key_cipher);
mlme_legacy_debug("peer "QDF_MAC_ADDR_FMT" hdr_len %d mic_len %d key_cipher 0x%x",
QDF_MAC_ADDR_REF(peer_mac),
*mic_hdr_len, *mic_len, key_cipher);
return QDF_STATUS_SUCCESS;
}

20
components/nan/core/src/nan_main.c
View file

@ -352,9 +352,9 @@ nan_increment_ndp_sessions(struct wlan_objmgr_psoc *psoc,
sizeof(struct nan_datapath_channel_info));
peer_nan_obj->active_ndp_sessions++;
nan_debug("Number of active session = %d for peer:"QDF_MAC_ADDR_STR"",
nan_debug("Number of active session = %d for peer:"QDF_MAC_ADDR_FMT,
peer_nan_obj->active_ndp_sessions,
QDF_MAC_ADDR_ARRAY(peer_ndi_mac->bytes));
QDF_MAC_ADDR_REF(peer_ndi_mac->bytes));
qdf_spin_unlock_bh(&peer_nan_obj->lock);
wlan_objmgr_peer_release_ref(peer, WLAN_NAN_ID);
@ -391,9 +391,9 @@ static QDF_STATUS nan_decrement_ndp_sessions(struct wlan_objmgr_psoc *psoc,
return QDF_STATUS_E_FAILURE;
}
peer_nan_obj->active_ndp_sessions--;
nan_debug("Number of active session = %d for peer:"QDF_MAC_ADDR_STR"",
nan_debug("Number of active session = %d for peer:"QDF_MAC_ADDR_FMT,
peer_nan_obj->active_ndp_sessions,
QDF_MAC_ADDR_ARRAY(peer_ndi_mac->bytes));
QDF_MAC_ADDR_REF(peer_ndi_mac->bytes));
qdf_spin_unlock_bh(&peer_nan_obj->lock);
wlan_objmgr_peer_release_ref(peer, WLAN_NAN_ID);
@ -434,8 +434,8 @@ ndi_remove_and_update_primary_connection(struct wlan_objmgr_psoc *psoc,
while (peer) {
peer_nan_obj = nan_get_peer_priv_obj(peer);
if (!peer_nan_obj)
nan_err("NAN peer object for Peer " QDF_MAC_ADDR_STR " is NULL",
QDF_MAC_ADDR_ARRAY(wlan_peer_get_macaddr(peer)));
nan_err("NAN peer object for Peer " QDF_MAC_ADDR_FMT " is NULL",
QDF_MAC_ADDR_REF(wlan_peer_get_macaddr(peer)));
else if (peer_nan_obj->active_ndp_sessions)
break;
@ -576,8 +576,8 @@ static QDF_STATUS nan_handle_confirm(struct nan_datapath_confirm_event *confirm)
* This peer was created at ndp_indication but
* confirm failed, so it needs to be deleted
*/
nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDR_STR" on vdev_id: %d",
QDF_MAC_ADDR_ARRAY(confirm->peer_ndi_mac_addr.bytes),
nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDR_FMT" on vdev_id: %d",
QDF_MAC_ADDR_REF(confirm->peer_ndi_mac_addr.bytes),
vdev_id);
psoc_nan_obj->cb_obj.delete_peers_by_addr(vdev_id,
confirm->peer_ndi_mac_addr);
@ -661,9 +661,9 @@ static QDF_STATUS nan_handle_ndp_ind(
}
nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr "
QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_FMT,
ndp_ind->role, vdev_id, ndp_ind->ncs_sk_type,
QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes));
QDF_MAC_ADDR_REF(ndp_ind->peer_mac_addr.bytes));
if ((ndp_ind->role == NAN_DATAPATH_ROLE_INITIATOR) ||
((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) &&

62
components/p2p/core/src/wlan_p2p_off_chan_tx.c
View file

@ -807,9 +807,9 @@ static QDF_STATUS p2p_tx_update_connection_status(
if (tx_frame_info->public_action_type !=
P2P_PUBLIC_ACTION_NOT_SUPPORT)
p2p_debug("%s ---> OTA to " QDF_MAC_ADDR_STR,
p2p_debug("%s ---> OTA to " QDF_MAC_ADDR_FMT,
p2p_get_frame_type_str(tx_frame_info),
QDF_MAC_ADDR_ARRAY(mac_to));
QDF_MAC_ADDR_REF(mac_to));
if ((tx_frame_info->public_action_type ==
P2P_PUBLIC_ACTION_PROV_DIS_REQ) &&
@ -851,9 +851,9 @@ static QDF_STATUS p2p_rx_update_connection_status(
if (rx_frame_info->public_action_type !=
P2P_PUBLIC_ACTION_NOT_SUPPORT)
p2p_info("%s <--- OTA from " QDF_MAC_ADDR_STR,
p2p_info("%s <--- OTA from " QDF_MAC_ADDR_FMT,
p2p_get_frame_type_str(rx_frame_info),
QDF_MAC_ADDR_ARRAY(mac_from));
QDF_MAC_ADDR_REF(mac_from));
if ((rx_frame_info->public_action_type ==
P2P_PUBLIC_ACTION_PROV_DIS_REQ) &&
@ -1560,8 +1560,8 @@ static QDF_STATUS p2p_populate_rmf_field(struct tx_action_context *tx_ctx,
if (!p2p_soc_obj->p2p_cb.is_mgmt_protected(
tx_ctx->vdev_id, wh->i_addr1)) {
p2p_debug("non rmf connection vdev %d "QDF_MAC_ADDR_STR,
tx_ctx->vdev_id, QDF_MAC_ADDR_ARRAY(wh->i_addr1));
p2p_debug("non rmf connection vdev %d "QDF_MAC_ADDR_FMT,
tx_ctx->vdev_id, QDF_MAC_ADDR_REF(wh->i_addr1));
return QDF_STATUS_SUCCESS;
}
if (!qdf_is_macaddr_group((struct qdf_mac_addr *)wh->i_addr1) &&
@ -1595,10 +1595,10 @@ static QDF_STATUS p2p_populate_rmf_field(struct tx_action_context *tx_ctx,
*size - sizeof(*wh));
rmf_wh = (struct wlan_frame_hdr *)frame;
(rmf_wh)->i_fc[1] |= IEEE80211_FC1_WEP;
p2p_debug("set protection 0x%x cat %d "QDF_MAC_ADDR_STR,
p2p_debug("set protection 0x%x cat %d "QDF_MAC_ADDR_FMT,
tx_ctx->frame_info.sub_type,
action_hdr->action_category,
QDF_MAC_ADDR_ARRAY(wh->i_addr1));
QDF_MAC_ADDR_REF(wh->i_addr1));
qdf_nbuf_free(*ppkt);
*ppbuf = frame;
@ -2095,8 +2095,8 @@ p2p_add_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
struct p2p_vdev_priv_obj *p2p_vdev_obj;
struct wlan_objmgr_vdev *vdev;
p2p_debug("random_mac:vdev %d mac_addr:%pM rnd_cookie=%llu freq = %u",
vdev_id, mac, rnd_cookie, freq);
p2p_debug("random_mac:vdev %d mac_addr:"QDF_MAC_ADDR_FMT" rnd_cookie=%llu freq = %u",
vdev_id, QDF_MAC_ADDR_REF(mac), rnd_cookie, freq);
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(soc, vdev_id, WLAN_P2P_ID);
if (!vdev) {
@ -2138,8 +2138,8 @@ p2p_add_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
rnd_cookie);
qdf_spin_unlock(&p2p_vdev_obj->random_mac_lock);
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
p2p_debug("random_mac:append %d vdev %d freq %d %pM rnd_cookie %llu",
append_ret, vdev_id, freq, mac, rnd_cookie);
p2p_debug("random_mac:append %d vdev %d freq %d "QDF_MAC_ADDR_FMT" rnd_cookie %llu",
append_ret, vdev_id, freq, QDF_MAC_ADDR_REF(mac), rnd_cookie);
if (!append_ret) {
p2p_debug("random_mac:failed to append rnd_cookie");
return QDF_STATUS_E_NOMEM;
@ -2174,8 +2174,8 @@ p2p_add_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
p2p_vdev_obj->random_mac[i].freq = freq;
qdf_spin_unlock(&p2p_vdev_obj->random_mac_lock);
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
p2p_debug("random_mac:add vdev %d freq %d %pM rnd_cookie %llu",
vdev_id, freq, mac, rnd_cookie);
p2p_debug("random_mac:add vdev %d freq %d "QDF_MAC_ADDR_FMT" rnd_cookie %llu",
vdev_id, freq, QDF_MAC_ADDR_REF(mac), rnd_cookie);
return QDF_STATUS_SUCCESS;
}
@ -2231,8 +2231,8 @@ p2p_del_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
qdf_mc_timer_start(&random_mac->clear_timer, duration);
qdf_spin_lock(&p2p_vdev_obj->random_mac_lock);
p2p_debug("random_mac:noref on vdev %d addr %pM",
vdev_id, random_mac->addr);
p2p_debug("random_mac:noref on vdev %d addr "QDF_MAC_ADDR_FMT,
vdev_id, QDF_MAC_ADDR_REF(random_mac->addr));
}
break;
}
@ -2282,8 +2282,8 @@ void p2p_del_all_rand_mac_vdev(struct wlan_objmgr_vdev *vdev)
qdf_mc_timer_stop(&p2p_vdev_obj->random_mac[i].clear_timer);
p2p_clear_mac_filter(wlan_vdev_get_psoc(vdev),
wlan_vdev_get_id(vdev), addr, freq);
p2p_debug("random_mac:delall vdev %d freq %d addr %pM",
wlan_vdev_get_id(vdev), freq, addr);
p2p_debug("random_mac:delall vdev %d freq %d addr "QDF_MAC_ADDR_FMT,
wlan_vdev_get_id(vdev), freq, QDF_MAC_ADDR_REF(addr));
qdf_spin_lock(&p2p_vdev_obj->random_mac_lock);
}
@ -2404,9 +2404,10 @@ QDF_STATUS p2p_process_set_rand_mac_rsp(struct p2p_mac_filter_rsp *resp)
return QDF_STATUS_E_INVAL;
}
p2p_debug("random_mac:get pending req on vdev %d set %d mac filter %pM freq %d",
p2p_debug("random_mac:get pending req on vdev %d set %d mac filter "QDF_MAC_ADDR_FMT" freq %d",
p2p_vdev_obj->pending_req.vdev_id,
p2p_vdev_obj->pending_req.set, p2p_vdev_obj->pending_req.mac,
p2p_vdev_obj->pending_req.set,
QDF_MAC_ADDR_REF(p2p_vdev_obj->pending_req.mac),
p2p_vdev_obj->pending_req.freq);
if (p2p_vdev_obj->pending_req.cb)
p2p_vdev_obj->pending_req.cb(
@ -2433,9 +2434,9 @@ p2p_process_set_rand_mac(struct p2p_set_mac_filter_req *set_filter_req)
p2p_debug("random_mac:set_filter_req is null");
return QDF_STATUS_E_INVAL;
}
p2p_debug("random_mac:vdev %d set %d mac filter %pM freq %d",
p2p_debug("random_mac:vdev %d set %d mac filter "QDF_MAC_ADDR_FMT" freq %d",
set_filter_req->vdev_id, set_filter_req->set,
set_filter_req->mac, set_filter_req->freq);
QDF_MAC_ADDR_REF(set_filter_req->mac), set_filter_req->freq);
soc = set_filter_req->soc;
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(
@ -2453,10 +2454,10 @@ p2p_process_set_rand_mac(struct p2p_set_mac_filter_req *set_filter_req)
goto get_p2p_obj_failed;
}
if (p2p_vdev_obj->pending_req.soc) {
p2p_debug("random_mac:Busy on vdev %d set %d mac filter %pM freq %d",
p2p_debug("random_mac:Busy on vdev %d set %d mac filter "QDF_MAC_ADDR_FMT" freq %d",
p2p_vdev_obj->pending_req.vdev_id,
p2p_vdev_obj->pending_req.set,
p2p_vdev_obj->pending_req.mac,
QDF_MAC_ADDR_REF(p2p_vdev_obj->pending_req.mac),
p2p_vdev_obj->pending_req.freq);
goto get_p2p_obj_failed;
}
@ -2513,8 +2514,8 @@ p2p_set_mac_filter(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
struct scheduler_msg msg = {0};
QDF_STATUS status;
p2p_debug("random_mac:vdev %d freq %d set %d %pM",
vdev_id, freq, set, mac);
p2p_debug("random_mac:vdev %d freq %d set %d "QDF_MAC_ADDR_FMT,
vdev_id, freq, set, QDF_MAC_ADDR_REF(mac));
set_filter_req = qdf_mem_malloc(sizeof(*set_filter_req));
if (!set_filter_req)
@ -2633,8 +2634,9 @@ p2p_set_rand_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
} else {
priv = osif_request_priv(request);
ret = priv->result;
p2p_debug("random_mac:vdev %d freq %d result %d %pM rnd_cookie %llu",
vdev_id, freq, priv->result, mac, rnd_cookie);
p2p_debug("random_mac:vdev %d freq %d result %d "QDF_MAC_ADDR_FMT" rnd_cookie %llu",
vdev_id, freq, priv->result,
QDF_MAC_ADDR_REF(mac), rnd_cookie);
}
}
osif_request_put(request);
@ -2751,8 +2753,8 @@ static void p2p_mac_clear_timeout(void *context)
qdf_spin_unlock(&p2p_vdev_obj->random_mac_lock);
vdev_id = wlan_vdev_get_id(p2p_vdev_obj->vdev);
p2p_debug("random_mac:clear timeout vdev %d %pM freq %d clr %d",
vdev_id, addr, freq, clear);
p2p_debug("random_mac:clear timeout vdev %d "QDF_MAC_ADDR_FMT" freq %d clr %d",
vdev_id, QDF_MAC_ADDR_REF(addr), freq, clear);
if (clear)
p2p_clear_mac_filter(wlan_vdev_get_psoc(p2p_vdev_obj->vdev),
vdev_id, addr, freq);

4
components/p2p/dispatcher/src/wlan_p2p_ucfg_api.c
View file

@ -586,8 +586,8 @@ QDF_STATUS ucfg_p2p_register_callbacks(struct wlan_objmgr_psoc *soc,
struct p2p_soc_priv_obj *p2p_soc_obj;
if (!soc || !cb_obj) {
p2p_err("psoc %pM cb_obj %pM context passed is NULL", soc,
cb_obj);
p2p_err("psoc: %pK or cb_obj: %pK context passed is NULL",
soc, cb_obj);
return QDF_STATUS_E_INVAL;
}

6
components/pmo/core/src/wlan_pmo_arp.c
View file

@ -49,9 +49,9 @@ static QDF_STATUS pmo_core_cache_arp_in_vdev_priv(
qdf_mem_copy(&request->bssid.bytes, &peer_bssid.bytes,
QDF_MAC_ADDR_SIZE);
pmo_debug("vdev self mac addr: %pM bss peer mac addr: %pM",
wlan_vdev_mlme_get_macaddr(vdev),
peer_bssid.bytes);
pmo_debug("vdev self mac addr: "QDF_MAC_ADDR_FMT" bss peer mac addr: "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(wlan_vdev_mlme_get_macaddr(vdev)),
QDF_MAC_ADDR_REF(peer_bssid.bytes));
request->enable = PMO_OFFLOAD_ENABLE;
request->is_offload_applied = false;

6
components/pmo/core/src/wlan_pmo_gtk.c
View file

@ -141,9 +141,9 @@ static QDF_STATUS pmo_core_is_gtk_enabled_in_fwr(
if (qdf_mem_cmp(&vdev_ctx->vdev_gtk_req.bssid,
&peer_bssid, QDF_MAC_ADDR_SIZE)) {
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
pmo_err("cache request mac:%pM, peer mac:%pM are not same",
vdev_ctx->vdev_gtk_req.bssid.bytes,
peer_bssid.bytes);
pmo_err("cache request mac:"QDF_MAC_ADDR_FMT", peer mac:"QDF_MAC_ADDR_FMT" are not same",
QDF_MAC_ADDR_REF(vdev_ctx->vdev_gtk_req.bssid.bytes),
QDF_MAC_ADDR_REF(peer_bssid.bytes));
return QDF_STATUS_E_INVAL;
}

7
components/pmo/core/src/wlan_pmo_mc_addr_filtering.c
View file

@ -57,8 +57,8 @@ static void pmo_core_fill_mc_list(struct pmo_vdev_priv_obj **vdev_ctx,
QDF_MAC_ADDR_SIZE)) ||
(addr_fp &&
(!qdf_mem_cmp(ip->mc_addr[i].bytes, &addr_fp, 1)))) {
pmo_debug("MC/BC filtering Skip addr %pM",
ip->mc_addr[i].bytes);
pmo_debug("MC/BC filtering Skip addr "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(ip->mc_addr[i].bytes));
qdf_spin_lock_bh(&temp_ctx->pmo_vdev_lock);
op_list->mc_cnt--;
qdf_spin_unlock_bh(&temp_ctx->pmo_vdev_lock);
@ -70,7 +70,8 @@ static void pmo_core_fill_mc_list(struct pmo_vdev_priv_obj **vdev_ctx,
qdf_mem_copy(&op_list->mc_addr[j].bytes,
ip->mc_addr[i].bytes, QDF_MAC_ADDR_SIZE);
qdf_spin_unlock_bh(&temp_ctx->pmo_vdev_lock);
pmo_debug("Index = %d, mac[%pM]", j, op_list->mc_addr[i].bytes);
pmo_debug("Index = %d, mac["QDF_MAC_ADDR_FMT"]", j,
QDF_MAC_ADDR_REF(op_list->mc_addr[i].bytes));
j++;
}
}

6
components/pmo/core/src/wlan_pmo_ns.c
View file

@ -98,9 +98,9 @@ static QDF_STATUS pmo_core_cache_ns_in_vdev_priv(
status = QDF_STATUS_E_INVAL;
goto out;
}
pmo_debug("vdev self mac addr: %pM bss peer mac addr: %pM",
wlan_vdev_mlme_get_macaddr(vdev),
wlan_peer_get_macaddr(peer));
pmo_debug("vdev self mac addr: "QDF_MAC_ADDR_FMT" bss peer mac addr: "QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(wlan_vdev_mlme_get_macaddr(vdev)),
QDF_MAC_ADDR_REF(wlan_peer_get_macaddr(peer)));
/* get peer and peer mac accdress aka ap mac address */
qdf_mem_copy(&request.bssid,
wlan_peer_get_macaddr(peer),

8
components/target_if/cp_stats/src/target_if_mc_cp_stats.c
View file

@ -199,8 +199,8 @@ static int target_if_twt_session_params_event_handler(ol_scn_t scn,
WLAN_CP_STATS_ID);
if (!peer_obj) {
target_if_err("peer obj not found for "
QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(twt_params.peer_mac));
QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(twt_params.peer_mac));
continue;
}
@ -213,8 +213,8 @@ static int target_if_twt_session_params_event_handler(ol_scn_t scn,
mc_cp_stats = target_if_obtain_mc_cp_stat_obj(peer_obj);
if (!mc_cp_stats) {
target_if_err("Unable to retrieve mc cp stats obj for "
QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(twt_params.peer_mac));
QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(twt_params.peer_mac));
wlan_objmgr_peer_release_ref(peer_obj,
WLAN_CP_STATS_ID);
continue;

6
components/target_if/interop_issues_ap/src/target_if_interop_issues_ap.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2019-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
@ -68,8 +68,8 @@ static int target_if_interop_issues_ap_event_handler(ol_scn_t sc,
if (ret)
return -EINVAL;
target_if_debug("interop issues ap macaddr: " QDF_MAC_ADDR_STR,
QDF_MAC_ADDR_ARRAY(data.rap_addr.bytes));
target_if_debug("interop issues ap macaddr: " QDF_MAC_ADDR_FMT,
QDF_MAC_ADDR_REF(data.rap_addr.bytes));
return tgt_interop_issues_ap_info_callback(psoc, &data);
}

10
components/target_if/pmo/src/target_if_pmo_lphb.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
@ -76,12 +76,12 @@ QDF_STATUS target_if_pmo_send_lphb_tcp_params(struct wlan_objmgr_psoc *psoc,
target_if_info("PMO --> WMI_HB_SET_TCP_PARAMS srv_ip=%08x, "
"dev_ip=%08x, src_port=%d, dst_port=%d, timeout=%d, "
"session=%d, gateway_mac= %pM, time_period_sec=%d,"
"session=%d, gateway_mac= "QDF_MAC_ADDR_FMT", time_period_sec=%d,"
"tcp_sn=%d", ts_lphb_tcp_param->srv_ip,
ts_lphb_tcp_param->dev_ip, ts_lphb_tcp_param->src_port,
ts_lphb_tcp_param->dst_port, ts_lphb_tcp_param->timeout,
ts_lphb_tcp_param->session,
ts_lphb_tcp_param->gateway_mac.bytes,
QDF_MAC_ADDR_REF(ts_lphb_tcp_param->gateway_mac.bytes),
ts_lphb_tcp_param->time_period_sec, ts_lphb_tcp_param->tcp_sn);
/* fill in values */
@ -158,12 +158,12 @@ QDF_STATUS target_if_pmo_send_lphb_udp_params(struct wlan_objmgr_psoc *psoc,
target_if_info("HB_SET_UDP_PARAMS srv_ip=%d, dev_ip=%d, src_port=%d, "
"dst_port=%d, interval=%d, timeout=%d, session=%d, "
"gateway_mac= %pM",
"gateway_mac= "QDF_MAC_ADDR_FMT,
ts_lphb_udp_param->srv_ip, ts_lphb_udp_param->dev_ip,
ts_lphb_udp_param->src_port, ts_lphb_udp_param->dst_port,
ts_lphb_udp_param->interval, ts_lphb_udp_param->timeout,
ts_lphb_udp_param->session,
ts_lphb_udp_param->gateway_mac.bytes);
QDF_MAC_ADDR_REF(ts_lphb_udp_param->gateway_mac.bytes));
/* fill in values */
hb_udp_params_fp.vdev_id = ts_lphb_udp_param->session;

7
components/wmi/src/wmi_unified_mc_cp_stats_tlv.c
View file

@ -288,8 +288,9 @@ send_request_peer_stats_info_cmd_tlv(wmi_unified_t wmi_handle,
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_mac_addr, &cmd->peer_macaddr);
cmd->reset_after_request = param->reset_after_request;
WMI_LOGD("PEER STATS REQ VDEV_ID:%d PEER:%pM TYPE:%d RESET:%d",
cmd->vdev_id, param->peer_mac_addr, cmd->request_type,
WMI_LOGD("PEER STATS REQ VDEV_ID:%d PEER:"QDF_MAC_ADDR_FMT" TYPE:%d RESET:%d",
cmd->vdev_id, QDF_MAC_ADDR_REF(param->peer_mac_addr),
cmd->request_type,
cmd->reset_after_request);
wmi_mtrace(WMI_REQUEST_PEER_STATS_INFO_CMDID, cmd->vdev_id, 0);
@ -340,7 +341,7 @@ static void dump_peer_stats_info(wmi_peer_stats_info *stats)
int i;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&stats->peer_macaddr, mac);
WMI_LOGD("mac %pM", mac);
WMI_LOGD("mac "QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(mac));
WMI_LOGD("tx_bytes %d %d tx_packets %d %d",
stats->tx_bytes.low_32,
stats->tx_bytes.high_32,