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

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

CRs-Fixed: 2752355
Change-Id: I2d776be789df3e83e0c13211844b66d595498829

components/blacklist_mgr/core/src/wlan_blm_core.c

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

components/cp_stats/dispatcher/src/wlan_cp_stats_mc_tgt_api.c

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

components/cp_stats/dispatcher/src/wlan_cp_stats_mc_ucfg_api.c

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

components/ipa/core/src/wlan_ipa_core.c

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

components/ipa/core/src/wlan_ipa_stats.c

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

components/mlme/core/src/wlan_mlme_main.c

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

components/nan/core/src/nan_main.c

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

components/p2p/core/src/wlan_p2p_off_chan_tx.c

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

components/p2p/dispatcher/src/wlan_p2p_ucfg_api.c

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

components/pmo/core/src/wlan_pmo_arp.c

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

components/pmo/core/src/wlan_pmo_gtk.c

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

components/pmo/core/src/wlan_pmo_mc_addr_filtering.c

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

components/pmo/core/src/wlan_pmo_ns.c

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

components/target_if/cp_stats/src/target_if_mc_cp_stats.c

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

components/target_if/interop_issues_ap/src/target_if_interop_issues_ap.c

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

components/target_if/pmo/src/target_if_pmo_lphb.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -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;

components/wmi/src/wmi_unified_mc_cp_stats_tlv.c

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