From 10b62b81ff384d57d0dc76cd48c9b74d3570ae7a Mon Sep 17 00:00:00 2001 From: Todd Chou Date: Thu, 6 Jan 2022 17:06:42 +0800 Subject: [PATCH] Infineon CYW30739 - lighting-app support --- .github/.wordlist.txt | 3 + .github/workflows/examples-cyw30739.yaml | 72 ++ .gitmodules | 16 + examples/build_overrides/cyw30739_sdk.gni | 19 + examples/lighting-app/cyw30739/.gn | 28 + examples/lighting-app/cyw30739/BUILD.gn | 68 ++ examples/lighting-app/cyw30739/README.md | 104 ++ examples/lighting-app/cyw30739/args.gni | 18 + .../lighting-app/cyw30739/build_overrides | 1 + .../cyw30739/include/AppShellCommands.h | 22 + .../cyw30739/include/ButtonHandler.h | 13 + .../cyw30739/include/CHIPProjectConfig.h | 61 ++ .../cyw30739/include/LightingManager.h | 75 ++ .../cyw30739/src/AppShellCommands.cpp | 103 ++ .../cyw30739/src/ButtonHandler.cpp | 77 ++ .../cyw30739/src/LightingManager.cpp | 116 +++ .../cyw30739/src/ZclCallbacks.cpp | 71 ++ examples/lighting-app/cyw30739/src/main.cpp | 181 ++++ .../lighting-app/cyw30739/static_config.txt | 21 + .../cyw30739/third_party/connectedhomeip | 1 + examples/platform/cyw30739/BUILD.gn | 27 + examples/platform/cyw30739/args.gni | 19 + .../project_include/OpenThreadConfig.h | 36 + scripts/flashing/cyw30739_firmware_utils.py | 134 +++ scripts/tools/memory/platform/cyw30739.cfg | 41 + src/lib/shell/BUILD.gn | 5 + src/lib/shell/MainLoopCYW30739.cpp | 176 ++++ src/lib/shell/streamer_cyw30739.cpp | 77 ++ src/lwip/BUILD.gn | 8 +- src/lwip/cyw30739/arch/cc.h | 23 + src/lwip/cyw30739/arch/perf.h | 20 + src/lwip/cyw30739/lwipopts.h | 118 +++ src/platform/BUILD.gn | 7 + src/platform/CYW30739/BLEManagerImpl.cpp | 917 ++++++++++++++++++ src/platform/CYW30739/BLEManagerImpl.h | 180 ++++ src/platform/CYW30739/BUILD.gn | 81 ++ src/platform/CYW30739/BlePlatformConfig.h | 34 + .../CYW30739/CHIPDevicePlatformConfig.h | 72 ++ .../CYW30739/CHIPDevicePlatformEvent.h | 44 + src/platform/CYW30739/CHIPPlatformConfig.h | 31 + src/platform/CYW30739/CYW30739Config.cpp | 130 +++ src/platform/CYW30739/CYW30739Config.h | 94 ++ .../CYW30739/ConfigurationManagerImpl.cpp | 169 ++++ .../CYW30739/ConfigurationManagerImpl.h | 74 ++ .../CYW30739/ConnectivityManagerImpl.cpp | 57 ++ .../CYW30739/ConnectivityManagerImpl.h | 97 ++ .../DeviceNetworkProvisioningDelegateImpl.cpp | 39 + .../DeviceNetworkProvisioningDelegateImpl.h | 43 + .../CYW30739/DiagnosticDataProviderImpl.cpp | 69 ++ .../CYW30739/DiagnosticDataProviderImpl.h | 48 + src/platform/CYW30739/InetPlatformConfig.h | 27 + .../CYW30739/KeyValueStoreManagerImpl.cpp | 205 ++++ .../CYW30739/KeyValueStoreManagerImpl.h | 107 ++ src/platform/CYW30739/Logging.cpp | 37 + src/platform/CYW30739/PlatformManagerImpl.cpp | 251 +++++ src/platform/CYW30739/PlatformManagerImpl.h | 103 ++ src/platform/CYW30739/SystemPlatformConfig.h | 31 + src/platform/CYW30739/SystemTimeSupport.cpp | 66 ++ .../CYW30739/ThreadStackManagerImpl.cpp | 108 +++ .../CYW30739/ThreadStackManagerImpl.h | 102 ++ src/platform/CYW30739/args.gni | 66 ++ src/platform/CYW30739/cycfg_gatt_db.c | 128 +++ src/platform/CYW30739/cycfg_gatt_db.h | 95 ++ .../CYW30739/cyw30739-chip-mbedtls-config.h | 202 ++++ src/platform/CYW30739/wiced_button_manager.c | 691 +++++++++++++ src/platform/CYW30739/wiced_led_manager.c | 305 ++++++ src/platform/device.gni | 6 +- third_party/cyw30739_sdk/BUILD.gn | 45 + .../bsp_design_modus/cycfg_notices.h | 41 + .../bsp_design_modus/cycfg_pins.c | 121 +++ .../bsp_design_modus/cycfg_pins.h | 92 ++ .../bsp_design_modus/cycfg_routing.h | 52 + third_party/cyw30739_sdk/btp_reader.py | 31 + third_party/cyw30739_sdk/cyw30739_arm.gni | 17 + .../cyw30739_sdk/cyw30739_executable.gni | 81 ++ third_party/cyw30739_sdk/cyw30739_sdk.gni | 281 ++++++ third_party/cyw30739_sdk/include/auto_flags.h | 7 + .../include/wiced_button_manager.h | 234 +++++ .../cyw30739_sdk/include/wiced_led_manager.h | 135 +++ third_party/cyw30739_sdk/repos/30739A0 | 1 + .../cyw30739_sdk/repos/CYW930739M2EVB-01 | 1 + third_party/cyw30739_sdk/repos/btsdk-include | 1 + third_party/cyw30739_sdk/repos/btsdk-tools | 1 + .../cyw30739_sdk/src/platform_retarget_lock.c | 89 ++ third_party/openthread/ot-ifx | 1 + third_party/openthread/platforms/ifx/BUILD.gn | 53 + 86 files changed, 7751 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/examples-cyw30739.yaml create mode 100644 examples/build_overrides/cyw30739_sdk.gni create mode 100644 examples/lighting-app/cyw30739/.gn create mode 100644 examples/lighting-app/cyw30739/BUILD.gn create mode 100644 examples/lighting-app/cyw30739/README.md create mode 100644 examples/lighting-app/cyw30739/args.gni create mode 120000 examples/lighting-app/cyw30739/build_overrides create mode 100644 examples/lighting-app/cyw30739/include/AppShellCommands.h create mode 100644 examples/lighting-app/cyw30739/include/ButtonHandler.h create mode 100644 examples/lighting-app/cyw30739/include/CHIPProjectConfig.h create mode 100644 examples/lighting-app/cyw30739/include/LightingManager.h create mode 100644 examples/lighting-app/cyw30739/src/AppShellCommands.cpp create mode 100644 examples/lighting-app/cyw30739/src/ButtonHandler.cpp create mode 100644 examples/lighting-app/cyw30739/src/LightingManager.cpp create mode 100644 examples/lighting-app/cyw30739/src/ZclCallbacks.cpp create mode 100644 examples/lighting-app/cyw30739/src/main.cpp create mode 100644 examples/lighting-app/cyw30739/static_config.txt create mode 120000 examples/lighting-app/cyw30739/third_party/connectedhomeip create mode 100644 examples/platform/cyw30739/BUILD.gn create mode 100644 examples/platform/cyw30739/args.gni create mode 100644 examples/platform/cyw30739/project_include/OpenThreadConfig.h create mode 100644 scripts/flashing/cyw30739_firmware_utils.py create mode 100644 scripts/tools/memory/platform/cyw30739.cfg create mode 100644 src/lib/shell/MainLoopCYW30739.cpp create mode 100644 src/lib/shell/streamer_cyw30739.cpp create mode 100644 src/lwip/cyw30739/arch/cc.h create mode 100644 src/lwip/cyw30739/arch/perf.h create mode 100644 src/lwip/cyw30739/lwipopts.h create mode 100644 src/platform/CYW30739/BLEManagerImpl.cpp create mode 100644 src/platform/CYW30739/BLEManagerImpl.h create mode 100644 src/platform/CYW30739/BUILD.gn create mode 100644 src/platform/CYW30739/BlePlatformConfig.h create mode 100644 src/platform/CYW30739/CHIPDevicePlatformConfig.h create mode 100644 src/platform/CYW30739/CHIPDevicePlatformEvent.h create mode 100644 src/platform/CYW30739/CHIPPlatformConfig.h create mode 100644 src/platform/CYW30739/CYW30739Config.cpp create mode 100644 src/platform/CYW30739/CYW30739Config.h create mode 100644 src/platform/CYW30739/ConfigurationManagerImpl.cpp create mode 100644 src/platform/CYW30739/ConfigurationManagerImpl.h create mode 100644 src/platform/CYW30739/ConnectivityManagerImpl.cpp create mode 100644 src/platform/CYW30739/ConnectivityManagerImpl.h create mode 100644 src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.cpp create mode 100644 src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.h create mode 100644 src/platform/CYW30739/DiagnosticDataProviderImpl.cpp create mode 100644 src/platform/CYW30739/DiagnosticDataProviderImpl.h create mode 100644 src/platform/CYW30739/InetPlatformConfig.h create mode 100644 src/platform/CYW30739/KeyValueStoreManagerImpl.cpp create mode 100644 src/platform/CYW30739/KeyValueStoreManagerImpl.h create mode 100644 src/platform/CYW30739/Logging.cpp create mode 100644 src/platform/CYW30739/PlatformManagerImpl.cpp create mode 100644 src/platform/CYW30739/PlatformManagerImpl.h create mode 100644 src/platform/CYW30739/SystemPlatformConfig.h create mode 100644 src/platform/CYW30739/SystemTimeSupport.cpp create mode 100644 src/platform/CYW30739/ThreadStackManagerImpl.cpp create mode 100644 src/platform/CYW30739/ThreadStackManagerImpl.h create mode 100644 src/platform/CYW30739/args.gni create mode 100644 src/platform/CYW30739/cycfg_gatt_db.c create mode 100644 src/platform/CYW30739/cycfg_gatt_db.h create mode 100644 src/platform/CYW30739/cyw30739-chip-mbedtls-config.h create mode 100644 src/platform/CYW30739/wiced_button_manager.c create mode 100644 src/platform/CYW30739/wiced_led_manager.c create mode 100644 third_party/cyw30739_sdk/BUILD.gn create mode 100644 third_party/cyw30739_sdk/bsp_design_modus/cycfg_notices.h create mode 100644 third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.c create mode 100644 third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.h create mode 100644 third_party/cyw30739_sdk/bsp_design_modus/cycfg_routing.h create mode 100644 third_party/cyw30739_sdk/btp_reader.py create mode 100644 third_party/cyw30739_sdk/cyw30739_arm.gni create mode 100644 third_party/cyw30739_sdk/cyw30739_executable.gni create mode 100644 third_party/cyw30739_sdk/cyw30739_sdk.gni create mode 100644 third_party/cyw30739_sdk/include/auto_flags.h create mode 100644 third_party/cyw30739_sdk/include/wiced_button_manager.h create mode 100644 third_party/cyw30739_sdk/include/wiced_led_manager.h create mode 160000 third_party/cyw30739_sdk/repos/30739A0 create mode 160000 third_party/cyw30739_sdk/repos/CYW930739M2EVB-01 create mode 160000 third_party/cyw30739_sdk/repos/btsdk-include create mode 160000 third_party/cyw30739_sdk/repos/btsdk-tools create mode 100644 third_party/cyw30739_sdk/src/platform_retarget_lock.c create mode 160000 third_party/openthread/ot-ifx create mode 100644 third_party/openthread/platforms/ifx/BUILD.gn diff --git a/.github/.wordlist.txt b/.github/.wordlist.txt index d7f33d37231f92..9318e7dd516afb 100644 --- a/.github/.wordlist.txt +++ b/.github/.wordlist.txt @@ -27,6 +27,7 @@ adb AddOrUpdateThreadNetwork AddOrUpdateWiFiNetwork addr +AddThreadNetwork adk adoc AdvAutonomous @@ -252,6 +253,7 @@ customizations cvfJ cxx CY +CYW DAC DAP DataFrame @@ -355,6 +357,7 @@ elftools elock emberAfExternalAttributeReadCallback emberAfExternalAttributeWriteCallback +EnableNetwork EnableWiFiNetwork EndpointId endpointName diff --git a/.github/workflows/examples-cyw30739.yaml b/.github/workflows/examples-cyw30739.yaml new file mode 100644 index 00000000000000..ef06899f9e7805 --- /dev/null +++ b/.github/workflows/examples-cyw30739.yaml @@ -0,0 +1,72 @@ +# Copyright (c) 2021 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +name: Build example - Infineon CYW30739 + +on: + push: + pull_request: + +concurrency: + group: ${{ github.ref }}-${{ github.workflow }}-${{ (github.event_name == 'pull_request' && github.event.number) || (github.event_name == 'workflow_dispatch' && github.run_number) || github.sha }} + cancel-in-progress: true + +jobs: + cyw30739: + name: CYW30739 + timeout-minutes: 60 + + runs-on: ubuntu-latest + if: github.actor != 'restyled-io[bot]' + + container: + image: connectedhomeip/chip-build:latest + volumes: + - "/tmp/bloat_reports:/tmp/bloat_reports" + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + submodules: true + + - name: Set up environment for size reports + if: ${{ !env.ACT }} + env: + GH_CONTEXT: ${{ toJson(github) }} + run: scripts/tools/memory/gh_sizes_environment.py "${GH_CONTEXT}" + + - name: Bootstrap + timeout-minutes: 25 + run: scripts/build/gn_bootstrap.sh + - name: Uploading bootstrap logs + uses: actions/upload-artifact@v2 + if: ${{ always() }} && ${{ !env.ACT }} + with: + name: bootstrap-logs + path: | + .environment/gn_out/.ninja_log + .environment/pigweed-venv/*.log + - name: Build example CYW30739 Lighting App + timeout-minutes: 10 + run: | + scripts/examples/gn_build_example.sh examples/lighting-app/cyw30739 out/lighting_app + .environment/pigweed-venv/bin/python3 scripts/tools/memory/gh_sizes.py cyw30739 CYW30739 lighting-app \ + out/lighting_app/chip-cyw30739-lighting-example.elf /tmp/bloat_reports/ + - name: Uploading Size Reports + uses: actions/upload-artifact@v2 + if: ${{ !env.ACT }} + with: + name: Size,CYW30739-Examples,${{ env.GH_EVENT_PR }},${{ env.GH_EVENT_HASH }},${{ env.GH_EVENT_PARENT }} + path: | + /tmp/bloat_reports/ diff --git a/.gitmodules b/.gitmodules index e90a9c72373ae2..d460c46d8b1f56 100644 --- a/.gitmodules +++ b/.gitmodules @@ -79,6 +79,10 @@ [submodule "third_party/openthread/ot-efr32"] path = third_party/openthread/ot-efr32 url = https://github.com/openthread/ot-efr32.git +[submodule "third_party/openthread/ot-ifx"] + path = third_party/openthread/ot-ifx + url = https://github.com/Infineon/ot-ifx-release.git + branch = cyw30739 [submodule "third_party/mbed-os/repo"] path = third_party/mbed-os/repo url = https://github.com/ARMmbed/mbed-os.git @@ -162,3 +166,15 @@ [submodule "p6/lwip"] path = third_party/p6/p6_sdk/libs/lwip url = https://github.com/lwip-tcpip/lwip.git +[submodule "cyw30739_sdk/30739A0"] + path = third_party/cyw30739_sdk/repos/30739A0 + url = https://github.com/Infineon/30739A0.git +[submodule "cyw30739_sdk/include"] + path = third_party/cyw30739_sdk/repos/btsdk-include + url = https://github.com/Infineon/btsdk-include.git +[submodule "cyw30739_sdk/target"] + path = third_party/cyw30739_sdk/repos/CYW930739M2EVB-01 + url = https://github.com/Infineon/TARGET_CYW930739M2EVB-01.git +[submodule "cyw30739_sdk/tools"] + path = third_party/cyw30739_sdk/repos/btsdk-tools + url = https://github.com/Infineon/btsdk-tools.git diff --git a/examples/build_overrides/cyw30739_sdk.gni b/examples/build_overrides/cyw30739_sdk.gni new file mode 100644 index 00000000000000..d2c81de46ba614 --- /dev/null +++ b/examples/build_overrides/cyw30739_sdk.gni @@ -0,0 +1,19 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +declare_args() { + # Root directory for CYW30739 SDK. + cyw30739_sdk_build_root = + "//third_party/connectedhomeip/third_party/cyw30739_sdk" +} diff --git a/examples/lighting-app/cyw30739/.gn b/examples/lighting-app/cyw30739/.gn new file mode 100644 index 00000000000000..90115e4209947e --- /dev/null +++ b/examples/lighting-app/cyw30739/.gn @@ -0,0 +1,28 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/build.gni") + +# The location of the build configuration file. +buildconfig = "${build_root}/config/BUILDCONFIG.gn" + +# CHIP uses angle bracket includes. +check_system_includes = true + +default_args = { + target_cpu = "arm" + target_os = "cyw30739" + + import("//args.gni") +} diff --git a/examples/lighting-app/cyw30739/BUILD.gn b/examples/lighting-app/cyw30739/BUILD.gn new file mode 100644 index 00000000000000..8912b0594c2c76 --- /dev/null +++ b/examples/lighting-app/cyw30739/BUILD.gn @@ -0,0 +1,68 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/build.gni") +import("//build_overrides/chip.gni") +import("//build_overrides/cyw30739_sdk.gni") + +import("${cyw30739_sdk_build_root}/cyw30739_executable.gni") +import("${cyw30739_sdk_build_root}/cyw30739_sdk.gni") + +cyw30739_project_dir = "${chip_root}/examples/lighting-app/cyw30739" + +declare_args() { + setupPinCode = 0 + setupDiscriminator = 0 +} + +cyw30739_sdk("sdk") { + sources = [ "${cyw30739_project_dir}/include/CHIPProjectConfig.h" ] + + include_dirs = [ "${cyw30739_project_dir}/include" ] + + defines = [ + "CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE=${setupPinCode}", + "CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR=${setupDiscriminator}", + ] +} + +cyw30739_executable("lighting_app") { + output_name = "chip-cyw30739-lighting-example.elf" + + sources = [ + "src/AppShellCommands.cpp", + "src/ButtonHandler.cpp", + "src/LightingManager.cpp", + "src/ZclCallbacks.cpp", + "src/main.cpp", + ] + + deps = [ + ":sdk", + "${chip_root}/examples/lighting-app/lighting-common", + "${chip_root}/examples/shell/shell_common:shell_common", + "${chip_root}/src/lib", + "${chip_root}/third_party/openthread/repo:libopenthread-ftd", + ] + + include_dirs = [ "include" ] +} + +group("cyw30739") { + deps = [ ":lighting_app" ] +} + +group("default") { + deps = [ ":cyw30739" ] +} diff --git a/examples/lighting-app/cyw30739/README.md b/examples/lighting-app/cyw30739/README.md new file mode 100644 index 00000000000000..3d333ee204a75c --- /dev/null +++ b/examples/lighting-app/cyw30739/README.md @@ -0,0 +1,104 @@ +# Matter CYW30739 Lighting Example + +An example showing the use of Matter on the Infineon CYW30739 platform. + +--- + +## Table of Contents + +- [CHIP CYW30739 Lighting Example](#matter-cyw30739-lighting-example) + - [Introduction](#introduction) + - [Building](#building) + - [Flashing the Application](#flashing-the-application) + - [Running the Complete Example](#running-the-complete-example) + +--- + +## Introduction + +The CYW30739 lighting example provides a baseline demonstration of a Light +control device, built using Matter and the Infineon Modustoolbox SDK. It can be +controlled by a Matter controller over Openthread network. + +The CYW30739 device can be commissioned over Bluetooth Low Energy where the +device and the Matter controller will exchange security information with the +Rendez-vous procedure. Thread Network credentials are then provided to the +CYW30739 device which will then join the network. + +## Building + +- Build the example application: + + ```bash + $ cd ~/connectedhomeip + $ git submodule update --init + $ ./scripts/examples/gn_build_example.sh examples/lighting-app/cyw30739 out/lighting-app + ``` + +- To delete generated executable, libraries and object files use: + + ```bash + $ cd ~/connectedhomeip + $ rm -rf ./out/ + ``` + +- OR use GN/Ninja directly + + ```bash + $ cd ~/connectedhomeip/examples/lighting-app/cyw30739 + $ git submodule update --init + $ source third_party/connectedhomeip/scripts/activate.sh + $ gn gen out/debug + $ ninja -C out/debug + ``` + +- To delete generated executable, libraries and object files use: + + ```bash + $ cd ~/connectedhomeip/examples/lighting-app/cyw30739 + $ rm -rf out/ + ``` + +## Flashing the Application + +### Enter Recovery Mode + +Put the CYW30739 in to the recovery mode before running the flash script. + +1. Press and hold the `RECOVERY` button on the board. +2. Press and hold the `RESET` button on the board. +3. Release the `RESET` button. +4. After one second, release the `RECOVERY` button. + +### Run Flash Script + +- On the command line: + + ```bash + $ cd ~/connectedhomeip/examples/lighting-app/cyw30739 + $ python3 out/debug/chip-cyw30739-lighting-example.flash.py + ``` + +## Running the Complete Example + +- It is assumed here that you already have an OpenThread border router + configured and running. If not see the following guide + [Openthread_border_router](https://github.com/project-chip/connectedhomeip/blob/master/docs/guides/openthread_border_router_pi.md) + for more information on how to setup a border router on a raspberryPi. + +- You can provision and control the Chip device using the python controller, + Chip tool standalone, Android or iOS app + + [Python Controller](https://github.com/project-chip/connectedhomeip/blob/master/src/controller/python/README.md) + + Here is an example with the Python controller: + + ```bash + $ chip-device-ctrl + chip-device-ctrl > connect -ble 3840 20202021 1234 + chip-device-ctrl > zcl NetworkCommissioning AddThreadNetwork 1234 0 0 operationalDataset=hex:0e080000000000000000000300000b35060004001fffe00208dead00beef00cafe0708fddead00beef000005108e11d8ea8ffaa875713699f59e8807e0030a4f70656e5468726561640102c2980410edc641eb63b100b87e90a9980959befc0c0402a0fff8 breadcrumb=0 timeoutMs=1000 + chip-device-ctrl > zcl NetworkCommissioning EnableNetwork 1234 0 0 networkID=hex:dead00beef00cafe breadcrumb=0 timeoutMs=1000 + chip-device-ctrl > close-ble + chip-device-ctrl > resolve 1234 + chip-device-ctrl > zcl OnOff Toggle 1234 1 0 + ``` diff --git a/examples/lighting-app/cyw30739/args.gni b/examples/lighting-app/cyw30739/args.gni new file mode 100644 index 00000000000000..149f7d42b18b5f --- /dev/null +++ b/examples/lighting-app/cyw30739/args.gni @@ -0,0 +1,18 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/chip.gni") +import("${chip_root}/src/platform/CYW30739/args.gni") + +cyw30739_sdk_target = get_label_info(":sdk", "label_no_toolchain") diff --git a/examples/lighting-app/cyw30739/build_overrides b/examples/lighting-app/cyw30739/build_overrides new file mode 120000 index 00000000000000..e578e73312ebd1 --- /dev/null +++ b/examples/lighting-app/cyw30739/build_overrides @@ -0,0 +1 @@ +../../build_overrides \ No newline at end of file diff --git a/examples/lighting-app/cyw30739/include/AppShellCommands.h b/examples/lighting-app/cyw30739/include/AppShellCommands.h new file mode 100644 index 00000000000000..575d6c24a3e2d0 --- /dev/null +++ b/examples/lighting-app/cyw30739/include/AppShellCommands.h @@ -0,0 +1,22 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +void RegisterAppShellCommands(); diff --git a/examples/lighting-app/cyw30739/include/ButtonHandler.h b/examples/lighting-app/cyw30739/include/ButtonHandler.h new file mode 100644 index 00000000000000..78f3fa66e1d731 --- /dev/null +++ b/examples/lighting-app/cyw30739/include/ButtonHandler.h @@ -0,0 +1,13 @@ +/* + * $ Copyright 2021-YEAR Cypress Semiconductor $ + */ +#include "wiced.h" + +typedef enum +{ + ON_OFF_BUTTON, + APP_MAX_BUTTON, +} application_button_t; +#define APP_MAX_BUTTON_DEF 1 // define for preprocessor + +wiced_result_t app_button_init(void); diff --git a/examples/lighting-app/cyw30739/include/CHIPProjectConfig.h b/examples/lighting-app/cyw30739/include/CHIPProjectConfig.h new file mode 100644 index 00000000000000..f9a91d3f03b70f --- /dev/null +++ b/examples/lighting-app/cyw30739/include/CHIPProjectConfig.h @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Example project configuration file for CHIP. + * + * This is a place to put application or project-specific overrides + * to the default configuration values for general CHIP features. + * + */ + +#pragma once + +// -------------------- Device Identification Configuration -------------------- + +/* The VendorName attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME "Infineon" + +/* The VendorID attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_VENDOR_ID 0x0009 + +/* The ProductName attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME "CYW30739 Lighting App" + +/* The ProductID attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID 0x154c + +/* The HardwareVersionString attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING "30739" + +/* The HardwareVersion attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION 30739 + +/* The SoftwareVersionString attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING "TE7.5" + +/* The SoftwareVersion attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION 0x0705 + +/* The SerialNumber attribute of the Basic cluster. */ +#define CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER "TEST_SN" + +// -------------------- Test Configuration -------------------- +#define CHIP_DEVICE_CONFIG_ENABLE_TEST_DEVICE_IDENTITY 1 diff --git a/examples/lighting-app/cyw30739/include/LightingManager.h b/examples/lighting-app/cyw30739/include/LightingManager.h new file mode 100644 index 00000000000000..0ce5b5c4073bfa --- /dev/null +++ b/examples/lighting-app/cyw30739/include/LightingManager.h @@ -0,0 +1,75 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include + +class LightingManager +{ +public: + enum Action_t + { + ON_ACTION = 0, + OFF_ACTION, + LEVEL_ACTION, + + INVALID_ACTION + } Action; + + enum State_t + { + kState_OffInitiated = 0, + kState_OffCompleted, + kState_OnInitiated, + kState_OnCompleted, + } State; + + enum Actor_t + { + ACTOR_ZCL_CMD = 0, + ACTOR_APP_CMD, + ACTOR_BUTTON, + } Actor; + + CHIP_ERROR Init(); + bool IsLightOn(); + bool IsActionInProgress(); + bool InitiateAction(Actor_t aActor, Action_t aAction, uint8_t vallue); + + typedef void (*Callback_fn_initiated)(Actor_t, Action_t, uint8_t); + typedef void (*Callback_fn_completed)(Action_t); + void SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB); + +private: + void WriteClusterState(uint8_t value); + void WriteClusterLevel(uint8_t value); + + friend LightingManager & LightMgr(void); + State_t mState; + + Callback_fn_initiated mActionInitiated_CB; + Callback_fn_completed mActionCompleted_CB; + + static LightingManager sLight; +}; + +inline LightingManager & LightMgr(void) +{ + return LightingManager::sLight; +} diff --git a/examples/lighting-app/cyw30739/src/AppShellCommands.cpp b/examples/lighting-app/cyw30739/src/AppShellCommands.cpp new file mode 100644 index 00000000000000..84f7b74adefc94 --- /dev/null +++ b/examples/lighting-app/cyw30739/src/AppShellCommands.cpp @@ -0,0 +1,103 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "LightingManager.h" +#include +#include + +using namespace chip::Shell; + +static CHIP_ERROR AppCommandHelpHandler(int argc, char * argv[]); +static CHIP_ERROR AppCommandLightingHandler(int argc, char * argv[]); +static CHIP_ERROR AppCommandDispatch(int argc, char * argv[]); + +static chip::Shell::Engine sAppSubcommands; + +void RegisterAppShellCommands(void) +{ + static const shell_command_t sAppSubCommands[] = { + { + .cmd_func = AppCommandHelpHandler, + .cmd_name = "help", + .cmd_help = "Usage: app ", + }, + { + .cmd_func = AppCommandLightingHandler, + .cmd_name = "light", + .cmd_help = "Usage: app light [on|off|toggle]", + }, + }; + + static const shell_command_t sAppCommand = { + .cmd_func = AppCommandDispatch, + .cmd_name = "app", + .cmd_help = "App commands", + }; + + sAppSubcommands.RegisterCommands(sAppSubCommands, ArraySize(sAppSubCommands)); + + Engine::Root().RegisterCommands(&sAppCommand, 1); +} + +CHIP_ERROR AppCommandHelpHandler(int argc, char * argv[]) +{ + sAppSubcommands.ForEachCommand(PrintCommandHelp, nullptr); + return CHIP_NO_ERROR; +} + +CHIP_ERROR AppCommandLightingHandler(int argc, char * argv[]) +{ + if (argc == 0) + { + streamer_printf(streamer_get(), "The light is %s\n", LightMgr().IsLightOn() ? "on" : "off"); + } + else if (strcmp(argv[0], "on") == 0) + { + streamer_printf(streamer_get(), "Turning the light on ...\n"); + LightMgr().InitiateAction(LightingManager::ACTOR_APP_CMD, LightingManager::ON_ACTION, 0); + } + else if (strcmp(argv[0], "off") == 0) + { + streamer_printf(streamer_get(), "Turning the light off ...\n"); + LightMgr().InitiateAction(LightingManager::ACTOR_APP_CMD, LightingManager::OFF_ACTION, 0); + } + else if (strcmp(argv[0], "toggle") == 0) + { + streamer_printf(streamer_get(), "Toggling the light ...\n"); + if (LightMgr().IsLightOn()) + LightMgr().InitiateAction(LightingManager::ACTOR_APP_CMD, LightingManager::OFF_ACTION, 0); + else + LightMgr().InitiateAction(LightingManager::ACTOR_APP_CMD, LightingManager::ON_ACTION, 0); + } + else + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + return CHIP_NO_ERROR; +} + +CHIP_ERROR AppCommandDispatch(int argc, char * argv[]) +{ + if (argc == 0) + { + AppCommandHelpHandler(argc, argv); + return CHIP_NO_ERROR; + } + return sAppSubcommands.ExecCommand(argc, argv); +} diff --git a/examples/lighting-app/cyw30739/src/ButtonHandler.cpp b/examples/lighting-app/cyw30739/src/ButtonHandler.cpp new file mode 100644 index 00000000000000..85eae4a4aac974 --- /dev/null +++ b/examples/lighting-app/cyw30739/src/ButtonHandler.cpp @@ -0,0 +1,77 @@ +/* + * $ Copyright 2021-YEAR Cypress Semiconductor $ + */ + +/* + * @app_button.cpp : Application's Button-list entries + */ +#include +#include +#include +#include +#include +#include + +/****************************************************** + * Macros + ******************************************************/ +void app_button_event_handler(const button_manager_button_t * button, button_manager_event_t event, + button_manager_button_state_t state); + +static wiced_button_manager_configuration_t app_button_manager_configuration = { + .short_hold_duration = 500, /*msec*/ + .medium_hold_duration = 700, + .long_hold_duration = 1500, + .very_long_hold_duration = 2500, + .debounce_duration = 150, /* typically a click takes around ~150-200 ms */ + .double_click_interval = 250, + .continuous_hold_detect = WICED_TRUE, + .event_handler = app_button_event_handler, +}; + +/* Static button configuration */ +static wiced_button_configuration_t app_button_configurations[APP_MAX_BUTTON_DEF]; +/* Button objects for the button manager */ +static button_manager_button_t app_buttons[APP_MAX_BUTTON_DEF]; +static button_manager_t app_button_manager; + +wiced_result_t app_button_init(void) +{ + wiced_result_t result = WICED_ERROR; + + memset(app_button_configurations, 0, (sizeof(wiced_button_configuration_t) * APP_MAX_BUTTON_DEF)); + memset(app_buttons, 0, (sizeof(button_manager_button_t) * APP_MAX_BUTTON_DEF)); + + app_button_configurations[ON_OFF_BUTTON].button = PLATFORM_BUTTON_1; + app_button_configurations[ON_OFF_BUTTON].button_event_mask = BUTTON_CLICK_EVENT; + app_buttons[ON_OFF_BUTTON].configuration = &app_button_configurations[ON_OFF_BUTTON]; + + result = wiced_button_manager_init(&app_button_manager, &app_button_manager_configuration, app_buttons, 1); + + if (result != WICED_SUCCESS) + { + printf("button_manager_init failed (%d)\n", result); + } + return result; +} + +void app_button_event_handler(const button_manager_button_t * button_mgr, button_manager_event_t event, + button_manager_button_state_t state) +{ + // printf("app_button_event_handler. button=%d, event=%d, state=%d\n", button_mgr[ON_OFF_BUTTON].configuration->button, event, + // state); + + if (button_mgr[0].configuration->button == PLATFORM_BUTTON_1 && event == BUTTON_CLICK_EVENT && state == BUTTON_STATE_RELEASED) + { + if (LightMgr().IsLightOn()) + { + printf("Button Toggle:ON -> OFF\n"); + LightMgr().InitiateAction(LightingManager::ACTOR_BUTTON, LightingManager::OFF_ACTION, 0); + } + else + { + printf("Button Toggle:OFF -> ON\n"); + LightMgr().InitiateAction(LightingManager::ACTOR_BUTTON, LightingManager::ON_ACTION, 0); + } + } +} diff --git a/examples/lighting-app/cyw30739/src/LightingManager.cpp b/examples/lighting-app/cyw30739/src/LightingManager.cpp new file mode 100644 index 00000000000000..34c46d9fde9f42 --- /dev/null +++ b/examples/lighting-app/cyw30739/src/LightingManager.cpp @@ -0,0 +1,116 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "LightingManager.h" +#include +#include +#include +#include +#include +#include + +LightingManager LightingManager::sLight; + +CHIP_ERROR LightingManager::Init() +{ + mState = kState_OffCompleted; + + return CHIP_NO_ERROR; +} + +void LightingManager::SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB) +{ + mActionInitiated_CB = aActionInitiated_CB; + mActionCompleted_CB = aActionCompleted_CB; +} + +bool LightingManager::IsActionInProgress() +{ + return (mState == kState_OffInitiated || mState == kState_OnInitiated); +} + +bool LightingManager::IsLightOn(void) +{ + uint8_t value; + const EmberAfStatus status = + emberAfReadServerAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, &value, sizeof(value)); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + printf("Error ReadServerAttribute 0x%02x\n", status); + } + + return value != 0; +} + +bool LightingManager::InitiateAction(Actor_t aActor, Action_t aAction, uint8_t value) +{ + if (mActionInitiated_CB) + { + mActionInitiated_CB(aActor, aAction, value); + } + + switch (aAction) + { + case ON_ACTION: + mState = kState_OnInitiated; + if (aActor != ACTOR_ZCL_CMD) + { + WriteClusterState(1); + } + mState = kState_OnCompleted; + break; + case OFF_ACTION: + mState = kState_OffInitiated; + if (aActor != ACTOR_ZCL_CMD) + { + WriteClusterState(0); + } + mState = kState_OffCompleted; + break; + default: + return false; + } + + if (mActionCompleted_CB) + { + mActionCompleted_CB(aAction); + } + + return true; +} + +void LightingManager::WriteClusterState(uint8_t value) +{ + const EmberAfStatus status = + emberAfWriteServerAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, &value, ZCL_BOOLEAN_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + printf("Error WriteServerAttribute 0x%02x\n", status); + } +} + +void LightingManager::WriteClusterLevel(uint8_t value) +{ + const EmberAfStatus status = emberAfWriteServerAttribute(1, ZCL_LEVEL_CONTROL_CLUSTER_ID, ZCL_CURRENT_LEVEL_ATTRIBUTE_ID, + &value, ZCL_INT8U_ATTRIBUTE_TYPE); + if (status != EMBER_ZCL_STATUS_SUCCESS) + { + printf("Error WriteServerAttribute 0x%02x\n", status); + } +} diff --git a/examples/lighting-app/cyw30739/src/ZclCallbacks.cpp b/examples/lighting-app/cyw30739/src/ZclCallbacks.cpp new file mode 100644 index 00000000000000..ce4b51297cc321 --- /dev/null +++ b/examples/lighting-app/cyw30739/src/ZclCallbacks.cpp @@ -0,0 +1,71 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "LightingManager.h" +#include +#include + +using namespace chip; +using namespace chip::app::Clusters; +using namespace chip::DeviceLayer; + +void emberAfBasicClusterInitCallback(EndpointId endpoint) +{ + uint16_t year; + uint8_t month; + uint8_t dayOfMonth; + char cString[16] = "00000000"; + + if (ConfigurationMgr().GetManufacturingDate(year, month, dayOfMonth) == CHIP_NO_ERROR) + { + snprintf(cString, sizeof(cString), "%04u%02u%02u", year, month, dayOfMonth); + } + Basic::Attributes::ManufacturingDate::Set(endpoint, CharSpan(cString)); +} + +void MatterPostAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint8_t mask, uint8_t type, uint16_t size, + uint8_t * value) + +{ + switch (attributePath.mClusterId) + { + case OnOff::Id: + if (attributePath.mAttributeId == OnOff::Attributes::OnOff::Id) + { + printf("ZCL OnOff -> %u\n", *value); + LightMgr().InitiateAction(LightingManager::ACTOR_ZCL_CMD, + (*value == 0) ? LightingManager::OFF_ACTION : LightingManager::ON_ACTION, *value); + return; + } + break; + case LevelControl::Id: + if (attributePath.mAttributeId == LevelControl::Attributes::CurrentLevel::Id) + { + printf("ZCL CurrentLevel -> %u\n", *value); + LightMgr().InitiateAction(LightingManager::ACTOR_ZCL_CMD, LightingManager::LEVEL_ACTION, *value); + return; + } + break; + default: + printf("Unhandled cluster ID: 0x%04lx\n", attributePath.mClusterId); + return; + } + + printf("ERROR clusterId: 0x%04lx, unknown attribute ID: 0x%04lx\n", attributePath.mClusterId, attributePath.mAttributeId); +} diff --git a/examples/lighting-app/cyw30739/src/main.cpp b/examples/lighting-app/cyw30739/src/main.cpp new file mode 100644 index 00000000000000..3a99588bc7f4f6 --- /dev/null +++ b/examples/lighting-app/cyw30739/src/main.cpp @@ -0,0 +1,181 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::chip::Credentials; +using namespace ::chip::DeviceLayer; +using namespace ::chip::Shell; + +static void EventHandler(const ChipDeviceEvent * event, intptr_t arg); +static void HandleThreadStateChangeEvent(const ChipDeviceEvent * event); +static void LightManagerCallback(LightingManager::Actor_t actor, LightingManager::Action_t action, uint8_t value); + +static wiced_led_config_t chip_lighting_led_config = { + .led = PLATFORM_LED_1, + .bright = 50, +}; + +APPLICATION_START() +{ + CHIP_ERROR err; + wiced_result_t result; + + printf("\nChipLighting App starting\n"); + + mbedtls_platform_set_calloc_free(CHIPPlatformMemoryCalloc, CHIPPlatformMemoryFree); + + err = chip::Platform::MemoryInit(); + if (err != CHIP_NO_ERROR) + { + printf("ERROR MemoryInit %ld\n", err.AsInteger()); + } + + result = app_button_init(); + if (result != WICED_SUCCESS) + { + printf("ERROR app_button_init %d\n", result); + } + + /* Init. LED Manager. */ + result = wiced_led_manager_init(&chip_lighting_led_config); + if (result != WICED_SUCCESS) + printf("wiced_led_manager_init fail (%d)\n", result); + + printf("Initializing CHIP\n"); + err = PlatformMgr().InitChipStack(); + if (err != CHIP_NO_ERROR) + { + printf("ERROR InitChipStack %ld\n", err.AsInteger()); + } + +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + printf("Initializing OpenThread stack\n"); + err = ThreadStackMgr().InitThreadStack(); + if (err != CHIP_NO_ERROR) + { + printf("ERROR InitThreadStack %ld\n", err.AsInteger()); + } +#endif + +#if CHIP_DEVICE_CONFIG_THREAD_FTD + err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_Router); +#else // !CHIP_DEVICE_CONFIG_THREAD_FTD + err = ConnectivityMgr().SetThreadDeviceType(ConnectivityManager::kThreadDeviceType_MinimalEndDevice); +#endif // CHIP_DEVICE_CONFIG_THREAD_FTD + if (err != CHIP_NO_ERROR) + { + printf("ERROR SetThreadDeviceType %ld\n", err.AsInteger()); + } + + printf("Starting event loop task\n"); + err = PlatformMgr().StartEventLoopTask(); + if (err != CHIP_NO_ERROR) + { + printf("ERROR StartEventLoopTask %ld\n", err.AsInteger()); + } + +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + printf("Starting thread task\n"); + err = ThreadStackMgr().StartThreadTask(); + if (err != CHIP_NO_ERROR) + { + printf("ERROR StartThreadTask %ld\n", err.AsInteger()); + } +#endif + + PlatformMgrImpl().AddEventHandler(EventHandler, 0); + + LightMgr().Init(); + LightMgr().SetCallbacks(LightManagerCallback, NULL); + + /* Start CHIP datamodel server */ + chip::Server::GetInstance().Init(); + + SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider()); + + ConfigurationMgr().LogDeviceConfig(); + + const int ret = Engine::Root().Init(); + if (!chip::ChipError::IsSuccess(ret)) + { + printf("ERROR Shell Init %d\n", ret); + } + cmd_ping_init(); + RegisterAppShellCommands(); + Engine::Root().RunMainLoop(); + + assert(!wiced_rtos_check_for_stack_overflow()); +} + +void EventHandler(const ChipDeviceEvent * event, intptr_t arg) +{ + switch (event->Type) + { + case DeviceEventType::kThreadStateChange: + HandleThreadStateChangeEvent(event); + break; + default: + break; + } +} + +void HandleThreadStateChangeEvent(const ChipDeviceEvent * event) +{ +#if CHIP_BYPASS_RENDEZVOUS + if (event->ThreadStateChange.NetDataChanged && !ConnectivityMgr().IsThreadProvisioned()) + { + ThreadStackMgr().JoinerStart(); + } +#endif /* CHIP_BYPASS_RENDEZVOUS */ +} + +void LightManagerCallback(LightingManager::Actor_t actor, LightingManager::Action_t action, uint8_t level) +{ + if (action == LightingManager::ON_ACTION) + { + printf("Turning light ON\n"); + wiced_led_manager_enable_led(PLATFORM_LED_1); + } + else if (action == LightingManager::OFF_ACTION) + { + printf("Turning light OFF\n"); + wiced_led_manager_disable_led(PLATFORM_LED_1); + } + else if (action == LightingManager::LEVEL_ACTION) + { + printf("Set light level = %d\n", level); + chip_lighting_led_config.bright = (uint16_t) level * 100 / 0xfe; + wiced_led_manager_reconfig_led(&chip_lighting_led_config); + } +} diff --git a/examples/lighting-app/cyw30739/static_config.txt b/examples/lighting-app/cyw30739/static_config.txt new file mode 100644 index 00000000000000..f256ac94aa5abf --- /dev/null +++ b/examples/lighting-app/cyw30739/static_config.txt @@ -0,0 +1,21 @@ +# The post-building script uses this file to generate specified static configurations. +# All '#' prefixed lines are ignored by the script. +# Each line defines a static configuration by 3 fields separated by commas. +# +# The 1st field is a 16-bit ID from 0x2000 to 0x3ffff. +# All IDs in this file have to be different. +# +# The 2nd field is a type to which the script interprets the value according. +# +# The 3rd field is a value of the static configuration. The value format depends on what the value type is: +# - hex: Multiple hexadecimal values separated by commas. +# - uint32/uint16/uint8/int16/int8: A integer. +# - eui64: random or btext. If the value is btext, the configuration will be generated from the BT address. +# +# ID, type, value +# EUI64 +0x2000, eui64, random +# Setup Pin Code +0x2105, uint32, 20202021 +# Setup Discriminator +0x2107, uint32, 3840 diff --git a/examples/lighting-app/cyw30739/third_party/connectedhomeip b/examples/lighting-app/cyw30739/third_party/connectedhomeip new file mode 120000 index 00000000000000..c866b86874994d --- /dev/null +++ b/examples/lighting-app/cyw30739/third_party/connectedhomeip @@ -0,0 +1 @@ +../../../.. \ No newline at end of file diff --git a/examples/platform/cyw30739/BUILD.gn b/examples/platform/cyw30739/BUILD.gn new file mode 100644 index 00000000000000..8390dd680d1004 --- /dev/null +++ b/examples/platform/cyw30739/BUILD.gn @@ -0,0 +1,27 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/chip.gni") + +config("chip_examples_project_config") { + include_dirs = [ "project_include" ] +} + +source_set("openthread_core_config_ifx_chip_examples") { + sources = [ "project_include/OpenThreadConfig.h" ] + + public_deps = [ "${chip_root}/third_party/openthread/platforms/ifx:openthread_core_config_ifx" ] + + public_configs = [ ":chip_examples_project_config" ] +} diff --git a/examples/platform/cyw30739/args.gni b/examples/platform/cyw30739/args.gni new file mode 100644 index 00000000000000..4c1695e32252e1 --- /dev/null +++ b/examples/platform/cyw30739/args.gni @@ -0,0 +1,19 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +chip_ble_project_config_include = "" +chip_device_project_config_include = "" +chip_project_config_include = "" +chip_inet_project_config_include = "" +chip_system_project_config_include = "" diff --git a/examples/platform/cyw30739/project_include/OpenThreadConfig.h b/examples/platform/cyw30739/project_include/OpenThreadConfig.h new file mode 100644 index 00000000000000..eb6006f52d5cfe --- /dev/null +++ b/examples/platform/cyw30739/project_include/OpenThreadConfig.h @@ -0,0 +1,36 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Overrides to default OpenThread configuration. + * + */ + +#pragma once + +#ifndef OPENTHREAD_CONFIG_LOG_LEVEL +#define OPENTHREAD_CONFIG_LOG_LEVEL OT_LOG_LEVEL_CRIT +#endif + +#define OPENTHREAD_CONFIG_PLATFORM_ASSERT_MANAGEMENT 1 +#define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_HOST_ADDRESSES 4 +#define OPENTHREAD_CONFIG_TCP_ENABLE 0 + +#include diff --git a/scripts/flashing/cyw30739_firmware_utils.py b/scripts/flashing/cyw30739_firmware_utils.py new file mode 100644 index 00000000000000..58913202ed53df --- /dev/null +++ b/scripts/flashing/cyw30739_firmware_utils.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +# Copyright (c) 2021 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Flash an CYW30739 device. + +This is layered so that a caller can perform individual operations +through an `Flasher` instance, or operations according to a command line. +For `Flasher`, see the class documentation. +""" + +import os +import sys + +import firmware_utils + +# Additional options that can be use to configure an `Flasher` +# object (as dictionary keys) and/or passed as command line options. +CYW30739_OPTIONS = { + # Configuration options define properties used in flashing operations. + "configuration": { + "direct": { + "help": "Set 1 to enable direct load", + "default": 0, + "argparse": {"action": "store"}, + }, + "sdk_scripts_dir": { + "help": "The SDK scripts directory", + "default": None, + "argparse": {"action": "store"}, + }, + "sdk_tools_dir": { + "help": "The SDK tools directory", + "default": None, + "argparse": {"action": "store"}, + }, + "program": { + "help": "The script to program the flash.", + "command": [ + "bash", + "--norc", + "--noprofile", + "{sdk_scripts_dir}/bt_program.bash", + "--tools={sdk_tools_dir}", + "--scripts={sdk_scripts_dir}", + "--elf={application}", + "--direct={direct}", + (), + ], + }, + "port": { + "help": "The serial port of device to flash", + "default": None, + "argparse": {}, + }, + }, +} + + +class Flasher(firmware_utils.Flasher): + """Manage CYW30739 flashing.""" + + def __init__(self, **options): + super().__init__(platform="CYW30739", module=__name__, **options) + self.define_options(CYW30739_OPTIONS) + + def erase(self): + """Not supported""" + self.log(0, "Do not support erasing device.") + self.err = 1 + return self + + def verify(self): + """Not supported""" + self.log(0, "Do not support verifying image.") + self.err = 1 + return self + + def flash(self): + """Flash image.""" + + arguments = [ + "--hex={}/{}_download.hex".format( + self.option.application.parent, self.option.application.stem + ), + ] + if self.option.port: + arguments.append("--uart={port}") + if self.option.verbose > 0: + arguments.append("--verbose") + + return self.run_tool("program", arguments, name="Flash") + + def reset(self): + """Not supported""" + self.log(0, "Do not support resetting device.") + self.err = 1 + return self + + def actions(self): + """Perform actions on the device according to self.option.""" + self.log(3, "Options:", self.option) + + if self.option.erase: + if self.erase().err: + return self + + if self.option.verify_application: + if self.verify().err: + return self + + if self.option.reset: + if self.reset().err: + return self + + if self.option.application: + if self.flash().err: + return self + + return self + + +if __name__ == "__main__": + sys.exit(Flasher().flash_command(sys.argv)) diff --git a/scripts/tools/memory/platform/cyw30739.cfg b/scripts/tools/memory/platform/cyw30739.cfg new file mode 100644 index 00000000000000..773593490e6a3c --- /dev/null +++ b/scripts/tools/memory/platform/cyw30739.cfg @@ -0,0 +1,41 @@ +# Copyright (c) 2021 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Memory tools default configuation for Silicon Labs EFR32. + +{ + 'section': { + # By default, only these sections will be included + # when operating by sections. + 'default': [ + '.app_xip_area', + '.text', + '.rodata', + '.data', + '.bss', + ] + }, + 'region': { + # Regions are sets of sections that can be used for aggregate reports. + 'sections': { + 'FLASH': [ + '.app_xip_area', + ], + 'RAM': [ + '.data', + '.bss', + ] + } + }, +} diff --git a/src/lib/shell/BUILD.gn b/src/lib/shell/BUILD.gn index 6f5ff3feaf2b84..0e4f7d74557057 100644 --- a/src/lib/shell/BUILD.gn +++ b/src/lib/shell/BUILD.gn @@ -58,6 +58,11 @@ static_library("shell") { "MainLoopDefault.cpp", "streamer_k32w.cpp", ] + } else if (chip_device_platform == "cyw30739") { + sources += [ + "MainLoopCYW30739.cpp", + "streamer_cyw30739.cpp", + ] } else if (current_os == "zephyr") { sources += [ "MainLoopZephyr.cpp", diff --git a/src/lib/shell/MainLoopCYW30739.cpp b/src/lib/shell/MainLoopCYW30739.cpp new file mode 100644 index 00000000000000..7f7044d342e6e9 --- /dev/null +++ b/src/lib/shell/MainLoopCYW30739.cpp @@ -0,0 +1,176 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "streamer.h" +#include +#include +#include + +#include +#include + +using chip::FormatCHIPError; +using chip::Platform::MemoryAlloc; +using chip::Platform::MemoryFree; +using chip::Shell::Engine; +using chip::Shell::streamer_get; + +namespace { + +bool IsSeparator(char ch) +{ + return (ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n'); +} + +bool IsEscape(char ch) +{ + return (ch == '\\'); +} + +bool IsEscapable(char ch) +{ + return IsSeparator(ch) || IsEscape(ch); +} + +int TokenizeLine(char * buffer, char ** tokens, int max_tokens) +{ + size_t len = strlen(buffer); + int cursor = 0; + size_t i = 0; + + // Strip leading spaces + while (buffer[i] && buffer[i] == ' ') + { + i++; + } + + if (len <= i) + { + return 0; + } + + // The first token starts at the beginning. + tokens[cursor++] = &buffer[i]; + + for (; i < len && cursor < max_tokens; i++) + { + if (IsEscape(buffer[i]) && IsEscapable(buffer[i + 1])) + { + // include the null terminator: strlen(cmd) = strlen(cmd + 1) + 1 + memmove(&buffer[i], &buffer[i + 1], strlen(&buffer[i])); + } + else if (IsSeparator(buffer[i])) + { + buffer[i] = 0; + if (!IsSeparator(buffer[i + 1])) + { + tokens[cursor++] = &buffer[i + 1]; + } + } + } + + tokens[cursor] = nullptr; + + return cursor; +} + +void ProcessShellLine(intptr_t args) +{ + int argc; + char * argv[CHIP_SHELL_MAX_TOKENS]; + + char * line = reinterpret_cast(args); + argc = TokenizeLine(line, argv, CHIP_SHELL_MAX_TOKENS); + + if (argc > 0) + { + CHIP_ERROR retval = Engine::Root().ExecCommand(argc, argv); + + if (retval != CHIP_NO_ERROR) + { + char errorStr[160]; + bool errorStrFound = FormatCHIPError(errorStr, sizeof(errorStr), retval); + if (!errorStrFound) + { + errorStr[0] = 0; + } + streamer_printf(streamer_get(), "Error %s: %s\r\n", argv[0], errorStr); + } + else + { + streamer_printf(streamer_get(), "Done\r\n"); + } + } + streamer_printf(streamer_get(), CHIP_SHELL_PROMPT); +} + +} // namespace + +namespace chip { +namespace Shell { + +static char sInputBuffer[CHIP_SHELL_MAX_LINE_SIZE]; +static uint16_t sInputLength; + +void ProcessInput(intptr_t args) +{ + char input[32]; + const ssize_t read_count = streamer_read(streamer_get(), input, sizeof(input)); + for (uint8_t i = 0; i < read_count; i++) + { + switch (input[i]) + { + case '\r': + case '\n': + streamer_printf(streamer_get(), "\r\n"); + sInputBuffer[sInputLength] = '\0'; + ProcessShellLine(reinterpret_cast(sInputBuffer)); + sInputLength = 0; + break; + + case '\b': + case 127: + if (sInputLength > 0) + { + streamer_printf(streamer_get(), "\b \b"); + sInputBuffer[--sInputLength] = '\0'; + } + break; + + default: + if (sInputLength < ArraySize(sInputBuffer) - 1) + { + sInputBuffer[sInputLength++] = input[i]; + } + if (isprint(static_cast(input[i])) || input[i] == '\t') + { + streamer_printf(streamer_get(), "%c", input[i]); + } + break; + } + } +} + +void Engine::RunMainLoop() +{ + sInputLength = 0; + + streamer_printf(streamer_get(), CHIP_SHELL_PROMPT); +} + +} // namespace Shell +} // namespace chip diff --git a/src/lib/shell/streamer_cyw30739.cpp b/src/lib/shell/streamer_cyw30739.cpp new file mode 100644 index 00000000000000..6c8e5aca412114 --- /dev/null +++ b/src/lib/shell/streamer_cyw30739.cpp @@ -0,0 +1,77 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +namespace chip { +namespace Shell { + +void ProcessInput(intptr_t args); + +static int streamer_cyw30739_init(streamer_t * streamer); +static ssize_t streamer_cyw30739_read(streamer_t * streamer, char * buf, size_t len); +static ssize_t streamer_cyw30739_write(streamer_t * streamer, const char * buf, size_t len); +static void streamer_cyw30739_uart_rx_handler(void * arg); + +static streamer_t streamer_stdio = { + .init_cb = streamer_cyw30739_init, + .read_cb = streamer_cyw30739_read, + .write_cb = streamer_cyw30739_write, +}; + +streamer_t * streamer_get() +{ + return &streamer_stdio; +} + +int streamer_cyw30739_init(streamer_t * streamer) +{ + wiced_platform_puart_init(streamer_cyw30739_uart_rx_handler); + return 0; +} + +ssize_t streamer_cyw30739_read(streamer_t * streamer, char * buf, size_t len) +{ + size_t count; + for (count = 0; count < len; count++) + { + if (!wiced_hal_puart_read(Uint8::from_char(buf) + count)) + break; + } + wiced_hal_puart_reset_puart_interrupt(); + return count; +} + +ssize_t streamer_cyw30739_write(streamer_t * streamer, const char * buf, size_t len) +{ + wiced_hal_puart_print(const_cast(buf)); + return 0; +} + +void streamer_cyw30739_uart_rx_handler(void * arg) +{ + DeviceLayer::PlatformMgr().LockChipStack(); + DeviceLayer::PlatformMgr().ScheduleWork(ProcessInput, 0); + DeviceLayer::PlatformMgr().UnlockChipStack(); +} + +} // namespace Shell +} // namespace chip diff --git a/src/lwip/BUILD.gn b/src/lwip/BUILD.gn index a038fe06875500..205f84b647bd5b 100644 --- a/src/lwip/BUILD.gn +++ b/src/lwip/BUILD.gn @@ -31,7 +31,8 @@ if (lwip_platform == "") { assert(lwip_platform == "external" || lwip_platform == "standalone" || lwip_platform == "cc13x2_26x2" || lwip_platform == "efr32" || lwip_platform == "k32w0" || lwip_platform == "qpg" || - lwip_platform == "mbed" || lwip_platform == "p6", + lwip_platform == "mbed" || lwip_platform == "p6" || + lwip_platform == "cyw30739", "Unsupported lwIP platform: ${lwip_platform}") if (lwip_platform != "external") { @@ -52,6 +53,8 @@ if (lwip_platform == "cc13x2_26x2") { import("//build_overrides/k32w0_sdk.gni") } else if (lwip_platform == "p6") { import("//build_overrides/p6.gni") +} else if (lwip_platform == "cyw30739") { + import("//build_overrides/cyw30739_sdk.gni") } buildconfig_header("lwip_buildconfig") { @@ -136,6 +139,7 @@ if (current_os == "zephyr" || current_os == "mbed") { if (lwip_platform == "standalone") { public += [ "standalone/arch/sys_arch.h" ] sources += [ "standalone/sys_arch.c" ] + } else if (lwip_platform == "cyw30739") { } else { public += [ "${lwip_platform}/lwippools.h", @@ -153,6 +157,8 @@ if (current_os == "zephyr" || current_os == "mbed") { public_deps += [ "${chip_root}/src/lib/support" ] } else if (lwip_platform == "k32w0") { public_deps += [ "${k32w0_sdk_build_root}:k32w0_sdk" ] + } else if (lwip_platform == "cyw30739") { + public_deps += [ "${cyw30739_sdk_build_root}:cyw30739_sdk" ] } public_configs = [ diff --git a/src/lwip/cyw30739/arch/cc.h b/src/lwip/cyw30739/arch/cc.h new file mode 100644 index 00000000000000..3a10bf171893ad --- /dev/null +++ b/src/lwip/cyw30739/arch/cc.h @@ -0,0 +1,23 @@ +/* + * + * Copyright (c) 2020 Nest Labs, Inc. + * All rights reserved. + * + * This document is the property of Nest. It is considered + * confidential and proprietary information. + * + * This document may not be reproduced or transmitted in any form, + * in whole or in part, without the express written permission of + * Nest. + * + * Description: + * This file defines processor-architecture- and toolchain- + * specific constants and types required for building + * LwIP against FreeRTOS. + * + */ +#pragma once + +#include + +#define LWIP_PLATFORM_ASSERT(MSG) assert(MSG) diff --git a/src/lwip/cyw30739/arch/perf.h b/src/lwip/cyw30739/arch/perf.h new file mode 100644 index 00000000000000..3799d0c5184706 --- /dev/null +++ b/src/lwip/cyw30739/arch/perf.h @@ -0,0 +1,20 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#pragma once diff --git a/src/lwip/cyw30739/lwipopts.h b/src/lwip/cyw30739/lwipopts.h new file mode 100644 index 00000000000000..40d3c1c6e1586a --- /dev/null +++ b/src/lwip/cyw30739/lwipopts.h @@ -0,0 +1,118 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Compile-time configuration for LwIP on CYW30739 platform. + */ +#pragma once + +/* Make the lwip/errno.h to include the errno.h from the toolchain. */ +#define LWIP_ERRNO_INCLUDE <../include/errno.h> + +#if CHIP_HAVE_CONFIG_H +#include +#endif + +/* NO SYS */ +#define NO_SYS 1 +#define LWIP_TIMERS 0 + +/* Core locking */ +#define SYS_LIGHTWEIGHT_PROT 0 +#define LOCK_TCPIP_CORE() +#define UNLOCK_TCPIP_CORE() + +/* Memory options */ +#define MEM_ALIGNMENT 4 + +/* Internal Memory Pool Sizes */ +#define MEMP_SEPARATE_POOLS 1 + +/* ARP options */ +#define LWIP_ARP 0 + +/* IP options */ +#define LWIP_IPV4 0 +#define IP_REASSEMBLY 0 +#define LWIP_RANDOMIZE_INITIAL_LOCAL_PORTS 1 + +/* ICMP options */ + +/* RAW options */ + +/* DHCP options */ + +/* AUTOIP options */ + +/* SNMP MIB2 support */ + +/* Multicast options */ + +/* IGMP options */ + +/* DNS options */ + +/* UDP options */ + +/* TCP options */ +#define LWIP_TCP 0 + +/* Pbuf options */ +#define PBUF_POOL_BUFSIZE 1356 + +/* Network Interfaces options */ +#define PBUF_POOL_SIZE 8 + +/* LOOPIF options */ + +/* Thread options */ + +/* Sequential layer options */ +#define LWIP_NETCONN 0 + +/* Socket options */ +#define LWIP_SOCKET 0 +#define LWIP_SOCKET_SET_ERRNO 0 + +/* Statistics options */ +#define LWIP_STATS 0 + +/* Checksum options */ + +/* IPv6 options */ +#define LWIP_IPV6 1 +#define LWIP_IPV6_REASS 0 +#define LWIP_IPV6_ND 0 +#define LWIP_ND6_TCP_REACHABILITY_HINTS 0 +#define LWIP_ND6_LISTEN_RA 0 +#define LWIP_IPV6_ROUTER_SUPPORT 0 + +/* Hook options */ + +/* Debugging options */ +#ifndef LWIP_DEBUG +#define LWIP_DEBUG 0 +#endif + +#define INET_DEBUG LWIP_DBG_OFF +#define MEMP_DEBUG LWIP_DBG_OFF +#define UDP_DEBUG LWIP_DBG_OFF +#define IP6_DEBUG LWIP_DBG_OFF + +/* Performance tracking options */ diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn index 741134a0c931fc..5709d0544f4b78 100644 --- a/src/platform/BUILD.gn +++ b/src/platform/BUILD.gn @@ -217,6 +217,11 @@ if (chip_device_platform != "none") { "CHIP_DEVICE_LAYER_TARGET=Ameba", "CHIP_DEVICE_CONFIG_ENABLE_WIFI=${chip_enable_wifi}", ] + } else if (chip_device_platform == "cyw30739") { + defines += [ + "CHIP_DEVICE_LAYER_TARGET_CYW30739=1", + "CHIP_DEVICE_LAYER_TARGET=CYW30739", + ] } } } else { @@ -345,6 +350,8 @@ if (chip_device_platform != "none") { _platform_target = "Ameba" } else if (chip_device_platform == "fake") { _platform_target = "fake" + } else if (chip_device_platform == "cyw30739") { + _platform_target = "CYW30739" } else { assert(false, "Unknown chip_device_platform: ${chip_device_platform}") } diff --git a/src/platform/CYW30739/BLEManagerImpl.cpp b/src/platform/CYW30739/BLEManagerImpl.cpp new file mode 100644 index 00000000000000..f2c863585cd1ce --- /dev/null +++ b/src/platform/CYW30739/BLEManagerImpl.cpp @@ -0,0 +1,917 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Nest Labs, Inc. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the BLEManager singleton object + * for the P64343W platform. + */ + +/* this file behaves like a config.h, comes first */ +#include + +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE + +#include +#include +#include +#include + +#include "cycfg_gatt_db.h" +#include "wiced_bt_stack.h" +#include +#include +#ifdef BLE_OTA_FW_UPGRADE +#include +#endif +#include "wiced_platform_bt_cfg.h" + +using namespace ::chip; +using namespace ::chip::Ble; + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +namespace { + +const ChipBleUUID chipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, + 0x9D, 0x11 } }; + +const ChipBleUUID ChipUUID_CHIPoBLEChar_TX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, + 0x9D, 0x12 } }; + +} // unnamed namespace + +BLEManagerImpl BLEManagerImpl::sInstance; + +wiced_bt_gatt_status_t app_gatts_callback(wiced_bt_gatt_evt_t event, wiced_bt_gatt_event_data_t * p_data); + +CHIP_ERROR BLEManagerImpl::_Init() +{ + CHIP_ERROR err; + + // Initialize the CHIP BleLayer. + err = BleLayer::Init(this, this, &DeviceLayer::SystemLayer()); + SuccessOrExit(err); + + mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Enabled; + if (CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART) + { + mFlags.Set(Flags::kFlag_AdvertisingEnabled, true); + } + else + { + mFlags.Set(Flags::kFlag_AdvertisingEnabled, false); + } + mNumCons = 0; + memset(mCons, 0, sizeof(mCons)); + memset(mDeviceName, 0, sizeof(mDeviceName)); + + // Register with stack to receive GATT callback + wiced_bt_gatt_register(app_gatts_callback); + + // Inform the stack to use this app GATT database + wiced_bt_gatt_db_init(gatt_database, gatt_database_len); + + ChipLogProgress(DeviceLayer, "BLEManagerImpl::Init() complete"); + + PlatformMgr().ScheduleWork(DriveBLEState, 0); + +exit: + return err; +} + +CHIP_ERROR BLEManagerImpl::_SetCHIPoBLEServiceMode(CHIPoBLEServiceMode val) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + VerifyOrExit(val != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_INVALID_ARGUMENT); + VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE); + + if (val != mServiceMode) + { + mServiceMode = val; + PlatformMgr().ScheduleWork(DriveBLEState, 0); + } + +exit: + return err; +} + +bool BLEManagerImpl::_IsAdvertisingEnabled(void) +{ + return mFlags.Has(Flags::kFlag_AdvertisingEnabled); +} + +CHIP_ERROR BLEManagerImpl::_SetAdvertisingEnabled(bool val) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE); + + if (mFlags.Has(Flags::kFlag_AdvertisingEnabled) != val) + { + mFlags.Set(Flags::kFlag_AdvertisingEnabled, val); + PlatformMgr().ScheduleWork(DriveBLEState, 0); + } + +exit: + return err; +} + +/* + * TODO + */ +CHIP_ERROR BLEManagerImpl::_SetAdvertisingMode(BLEAdvertisingMode mode) +{ + (void) (mode); + + return CHIP_ERROR_NOT_IMPLEMENTED; +} + +#if 0 +CHIP_ERROR BLEManagerImpl::_SetFastAdvertisingEnabled(bool val) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + VerifyOrExit(mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE); + + if (GetFlag(mFlags, kFlag_FastAdvertisingEnabled) != val) + { + SetFlag(mFlags, kFlag_FastAdvertisingEnabled, val); + PlatformMgr().ScheduleWork(DriveBLEState, 0); + } + +exit: + return err; +} +#endif + +CHIP_ERROR BLEManagerImpl::_GetDeviceName(char * buf, size_t bufSize) +{ + if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_NotSupported) + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } + if (strlen(mDeviceName) >= bufSize) + { + return CHIP_ERROR_BUFFER_TOO_SMALL; + } + strcpy(buf, mDeviceName); + ChipLogProgress(DeviceLayer, "Getting device name to : \"%s\"", mDeviceName); + return CHIP_NO_ERROR; +} + +CHIP_ERROR BLEManagerImpl::_SetDeviceName(const char * deviceName) +{ + if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_NotSupported) + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } + if (deviceName != NULL && deviceName[0] != 0) + { + if (strlen(deviceName) >= kMaxDeviceNameLength) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + memset(mDeviceName, 0, kMaxDeviceNameLength); + strncpy(mDeviceName, deviceName, strlen(deviceName)); + mFlags.Set(Flags::kFlag_DeviceNameSet, true); + ChipLogProgress(DeviceLayer, "Setting device name to : \"%s\"", deviceName); + } + else + { + wiced_platform_bt_cfg_settings.device_name[0] = 0; + mDeviceName[0] = 0; + mFlags.Set(Flags::kFlag_DeviceNameSet, false); + } + + return CHIP_NO_ERROR; +} + +uint16_t BLEManagerImpl::_NumConnections(void) +{ + return mNumCons; +} + +void BLEManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) +{ + switch (event->Type) + { + case DeviceEventType::kCHIPoBLESubscribe: + HandleSubscribeReceived(event->CHIPoBLESubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX); + { + ChipDeviceEvent _event; + _event.Type = DeviceEventType::kCHIPoBLEConnectionEstablished; + PlatformMgr().PostEventOrDie(&_event); + } + break; + + case DeviceEventType::kCHIPoBLEUnsubscribe: + HandleUnsubscribeReceived(event->CHIPoBLEUnsubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX); + break; + + case DeviceEventType::kCHIPoBLEWriteReceived: + ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEWriteReceived"); + HandleWriteReceived(event->CHIPoBLEWriteReceived.ConId, &CHIP_BLE_SVC_ID, &chipUUID_CHIPoBLEChar_RX, + PacketBufferHandle::Adopt(event->CHIPoBLEWriteReceived.Data)); + break; + + case DeviceEventType::kCHIPoBLEIndicateConfirm: + HandleIndicationConfirmation(event->CHIPoBLEIndicateConfirm.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX); + break; + + case DeviceEventType::kCHIPoBLEConnectionError: + HandleConnectionError(event->CHIPoBLEConnectionError.ConId, event->CHIPoBLEConnectionError.Reason); + break; + + case DeviceEventType::kFabricMembershipChange: + case DeviceEventType::kServiceProvisioningChange: + case DeviceEventType::kAccountPairingChange: + + // If CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED is enabled, and there is a change to the + // device's provisioning state, then automatically disable CHIPoBLE advertising if the device + // is now fully provisioned. +#if CHIP_DEVICE_CONFIG_CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED + if (ConfigurationMgr().IsFullyProvisioned()) + { + ClearFlag(mFlags, kFlag_AdvertisingEnabled); + ChipLogProgress(DeviceLayer, "CHIPoBLE advertising disabled because device is fully provisioned"); + } +#endif // CHIP_DEVICE_CONFIG_CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED + + // Force the advertising state to be refreshed to reflect new provisioning state. + mFlags.Set(Flags::kFlag_AdvertisingRefreshNeeded, true); + + DriveBLEState(); + break; + + default: + break; + } +} + +bool BLEManagerImpl::SubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId) +{ + ChipLogProgress(DeviceLayer, "BLEManagerImpl::SubscribeCharacteristic() not supported"); + return false; +} + +bool BLEManagerImpl::UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId) +{ + ChipLogProgress(DeviceLayer, "BLEManagerImpl::UnsubscribeCharacteristic() not supported"); + return false; +} + +bool BLEManagerImpl::CloseConnection(BLE_CONNECTION_OBJECT conId) +{ + ChipLogProgress(DeviceLayer, "Closing BLE GATT connection (con %u)", conId); + + // Initiate a GAP disconnect. + wiced_bt_gatt_status_t gatt_err = wiced_bt_gatt_disconnect((uint16_t) conId); + if (gatt_err != WICED_BT_GATT_SUCCESS) + { + ChipLogError(DeviceLayer, "wiced_bt_gatt_disconnect() failed: %d", gatt_err); + } + + return (gatt_err == WICED_BT_GATT_SUCCESS); +} + +uint16_t BLEManagerImpl::GetMTU(BLE_CONNECTION_OBJECT conId) const +{ + CHIPoBLEConState * p_conn; + + /* Check if target connection state exists. */ + p_conn = BLEManagerImpl::sInstance.GetConnectionState(conId); + + if (!p_conn) + { + return wiced_platform_bt_cfg_settings.gatt_cfg.max_mtu_size; + } + else + { + return p_conn->Mtu; + } +} + +bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId, + PacketBufferHandle data) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + uint16_t dataLen = data->DataLength(); + wiced_bt_gatt_status_t gatt_err = WICED_BT_GATT_SUCCESS; + CHIPoBLEConState * conState = GetConnectionState(conId); + + VerifyOrExit(conState != NULL, err = CHIP_ERROR_INVALID_ARGUMENT); + + ChipLogDetail(DeviceLayer, "Sending indication for CHIPoBLE TX characteristic (con %u, len %u)", conId, dataLen); + + // Send a indication for the CHIPoBLE TX characteristic to the client containing the supplied data. + gatt_err = wiced_bt_gatt_send_indication((uint16_t) conId, HDLC_CHIP_SERVICE_CHAR_C2_VALUE, dataLen, data->Start()); + +exit: + if (gatt_err != WICED_BT_GATT_SUCCESS) + { + ChipLogError(DeviceLayer, "BLEManagerImpl::SendIndication() failed: %d", gatt_err); + return false; + } + return err == CHIP_NO_ERROR; +} + +bool BLEManagerImpl::SendWriteRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId, + PacketBufferHandle data) + +{ + ChipLogError(DeviceLayer, "BLEManagerImpl::SendWriteRequest() not supported"); + return false; +} + +bool BLEManagerImpl::SendReadRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId, + PacketBufferHandle data) +{ + ChipLogError(DeviceLayer, "BLEManagerImpl::SendReadRequest() not supported"); + return false; +} + +bool BLEManagerImpl::SendReadResponse(BLE_CONNECTION_OBJECT conId, BLE_READ_REQUEST_CONTEXT requestContext, + const ChipBleUUID * svcId, const ChipBleUUID * charId) +{ + ChipLogError(DeviceLayer, "BLEManagerImpl::SendReadResponse() not supported"); + return false; +} + +void BLEManagerImpl::NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId) {} + +void BLEManagerImpl::DriveBLEState(void) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + // Perform any initialization actions that must occur after the CHIP task is running. + if (!mFlags.Has(Flags::kFlag_AsyncInitCompleted)) + { + mFlags.Set(Flags::kFlag_AsyncInitCompleted, true); + + // If CHIP_DEVICE_CONFIG_CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED is enabled, + // disable CHIPoBLE advertising if the device is fully provisioned. +#if CHIP_DEVICE_CONFIG_CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED + if (ConfigurationMgr().IsFullyProvisioned()) + { + ClearFlag(mFlags, kFlag_AdvertisingEnabled); + ChipLogProgress(DeviceLayer, "CHIPoBLE advertising disabled because device is fully provisioned"); + } +#endif // CHIP_DEVICE_CONFIG_CHIPOBLE_DISABLE_ADVERTISING_WHEN_PROVISIONED + } + + // If the application has enabled CHIPoBLE and BLE advertising... + if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled && + mFlags.Has(Flags::kFlag_AdvertisingEnabled) +#if CHIP_DEVICE_CONFIG_CHIPOBLE_SINGLE_CONNECTION + // and no connections are active... + && (mNumCons == 0) +#endif + ) + { + // Start/re-start SoftDevice advertising if not already advertising, or if the + // advertising state of the SoftDevice needs to be refreshed. + if (!mFlags.Has(Flags::kFlag_Advertising) || mFlags.Has(Flags::kFlag_AdvertisingRefreshNeeded)) + { + ChipLogProgress(DeviceLayer, "CHIPoBLE advertising started"); + + mFlags.Set(Flags::kFlag_Advertising, true); + mFlags.Set(Flags::kFlag_AdvertisingRefreshNeeded, false); + + SetAdvertisingData(); + + wiced_bt_start_advertisements(BTM_BLE_ADVERT_UNDIRECTED_HIGH, BLE_ADDR_PUBLIC, NULL); + + // Post a CHIPoBLEAdvertisingChange(Started) event. + { + ChipDeviceEvent advChange; + advChange.Type = DeviceEventType::kCHIPoBLEAdvertisingChange; + advChange.CHIPoBLEAdvertisingChange.Result = kActivity_Started; + PlatformMgr().PostEventOrDie(&advChange); + } + } + } + + // Otherwise, stop advertising if currently active. + else + { + if (mFlags.Has(Flags::kFlag_Advertising)) + { + mFlags.Set(Flags::kFlag_Advertising, false); + + ChipLogProgress(DeviceLayer, "CHIPoBLE stop advertising"); + wiced_bt_start_advertisements(BTM_BLE_ADVERT_OFF, BLE_ADDR_PUBLIC, NULL); + } + } + + // exit: + if (err != CHIP_NO_ERROR) + { + ChipLogError(DeviceLayer, "Disabling CHIPoBLE service due to error: %s", ErrorStr(err)); + mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Disabled; + } +} + +/* + * This function searches through the GATT DB to point to the attribute + * corresponding to the given handle + */ +gatt_db_lookup_table_t * BLEManagerImpl::GetGattAttr(uint16_t handle) +{ + /* Search for the given handle in the GATT DB and return the pointer to the + correct attribute */ + uint8_t array_index = 0; + + for (array_index = 0; array_index < app_gatt_db_ext_attr_tbl_size; array_index++) + { + if (app_gatt_db_ext_attr_tbl[array_index].handle == handle) + { + return (&app_gatt_db_ext_attr_tbl[array_index]); + } + } + return NULL; +} + +/* + * Currently there is no reason to pass Read Req to CHIP. Only process request for + * attributes in the GATT DB attribute table + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattServiceRead(uint16_t conn_id, wiced_bt_gatt_read_t * p_read_data) +{ + gatt_db_lookup_table_t * puAttribute; + int attr_len_to_copy; + +#ifdef BLE_OTA_FW_UPGRADE + if (wiced_ota_fw_upgrade_is_gatt_handle(p_read_data->handle)) + { + return wiced_ota_fw_upgrade_read_handler(conn_id, p_read_data); + } +#endif + + /* Get the right address for the handle in Gatt DB */ + if (NULL == (puAttribute = GetGattAttr(p_read_data->handle))) + { + ChipLogError(DeviceLayer, "Read handle attribute not found. Handle:0x%X\n", p_read_data->handle); + return WICED_BT_GATT_INVALID_HANDLE; + } + + attr_len_to_copy = puAttribute->cur_len; + + ChipLogProgress(DeviceLayer, "GATT Read handler: conn_id:%04x handle:%04x len:%d", conn_id, p_read_data->handle, + attr_len_to_copy); + + /* If the incoming offset is greater than the current length in the GATT DB + then the data cannot be read back*/ + if (p_read_data->offset >= puAttribute->cur_len) + { + attr_len_to_copy = 0; + } + + /* Calculate the number of bytes and the position of the data and copy it to + the given pointer */ + if (attr_len_to_copy != 0) + { + uint8_t * from; + int size_to_copy = attr_len_to_copy - p_read_data->offset; + + if (size_to_copy > *p_read_data->p_val_len) + { + size_to_copy = *p_read_data->p_val_len; + } + + from = ((uint8_t *) puAttribute->p_data) + p_read_data->offset; + *p_read_data->p_val_len = size_to_copy; + + memcpy(p_read_data->p_val, from, size_to_copy); + } + return WICED_BT_GATT_SUCCESS; +} + +/* + * If Attribute is for CHIP, pass it through. Otherwise process request for + * attributes in the GATT DB attribute table. + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattServiceWrite(uint16_t conn_id, wiced_bt_gatt_write_t * p_data) +{ + wiced_bt_gatt_status_t result = WICED_BT_GATT_SUCCESS; + gatt_db_lookup_table_t * puAttribute; + const uint16_t valLen = p_data->val_len; + +#ifdef BLE_OTA_FW_UPGRADE + if (wiced_ota_fw_upgrade_is_gatt_handle(p_data->handle)) + { + return wiced_ota_fw_upgrade_write_handler(conn_id, p_data); + } +#endif + + // special handling for CHIP RX path + if (p_data->handle == HDLC_CHIP_SERVICE_CHAR_C1_VALUE) + { + System::PacketBufferHandle buf; + + buf = System::PacketBufferHandle::NewWithData(p_data->p_val, valLen, 0, 0); + if (!buf.IsNull()) + { + + ChipLogDetail(DeviceLayer, "Write received for CHIPoBLE RX characteristic con %04x len %d", conn_id, valLen); + + // Post an event to the CHIP queue to deliver the data into the CHIP stack. + { + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoBLEWriteReceived; + event.CHIPoBLEWriteReceived.ConId = conn_id; + event.CHIPoBLEWriteReceived.Data = std::move(buf).UnsafeRelease(); + PlatformMgr().PostEventOrDie(&event); + } + } + else + { + ChipLogError(DeviceLayer, "BLEManagerImpl: Out of buffers during CHIPoBLE RX"); + } + } + else + { + ChipLogDetail(DeviceLayer, "Write received for CHIPoBLE RX characteristic con:%04x handle:%04x len:%d", conn_id, + p_data->handle, valLen); + + /* Get the right address for the handle in Gatt DB */ + if (NULL == (puAttribute = GetGattAttr(p_data->handle))) + { + ChipLogError(DeviceLayer, "BLEManagerImpl: Write wrong handle:%04x", p_data->handle); + return WICED_BT_GATT_INVALID_HANDLE; + } + puAttribute->cur_len = valLen > puAttribute->max_len ? puAttribute->max_len : valLen; + memcpy(puAttribute->p_data, p_data->p_val, puAttribute->cur_len); + + // Post an event to the Chip queue to process either a CHIPoBLE Subscribe or Unsubscribe based on + // whether the client is enabling or disabling indications. + if (p_data->handle == HDLD_CHIP_SERVICE_RX_CLIENT_CHAR_CONFIG) + { + ChipDeviceEvent event; + event.Type = (app_chip_service_char_tx_client_char_config[0] != 0) ? DeviceEventType::kCHIPoBLESubscribe + : DeviceEventType::kCHIPoBLEUnsubscribe; + event.CHIPoBLESubscribe.ConId = conn_id; + PlatformMgr().PostEventOrDie(&event); + } + + ChipLogProgress(DeviceLayer, "CHIPoBLE %s received", + app_chip_service_char_tx_client_char_config[0] != 0 ? "subscribe" : "unsubscribe"); + } + return result; +} + +/* + * Process MTU request received from the GATT client + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattServiceMtuReq(wiced_bt_gatt_attribute_request_t * p_data, + CHIPoBLEConState * p_conn) +{ + p_data->data.mtu = p_conn->Mtu; + + return WICED_BT_GATT_SUCCESS; +} + +/* + * Process GATT Indication Confirm from the client + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattServiceIndCfm(uint16_t conn_id, uint16_t handle) +{ + ChipLogDetail(DeviceLayer, "GATT Ind Cfm received con:%04x handle:%d", conn_id, handle); + + if (handle == HDLC_CHIP_SERVICE_CHAR_C2_VALUE) + { + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoBLEIndicateConfirm; + event.CHIPoBLEIndicateConfirm.ConId = conn_id; + PlatformMgr().PostEventOrDie(&event); + } +#ifdef BLE_OTA_FW_UPGRADE + else if (wiced_ota_fw_upgrade_is_gatt_handle(handle)) + { + return wiced_ota_fw_upgrade_indication_cfm_handler(conn_id, handle); + } +#endif + return WICED_BT_GATT_SUCCESS; +} + +/* + * Process GATT attribute requests + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattServiceRequestEvent(wiced_bt_gatt_attribute_request_t * p_request, + CHIPoBLEConState * p_conn) +{ + wiced_bt_gatt_status_t result = WICED_BT_GATT_INVALID_PDU; + + switch (p_request->request_type) + { + case GATTS_REQ_TYPE_READ: + result = HandleGattServiceRead(p_request->conn_id, &(p_request->data.read_req)); + break; + + case GATTS_REQ_TYPE_WRITE: + result = HandleGattServiceWrite(p_request->conn_id, &(p_request->data.write_req)); + break; + + case GATTS_REQ_TYPE_MTU: + result = HandleGattServiceMtuReq(p_request, p_conn); + break; + + case GATTS_REQ_TYPE_CONF: + result = HandleGattServiceIndCfm(p_request->conn_id, p_request->data.handle); + break; + + default: + break; + } + + return result; +} + +/* + * Handle GATT connection events from the stack + */ +wiced_bt_gatt_status_t BLEManagerImpl::HandleGattConnectEvent(wiced_bt_gatt_connection_status_t * p_conn_status, + CHIPoBLEConState * p_conn) +{ +#ifdef BLE_OTA_FW_UPGRADE + wiced_ota_fw_upgrade_connection_status_event(p_conn_status); +#endif + + if (p_conn_status->connected) + { + /* Device got connected */ + p_conn->connected = true; + ChipLogProgress(DeviceLayer, "BLE GATT connection up (con %u)", p_conn_status->conn_id); + } + else /* Device got disconnected */ + { + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoBLEConnectionError; + event.CHIPoBLEConnectionError.ConId = p_conn_status->conn_id; + + switch (p_conn_status->reason) + { + case GATT_CONN_TERMINATE_PEER_USER: + event.CHIPoBLEConnectionError.Reason = BLE_ERROR_REMOTE_DEVICE_DISCONNECTED; + break; + + case GATT_CONN_TERMINATE_LOCAL_HOST: + event.CHIPoBLEConnectionError.Reason = BLE_ERROR_APP_CLOSED_CONNECTION; + break; + + default: + event.CHIPoBLEConnectionError.Reason = BLE_ERROR_CHIPOBLE_PROTOCOL_ABORT; + break; + } + + ChipLogProgress(DeviceLayer, "BLE GATT connection closed (con %u, reason %u)", p_conn_status->conn_id, + p_conn_status->reason); + + PlatformMgr().PostEventOrDie(&event); + + // Arrange to re-enable connectable advertising in case it was disabled due to the + // maximum connection limit being reached. + mFlags.Set(Flags::kFlag_Advertising, false); + PlatformMgr().ScheduleWork(DriveBLEState, 0); + + ReleaseConnectionState(p_conn->ConId); + } + return WICED_BT_GATT_SUCCESS; +} + +/* + * Process GATT requests. Callback is received in the BT stack thread context. + * + */ +wiced_bt_gatt_status_t app_gatts_callback(wiced_bt_gatt_evt_t event, wiced_bt_gatt_event_data_t * p_data) +{ + uint16_t conn_id; + BLEManagerImpl::CHIPoBLEConState * p_conn; + + /* Check parameter. */ + if (!p_data) + { + return WICED_BT_GATT_ILLEGAL_PARAMETER; + } + + /* Check if target connection state exists. */ + switch (event) + { + case GATT_CONNECTION_STATUS_EVT: + conn_id = p_data->connection_status.conn_id; + break; + + case GATT_OPERATION_CPLT_EVT: + conn_id = p_data->operation_complete.conn_id; + break; + + case GATT_DISCOVERY_RESULT_EVT: + conn_id = p_data->discovery_result.conn_id; + break; + + case GATT_DISCOVERY_CPLT_EVT: + conn_id = p_data->discovery_complete.conn_id; + break; + + case GATT_ATTRIBUTE_REQUEST_EVT: + conn_id = p_data->attribute_request.conn_id; + break; + + case GATT_CONGESTION_EVT: + conn_id = p_data->congestion.conn_id; + break; + + default: + return WICED_BT_GATT_ILLEGAL_PARAMETER; + } + + p_conn = BLEManagerImpl::sInstance.GetConnectionState(conn_id); + + /* Allocate connection state if no exist. */ + if (!p_conn) + { + p_conn = BLEManagerImpl::sInstance.AllocConnectionState(conn_id); + + if (!p_conn) + { + return WICED_BT_GATT_INSUF_RESOURCE; + } + } + + switch (event) + { + case GATT_CONNECTION_STATUS_EVT: + return BLEManagerImpl::sInstance.HandleGattConnectEvent(&p_data->connection_status, p_conn); + + case GATT_ATTRIBUTE_REQUEST_EVT: + return BLEManagerImpl::sInstance.HandleGattServiceRequestEvent(&p_data->attribute_request, p_conn); + + default: + break; + } + + return WICED_BT_GATT_ILLEGAL_PARAMETER; +} + +void BLEManagerImpl::SetAdvertisingData(void) +{ + CHIP_ERROR err; + wiced_bt_ble_advert_elem_t adv_elem[4]; + uint8_t num_elem = 0; + uint8_t flag = BTM_BLE_GENERAL_DISCOVERABLE_FLAG | BTM_BLE_BREDR_NOT_SUPPORTED; + uint8_t chip_service_uuid[2] = { BIT16_TO_8(__UUID16_CHIPoBLEService) }; + ChipBLEDeviceIdentificationInfo mDeviceIdInfo; + uint16_t deviceDiscriminator = 0; + uint8_t localDeviceNameLen; + uint8_t service_data[9]; + uint8_t * p = service_data; + uint8_t * rpa = wiced_btm_get_private_bda(); + + // Initialize the CHIP BLE Device Identification Information block that will be sent as payload + // within the BLE service advertisement data. + err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(mDeviceIdInfo); + SuccessOrExit(err); + + // Verify device name was not already set + if (!sInstance.mFlags.Has(Flags::kFlag_DeviceNameSet)) + { + /* Default device name is CHIP- */ + deviceDiscriminator = mDeviceIdInfo.GetDeviceDiscriminator(); + + memset(sInstance.mDeviceName, 0, kMaxDeviceNameLength); + snprintf(sInstance.mDeviceName, kMaxDeviceNameLength, "%s%04u", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, + deviceDiscriminator); + localDeviceNameLen = strlen(sInstance.mDeviceName); + + memset((void *) app_gap_device_name, 0, sizeof(app_gap_device_name)); + strncpy((char *) app_gap_device_name, sInstance.mDeviceName, sizeof(app_gap_device_name) - 1); + app_gatt_db_ext_attr_tbl[0].cur_len = app_gatt_db_ext_attr_tbl[0].max_len < strlen(sInstance.mDeviceName) + ? app_gatt_db_ext_attr_tbl[0].max_len + : strlen(sInstance.mDeviceName); + + ChipLogProgress(DeviceLayer, "SetAdvertisingData: device name set: %s", sInstance.mDeviceName); + } + else + { + localDeviceNameLen = strlen(sInstance.mDeviceName); + } + + ChipLogProgress(DeviceLayer, "SetAdvertisingData: RPA: %02X%02X%02X%02X%02X%02X", rpa[0], rpa[1], rpa[2], rpa[3], rpa[4], + rpa[5]); + + /* First element is the advertisment flags */ + adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_FLAG; + adv_elem[num_elem].len = sizeof(uint8_t); + adv_elem[num_elem].p_data = &flag; + num_elem++; + + /* Second element is the service data for CHIP service */ + adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_SERVICE_DATA; + adv_elem[num_elem].len = sizeof(service_data); + adv_elem[num_elem].p_data = service_data; + num_elem++; + UINT8_TO_STREAM(p, chip_service_uuid[0]); + UINT8_TO_STREAM(p, chip_service_uuid[1]); + UINT8_TO_STREAM(p, 0); // CHIP BLE Opcode == 0x00 (Uncommissioned) + UINT16_TO_STREAM(p, deviceDiscriminator); + UINT8_TO_STREAM(p, mDeviceIdInfo.DeviceVendorId[0]); + UINT8_TO_STREAM(p, mDeviceIdInfo.DeviceVendorId[1]); + UINT8_TO_STREAM(p, mDeviceIdInfo.DeviceProductId[0]); + UINT8_TO_STREAM(p, mDeviceIdInfo.DeviceProductId[1]); + + adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_NAME_COMPLETE; + adv_elem[num_elem].len = localDeviceNameLen; + adv_elem[num_elem].p_data = (uint8_t *) sInstance.mDeviceName; + num_elem++; + + wiced_bt_ble_set_raw_advertisement_data(num_elem, adv_elem); + + /* Configure Scan Response data */ + num_elem = 0; + adv_elem[num_elem].advert_type = BTM_BLE_ADVERT_TYPE_NAME_COMPLETE; + adv_elem[num_elem].len = localDeviceNameLen; + adv_elem[num_elem].p_data = (uint8_t *) sInstance.mDeviceName; + num_elem++; + + wiced_bt_ble_set_raw_scan_response_data(num_elem, adv_elem); + +exit: + ChipLogProgress(DeviceLayer, "BLEManagerImpl::SetAdvertisingData err:%ld", err.AsInteger()); +} + +BLEManagerImpl::CHIPoBLEConState * BLEManagerImpl::AllocConnectionState(uint16_t conId) +{ + for (uint16_t i = 0; i < kMaxConnections; i++) + { + if (mCons[i].connected == false) + { + mCons[i].ConId = conId; + mCons[i].Mtu = wiced_platform_bt_cfg_settings.gatt_cfg.max_mtu_size; + mCons[i].connected = false; + + mNumCons++; + + return &mCons[i]; + } + } + ChipLogError(DeviceLayer, "Failed to allocate CHIPoBLEConState"); + return NULL; +} + +BLEManagerImpl::CHIPoBLEConState * BLEManagerImpl::GetConnectionState(uint16_t conId) +{ + for (uint16_t i = 0; i < kMaxConnections; i++) + { + if (mCons[i].ConId == conId) + { + return &mCons[i]; + } + } + ChipLogError(DeviceLayer, "Failed to find CHIPoBLEConState"); + return NULL; +} + +bool BLEManagerImpl::ReleaseConnectionState(uint16_t conId) +{ + for (uint16_t i = 0; i < kMaxConnections; i++) + { + if (mCons[i].ConId == conId) + { + memset(&mCons[i], 0, sizeof(CHIPoBLEConState)); + mNumCons--; + return true; + } + } + ChipLogError(DeviceLayer, "Failed to delete CHIPoBLEConState"); + return false; +} + +void BLEManagerImpl::DriveBLEState(intptr_t arg) +{ + sInstance.DriveBLEState(); +} + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip + +#endif diff --git a/src/platform/CYW30739/BLEManagerImpl.h b/src/platform/CYW30739/BLEManagerImpl.h new file mode 100644 index 00000000000000..9aedc3abc5ceb6 --- /dev/null +++ b/src/platform/CYW30739/BLEManagerImpl.h @@ -0,0 +1,180 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2018 Nest Labs, Inc. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the BLEManager singleton object + * for the P64343W platform. + */ + +#pragma once + +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE + +#include "cycfg_gatt_db.h" +#include +#include +#include + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +/** + * Concrete implementation of the NetworkProvisioningServer singleton object for the P64343W platform. + */ +class BLEManagerImpl final : public BLEManager, + private Ble::BleLayer, + private Ble::BlePlatformDelegate, + private Ble::BleApplicationDelegate +{ + // Allow the BLEManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend BLEManager; + + // ===== Members that implement the BLEManager internal interface. + + CHIP_ERROR _Init(void); + CHIP_ERROR _Shutdown() { return CHIP_NO_ERROR; } + CHIPoBLEServiceMode _GetCHIPoBLEServiceMode(void); + CHIP_ERROR _SetCHIPoBLEServiceMode(CHIPoBLEServiceMode val); + bool _IsAdvertisingEnabled(void); + CHIP_ERROR _SetAdvertisingEnabled(bool val); + bool _IsFastAdvertisingEnabled(void); +#if 0 + CHIP_ERROR _SetFastAdvertisingEnabled(bool val); +#endif + bool _IsAdvertising(void); + CHIP_ERROR _SetAdvertisingMode(BLEAdvertisingMode mode); + CHIP_ERROR _GetDeviceName(char * buf, size_t bufSize); + CHIP_ERROR _SetDeviceName(const char * deviceName); + uint16_t _NumConnections(void); + void _OnPlatformEvent(const ChipDeviceEvent * event); + ::chip::Ble::BleLayer * _GetBleLayer(void); + + // ===== Members that implement virtual methods on BlePlatformDelegate. + + bool SubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const Ble::ChipBleUUID * svcId, + const Ble::ChipBleUUID * charId) override; + bool UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const Ble::ChipBleUUID * svcId, + const Ble::ChipBleUUID * charId) override; + bool CloseConnection(BLE_CONNECTION_OBJECT conId) override; + uint16_t GetMTU(BLE_CONNECTION_OBJECT conId) const override; + bool SendIndication(BLE_CONNECTION_OBJECT conId, const Ble::ChipBleUUID * svcId, const Ble::ChipBleUUID * charId, + System::PacketBufferHandle data) override; + bool SendWriteRequest(BLE_CONNECTION_OBJECT conId, const Ble::ChipBleUUID * svcId, const Ble::ChipBleUUID * charId, + System::PacketBufferHandle data) override; + bool SendReadRequest(BLE_CONNECTION_OBJECT conId, const Ble::ChipBleUUID * svcId, const Ble::ChipBleUUID * charId, + System::PacketBufferHandle data) override; + bool SendReadResponse(BLE_CONNECTION_OBJECT conId, BLE_READ_REQUEST_CONTEXT requestContext, const Ble::ChipBleUUID * svcId, + const Ble::ChipBleUUID * charId) override; + + // ===== Members that implement virtual methods on BleApplicationDelegate. + + void NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId) override; + + // ===== Members for internal use by the following friends. + + friend BLEManager & BLEMgr(void); + friend BLEManagerImpl & BLEMgrImpl(void); + +public: + static BLEManagerImpl sInstance; + + // ===== Private members reserved for use by this class only. + enum class Flags : uint16_t + { + kFlag_AsyncInitCompleted = 0x0001, /**< One-time asynchronous initialization actions have been performed. */ + kFlag_AdvertisingEnabled = 0x0002, /**< The application has enabled CHIPoBLE advertising. */ + kFlag_FastAdvertisingEnabled = 0x0004, /**< The application has enabled fast advertising. */ + kFlag_Advertising = 0x0008, /**< The system is currently CHIPoBLE advertising. */ + kFlag_AdvertisingRefreshNeeded = + 0x0010, /**< The advertising state/configuration has changed, but the SoftDevice has yet to be updated. */ + kFlag_DeviceNameSet = 0x0020, + }; + + enum + { + kMaxConnections = BLE_LAYER_NUM_BLE_ENDPOINTS, + }; + + struct CHIPoBLEConState + { + // System::PacketBuffer * PendingIndBuf; + uint16_t ConId; + uint16_t Mtu; + bool connected; + }; + + CHIPoBLEConState mCons[kMaxConnections]; + uint16_t mNumCons; + CHIPoBLEServiceMode mServiceMode; + BitFlags mFlags; + char mDeviceName[kMaxDeviceNameLength]; + + void DriveBLEState(void); + void SetAdvertisingData(void); + + wiced_bt_gatt_status_t HandleGattConnectEvent(wiced_bt_gatt_connection_status_t * p_conn_status, CHIPoBLEConState * p_conn); + wiced_bt_gatt_status_t HandleGattServiceRead(uint16_t conn_id, wiced_bt_gatt_read_t * p_read_data); + wiced_bt_gatt_status_t HandleGattServiceWrite(uint16_t conn_id, wiced_bt_gatt_write_t * p_data); + wiced_bt_gatt_status_t HandleGattServiceMtuReq(wiced_bt_gatt_attribute_request_t * p_data, CHIPoBLEConState * p_conn); + wiced_bt_gatt_status_t HandleGattServiceIndCfm(uint16_t conn_id, uint16_t handle); + wiced_bt_gatt_status_t HandleGattServiceRequestEvent(wiced_bt_gatt_attribute_request_t * p_request, CHIPoBLEConState * p_conn); + + CHIPoBLEConState * AllocConnectionState(uint16_t conId); + CHIPoBLEConState * GetConnectionState(uint16_t conId); + bool ReleaseConnectionState(uint16_t conId); + gatt_db_lookup_table_t * GetGattAttr(uint16_t handle); + + static void DriveBLEState(intptr_t arg); +}; + +/** + * Returns a reference to the public interface of the BLEManager singleton object. + * + * Internal components should use this to access features of the BLEManager object + * that are common to all platforms. + */ +inline BLEManager & BLEMgr(void) +{ + return BLEManagerImpl::sInstance; +} + +/** + * Returns the platform-specific implementation of the BLEManager singleton object. + * + * Internal components can use this to gain access to features of the BLEManager + * that are specific to the P64343W platform. + */ +inline BLEManagerImpl & BLEMgrImpl(void) +{ + return BLEManagerImpl::sInstance; +} + +inline Ble::BleLayer * BLEManagerImpl::_GetBleLayer() +{ + return this; +} + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip + +#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE diff --git a/src/platform/CYW30739/BUILD.gn b/src/platform/CYW30739/BUILD.gn new file mode 100644 index 00000000000000..b09c70c9748272 --- /dev/null +++ b/src/platform/CYW30739/BUILD.gn @@ -0,0 +1,81 @@ +# Copyright (c) 2021 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/chip.gni") + +import("${chip_root}/src/platform/device.gni") + +assert(chip_device_platform == "cyw30739") + +if (chip_enable_openthread) { + import("//build_overrides/openthread.gni") +} + +static_library("CYW30739") { + sources = [ + "../SingletonConfigurationManager.cpp", + "BLEManagerImpl.cpp", + "BLEManagerImpl.h", + "BlePlatformConfig.h", + "CHIPDevicePlatformConfig.h", + "CHIPDevicePlatformEvent.h", + "CHIPPlatformConfig.h", + "CYW30739Config.cpp", + "CYW30739Config.h", + "ConfigurationManagerImpl.cpp", + "ConfigurationManagerImpl.h", + "ConnectivityManagerImpl.cpp", + "ConnectivityManagerImpl.h", + "DeviceNetworkProvisioningDelegateImpl.cpp", + "DeviceNetworkProvisioningDelegateImpl.h", + "DiagnosticDataProviderImpl.cpp", + "DiagnosticDataProviderImpl.h", + "InetPlatformConfig.h", + "KeyValueStoreManagerImpl.cpp", + "KeyValueStoreManagerImpl.h", + "Logging.cpp", + "PlatformManagerImpl.cpp", + "PlatformManagerImpl.h", + "SystemPlatformConfig.h", + "SystemTimeSupport.cpp", + "cycfg_gatt_db.c", + "cycfg_gatt_db.h", + "cyw30739-chip-mbedtls-config.h", + "wiced_button_manager.c", + "wiced_led_manager.c", + ] + + deps = [ "${chip_root}/src/crypto" ] + + public_deps = [ "${chip_root}/src/platform:platform_base" ] + + if (chip_enable_openthread) { + sources += [ + "../OpenThread/OpenThreadUtils.cpp", + "ThreadStackManagerImpl.cpp", + "ThreadStackManagerImpl.h", + ] + + deps += [ + "${chip_root}/third_party/openthread/platforms:libopenthread-platform", + "${openthread_root}/src/core:libopenthread_core_headers", + ] + + if (chip_mdns == "platform") { + sources += [ "../OpenThread/DnssdImpl.cpp" ] + + deps += [ "${chip_root}/src/lib/dnssd:platform_header" ] + } + } +} diff --git a/src/platform/CYW30739/BlePlatformConfig.h b/src/platform/CYW30739/BlePlatformConfig.h new file mode 100644 index 00000000000000..cdf8d9aa98d863 --- /dev/null +++ b/src/platform/CYW30739/BlePlatformConfig.h @@ -0,0 +1,34 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific configuration overrides for the CHIP BLE + * Layer on CYW20739B2 platform. + * + */ + +#pragma once + +// ==================== Platform Adaptations ==================== + +#define BLE_CONNECTION_OBJECT uint16_t +#define BLE_CONNECTION_UNINITIALIZED ((uint16_t) 0xffff) + +// ========== Platform-specific Configuration Overrides ========= + +/* none so far */ diff --git a/src/platform/CYW30739/CHIPDevicePlatformConfig.h b/src/platform/CYW30739/CHIPDevicePlatformConfig.h new file mode 100644 index 00000000000000..f19d20c703a88b --- /dev/null +++ b/src/platform/CYW30739/CHIPDevicePlatformConfig.h @@ -0,0 +1,72 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019-2020 Google LLC. + * Copyright (c) 2018 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Defines compile-time configuration overrides for the chip Device Layer. + */ + +#pragma once + +// -------------------- General Configuration -------------------- +#define CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE 0x00001300 +#define CHIP_DEVICE_CONFIG_LOG_PROVISIONING_HASH 0 + +// -------------------- WiFi Station Configuration -------------------- + +// -------------------- WiFi AP Configuration -------------------- +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION 0 +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI_AP 0 + +// -------------------- BLE/CHIPoBLE Configuration -------------------- +#ifndef CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE +#define CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE 1 +#endif +#define CHIP_DEVICE_CONFIG_CHIPOBLE_SINGLE_CONNECTION 1 +#define CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART 1 +#define CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL 60 // 60*0.625ms=37.5ms +#define CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL 600 // 600*0.625ms=375 + +// -------------------- Time Sync Configuration -------------------- + +// -------------------- Service Provisioning Configuration -------------------- + +// -------------------- Just-In-Time Provisioning Configuration -------------------- + +// -------------------- Service Discovery Configuration ----------------------- +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD_SRP_CLIENT 1 + +// -------------------- Thread Configuration -------------------- +#ifndef CHIP_DEVICE_CONFIG_ENABLE_THREAD +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD 1 +#define CHIP_DEVICE_CONFIG_THREAD_FTD 1 +#define CHIP_DEVICE_CONFIG_THREAD_TASK_STACK_SIZE 0x00001000 +#define CHIP_DEVICE_CONFIG_THREAD_SRP_MAX_SERVICES 5 +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD_DNS_CLIENT 1 +#endif + +// -------------------- Trait Manager Configuration -------------------- + +// -------------------- Network Telemetry Configuration -------------------- + +// -------------------- Event Logging Configuration -------------------- +#define CHIP_DEVICE_CONFIG_EVENT_LOGGING_CRIT_BUFFER_SIZE 256 +#define CHIP_DEVICE_CONFIG_EVENT_LOGGING_PROD_BUFFER_SIZE 256 + +// -------------------- Software Update Manager Configuration -------------------- diff --git a/src/platform/CYW30739/CHIPDevicePlatformEvent.h b/src/platform/CYW30739/CHIPDevicePlatformEvent.h new file mode 100644 index 00000000000000..519bfd717d7e73 --- /dev/null +++ b/src/platform/CYW30739/CHIPDevicePlatformEvent.h @@ -0,0 +1,44 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Defines platform-specific event types and data for the Chip + * Device Layer on the platform. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Represents platform-specific event information for the platforms. + */ +struct ChipDevicePlatformEvent final +{ + union + { + /* None currently defined */ + }; +}; + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/CHIPPlatformConfig.h b/src/platform/CYW30739/CHIPPlatformConfig.h new file mode 100644 index 00000000000000..2b3f19733d859a --- /dev/null +++ b/src/platform/CYW30739/CHIPPlatformConfig.h @@ -0,0 +1,31 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific configuration overrides for CHIP. + */ + +#pragma once + +#define CHIP_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH 2048 +#define CHIP_CONFIG_MAX_DEVICE_ADMINS 4 +#define CHIP_CONFIG_UNAUTHENTICATED_CONNECTION_POOL_SIZE 10 +#define CHIP_DEVICE_CONFIG_ENABLE_EXTENDED_DISCOVERY 1 +#define CHIP_DEVICE_CONFIG_ENABLE_JUST_IN_TIME_PROVISIONING 1 +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD_COMMISSIONABLE_DISCOVERY 1 diff --git a/src/platform/CYW30739/CYW30739Config.cpp b/src/platform/CYW30739/CYW30739Config.cpp new file mode 100644 index 00000000000000..cd845cdbd24bfe --- /dev/null +++ b/src/platform/CYW30739/CYW30739Config.cpp @@ -0,0 +1,130 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Utilities for accessing persisted device configuration. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include +#include + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +CHIP_ERROR CYW30739Config::Init() +{ + return CHIP_NO_ERROR; +} + +template +CHIP_ERROR CYW30739Config::ReadConfigValue(Key key, T & val) +{ + wiced_result_t result; + uint16_t read_count = wiced_hal_read_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, sizeof(val), (uint8_t *) &val, &result); + if (result != WICED_SUCCESS || read_count != sizeof(val)) + { + read_count = wiced_hal_read_nvram_static(PLATFORM_NVRAM_SSID_MATTER_BASE + key, sizeof(val), &val, &result); + } + if (result == WICED_SUCCESS && read_count == sizeof(val)) + return CHIP_NO_ERROR; + else + return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND; +} + +CHIP_ERROR CYW30739Config::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) +{ + return ReadConfigValueBin(key, reinterpret_cast(buf), bufSize, outLen); +} + +CHIP_ERROR CYW30739Config::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) +{ + wiced_result_t result; + uint16_t read_count = wiced_hal_read_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, bufSize, (uint8_t *) buf, &result); + if (result != WICED_SUCCESS) + { + read_count = wiced_hal_read_nvram_static(PLATFORM_NVRAM_SSID_MATTER_BASE + key, bufSize, buf, &result); + } + if (result == WICED_SUCCESS) + { + outLen = read_count; + return CHIP_NO_ERROR; + } + else + return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND; +} + +template CHIP_ERROR CYW30739Config::ReadConfigValue(Key key, bool & val); +template CHIP_ERROR CYW30739Config::ReadConfigValue(Key key, uint32_t & val); +template CHIP_ERROR CYW30739Config::ReadConfigValue(Key key, uint64_t & val); + +CHIP_ERROR CYW30739Config::WriteConfigValue(Key key, uint32_t val) +{ + wiced_result_t result; + uint16_t write_count = wiced_hal_write_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, sizeof(val), (uint8_t *) &val, &result); + if (result == WICED_SUCCESS && write_count == sizeof(val)) + return CHIP_NO_ERROR; + else + return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND; +} + +CHIP_ERROR CYW30739Config::WriteConfigValueStr(Key key, const char * str) +{ + return WriteConfigValueStr(key, str, (str != NULL) ? strlen(str) : 0); +} + +CHIP_ERROR CYW30739Config::WriteConfigValueStr(Key key, const char * str, size_t strLen) +{ + return WriteConfigValueBin(key, reinterpret_cast(str), strLen); +} + +CHIP_ERROR CYW30739Config::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) +{ + wiced_result_t result; + wiced_hal_write_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, dataLen, (uint8_t *) data, &result); + if (result == WICED_SUCCESS) + return CHIP_NO_ERROR; + else + return CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND; +} + +bool CYW30739Config::ConfigValueExists(Key key) +{ + wiced_result_t result; + wiced_hal_read_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, 0, NULL, &result); + if (result != WICED_SUCCESS) + wiced_hal_read_nvram_static(PLATFORM_NVRAM_SSID_MATTER_BASE + key, 0, NULL, &result); + return result == WICED_SUCCESS; +} + +CHIP_ERROR CYW30739Config::FactoryResetConfig(void) +{ + wiced_result_t result; + for (Key key = kConfigKey_Base; key <= kConfigKey_Max; key++) + wiced_hal_delete_nvram(PLATFORM_NVRAM_VSID_MATTER_BASE + key, &result); + return CHIP_NO_ERROR; +} + +void CYW30739Config::RunConfigUnitTest(void) {} + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/CYW30739Config.h b/src/platform/CYW30739/CYW30739Config.h new file mode 100644 index 00000000000000..3bd29db9a8420c --- /dev/null +++ b/src/platform/CYW30739/CYW30739Config.h @@ -0,0 +1,94 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019-2020 Google LLC. + * Copyright (c) 2018 Nest Labs, Inc. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Utilities for accessing persisted device configuration on + * CYW30739 platforms. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +/** + * Provides functions and definitions for accessing device configuration information. + */ +class CYW30739Config +{ +public: + using Key = uint32_t; + + // Key definitions for well-known keys. + // Factory config keys + static constexpr Key kConfigKey_SerialNum = 0; + static constexpr Key kConfigKey_MfrDeviceId = 1; + static constexpr Key kConfigKey_MfrDeviceCert = 2; + static constexpr Key kConfigKey_MfrDevicePrivateKey = 3; + static constexpr Key kConfigKey_ManufacturingDate = 4; + static constexpr Key kConfigKey_SetupPinCode = 5; + static constexpr Key kConfigKey_MfrDeviceICACerts = 6; + static constexpr Key kConfigKey_SetupDiscriminator = 7; + // CHIP Config Keys + static constexpr Key kConfigKey_FabricId = 8; + static constexpr Key kConfigKey_ServiceConfig = 9; + static constexpr Key kConfigKey_PairedAccountId = 10; + static constexpr Key kConfigKey_ServiceId = 11; + static constexpr Key kConfigKey_FabricSecret = 12; + static constexpr Key kConfigKey_LastUsedEpochKeyId = 13; + static constexpr Key kConfigKey_FailSafeArmed = 14; + static constexpr Key kConfigKey_GroupKey = 15; + static constexpr Key kConfigKey_HardwareVersion = 16; + static constexpr Key kConfigKey_RegulatoryLocation = 17; + static constexpr Key kConfigKey_CountryCode = 18; + static constexpr Key kConfigKey_ActiveLocale = 19; + static constexpr Key kConfigKey_HourFormat = 20; + static constexpr Key kConfigKey_CalendarType = 21; + static constexpr Key kConfigKey_Breadcrumb = 22; + + // Set key id limits for each group. + static constexpr Key kConfigKey_Base = kConfigKey_SerialNum; + static constexpr Key kConfigKey_Max = kConfigKey_Breadcrumb; + + static CHIP_ERROR Init(void); + + // Config value accessors. + template + static CHIP_ERROR ReadConfigValue(Key key, T & val); + + static CHIP_ERROR ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen); + static CHIP_ERROR ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen); + static CHIP_ERROR WriteConfigValue(Key key, uint32_t val); + static CHIP_ERROR WriteConfigValueStr(Key key, const char * str); + static CHIP_ERROR WriteConfigValueStr(Key key, const char * str, size_t strLen); + static CHIP_ERROR WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen); + static CHIP_ERROR ClearConfigValue(Key key); + static bool ConfigValueExists(Key key); + static CHIP_ERROR FactoryResetConfig(void); + static void RunConfigUnitTest(void); +}; + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/ConfigurationManagerImpl.cpp b/src/platform/CYW30739/ConfigurationManagerImpl.cpp new file mode 100644 index 00000000000000..891ec57385cb36 --- /dev/null +++ b/src/platform/CYW30739/ConfigurationManagerImpl.cpp @@ -0,0 +1,169 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides the implementation of the Device Layer ConfigurationManager object + * for CYW30739 platform. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include + +#include +#include + +#include +#include + +namespace chip { +namespace DeviceLayer { + +using namespace ::chip::DeviceLayer::Internal; + +ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance() +{ + static ConfigurationManagerImpl sInstance; + return sInstance; +} + +CHIP_ERROR ConfigurationManagerImpl::Init() +{ + CHIP_ERROR err; + + // Initialize the generic implementation base class. + err = Internal::GenericConfigurationManagerImpl::Init(); + SuccessOrExit(err); + +exit: + return err; +} + +bool ConfigurationManagerImpl::CanFactoryReset(void) +{ + return true; +} + +void ConfigurationManagerImpl::InitiateFactoryReset(void) +{ + PlatformMgr().ScheduleWork(DoFactoryReset); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value) +{ + const size_t keyLength = strnlen(key, CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH + 1); + VerifyOrReturnError(keyLength <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH, CHIP_ERROR_INVALID_STRING_LENGTH); + + return PersistedStorage::KeyValueStoreMgr().Get(key, &value, sizeof(value)); +} + +CHIP_ERROR ConfigurationManagerImpl::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value) +{ + const size_t keyLength = strnlen(key, CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH + 1); + VerifyOrReturnError(keyLength <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH, CHIP_ERROR_INVALID_STRING_LENGTH); + + return PersistedStorage::KeyValueStoreMgr().Put(key, &value, sizeof(value)); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val) +{ + return CYW30739Config::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val) +{ + return CYW30739Config::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val) +{ + return CYW30739Config::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) +{ + return CYW30739Config::ReadConfigValueStr(key, buf, bufSize, outLen); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) +{ + return CYW30739Config::ReadConfigValueBin(key, buf, bufSize, outLen); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val) +{ + return CYW30739Config::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val) +{ + return CYW30739Config::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val) +{ + return CYW30739Config::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str) +{ + return CYW30739Config::WriteConfigValueStr(key, str); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen) +{ + return CYW30739Config::WriteConfigValueStr(key, str, strLen); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) +{ + return CYW30739Config::WriteConfigValueBin(key, data, dataLen); +} + +void ConfigurationManagerImpl::RunConfigUnitTest(void) +{ + CYW30739Config::RunConfigUnitTest(); +} + +void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg) +{ + CHIP_ERROR err; + + ChipLogProgress(DeviceLayer, "Performing factory reset"); + + err = CYW30739Config::FactoryResetConfig(); + if (err != CHIP_NO_ERROR) + { + ChipLogError(DeviceLayer, "FactoryResetConfig() failed: %s", ErrorStr(err)); + } + +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + + ChipLogProgress(DeviceLayer, "Clearing Thread provision"); + ThreadStackMgr().ErasePersistentInfo(); + +#endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD + + // Restart the system. + ChipLogProgress(DeviceLayer, "System restarting"); + wiced_hal_wdog_reset_system(); +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/ConfigurationManagerImpl.h b/src/platform/CYW30739/ConfigurationManagerImpl.h new file mode 100644 index 00000000000000..021fde30a0067e --- /dev/null +++ b/src/platform/CYW30739/ConfigurationManagerImpl.h @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the ConfigurationManager object + * for CYW30739 platform. + */ + +#pragma once + +#include + +#include "CYW30739Config.h" + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the ConfigurationManager singleton object for the CYW30739 platform. + */ +class ConfigurationManagerImpl : public Internal::GenericConfigurationManagerImpl +{ +public: + // This returns an instance of this class. + static ConfigurationManagerImpl & GetDefaultInstance(); + +private: + // ===== Members that implement the ConfigurationManager public interface. + + CHIP_ERROR Init(void) override; + bool CanFactoryReset(void) override; + void InitiateFactoryReset(void) override; + CHIP_ERROR ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value) override; + CHIP_ERROR WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value) override; + + // NOTE: Other public interface methods are implemented by GenericConfigurationManagerImpl<>. + + // ===== Members that implement the GenericConfigurationManagerImpl protected interface. + CHIP_ERROR ReadConfigValue(Key key, bool & val) override; + CHIP_ERROR ReadConfigValue(Key key, uint32_t & val) override; + CHIP_ERROR ReadConfigValue(Key key, uint64_t & val) override; + CHIP_ERROR ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) override; + CHIP_ERROR ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) override; + CHIP_ERROR WriteConfigValue(Key key, bool val) override; + CHIP_ERROR WriteConfigValue(Key key, uint32_t val) override; + CHIP_ERROR WriteConfigValue(Key key, uint64_t val) override; + CHIP_ERROR WriteConfigValueStr(Key key, const char * str) override; + CHIP_ERROR WriteConfigValueStr(Key key, const char * str, size_t strLen) override; + CHIP_ERROR WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) override; + void RunConfigUnitTest(void) override; + + // ===== Private members reserved for use by this class only. + + static void DoFactoryReset(intptr_t arg); +}; + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/ConnectivityManagerImpl.cpp b/src/platform/CYW30739/ConnectivityManagerImpl.cpp new file mode 100644 index 00000000000000..7d8852c66fab44 --- /dev/null +++ b/src/platform/CYW30739/ConnectivityManagerImpl.cpp @@ -0,0 +1,57 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include + +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD +#include +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE +#include +#endif + +namespace chip { +namespace DeviceLayer { + +ConnectivityManagerImpl ConnectivityManagerImpl::sInstance; + +CHIP_ERROR ConnectivityManagerImpl::_Init() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + // Initialize the generic base classes that require it. +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + GenericConnectivityManagerImpl_Thread::_Init(); +#endif + SuccessOrExit(err); + +exit: + return err; +} + +void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) +{ +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + GenericConnectivityManagerImpl_Thread::_OnPlatformEvent(event); +#endif +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/ConnectivityManagerImpl.h b/src/platform/CYW30739/ConnectivityManagerImpl.h new file mode 100644 index 00000000000000..3fc89d769be695 --- /dev/null +++ b/src/platform/CYW30739/ConnectivityManagerImpl.h @@ -0,0 +1,97 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE +#include +#else +#include +#endif +#include +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD +#include +#else +#include +#endif + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the ConnectivityManager singleton object for the platforms. + */ +class ConnectivityManagerImpl final : public ConnectivityManager, + public Internal::GenericConnectivityManagerImpl, +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE + public Internal::GenericConnectivityManagerImpl_BLE, +#else + public Internal::GenericConnectivityManagerImpl_NoBLE, +#endif + public Internal::GenericConnectivityManagerImpl_NoWiFi, +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + public Internal::GenericConnectivityManagerImpl_Thread +#else + public Internal::GenericConnectivityManagerImpl_NoThread +#endif +{ + // Allow the ConnectivityManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend class ConnectivityManager; + +private: + // ===== Members that implement the ConnectivityManager abstract interface. + + bool _HaveServiceConnectivity(void); + CHIP_ERROR _Init(void); + void _OnPlatformEvent(const ChipDeviceEvent * event); + + // ===== Members for internal use by the following friends. + + friend ConnectivityManager & ConnectivityMgr(void); + friend ConnectivityManagerImpl & ConnectivityMgrImpl(void); + + static ConnectivityManagerImpl sInstance; +}; + +/** + * Returns the public interface of the ConnectivityManager singleton object. + * + * Chip applications should use this to access features of the ConnectivityManager object + * that are common to all platforms. + */ +inline ConnectivityManager & ConnectivityMgr(void) +{ + return ConnectivityManagerImpl::sInstance; +} + +/** + * Returns the platform-specific implementation of the ConnectivityManager singleton object. + * + * Chip applications can use this to gain access to features of the ConnectivityManager + * that are specific to the ESP32 platform. + */ +inline ConnectivityManagerImpl & ConnectivityMgrImpl(void) +{ + return ConnectivityManagerImpl::sInstance; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.cpp b/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.cpp new file mode 100644 index 00000000000000..57d9a29113e9fc --- /dev/null +++ b/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.cpp @@ -0,0 +1,39 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "DeviceNetworkProvisioningDelegateImpl.h" + +namespace chip { +namespace DeviceLayer { + +CHIP_ERROR DeviceNetworkProvisioningDelegateImpl::_ProvisionThreadNetwork(ByteSpan threadData) +{ +#if CHIP_DEVICE_CONFIG_ENABLE_THREAD + CHIP_ERROR error = CHIP_NO_ERROR; + + SuccessOrExit(error = ThreadStackMgr().SetThreadEnabled(false)); + SuccessOrExit(error = ThreadStackMgr().SetThreadProvision(threadData)); + SuccessOrExit(error = ThreadStackMgr().SetThreadEnabled(true)); +exit: + return error; +#else + return CHIP_ERROR_NOT_IMPLEMENTED; +#endif /* CHIP_DEVICE_CONFIG_ENABLE_THREAD */ +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.h b/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.h new file mode 100644 index 00000000000000..e799358e4b7536 --- /dev/null +++ b/src/platform/CYW30739/DeviceNetworkProvisioningDelegateImpl.h @@ -0,0 +1,43 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { + +namespace Internal { + +template +class GenericDeviceNetworkProvisioningDelegateImpl; + +} // namespace Internal + +class DeviceNetworkProvisioningDelegateImpl final + : public Internal::GenericDeviceNetworkProvisioningDelegateImpl +{ + friend class GenericDeviceNetworkProvisioningDelegateImpl; + +private: + CHIP_ERROR _ProvisionWiFiNetwork(const char * ssid, const char * passwd) { return CHIP_ERROR_NOT_IMPLEMENTED; } + CHIP_ERROR _ProvisionThreadNetwork(ByteSpan threadData); +}; + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/DiagnosticDataProviderImpl.cpp b/src/platform/CYW30739/DiagnosticDataProviderImpl.cpp new file mode 100644 index 00000000000000..7360320ad800ed --- /dev/null +++ b/src/platform/CYW30739/DiagnosticDataProviderImpl.cpp @@ -0,0 +1,69 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the DiagnosticDataProvider object + * for CYW30739 platform. + */ + +#include + +#include +#include + +#include +#include + +namespace chip { +namespace DeviceLayer { + +DiagnosticDataProviderImpl & DiagnosticDataProviderImpl::GetDefaultInstance() +{ + static DiagnosticDataProviderImpl sInstance; + return sInstance; +} + +CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapFree(uint64_t & currentHeapFree) +{ + const struct mallinfo mallocInfo = mallinfo(); + + currentHeapFree = wiced_memory_get_free_bytes() + mallocInfo.fordblks; + + return CHIP_NO_ERROR; +} + +CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapUsed(uint64_t & currentHeapUsed) +{ + const struct mallinfo mallocInfo = mallinfo(); + + currentHeapUsed = mallocInfo.uordblks; + + return CHIP_NO_ERROR; +} + +CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapHighWatermark(uint64_t & currentHeapHighWatermark) +{ + const struct mallinfo mallocInfo = mallinfo(); + + currentHeapHighWatermark = mallocInfo.arena; + + return CHIP_NO_ERROR; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/DiagnosticDataProviderImpl.h b/src/platform/CYW30739/DiagnosticDataProviderImpl.h new file mode 100644 index 00000000000000..6505cf5eedff17 --- /dev/null +++ b/src/platform/CYW30739/DiagnosticDataProviderImpl.h @@ -0,0 +1,48 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the DiagnosticDataProvider object. + */ + +#pragma once + +#include + +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the PlatformManager singleton object for Linux platforms. + */ +class DiagnosticDataProviderImpl : public DiagnosticDataProvider +{ +public: + static DiagnosticDataProviderImpl & GetDefaultInstance(); + + // ===== Methods that implement the PlatformManager abstract interface. + + CHIP_ERROR GetCurrentHeapFree(uint64_t & currentHeapFree) override; + CHIP_ERROR GetCurrentHeapUsed(uint64_t & currentHeapUsed) override; + CHIP_ERROR GetCurrentHeapHighWatermark(uint64_t & currentHeapHighWatermark) override; +}; + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/InetPlatformConfig.h b/src/platform/CYW30739/InetPlatformConfig.h new file mode 100644 index 00000000000000..f73534e6d00ceb --- /dev/null +++ b/src/platform/CYW30739/InetPlatformConfig.h @@ -0,0 +1,27 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific configuration overrides for the CHIP Inet Layer. + */ + +#pragma once + +#define INET_CONFIG_NUM_TCP_ENDPOINTS 4 +#define INET_CONFIG_NUM_UDP_ENDPOINTS 4 diff --git a/src/platform/CYW30739/KeyValueStoreManagerImpl.cpp b/src/platform/CYW30739/KeyValueStoreManagerImpl.cpp new file mode 100644 index 00000000000000..439865f1a4e8d1 --- /dev/null +++ b/src/platform/CYW30739/KeyValueStoreManagerImpl.cpp @@ -0,0 +1,205 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific key value storage implementation + */ + +#include + +#include +#include +#include + +namespace chip { +namespace DeviceLayer { +namespace PersistedStorage { + +KeyValueStoreManagerImpl KeyValueStoreManagerImpl::sInstance; + +CHIP_ERROR KeyValueStoreManagerImpl::_Get(const char * key, void * value, size_t value_size, size_t * read_bytes_size, + size_t offset_bytes) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + KeyEntryStorage * keyEntryStorage = NULL; + uint16_t nvramID = 0; + wiced_result_t result; + uint16_t byte_count; + + VerifyOrReturnError(offset_bytes == 0, CHIP_ERROR_NOT_IMPLEMENTED); + + const size_t keyLength = strnlen(key, CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH); + VerifyOrExit(keyLength != 0 && keyLength <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH && + value_size <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH, + err = CHIP_ERROR_INVALID_ARGUMENT); + + keyEntryStorage = new KeyEntryStorage(); + VerifyOrExit(keyEntryStorage != NULL, ChipLogError(DeviceLayer, "%s new KeyEntryStorage", __func__); + err = CHIP_ERROR_NO_MEMORY;); + + SuccessOrExit(err = keyEntryStorage->FindKeyNvramID(nvramID, key)); + + byte_count = wiced_hal_read_nvram(nvramID, value_size, (uint8_t *) value, &result); + VerifyOrExit(result == WICED_SUCCESS, ChipLogError(DeviceLayer, "%s wiced_hal_read_nvram %u", __func__, result); + err = CHIP_ERROR_INTEGRITY_CHECK_FAILED;); + + if (read_bytes_size != NULL) + { + *read_bytes_size = byte_count; + } + +exit: + delete keyEntryStorage; + + return err; +} + +CHIP_ERROR KeyValueStoreManagerImpl::_Put(const char * key, const void * value, size_t value_size) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + KeyEntryStorage * keyEntryStorage = NULL; + uint16_t nvramID = 0; + wiced_result_t result; + uint16_t byte_count; + + const size_t keyLength = strnlen(key, CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH + 1); + VerifyOrExit(keyLength != 0 && keyLength <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH && + value_size <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH, + err = CHIP_ERROR_INVALID_ARGUMENT); + + keyEntryStorage = new KeyEntryStorage(); + VerifyOrExit(keyEntryStorage != NULL, ChipLogError(DeviceLayer, "%s new KeyEntryStorage", __func__); + err = CHIP_ERROR_NO_MEMORY;); + + err = keyEntryStorage->AllocateEntry(nvramID, key, keyLength); + VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(DeviceLayer, "%s AllocateEntry %s", __func__, ErrorStr(err))); + + byte_count = wiced_hal_write_nvram(nvramID, value_size, (uint8_t *) value, &result); + VerifyOrExit(byte_count == value_size && result == WICED_SUCCESS, + ChipLogError(DeviceLayer, "%s wiced_hal_write_nvram %u", __func__, result); + keyEntryStorage->ReleaseEntry(key); err = CHIP_ERROR_PERSISTED_STORAGE_FAILED;); + +exit: + delete keyEntryStorage; + + return err; +} + +CHIP_ERROR KeyValueStoreManagerImpl::_Delete(const char * key) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + KeyEntryStorage * keyEntryStorage = NULL; + uint16_t nvramID = 0; + + const size_t keyLength = strnlen(key, CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH); + VerifyOrExit(keyLength != 0 && keyLength <= CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH, err = CHIP_ERROR_INVALID_ARGUMENT); + + keyEntryStorage = new KeyEntryStorage(); + VerifyOrExit(keyEntryStorage != NULL, ChipLogError(DeviceLayer, "%s new KeyEntryStorage", __func__); + err = CHIP_ERROR_NO_MEMORY;); + + SuccessOrExit(err = keyEntryStorage->FindKeyNvramID(nvramID, key)); + + keyEntryStorage->ReleaseEntry(key); + +exit: + delete keyEntryStorage; + + return err; +} + +bool KeyValueStoreManagerImpl::KeyEntry::IsMatchKey(const char * key) +{ + return mIsValid && strncmp(mKey, key, sizeof(mKey)) == 0; +} + +KeyValueStoreManagerImpl::KeyEntryStorage::KeyEntryStorage(void) : mIsDirty(false) +{ + wiced_result_t result; + const uint16_t byte_count = + wiced_hal_read_nvram(PLATFORM_NVRAM_ID_ENTRY_INFO_STRING, sizeof(mKeyEntries), (uint8_t *) mKeyEntries, &result); + if (byte_count != sizeof(mKeyEntries) || result != WICED_SUCCESS) + { + memset(mKeyEntries, 0, sizeof(mKeyEntries)); + } +} + +KeyValueStoreManagerImpl::KeyEntryStorage::~KeyEntryStorage(void) +{ + if (mIsDirty) + { + wiced_result_t result; + const uint16_t byte_count = + wiced_hal_write_nvram(PLATFORM_NVRAM_ID_ENTRY_INFO_STRING, sizeof(mKeyEntries), (uint8_t *) mKeyEntries, &result); + if (byte_count != sizeof(mKeyEntries) || result != WICED_SUCCESS) + { + ChipLogError(DeviceLayer, "%s wiced_hal_write_nvram %u", __func__, result); + } + } +} + +CHIP_ERROR KeyValueStoreManagerImpl::KeyEntryStorage::AllocateEntry(uint16_t & nvramID, const char * key, size_t keyLength) +{ + ReturnErrorCodeIf(keyLength == 0 || keyLength > sizeof(mKeyEntries[0].mKey), CHIP_ERROR_INVALID_ARGUMENT); + ReturnErrorCodeIf(FindKeyNvramID(nvramID, key) == CHIP_NO_ERROR, CHIP_NO_ERROR); + + for (uint8_t i = 0; i < ArraySize(mKeyEntries); i++) + { + if (!mKeyEntries[i].mIsValid) + { + mKeyEntries[i].mIsValid = true; + memcpy(mKeyEntries[i].mKey, key, keyLength); + mIsDirty = true; + nvramID = PLATFORM_NVRAM_ID_ENTRY_DATA_STRING + i; + return CHIP_NO_ERROR; + } + } + + return CHIP_ERROR_NO_MEMORY; +} + +void KeyValueStoreManagerImpl::KeyEntryStorage::ReleaseEntry(const char * key) +{ + for (uint8_t i = 0; i < ArraySize(mKeyEntries); i++) + { + if (mKeyEntries[i].IsMatchKey(key)) + { + mKeyEntries[i].mIsValid = false; + mIsDirty = true; + break; + } + } +} + +CHIP_ERROR KeyValueStoreManagerImpl::KeyEntryStorage::FindKeyNvramID(uint16_t & nvramID, const char * key) +{ + for (uint8_t i = 0; i < ArraySize(mKeyEntries); i++) + { + if (mKeyEntries[i].IsMatchKey(key)) + { + nvramID = PLATFORM_NVRAM_ID_ENTRY_DATA_STRING + i; + return CHIP_NO_ERROR; + } + } + return CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; +} + +} // namespace PersistedStorage +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/KeyValueStoreManagerImpl.h b/src/platform/CYW30739/KeyValueStoreManagerImpl.h new file mode 100644 index 00000000000000..6cc0fbe0a85032 --- /dev/null +++ b/src/platform/CYW30739/KeyValueStoreManagerImpl.h @@ -0,0 +1,107 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific key value storage implementation. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { +namespace PersistedStorage { + +class KeyValueStoreManagerImpl final : public KeyValueStoreManager +{ + // Allow the KeyValueStoreManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend class KeyValueStoreManager; + +public: + // NOTE: Currently this platform does not support partial and offset reads + // these will return CHIP_ERROR_NOT_IMPLEMENTED. + CHIP_ERROR _Get(const char * key, void * value, size_t value_size, size_t * read_bytes_size = nullptr, size_t offset = 0); + + CHIP_ERROR _Delete(const char * key); + + CHIP_ERROR _Put(const char * key, const void * value, size_t value_size); + +private: + static constexpr uint8_t mMaxEntryCount = 1 + /* For the global message counter */ + 1 + /* For the admin key count */ + CHIP_CONFIG_MAX_DEVICE_ADMINS + 1 + /* For the session key count */ + CHIP_CONFIG_MAX_SESSION_KEYS; + + struct KeyEntry + { + bool mIsValid; + char mKey[CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH]; + + bool IsMatchKey(const char * key); + }; + + class KeyEntryStorage + { + public: + KeyEntryStorage(void); + ~KeyEntryStorage(void); + + CHIP_ERROR AllocateEntry(uint16_t & nvramID, const char * key, size_t keyLength); + void ReleaseEntry(const char * key); + CHIP_ERROR FindKeyNvramID(uint16_t & nvramID, const char * key); + + private: + KeyEntry mKeyEntries[mMaxEntryCount]; + bool mIsDirty; + }; + + // ===== Members for internal use by the following friends. + friend KeyValueStoreManager & KeyValueStoreMgr(); + friend KeyValueStoreManagerImpl & KeyValueStoreMgrImpl(); + + static KeyValueStoreManagerImpl sInstance; +}; + +/** + * Returns the public interface of the KeyValueStoreManager singleton object. + * + * Chip applications should use this to access features of the KeyValueStoreManager object + * that are common to all platforms. + */ +inline KeyValueStoreManager & KeyValueStoreMgr(void) +{ + return KeyValueStoreManagerImpl::sInstance; +} + +/** + * Returns the platform-specific implementation of the KeyValueStoreManager singleton object. + * + * Chip applications can use this to gain access to features of the KeyValueStoreManager + * that are specific to the ESP32 platform. + */ +inline KeyValueStoreManagerImpl & KeyValueStoreMgrImpl(void) +{ + return KeyValueStoreManagerImpl::sInstance; +} + +} // namespace PersistedStorage +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/Logging.cpp b/src/platform/CYW30739/Logging.cpp new file mode 100644 index 00000000000000..982666594ca291 --- /dev/null +++ b/src/platform/CYW30739/Logging.cpp @@ -0,0 +1,37 @@ +/* See Project CHIP LICENSE file for licensing information. */ + +#include +#include +#include +#include +#include + +namespace chip { +namespace Logging { +namespace Platform { + +void LogV(const char * module, uint8_t category, const char * msg, va_list v) +{ + switch (category) + { + case chip::Logging::LogCategory::kLogCategory_Error: + printf("Error"); + break; + case chip::Logging::LogCategory::kLogCategory_Progress: + printf("InfoP"); + break; + case chip::Logging::LogCategory::kLogCategory_Detail: + printf("InfoD"); + break; + } + + static char buffer[256]; + vsnprintf(buffer, sizeof(buffer), msg, v); + printf(" CHIP:%s: %s\n", module, buffer); + + assert(!wiced_rtos_check_for_stack_overflow()); +} + +} // namespace Platform +} // namespace Logging +} // namespace chip diff --git a/src/platform/CYW30739/PlatformManagerImpl.cpp b/src/platform/CYW30739/PlatformManagerImpl.cpp new file mode 100644 index 00000000000000..3b097fa24c886f --- /dev/null +++ b/src/platform/CYW30739/PlatformManagerImpl.cpp @@ -0,0 +1,251 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the PlatformManager object. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include +#include +#include + +#include +#include +#include + +namespace chip { +namespace DeviceLayer { + +PlatformManagerImpl PlatformManagerImpl::sInstance; + +CHIP_ERROR PlatformManagerImpl::_InitChipStack(void) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + wiced_result_t result; + + // Initialize the configuration system. + err = Internal::CYW30739Config::Init(); + SuccessOrExit(err); + + SetConfigurationMgr(&ConfigurationManagerImpl::GetDefaultInstance()); + SetDiagnosticDataProvider(&DiagnosticDataProviderImpl::GetDefaultInstance()); + + /* Initialize LwIP. */ + lwip_init(); + + /* Create the thread object. */ + mThread = wiced_rtos_create_thread(); + VerifyOrExit(mThread != nullptr, err = CHIP_ERROR_NO_MEMORY); + + /* Initialize the event flags. */ + mEventFlags = wiced_rtos_create_event_flags(); + VerifyOrExit(mEventFlags != nullptr, err = CHIP_ERROR_NO_MEMORY); + + result = wiced_rtos_init_event_flags(mEventFlags); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY); + /* Initialize the event queue. */ + mEventQueue = wiced_rtos_create_queue(); + VerifyOrExit(mEventQueue != nullptr, err = CHIP_ERROR_NO_MEMORY); + + result = wiced_rtos_init_queue(mEventQueue, "EventQueue", sizeof(ChipDeviceEvent), CHIP_DEVICE_CONFIG_MAX_EVENT_QUEUE_SIZE); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY); + + /* Initialize the timer. */ + result = wiced_init_timer(&mTimer, TimerCallback, 0, WICED_MILLI_SECONDS_TIMER); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_INTERNAL); + + /* Initialize the mutex. */ + mMutex = wiced_rtos_create_mutex(); + VerifyOrExit(mMutex != nullptr, err = CHIP_ERROR_NO_MEMORY); + + result = wiced_rtos_init_mutex(mMutex); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_INTERNAL); + + ReturnErrorOnFailure(chip::Crypto::add_entropy_source(GetEntropy, NULL, 16)); + + ReturnErrorOnFailure(GenericPlatformManagerImpl::_InitChipStack()); + +exit: + return err; +} + +void PlatformManagerImpl::_RunEventLoop(void) +{ + ChipLogDetail(DeviceLayer, "Free RAM sizes: %lu\n", wiced_memory_get_free_bytes()); + + while (true) + { + uint32_t flags_set = 0; + const wiced_result_t result = wiced_rtos_wait_for_event_flags(mEventFlags, 0xffffffff, &flags_set, WICED_TRUE, + WAIT_FOR_ANY_EVENT, WICED_WAIT_FOREVER); + if (result != WICED_SUCCESS) + { + ChipLogError(DeviceLayer, "wiced_rtos_wait_for_event_flags 0x%08x", result); + continue; + } + + if (flags_set & kTimerEventFlag) + { + HandleTimerEvent(); + } + + if (flags_set & kPostEventFlag) + { + HandlePostEvent(); + } + } +} + +CHIP_ERROR PlatformManagerImpl::_StartEventLoopTask(void) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + wiced_result_t result; + + result = wiced_rtos_init_thread(mThread, CHIP_DEVICE_CONFIG_CHIP_TASK_PRIORITY, CHIP_DEVICE_CONFIG_CHIP_TASK_NAME, + EventLoopTaskMain, CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE, this); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY); + +exit: + return err; +} + +void PlatformManagerImpl::_LockChipStack(void) +{ + const wiced_result_t result = wiced_rtos_lock_mutex(mMutex); + VerifyOrReturn(result == WICED_SUCCESS, ChipLogError(DeviceLayer, "%s %x", __func__, result)); +} + +void PlatformManagerImpl::_UnlockChipStack(void) +{ + const wiced_result_t result = wiced_rtos_unlock_mutex(mMutex); + VerifyOrReturn(result == WICED_SUCCESS || result == WICED_NOT_OWNED, ChipLogError(DeviceLayer, "%s %x", __func__, result)); +} + +CHIP_ERROR PlatformManagerImpl::_PostEvent(const ChipDeviceEvent * event) +{ + const wiced_result_t result = wiced_rtos_push_to_queue(mEventQueue, const_cast(event), WICED_NO_WAIT); + if (WICED_SUCCESS != result) + { + ChipLogError(DeviceLayer, "wiced_rtos_push_to_queue %u", result); + return CHIP_ERROR_INTERNAL; + } + + SetEventFlags(kPostEventFlag); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR PlatformManagerImpl::_StartChipTimer(System::Clock::Timeout durationMS) +{ + if (durationMS.count() == 0) + { + TimerCallback(0); + } + else + { + const wiced_result_t result = wiced_start_timer(&mTimer, durationMS.count()); + if (WICED_SUCCESS != result) + { + ChipLogError(DeviceLayer, "wiced_start_timer 0x%02x", result); + return CHIP_ERROR_INTERNAL; + } + } + return CHIP_NO_ERROR; +} + +CHIP_ERROR PlatformManagerImpl::_Shutdown() +{ + return CHIP_NO_ERROR; +} + +void PlatformManagerImpl::SetEventFlags(uint32_t flags) +{ + assert(!wiced_rtos_check_for_stack_overflow()); + + if (wiced_rtos_set_event_flags(mEventFlags, flags) != WICED_SUCCESS) + { + ChipLogError(DeviceLayer, "%s wiced_rtos_set_event_flags %08lx", __func__, flags); + } +} + +void PlatformManagerImpl::HandleTimerEvent(void) +{ + const CHIP_ERROR err = static_cast(DeviceLayer::SystemLayer()).HandlePlatformTimer(); + if (err != CHIP_NO_ERROR) + { + ChipLogError(DeviceLayer, "HandlePlatformTimer %ld", err.AsInteger()); + } +} + +void PlatformManagerImpl::HandlePostEvent(void) +{ + wiced_result_t result; + ChipDeviceEvent event; + + /* Check the event queue. */ + if (wiced_rtos_is_queue_empty(mEventQueue)) + { + return; + } + + /* Pop one event from the event queue. */ + result = wiced_rtos_pop_from_queue(mEventQueue, &event, WICED_WAIT_FOREVER); + + if (WICED_SUCCESS != result) + { + ChipLogError(DeviceLayer, "wiced_rtos_pop_from_queue %u", result); + return; + } + + /* Process this event. */ + DispatchEvent(&event); + + /* Set another application thread event if the event queue is not empty. */ + if (!wiced_rtos_is_queue_empty(mEventQueue)) + { + SetEventFlags(kPostEventFlag); + } +} + +void PlatformManagerImpl::EventLoopTaskMain(uint32_t arg) +{ + ChipLogDetail(DeviceLayer, "CHIP task running"); + reinterpret_cast(arg)->RunEventLoop(); +} + +void PlatformManagerImpl::TimerCallback(WICED_TIMER_PARAM_TYPE params) +{ + PlatformMgrImpl().SetEventFlags(kTimerEventFlag); +} + +int PlatformManagerImpl::GetEntropy(void * data, unsigned char * output, size_t len, size_t * olen) +{ + const wiced_result_t result = wiced_platform_entropy_get(output, static_cast(len)); + if (result != WICED_SUCCESS) + { + return -1; + } + *olen = len; + return 0; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/PlatformManagerImpl.h b/src/platform/CYW30739/PlatformManagerImpl.h new file mode 100644 index 00000000000000..9b0523db9bd913 --- /dev/null +++ b/src/platform/CYW30739/PlatformManagerImpl.h @@ -0,0 +1,103 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the PlatformManager object. + * for the platform. + */ + +#pragma once + +#include +#include +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the PlatformManager singleton object for the platform. + */ +class PlatformManagerImpl final : public PlatformManager, public Internal::GenericPlatformManagerImpl +{ + // Allow the PlatformManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend PlatformManager; + +private: + // ===== Methods that implement the PlatformManager abstract interface. + + CHIP_ERROR _InitChipStack(void); + void _RunEventLoop(void); + CHIP_ERROR _StartEventLoopTask(void); + CHIP_ERROR _StopEventLoopTask(void); + void _LockChipStack(void); + bool _TryLockChipStack(void); + void _UnlockChipStack(void); + CHIP_ERROR _PostEvent(const ChipDeviceEvent * event); + CHIP_ERROR _StartChipTimer(System::Clock::Timeout durationMS); + CHIP_ERROR _Shutdown(void); + + void SetEventFlags(uint32_t flags); + void HandleTimerEvent(void); + void HandlePostEvent(void); + + // ===== Members for internal use by the following friends. + + friend PlatformManager & PlatformMgr(void); + friend PlatformManagerImpl & PlatformMgrImpl(void); + + wiced_thread_t * mThread; + wiced_event_flags_t * mEventFlags; + wiced_queue_t * mEventQueue; + wiced_timer_t mTimer; + wiced_mutex_t * mMutex; + + static void EventLoopTaskMain(uint32_t arg); + static void TimerCallback(WICED_TIMER_PARAM_TYPE params); + static int GetEntropy(void * data, unsigned char * output, size_t len, size_t * olen); + static PlatformManagerImpl sInstance; + static constexpr uint32_t kTimerEventFlag = 1 << 0; + static constexpr uint32_t kPostEventFlag = 1 << 1; +}; + +/** + * Returns the public interface of the PlatformManager singleton object. + * + * Chip applications should use this to access features of the PlatformManager object + * that are common to all platforms. + */ +inline PlatformManager & PlatformMgr(void) +{ + return PlatformManagerImpl::sInstance; +} + +/** + * Returns the platform-specific implementation of the PlatformManager singleton object. + * + * Chip applications can use this to gain access to features of the PlatformManager + * that are specific to the ESP32 platform. + */ +inline PlatformManagerImpl & PlatformMgrImpl(void) +{ + return PlatformManagerImpl::sInstance; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/CYW30739/SystemPlatformConfig.h b/src/platform/CYW30739/SystemPlatformConfig.h new file mode 100644 index 00000000000000..0da60ba4965ed0 --- /dev/null +++ b/src/platform/CYW30739/SystemPlatformConfig.h @@ -0,0 +1,31 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Google LLC. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Platform-specific configuration overrides for the CHIP system layer. + * + */ + +#pragma once + +// ==================== Platform Adaptations ==================== +#define CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME 1 +#define CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE const struct ::chip::DeviceLayer::ChipDeviceEvent * + +// ========== Platform-specific Configuration Overrides ========= diff --git a/src/platform/CYW30739/SystemTimeSupport.cpp b/src/platform/CYW30739/SystemTimeSupport.cpp new file mode 100644 index 00000000000000..5eaf8a3e4f1f1c --- /dev/null +++ b/src/platform/CYW30739/SystemTimeSupport.cpp @@ -0,0 +1,66 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2018 Nest Labs, Inc. + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides implementations of the CHIP System Layer platform + * time/clock functions. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include +#include + +namespace chip { +namespace System { +namespace Clock { + +namespace Internal { +ClockImpl gClockImpl; +} // namespace Internal + +Clock::Microseconds64 ClockImpl::GetMonotonicMicroseconds64(void) +{ + return Clock::Microseconds64(clock_SystemTimeMicroseconds64()); +} + +Clock::Milliseconds64 ClockImpl::GetMonotonicMilliseconds64(void) +{ + return Clock::Milliseconds64(clock_SystemTimeMicroseconds64() / 1000); +} + +CHIP_ERROR ClockImpl::GetClock_RealTime(Clock::Microseconds64 & aCurTime) +{ + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +} + +CHIP_ERROR ClockImpl::GetClock_RealTimeMS(Clock::Milliseconds64 & aCurTime) +{ + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +} + +CHIP_ERROR ClockImpl::SetClock_RealTime(Clock::Microseconds64 aNewCurTime) +{ + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +} + +} // namespace Clock +} // namespace System +} // namespace chip diff --git a/src/platform/CYW30739/ThreadStackManagerImpl.cpp b/src/platform/CYW30739/ThreadStackManagerImpl.cpp new file mode 100644 index 00000000000000..f8d8a76b034120 --- /dev/null +++ b/src/platform/CYW30739/ThreadStackManagerImpl.cpp @@ -0,0 +1,108 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the ThreadStackManager object. + * + */ +/* this file behaves like a config.h, comes first */ +#include + +#include + +#include +#include +#include + +namespace chip { +namespace DeviceLayer { + +using namespace ::chip::DeviceLayer::Internal; + +ThreadStackManagerImpl ThreadStackManagerImpl::sInstance; + +CHIP_ERROR ThreadStackManagerImpl::_InitThreadStack() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + wiced_result_t result; + + mThread = wiced_rtos_create_thread(); + VerifyOrExit(mThread != nullptr, err = CHIP_ERROR_NO_MEMORY); + + mMutex = wiced_rtos_create_mutex(); + VerifyOrExit(mMutex != nullptr, err = CHIP_ERROR_NO_MEMORY); + + result = wiced_rtos_init_mutex(mMutex); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_INTERNAL); + otSysInit(0, NULL); + + err = GenericThreadStackManagerImpl_OpenThread_LwIP::DoInit(NULL); + +exit: + return err; +} + +CHIP_ERROR ThreadStackManagerImpl::_StartThreadTask() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + wiced_result_t result; + + result = wiced_rtos_init_thread(mThread, CHIP_DEVICE_CONFIG_THREAD_TASK_PRIORITY, CHIP_DEVICE_CONFIG_THREAD_TASK_NAME, + ThreadTaskMain, CHIP_DEVICE_CONFIG_THREAD_TASK_STACK_SIZE, this); + VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY); + +exit: + return err; +} + +void ThreadStackManagerImpl::_LockThreadStack() +{ + const wiced_result_t result = wiced_rtos_lock_mutex(mMutex); + VerifyOrReturn(result == WICED_SUCCESS, ChipLogError(DeviceLayer, "%s %x", __func__, result)); +} + +void ThreadStackManagerImpl::_UnlockThreadStack() +{ + const wiced_result_t result = wiced_rtos_unlock_mutex(mMutex); + VerifyOrReturn(result == WICED_SUCCESS || result == WICED_NOT_OWNED, ChipLogError(DeviceLayer, "%s %x", __func__, result)); +} + +void ThreadStackManagerImpl::ThreadTaskMain(void) +{ + while (true) + { + LockThreadStack(); + ProcessThreadActivity(); + UnlockThreadStack(); + } +} + +void ThreadStackManagerImpl::ThreadTaskMain(uint32_t arg) +{ + ChipLogDetail(DeviceLayer, "Thread task running"); + reinterpret_cast(arg)->ThreadTaskMain(); +} + +} // namespace DeviceLayer +} // namespace chip + +/* A wrapper for the GenericThreadStackManagerImpl_OpenThread_LwIP implementation. */ +err_t tcpip_input(struct pbuf * p, struct netif * inp) +{ + return ip_input(p, inp); +} diff --git a/src/platform/CYW30739/ThreadStackManagerImpl.h b/src/platform/CYW30739/ThreadStackManagerImpl.h new file mode 100644 index 00000000000000..a8068ed1fc9962 --- /dev/null +++ b/src/platform/CYW30739/ThreadStackManagerImpl.h @@ -0,0 +1,102 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2019 Nest Labs, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Provides an implementation of the ThreadStackManager object + * for the platforms using the OpenThread stack. + */ + +#pragma once + +#include +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the ThreadStackManager singleton object for the platform. + */ +class ThreadStackManagerImpl final : public ThreadStackManager, + public Internal::GenericThreadStackManagerImpl_OpenThread_LwIP +{ + // Allow the ThreadStackManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend class ThreadStackManager; + +public: + // ===== Methods that implement the ThreadStackManager abstract interface. + CHIP_ERROR _InitThreadStack(); + +protected: + // ===== Methods that implement the ThreadStackManager abstract interface. + + CHIP_ERROR _StartThreadTask(); + void _LockThreadStack(); + bool _TryLockThreadStack(); + void _UnlockThreadStack(); + + // ===== Methods that override the GenericThreadStackManagerImpl_OpenThread abstract interface. + + void _OnCHIPoBLEAdvertisingStart(); + void _OnCHIPoBLEAdvertisingStop(); + +private: + // ===== Members for internal use by the following friends. + + friend ThreadStackManager & ::chip::DeviceLayer::ThreadStackMgr(void); + friend ThreadStackManagerImpl & ::chip::DeviceLayer::ThreadStackMgrImpl(void); + + wiced_thread_t * mThread; + wiced_mutex_t * mMutex; + static ThreadStackManagerImpl sInstance; + + // ===== Private members for use by this class only. + + void ThreadTaskMain(void); + + static void ThreadTaskMain(uint32_t arg); +}; + +/** + * Returns the public interface of the ThreadStackManager singleton object. + * + * Chip applications should use this to access features of the ThreadStackManager object + * that are common to all platforms. + */ +inline ThreadStackManager & ThreadStackMgr(void) +{ + return ThreadStackManagerImpl::sInstance; +} + +/** + * Returns the platform-specific implementation of the ThreadStackManager singleton object. + * + * Chip applications can use this to gain access to features of the ThreadStackManager + * that are specific to the platforms. + */ +inline ThreadStackManagerImpl & ThreadStackMgrImpl(void) +{ + return ThreadStackManagerImpl::sInstance; +} + +} // namespace DeviceLayer +} // namespace chip + +err_t tcpip_input(struct pbuf * p, struct netif * inp); diff --git a/src/platform/CYW30739/args.gni b/src/platform/CYW30739/args.gni new file mode 100644 index 00000000000000..a49440e56219ee --- /dev/null +++ b/src/platform/CYW30739/args.gni @@ -0,0 +1,66 @@ +# Copyright (c) 2021 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/build.gni") +import("//build_overrides/chip.gni") +import("//build_overrides/cyw30739_sdk.gni") +import("//build_overrides/pigweed.gni") + +import("${chip_root}/examples/platform/cyw30739/args.gni") + +custom_toolchain = "${build_root}/toolchain/arm_gcc" + +arm_platform_config = "${cyw30739_sdk_build_root}/cyw30739_arm.gni" + +chip_target_style = "embedded" +chip_crypto = "mbedtls" + +chip_device_platform = "cyw30739" +chip_mdns = "platform" + +chip_enable_openthread = true + +lwip_platform = "cyw30739" + +chip_inet_config_enable_ipv4 = false +chip_inet_config_enable_dns_resolver = false +chip_inet_config_enable_tcp_endpoint = false +chip_inet_config_enable_raw_endpoint = false + +chip_system_config_locking = "none" +chip_system_config_use_lwip = true +chip_system_config_use_sockets = false + +is_debug = false +default_configs_optimize = [ "$dir_pw_build:optimize_size" ] + +chip_build_tests = false + +mbedtls_target = "${cyw30739_sdk_build_root}:mbedtls" +openthread_external_mbedtls = mbedtls_target + +openthread_project_core_config_file = "OpenThreadConfig.h" +openthread_core_config_deps = [ "${chip_root}/examples/platform/cyw30739:openthread_core_config_ifx_chip_examples" ] + +openthread_external_platform = + "${chip_root}/third_party/openthread/platforms/ifx:libopenthread-ifx" + +openthread_enable_core_config_args = true +openthread_config_dhcp6_client_enable = true +openthread_config_dns_client_enable = true +openthread_config_ecdsa_enable = true +openthread_config_ip6_slaac_enable = true +openthread_config_joiner_enable = true +openthread_config_log_output = "platform_defined" +openthread_config_srp_client_enable = true diff --git a/src/platform/CYW30739/cycfg_gatt_db.c b/src/platform/CYW30739/cycfg_gatt_db.c new file mode 100644 index 00000000000000..7e24da9154b911 --- /dev/null +++ b/src/platform/CYW30739/cycfg_gatt_db.c @@ -0,0 +1,128 @@ +/***************************************************************************/ /** + * File Name: cycfg_gatt_db.c + * Version: 2.1 + * + * Description: + * BLE device's GATT database and device + *configuration. + * + ******************************************************************************** + * Copyright 2020 Cypress Semiconductor Corporation + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the + *"License"); you may not use this file except in + *compliance with the License. You may obtain a copy + *of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in + *writing, software distributed under the License is + *distributed on an "AS IS" BASIS, WITHOUT WARRANTIES + *OR CONDITIONS OF ANY KIND, either express or + *implied. See the License for the specific language + *governing permissions and limitations under the + *License. + *******************************************************************************/ + +#include "cycfg_gatt_db.h" +#include "wiced_bt_gatt.h" +#include "wiced_bt_uuid.h" +#ifdef BLE_OTA_FW_UPGRADE +#include +#endif + +/************************************************************************************* + * GATT server definitions + *************************************************************************************/ + +const uint8_t gatt_database[] = { + /* Primary Service: Generic Access */ + PRIMARY_SERVICE_UUID16(HDLS_GAP, __UUID_SERVICE_GENERIC_ACCESS), + + /* Characteristic: Device Name */ + CHARACTERISTIC_UUID16(HDLC_GAP_DEVICE_NAME, HDLC_GAP_DEVICE_NAME_VALUE, __UUID_CHARACTERISTIC_DEVICE_NAME, + LEGATTDB_CHAR_PROP_READ, LEGATTDB_PERM_READABLE), + + /* Characteristic: Appearance */ + CHARACTERISTIC_UUID16(HDLC_GAP_APPEARANCE, HDLC_GAP_APPEARANCE_VALUE, __UUID_CHARACTERISTIC_APPEARANCE, LEGATTDB_CHAR_PROP_READ, + LEGATTDB_PERM_READABLE), + + /* Primary Service: Generic Attribute */ + PRIMARY_SERVICE_UUID16(HDLS_GATT, __UUID_SERVICE_GENERIC_ATTRIBUTE), + + /* Primary Service: Custom Service */ + PRIMARY_SERVICE_UUID16(HDLS_CHIP_SERVICE, __UUID16_CHIPoBLEService), + + /* Characteristic: C1 */ + CHARACTERISTIC_UUID128_WRITABLE(HDLC_CHIP_SERVICE_CHAR_C1, HDLC_CHIP_SERVICE_CHAR_C1_VALUE, __UUID128_CHIPoBLEChar_C1, + LEGATTDB_CHAR_PROP_WRITE, + LEGATTDB_PERM_VARIABLE_LENGTH | LEGATTDB_PERM_READABLE | LEGATTDB_PERM_WRITE_REQ), + /* Characteristic: C2 */ + CHARACTERISTIC_UUID128_WRITABLE(HDLC_CHIP_SERVICE_CHAR_C2, HDLC_CHIP_SERVICE_CHAR_C2_VALUE, __UUID128_CHIPoBLEChar_C2, + LEGATTDB_CHAR_PROP_READ | LEGATTDB_CHAR_PROP_NOTIFY, + LEGATTDB_PERM_RELIABLE_WRITE | LEGATTDB_PERM_READABLE | LEGATTDB_PERM_WRITABLE), + + /* Descriptor: Client Characteristic Configuration */ + CHAR_DESCRIPTOR_UUID16_WRITABLE(HDLD_CHIP_SERVICE_RX_CLIENT_CHAR_CONFIG, __UUID_DESCRIPTOR_CLIENT_CHARACTERISTIC_CONFIGURATION, + LEGATTDB_PERM_AUTH_READABLE | LEGATTDB_PERM_WRITE_REQ), + +#ifdef BLE_OTA_FW_UPGRADE + /* WICED Upgrade Service. */ + PRIMARY_SERVICE_UUID128(HANDLE_OTA_FW_UPGRADE_SERVICE, UUID_OTA_FW_UPGRADE_SERVICE), + + /* characteristic Control Point */ + CHARACTERISTIC_UUID128_WRITABLE(HANDLE_OTA_FW_UPGRADE_CHARACTERISTIC_CONTROL_POINT, HANDLE_OTA_FW_UPGRADE_CONTROL_POINT, + UUID_OTA_FW_UPGRADE_CHARACTERISTIC_CONTROL_POINT, + LEGATTDB_CHAR_PROP_WRITE | LEGATTDB_CHAR_PROP_NOTIFY | LEGATTDB_CHAR_PROP_INDICATE, + LEGATTDB_PERM_VARIABLE_LENGTH | LEGATTDB_PERM_WRITE_REQ), + + /* client characteristic configuration descriptor */ + CHAR_DESCRIPTOR_UUID16_WRITABLE(HANDLE_OTA_FW_UPGRADE_CLIENT_CONFIGURATION_DESCRIPTOR, + UUID_DESCRIPTOR_CLIENT_CHARACTERISTIC_CONFIGURATION, + LEGATTDB_PERM_READABLE | LEGATTDB_PERM_WRITE_REQ), + + /* characteristic Data. */ + CHARACTERISTIC_UUID128_WRITABLE(HANDLE_OTA_FW_UPGRADE_CHARACTERISTIC_DATA, HANDLE_OTA_FW_UPGRADE_DATA, + UUID_OTA_FW_UPGRADE_CHARACTERISTIC_DATA, LEGATTDB_CHAR_PROP_WRITE, + LEGATTDB_PERM_VARIABLE_LENGTH | LEGATTDB_PERM_WRITE_REQ | LEGATTDB_PERM_RELIABLE_WRITE), +#endif /* BLE_OTA_FW_UPGRADE */ +}; + +/* Length of the GATT database */ +const uint16_t gatt_database_len = sizeof(gatt_database); + +/************************************************************************************* + * GATT Initial Value Arrays + ************************************************************************************/ + +uint8_t app_gap_device_name[kMaxDeviceNameLength] = { 'I', 'F', 'X', ' ', 'C', 'H', 'I', 'P' }; +uint8_t app_gap_appearance[] = { + 0x00, + 0x00, +}; +uint8_t app_chip_service_char_tx_client_char_config[] = { + 0x00, + 0x00, +}; + +/************************************************************************************ + * GATT Lookup Table + ************************************************************************************/ + +gatt_db_lookup_table_t app_gatt_db_ext_attr_tbl[] = { + /* { attribute handle, maxlen, curlen, attribute data } */ + { HDLC_GAP_DEVICE_NAME_VALUE, sizeof(app_gap_device_name), sizeof(app_gap_device_name), app_gap_device_name }, + { HDLC_GAP_APPEARANCE_VALUE, sizeof(app_gap_appearance), sizeof(app_gap_appearance), app_gap_appearance }, + { HDLD_CHIP_SERVICE_RX_CLIENT_CHAR_CONFIG, sizeof(app_chip_service_char_tx_client_char_config), + sizeof(app_chip_service_char_tx_client_char_config), app_chip_service_char_tx_client_char_config }, +}; + +/* Number of Lookup Table entries */ +const uint16_t app_gatt_db_ext_attr_tbl_size = (sizeof(app_gatt_db_ext_attr_tbl) / sizeof(gatt_db_lookup_table_t)); + +/* Number of GATT initial value arrays entries */ +const uint16_t app_gap_device_name_len = (sizeof(app_gap_device_name)); +const uint16_t app_gap_appearance_len = (sizeof(app_gap_appearance)); +const uint16_t app_chip_service_char_tx_client_char_config_len = (sizeof(app_chip_service_char_tx_client_char_config)); diff --git a/src/platform/CYW30739/cycfg_gatt_db.h b/src/platform/CYW30739/cycfg_gatt_db.h new file mode 100644 index 00000000000000..a525696adae572 --- /dev/null +++ b/src/platform/CYW30739/cycfg_gatt_db.h @@ -0,0 +1,95 @@ +/***************************************************************************/ +/** + * File Name: cycfg_gatt_db.h + * Version: 2.1 + * + * Description: + * Definitions for constants used in the device's GATT + *database and function prototypes. This file should + *not be modified. It was automatically generated by + * Bluetooth Configurator 2.1.0.2188 + * + ******************************************************************************** + * Copyright 2020 Cypress Semiconductor Corporation + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the + *"License"); you may not use this file except in + *compliance with the License. You may obtain a copy + *of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in + *writing, software distributed under the License is + *distributed on an "AS IS" BASIS, WITHOUT WARRANTIES + *OR CONDITIONS OF ANY KIND, either express or + *implied. See the License for the specific language + *governing permissions and limitations under the + *License. + *******************************************************************************/ + +#if !defined(CYCFG_GATT_DB_H) +#define CYCFG_GATT_DB_H + +#include "stdint.h" + +#define __UUID_SERVICE_GENERIC_ACCESS 0x1800 +#define __UUID_CHARACTERISTIC_DEVICE_NAME 0x2A00 +#define __UUID_CHARACTERISTIC_APPEARANCE 0x2A01 +#define __UUID_SERVICE_GENERIC_ATTRIBUTE 0x1801 +#define __UUID16_CHIPoBLEService 0xFFF6 +#define __UUID128_CHIPoBLEChar_C1 0x11, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18 +#define __UUID128_CHIPoBLEChar_C2 0x12, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18 +#define __UUID_DESCRIPTOR_CLIENT_CHARACTERISTIC_CONFIGURATION 0x2902 + +/* Service Generic Access */ +#define HDLS_GAP 0x01 +/* Characteristic Device Name */ +#define HDLC_GAP_DEVICE_NAME 0x02 +#define HDLC_GAP_DEVICE_NAME_VALUE 0x03 +/* Characteristic Appearance */ +#define HDLC_GAP_APPEARANCE 0x04 +#define HDLC_GAP_APPEARANCE_VALUE 0x05 + +/* Service Generic Attribute */ +#define HDLS_GATT 0x06 + +/* Service CHIP Service */ +#define HDLS_CHIP_SERVICE 0x07 + +/* Characteristic CHIP C1 */ +#define HDLC_CHIP_SERVICE_CHAR_C1 0x08 +#define HDLC_CHIP_SERVICE_CHAR_C1_VALUE 0x09 + +/* Characteristic CHIP C2 */ +#define HDLC_CHIP_SERVICE_CHAR_C2 0x0A +#define HDLC_CHIP_SERVICE_CHAR_C2_VALUE 0x0B + +/* Descriptor Client Characteristic Configuration */ +#define HDLD_CHIP_SERVICE_RX_CLIENT_CHAR_CONFIG 0x0C + +/* External Lookup Table Entry */ +typedef struct +{ + uint16_t handle; + uint16_t max_len; + uint16_t cur_len; + uint8_t * p_data; +} gatt_db_lookup_table_t; + +#define kMaxDeviceNameLength 32 + +/* External definitions */ +extern const uint8_t gatt_database[]; +extern const uint16_t gatt_database_len; +extern gatt_db_lookup_table_t app_gatt_db_ext_attr_tbl[]; +extern const uint16_t app_gatt_db_ext_attr_tbl_size; +extern uint8_t app_gap_device_name[kMaxDeviceNameLength]; +extern const uint16_t app_gap_device_name_len; +extern uint8_t app_gap_appearance[]; +extern const uint16_t app_gap_appearance_len; +extern uint8_t app_chip_service_char_tx_client_char_config[]; +extern const uint16_t app_chip_service_char_tx_client_char_config_len; + +#endif /* CYCFG_GATT_DB_H */ diff --git a/src/platform/CYW30739/cyw30739-chip-mbedtls-config.h b/src/platform/CYW30739/cyw30739-chip-mbedtls-config.h new file mode 100644 index 00000000000000..0a7a749871aa48 --- /dev/null +++ b/src/platform/CYW30739/cyw30739-chip-mbedtls-config.h @@ -0,0 +1,202 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +/** + * \def MBEDTLS_AES_ALT + * + * MBEDTLS__MODULE_NAME__ALT: Uncomment a macro to let mbed TLS use your + * alternate core implementation of a symmetric crypto, an arithmetic or hash + * module (e.g. platform specific assembly optimized implementations). Keep + * in mind that the function prototypes should remain the same. + * + * This replaces the whole module. If you only want to replace one of the + * functions, use one of the MBEDTLS__FUNCTION_NAME__ALT flags. + * + * Example: In case you uncomment MBEDTLS_AES_ALT, mbed TLS will no longer + * provide the "struct mbedtls_aes_context" definition and omit the base + * function declarations and implementations. "aes_alt.h" will be included from + * "aes.h" to include the new function definitions. + * + * Uncomment a macro to enable alternate implementation of the corresponding + * module. + * + * \warning MD2, MD4, MD5, ARC4, DES and SHA-1 are considered weak and their + * use constitutes a security risk. If possible, we recommend + * avoiding dependencies on them, and considering stronger message + * digests and ciphers instead. + * + */ +//#define MBEDTLS_AES_ALT +//#define MBEDTLS_ARC4_ALT +//#define MBEDTLS_ARIA_ALT +//#define MBEDTLS_BLOWFISH_ALT +//#define MBEDTLS_CAMELLIA_ALT +//#define MBEDTLS_CCM_ALT +//#define MBEDTLS_CHACHA20_ALT +//#define MBEDTLS_CHACHAPOLY_ALT +//#define MBEDTLS_CMAC_ALT +//#define MBEDTLS_DES_ALT +//#define MBEDTLS_DHM_ALT +//#define MBEDTLS_ECJPAKE_ALT +//#define MBEDTLS_GCM_ALT +//#define MBEDTLS_NIST_KW_ALT +//#define MBEDTLS_MD2_ALT +//#define MBEDTLS_MD4_ALT +//#define MBEDTLS_MD5_ALT +//#define MBEDTLS_POLY1305_ALT +//#define MBEDTLS_RIPEMD160_ALT +//#define MBEDTLS_RSA_ALT +//#define MBEDTLS_SHA1_ALT +//#define MBEDTLS_SHA256_ALT +//#define MBEDTLS_SHA512_ALT +//#define MBEDTLS_XTEA_ALT + +/** + * \def MBEDTLS_ERROR_STRERROR_DUMMY + * + * Enable a dummy error function to make use of mbedtls_strerror() in + * third party libraries easier when MBEDTLS_ERROR_C is disabled + * (no effect when MBEDTLS_ERROR_C is enabled). + * + * You can safely disable this if MBEDTLS_ERROR_C is enabled, or if you're + * not using mbedtls_strerror() or error_strerror() in your application. + * + * Disable if you run into name conflicts and want to really remove the + * mbedtls_strerror() + */ +#define MBEDTLS_ERROR_STRERROR_DUMMY + +/** + * \def MBEDTLS_BASE64_C + * + * Enable the Base64 module. + * + * Module: library/base64.c + * Caller: library/pem.c + * + * This module is required for PEM support (required by X.509). + */ +#define MBEDTLS_BASE64_C + +/** + * \def MBEDTLS_HKDF_C + * + * Enable the HKDF algorithm (RFC 5869). + * + * Module: library/hkdf.c + * Caller: + * + * Requires: MBEDTLS_MD_C + * + * This module adds support for the Hashed Message Authentication Code + * (HMAC)-based key derivation function (HKDF). + */ +#define MBEDTLS_HKDF_C + +/** + * \def MBEDTLS_OID_C + * + * Enable the OID database. + * + * Module: library/oid.c + * Caller: library/asn1write.c + * library/pkcs5.c + * library/pkparse.c + * library/pkwrite.c + * library/rsa.c + * library/x509.c + * library/x509_create.c + * library/x509_crl.c + * library/x509_crt.c + * library/x509_csr.c + * library/x509write_crt.c + * library/x509write_csr.c + * + * This modules translates between OIDs and internal values. + */ +#define MBEDTLS_OID_C + +/** + * \def MBEDTLS_PEM_WRITE_C + * + * Enable PEM encoding / writing. + * + * Module: library/pem.c + * Caller: library/pkwrite.c + * library/x509write_crt.c + * library/x509write_csr.c + * + * Requires: MBEDTLS_BASE64_C + * + * This modules adds support for encoding / writing PEM files. + */ +#define MBEDTLS_PEM_WRITE_C + +/** + * \def MBEDTLS_PK_WRITE_C + * + * Enable the generic public (asymetric) key writer. + * + * Module: library/pkwrite.c + * Caller: library/x509write.c + * + * Requires: MBEDTLS_PK_C + * + * Uncomment to enable generic public key write functions. + */ +#define MBEDTLS_PK_WRITE_C + +/** + * \def MBEDTLS_PKCS5_C + * + * Enable PKCS#5 functions. + * + * Module: library/pkcs5.c + * + * Requires: MBEDTLS_MD_C + * + * This module adds support for the PKCS#5 functions. + */ +#define MBEDTLS_PKCS5_C + +/** + * \def MBEDTLS_X509_CREATE_C + * + * Enable X.509 core for creating certificates. + * + * Module: library/x509_create.c + * + * Requires: MBEDTLS_BIGNUM_C, MBEDTLS_OID_C, MBEDTLS_PK_WRITE_C + * + * This module is the basis for creating X.509 certificates and CSRs. + */ +#define MBEDTLS_X509_CREATE_C + +/** + * \def MBEDTLS_X509_CSR_WRITE_C + * + * Enable creating X.509 Certificate Signing Requests (CSR). + * + * Module: library/x509_csr_write.c + * + * Requires: MBEDTLS_X509_CREATE_C + * + * This module is required for X.509 certificate request writing. + */ +#define MBEDTLS_X509_CSR_WRITE_C diff --git a/src/platform/CYW30739/wiced_button_manager.c b/src/platform/CYW30739/wiced_button_manager.c new file mode 100644 index 00000000000000..c17472fa5a022a --- /dev/null +++ b/src/platform/CYW30739/wiced_button_manager.c @@ -0,0 +1,691 @@ +/* + * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related + * materials ("Software") is owned by Cypress Semiconductor Corporation + * or one of its affiliates ("Cypress") and is protected by and subject to + * worldwide patent protection (United States and foreign), + * United States copyright laws and international treaty provisions. + * Therefore, you may use this Software only as provided in the license + * agreement accompanying the software package from which you + * obtained this Software ("EULA"). + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software + * source code solely for use in connection with Cypress's + * integrated circuit products. Any reproduction, modification, translation, + * compilation, or representation of this Software except as specified + * above is prohibited without the express written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer + * of such system or application assumes all risk of such use and in doing + * so agrees to indemnify Cypress against all liability. + */ +/** @file + * + * Button manager implements generic interface for button events and button type configurations. + * It exposes interface to configure platform button events (like click,long press) with user configurable timing. + */ +#include "wiced_button_manager.h" +#include "clock_timer.h" +#include "platform_button.h" +#include "string.h" +#include "wiced_bt_trace.h" +#ifdef CYW55572 +#include "wiced_memory.h" +#include "wiced_misc_rtos_utils.h" +#endif + +/****************************************************** + * Macros + ******************************************************/ + +#define BUTTON_TIMER_TIMEOUT (100) /*msec*/ + +/****************************************************** + * Constants + ******************************************************/ + +/****************************************************** + * Enumerations + ******************************************************/ + +/****************************************************** + * Type Definitions + ******************************************************/ +#if BTSTACK_VER >= 0x03000001 +#define TIMER_PARAM_TYPE WICED_TIMER_PARAM_TYPE +#endif + +#ifdef CYW55572 +#define BUTTON_EVENT_QUEUE_DEPTH 16 +#endif + +/****************************************************** + * Structures + ******************************************************/ +#ifdef CYW55572 +typedef struct +{ + button_manager_button_t * p_button; + button_manager_event_t event; +} button_event_defer_to_mpaf_t; +#endif + +/****************************************************** + * Function Declarations + ******************************************************/ +static void button_state_change_callback(platform_button_t id, wiced_bool_t new_state); +static wiced_result_t button_pressed_event_handler(void * arg); +static wiced_result_t button_released_event_handler(void * arg); +static wiced_result_t deferred_button_timer_handler(void * arg); + +static wiced_bool_t button_check_event_mask(button_manager_button_t * button, uint16_t new_event); +static void button_check_for_double_click(button_manager_button_t * button, button_manager_event_t * new_event); +static button_manager_event_t button_deduce_duration_event(button_manager_button_t * button, uint32_t current_interval); +static button_manager_button_t * get_button(platform_button_t id); +#ifdef CYW55572 +static void button_event_defer_to_mpaf(void * arg); +#endif + +/****************************************************** + * Variables Definitions + ******************************************************/ +static button_manager_t * button_manager; +#ifdef CYW55572 +static wiced_mutex_t * p_mutex_button_event; +static wiced_bt_buffer_q_t button_event_queue; +static wiced_bt_pool_t * p_button_event_pool = NULL; +#endif + +/****************************************************** + * Function Definitions + ******************************************************/ + +/* + * button_long_press_detect_timeout_handler + * + * Timeout handler for button long press detect timer. + * + * The execution duration of this utility is defined in BUTTON_TIMER_TIMEOUT. + */ +static void button_long_press_detect_timeout_handler(TIMER_PARAM_TYPE arg) +{ + button_manager_button_t * p_button = (button_manager_button_t *) arg; + + /* Check if button is under debouncing state. */ + if (p_button->debouncing) + { + return; + } + + /* Get current button state. */ + p_button->current_state = (button_manager_button_state_t) platform_button_get_value(p_button->configuration->button); + + if (p_button->current_state != BUTTON_STATE_HELD) + { + WICED_BT_TRACE("Err: Button %d is already released\n", p_button->configuration->button); + + if (wiced_is_timer_in_use(&p_button->long_press_timer)) + { + wiced_stop_timer(&p_button->long_press_timer); + } + + return; + } + /* Get current timestatmp. */ + p_button->timer_timestamp = clock_SystemTimeMicroseconds64(); + + deferred_button_timer_handler((void *) p_button); +} + +/* + * button_debounce_timeout_handler + * + * Timeout handler for button debounce timer. + */ +static void button_debounce_timeout_handler(TIMER_PARAM_TYPE arg) +{ + button_manager_button_t * p_button = (button_manager_button_t *) arg; + wiced_result_t result; + + // WICED_BT_TRACE("button_debounce_timeout_handler (%d, %d)\n", p_button->configuration->button, p_button->debounce_counter); + + if (p_button->debounce_counter > 0) + { + /* Reset the button debounce counter. */ + p_button->debounce_counter = 0; + + button_pressed_event_handler((void *) p_button); + } + else + { + if (wiced_is_timer_in_use(&p_button->long_press_timer)) + { + wiced_stop_timer(&p_button->long_press_timer); + } + } + + /* Reset the button debounce state. */ + p_button->debouncing = WICED_FALSE; +} + +/** + * The application should call this function to Initialize the Button Manager + */ +wiced_result_t __attribute__((weak)) +wiced_button_manager_init(button_manager_t * manager, const wiced_button_manager_configuration_t * configuration, + button_manager_button_t * buttons, uint32_t number_of_buttons) +{ + uint32_t a; + + memset(manager, 0, sizeof(*manager)); + + manager->configuration = configuration; + manager->buttons = buttons; + manager->number_of_buttons = number_of_buttons; + + button_manager = manager; + + for (a = 0; a < number_of_buttons; a++) + { + platform_button_init(buttons[a].configuration->button); + platform_button_enable(buttons[a].configuration->button); + buttons[a].current_state = BUTTON_STATE_RELEASED; + buttons[a].repeat = 0; + buttons[a].debounce_counter = 0; + buttons[a].debouncing = WICED_FALSE; + } + + platform_button_register_state_change_callback(button_state_change_callback); + + /* Initialize the timers used for detecting the long press event. */ + for (a = 0; a < number_of_buttons; a++) + { + wiced_init_timer(&buttons[a].long_press_timer, button_long_press_detect_timeout_handler, (TIMER_PARAM_TYPE) &buttons[a], + WICED_MILLI_SECONDS_PERIODIC_TIMER); + } + + /* Initialize the timers used for de-bounce. */ + for (a = 0; a < number_of_buttons; a++) + { + wiced_init_timer(&buttons[a].debounce_timer, button_debounce_timeout_handler, (TIMER_PARAM_TYPE) &buttons[a], + WICED_MILLI_SECONDS_TIMER); + } + +#ifdef CYW55572 + p_button_event_pool = + wiced_bt_create_pool("Button Event", sizeof(button_event_defer_to_mpaf_t), BUTTON_EVENT_QUEUE_DEPTH, NULL); + + if (!p_button_event_pool) + { + WICED_BT_TRACE("%s: Fail to create pool.\n", __FUNCTION__); + return WICED_ERROR; + } + + wiced_bt_init_q(&button_event_queue, NULL); + p_mutex_button_event = wiced_rtos_create_mutex(); + if (p_mutex_button_event == NULL) + { + WICED_BT_TRACE("%s: Fail to create mutex.\n", __FUNCTION__); + return WICED_ERROR; + } + + if (wiced_rtos_init_mutex(p_mutex_button_event) != WICED_SUCCESS) + { + WICED_BT_TRACE("%s: Fail to init. mutex.\n", __FUNCTION__); + return WICED_ERROR; + } +#endif + + return WICED_SUCCESS; +} + +/** + * The application should call this function to de-Initialize the Button Manager + * + * @param manager : Pointer to button manager to de-initialize. + * @return : result. + */ +wiced_result_t wiced_button_manager_deinit(button_manager_t * manager) +{ + uint32_t a; + for (a = 0; a < manager->number_of_buttons; a++) + { + platform_button_disable(manager->buttons[a].configuration->button); + platform_button_deinit(manager->buttons[a].configuration->button); + } + + for (a = 0; a < manager->number_of_buttons; a++) + { + if (WICED_TRUE == wiced_is_timer_in_use(&manager->buttons[a].debounce_timer)) + { + wiced_stop_timer(&manager->buttons[a].debounce_timer); + } + + wiced_deinit_timer(&manager->buttons[a].debounce_timer); + + if (WICED_TRUE == wiced_is_timer_in_use(&manager->buttons[a].long_press_timer)) + { + wiced_stop_timer(&manager->buttons[a].long_press_timer); + } + + wiced_deinit_timer(&manager->buttons[a].long_press_timer); + } + + button_manager = NULL; + return WICED_SUCCESS; +} + +/** + * Deferred Handler initiated from timer handler + * + * @param arg : Arguments passed by the timer framework to timer handler + * @return : result + */ +static wiced_result_t deferred_button_timer_handler(void * arg) +{ + button_manager_button_t * p_button = (button_manager_button_t *) arg; + uint64_t duration; // us + button_manager_event_t new_held_event = 0; + + /* Check current button state. */ + if (p_button->current_state == BUTTON_STATE_RELEASED) + { + return WICED_SUCCESS; + } + + /* Calculate the time difference. */ + duration = p_button->timer_timestamp - p_button->pressed_timestamp; // us + duration = duration / 1000; // ms + + /* deduce the event depending on the duration */ + new_held_event = button_deduce_duration_event(p_button, (uint32_t) duration); + + /* + * timers should be mainly interested in duration-specific events; + * let release_handler only report Click events to the application + */ + if (new_held_event == BUTTON_CLICK_EVENT) + { + return WICED_SUCCESS; + } + + if (button_check_event_mask(p_button, new_held_event)) + { + if (p_button->last_sent_event != BUTTON_HOLDING_EVENT) + { + if (p_button->last_sent_event != new_held_event) + { + button_manager->configuration->event_handler(p_button, new_held_event, p_button->current_state); + p_button->last_sent_event = new_held_event; + } + } + else + { + button_manager->configuration->event_handler(p_button, new_held_event, p_button->current_state); + p_button->last_sent_event = new_held_event; + } + } + + return WICED_SUCCESS; +} + +static void button_state_change_callback_pressed(button_manager_button_t * p_button) +{ + /* Check if the button is under de-bounce state. */ + if (p_button->debouncing) + { // under de-bounce state + p_button->debounce_counter++; + } + else + { + /* ignore pressed event for already pressed button*/ + if (p_button->current_state == BUTTON_STATE_HELD) + { + return; + } + + /* Get current timestamp for pressed event. */ + p_button->pressed_timestamp = clock_SystemTimeMicroseconds64(); + + /* Start the button debounce timer. */ + wiced_start_timer(&p_button->debounce_timer, (uint32_t) button_manager->configuration->debounce_duration); + + /* Start the long pressed event detect timer. */ + wiced_start_timer(&p_button->long_press_timer, BUTTON_TIMER_TIMEOUT); + + /* Update information. */ + p_button->debouncing = WICED_TRUE; + p_button->debounce_counter = 1; + } +} + +static void button_state_change_callback_released(button_manager_button_t * p_button) +{ + wiced_result_t result; + + /* Check if the button is under de-bounce state. */ + if (p_button->debouncing) + { // under de-bounce state + p_button->debounce_counter--; + } + else + { + /* ignore released event for already released button */ + if (p_button->current_state == BUTTON_STATE_RELEASED) + { + return; + } + + /* Get current timestamp for release event. */ + p_button->released_timestamp = clock_SystemTimeMicroseconds64(); + + /* Stop the long pressed event detect timer. */ + if (wiced_is_timer_in_use(&p_button->long_press_timer)) + { + wiced_stop_timer(&p_button->long_press_timer); + } + + button_released_event_handler((void *) p_button); + } +} + +/** + * Call back received when button state is changed. + * + * @param id : id of the button. + * @param new_state : new state of the button. + * @return void : no return value is expected. + */ +static void button_state_change_callback(platform_button_t id, wiced_bool_t new_state) +{ + button_manager_button_t * button = get_button(id); + +#if 0 + WICED_BT_TRACE("button_state_change_callback (button %d %s, %s, %d, %d)\n", + id, + button->current_state == BUTTON_STATE_HELD ? "H" : "R", + button->debouncing ? "D" : "-", + new_state, + button->debounce_counter); +#endif + + /* Check module state.*/ + if (button == NULL || button_manager == NULL) + { + WICED_BT_TRACE("button manager not initialized\n"); + return; + } + + if (new_state == WICED_TRUE) + { + button_state_change_callback_pressed(button); + } + else + { + button_state_change_callback_released(button); + } +} + +/** + * Event handler for button press event. + * + * @param arg : Arguments passed by the event manager + * @return void : No return value expected. + */ +static wiced_result_t button_pressed_event_handler(void * arg) +{ + button_manager_button_t * button = (button_manager_button_t *) arg; + + if (button->current_state == BUTTON_STATE_HELD) + { + return WICED_SUCCESS; + } + + /** Button is pressed; update the state so that timer-handlers know it */ + button->current_state = BUTTON_STATE_HELD; + + return WICED_SUCCESS; +} + +/** + * Event handler for button release event. + * + * @param arg : Arguments passed by the event manager + * @return void : No return value expected. + */ + +static wiced_result_t button_released_event_handler(void * arg) +{ + button_manager_button_t * button = (button_manager_button_t *) arg; + button_manager_event_t new_release_event = 0; + uint64_t duration; // us + + if (button->current_state == BUTTON_STATE_RELEASED) + { + return WICED_SUCCESS; + } + + button->current_state = BUTTON_STATE_RELEASED; + + /* Calculate the time difference. */ + duration = button->released_timestamp - button->pressed_timestamp; // us + duration = duration / 1000; // ms + + /** If release event comes before debounce duration, ignore it */ + if (duration <= button_manager->configuration->debounce_duration) + { + return WICED_SUCCESS; + } + + /** deduce the event depending on the duration */ + new_release_event = button_deduce_duration_event(button, (uint32_t) duration); + + /** Check if this Release is from 2nd click of a double-click event */ + button_check_for_double_click(button, &new_release_event); + + /** + * As the new state is Release and application has asked for this kind of event, + * send it irrespective of whether timer-hanlder + * had sent it previously + */ + if (button_check_event_mask(button, new_release_event)) + { +#ifndef CYW55572 + button_manager->configuration->event_handler(button, new_release_event, button->current_state); +#else + /* + * Button released event is handled by another thread, it needs defer to mpaf thread. + * Deferred_button_timer_handler(long press) is handled by timer which is in mpaf thread, + * it does not need defer. + */ + wiced_result_t result; + + wiced_rtos_lock_mutex(p_mutex_button_event); + button_event_defer_to_mpaf_t * p_data = (button_event_defer_to_mpaf_t *) wiced_bt_get_buffer_from_pool(p_button_event_pool); + + if (!p_data) + { + wiced_rtos_unlock_mutex(p_mutex_button_event); + WICED_BT_TRACE("Err: release event_handler no memory \n"); + goto DEFER_MPAF_ERROR; + } + + p_data->p_button = button; + p_data->event = new_release_event; + wiced_bt_enqueue(&button_event_queue, (wiced_bt_buffer_t *) p_data); + wiced_rtos_unlock_mutex(p_mutex_button_event); + result = wiced_rtos_defer_execution(WICED_RTOS_DEFER_TO_MPAF_THREAD, &button_event_defer_to_mpaf, NULL); + + if (result != WICED_SUCCESS) + { + wiced_rtos_lock_mutex(p_mutex_button_event); + button_event_defer_to_mpaf_t * p_buf = (button_event_defer_to_mpaf_t *) wiced_bt_dequeue(&button_event_queue); + wiced_bt_free_buffer(p_buf); + wiced_rtos_unlock_mutex(p_mutex_button_event); + WICED_BT_TRACE("Err: release event_handler wiced_rtos_defer_execution (%d)\n", result); + goto DEFER_MPAF_ERROR; + } +#endif + } + +#ifdef CYW55572 +DEFER_MPAF_ERROR: +#endif + + /** reset the button's last-sent so that a new press/held after this release is handled properly */ + button->last_sent_event = 0; + + return WICED_SUCCESS; +} + +/** + * Checks if the event is a double click event. + * + * @param button : button information. + * @param new_event : new event generated for the button. + * @return void : no return value is expected. + */ +static void button_check_for_double_click(button_manager_button_t * button, button_manager_event_t * new_event) +{ + if (!button_check_event_mask(button, BUTTON_DOUBLE_CLICK_EVENT) || *new_event != BUTTON_CLICK_EVENT) + { + return; + } + /** figure out the time-difference in two-releases */ + if ((button->released_timestamp - button->last_released_timestamp) <= button_manager->configuration->double_click_interval) + { + /** morph it as DOUBLE_CLICK */ + *new_event = BUTTON_DOUBLE_CLICK_EVENT; + } + + button->last_released_timestamp = button->released_timestamp; + + return; +} + +/** + * Checks the event mask for the button + * + * @param button : button information. + * @param new_event : new event generated for the button. + * @return wiced_bool_t : returns true/false based on the new event. + */ +static wiced_bool_t button_check_event_mask(button_manager_button_t * button, uint16_t new_event) +{ + if (!button) + { + return WICED_FALSE; + } + + return ((new_event & button->configuration->button_event_mask) ? WICED_TRUE : WICED_FALSE); +} + +/** + * Checks duration of the event + * + * @param button : the button that been triggered + * @param current_interval : current time interval + * @return button_manager_event_t : returns button manager event. + */ + +static button_manager_event_t button_deduce_duration_event(button_manager_button_t * button, uint32_t current_interval) +{ + button_manager_event_t new_event = 0; + uint32_t target_hold_interval; + + if (current_interval <= button_manager->configuration->debounce_duration) + { + return (button_manager_event_t) 0; + } + else if (current_interval > button_manager->configuration->debounce_duration && + current_interval <= button_manager->configuration->short_hold_duration) + { + return BUTTON_CLICK_EVENT; + } + else if (current_interval > button_manager->configuration->short_hold_duration && + current_interval <= button_manager->configuration->medium_hold_duration) + { + return BUTTON_SHORT_DURATION_EVENT; + } + else if (current_interval > button_manager->configuration->medium_hold_duration && + current_interval <= button_manager->configuration->long_hold_duration) + { + return BUTTON_MEDIUM_DURATION_EVENT; + } + else if (current_interval > button_manager->configuration->long_hold_duration && + current_interval <= button_manager->configuration->very_long_hold_duration) + { + button->repeat = 0; + return BUTTON_LONG_DURATION_EVENT; + } + else + { // current_interval > button_manager->configuration->very_long_hold_duration + if (button_manager->configuration->continuous_hold_detect == WICED_FALSE) + { + return BUTTON_VERY_LONG_DURATION_EVENT; + } + else + { + target_hold_interval = (button->repeat + 2) * button_manager->configuration->long_hold_duration; + + if (current_interval > target_hold_interval) + { + button->repeat++; + + return BUTTON_HOLDING_EVENT; + } + else + { + return (button_manager_event_t) 0; + } + } + } +} + +/** + * returns button based on the button id + * + * @param id : id of the buttonl + * @return button_manager_button_t : returns button. + */ + +static button_manager_button_t * get_button(platform_button_t id) +{ + uint8_t a; + + for (a = 0; a < button_manager->number_of_buttons; a++) + { + if (button_manager->buttons[a].configuration->button == id) + { + return &button_manager->buttons[a]; + } + } + + return NULL; +} + +#ifdef CYW55572 +static void button_event_defer_to_mpaf(void * arg) +{ + button_event_defer_to_mpaf_t button_event_buf; + + wiced_rtos_lock_mutex(p_mutex_button_event); + button_event_defer_to_mpaf_t * p_buf = (button_event_defer_to_mpaf_t *) wiced_bt_dequeue(&button_event_queue); + memcpy(&button_event_buf, p_buf, sizeof(button_event_defer_to_mpaf_t)); + wiced_bt_free_buffer(p_buf); + wiced_rtos_unlock_mutex(p_mutex_button_event); + button_manager->configuration->event_handler(button_event_buf.p_button, button_event_buf.event, + button_event_buf.p_button->current_state); +} +#endif diff --git a/src/platform/CYW30739/wiced_led_manager.c b/src/platform/CYW30739/wiced_led_manager.c new file mode 100644 index 00000000000000..7761c92f8fcbfa --- /dev/null +++ b/src/platform/CYW30739/wiced_led_manager.c @@ -0,0 +1,305 @@ +/* + * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related + * materials ("Software") is owned by Cypress Semiconductor Corporation + * or one of its affiliates ("Cypress") and is protected by and subject to + * worldwide patent protection (United States and foreign), + * United States copyright laws and international treaty provisions. + * Therefore, you may use this Software only as provided in the license + * agreement accompanying the software package from which you + * obtained this Software ("EULA"). + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software + * source code solely for use in connection with Cypress's + * integrated circuit products. Any reproduction, modification, translation, + * compilation, or representation of this Software except as specified + * above is prohibited without the express written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer + * of such system or application assumes all risk of such use and in doing + * so agrees to indemnify Cypress against all liability. + */ +/** @file + * + * This file provides implementation for the LED Manager library interface. + * LED Manager library provides API's to enable/disable, blink and set brightness of a LED. + */ + +#include "wiced_led_manager.h" +#include "platform_led.h" +#include "wiced_bt_dev.h" +#include "wiced_bt_trace.h" +#include "wiced_hal_gpio.h" +#include "wiced_platform.h" +#include "wiced_rtos.h" +#include "wiced_timer.h" +/****************************************************** + * Macros + ******************************************************/ +#define LED_FREQ (60) /*Hz*/ + +/****************************************************** + * Constants + ******************************************************/ + +/****************************************************** + * Enumerations + ******************************************************/ + +/****************************************************** + * Type Definitions + ******************************************************/ +extern platform_led_config_t platform_led_config[PLATFORM_LED_MAX]; +/****************************************************** + * Structures + ******************************************************/ + +/** + * @brief timer structure for LED manager + * + */ +typedef struct +{ + wiced_led_t led; + wiced_bool_t led_state; + uint32_t on_period; + uint32_t off_period; + wiced_timer_t timer; + wiced_bool_t is_init; +} led_manager_timer; + +/** + * @brief LED timer + * + */ +static led_manager_timer led_timer[PLATFORM_LED_MAX] = { 0 }; + +/****************************************************** + * Function Declarations + ******************************************************/ +void led_timer_function(uint32_t arg); + +/** + * Function to Initialize the LED Manager + * + * @param config : Configuration for the LED. + * @return : result. + */ +wiced_result_t wiced_led_manager_init(wiced_led_config_t * config) +{ + uint32_t i; + uint16_t bright; + // WICED_BT_TRACE("%s <<\n",__func__); + if (config == NULL) + return WICED_ERROR; + + if (config->led >= PLATFORM_LED_MAX) + { + WICED_BT_TRACE("Invalid LED for platform\n"); + return WICED_ERROR; + } + + /* check whether initialized */ + if (led_timer[config->led].is_init) + { + WICED_BT_TRACE("Error: Init LED(%d) multiple times\n", config->led); + return WICED_ERROR; + } + + bright = config->bright; + + if (bright > 99) + { + bright = 99; + } + + if (WICED_SUCCESS != platform_led_init(&platform_led_config[config->led], LED_FREQ, bright)) + return WICED_ERROR; + + led_timer[config->led].led = config->led; + + /* initialize timer */ + wiced_init_timer(&led_timer[config->led].timer, &led_timer_function, (uint32_t) config->led, + WICED_MILLI_SECONDS_PERIODIC_TIMER); + + led_timer[config->led].is_init = WICED_TRUE; + + return WICED_SUCCESS; +} + +/** + * Function to de-initialize the LED Manager + * + * @param void : No arguments. + * @return : result. + */ +wiced_result_t wiced_led_manager_deinit() +{ + uint32_t i; + /*if any led active we stop all of them*/ + for (i = 0; i < PLATFORM_LED_MAX; i++) + platform_led_deinit(&platform_led_config[i]); + + /* deinit timer */ + for (i = 0; i < PLATFORM_LED_MAX; i++) + { + if (led_timer[i].is_init) + { + wiced_deinit_timer(&led_timer[i].timer); + led_timer[i].is_init = WICED_FALSE; + } + } + + return WICED_SUCCESS; +} + +/** + * Enables the selected LED + * + * @param led : LED to be enabled. + * @return : result. + */ +wiced_result_t wiced_led_manager_enable_led(wiced_led_t led) +{ + wiced_result_t result; + if (led >= PLATFORM_LED_MAX) + { + WICED_BT_TRACE("Invalid LED for platform\n"); + return WICED_ERROR; + } + + result = platform_led_start(&platform_led_config[led]); + + return result; +} + +/** + * Disables the selected LED + * + * @param led : LED to be disabled. + * @return : result. + */ +wiced_result_t wiced_led_manager_disable_led(wiced_led_t led) +{ + wiced_result_t result; + if (led >= PLATFORM_LED_MAX) + { + WICED_BT_TRACE("Invalid LED for platform\n"); + return WICED_ERROR; + } + if (wiced_is_timer_in_use(&led_timer[led].timer)) + { + wiced_stop_timer(&led_timer[led].timer); + // wiced_deinit_timer(&led_timer[led].timer); + } + + result = platform_led_stop(&platform_led_config[led]); + + return result; +} + +/** + * Reconfigures the LED + * + * @param config : Configuration for the LED. + * @return : result. + */ +wiced_result_t wiced_led_manager_reconfig_led(wiced_led_config_t * config) +{ + uint16_t bright; + + if (config == NULL) + return WICED_ERROR; + + if (config->led >= PLATFORM_LED_MAX) + { + WICED_BT_TRACE("Invalid LED for platform\n"); + return WICED_ERROR; + } + + bright = config->bright; + + if (bright > 99) + { + bright = 99; + } + + return platform_led_reinit(&platform_led_config[config->led], LED_FREQ, bright); +} + +/** + * LED timer handler + * + * @param arg : arguments passed to the handler. + * @return : no return value expected. + */ +void led_timer_function(uint32_t arg) +{ + if (led_timer[arg].led_state == WICED_TRUE) + { + // WICED_BT_TRACE("Timer led %d stop\n",led_timer[arg].led); + platform_led_stop(&platform_led_config[led_timer[arg].led]); + led_timer[arg].led_state = WICED_FALSE; + } + else + { + platform_led_start(&platform_led_config[led_timer[arg].led]); + // WICED_BT_TRACE("Timer led %d start\n",led_timer[arg].led); + led_timer[arg].led_state = WICED_TRUE; + } + + wiced_stop_timer(&led_timer[arg].timer); + wiced_start_timer(&led_timer[arg].timer, + led_timer[arg].led_state == WICED_TRUE ? led_timer[arg].on_period : led_timer[arg].off_period); +} + +/** + * Function called to blink a LED + * + * @param led : LED to be blinked. + * @param on_period : on period (ms) + * @param off_period : off period (ms) + * @return : result. + */ + +wiced_result_t wiced_led_manager_blink_led(wiced_led_t led, uint32_t on_period, uint32_t off_period) +{ + // WICED_BT_TRACE("%s <<\n",__func__); + if (led >= PLATFORM_LED_MAX) + { + WICED_BT_TRACE("Invalid LED for platform\n"); + return WICED_ERROR; + } + + if (led_timer[led].is_init == WICED_FALSE) + { + WICED_BT_TRACE("LED(%d) un-init\n", led); + return WICED_ERROR; + } + + led_timer[led].on_period = on_period; + led_timer[led].off_period = off_period; + + if (WICED_SUCCESS != wiced_led_manager_enable_led(led)) + { + WICED_BT_TRACE("LED enable failed\n"); + return WICED_ERROR; + } + + led_timer[led].led_state = WICED_TRUE; + wiced_start_timer(&led_timer[led].timer, on_period); + // WICED_BT_TRACE("timer started\n"); + + return WICED_SUCCESS; +} diff --git a/src/platform/device.gni b/src/platform/device.gni index ff9ce0b0e43b5e..87b4c05ae05d4f 100755 --- a/src/platform/device.gni +++ b/src/platform/device.gni @@ -16,7 +16,7 @@ import("//build_overrides/chip.gni") import("${chip_root}/src/ble/ble.gni") declare_args() { - # Device platform layer: cc13x2_26x2, darwin, efr32, esp32, external, freertos, linux, nrfconnect, k32w0, qpg, tizen, none. + # Device platform layer: cc13x2_26x2, darwin, efr32, esp32, external, freertos, linux, nrfconnect, k32w0, qpg, tizen, cyw30739, none. chip_device_platform = "auto" chip_platform_target = "" @@ -114,6 +114,8 @@ if (chip_device_platform == "cc13x2_26x2") { _chip_device_layer = "android" } else if (chip_device_platform == "ameba") { _chip_device_layer = "Ameba" +} else if (chip_device_platform == "cyw30739") { + _chip_device_layer = "CYW30739" } if (chip_device_platform != "external") { @@ -156,5 +158,5 @@ assert( chip_device_platform == "k32w0" || chip_device_platform == "qpg" || chip_device_platform == "telink" || chip_device_platform == "mbed" || chip_device_platform == "p6" || chip_device_platform == "android" || - chip_device_platform == "ameba", + chip_device_platform == "ameba" || chip_device_platform == "cyw30739", "Please select a valid value for chip_device_platform") diff --git a/third_party/cyw30739_sdk/BUILD.gn b/third_party/cyw30739_sdk/BUILD.gn new file mode 100644 index 00000000000000..288d0135525ba7 --- /dev/null +++ b/third_party/cyw30739_sdk/BUILD.gn @@ -0,0 +1,45 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/chip.gni") +import("//build_overrides/mbedtls.gni") +import("//build_overrides/openthread.gni") + +import("${mbedtls_root}/mbedtls.gni") + +declare_args() { + # Build target to use for CYW30739 SDK. Use this to set global SDK defines. + cyw30739_sdk_target = "" +} + +assert(cyw30739_sdk_target != "", "cyw30739_sdk_target must be specified") + +group("cyw30739_sdk") { + public_deps = [ cyw30739_sdk_target ] +} + +config("mbedtls_cyw30739_config") { + defines = [ + "MBEDTLS_CONFIG_FILE=", + "MBEDTLS_USER_CONFIG_FILE=", + ] + + include_dirs = [ chip_root ] +} + +mbedtls_target("mbedtls") { + public_configs = [ ":mbedtls_cyw30739_config" ] + + public_deps = [ "${openthread_root}/src/core:libopenthread_core_headers" ] +} diff --git a/third_party/cyw30739_sdk/bsp_design_modus/cycfg_notices.h b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_notices.h new file mode 100644 index 00000000000000..3d64d129352038 --- /dev/null +++ b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_notices.h @@ -0,0 +1,41 @@ +/******************************************************************************* + * File Name: cycfg_notices.h + * + * Description: + * Contains warnings and errors that occurred while generating code for the + * design. + * This file was automatically generated and should not be modified. + * Tools Package 2.4.0.5880 + * 20739B2 CSP + * personalities 1.0.0.31 + * udd 3.0.0.1454 + * + ******************************************************************************** + * Copyright 2021 Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ********************************************************************************/ + +#if !defined(CYCFG_NOTICES_H) +#define CYCFG_NOTICES_H + +#ifdef CY_SUPPORTS_DEVICE_VALIDATION +#ifndef LBCA1KU1WA +#error \ + "Unexpected target MCU; expected LBCA1KU1WA. There may be an inconsistency between the *.modus file and the makefile target configuration device sets." +#endif +#endif + +#endif /* CYCFG_NOTICES_H */ diff --git a/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.c b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.c new file mode 100644 index 00000000000000..074229958e8113 --- /dev/null +++ b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.c @@ -0,0 +1,121 @@ +/******************************************************************************* + * File Name: cycfg_pins.c + * + * Description: + * Pin configuration + * This file was automatically generated and should not be modified. + * Tools Package 2.4.0.5880 + * 20739B2 CSP + * personalities 1.0.0.31 + * udd 3.0.0.1454 + * + ******************************************************************************** + * Copyright 2021 Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ********************************************************************************/ + +#include "cycfg_pins.h" + +#define BUTTON_USER_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_0].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP, .default_state = GPIO_PIN_OUTPUT_HIGH, \ + .button_pressed_value = GPIO_PIN_OUTPUT_LOW, \ + } +#define GPIO2_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_5].gpio_pin, \ + .config = GPIO_OUTPUT_ENABLE | GPIO_INPUT_DISABLE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define RX_PU_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_6].gpio_pin, \ + .config = GPIO_OUTPUT_ENABLE | GPIO_INPUT_DISABLE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define GPIO3_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_7].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP_DOWN_NONE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define TX_PU_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_8].gpio_pin, \ + .config = GPIO_OUTPUT_ENABLE | GPIO_INPUT_DISABLE, .default_state = GPIO_PIN_OUTPUT_HIGH, \ + } +#define GPIO4_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_9].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP_DOWN_NONE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define GPIO5_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_10].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP_DOWN_NONE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define DEBUG_UART_TXD_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_12].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP_DOWN_NONE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } +#define LED1_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_13].gpio_pin, \ + .config = GPIO_OUTPUT_ENABLE | GPIO_PULL_UP, .default_state = GPIO_PIN_OUTPUT_HIGH, \ + } +#define LED2_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_14].gpio_pin, \ + .config = GPIO_OUTPUT_ENABLE | GPIO_PULL_UP, .default_state = GPIO_PIN_OUTPUT_HIGH, \ + } +#define GPIO1_config \ + { \ + .gpio = (wiced_bt_gpio_numbers_t *) &platform_gpio_pins[PLATFORM_GPIO_3].gpio_pin, \ + .config = GPIO_INPUT_ENABLE | GPIO_PULL_UP_DOWN_NONE, .default_state = GPIO_PIN_OUTPUT_LOW, \ + } + +const wiced_platform_gpio_t platform_gpio_pins[] = { + [PLATFORM_GPIO_0] = { WICED_P00, WICED_GPIO }, + [PLATFORM_GPIO_1] = { WICED_P04, pwm_0_pwm_0_TRIGGER_IN }, + [PLATFORM_GPIO_2] = { WICED_P06, uart_1_rxd_0_TRIGGER_IN }, + [PLATFORM_GPIO_3] = { WICED_P07, WICED_GPIO }, + [PLATFORM_GPIO_4] = { WICED_P10, uart_1_txd_0_TRIGGER_IN }, + [PLATFORM_GPIO_5] = { WICED_P16, WICED_GPIO }, + [PLATFORM_GPIO_6] = { WICED_P17, WICED_GPIO }, + [PLATFORM_GPIO_7] = { WICED_P25, WICED_GPIO }, + [PLATFORM_GPIO_8] = { WICED_P26, WICED_GPIO }, + [PLATFORM_GPIO_9] = { WICED_P28, WICED_GPIO }, + [PLATFORM_GPIO_10] = { WICED_P29, WICED_GPIO }, + [PLATFORM_GPIO_11] = { WICED_P30, WICED_GPIO }, + [PLATFORM_GPIO_12] = { WICED_P33, WICED_GPIO }, + [PLATFORM_GPIO_13] = { WICED_P34, WICED_GPIO }, + [PLATFORM_GPIO_14] = { WICED_P38, WICED_GPIO }, +}; +const size_t platform_gpio_pin_count = (sizeof(platform_gpio_pins) / sizeof(wiced_platform_gpio_t)); +const wiced_platform_led_config_t platform_led[] = { + [WICED_PLATFORM_LED_1] = LED1_config, + [WICED_PLATFORM_LED_2] = LED2_config, +}; +const size_t led_count = (sizeof(platform_led) / sizeof(wiced_platform_led_config_t)); +const wiced_platform_button_config_t platform_button[] = { + [WICED_PLATFORM_BUTTON_1] = BUTTON_USER_config, +}; +const size_t button_count = (sizeof(platform_button) / sizeof(wiced_platform_button_config_t)); +const wiced_platform_gpio_config_t platform_gpio[] = { + [WICED_PLATFORM_GPIO_1] = GPIO1_config, [WICED_PLATFORM_GPIO_2] = GPIO2_config, [WICED_PLATFORM_GPIO_7] = RX_PU_config, + [WICED_PLATFORM_GPIO_3] = GPIO3_config, [WICED_PLATFORM_GPIO_6] = TX_PU_config, [WICED_PLATFORM_GPIO_4] = GPIO4_config, + [WICED_PLATFORM_GPIO_5] = GPIO5_config, [WICED_PLATFORM_GPIO_8] = DEBUG_UART_TXD_config, +}; +const size_t gpio_count = (sizeof(platform_gpio) / sizeof(wiced_platform_gpio_config_t)); diff --git a/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.h b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.h new file mode 100644 index 00000000000000..de4b9f30d2d897 --- /dev/null +++ b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_pins.h @@ -0,0 +1,92 @@ +/******************************************************************************* + * File Name: cycfg_pins.h + * + * Description: + * Pin configuration + * This file was automatically generated and should not be modified. + * Tools Package 2.4.0.5880 + * 20739B2 CSP + * personalities 1.0.0.31 + * udd 3.0.0.1454 + * + ******************************************************************************** + * Copyright 2021 Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ********************************************************************************/ + +#if !defined(CYCFG_PINS_H) +#define CYCFG_PINS_H + +#include "cycfg_notices.h" +#include "cycfg_routing.h" +#include "wiced_platform.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +#define bluetooth_0_ENABLED 1U +#define ioss_0_ENABLED 1U +#define WICED_GET_PIN_FOR_LED(idx) (*(platform_led[(idx)].gpio)) +#define WICED_GET_PIN_FOR_BUTTON(idx) (*(platform_button[(idx)].gpio)) +#define WICED_GET_PIN_FOR_IO(idx) (*(platform_gpio[(idx)].gpio)) +#define BUTTON_USER_ENABLED 1U +#define BUTTON_USER WICED_P00 +#define PUART_TXD_ENABLED 1U +#define PUART_TXD WICED_P10 +#define GPIO2_ENABLED 1U +#define GPIO2 WICED_P16 +#define RX_PU_ENABLED 1U +#define RX_PU WICED_P17 +#define GPIO3_ENABLED 1U +#define GPIO3 WICED_P25 +#define TX_PU_ENABLED 1U +#define TX_PU WICED_P26 +#define GPIO4_ENABLED 1U +#define GPIO4 WICED_P28 +#define GPIO5_ENABLED 1U +#define GPIO5 WICED_P29 +#define ioss_0_pin_30_ENABLED 1U +#define ioss_0_pin_30 WICED_P30 +#define DEBUG_UART_TXD_ENABLED 1U +#define DEBUG_UART_TXD WICED_P33 +#define LED1_ENABLED 1U +#define LED1 WICED_P34 +#define LED2_ENABLED 1U +#define LED2 WICED_P38 +#define PWM0_ENABLED 1U +#define PWM0 WICED_P04 +#define PUART_RXD_ENABLED 1U +#define PUART_RXD WICED_P06 +#define GPIO1_ENABLED 1U +#define GPIO1 WICED_P07 +#define pwm_0_ENABLED 1U +#define uart_1_ENABLED 1U + +extern const wiced_platform_gpio_t platform_gpio_pins[]; +extern const size_t platform_gpio_pin_count; +extern const wiced_platform_led_config_t platform_led[]; +extern const size_t led_count; +extern const wiced_platform_button_config_t platform_button[]; +extern const size_t button_count; +extern const wiced_platform_gpio_config_t platform_gpio[]; +extern const size_t gpio_count; + +#if defined(__cplusplus) +} +#endif + +#endif /* CYCFG_PINS_H */ diff --git a/third_party/cyw30739_sdk/bsp_design_modus/cycfg_routing.h b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_routing.h new file mode 100644 index 00000000000000..47e1e82b52b8cc --- /dev/null +++ b/third_party/cyw30739_sdk/bsp_design_modus/cycfg_routing.h @@ -0,0 +1,52 @@ +/******************************************************************************* + * File Name: cycfg_routing.h + * + * Description: + * Establishes all necessary connections between hardware elements. + * This file was automatically generated and should not be modified. + * Tools Package 2.4.0.5880 + * 20739B2 CSP + * personalities 1.0.0.31 + * udd 3.0.0.1454 + * + ******************************************************************************** + * Copyright 2021 Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ********************************************************************************/ + +#if !defined(CYCFG_ROUTING_H) +#define CYCFG_ROUTING_H + +#if defined(__cplusplus) +extern "C" { +#endif + +#include "cycfg_notices.h" +static inline void init_cycfg_routing(void) {} +#define init_cycfg_connectivity() init_cycfg_routing() +#define ioss_0_pin_4_AUX UNKNOWN +#define ioss_0_pin_6_AUX UNKNOWN +#define ioss_0_pin_10_AUX UNKNOWN + +#define pwm_0_pwm_0_TRIGGER_IN WICED_PWM0 +#define uart_1_rxd_0_TRIGGER_IN WICED_UART_2_RXD +#define uart_1_txd_0_TRIGGER_IN WICED_UART_2_TXD + +#if defined(__cplusplus) +} +#endif + +#endif /* CYCFG_ROUTING_H */ diff --git a/third_party/cyw30739_sdk/btp_reader.py b/third_party/cyw30739_sdk/btp_reader.py new file mode 100644 index 00000000000000..4a1de71dcd740e --- /dev/null +++ b/third_party/cyw30739_sdk/btp_reader.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python + +import json +import sys + + +def main(): + btp_file = sys.argv[1] + + items = {} + with open(btp_file) as btp: + for line in btp: + item = line.strip().split("=") + if len(item) == 2: + key = item[0].strip() + value = item[1].strip() + items[key] = value + + items["XIP_DS_OFFSET"] = "0x0001e000" + items["XIP_LEN"] = "0x{:08x}".format( + int(items["ConfigDS2Location"], 16) + - int(items["ConfigDSLocation"], 16) + - int(items["XIP_DS_OFFSET"], 16) + ) + + print(json.dumps(items)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/third_party/cyw30739_sdk/cyw30739_arm.gni b/third_party/cyw30739_sdk/cyw30739_arm.gni new file mode 100644 index 00000000000000..44b76f74c502a3 --- /dev/null +++ b/third_party/cyw30739_sdk/cyw30739_arm.gni @@ -0,0 +1,17 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +arm_cpu = "cortex-m4" +arm_float_abi = "hard" +arm_fpu = "fpv4-sp-d16" diff --git a/third_party/cyw30739_sdk/cyw30739_executable.gni b/third_party/cyw30739_sdk/cyw30739_executable.gni new file mode 100644 index 00000000000000..ca2e92fbd6ca3c --- /dev/null +++ b/third_party/cyw30739_sdk/cyw30739_executable.gni @@ -0,0 +1,81 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/build.gni") +import("//build_overrides/chip.gni") +import("//build_overrides/cyw30739_sdk.gni") + +import("${build_root}/toolchain/flashable_executable.gni") +import("${cyw30739_sdk_build_root}/cyw30739_sdk.gni") + +template("cyw30739_executable") { + if (!defined(invoker.output_dir)) { + invoker.output_dir = root_out_dir + } + + output_base_name = get_path_info(invoker.output_name, "name") + ldscript_file = "${root_build_dir}/${output_base_name}.ld" + flashable_target = "${target_name}.flashable" + + cyw30739_sdk_pre_build("${target_name}.pre_build") { + } + + cyw30739_sdk_post_build("${target_name}.post_build") { + executable_target = ":${flashable_target}.executable" + } + + group(target_name) { + deps = [ + ":${flashable_target}", + ":${target_name}.post_build", + ] + } + + # Copy flashing dependencies to the output directory so that the output + # is collectively self-contained; this allows flashing to work reliably + # even if the build and flashing steps take place on different machines + # or in different containers. + + flashing_runtime_target = target_name + ".flashing_runtime" + flashing_script_inputs = [ + "${chip_root}/scripts/flashing/cyw30739_firmware_utils.py", + "${chip_root}/scripts/flashing/firmware_utils.py", + ] + copy(flashing_runtime_target) { + sources = flashing_script_inputs + outputs = [ "${root_out_dir}/{{source_file_part}}" ] + } + + flashing_script_generator = + "${chip_root}/scripts/flashing/gen_flashing_script.py" + flashing_script_name = output_base_name + ".flash.py" + flashing_options = [ + "cyw30739", + "--sdk-scripts-dir", + rebase_path(invoker.cyw30739_sdk_scripts_dir), + "--sdk-tools-dir", + rebase_path(invoker.cyw30739_sdk_tools_dir), + ] + + flashable_executable(flashable_target) { + forward_variables_from(invoker, "*") + data_deps = [ ":${flashing_runtime_target}" ] + + deps += [ ":${target_name}.pre_build" ] + + inputs = [ ldscript_file ] + + ldflags = [ "-T" + rebase_path(ldscript_file, root_build_dir) ] + } +} diff --git a/third_party/cyw30739_sdk/cyw30739_sdk.gni b/third_party/cyw30739_sdk/cyw30739_sdk.gni new file mode 100644 index 00000000000000..c041b955bf0c5e --- /dev/null +++ b/third_party/cyw30739_sdk/cyw30739_sdk.gni @@ -0,0 +1,281 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/build.gni") +import("//build_overrides/cyw30739_sdk.gni") + +declare_args() { + # Location of the CYW30739 SDK. + cyw30739_sdk_root = "${cyw30739_sdk_build_root}/repos" + cyw30739_sdk_verbose = false +} + +assert(cyw30739_sdk_root != "", "cyw30739_sdk_root must be specified") + +cyw30739_sdk_bsp_design_modus_dir = + "${cyw30739_sdk_build_root}/bsp_design_modus" +cyw30739_sdk_baselib_dir = "${cyw30739_sdk_root}/30739A0/COMPONENT_30739A0" +cyw30739_sdk_board_dir = "${cyw30739_sdk_root}/CYW930739M2EVB-01" +cyw30739_sdk_include_dir = "${cyw30739_sdk_root}/btsdk-include" +cyw30739_sdk_patch_dir = + "${cyw30739_sdk_baselib_dir}/internal/30739A0/patches_CYW930739M2EVB_01" +cyw30739_sdk_platform_dir = "${cyw30739_sdk_baselib_dir}/platforms" +cyw30739_sdk_scripts_dir = "${cyw30739_sdk_baselib_dir}/make/scripts" +cyw30739_sdk_btp_file = "${cyw30739_sdk_platform_dir}/flash.btp" +cyw30739_sdk_patch_sym_file = "${cyw30739_sdk_patch_dir}/patch.sym" + +cyw30739_sdk_tools_dir = "${cyw30739_sdk_root}/btsdk-tools/" +if (host_os == "linux") { + cyw30739_sdk_tools_dir += "Linux64" +} else if (host_os == "mac") { + cyw30739_sdk_tools_dir += "OSX" +} else if (host_os == "win") { + cyw30739_sdk_tools_dir += "Windows" +} + +template("cyw30739_sdk_script") { + action(target_name) { + forward_variables_from(invoker, + [ + "deps", + "script_file_name", + "sources", + "outputs", + ]) + + script_file = "${cyw30739_sdk_scripts_dir}/${script_file_name}" + + script = "${build_root}/gn_run_binary.py" + + inputs = [ script_file ] + + args = [ + "bash", + "--norc", + "--noprofile", + rebase_path(script_file, root_build_dir), + "--scripts=" + rebase_path(cyw30739_sdk_scripts_dir, root_build_dir), + ] + if (defined(invoker.args)) { + args += invoker.args + } + if (cyw30739_sdk_verbose) { + args += [ "--verbose" ] + } + } +} + +# Defines a CYW30739 SDK build target. +# +# Parameters: +# cyw30739_sdk_root - The location of the erf32 SDK. +# sources - The sources files to build. +template("cyw30739_sdk") { + if (defined(invoker.cyw30739_sdk_root)) { + cyw30739_sdk_root = invoker.cyw30739_sdk_root + } + + assert(cyw30739_sdk_root != "", "cyw30739_sdk_root must be specified") + + config("${target_name}_config") { + include_dirs = [] + defines = [] + libs = [] + + if (is_debug) { + enable_debug = 1 + } else { + enable_debug = 0 + } + + if (defined(invoker.include_dirs)) { + include_dirs += invoker.include_dirs + } + + if (defined(invoker.defines)) { + defines += invoker.defines + } + + include_dirs += [ + "${cyw30739_sdk_baselib_dir}/WICED/common", + "${cyw30739_sdk_baselib_dir}/include", + "${cyw30739_sdk_baselib_dir}/include/hal", + "${cyw30739_sdk_baselib_dir}/include/internal", + "${cyw30739_sdk_baselib_dir}/include/stack", + "${cyw30739_sdk_baselib_dir}/platforms", + "${cyw30739_sdk_board_dir}", + "${cyw30739_sdk_build_root}/include", + "${cyw30739_sdk_include_dir}", + ] + + defines += [ + "CHIP_HAVE_CONFIG_H=1", + "CY_PLATFORM_SWDCK=WICED_P05", + "CY_PLATFORM_SWDIO=WICED_P03", + "ENABLE_DEBUG=${enable_debug}", + "SPAR_CRT_SETUP=spar_crt_setup", + ] + + cflags = [ "--specs=nano.specs" ] + if (is_debug) { + cflags += [ "-Wno-unused" ] + } + + ldflags = [ + "--specs=nano.specs", + "-Wl,--entry=spar_crt_setup", + "-Wl,--just-symbols=" + + rebase_path(cyw30739_sdk_patch_sym_file, root_build_dir), + "-nostartfiles", + ] + } + + cyw30739_sdk_script("${target_name}_gen_lib_installer") { + script_file_name = "bt_gen_lib_installer.bash" + + lib_installer_file = "${root_gen_dir}/lib_installer.c" + + args = [ "--out=" + rebase_path(lib_installer_file, root_build_dir) ] + + outputs = [ lib_installer_file ] + } + + source_set(target_name) { + sources = [ + "${cyw30739_sdk_baselib_dir}/WICED/common/spar_setup.c", + "${cyw30739_sdk_baselib_dir}/platforms/platform_entropy.c", + "${cyw30739_sdk_baselib_dir}/platforms/platform_nvram.h", + "${cyw30739_sdk_baselib_dir}/platforms/platform_retarget_lock.h", + "${cyw30739_sdk_baselib_dir}/platforms/platform_stdio.c", + "${cyw30739_sdk_baselib_dir}/platforms/wiced_platform.c", + "${cyw30739_sdk_baselib_dir}/platforms/wiced_platform_bt_cfg.c", + "${cyw30739_sdk_baselib_dir}/platforms/wiced_platform_bt_cfg.h", + "${cyw30739_sdk_baselib_dir}/platforms/wiced_platform_memory.c", + "${cyw30739_sdk_baselib_dir}/platforms/wiced_platform_os.c", + "${cyw30739_sdk_board_dir}/gpio_button.c", + "${cyw30739_sdk_board_dir}/gpio_button.h", + "${cyw30739_sdk_board_dir}/platform.c", + "${cyw30739_sdk_board_dir}/platform_button.c", + "${cyw30739_sdk_board_dir}/wiced_platform.h", + "${cyw30739_sdk_board_dir}/wiced_platform_memory.h", + "${cyw30739_sdk_board_dir}/wiced_platform_os.h", + "${cyw30739_sdk_bsp_design_modus_dir}/cycfg_notices.h", + "${cyw30739_sdk_bsp_design_modus_dir}/cycfg_pins.c", + "${cyw30739_sdk_bsp_design_modus_dir}/cycfg_pins.h", + "${cyw30739_sdk_bsp_design_modus_dir}/cycfg_routing.h", + "${cyw30739_sdk_build_root}/src/platform_retarget_lock.c", + ] + + sources += get_target_outputs(":${target_name}_gen_lib_installer") + + if (defined(invoker.sources)) { + sources += invoker.sources + } + + public_configs = [ ":${target_name}_config" ] + + deps = [ ":${target_name}_gen_lib_installer" ] + } +} + +template("cyw30739_sdk_pre_build") { + cyw30739_sdk_script(target_name) { + script_file_name = "bt_pre_build.bash" + + btp = exec_script("${cyw30739_sdk_build_root}/btp_reader.py", + [ rebase_path(cyw30739_sdk_btp_file, root_build_dir) ], + "json") + + linker_defines = [ + "FLASH0_BEGIN_ADDR=" + btp.DLConfigSSLocation, + "FLASH0_LENGTH=0x00100000", + "XIP_DS_OFFSET=" + btp.XIP_DS_OFFSET, + "XIP_LEN=" + btp.XIP_LEN, + "SRAM_BEGIN_ADDR=0x00200000", + "SRAM_LENGTH=0x00070000", + "AON_AREA_END=0x00284000", + "ISTATIC_BEGIN=0x500C00", + "ISTATIC_LEN=0x400", + "NUM_PATCH_ENTRIES=256", + "BTP=" + rebase_path(cyw30739_sdk_btp_file, root_build_dir), + ] + + args = [ + "--defs=" + string_join(" ", linker_defines), + "--ld=" + rebase_path(invoker.ldscript_file, root_build_dir), + "--patch=" + rebase_path(cyw30739_sdk_patch_sym_file, root_build_dir), + ] + + sources = [ cyw30739_sdk_btp_file ] + + outputs = [ invoker.ldscript_file ] + } +} + +template("cyw30739_sdk_post_build") { + copy("${target_name}_static_config") { + sources = [ "static_config.txt" ] + outputs = [ "${root_out_dir}/{{source_file_part}}" ] + } + + cyw30739_sdk_script(target_name) { + script_file_name = "bt_post_build.bash" + + cgs_list = [ + "${cyw30739_sdk_patch_dir}/patch.cgs", + "${cyw30739_sdk_platform_dir}/platform.cgs", + "${cyw30739_sdk_platform_dir}/platform_xip.cgs", + ] + + args = [ + "--cross=arm-none-eabi-", + "--tools=" + rebase_path(cyw30739_sdk_tools_dir, root_build_dir), + "--builddir=" + rebase_path(root_out_dir, root_build_dir), + "--elfname=${invoker.output_base_name}.elf", + "--appname=${invoker.output_base_name}", + "--appver=0x00000000", + "--hdf=" + rebase_path( + "${cyw30739_sdk_baselib_dir}/internal/30739A0/configdef30739A0.hdf", + root_build_dir), + "--entry=spar_crt_setup.entry", + "--cgslist=" + string_join(" ", rebase_path(cgs_list, root_build_dir)), + "--cgsargs=-O DLConfigBD_ADDRBase:default", + "--btp=" + rebase_path(cyw30739_sdk_btp_file, root_build_dir), + "--id=" + rebase_path("${cyw30739_sdk_platform_dir}/IDFILE.txt", + root_build_dir), + "--overridebaudfile=" + + rebase_path("${cyw30739_sdk_platform_dir}/BAUDRATEFILE.txt", + root_build_dir), + "--chip=30739A0", + "--minidriver=" + + rebase_path("${cyw30739_sdk_platform_dir}/minidriver.hex", + root_build_dir), + "--clflags=-NOHCIRESET", + "--extras=static_config_XIP_", + ] + + sources = [ + "${root_out_dir}/static_config.txt", + cyw30739_sdk_btp_file, + ] + sources += cgs_list + + outputs = [ "${root_out_dir}/${invoker.output_base_name}_download.hex" ] + + deps = [ + ":${target_name}_static_config", + invoker.executable_target, + ] + } +} diff --git a/third_party/cyw30739_sdk/include/auto_flags.h b/third_party/cyw30739_sdk/include/auto_flags.h new file mode 100644 index 00000000000000..6e09909a5840a1 --- /dev/null +++ b/third_party/cyw30739_sdk/include/auto_flags.h @@ -0,0 +1,7 @@ +#pragma once + +#define ALWAYS_ON_MEMORY_SUPPORT 1 +#define CPU_CM4 1 +#define DYNAMIC_MEMORY_NUM_POOLS 4 +#define MICRO_BCS 1 +#define TOOLCHAIN_wiced 1 diff --git a/third_party/cyw30739_sdk/include/wiced_button_manager.h b/third_party/cyw30739_sdk/include/wiced_button_manager.h new file mode 100644 index 00000000000000..6162dc95b830c8 --- /dev/null +++ b/third_party/cyw30739_sdk/include/wiced_button_manager.h @@ -0,0 +1,234 @@ +/* + * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related + * materials ("Software") is owned by Cypress Semiconductor Corporation + * or one of its affiliates ("Cypress") and is protected by and subject to + * worldwide patent protection (United States and foreign), + * United States copyright laws and international treaty provisions. + * Therefore, you may use this Software only as provided in the license + * agreement accompanying the software package from which you + * obtained this Software ("EULA"). + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software + * source code solely for use in connection with Cypress's + * integrated circuit products. Any reproduction, modification, translation, + * compilation, or representation of this Software except as specified + * above is prohibited without the express written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer + * of such system or application assumes all risk of such use and in doing + * so agrees to indemnify Cypress against all liability. + */ +/** @file + * + * Button manager defines generic interface for button events and button type configurations. + * It exposes interface to configure platform button events (like click,long press) with user configurable timing. + */ +#pragma once + +#include "platform_button.h" +#include "wiced.h" +#include "wiced_rtos.h" +#include "wiced_timer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************** + * Macros + ******************************************************/ + +/****************************************************** + * Constants + ******************************************************/ + +/****************************************************** + * Enumerations + ******************************************************/ + +/** + * @brief Button Manager events. + * + */ +typedef enum +{ + BUTTON_CLICK_EVENT = (1 << 0), /**< A click is a combination of press and release button events. Typically ~ < 200 ms. */ + BUTTON_SHORT_DURATION_EVENT = (1 << 1), /**< Short duration click event */ + BUTTON_MEDIUM_DURATION_EVENT = (1 << 2), /**< Medium duration click event */ + BUTTON_LONG_DURATION_EVENT = (1 << 3), /**< Long duration click event */ + BUTTON_VERY_LONG_DURATION_EVENT = (1 << 4), /**< Very long duration click event */ + BUTTON_DOUBLE_CLICK_EVENT = + (1 << 5), /**< A double click is a combination of two single clicks with some delay between them */ + BUTTON_HOLDING_EVENT = (1 << 6), /**< Button is holding over at least two long duration. */ +} button_manager_event_t; + +/** + * @brief Button states. + * + */ +typedef enum +{ + BUTTON_STATE_HELD = (0), /**< Button state held */ + BUTTON_STATE_RELEASED = (1), /**< Button state released */ +} button_manager_button_state_t; + +/****************************************************** + * Type Definitions + ******************************************************/ + +/** + * @brief Worker thread structure. + * + */ +typedef struct +{ + wiced_thread_t * thread; /**< Button event thread */ + wiced_queue_t * event_queue; /**< Button event queue */ +} button_worker_thread_t; + +/** + * @brief Button Event Message. + * + */ +typedef struct +{ + event_handler_t function; /**< Button event handler function */ + void * arg; /**< Button event message arguments to be passed */ +} button_event_message_t; +/****************************************************** + * Structures + ******************************************************/ + +/** + * @brief Button configuration. + * + */ +typedef struct +{ + platform_button_t button; /**< Logical Button-ids which map to physical buttons on the board */ + uint16_t button_event_mask; /**< Button event mask */ + uint32_t application_event; /**< Application event */ +} wiced_button_configuration_t; + +/** + * @brief Button Information. + * + */ +typedef struct +{ + const wiced_button_configuration_t * configuration; /**< Button configuration */ + button_manager_button_state_t current_state; /**< Button current state */ + button_manager_event_t last_sent_event; /**< Button last sent event */ + uint64_t pressed_timestamp; /**< Button pressed time stamp (us) */ + uint64_t released_timestamp; /**< Button released time stamp (us) */ + uint32_t last_released_timestamp; /**< Button last released time stamp */ + wiced_bool_t check_for_double_click; /**< Button double click event or not */ + uint32_t repeat; /**< Button holding counter */ + int32_t debounce_counter; /**< Button debounce counter */ + wiced_timer_t debounce_timer; /**< Button debounce timer */ + wiced_bool_t debouncing; /**< Button debounce state indication */ + wiced_timer_t long_press_timer; /**< Button long press detection timer */ + uint64_t timer_timestamp; /**< Button event time stamp (us) */ +} button_manager_button_t; + +/** + * Button event handler + * + * @param button Which button in the list has been pressed/released/held + * @param event What exact event the button is generating. + * @param state What exact state the button is in. + * + * @return void Library should not care whether app handled the button-events correctly or not. + * + */ +typedef void (*wiced_button_event_handler_t)(const button_manager_button_t * button, button_manager_event_t event, + button_manager_button_state_t state); + +/** + * @brief Button manager Configuration. + * + */ +typedef struct +{ + uint16_t short_hold_duration; /**< held for short duration (ms) */ + uint16_t medium_hold_duration; /**< held for medium duration (ms) */ + uint16_t long_hold_duration; /**< held for long duration (ms) */ + uint16_t very_long_hold_duration; /**< held for very long duration (ms) */ + uint16_t debounce_duration; /**< duration taken to de-bounce (ms) */ + uint16_t double_click_interval; /**< Time interval between two RELEASE events */ + wiced_bool_t continuous_hold_detect; /**< Flag to enable button holding detection.\n + If this is set to true, the BUTTON_VERY_LONG_DURATION_EVENT is disabled + and a BUTTON_HOLDING_EVENT will be triggered if a button is pressed over + twice the long_hold_duration.\n + The BUTTON_HOLDING_EVENT will continuous be sent every long_hold_duration + after the first BUTTON_HOLDING_EVENT event been sent. */ + wiced_button_event_handler_t event_handler; +} wiced_button_manager_configuration_t; + +/** + * @brief Button Manager structure. + * + */ +typedef struct +{ + const wiced_button_manager_configuration_t * configuration; /**< Button manager configuration */ + button_manager_button_t * buttons; /**< Button information */ + uint32_t number_of_buttons; /**< Number of buttons */ + wiced_button_event_handler_t button_callback; /**< Button event handler */ +} button_manager_t; + +/** + * Button's state change call back + * + * @param id Id of the button + * @param new_state What exact new state the button is going to. + * + * @return void Library should not care whether app handled the button-events correctly or not. + */ + +typedef void (*wiced_button_state_change_callback_t)(platform_button_t id, wiced_bool_t new_state); + +/****************************************************** + * Global Variables + ******************************************************/ + +/****************************************************** + * Function Declarations + ******************************************************/ + +/** + * The application should call this function to Initialize the Button Manager + * + * @param manager : pointer to button manager. + * @param configuration : Configuration for the button. + * @param buttons : Button information. + * @param number_of_buttons : Number of buttons. + * @return : result. + */ +extern wiced_result_t wiced_button_manager_init(button_manager_t * manager, + const wiced_button_manager_configuration_t * configuration, + button_manager_button_t * buttons, uint32_t number_of_buttons); + +/** + * The application should call this function to de-Initialize the Button Manager + * + * @param manager : Pointer to button manager to de-initialize. + * @return : result. + */ +extern wiced_result_t wiced_button_manager_deinit(button_manager_t * manager); + +#ifdef __cplusplus +} /* extern "C" */ +#endif diff --git a/third_party/cyw30739_sdk/include/wiced_led_manager.h b/third_party/cyw30739_sdk/include/wiced_led_manager.h new file mode 100644 index 00000000000000..c23f3672a2c9e5 --- /dev/null +++ b/third_party/cyw30739_sdk/include/wiced_led_manager.h @@ -0,0 +1,135 @@ +/* + * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related + * materials ("Software") is owned by Cypress Semiconductor Corporation + * or one of its affiliates ("Cypress") and is protected by and subject to + * worldwide patent protection (United States and foreign), + * United States copyright laws and international treaty provisions. + * Therefore, you may use this Software only as provided in the license + * agreement accompanying the software package from which you + * obtained this Software ("EULA"). + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software + * source code solely for use in connection with Cypress's + * integrated circuit products. Any reproduction, modification, translation, + * compilation, or representation of this Software except as specified + * above is prohibited without the express written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer + * of such system or application assumes all risk of such use and in doing + * so agrees to indemnify Cypress against all liability. + */ +/** @file + * + * This file provides definitions of the LED Manager library interface. + * LED Manager library provides API's to enable/disable, blink and set brightness of a LED. + */ +#pragma once + +#include "platform_led.h" +#include "wiced.h" +#include "wiced_rtos.h" +#include "wiced_timer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************** + * Macros + ******************************************************/ + +/****************************************************** + * Constants + ******************************************************/ + +/****************************************************** + * Enumerations + ******************************************************/ + +/** + * @brief Logical LED-id's which map to physical LED's on the board + * + */ +typedef platform_led_t wiced_led_t; + +/** + * @brief LED configuration + * + */ +typedef struct +{ + wiced_led_t led; /**< LED id */ + uint16_t bright; /**< in % from 1 to 100 */ +} wiced_led_config_t; +/****************************************************** + * Global Variables + ******************************************************/ + +/****************************************************** + * Function Declarations + ******************************************************/ + +/** + * Function to Initialize the LED Manager + * + * @param config : Configuration for the LED. + * @return : result. + */ +extern wiced_result_t wiced_led_manager_init(wiced_led_config_t * config); + +/** + * Function to de-initialize the LED Manager + * + * @param void : No arguments. + * @return : result. + */ +extern wiced_result_t wiced_led_manager_deinit(void); + +/** + * Enables the selected LED + * + * @param led : LED to be enabled. + * @return : result. + */ +extern wiced_result_t wiced_led_manager_enable_led(wiced_led_t led); + +/** + * Disables the selected LED + * + * @param led : LED to be disabled. + * @return : result. + */ +extern wiced_result_t wiced_led_manager_disable_led(wiced_led_t led); + +/** + * Reconfigures the LED + * + * @param config : Configuration for the LED. + * @return : result. + */ +extern wiced_result_t wiced_led_manager_reconfig_led(wiced_led_config_t * config); + +/** + * Function called to blink a LED + * + * @param led : LED to be blinked. + * @param on_period : on period (ms) + * @param off_period : off period (ms) + * @return : result. + */ +wiced_result_t wiced_led_manager_blink_led(wiced_led_t led, uint32_t on_period, uint32_t off_period); +#ifdef __cplusplus +} /* extern "C" */ +#endif diff --git a/third_party/cyw30739_sdk/repos/30739A0 b/third_party/cyw30739_sdk/repos/30739A0 new file mode 160000 index 00000000000000..c50b1e77f78d7a --- /dev/null +++ b/third_party/cyw30739_sdk/repos/30739A0 @@ -0,0 +1 @@ +Subproject commit c50b1e77f78d7a52f3677bae8cdb58dd1880a9fe diff --git a/third_party/cyw30739_sdk/repos/CYW930739M2EVB-01 b/third_party/cyw30739_sdk/repos/CYW930739M2EVB-01 new file mode 160000 index 00000000000000..92ec8873d34162 --- /dev/null +++ b/third_party/cyw30739_sdk/repos/CYW930739M2EVB-01 @@ -0,0 +1 @@ +Subproject commit 92ec8873d34162c9ce5aab23bb7b0275d8e21806 diff --git a/third_party/cyw30739_sdk/repos/btsdk-include b/third_party/cyw30739_sdk/repos/btsdk-include new file mode 160000 index 00000000000000..b1eb9b39f3ef86 --- /dev/null +++ b/third_party/cyw30739_sdk/repos/btsdk-include @@ -0,0 +1 @@ +Subproject commit b1eb9b39f3ef86211164c4d9825bee6316ac76c6 diff --git a/third_party/cyw30739_sdk/repos/btsdk-tools b/third_party/cyw30739_sdk/repos/btsdk-tools new file mode 160000 index 00000000000000..9743681eed4d3f --- /dev/null +++ b/third_party/cyw30739_sdk/repos/btsdk-tools @@ -0,0 +1 @@ +Subproject commit 9743681eed4d3f16a291bff6f8aee65349d1241b diff --git a/third_party/cyw30739_sdk/src/platform_retarget_lock.c b/third_party/cyw30739_sdk/src/platform_retarget_lock.c new file mode 100644 index 00000000000000..2de5160261a8c6 --- /dev/null +++ b/third_party/cyw30739_sdk/src/platform_retarget_lock.c @@ -0,0 +1,89 @@ +/* + * Copyright 2016-2021, Cypress Semiconductor Corporation (an Infineon company) or + * an affiliate of Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related + * materials ("Software") is owned by Cypress Semiconductor Corporation + * or one of its affiliates ("Cypress") and is protected by and subject to + * worldwide patent protection (United States and foreign), + * United States copyright laws and international treaty provisions. + * Therefore, you may use this Software only as provided in the license + * agreement accompanying the software package from which you + * obtained this Software ("EULA"). + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software + * source code solely for use in connection with Cypress's + * integrated circuit products. Any reproduction, modification, translation, + * compilation, or representation of this Software except as specified + * above is prohibited without the express written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer + * of such system or application assumes all risk of such use and in doing + * so agrees to indemnify Cypress against all liability. + */ + +#include +#include + +typedef struct __lock +{ + wiced_mutex_t * mutex; +} lock_t; + +static void lock_init_recursive(lock_t * lock); + +lock_t __lock___sinit_recursive_mutex; +lock_t __lock___sfp_recursive_mutex; +lock_t __lock___atexit_recursive_mutex; +lock_t __lock___malloc_recursive_mutex; +lock_t __lock___env_recursive_mutex; +lock_t __lock___tz_mutex; + +void platform_retarget_lock_init(void) +{ + lock_init_recursive(&__lock___sinit_recursive_mutex); + lock_init_recursive(&__lock___sfp_recursive_mutex); + lock_init_recursive(&__lock___malloc_recursive_mutex); +} + +void __retarget_lock_init_recursive(lock_t ** lock) {} + +void __retarget_lock_close_recursive(lock_t * lock) {} + +void __retarget_lock_acquire(lock_t * lock) {} + +void __retarget_lock_acquire_recursive(lock_t * lock) +{ + if (lock != NULL && lock->mutex != NULL) + { + wiced_rtos_lock_mutex(lock->mutex); + } +} + +void __retarget_lock_release(lock_t * lock) {} + +void __retarget_lock_release_recursive(lock_t * lock) +{ + if (lock != NULL && lock->mutex != NULL) + { + wiced_rtos_unlock_mutex(lock->mutex); + } +} + +void lock_init_recursive(lock_t * lock) +{ + lock->mutex = wiced_rtos_create_mutex(); + if (lock->mutex != NULL) + { + wiced_rtos_init_mutex(lock->mutex); + } +} diff --git a/third_party/openthread/ot-ifx b/third_party/openthread/ot-ifx new file mode 160000 index 00000000000000..da522560fbff49 --- /dev/null +++ b/third_party/openthread/ot-ifx @@ -0,0 +1 @@ +Subproject commit da522560fbff49f6b27bfef2139e898018c5f0f4 diff --git a/third_party/openthread/platforms/ifx/BUILD.gn b/third_party/openthread/platforms/ifx/BUILD.gn new file mode 100644 index 00000000000000..ce9f1e1b89fab2 --- /dev/null +++ b/third_party/openthread/platforms/ifx/BUILD.gn @@ -0,0 +1,53 @@ +# Copyright (c) 2020 Project CHIP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build_overrides/chip.gni") +import("//build_overrides/cyw30739_sdk.gni") +import("//build_overrides/openthread.gni") + +openthread_ifx_root = "${chip_root}/third_party/openthread/ot-ifx" +openthread_ifx_mcu = "cyw30739" + +config("openthread_ifx_config") { + include_dirs = [ "${openthread_ifx_root}/src/${openthread_ifx_mcu}" ] +} + +source_set("openthread_core_config_ifx") { + sources = [ "${openthread_ifx_root}/src/${openthread_ifx_mcu}/openthread-core-cyw30739-config.h" ] + + public_deps = [ "${cyw30739_sdk_build_root}:cyw30739_sdk" ] + + public_configs = [ ":openthread_ifx_config" ] +} + +source_set("libopenthread-ifx") { + sources = [ + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/alarm.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/entropy.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/logging.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/misc.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/radio.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/settings.c", + "${openthread_ifx_root}/src/${openthread_ifx_mcu}/system.c", + ] + + defines = [ "CHIP_HAVE_CONFIG_H=1" ] + + public_deps = [ + ":openthread_core_config_ifx", + "${openthread_root}/src/core:libopenthread_core_headers", + "..:libopenthread-platform", + "..:libopenthread-platform-utils", + ] +}