qcacld-3.0: sme: 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: I5c537f3940825fa784f026a7e28adc75eeb99d09

core/sme/src/common/sme_api.c

@@ -4372,7 +4372,8 @@ struct wlan_objmgr_vdev
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
 	struct wlan_objmgr_vdev *vdev;
 
-	sme_debug("addr:%pM opmode:%d", vdev_params->macaddr,
+	sme_debug("addr:"QDF_MAC_ADDR_FMT" opmode:%d",
+		  QDF_MAC_ADDR_REF(vdev_params->macaddr),
 		  vdev_params->opmode);
 
 	vdev = wlan_objmgr_vdev_obj_create(mac_ctx->pdev, vdev_params);
@@ -11654,8 +11655,8 @@ int sme_send_he_om_ctrl_update(mac_handle_t mac_handle, uint8_t session_id)
 		 omi_data.ch_bw, omi_data.tx_nsts, omi_data.rx_nss,
 		 omi_data.ul_mu_dis, omi_data.omi_in_vht, omi_data.omi_in_he);
 	qdf_mem_copy(&param_val, &omi_data, sizeof(omi_data));
-	sme_debug("param val %08X, bssid:"QDF_MAC_ADDR_STR, param_val,
-		  QDF_MAC_ADDR_ARRAY(session->connectedProfile.bssid.bytes));
+	sme_debug("param val %08X, bssid:"QDF_MAC_ADDR_FMT, param_val,
+		  QDF_MAC_ADDR_REF(session->connectedProfile.bssid.bytes));
 	status = wma_set_peer_param(wma_handle,
 				    session->connectedProfile.bssid.bytes,
 				    WMI_PEER_PARAM_XMIT_OMI,
@@ -14745,8 +14746,8 @@ static bool sme_get_status_for_candidate(mac_handle_t mac_handle,
 	 */
 	if ((bss_desc->rssi < mbo_cfg->mbo_candidate_rssi_thres) &&
 	    (conn_bss_desc->rssi > mbo_cfg->mbo_current_rssi_thres)) {
-		sme_err("Candidate BSS "QDF_MAC_ADDR_STR" has LOW RSSI(%d), hence reject",
-			QDF_MAC_ADDR_ARRAY(bss_desc->bssId), bss_desc->rssi);
+		sme_err("Candidate BSS "QDF_MAC_ADDR_FMT" has LOW RSSI(%d), hence reject",
+			QDF_MAC_ADDR_REF(bss_desc->bssId), bss_desc->rssi);
 		info->status = QCA_STATUS_REJECT_LOW_RSSI;
 		return true;
 	}
@@ -14765,8 +14766,8 @@ static bool sme_get_status_for_candidate(mac_handle_t mac_handle,
 		current_rssi_mcc_thres = mbo_cfg->mbo_current_rssi_mcc_thres;
 		if ((conn_bss_desc->rssi > current_rssi_mcc_thres) &&
 		    csr_is_mcc_channel(mac_ctx, bss_chan_freq)) {
-			sme_err("Candidate BSS "QDF_MAC_ADDR_STR" causes MCC, hence reject",
-				QDF_MAC_ADDR_ARRAY(bss_desc->bssId));
+			sme_err("Candidate BSS "QDF_MAC_ADDR_FMT" causes MCC, hence reject",
+				QDF_MAC_ADDR_REF(bss_desc->bssId));
 			info->status =
 				QCA_STATUS_REJECT_INSUFFICIENT_QOS_CAPACITY;
 			return true;
@@ -14783,8 +14784,8 @@ static bool sme_get_status_for_candidate(mac_handle_t mac_handle,
 		    WLAN_REG_IS_24GHZ_CH_FREQ(bss_chan_freq) &&
 		    is_bt_in_progress &&
 		    (bss_desc->rssi < mbo_cfg->mbo_candidate_rssi_btc_thres)) {
-			sme_err("Candidate BSS "QDF_MAC_ADDR_STR" causes BT coex, hence reject",
-				QDF_MAC_ADDR_ARRAY(bss_desc->bssId));
+			sme_err("Candidate BSS "QDF_MAC_ADDR_FMT" causes BT coex, hence reject",
+				QDF_MAC_ADDR_REF(bss_desc->bssId));
 			info->status =
 				QCA_STATUS_REJECT_EXCESSIVE_DELAY_EXPECTED;
 			return true;
@@ -14802,8 +14803,8 @@ static bool sme_get_status_for_candidate(mac_handle_t mac_handle,
 
 		if (conn_bss_chan_safe && !bss_chan_safe) {
 			sme_err("High interference expected if transitioned to BSS "
-				QDF_MAC_ADDR_STR" hence reject",
-				QDF_MAC_ADDR_ARRAY(bss_desc->bssId));
+				QDF_MAC_ADDR_FMT" hence reject",
+				QDF_MAC_ADDR_REF(bss_desc->bssId));
 			info->status =
 				QCA_STATUS_REJECT_HIGH_INTERFERENCE;
 			return true;
@@ -14854,8 +14855,8 @@ QDF_STATUS sme_get_bss_transition_status(mac_handle_t mac_handle,
 						       &info[i].bssid,
 						       res);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
-			sme_err("BSS "QDF_MAC_ADDR_STR" not present in scan list",
-				QDF_MAC_ADDR_ARRAY(info[i].bssid.bytes));
+			sme_err("BSS "QDF_MAC_ADDR_FMT" not present in scan list",
+				QDF_MAC_ADDR_REF(info[i].bssid.bytes));
 			info[i].status = QCA_STATUS_REJECT_UNKNOWN;
 			continue;
 		}
@@ -15029,9 +15030,9 @@ QDF_STATUS sme_handle_sae_msg(mac_handle_t mac_handle,
 			     peer_mac_addr.bytes,
 			     QDF_MAC_ADDR_SIZE);
 		sme_debug("SAE: sae_status %d vdev_id %d Peer: "
-			  QDF_MAC_ADDR_STR, sae_msg->sae_status,
+			  QDF_MAC_ADDR_FMT, sae_msg->sae_status,
 			  sae_msg->vdev_id,
-			  QDF_MAC_ADDR_ARRAY(sae_msg->peer_mac_addr));
+			  QDF_MAC_ADDR_REF(sae_msg->peer_mac_addr));
 
 		sch_msg.type = eWNI_SME_SEND_SAE_MSG;
 		sch_msg.bodyptr = sae_msg;

core/sme/src/csr/csr_api_roam.c

@@ -181,9 +181,9 @@ static QDF_STATUS csr_sae_callback(struct mac_context *mac_ctx,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	sme_debug("vdev_id %d "QDF_MAC_ADDR_STR"",
+	sme_debug("vdev_id %d "QDF_MAC_ADDR_FMT,
 		sae_info->vdev_id,
-		QDF_MAC_ADDR_ARRAY(sae_info->peer_mac_addr.bytes));
+		QDF_MAC_ADDR_REF(sae_info->peer_mac_addr.bytes));
 
 	session_id = sae_info->vdev_id;
 	if (session_id == WLAN_UMAC_VDEV_ID_MAX)
@@ -547,8 +547,8 @@ csr_roam_issue_disassociate(struct mac_context *mac, uint32_t sessionId,
 			     sizeof(struct qdf_mac_addr));
 	}
 
-	sme_debug("Disassociate Bssid " QDF_MAC_ADDR_STR " subState: %s reason: %d",
-		  QDF_MAC_ADDR_ARRAY(bssId.bytes),
+	sme_debug("Disassociate Bssid " QDF_MAC_ADDR_FMT " subState: %s reason: %d",
+		  QDF_MAC_ADDR_REF(bssId.bytes),
 		  mac_trace_getcsr_roam_sub_state(NewSubstate),
 		  reasonCode);
 
@@ -2105,8 +2105,8 @@ static void csr_send_ese_adjacent_ap_rep_ind(struct mac_context *mac,
 		return;
 	roamTS2 = qdf_mc_timer_get_system_time();
 	roam_info->tsmRoamDelay = roamTS2 - pSession->roamTS1;
-	sme_debug("Bssid(" QDF_MAC_ADDR_STR ") Roaming Delay(%u ms)",
-		QDF_MAC_ADDR_ARRAY(pSession->connectedProfile.bssid.bytes),
+	sme_debug("Bssid(" QDF_MAC_ADDR_FMT ") Roaming Delay(%u ms)",
+		QDF_MAC_ADDR_REF(pSession->connectedProfile.bssid.bytes),
 		roam_info->tsmRoamDelay);
 
 	pe_session = pe_find_session_by_bssid(mac,
@@ -3436,11 +3436,11 @@ csr_connect_info(struct mac_context *mac_ctx,
 	conn_stats.reason_code = 0;
 	conn_stats.op_freq = conn_profile->op_freq;
 	sme_nofl_debug("+---------CONNECTION INFO START------------+");
-	sme_nofl_debug("VDEV-ID: %d self_mac:%pM", session->vdev_id,
-		       session->self_mac_addr.bytes);
-	sme_nofl_debug("ssid: %.*s bssid: %pM RSSI: %d dBm",
+	sme_nofl_debug("VDEV-ID: %d self_mac:"QDF_MAC_ADDR_FMT, session->vdev_id,
+		       QDF_MAC_ADDR_REF(session->self_mac_addr.bytes));
+	sme_nofl_debug("ssid: %.*s bssid: "QDF_MAC_ADDR_FMT" RSSI: %d dBm",
 		       conn_stats.ssid_len, conn_stats.ssid,
-		       conn_stats.bssid, conn_stats.rssi);
+		       QDF_MAC_ADDR_REF(conn_stats.bssid), conn_stats.rssi);
 	sme_nofl_debug("Channel Freq: %d channel_bw: %s dot11Mode: %s", conn_stats.op_freq,
 		       csr_get_ch_width_str(conn_stats.chnl_bw),
 		       csr_get_dot11_mode_str(conn_stats.dot11mode));
@@ -3479,7 +3479,8 @@ void csr_get_sta_cxn_info(struct mac_context *mac_ctx,
 		return;
 	qdf_mem_set(buf, buf_sz, '\0');
 	len += qdf_scnprintf(buf + len, buf_sz - len,
-			     "\n\tbssid: %pM", conn_profile->bssid.bytes);
+			     "\n\tbssid: "QDF_MAC_ADDR_FMT,
+			     QDF_MAC_ADDR_REF(conn_profile->bssid.bytes));
 	len += qdf_scnprintf(buf + len, buf_sz - len,
 			     "\n\tssid: %.*s", conn_profile->SSID.length,
 			     conn_profile->SSID.ssId);
@@ -3832,8 +3833,8 @@ csr_is_deauth_disassoc_already_active(struct mac_context *mac_ctx,
 							  peer_macaddr);
 
 	if (ret)
-		sme_debug("Deauth/Disassoc already in progress for %pM",
-			  peer_macaddr.bytes);
+		sme_debug("Deauth/Disassoc already in progress for "QDF_MAC_ADDR_FMT,
+			  QDF_MAC_ADDR_REF(peer_macaddr.bytes));
 
 	return ret;
 }
@@ -3970,8 +3971,8 @@ QDF_STATUS csr_roam_issue_deauth(struct mac_context *mac, uint32_t sessionId,
 		qdf_mem_copy(bssId.bytes, pSession->pConnectBssDesc->bssId,
 			     sizeof(struct qdf_mac_addr));
 	}
-	sme_debug("Deauth to Bssid " QDF_MAC_ADDR_STR,
-		  QDF_MAC_ADDR_ARRAY(bssId.bytes));
+	sme_debug("Deauth to Bssid " QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(bssId.bytes));
 	csr_roam_substate_change(mac, NewSubstate, sessionId);
 
 	status =
@@ -3981,8 +3982,8 @@ QDF_STATUS csr_roam_issue_deauth(struct mac_context *mac, uint32_t sessionId,
 		csr_roam_link_down(mac, sessionId);
 	else {
 		sme_err("csr_send_mb_deauth_req_msg failed with status %d Session ID: %d"
-			QDF_MAC_ADDR_STR, status, sessionId,
-			QDF_MAC_ADDR_ARRAY(bssId.bytes));
+			QDF_MAC_ADDR_FMT, status, sessionId,
+			QDF_MAC_ADDR_REF(bssId.bytes));
 	}
 
 	return status;
@@ -5423,8 +5424,9 @@ static bool csr_roam_select_bss(struct mac_context *mac_ctx,
 				(struct qdf_mac_addr *)
 				&result->BssDescriptor.bssId, &temp_vdev_id);
 		if (QDF_IS_STATUS_SUCCESS(qdf_status)) {
-			sme_info("vdev_id %d already connected to %pM. select next bss for vdev_id %d",
-				 temp_vdev_id, result->BssDescriptor.bssId,
+			sme_info("vdev_id %d already connected to "QDF_MAC_ADDR_FMT". select next bss for vdev_id %d",
+				 temp_vdev_id,
+				 QDF_MAC_ADDR_REF(result->BssDescriptor.bssId),
 				 vdev_id);
 			*roam_state = eCsrStopRoamingDueToConcurrency;
 			status = true;
@@ -5441,8 +5443,9 @@ static bool csr_roam_select_bss(struct mac_context *mac_ctx,
 						       mode,
 						       chan_freq,
 						       HW_MODE_20_MHZ)) {
-			sme_err("Concurrency not allowed for this channel freq %d bssid %pM, selecting next",
-				chan_freq, result->BssDescriptor.bssId);
+			sme_err("Concurrency not allowed for this channel freq %d bssid "QDF_MAC_ADDR_FMT", selecting next",
+				chan_freq,
+				QDF_MAC_ADDR_REF(result->BssDescriptor.bssId));
 			*roam_state = eCsrStopRoamingDueToConcurrency;
 			status = true;
 			*roam_bss_entry = csr_ll_next(&bss_list->List,
@@ -5457,9 +5460,9 @@ static bool csr_roam_select_bss(struct mac_context *mac_ctx,
 		 */
 		if (!policy_mgr_is_hwmode_set_for_given_chnl(
 		    mac_ctx->psoc, result->BssDescriptor.chan_freq)) {
-			sme_err("HW mode isn't properly set, freq %d BSSID %pM",
+			sme_err("HW mode isn't properly set, freq %d BSSID "QDF_MAC_ADDR_FMT,
 				result->BssDescriptor.chan_freq,
-				result->BssDescriptor.bssId);
+				QDF_MAC_ADDR_REF(result->BssDescriptor.bssId));
 			*roam_state = eCsrStopRoamingDueToConcurrency;
 			status = true;
 			*roam_bss_entry = csr_ll_next(&bss_list->List,
@@ -6033,8 +6036,8 @@ static void csr_get_peer_rssi(struct mac_context *mac, uint32_t session_id,
 						vdev,
 						TYPE_PEER_STATS,
 						&info);
-		sme_debug("peer_mac" QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(peer_mac.bytes));
+		sme_debug("peer_mac" QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(peer_mac.bytes));
 		if (QDF_IS_STATUS_ERROR(status))
 			sme_err("stats req failed: %d", status);
 
@@ -6565,9 +6568,9 @@ void csr_update_scan_entry_associnfo(struct mac_context *mac_ctx,
 	qdf_mem_copy(&bss.ssid.ssid, &conn_profile->SSID.ssId,
 		     bss.ssid.length);
 
-	sme_debug("Update MLME info in scan database. bssid %pM ssid:%.*s freq %d state: %d",
-		  bss.bssid.bytes, bss.ssid.length, bss.ssid.ssid, bss.freq,
-		  state);
+	sme_debug("Update MLME info in scan database. bssid "QDF_MAC_ADDR_FMT" ssid:%.*s freq %d state: %d",
+		  QDF_MAC_ADDR_REF(bss.bssid.bytes), bss.ssid.length,
+		  bss.ssid.ssid, bss.freq, state);
 	mlme.assoc_state = state;
 	status = ucfg_scan_update_mlme_by_bssinfo(mac_ctx->pdev, &bss, &mlme);
 	if (QDF_IS_STATUS_ERROR(status))
@@ -8334,8 +8337,8 @@ static void csr_roam_print_candidate_aps(tScanResultHandle results)
 	while (entry) {
 		bss_desc = GET_BASE_ADDR(entry,
 				struct tag_csrscan_result, Link);
-		sme_nofl_debug(QDF_MAC_ADDR_STR " score: %d",
-			QDF_MAC_ADDR_ARRAY(bss_desc->Result.BssDescriptor.bssId),
+		sme_nofl_debug(QDF_MAC_ADDR_FMT " score: %d",
+			QDF_MAC_ADDR_REF(bss_desc->Result.BssDescriptor.bssId),
 			bss_desc->bss_score);
 
 		entry = csr_ll_next(&bss_list->List, entry,
@@ -9270,8 +9273,8 @@ static void csr_roam_join_rsp_processor(struct mac_context *mac,
 		if (!pmksa)
 			return;
 
-		sme_warn("Assoc reject from BSSID:%pM due to invalid PMKID",
-			 session_ptr->joinFailStatusCode.bssId);
+		sme_warn("Assoc reject from BSSID:"QDF_MAC_ADDR_FMT" due to invalid PMKID",
+			 QDF_MAC_ADDR_REF(session_ptr->joinFailStatusCode.bssId));
 		qdf_mem_copy(pmksa->bssid.bytes,
 			     &session_ptr->joinFailStatusCode.bssId,
 			     sizeof(tSirMacAddr));
@@ -10057,8 +10060,8 @@ void csr_handle_disassoc_ho(struct mac_context *mac, uint32_t session_id)
 
 	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
 		  "LFR2DBG: preauthed bss_node->pBssDescription BSSID"\
-		  QDF_MAC_ADDR_STR",freq:%d",
-		  QDF_MAC_ADDR_ARRAY(bss_node->pBssDescription->bssId),
+		  QDF_MAC_ADDR_FMT",freq:%d",
+		  QDF_MAC_ADDR_REF(bss_node->pBssDescription->bssId),
 		  bss_node->pBssDescription->chan_freq);
 
 	status = policy_mgr_handle_conc_multiport(
@@ -11050,8 +11053,8 @@ static QDF_STATUS csr_send_reset_ap_caps_changed(struct mac_context *mac,
 		pMsg->length = len;
 		qdf_copy_macaddr(&pMsg->bssId, bssId);
 		sme_debug(
-			"CSR reset caps change for Bssid= " QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(pMsg->bssId.bytes));
+			"CSR reset caps change for Bssid= " QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(pMsg->bssId.bytes));
 		status = umac_send_mb_message_to_mac(pMsg);
 	} else {
 		sme_err("Memory allocation failed");
@@ -11565,8 +11568,8 @@ csr_roam_chk_lnk_disassoc_ind(struct mac_context *mac_ctx, tSirSmeRsp *msg_ptr)
 	status = csr_roam_get_session_id_from_bssid(mac_ctx,
 				&pDisassocInd->bssid, &sessionId);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
-		sme_err("Session Id not found for BSSID "QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(pDisassocInd->bssid.bytes));
+		sme_err("Session Id not found for BSSID "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(pDisassocInd->bssid.bytes));
 		qdf_mem_free(cmd);
 		return;
 	}
@@ -11577,9 +11580,9 @@ csr_roam_chk_lnk_disassoc_ind(struct mac_context *mac_ctx, tSirSmeRsp *msg_ptr)
 		return;
 	}
 
-	sme_nofl_info("disassoc from peer " QDF_MAC_ADDR_STR
+	sme_nofl_info("disassoc from peer " QDF_MAC_ADDR_FMT
 		      "reason: %d status: %d vid %d",
-		      QDF_MAC_ADDR_ARRAY(pDisassocInd->peer_macaddr.bytes),
+		      QDF_MAC_ADDR_REF(pDisassocInd->peer_macaddr.bytes),
 		      pDisassocInd->reasonCode,
 		      pDisassocInd->status_code, sessionId);
 	/*
@@ -11651,8 +11654,9 @@ csr_roam_chk_lnk_deauth_ind(struct mac_context *mac_ctx, tSirSmeRsp *msg_ptr)
 	struct deauth_ind *pDeauthInd;
 
 	pDeauthInd = (struct deauth_ind *)msg_ptr;
-	sme_debug("DEAUTH Indication from MAC for vdev_id %d bssid %pM",
-		  pDeauthInd->vdev_id, pDeauthInd->bssid.bytes);
+	sme_debug("DEAUTH Indication from MAC for vdev_id %d bssid "QDF_MAC_ADDR_FMT,
+		  pDeauthInd->vdev_id,
+		  QDF_MAC_ADDR_REF(pDeauthInd->bssid.bytes));
 
 	status = csr_roam_get_session_id_from_bssid(mac_ctx,
 						   &pDeauthInd->bssid,
@@ -12181,9 +12185,9 @@ csr_roam_chk_lnk_set_ctx_rsp(struct mac_context *mac_ctx, tSirSmeRsp *msg_ptr)
 		result = eCSR_ROAM_RESULT_FAILURE;
 		sme_err(
 			"CSR: setkey command failed(err=%d) PeerMac "
-			QDF_MAC_ADDR_STR,
+			QDF_MAC_ADDR_FMT,
 			pRsp->status_code,
-			QDF_MAC_ADDR_ARRAY(pRsp->peer_macaddr.bytes));
+			QDF_MAC_ADDR_REF(pRsp->peer_macaddr.bytes));
 	}
 	/* keeping roam_id = 0 as nobody is using roam_id for set_key */
 	csr_roam_call_callback(mac_ctx, sessionId, roam_info,
@@ -14527,8 +14531,8 @@ static void csr_update_sae_config(struct join_req *csr_join_req,
 	if (!csr_join_req->sae_pmk_cached)
 		return;
 
-	sme_debug("Found for BSSID=" QDF_MAC_ADDR_STR,
-		  QDF_MAC_ADDR_ARRAY(csr_join_req->bssDescription.bssId));
+	sme_debug("Found for BSSID=" QDF_MAC_ADDR_FMT,
+		  QDF_MAC_ADDR_REF(csr_join_req->bssDescription.bssId));
 }
 #else
 static inline void csr_update_sae_config(struct join_req *csr_join_req,
@@ -14707,8 +14711,8 @@ static QDF_STATUS csr_check_and_validate_6g_ap(struct mac_context *mac_ctx,
 		return QDF_STATUS_SUCCESS;
 
 	if (!he_op->oper_info_6g_present) {
-		sme_err("%pM Invalid 6GHZ AP BSS description IE",
-			bss->bssId);
+		sme_err(QDF_MAC_ADDR_FMT" Invalid 6GHZ AP BSS description IE",
+			QDF_MAC_ADDR_REF(bss->bssId));
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -14911,11 +14915,11 @@ QDF_STATUS csr_send_join_req_msg(struct mac_context *mac, uint32_t sessionId,
 		qdf_mem_copy(&csr_join_req->self_mac_addr,
 			     &pSession->self_mac_addr,
 			     sizeof(tSirMacAddr));
-		sme_nofl_info("vdev-%d: Connecting to %.*s " QDF_MAC_ADDR_STR
+		sme_nofl_info("vdev-%d: Connecting to %.*s " QDF_MAC_ADDR_FMT
 			      " rssi: %d freq: %d akm %d cipher: uc %d mc %d, CC: %c%c",
 			      sessionId, csr_join_req->ssId.length,
 			      csr_join_req->ssId.ssId,
-			      QDF_MAC_ADDR_ARRAY(pBssDescription->bssId),
+			      QDF_MAC_ADDR_REF(pBssDescription->bssId),
 			      pBssDescription->rssi, pBssDescription->chan_freq,
 			      pProfile->negotiatedAuthType,
 			      pProfile->negotiatedUCEncryptionType,
@@ -15847,8 +15851,8 @@ QDF_STATUS csr_send_chng_mcc_beacon_interval(struct mac_context *mac,
 
 		qdf_copy_macaddr(&pMsg->bssid, &pSession->self_mac_addr);
 		sme_debug("CSR Attempting to change BI for Bssid= "
-			  QDF_MAC_ADDR_STR,
-			  QDF_MAC_ADDR_ARRAY(pMsg->bssid.bytes));
+			  QDF_MAC_ADDR_FMT,
+			  QDF_MAC_ADDR_REF(pMsg->bssid.bytes));
 		pMsg->sessionId = sessionId;
 		sme_debug("session %d BeaconInterval %d",
 			sessionId,
@@ -15890,8 +15894,8 @@ QDF_STATUS csr_set_ht2040_mode(struct mac_context *mac, uint32_t sessionId,
 		qdf_copy_macaddr(&pMsg->bssid, &pSession->self_mac_addr);
 		sme_debug(
 			"CSR Attempting to set HT20/40 mode for Bssid= "
-			 QDF_MAC_ADDR_STR,
-			 QDF_MAC_ADDR_ARRAY(pMsg->bssid.bytes));
+			 QDF_MAC_ADDR_FMT,
+			 QDF_MAC_ADDR_REF(pMsg->bssid.bytes));
 		pMsg->sessionId = sessionId;
 		sme_debug("  session %d HT20/40 mode %d",
 			sessionId, cbMode);
@@ -16397,9 +16401,9 @@ QDF_STATUS csr_setup_vdev_session(struct vdev_mlme_obj *vdev_mlme)
 	status = csr_roam_get_session_id_from_bssid(mac_ctx, mac_addr,
 						    &existing_session_id);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		sme_err("Session %d exists with mac address %pM",
+		sme_err("Session %d exists with mac address "QDF_MAC_ADDR_FMT,
 			existing_session_id,
-			mac_addr);
+			QDF_MAC_ADDR_REF(mac_addr->bytes));
 		return QDF_STATUS_E_FAILURE;
 	}
 
@@ -16636,8 +16640,8 @@ static void csr_roam_link_up(struct mac_context *mac, struct qdf_mac_addr bssid)
 	 * profile info from pmac global structure
 	 */
 
-	sme_debug("WLAN link UP with AP= " QDF_MAC_ADDR_STR,
-		QDF_MAC_ADDR_ARRAY(bssid.bytes));
+	sme_debug("WLAN link UP with AP= " QDF_MAC_ADDR_FMT,
+		QDF_MAC_ADDR_REF(bssid.bytes));
 	/* Indicate the neighbor roal algorithm about the connect indication */
 	csr_roam_get_session_id_from_bssid(mac, &bssid,
 					   &sessionId);
@@ -17106,15 +17110,15 @@ static void csr_update_btm_offload_config(struct mac_context *mac_ctx,
 				    session->pConnectBssDesc->bssId,
 				    WLAN_LEGACY_SME_ID);
 	if (!peer) {
-		sme_debug("Peer of peer_mac %pM not found",
-			  session->pConnectBssDesc->bssId);
+		sme_debug("Peer of peer_mac "QDF_MAC_ADDR_FMT" not found",
+			  QDF_MAC_ADDR_REF(session->pConnectBssDesc->bssId));
 		return;
 	}
 
 	is_pmf_enabled = mlme_get_peer_pmf_status(peer);
 	wlan_objmgr_peer_release_ref(peer, WLAN_LEGACY_SME_ID);
-	sme_debug("get is_pmf_enabled %d for %pM", is_pmf_enabled,
-		  session->pConnectBssDesc->bssId);
+	sme_debug("get is_pmf_enabled %d for "QDF_MAC_ADDR_FMT, is_pmf_enabled,
+		  QDF_MAC_ADDR_REF(session->pConnectBssDesc->bssId));
 
 	/* If peer does not support PMF in case of OCE/MBO
 	 * Connection, Disable BTM offload to firmware.
@@ -17835,8 +17839,8 @@ csr_add_rssi_reject_ap_list(struct mac_context *mac_ctx,
 
 	for (i = 0; i < roam_params->num_rssi_rejection_ap; i++) {
 		roam_params->rssi_reject_bssid_list[i] = reject_list[i];
-		sme_debug("BSSID %pM expected rssi %d remaining duration %d",
-			  roam_params->rssi_reject_bssid_list[i].bssid.bytes,
+		sme_debug("BSSID "QDF_MAC_ADDR_FMT" expected rssi %d remaining duration %d",
+			  QDF_MAC_ADDR_REF(roam_params->rssi_reject_bssid_list[i].bssid.bytes),
 			  roam_params->rssi_reject_bssid_list[i].expected_rssi,
 			  roam_params->rssi_reject_bssid_list[i].
 							reject_duration);
@@ -19788,8 +19792,8 @@ csr_cm_roam_scan_filter(struct mac_context *mac_ctx, uint8_t vdev_id,
 	}
 
 	for (i = 0; i < params->num_bssid_black_list; i++)
-		sme_debug("Blacklist bssid[%d]:" QDF_MAC_ADDR_STR, i,
-			  QDF_MAC_ADDR_ARRAY(params->bssid_avoid_list[i].bytes));
+		sme_debug("Blacklist bssid[%d]:" QDF_MAC_ADDR_FMT, i,
+			  QDF_MAC_ADDR_REF(params->bssid_avoid_list[i].bytes));
 	qdf_mem_copy(params->bssid_favored, roam_params->bssid_favored,
 		     MAX_BSSID_FAVORED * sizeof(struct qdf_mac_addr));
 	qdf_mem_copy(params->bssid_favored_factor,
@@ -19800,8 +19804,8 @@ csr_cm_roam_scan_filter(struct mac_context *mac_ctx, uint8_t vdev_id,
 			sizeof(struct reject_ap_config_params));
 
 	for (i = 0; i < params->num_bssid_preferred_list; i++)
-		sme_debug("Preferred Bssid[%d]:"QDF_MAC_ADDR_STR" score: %d", i,
-			  QDF_MAC_ADDR_ARRAY(params->bssid_favored[i].bytes),
+		sme_debug("Preferred Bssid[%d]:"QDF_MAC_ADDR_FMT" score: %d", i,
+			  QDF_MAC_ADDR_REF(params->bssid_favored[i].bytes),
 			  params->bssid_favored_factor[i]);
 
 	if (params->lca_disallow_config_present) {
@@ -22086,8 +22090,8 @@ csr_process_roam_sync_callback(struct mac_context *mac_ctx,
 
 		qdf_copy_macaddr(&pmkid_cache->BSSID,
 				 &session->connectedProfile.bssid);
-		sme_debug("Trying to find PMKID for " QDF_MAC_ADDR_STR,
-			  QDF_MAC_ADDR_ARRAY(pmkid_cache->BSSID.bytes));
+		sme_debug("Trying to find PMKID for " QDF_MAC_ADDR_FMT,
+			  QDF_MAC_ADDR_REF(pmkid_cache->BSSID.bytes));
 		if (csr_lookup_pmkid_using_bssid(mac_ctx, session,
 						 pmkid_cache)) {
 			session->pmk_len = pmkid_cache->pmk_len;
@@ -22095,12 +22099,12 @@ csr_process_roam_sync_callback(struct mac_context *mac_ctx,
 				     sizeof(session->psk_pmk));
 			qdf_mem_copy(session->psk_pmk, pmkid_cache->pmk,
 				     session->pmk_len);
-			sme_debug("pmkid found for " QDF_MAC_ADDR_STR " len %d",
-				  QDF_MAC_ADDR_ARRAY(pmkid_cache->BSSID.bytes),
+			sme_debug("pmkid found for " QDF_MAC_ADDR_FMT " len %d",
+				  QDF_MAC_ADDR_REF(pmkid_cache->BSSID.bytes),
 				  (uint32_t)session->pmk_len);
 		} else {
-			sme_debug("PMKID Not found in cache for " QDF_MAC_ADDR_STR,
-				  QDF_MAC_ADDR_ARRAY(pmkid_cache->BSSID.bytes));
+			sme_debug("PMKID Not found in cache for " QDF_MAC_ADDR_FMT,
+				  QDF_MAC_ADDR_REF(pmkid_cache->BSSID.bytes));
 			if (roam_synch_data->pmk_len) {
 				pmksa = qdf_mem_malloc(sizeof(*pmksa));
 				if (!pmksa) {

core/sme/src/csr/csr_api_scan.c

@@ -1643,10 +1643,10 @@ QDF_STATUS csr_scan_create_entry_in_scan_cache(struct mac_context *mac,
 	if (!pSession) {
 		return QDF_STATUS_E_FAILURE;
 	}
-	sme_debug("Current bssid::"QDF_MAC_ADDR_STR,
-		QDF_MAC_ADDR_ARRAY(pSession->pConnectBssDesc->bssId));
-	sme_debug("My bssid::"QDF_MAC_ADDR_STR" ch_freq %d",
-		QDF_MAC_ADDR_ARRAY(bssid.bytes), ch_freq);
+	sme_debug("Current bssid::"QDF_MAC_ADDR_FMT,
+		QDF_MAC_ADDR_REF(pSession->pConnectBssDesc->bssId));
+	sme_debug("My bssid::"QDF_MAC_ADDR_FMT" ch_freq %d",
+		QDF_MAC_ADDR_REF(bssid.bytes), ch_freq);
 
 	size = pSession->pConnectBssDesc->length +
 		sizeof(pSession->pConnectBssDesc->length);
@@ -1710,8 +1710,8 @@ csr_rso_save_ap_to_scan_cache(struct mac_context *mac,
 			bss_desc_ptr,
 			(sizeof(struct bss_description) + length));
 
-	sme_debug("LFR3:Add BSSID to scan cache" QDF_MAC_ADDR_STR,
-		QDF_MAC_ADDR_ARRAY(scan_res_ptr->Result.BssDescriptor.bssId));
+	sme_debug("LFR3:Add BSSID to scan cache" QDF_MAC_ADDR_FMT,
+		QDF_MAC_ADDR_REF(scan_res_ptr->Result.BssDescriptor.bssId));
 	csr_scan_add_result(mac, scan_res_ptr);
 	csr_free_scan_result_entry(mac, scan_res_ptr);
 	return QDF_STATUS_SUCCESS;
@@ -2219,8 +2219,9 @@ static QDF_STATUS csr_fill_bss_from_scan_entry(struct mac_context *mac_ctx,
 				scan_entry->channel.chan_freq);
 	if (ap_channel_state == CHANNEL_STATE_DISABLE ||
 	    ap_channel_state == CHANNEL_STATE_INVALID) {
-		sme_err("BSS %pM channel %d invalid, not populating this BSSID",
-			scan_entry->bssid.bytes, scan_entry->channel.chan_freq);
+		sme_err("BSS "QDF_MAC_ADDR_FMT" channel %d invalid, not populating this BSSID",
+			QDF_MAC_ADDR_REF(scan_entry->bssid.bytes),
+			scan_entry->channel.chan_freq);
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -2605,7 +2606,8 @@ static inline void csr_flush_bssid(struct mac_context *mac_ctx,
 		     bssid, QDF_MAC_ADDR_SIZE);
 
 	csr_flush_scan_results(mac_ctx, filter);
-	sme_debug("Removed BSS entry:%pM", bssid);
+	sme_debug("Removed BSS entry:"QDF_MAC_ADDR_FMT,
+		   QDF_MAC_ADDR_REF(bssid));
 	if (filter)
 		qdf_mem_free(filter);
 }

core/sme/src/csr/csr_host_scan_roam.c

@@ -169,9 +169,9 @@ void csr_neighbor_roam_process_scan_results(struct mac_context *mac_ctx,
 			descr = &scan_result->BssDescriptor;
 			bss_chan_freq = descr->chan_freq;
 			QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-				  FL("Scan result: BSSID " QDF_MAC_ADDR_STR
+				  FL("Scan result: BSSID " QDF_MAC_ADDR_FMT
 				     " (Rssi %d, Ch:%d)"),
-				  QDF_MAC_ADDR_ARRAY(descr->bssId),
+				  QDF_MAC_ADDR_REF(descr->bssId),
 				  (int)abs(descr->rssi), descr->chan_freq);
 
 			if (!qdf_mem_cmp(descr->bssId,
@@ -250,15 +250,15 @@ void csr_neighbor_roam_process_scan_results(struct mac_context *mac_ctx,
 			    (qavail < n_roam_info->MinQBssLoadRequired)) {
 				QDF_TRACE(QDF_MODULE_ID_SME,
 					QDF_TRACE_LEVEL_DEBUG,
-					"BSSID:" QDF_MAC_ADDR_STR "has no BW",
-					QDF_MAC_ADDR_ARRAY(descr->bssId));
+					"BSSID:" QDF_MAC_ADDR_FMT "has no BW",
+					QDF_MAC_ADDR_REF(descr->bssId));
 				continue;
 			}
 			if (voadmitted && !qpresent) {
 				QDF_TRACE(QDF_MODULE_ID_SME,
 					QDF_TRACE_LEVEL_DEBUG,
-					"BSSID:" QDF_MAC_ADDR_STR "no LOAD IE",
-					QDF_MAC_ADDR_ARRAY(descr->bssId));
+					"BSSID:" QDF_MAC_ADDR_FMT "no LOAD IE",
+					QDF_MAC_ADDR_REF(descr->bssId));
 				continue;
 			}
 #endif /* FEATURE_WLAN_ESE */
@@ -528,8 +528,8 @@ void csr_neighbor_roam_request_handoff(struct mac_context *mac_ctx,
 		return;
 	}
 	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-		  FL("HANDOFF CANDIDATE BSSID "QDF_MAC_ADDR_STR),
-		  QDF_MAC_ADDR_ARRAY(handoff_node.pBssDescription->bssId));
+		  FL("HANDOFF CANDIDATE BSSID "QDF_MAC_ADDR_FMT),
+		  QDF_MAC_ADDR_REF(handoff_node.pBssDescription->bssId));
 
 	roam_info = qdf_mem_malloc(sizeof(*roam_info));
 	if (!roam_info)

core/sme/src/csr/csr_neighbor_roam.c

@@ -654,9 +654,9 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 	}
 	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
 			FL("Disconn ind on session %d in state %d from bss :"
-			QDF_MAC_ADDR_STR), sessionId,
+			QDF_MAC_ADDR_FMT), sessionId,
 			pNeighborRoamInfo->neighborRoamState,
-			QDF_MAC_ADDR_ARRAY(pSession->connectedProfile.bssid.bytes));
+			QDF_MAC_ADDR_REF(pSession->connectedProfile.bssid.bytes));
 	/*
 	 * Free the current previous profile and move
 	 * the current profile to prev profile.

core/sme/src/csr/csr_roam_preauth.c

@@ -242,8 +242,8 @@ QDF_STATUS csr_neighbor_roam_preauth_rsp_handler(struct mac_context *mac_ctx,
 	if ((QDF_STATUS_SUCCESS == lim_status) && (preauth_rsp_node)) {
 		sme_debug("Preauth completed successfully after %d tries",
 			  neighbor_roam_info->FTRoamInfo.numPreAuthRetries);
-		sme_debug("After Pre-Auth: BSSID " QDF_MAC_ADDR_STR ", ChFq:%d",
-			  QDF_MAC_ADDR_ARRAY(
+		sme_debug("After Pre-Auth: BSSID " QDF_MAC_ADDR_FMT ", ChFq:%d",
+			  QDF_MAC_ADDR_REF(
 				preauth_rsp_node->pBssDescription->bssId),
 			  preauth_rsp_node->pBssDescription->chan_freq);
 
@@ -383,8 +383,8 @@ static QDF_STATUS csr_neighbor_roam_add_preauth_fail(struct mac_context *mac_ctx
 	uint8_t num_mac_addr = neighbor_roam_info->FTRoamInfo.preAuthFailList.
 				numMACAddress;
 
-	sme_warn("Added BSSID " QDF_MAC_ADDR_STR " to Preauth failed list",
-		QDF_MAC_ADDR_ARRAY(bssid));
+	sme_warn("Added BSSID " QDF_MAC_ADDR_FMT " to Preauth failed list",
+		QDF_MAC_ADDR_REF(bssid));
 
 	for (i = 0;
 	     i < neighbor_roam_info->FTRoamInfo.preAuthFailList.numMACAddress;
@@ -392,8 +392,8 @@ static QDF_STATUS csr_neighbor_roam_add_preauth_fail(struct mac_context *mac_ctx
 		if (!qdf_mem_cmp(
 		   neighbor_roam_info->FTRoamInfo.preAuthFailList.macAddress[i],
 		   bssid, sizeof(tSirMacAddr))) {
-			sme_warn("BSSID "QDF_MAC_ADDR_STR" already fail list",
-			QDF_MAC_ADDR_ARRAY(bssid));
+			sme_warn("BSSID "QDF_MAC_ADDR_FMT" already fail list",
+			QDF_MAC_ADDR_REF(bssid));
 			return QDF_STATUS_SUCCESS;
 		}
 	}
@@ -438,8 +438,8 @@ bool csr_neighbor_roam_is_preauth_candidate(struct mac_context *mac,
 		if (!qdf_mem_cmp(pNeighborRoamInfo->FTRoamInfo.
 				    preAuthFailList.macAddress[i], bssId,
 				    sizeof(tSirMacAddr))) {
-			sme_err("BSSID exists in fail list" QDF_MAC_ADDR_STR,
-					QDF_MAC_ADDR_ARRAY(bssId));
+			sme_err("BSSID exists in fail list" QDF_MAC_ADDR_FMT,
+					QDF_MAC_ADDR_REF(bssId));
 			return false;
 		}
 	}
@@ -769,8 +769,8 @@ QDF_STATUS csr_neighbor_roam_issue_preauth_req(struct mac_context *mac_ctx,
 				neighbor_bss_node->pBssDescription,
 				eCsrPerformPreauth, true);
 
-	sme_debug("Before Pre-Auth: BSSID " QDF_MAC_ADDR_STR ", Ch:%d",
-		  QDF_MAC_ADDR_ARRAY(neighbor_bss_node->pBssDescription->bssId),
+	sme_debug("Before Pre-Auth: BSSID " QDF_MAC_ADDR_FMT ", Ch:%d",
+		  QDF_MAC_ADDR_REF(neighbor_bss_node->pBssDescription->bssId),
 		  neighbor_bss_node->pBssDescription->chan_freq);
 
 	if (QDF_STATUS_SUCCESS != status) {

core/sme/src/rrm/sme_rrm.c

@@ -213,9 +213,9 @@ sme_rrm_send_beacon_report_xmit_ind(struct mac_context *mac_ctx,
 				bss_desc, size);
 			tmp_bss_desc[i] =
 				beacon_rep->pBssDescription[i];
-			sme_debug("RRM Result Bssid = " QDF_MAC_ADDR_STR
+			sme_debug("RRM Result Bssid = " QDF_MAC_ADDR_FMT
 				  " freq= %d, rssi = -%d",
-				  QDF_MAC_ADDR_ARRAY(
+				  QDF_MAC_ADDR_REF(
 				  beacon_rep->pBssDescription[i]->bssId),
 				  beacon_rep->pBssDescription[i]->chan_freq,
 				  beacon_rep->pBssDescription[i]->rssi * (-1));
@@ -365,8 +365,8 @@ static QDF_STATUS sme_ese_send_beacon_req_scan_results(
 				continue;
 			bcn_report->bcnRepBssInfo[j].ieLen = out_ie_len;
 
-			sme_debug("Bssid"QDF_MAC_ADDR_STR" Freq:%d Rssi:%d",
-				  QDF_MAC_ADDR_ARRAY(bss_desc->bssId),
+			sme_debug("Bssid"QDF_MAC_ADDR_FMT" Freq:%d Rssi:%d",
+				  QDF_MAC_ADDR_REF(bss_desc->bssId),
 				  bss_desc->chan_freq, (-1) * bss_desc->rssi);
 			bcn_report->numBss++;
 			if (++j >= SIR_BCN_REPORT_MAX_BSS_DESC)
@@ -802,8 +802,8 @@ QDF_STATUS sme_rrm_issue_scan_req(struct mac_context *mac_ctx, uint8_t idx)
 	status = csr_roam_get_session_id_from_bssid(mac_ctx,
 			&sme_rrm_ctx->sessionBssId, &session_id);
 	if (status != QDF_STATUS_SUCCESS) {
-		sme_err("sme session ID not found for bssid= "QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(sme_rrm_ctx->sessionBssId.bytes));
+		sme_err("sme session ID not found for bssid= "QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(sme_rrm_ctx->sessionBssId.bytes));
 		status = QDF_STATUS_E_FAILURE;
 		goto send_ind;
 	}
@@ -1592,8 +1592,8 @@ static QDF_STATUS sme_rrm_process_neighbor_report(struct mac_context *mac,
 			     sizeof(tSirNeighborBssDescription));
 
 		sme_debug("Received neighbor report with Neighbor BSSID: "
-			QDF_MAC_ADDR_STR,
-			QDF_MAC_ADDR_ARRAY(
+			QDF_MAC_ADDR_FMT,
+			QDF_MAC_ADDR_REF(
 			       neighbor_rpt->sNeighborBssDescription[i].bssId));
 
 		rrm_calculate_neighbor_ap_roam_score(mac, neighbor_rpt_desc);
@@ -1603,9 +1603,9 @@ static QDF_STATUS sme_rrm_process_neighbor_report(struct mac_context *mac,
 					mac, neighbor_rpt_desc,
 					neighbor_rpt->measurement_idx);
 		} else {
-			sme_err("Roam score of BSSID  " QDF_MAC_ADDR_STR
+			sme_err("Roam score of BSSID  " QDF_MAC_ADDR_FMT
 				" is 0, Ignoring..",
-				QDF_MAC_ADDR_ARRAY(neighbor_rpt->
+				QDF_MAC_ADDR_REF(neighbor_rpt->
 					       sNeighborBssDescription[i].
 					       bssId));