diff --git a/core/mac/inc/sir_api.h b/core/mac/inc/sir_api.h
index bae0b4c..0bd15f7 100644
--- a/core/mac/inc/sir_api.h
+++ b/core/mac/inc/sir_api.h
@@ -557,8 +557,8 @@
 	uint16_t length;
 	uint8_t sessionId;      /* Added for BT-AMP Support */
 	uint16_t transactionId; /* Added for BT-AMP Support */
-	tSirMacAddr bssId;      /* Added for BT-AMP Support */
-	tSirMacAddr selfMacAddr;        /* Added for BT-AMP Support */
+	struct cdf_mac_addr bssid;      /* Added for BT-AMP Support */
+	struct cdf_mac_addr self_macaddr;        /* Added for BT-AMP Support */
 	uint16_t beaconInterval;        /* Added for BT-AMP Support */
 	uint8_t dot11mode;
 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
diff --git a/core/mac/src/pe/lim/lim_process_sme_req_messages.c b/core/mac/src/pe/lim/lim_process_sme_req_messages.c
index a54ed92..3846b8b 100644
--- a/core/mac/src/pe/lim/lim_process_sme_req_messages.c
+++ b/core/mac/src/pe/lim/lim_process_sme_req_messages.c
@@ -669,7 +669,7 @@
 		 * If session is not existed, then create a new session
 		 */
 		session = pe_find_session_by_bssid(mac_ctx,
-				sme_start_bss_req->bssId, &session_id);
+				sme_start_bss_req->bssid.bytes, &session_id);
 		if (session != NULL) {
 			lim_log(mac_ctx, LOGW,
 				FL("Session Already exists for given BSSID"));
@@ -678,7 +678,7 @@
 			goto free;
 		} else {
 			session = pe_create_session(mac_ctx,
-					sme_start_bss_req->bssId,
+					sme_start_bss_req->bssid.bytes,
 					&session_id, mac_ctx->lim.maxStation,
 					sme_start_bss_req->bssType);
 			if (session == NULL) {
@@ -726,7 +726,7 @@
 			     sizeof(session->htConfig));
 
 		sir_copy_mac_addr(session->selfMacAddr,
-				  sme_start_bss_req->selfMacAddr);
+				  sme_start_bss_req->self_macaddr.bytes);
 
 		/* Copy SSID to session table */
 		cdf_mem_copy((uint8_t *) &session->ssId,
diff --git a/core/sme/src/csr/csr_api_roam.c b/core/sme/src/csr/csr_api_roam.c
index d4c39e4..fdc18bd 100644
--- a/core/sme/src/csr/csr_api_roam.c
+++ b/core/sme/src/csr/csr_api_roam.c
@@ -14687,11 +14687,9 @@
 	pMsg->sessionId = sessionId;
 	pMsg->length = sizeof(tSirSmeStartBssReq);
 	pMsg->transactionId = 0;
-	cdf_mem_copy(pMsg->bssId, pParam->bssid.bytes, sizeof(tSirMacAddr));
+	cdf_copy_macaddr(&pMsg->bssid, &pParam->bssid);
 	/* selfMacAddr */
-	cdf_mem_copy(pMsg->selfMacAddr,
-		     pSession->selfMacAddr.bytes,
-		     sizeof(tSirMacAddr));
+	cdf_copy_macaddr(&pMsg->self_macaddr, &pSession->selfMacAddr);
 	/* beaconInterval */
 	if (pBssDesc && pBssDesc->beaconInterval)
 		wTmp = pBssDesc->beaconInterval;
