[rtl872x] hal: use the BLE mac address from BLE calibration data in efuse

Author: XuGuohui

hal/src/rtl872x/ble_hal.cpp

@@ -158,7 +158,7 @@ bool addressEqual(const hal_ble_addr_t& srcAddr, const hal_ble_addr_t& destAddr)
     return (srcAddr.addr_type == destAddr.addr_type && !memcmp(srcAddr.addr, destAddr.addr, BLE_SIG_ADDR_LEN));
 }
 
-hal_ble_addr_t chipDefaultAddress() {
+hal_ble_addr_t chipDefaultPublicAddress() {
     hal_ble_addr_t localAddr = {};
     hal_get_ble_mac_address(localAddr.addr, BLE_SIG_ADDR_LEN, nullptr);
     localAddr.addr_type = BLE_SIG_ADDR_TYPE_PUBLIC;
@@ -924,23 +924,37 @@ int BleGap::getDeviceName(char* deviceName, size_t len) const {
 }
 
 int BleGap::setDeviceAddress(const hal_ble_addr_t* address) {
-    hal_ble_addr_t newAddr = {};
-    if (address == nullptr) {
-        // default to reserved MAC address for this platform
-        newAddr = chipDefaultAddress();
-    } else {
-        newAddr = *address;
+    CHECK_FALSE(isAdvertising(), SYSTEM_ERROR_INVALID_STATE);
+    CHECK_FALSE(scanning(), SYSTEM_ERROR_INVALID_STATE);
+    // RTL872x doesn't support changing the the public address.
+    // But to be compatible with existing BLE platforms, it should accept nulllptr.
+    if (!address) {
+        addr_ = chipDefaultPublicAddress();
+        return SYSTEM_ERROR_NONE;
     }
-    if (newAddr.addr_type != BLE_SIG_ADDR_TYPE_PUBLIC && newAddr.addr_type != BLE_SIG_ADDR_TYPE_RANDOM_STATIC) {
+    if (address->addr_type != BLE_SIG_ADDR_TYPE_RANDOM_STATIC) {
         return SYSTEM_ERROR_INVALID_ARGUMENT;
     }
-    if (newAddr.addr_type == BLE_SIG_ADDR_TYPE_RANDOM_STATIC && (newAddr.addr[5] & 0xC0) != 0xC0) {
+    if ((address->addr[5] & 0xC0) != 0xC0) {
         // For random static address, the two most significant bits of the address shall be equal to 1.
         return SYSTEM_ERROR_INVALID_ARGUMENT;
     }
+    uint8_t addr[BLE_SIG_ADDR_LEN] = {};
+    memcpy(addr, address->addr, BLE_SIG_ADDR_LEN);
+    CHECK_RTL(le_cfg_local_identity_address(addr, GAP_IDENT_ADDR_RAND));
+    CHECK_RTL(le_set_gap_param(GAP_PARAM_RANDOM_ADDR, BLE_SIG_ADDR_LEN, addr));
+    addr_ = *address;
 
-    CHECK_RTL(le_cfg_local_identity_address(newAddr.addr, (newAddr.addr_type == BLE_SIG_ADDR_TYPE_PUBLIC) ?  GAP_IDENT_ADDR_PUBLIC : GAP_IDENT_ADDR_RAND));
-    addr_ = newAddr;
+    uint8_t advLocalAddrType = GAP_LOCAL_ADDR_LE_PUBLIC;
+    if (address->addr_type == BLE_SIG_ADDR_TYPE_RANDOM_STATIC) {
+        advLocalAddrType = GAP_LOCAL_ADDR_LE_RANDOM;
+    }
+    CHECK_RTL(le_adv_set_param(GAP_PARAM_ADV_LOCAL_ADDR_TYPE, sizeof(advLocalAddrType), &advLocalAddrType));
+    uint8_t scanLocalAddrType = GAP_LOCAL_ADDR_LE_PUBLIC;
+    if (address->addr_type == BLE_SIG_ADDR_TYPE_RANDOM_STATIC) {
+        scanLocalAddrType = GAP_LOCAL_ADDR_LE_RANDOM;
+    }
+    CHECK_RTL(le_scan_set_param(GAP_PARAM_SCAN_LOCAL_ADDR_TYPE, sizeof(uint8_t), &scanLocalAddrType));
 
     return SYSTEM_ERROR_NONE;
 }

hal/src/rtl872x/deviceid_hal.cpp

@@ -43,13 +43,15 @@ using namespace particle;
 #define EFUSE_SUCCESS           1
 #define EFUSE_FAILURE           0
 
+#define BLE_MAC_OFFSET          0x190
 #define WIFI_MAC_OFFSET         0x11A
 #define MOBILE_SECRET_OFFSET    0x160
 #define SERIAL_NUMBER_OFFSET    0x16F
 #define HARDWARE_DATA_OFFSET    0x178
 #define HARDWARE_MODEL_OFFSET   0x17B
 
 #define WIFI_MAC_SIZE                   6
+#define BLE_MAC_SIZE                    6
 #define SERIAL_NUMBER_FRONT_PART_SIZE   9
 #define HARDWARE_DATA_SIZE              4
 #define HARDWARE_MODEL_SIZE             4
@@ -84,13 +86,6 @@ int readLogicalEfuse(uint32_t offset, uint8_t* buf, size_t size) {
     return SYSTEM_ERROR_NONE;
 };
 
-// big-endian
-int readBaseMacAddress(uint8_t* dest, size_t destLen) {
-    // The parameters should have been checked
-    CHECK(readLogicalEfuse(WIFI_MAC_OFFSET, dest, destLen));
-    return WIFI_MAC_SIZE;
-}
-
 } // Anonymous
 
 unsigned hal_get_device_id(uint8_t* dest, unsigned destLen) {
@@ -113,16 +108,15 @@ int HAL_Get_Device_Identifier(const char** name, char* buf, size_t buflen, unsig
 }
 
 int hal_get_ble_mac_address(uint8_t* dest, size_t destLen, void* reserved) {
-    CHECK_TRUE(dest && destLen >= WIFI_MAC_SIZE, SYSTEM_ERROR_INVALID_ARGUMENT);
-    uint8_t mac[WIFI_MAC_SIZE] = {};
-    destLen = WIFI_MAC_SIZE;
-    CHECK(readBaseMacAddress(mac, WIFI_MAC_SIZE));
+    CHECK_TRUE(dest && destLen >= BLE_MAC_SIZE, SYSTEM_ERROR_INVALID_ARGUMENT);
+    uint8_t mac[BLE_MAC_SIZE] = {};
+    destLen = BLE_MAC_SIZE;
+    CHECK(readLogicalEfuse(BLE_MAC_OFFSET, mac, BLE_MAC_SIZE));
     // As per BLE spec, we store BLE data in little-endian
-    for (uint8_t i = 0, j = WIFI_MAC_SIZE - 1; i < WIFI_MAC_SIZE; i++, j--) {
+    for (uint8_t i = 0, j = BLE_MAC_SIZE - 1; i < BLE_MAC_SIZE; i++, j--) {
         dest[i] = mac[j];
     }
-    dest[0] += BLE_MAC_DELTA;
-    return WIFI_MAC_SIZE;
+    return BLE_MAC_SIZE;
 }