Unify ble manager for silabs platforms

src/platform/silabs/AbstractBLEManagerImpl.cpp

@@ -0,0 +1,303 @@
+#include "AbstractBLEManagerImpl.h"
+
+#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+
+#include <platform/internal/CHIPDeviceLayerInternal.h>
+
+#include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <platform/ConnectivityManager.h>
+
+#include <cstring>
+
+namespace chip {
+namespace DeviceLayer {
+namespace Internal {
+
+CHIP_ERROR AbstractBLEManagerImpl::_Init()
+{
+    return PlatformInit();
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::_SetAdvertisingEnabled(bool val)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported,
+                 err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);
+
+    if (mFlags.Has(Flags::kAdvertisingEnabled) != val)
+    {
+        mFlags.Set(Flags::kAdvertisingEnabled, val);
+        PostDriveBLEState();
+    }
+
+exit:
+    return err;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::_SetAdvertisingMode(BLEAdvertisingMode mode)
+{
+    switch (mode)
+    {
+    case BLEAdvertisingMode::kFastAdvertising:
+        mFlags.Set(Flags::kFastAdvertisingEnabled, true);
+        break;
+    case BLEAdvertisingMode::kSlowAdvertising:
+        mFlags.Set(Flags::kFastAdvertisingEnabled, false);
+        break;
+    default:
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+    mFlags.Set(Flags::kRestartAdvertising);
+    PostDriveBLEState();
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::_GetDeviceName(char * buf, size_t bufSize)
+{
+    if (strlen(mDeviceName) >= bufSize)
+    {
+        return CHIP_ERROR_BUFFER_TOO_SMALL;
+    }
+    strcpy(buf, mDeviceName);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::_SetDeviceName(const char * deviceName)
+{
+#if (SLI_SI91X_ENABLE_BLE || RSI_BLE_ENABLE)
+    ChipLogProgress(DeviceLayer, "_SetDeviceName Started");
+#endif
+
+    if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_NotSupported)
+    {
+#if (SLI_SI91X_ENABLE_BLE || RSI_BLE_ENABLE)
+        ChipLogProgress(DeviceLayer, "_SetDeviceName CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE");
+#endif
+        return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+    }
+    if (deviceName != nullptr && deviceName[0] != 0)
+    {
+        if (strlen(deviceName) >= kMaxDeviceNameLength)
+        {
+#if (SLI_SI91X_ENABLE_BLE || RSI_BLE_ENABLE)
+            ChipLogProgress(DeviceLayer, "_SetDeviceName CHIP_ERROR_INVALID_ARGUMENT");
+#endif
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+        strcpy(mDeviceName, deviceName);
+        mFlags.Set(Flags::kDeviceNameSet);
+        mFlags.Set(Flags::kRestartAdvertising);
+        ChipLogProgress(DeviceLayer, "Setting device name to : \"%s\"", mDeviceName);
+    }
+    else
+    {
+        mDeviceName[0] = 0;
+    }
+
+    PostDriveBLEState();
+
+#if (SLI_SI91X_ENABLE_BLE || RSI_BLE_ENABLE)
+    ChipLogProgress(DeviceLayer, "_SetDeviceName Ended");
+#endif
+    return CHIP_NO_ERROR;
+}
+
+uint16_t AbstractBLEManagerImpl::_NumConnections(void)
+{
+    uint16_t numCons = 0;
+    for (uint16_t i = 0; i < kMaxConnections; i++)
+    {
+        if (mBleConnections[i].allocated)
+        {
+            numCons++;
+        }
+    }
+
+    return numCons;
+}
+
+void AbstractBLEManagerImpl::HandleBootEvent(void)
+{
+    mFlags.Set(Flags::kSiLabsBLEStackInitialize);
+    PostDriveBLEState();
+}
+
+void AbstractBLEManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
+{
+    switch (event->Type)
+    {
+    case DeviceEventType::kCHIPoBLESubscribe: {
+        ChipDeviceEvent connEstEvent;
+
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLESubscribe");
+        HandleSubscribeReceived(event->CHIPoBLESubscribe.ConId, &CHIP_BLE_SVC_ID, &Ble::CHIP_BLE_CHAR_2_UUID);
+        connEstEvent.Type = DeviceEventType::kCHIPoBLEConnectionEstablished;
+        PlatformMgr().PostEventOrDie(&connEstEvent);
+    }
+    break;
+
+    case DeviceEventType::kCHIPoBLEUnsubscribe: {
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEUnsubscribe");
+        HandleUnsubscribeReceived(event->CHIPoBLEUnsubscribe.ConId, &CHIP_BLE_SVC_ID, &Ble::CHIP_BLE_CHAR_2_UUID);
+    }
+    break;
+
+    case DeviceEventType::kCHIPoBLEWriteReceived: {
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEWriteReceived");
+        HandleWriteReceived(event->CHIPoBLEWriteReceived.ConId, &CHIP_BLE_SVC_ID, &Ble::CHIP_BLE_CHAR_1_UUID,
+                            PacketBufferHandle::Adopt(event->CHIPoBLEWriteReceived.Data));
+    }
+    break;
+
+    case DeviceEventType::kCHIPoBLEConnectionError: {
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEConnectionError");
+        HandleConnectionError(event->CHIPoBLEConnectionError.ConId, event->CHIPoBLEConnectionError.Reason);
+    }
+    break;
+
+    case DeviceEventType::kCHIPoBLEIndicateConfirm: {
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEIndicateConfirm");
+        HandleIndicationConfirmation(event->CHIPoBLEIndicateConfirm.ConId, &CHIP_BLE_SVC_ID, &Ble::CHIP_BLE_CHAR_2_UUID);
+    }
+    break;
+
+    default:
+        ChipLogProgress(DeviceLayer, "_OnPlatformEvent default:  event->Type = %d", event->Type);
+        break;
+    }
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::SubscribeCharacteristic(BLE_CONNECTION_OBJECT, const Ble::ChipBleUUID *,
+                                                           const Ble::ChipBleUUID *)
+{
+    ChipLogProgress(DeviceLayer, "AbstractBLEManagerImpl::SubscribeCharacteristic() not supported");
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT, const Ble::ChipBleUUID *,
+                                                             const Ble::ChipBleUUID *)
+{
+    ChipLogProgress(DeviceLayer, "AbstractBLEManagerImpl::UnsubscribeCharacteristic() not supported");
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::SendWriteRequest(BLE_CONNECTION_OBJECT, const Ble::ChipBleUUID *, const Ble::ChipBleUUID *,
+                                                    System::PacketBufferHandle)
+{
+    ChipLogProgress(DeviceLayer, "AbstractBLEManagerImpl::SendWriteRequest() not supported");
+    return CHIP_ERROR_NOT_IMPLEMENTED;
+}
+
+bool AbstractBLEManagerImpl::RemoveConnection(uint8_t connectionHandle)
+{
+    BLEConState * bleConnState = GetConnectionState(connectionHandle, true);
+    bool status                = false;
+
+    if (bleConnState != nullptr)
+    {
+        memset(bleConnState, 0, sizeof(BLEConState));
+        status = true;
+    }
+
+    return status;
+}
+
+void AbstractBLEManagerImpl::AddConnection(uint8_t connectionHandle, uint8_t bondingHandle)
+{
+    BLEConState * bleConnState = GetConnectionState(connectionHandle, true);
+
+    if (bleConnState != nullptr)
+    {
+        memset(bleConnState, 0, sizeof(BLEConState));
+        bleConnState->allocated        = 1;
+        bleConnState->connectionHandle = connectionHandle;
+        bleConnState->bondingHandle    = bondingHandle;
+    }
+}
+
+AbstractBLEManagerImpl::BLEConState * AbstractBLEManagerImpl::GetConnectionState(uint8_t connectionHandle, bool allocate)
+{
+    uint8_t freeIndex = kMaxConnections;
+
+    for (uint8_t i = 0; i < kMaxConnections; i++)
+    {
+        if (mBleConnections[i].allocated == 1)
+        {
+            if (mBleConnections[i].connectionHandle == connectionHandle)
+            {
+                return &mBleConnections[i];
+            }
+        }
+        else if (i < freeIndex)
+        {
+            freeIndex = i;
+        }
+    }
+
+    if (allocate)
+    {
+        if (freeIndex < kMaxConnections)
+        {
+            return &mBleConnections[freeIndex];
+        }
+
+        ChipLogError(DeviceLayer, "Failed to allocate BLEConState");
+    }
+
+    return nullptr;
+}
+
+uint8_t AbstractBLEManagerImpl::GetTimerHandle(uint8_t connectionHandle, bool allocate)
+{
+    uint8_t freeIndex = kMaxConnections;
+
+    for (uint8_t i = 0; i < kMaxConnections; i++)
+    {
+        if (mIndConfId[i] == connectionHandle)
+        {
+            return i;
+        }
+        else if (allocate && i < freeIndex)
+        {
+            freeIndex = i;
+        }
+    }
+
+    if (freeIndex < kMaxConnections)
+    {
+        mIndConfId[freeIndex] = connectionHandle;
+    }
+    else if (allocate)
+    {
+        ChipLogError(DeviceLayer, "Failed to Save Conn Handle for indication");
+    }
+
+    return freeIndex;
+}
+
+CHIP_ERROR AbstractBLEManagerImpl::MapBLEError(int bleErr)
+{
+    switch (bleErr)
+    {
+    case SL_STATUS_OK:
+        return CHIP_NO_ERROR;
+    case SL_STATUS_BT_ATT_INVALID_ATT_LENGTH:
+        return CHIP_ERROR_INVALID_STRING_LENGTH;
+    case SL_STATUS_INVALID_PARAMETER:
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    case SL_STATUS_INVALID_STATE:
+        return CHIP_ERROR_INCORRECT_STATE;
+    case SL_STATUS_NOT_SUPPORTED:
+        return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+    default:
+        return CHIP_ERROR(ChipError::Range::kPlatform, bleErr + CHIP_DEVICE_CONFIG_SILABS_BLE_ERROR_MIN);
+    }
+}
+
+} // namespace Internal
+} // namespace DeviceLayer
+} // namespace chip
+
+#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE