qcacld-3.0: mac: 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: I684c9688dda0421065f84d6775fb3417bb99ec0d

core/mac/src/dph/dph_hash_table.c

@@ -226,9 +226,8 @@ tpDphHashNode dph_add_hash_entry(struct mac_context *mac, tSirMacAddr staAddr,
 	tpDphHashNode ptr, node;
 	uint16_t index = hash_function(mac, staAddr, hash_table->size);
 
-	pe_debug("assocId %d index %d STA addr",
-		       assocId, index);
-	pe_debug(QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(staAddr));
+	pe_debug("assocId: %d index: %d STA addr: "QDF_MAC_ADDR_FMT,
+		 assocId, index, QDF_MAC_ADDR_REF(staAddr));
 
 	if (assocId >= hash_table->size) {
 		pe_err("invalid STA id %d", assocId);
@@ -299,8 +298,8 @@ QDF_STATUS dph_delete_hash_entry(struct mac_context *mac, tSirMacAddr staAddr,
 	tpDphHashNode ptr, prev;
 	uint16_t index = hash_function(mac, staAddr, hash_table->size);
 
-	pe_debug("assocId %d index %d STA addr", assocId, index);
-	pe_debug(QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(staAddr));
+	pe_debug("assocId: %d index: %d STA addr: "QDF_MAC_ADDR_FMT,
+		 assocId, index, QDF_MAC_ADDR_REF(staAddr));
 
 	if (assocId >= hash_table->size) {
 		pe_err("invalid STA id %d", assocId);
@@ -335,8 +334,8 @@ QDF_STATUS dph_delete_hash_entry(struct mac_context *mac, tSirMacAddr staAddr,
 		ptr->sta_deletion_in_progress = false;
 		ptr->next = 0;
 	} else {
-		pe_err("Entry not present STA addr");
-		pe_err(QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(staAddr));
+		pe_err("Entry not present STA addr: "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(staAddr));
 		return QDF_STATUS_E_FAILURE;
 	}
 

core/mac/src/pe/lim/lim_admit_control.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-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
@@ -605,9 +605,9 @@ lim_validate_access_policy(struct mac_context *mac,
 
 	if (retval != QDF_STATUS_SUCCESS)
 		pe_warn("accPol: %d lle: %d wme: %d wsm: %d sta mac "
-			QDF_MAC_ADDR_STR, accessPolicy, pSta->lleEnabled,
+			QDF_MAC_ADDR_FMT, accessPolicy, pSta->lleEnabled,
 			pSta->wmeEnabled, pSta->wsmEnabled,
-			QDF_MAC_ADDR_ARRAY(pSta->staAddr));
+			QDF_MAC_ADDR_REF(pSta->staAddr));
 
 	return retval;
 }

core/mac/src/pe/lim/lim_api.c

@@ -1909,8 +1909,8 @@ lim_roam_gen_mbssid_beacon(struct mac_context *mac,
 		scan_entry = scan_node->entry;
 		if (qdf_is_macaddr_equal(&roam_ind->bssid,
 					 &scan_entry->bssid)) {
-			pe_debug("matched BSSID %pM bcn len %d profiles %d",
-				 scan_entry->bssid.bytes,
+			pe_debug("matched BSSID "QDF_MAC_ADDR_FMT" bcn len %d profiles %d",
+				 QDF_MAC_ADDR_REF(scan_entry->bssid.bytes),
 				 scan_entry->raw_frame.len,
 				 list_count);
 			nontx_bcn_prbrsp = scan_entry->raw_frame.ptr;
@@ -2005,17 +2005,17 @@ lim_roam_gen_beacon_descr(struct mac_context *mac,
 	ie_offset = SIR_MAC_HDR_LEN_3A + SIR_MAC_B_PR_SSID_OFFSET;
 
 	if (qdf_is_macaddr_zero((struct qdf_mac_addr *)mac_hdr->bssId)) {
-		pe_debug("bssid is 0 in beacon/probe update it with bssId %pM in sync ind",
-			roam_ind->bssid.bytes);
+		pe_debug("bssid is 0 in beacon/probe update it with bssId "QDF_MAC_ADDR_FMT" in sync ind",
+			QDF_MAC_ADDR_REF(roam_ind->bssid.bytes));
 		qdf_mem_copy(mac_hdr->bssId, roam_ind->bssid.bytes,
 			     sizeof(tSirMacAddr));
 	}
 
 	if (qdf_mem_cmp(&roam_ind->bssid.bytes,
 			&mac_hdr->bssId, QDF_MAC_ADDR_SIZE) != 0) {
-		pe_debug("LFR3:MBSSID Beacon/Prb Rsp: %d bssid %pM",
+		pe_debug("LFR3:MBSSID Beacon/Prb Rsp: %d bssid "QDF_MAC_ADDR_FMT,
 			 roam_ind->isBeacon,
-			 mac_hdr->bssId);
+			 QDF_MAC_ADDR_REF(mac_hdr->bssId));
 		/*
 		 * Its a MBSSID non-tx BSS roaming scenario.
 		 * Generate non tx BSS beacon/probe response
@@ -2099,10 +2099,10 @@ lim_roam_fill_bss_descr(struct mac_context *mac,
 		qdf_mem_free(parsed_frm_ptr);
 		return QDF_STATUS_E_FAILURE;
 	}
-	pe_debug("LFR3:Beacon/Prb Rsp: %d bssid %pM beacon %pM",
+	pe_debug("LFR3:Beacon/Prb Rsp: %d bssid "QDF_MAC_ADDR_FMT" beacon "QDF_MAC_ADDR_FMT,
 		 roam_synch_ind_ptr->isBeacon,
-		 roam_synch_ind_ptr->bssid.bytes,
-		 mac_hdr->bssId);
+		 QDF_MAC_ADDR_REF(roam_synch_ind_ptr->bssid.bytes),
+		 QDF_MAC_ADDR_REF(mac_hdr->bssId));
 
 	status = lim_roam_gen_beacon_descr(mac,
 					   roam_synch_ind_ptr,
@@ -2489,8 +2489,9 @@ pe_roam_synch_callback(struct mac_context *mac_ctx,
 		return status;
 	}
 
-	pe_debug("LFR3:Received ROAM SYNCH IND bssid %pM auth: %d vdevId: %d",
-		 roam_sync_ind_ptr->bssid.bytes, roam_sync_ind_ptr->authStatus,
+	pe_debug("LFR3:Received ROAM SYNCH IND bssid "QDF_MAC_ADDR_FMT" auth: %d vdevId: %d",
+		 QDF_MAC_ADDR_REF(roam_sync_ind_ptr->bssid.bytes),
+		 roam_sync_ind_ptr->authStatus,
 		 roam_sync_ind_ptr->roamed_vdev_id);
 
 	/*
@@ -2563,8 +2564,8 @@ pe_roam_synch_callback(struct mac_context *mac_ctx,
 					 DPH_STA_HASH_INDEX_PEER,
 					 &ft_session_ptr->dph.dphHashTable);
 	if (!curr_sta_ds) {
-		pe_err("LFR3:failed to add hash entry for %pM",
-		       add_bss_params->staContext.staMac);
+		pe_err("LFR3:failed to add hash entry for "QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(add_bss_params->staContext.staMac));
 		ft_session_ptr->bRoamSynchInProgress = false;
 		return status;
 	}

core/mac/src/pe/lim/lim_assoc_utils.c

@@ -518,10 +518,10 @@ lim_send_del_sta_cnf(struct mac_context *mac, struct qdf_mac_addr sta_dsaddr,
 	tLimMlmDeauthCnf mlmDeauthCnf;
 	tLimMlmPurgeStaInd mlmPurgeStaInd;
 
-	pe_debug("Sessionid: %d staDsAssocId: %d Trigger: %d status_code: %d sta_dsaddr: "QDF_MAC_ADDR_STR,
+	pe_debug("Sessionid: %d staDsAssocId: %d Trigger: %d status_code: %d sta_dsaddr: "QDF_MAC_ADDR_FMT,
 		pe_session->peSessionId, staDsAssocId,
 		mlmStaContext.cleanupTrigger, status_code,
-		QDF_MAC_ADDR_ARRAY(sta_dsaddr.bytes));
+		QDF_MAC_ADDR_REF(sta_dsaddr.bytes));
 
 	if (LIM_IS_STA_ROLE(pe_session)) {
 		/* Set BSSID at CFG to null */
@@ -693,10 +693,10 @@ lim_reject_association(struct mac_context *mac_ctx, tSirMacAddr peer_addr,
 {
 	tpDphHashNode sta_ds;
 
-	pe_debug("Sessionid: %d auth_type: %d sub_type: %d add_pre_auth_context: %d sta_id: %d delete_sta: %d result_code : %d peer_addr: " QDF_MAC_ADDR_STR,
+	pe_debug("Sessionid: %d auth_type: %d sub_type: %d add_pre_auth_context: %d sta_id: %d delete_sta: %d result_code : %d peer_addr: " QDF_MAC_ADDR_FMT,
 		session_entry->peSessionId, auth_type, sub_type,
 		add_pre_auth_context, sta_id, delete_sta, result_code,
-		QDF_MAC_ADDR_ARRAY(peer_addr));
+		QDF_MAC_ADDR_REF(peer_addr));
 
 	if (add_pre_auth_context) {
 		/* Create entry for this STA in pre-auth list */
@@ -792,8 +792,9 @@ lim_decide_ap_protection_on_ht20_delete(struct mac_context *mac_ctx,
 {
 	uint32_t i = 0;
 
-	pe_debug("(%d) A HT 20 STA is disassociated. Addr is %pM",
-		session_entry->gLimHt20Params.numSta, sta_ds->staAddr);
+	pe_debug("(%d) A HT 20 STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+		session_entry->gLimHt20Params.numSta,
+		QDF_MAC_ADDR_REF(sta_ds->staAddr));
 
 	if (session_entry->gLimHt20Params.numSta > 0) {
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
@@ -860,8 +861,9 @@ lim_decide_ap_protection_on_delete(struct mac_context *mac_ctx,
 		 * HT station leaving ==> this case is commonly handled
 		 * between both the bands below.
 		 */
-		pe_debug("(%d) A 11A STA is disassociated. Addr is %pM",
-			session_entry->gLim11aParams.numSta, sta_ds->staAddr);
+		pe_debug("(%d) A 11A STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+			session_entry->gLim11aParams.numSta,
+			QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->protStaCache[i].active &&
 				(!qdf_mem_cmp(
@@ -885,8 +887,9 @@ lim_decide_ap_protection_on_delete(struct mac_context *mac_ctx,
 		(phy_mode == WNI_CFG_PHY_MODE_11G ||
 		session_entry->htCapability) &&
 		(erp_enabled == eHAL_CLEAR)) {
-		pe_debug("(%d) A legacy STA is disassociated. Addr is %pM",
-			session_entry->gLim11bParams.numSta, sta_ds->staAddr);
+		pe_debug("(%d) A legacy STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+			session_entry->gLim11bParams.numSta,
+			QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->protStaCache[i].active &&
 				(!qdf_mem_cmp(
@@ -914,8 +917,9 @@ lim_decide_ap_protection_on_delete(struct mac_context *mac_ctx,
 	if ((REG_BAND_2G == rf_band) &&
 		session_entry->htCapability &&
 		!sta_ds->mlmStaContext.htCapability) {
-		pe_debug("(%d) A 11g STA is disassociated. Addr is %pM",
-			session_entry->gLim11bParams.numSta, sta_ds->staAddr);
+		pe_debug("(%d) A 11g STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+			session_entry->gLim11bParams.numSta,
+			QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->protStaCache[i].active &&
 				(!qdf_mem_cmp(
@@ -945,8 +949,9 @@ lim_decide_ap_protection_on_delete(struct mac_context *mac_ctx,
 	 * HT non-GF leaving
 	 */
 	if (!sta_ds->htGreenfield) {
-		pe_debug("(%d) A non-GF STA is disassociated. Addr is %pM",
-			session_entry->gLimNonGfParams.numSta, sta_ds->staAddr);
+		pe_debug("(%d) A non-GF STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+			session_entry->gLimNonGfParams.numSta,
+			QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->protStaCache[i].active &&
 				(!qdf_mem_cmp(
@@ -983,9 +988,9 @@ lim_decide_ap_protection_on_delete(struct mac_context *mac_ctx,
 	if ((false == session_entry->beaconParams.
 				fLsigTXOPProtectionFullSupport) &&
 		(false == sta_ds->htLsigTXOPProtection)) {
-		pe_debug("(%d) A HT LSIG not supporting STA is disassociated. Addr is %pM",
+		pe_debug("(%d) A HT LSIG not supporting STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
 			session_entry->gLimLsigTxopParams.numSta,
-			sta_ds->staAddr);
+			QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->protStaCache[i].active &&
 				(!qdf_mem_cmp(
@@ -1025,9 +1030,9 @@ static void lim_decide_short_preamble(struct mac_context *mac_ctx,
 	uint32_t i;
 
 	if (sta_ds->shortPreambleEnabled == eHAL_CLEAR) {
-		pe_debug("(%d) A non-short preamble STA is disassociated. Addr is %pM",
-		       session_entry->gLimNoShortParams.numNonShortPreambleSta,
-			 sta_ds->staAddr);
+		pe_debug("(%d) A non-short preamble STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
+			 session_entry->gLimNoShortParams.numNonShortPreambleSta,
+			 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		for (i = 0; i < LIM_PROT_STA_CACHE_SIZE; i++) {
 			if (session_entry->gLimNoShortParams.
 				staNoShortCache[i].active &&
@@ -1080,9 +1085,9 @@ lim_decide_short_slot(struct mac_context *mac_ctx, tpDphHashNode sta_ds,
 	if (sta_ds->shortSlotTimeEnabled != eHAL_CLEAR)
 		return;
 
-	pe_debug("(%d) A non-short slottime STA is disassociated. Addr is %pM",
+	pe_debug("(%d) A non-short slottime STA is disassociated. Addr is "QDF_MAC_ADDR_FMT,
 		mac_ctx->lim.gLimNoShortSlotParams.numNonShortSlotSta,
-		sta_ds->staAddr);
+		QDF_MAC_ADDR_REF(sta_ds->staAddr));
 
 	val = mac_ctx->mlme_cfg->feature_flags.enable_short_slot_time_11g;
 
@@ -2160,8 +2165,8 @@ lim_add_sta(struct mac_context *mac_ctx,
 	else
 		sta_Addr = &sta_mac;
 
-	pe_debug(QDF_MAC_ADDR_STR ": Subtype(Assoc/Reassoc): %d",
-		QDF_MAC_ADDR_ARRAY(*sta_Addr), sta_ds->mlmStaContext.subType);
+	pe_debug(QDF_MAC_ADDR_FMT ": Subtype(Assoc/Reassoc): %d",
+		QDF_MAC_ADDR_REF(*sta_Addr), sta_ds->mlmStaContext.subType);
 
 	qdf_mem_copy((uint8_t *) add_sta_params->staMac,
 		     (uint8_t *) *sta_Addr, sizeof(tSirMacAddr));
@@ -2223,9 +2228,9 @@ lim_add_sta(struct mac_context *mac_ctx,
 	}
 
 	pe_debug("updateSta: %d htcapable: %d vhtCapable: %d sta mac"
-		 QDF_MAC_ADDR_STR, add_sta_params->updateSta,
+		 QDF_MAC_ADDR_FMT, add_sta_params->updateSta,
 		 add_sta_params->htCapable, add_sta_params->vhtCapable,
-		 QDF_MAC_ADDR_ARRAY(add_sta_params->staMac));
+		 QDF_MAC_ADDR_REF(add_sta_params->staMac));
 
 	/*
 	 * If HT client is connected to SAP DUT and self cap is NSS = 2 then
@@ -2626,10 +2631,11 @@ lim_del_sta(struct mac_context *mac,
 	msgQ.bodyval = 0;
 
 	pe_debug("Sessionid %d :Sending SIR_HAL_DELETE_STA_REQ "
-		 "for mac_addr %pM and AssocID: %d MAC : "
-		 QDF_MAC_ADDR_STR, pDelStaParams->sessionId,
-		 pDelStaParams->staMac, pDelStaParams->assocId,
-		 QDF_MAC_ADDR_ARRAY(sta->staAddr));
+		 "for mac_addr "QDF_MAC_ADDR_FMT" and AssocID: %d MAC : "
+		 QDF_MAC_ADDR_FMT, pDelStaParams->sessionId,
+		 QDF_MAC_ADDR_REF(pDelStaParams->staMac),
+		 pDelStaParams->assocId,
+		 QDF_MAC_ADDR_REF(sta->staAddr));
 
 	MTRACE(mac_trace_msg_tx(mac, pe_session->peSessionId, msgQ.type));
 	retCode = wma_post_ctrl_msg(mac, &msgQ);
@@ -2800,8 +2806,8 @@ lim_add_sta_self(struct mac_context *mac, uint8_t updateSta,
 	msgQ.bodyptr = pAddStaParams;
 	msgQ.bodyval = 0;
 
-	pe_debug(QDF_MAC_ADDR_STR ": vdev %d Sending WMA_ADD_STA_REQ.LI %d",
-		 QDF_MAC_ADDR_ARRAY(pAddStaParams->staMac),
+	pe_debug(QDF_MAC_ADDR_FMT ": vdev %d Sending WMA_ADD_STA_REQ.LI %d",
+		 QDF_MAC_ADDR_REF(pAddStaParams->staMac),
 		 pe_session->vdev_id, pAddStaParams->listenInterval);
 	MTRACE(mac_trace_msg_tx(mac, pe_session->peSessionId, msgQ.type));
 
@@ -2912,8 +2918,8 @@ lim_delete_dph_hash_entry(struct mac_context *mac_ctx, tSirMacAddr sta_addr,
 		return;
 	}
 
-	pe_debug("Deleting DPH Hash entry sta mac " QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY(sta_addr));
+	pe_debug("Deleting DPH Hash entry sta mac " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(sta_addr));
 	/*
 	 * update the station count and perform associated actions
 	 * do this before deleting the dph hash entry
@@ -2959,8 +2965,8 @@ lim_delete_dph_hash_entry(struct mac_context *mac_ctx, tSirMacAddr sta_addr,
 #ifdef WLAN_FEATURE_11W
 		if (sta_ds->rmfEnabled) {
 			pe_debug("delete pmf timer assoc-id:%d sta mac "
-				 QDF_MAC_ADDR_STR, sta_ds->assocId,
-				 QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+				 QDF_MAC_ADDR_FMT, sta_ds->assocId,
+				 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 			tx_timer_delete(&sta_ds->pmfSaQueryTimer);
 		}
 #endif
@@ -3032,8 +3038,9 @@ lim_check_and_announce_join_success(struct mac_context *mac_ctx,
 	if (!LIM_IS_STA_ROLE(session_entry))
 		return;
 
-	pe_debug("Received Beacon/PR with BSSID:%pM pe session %d vdev %d",
-		 session_entry->bssId, session_entry->peSessionId,
+	pe_debug("Received Beacon/PR with BSSID:"QDF_MAC_ADDR_FMT" pe session %d vdev %d",
+		 QDF_MAC_ADDR_REF(session_entry->bssId),
+		 session_entry->peSessionId,
 		 session_entry->vdev_id);
 
 	/* Deactivate Join Failure timer */
@@ -3089,9 +3096,9 @@ lim_check_and_announce_join_success(struct mac_context *mac_ctx,
 	 */
 	if (!session_entry->ignore_assoc_disallowed &&
 			beacon_probe_rsp->assoc_disallowed) {
-		pe_err("Connection fails due to assoc disallowed reason(%d):%pM PESessionID %d",
+		pe_err("Connection fails due to assoc disallowed reason(%d):"QDF_MAC_ADDR_FMT" PESessionID %d",
 				beacon_probe_rsp->assoc_disallowed_reason,
-				session_entry->bssId,
+				QDF_MAC_ADDR_REF(session_entry->bssId),
 				session_entry->peSessionId);
 		mlm_join_cnf.resultCode = eSIR_SME_ASSOC_REFUSED;
 		mlm_join_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
@@ -3261,9 +3268,9 @@ lim_del_bss(struct mac_context *mac, tpDphHashNode sta, uint16_t bss_idx,
 	msgQ.bodyptr = NULL;
 	msgQ.bodyval = pe_session->smeSessionId;
 
-	pe_debug("Sessionid %d : Sending HAL_DELETE_BSS_REQ BSSID:" QDF_MAC_ADDR_STR,
+	pe_debug("Sessionid %d : Sending HAL_DELETE_BSS_REQ BSSID:" QDF_MAC_ADDR_FMT,
 		 pe_session->peSessionId,
-		 QDF_MAC_ADDR_ARRAY(pe_session->bssId));
+		 QDF_MAC_ADDR_REF(pe_session->bssId));
 	MTRACE(mac_trace_msg_tx(mac, pe_session->peSessionId, msgQ.type));
 
 	retCode = wma_post_ctrl_msg(mac, &msgQ);
@@ -3516,8 +3523,8 @@ QDF_STATUS lim_sta_send_add_bss(struct mac_context *mac, tpSirAssocRsp pAssocRsp
 				&pe_session->dph.dphHashTable);
 	if (!sta) {
 		pe_err("Couldn't get assoc id for " "MAC ADDR: "
-			QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(
+			QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(
 				pAddBssParams->staContext.staMac));
 			return QDF_STATUS_E_FAILURE;
 	}

core/mac/src/pe/lim/lim_ft_preauth.c

@@ -141,9 +141,9 @@ int lim_process_ft_pre_auth_req(struct mac_context *mac_ctx,
 					   ft_pre_auth_req->currbssId,
 					   &session_id);
 	if (!session) {
-		pe_err("Unable to find session for the bssid"
-			   QDF_MAC_ADDR_STR,
-			   QDF_MAC_ADDR_ARRAY(ft_pre_auth_req->currbssId));
+		pe_err("Unable to find session for the bssid "
+			QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(ft_pre_auth_req->currbssId));
 		/* Post the FT Pre Auth Response to SME */
 		lim_post_ft_pre_auth_rsp(mac_ctx, QDF_STATUS_E_FAILURE, NULL, 0,
 					 session);

core/mac/src/pe/lim/lim_link_monitoring_algo.c

@@ -132,8 +132,8 @@ static void lim_delete_sta_util(struct mac_context *mac_ctx, tpDeleteStaContext
 			pe_debug("Received SIR_LIM_DELETE_STA_CONTEXT_IND for "
 					"STA that either has no context or "
 					"in some transit state, Addr = "
-					QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(msg->bssId));
+					QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(msg->bssId));
 			return;
 		}
 
@@ -413,8 +413,8 @@ lim_tear_down_link_with_ap(struct mac_context *mac, uint8_t sessionId,
 				mac->lim.gLimHeartBeatApMacIndex = 1;
 
 			pe_debug("HB Failure on MAC "
-				 QDF_MAC_ADDR_STR" Store it on Index %d",
-				 QDF_MAC_ADDR_ARRAY(sta->staAddr), apCount);
+				 QDF_MAC_ADDR_FMT" Store it on Index %d",
+				 QDF_MAC_ADDR_REF(sta->staAddr), apCount);
 
 			sir_copy_mac_addr(mac->lim.gLimHeartBeatApMac[apCount],
 					  sta->staAddr);

core/mac/src/pe/lim/lim_process_action_frame.c

@@ -1976,8 +1976,9 @@ void lim_process_action_frame(struct mac_context *mac_ctx,
 		}
 		break;
 	case ACTION_CATEGORY_BACK:
-		pe_debug("Rcvd Block Ack for %pM; action: %d",
-			session->self_mac_addr, action_hdr->actionID);
+		pe_debug("Rcvd Block Ack for "QDF_MAC_ADDR_FMT"; action: %d",
+			  QDF_MAC_ADDR_REF(session->self_mac_addr),
+			  action_hdr->actionID);
 		switch (action_hdr->actionID) {
 		case ADDBA_REQUEST:
 			lim_process_addba_req(mac_ctx, rx_pkt_info, session);

core/mac/src/pe/lim/lim_process_assoc_req_frame.c

@@ -169,17 +169,17 @@ static QDF_STATUS lim_check_sta_in_pe_entries(struct mac_context *mac_ctx,
 				    eLIM_MLM_WT_DEL_BSS_RSP_STATE ||
 				    sta_ds->sta_deletion_in_progress) {
 					pe_debug(
-					"Deletion is in progress (%d) for peer:%pM in mlmState %d",
+					"Deletion is in progress (%d) for peer:"QDF_MAC_ADDR_FMT" in mlmState %d",
 					sta_ds->sta_deletion_in_progress,
-					sta_ds->staAddr,
+					QDF_MAC_ADDR_REF(sta_ds->staAddr),
 					sta_ds->mlmStaContext.mlmState);
 					*dup_entry = true;
 					return QDF_STATUS_E_AGAIN;
 				}
 				sta_ds->sta_deletion_in_progress = true;
 				pe_err("Sending Disassoc and Deleting existing STA entry:"
-				       QDF_MAC_ADDR_STR,
-				       QDF_MAC_ADDR_ARRAY(
+				       QDF_MAC_ADDR_FMT,
+				       QDF_MAC_ADDR_REF(
 						session->self_mac_addr));
 				lim_send_disassoc_mgmt_frame(mac_ctx,
 					eSIR_MAC_UNSPEC_FAILURE_REASON,
@@ -264,7 +264,7 @@ static bool lim_chk_assoc_req_parse_error(struct mac_context *mac_ctx,
 		return true;
 
 	pe_warn("Assoc Req rejected: frame parsing error. source addr:"
-			QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(hdr->sa));
+			QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(hdr->sa));
 	lim_send_assoc_rsp_mgmt_frame(mac_ctx, eSIR_MAC_UNSPEC_FAILURE_STATUS,
 				      1, hdr->sa, sub_type, 0, session, false);
 	return false;
@@ -300,9 +300,9 @@ static bool lim_chk_capab(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 	if (lim_compare_capabilities(mac_ctx, assoc_req,
 				     local_cap, session) == false) {
 		pe_warn("Rcvd %s Req with unsupported capab from"
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 			(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+			QDF_MAC_ADDR_REF(hdr->sa));
 		/*
 		 * Capabilities of requesting STA does not match with
 		 * local capabilities. Respond with 'unsupported capabilities'
@@ -336,11 +336,11 @@ static bool lim_chk_ssid(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 		return true;
 
 	pe_err("%s Req with ssid wrong(Rcvd: %.*s self: %.*s) from "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 		(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
 		assoc_req->ssId.length, assoc_req->ssId.ssId,
 		session->ssId.length, session->ssId.ssId,
-		QDF_MAC_ADDR_ARRAY(hdr->sa));
+		QDF_MAC_ADDR_REF(hdr->sa));
 
 	/*
 	 * Received Re/Association Request with either Broadcast SSID OR with
@@ -393,9 +393,9 @@ static bool lim_chk_rates(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 		return true;
 
 	pe_warn("Assoc Req rejected: unsupported rates, soruce addr: %s"
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 		(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
-		QDF_MAC_ADDR_ARRAY(hdr->sa));
+		QDF_MAC_ADDR_REF(hdr->sa));
 	/*
 	 * Requesting STA does not support ALL BSS basic rates. Respond with
 	 * 'basic rates not supported' status code.
@@ -426,8 +426,8 @@ static bool lim_chk_11g_only(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 	    (session->dot11mode == MLME_DOT11_MODE_11G_ONLY) &&
 	    (assoc_req->HTCaps.present)) {
 		pe_err("SOFTAP was in 11G only mode, rejecting legacy STA: "
-				QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(hdr->sa));
 		lim_send_assoc_rsp_mgmt_frame(
 			mac_ctx, eSIR_MAC_CAPABILITIES_NOT_SUPPORTED_STATUS,
 			1, hdr->sa, sub_type, 0, session, false);
@@ -456,8 +456,8 @@ static bool lim_chk_11n_only(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 	    (session->dot11mode == MLME_DOT11_MODE_11N_ONLY) &&
 	    (!assoc_req->HTCaps.present)) {
 		pe_err("SOFTAP was in 11N only mode, rejecting legacy STA: "
-				QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(hdr->sa));
 		lim_send_assoc_rsp_mgmt_frame(
 			mac_ctx, eSIR_MAC_CAPABILITIES_NOT_SUPPORTED_STATUS,
 			1, hdr->sa, sub_type, 0, session, false);
@@ -624,17 +624,17 @@ lim_process_for_spectrum_mgmt(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 				 */
 				if (!assoc_req->powerCapabilityPresent) {
 					pe_warn("LIM Info: Missing Power capability IE in %s Req from "
-							QDF_MAC_ADDR_STR,
+							QDF_MAC_ADDR_FMT,
 						(LIM_ASSOC == sub_type) ?
 							"Assoc" : "ReAssoc",
-						QDF_MAC_ADDR_ARRAY(hdr->sa));
+						QDF_MAC_ADDR_REF(hdr->sa));
 				}
 				if (!assoc_req->supportedChannelsPresent) {
 					pe_warn("LIM Info: Missing Supported channel IE in %s Req from "
-							QDF_MAC_ADDR_STR,
+							QDF_MAC_ADDR_FMT,
 						(LIM_ASSOC == sub_type) ?
 							"Assoc" : "ReAssoc",
-						QDF_MAC_ADDR_ARRAY(hdr->sa));
+						QDF_MAC_ADDR_REF(hdr->sa));
 				}
 			} else {
 				/* Assoc request has mandatory fields */
@@ -643,19 +643,19 @@ lim_process_for_spectrum_mgmt(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 					mac_ctx, assoc_req, session);
 				if (QDF_STATUS_SUCCESS != status) {
 					pe_warn("LIM Info: MinTxPower(STA) > MaxTxPower(AP) in %s Req from "
-						QDF_MAC_ADDR_STR,
+						QDF_MAC_ADDR_FMT,
 						(LIM_ASSOC == sub_type) ?
 							"Assoc" : "ReAssoc",
-						QDF_MAC_ADDR_ARRAY(hdr->sa));
+						QDF_MAC_ADDR_REF(hdr->sa));
 				}
 				status = lim_is_dot11h_supported_channels_valid(
 							mac_ctx, assoc_req);
 				if (QDF_STATUS_SUCCESS != status) {
 					pe_warn("LIM Info: wrong supported channels (STA) in %s Req from "
-						QDF_MAC_ADDR_STR,
+						QDF_MAC_ADDR_FMT,
 						(LIM_ASSOC == sub_type) ?
 							"Assoc" : "ReAssoc",
-						QDF_MAC_ADDR_ARRAY(hdr->sa));
+						QDF_MAC_ADDR_REF(hdr->sa));
 				}
 				/* IEs are valid, use them if needed */
 			}
@@ -698,9 +698,9 @@ static bool lim_chk_mcs(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 	if ((assoc_req->HTCaps.present) && (lim_check_mcs_set(mac_ctx,
 			assoc_req->HTCaps.supportedMCSSet) == false)) {
 		pe_warn("rcvd %s req with unsupported MCS Rate Set from "
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 			(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+			QDF_MAC_ADDR_REF(hdr->sa));
 		/*
 		 * Requesting STA does not support ALL BSS MCS basic Rate set
 		 * rates. Spec does not define any status code for this
@@ -956,13 +956,13 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 	qdf_mem_zero((uint8_t *) &dot11f_ie_rsn, sizeof(dot11f_ie_rsn));
 	qdf_mem_zero((uint8_t *) &dot11f_ie_wpa, sizeof(dot11f_ie_wpa));
 	pe_debug("RSN enabled auth, Re/Assoc req from STA: "
-		 QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(hdr->sa));
+		 QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(hdr->sa));
 
 	if (assoc_req->rsnPresent) {
 		if (!(assoc_req->rsn.length)) {
 			pe_warn("Re/Assoc rejected from: "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			/*
 			 * rcvd Assoc req frame with RSN IE but
 			 * length is zero
@@ -993,8 +993,8 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 						  pmf_connection);
 			if (eSIR_MAC_SUCCESS_STATUS != status) {
 				pe_warn("Re/Assoc rejected from: "
-					QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(hdr->sa));
+					QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(hdr->sa));
 
 				lim_send_assoc_rsp_mgmt_frame(
 					mac_ctx, status, 1, hdr->sa, sub_type,
@@ -1002,8 +1002,8 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 				return false;
 			}
 		} else {
-			pe_warn("Re/Assoc rejected from: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+			pe_warn("Re/Assoc rejected from: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			/*
 			 * rcvd Assoc req frame with RSN IE but
 			 * IE version is wrong
@@ -1021,8 +1021,8 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 					       *akm_type);
 		if (eSIR_MAC_SUCCESS_STATUS != status) {
 			/* Reject pmf disable SAE STA */
-			pe_warn("Re/Assoc rejected from: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+			pe_warn("Re/Assoc rejected from: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			lim_send_assoc_rsp_mgmt_frame(mac_ctx, status,
 						      1, hdr->sa, sub_type,
 						      0, session, false);
@@ -1032,8 +1032,8 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 	} else if (assoc_req->wpaPresent) {
 		if (!(assoc_req->wpa.length)) {
 			pe_warn("Re/Assoc rejected from: "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 
 			/* rcvd Assoc req frame with invalid WPA IE length */
 			lim_send_assoc_rsp_mgmt_frame(
@@ -1059,8 +1059,8 @@ static bool lim_check_wpa_rsn_ie(struct pe_session *session,
 					  &dot11f_ie_wpa);
 		if (eSIR_MAC_SUCCESS_STATUS != status) {
 			pe_warn("Re/Assoc rejected from: "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			/*
 			 * rcvd Assoc req frame with WPA IE
 			 * but there is mismatch
@@ -1175,9 +1175,9 @@ static bool lim_process_assoc_req_no_sta_ctx(struct mac_context *mac_ctx,
 				hdr->sa, session, false);
 
 		pe_warn("rcvd %s req, sessionid: %d, without pre-auth ctx"
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 			(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
-			session->peSessionId, QDF_MAC_ADDR_ARRAY(hdr->sa));
+			session->peSessionId, QDF_MAC_ADDR_REF(hdr->sa));
 		return false;
 	}
 	/* Delete 'pre-auth' context of STA */
@@ -1247,9 +1247,10 @@ static bool lim_process_assoc_req_sta_ctx(struct mac_context *mac_ctx,
 	if (sta_ds->sta_deletion_in_progress ||
 	    (sta_ds->mlmStaContext.mlmState !=
 	     eLIM_MLM_LINK_ESTABLISHED_STATE)) {
-		pe_debug("%s: peer:%pM in mlmState %d (%s) and sta del %d",
+		pe_debug("%s: peer:"QDF_MAC_ADDR_FMT" in mlmState %d (%s) and sta del %d",
 			 (sub_type == LIM_ASSOC) ? "Assoc" : "ReAssoc",
-			 sta_ds->staAddr, sta_ds->mlmStaContext.mlmState,
+			 QDF_MAC_ADDR_REF(sta_ds->staAddr),
+			 sta_ds->mlmStaContext.mlmState,
 			 lim_mlm_state_str(sta_ds->mlmStaContext.mlmState),
 			 sta_ds->sta_deletion_in_progress);
 		lim_update_assoc_drop_count(mac_ctx, sub_type);
@@ -1679,8 +1680,8 @@ static bool lim_update_sta_ds(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 			&assoc_req->he_cap) != QDF_STATUS_SUCCESS) {
 		/* Could not update hash table entry at DPH with rateset */
 		pe_err("Couldn't update hash entry for aid: %d MacAddr: "
-		       QDF_MAC_ADDR_STR,
-		       peer_idx, QDF_MAC_ADDR_ARRAY(hdr->sa));
+		       QDF_MAC_ADDR_FMT,
+		       peer_idx, QDF_MAC_ADDR_REF(hdr->sa));
 
 		/* Release AID */
 		lim_release_peer_idx(mac_ctx, peer_idx, session);
@@ -1787,8 +1788,8 @@ static bool lim_update_sta_ds(struct mac_context *mac_ctx, tpSirMacMgmtHdr hdr,
 					       session);
 			return false;
 		}
-		pe_debug("Created pmf timer assoc-id:%d sta mac" QDF_MAC_ADDR_STR,
-			 sta_ds->assocId, QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+		pe_debug("Created pmf timer assoc-id:%d sta mac" QDF_MAC_ADDR_FMT,
+			 sta_ds->assocId, QDF_MAC_ADDR_REF(sta_ds->staAddr));
 	}
 #endif
 
@@ -1871,8 +1872,8 @@ static bool lim_update_sta_ctx(struct mac_context *mac_ctx, struct pe_session *s
 			if (lim_del_sta(mac_ctx, sta_ds, true, session)
 					!= QDF_STATUS_SUCCESS) {
 				pe_err("Couldn't DEL STA, assocId: %d sta mac"
-				       QDF_MAC_ADDR_STR, sta_ds->assocId,
-				       QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+				       QDF_MAC_ADDR_FMT, sta_ds->assocId,
+				       QDF_MAC_ADDR_REF(sta_ds->staAddr));
 				lim_reject_association(mac_ctx, sta_ds->staAddr,
 					sta_ds->mlmStaContext.subType, true,
 					sta_ds->mlmStaContext.authType,
@@ -2052,9 +2053,9 @@ bool lim_send_assoc_ind_to_sme(struct mac_context *mac_ctx,
 		return false;
 
 	/* STA is Associated ! */
-	pe_debug("Received: %s Req  successful from " QDF_MAC_ADDR_STR,
+	pe_debug("Received: %s Req  successful from " QDF_MAC_ADDR_FMT,
 		 (sub_type == LIM_ASSOC) ? "Assoc" : "ReAssoc",
-		 QDF_MAC_ADDR_ARRAY(hdr->sa));
+		 QDF_MAC_ADDR_REF(hdr->sa));
 
 	/*
 	 * AID for this association will be same as the peer Index used in DPH
@@ -2083,7 +2084,7 @@ bool lim_send_assoc_ind_to_sme(struct mac_context *mac_ctx,
 	if (!sta_ds) {
 		/* Could not add hash table entry at DPH */
 		pe_err("couldn't add hash entry at DPH for aid: %d MacAddr:"
-			   QDF_MAC_ADDR_STR, peer_idx, QDF_MAC_ADDR_ARRAY(hdr->sa));
+			   QDF_MAC_ADDR_FMT, peer_idx, QDF_MAC_ADDR_REF(hdr->sa));
 
 		/* Release AID */
 		lim_release_peer_idx(mac_ctx, peer_idx, session);
@@ -2168,8 +2169,8 @@ lim_peer_present_on_any_sta(struct mac_context *mac_ctx, uint8_t *peer_addr)
 	peer_vdev_id = wlan_vdev_get_id(wlan_peer_get_vdev(peer));
 	mode = wlan_vdev_mlme_get_opmode(wlan_peer_get_vdev(peer));
 	if (mode == QDF_STA_MODE || mode == QDF_P2P_CLIENT_MODE) {
-		pe_debug("duplicate mac detected!!! Peer " QDF_MAC_ADDR_STR " present on STA vdev %d",
-			 QDF_MAC_ADDR_ARRAY(peer_addr), peer_vdev_id);
+		pe_debug("duplicate mac detected!!! Peer " QDF_MAC_ADDR_FMT " present on STA vdev %d",
+			 QDF_MAC_ADDR_REF(peer_addr), peer_vdev_id);
 		sta_peer_present = true;
 	}
 
@@ -2216,18 +2217,18 @@ void lim_process_assoc_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_in
 	hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
 	frame_len = WMA_GET_RX_PAYLOAD_LEN(rx_pkt_info);
 
-	pe_nofl_debug("Assoc req RX: subtype %d vdev %d sys role %d lim state %d rssi %d from " QDF_MAC_ADDR_STR,
+	pe_nofl_debug("Assoc req RX: subtype %d vdev %d sys role %d lim state %d rssi %d from " QDF_MAC_ADDR_FMT,
 		      sub_type, session->vdev_id, GET_LIM_SYSTEM_ROLE(session),
 		      session->limMlmState,
 		      WMA_GET_RX_RSSI_NORMALIZED(rx_pkt_info),
-		      QDF_MAC_ADDR_ARRAY(hdr->sa));
+		      QDF_MAC_ADDR_REF(hdr->sa));
 
 	if (LIM_IS_STA_ROLE(session)) {
 		pe_err("Rcvd unexpected ASSOC REQ, sessionid: %d sys sub_type: %d for role: %d from: "
-			   QDF_MAC_ADDR_STR,
+			   QDF_MAC_ADDR_FMT,
 			session->peSessionId, sub_type,
 			GET_LIM_SYSTEM_ROLE(session),
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+			QDF_MAC_ADDR_REF(hdr->sa));
 		QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
 				   WMA_GET_RX_MPDU_DATA(rx_pkt_info),
 				   frame_len);
@@ -2235,10 +2236,10 @@ void lim_process_assoc_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_in
 	}
 	if (session->limMlmState == eLIM_MLM_WT_DEL_BSS_RSP_STATE) {
 		pe_err("drop ASSOC REQ on sessionid: %d "
-			"role: %d from: "QDF_MAC_ADDR_STR" in limMlmState: %d",
+			"role: %d from: "QDF_MAC_ADDR_FMT" in limMlmState: %d",
 			session->peSessionId,
 			GET_LIM_SYSTEM_ROLE(session),
-			QDF_MAC_ADDR_ARRAY(hdr->sa),
+			QDF_MAC_ADDR_REF(hdr->sa),
 			eLIM_MLM_WT_DEL_BSS_RSP_STATE);
 		return;
 	}
@@ -2275,9 +2276,9 @@ void lim_process_assoc_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_in
 	if (sta_ds) {
 		if (hdr->fc.retry > 0) {
 			pe_err("STA is initiating Assoc Req after ACK lost. Do not process sessionid: %d sys sub_type=%d for role=%d from: "
-				QDF_MAC_ADDR_STR, session->peSessionId,
+				QDF_MAC_ADDR_FMT, session->peSessionId,
 			sub_type, GET_LIM_SYSTEM_ROLE(session),
-			QDF_MAC_ADDR_ARRAY(hdr->sa));
+			QDF_MAC_ADDR_REF(hdr->sa));
 			return;
 		} else if (!sta_ds->rmfEnabled && (sub_type == LIM_REASSOC)) {
 			/*
@@ -2305,10 +2306,10 @@ void lim_process_assoc_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_in
 				sub_type,
 				sta_ds, session, false);
 			pe_err("DUT already received an assoc request frame and STA is sending another assoc req.So, do not Process sessionid: %d sys sub_type: %d for role: %d from: "
-					QDF_MAC_ADDR_STR,
+					QDF_MAC_ADDR_FMT,
 				session->peSessionId, sub_type,
 				session->limSystemRole,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+				QDF_MAC_ADDR_REF(hdr->sa));
 			return;
 		}
 	}
@@ -2340,9 +2341,9 @@ void lim_process_assoc_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_in
 		 * ignore it
 		 */
 		pe_err("Rcvd: %s Req, sessionid: %d from a BC/MC address"
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 			(LIM_ASSOC == sub_type) ? "Assoc" : "ReAssoc",
-			session->peSessionId, QDF_MAC_ADDR_ARRAY(hdr->sa));
+			session->peSessionId, QDF_MAC_ADDR_REF(hdr->sa));
 		return;
 	}
 
@@ -2973,9 +2974,9 @@ void lim_send_mlm_assoc_ind(struct mac_context *mac_ctx,
 		sub_type = LIM_ASSOC;
 
 	pe_debug("Sessionid: %d ssid: %s sub_type: %d Associd: %d staAddr: "
-		 QDF_MAC_ADDR_STR, session_entry->peSessionId,
+		 QDF_MAC_ADDR_FMT, session_entry->peSessionId,
 		 assoc_req->ssId.ssId, sub_type, sta_ds->assocId,
-		 QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+		 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 
 	if (sub_type == LIM_ASSOC || sub_type == LIM_REASSOC) {
 		temp = sizeof(tLimMlmAssocInd);

core/mac/src/pe/lim/lim_process_assoc_rsp_frame.c

@@ -663,11 +663,11 @@ lim_process_assoc_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		return;
 	}
 
-	pe_nofl_info("Assoc rsp RX: subtype %d vdev %d sys role %d lim state %d rssi %d from " QDF_MAC_ADDR_STR,
+	pe_nofl_info("Assoc rsp RX: subtype %d vdev %d sys role %d lim state %d rssi %d from " QDF_MAC_ADDR_FMT,
 		     subtype, vdev_id,
 		     GET_LIM_SYSTEM_ROLE(session_entry),
 		     session_entry->limMlmState, rssi,
-		     QDF_MAC_ADDR_ARRAY(hdr->sa));
+		     QDF_MAC_ADDR_REF(hdr->sa));
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
 			   (uint8_t *)hdr, frame_len + SIR_MAC_HDR_LEN_3A);
 
@@ -707,8 +707,8 @@ lim_process_assoc_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 			 * other than one to which request was initiated.
 			 * Ignore this and wait until Assoc Failure Timeout
 			 */
-			pe_warn("received AssocRsp from unexpected peer "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+			pe_warn("received AssocRsp from unexpected peer "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			qdf_mem_free(beacon);
 			return;
 		}
@@ -721,8 +721,8 @@ lim_process_assoc_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 			 * other than one to which request was initiated.
 			 * Ignore this and wait until Reassoc Failure Timeout.
 			 */
-			pe_warn("received ReassocRsp from unexpected peer "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(hdr->sa));
+			pe_warn("received ReassocRsp from unexpected peer "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(hdr->sa));
 			qdf_mem_free(beacon);
 			return;
 		}
@@ -1027,8 +1027,8 @@ lim_process_assoc_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		qdf_mem_free(beacon);
 		return;
 	}
-	pe_debug("Successfully Associated with BSS " QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY(hdr->sa));
+	pe_debug("Successfully Associated with BSS " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(hdr->sa));
 #ifdef FEATURE_WLAN_ESE
 	if (session_entry->eseContext.tsm.tsmInfo.state)
 		session_entry->eseContext.tsm.tsmMetrics.RoamingCount = 0;
@@ -1148,10 +1148,10 @@ assocReject:
 		&& (session_entry->limMlmState ==
 		    eLIM_MLM_WT_FT_REASSOC_RSP_STATE))) {
 		pe_err("Assoc Rejected by the peer mlmestate: %d sessionid: %d Reason: %d MACADDR:"
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			session_entry->limMlmState,
 			session_entry->peSessionId,
-			assoc_cnf.resultCode, QDF_MAC_ADDR_ARRAY(hdr->sa));
+			assoc_cnf.resultCode, QDF_MAC_ADDR_REF(hdr->sa));
 		session_entry->limMlmState = eLIM_MLM_IDLE_STATE;
 		MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE,
 			session_entry->peSessionId,

core/mac/src/pe/lim/lim_process_auth_frame.c

@@ -136,9 +136,9 @@ static void lim_process_auth_shared_system_algo(struct mac_context *mac_ctx,
 	cfg_privacy_opt_imp = (uint8_t) val;
 	if (!cfg_privacy_opt_imp) {
 		pe_err("rx Auth frame for unsupported auth algorithm %d "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authAlgoNumber,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 
 		/*
 		 * Authenticator does not have WEP
@@ -321,12 +321,12 @@ static void lim_external_auth_add_pre_auth_node(struct mac_context *mac_ctx,
 	/* Create entry for this STA in pre-auth list */
 	auth_node = lim_acquire_free_pre_auth_node(mac_ctx, preauth_table);
 	if (!auth_node) {
-		pe_debug("Max pre-auth nodes reached " QDF_MAC_ADDR_STR,
-			 QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+		pe_debug("Max pre-auth nodes reached " QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
-	pe_debug("Creating preauth node for SAE peer " QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+	pe_debug("Creating preauth node for SAE peer " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(mac_hdr->sa));
 	qdf_mem_copy((uint8_t *)auth_node->peerMacAddr,
 		     mac_hdr->sa, sizeof(tSirMacAddr));
 	auth_node->mlmState = mlm_state;
@@ -417,9 +417,9 @@ static void lim_process_sae_auth_frame(struct mac_context *mac_ctx,
 	body_ptr = WMA_GET_RX_MPDU_DATA(rx_pkt_info);
 	frame_len = WMA_GET_RX_PAYLOAD_LEN(rx_pkt_info);
 
-	pe_nofl_info("SAE Auth RX type %d subtype %d from %pM",
+	pe_nofl_info("SAE Auth RX type %d subtype %d from "QDF_MAC_ADDR_FMT,
 		     mac_hdr->fc.type, mac_hdr->fc.subType,
-		     mac_hdr->sa);
+		     QDF_MAC_ADDR_REF(mac_hdr->sa));
 
 	if (LIM_IS_STA_ROLE(pe_session) &&
 	    pe_session->limMlmState != eLIM_MLM_WT_SAE_AUTH_STATE)
@@ -497,8 +497,8 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 				&pMlmDisassocReq->peer_macaddr.bytes,
 				QDF_MAC_ADDR_SIZE))) {
 			pe_debug("TODO:Ack for disassoc frame is pending Issue delsta for "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(
 					pMlmDisassocReq->peer_macaddr.bytes));
 			lim_process_disassoc_ack_timeout(mac_ctx);
 			is_connected = false;
@@ -510,8 +510,8 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 				&pMlmDeauthReq->peer_macaddr.bytes,
 				QDF_MAC_ADDR_SIZE))) {
 			pe_debug("TODO:Ack for deauth frame is pending Issue delsta for "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(
 					pMlmDeauthReq->peer_macaddr.bytes));
 			lim_process_deauth_ack_timeout(mac_ctx);
 			is_connected = false;
@@ -538,8 +538,8 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 		   ) {
 			pe_err("STA is already connected but received auth frame"
 			       "Send the Deauth and lim Delete Station Context"
-			       "(associd: %d) sta mac" QDF_MAC_ADDR_STR,
-			       associd, QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			       "(associd: %d) sta mac" QDF_MAC_ADDR_FMT,
+			       associd, QDF_MAC_ADDR_REF(mac_hdr->sa));
 			lim_send_deauth_mgmt_frame(mac_ctx,
 				eSIR_MAC_UNSPEC_FAILURE_REASON,
 				(uint8_t *) mac_hdr->sa,
@@ -602,8 +602,8 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 #endif
 		   ) {
 			pe_debug("lim Del Sta Ctx associd: %d sta mac"
-				 QDF_MAC_ADDR_STR, associd,
-				 QDF_MAC_ADDR_ARRAY(sta_ds_ptr->staAddr));
+				 QDF_MAC_ADDR_FMT, associd,
+				 QDF_MAC_ADDR_REF(sta_ds_ptr->staAddr));
 			lim_send_deauth_mgmt_frame(mac_ctx,
 				eSIR_MAC_UNSPEC_FAILURE_REASON,
 				(uint8_t *)auth_node->peerMacAddr,
@@ -670,9 +670,9 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 			break;
 		default:
 			pe_err("rx Auth frm for unsupported auth algo %d "
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 				rx_auth_frm_body->authAlgoNumber,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 
 			/*
 			 * Responding party does not support the
@@ -694,9 +694,9 @@ static void lim_process_auth_frame_type1(struct mac_context *mac_ctx,
 		}
 	} else {
 		pe_err("received Authentication frame for unsupported auth algorithm %d "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authAlgoNumber,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 
 		/*
 		 * Responding party does not support the
@@ -750,8 +750,9 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 			mac_hdr->sa, sizeof(tSirMacAddr)))) {
 
 			/* Update the FTIEs in the saved auth response */
-			pe_warn("rx PreAuth frm2 in smestate: %d from: %pM",
-				pe_session->limSmeState, mac_hdr->sa);
+			pe_warn("rx PreAuth frm2 in smestate: %d from: "QDF_MAC_ADDR_FMT,
+				pe_session->limSmeState,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			pe_session->ftPEContext.saved_auth_rsp_length = 0;
 
 			if ((body_ptr) && (frame_len < MAX_FTIE_SIZE)) {
@@ -783,7 +784,7 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 		 */
 
 		pe_warn("received Auth frame2 from unexpected peer"
-			QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -822,9 +823,9 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 			 */
 
 			pe_warn("rx Auth frame2 for unexpected auth algo %d"
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 				rx_auth_frm_body->authAlgoNumber,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			return;
 		}
 	}
@@ -835,9 +836,9 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 		 * Return Auth confirm with received failure code to SME
 		 */
 		pe_err("rx Auth frame from peer with failure code %d "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authStatusCode,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		lim_restore_from_auth_state(mac_ctx, eSIR_SME_AUTH_REFUSED,
 			rx_auth_frm_body->authStatusCode,
 			pe_session);
@@ -861,7 +862,8 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 			return;
 		}
 
-		pe_debug("add new auth node: for %pM", mac_hdr->sa);
+		pe_debug("add new auth node: for "QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(mac_hdr->sa));
 		qdf_mem_copy((uint8_t *) auth_node->peerMacAddr,
 				mac_ctx->lim.gpLimMlmAuthReq->peerMacAddr,
 				sizeof(tSirMacAddr));
@@ -890,9 +892,9 @@ static void lim_process_auth_frame_type2(struct mac_context *mac_ctx,
 			 */
 
 			pe_err("rx Auth frm from peer for unsupported auth algo %d "
-						QDF_MAC_ADDR_STR,
+						QDF_MAC_ADDR_FMT,
 					rx_auth_frm_body->authAlgoNumber,
-					QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+					QDF_MAC_ADDR_REF(mac_hdr->sa));
 
 			auth_frame->authAlgoNumber =
 				rx_auth_frm_body->authAlgoNumber;
@@ -994,9 +996,9 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 	/* AuthFrame 3 */
 	if (rx_auth_frm_body->authAlgoNumber != eSIR_SHARED_KEY) {
 		pe_err("rx Auth frame3 from peer with auth algo number %d "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authAlgoNumber,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		/*
 		 * Received Authentication frame3 with algorithm other than
 		 * Shared Key authentication type. Reject with Auth frame4
@@ -1020,8 +1022,8 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 		 */
 		if (!mac_hdr->fc.wep) {
 			pe_err("received Auth frame3 from peer with no WEP bit set "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/* WEP bit is not set in FC of Auth Frame3 */
 			auth_frame->authAlgoNumber = eSIR_SHARED_KEY;
 			auth_frame->authTransactionSeqNumber =
@@ -1038,8 +1040,8 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 		auth_node = lim_search_pre_auth_list(mac_ctx, mac_hdr->sa);
 		if (!auth_node) {
 			pe_warn("received AuthFrame3 from peer that has no preauth context "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * No 'pre-auth' context exists for this STA that sent
 			 * an Authentication frame3. Send Auth frame4 with
@@ -1058,8 +1060,8 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 
 		if (auth_node->mlmState == eLIM_MLM_AUTH_RSP_TIMEOUT_STATE) {
 			pe_warn("auth response timer timedout for peer "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * Received Auth Frame3 after Auth Response timeout.
 			 * Reject by sending Auth Frame4 with
@@ -1086,9 +1088,9 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 			 * to delete STA context.
 			 */
 			pe_err("rx Auth frm3 from peer with status code %d "
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 				rx_auth_frm_body->authStatusCode,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 				return;
 		}
 		/*
@@ -1121,8 +1123,8 @@ static void lim_process_auth_frame_type3(struct mac_context *mac_ctx,
 				pe_session);
 			return;
 		} else {
-			pe_warn("Challenge failure for peer "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			pe_warn("Challenge failure for peer "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * Challenge Failure.
 			 * Send Authentication frame4 with 'challenge failure'
@@ -1156,9 +1158,9 @@ static void lim_process_auth_frame_type4(struct mac_context *mac_ctx,
 		 * Log error and ignore the frame.
 		 */
 		pe_warn("received unexpected Auth frame4 from peer in state %d, addr "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			pe_session->limMlmState,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -1170,9 +1172,9 @@ static void lim_process_auth_frame_type4(struct mac_context *mac_ctx,
 		 * failure to SME.
 		 */
 		pe_err("received Auth frame4 from peer with invalid auth algo %d"
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authAlgoNumber,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -1185,8 +1187,8 @@ static void lim_process_auth_frame_type4(struct mac_context *mac_ctx,
 		 * Wait until Authentication Failure Timeout.
 		 */
 
-		pe_warn("received Auth frame4 from unexpected peer "QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+		pe_warn("received Auth frame4 from unexpected peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -1199,9 +1201,9 @@ static void lim_process_auth_frame_type4(struct mac_context *mac_ctx,
 		 */
 
 		pe_err("received Authentication frame from peer with invalid auth seq number %d "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authTransactionSeqNumber,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -1235,8 +1237,8 @@ static void lim_process_auth_frame_type4(struct mac_context *mac_ctx,
 		 * Authentication failure.
 		 * Return Auth confirm with received failure code to SME
 		 */
-		pe_err("Authentication failure from peer "QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+		pe_err("Authentication failure from peer "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		lim_restore_from_auth_state(mac_ctx, eSIR_SME_AUTH_REFUSED,
 				rx_auth_frm_body->authStatusCode,
 				pe_session);
@@ -1299,8 +1301,8 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 
 	if (!frame_len) {
 		/* Log error */
-		pe_err("received Auth frame with no body from: %pM",
-			mac_hdr->sa);
+		pe_err("received Auth frame with no body from: "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 
@@ -1309,8 +1311,8 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		 * Received Auth frame from a BC/MC address
 		 * Log error and ignore it
 		 */
-		pe_err("received Auth frame from a BC/MC addr: %pM",
-			mac_hdr->sa);
+		pe_err("received Auth frame from a BC/MC addr: "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		return;
 	}
 	curr_seq_num = (mac_hdr->seqControl.seqNumHi << 4) |
@@ -1334,10 +1336,10 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 	}
 	auth_alg = *(uint16_t *) body_ptr;
 
-	pe_nofl_info("Auth RX: vdev %d sys role %d lim_state %d from " QDF_MAC_ADDR_STR " rssi %d auth_alg %d seq %d",
+	pe_nofl_info("Auth RX: vdev %d sys role %d lim_state %d from " QDF_MAC_ADDR_FMT " rssi %d auth_alg %d seq %d",
 		     pe_session->vdev_id, GET_LIM_SYSTEM_ROLE(pe_session),
 		     pe_session->limMlmState,
-		     QDF_MAC_ADDR_ARRAY(mac_hdr->sa),
+		     QDF_MAC_ADDR_REF(mac_hdr->sa),
 		     WMA_GET_RX_RSSI_NORMALIZED(rx_pkt_info),
 		     auth_alg, curr_seq_num);
 
@@ -1398,8 +1400,9 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 			auth_frame->authStatusCode =
 				eSIR_MAC_CHALLENGE_FAILURE_STATUS;
 			/* Log error */
-			pe_err("rx Auth frm with wep bit set role: %d %pM",
-				GET_LIM_SYSTEM_ROLE(pe_session), mac_hdr->sa);
+			pe_err("rx Auth frm with wep bit set role: %d "QDF_MAC_ADDR_FMT,
+				GET_LIM_SYSTEM_ROLE(pe_session),
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			lim_send_auth_mgmt_frame(mac_ctx, auth_frame,
 				mac_hdr->sa, LIM_NO_WEP_IN_FC,
 				pe_session);
@@ -1426,8 +1429,8 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 
 		if (!cfg_privacy_opt_imp) {
 			pe_err("received Authentication frame3 from peer that while privacy option is turned OFF "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * Privacy option is not implemented.
 			 * So reject Authentication frame received with
@@ -1455,8 +1458,8 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		auth_node = lim_search_pre_auth_list(mac_ctx, mac_hdr->sa);
 		if (!auth_node) {
 			pe_err("rx Auth frame with no preauth ctx with WEP bit set "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * No 'pre-auth' context exists for this STA
 			 * that sent an Authentication frame with FC
@@ -1482,9 +1485,9 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 			(auth_node->mlmState !=
 				eLIM_MLM_AUTH_RSP_TIMEOUT_STATE)) {
 			pe_err("received Authentication frame from peer that is in state %d "
-				QDF_MAC_ADDR_STR,
+				QDF_MAC_ADDR_FMT,
 				auth_node->mlmState,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/*
 			 * Should not have received Authentication frame
 			 * with WEP bit set in FC in other states.
@@ -1543,8 +1546,8 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 							SIR_MAC_WEP_IV_LENGTH));
 		if (decrypt_result == LIM_DECRYPT_ICV_FAIL) {
 			pe_err("received Authentication frame from peer that failed decryption: "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(mac_hdr->sa));
 			/* ICV failure */
 			lim_delete_pre_auth_node(mac_ctx, mac_hdr->sa);
 			auth_frame->authAlgoNumber = eSIR_SHARED_KEY;
@@ -1630,9 +1633,9 @@ lim_process_auth_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		break;
 	default:
 		/* Invalid Authentication Frame received. Ignore it. */
-		pe_warn("rx auth frm with invalid authseq no: %d from: %pM",
+		pe_warn("rx auth frm with invalid authseq no: %d from: "QDF_MAC_ADDR_FMT,
 			rx_auth_frm_body->authTransactionSeqNumber,
-			mac_hdr->sa);
+			QDF_MAC_ADDR_REF(mac_hdr->sa));
 		break;
 	}
 free:
@@ -1723,8 +1726,8 @@ QDF_STATUS lim_process_auth_frame_no_session(struct mac_context *mac, uint8_t *p
 	pBody = WMA_GET_RX_MPDU_DATA(pBd);
 	frameLen = WMA_GET_RX_PAYLOAD_LEN(pBd);
 
-	pe_debug("Auth Frame Received: BSSID " QDF_MAC_ADDR_STR " (RSSI %d)",
-		 QDF_MAC_ADDR_ARRAY(pHdr->bssId),
+	pe_debug("Auth Frame Received: BSSID " QDF_MAC_ADDR_FMT " (RSSI %d)",
+		 QDF_MAC_ADDR_REF(pHdr->bssId),
 		 (uint) abs((int8_t) WMA_GET_RX_RSSI_NORMALIZED(pBd)));
 
 	if (frameLen == 0) {

core/mac/src/pe/lim/lim_process_beacon_frame.c

@@ -68,9 +68,9 @@ lim_process_beacon_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 	 */
 	mac_hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
 
-	pe_debug("Beacon (len %d): " QDF_MAC_ADDR_STR " RSSI %d",
+	pe_debug("Beacon (len %d): " QDF_MAC_ADDR_FMT " RSSI %d",
 		 WMA_GET_RX_MPDU_LEN(rx_pkt_info),
-		 QDF_MAC_ADDR_ARRAY(mac_hdr->sa),
+		 QDF_MAC_ADDR_REF(mac_hdr->sa),
 		 (uint)abs((int8_t)
 		 WMA_GET_RX_RSSI_NORMALIZED(rx_pkt_info)));
 

core/mac/src/pe/lim/lim_process_deauth_frame.c

@@ -149,8 +149,9 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 	/* Get reasonCode from Deauthentication frame body */
 	reasonCode = sir_read_u16(pBody);
 
-	pe_nofl_info("Deauth RX: vdev %d from %pM for %pM RSSI = %d reason %d mlm state = %d, sme state = %d systemrole = %d ",
-		     pe_session->vdev_id, pHdr->sa, pHdr->da, frame_rssi,
+	pe_nofl_info("Deauth RX: vdev %d from "QDF_MAC_ADDR_FMT" for "QDF_MAC_ADDR_FMT" RSSI = %d reason %d mlm state = %d, sme state = %d systemrole = %d ",
+		     pe_session->vdev_id, QDF_MAC_ADDR_REF(pHdr->sa),
+		     QDF_MAC_ADDR_REF(pHdr->da), frame_rssi,
 		     reasonCode, pe_session->limMlmState,
 		     pe_session->limSmeState,
 		     GET_LIM_SYSTEM_ROLE(pe_session));
@@ -176,8 +177,8 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 			/* Invalid reasonCode in received Deauthentication frame */
 			/* Log error and ignore the frame */
 			pe_err("received Deauth frame with invalid reasonCode %d from "
-				       QDF_MAC_ADDR_STR, reasonCode,
-				       QDF_MAC_ADDR_ARRAY(pHdr->sa));
+				       QDF_MAC_ADDR_FMT, reasonCode,
+				       QDF_MAC_ADDR_REF(pHdr->sa));
 
 			break;
 		}
@@ -196,17 +197,17 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 			/* Invalid reasonCode in received Deauth frame */
 			/* Log error and ignore the frame */
 			pe_err("received Deauth frame with invalid reasonCode %d from "
-				       QDF_MAC_ADDR_STR, reasonCode,
-				       QDF_MAC_ADDR_ARRAY(pHdr->sa));
+				       QDF_MAC_ADDR_FMT, reasonCode,
+				       QDF_MAC_ADDR_REF(pHdr->sa));
 
 			break;
 		}
 	} else {
 		/* Received Deauth frame un-known role. Log and ignore it */
 		pe_err("received Deauth frame with reasonCode %d in role %d from "
-			QDF_MAC_ADDR_STR, reasonCode,
+			QDF_MAC_ADDR_FMT, reasonCode,
 			GET_LIM_SYSTEM_ROLE(pe_session),
-			QDF_MAC_ADDR_ARRAY(pHdr->sa));
+			QDF_MAC_ADDR_REF(pHdr->sa));
 
 		return;
 	}
@@ -259,10 +260,10 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		}
 		if (!IS_REASSOC_BSSID(mac, pHdr->sa, pe_session)) {
 			pe_debug("Rcv Deauth from unknown/different "
-				"AP while ReAssoc. Ignore " QDF_MAC_ADDR_STR
-				"limReAssocbssId : " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(pHdr->sa),
-				QDF_MAC_ADDR_ARRAY(pe_session->limReAssocbssId));
+				"AP while ReAssoc. Ignore " QDF_MAC_ADDR_FMT
+				"limReAssocbssId : " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(pHdr->sa),
+				QDF_MAC_ADDR_REF(pe_session->limReAssocbssId));
 			return;
 		}
 
@@ -271,10 +272,10 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		 */
 		if (!IS_CURRENT_BSSID(mac, pHdr->sa, pe_session)) {
 			pe_debug("received DeAuth from the New AP to "
-				"which ReAssoc is sent " QDF_MAC_ADDR_STR
-				"pe_session->bssId: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(pHdr->sa),
-				QDF_MAC_ADDR_ARRAY(pe_session->bssId));
+				"which ReAssoc is sent " QDF_MAC_ADDR_FMT
+				"pe_session->bssId: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(pHdr->sa),
+				QDF_MAC_ADDR_REF(pe_session->bssId));
 
 			lim_restore_pre_reassoc_state(mac,
 						      eSIR_SME_REASSOC_REFUSED,
@@ -291,7 +292,7 @@ lim_process_deauth_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		if (!IS_CURRENT_BSSID(mac, pHdr->bssId, pe_session)) {
 			pe_err("received DeAuth from an AP other "
 				"than we're trying to join. Ignore. "
-				QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(pHdr->sa));
+				QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(pHdr->sa));
 
 			if (lim_search_pre_auth_list(mac, pHdr->sa)) {
 				pe_debug("Preauth entry exist. Deleting");
@@ -345,9 +346,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 			 */
 
 			pe_debug("received Deauth frame state %X with failure "
-				"code %d from " QDF_MAC_ADDR_STR,
+				"code %d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 
 			lim_restore_from_auth_state(mac_ctx,
 				eSIR_SME_DEAUTH_WHILE_JOIN,
@@ -357,9 +358,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 
 		case eLIM_MLM_AUTHENTICATED_STATE:
 			pe_debug("received Deauth frame state %X with "
-				"reasonCode=%d from " QDF_MAC_ADDR_STR,
+				"reasonCode=%d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			/* / Issue Deauth Indication to SME. */
 			qdf_mem_copy((uint8_t *) &mlmDeauthInd.peerMacAddr,
 				addr, sizeof(tSirMacAddr));
@@ -383,9 +384,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 			 * if any and issue ASSOC_CNF to SME.
 			 */
 			pe_debug("received Deauth frame state %X with "
-				"reasonCode=%d from " QDF_MAC_ADDR_STR,
+				"reasonCode=%d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			if (lim_search_pre_auth_list(mac_ctx, addr))
 				lim_delete_pre_auth_node(mac_ctx, addr);
 
@@ -420,9 +421,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 		case eLIM_MLM_WT_ADD_STA_RSP_STATE:
 			pe_session->fDeauthReceived = true;
 			pe_debug("Received Deauth frame in state %X with Reason "
-				"Code %d from Peer" QDF_MAC_ADDR_STR,
+				"Code %d from Peer" QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			return;
 
 		case eLIM_MLM_IDLE_STATE:
@@ -432,9 +433,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 				&& (STA_ENTRY_TDLS_PEER == sta_ds->staType)) {
 				pe_err("received Deauth frame in state %X with "
 					"reason code %d from Tdls peer"
-					QDF_MAC_ADDR_STR,
+					QDF_MAC_ADDR_FMT,
 					pe_session->limMlmState, rc,
-					QDF_MAC_ADDR_ARRAY(addr));
+					QDF_MAC_ADDR_REF(addr));
 			lim_send_sme_tdls_del_sta_ind(mac_ctx, sta_ds,
 							pe_session,
 							rc);
@@ -462,23 +463,23 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 
 		case eLIM_MLM_WT_REASSOC_RSP_STATE:
 			pe_err("received Deauth frame state %X with "
-				"reasonCode=%d from " QDF_MAC_ADDR_STR,
+				"reasonCode=%d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			break;
 
 		case eLIM_MLM_WT_FT_REASSOC_RSP_STATE:
 			pe_err("received Deauth frame in FT state %X with "
-				"reasonCode=%d from " QDF_MAC_ADDR_STR,
+				"reasonCode=%d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			break;
 
 		default:
 			pe_err("received Deauth frame in state %X with "
-				"reasonCode=%d from " QDF_MAC_ADDR_STR,
+				"reasonCode=%d from " QDF_MAC_ADDR_FMT,
 				pe_session->limMlmState, rc,
-				QDF_MAC_ADDR_ARRAY(addr));
+				QDF_MAC_ADDR_REF(addr));
 			return;
 		}
 		break;
@@ -506,8 +507,9 @@ void lim_perform_deauth(struct mac_context *mac_ctx, struct pe_session *pe_sessi
 		 * Already in the process of deleting context for the peer
 		 * and received Deauthentication frame. Log and Ignore.
 		 */
-		pe_debug("Deletion is in progress (%d) for peer:%pM in mlmState %d",
-			 sta_ds->sta_deletion_in_progress, addr,
+		pe_debug("Deletion is in progress (%d) for peer:"QDF_MAC_ADDR_FMT" in mlmState %d",
+			 sta_ds->sta_deletion_in_progress,
+			 QDF_MAC_ADDR_REF(addr),
 			 sta_ds->mlmStaContext.mlmState);
 		return;
 	}

core/mac/src/pe/lim/lim_process_disassoc_frame.c

@@ -147,8 +147,9 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 	/* Get reasonCode from Disassociation frame body */
 	reasonCode = sir_read_u16(pBody);
 
-	pe_nofl_info("Disassoc RX: vdev %d from %pM for %pM RSSI = %d reason %d mlm state = %d, sme state = %d systemrole = %d ",
-		     pe_session->vdev_id, pHdr->sa, pHdr->da, frame_rssi,
+	pe_nofl_info("Disassoc RX: vdev %d from "QDF_MAC_ADDR_FMT" for "QDF_MAC_ADDR_FMT" RSSI = %d reason %d mlm state = %d, sme state = %d systemrole = %d ",
+		     pe_session->vdev_id, QDF_MAC_ADDR_REF(pHdr->sa),
+		     QDF_MAC_ADDR_REF(pHdr->da), frame_rssi,
 		     reasonCode, pe_session->limMlmState,
 		     pe_session->limSmeState,
 		     GET_LIM_SYSTEM_ROLE(pe_session));
@@ -169,8 +170,8 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		 * Log error.
 		 */
 		pe_err("received Disassoc frame from STA that does not have context"
-			"reasonCode=%d, addr " QDF_MAC_ADDR_STR,
-			reasonCode, QDF_MAC_ADDR_ARRAY(pHdr->sa));
+			"reasonCode=%d, addr " QDF_MAC_ADDR_FMT,
+			reasonCode, QDF_MAC_ADDR_REF(pHdr->sa));
 		return;
 	}
 
@@ -235,8 +236,8 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 
 		default:
 			/* Invalid reasonCode in received Disassociation frame */
-			pe_warn("received Disassoc frame with invalid reasonCode: %d from " QDF_MAC_ADDR_STR,
-				reasonCode, QDF_MAC_ADDR_ARRAY(pHdr->sa));
+			pe_warn("received Disassoc frame with invalid reasonCode: %d from " QDF_MAC_ADDR_FMT,
+				reasonCode, QDF_MAC_ADDR_REF(pHdr->sa));
 			break;
 		}
 	} else if (LIM_IS_STA_ROLE(pe_session) &&
@@ -252,8 +253,8 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 			/* as long as we're not about to channel switch */
 			if (pe_session->gLimChannelSwitch.state !=
 			    eLIM_CHANNEL_SWITCH_IDLE) {
-				pe_err("Ignoring disassoc frame due to upcoming channel switch, from "QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(pHdr->sa));
+				pe_err("Ignoring disassoc frame due to upcoming channel switch, from "QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(pHdr->sa));
 				return;
 			}
 			break;
@@ -264,9 +265,9 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 	} else {
 		/* Received Disassoc in un-known role. Log and ignore it */
 		pe_err("received Disassoc frame with invalid reasonCode: %d in role:"
-				"%d in sme state: %d from " QDF_MAC_ADDR_STR, reasonCode,
+				"%d in sme state: %d from " QDF_MAC_ADDR_FMT, reasonCode,
 			GET_LIM_SYSTEM_ROLE(pe_session), pe_session->limSmeState,
-			QDF_MAC_ADDR_ARRAY(pHdr->sa));
+			QDF_MAC_ADDR_REF(pHdr->sa));
 
 		return;
 	}
@@ -278,8 +279,9 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		 * Already in the process of deleting context for the peer
 		 * and received Disassociation frame. Log and Ignore.
 		 */
-		pe_debug("Deletion is in progress (%d) for peer:%pM in mlmState %d",
-			 sta->sta_deletion_in_progress, pHdr->sa,
+		pe_debug("Deletion is in progress (%d) for peer:"QDF_MAC_ADDR_FMT" in mlmState %d",
+			 sta->sta_deletion_in_progress,
+			 QDF_MAC_ADDR_REF(pHdr->sa),
 			 sta->mlmStaContext.mlmState);
 		return;
 	}
@@ -294,9 +296,9 @@ lim_process_disassoc_frame(struct mac_context *mac, uint8_t *pRxPacketInfo,
 		    eLIM_MLM_WT_ASSOC_CNF_STATE)
 			sta->mlmStaContext.updateContext = 1;
 
-		pe_err("received Disassoc frame from peer that is in state: %X, addr "QDF_MAC_ADDR_STR,
+		pe_err("received Disassoc frame from peer that is in state: %X, addr "QDF_MAC_ADDR_FMT,
 			sta->mlmStaContext.mlmState,
-			       QDF_MAC_ADDR_ARRAY(pHdr->sa));
+			       QDF_MAC_ADDR_REF(pHdr->sa));
 
 	} /* if (sta->mlmStaContext.mlmState != eLIM_MLM_LINK_ESTABLISHED_STATE) */
 

core/mac/src/pe/lim/lim_process_message_queue.c

@@ -132,8 +132,8 @@ static void lim_process_sae_msg_ap(struct mac_context *mac,
 
 	if (!sta_pre_auth_ctx) {
 		pe_debug("No preauth node created for "
-			 QDF_MAC_ADDR_STR,
-			 QDF_MAC_ADDR_ARRAY(sae_msg->peer_mac_addr));
+			 QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(sae_msg->peer_mac_addr));
 		return;
 	}
 
@@ -141,8 +141,8 @@ static void lim_process_sae_msg_ap(struct mac_context *mac,
 
 	if (sae_msg->sae_status != IEEE80211_STATUS_SUCCESS) {
 		pe_debug("SAE authentication failed for "
-			 QDF_MAC_ADDR_STR " status: %u",
-			 QDF_MAC_ADDR_ARRAY(sae_msg->peer_mac_addr),
+			 QDF_MAC_ADDR_FMT " status: %u",
+			 QDF_MAC_ADDR_REF(sae_msg->peer_mac_addr),
 			 sae_msg->sae_status);
 		if (assoc_req->present) {
 			pe_debug("Assoc req cached; clean it up");
@@ -214,9 +214,9 @@ static void lim_process_sae_msg(struct mac_context *mac, struct sir_sae_msg *bod
 	}
 
 	pe_debug("SAE:status %d limMlmState %d opmode %d peer: "
-		 QDF_MAC_ADDR_STR, sae_msg->sae_status,
+		 QDF_MAC_ADDR_FMT, sae_msg->sae_status,
 		 session->limMlmState, session->opmode,
-		 QDF_MAC_ADDR_ARRAY(sae_msg->peer_mac_addr));
+		 QDF_MAC_ADDR_REF(sae_msg->peer_mac_addr));
 	if (LIM_IS_STA_ROLE(session))
 		lim_process_sae_msg_sta(mac, session, sae_msg);
 	else if (LIM_IS_AP_ROLE(session))
@@ -1803,9 +1803,9 @@ static void lim_process_messages(struct mac_context *mac_ctx,
 					     msg->bodyptr,
 					     sizeof(tSirP2PNoaAttr));
 				pe_debug("bssId"
-					 QDF_MAC_ADDR_STR
+					 QDF_MAC_ADDR_FMT
 					 " ctWin=%d oppPsFlag=%d",
-					 QDF_MAC_ADDR_ARRAY(session_entry->bssId),
+					 QDF_MAC_ADDR_REF(session_entry->bssId),
 					 session_entry->p2pGoPsUpdate.ctWin,
 					 session_entry->p2pGoPsUpdate.oppPsFlag);
 				pe_debug("uNoa1IntervalCnt=%d uNoa1Duration=%d uNoa1Interval=%d uNoa1StartTime=%d",

core/mac/src/pe/lim/lim_process_mlm_host_roam.c

@@ -73,10 +73,10 @@ void lim_process_mlm_reassoc_req(struct mac_context *mac_ctx,
 		return;
 	}
 
-	pe_debug("ReAssoc Req on session: %d role: %d mlm: %d " QDF_MAC_ADDR_STR,
+	pe_debug("ReAssoc Req on session: %d role: %d mlm: %d " QDF_MAC_ADDR_FMT,
 		reassoc_req->sessionId, GET_LIM_SYSTEM_ROLE(session),
 		session->limMlmState,
-		QDF_MAC_ADDR_ARRAY(reassoc_req->peerMacAddr));
+		QDF_MAC_ADDR_REF(reassoc_req->peerMacAddr));
 
 	if (LIM_IS_AP_ROLE(session) ||
 		(session->limMlmState !=
@@ -87,9 +87,9 @@ void lim_process_mlm_reassoc_req(struct mac_context *mac_ctx,
 		 * parameters code.
 		 */
 
-		pe_warn("unexpect msg state: %X role: %d MAC" QDF_MAC_ADDR_STR,
+		pe_warn("unexpect msg state: %X role: %d MAC" QDF_MAC_ADDR_FMT,
 			session->limMlmState, GET_LIM_SYSTEM_ROLE(session),
-			QDF_MAC_ADDR_ARRAY(reassoc_req->peerMacAddr));
+			QDF_MAC_ADDR_REF(reassoc_req->peerMacAddr));
 		lim_print_mlm_state(mac_ctx, LOGW, session->limMlmState);
 		reassoc_cnf.resultCode = eSIR_SME_INVALID_PARAMETERS;
 		reassoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
@@ -398,8 +398,8 @@ void lim_process_sta_mlm_add_bss_rsp_ft(struct mac_context *mac,
 				 &pe_session->dph.dphHashTable);
 	if (!sta) {
 		/* Could not add hash table entry */
-		pe_err("could not add hash entry at DPH for %pM",
-		       pe_session->bssId);
+		pe_err("could not add hash entry at DPH for "QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(pe_session->bssId));
 		goto end;
 	}
 

core/mac/src/pe/lim/lim_process_mlm_req_messages.c

@@ -583,11 +583,11 @@ static QDF_STATUS lim_process_mlm_auth_req_sae(struct mac_context *mac_ctx,
 		session->ssId.ssId,
 		session->ssId.length);
 
-	pe_debug("vdev_id %d ssid %.*s "QDF_MAC_ADDR_STR,
+	pe_debug("vdev_id %d ssid %.*s "QDF_MAC_ADDR_FMT,
 		sae_info->vdev_id,
 		sae_info->ssid.length,
 		sae_info->ssid.ssId,
-		QDF_MAC_ADDR_ARRAY(sae_info->peer_mac_addr.bytes));
+		QDF_MAC_ADDR_REF(sae_info->peer_mac_addr.bytes));
 
 	msg.type = eWNI_SME_TRIGGER_SAE;
 	msg.bodyptr = sae_info;
@@ -661,10 +661,10 @@ static void lim_process_mlm_auth_req(struct mac_context *mac_ctx, uint32_t *msg)
 		return;
 	}
 
-	pe_debug("vdev %d Systemrole %d mlmstate %d from: " QDF_MAC_ADDR_STR "with authtype %d",
+	pe_debug("vdev %d Systemrole %d mlmstate %d from: " QDF_MAC_ADDR_FMT "with authtype %d",
 		 session->vdev_id, GET_LIM_SYSTEM_ROLE(session),
 		 session->limMlmState,
-		 QDF_MAC_ADDR_ARRAY(mac_ctx->lim.gpLimMlmAuthReq->peerMacAddr),
+		 QDF_MAC_ADDR_REF(mac_ctx->lim.gpLimMlmAuthReq->peerMacAddr),
 		 mac_ctx->lim.gpLimMlmAuthReq->authType);
 
 	sir_copy_mac_addr(curr_bssid, session->bssId);
@@ -687,8 +687,8 @@ static void lim_process_mlm_auth_req(struct mac_context *mac_ctx, uint32_t *msg)
 	 */
 	if (lim_is_preauth_ctx_exists(mac_ctx, session, &preauth_node)) {
 		pe_debug("Already have pre-auth context with peer: "
-		    QDF_MAC_ADDR_STR,
-		    QDF_MAC_ADDR_ARRAY(mac_ctx->lim.gpLimMlmAuthReq->peerMacAddr));
+		    QDF_MAC_ADDR_FMT,
+		    QDF_MAC_ADDR_REF(mac_ctx->lim.gpLimMlmAuthReq->peerMacAddr));
 		mlm_auth_cnf.resultCode = (tSirResultCodes)
 						eSIR_MAC_SUCCESS_STATUS;
 		goto end;
@@ -866,9 +866,9 @@ static void lim_process_mlm_assoc_req(struct mac_context *mac_ctx, uint32_t *msg
 		 * Return Assoc confirm with Invalid parameters code.
 		 */
 		pe_warn("received unexpected MLM_ASSOC_CNF in state %X for role=%d, MAC addr= "
-			   QDF_MAC_ADDR_STR, session_entry->limMlmState,
+			   QDF_MAC_ADDR_FMT, session_entry->limMlmState,
 			GET_LIM_SYSTEM_ROLE(session_entry),
-			QDF_MAC_ADDR_ARRAY(mlm_assoc_req->peerMacAddr));
+			QDF_MAC_ADDR_REF(mlm_assoc_req->peerMacAddr));
 		lim_print_mlm_state(mac_ctx, LOGW, session_entry->limMlmState);
 		mlm_assoc_cnf.resultCode = eSIR_SME_INVALID_PARAMETERS;
 		mlm_assoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
@@ -971,9 +971,9 @@ lim_process_mlm_disassoc_req_ntf(struct mac_context *mac_ctx,
 				return;
 			}
 
-			pe_debug("send disassoc rsp with ret code %d for" QDF_MAC_ADDR_STR,
-				eSIR_SME_DEAUTH_STATUS,
-				QDF_MAC_ADDR_ARRAY(
+			pe_debug("send disassoc rsp with ret code %d for "QDF_MAC_ADDR_FMT,
+				 eSIR_SME_DEAUTH_STATUS,
+				 QDF_MAC_ADDR_REF(
 					mlm_disassocreq->peer_macaddr.bytes));
 
 			sme_disassoc_rsp->messageType = eWNI_SME_DISASSOC_RSP;
@@ -1016,8 +1016,8 @@ lim_process_mlm_disassoc_req_ntf(struct mac_context *mac_ctx,
 		 * Received LIM_MLM_DISASSOC_REQ for STA that does not
 		 * have context or in some transit state.
 		 */
-		pe_warn("Invalid MLM_DISASSOC_REQ, Addr= " QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(mlm_disassocreq->peer_macaddr.bytes));
+		pe_warn("Invalid MLM_DISASSOC_REQ, Addr= " QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mlm_disassocreq->peer_macaddr.bytes));
 		if (stads)
 			pe_err("Sta MlmState: %d", stads->mlmStaContext.mlmState);
 
@@ -1283,11 +1283,11 @@ lim_process_mlm_deauth_req_ntf(struct mac_context *mac_ctx,
 			if (qdf_mem_cmp(mlm_deauth_req->peer_macaddr.bytes,
 					curr_bssId, QDF_MAC_ADDR_SIZE)) {
 				pe_err("received MLM_DEAUTH_REQ with invalid BSS id "
-					   "Peer MAC: "QDF_MAC_ADDR_STR
-					   " CFG BSSID Addr : "QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(
+					   "Peer MAC: "QDF_MAC_ADDR_FMT
+					   " CFG BSSID Addr : "QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(
 						mlm_deauth_req->peer_macaddr.bytes),
-					QDF_MAC_ADDR_ARRAY(curr_bssId));
+					QDF_MAC_ADDR_REF(curr_bssId));
 				/*
 				 * Deauthentication response to host triggered
 				 * deauthentication
@@ -1340,9 +1340,9 @@ lim_process_mlm_deauth_req_ntf(struct mac_context *mac_ctx,
 			break;
 		default:
 			pe_warn("received MLM_DEAUTH_REQ with in state %d for peer "
-				   QDF_MAC_ADDR_STR,
+				   QDF_MAC_ADDR_FMT,
 				session->limMlmState,
-				QDF_MAC_ADDR_ARRAY(
+				QDF_MAC_ADDR_REF(
 					mlm_deauth_req->peer_macaddr.bytes));
 			lim_print_mlm_state(mac_ctx, LOGW,
 					    session->limMlmState);
@@ -1378,12 +1378,10 @@ lim_process_mlm_deauth_req_ntf(struct mac_context *mac_ctx,
 			 * Associated nor Pre-authenticated. Log error,
 			 * Prepare and Send LIM_MLM_DEAUTH_CNF
 			 */
-			pe_warn("rcvd MLM_DEAUTH_REQ in mlme state %d",
-				session->limMlmState);
-			pe_warn("STA does not have context, Addr="
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(
-				mlm_deauth_req->peer_macaddr.bytes));
+			pe_warn("rcvd MLM_DEAUTH_REQ in mlme state %d STA does not have context, Addr="QDF_MAC_ADDR_FMT,
+				session->limMlmState,
+				QDF_MAC_ADDR_REF(
+					mlm_deauth_req->peer_macaddr.bytes));
 			mlm_deauth_cnf.resultCode =
 				eSIR_SME_STA_NOT_AUTHENTICATED;
 		} else {
@@ -1408,8 +1406,8 @@ lim_process_mlm_deauth_req_ntf(struct mac_context *mac_ctx,
 		 * received MLM_DEAUTH_REQ for STA that either has no
 		 * context or in some transit state
 		 */
-		pe_warn("Invalid MLM_DEAUTH_REQ, Addr=" QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(mlm_deauth_req->
+		pe_warn("Invalid MLM_DEAUTH_REQ, Addr=" QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(mlm_deauth_req->
 			peer_macaddr.bytes));
 		/* Prepare and Send LIM_MLM_DEAUTH_CNF */
 		mlm_deauth_cnf.resultCode = eSIR_SME_INVALID_PARAMETERS;
@@ -1554,9 +1552,9 @@ void lim_process_join_failure_timeout(struct mac_context *mac_ctx)
 					eLIM_PERIODIC_JOIN_PROBE_REQ_TIMER);
 		/* Issue MLM join confirm with timeout reason code */
 		pe_err("Join Failure Timeout, In eLIM_MLM_WT_JOIN_BEACON_STATE session:%d "
-			   QDF_MAC_ADDR_STR,
+			   QDF_MAC_ADDR_FMT,
 			session->peSessionId,
-			QDF_MAC_ADDR_ARRAY(session->bssId));
+			QDF_MAC_ADDR_REF(session->bssId));
 
 		mlm_join_cnf.resultCode = eSIR_SME_JOIN_TIMEOUT_RESULT_CODE;
 		mlm_join_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
@@ -1836,14 +1834,14 @@ lim_process_auth_rsp_timeout(struct mac_context *mac_ctx, uint32_t auth_idx)
 	if (LIM_IS_AP_ROLE(session)) {
 		if (auth_node->mlmState != eLIM_MLM_WT_AUTH_FRAME3_STATE) {
 			pe_err("received AUTH rsp timeout in unexpected "
-				   "state for MAC address: " QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(auth_node->peerMacAddr));
+				   "state for MAC address: " QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(auth_node->peerMacAddr));
 		} else {
 			auth_node->mlmState = eLIM_MLM_AUTH_RSP_TIMEOUT_STATE;
 			auth_node->fTimerStarted = 0;
 			pe_debug("AUTH rsp timedout for MAC address "
-				   QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(auth_node->peerMacAddr));
+				   QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(auth_node->peerMacAddr));
 			/* Change timer to reactivate it in future */
 			lim_deactivate_and_change_per_sta_id_timer(mac_ctx,
 				eLIM_AUTH_RSP_TIMER, auth_node->authNodeIdx);
@@ -1903,14 +1901,14 @@ void lim_process_assoc_failure_timeout(struct mac_context *mac_ctx,
 	    mlme_get_reconn_after_assoc_timeout_flag(mac_ctx->psoc,
 						     session->vdev_id)) {
 		pe_debug("vdev: %d skip sending deauth on channel freq %d to BSSID: "
-			QDF_MAC_ADDR_STR, session->vdev_id,
+			QDF_MAC_ADDR_FMT, session->vdev_id,
 			session->curr_op_freq,
-			QDF_MAC_ADDR_ARRAY(session->bssId));
+			QDF_MAC_ADDR_REF(session->bssId));
 	} else {
 		pe_debug("vdev: %d try sending deauth on channel freq %d to BSSID: "
-			QDF_MAC_ADDR_STR, session->vdev_id,
+			QDF_MAC_ADDR_FMT, session->vdev_id,
 			session->curr_op_freq,
-			QDF_MAC_ADDR_ARRAY(session->bssId));
+			QDF_MAC_ADDR_REF(session->bssId));
 		lim_send_deauth_mgmt_frame(mac_ctx,
 					   eSIR_MAC_UNSPEC_FAILURE_REASON,
 					   session->bssId, session, false);
@@ -1949,8 +1947,8 @@ void lim_process_assoc_failure_timeout(struct mac_context *mac_ctx,
 		}
 		/* To remove the preauth node in case of fail to associate */
 		if (lim_search_pre_auth_list(mac_ctx, session->bssId)) {
-			pe_debug("delete pre auth node for "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(session->bssId));
+			pe_debug("delete pre auth node for "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(session->bssId));
 			lim_delete_pre_auth_node(mac_ctx,
 						 session->bssId);
 		}

core/mac/src/pe/lim/lim_process_mlm_rsp_messages.c

@@ -995,8 +995,8 @@ static void lim_process_mlm_deauth_ind(struct mac_context *mac_ctx,
 					   deauth_ind->peerMacAddr,
 					   &session_id);
 	if (!session) {
-		pe_err("session does not exist for Addr:" QDF_MAC_ADDR_STR,
-		       QDF_MAC_ADDR_ARRAY(deauth_ind->peerMacAddr));
+		pe_err("session does not exist for Addr:" QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(deauth_ind->peerMacAddr));
 		return;
 	}
 	role = GET_LIM_SYSTEM_ROLE(session);
@@ -1447,9 +1447,9 @@ void lim_process_sta_mlm_add_sta_rsp(struct mac_context *mac_ctx,
 	if (true == session_entry->fDeauthReceived) {
 		pe_err("Received Deauth frame in ADD_STA_RESP state");
 		if (QDF_STATUS_SUCCESS == add_sta_params->status) {
-			pe_err("ADD_STA success, send update result code with eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA limMlmState: %d bssid %pM",
+			pe_err("ADD_STA success, send update result code with eSIR_SME_JOIN_DEAUTH_FROM_AP_DURING_ADD_STA limMlmState: %d bssid "QDF_MAC_ADDR_FMT,
 				session_entry->limMlmState,
-				add_sta_params->staMac);
+				QDF_MAC_ADDR_REF(add_sta_params->staMac));
 
 			if (session_entry->limSmeState ==
 					eLIM_SME_WT_REASSOC_STATE)
@@ -1600,7 +1600,8 @@ void lim_process_sta_mlm_del_bss_rsp(struct mac_context *mac,
 			status_code = eSIR_SME_REFUSED;
 			goto end;
 		}
-		pe_debug("STA AssocID %d MAC %pM", sta->assocId, sta->staAddr);
+		pe_debug("STA AssocID %d MAC "QDF_MAC_ADDR_FMT, sta->assocId,
+			 QDF_MAC_ADDR_REF(sta->staAddr));
 	} else {
 		pe_err("DEL BSS failed!");
 		status_code = eSIR_SME_STOP_BSS_FAILURE;
@@ -1811,8 +1812,8 @@ void lim_process_ap_mlm_del_sta_rsp(struct mac_context *mac_ctx,
 	}
 
 	pe_debug("AP received the DEL_STA_RSP for assocID: %X sta mac "
-		QDF_MAC_ADDR_STR, del_sta_params->assocId,
-		QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+		QDF_MAC_ADDR_FMT, del_sta_params->assocId,
+		QDF_MAC_ADDR_REF(sta_ds->staAddr));
 	if ((eLIM_MLM_WT_DEL_STA_RSP_STATE != sta_ds->mlmStaContext.mlmState) &&
 	    (eLIM_MLM_WT_ASSOC_DEL_STA_RSP_STATE !=
 	     sta_ds->mlmStaContext.mlmState)) {
@@ -1964,8 +1965,8 @@ void lim_process_ap_mlm_add_sta_rsp(struct mac_context *mac,
 	/* if the AssocRsp frame is not acknowledged, then keep alive timer will take care of the state */
 	sta->valid = 1;
 	sta->mlmStaContext.mlmState = eLIM_MLM_WT_ASSOC_CNF_STATE;
-	pe_debug("AddStaRsp Success.STA AssocID %d sta mac" QDF_MAC_ADDR_STR,
-		 sta->assocId, QDF_MAC_ADDR_ARRAY(sta->staAddr));
+	pe_debug("AddStaRsp Success.STA AssocID %d sta mac" QDF_MAC_ADDR_FMT,
+		 sta->assocId, QDF_MAC_ADDR_REF(sta->staAddr));
 	lim_print_mac_addr(mac, sta->staAddr, LOGD);
 
 	/* For BTAMP-AP, the flow sequence shall be:
@@ -2685,11 +2686,11 @@ static void lim_process_switch_channel_join_req(
 				mac_ctx->lim.gLimHeartBeatApMac[apCount], sizeof(tSirMacAddr))) {
 
 				pe_err("Index %d Sessionid: %d Send deauth on "
-				"channel freq %d to BSSID: " QDF_MAC_ADDR_STR,
+				"channel freq %d to BSSID: " QDF_MAC_ADDR_FMT,
 				apCount,
 				session_entry->peSessionId,
 				session_entry->curr_op_freq,
-				QDF_MAC_ADDR_ARRAY(
+				QDF_MAC_ADDR_REF(
 				session_entry->pLimMlmJoinReq->bssDescription.bssId));
 
 				lim_send_deauth_mgmt_frame(mac_ctx, eSIR_MAC_UNSPEC_FAILURE_REASON,
@@ -2729,9 +2730,9 @@ static void lim_process_switch_channel_join_req(
 	/* assign appropriate sessionId to the timer object */
 	mac_ctx->lim.lim_timers.gLimPeriodicJoinProbeReqTimer.sessionId =
 		session_entry->peSessionId;
-	pe_debug("vdev %d Send Probe req on freq %d %.*s  " QDF_MAC_ADDR_STR, session_entry->vdev_id,
+	pe_debug("vdev %d Send Probe req on freq %d %.*s  " QDF_MAC_ADDR_FMT, session_entry->vdev_id,
 		 session_entry->curr_op_freq, ssId.length, ssId.ssId,
-		 QDF_MAC_ADDR_ARRAY(
+		 QDF_MAC_ADDR_REF(
 		 session_entry->pLimMlmJoinReq->bssDescription.bssId));
 
 	/*

core/mac/src/pe/lim/lim_process_probe_req_frame.c

@@ -281,8 +281,8 @@ lim_process_probe_req_frame(struct mac_context *mac_ctx, uint8_t *rx_pkt_info,
 		if (sir_convert_probe_req_frame2_struct(mac_ctx, body_ptr,
 				frame_len, &probe_req) == QDF_STATUS_E_FAILURE) {
 			pe_err("Parse error ProbeReq, length: %d, SA is: "
-					QDF_MAC_ADDR_STR, frame_len,
-					QDF_MAC_ADDR_ARRAY(mac_hdr->sa));
+					QDF_MAC_ADDR_FMT, frame_len,
+					QDF_MAC_ADDR_REF(mac_hdr->sa));
 			return;
 		}
 		if (session->opmode == QDF_P2P_GO_MODE) {

core/mac/src/pe/lim/lim_process_probe_rsp_frame.c

@@ -136,9 +136,9 @@ lim_process_probe_rsp_frame(struct mac_context *mac_ctx, uint8_t *rx_Packet_info
 	}
 
 	frame_len = WMA_GET_RX_PAYLOAD_LEN(rx_Packet_info);
-	pe_debug("Probe Resp(len %d): " QDF_MAC_ADDR_STR " RSSI %d",
+	pe_debug("Probe Resp(len %d): " QDF_MAC_ADDR_FMT " RSSI %d",
 		 WMA_GET_RX_MPDU_LEN(rx_Packet_info),
-		 QDF_MAC_ADDR_ARRAY(header->bssId),
+		 QDF_MAC_ADDR_REF(header->bssId),
 		 (uint)abs((int8_t)
 		 WMA_GET_RX_RSSI_NORMALIZED(rx_Packet_info)));
 	/* Get pointer to Probe Response frame body */

core/mac/src/pe/lim/lim_process_sme_req_messages.c

@@ -1044,9 +1044,9 @@ static void lim_update_sae_config(struct pe_session *session,
 {
 	session->sae_pmk_cached = sme_join_req->sae_pmk_cached;
 
-	pe_debug("pmk_cached %d for BSSID=" QDF_MAC_ADDR_STR,
+	pe_debug("pmk_cached %d for BSSID=" QDF_MAC_ADDR_FMT,
 		session->sae_pmk_cached,
-		QDF_MAC_ADDR_ARRAY(sme_join_req->bssDescription.bssId));
+		QDF_MAC_ADDR_REF(sme_join_req->bssDescription.bssId));
 }
 #else
 static inline void lim_update_sae_config(struct pe_session *session,
@@ -1249,9 +1249,9 @@ __lim_process_sme_join_req(struct mac_context *mac_ctx, void *msg_buf)
 
 		if (session) {
 			pe_err("Session(%d) Already exists for BSSID: "
-				   QDF_MAC_ADDR_STR " in limSmeState = %X",
+				   QDF_MAC_ADDR_FMT " in limSmeState = %X",
 				session_id,
-				QDF_MAC_ADDR_ARRAY(bss_desc->bssId),
+				QDF_MAC_ADDR_REF(bss_desc->bssId),
 				session->limSmeState);
 
 			if (session->limSmeState == eLIM_SME_LINK_EST_STATE &&
@@ -2014,19 +2014,19 @@ static void __lim_process_sme_disassoc_req(struct mac_context *mac,
 				&sessionId);
 	if (!pe_session) {
 		pe_err("session does not exist for given bssId "
-			   QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(smeDisassocReq.bssid.bytes));
+			   QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(smeDisassocReq.bssid.bytes));
 		retCode = eSIR_SME_INVALID_PARAMETERS;
 		disassocTrigger = eLIM_HOST_DISASSOC;
 		goto sendDisassoc;
 	}
 	pe_debug("vdev %d (session %d) Systemrole %d Reason: %u SmeState: %d limMlmState %d ho fail %d  send OTA %d from: "
-		 QDF_MAC_ADDR_STR, pe_session->vdev_id, pe_session->peSessionId,
+		 QDF_MAC_ADDR_FMT, pe_session->vdev_id, pe_session->peSessionId,
 		 GET_LIM_SYSTEM_ROLE(pe_session), smeDisassocReq.reasonCode,
 		 pe_session->limSmeState, pe_session->limMlmState,
 		 smeDisassocReq.process_ho_fail,
 		 smeDisassocReq.doNotSendOverTheAir,
-		 QDF_MAC_ADDR_ARRAY(smeDisassocReq.peer_macaddr.bytes));
+		 QDF_MAC_ADDR_REF(smeDisassocReq.peer_macaddr.bytes));
 
 #ifdef FEATURE_WLAN_DIAG_SUPPORT_LIM    /* FEATURE_WLAN_DIAG_SUPPORT */
 	lim_diag_event_report(mac, WLAN_PE_DIAG_DISASSOC_REQ_EVENT, pe_session,
@@ -2272,8 +2272,8 @@ void __lim_process_sme_disassoc_cnf(struct mac_context *mac, uint32_t *msg_buf)
 				&pe_session->dph.dphHashTable);
 		if (!sta) {
 			pe_err("DISASSOC_CNF for a STA with no context, addr= "
-				QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(smeDisassocCnf.peer_macaddr.bytes));
+				QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(smeDisassocCnf.peer_macaddr.bytes));
 			status = lim_prepare_disconnect_done_ind(mac, &msg,
 						pe_session->smeSessionId,
 						eSIR_SME_INVALID_PARAMETERS,
@@ -2289,8 +2289,8 @@ void __lim_process_sme_disassoc_cnf(struct mac_context *mac, uint32_t *msg_buf)
 				eLIM_MLM_WT_DEL_STA_RSP_STATE) ||
 			(sta->mlmStaContext.mlmState ==
 				eLIM_MLM_WT_DEL_BSS_RSP_STATE)) {
-			pe_err("No need of cleanup for addr:" QDF_MAC_ADDR_STR "as MLM state is %d",
-				QDF_MAC_ADDR_ARRAY(smeDisassocCnf.peer_macaddr.bytes),
+			pe_err("No need of cleanup for addr:" QDF_MAC_ADDR_FMT "as MLM state is %d",
+				QDF_MAC_ADDR_REF(smeDisassocCnf.peer_macaddr.bytes),
 				sta->mlmStaContext.mlmState);
 			status = lim_prepare_disconnect_done_ind(mac, &msg,
 						pe_session->smeSessionId,
@@ -2363,10 +2363,10 @@ static void __lim_process_sme_deauth_req(struct mac_context *mac_ctx,
 		goto send_deauth;
 	}
 	pe_debug("vdev %d (session %d) Systemrole %d reasoncode %u limSmestate %d limMlmState %d from "
-		 QDF_MAC_ADDR_STR, vdev_id, session_entry->peSessionId,
+		 QDF_MAC_ADDR_FMT, vdev_id, session_entry->peSessionId,
 		 GET_LIM_SYSTEM_ROLE(session_entry), sme_deauth_req.reasonCode,
 		 session_entry->limSmeState, session_entry->limMlmState,
-		 QDF_MAC_ADDR_ARRAY(sme_deauth_req.peer_macaddr.bytes));
+		 QDF_MAC_ADDR_REF(sme_deauth_req.peer_macaddr.bytes));
 #ifdef FEATURE_WLAN_DIAG_SUPPORT_LIM    /* FEATURE_WLAN_DIAG_SUPPORT */
 	lim_diag_event_report(mac_ctx, WLAN_PE_DIAG_DEAUTH_REQ_EVENT,
 			session_entry, 0, sme_deauth_req.reasonCode);
@@ -3101,8 +3101,8 @@ __lim_process_sme_delts_req(struct mac_context *mac, uint32_t *msg_buf)
 	}
 
 	pe_debug("Sent DELTS request to station with assocId = %d MacAddr = "
-		QDF_MAC_ADDR_STR,
-		pDeltsReq->aid, QDF_MAC_ADDR_ARRAY(peerMacAddr));
+		QDF_MAC_ADDR_FMT,
+		pDeltsReq->aid, QDF_MAC_ADDR_REF(peerMacAddr));
 
 	lim_send_delts_req_action_frame(mac, peerMacAddr,
 					pDeltsReq->req.wmeTspecPresent,
@@ -4120,13 +4120,13 @@ static void __lim_process_send_disassoc_frame(struct mac_context *mac_ctx,
 	session_entry = pe_find_session_by_vdev_id(mac_ctx, req->vdev_id);
 	if (!session_entry) {
 		pe_err("session does not exist for given bssId "
-		       QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(req->peer_mac));
+		       QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(req->peer_mac));
 		return;
 	}
 
-	pe_debug("msg_type %d len %d vdev_id %d mac: " QDF_MAC_ADDR_STR " reason %d wait_for_ack %d",
+	pe_debug("msg_type %d len %d vdev_id %d mac: " QDF_MAC_ADDR_FMT " reason %d wait_for_ack %d",
 		 req->msg_type, req->length,  req->vdev_id,
-		 QDF_MAC_ADDR_ARRAY(req->peer_mac), req->reason, req->wait_for_ack);
+		 QDF_MAC_ADDR_REF(req->peer_mac), req->reason, req->wait_for_ack);
 
 	lim_send_disassoc_mgmt_frame(mac_ctx, req->reason, req->peer_mac,
 				     session_entry, req->wait_for_ack);
@@ -4447,8 +4447,8 @@ static void lim_process_sme_disassoc_cnf(struct mac_context *mac_ctx,
 					   sme_disassoc_cnf.bssid.bytes,
 					   &session_id);
 	if (!session) {
-		pe_err("session not found for bssid:%pM",
-		       sme_disassoc_cnf.bssid.bytes);
+		pe_err("session not found for bssid:"QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(sme_disassoc_cnf.bssid.bytes));
 		status = lim_prepare_disconnect_done_ind
 						(mac_ctx, &err_msg,
 						sme_disassoc_cnf.vdev_id,
@@ -4482,8 +4482,8 @@ static void lim_process_sme_disassoc_req(struct mac_context *mac_ctx,
 					   disassoc_req.bssid.bytes,
 					   &session_id);
 	if (!session) {
-		pe_err("session not found for bssid:%pM",
-		       disassoc_req.bssid.bytes);
+		pe_err("session not found for bssid:"QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(disassoc_req.bssid.bytes));
 		lim_send_sme_disassoc_ntf(mac_ctx,
 					  disassoc_req.peer_macaddr.bytes,
 					  eSIR_SME_INVALID_PARAMETERS,
@@ -4530,8 +4530,8 @@ static void lim_process_sme_deauth_req(struct mac_context *mac_ctx,
 					   sme_deauth_req.bssid.bytes,
 					   &session_id);
 	if (!session) {
-		pe_err("session not found for bssid:%pM",
-		       sme_deauth_req.bssid.bytes);
+		pe_err("session not found for bssid:"QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(sme_deauth_req.bssid.bytes));
 		lim_send_sme_deauth_ntf(mac_ctx,
 					sme_deauth_req.peer_macaddr.bytes,
 					eSIR_SME_INVALID_PARAMETERS,
@@ -5159,8 +5159,8 @@ static void lim_process_modify_add_ies(struct mac_context *mac_ctx,
 
 	if (!session_entry) {
 		pe_err("Session not found for given bssid"
-					QDF_MAC_ADDR_STR,
-		QDF_MAC_ADDR_ARRAY(modify_add_ies->modifyIE.bssid.bytes));
+					QDF_MAC_ADDR_FMT,
+		QDF_MAC_ADDR_REF(modify_add_ies->modifyIE.bssid.bytes));
 		goto end;
 	}
 	if ((0 == modify_add_ies->modifyIE.ieBufferlength) ||
@@ -5238,8 +5238,8 @@ static void lim_process_update_add_ies(struct mac_context *mac_ctx,
 
 	if (!session_entry) {
 		pe_debug("Session not found for given bssid"
-			 QDF_MAC_ADDR_STR,
-			 QDF_MAC_ADDR_ARRAY(update_ie->bssid.bytes));
+			 QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(update_ie->bssid.bytes));
 		goto end;
 	}
 	addn_ie = &session_entry->add_ie_params;
@@ -5458,8 +5458,8 @@ static void lim_process_sme_dfs_csa_ie_request(struct mac_context *mac_ctx,
 	session_entry = pe_find_session_by_bssid(mac_ctx,
 			dfs_csa_ie_req->bssid, &session_id);
 	if (!session_entry) {
-		pe_err("Session not found for given BSSID" QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(dfs_csa_ie_req->bssid));
+		pe_err("Session not found for given BSSID" QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(dfs_csa_ie_req->bssid));
 		return;
 	}
 

core/mac/src/pe/lim/lim_process_tdls.c

@@ -424,12 +424,12 @@ static uint32_t lim_prepare_tdls_frame_header(struct mac_context *mac, uint8_t *
 		     (uint8_t *) (addr3), sizeof(tSirMacAddr));
 
 	pe_debug("Preparing TDLS frame header to %s A1:"
-		   QDF_MAC_ADDR_STR", A2:"QDF_MAC_ADDR_STR", A3:"
-		   QDF_MAC_ADDR_STR,
+		   QDF_MAC_ADDR_FMT", A2:"QDF_MAC_ADDR_FMT", A3:"
+		   QDF_MAC_ADDR_FMT,
 		(tdlsLinkType == TDLS_LINK_AP) ? "AP" : "DIRECT",
-		QDF_MAC_ADDR_ARRAY(pMacHdr->addr1),
-		QDF_MAC_ADDR_ARRAY(pMacHdr->addr2),
-		QDF_MAC_ADDR_ARRAY(pMacHdr->addr3));
+		QDF_MAC_ADDR_REF(pMacHdr->addr1),
+		QDF_MAC_ADDR_REF(pMacHdr->addr2),
+		QDF_MAC_ADDR_REF(pMacHdr->addr3));
 
 	if (pMacHdr->fc.subType == SIR_MAC_DATA_QOS_DATA) {
 		pMacHdr->qosControl.tid = tid;
@@ -636,10 +636,10 @@ static QDF_STATUS lim_send_tdls_dis_req_frame(struct mac_context *mac,
 	}
 #endif
 
-	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_DISCOVERY_REQUEST,
 		lim_trace_tdls_action_string(TDLS_DISCOVERY_REQUEST),
-		QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -941,10 +941,10 @@ static QDF_STATUS lim_send_tdls_dis_rsp_frame(struct mac_context *mac,
 		qdf_mem_copy(pFrame + sizeof(tSirMacMgmtHdr) + nPayload, addIe,
 			     addIeLen);
 	}
-	pe_debug("[TDLS] action: %d (%s) -DIRECT-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -DIRECT-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_DISCOVERY_RESPONSE,
 		lim_trace_tdls_action_string(TDLS_DISCOVERY_RESPONSE),
-		QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -1007,8 +1007,8 @@ static void populate_dotf_tdls_vht_aid(struct mac_context *mac, uint32_t selfDot
 			} else {
 				Aid->present = 0;
 				pe_err("sta is NULL for "
-					   QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(peerMac.bytes));
+					   QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(peerMac.bytes));
 			}
 		}
 	} else {
@@ -1318,10 +1318,10 @@ QDF_STATUS lim_send_tdls_link_setup_req_frame(struct mac_context *mac,
 			     addIeLen);
 	}
 
-	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_SETUP_REQUEST,
 		lim_trace_tdls_action_string(TDLS_SETUP_REQUEST),
-		QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -1509,12 +1509,12 @@ QDF_STATUS lim_send_tdls_teardown_frame(struct mac_context *mac,
 				    padLen - MIN_VENDOR_SPECIFIC_IE_SIZE);
 	}
 #endif
-	pe_debug("[TDLS] action: %d (%s) -%s-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -%s-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_TEARDOWN,
 		lim_trace_tdls_action_string(TDLS_TEARDOWN),
 		((reason == eSIR_MAC_TDLS_TEARDOWN_PEER_UNREACHABLE) ? "AP" :
 		    "DIRECT"),
-		QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -1771,10 +1771,10 @@ static QDF_STATUS lim_send_tdls_setup_rsp_frame(struct mac_context *mac,
 			     addIeLen);
 	}
 
-	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_SETUP_RESPONSE,
 		lim_trace_tdls_action_string(TDLS_SETUP_RESPONSE),
-		QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -1978,10 +1978,10 @@ QDF_STATUS lim_send_tdls_link_setup_cnf_frame(struct mac_context *mac,
 	}
 #endif
 
-	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_STR,
+	pe_debug("[TDLS] action: %d (%s) -AP-> OTA peer="QDF_MAC_ADDR_FMT,
 		TDLS_SETUP_CONFIRM,
 		lim_trace_tdls_action_string(TDLS_SETUP_CONFIRM),
-	       QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+	       QDF_MAC_ADDR_REF(peer_mac.bytes));
 
 	mac->lim.tdls_frm_session_id = pe_session->smeSessionId;
 	lim_diag_mgmt_tx_event_report(mac, (tpSirMacMgmtHdr) pFrame,
@@ -2500,14 +2500,14 @@ static QDF_STATUS lim_tdls_setup_add_sta(struct mac_context *mac,
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (sta && pAddStaReq->tdls_oper == TDLS_OPER_ADD) {
-		pe_err("TDLS entry for peer: "QDF_MAC_ADDR_STR " already exist, cannot add new entry",
-			QDF_MAC_ADDR_ARRAY(pAddStaReq->peermac.bytes));
+		pe_err("TDLS entry for peer: "QDF_MAC_ADDR_FMT " already exist, cannot add new entry",
+			QDF_MAC_ADDR_REF(pAddStaReq->peermac.bytes));
 			return QDF_STATUS_E_FAILURE;
 	}
 
 	if (sta && sta->staType != STA_ENTRY_TDLS_PEER) {
-		pe_err("Non TDLS entry for peer: "QDF_MAC_ADDR_STR " already exist",
-			QDF_MAC_ADDR_ARRAY(pAddStaReq->peermac.bytes));
+		pe_err("Non TDLS entry for peer: "QDF_MAC_ADDR_FMT " already exist",
+			QDF_MAC_ADDR_REF(pAddStaReq->peermac.bytes));
 			return QDF_STATUS_E_FAILURE;
 	}
 
@@ -2515,16 +2515,16 @@ static QDF_STATUS lim_tdls_setup_add_sta(struct mac_context *mac,
 		aid = lim_assign_peer_idx(mac, pe_session);
 
 		if (!aid) {
-			pe_err("No more free AID for peer: "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(pAddStaReq->peermac.bytes));
+			pe_err("No more free AID for peer: "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(pAddStaReq->peermac.bytes));
 			return QDF_STATUS_E_FAILURE;
 		}
 
 		/* Set the aid in peerAIDBitmap as it has been assigned to TDLS peer */
 		SET_PEER_AID_BITMAP(pe_session->peerAIDBitmap, aid);
 
-		pe_debug("Aid: %d, for peer: " QDF_MAC_ADDR_STR,
-			aid, QDF_MAC_ADDR_ARRAY(pAddStaReq->peermac.bytes));
+		pe_debug("Aid: %d, for peer: " QDF_MAC_ADDR_FMT,
+			aid, QDF_MAC_ADDR_REF(pAddStaReq->peermac.bytes));
 		sta =
 			dph_get_hash_entry(mac, aid,
 					   &pe_session->dph.dphHashTable);
@@ -2580,8 +2580,8 @@ static QDF_STATUS lim_tdls_del_sta(struct mac_context *mac,
 	if (sta && sta->staType == STA_ENTRY_TDLS_PEER)
 		status = lim_del_sta(mac, sta, resp_reqd, pe_session);
 	else
-		pe_debug("TDLS peer "QDF_MAC_ADDR_STR" not found",
-			 QDF_MAC_ADDR_ARRAY(peerMac.bytes));
+		pe_debug("TDLS peer "QDF_MAC_ADDR_FMT" not found",
+			 QDF_MAC_ADDR_REF(peerMac.bytes));
 
 	return status;
 }
@@ -2644,8 +2644,8 @@ QDF_STATUS lim_process_tdls_add_sta_rsp(struct mac_context *mac, void *msg,
 	uint16_t aid = 0;
 
 	SET_LIM_PROCESS_DEFD_MESGS(mac, true);
-	pe_debug("staMac: "QDF_MAC_ADDR_STR,
-	       QDF_MAC_ADDR_ARRAY(pAddStaParams->staMac));
+	pe_debug("staMac: "QDF_MAC_ADDR_FMT,
+	       QDF_MAC_ADDR_REF(pAddStaParams->staMac));
 
 	if (pAddStaParams->status != QDF_STATUS_SUCCESS) {
 		QDF_ASSERT(0);
@@ -3037,8 +3037,8 @@ static void lim_check_aid_and_delete_peer(struct mac_context *p_mac,
 			if (!stads)
 				goto skip;
 
-			pe_debug("Deleting "QDF_MAC_ADDR_STR,
-				QDF_MAC_ADDR_ARRAY(stads->staAddr));
+			pe_debug("Deleting "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(stads->staAddr));
 
 			if (!lim_is_roam_synch_in_progress(p_mac->psoc,
 							   session_entry)) {

core/mac/src/pe/lim/lim_scan_result_utils.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-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
@@ -114,7 +114,7 @@ lim_collect_bss_description(struct mac_context *mac,
 
 	if (!pBssDescr->beaconInterval) {
 		pe_warn("Beacon Interval is ZERO, making it to default 100 "
-			   QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(pHdr->bssId));
+			   QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(pHdr->bssId));
 		pBssDescr->beaconInterval = 100;
 	}
 	/*
@@ -143,16 +143,17 @@ lim_collect_bss_description(struct mac_context *mac,
 
 	/* SINR no longer reported by HW */
 	pBssDescr->sinr = 0;
-	pe_debug(QDF_MAC_ADDR_STR " rssi: normalized: %d, absolute: %d",
-		QDF_MAC_ADDR_ARRAY(pHdr->bssId), pBssDescr->rssi,
+	pe_debug(QDF_MAC_ADDR_FMT " rssi: normalized: %d, absolute: %d",
+		QDF_MAC_ADDR_REF(pHdr->bssId), pBssDescr->rssi,
 		pBssDescr->rssi_raw);
 
 	pBssDescr->received_time = (uint64_t)qdf_mc_timer_get_system_time();
 	pBssDescr->tsf_delta = WMA_GET_RX_TSF_DELTA(pRxPacketInfo);
 	pBssDescr->seq_ctrl = pHdr->seqControl;
 
-	pe_debug("Received %s from BSSID: %pM tsf_delta = %u Seq Num: %x ssid:%.*s, rssi: %d",
-		 pBssDescr->fProbeRsp ? "Probe Rsp" : "Beacon", pHdr->bssId,
+	pe_debug("Received %s from BSSID: "QDF_MAC_ADDR_FMT" tsf_delta = %u Seq Num: %x ssid:%.*s, rssi: %d",
+		 pBssDescr->fProbeRsp ? "Probe Rsp" : "Beacon",
+		 QDF_MAC_ADDR_REF(pHdr->bssId),
 		 pBssDescr->tsf_delta, ((pHdr->seqControl.seqNumHi <<
 		 HIGH_SEQ_NUM_OFFSET) | pHdr->seqControl.seqNumLo),
 		 pBPR->ssId.length, pBPR->ssId.ssId, pBssDescr->rssi_raw);

core/mac/src/pe/lim/lim_security_utils.c

@@ -363,8 +363,9 @@ void lim_delete_pre_auth_node(struct mac_context *mac, tSirMacAddr macAddr)
 
 		mac->lim.pLimPreAuthList = pTempNode->next;
 
-		pe_debug("fRelease data for %d peer %pM",
-			 pTempNode->authNodeIdx, macAddr);
+		pe_debug("fRelease data for %d peer "QDF_MAC_ADDR_FMT,
+			 pTempNode->authNodeIdx,
+			 QDF_MAC_ADDR_REF(macAddr));
 		lim_release_pre_auth_node(mac, pTempNode);
 
 		return;

core/mac/src/pe/lim/lim_send_management_frames.c

@@ -414,9 +414,9 @@ lim_send_probe_req_mgmt_frame(struct mac_context *mac_ctx,
 			     additional_ie, addn_ielen);
 		payload += addn_ielen;
 	}
-	pe_nofl_debug("Probe req TX: vdev %d seq num %d to " QDF_MAC_ADDR_STR " len %d",
+	pe_nofl_debug("Probe req TX: vdev %d seq num %d to " QDF_MAC_ADDR_FMT " len %d",
 		      vdev_id, mac_ctx->mgmtSeqNum,
-		      QDF_MAC_ADDR_ARRAY(bssid),
+		      QDF_MAC_ADDR_REF(bssid),
 		      (int)sizeof(tSirMacMgmtHdr) + payload);
 
 	/* If this probe request is sent during P2P Search State, then we need
@@ -1535,8 +1535,9 @@ lim_send_assoc_rsp_mgmt_frame(
 			status);
 	}
 
-	pe_nofl_debug("Assoc rsp TX: vdev %d subtype %d to %pM seq num %d status %d aid %d",
-		      pe_session->vdev_id, subtype, mac_hdr->da,
+	pe_nofl_debug("Assoc rsp TX: vdev %d subtype %d to "QDF_MAC_ADDR_FMT" seq num %d status %d aid %d",
+		      pe_session->vdev_id, subtype,
+		      QDF_MAC_ADDR_REF(mac_hdr->da),
 		      mac_ctx->mgmtSeqNum, status_code, aid);
 
 	if (addn_ie_len && addn_ie_len <= WNI_CFG_ASSOC_RSP_ADDNIE_DATA_LEN)
@@ -2461,8 +2462,9 @@ lim_send_assoc_req_mgmt_frame(struct mac_context *mac_ctx,
 	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
 			 pe_session->peSessionId, mac_hdr->fc.subType));
 
-	pe_nofl_info("Assoc req TX: vdev %d to %pM seq num %d", pe_session->vdev_id,
-		     pe_session->bssId, mac_ctx->mgmtSeqNum);
+	pe_nofl_info("Assoc req TX: vdev %d to "QDF_MAC_ADDR_FMT" seq num %d", pe_session->vdev_id,
+		     QDF_MAC_ADDR_REF(pe_session->bssId),
+		     mac_ctx->mgmtSeqNum);
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
 			  frame, (uint16_t)(sizeof(tSirMacMgmtHdr) + payload));
 
@@ -2921,10 +2923,10 @@ alloc_packet:
 		}
 	}
 
-	pe_nofl_info("Auth TX: seq %d seq num %d status %d WEP %d to " QDF_MAC_ADDR_STR,
+	pe_nofl_info("Auth TX: seq %d seq num %d status %d WEP %d to " QDF_MAC_ADDR_FMT,
 		     auth_frame->authTransactionSeqNumber, mac_ctx->mgmtSeqNum,
 		     auth_frame->authStatusCode, mac_hdr->fc.wep,
-		     QDF_MAC_ADDR_ARRAY(mac_hdr->da));
+		     QDF_MAC_ADDR_REF(mac_hdr->da));
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
 			   frame, frame_len);
 
@@ -3402,10 +3404,10 @@ lim_send_disassoc_mgmt_frame(struct mac_context *mac,
 				&nPayload, discon_ie);
 	mlme_free_self_disconnect_ies(pe_session->vdev);
 
-	pe_nofl_info("Disassoc TX: vdev %d seq %d reason %u and waitForAck %d to " QDF_MAC_ADDR_STR " From " QDF_MAC_ADDR_STR,
+	pe_nofl_info("Disassoc TX: vdev %d seq %d reason %u and waitForAck %d to " QDF_MAC_ADDR_FMT " From " QDF_MAC_ADDR_FMT,
 		     pe_session->vdev_id, mac->mgmtSeqNum, nReason, waitForAck,
-		     QDF_MAC_ADDR_ARRAY(pMacHdr->da),
-		     QDF_MAC_ADDR_ARRAY(pe_session->self_mac_addr));
+		     QDF_MAC_ADDR_REF(pMacHdr->da),
+		     QDF_MAC_ADDR_REF(pe_session->self_mac_addr));
 
 	if (!wlan_reg_is_24ghz_ch_freq(pe_session->curr_op_freq) ||
 	    pe_session->opmode == QDF_P2P_CLIENT_MODE ||
@@ -3590,10 +3592,10 @@ lim_send_deauth_mgmt_frame(struct mac_context *mac,
 				&nPayload, discon_ie);
 	mlme_free_self_disconnect_ies(pe_session->vdev);
 
-	pe_nofl_info("Deauth TX: vdev %d seq_num %d reason %u waitForAck %d to " QDF_MAC_ADDR_STR " from " QDF_MAC_ADDR_STR,
+	pe_nofl_info("Deauth TX: vdev %d seq_num %d reason %u waitForAck %d to " QDF_MAC_ADDR_FMT " from " QDF_MAC_ADDR_FMT,
 		     pe_session->vdev_id, mac->mgmtSeqNum, nReason, waitForAck,
-		     QDF_MAC_ADDR_ARRAY(pMacHdr->da),
-		     QDF_MAC_ADDR_ARRAY(pe_session->self_mac_addr));
+		     QDF_MAC_ADDR_REF(pMacHdr->da),
+		     QDF_MAC_ADDR_REF(pe_session->self_mac_addr));
 
 	if (!wlan_reg_is_24ghz_ch_freq(pe_session->curr_op_freq) ||
 	    pe_session->opmode == QDF_P2P_CLIENT_MODE ||
@@ -4182,8 +4184,8 @@ lim_send_extended_chan_switch_action_frame(struct mac_context *mac_ctx,
 	    session_entry->opmode == QDF_P2P_GO_MODE)
 		txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
 
-	pe_debug("ECSA frame to :"QDF_MAC_ADDR_STR" count %d mode %d chan %d op class %d",
-		 QDF_MAC_ADDR_ARRAY(mac_hdr->da),
+	pe_debug("ECSA frame to :"QDF_MAC_ADDR_FMT" count %d mode %d chan %d op class %d",
+		 QDF_MAC_ADDR_REF(mac_hdr->da),
 		 frm.ext_chan_switch_ann_action.switch_count,
 		 frm.ext_chan_switch_ann_action.switch_mode,
 		 frm.ext_chan_switch_ann_action.new_channel,
@@ -4335,8 +4337,8 @@ lim_p2p_oper_chan_change_confirm_action_frame(struct mac_context *mac_ctx,
 		tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
 	}
 	pe_debug("Send frame on channel freq %d to mac "
-		QDF_MAC_ADDR_STR, session_entry->curr_op_freq,
-		QDF_MAC_ADDR_ARRAY(peer));
+		QDF_MAC_ADDR_FMT, session_entry->curr_op_freq,
+		QDF_MAC_ADDR_REF(peer));
 
 	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
 			session_entry->peSessionId, mac_hdr->fc.subType));
@@ -4589,7 +4591,8 @@ lim_send_link_report_action_frame(struct mac_context *mac,
 			nStatus);
 	}
 
-	pe_warn("RRM: Sending Link Report to %pM on vdev[%d]", peer, vdev_id);
+	pe_warn("RRM: Sending Link Report to "QDF_MAC_ADDR_FMT" on vdev[%d]",
+		QDF_MAC_ADDR_REF(peer), vdev_id);
 
 	if (!wlan_reg_is_24ghz_ch_freq(pe_session->curr_op_freq) ||
 	    pe_session->opmode == QDF_P2P_CLIENT_MODE ||
@@ -4758,13 +4761,14 @@ lim_send_radio_measure_report_action_frame(struct mac_context *mac,
 			nStatus);
 	}
 
-	pe_nofl_info("TX: %s seq_no:%d dialog_token:%d no. of APs:%d is_last_rpt:%d num_report: %d peer:%pM",
+	pe_nofl_info("TX: %s seq_no:%d dialog_token:%d no. of APs:%d is_last_rpt:%d num_report: %d peer:"QDF_MAC_ADDR_FMT,
 		     frm->MeasurementReport[0].type == SIR_MAC_RRM_BEACON_TYPE ?
 		     "[802.11 BCN_RPT]" : "[802.11 RRM]",
 		     (pMacHdr->seqControl.seqNumHi << HIGH_SEQ_NUM_OFFSET |
 		     pMacHdr->seqControl.seqNumLo),
 		     dialog_token, frm->num_MeasurementReport,
-		     is_last_report, num_report, peer);
+		     is_last_report, num_report,
+		     QDF_MAC_ADDR_REF(peer));
 
 	if (!wlan_reg_is_24ghz_ch_freq(pe_session->curr_op_freq) ||
 	    pe_session->opmode == QDF_P2P_CLIENT_MODE ||
@@ -5159,8 +5163,9 @@ QDF_STATUS lim_send_addba_response_frame(struct mac_context *mac_ctx,
 		}
 	}
 
-	pe_debug("Sending a ADDBA Response from %pM to %pM",
-		session->self_mac_addr, peer_mac);
+	pe_debug("Sending a ADDBA Response from "QDF_MAC_ADDR_FMT" to "QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(session->self_mac_addr),
+		 QDF_MAC_ADDR_REF(peer_mac));
 	pe_debug("tid %d dialog_token %d status %d buff_size %d amsdu_supp %d",
 		 tid, frm.DialogToken.token, frm.Status.status,
 		 frm.addba_param_set.buff_size,
@@ -5297,8 +5302,9 @@ static QDF_STATUS lim_delba_tx_complete_cnf(void *context,
 		       status, frame_len);
 		goto error;
 	}
-	pe_debug("delba ota done vdev %d %pM tid %d desc_id %d status %d",
-		 mgmt_params->vdev_id, mac_hdr->da, frm.delba_param_set.tid,
+	pe_debug("delba ota done vdev %d "QDF_MAC_ADDR_FMT" tid %d desc_id %d status %d",
+		 mgmt_params->vdev_id,
+		 QDF_MAC_ADDR_REF(mac_hdr->da), frm.delba_param_set.tid,
 		 mgmt_params->desc_id, tx_complete);
 	cdp_delba_tx_completion(soc, mac_hdr->da, mgmt_params->vdev_id,
 				frm.delba_param_set.tid, tx_complete);
@@ -5329,8 +5335,8 @@ QDF_STATUS lim_send_delba_action_frame(struct mac_context *mac_ctx,
 		pe_debug("delba invalid vdev id %d ", vdev_id);
 		return QDF_STATUS_E_INVAL;
 	}
-	pe_debug("send delba vdev %d %pM tid %d reason %d", vdev_id,
-		 peer_macaddr, tid, reason_code);
+	pe_debug("send delba vdev %d "QDF_MAC_ADDR_FMT" tid %d reason %d", vdev_id,
+		 QDF_MAC_ADDR_REF(peer_macaddr), tid, reason_code);
 	qdf_mem_zero((uint8_t *)&frm, sizeof(frm));
 	frm.Category.category = ACTION_CATEGORY_BACK;
 	frm.Action.action = DELBA;

core/mac/src/pe/lim/lim_send_messages.c

@@ -482,8 +482,8 @@ QDF_STATUS lim_send_ht40_obss_scanind(struct mac_context *mac_ctx,
 	if (!ht40_obss_scanind)
 		return QDF_STATUS_E_FAILURE;
 	QDF_TRACE(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_ERROR,
-		  "OBSS Scan Indication bssid " QDF_MAC_ADDR_STR,
-		  QDF_MAC_ADDR_ARRAY(session->bssId));
+		  "OBSS Scan Indication bssid " QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(session->bssId));
 
 	ht40_obss_scanind->cmd = HT40_OBSS_SCAN_PARAM_START;
 	ht40_obss_scanind->scan_type = eSIR_ACTIVE_SCAN;

core/mac/src/pe/lim/lim_send_sme_rsp_messages.c

@@ -667,8 +667,8 @@ void lim_send_sme_disassoc_ntf(struct mac_context *mac,
 		 * Duplicate entry is removed at LIM.
 		 * Initiate new entry for other session
 		 */
-		pe_debug("Rcvd eLIM_DUPLICATE_ENTRY for " QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(peerMacAddr));
+		pe_debug("Rcvd eLIM_DUPLICATE_ENTRY for " QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(peerMacAddr));
 
 		for (i = 0; i < mac->lim.maxBssId; i++) {
 			session = &mac->lim.gpSession[i];
@@ -710,8 +710,8 @@ void lim_send_sme_disassoc_ntf(struct mac_context *mac,
 			goto error;
 		}
 		pe_debug("send eWNI_SME_DISASSOC_RSP with retCode: %d for "
-			 QDF_MAC_ADDR_STR,
-			 reasonCode, QDF_MAC_ADDR_ARRAY(peerMacAddr));
+			 QDF_MAC_ADDR_FMT,
+			 reasonCode, QDF_MAC_ADDR_REF(peerMacAddr));
 		pSirSmeDisassocRsp->messageType = eWNI_SME_DISASSOC_RSP;
 		pSirSmeDisassocRsp->length = sizeof(struct disassoc_rsp);
 		pSirSmeDisassocRsp->sessionId = smesessionId;
@@ -751,8 +751,8 @@ void lim_send_sme_disassoc_ntf(struct mac_context *mac,
 			goto error;
 		}
 		pe_debug("send eWNI_SME_DISASSOC_IND with retCode: %d for "
-			 QDF_MAC_ADDR_STR,
-			 reasonCode, QDF_MAC_ADDR_ARRAY(peerMacAddr));
+			 QDF_MAC_ADDR_FMT,
+			 reasonCode, QDF_MAC_ADDR_REF(peerMacAddr));
 		pSirSmeDisassocInd->messageType = eWNI_SME_DISASSOC_IND;
 		pSirSmeDisassocInd->length = sizeof(*pSirSmeDisassocInd);
 		pSirSmeDisassocInd->vdev_id = smesessionId;
@@ -936,8 +936,8 @@ lim_send_sme_tdls_del_sta_ind(struct mac_context *mac, tpDphHashNode sta,
 {
 	struct tdls_event_info info;
 
-	pe_debug("Delete TDLS Peer "QDF_MAC_ADDR_STR "with reason code: %d",
-			QDF_MAC_ADDR_ARRAY(sta->staAddr), reasonCode);
+	pe_debug("Delete TDLS Peer "QDF_MAC_ADDR_FMT "with reason code: %d",
+			QDF_MAC_ADDR_REF(sta->staAddr), reasonCode);
 	info.vdev_id = pe_session->smeSessionId;
 	qdf_mem_copy(info.peermac.bytes, sta->staAddr, QDF_MAC_ADDR_SIZE);
 	info.message_type = TDLS_PEER_DISCONNECTED;
@@ -1063,8 +1063,8 @@ void lim_send_sme_deauth_ntf(struct mac_context *mac, tSirMacAddr peerMacAddr,
 		if (!pSirSmeDeauthRsp)
 			return;
 		pe_debug("send eWNI_SME_DEAUTH_RSP with retCode: %d for "
-			 QDF_MAC_ADDR_STR,
-			 reasonCode, QDF_MAC_ADDR_ARRAY(peerMacAddr));
+			 QDF_MAC_ADDR_FMT,
+			 reasonCode, QDF_MAC_ADDR_REF(peerMacAddr));
 		pSirSmeDeauthRsp->messageType = eWNI_SME_DEAUTH_RSP;
 		pSirSmeDeauthRsp->length = sizeof(*pSirSmeDeauthRsp);
 		pSirSmeDeauthRsp->status_code = reasonCode;
@@ -1101,8 +1101,8 @@ void lim_send_sme_deauth_ntf(struct mac_context *mac, tSirMacAddr peerMacAddr,
 		if (!pSirSmeDeauthInd)
 			return;
 		pe_debug("send eWNI_SME_DEAUTH_IND with retCode: %d for "
-			 QDF_MAC_ADDR_STR,
-			 reasonCode, QDF_MAC_ADDR_ARRAY(peerMacAddr));
+			 QDF_MAC_ADDR_FMT,
+			 reasonCode, QDF_MAC_ADDR_REF(peerMacAddr));
 		pSirSmeDeauthInd->messageType = eWNI_SME_DEAUTH_IND;
 		pSirSmeDeauthInd->length = sizeof(*pSirSmeDeauthInd);
 		pSirSmeDeauthInd->reasonCode = eSIR_MAC_UNSPEC_FAILURE_REASON;
@@ -1386,8 +1386,8 @@ void lim_send_sme_pe_ese_tsm_rsp(struct mac_context *mac,
 		/* Fill the Session Id */
 		pPeStats->sessionId = pPeSessionEntry->smeSessionId;
 	} else {
-		pe_err("Session not found for the Sta peer:" QDF_MAC_ADDR_STR,
-		       QDF_MAC_ADDR_ARRAY(pPeStats->bssid.bytes));
+		pe_err("Session not found for the Sta peer:" QDF_MAC_ADDR_FMT,
+		       QDF_MAC_ADDR_REF(pPeStats->bssid.bytes));
 		qdf_mem_free(pPeStats->tsmStatsReq);
 		qdf_mem_free(pPeStats);
 		return;
@@ -1582,8 +1582,8 @@ void lim_handle_csa_offload_msg(struct mac_context *mac_ctx,
 		pe_find_session_by_bssid(mac_ctx,
 			csa_params->bssId, &session_id);
 	if (!session_entry) {
-		pe_err("Session does not exists for %pM",
-				csa_params->bssId);
+		pe_err("Session does not exists for "QDF_MAC_ADDR_FMT,
+				QDF_MAC_ADDR_REF(csa_params->bssId));
 		goto err;
 	}
 
@@ -1926,8 +1926,8 @@ void lim_send_sme_max_assoc_exceeded_ntf(struct mac_context *mac, tSirMacAddr pe
 	pSmeMaxAssocInd->sessionId = smesessionId;
 	mmhMsg.type = pSmeMaxAssocInd->mesgType;
 	mmhMsg.bodyptr = pSmeMaxAssocInd;
-	pe_debug("msgType: %s peerMacAddr "QDF_MAC_ADDR_STR "sme session id %d",
-		"eWNI_SME_MAX_ASSOC_EXCEEDED", QDF_MAC_ADDR_ARRAY(peerMacAddr),
+	pe_debug("msgType: %s peerMacAddr "QDF_MAC_ADDR_FMT "sme session id %d",
+		"eWNI_SME_MAX_ASSOC_EXCEEDED", QDF_MAC_ADDR_REF(peerMacAddr),
 		pSmeMaxAssocInd->sessionId);
 	MTRACE(mac_trace(mac, TRACE_CODE_TX_SME_MSG,
 			 smesessionId, mmhMsg.type));

core/mac/src/pe/lim/lim_session.c

@@ -446,8 +446,8 @@ void lim_set_bcn_probe_filter(struct mac_context *mac_ctx,
 	if (eSIR_INFRASTRUCTURE_MODE == bss_type) {
 		filter->num_sta_sessions++;
 		sir_copy_mac_addr(filter->sta_bssid[session_id], *bssid);
-		pe_debug("Set filter for STA Session %d bssid "QDF_MAC_ADDR_STR,
-			session_id, QDF_MAC_ADDR_ARRAY(*bssid));
+		pe_debug("Set filter for STA Session %d bssid "QDF_MAC_ADDR_FMT,
+			session_id, QDF_MAC_ADDR_REF(*bssid));
 	} else if (eSIR_INFRA_AP_MODE == bss_type) {
 		if (!sap_channel) {
 			pe_err("SAP Type with invalid channel");
@@ -622,8 +622,8 @@ struct pe_session *pe_create_session(struct mac_context *mac,
 	session_ptr->is_session_obss_color_collision_det_enabled =
 		mac->mlme_cfg->obss_ht40.obss_color_collision_offload_enabled;
 
-	pe_debug("Create PE session: %d opmode %d vdev_id %d  BSSID: "QDF_MAC_ADDR_STR" Max No of STA: %d",
-		 *sessionId, opmode, vdev_id, QDF_MAC_ADDR_ARRAY(bssid),
+	pe_debug("Create PE session: %d opmode %d vdev_id %d  BSSID: "QDF_MAC_ADDR_FMT" Max No of STA: %d",
+		 *sessionId, opmode, vdev_id, QDF_MAC_ADDR_REF(bssid),
 		 numSta);
 
 	if (bssType == eSIR_INFRA_AP_MODE) {
@@ -854,9 +854,9 @@ void pe_delete_session(struct mac_context *mac_ctx, struct pe_session *session)
 		return;
 	}
 
-	pe_debug("Delete PE session: %d opmode: %d vdev_id: %d BSSID: "QDF_MAC_ADDR_STR,
+	pe_debug("Delete PE session: %d opmode: %d vdev_id: %d BSSID: "QDF_MAC_ADDR_FMT,
 		 session->peSessionId, session->opmode, session->vdev_id,
-		 QDF_MAC_ADDR_ARRAY(session->bssId));
+		 QDF_MAC_ADDR_REF(session->bssId));
 
 	lim_reset_bcn_probe_filter(mac_ctx, session);
 	lim_sae_auth_cleanup_retry(mac_ctx, session->vdev_id);
@@ -1073,7 +1073,8 @@ struct pe_session *pe_find_session_by_peer_sta(struct mac_context *mac, uint8_t
 		}
 	}
 
-	pe_debug("Session lookup fails for Peer StaId: %pM", sa);
+	pe_debug("Session lookup fails for Peer: "QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(sa));
 	return NULL;
 }
 

core/mac/src/pe/lim/lim_utils.c

@@ -635,7 +635,7 @@ void lim_cleanup_mlm(struct mac_context *mac_ctx)
 
 void lim_print_mac_addr(struct mac_context *mac, tSirMacAddr macAddr, uint8_t logLevel)
 {
-	pe_debug(QDF_MAC_ADDR_STR, QDF_MAC_ADDR_ARRAY(macAddr));
+	pe_debug(QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(macAddr));
 } /****** end lim_print_mac_addr() ******/
 
 /*
@@ -4716,12 +4716,13 @@ void lim_diag_mgmt_tx_event_report(struct mac_context *mac_ctx, void *mgmt_hdr,
 	lim_diag_fill_mgmt_event_report(mac_ctx, mac_hdr, session,
 					result_code, reason_code, &mgmt_event);
 
-	pe_debug("TX frame: type:%d sub_type:%d seq_num:%d ssid:%.*s selfmacaddr:%pM bssid:%pM channel:%d",
+	pe_debug("TX frame: type:%d sub_type:%d seq_num:%d ssid:%.*s selfmacaddr:"QDF_MAC_ADDR_FMT" bssid:"QDF_MAC_ADDR_FMT" channel:%d",
 		 mgmt_event.mgmt_type, mgmt_event.mgmt_subtype,
 		 ((mac_hdr->seqControl.seqNumHi << 4) |
 				mac_hdr->seqControl.seqNumLo),
 		 mgmt_event.ssid_len, mgmt_event.ssid,
-		 mgmt_event.self_mac_addr, mgmt_event.bssid,
+		 QDF_MAC_ADDR_REF(mgmt_event.self_mac_addr),
+		 QDF_MAC_ADDR_REF(mgmt_event.bssid),
 		 mgmt_event.operating_channel);
 	WLAN_HOST_DIAG_EVENT_REPORT(&mgmt_event, EVENT_WLAN_HOST_MGMT_TX_V2);
 }
@@ -4740,12 +4741,13 @@ void lim_diag_mgmt_rx_event_report(struct mac_context *mac_ctx, void *mgmt_hdr,
 	}
 	lim_diag_fill_mgmt_event_report(mac_ctx, mac_hdr, session,
 					result_code, reason_code, &mgmt_event);
-	pe_debug("RX frame: type:%d sub_type:%d seq_num:%d ssid:%.*s selfmacaddr:%pM bssid:%pM channel:%d",
+	pe_debug("RX frame: type:%d sub_type:%d seq_num:%d ssid:%.*s selfmacaddr:"QDF_MAC_ADDR_FMT" bssid:"QDF_MAC_ADDR_FMT" channel:%d",
 		 mgmt_event.mgmt_type, mgmt_event.mgmt_subtype,
 		 ((mac_hdr->seqControl.seqNumHi << 4) |
 				mac_hdr->seqControl.seqNumLo),
 		 mgmt_event.ssid_len, mgmt_event.ssid,
-		 mgmt_event.self_mac_addr, mgmt_event.bssid,
+		 QDF_MAC_ADDR_REF(mgmt_event.self_mac_addr),
+		 QDF_MAC_ADDR_REF(mgmt_event.bssid),
 		 mgmt_event.operating_channel);
 	WLAN_HOST_DIAG_EVENT_REPORT(&mgmt_event, EVENT_WLAN_HOST_MGMT_RX_V2);
 }
@@ -5925,14 +5927,14 @@ void lim_del_pmf_sa_query_timer(struct mac_context *mac_ctx, struct pe_session *
 			continue;
 		if (!sta_ds->rmfEnabled) {
 			pe_debug("no PMF timer for assoc-id:%d sta mac"
-				 QDF_MAC_ADDR_STR, sta_ds->assocId,
-				 QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+				 QDF_MAC_ADDR_FMT, sta_ds->assocId,
+				 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 			continue;
 		}
 
 		pe_debug("Deleting pmfSaQueryTimer for assoc-id:%d sta mac"
-			 QDF_MAC_ADDR_STR, sta_ds->assocId,
-			 QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+			 QDF_MAC_ADDR_FMT, sta_ds->assocId,
+			 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 		tx_timer_deactivate(&sta_ds->pmfSaQueryTimer);
 		tx_timer_delete(&sta_ds->pmfSaQueryTimer);
 	}
@@ -6511,8 +6513,8 @@ bool lim_is_valid_frame(last_processed_msg *last_processed_frm,
 
 	if (last_processed_frm->seq_num == seq_num &&
 		qdf_mem_cmp(last_processed_frm->sa, pHdr->sa, ETH_ALEN) == 0) {
-		pe_err("Duplicate frame from "QDF_MAC_ADDR_STR " Seq Number %d",
-		QDF_MAC_ADDR_ARRAY(pHdr->sa), seq_num);
+		pe_err("Duplicate frame from "QDF_MAC_ADDR_FMT " Seq Number %d",
+		QDF_MAC_ADDR_REF(pHdr->sa), seq_num);
 		return false;
 	}
 	return true;
@@ -6586,12 +6588,12 @@ void lim_ap_check_6g_compatible_peer(struct mac_context *mac_ctx,
 		if (!lim_support_6ghz_band_op_class(
 			mac_ctx, &sta_ds->supp_operating_classes)) {
 			legacy_client_present = true;
-			pe_debug("peer %pM 6ghz not supported",
-				 sta_ds->staAddr);
+			pe_debug("peer "QDF_MAC_ADDR_FMT" 6ghz not supported",
+				 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 			break;
 		}
-		pe_debug("peer %pM 6ghz supported",
-			 sta_ds->staAddr);
+		pe_debug("peer "QDF_MAC_ADDR_FMT" 6ghz supported",
+			 QDF_MAC_ADDR_REF(sta_ds->staAddr));
 	}
 	if (legacy_client_present)
 		policy_mgr_set_ap_6ghz_capable(
@@ -7702,8 +7704,8 @@ lim_rem_blacklist_entry_with_lowest_delta(qdf_list_t *list)
 	}
 
 	if (oldest_node) {
-		pe_debug("remove node %pM with lowest delta %d",
-			oldest_node->bssid.bytes,
+		pe_debug("remove node "QDF_MAC_ADDR_FMT" with lowest delta %d",
+			QDF_MAC_ADDR_REF(oldest_node->bssid.bytes),
 			lim_assoc_rej_get_remaining_delta(oldest_node));
 		qdf_list_remove_node(list, &oldest_node->node);
 		qdf_mem_free(oldest_node);
@@ -8519,7 +8521,8 @@ void lim_flush_bssid(struct mac_context *mac_ctx, uint8_t *bssid)
 	wlan_objmgr_pdev_release_ref(pdev, WLAN_LEGACY_MAC_ID);
 
 	if (QDF_IS_STATUS_SUCCESS(status))
-		pe_debug("Removed BSS entry:%pM from scan cache", bssid);
+		pe_debug("Removed BSS entry:"QDF_MAC_ADDR_FMT" from scan cache",
+			 QDF_MAC_ADDR_REF(bssid));
 
 	if (filter)
 		qdf_mem_free(filter);

core/mac/src/pe/nan/nan_datapath.c

@@ -71,8 +71,8 @@ static QDF_STATUS lim_add_ndi_peer(struct mac_context *mac_ctx,
 		pe_err("NDI Peer already exists!!");
 		return QDF_STATUS_SUCCESS;
 	}
-	pe_info("Need to create NDI Peer :" QDF_MAC_ADDR_STR,
-		QDF_MAC_ADDR_ARRAY(peer_mac_addr.bytes));
+	pe_info("Need to create NDI Peer :" QDF_MAC_ADDR_FMT,
+		QDF_MAC_ADDR_REF(peer_mac_addr.bytes));
 
 	peer_idx = lim_assign_peer_idx(mac_ctx, session);
 	if (!peer_idx) {
@@ -135,8 +135,8 @@ static void lim_ndp_delete_peer_by_addr(struct mac_context *mac_ctx, uint8_t vde
 		return;
 	}
 
-	pe_info("deleting peer: "QDF_MAC_ADDR_STR" confirm rejected",
-		QDF_MAC_ADDR_ARRAY(peer_ndi_mac_addr.bytes));
+	pe_info("deleting peer: "QDF_MAC_ADDR_FMT" confirm rejected",
+		QDF_MAC_ADDR_REF(peer_ndi_mac_addr.bytes));
 
 	session = pe_find_session_by_vdev_id(mac_ctx, vdev_id);
 	if (!session || (session->bssType != eSIR_NDI_MODE)) {
@@ -199,9 +199,9 @@ static void lim_ndp_delete_peers(struct mac_context *mac_ctx,
 		return;
 
 	for (i = 0; i < num_peers; i++) {
-		pe_debug("ndp_map[%d]: MAC: " QDF_MAC_ADDR_STR " num_active %d",
+		pe_debug("ndp_map[%d]: MAC: " QDF_MAC_ADDR_FMT " num_active %d",
 			 i,
-			 QDF_MAC_ADDR_ARRAY(ndp_map[i].peer_ndi_mac_addr.bytes),
+			 QDF_MAC_ADDR_REF(ndp_map[i].peer_ndi_mac_addr.bytes),
 			 ndp_map[i].num_active_ndp_sessions);
 
 		/* Do not delete a peer with active NDPs */
@@ -304,9 +304,9 @@ void lim_process_ndi_del_sta_rsp(struct mac_context *mac_ctx,
 		pe_err("DEL STA failed!");
 		goto skip_event;
 	}
-	pe_info("Deleted STA AssocID %d MAC " QDF_MAC_ADDR_STR,
+	pe_info("Deleted STA AssocID %d MAC " QDF_MAC_ADDR_FMT,
 		sta_ds->assocId,
-		QDF_MAC_ADDR_ARRAY(sta_ds->staAddr));
+		QDF_MAC_ADDR_REF(sta_ds->staAddr));
 
 	qdf_mem_copy(&peer_ind.peer_mac_addr.bytes,
 		sta_ds->staAddr, sizeof(tSirMacAddr));
@@ -468,15 +468,16 @@ void lim_ndp_add_sta_rsp(struct mac_context *mac_ctx, struct pe_session *session
 				    &session->dph.dphHashTable);
 	if (!sta_ds) {
 		pe_err("NAN: ADD_STA_RSP for unknown MAC addr "
-			QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(add_sta_rsp->staMac));
+			QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(add_sta_rsp->staMac));
 		qdf_mem_free(add_sta_rsp);
 		return;
 	}
 
 	if (add_sta_rsp->status != QDF_STATUS_SUCCESS) {
-		pe_err("NAN: ADD_STA_RSP error %x for MAC addr: %pM",
-			add_sta_rsp->status, add_sta_rsp->staMac);
+		pe_err("NAN: ADD_STA_RSP error %x for MAC addr: "QDF_MAC_ADDR_FMT,
+			add_sta_rsp->status,
+			QDF_MAC_ADDR_REF(add_sta_rsp->staMac));
 		/* delete the sta_ds allocated during ADD STA */
 		lim_delete_dph_hash_entry(mac_ctx, add_sta_rsp->staMac,
 				      peer_idx, session);

core/mac/src/pe/rrm/rrm_api.c

@@ -597,11 +597,11 @@ rrm_process_beacon_report_req(struct mac_context *mac,
 
 	measDuration = pBeaconReq->measurement_request.Beacon.meas_duration;
 
-	pe_nofl_info("RX: [802.11 BCN_RPT] seq:%d SSID:%.*s BSSID:%pM Token:%d op_class:%d ch:%d meas_mode:%d meas_duration:%d max_dur: %d sign: %d max_meas_dur: %d",
+	pe_nofl_info("RX: [802.11 BCN_RPT] seq:%d SSID:%.*s BSSID:"QDF_MAC_ADDR_FMT" Token:%d op_class:%d ch:%d meas_mode:%d meas_duration:%d max_dur: %d sign: %d max_meas_dur: %d",
 		     mac->rrm.rrmPEContext.prev_rrm_report_seq_num,
 		     pBeaconReq->measurement_request.Beacon.SSID.num_ssid,
 		     pBeaconReq->measurement_request.Beacon.SSID.ssid,
-		     pBeaconReq->measurement_request.Beacon.BSSID,
+		     QDF_MAC_ADDR_REF(pBeaconReq->measurement_request.Beacon.BSSID),
 		     pBeaconReq->measurement_token,
 		     pBeaconReq->measurement_request.Beacon.regClass,
 		     pBeaconReq->measurement_request.Beacon.channel,
@@ -974,8 +974,8 @@ rrm_process_beacon_report_xmit(struct mac_context *mac_ctx,
 		session_entry = pe_find_session_by_bssid(mac_ctx,
 				beacon_xmit_ind->bssId, &session_id);
 		if (!session_entry) {
-			pe_err("TX: [802.11 BCN_RPT] Session does not exist for bssId:%pM",
-			       beacon_xmit_ind->bssId);
+			pe_err("TX: [802.11 BCN_RPT] Session does not exist for bssId:"QDF_MAC_ADDR_FMT"",
+			       QDF_MAC_ADDR_REF(beacon_xmit_ind->bssId));
 			status = QDF_STATUS_E_FAILURE;
 			goto end;
 		}

core/mac/src/pe/sch/sch_beacon_process.c

@@ -1415,10 +1415,10 @@ QDF_STATUS lim_process_obss_detection_ind(struct mac_context *mac_ctx,
 	enum reg_wifi_band rf_band = REG_BAND_UNKNOWN;
 	struct obss_detection_cfg *cur_detect;
 
-	pe_debug("obss detect ind id %d, reason %d, msk 0x%x, " QDF_MAC_ADDR_STR,
+	pe_debug("obss detect ind id %d, reason %d, msk 0x%x, " QDF_MAC_ADDR_FMT,
 		 obss_detection->vdev_id, obss_detection->reason,
 		 obss_detection->matched_detection_masks,
-		 QDF_MAC_ADDR_ARRAY(obss_detection->matched_bssid_addr));
+		 QDF_MAC_ADDR_REF(obss_detection->matched_bssid_addr));
 
 	session = pe_find_session_by_vdev_id(mac_ctx, obss_detection->vdev_id);
 	if (!session) {

core/mac/src/sys/legacy/src/system/src/sys_entry_func.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-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
@@ -116,24 +116,24 @@ QDF_STATUS sys_bbt_process_message_core(struct mac_context *mac_ctx,
 
 		mac_hdr = WMA_GET_RX_MAC_HEADER(bd_ptr);
 		if (subtype == SIR_MAC_MGMT_ASSOC_REQ) {
-			pe_debug("ASSOC REQ frame allowed: da: " QDF_MAC_ADDR_STR ", sa: " QDF_MAC_ADDR_STR ", bssid: " QDF_MAC_ADDR_STR ", Assoc Req count so far: %d",
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->da),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->sa),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->bssId),
+			pe_debug("ASSOC REQ frame allowed: da: " QDF_MAC_ADDR_FMT ", sa: " QDF_MAC_ADDR_FMT ", bssid: " QDF_MAC_ADDR_FMT ", Assoc Req count so far: %d",
+				 QDF_MAC_ADDR_REF(mac_hdr->da),
+				 QDF_MAC_ADDR_REF(mac_hdr->sa),
+				 QDF_MAC_ADDR_REF(mac_hdr->bssId),
 				 mac_ctx->sys.gSysFrameCount[type][subtype]);
 		}
 		if (subtype == SIR_MAC_MGMT_DEAUTH) {
-			pe_debug("DEAUTH frame allowed: da: " QDF_MAC_ADDR_STR ", sa: " QDF_MAC_ADDR_STR ", bssid: " QDF_MAC_ADDR_STR ", DEAUTH count so far: %d",
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->da),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->sa),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->bssId),
+			pe_debug("DEAUTH frame allowed: da: " QDF_MAC_ADDR_FMT ", sa: " QDF_MAC_ADDR_FMT ", bssid: " QDF_MAC_ADDR_FMT ", DEAUTH count so far: %d",
+				 QDF_MAC_ADDR_REF(mac_hdr->da),
+				 QDF_MAC_ADDR_REF(mac_hdr->sa),
+				 QDF_MAC_ADDR_REF(mac_hdr->bssId),
 				 mac_ctx->sys.gSysFrameCount[type][subtype]);
 		}
 		if (subtype == SIR_MAC_MGMT_DISASSOC) {
-			pe_debug("DISASSOC frame allowed: da: " QDF_MAC_ADDR_STR ", sa: " QDF_MAC_ADDR_STR ", bssid: " QDF_MAC_ADDR_STR ", DISASSOC count so far: %d",
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->da),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->sa),
-				 QDF_MAC_ADDR_ARRAY(mac_hdr->bssId),
+			pe_debug("DISASSOC frame allowed: da: " QDF_MAC_ADDR_FMT ", sa: " QDF_MAC_ADDR_FMT ", bssid: " QDF_MAC_ADDR_FMT ", DISASSOC count so far: %d",
+				 QDF_MAC_ADDR_REF(mac_hdr->da),
+				 QDF_MAC_ADDR_REF(mac_hdr->sa),
+				 QDF_MAC_ADDR_REF(mac_hdr->bssId),
 				 mac_ctx->sys.gSysFrameCount[type][subtype]);
 		}