qcacld-3.0: wma: 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: Ifcae4ff3dd8b5303b65012f0bd96843d0ab0fde7

core/wma/src/wma_data.c

@@ -1223,8 +1223,8 @@ QDF_STATUS wma_process_rate_update_indicate(tp_wma_handle wma,
 	/* Get the vdev id */
 	if (wma_find_vdev_id_by_addr(wma, pRateUpdateParams->bssid.bytes,
 				     &vdev_id)) {
-		wma_err("vdev handle is invalid for %pM",
-			 pRateUpdateParams->bssid.bytes);
+		wma_err("vdev handle is invalid for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(pRateUpdateParams->bssid.bytes));
 		qdf_mem_free(pRateUpdateParams);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -1261,8 +1261,8 @@ QDF_STATUS wma_process_rate_update_indicate(tp_wma_handle wma,
 	wma_debug("dev_id = %d, dev_type = %d, dev_mode = %d,",
 		 vdev_id, intr[vdev_id].type,
 		 pRateUpdateParams->dev_mode);
-	wma_debug("mac = %pM, config.shortgi = %d, rate_flags = 0x%x",
-		 pRateUpdateParams->bssid.bytes,
+	wma_debug("mac = "QDF_MAC_ADDR_FMT", config.shortgi = %d, rate_flags = 0x%x",
+		 QDF_MAC_ADDR_REF(pRateUpdateParams->bssid.bytes),
 		 intr[vdev_id].config.shortgi, rate_flag);
 	ret = wma_encode_mc_rate(short_gi, intr[vdev_id].config.chwidth,
 				 intr[vdev_id].ch_freq, mbpsx10_rate,
@@ -2893,7 +2893,8 @@ void wma_tx_abort(uint8_t vdev_id)
 		return;
 	}
 
-	wma_debug("vdevid %d bssid %pM", vdev_id, bssid);
+	wma_debug("vdevid %d bssid "QDF_MAC_ADDR_FMT, vdev_id,
+		  QDF_MAC_ADDR_REF(bssid));
 	wma_vdev_set_pause_bit(vdev_id, PAUSE_TYPE_HOST);
 	cdp_fc_vdev_pause(cds_get_context(QDF_MODULE_ID_SOC), vdev_id,
 			  OL_TXQ_PAUSE_REASON_TX_ABORT, 0);
@@ -2967,7 +2968,8 @@ void wma_delete_invalid_peer_entries(uint8_t vdev_id, uint8_t *peer_mac_addr)
 			}
 		}
 		if (i == INVALID_PEER_MAX_NUM)
-			wma_debug("peer_mac_addr %pM is not found", peer_mac_addr);
+			wma_debug("peer_mac_addr "QDF_MAC_ADDR_FMT" is not found",
+				  QDF_MAC_ADDR_REF(peer_mac_addr));
 	} else {
 		qdf_mem_zero(iface->invalid_peers,
 			     sizeof(iface->invalid_peers));
@@ -3019,19 +3021,17 @@ uint8_t wma_rx_invalid_peer_ind(uint8_t vdev_id, void *wh)
 			(index + 1) % INVALID_PEER_MAX_NUM;
 
 		/* send deauth */
-		wma_debug("vdev_id %d", vdev_id);
-		wma_debug(" RA: " QDF_MAC_ADDR_STR,
-			  QDF_MAC_ADDR_ARRAY(rx_inv_msg->ra));
-		wma_debug(" TA: " QDF_MAC_ADDR_STR,
-			  QDF_MAC_ADDR_ARRAY(rx_inv_msg->ta));
+		wma_debug("vdev_id: %d RA: "QDF_MAC_ADDR_FMT" TA: "QDF_MAC_ADDR_FMT,
+			  vdev_id, QDF_MAC_ADDR_REF(rx_inv_msg->ra),
+			  QDF_MAC_ADDR_REF(rx_inv_msg->ta));
 
 		wma_send_msg(wma,
 			     SIR_LIM_RX_INVALID_PEER,
 			     (void *)rx_inv_msg, 0);
 	} else {
 		wma_debug_rl("Ignore invalid peer indication as received more than once "
-			QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(rx_inv_msg->ta));
+			QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(rx_inv_msg->ta));
 		qdf_mem_free(rx_inv_msg);
 	}
 
@@ -3055,8 +3055,8 @@ int wma_dp_send_delba_ind(uint8_t vdev_id, uint8_t *peer_macaddr,
 	qdf_mem_copy(req->peer_macaddr, peer_macaddr, QDF_MAC_ADDR_SIZE);
 	req->tid = tid;
 	req->reason_code = reason_code;
-	wma_debug("req delba_ind vdev %d %pM tid %d reason %d",
-		 vdev_id, peer_macaddr, tid, reason_code);
+	wma_debug("req delba_ind vdev %d "QDF_MAC_ADDR_FMT" tid %d reason %d",
+		 vdev_id, QDF_MAC_ADDR_REF(peer_macaddr), tid, reason_code);
 	wma_send_msg_high_priority(wma, SIR_HAL_REQ_SEND_DELBA_REQ_IND,
 				   (void *)req, 0);
 

core/wma/src/wma_dev_if.c

@@ -516,8 +516,8 @@ static QDF_STATUS wma_self_peer_remove(tp_wma_handle wma_handle,
 	struct wma_target_req *msg = NULL;
 	struct del_sta_self_rsp_params *sta_self_wmi_rsp;
 
-	wma_debug("P2P Device: removing self peer %pM",
-		  del_vdev_req->self_mac_addr);
+	wma_debug("P2P Device: removing self peer "QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(del_vdev_req->self_mac_addr));
 
 	qdf_status = wma_remove_peer(wma_handle, del_vdev_req->self_mac_addr,
 				     vdev_id);
@@ -587,7 +587,8 @@ static void wma_remove_objmgr_peer(tp_wma_handle wma,
 		/* Unref to decrement ref happened in find_peer */
 		wlan_objmgr_peer_release_ref(obj_peer, WLAN_LEGACY_WMA_ID);
 	} else {
-		wma_nofl_err("Peer %pM not found", peer_addr);
+		wma_nofl_err("Peer "QDF_MAC_ADDR_FMT" not found",
+			 QDF_MAC_ADDR_REF(peer_addr));
 	}
 
 }
@@ -924,9 +925,9 @@ static void wma_peer_send_phymode(struct wlan_objmgr_vdev *vdev,
 				       IS_WLAN_PHYMODE_HE(old_peer_phymode));
 
 	if (new_phymode == old_peer_phymode) {
-		wma_debug("Ignore update as old %d and new %d phymode are same for mac "QDF_MAC_ADDR_STR,
+		wma_debug("Ignore update as old %d and new %d phymode are same for mac "QDF_MAC_ADDR_FMT,
 			  old_peer_phymode, new_phymode,
-			  QDF_MAC_ADDR_ARRAY(peer_mac_addr));
+			  QDF_MAC_ADDR_REF(peer_mac_addr));
 		return;
 	}
 	wlan_peer_set_phymode(peer, new_phymode);
@@ -942,9 +943,9 @@ static void wma_peer_send_phymode(struct wlan_objmgr_vdev *vdev,
 	wma_set_peer_param(wma, peer_mac_addr, WMI_PEER_CHWIDTH,
 			   max_ch_width_supported, vdev_id);
 
-	wma_debug("FW phymode %d old phymode %d new phymode %d bw %d macaddr "QDF_MAC_ADDR_STR,
+	wma_debug("FW phymode %d old phymode %d new phymode %d bw %d macaddr "QDF_MAC_ADDR_FMT,
 		  fw_phymode, old_peer_phymode, new_phymode,
-		  max_ch_width_supported, QDF_MAC_ADDR_ARRAY(peer_mac_addr));
+		  max_ch_width_supported, QDF_MAC_ADDR_REF(peer_mac_addr));
 }
 
 static
@@ -1498,8 +1499,8 @@ QDF_STATUS wma_remove_peer(tp_wma_handle wma, uint8_t *mac_addr,
 	bool roam_synch_in_progress = false;
 
 	if (!wma->interfaces[vdev_id].peer_count) {
-		wma_err("Can't remove peer with peer_addr %pM vdevid %d peer_count %d",
-			peer_addr, vdev_id,
+		wma_err("Can't remove peer with peer_addr "QDF_MAC_ADDR_FMT" vdevid %d peer_count %d",
+			QDF_MAC_ADDR_REF(peer_addr), vdev_id,
 			wma->interfaces[vdev_id].peer_count);
 		QDF_ASSERT(0);
 		return QDF_STATUS_E_INVAL;
@@ -1512,15 +1513,15 @@ QDF_STATUS wma_remove_peer(tp_wma_handle wma, uint8_t *mac_addr,
 	}
 
 	if (!wma_objmgr_peer_exist(wma, peer_addr, &peer_vdev_id)) {
-		wma_err("peer doesn't exist peer_addr %pM vdevid %d peer_count %d",
-			 peer_addr, vdev_id,
+		wma_err("peer doesn't exist peer_addr "QDF_MAC_ADDR_FMT" vdevid %d peer_count %d",
+			 QDF_MAC_ADDR_REF(peer_addr), vdev_id,
 			 wma->interfaces[vdev_id].peer_count);
 		return QDF_STATUS_E_INVAL;
 	}
 
 	if (peer_vdev_id != vdev_id) {
-		wma_err("peer %pM is on vdev id %d but delete req on vdevid %d peer_count %d",
-			 peer_addr, peer_vdev_id, vdev_id,
+		wma_err("peer "QDF_MAC_ADDR_FMT" is on vdev id %d but delete req on vdevid %d peer_count %d",
+			 QDF_MAC_ADDR_REF(peer_addr), peer_vdev_id, vdev_id,
 			 wma->interfaces[vdev_id].peer_count);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -1558,16 +1559,16 @@ QDF_STATUS wma_remove_peer(tp_wma_handle wma, uint8_t *mac_addr,
 	}
 
 peer_detach:
-	wma_debug("vdevid %d is detaching with peer_addr %pM peer_count %d",
-		vdev_id, peer_addr,
+	wma_debug("vdevid %d is detaching with peer_addr "QDF_MAC_ADDR_FMT" peer_count %d",
+		vdev_id, QDF_MAC_ADDR_REF(peer_addr),
 		wma->interfaces[vdev_id].peer_count);
 	/* Copy peer mac to find and delete objmgr peer */
 	qdf_mem_copy(peer_mac, peer_addr, QDF_MAC_ADDR_SIZE);
 	if (roam_synch_in_progress &&
 	    is_cdp_peer_detach_force_delete_supported(soc)) {
 		if (!peer_unmap_conf_support_enabled) {
-			wma_debug("LFR3: trigger force delete for peer %pM",
-				 peer_addr);
+			wma_debug("LFR3: trigger force delete for peer "QDF_MAC_ADDR_FMT,
+				 QDF_MAC_ADDR_REF(peer_addr));
 			cdp_peer_detach_force_delete(soc, vdev_id, peer_addr);
 		} else {
 			cdp_peer_delete_sync(soc, vdev_id, peer_addr,
@@ -1576,7 +1577,8 @@ peer_detach:
 		}
 	} else {
 		if (roam_synch_in_progress)
-			wma_debug("LFR3: Delete the peer %pM", peer_addr);
+			wma_debug("LFR3: Delete the peer "QDF_MAC_ADDR_FMT,
+				  QDF_MAC_ADDR_REF(peer_addr));
 
 		if (peer_unmap_conf_support_enabled)
 			cdp_peer_delete_sync(soc, vdev_id, peer_addr,
@@ -1671,8 +1673,8 @@ static struct wlan_objmgr_peer *wma_create_objmgr_peer(tp_wma_handle wma,
 	 * adding this peer.
 	 */
 	if (wma_objmgr_peer_exist(wma, peer_addr, &peer_vdev_id)) {
-		wma_info("Peer %pM already exist on vdev %d, current vdev %d",
-			  peer_addr, peer_vdev_id, vdev_id);
+		wma_info("Peer "QDF_MAC_ADDR_FMT" already exist on vdev %d, current vdev %d",
+			  QDF_MAC_ADDR_REF(peer_addr), peer_vdev_id, vdev_id);
 		return NULL;
 	}
 
@@ -1763,7 +1765,8 @@ QDF_STATUS wma_create_peer(tp_wma_handle wma,
 	 */
 	status = cdp_peer_create(dp_soc, vdev_id, peer_addr);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		wma_err("Unable to attach peer %pM", peer_addr);
+		wma_err("Unable to attach peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(peer_addr));
 		wlan_objmgr_peer_obj_delete(obj_peer);
 		goto err;
 	}
@@ -1772,8 +1775,8 @@ QDF_STATUS wma_create_peer(tp_wma_handle wma,
 		cdp_peer_set_peer_as_tdls(dp_soc, vdev_id, peer_addr, true);
 
 	if (MLME_IS_ROAM_SYNCH_IN_PROGRESS(wma->psoc, vdev_id)) {
-		wma_debug("LFR3: Created peer %pM vdev_id %d, peer_count %d",
-			 peer_addr, vdev_id,
+		wma_debug("LFR3: Created peer "QDF_MAC_ADDR_FMT" vdev_id %d, peer_count %d",
+			 QDF_MAC_ADDR_REF(peer_addr), vdev_id,
 			 wma->interfaces[vdev_id].peer_count);
 		cdp_peer_setup(dp_soc, vdev_id, peer_addr);
 		return QDF_STATUS_SUCCESS;
@@ -1797,8 +1800,8 @@ QDF_STATUS wma_create_peer(tp_wma_handle wma,
 		goto err;
 	}
 
-	wma_debug("Created peer peer_addr %pM vdev_id %d, peer_count - %d",
-		  peer_addr, vdev_id,
+	wma_debug("Created peer peer_addr "QDF_MAC_ADDR_FMT" vdev_id %d, peer_count - %d",
+		  QDF_MAC_ADDR_REF(peer_addr), vdev_id,
 		  wma->interfaces[vdev_id].peer_count);
 
 	wlan_roam_debug_log(vdev_id, DEBUG_PEER_CREATE_SEND,
@@ -2141,20 +2144,22 @@ __wma_handle_vdev_stop_rsp(struct vdev_stop_response *resp_event)
 		peer_exist = cdp_find_peer_exist(soc, OL_TXRX_PDEV_ID,
 						 bssid.bytes);
 		if (!peer_exist) {
-			wma_err("Failed to find peer %pM", bssid.bytes);
+			wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(bssid.bytes));
 			status = QDF_STATUS_E_FAILURE;
 			goto free_params;
 		}
 
 		if (!iface->peer_count) {
-			wma_err("Can't remove peer with peer_addr %pM vdevid %d peer_count %d",
-				bssid.bytes, resp_event->vdev_id,
+			wma_err("Can't remove peer with peer_addr "QDF_MAC_ADDR_FMT" vdevid %d peer_count %d",
+				QDF_MAC_ADDR_REF(bssid.bytes),
+				resp_event->vdev_id,
 				 iface->peer_count);
 			goto free_params;
 		}
 
-		wma_debug("peer_addr %pM to vdev_id %d, peer_count - %d",
-			 bssid.bytes,
+		wma_debug("peer_addr "QDF_MAC_ADDR_FMT" to vdev_id %d, peer_count - %d",
+			  QDF_MAC_ADDR_REF(bssid.bytes),
 			 resp_event->vdev_id, iface->peer_count);
 		if (cdp_cfg_get_peer_unmap_conf_support(soc))
 			cdp_peer_delete_sync(soc, resp_event->vdev_id,
@@ -2169,8 +2174,8 @@ __wma_handle_vdev_stop_rsp(struct vdev_stop_response *resp_event)
 				       bssid.bytes);
 		iface->peer_count--;
 
-		wma_info("Removed peer %pM vdev_id %d, peer_count %d",
-			 bssid.bytes,
+		wma_info("Removed peer "QDF_MAC_ADDR_FMT" vdev_id %d, peer_count %d",
+			 QDF_MAC_ADDR_REF(bssid.bytes),
 			 resp_event->vdev_id, iface->peer_count);
 		vdev_stop_resp->status = status;
 		vdev_stop_resp->vdev_id = resp_event->vdev_id;
@@ -2784,8 +2789,8 @@ int wma_peer_assoc_conf_handler(void *handle, uint8_t *cmd_param_info,
 	}
 
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, macaddr);
-	wma_debug("peer assoc conf for vdev:%d mac=%pM",
-		 event->vdev_id, macaddr);
+	wma_debug("peer assoc conf for vdev:%d mac="QDF_MAC_ADDR_FMT,
+		 event->vdev_id, QDF_MAC_ADDR_REF(macaddr));
 
 	req_msg = wma_find_req(wma, event->vdev_id,
 				    WMA_PEER_ASSOC_CNF_START);
@@ -2810,9 +2815,9 @@ int wma_peer_assoc_conf_handler(void *handle, uint8_t *cmd_param_info,
 
 		/* peer assoc conf event means the cmd succeeds */
 		params->status = event->status;
-		wma_debug("Send ADD_STA_RSP: statype %d vdev_id %d aid %d bssid %pM status %d",
+		wma_debug("Send ADD_STA_RSP: statype %d vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT" status %d",
 			 params->staType, params->smesessionId,
-			 params->assocId, params->bssId,
+			 params->assocId, QDF_MAC_ADDR_REF(params->bssId),
 			 params->status);
 		wma_send_msg_high_priority(wma, WMA_ADD_STA_RSP,
 					   (void *)params, 0);
@@ -2861,8 +2866,8 @@ int wma_peer_delete_handler(void *handle, uint8_t *cmd_param_info,
 	}
 
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, macaddr);
-	wma_debug("Peer Delete Response, vdev %d Peer %pM",
-			event->vdev_id, macaddr);
+	wma_debug("Peer Delete Response, vdev %d Peer "QDF_MAC_ADDR_FMT,
+			event->vdev_id, QDF_MAC_ADDR_REF(macaddr));
 	wlan_roam_debug_log(event->vdev_id, DEBUG_PEER_DELETE_RESP,
 			    DEBUG_INVALID_PEER_ID, macaddr, NULL, 0, 0);
 	req_msg = wma_find_remove_req_msgtype(wma, event->vdev_id,
@@ -2965,8 +2970,8 @@ void wma_hold_req_timer(void *data)
 
 		params->status = QDF_STATUS_E_TIMEOUT;
 		wma_alert("WMA_ADD_STA_REQ timed out");
-		wma_debug("Sending add sta rsp to umac (mac:%pM, status:%d)",
-			 params->staMac, params->status);
+		wma_debug("Sending add sta rsp to umac (mac:"QDF_MAC_ADDR_FMT", status:%d)",
+			 QDF_MAC_ADDR_REF(params->staMac), params->status);
 		if (wma_crash_on_fw_timeout(wma->fw_timeout_crash))
 			wma_trigger_recovery_assert_on_fw_timeout(
 				WMA_ADD_STA_REQ,
@@ -2992,8 +2997,8 @@ void wma_hold_req_timer(void *data)
 				(tpDeleteStaParams) tgt_req->user_data;
 		params->status = QDF_STATUS_E_TIMEOUT;
 		wma_err("WMA_DEL_STA_REQ timed out");
-		wma_debug("Sending del sta rsp to umac (mac:%pM, status:%d)",
-			 params->staMac, params->status);
+		wma_debug("Sending del sta rsp to umac (mac:"QDF_MAC_ADDR_FMT", status:%d)",
+			 QDF_MAC_ADDR_REF(params->staMac), params->status);
 
 		if (wma_crash_on_fw_timeout(wma->fw_timeout_crash))
 			wma_trigger_recovery_assert_on_fw_timeout(
@@ -3260,12 +3265,14 @@ wma_set_peer_pmf_status(tp_wma_handle wma, uint8_t *peer_mac,
 				    wlan_objmgr_pdev_get_pdev_id(wma->pdev),
 				    peer_mac, WLAN_LEGACY_WMA_ID);
 	if (!peer) {
-		wma_err("Peer of peer_mac %pM not found", peer_mac);
+		wma_err("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			QDF_MAC_ADDR_REF(peer_mac));
 		return QDF_STATUS_E_INVAL;
 	}
 	mlme_set_peer_pmf_status(peer, is_pmf_enabled);
 	wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_WMA_ID);
-	wma_debug("set is_pmf_enabled %d for %pM", is_pmf_enabled, peer_mac);
+	wma_debug("set is_pmf_enabled %d for "QDF_MAC_ADDR_FMT,
+		  is_pmf_enabled, QDF_MAC_ADDR_REF(peer_mac));
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -3323,7 +3330,8 @@ QDF_STATUS wma_pre_vdev_start_setup(uint8_t vdev_id,
 	}
 
 	if (!cdp_find_peer_exist(soc, OL_TXRX_PDEV_ID, mac_addr)) {
-		wma_err("Failed to find peer %pM", mac_addr);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(mac_addr));
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -3460,8 +3468,9 @@ QDF_STATUS wma_save_bss_params(tp_wma_handle wma, struct bss_params *add_bss)
 	qdf_mem_copy(add_bss->staContext.staMac, add_bss->bssId,
 		     sizeof(add_bss->staContext.staMac));
 
-	wma_debug("update_bss %d nw_type %d bssid %pM status %d",
-		 add_bss->updateBss, add_bss->nwType, add_bss->bssId,
+	wma_debug("update_bss %d nw_type %d bssid "QDF_MAC_ADDR_FMT" status %d",
+		 add_bss->updateBss, add_bss->nwType,
+		 QDF_MAC_ADDR_REF(add_bss->bssId),
 		 status);
 
 	return status;
@@ -3496,10 +3505,12 @@ void wma_add_bss_lfr3(tp_wma_handle wma, struct bss_params *add_bss)
 		return;
 
 	if (!wma_cdp_find_peer_by_addr(add_bss->bssId)) {
-		wma_err("Failed to find peer %pM", add_bss->bssId);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(add_bss->bssId));
 		return;
 	}
-	wma_debug("LFR3: bssid %pM", add_bss->bssId);
+	wma_debug("LFR3: bssid "QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(add_bss->bssId));
 }
 
 
@@ -3565,8 +3576,8 @@ QDF_STATUS wma_add_bss_lfr2_vdev_start(struct wlan_objmgr_vdev *vdev,
 
 	peer_exist = wma_cdp_find_peer_by_addr(mlme_obj->mgmt.generic.bssid);
 	if (!peer_exist) {
-		wma_err("Failed to find peer %pM",
-			mlme_obj->mgmt.generic.bssid);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mlme_obj->mgmt.generic.bssid));
 		goto send_fail_resp;
 	}
 
@@ -3636,20 +3647,21 @@ QDF_STATUS wma_send_peer_assoc_req(struct bss_params *add_bss)
 		goto send_resp;
 
 	if (!peer_exist) {
-		wma_err("Failed to find peer %pM", add_bss->bssId);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(add_bss->bssId));
 		status = QDF_STATUS_E_FAILURE;
 		goto send_resp;
 	}
 
 
 	if (add_bss->staContext.encryptType == eSIR_ED_NONE) {
-		wma_debug("Update peer(%pM) state into auth",
-			 add_bss->bssId);
+		wma_debug("Update peer("QDF_MAC_ADDR_FMT") state into auth",
+			 QDF_MAC_ADDR_REF(add_bss->bssId));
 		cdp_peer_state_update(soc, add_bss->bssId,
 				      OL_TXRX_PEER_STATE_AUTH);
 	} else {
-		wma_debug("Update peer(%pM) state into conn",
-			 add_bss->bssId);
+		wma_debug("Update peer("QDF_MAC_ADDR_FMT") state into conn",
+			 QDF_MAC_ADDR_REF(add_bss->bssId));
 		cdp_peer_state_update(soc, add_bss->bssId,
 				      OL_TXRX_PEER_STATE_CONN);
 		status = wma_set_cdp_vdev_pause_reason(wma, vdev_id);
@@ -3774,8 +3786,8 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	if (cdp_find_peer_exist_on_vdev(soc, add_sta->smesessionId,
 					add_sta->staMac)) {
 		wma_remove_peer(wma, add_sta->staMac, add_sta->smesessionId);
-		wma_err("Peer already exists, Deleted peer with peer_addr %pM",
-			add_sta->staMac);
+		wma_err("Peer already exists, Deleted peer with peer_addr "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(add_sta->staMac));
 	}
 	/* The code above only checks the peer existence on its own vdev.
 	 * Need to check whether the peer exists on other vDevs because firmware
@@ -3784,8 +3796,9 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	 * here.
 	 */
 	if (cdp_find_peer_exist(soc, pdev_id, add_sta->staMac)) {
-		wma_err("My vdev id %d, but Peer exists on other vdev with peer_addr %pM",
-			 add_sta->smesessionId, add_sta->staMac);
+		wma_err("My vdev id %d, but Peer exists on other vdev with peer_addr "QDF_MAC_ADDR_FMT,
+			 add_sta->smesessionId,
+			 QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = QDF_STATUS_E_FAILURE;
 		goto send_rsp;
 	}
@@ -3795,15 +3808,16 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	status = wma_create_peer(wma, add_sta->staMac, WMI_PEER_TYPE_DEFAULT,
 				 add_sta->smesessionId);
 	if (status != QDF_STATUS_SUCCESS) {
-		wma_err("Failed to create peer for %pM", add_sta->staMac);
+		wma_err("Failed to create peer for "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = status;
 		goto send_rsp;
 	}
 
 	if (!cdp_find_peer_exist_on_vdev(soc, add_sta->smesessionId,
 					 add_sta->staMac)) {
-		wma_err("Failed to find peer handle using peer mac %pM",
-			add_sta->staMac);
+		wma_err("Failed to find peer handle using peer mac "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = QDF_STATUS_E_FAILURE;
 		wma_remove_peer(wma, add_sta->staMac, add_sta->smesessionId);
 		goto send_rsp;
@@ -3884,8 +3898,8 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 					    add_sta->staMac,
 					    add_sta->uAPSD, add_sta->maxSPLen);
 		if (QDF_IS_STATUS_ERROR(status)) {
-			wma_err("Failed to set peer uapsd param for %pM",
-				add_sta->staMac);
+			wma_err("Failed to set peer uapsd param for "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(add_sta->staMac));
 			add_sta->status = QDF_STATUS_E_FAILURE;
 			wma_remove_peer(wma, add_sta->staMac,
 					add_sta->smesessionId);
@@ -3893,8 +3907,8 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 		}
 	}
 
-	wma_debug("Moving peer %pM to state %d",
-		 add_sta->staMac, state);
+	wma_debug("Moving peer "QDF_MAC_ADDR_FMT" to state %d",
+		  QDF_MAC_ADDR_REF(add_sta->staMac), state);
 	cdp_peer_state_update(soc, add_sta->staMac, state);
 
 	add_sta->nss    = iface->nss;
@@ -3906,9 +3920,9 @@ send_rsp:
 		return;
 	}
 
-	wma_debug("statype %d vdev_id %d aid %d bssid %pM status %d",
+	wma_debug("statype %d vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT" status %d",
 		 add_sta->staType, add_sta->smesessionId,
-		 add_sta->assocId, add_sta->bssId,
+		 add_sta->assocId, QDF_MAC_ADDR_REF(add_sta->bssId),
 		 add_sta->status);
 	wma_send_msg_high_priority(wma, WMA_ADD_STA_RSP, (void *)add_sta, 0);
 }
@@ -3932,9 +3946,10 @@ static void wma_add_tdls_sta(tp_wma_handle wma, tpAddStaParams add_sta)
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	uint8_t pdev_id = OL_TXRX_PDEV_ID;
 
-	wma_debug("staType: %d, updateSta: %d, bssId: %pM, staMac: %pM",
+	wma_debug("staType: %d, updateSta: %d, bssId: "QDF_MAC_ADDR_FMT", staMac: "QDF_MAC_ADDR_FMT,
 		 add_sta->staType,
-		 add_sta->updateSta, add_sta->bssId, add_sta->staMac);
+		 add_sta->updateSta, QDF_MAC_ADDR_REF(add_sta->bssId),
+		 QDF_MAC_ADDR_REF(add_sta->staMac));
 
 	if (MLME_IS_ROAM_SYNCH_IN_PROGRESS(wma->psoc, add_sta->smesessionId) ||
 	    wma_is_roam_in_progress(add_sta->smesessionId)) {
@@ -3949,20 +3964,22 @@ static void wma_add_tdls_sta(tp_wma_handle wma, tpAddStaParams add_sta)
 		cdp_peer_copy_mac_addr_raw(soc, add_sta->smesessionId,
 					   add_sta->bssId);
 
-		wma_debug("addSta, calling wma_create_peer for %pM, vdev_id %hu",
-			add_sta->staMac, add_sta->smesessionId);
+		wma_debug("addSta, calling wma_create_peer for "QDF_MAC_ADDR_FMT", vdev_id %hu",
+			  QDF_MAC_ADDR_REF(add_sta->staMac),
+			  add_sta->smesessionId);
 
 		status = wma_create_peer(wma, add_sta->staMac,
 					 WMI_PEER_TYPE_TDLS,
 					 add_sta->smesessionId);
 		if (status != QDF_STATUS_SUCCESS) {
-			wma_err("Failed to create peer for %pM", add_sta->staMac);
+			wma_err("Failed to create peer for "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(add_sta->staMac));
 			add_sta->status = status;
 			goto send_rsp;
 		}
 
-		wma_debug("addSta, after calling cdp_local_peer_id, staMac: %pM",
-			 add_sta->staMac);
+		wma_debug("addSta, after calling cdp_local_peer_id, staMac: "QDF_MAC_ADDR_FMT,
+			  QDF_MAC_ADDR_REF(add_sta->staMac));
 
 		peer_state = qdf_mem_malloc(sizeof(*peer_state));
 	if (!peer_state) {
@@ -4023,9 +4040,9 @@ send_rsp:
 	if (peer_assoc_cnf)
 		return;
 
-	wma_debug("statype %d vdev_id %d aid %d bssid %pM status %d",
+	wma_debug("statype %d vdev_id %d aid %d bssid "QDF_MAC_ADDR_FMT" status %d",
 		 add_sta->staType, add_sta->smesessionId,
-		 add_sta->assocId, add_sta->bssId,
+		 add_sta->assocId, QDF_MAC_ADDR_REF(add_sta->bssId),
 		 add_sta->status);
 	wma_send_msg_high_priority(wma, WMA_ADD_STA_RSP, (void *)add_sta, 0);
 }
@@ -4109,8 +4126,9 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 	}
 
 	if (wma_is_vdev_up(params->smesessionId)) {
-		wma_debug("vdev id %d is already UP for %pM",
-			 params->smesessionId, params->bssId);
+		wma_debug("vdev id %d is already UP for "QDF_MAC_ADDR_FMT,
+			 params->smesessionId,
+			 QDF_MAC_ADDR_REF(params->bssId));
 		status = QDF_STATUS_E_FAILURE;
 		goto out;
 	}
@@ -4125,13 +4143,13 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 
 		/* Update peer state */
 		if (params->encryptType == eSIR_ED_NONE) {
-			wma_debug("Update peer(%pM) state into auth",
-				 params->bssId);
+			wma_debug("Update peer("QDF_MAC_ADDR_FMT") state into auth",
+				  QDF_MAC_ADDR_REF(params->bssId));
 			cdp_peer_state_update(soc, params->bssId,
 					      OL_TXRX_PEER_STATE_AUTH);
 		} else {
-			wma_debug("Update peer(%pM) state into conn",
-				 params->bssId);
+			wma_debug("Update peer("QDF_MAC_ADDR_FMT") state into conn",
+				  QDF_MAC_ADDR_REF(params->bssId));
 			cdp_peer_state_update(soc, params->bssId,
 					      OL_TXRX_PEER_STATE_CONN);
 		}
@@ -4149,9 +4167,10 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 			qdf_atomic_set(&iface->bss_status,
 				       WMA_BSS_STATUS_STARTED);
 			iface->aid = params->assocId;
-			wma_debug("LFR3:statype %d vdev %d aid %d bssid %pM",
+			wma_debug("LFR3:statype %d vdev %d aid %d bssid "QDF_MAC_ADDR_FMT,
 					params->staType, params->smesessionId,
-					params->assocId, params->bssId);
+					params->assocId,
+					QDF_MAC_ADDR_REF(params->bssId));
 			return;
 		}
 		wmi_unified_send_txbf(wma, params);
@@ -4298,9 +4317,9 @@ out:
 		return;
 
 	params->status = status;
-	wma_debug("vdev_id %d aid %d sta mac " QDF_MAC_ADDR_STR " status %d",
+	wma_debug("vdev_id %d aid %d sta mac " QDF_MAC_ADDR_FMT " status %d",
 		  params->smesessionId, params->assocId,
-		  QDF_MAC_ADDR_ARRAY(params->bssId), params->status);
+		  QDF_MAC_ADDR_REF(params->bssId), params->status);
 	/* Don't send a response during roam sync operation */
 	if (!MLME_IS_ROAM_SYNCH_IN_PROGRESS(wma->psoc, params->smesessionId))
 		wma_send_msg_high_priority(wma, WMA_ADD_STA_RSP,
@@ -4385,8 +4404,8 @@ static void wma_del_tdls_sta(tp_wma_handle wma, tpDeleteStaParams del_sta)
 	qdf_mem_copy(&peer_state->peer_macaddr,
 		     &del_sta->staMac, sizeof(tSirMacAddr));
 
-	wma_debug("sending tdls_peer_state for peer mac: %pM, peerState: %d",
-		 peer_state->peer_macaddr,
+	wma_debug("sending tdls_peer_state for peer mac: "QDF_MAC_ADDR_FMT", peerState: %d",
+		  QDF_MAC_ADDR_REF(peer_state->peer_macaddr),
 		 peer_state->peer_state);
 
 	status = wma_update_tdls_peer_state(wma, peer_state);
@@ -4483,7 +4502,8 @@ void wma_add_sta(tp_wma_handle wma, tpAddStaParams add_sta)
 		return;
 	}
 
-	wma_debug("Vdev %d BSSID %pM", add_sta->smesessionId, add_sta->bssId);
+	wma_debug("Vdev %d BSSID "QDF_MAC_ADDR_FMT, add_sta->smesessionId,
+		  QDF_MAC_ADDR_REF(add_sta->bssId));
 
 	if (wma_is_vdev_in_ap_mode(wma, add_sta->smesessionId))
 		oper_mode = BSS_OPERATIONAL_MODE_AP;
@@ -4737,7 +4757,8 @@ void wma_delete_bss(tp_wma_handle wma, uint8_t vdev_id)
 	else
 		peer_exist = wma_cdp_find_peer_by_addr(bssid.bytes);
 	if (!peer_exist) {
-		wma_err("Failed to find peer %pM", bssid.bytes);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(bssid.bytes));
 		status = QDF_STATUS_E_FAILURE;
 		goto out;
 	}
@@ -4813,7 +4834,8 @@ void wma_delete_bss(tp_wma_handle wma, uint8_t vdev_id)
 		qdf_atomic_set(&iface->bss_status, WMA_BSS_STATUS_STOPPED);
 		goto detach_peer;
 	}
-	wma_debug("bssid %pM vdev_id %d", bssid.bytes, vdev_id);
+	wma_debug("bssid "QDF_MAC_ADDR_FMT" vdev_id %d",
+		  QDF_MAC_ADDR_REF(bssid.bytes), vdev_id);
 
 	return;
 

core/wma/src/wma_features.c

@@ -259,8 +259,8 @@ void wma_get_rx_retry_cnt(struct mac_context *mac, uint8_t vdev_id,
 	}
 
 	mac->rx_retry_cnt = peer_stats->rx.rx_retries;
-	wma_debug("Rx retry count %d, Peer" QDF_MAC_ADDR_STR, mac->rx_retry_cnt,
-		  QDF_MAC_ADDR_ARRAY(mac_addr));
+	wma_debug("Rx retry count %d, Peer" QDF_MAC_ADDR_FMT, mac->rx_retry_cnt,
+		  QDF_MAC_ADDR_REF(mac_addr));
 
 exit:
 	qdf_mem_free(peer_stats);
@@ -534,11 +534,11 @@ QDF_STATUS wma_process_dhcp_ind(WMA_HANDLE handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	wma_debug("WMA --> WMI_PEER_SET_PARAM triggered by DHCP, msgType=%s, device_mode=%d, macAddr=" QDF_MAC_ADDR_STR,
+	wma_debug("WMA --> WMI_PEER_SET_PARAM triggered by DHCP, msgType=%s, device_mode=%d, macAddr=" QDF_MAC_ADDR_FMT,
 		ta_dhcp_ind->msgType == WMA_DHCP_START_IND ?
 		"WMA_DHCP_START_IND" : "WMA_DHCP_STOP_IND",
 		ta_dhcp_ind->device_mode,
-		QDF_MAC_ADDR_ARRAY(ta_dhcp_ind->peerMacAddr.bytes));
+		QDF_MAC_ADDR_REF(ta_dhcp_ind->peerMacAddr.bytes));
 
 	/* fill in values */
 	peer_set_param_fp.vdev_id = vdev_id;
@@ -711,8 +711,8 @@ QDF_STATUS wma_get_link_speed(WMA_HANDLE handle,
 	/* Copy the peer macaddress to the wma buffer */
 	WMI_CHAR_ARRAY_TO_MAC_ADDR(pLinkSpeed->peer_macaddr.bytes,
 				   &peer_macaddr);
-	wma_debug("pLinkSpeed->peerMacAddr: %pM, peer_macaddr.mac_addr31to0: 0x%x, peer_macaddr.mac_addr47to32: 0x%x",
-		 pLinkSpeed->peer_macaddr.bytes,
+	wma_debug("pLinkSpeed->peerMacAddr: "QDF_MAC_ADDR_FMT", peer_macaddr.mac_addr31to0: 0x%x, peer_macaddr.mac_addr47to32: 0x%x",
+		 QDF_MAC_ADDR_REF(pLinkSpeed->peer_macaddr.bytes),
 		 peer_macaddr.mac_addr31to0,
 		 peer_macaddr.mac_addr47to32);
 	if (wmi_unified_get_link_speed_cmd(wma_handle->wmi_handle,
@@ -1166,8 +1166,9 @@ int wma_csa_offload_handler(void *handle, uint8_t *event, uint32_t len)
 
 	csa_offload_event->ies_present_flag = csa_event->ies_present_flag;
 
-	wma_debug("CSA: BSSID %pM chan %d freq %d flag 0x%x width = %d freq1 = %d freq2 = %d op class = %d",
-		 csa_offload_event->bssId, csa_offload_event->channel,
+	wma_debug("CSA: BSSID "QDF_MAC_ADDR_FMT" chan %d freq %d flag 0x%x width = %d freq1 = %d freq2 = %d op class = %d",
+		 QDF_MAC_ADDR_REF(csa_offload_event->bssId),
+		 csa_offload_event->channel,
 		 csa_offload_event->csa_chan_freq,
 		 csa_event->ies_present_flag,
 		 csa_offload_event->new_ch_width,
@@ -2104,8 +2105,8 @@ static void wma_wow_parse_data_pkt(t_wma_handle *wma,
 
 	src_mac = data + QDF_NBUF_SRC_MAC_OFFSET;
 	dest_mac = data + QDF_NBUF_DEST_MAC_OFFSET;
-	wma_info("Src_mac: " QDF_MAC_ADDR_STR ", Dst_mac: " QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY(src_mac), QDF_MAC_ADDR_ARRAY(dest_mac));
+	wma_info("Src_mac: " QDF_MAC_ADDR_FMT ", Dst_mac: " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(src_mac), QDF_MAC_ADDR_REF(dest_mac));
 
 	wma_wow_inc_wake_lock_stats_by_dst_addr(wma, vdev_id, dest_mac);
 
@@ -2195,9 +2196,9 @@ static void wma_wow_dump_mgmt_buffer(uint8_t *wow_packet_buffer,
 		uint8_t to_from_ds, frag_num;
 		uint32_t seq_num;
 
-		wma_err("RA: " QDF_MAC_ADDR_STR " TA: " QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(wh->i_addr1),
-			QDF_MAC_ADDR_ARRAY(wh->i_addr2));
+		wma_err("RA: " QDF_MAC_ADDR_FMT " TA: " QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(wh->i_addr1),
+			QDF_MAC_ADDR_REF(wh->i_addr2));
 
 		wma_err("TO_DS: %u, FROM_DS: %u",
 			wh->i_fc[1] & IEEE80211_FC1_DIR_TODS,
@@ -2207,23 +2208,23 @@ static void wma_wow_dump_mgmt_buffer(uint8_t *wow_packet_buffer,
 
 		switch (to_from_ds) {
 		case IEEE80211_FC1_DIR_NODS:
-			wma_err("BSSID: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(wh->i_addr3));
+			wma_err("BSSID: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(wh->i_addr3));
 			break;
 		case IEEE80211_FC1_DIR_TODS:
-			wma_err("DA: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(wh->i_addr3));
+			wma_err("DA: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(wh->i_addr3));
 			break;
 		case IEEE80211_FC1_DIR_FROMDS:
-			wma_err("SA: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(wh->i_addr3));
+			wma_err("SA: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(wh->i_addr3));
 			break;
 		case IEEE80211_FC1_DIR_DSTODS:
 			if (buf_len >= sizeof(struct ieee80211_frame_addr4))
-				wma_err("DA: " QDF_MAC_ADDR_STR " SA: "
-					QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(wh->i_addr3),
-					QDF_MAC_ADDR_ARRAY(wh->i_addr4));
+				wma_err("DA: " QDF_MAC_ADDR_FMT " SA: "
+					QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(wh->i_addr3),
+					QDF_MAC_ADDR_REF(wh->i_addr4));
 			break;
 		}
 
@@ -2992,8 +2993,8 @@ QDF_STATUS wma_process_add_periodic_tx_ptrn_ind(WMA_HANDLE handle,
 	if (wma_find_vdev_id_by_addr(wma_handle,
 				     pattern->mac_address.bytes,
 				     &vdev_id)) {
-		wma_err("Failed to find vdev id for %pM",
-			 pattern->mac_address.bytes);
+		wma_err("Failed to find vdev id for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(pattern->mac_address.bytes));
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -3039,8 +3040,8 @@ QDF_STATUS wma_process_del_periodic_tx_ptrn_ind(WMA_HANDLE handle,
 			wma_handle,
 			pDelPeriodicTxPtrnParams->mac_address.bytes,
 			&vdev_id)) {
-		wma_err("Failed to find vdev id for %pM",
-			pDelPeriodicTxPtrnParams->mac_address.bytes);
+		wma_err("Failed to find vdev id for "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(pDelPeriodicTxPtrnParams->mac_address.bytes));
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -3472,8 +3473,8 @@ int wma_update_tdls_peer_state(WMA_HANDLE handle,
 
 	if (!wma_objmgr_peer_exist(wma_handle,
 				   peer_state->peer_macaddr, NULL)) {
-		wma_err("peer:" QDF_MAC_ADDR_STR "doesn't exist",
-			QDF_MAC_ADDR_ARRAY(peer_state->peer_macaddr));
+		wma_err("peer:" QDF_MAC_ADDR_FMT "doesn't exist",
+			QDF_MAC_ADDR_REF(peer_state->peer_macaddr));
 		ret = -EINVAL;
 		goto end_tdls_peer_state;
 	}
@@ -3517,9 +3518,9 @@ int wma_update_tdls_peer_state(WMA_HANDLE handle,
 						peer_state->vdev_id,
 						peer_state->peer_macaddr);
 
-		wma_debug("calling wma_remove_peer for peer " QDF_MAC_ADDR_STR
+		wma_debug("calling wma_remove_peer for peer " QDF_MAC_ADDR_FMT
 			 " vdevId: %d",
-			 QDF_MAC_ADDR_ARRAY(peer_state->peer_macaddr),
+			 QDF_MAC_ADDR_REF(peer_state->peer_macaddr),
 			 peer_state->vdev_id);
 		qdf_status = wma_remove_peer(wma_handle,
 					     peer_state->peer_macaddr,
@@ -4908,7 +4909,7 @@ int wma_pdev_div_info_evt_handler(void *handle, u_int8_t *event_buf,
 	qdf_mem_zero(&chain_rssi_result, sizeof(chain_rssi_result));
 
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->macaddr, macaddr);
-	wma_debug("macaddr: " QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(macaddr));
+	wma_debug("macaddr: " QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(macaddr));
 
 	wma_debug("num_chains_valid: %d", event->num_chains_valid);
 	chain_rssi_result.num_chains_valid = event->num_chains_valid;
@@ -5072,7 +5073,8 @@ void wma_set_peer_ucast_cipher(uint8_t *mac_addr,
 				    wlan_objmgr_pdev_get_pdev_id(wma->pdev),
 				    mac_addr, WLAN_LEGACY_WMA_ID);
 	if (!peer) {
-		wma_err("Peer of peer_mac %pM not found", mac_addr);
+		wma_err("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			QDF_MAC_ADDR_REF(mac_addr));
 		return;
 	}
 	cipher_cap = wma_cipher_to_cap(cipher);
@@ -5085,8 +5087,9 @@ void wma_set_peer_ucast_cipher(uint8_t *mac_addr,
 				   set_val);
 	wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_WMA_ID);
 
-	wma_debug("Set unicast cipher %x and cap %x for %pM", 1 << cipher,
-		  1 << cipher_cap, mac_addr);
+	wma_debug("Set unicast cipher %x and cap %x for "QDF_MAC_ADDR_FMT,
+		  1 << cipher, 1 << cipher_cap,
+		  QDF_MAC_ADDR_REF(mac_addr));
 }
 
 void wma_update_set_key(uint8_t session_id, bool pairwise,

core/wma/src/wma_main.c

@@ -721,8 +721,8 @@ static void wma_process_send_addba_req(tp_wma_handle wma_handle,
 	if (QDF_STATUS_SUCCESS != status) {
 		wma_err("Failed to process WMA_SEND_ADDBA_REQ");
 	}
-	wma_debug("sent ADDBA req to" QDF_MAC_ADDR_STR "tid %d buff_size %d",
-			QDF_MAC_ADDR_ARRAY(send_addba->mac_addr),
+	wma_debug("sent ADDBA req to" QDF_MAC_ADDR_FMT "tid %d buff_size %d",
+			QDF_MAC_ADDR_REF(send_addba->mac_addr),
 			send_addba->param.tidno,
 			send_addba->param.buffersize);
 
@@ -3515,8 +3515,8 @@ static int wma_set_base_macaddr_indicate(tp_wma_handle wma_handle,
 				     (uint8_t *)customAddr);
 	if (err)
 		return -EIO;
-	wma_debug("Base MAC Addr: " QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY((*customAddr)));
+	wma_debug("Base MAC Addr: " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF((*customAddr)));
 
 	return 0;
 }

core/wma/src/wma_mgmt.c

@@ -338,7 +338,8 @@ int wma_peer_sta_kickout_event_handler(void *handle, uint8_t *event,
 	WMI_MAC_ADDR_TO_CHAR_ARRAY(&kickout_event->peer_macaddr, macaddr);
 	if (cdp_peer_get_vdevid(soc, macaddr, &vdev_id) !=
 			QDF_STATUS_SUCCESS) {
-		wma_err("Not able to find BSSID for peer [%pM]", macaddr);
+		wma_err("Not able to find BSSID for peer ["QDF_MAC_ADDR_FMT"]",
+			 QDF_MAC_ADDR_REF(macaddr));
 		return -EINVAL;
 	}
 	vdev = wma->interfaces[vdev_id].vdev;
@@ -348,8 +349,9 @@ int wma_peer_sta_kickout_event_handler(void *handle, uint8_t *event,
 	}
 	addr = wlan_vdev_mlme_get_macaddr(vdev);
 
-	wma_nofl_info("STA kickout for %pM, on mac %pM, vdev %d, reason:%d",
-		      macaddr, addr, vdev_id, kickout_event->reason);
+	wma_nofl_info("STA kickout for "QDF_MAC_ADDR_FMT", on mac "QDF_MAC_ADDR_FMT", vdev %d, reason:%d",
+		      QDF_MAC_ADDR_REF(macaddr), QDF_MAC_ADDR_REF(addr),
+		      vdev_id, kickout_event->reason);
 
 	if (wma->interfaces[vdev_id].roaming_in_progress) {
 		wma_err("Ignore STA kick out since roaming is in progress");
@@ -369,8 +371,8 @@ int wma_peer_sta_kickout_event_handler(void *handle, uint8_t *event,
 		del_sta_ctx = (tpDeleteStaContext)
 			qdf_mem_malloc(sizeof(tDeleteStaContext));
 		if (!del_sta_ctx) {
-			wma_err("mem alloc failed for struct del_sta_context for TDLS peer: %pM",
-				macaddr);
+			wma_err("mem alloc failed for struct del_sta_context for TDLS peer: "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(macaddr));
 			return -ENOMEM;
 		}
 
@@ -3170,8 +3172,8 @@ int wma_process_rmf_frame(tp_wma_handle wma_handle,
 		rx_pkt->pkt_meta.mpdu_data_ptr =
 		rx_pkt->pkt_meta.mpdu_hdr_ptr +
 		rx_pkt->pkt_meta.mpdu_hdr_len;
-		wma_debug("BSSID: "QDF_MAC_ADDR_STR" tsf_delta: %u",
-			  QDF_MAC_ADDR_ARRAY(wh->i_addr3),
+		wma_debug("BSSID: "QDF_MAC_ADDR_FMT" tsf_delta: %u",
+			  QDF_MAC_ADDR_REF(wh->i_addr3),
 			  rx_pkt->pkt_meta.tsf_delta);
 	} else {
 		if (QDF_IS_ADDR_BROADCAST(wh->i_addr1) ||
@@ -3211,13 +3213,14 @@ wma_get_peer_pmf_status(tp_wma_handle wma, uint8_t *peer_mac)
 				    wlan_objmgr_pdev_get_pdev_id(wma->pdev),
 				    peer_mac, WLAN_LEGACY_WMA_ID);
 	if (!peer) {
-		wma_err("Peer of peer_mac %pM not found", peer_mac);
+		wma_err("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			 QDF_MAC_ADDR_REF(peer_mac));
 		return false;
 	}
 	is_pmf_enabled = mlme_get_peer_pmf_status(peer);
 	wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_WMA_ID);
-	wma_nofl_debug("get is_pmf_enabled %d for %pM",
-		       is_pmf_enabled, peer_mac);
+	wma_nofl_debug("get is_pmf_enabled %d for "QDF_MAC_ADDR_FMT,
+		       is_pmf_enabled, QDF_MAC_ADDR_REF(peer_mac));
 
 	return is_pmf_enabled;
 }
@@ -3433,9 +3436,9 @@ int wma_form_rx_packet(qdf_nbuf_t buf,
 	 * If the mpdu_data_len is greater than Max (2k), drop the frame
 	 */
 	if (rx_pkt->pkt_meta.mpdu_data_len > WMA_MAX_MGMT_MPDU_LEN) {
-		wma_err("Data Len %d greater than max, dropping frame from "QDF_MAC_ADDR_STR,
+		wma_err("Data Len %d greater than max, dropping frame from "QDF_MAC_ADDR_FMT,
 			 rx_pkt->pkt_meta.mpdu_data_len,
-			 QDF_MAC_ADDR_ARRAY(wh->i_addr3));
+			 QDF_MAC_ADDR_REF(wh->i_addr3));
 		qdf_nbuf_free(buf);
 		qdf_mem_free(rx_pkt);
 		return -EINVAL;
@@ -3485,8 +3488,8 @@ int wma_form_rx_packet(qdf_nbuf_t buf,
 		if (mgmt_rx_params->buf_len <=
 			(sizeof(struct ieee80211_frame) +
 			offsetof(struct wlan_bcn_frame, ie))) {
-			wma_debug("Dropping frame from "QDF_MAC_ADDR_STR,
-				 QDF_MAC_ADDR_ARRAY(wh->i_addr3));
+			wma_debug("Dropping frame from "QDF_MAC_ADDR_FMT,
+				 QDF_MAC_ADDR_REF(wh->i_addr3));
 			cds_pkt_return_packet(rx_pkt);
 			return -EINVAL;
 		}

core/wma/src/wma_nan_datapath.c

@@ -51,13 +51,13 @@ void wma_add_sta_ndi_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	struct wma_txrx_node *iface;
 
 	iface = &wma->interfaces[add_sta->smesessionId];
-	wma_debug("vdev: %d, peer_mac_addr: "QDF_MAC_ADDR_STR,
-		add_sta->smesessionId, QDF_MAC_ADDR_ARRAY(add_sta->staMac));
+	wma_debug("vdev: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT,
+		add_sta->smesessionId, QDF_MAC_ADDR_REF(add_sta->staMac));
 
 	if (cdp_find_peer_exist_on_vdev(soc, add_sta->smesessionId,
 					add_sta->staMac)) {
-		wma_err("NDI peer already exists, peer_addr %pM",
-			 add_sta->staMac);
+		wma_err("NDI peer already exists, peer_addr "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = QDF_STATUS_E_EXISTS;
 		goto send_rsp;
 	}
@@ -70,8 +70,8 @@ void wma_add_sta_ndi_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	 * here.
 	 */
 	if (cdp_find_peer_exist(soc, pdev_id, add_sta->staMac)) {
-		wma_err("peer exists on other vdev with peer_addr %pM",
-			 add_sta->staMac);
+		wma_err("peer exists on other vdev with peer_addr "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = QDF_STATUS_E_EXISTS;
 		goto send_rsp;
 	}
@@ -79,28 +79,30 @@ void wma_add_sta_ndi_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	status = wma_create_peer(wma, add_sta->staMac,
 				 WMI_PEER_TYPE_NAN_DATA, add_sta->smesessionId);
 	if (status != QDF_STATUS_SUCCESS) {
-		wma_err("Failed to create peer for %pM", add_sta->staMac);
+		wma_err("Failed to create peer for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = status;
 		goto send_rsp;
 	}
 
 	if (!cdp_find_peer_exist_on_vdev(soc, add_sta->smesessionId,
 					 add_sta->staMac)) {
-		wma_err("Failed to find peer handle using peer mac %pM",
-			 add_sta->staMac);
+		wma_err("Failed to find peer handle using peer mac "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(add_sta->staMac));
 		add_sta->status = QDF_STATUS_E_FAILURE;
 		wma_remove_peer(wma, add_sta->staMac, add_sta->smesessionId);
 		goto send_rsp;
 	}
 
-	wma_debug("Moving peer %pM to state %d", add_sta->staMac, state);
+	wma_debug("Moving peer "QDF_MAC_ADDR_FMT" to state %d",
+		  QDF_MAC_ADDR_REF(add_sta->staMac), state);
 	cdp_peer_state_update(soc, add_sta->staMac, state);
 
 	add_sta->nss    = iface->nss;
 	add_sta->status = QDF_STATUS_SUCCESS;
 send_rsp:
-	wma_debug("Sending add sta rsp to umac (mac:%pM, status:%d)",
-		 add_sta->staMac, add_sta->status);
+	wma_debug("Sending add sta rsp to umac (mac:"QDF_MAC_ADDR_FMT", status:%d)",
+		  QDF_MAC_ADDR_REF(add_sta->staMac), add_sta->status);
 	wma_send_msg_high_priority(wma, WMA_ADD_STA_RSP, (void *)add_sta, 0);
 }
 

core/wma/src/wma_power.c

@@ -178,21 +178,21 @@ QDF_STATUS wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
 		break;
 	}
 
-	wma_debug("Set WMI_AP_PS_PEER_PARAM_UAPSD 0x%x for %pM",
-		 uapsd, peer_addr);
+	wma_debug("Set WMI_AP_PS_PEER_PARAM_UAPSD 0x%x for "QDF_MAC_ADDR_FMT,
+		 uapsd, QDF_MAC_ADDR_REF(peer_addr));
 	param.vdev_id = vdev_id;
 	param.param = WMI_AP_PS_PEER_PARAM_UAPSD;
 	param.value = uapsd;
 	ret = wmi_unified_ap_ps_cmd_send(wma->wmi_handle, peer_addr,
 						&param);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		wma_err("Failed to set WMI_AP_PS_PEER_PARAM_UAPSD for %pM",
-			peer_addr);
+		wma_err("Failed to set WMI_AP_PS_PEER_PARAM_UAPSD for "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(peer_addr));
 		return ret;
 	}
 
-	wma_debug("Set WMI_AP_PS_PEER_PARAM_MAX_SP 0x%x for %pM",
-		 max_sp_len, peer_addr);
+	wma_debug("Set WMI_AP_PS_PEER_PARAM_MAX_SP 0x%x for "QDF_MAC_ADDR_FMT,
+		 max_sp_len, QDF_MAC_ADDR_REF(peer_addr));
 
 	param.vdev_id = vdev_id;
 	param.param = WMI_AP_PS_PEER_PARAM_MAX_SP;
@@ -200,8 +200,8 @@ QDF_STATUS wma_set_ap_peer_uapsd(tp_wma_handle wma, uint32_t vdev_id,
 	ret = wmi_unified_ap_ps_cmd_send(wma->wmi_handle, peer_addr,
 					  &param);
 	if (QDF_IS_STATUS_ERROR(ret)) {
-		wma_err("Failed to set WMI_AP_PS_PEER_PARAM_MAX_SP for %pM",
-			peer_addr);
+		wma_err("Failed to set WMI_AP_PS_PEER_PARAM_MAX_SP for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(peer_addr));
 		return ret;
 	}
 
@@ -267,15 +267,15 @@ void wma_set_tx_power(WMA_HANDLE handle,
 						&vdev_id);
 	}
 	if (ret) {
-		wma_err("vdev id is invalid for %pM",
-			tx_pwr_params->bssId.bytes);
+		wma_err("vdev id is invalid for "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(tx_pwr_params->bssId.bytes));
 		qdf_mem_free(tx_pwr_params);
 		return;
 	}
 
 	if (!wma_is_vdev_up(vdev_id)) {
-		wma_err("vdev id %d is not up for %pM", vdev_id,
-			tx_pwr_params->bssId.bytes);
+		wma_err("vdev id %d is not up for "QDF_MAC_ADDR_FMT, vdev_id,
+			QDF_MAC_ADDR_REF(tx_pwr_params->bssId.bytes));
 		qdf_mem_free(tx_pwr_params);
 		return;
 	}
@@ -372,8 +372,8 @@ void wma_set_max_tx_power(WMA_HANDLE handle,
 						&vdev_id);
 	}
 	if (ret) {
-		wma_err("vdev id is invalid for %pM",
-			tx_pwr_params->bssId.bytes);
+		wma_err("vdev id is invalid for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(tx_pwr_params->bssId.bytes));
 		qdf_mem_free(tx_pwr_params);
 		return;
 	}
@@ -1411,9 +1411,9 @@ void wma_process_set_mimops_req(tp_wma_handle wma_handle,
 	else if (mimops->htMIMOPSState == eSIR_HT_MIMO_PS_NO_LIMIT)
 		mimops->htMIMOPSState = WMI_PEER_MIMO_PS_NONE;
 
-	wma_debug("htMIMOPSState = %d, sessionId = %d peerMac <"QDF_MAC_ADDR_STR">",
+	wma_debug("htMIMOPSState = %d, sessionId = %d peerMac <"QDF_MAC_ADDR_FMT">",
 		 mimops->htMIMOPSState, mimops->sessionId,
-		 QDF_MAC_ADDR_ARRAY(mimops->peerMac));
+		 QDF_MAC_ADDR_REF(mimops->peerMac));
 
 	wma_set_peer_param(wma_handle, mimops->peerMac,
 			   WMI_PEER_MIMO_PS_STATE, mimops->htMIMOPSState,

core/wma/src/wma_scan_roam.c

@@ -1523,8 +1523,8 @@ static QDF_STATUS wma_roam_scan_filter(tp_wma_handle wma_handle,
 	}
 
 	for (i = 0; i < params->num_bssid_black_list; i++)
-		wma_debug("Blacklist bssid[%d]:" QDF_MAC_ADDR_STR, i,
-			  QDF_MAC_ADDR_ARRAY(params->bssid_avoid_list[i].bytes));
+		wma_debug("Blacklist bssid[%d]:" QDF_MAC_ADDR_FMT, i,
+			  QDF_MAC_ADDR_REF(params->bssid_avoid_list[i].bytes));
 	qdf_mem_copy(params->bssid_favored, roam_params->bssid_favored,
 			MAX_BSSID_FAVORED * sizeof(struct qdf_mac_addr));
 	qdf_mem_copy(params->bssid_favored_factor,
@@ -1535,8 +1535,8 @@ static QDF_STATUS wma_roam_scan_filter(tp_wma_handle wma_handle,
 		sizeof(struct reject_ap_config_params));
 
 	for (i = 0; i < params->num_bssid_preferred_list; i++)
-		wma_debug("Preferred Bssid[%d]:"QDF_MAC_ADDR_STR" score: %d", i,
-			  QDF_MAC_ADDR_ARRAY(params->bssid_favored[i].bytes),
+		wma_debug("Preferred Bssid[%d]:"QDF_MAC_ADDR_FMT" score: %d", i,
+			  QDF_MAC_ADDR_REF(params->bssid_favored[i].bytes),
 			  params->bssid_favored_factor[i]);
 
 	if (params->lca_disallow_config_present) {
@@ -2735,7 +2735,8 @@ static void wma_update_roamed_peer_unicast_cipher(tp_wma_handle wma,
 				    wlan_objmgr_pdev_get_pdev_id(wma->pdev),
 				    peer_mac, WLAN_LEGACY_WMA_ID);
 	if (!peer) {
-		wma_err("Peer of peer_mac %pM not found", peer_mac);
+		wma_err("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			QDF_MAC_ADDR_REF(peer_mac));
 		return;
 	}
 	wlan_crypto_set_peer_param(peer, WLAN_CRYPTO_PARAM_CIPHER_CAP,
@@ -2745,8 +2746,8 @@ static void wma_update_roamed_peer_unicast_cipher(tp_wma_handle wma,
 
 	wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_WMA_ID);
 
-	wma_debug("Set unicast cipher %x and cap %x for %pM", uc_cipher,
-		  cipher_cap, peer_mac);
+	wma_debug("Set unicast cipher %x and cap %x for "QDF_MAC_ADDR_FMT,
+		  uc_cipher, cipher_cap, QDF_MAC_ADDR_REF(peer_mac));
 }
 
 static void wma_get_peer_uc_cipher(tp_wma_handle wma, uint8_t *peer_mac,
@@ -2763,7 +2764,8 @@ static void wma_get_peer_uc_cipher(tp_wma_handle wma, uint8_t *peer_mac,
 				    wlan_objmgr_pdev_get_pdev_id(wma->pdev),
 				    peer_mac, WLAN_LEGACY_WMA_ID);
 	if (!peer) {
-		wma_err("Peer of peer_mac %pM not found", peer_mac);
+		wma_err("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			 QDF_MAC_ADDR_REF(peer_mac));
 		return;
 	}
 
@@ -3403,8 +3405,8 @@ int wma_roam_auth_offload_event_handler(WMA_HANDLE handle, uint8_t *event,
 	}
 
 	vdev_id = rso_auth_start_ev->vdev_id;
-	wma_debug("Received Roam auth offload event for bss:%pM vdev_id:%d",
-		  ap_bssid.bytes, vdev_id);
+	wma_debug("Received Roam auth offload event for bss:"QDF_MAC_ADDR_FMT" vdev_id:%d",
+		  QDF_MAC_ADDR_REF(ap_bssid.bytes), vdev_id);
 
 	lim_sae_auth_cleanup_retry(mac_ctx, vdev_id);
 	status = wma->csr_roam_auth_event_handle_cb(mac_ctx, vdev_id, ap_bssid);
@@ -3628,9 +3630,9 @@ wma_rso_print_btm_rsp_info(struct roam_btm_response_data *data,
 	char time[TIME_STRING_LEN];
 
 	mlme_get_converted_timestamp(data->timestamp, time);
-	wma_info("%s [BTM RSP]: VDEV[%d], Status: %d, VSIE reason: %d, BSSID: %pM",
+	wma_info("%s [BTM RSP]: VDEV[%d], Status: %d, VSIE reason: %d, BSSID: "QDF_MAC_ADDR_FMT,
 		 time, vdev_id, data->btm_status, data->vsie_reason,
-		 data->target_bssid.bytes);
+		 QDF_MAC_ADDR_REF(data->target_bssid.bytes));
 }
 
 /**
@@ -3682,8 +3684,8 @@ wma_log_roam_scan_candidates(struct wmi_roam_candidate_info *ap,
 	for (i = 0; i < num_entries; i++) {
 		mlme_get_converted_timestamp(ap->timestamp, time);
 		mlme_get_converted_timestamp(ap->bl_timestamp, time2);
-		wma_nofl_info(QDF_MAC_ADDR_STR " %17s %4d %-4s %4d %3d/%-4d %2d/%-4d %5d %7d %7d   %17s %9d",
-			      QDF_MAC_ADDR_ARRAY(ap->bssid.bytes), time,
+		wma_nofl_info(QDF_MAC_ADDR_FMT " %17s %4d %-4s %4d %3d/%-4d %2d/%-4d %5d %7d %7d   %17s %9d",
+			      QDF_MAC_ADDR_REF(ap->bssid.bytes), time,
 			      ap->freq,
 			      ((ap->type == 0) ? "C_AP" :
 			       ((ap->type == 2) ? "R_AP" : "P_AP")),
@@ -4293,7 +4295,8 @@ int wma_rssi_breached_event_handler(void *handle,
 
 	wma_debug("req_id: %u vdev_id: %d curr_rssi: %d",
 		 rssi.request_id, rssi.session_id, rssi.curr_rssi);
-	wma_debug("curr_bssid: %pM", rssi.curr_bssid.bytes);
+	wma_debug("curr_bssid: "QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(rssi.curr_bssid.bytes));
 
 	mac->sme.rssi_threshold_breached_cb(mac->hdd_handle, &rssi);
 	wma_debug("Invoke HDD rssi breached callback");
@@ -6262,7 +6265,8 @@ int wma_roam_event_callback(WMA_HANDLE handle, uint8_t *event_buf,
 		bssid.bytes[3] = wmi_event->notif_params >> 24 & 0xFF;
 		bssid.bytes[4] = wmi_event->notif_params1 >> 0 & 0xFF;
 		bssid.bytes[5] = wmi_event->notif_params1 >> 8 & 0xFF;
-		wma_debug("mac addr to avoid %pM", bssid.bytes);
+		wma_debug("mac addr to avoid "QDF_MAC_ADDR_FMT,
+			  QDF_MAC_ADDR_REF(bssid.bytes));
 		wma_handle_hw_mode_transition(wma_handle, param_buf);
 		wma_roam_ho_fail_handler(wma_handle, wmi_event->vdev_id, bssid);
 		lim_sae_auth_cleanup_retry(wma_handle->mac_context,
@@ -6671,8 +6675,8 @@ int wma_roam_pmkid_request_event_handler(void *handle, uint8_t *event,
 			qdf_mem_free(dst_list);
 			return -EINVAL;
 		}
-		wma_debug("Received pmkid fallback for bssid: %pM vdev_id:%d",
-			 roam_bsslist->bytes,
+		wma_debug("Received pmkid fallback for bssid: "QDF_MAC_ADDR_FMT" vdev_id:%d",
+			  QDF_MAC_ADDR_REF(roam_bsslist->bytes),
 			 roam_pmkid_req_ev->vdev_id);
 		src_list++;
 	}

core/wma/src/wma_utils.c

@@ -4162,7 +4162,8 @@ void wma_remove_bss_peer_on_vdev_start_failure(tp_wma_handle wma,
 	wma_err("ADD BSS failure for vdev %d", vdev_id);
 
 	if (!cdp_find_peer_exist(soc, pdev_id, bss_peer.bytes)) {
-		wma_err("Failed to find peer %pM", bss_peer.bytes);
+		wma_err("Failed to find peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(bss_peer.bytes));
 		return;
 	}