From 189fba67347042c6ad79641d70e43e1dec388392 Mon Sep 17 00:00:00 2001 From: "Anu Biradar (local)" Date: Wed, 25 May 2022 16:38:14 -0500 Subject: [PATCH 01/12] inital cc32xx commit Co-authored-by: Suyash Jain Co-authored-by: Kobi Leibovitch --- .gitmodules | 5 + .vscode/settings.json | 6 +- config/cc32xx/toolchain/BUILD.gn | 25 + examples/lock-app/cc32xx/.gn | 28 + examples/lock-app/cc32xx/BUILD.gn | 119 ++++ examples/lock-app/cc32xx/README.md | 188 ++++++ examples/lock-app/cc32xx/args.gni | 43 ++ examples/lock-app/cc32xx/build_overrides | 1 + examples/lock-app/cc32xx/chip.syscfg | 74 +++ examples/lock-app/cc32xx/main/AppConfig.h | 34 ++ examples/lock-app/cc32xx/main/AppEvent.h | 60 ++ examples/lock-app/cc32xx/main/AppTask.cpp | 310 ++++++++++ examples/lock-app/cc32xx/main/AppTask.h | 78 +++ .../lock-app/cc32xx/main/BoltLockManager.cpp | 205 +++++++ .../lock-app/cc32xx/main/BoltLockManager.h | 87 +++ .../cc32xx/main/CXXExceptionStubs.cpp | 80 +++ .../lock-app/cc32xx/main/ZclCallbacks.cpp | 56 ++ .../lock-app/cc32xx/main/cc32xxWifiInit.c | 244 ++++++++ .../lock-app/cc32xx/main/debug_settings.h | 42 ++ .../cc32xx/main/include/CHIPProjectConfig.h | 151 +++++ examples/lock-app/cc32xx/main/main.cpp | 78 +++ examples/lock-app/cc32xx/main/wifi_settings.h | 103 ++++ .../cc32xx/third_party/connectedhomeip | 1 + examples/platform/cc32xx/BUILD.gn | 20 + examples/platform/cc32xx/args.gni | 24 + scripts/checkout_submodules.py | 1 + src/lwip/BUILD.gn | 15 +- src/lwip/cc32xx/arch/cc.h | 98 +++ src/lwip/cc32xx/arch/perf.h | 35 ++ src/lwip/cc32xx/lwipopts.h | 175 ++++++ src/lwip/cc32xx/lwippools.h | 2 + src/platform/BUILD.gn | 7 + src/platform/cc32xx/BUILD.gn | 63 ++ src/platform/cc32xx/BlePlatformConfig.h | 31 + src/platform/cc32xx/CC32XXConfig.cpp | 559 ++++++++++++++++++ src/platform/cc32xx/CC32XXConfig.h | 101 ++++ .../cc32xx/CHIPDevicePlatformConfig.h | 47 ++ src/platform/cc32xx/CHIPDevicePlatformEvent.h | 46 ++ src/platform/cc32xx/CHIPPlatformConfig.h | 89 +++ .../cc32xx/ConfigurationManagerImpl.cpp | 201 +++++++ .../cc32xx/ConfigurationManagerImpl.h | 73 +++ .../cc32xx/ConnectivityManagerImpl.cpp | 240 ++++++++ src/platform/cc32xx/ConnectivityManagerImpl.h | 168 ++++++ .../DeviceNetworkProvisioningDelegateImpl.cpp | 44 ++ .../DeviceNetworkProvisioningDelegateImpl.h | 43 ++ .../cc32xx/DiagnosticDataProviderImpl.cpp | 60 ++ .../cc32xx/DiagnosticDataProviderImpl.h | 46 ++ src/platform/cc32xx/FreeRTOSConfig.h | 212 +++++++ src/platform/cc32xx/InetPlatformConfig.h | 51 ++ .../cc32xx/KeyValueStoreManagerImpl.cpp | 66 +++ .../cc32xx/KeyValueStoreManagerImpl.h | 75 +++ src/platform/cc32xx/Logging.cpp | 151 +++++ src/platform/cc32xx/PlatformManagerImpl.cpp | 92 +++ src/platform/cc32xx/PlatformManagerImpl.h | 90 +++ src/platform/cc32xx/README.md | 85 +++ .../cc32xx/SoftwareUpdateManagerImpl.cpp | 41 ++ src/platform/cc32xx/SystemPlatformConfig.h | 54 ++ src/platform/cc32xx/args.gni | 36 ++ src/platform/cc32xx/cc32xx-mbedtls-config.h | 99 ++++ src/platform/device.gni | 17 +- third_party/ti_simplelink_sdk/BUILD.gn | 71 ++- third_party/ti_simplelink_sdk/repo_cc32xx | 1 + .../ti_simplelink_arm_platform_config.gni | 7 + .../ti_simplelink_sdk/ti_simplelink_board.gni | 14 + .../ti_simplelink_executable.gni | 36 +- .../ti_simplelink_sdk/ti_simplelink_sdk.gni | 198 ++++--- 66 files changed, 5488 insertions(+), 114 deletions(-) create mode 100755 config/cc32xx/toolchain/BUILD.gn create mode 100644 examples/lock-app/cc32xx/.gn create mode 100755 examples/lock-app/cc32xx/BUILD.gn create mode 100644 examples/lock-app/cc32xx/README.md create mode 100755 examples/lock-app/cc32xx/args.gni create mode 120000 examples/lock-app/cc32xx/build_overrides create mode 100755 examples/lock-app/cc32xx/chip.syscfg create mode 100755 examples/lock-app/cc32xx/main/AppConfig.h create mode 100755 examples/lock-app/cc32xx/main/AppEvent.h create mode 100755 examples/lock-app/cc32xx/main/AppTask.cpp create mode 100755 examples/lock-app/cc32xx/main/AppTask.h create mode 100755 examples/lock-app/cc32xx/main/BoltLockManager.cpp create mode 100755 examples/lock-app/cc32xx/main/BoltLockManager.h create mode 100755 examples/lock-app/cc32xx/main/CXXExceptionStubs.cpp create mode 100755 examples/lock-app/cc32xx/main/ZclCallbacks.cpp create mode 100755 examples/lock-app/cc32xx/main/cc32xxWifiInit.c create mode 100644 examples/lock-app/cc32xx/main/debug_settings.h create mode 100755 examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h create mode 100755 examples/lock-app/cc32xx/main/main.cpp create mode 100644 examples/lock-app/cc32xx/main/wifi_settings.h create mode 120000 examples/lock-app/cc32xx/third_party/connectedhomeip create mode 100644 examples/platform/cc32xx/BUILD.gn create mode 100644 examples/platform/cc32xx/args.gni create mode 100644 src/lwip/cc32xx/arch/cc.h create mode 100644 src/lwip/cc32xx/arch/perf.h create mode 100644 src/lwip/cc32xx/lwipopts.h create mode 100644 src/lwip/cc32xx/lwippools.h create mode 100644 src/platform/cc32xx/BUILD.gn create mode 100644 src/platform/cc32xx/BlePlatformConfig.h create mode 100644 src/platform/cc32xx/CC32XXConfig.cpp create mode 100644 src/platform/cc32xx/CC32XXConfig.h create mode 100644 src/platform/cc32xx/CHIPDevicePlatformConfig.h create mode 100644 src/platform/cc32xx/CHIPDevicePlatformEvent.h create mode 100644 src/platform/cc32xx/CHIPPlatformConfig.h create mode 100644 src/platform/cc32xx/ConfigurationManagerImpl.cpp create mode 100644 src/platform/cc32xx/ConfigurationManagerImpl.h create mode 100644 src/platform/cc32xx/ConnectivityManagerImpl.cpp create mode 100644 src/platform/cc32xx/ConnectivityManagerImpl.h create mode 100644 src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.cpp create mode 100644 src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.h create mode 100644 src/platform/cc32xx/DiagnosticDataProviderImpl.cpp create mode 100644 src/platform/cc32xx/DiagnosticDataProviderImpl.h create mode 100755 src/platform/cc32xx/FreeRTOSConfig.h create mode 100644 src/platform/cc32xx/InetPlatformConfig.h create mode 100644 src/platform/cc32xx/KeyValueStoreManagerImpl.cpp create mode 100644 src/platform/cc32xx/KeyValueStoreManagerImpl.h create mode 100644 src/platform/cc32xx/Logging.cpp create mode 100644 src/platform/cc32xx/PlatformManagerImpl.cpp create mode 100644 src/platform/cc32xx/PlatformManagerImpl.h create mode 100644 src/platform/cc32xx/README.md create mode 100644 src/platform/cc32xx/SoftwareUpdateManagerImpl.cpp create mode 100644 src/platform/cc32xx/SystemPlatformConfig.h create mode 100755 src/platform/cc32xx/args.gni create mode 100755 src/platform/cc32xx/cc32xx-mbedtls-config.h create mode 160000 third_party/ti_simplelink_sdk/repo_cc32xx diff --git a/.gitmodules b/.gitmodules index 7a0b2154efd292..a83efa514d8e39 100644 --- a/.gitmodules +++ b/.gitmodules @@ -247,3 +247,8 @@ url = https://github.com/bouffalolab/bl_iot_sdk_matter.git branch = bl602_release platforms = bl602 +[submodule "third_party/ti_simplelink_sdk/repo_cc32xx"] + path = third_party/ti_simplelink_sdk/repo_cc32xx + url = https://github.com/TexasInstruments/cc32xx_open_sdk.git + branch = main + platform = cc32xx diff --git a/.vscode/settings.json b/.vscode/settings.json index 6ff631080c2465..ac8bf404d4ec08 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -111,7 +111,11 @@ "ratio": "cpp", "set": "cpp", "stack": "cpp", - "regex": "cpp" + "regex": "cpp", + "condition_variable": "cpp", + "numeric": "cpp", + "random": "cpp", + "thread": "cpp" }, "files.eol": "\n", "editor.formatOnSave": true, diff --git a/config/cc32xx/toolchain/BUILD.gn b/config/cc32xx/toolchain/BUILD.gn new file mode 100755 index 00000000000000..ce58d55fd7dad4 --- /dev/null +++ b/config/cc32xx/toolchain/BUILD.gn @@ -0,0 +1,25 @@ +# 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_root}/toolchain/arm_gcc/arm_toolchain.gni") + +arm_toolchain("cc32xx_lock_app") { + toolchain_args = { + current_os = "freertos" + import("${chip_root}/examples/lock-app/cc32xx/args.gni") + } +} \ No newline at end of file diff --git a/examples/lock-app/cc32xx/.gn b/examples/lock-app/cc32xx/.gn new file mode 100644 index 00000000000000..3d48789e30ab3d --- /dev/null +++ b/examples/lock-app/cc32xx/.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 = "freertos" + + import("//args.gni") +} diff --git a/examples/lock-app/cc32xx/BUILD.gn b/examples/lock-app/cc32xx/BUILD.gn new file mode 100755 index 00000000000000..e1c9993d9cdb50 --- /dev/null +++ b/examples/lock-app/cc32xx/BUILD.gn @@ -0,0 +1,119 @@ +# 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/ti_simplelink_sdk.gni") +import("${build_root}/config/defaults.gni") +import("${chip_root}/src/platform/device.gni") +import("${ti_simplelink_sdk_build_root}/ti_simplelink_executable.gni") +import("${ti_simplelink_sdk_build_root}/ti_simplelink_sdk.gni") + +assert(current_os == "freertos") + +project_dir = "${chip_root}/examples/lock-app/cc32xx" + +ti_simplelink_sdk("sdk") { + include_dirs = [ "${project_dir}/main/include" ] + + defines = [] + if (is_debug) { + defines += [ "BUILD_RELEASE=0" ] + } else { + defines += [ "BUILD_RELEASE=1" ] + } +} + +ti_sysconfig("sysconfig") { + sources = [ "${project_dir}/chip.syscfg" ] + outputs = [ + "ti_drivers_net_wifi_config.c", + "ti_net_config.c", + "ti_drivers_config.c", + "ti_drivers_config.h", + ] +} + +source_set("lock_app_sdk") { + defines = [] + + configs -= [ "${build_root}/config/compiler:std_default" ] + configs += [ ":sdk_posix_config" ] + + sources = [ + "${chip_root}/src/platform/cc32xx/Logging.cpp", + "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/lwip_if.c", + "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/utils_if.c", + "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/wifi_if.c", + "${project_dir}/main/main.cpp", + "${project_dir}/main/cc32xxWifiInit.c", + ] + + include_dirs = [ + "${project_dir}/include", + "${project_dir}/main", + "${project_dir}/main/ifmod/", + "${chip_root}/src/platform/cc32xx", + ] + + deps = [ + ":sdk", + ":sysconfig", + "${chip_root}/examples/lock-app/lock-common", + "${chip_root}/src/lib", + "${chip_root}/src/setup_payload", + ] +} + +ti_simplelink_executable("lock_app") { + defines = [] + output_name = "chip-${ti_simplelink_board}-lock-example.out" + + sources = [ + "${project_dir}/main/AppTask.cpp", + "${project_dir}/main/BoltLockManager.cpp", + "${project_dir}/main/CXXExceptionStubs.cpp", + "${project_dir}/main/ZclCallbacks.cpp", + ] + + deps = [ + ":lock_app_sdk", + ":sdk", + ":sysconfig", + "${chip_root}/examples/lock-app/lock-common", + "${chip_root}/src/lib", + "${chip_root}/src/setup_payload", + ] + + include_dirs = [ + "${project_dir}", + "${project_dir}/main", + ] + + cflags = [ + "-Wno-implicit-fallthrough", + "-Wno-sign-compare", + "-Wconversion", + ] + + output_dir = root_out_dir +} + +group("cc32xx") { + deps = [ ":lock_app" ] +} + +group("default") { + deps = [ ":cc32xx" ] +} diff --git a/examples/lock-app/cc32xx/README.md b/examples/lock-app/cc32xx/README.md new file mode 100644 index 00000000000000..6c61b9c2726077 --- /dev/null +++ b/examples/lock-app/cc32xx/README.md @@ -0,0 +1,188 @@ +# Matter CC32XXSF Lock Example Application + +An example application showing the use of [Matter][matter] on the Texas +Instruments CC32XX family of Wireless MCUs. + +--- + +- [Matter CC32XX Lock Example Application](#matter-cc32xx-lock-example-application) + - [Introduction](#introduction) + - [Device UI](#device-ui) + - [Building](#building) + - [Preparation](#preparation) + - [Compilation](#compilation) + - [Programming](#programming) + - [Code Composer Studio](#code-composer-studio) + - [UniFlash](#uniflash) + - [Viewing Logging Output](#viewing-logging-output) + - [Running the Example](#running-the-example) + - [Provisioning](#provisioning) + - [Matter Remote Commands](#matter-remote-commands) + - [TI Support](#ti-support) + +--- + +## Introduction + +![CC3235SF_LAUNCHXL](doc/images/cc3235sf_launchxl.jpg) + +The CC32XX lock example application provides a working demonstration of a +connected door lock device. This uses the open-source CHIP implementation and +the Texas Instruments SimpleLink™ Wi-Fi® CC32xx software development kit. + +By default this example targets the [CC3235SF_LAUNCHXL][cc3235sf_launchxl] +LaunchPad, but the example application is enabled to build on the whole +`CC32XX` family of MCUs. + +The lock example is intended to serve both as a means to explore the workings +of CHIP, as well as a template for creating real products based on the Texas +Instruments devices. + +## Device UI + +This example application has a simple User Interface to depict the state of the +door lock and to control the state. The user LEDs on the LaunchPad are set on +when the lock is locked, and are set off when unlocked. The LEDs will flash +when in the transition state between locked and unlocked. The user buttons are +used for requesting lock and unlock of the door lock. The left button (`BTN-1`) +is used to enable provsioning (provisioning is enabled as "oneshot" by default. +The right button (`BTN-2`) us used to toggle the "Lock" state. + +## Building + +### Preparation + +Some initial setup is necessary for preparing the build environment. This +section will need to be done when migrating to new versions of the SDK. This +guide assumes that the environment is linux based, and recommends Ubuntu 20.04. + +- Download and install [SysConfig][sysconfig] ([recommended version][sysconfig_recommended]). This can be done simply with the following commands. + + ``` + $ cd ~ + $ wget https://software-dl.ti.com/ccs/esd/sysconfig/sysconfig-1.12.1_2446-setup.run + $ chmod +x sysconfig-1.12.1_2446-setup.run + $ ./sysconfig-1.12.1_2446-setup.run + ``` + +- Run the bootstrap script to setup the build environment. + + ``` + $ cd ~/connectedhomeip + $ source ./scripts/bootstrap.sh + ``` + +### Compilation + +It is necessary to activate the environment in every new shell. Then run GN and +Ninja to build the executable. + +- Activate the build environment with the repository activate script. + + ``` + $ cd ~/connectedhomeip + $ source ./scripts/activate.sh + ``` + +- Run the build to produce a default executable. By default on Linux the + Sysconfig is located in a `ti` folder in the user's + home directory, and you must provide the absolute path for it. For example + `/home/username/ti/sysconfig_1.12.1`. On Windows the default directory is + `C:\ti`. Take note of this install path, as it will be used in the next + step. + + + ``` + $ cd ~/connectedhomeip/examples/lock-app/cc32xx + $ gn gen out/debug --args="ti_sysconfig_root=\"$HOME/ti/sysconfig_1.12.1\"" + $ ninja -C out/debug + ``` + + +## Programming + +Loading the built image onto a LaunchPad is supported through Code Composer Studio (CCS). +Code Composer Studio can be used to load the image and debug the source code. +UniFlash programming (bin) image is not generated currently. + +### Code Composer Studio + +Programming with CCS will allow for a full debug environment within the IDE. +This is accomplished by creating a target connection to the XDS110 debugger and +starting a project-less debug session. The CCS IDE will attempt to find the +source files on the local machine based on the debug information embedded within +the ELF. CCS may prompt you to find the source code if the image was built on +another machine or the source code is located in a different location than is +recorded within the ELF. + +Download and install [Code Composer Studio][ccs]. + +First open CCS and create a new workspace. + +Create a target connection (sometimes called the CCXML) for your target SoC and +debugger as described in the [Manual Method][ccs_manual_method] section of the +CCS User's Guide. + +Next initiate a project-less debug session as described in the [Manual +Launch][ccs_manual_launch] section of the CCS User's Guide. + +CCS should switch to the debug view described in the [After +Launch][ccs_after_launch] section of the User's Guide. The SoC core will likely +be disconnected and symbols will not be loaded. Connect to the core as described +in the [Debug View][ccs_debug_view] section of the User's Guide. Once the core +is connected, use the `Load` button on the toolbar to load the ELF image. + +Note that the default configuration of the CCXML uses 2-wire cJTAG instead of +the full 4-wire JTAG connection to match the default jumper configuration of the +LaunchPad. + + +## Viewing Logging Output + +By default the log output will be sent to the Application/User UART. Open a +terminal emulator to that port to see the output with the following options: + +| Parameter | Value | +| ------------ | -------- | +| Speed (baud) | `115200` | +| Data bits | `8` | +| Stop bits | `1` | +| Parity | `None` | +| Flow control | `None` | + +## Running the Example + +### Provisioning + +The first step to bring the Matter device onto the network is to provision it. +The example accomplishes this through the proprietary SimpleLink provisioning method (AP or Smart Config) using the SimpleLink Starter Pro mobile app. +Once the device is connected to the local AP, commissioning can be triggered using "OnNetwork" configuration. + +#### Bluetooth LE Provisioning +BLE provisioning is not supported currently. + +### CHIP tool changes needed for Wi-Fi example +The timeout for the CHIP tool needs to be increased from 10 to 15 seconds. This can be done in chip::System::Clock::Timeout GetWaitDuration in connectedhomeip/examples/chip-tool/commands/clusters/ModelCommand.h + +## TI Support + +For technical support, please consider creating a post on TI's [E2E forum][e2e]. +Additionally, we welcome any feedback. + +[matter]: https://github.com/project-chip/connectedhomeip +[ccs]: https://www.ti.com/tool/CCSTUDIO +[ccs_after_launch]: + https://software-dl.ti.com/ccs/esd/documents/users_guide/ccs_debug-main.html?configuration#after-launch +[ccs_debug_view]: + https://software-dl.ti.com/ccs/esd/documents/users_guide/ccs_debug-main.html?configuration#debug-view +[ccs_manual_launch]: + https://software-dl.ti.com/ccs/esd/documents/users_guide/ccs_debug-main.html?configuration#manual-launch +[ccs_manual_method]: + https://software-dl.ti.com/ccs/esd/documents/users_guide/ccs_debug-main.html?configuration#manual-method +[cc3235sf_launchxl]: https://www.ti.com/tool/LAUNCHXL-CC3235SF +[e2e]: https://e2e.ti.com/support/wireless-connectivity/wi-fi-group/wifi/f/wi-fi-forum +[sysconfig]: https://www.ti.com/tool/SYSCONFIG +[sysconfig_recommended]: + https://software-dl.ti.com/ccs/esd/sysconfig/sysconfig-1.12.1_2446-setup.run +[ti_cc32xx_matter_request]: https://www.ti.com/tool/download/SIMPLELINK-CC32XX-SDK/5.30.00.08 +[uniflash]: https://www.ti.com/tool/download/UNIFLASH diff --git a/examples/lock-app/cc32xx/args.gni b/examples/lock-app/cc32xx/args.gni new file mode 100755 index 00000000000000..8d5afa600c2067 --- /dev/null +++ b/examples/lock-app/cc32xx/args.gni @@ -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. + +import("//build_overrides/chip.gni") +import("${chip_root}/examples/platform/cc32xx/args.gni") + +ti_simplelink_sdk_target = get_label_info(":sdk", "label_no_toolchain") +ti_simplelink_sysconfig_target = + get_label_info(":sysconfig", "label_no_toolchain") + +ti_simplelink_board = "CC3235SF_LAUNCHXL" + +# use -Os instead of -Og +#is_debug = false + +# disable BLE for now +chip_config_network_layer_ble = false +chip_bypass_rendezvous = false + +#enable logging +chip_progress_logging = true +chip_detail_logging = true +chip_automation_logging = true + +## Disable lock tracking, since our FreeRTOS configuration does not set +# INCLUDE_xSemaphoreGetMutexHolder +chip_stack_lock_tracking = "none" + +matter_device_vid = "0xFFF1" +matter_device_pid = "0x8006" +matter_software_ver = "0x0001" +matter_software_ver_str = "1.0d1" diff --git a/examples/lock-app/cc32xx/build_overrides b/examples/lock-app/cc32xx/build_overrides new file mode 120000 index 00000000000000..194ee0b812dc3d --- /dev/null +++ b/examples/lock-app/cc32xx/build_overrides @@ -0,0 +1 @@ +../../build_overrides/ \ No newline at end of file diff --git a/examples/lock-app/cc32xx/chip.syscfg b/examples/lock-app/cc32xx/chip.syscfg new file mode 100755 index 00000000000000..14fd3130d99c4f --- /dev/null +++ b/examples/lock-app/cc32xx/chip.syscfg @@ -0,0 +1,74 @@ +/** + * Import the modules used in this configuration. + */ +const Display = scripting.addModule("/ti/display/Display"); +const Display1 = Display.addInstance(); +const SPI = scripting.addModule("/ti/drivers/SPI"); +const Button = scripting.addModule("/ti/drivers/apps/Button"); +const Button1 = Button.addInstance(); +const Button2 = Button.addInstance(); +const LED = scripting.addModule("/ti/drivers/apps/LED"); +const LED1 = LED.addInstance(); +const LED2 = LED.addInstance(); +const LED3 = LED.addInstance(); +const SimpleLinkWifi = scripting.addModule("/ti/drivers/net/wifi/SimpleLinkWifi"); +const net_utils = scripting.addModule("/ti/drivers/net/wifi/net_utils", {}, false); +const net_utils1 = net_utils.addInstance(); +const HTTPClient = scripting.addModule("/ti/net/HTTPClient", {}, false); +const HTTPClient1 = HTTPClient.addInstance(); +const MQTT = scripting.addModule("/ti/net/MQTT", {}, false); +const MQTT1 = MQTT.addInstance(); +const SNTP = scripting.addModule("/ti/net/SNTP"); +const SlNet = scripting.addModule("/ti/net/SlNet", {}, false); +const SlNet1 = SlNet.addInstance(); + +/** + * Write custom configuration values to the imported modules. + */ +Display1.$name = "CONFIG_Display_0"; +Display1.$hardware = system.deviceData.board.components.XDS110UART; +Display1.uart.$name = "CONFIG_UART2_0"; + +const Power = scripting.addModule("/ti/drivers/Power", {}, false); +Power.parkPins.$name = "ti_drivers_power_PowerCC32XXPins0"; + +Button1.$hardware = system.deviceData.board.components.SW2; +Button1.$name = "CONFIG_BTN_LEFT"; + +Button2.$hardware = system.deviceData.board.components.SW3; +Button2.$name = "CONFIG_BTN_RIGHT"; + +LED1.$hardware = system.deviceData.board.components.LED_BLUE; +LED1.$name = "CONFIG_LED_BLUE"; + +LED2.$hardware = system.deviceData.board.components.LED_GREEN; +LED2.$name = "CONFIG_LED_GREEN"; + +LED3.$hardware = system.deviceData.board.components.LED_RED; +LED3.dimmable = true; +LED3.$name = "CONFIG_LED_RED"; + +net_utils1.$name = "CONFIG_NET_UTILS_0"; + +HTTPClient1.$name = "CONFIG_HTTPCLIENT_0"; + +MQTT1.$name = "CONFIG_MQTT_0"; + +SlNet1.$name = "CONFIG_SLNET_0"; + +/** + * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future + * version of the tool will not impact the pinmux you originally saw. These lines can be completely deleted in order to + * re-solve from scratch. + */ +Display1.uart.uart.$suggestSolution = "UART1"; +Display1.uart.uart.txPin.$suggestSolution = "ball.55"; +Display1.uart.uart.txDmaChannel.$suggestSolution = "UDMA_CH11"; +Display1.uart.uart.rxPin.$suggestSolution = "ball.57"; +Display1.uart.uart.rxDmaChannel.$suggestSolution = "UDMA_CH10"; +Button1.button.$suggestSolution = "boosterpack.3"; +Button2.button.$suggestSolution = "boosterpack.11"; +LED1.ledPin.$suggestSolution = "boosterpack.29"; +LED2.ledPin.$suggestSolution = "boosterpack.10"; +LED3.pwmPin.timer.$suggestSolution = "Timer3"; +LED3.pwmPin.timer.pwmPin.$suggestSolution = "boosterpack.9"; diff --git a/examples/lock-app/cc32xx/main/AppConfig.h b/examples/lock-app/cc32xx/main/AppConfig.h new file mode 100755 index 00000000000000..8eeee7fb61e3ed --- /dev/null +++ b/examples/lock-app/cc32xx/main/AppConfig.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +#ifndef APP_CONFIG_H +#define APP_CONFIG_H + +// Logging +#ifdef __cplusplus +extern "C" { +#endif + +int cc32xxLogInit(void); +void cc32xxLog(const char * aFormat, ...); +#define PLAT_LOG(...) cc32xxLog(__VA_ARGS__); + +#ifdef __cplusplus +} +#endif +#endif // APP_CONFIG_H diff --git a/examples/lock-app/cc32xx/main/AppEvent.h b/examples/lock-app/cc32xx/main/AppEvent.h new file mode 100755 index 00000000000000..ad9e93ee3ad1a5 --- /dev/null +++ b/examples/lock-app/cc32xx/main/AppEvent.h @@ -0,0 +1,60 @@ +/* + * + * 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. + */ + +#ifndef APP_EVENT_H +#define APP_EVENT_H + +struct AppEvent; +typedef void (*EventHandler)(AppEvent *); + +struct AppEvent +{ + enum AppEventType + { + kEventType_None = 0, + kEventType_ButtonLeft, + kEventType_ButtonRight, + kEventType_AppEvent, + }; + + enum AppEventButtonType + { + kAppEventButtonType_None = 0, + kAppEventButtonType_Clicked, + kAppEventButtonType_LongClicked, + }; + + enum AppEventType Type; + + union + { + struct + { + enum AppEventButtonType Type; + } ButtonEvent; + + struct + { + void * Context; + } BoltLockEvent; + }; + + EventHandler Handler; +}; + +#endif // APP_EVENT_H diff --git a/examples/lock-app/cc32xx/main/AppTask.cpp b/examples/lock-app/cc32xx/main/AppTask.cpp new file mode 100755 index 00000000000000..265670ea54b702 --- /dev/null +++ b/examples/lock-app/cc32xx/main/AppTask.cpp @@ -0,0 +1,310 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * 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 "AppTask.h" +#include "AppConfig.h" +#include "AppEvent.h" +#include +#include +#include +#include + +#include "FreeRTOS.h" + +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include + +/* syscfg */ +#include + +extern "C" +{ +extern int WiFi_init(); +extern void DisplayBanner(); +} + +/* Application Version and Naming*/ + + +#define APP_TASK_STACK_SIZE (4096) +#define APP_TASK_PRIORITY 4 +#define APP_EVENT_QUEUE_SIZE 10 + +// Added the below three for DNS Server Initialization +using namespace ::chip; +using namespace ::chip::Inet; +using namespace ::chip::System; + +using namespace ::chip::Credentials; +using namespace ::chip::DeviceLayer; + +static TaskHandle_t sAppTaskHandle; +static QueueHandle_t sAppEventQueue; + +extern LED_Handle gLedGreenHandle, gLedRedHandle; +static Button_Handle gButtonRightHandle; + + +AppTask AppTask::sAppTask; + +int AppTask::StartAppTask() +{ + int ret = 0; + + sAppEventQueue = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(AppEvent)); + if (sAppEventQueue == NULL) + { + PLAT_LOG("Failed to allocate app event queue"); + while (1) + ; + } + + // Start App task. + if (xTaskCreate(AppTaskMain, "APP", APP_TASK_STACK_SIZE / sizeof(StackType_t), NULL, APP_TASK_PRIORITY, &sAppTaskHandle) != + pdPASS) + { + PLAT_LOG("Failed to create app task"); + while (1) + ; + } + return ret; +} + + + +int AppTask::Init() +{ + CHIP_ERROR ret; + LED_Params ledParams; + Button_Params buttonParams; + + cc32xxLogInit(); + + /* Initial Terminal, and print Application name */ + DisplayBanner(); + + // Init Chip memory management before the stack + PLAT_LOG("Initialize Memory"); + chip::Platform::MemoryInit(); + + // Initialize LEDs + PLAT_LOG("Initialize LEDs"); + LED_init(); + + LED_Params_init(&ledParams); // default PWM LED + gLedRedHandle = LED_open(CONFIG_LED_RED, &ledParams); + LED_setOff(gLedRedHandle); + + LED_Params_init(&ledParams); // default PWM LED + gLedGreenHandle = LED_open(CONFIG_LED_GREEN, &ledParams); + LED_setOff(gLedGreenHandle); + + // Initialize buttons + PLAT_LOG("Initialize buttons"); + Button_init(); + + Button_Params_init(&buttonParams); + buttonParams.buttonEventMask = Button_EV_CLICKED | Button_EV_LONGCLICKED; + buttonParams.longPressDuration = 1000U; // ms + gButtonRightHandle = Button_open(CONFIG_BTN_RIGHT, &buttonParams); + Button_setCallback(gButtonRightHandle, ButtonRightEventHandler); + + PLAT_LOG("Initialize Wi-Fi"); + WiFi_init(); + + PLAT_LOG("Initialize CHIP stack"); + ret = PlatformMgr().InitChipStack(); + if (ret != CHIP_NO_ERROR) + { + PLAT_LOG("PlatformMgr().InitChipStack() failed"); + while (1) + ; + } + PLAT_LOG("Start Event Loop Task"); + ret = PlatformMgr().StartEventLoopTask(); + if (ret != CHIP_NO_ERROR) + { + PLAT_LOG("PlatformMgr().StartEventLoopTask() failed"); + while (1) + ; + } + + // Init ZCL Data Model and start server + PLAT_LOG("Initialize Server"); + static chip::CommonCaseDeviceServerInitParams initParams; + (void) initParams.InitializeStaticResourcesBeforeServerInit(); + chip::Server::GetInstance().Init(initParams); + + // Initialize device attestation config + PLAT_LOG("Initialize device attestation config"); + SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider()); + + // Initialize BoltLock module + PLAT_LOG("Initialize BoltLock"); + BoltLockMgr().Init(); + + BoltLockMgr().SetCallbacks(ActionInitiated, ActionCompleted); + + ConfigurationMgr().LogDeviceConfig(); + + // QR code will be used with CHIP Tool + PLAT_LOG("Print Onboarding Codes"); + PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kOnNetwork)); + + PLAT_LOG("Start DNS Server"); + chip::app::DnssdServer::Instance().StartServer(); + + return 0; +} + +void AppTask::AppTaskMain(void * pvParameter) +{ + AppEvent event; + + sAppTask.Init(); + + while (1) + { + /* Task pend until we have stuff to do */ + if (xQueueReceive(sAppEventQueue, &event, portMAX_DELAY) == pdTRUE) + { + sAppTask.DispatchEvent(&event); + } + } +} + +void AppTask::ButtonRightEventHandler(Button_Handle handle, Button_EventMask events) +{ + AppEvent event; + event.Type = AppEvent::kEventType_ButtonRight; + + if (events & Button_EV_CLICKED) + { + event.ButtonEvent.Type = AppEvent::kAppEventButtonType_Clicked; + } + else if (events & Button_EV_LONGCLICKED) + { + event.ButtonEvent.Type = AppEvent::kAppEventButtonType_LongClicked; + } + // button callbacks are in ISR context + if (xQueueSendFromISR(sAppEventQueue, &event, NULL) != pdPASS) + { + /* Failed to post the message */ + } +} + +void AppTask::PostEvent(const AppEvent * aEvent) +{ + if (xQueueSend(sAppEventQueue, aEvent, 0) != pdPASS) + { + /* Failed to post the message */ + } +} + +void AppTask::ActionInitiated(BoltLockManager::Action_t aAction, int32_t aActor) +{ + // If the action has been initiated by the lock, update the bolt lock trait + // and start flashing the LEDs rapidly to indicate action initiation. + if (aAction == BoltLockManager::LOCK_ACTION) + { + PLAT_LOG("Lock initiated"); + ; // TODO + } + else if (aAction == BoltLockManager::UNLOCK_ACTION) + { + PLAT_LOG("Unlock initiated"); + ; // TODO + } + + LED_setOn(gLedGreenHandle, LED_BRIGHTNESS_MAX); + LED_startBlinking(gLedGreenHandle, 50 /* ms */, LED_BLINK_FOREVER); + LED_setOn(gLedRedHandle, LED_BRIGHTNESS_MAX); + LED_startBlinking(gLedRedHandle, 110 /* ms */, LED_BLINK_FOREVER); +} + +void AppTask::ActionCompleted(BoltLockManager::Action_t aAction) +{ + uint8_t state; + + // if the action has been completed by the lock, update the bolt lock trait. + // Turn on the lock LED if in a LOCKED state OR + // Turn off the lock LED if in an UNLOCKED state. + if (aAction == BoltLockManager::LOCK_ACTION) + { + PLAT_LOG("Lock completed"); + LED_stopBlinking(gLedGreenHandle); + LED_setOn(gLedGreenHandle, LED_BRIGHTNESS_MAX); + LED_stopBlinking(gLedRedHandle); + LED_setOn(gLedRedHandle, LED_BRIGHTNESS_MAX); + state = 1; + } + else if (aAction == BoltLockManager::UNLOCK_ACTION) + { + PLAT_LOG("Unlock completed"); + LED_stopBlinking(gLedGreenHandle); + LED_setOff(gLedGreenHandle); + LED_stopBlinking(gLedRedHandle); + LED_setOff(gLedRedHandle); + state = 0; + } + emberAfWriteAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, &state, + ZCL_BOOLEAN_ATTRIBUTE_TYPE); +} + +void AppTask::DispatchEvent(AppEvent * aEvent) +{ + switch (aEvent->Type) + { + case AppEvent::kEventType_ButtonRight: + if (AppEvent::kAppEventButtonType_Clicked == aEvent->ButtonEvent.Type) + { + if (BoltLockMgr().IsUnlocked()) + { + BoltLockMgr().InitiateAction(0, BoltLockManager::LOCK_ACTION); + } + else + { + BoltLockMgr().InitiateAction(0, BoltLockManager::UNLOCK_ACTION); + } + } + break; + + case AppEvent::kEventType_AppEvent: + if (NULL != aEvent->Handler) + { + // XXX: assume our caller isn't trying to crash our stack + aEvent->Handler(aEvent); + } + break; + + case AppEvent::kEventType_None: + default: + break; + } +} diff --git a/examples/lock-app/cc32xx/main/AppTask.h b/examples/lock-app/cc32xx/main/AppTask.h new file mode 100755 index 00000000000000..803db3d30c9362 --- /dev/null +++ b/examples/lock-app/cc32xx/main/AppTask.h @@ -0,0 +1,78 @@ +/* + * 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. + */ + +#ifndef APP_TASK_H +#define APP_TASK_H + +#include +#include + +#include "FreeRTOS.h" +#include "semphr.h" +#include "task.h" + +#include "AppEvent.h" +#include "BoltLockManager.h" + +#include + +class AppTask +{ +public: + int StartAppTask(); + static void AppTaskMain(void * pvParameter); + + void PostLockActionRequest(int32_t aActor, BoltLockManager::Action_t aAction); + void PostEvent(const AppEvent * event); + +private: + friend AppTask & GetAppTask(void); + + int Init(); + + // should this be done by BoltLock Manager? I don't want to unravel this spaghetti quite yet + static void ActionInitiated(BoltLockManager::Action_t aAction, int32_t aActor); + static void ActionCompleted(BoltLockManager::Action_t aAction); + + void DispatchEvent(AppEvent * event); + + static void ButtonRightEventHandler(Button_Handle handle, Button_EventMask events); + + static void TimerEventHandler(void * p_context); + + enum Function_t + { + kFunction_NoneSelected = 0, + kFunction_SoftwareUpdate = 0, + kFunction_FactoryReset, + + kFunction_Invalid + } Function; + + Function_t mFunction; + bool mFunctionTimerActive; + + static AppTask sAppTask; +}; + +inline AppTask & GetAppTask(void) +{ + return AppTask::sAppTask; +} + +#endif // APP_TASK_H diff --git a/examples/lock-app/cc32xx/main/BoltLockManager.cpp b/examples/lock-app/cc32xx/main/BoltLockManager.cpp new file mode 100755 index 00000000000000..ee734a69b7b55a --- /dev/null +++ b/examples/lock-app/cc32xx/main/BoltLockManager.cpp @@ -0,0 +1,205 @@ +/* + * + * 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. + */ + +#include "BoltLockManager.h" + +#include "AppConfig.h" +#include "AppTask.h" +#include "FreeRTOS.h" + +#define ACTUATOR_MOVEMENT_PERIOS_MS 1000 + +BoltLockManager BoltLockManager::sLock; + +int BoltLockManager::Init() +{ + int ret = 0; + + mTimerHandle = xTimerCreate("BLT_TIMER", pdMS_TO_TICKS(ACTUATOR_MOVEMENT_PERIOS_MS), pdFALSE, this, TimerEventHandler); + if (NULL == mTimerHandle) + { + PLAT_LOG("failed to create bolt lock timer"); + while (1); + } + + mState = kState_UnlockingCompleted; + mAutoLockTimerArmed = false; + mAutoRelock = false; + mAutoLockDuration = 0; + + return ret; +} + +void BoltLockManager::SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB) +{ + mActionInitiated_CB = aActionInitiated_CB; + mActionCompleted_CB = aActionCompleted_CB; +} + +bool BoltLockManager::IsActionInProgress() +{ + return (mState == kState_LockingInitiated || mState == kState_UnlockingInitiated) ? true : false; +} + +bool BoltLockManager::IsUnlocked() +{ + return (mState == kState_UnlockingCompleted) ? true : false; +} + +void BoltLockManager::EnableAutoRelock(bool aOn) +{ + mAutoRelock = aOn; +} + +void BoltLockManager::SetAutoLockDuration(uint32_t aDurationInSecs) +{ + mAutoLockDuration = aDurationInSecs; +} + +bool BoltLockManager::InitiateAction(int32_t aActor, Action_t aAction) +{ + bool action_initiated = false; + State_t new_state; + + // Initiate Lock/Unlock Action only when the previous one is complete. + if (mState == kState_LockingCompleted && aAction == UNLOCK_ACTION) + { + action_initiated = true; + + new_state = kState_UnlockingInitiated; + } + else if (mState == kState_UnlockingCompleted && aAction == LOCK_ACTION) + { + action_initiated = true; + + new_state = kState_LockingInitiated; + } + + if (action_initiated) + { + if (mAutoLockTimerArmed && new_state == kState_LockingInitiated) + { + // If auto lock timer has been armed and someone initiates locking, + // cancel the timer and continue as normal. + mAutoLockTimerArmed = false; + + CancelTimer(); + } + + StartTimer(ACTUATOR_MOVEMENT_PERIOS_MS); + + // Since the timer started successfully, update the state and trigger callback + mState = new_state; + + if (mActionInitiated_CB) + { + mActionInitiated_CB(aAction, aActor); + } + } + + return action_initiated; +} + +void BoltLockManager::StartTimer(uint32_t aTimeoutMs) +{ + // XXX: Seth check returns + xTimerChangePeriod(mTimerHandle, pdMS_TO_TICKS(aTimeoutMs), 100); + xTimerStart(mTimerHandle, 100); +} + +void BoltLockManager::CancelTimer(void) +{ + xTimerStop(mTimerHandle, 100); +} + +void BoltLockManager::TimerEventHandler(TimerHandle_t aTimer) +{ + BoltLockManager * lock = static_cast(pvTimerGetTimerID(aTimer)); + + // The timer event handler will be called in the context of the timer task + // once sLockTimer expires. Post an event to apptask queue with the actual handler + // so that the event can be handled in the context of the apptask. + // XXX: Seth major spaghetti that I don't want to unravel + AppEvent event; + event.Type = AppEvent::kEventType_AppEvent; + event.BoltLockEvent.Context = static_cast(lock); + if (lock->mAutoLockTimerArmed) + { + event.Handler = AutoReLockTimerEventHandler; + } + else + { + event.Handler = ActuatorMovementTimerEventHandler; + } + GetAppTask().PostEvent(&event); +} + +void BoltLockManager::AutoReLockTimerEventHandler(AppEvent * aEvent) +{ + BoltLockManager * lock = static_cast(aEvent->BoltLockEvent.Context); + int32_t actor = 0; + + // Make sure auto lock timer is still armed. + if (!lock->mAutoLockTimerArmed) + { + return; + } + + lock->mAutoLockTimerArmed = false; + + PLAT_LOG("Auto Re-Lock has been triggered!"); + + lock->InitiateAction(actor, LOCK_ACTION); +} + +void BoltLockManager::ActuatorMovementTimerEventHandler(AppEvent * aEvent) +{ + Action_t actionCompleted = INVALID_ACTION; + + BoltLockManager * lock = static_cast(aEvent->BoltLockEvent.Context); + + if (lock->mState == kState_LockingInitiated) + { + lock->mState = kState_LockingCompleted; + actionCompleted = LOCK_ACTION; + } + else if (lock->mState == kState_UnlockingInitiated) + { + lock->mState = kState_UnlockingCompleted; + actionCompleted = UNLOCK_ACTION; + } + + if (actionCompleted != INVALID_ACTION) + { + if (lock->mActionCompleted_CB) + { + lock->mActionCompleted_CB(actionCompleted); + } + + if (lock->mAutoRelock && actionCompleted == UNLOCK_ACTION) + { + // Start the timer for auto relock + lock->StartTimer(lock->mAutoLockDuration * 1000); + + lock->mAutoLockTimerArmed = true; + + PLAT_LOG("Auto Re-lock enabled. Will be triggered in %u seconds", lock->mAutoLockDuration); + } + } +} diff --git a/examples/lock-app/cc32xx/main/BoltLockManager.h b/examples/lock-app/cc32xx/main/BoltLockManager.h new file mode 100755 index 00000000000000..40fc4ffb338a67 --- /dev/null +++ b/examples/lock-app/cc32xx/main/BoltLockManager.h @@ -0,0 +1,87 @@ +/* + * + * 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. + */ + +#ifndef LOCK_MANAGER_H +#define LOCK_MANAGER_H + +#include +#include + +#include "AppEvent.h" + +#include +#include + +class BoltLockManager +{ +public: + enum Action_t + { + LOCK_ACTION = 0, + UNLOCK_ACTION, + + INVALID_ACTION + } Action; + + enum State_t + { + kState_LockingInitiated = 0, + kState_LockingCompleted, + kState_UnlockingInitiated, + kState_UnlockingCompleted, + } State; + + int Init(); + bool IsUnlocked(); + void EnableAutoRelock(bool aOn); + void SetAutoLockDuration(uint32_t aDurationInSecs); + bool IsActionInProgress(); + bool InitiateAction(int32_t aActor, Action_t aAction); + + typedef void (*Callback_fn_initiated)(Action_t, int32_t aActor); + typedef void (*Callback_fn_completed)(Action_t); + void SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB); + +private: + friend BoltLockManager & BoltLockMgr(void); + State_t mState; + + Callback_fn_initiated mActionInitiated_CB; + Callback_fn_completed mActionCompleted_CB; + + bool mAutoRelock; + uint32_t mAutoLockDuration; + bool mAutoLockTimerArmed; + TimerHandle_t mTimerHandle; + + void CancelTimer(void); + void StartTimer(uint32_t aTimeoutMs); + + static void TimerEventHandler(TimerHandle_t aTimer); + static void AutoReLockTimerEventHandler(AppEvent * aEvent); + static void ActuatorMovementTimerEventHandler(AppEvent * aEvent); + + static BoltLockManager sLock; +}; + +inline BoltLockManager & BoltLockMgr(void) +{ + return BoltLockManager::sLock; +} + +#endif // LOCK_MANAGER_H diff --git a/examples/lock-app/cc32xx/main/CXXExceptionStubs.cpp b/examples/lock-app/cc32xx/main/CXXExceptionStubs.cpp new file mode 100755 index 00000000000000..a4ef5137758023 --- /dev/null +++ b/examples/lock-app/cc32xx/main/CXXExceptionStubs.cpp @@ -0,0 +1,80 @@ +/* + * + * 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 + * Stub implementations of the C++ ABI exception handling functions. + * + * These functions replace the standard C++ exception code from the system's + * C++ runtime library with stub implementations that simply abort. This + * reduces overall code size as well as eliminating some calls to malloc() + * that occur during global initialization (see the code in eh_alloc.cc). + * This provides significant memory savings on resource constrained devices + * that don't use exceptions. + * + */ + +#include + +extern "C" { + +void * __cxa_allocate_exception(size_t) +{ + abort(); +} + +void __cxa_free_exception(void *) +{ + abort(); +} + +void * __cxa_allocate_dependent_exception() +{ + abort(); +} + +void __cxa_free_dependent_exception(void *) +{ + abort(); +} + +void __cxa_throw(void *, void *, void (*)(void *)) +{ + abort(); +} + +void __cxa_rethrow() +{ + abort(); +} + +void * __cxa_begin_catch(void *) +{ + abort(); +} + +void __cxa_end_catch() +{ + abort(); +} + +void * __cxa_get_exception_ptr(void *) +{ + abort(); +} +} diff --git a/examples/lock-app/cc32xx/main/ZclCallbacks.cpp b/examples/lock-app/cc32xx/main/ZclCallbacks.cpp new file mode 100755 index 00000000000000..553862096ef67e --- /dev/null +++ b/examples/lock-app/cc32xx/main/ZclCallbacks.cpp @@ -0,0 +1,56 @@ +/* + * + * 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 "AppConfig.h" +#include "BoltLockManager.h" + +#include +#include +#include +#include + +using namespace ::chip; +using namespace ::chip::app::Clusters; + +void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t type, + uint16_t size, uint8_t * value) +{ + if (attributePath.mClusterId == OnOff::Id && attributePath.mAttributeId == OnOff::Attributes::OnOff::Id) + { + BoltLockMgr().InitiateAction(0, *value ? BoltLockManager::LOCK_ACTION : BoltLockManager::UNLOCK_ACTION); + } +} + +/** @brief OnOff Cluster Init + * + * This function is called when a specific cluster is initialized. It gives the + * application an opportunity to take care of cluster initialization procedures. + * It is called exactly once for each endpoint where cluster is present. + * + * @param endpoint Ver.: always + * + * TODO Issue #3841 + * emberAfOnOffClusterInitCallback happens before the stack initialize the cluster + * attributes to the default value. + * The logic here expects something similar to the deprecated Plugins callback + * emberAfPluginOnOffClusterServerPostInitCallback. + * + */ +void emberAfOnOffClusterInitCallback(EndpointId endpoint) +{ + // TODO: implement any additional Cluster Server init actions +} diff --git a/examples/lock-app/cc32xx/main/cc32xxWifiInit.c b/examples/lock-app/cc32xx/main/cc32xxWifiInit.c new file mode 100755 index 00000000000000..a9fa273130761a --- /dev/null +++ b/examples/lock-app/cc32xx/main/cc32xxWifiInit.c @@ -0,0 +1,244 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * 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. + */ + +//**************************************************************************** +// +//! \addtogroup +//! @{ +// +//**************************************************************************** + +/* Standard Include */ +#include +#include +#include +#include +#include +#include +#include +#include + +/* TI-DRIVERS Header files */ +#include +#include + +#include + +#include + +#include +#include + +#include "ti_drivers_config.h" +#include +#include +#include +#include +#include +#include +#include + +#include "utils_if.h" +#include "wifi_if.h" + +#include +int CHIP_IF_init(); + +/* Application Version and Naming*/ +#define APPLICATION_NAME "CC32XX-MATTER:: E-LOCK" +#define APPLICATION_VERSION "01.00.00.00" + + +/* USER's defines */ +#define SLNETCONN_TASK_STACK_SIZE (2048) +#define DISPLAY_TASK_STACK_SIZE (512) + +/**************************************************************************** + LOCAL FUNCTION PROTOTYPES + ****************************************************************************/ +static void ButtonLeftEventHandler(Button_Handle handle, Button_EventMask events); + +/**************************************************************************** + EXT. FUNCTION PROTOTYPES + ****************************************************************************/ +extern void LWIP_IF_start(); + +/**************************************************************************** + GLOBAL VARIABLES + ****************************************************************************/ +pthread_t gSlNetConnThread = (pthread_t) NULL; +Button_Handle gButtonLeftHandle, gButtonRightHandle; +LED_Handle gLedBlueHandle, gLedGreenHandle, gLedRedHandle; + +/**************************************************************************** + STATIC VARIABLES + ****************************************************************************/ +static bool gIsConnected = 0; + +//***************************************************************************** +// Local Functions +//***************************************************************************** + +void SimpleLinkSockEventHandler(SlSockEvent_t * pSock) +{ + /* Unused in this application */ +} + +void SimpleLinkHttpServerEventHandler(SlNetAppHttpServerEvent_t * pHttpEvent, SlNetAppHttpServerResponse_t * pHttpResponse) +{ + /* Unused in this application */ +} + +void SimpleLinkNetAppRequestEventHandler(SlNetAppRequest_t * pNetAppRequest, SlNetAppResponse_t * pNetAppResponse) +{ + /* Unused in this application */ +} + +void SimpleLinkNetAppRequestMemFreeEventHandler(uint8_t * buffer) +{ + /* Unused in this application */ +} + +//***************************************************************************** +// +//! \brief Application startup display on UART +//! +//! \param none +//! +//! \return none +//! +//***************************************************************************** +void DisplayBanner() +{ + cc32xxLog("\n\n\n\r"); + cc32xxLog("\t\t *************************************************\n\r"); + cc32xxLog("\t\t %s Application \n\r", APPLICATION_NAME); + cc32xxLog("\t\t %s \n\r", APPLICATION_VERSION); + cc32xxLog("\t\t *************************************************\n\r"); + cc32xxLog("\n\n\n\r"); +} + +//***************************************************************************** +// +//! \brief SlWifiConn Event Handler +//! +//***************************************************************************** +void SlNetConnEventHandler(uint32_t ifID, SlNetConnStatus_e netStatus, void * data) +{ + switch (netStatus) + { + case SLNETCONN_STATUS_CONNECTED_MAC: + gIsConnected = 1; + LED_setOn(gLedBlueHandle, LED_BRIGHTNESS_MAX); + cc32xxLog("[SlNetConnEventHandler] I/F %d - CONNECTED (MAC LEVEL)!\n\r", ifID); + break; + case SLNETCONN_STATUS_CONNECTED_IP: + gIsConnected = 1; + cc32xxLog("[SlNetConnEventHandler] I/F %d - CONNECTED (IP LEVEL)!\n\r", ifID); + break; + case SLNETCONN_STATUS_CONNECTED_INTERNET: + gIsConnected = 1; + cc32xxLog("[SlNetConnEventHandler] I/F %d - CONNECTED (INTERNET LEVEL)!\n\r", ifID); + break; + case SLNETCONN_STATUS_WAITING_FOR_CONNECTION: + case SLNETCONN_STATUS_DISCONNECTED: + gIsConnected = 0; + LED_setOff(gLedBlueHandle); + cc32xxLog("[SlNetConnEventHandler] I/F %d - DISCONNECTED!\n\r", ifID); + break; + default: + cc32xxLog("[SlNetConnEventHandler] I/F %d - UNKNOWN STATUS\n\r", ifID); + break; + } +} + +//***************************************************************************** +// +//! \brief Launchpad switch used to enable one shot provisioning +//! +//***************************************************************************** +static void ButtonLeftEventHandler(Button_Handle handle, Button_EventMask events) +{ + // Enable Provisioning + int retVal = SlWifiConn_enableProvisioning(WifiProvMode_ONE_SHOT, PROVISIONING_CMD, 0); + assert(retVal == 0); +} + +//***************************************************************************** +// +//! \brief Main application thread +//! +//! \param none +//! +//! \return none +//! +//***************************************************************************** +int WiFi_init() +{ + int retVal; + Button_Params buttonParams; + LED_Params ledParams; + + SPI_init(); + +#ifdef NWP_LOG + // NWP log config + // If your application already has UART0 configured, no need for this line + MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK); + // Mux Pin 62 to mode 1 for outputting NWP logs + MAP_PinTypeUART(PIN_62, PIN_MODE_1); +#endif + + LED_Params_init(&ledParams); // default PWM LED + gLedBlueHandle = LED_open(CONFIG_LED_BLUE, &ledParams); + LED_setOff(gLedBlueHandle); + + Button_Params_init(&buttonParams); + buttonParams.buttonEventMask = Button_EV_CLICKED | Button_EV_LONGCLICKED; + buttonParams.longPressDuration = 1000U; // ms + gButtonLeftHandle = Button_open(CONFIG_BTN_LEFT, &buttonParams); + Button_setCallback(gButtonLeftHandle, ButtonLeftEventHandler); + + /* Enable SlWifiConn */ + retVal = WIFI_IF_init(); + assert(retVal >= 0); + + /* Enable SlNet framework */ + retVal = ti_net_SlNet_initConfig(); + assert(retVal == 0); + + /* Enable SlNetConn */ + retVal = SlNetConn_init(0); + assert(retVal == 0); + gSlNetConnThread = OS_createTask(1, SLNETCONN_TASK_STACK_SIZE, SlNetConn_process, NULL, OS_TASK_FLAG_DETACHED); + assert(gSlNetConnThread); + + return (retVal); +} + +int WiFi_deinit() +{ + int retVal; + cc32xxLog("[APP] Networking App Completed (entering low power mode)\r\n "); + retVal = SlNetConn_stop(SlNetConnEventHandler); + retVal = WIFI_IF_deinit(); + cc32xxLog("[APP] Exit (%d) \r\n", retVal); + assert(retVal == 0); + return (retVal); +} diff --git a/examples/lock-app/cc32xx/main/debug_settings.h b/examples/lock-app/cc32xx/main/debug_settings.h new file mode 100644 index 00000000000000..ddf6792794b383 --- /dev/null +++ b/examples/lock-app/cc32xx/main/debug_settings.h @@ -0,0 +1,42 @@ +/* + * + * 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. + */ + +//***************************************************************************** +// Includes +//***************************************************************************** +// Standard includes +#ifndef DEBUG_SETTINGS_H +#define DEBUG_SETTINGS_H + +// Select the print method used in the main app +#define D_DEBUG_METHOD D_USER_DEFINED + +// Select Sevrity Color +#define _FATAL_CLR_ _CLR_B_RED_ +#define _ERROR_CLR_ _CLR_RED_ +#define _WARNING_CLR_ _CLR_MAGENTA_ +#define _INFO_CLR_ _CLR_GREEN_ +#define _DEBUG_CLR_ _CLR_YELLOW_ +#define _TRACE_CLR_ _CLR_RESET_ + +#if (D_DEBUG_METHOD == D_USER_DEFINED) +extern void cc32xxLog(const char * msg, ...); +#define PRINTF(...) cc32xxLog(__VA_ARGS__); +#endif + +#endif // DEBUG_SETTINGS_H diff --git a/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h b/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h new file mode 100755 index 00000000000000..94cae7807fb417 --- /dev/null +++ b/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h @@ -0,0 +1,151 @@ +/* + * 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. + * + */ + +#ifndef CHIP_PROJECT_CONFIG_H +#define CHIP_PROJECT_CONFIG_H + +#if BUILD_RELEASE // release build + +// Security and Authentication enabled for release build. +#define CHIP_CONFIG_SECURITY_TEST_MODE 0 +#define CHIP_CONFIG_REQUIRE_AUTH 1 + +#else // development build + +// Security and Authentication disabled for development build. +// For convenience, enable CHIP Security Test Mode and disable the requirement for +// authentication in various protocols. +// WARNING: These options make it possible to circumvent basic CHIP security functionality, +// including message encryption. Because of this they MUST NEVER BE ENABLED IN PRODUCTION BUILDS. +#define CHIP_CONFIG_SECURITY_TEST_MODE 0 +#define CHIP_CONFIG_REQUIRE_AUTH 0 + +/** + * CHIP_DEVICE_CONFIG_ENABLE_TEST_DEVICE_IDENTITY + * + * Enables the use of a hard-coded default CHIP device id and credentials if no device id + * is found in CHIP NV storage. + * + * This option is for testing only and should be disabled in production releases. + */ +#define CHIP_DEVICE_CONFIG_ENABLE_TEST_DEVICE_IDENTITY 34 + +// Use a default pairing code if one hasn't been provisioned in flash. +#define CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE 20202021 +#define CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR 0xF00 + +// Use a default pairing code if one hasn't been provisioned in flash. +#define CHIP_DEVICE_CONFIG_USE_TEST_PAIRING_CODE "CHIPUS" + +/** + * CHIP_DEVICE_CONFIG_USE_TEST_SERIAL_NUMBER + * + * Enables the use of a hard-coded default serial number if none + * is found in CHIP NV storage. + */ +#define CHIP_DEVICE_CONFIG_USE_TEST_SERIAL_NUMBER "DUMMY_SN" + +#endif // BUILD_RELEASE + +/** + * CHIP_DEVICE_CONFIG_DEVICE_VENDOR_ID + * + * 0xE100: Google's Vendor Id. + */ +#define CHIP_DEVICE_CONFIG_DEVICE_VENDOR_ID 0xFFF1 + +/** + * CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID + * + * 0xFE00: SDK Sample Lock Resource + */ +#define CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID 0x8006 + +/** + * CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_REVISION + * + * The product revision number assigned to device or product by the device vendor. This + * number is scoped to the device product id, and typically corresponds to a revision of the + * physical device, a change to its packaging, and/or a change to its marketing presentation. + * This value is generally *not* incremented for device software revisions. + */ +#define CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_REVISION 1 + +/** + * CHIP_DEVICE_CONFIG_DEVICE_FIRMWARE_REVISION + * + * A string identifying the firmware revision running on the device. + * CHIP currently expects the firmware version to be in the format + * {MAJOR_VERSION}.0d{MINOR_VERSION} + */ +#ifndef CHIP_DEVICE_CONFIG_DEVICE_FIRMWARE_REVISION +#define CHIP_DEVICE_CONFIG_DEVICE_FIRMWARE_REVISION "1.0d1" +#endif +/** + * CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE + * + * Enable support for CHIP-over-BLE (CHIPOBLE). + */ +#define CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE 0 + +/** + * CHIP_DEVICE_CONFIG_ENABLE_CHIP_TIME_SERVICE_TIME_SYNC + * + * Enables synchronizing the device's real time clock with a remote CHIP Time service + * using the CHIP Time Sync protocol. + */ +//#define CHIP_DEVICE_CONFIG_ENABLE_CHIP_TIME_SERVICE_TIME_SYNC 1 + +/** + * CHIP_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS + * + * Enable recording UTC timestamps. + */ +#define CHIP_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS 1 + +/** + * CHIP_DEVICE_CONFIG_EVENT_LOGGING_DEBUG_BUFFER_SIZE + * + * A size, in bytes, of the individual debug event logging buffer. + */ +#define CHIP_DEVICE_CONFIG_EVENT_LOGGING_DEBUG_BUFFER_SIZE (512) + +/** + * CHIP_CONFIG_EVENT_LOGGING_DEFAULT_IMPORTANCE + * + * For a development build, set the default importance of events to be logged as Debug. + * Since debug is the lowest importance level, this means all standard, critical, info and + * debug importance level vi events get logged. + */ +#if BUILD_RELEASE +#define CHIP_CONFIG_EVENT_LOGGING_DEFAULT_IMPORTANCE chip::Profiles::DataManagement::Production +#else +#define CHIP_CONFIG_EVENT_LOGGING_DEFAULT_IMPORTANCE chip::Profiles::DataManagement::Debug +#endif // BUILD_RELEASE + + +#endif // CHIP_PROJECT_CONFIG_H diff --git a/examples/lock-app/cc32xx/main/main.cpp b/examples/lock-app/cc32xx/main/main.cpp new file mode 100755 index 00000000000000..41fee94c39fb43 --- /dev/null +++ b/examples/lock-app/cc32xx/main/main.cpp @@ -0,0 +1,78 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * + * 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 + +/* Driver Header files */ +#include +#include +#include + +using namespace ::chip; +using namespace ::chip::Inet; +using namespace ::chip::DeviceLayer; + +// ================================================================================ +// FreeRTOS Callbacks +// ================================================================================ +extern "C" void vApplicationStackOverflowHook(void) +{ + while (1) + { + ; + } +} + + + +// ================================================================================ +// Main Code +// ================================================================================ +int main(void) +{ + Board_init(); + GPIO_init(); + + mbedtls_platform_set_calloc_free(CHIPPlatformMemoryCalloc, CHIPPlatformMemoryFree); + + int ret = GetAppTask().StartAppTask(); + if (ret != 0) + { + // can't log until the kernel is started + // PLAT_LOG("GetAppTask().StartAppTask() failed"); + while (1) + ; + } + + vTaskStartScheduler(); + + // Should never get here. + while (1) + ; +} diff --git a/examples/lock-app/cc32xx/main/wifi_settings.h b/examples/lock-app/cc32xx/main/wifi_settings.h new file mode 100644 index 00000000000000..f7f6b946b1f0cf --- /dev/null +++ b/examples/lock-app/cc32xx/main/wifi_settings.h @@ -0,0 +1,103 @@ +/* + * + * 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. + */ + +//***************************************************************************** +// Includes +//***************************************************************************** +// Standard includes +#ifndef WIFI_SETTINGS_H +#define WIFI_SETTINGS_H + +//***************************************************************************** +// WIFI IF INTRODUCTION +//***************************************************************************** +/* This module enables an easy integration of Wi-Fi to a SimpleLink Networking + * framework. + * It was designed for applications that use the Wi-Fi Station role only. + * The simple API and settings enables the user to initiate the Wi-Fi and + * configure the provisioning method that will be used upon first connection + * attempt. + * Upon successful init (WIFI_IF_init()), the system enables the NWP for any + * SL commands. + * The NWP will be in a low power state (AUTO-CONNECT will be disabled) waiting + * for connection request (SlNetConn_Start()). + * User should not call sl_Start/sl_Stop when using this module. Please use + * WIFI_IF_restart() (for reseting the NWP) or WIFI_IF_deinit() instead. + */ + +//***************************************************************************** +// WIFI IF USER SETTINGS +//***************************************************************************** + +/* + * Defines the minimum severity level allowed. + * Use E_DEBUG to enable Wifi internal messages + * Options: E_TRACE, E_DEBUG, E_INFO, E_WARNING, E_ERROR, E_FATAL + */ +#define WIFI_IF_DEBUG_LEVEL E_INFO + +/* + * Defines Provisioning (initial) Parameters: + * Mode can be: WifiProvMode_OFF, WifiProvMode_ON, WifiProvMode_ONE_SHOT + * Command can be one of the following: + * SL_WLAN_PROVISIONING_CMD_START_MODE_AP, + * SL_WLAN_PROVISIONING_CMD_START_MODE_SC, + * SL_WLAN_PROVISIONING_CMD_START_MODE_APSC, + * SL_WLAN_PROVISIONING_CMD_START_MODE_APSC_EXTERNAL_CONFIGURATION, + * SL_WLAN_PROVISIONING_CMD_START_MODE_EXTERNAL_CONFIGURATION + */ +#define PROVISIONING_MODE WifiProvMode_ONE_SHOT +#define PROVISIONING_CMD SL_WLAN_PROVISIONING_CMD_START_MODE_APSC + +/* + * Defines Provisioning AP /SC Parameters: + */ +#define PROVISIONING_TIMEOUT 0 // 0 - use default +#define PROVISIONING_AP_PASSWORD "1234567890" // NULL - use default (OPEN) +#define PROVISIONING_SC_KEY "1234567890123456" // NULL - use defaults + +/* Force provisioning by deleting existing profiles. + * To be used for testing during development only. + * Note: When FORCE_PROVSIONING is enabled - the following static profile + * configurations are ignored + */ +#define FORCE_PROVISIONING (0) + +/* Static Profile setting - Method 1: Hard coded + * Define AP_SSID and optionally AP_PASSWORD - to connect to local network + * Hard-Coded Definition: update AP_SSID and AP_PASSWORD (NULL means OPEN, else is WPA2) + */ +#define AP_SSID NULL // "network-name" +#define AP_PASSWORD NULL // "network-password" + +/* Static Profile setting - Method 2: Configuration file + * File format should be: + * "' '" + * i.e. ssid and password with one space character between them + * Do not use newline, extra space symbols or quotation mark + */ +#define AP_CFG_FILENAME "network.cfg" // config file name +#define AP_CFG_TOKEN 12345678 // config file read access token +#define AP_CFG_MAX_SIZE 100 // config file Maximum file length + +/* Define (if needed) the external handle for TI Driver's LED for wi-fi status: + * off: disconnected, blinking: provisionig, on: connected + * Comment the definition in case the auto control is not required */ +#define WIFI_LED_HANDLE gLedBlueHandle + +#endif // WIFI_SETTINGS_H diff --git a/examples/lock-app/cc32xx/third_party/connectedhomeip b/examples/lock-app/cc32xx/third_party/connectedhomeip new file mode 120000 index 00000000000000..11a54ed360106c --- /dev/null +++ b/examples/lock-app/cc32xx/third_party/connectedhomeip @@ -0,0 +1 @@ +../../../../ \ No newline at end of file diff --git a/examples/platform/cc32xx/BUILD.gn b/examples/platform/cc32xx/BUILD.gn new file mode 100644 index 00000000000000..10a6e39455e73d --- /dev/null +++ b/examples/platform/cc32xx/BUILD.gn @@ -0,0 +1,20 @@ +# 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" ] +} + diff --git a/examples/platform/cc32xx/args.gni b/examples/platform/cc32xx/args.gni new file mode 100644 index 00000000000000..009c56bf5a59fe --- /dev/null +++ b/examples/platform/cc32xx/args.gni @@ -0,0 +1,24 @@ +# 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/cc32xx/args.gni") + + +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/scripts/checkout_submodules.py b/scripts/checkout_submodules.py index 9356fcfc25aaf3..dc288911630bcb 100755 --- a/scripts/checkout_submodules.py +++ b/scripts/checkout_submodules.py @@ -29,6 +29,7 @@ 'android', 'bl602', 'cc13x2_26x2', + 'cc32xx', 'cyw30739', 'darwin', 'efr32', diff --git a/src/lwip/BUILD.gn b/src/lwip/BUILD.gn index 2708e1658efad6..727c1e3dba87e9 100644 --- a/src/lwip/BUILD.gn +++ b/src/lwip/BUILD.gn @@ -29,10 +29,11 @@ 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 == "cyw30739" || lwip_platform == "bl602", + lwip_platform == "cc13x2_26x2" || lwip_platform == "cc32xx" || + lwip_platform == "efr32" || lwip_platform == "k32w0" || + lwip_platform == "qpg" || lwip_platform == "mbed" || + lwip_platform == "p6" || lwip_platform == "cyw30739" || + lwip_platform == "bl602", "Unsupported lwIP platform: ${lwip_platform}") if (lwip_platform != "external") { @@ -44,6 +45,8 @@ if (lwip_platform != "external") { if (lwip_platform == "cc13x2_26x2") { import("//build_overrides/ti_simplelink_sdk.gni") +} else if (lwip_platform == "cc32xx") { + import("//build_overrides/ti_simplelink_sdk.gni") } else if (lwip_platform == "efr32") { import("//build_overrides/efr32_sdk.gni") } else if (lwip_platform == "qpg") { @@ -161,6 +164,10 @@ if (current_os == "zephyr" || current_os == "mbed") { public_deps = [ ":lwip_buildconfig" ] if (lwip_platform == "cc13x2_26x2") { public_deps += [ "${ti_simplelink_sdk_build_root}:ti_simplelink_sdk" ] + } else if (lwip_platform == "cc32xx") { + public_deps += [ "${ti_simplelink_sdk_build_root}:ti_simplelink_sdk" ] + sources += + [ "${chip_root}/third_party/lwip/repo/lwip/src/apps/mdns/mdns.c" ] } else if (lwip_platform == "efr32") { public_deps += [ "${efr32_sdk_build_root}:efr32_sdk" ] } else if (lwip_platform == "standalone") { diff --git a/src/lwip/cc32xx/arch/cc.h b/src/lwip/cc32xx/arch/cc.h new file mode 100644 index 00000000000000..91174cc16f219e --- /dev/null +++ b/src/lwip/cc32xx/arch/cc.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2018-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. + */ + +// XXX: Seth, what does this need for TI devices? + +/* + * + * Description: + * This file defines processor-architecture- and toolchain- + * specific constants and types required for building + * LwIP against FreeRTOS. + * + */ + +#ifndef CHIP_LWIP_FREERTOS_ARCH_CC_H +#define CHIP_LWIP_FREERTOS_ARCH_CC_H + +#include +#include +#include +#include +#include +#include + +#include + +//#include "app_error.h" + +#if __cplusplus +extern "C" { +#endif + +#ifndef LWIP_NOASSERT +#ifdef DEBUG +#define LWIP_PLATFORM_ASSERT(MSG) assert(0) +#else +#define LWIP_PLATFORM_ASSERT(MSG) assert(0) +#endif +#else +#define LWIP_PLATFORM_ASSERT(message) +#endif + +#ifndef BYTE_ORDER +#if defined(__LITTLE_ENDIAN__) +#define BYTE_ORDER LITTLE_ENDIAN +#elif defined(__BIG_ENDIAN__) +#define BYTE_ORDER BIG_ENDIAN +#elif defined(__BYTE_ORDER__) +#define BYTE_ORDER __BYTE_ORDER__ +#endif +#endif // BYTE_ORDER + +#define PACK_STRUCT_STRUCT __attribute__((__packed__)) +#define PACK_STRUCT_FIELD(x) x + +extern void LwIPLog(const char * fmt, ...); +#define LWIP_PLATFORM_DIAG(x) \ + do \ + { \ + LwIPLog x; \ + } while (0) + +// Place LwIP pools into their own subsections of .bss to make it easier to see +// their sizes in the linker map file. +extern uint8_t __attribute__((section(".bss.lwip_ND6_QUEUE"))) memp_memory_ND6_QUEUE_base[]; +extern uint8_t __attribute__((section(".bss.lwip_IP6_REASSDATA"))) memp_memory_IP6_REASSDATA_base[]; +extern uint8_t __attribute__((section(".bss.lwip_RAW_PCB"))) memp_memory_RAW_PCB_base[]; +extern uint8_t __attribute__((section(".bss.lwip_TCP_SEG"))) memp_memory_TCP_SEG_base[]; +extern uint8_t __attribute__((section(".bss.lwip_PBUF_POOL"))) memp_memory_PBUF_POOL_base[]; +extern uint8_t __attribute__((section(".bss.lwip_FRAG_PBUF"))) memp_memory_FRAG_PBUF_base[]; +extern uint8_t __attribute__((section(".bss.lwip_PBUF"))) memp_memory_PBUF_base[]; +extern uint8_t __attribute__((section(".bss.lwip_TCP_PCB_LISTEN"))) memp_memory_TCP_PCB_LISTEN_base[]; +extern uint8_t __attribute__((section(".bss.lwip_REASSDATA"))) memp_memory_REASSDATA_base[]; +extern uint8_t __attribute__((section(".bss.lwip_UDP_PCB"))) memp_memory_UDP_PCB_base[]; +extern uint8_t __attribute__((section(".bss.lwip_MLD6_GROUP"))) memp_memory_MLD6_GROUP_base[]; +extern uint8_t __attribute__((section(".bss.lwip_IGMP_GROUP"))) memp_memory_IGMP_GROUP_base[]; +extern uint8_t __attribute__((section(".bss.lwip_TCP_PCB"))) memp_memory_TCP_PCB_base[]; +extern uint8_t __attribute__((section(".bss.lwip_SYS_TIMEOUT"))) memp_memory_SYS_TIMEOUT_base[]; + +#if __cplusplus +} +#endif + +#endif /* CHIP_LWIP_FREERTOS_ARCH_CC_H */ diff --git a/src/lwip/cc32xx/arch/perf.h b/src/lwip/cc32xx/arch/perf.h new file mode 100644 index 00000000000000..6239d7e44e7b39 --- /dev/null +++ b/src/lwip/cc32xx/arch/perf.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2018-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. + */ + +// XXX: Seth, what does this need for TI devices? + +/* + * + * Description: + * This file defines processor-architecture-specific constants, + * interfaces and types required for LwIP performance + * measurement. + * + */ + +#ifndef CHIP_LWIP_FREERTOS_ARCH_PERF_H +#define CHIP_LWIP_FREERTOS_ARCH_PERF_H + +#define PERF_START +#define PERF_STOP(s) + +#endif /* CHIP_LWIP_FREERTOS_ARCH_PERF_H */ diff --git a/src/lwip/cc32xx/lwipopts.h b/src/lwip/cc32xx/lwipopts.h new file mode 100644 index 00000000000000..146ff2bec8556a --- /dev/null +++ b/src/lwip/cc32xx/lwipopts.h @@ -0,0 +1,175 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * 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 + * Compile-time configuration for LwIP on the TI CC32xx. + * + */ + +#ifndef __LWIPOPTS_H__ +#define __LWIPOPTS_H__ + +#include + +#define NO_SYS 0 +#define MEM_ALIGNMENT (4) +#define MEMP_NUM_TCP_SEG (TCP_SND_QUEUELEN + 1) +#define LWIP_TIMEVAL_PRIVATE (0) +#define MEM_LIBC_MALLOC (0) +#define LWIP_COMPAT_MUTEX (0) +#define SYS_LIGHTWEIGHT_PROT (1) +#define LWIP_AUTOIP (1) +#define LWIP_DHCP_AUTOIP_COOP (0) +#define LWIP_SOCKET_SET_ERRNO 0 +#define IP_REASS_MAX_PBUFS 0 +#define IP_REASSEMBLY 0 +#define MEMP_NUM_REASSDATA 0 +#define LWIP_SO_RCVTIMEO 0 +#define SO_REUSE (1) +#define LWIP_RANDOMIZE_INITIAL_LOCAL_PORTS (1) +#define LWIP_STATS (0) +#define LWIP_TCPIP_CORE_LOCKING 1 +#define TCP_QUEUE_OOSEQ 0 +#define ARP_QUEUEING (0) +#define TCPIP_THREAD_NAME "LWIP" + +#define LWIP_NETIF_LINK_CALLBACK 1 +#define LWIP_NETIF_STATUS_CALLBACK 1 + +#define LWIP_SOCKET 0 + +// TODO: seems like this is unnecessary on Thread-only platforms +#define LWIP_RAW 1 +#define MEMP_NUM_RAW_PCB (5) + +#define MEMP_NUM_UDP_PCB (7) + +#define LWIP_HAVE_LOOPIF (0) + +// TODO: not sure why this is disabled +#define LWIP_NETIF_LOOPBACK (0) + +#define MEMP_NUM_NETCONN (0) + +// enable ethernet for ipv6 support +#define LWIP_ETHERNET 1 + +#define LWIP_IPV4 1 +#define LWIP_IPV6 1 +#define LWIP_ARP (1) +#define LWIP_DNS (0) +#define LWIP_ICMP (0) +#define LWIP_IGMP (1) +#define LWIP_DHCP (1) +#define LWIP_IPV6_REASS (0) +#define LWIP_IPV6_DHCP6 0 +#define LWIP_IPV6_AUTOCONFIG (0) +#define LWIP_IPV6_ROUTER_SUPPORT 0 +#define LWIP_ND6_LISTEN_RA 0 + +#define LWIP_ND6_NUM_NEIGHBORS (0) +#define LWIP_ND6_NUM_DESTINATIONS (0) +#define LWIP_ND6_NUM_PREFIXES (0) +#define LWIP_ND6_NUM_ROUTERS (0) +#define LWIP_ND6_MAX_MULTICAST_SOLICIT (0) +#define LWIP_ND6_MAX_UNICAST_SOLICIT (0) +#define LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT (0) +#define LWIP_ND6_TCP_REACHABILITY_HINTS (0) + +#define MEMP_SEPARATE_POOLS (1) +#define LWIP_PBUF_FROM_CUSTOM_POOLS (0) +#define MEMP_USE_CUSTOM_POOLS (0) +#define PBUF_POOL_SIZE (16) +#define PBUF_POOL_BUFSIZE (1500) +#define PBUF_POOL_SIZE_LARGE (3) +#define PBUF_POOL_SIZE_MEDIUM (4) +#define PBUF_POOL_SIZE_SMALL (5) +#define PBUF_POOL_BUFSIZE_LARGE (1280) +#define PBUF_POOL_BUFSIZE_MEDIUM (640) +#define PBUF_POOL_BUFSIZE_SMALL (256) +#define PBUF_CUSTOM_POOL_IDX_START (MEMP_PBUF_POOL_SMALL) +#define PBUF_CUSTOM_POOL_IDX_END (MEMP_PBUF_POOL_LARGE) + +#define TCP_MSS (1152) +#define TCP_SND_BUF (2 * TCP_MSS) +#define TCP_LISTEN_BACKLOG (1) + +#define ETH_PAD_SIZE (0) +#define SUB_ETHERNET_HEADER_SPACE (0) +#define PBUF_LINK_HLEN (14) + +#define TCPIP_THREAD_STACKSIZE (4096) +#define TCPIP_THREAD_PRIO (2) + +#define NETIF_MAX_HWADDR_LEN 8U + +#define LWIP_IPV6_NUM_ADDRESSES 5 + +#define LWIP_IPV6_ND 1 +#define LWIP_IPV6_MLD 1 +#define LWIP_ND6_QUEUEING 0 + +#define LWIP_MULTICAST_PING 0 + +#define TCPIP_MBOX_SIZE 6 +#define DEFAULT_RAW_RECVMBOX_SIZE 6 +#define DEFAULT_UDP_RECVMBOX_SIZE 6 +#define DEFAULT_TCP_RECVMBOX_SIZE 6 + +// TODO: make LWIP_DEBUG conditional on build type + +#ifndef LWIP_DEBUG +#define LWIP_DEBUG 1 +#endif + +#define MEMP_OVERFLOW_CHECK (0) +#define MEMP_SANITY_CHECK (0) +#define MEM_DEBUG (LWIP_DBG_OFF) +#define MEMP_DEBUG (LWIP_DBG_OFF) +#define PBUF_DEBUG (LWIP_DBG_OFF) +#define API_LIB_DEBUG (LWIP_DBG_OFF) +#define API_MSG_DEBUG (LWIP_DBG_OFF) +#define TCPIP_DEBUG (LWIP_DBG_OFF) +#define NETIF_DEBUG (LWIP_DBG_OFF) +#define SOCKETS_DEBUG (LWIP_DBG_OFF) +#define DEMO_DEBUG (LWIP_DBG_OFF) +#define DHCP_DEBUG (LWIP_DBG_OFF) +#define AUTOIP_DEBUG (LWIP_DBG_OFF) +#define ETHARP_DEBUG (LWIP_DBG_OFF) +#define IP_DEBUG (LWIP_DBG_OFF) +#define IP_REASS_DEBUG (LWIP_DBG_OFF) +#define IP6_DEBUG (LWIP_DBG_OFF) +#define RAW_DEBUG (LWIP_DBG_OFF) +#define ICMP_DEBUG (LWIP_DBG_OFF) +#define UDP_DEBUG (LWIP_DBG_OFF) +#define TCP_DEBUG (LWIP_DBG_OFF) +#define TCP_INPUT_DEBUG (LWIP_DBG_OFF) +#define TCP_OUTPUT_DEBUG (LWIP_DBG_OFF) +#define TCP_RTO_DEBUG (LWIP_DBG_OFF) +#define TCP_CWND_DEBUG (LWIP_DBG_OFF) +#define TCP_WND_DEBUG (LWIP_DBG_OFF) +#define TCP_FR_DEBUG (LWIP_DBG_OFF) +#define TCP_QLEN_DEBUG (LWIP_DBG_OFF) +#define TCP_RST_DEBUG (LWIP_DBG_OFF) +#define PPP_DEBUG (LWIP_DBG_OFF) + +#define LWIP_DBG_TYPES_ON \ + (LWIP_DBG_ON | LWIP_DBG_TRACE) /* (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT) */ + +#endif /* __LWIPOPTS_H__ */ diff --git a/src/lwip/cc32xx/lwippools.h b/src/lwip/cc32xx/lwippools.h new file mode 100644 index 00000000000000..e8967a420f4344 --- /dev/null +++ b/src/lwip/cc32xx/lwippools.h @@ -0,0 +1,2 @@ + +// XXX: Seth, what does this need for TI devices? diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn index b4d717a0040b60..4dd826eae2a817 100644 --- a/src/platform/BUILD.gn +++ b/src/platform/BUILD.gn @@ -159,6 +159,11 @@ if (chip_device_platform != "none" && chip_device_platform != "external") { "CHIP_DEVICE_LAYER_TARGET_CC13X2_26X2=1", "CHIP_DEVICE_LAYER_TARGET=cc13x2_26x2", ] + } else if (chip_device_platform == "cc32xx") { + defines += [ + "CHIP_DEVICE_LAYER_TARGET_CC32XX=1", + "CHIP_DEVICE_LAYER_TARGET=cc32xx", + ] } else if (chip_device_platform == "darwin") { defines += [ "CHIP_DEVICE_LAYER_TARGET_DARWIN=1", @@ -370,6 +375,8 @@ if (chip_device_platform != "none") { if (chip_device_platform == "cc13x2_26x2") { _platform_target = "cc13x2_26x2" + } else if (chip_device_platform == "cc32xx") { + _platform_target = "cc32xx" } else if (chip_device_platform == "darwin") { _platform_target = "Darwin" } else if (chip_device_platform == "efr32") { diff --git a/src/platform/cc32xx/BUILD.gn b/src/platform/cc32xx/BUILD.gn new file mode 100644 index 00000000000000..5932becd949778 --- /dev/null +++ b/src/platform/cc32xx/BUILD.gn @@ -0,0 +1,63 @@ +# 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 == "cc32xx") + +static_library("cc32xx") { + sources = [ + "../FreeRTOS/SystemTimeSupport.cpp", + "../SingletonConfigurationManager.cpp", + "CC32XXConfig.cpp", + "CC32XXConfig.h", + "CHIPDevicePlatformConfig.h", + "CHIPDevicePlatformEvent.h", + "ConfigurationManagerImpl.cpp", + "ConnectivityManagerImpl.cpp", + "ConnectivityManagerImpl.h", + "DeviceNetworkProvisioningDelegateImpl.cpp", + "DeviceNetworkProvisioningDelegateImpl.h", + "DiagnosticDataProviderImpl.cpp", + "DiagnosticDataProviderImpl.h", + "InetPlatformConfig.h", + "KeyValueStoreManagerImpl.cpp", + "KeyValueStoreManagerImpl.h", + + #"Logging.cpp", + "PlatformManagerImpl.cpp", + "PlatformManagerImpl.h", + + #"Random.c", + + "SystemPlatformConfig.h", + ] + + include_dirs = [ "ifmod/" ] + deps = [] + + public_deps = [ + "${chip_root}/src/crypto", + "${chip_root}/src/platform:platform_base", + ] + + if (chip_enable_ble) { + sources += [ + "BLEManagerImpl.cpp", + "BLEManagerImpl.h", + ] + } +} diff --git a/src/platform/cc32xx/BlePlatformConfig.h b/src/platform/cc32xx/BlePlatformConfig.h new file mode 100644 index 00000000000000..e271014ad01c7b --- /dev/null +++ b/src/platform/cc32xx/BlePlatformConfig.h @@ -0,0 +1,31 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * + * 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 for the Texas Instruments CC32XX platform. + * + * NOTE: Empty because BLE is not enabled, but configure.ac defines this file + * to be included by the build configuration. + */ + +#ifndef BLE_PLATFORM_CONFIG_H +#define BLE_PLATFORM_CONFIG_H + +#endif // BLE_PLATFORM_CONFIG_H diff --git a/src/platform/cc32xx/CC32XXConfig.cpp b/src/platform/cc32xx/CC32XXConfig.cpp new file mode 100644 index 00000000000000..87b8a4f94fdd34 --- /dev/null +++ b/src/platform/cc32xx/CC32XXConfig.cpp @@ -0,0 +1,559 @@ +/* + * + * 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 + * Utilities for interacting with multiple file partitions and maps + * key-value config calls to the correct partition. + */ + +#include +#include + +#include +#include +#include +#include + +extern "C" { +int FILE_write(char * pFilename, uint16_t length, uint8_t * pValue, uint32_t * pToken, uint32_t flags); +int FILE_read(int8_t * pFilename, uint16_t length, uint8_t * pValue, uint32_t token); +}; + +// need to define custom tokens to read/write files from the file system +#define KVS_TOKEN 0x13578642 + +// need between 4k and 8k bytes to store the LL when reading/writing it as a buffer +#define NV_BUFFER_SIZE 8192 + +uint16_t NVBufferLength = 0; + +extern "C" void cc32xxLog(const char * aFormat, ...); + +char listName[] = "/sys/matter/kvs.cfg"; + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +/** + * This class is designed to be mixed-in to concrete implementation classes as a means to + * provide access to configuration information to generic base classes. + * + * This class contains the definition of a LL entry -- calling the constructor creates a LL entry only, adding the entry to a LL is + * handled in CC32XXKVSList + */ +class CC32XXKVSEntry +{ +private: + // KVS key + char mKey[40] = ""; + + // KVS values + uint16_t mValueLen; + uint8_t * mValue; + +public: + CC32XXKVSEntry * mPNext; + + CC32XXKVSEntry(char * key, const uint8_t * pBuf, uint16_t len) + { + uint32_t mKLen = strlen(key); + if (mKLen > 40) + { + strncpy(mKey, key, 39); + mKey[39] = '\0'; + } + else + { + strncpy(mKey, key, mKLen); + } + + mValueLen = len; + mValue = new uint8_t[len]; + if (mValue) + { + memcpy(mValue, pBuf, len); + } + mPNext = NULL; + } + + bool IsMatch(const char * key) { return (strcmp(mKey, key) == 0); } + + char * Key() { return mKey; } + + uint16_t Len() { return mValueLen; } + + uint8_t * Value() { return mValue; } + + CHIP_ERROR ReadVal(uint8_t * pBuff, size_t len) + { + CHIP_ERROR err = CHIP_ERROR_NOT_FOUND; + if (mValueLen <= (uint16_t) len) + { + memcpy(pBuff, mValue, mValueLen); + err = CHIP_NO_ERROR; + } + return err; + } + + CHIP_ERROR UpdateVal(const uint8_t * pBuff, uint16_t len) + { + CHIP_ERROR err = CHIP_ERROR_INVALID_MESSAGE_LENGTH; + if (len > 0) + { + if (mValue) + { + delete (mValue); + } + mValue = new uint8_t[len]; + mValueLen = len; + memcpy(mValue, pBuff, len); + err = CHIP_NO_ERROR; + } + return err; + } + + uint16_t DeleteVal(void) + { + delete mValue; + return 0; + } +}; + +/** + * Linked List traversal operations for when it is in RAM, and operations to read and write from NV + */ +class CC32XXKVSList +{ +private: + CC32XXKVSEntry * mPHead; + +public: + CC32XXKVSList() { mPHead = NULL; } + + CC32XXKVSEntry * GetEntryByKey(const char * key) + { + CC32XXKVSEntry * pEntry = mPHead; + while (pEntry) + { + if (pEntry->IsMatch(key)) + { + return pEntry; + } + pEntry = pEntry->mPNext; + } + return NULL; + } + + CHIP_ERROR AddEntryByKey(char * key, const uint8_t * pBuff, const uint16_t len) + { + CHIP_ERROR err; + CC32XXKVSEntry * pEntry = GetEntryByKey(key); + + if (!pEntry) + { + CC32XXKVSEntry * pEntryNew = new CC32XXKVSEntry(key, pBuff, len); + + if (mPHead) + { + pEntryNew->mPNext = mPHead; + } + + mPHead = pEntryNew; + + err = CHIP_NO_ERROR; + } + else + { + err = pEntry->UpdateVal(pBuff, len); + } + return err; + } + + CHIP_ERROR DeleteEntryByKey(char * key) + { + CHIP_ERROR err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; + + CC32XXKVSEntry * temp = mPHead; + CC32XXKVSEntry * prev = NULL; + + const char * tempKey = temp->Key(); + + if (strcmp(tempKey, key) == 0) + { + mPHead = temp->mPNext; + temp->DeleteVal(); + delete temp; + err = CHIP_NO_ERROR; + } + else + { + while (temp != NULL && strcmp(temp->Key(), key) != 0) + { + prev = temp; + temp = temp->mPNext; + } + if (temp != NULL) + { + prev->mPNext = temp->mPNext; + + delete temp; + err = CHIP_NO_ERROR; + } + } + + return err; + } + + uint8_t * SerializeLinkedList(uint16_t * length) + { + uint8_t * list = new uint8_t[8192]; + CC32XXKVSEntry * currentEntry = mPHead; + uint16_t bufferLength = 0; + + while (currentEntry != NULL) + { + // copy key length + list[bufferLength] = (uint8_t) strlen(currentEntry->Key()); + bufferLength++; + + // copy key + memcpy(list + bufferLength, currentEntry->Key(), strlen(currentEntry->Key())); + bufferLength += (uint16_t) strlen(currentEntry->Key()); + + // copy value length + list[bufferLength] = (uint8_t) (currentEntry->Len() & 0xFF); + list[bufferLength + 1] = (uint8_t) ((currentEntry->Len() & 0xFF00) >> 8); + bufferLength = bufferLength + 2; + + // copy value + uint8_t * value = currentEntry->Value(); + memcpy(list + bufferLength, value, currentEntry->Len()); + bufferLength += currentEntry->Len(); + + currentEntry = currentEntry->mPNext; + } + + *length = bufferLength; + + return list; + } + + void CreateLinkedListFromNV(uint8_t * list, uint16_t length) + { + uint16_t currentLength = 0; + + // check for end of LL + while (currentLength < length) + { + // read in key length + uint8_t keyLen = list[currentLength]; + currentLength++; + + // read in key + + char key[40] = { 0 }; + memcpy(key, list + currentLength, keyLen); + currentLength += keyLen; + + // read in value length + + uint16_t valueLen = 0; + valueLen = (uint16_t) (list[currentLength] | list[currentLength + 1] << 8); + currentLength += 2; + + // read in value + + uint8_t * value = new uint8_t[valueLen]; + memcpy(value, list + currentLength, valueLen); + currentLength += valueLen; + + // add entry to LL + + AddEntryByKey(key, value, valueLen); + + // value is stored in the LL, we do not need the value variable above + + delete value; + } + } +}; + +// *** CAUTION ***: Changing the names or namespaces of these values will *break* existing devices. + +// Keys stored in the Chip-factory namespace +const CC32XXConfig::Key CC32XXConfig::kConfigKey_SerialNum = { "TI_kConfigKey_SerialNum" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_MfrDeviceId = { "TI_kConfigKey_MfrDeviceId" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_MfrDeviceCert = { "TI_kConfigKey_MfrDeviceCert" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_MfrDeviceICACerts = { "TI_kConfigKey_MfrDeviceICACerts" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_MfrDevicePrivateKey = { "TI_kConfigKey_MfrDevicePrivateKey" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_HardwareVersion = { "TI_kConfigKey_HardwareVersion" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_ManufacturingDate = { "TI_kConfigKey_ManufacturingDate" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_SetupPinCode = { "TI_kConfigKey_SetupPinCode" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_SetupDiscriminator = { "TI_kConfigKey_SetupDiscriminator" }; + +// Keys stored in the Chip-config namespace +const CC32XXConfig::Key CC32XXConfig::kConfigKey_FabricId = { "TI_kConfigKey_FabricId" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_ServiceConfig = { "TI_kConfigKey_ServiceConfig" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_PairedAccountId = { "TI_kConfigKey_PairedAccountId" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_ServiceId = { "TI_kConfigKey_ServiceId" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_FabricSecret = { "TI_kConfigKey_FabricSecret" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_GroupKeyIndex = { "TI_kConfigKey_GroupKeyIndex" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_LastUsedEpochKeyId = { "TI_kConfigKey_LastUsedEpochKeyId" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_FailSafeArmed = { "TI_kConfigKey_FailSafeArmed" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_WiFiStationSecType = { "TI_kConfigKey_WiFiStationSecType" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_RegulatoryLocation = { "TI_kConfigKey_RegulatoryLocation" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_CountryCode = { "TI_kConfigKey_CountryCode" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_Breadcrumb = { "TI_kConfigKey_Breadcrumb" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_UniqueId = { "TI_kConfigKey_UniqueId" }; + +const CC32XXConfig::Key CC32XXConfig::kConfigKey_Spake2pIterationCount = { "TI_kConfigKey_Spake2pIterationCount" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_Spake2pSalt = { "TI_kConfigKey_Spake2pSalt" }; +const CC32XXConfig::Key CC32XXConfig::kConfigKey_Spake2pVerifier = { "TI_kConfigKey_Spake2pVerifier" }; + +CC32XXKVSList * pList; + +CHIP_ERROR CC32XXConfig::Init() +{ + cc32xxLog("[%s], KVS List created", __FUNCTION__); + pList = new CC32XXKVSList(); + ReadKVSFromNV(); + return CHIP_NO_ERROR; +} + +CHIP_ERROR CC32XXConfig::ReadConfigValue(Key key, bool & val) +{ + CHIP_ERROR ret; + size_t ignore; + uint8_t localVal; + cc32xxLog("[%s]", __FUNCTION__); + + ret = ReadConfigValueBin(key, &localVal, sizeof(localVal), ignore); + + // reference CC32XXConfig::WriteConfigValue(Key key, bool val) for storage of boolean values + val = (localVal != 0); + + return ret; +} + +CHIP_ERROR CC32XXConfig::ReadConfigValue(Key key, uint32_t & val) +{ + size_t ignore; + return ReadConfigValueBin(key, (uint8_t *) &val, sizeof(val), ignore); +} + +CHIP_ERROR CC32XXConfig::ReadConfigValue(Key key, uint64_t & val) +{ + size_t ignore; + return ReadConfigValueBin(key, (uint8_t *) &val, sizeof(val), ignore); +} + +CHIP_ERROR CC32XXConfig::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) +{ + return ReadConfigValueBin(key, (uint8_t *) buf, bufSize, outLen); +} + +CHIP_ERROR CC32XXConfig::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) +{ + cc32xxLog("[%s]", __FUNCTION__); + + CC32XXKVSEntry * pEntry = pList->GetEntryByKey(key.key); + + VerifyOrReturnError(pEntry != nullptr, CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND); + + pEntry->ReadVal(buf, bufSize); + if (outLen) + { + outLen = pEntry->Len(); + } + return CHIP_NO_ERROR; +} + +CHIP_ERROR CC32XXConfig::WriteConfigValue(Key key, bool val) +{ + uint8_t localVal = val ? 1 : 0; + return WriteConfigValueBin(key, (const uint8_t *) &localVal, sizeof(localVal)); +} + +CHIP_ERROR CC32XXConfig::WriteConfigValue(Key key, uint32_t val) +{ + return WriteConfigValueBin(key, (const uint8_t *) &val, sizeof(val)); +} + +CHIP_ERROR CC32XXConfig::WriteConfigValue(Key key, uint64_t val) +{ + return WriteConfigValueBin(key, (const uint8_t *) &val, sizeof(val)); +} + +CHIP_ERROR CC32XXConfig::WriteConfigValueStr(Key key, const char * str) +{ + size_t strLen = strlen(str); + return WriteConfigValueBin(key, (const uint8_t *) str, strLen); +} +CHIP_ERROR CC32XXConfig::WriteConfigValueStr(Key key, const char * str, size_t strLen) +{ + return WriteConfigValueBin(key, (const uint8_t *) str, strLen); +} + +CHIP_ERROR CC32XXConfig::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) +{ + cc32xxLog("[%s]", __FUNCTION__); + CHIP_ERROR err = CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND; + err = pList->AddEntryByKey(key.key, data, (uint16_t) dataLen); + return err; +} + +CHIP_ERROR CC32XXConfig::ClearConfigValue(Key key) +{ + cc32xxLog("[%s]", __FUNCTION__); + CHIP_ERROR err = CHIP_NO_ERROR; + pList->DeleteEntryByKey(key.key); + return err; +} + +bool CC32XXConfig::ConfigValueExists(Key key) +{ + cc32xxLog("[%s]", __FUNCTION__); + bool ret = false; + CC32XXKVSEntry * pEntry = pList->GetEntryByKey(key.key); + if (pEntry) + ret = true; + return ret; +} + +CHIP_ERROR CC32XXConfig::FactoryResetConfig() +{ + cc32xxLog("[%s]", __FUNCTION__); + while (1) + ; + CHIP_ERROR err = CHIP_NO_ERROR; + return err; +} + +void CC32XXConfig::RunConfigUnitTest() +{ + cc32xxLog("[%s]", __FUNCTION__); + // Run common unit test. + ::chip::DeviceLayer::Internal::RunConfigUnitTest(); +} + +CHIP_ERROR CC32XXConfig::ClearKVS(const char * key) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + char keyBuffer[40] = ""; + memcpy(keyBuffer, key, strlen(key)); + err = pList->DeleteEntryByKey(keyBuffer); + cc32xxLog("[%s] key %s", __FUNCTION__, key); + return err; +} + +CHIP_ERROR CC32XXConfig::WriteKVS(const char * key, const void * value, size_t value_size) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + cc32xxLog("[%s] Key is %s value size is %d ", __FUNCTION__, key, value_size); + // Write key value pair as LL entry in RAM buffer + char keyBuffer[40] = ""; + memcpy(keyBuffer, key, strlen(key)); + pList->AddEntryByKey(keyBuffer, (uint8_t *) value, value_size); + + return err; +} + +CHIP_ERROR CC32XXConfig::ReadKVS(const char * key, void * value, size_t value_size, size_t * read_bytes_size, size_t offset_bytes) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + CC32XXKVSEntry * entry = pList->GetEntryByKey(key); + // if (!entry) + // { + // err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; + // return err; + // } + VerifyOrReturnError(entry != nullptr, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + uint8_t * entryValue = entry->Value(); + uint16_t valueLen = entry->Len(); + + size_t readLen; + + if ((offset_bytes + value_size) > valueLen) + { + // trying to read up to the end of the element + readLen = valueLen - offset_bytes; + } + else + { + readLen = value_size; + } + + memcpy(value, entryValue + offset_bytes, readLen); + + if (read_bytes_size) + { + *read_bytes_size = readLen; + } + + cc32xxLog("[%s] key %s, read %d bytes", __FUNCTION__, key, readLen); + return err; +} + +CHIP_ERROR CC32XXConfig::WriteKVSToNV() +{ + uint8_t * list = pList->SerializeLinkedList(&NVBufferLength); + + uint32_t token = KVS_TOKEN; + + uint32_t fileSystemFlags = SL_FS_CREATE_STATIC_TOKEN | SL_FS_CREATE_VENDOR_TOKEN; + + int ret = FILE_write(listName, NVBufferLength, list, &token, fileSystemFlags); + if (ret < 0) + { + cc32xxLog("could not write in Linked List to NV, error %d", ret); + return CHIP_ERROR_PERSISTED_STORAGE_FAILED; + } + + else + { + return CHIP_NO_ERROR; + } + // return error +} + +CHIP_ERROR CC32XXConfig::ReadKVSFromNV() +{ + int rc; + uint16_t bufferLength; + + uint8_t * list = new uint8_t[NV_BUFFER_SIZE]; + rc = FILE_read((int8_t *) listName, NV_BUFFER_SIZE, list, KVS_TOKEN); + if (rc > 0) + { + bufferLength = rc; + pList->CreateLinkedListFromNV(list, bufferLength); + cc32xxLog("read in KVS Linked List from NV"); + return CHIP_NO_ERROR; + } + else + { + cc32xxLog("could not read in Linked List from NV, error %d", rc); + return CHIP_ERROR_PERSISTED_STORAGE_FAILED; + } +} + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/CC32XXConfig.h b/src/platform/cc32xx/CC32XXConfig.h new file mode 100644 index 00000000000000..5824afa3d50042 --- /dev/null +++ b/src/platform/cc32xx/CC32XXConfig.h @@ -0,0 +1,101 @@ +/* + * + * 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 + * Utilities for accessing persisted device configuration on + * Texas Instruments cc32xx SoCs. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { +namespace Internal { + +class CC32XXConfig +{ +public: + struct Key; + + // Key definitions for well-known keys. + static const Key kConfigKey_SerialNum; + static const Key kConfigKey_MfrDeviceId; + static const Key kConfigKey_MfrDeviceCert; + static const Key kConfigKey_MfrDeviceICACerts; + static const Key kConfigKey_MfrDevicePrivateKey; + static const Key kConfigKey_HardwareVersion; + static const Key kConfigKey_ManufacturingDate; + static const Key kConfigKey_SetupPinCode; + static const Key kConfigKey_SetupDiscriminator; + static const Key kConfigKey_FabricId; + static const Key kConfigKey_ServiceConfig; + static const Key kConfigKey_PairedAccountId; + static const Key kConfigKey_ServiceId; + static const Key kConfigKey_FabricSecret; + static const Key kConfigKey_GroupKeyIndex; + static const Key kConfigKey_LastUsedEpochKeyId; + static const Key kConfigKey_FailSafeArmed; + static const Key kConfigKey_WiFiStationSecType; + static const Key kConfigKey_RegulatoryLocation; + static const Key kConfigKey_CountryCode; + static const Key kConfigKey_Breadcrumb; + static const Key kConfigKey_UniqueId; + + static const Key kConfigKey_Spake2pIterationCount; + static const Key kConfigKey_Spake2pSalt; + static const Key kConfigKey_Spake2pVerifier; + + static CHIP_ERROR Init(void); + + // Config value accessors. + static CHIP_ERROR ReadConfigValue(Key key, bool & val); + static CHIP_ERROR ReadConfigValue(Key key, uint32_t & val); + static CHIP_ERROR ReadConfigValue(Key key, uint64_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, bool val); + static CHIP_ERROR WriteConfigValue(Key key, uint32_t val); + static CHIP_ERROR WriteConfigValue(Key key, uint64_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); + + // internal to the platform for KeyValueStoreManagerImpl.cpp + static CHIP_ERROR ReadKVS(const char * key, void * value, size_t value_size, size_t * read_bytes_size, size_t offset_bytes); + static CHIP_ERROR WriteKVS(const char * key, const void * value, size_t value_size); + static CHIP_ERROR ClearKVS(const char * key); + + static CHIP_ERROR WriteKVSToNV(void); + static CHIP_ERROR ReadKVSFromNV(void); +}; + +struct CC32XXConfig::Key +{ + char key[40]; +}; + +} // namespace Internal +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/CHIPDevicePlatformConfig.h b/src/platform/cc32xx/CHIPDevicePlatformConfig.h new file mode 100644 index 00000000000000..0a3b387aa4df0e --- /dev/null +++ b/src/platform/cc32xx/CHIPDevicePlatformConfig.h @@ -0,0 +1,47 @@ +/* + * + * 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 Device Layer + * for the Texas Instruments CC32XX platform. + * + * NOTE: currently a bare-bones implementation to allow for building. + */ + +#ifndef CHIP_DEVICE_PLATFORM_CONFIG_H +#define CHIP_DEVICE_PLATFORM_CONFIG_H + +// XXX: Seth this needs to be updated for TI devices + +// ==================== Platform Adaptations ==================== + +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION 1 +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI_AP 1 +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI CHIP_DEVICE_CONFIG_ENABLE_WIFI_AP | CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION + +// ========== Platform-specific Configuration ========= + +#define CHIP_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY 0 +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY 0 +#define CHIP_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY_FULL 0 +#define CHIP_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY 0 +#define CHIP_DEVICE_CONFIG_LOG_PROVISIONING_HASH 0 + +// ========== CHIP Platform Configuration ========= +#define CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE (8192) +#endif // CHIP_DEVICE_PLATFORM_CONFIG_H diff --git a/src/platform/cc32xx/CHIPDevicePlatformEvent.h b/src/platform/cc32xx/CHIPDevicePlatformEvent.h new file mode 100644 index 00000000000000..4085925ef7b5bc --- /dev/null +++ b/src/platform/cc32xx/CHIPDevicePlatformEvent.h @@ -0,0 +1,46 @@ +/* + * + * 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 + * Defines platform-specific event types and data for the chip + * for the Texas Instruments CC32XX platform. + * + * NOTE: currently a bare-bones implementation to allow for building. + */ + +#ifndef CHIP_DEVICE_PLATFORM_EVENT_H +#define CHIP_DEVICE_PLATFORM_EVENT_H + +#include + +// XXX: Seth, what device events do we need + +namespace chip { +namespace DeviceLayer { + +/** + * Represents platform-specific event information + */ +struct ChipDevicePlatformEvent final +{ +}; + +} // namespace DeviceLayer +} // namespace chip + +#endif // CHIP_DEVICE_PLATFORM_EVENT_H diff --git a/src/platform/cc32xx/CHIPPlatformConfig.h b/src/platform/cc32xx/CHIPPlatformConfig.h new file mode 100644 index 00000000000000..5eb53c5f41452f --- /dev/null +++ b/src/platform/cc32xx/CHIPPlatformConfig.h @@ -0,0 +1,89 @@ +/* + * + * 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 CHIP on + * the Texas Instruments CC32XX platform. + * + */ + +#ifndef CHIP_PLATFORM_CONFIG_H +#define CHIP_PLATFORM_CONFIG_H + +#include + +// ==================== General Platform Adaptations ==================== + +// XXX: Seth is there a platform specific error we can use?? +#define CHIP_CONFIG_ERROR_TYPE uint32_t +#define CHIP_CONFIG_NO_ERROR (0) + +// XXX: Seth is there a platform specific error we can use?? +#define ASN1_CONFIG_ERROR_TYPE uint32_t +#define ASN1_CONFIG_NO_ERROR (0) + +// XXX: Seth is there a platform specific version that would work better +#define ChipDie() assert() + +#define CHIP_CONFIG_PERSISTED_STORAGE_KEY_TYPE char * +#define CHIP_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID 1 +#define CHIP_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH 2 + +#define CHIP_CONFIG_PERSISTED_STORAGE_KEY_GLOBAL_MESSAGE_COUNTER (char *) "GlobalMCTR" + +// ==================== Security Adaptations ==================== + +// XXX: Seth, how much of this can we move to mbedtls?? +#define CHIP_CONFIG_USE_OPENSSL_ECC 0 +#define CHIP_CONFIG_USE_MICRO_ECC 1 + +#define CHIP_CONFIG_HASH_IMPLEMENTATION_OPENSSL 0 +#define CHIP_CONFIG_HASH_IMPLEMENTATION_MINCRYPT 1 +#define CHIP_CONFIG_HASH_IMPLEMENTATION_MBEDTLS 0 +#define CHIP_CONFIG_HASH_IMPLEMENTATION_PLATFORM 0 + +#define CHIP_CONFIG_AES_IMPLEMENTATION_OPENSSL 0 +#define CHIP_CONFIG_AES_IMPLEMENTATION_AESNI 0 +#define CHIP_CONFIG_AES_IMPLEMENTATION_MBEDTLS 1 +#define CHIP_CONFIG_AES_IMPLEMENTATION_PLATFORM 0 + +#define CHIP_CONFIG_RNG_IMPLEMENTATION_OPENSSL 0 +#define CHIP_CONFIG_RNG_IMPLEMENTATION_CHIPDRBG 1 +#define CHIP_CONFIG_RNG_IMPLEMENTATION_PLATFORM 0 + +#define CHIP_CONFIG_ENABLE_PASE_INITIATOR 0 +#define CHIP_CONFIG_ENABLE_PASE_RESPONDER 1 +#define CHIP_CONFIG_ENABLE_CASE_INITIATOR 1 + +#define CHIP_CONFIG_SUPPORT_PASE_CONFIG0 0 +#define CHIP_CONFIG_SUPPORT_PASE_CONFIG1 0 +#define CHIP_CONFIG_SUPPORT_PASE_CONFIG2 0 +#define CHIP_CONFIG_SUPPORT_PASE_CONFIG3 0 +#define CHIP_CONFIG_SUPPORT_PASE_CONFIG4 1 + +#define CHIP_CONFIG_ENABLE_KEY_EXPORT_INITIATOR 0 + +#define CHIP_CONFIG_ENABLE_PROVISIONING_BUNDLE_SUPPORT 0 + +#define CHIP_CONFIG_ENABLE_SERVER_IM_EVENT 1 + +// ==================== General Configuration Overrides ==================== + +/* none yet */ + +#endif /* CHIP_PLATFORM_CONFIG_H */ diff --git a/src/platform/cc32xx/ConfigurationManagerImpl.cpp b/src/platform/cc32xx/ConfigurationManagerImpl.cpp new file mode 100644 index 00000000000000..36028eab69a18d --- /dev/null +++ b/src/platform/cc32xx/ConfigurationManagerImpl.cpp @@ -0,0 +1,201 @@ +/* + * + * 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 the implementation of the Device Layer ConfigurationManager object + * for the Texas Instruments CC32XX platform. + * + */ + +/* this file behaves like a config.h, comes first */ +#include + +#include +#include + +#include +#include + +#include +#include + +#include + +#include + +#include + +#include + +#include +extern "C" void cc32xxLog(const char * aFormat, ...); + +namespace chip { +namespace DeviceLayer { + +using namespace ::chip::DeviceLayer::Internal; + +ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance() +{ + static ConfigurationManagerImpl sInstance; + return sInstance; +} + +CHIP_ERROR ConfigurationManagerImpl::Init() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + // Initialize the generic implementation base class. + err = Internal::GenericConfigurationManagerImpl::Init(); + + return err; +} + +bool ConfigurationManagerImpl::CanFactoryReset() +{ + // TODO: query the application to determine if factory reset is allowed. + return true; +} + +void ConfigurationManagerImpl::InitiateFactoryReset() +{ + PlatformMgr().ScheduleWork(DoFactoryReset); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t & value) +{ + + CC32XXConfig::Key configKey{ *key }; + + CHIP_ERROR err = ReadConfigValue(configKey, value); + + if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND) + { + err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; + } + + return CHIP_NO_ERROR; +} + +CHIP_ERROR ConfigurationManagerImpl::GetPrimaryWiFiMACAddress(uint8_t * buf) +{ +#if CHIP_DEVICE_CONFIG_ENABLE_WIFI + uint16_t macAddressLen = SL_MAC_ADDR_LEN; + uint16_t ConfigOpt = 0; + sl_NetCfgGet(SL_NETCFG_MAC_ADDRESS_GET, &ConfigOpt, &macAddressLen, (_u8 *) buf); + return CHIP_NO_ERROR; + +#else + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +#endif +} + +CHIP_ERROR ConfigurationManagerImpl::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key key, uint32_t value) +{ + CC32XXConfig::Key configKey{ *key }; + return WriteConfigValue(configKey, value); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val) +{ + return CC32XXConfig::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val) +{ + return CC32XXConfig::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val) +{ + return CC32XXConfig::ReadConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) +{ + return CC32XXConfig::ReadConfigValueStr(key, buf, bufSize, outLen); +} + +CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) +{ + return CC32XXConfig::ReadConfigValueBin(key, buf, bufSize, outLen); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val) +{ + return CC32XXConfig::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val) +{ + return CC32XXConfig::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val) +{ + return CC32XXConfig::WriteConfigValue(key, val); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str) +{ + return CC32XXConfig::WriteConfigValueStr(key, str); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen) +{ + return CC32XXConfig::WriteConfigValueStr(key, str, strLen); +} + +CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) +{ + return CC32XXConfig::WriteConfigValueBin(key, data, dataLen); +} + +void ConfigurationManagerImpl::RunConfigUnitTest(void) +{ + CC32XXConfig::RunConfigUnitTest(); +} + +void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg) +{ + CHIP_ERROR err; + + ChipLogProgress(DeviceLayer, "Performing factory reset"); + + err = CC32XXConfig::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"); + // There should probably be an OS API for this + MAP_PRCMHibernateCycleTrigger(); +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/ConfigurationManagerImpl.h b/src/platform/cc32xx/ConfigurationManagerImpl.h new file mode 100644 index 00000000000000..64be94ae27f57e --- /dev/null +++ b/src/platform/cc32xx/ConfigurationManagerImpl.h @@ -0,0 +1,73 @@ +/* + * + * 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 ConfigurationManager object + * for the Texas Instruments CC32XX platform. + */ + +#pragma once + +#include +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the ConfigurationManager singleton object for the CC32XX 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; + CHIP_ERROR GetPrimaryWiFiMACAddress(uint8_t * buf) 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/cc32xx/ConnectivityManagerImpl.cpp b/src/platform/cc32xx/ConnectivityManagerImpl.cpp new file mode 100644 index 00000000000000..e14436152d4f99 --- /dev/null +++ b/src/platform/cc32xx/ConnectivityManagerImpl.cpp @@ -0,0 +1,240 @@ +/* + * + * Copyright (c) 2020 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. + */ +/* this file behaves like a config.h, comes first */ +#include + +#include +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE +#include +#endif +#include + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include + +extern "C" +{ +#include + +#define SLNETCONN_TIMEOUT 0xffff // "infinite" Timeout + +extern int LWIP_IF_start(); +extern void SlNetConnEventHandler(uint32_t ifID, SlNetConnStatus_e netStatus, void * data); +} + +#if !CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION +#error "WiFi Station support must be enabled when building for CC32XX" +#endif + +#if !CHIP_DEVICE_CONFIG_ENABLE_WIFI_AP +#error "WiFi AP support must be enabled when building for CC32XX" +#endif + +using namespace ::chip; +using namespace ::chip::Inet; +using namespace ::chip::System; +using namespace ::chip::TLV; + +extern "C" void cc32xxLog(const char * aFormat, ...); + +namespace chip { +namespace DeviceLayer { + +ConnectivityManagerImpl ConnectivityManagerImpl::sInstance; + +ConnectivityManager::WiFiStationMode ConnectivityManagerImpl::_GetWiFiStationMode(void) +{ + cc32xxLog("ConnectivityManagerImpl::_GetWiFiStationMode()\n\r"); + return mWiFiStationMode; +} + +bool ConnectivityManagerImpl::_IsWiFiStationEnabled(void) +{ + cc32xxLog("ConnectivityManagerImpl::_IsWiFiStationEnabled()\n\r"); + return GetWiFiStationMode() == kWiFiStationMode_Enabled; +} + +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiStationMode(WiFiStationMode val) +{ + cc32xxLog("ConnectivityManagerImpl::_SetWiFiStationMode(%d)\n\r", val); + return CHIP_NO_ERROR; +} + +bool ConnectivityManagerImpl::_IsWiFiStationProvisioned(void) +{ + cc32xxLog("ConnectivityManagerImpl::_IsWiFiStationProvisioned()\n\r"); + return true; +} + +void ConnectivityManagerImpl::_ClearWiFiStationProvision(void) +{ + cc32xxLog("ConnectivityManagerImpl::_ClearWiFiStationProvision()\n\r"); +} + +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiAPMode(WiFiAPMode val) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + cc32xxLog("ConnectivityManagerImpl::_SetWiFiAPMode(%d)\n\r", val); + return err; +} + +void ConnectivityManagerImpl::_DemandStartWiFiAP(void) +{ + cc32xxLog("ConnectivityManagerImpl::_DemandStartWiFiAP()\n\r"); +} + +void ConnectivityManagerImpl::_StopOnDemandWiFiAP(void) +{ + cc32xxLog("ConnectivityManagerImpl::_StopOnDemandWiFiAP()\n\r"); +} + +void ConnectivityManagerImpl::_MaintainOnDemandWiFiAP(void) +{ + cc32xxLog("ConnectivityManagerImpl::_MaintainOnDemandWiFiAP()\n\r"); +} + +void ConnectivityManagerImpl::_SetWiFiAPIdleTimeoutMS(uint32_t val) +{ + cc32xxLog("ConnectivityManagerImpl::_SetWiFiAPIdleTimeoutMS()\n\r"); + mWiFiAPIdleTimeoutMS = val; + // SystemLayer.ScheduleWork(DriveAPState, NULL); +} + +CHIP_ERROR ConnectivityManagerImpl::_GetAndLogWifiStatsCounters(void) +{ + cc32xxLog("ConnectivityManagerImpl::_GetAndLogWifiStatsCounters()\n\r"); + return CHIP_NO_ERROR; +} + +// ==================== ConnectivityManager Platform Internal Methods ==================== + +CHIP_ERROR ConnectivityManagerImpl::_Init() +{ + + cc32xxLog("ConnectivityManagerImpl::_Init()\n\r"); + + int rc; + cc32xxLog("Start Wi-Fi\r\n"); + /* Try to connect to AP and go through provisioning (if needed) */ + rc = SlNetConn_start(SLNETCONN_SERVICE_LVL_MAC, SlNetConnEventHandler, SLNETCONN_TIMEOUT, 0); + assert(rc == 0); + + cc32xxLog("Start LWIP IF\n\r"); + rc = LWIP_IF_start(); + if (rc != 0) + { + cc32xxLog("LWIP IF not started, error = ", rc); + } + + return CHIP_NO_ERROR; +} + +void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) +{ + cc32xxLog("ConnectivityManagerImpl::_OnPlatformEvent()\n\r"); + + if (event->Type == DeviceLayer::DeviceEventType::kCommissioningComplete) + { + // if (event->CommissioningComplete.Status == CHIP_NO_ERROR) + // { + ChipLogProgress(AppServer, "Commissioning completed successfully"); + DeviceLayer::Internal::CC32XXConfig::WriteKVSToNV(); + // } + // else + // { + // ChipLogError(AppServer, "Commissioning failed with error %" CHIP_ERROR_FORMAT, + // event->CommissioningComplete.Status.Format()); + // } + } +} + +void ConnectivityManagerImpl::_OnWiFiScanDone() +{ + cc32xxLog("ConnectivityManagerImpl::_OnWiFiScanDone()\n\r"); +} +void ConnectivityManagerImpl::_OnWiFiStationProvisionChange() +{ + cc32xxLog("ConnectivityManagerImpl::_OnWiFiStationProvisionChange()\n\r"); +} + +// ==================== ConnectivityManager Private Methods ==================== + +void ConnectivityManagerImpl::DriveStationState() +{ + cc32xxLog("ConnectivityManagerImpl::DriveStationState()\n\r"); +} + +void ConnectivityManagerImpl::OnStationConnected() +{ + cc32xxLog("ConnectivityManagerImpl::OnStationConnected()\n\r"); +} + +void ConnectivityManagerImpl::ChangeWiFiStationState(WiFiStationState newState) +{ + cc32xxLog("ConnectivityManagerImpl::ChangeWiFiStationState()\n\r"); +} + +CHIP_ERROR ConnectivityManagerImpl::ConfigureWiFiAP() +{ + cc32xxLog("ConnectivityManagerImpl::ConfigureWiFiAP()\n\r"); + return CHIP_NO_ERROR; +} + +void ConnectivityManagerImpl::ChangeWiFiAPState(WiFiAPState newState) +{ + cc32xxLog("ConnectivityManagerImpl::ChangeWiFiAPState()\n\r"); +} + +void ConnectivityManagerImpl::UpdateInternetConnectivityState(void) +{ + cc32xxLog("ConnectivityManagerImpl::UpdateInternetConnectivityState()\n\r"); +} + +void ConnectivityManagerImpl::OnStationIPv4AddressAvailable() +{ + cc32xxLog("ConnectivityManagerImpl::OnStationIPv4AddressAvailable()\n\r"); +} + +void ConnectivityManagerImpl::OnStationIPv4AddressLost(void) +{ + cc32xxLog("ConnectivityManagerImpl::OnStationIPv4AddressLost()\n\r"); +} + +void ConnectivityManagerImpl::OnIPv6AddressAvailable() +{ + cc32xxLog("ConnectivityManagerImpl::OnIPv6AddressAvailable()\n\r"); +} + +void ConnectivityManagerImpl::RefreshMessageLayer(void) +{ + cc32xxLog("ConnectivityManagerImpl::RefreshMessageLayer()\n\r"); +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/ConnectivityManagerImpl.h b/src/platform/cc32xx/ConnectivityManagerImpl.h new file mode 100644 index 00000000000000..75d9866fbcb5af --- /dev/null +++ b/src/platform/cc32xx/ConnectivityManagerImpl.h @@ -0,0 +1,168 @@ +/* + * + * 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 connectivity manager class + * for the Texas Instruments CC32XX platform. + * + * NOTE: currently a bare-bones implementation to allow for building. + */ + +#pragma once + +#include +#include +#include +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE +#include +#else +#include +#endif +#include + +namespace chip { +namespace Inet { + +class IPAddress; + +} // namespace Inet +} // namespace chip + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the ConnectivityManager singleton object for the CC32XX platforms. + */ +class ConnectivityManagerImpl final : public ConnectivityManager, + public Internal::GenericConnectivityManagerImpl, + public Internal::GenericConnectivityManagerImpl_WiFi, +#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE + public Internal::GenericConnectivityManagerImpl_BLE, +#else + public Internal::GenericConnectivityManagerImpl_NoBLE, +#endif + public Internal::GenericConnectivityManagerImpl_NoThread + +{ + // 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. + + WiFiStationMode _GetWiFiStationMode(void); + CHIP_ERROR _SetWiFiStationMode(WiFiStationMode val); + bool _IsWiFiStationEnabled(void); + bool _IsWiFiStationApplicationControlled(void); + bool _IsWiFiStationConnected(void); + uint32_t _GetWiFiStationReconnectIntervalMS(void); + CHIP_ERROR _SetWiFiStationReconnectIntervalMS(uint32_t val); + bool _IsWiFiStationProvisioned(void); + void _ClearWiFiStationProvision(void); + WiFiAPMode _GetWiFiAPMode(void); + CHIP_ERROR _SetWiFiAPMode(WiFiAPMode val); + bool _IsWiFiAPActive(void); + bool _IsWiFiAPApplicationControlled(void); + void _DemandStartWiFiAP(void); + void _StopOnDemandWiFiAP(void); + void _MaintainOnDemandWiFiAP(void); + uint32_t _GetWiFiAPIdleTimeoutMS(void); + void _SetWiFiAPIdleTimeoutMS(uint32_t val); + CHIP_ERROR _GetAndLogWifiStatsCounters(void); + bool _HaveIPv4InternetConnectivity(void); + bool _HaveIPv6InternetConnectivity(void); + bool _HaveServiceConnectivity(void); + CHIP_ERROR _Init(void); + void _OnPlatformEvent(const ChipDeviceEvent * event); + bool _CanStartWiFiScan(); + void _OnWiFiScanDone(); + void _OnWiFiStationProvisionChange(); + + // ===== Members for internal use by the following friends. + + friend ConnectivityManager & ConnectivityMgr(void); + friend ConnectivityManagerImpl & ConnectivityMgrImpl(void); + + static ConnectivityManagerImpl sInstance; + + // ===== Private members reserved for use by this class only. + + uint64_t mLastStationConnectFailTime; + uint64_t mLastAPDemandTime; + WiFiStationMode mWiFiStationMode; + WiFiStationState mWiFiStationState; + WiFiAPMode mWiFiAPMode; + WiFiAPState mWiFiAPState; + uint32_t mWiFiStationReconnectIntervalMS; + uint32_t mWiFiAPIdleTimeoutMS; + uint16_t mFlags; + + void DriveStationState(void); + void OnStationConnected(void); + void OnStationDisconnected(void); + void ChangeWiFiStationState(WiFiStationState newState); + // static void DriveStationState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError); + + void DriveAPState(void); + CHIP_ERROR ConfigureWiFiAP(void); + void ChangeWiFiAPState(WiFiAPState newState); + // static void DriveAPState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError); + + void UpdateInternetConnectivityState(void); + void OnStationIPv4AddressAvailable(); + void OnStationIPv4AddressLost(void); + void OnIPv6AddressAvailable(); + + static void RefreshMessageLayer(void); +}; + +inline bool ConnectivityManagerImpl::_HaveIPv4InternetConnectivity(void) +{ + return false; +} + +inline bool ConnectivityManagerImpl::_HaveIPv6InternetConnectivity(void) +{ + return false; +} + +/** + * 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 CC32XX platform + */ +inline ConnectivityManagerImpl & ConnectivityMgrImpl(void) +{ + return ConnectivityManagerImpl::sInstance; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.cpp b/src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.cpp new file mode 100644 index 00000000000000..0f87641906c80b --- /dev/null +++ b/src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.cpp @@ -0,0 +1,44 @@ +/* + * + * 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" + +#if CHIP_ENABLE_OPENTHREAD +#include +#endif + +namespace chip { +namespace DeviceLayer { + +CHIP_ERROR +DeviceNetworkProvisioningDelegateImpl::_ProvisionThreadNetwork(ByteSpan threadData) +{ +#if CHIP_ENABLE_OPENTHREAD + 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_ENABLE_OPENTHREAD +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.h b/src/platform/cc32xx/DeviceNetworkProvisioningDelegateImpl.h new file mode 100644 index 00000000000000..e799358e4b7536 --- /dev/null +++ b/src/platform/cc32xx/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/cc32xx/DiagnosticDataProviderImpl.cpp b/src/platform/cc32xx/DiagnosticDataProviderImpl.cpp new file mode 100644 index 00000000000000..17f9fbbe3cca41 --- /dev/null +++ b/src/platform/cc32xx/DiagnosticDataProviderImpl.cpp @@ -0,0 +1,60 @@ +/* + * + * 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 cc32xx platform. + */ + +#include + +#include +#include +#include + +namespace chip { +namespace DeviceLayer { + +DiagnosticDataProviderImpl & DiagnosticDataProviderImpl::GetDefaultInstance() +{ + static DiagnosticDataProviderImpl sInstance; + return sInstance; +} + +/* + * The following Heap stats are compiled values done by the heap4 heap implementation. + */ +CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapFree(uint64_t & currentHeapFree) +{ + return CHIP_NO_ERROR; +} + +CHIP_ERROR DiagnosticDataProviderImpl::GetCurrentHeapUsed(uint64_t & currentHeapUsed) +{ + return CHIP_NO_ERROR; +} + +CHIP_ERROR DiagnosticDataProviderImpl::GetThreadMetrics(ThreadMetrics ** threadMetricsOut) +{ + return CHIP_NO_ERROR; +} + +void DiagnosticDataProviderImpl::ReleaseThreadMetrics(ThreadMetrics * threadMetrics) {} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/DiagnosticDataProviderImpl.h b/src/platform/cc32xx/DiagnosticDataProviderImpl.h new file mode 100644 index 00000000000000..b742146267621d --- /dev/null +++ b/src/platform/cc32xx/DiagnosticDataProviderImpl.h @@ -0,0 +1,46 @@ +/* + * + * 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 + +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 GetThreadMetrics(ThreadMetrics ** threadMetricsOut) override; + void ReleaseThreadMetrics(ThreadMetrics * threadMetrics) override; +}; + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/FreeRTOSConfig.h b/src/platform/cc32xx/FreeRTOSConfig.h new file mode 100755 index 00000000000000..2dc4874d7a3549 --- /dev/null +++ b/src/platform/cc32xx/FreeRTOSConfig.h @@ -0,0 +1,212 @@ +/* + * + * Copyright (c) 2020 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. + */ + +/****************************************************************************** + See http://www.freertos.org/a00110.html for an explanation of the + definitions contained in this file. +******************************************************************************/ + +#pragma once + +/*----------------------------------------------------------- + * Application specific definitions. + * + * These definitions should be adjusted for your particular hardware and + * application requirements. + * + * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE + * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE. + * http://www.freertos.org/a00110.html + *----------------------------------------------------------*/ + +/* Constants related to the behaviour or the scheduler. */ +#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1 +#define configTICK_RATE_HZ ((TickType_t) 1000) +#define configUSE_PREEMPTION 1 +#define configUSE_TIME_SLICING 0 +#define configMAX_PRIORITIES (10UL) +#define configIDLE_SHOULD_YIELD 0 +#define configUSE_16_BIT_TICKS 0 /* Only for 8 and 16-bit hardware. */ + +/* Constants used to specify if only static allocation is to be supported (in +which case a heap_n.c file is not required), only dynamic allocation is to be +supported, or if both static and dynamic allocation are supported. */ +#define configSUPPORT_STATIC_ALLOCATION 1 +#define configSUPPORT_DYNAMIC_ALLOCATION 1 + +/* Constants that describe the hardware and memory usage. */ +#define configCPU_CLOCK_HZ ((unsigned long) 80000000) +/* Smallest stack size allowed in words */ +#define configMINIMAL_STACK_SIZE ((unsigned short) 256) // changed from 128 +#define configMAX_TASK_NAME_LEN (12) + +#define configTOTAL_HEAP_SIZE ((size_t) (0x14000)) // inreased from 0xe000 + +/* Idle task stack size in words */ +#define configIDLE_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2) + +/* Default stack size for TI-POSIX threads (in words) */ +#define configPOSIX_STACK_SIZE ((unsigned short) 512) // changed from 256 + +/* Constants that build features in or out. */ +#define configUSE_MUTEXES 1 +#define configUSE_TICKLESS_IDLE 1 +#define configUSE_APPLICATION_TASK_TAG 1 /* Need by POSIX/pthread */ +#define configUSE_CO_ROUTINES 0 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configUSE_QUEUE_SETS 0 +#define configUSE_TASK_NOTIFICATIONS 1 + +/* Constants that define which hook (callback) functions should be used. */ +#define configUSE_IDLE_HOOK 0 +#define configUSE_TICK_HOOK 0 +#define configUSE_MALLOC_FAILED_HOOK 0 + +/* Constants provided for debugging and optimisation assistance. */ +#define configCHECK_FOR_STACK_OVERFLOW 2 +#define configASSERT(x) \ + if ((x) == 0) \ + { \ + taskDISABLE_INTERRUPTS(); \ + for (;;) \ + ; \ + } +#define configQUEUE_REGISTRY_SIZE 0 + +/* + * Minimum number of full tick periods of idle time required to run Power + * sleep policy function. + */ +#define configEXPECTED_IDLE_TIME_BEFORE_SLEEP 5 + +/* Software timer definitions. */ +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY (6) +#define configTIMER_QUEUE_LENGTH (20) +/* Timer task stack size in words */ +#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2) + +#define configENABLE_BACKWARD_COMPATIBILITY 1 + +#if defined(__TI_COMPILER_VERSION__) || defined(__ti_version__) +#include +#define traceTASK_DELETE(pxTCB) PTLS_taskDeleteHook(pxTCB) +#elif defined(__IAR_SYSTEMS_ICC__) +#ifndef __IAR_SYSTEMS_ASM__ +#include +#define traceTASK_DELETE(pxTCB) Mtx_taskDeleteHook(pxTCB) +#endif +#endif + +/* + * Enable thread local storage + * + * Assign TLS array index ownership here to avoid collisions. + * TLS storage is needed to implement thread-safe errno with + * TI and IAR compilers. With GNU compiler, we enable newlib. + */ +#if defined(__TI_COMPILER_VERSION__) || defined(__ti_version__) || defined(__IAR_SYSTEMS_ICC__) + +#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 1 + +#if defined(__TI_COMPILER_VERSION__) || defined(__ti_version__) +#define PTLS_TLS_INDEX 0 /* ti.posix.freertos.PTLS */ +#elif defined(__IAR_SYSTEMS_ICC__) +#define MTX_TLS_INDEX 0 /* ti.posix.freertos.Mtx */ +#endif + +#elif defined(__GNUC__) +/* note: system locks required by newlib are not implemented */ +#define configUSE_NEWLIB_REENTRANT 1 +#endif + +/* + * Set the following definitions to 1 to include the API function, or zero + * to exclude the API function. NOTE: Setting an INCLUDE_ parameter to 0 is only + * necessary if the linker does not automatically remove functions that are not + * referenced anyway. + */ +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskCleanUpResources 0 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 0 +#define INCLUDE_xTaskGetIdleTaskHandle 0 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xTaskResumeFromISR 0 +#define INCLUDE_xTaskGetCurrentTaskHandle 1 +#define INCLUDE_xTaskGetSchedulerState 0 +#define INCLUDE_xSemaphoreGetMutexHolder 0 +#define INCLUDE_xTimerPendFunctionCall 0 + +/* Cortex-M3/4 interrupt priority configuration follows...................... */ + +/* Use the system definition, if there is one. */ +#ifdef __NVIC_PRIO_BITS +#define configPRIO_BITS __NVIC_PRIO_BITS +#else +#define configPRIO_BITS 3 /* 8 priority levels */ +#endif + +/* The lowest interrupt priority that can be used in a call to a "set priority" +function. */ +#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY 0x07 + +/* + * The highest interrupt priority that can be used by any interrupt service + * routine that makes calls to interrupt safe FreeRTOS API functions. DO NOT CALL + * INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER + * PRIORITY THAN THIS! (higher priorities are lower numeric values. + */ +#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 1 + +/* + * Priority 7 (shifted 5 since only the top 3 bits are implemented). + * Priority 7 is the lowest priority. + */ +#define configKERNEL_INTERRUPT_PRIORITY (configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS)) + +/* + * Priority 1 (shifted 5 since only the top 3 bits are implemented). + * Priority 1 is the second highest priority. + * Priority 0 is the highest priority. + * !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!! + * See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. + */ +#define configMAX_SYSCALL_INTERRUPT_PRIORITY (configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS)) + +/* The trace facility is turned on to make some functions available for use in +CLI commands. */ +#define configUSE_TRACE_FACILITY 1 + +/* Constants related to the generation of run time stats. */ +#define configGENERATE_RUN_TIME_STATS 0 +#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() +#define portGET_RUN_TIME_COUNTER_VALUE() 0 + +/* + * Runtime Object View is a Texas Instrument host tool that helps visualize + * the application. When enabled, the ISR stack will be initialized in the + * startup__.c file to 0xa5a5a5a5. The stack peak can then + * be displayed in Runtime Object View. + */ +#define configENABLE_ISR_STACK_INIT 1 diff --git a/src/platform/cc32xx/InetPlatformConfig.h b/src/platform/cc32xx/InetPlatformConfig.h new file mode 100644 index 00000000000000..c40a4031de6033 --- /dev/null +++ b/src/platform/cc32xx/InetPlatformConfig.h @@ -0,0 +1,51 @@ +/* + * + * 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 Openchip Inet + * Layer on CC32XX platforms using the Texas Instruments SDK. + * + */ + +#ifndef INET_PLATFORM_CONFIG_H +#define INET_PLATFORM_CONFIG_H + +// XXX: Seth update config? + +// ==================== Platform Adaptations ==================== + +// XXX: Seth is there a proper platform error type?? +#define INET_CONFIG_ERROR_TYPE uint32_t +#define INET_CONFIG_NO_ERROR (0) + +#define INET_CONFIG_ERROR_MIN 1000000 +#define INET_CONFIG_ERROR_MAX 1000999 + +#define INET_CONFIG_ENABLE_IPV4 1 + +// ========== Platform-specific Configuration Overrides ========= + +#ifndef INET_CONFIG_NUM_TCP_ENDPOINTS +#define INET_CONFIG_NUM_TCP_ENDPOINTS 4 +#endif // INET_CONFIG_NUM_TCP_ENDPOINTS + +#ifndef INET_CONFIG_NUM_UDP_ENDPOINTS +#define INET_CONFIG_NUM_UDP_ENDPOINTS 4 +#endif // INET_CONFIG_NUM_UDP_ENDPOINTS + +#endif // INET_PLATFORM_CONFIG_H diff --git a/src/platform/cc32xx/KeyValueStoreManagerImpl.cpp b/src/platform/cc32xx/KeyValueStoreManagerImpl.cpp new file mode 100644 index 00000000000000..13c1a023443594 --- /dev/null +++ b/src/platform/cc32xx/KeyValueStoreManagerImpl.cpp @@ -0,0 +1,66 @@ +/* + * + * 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 for CC32XX + */ + +/* this file behaves like a config.h, comes first */ +#include + +#include + +#include + +#include + +namespace chip { +namespace DeviceLayer { +namespace PersistedStorage { + +using namespace ::chip::DeviceLayer::Internal; + +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) const +{ + VerifyOrReturnError(key, CHIP_ERROR_INVALID_ARGUMENT); + VerifyOrReturnError(value, CHIP_ERROR_INVALID_ARGUMENT); + + return CC32XXConfig::ReadKVS(key, value, value_size, read_bytes_size, offset_bytes); +} + +CHIP_ERROR KeyValueStoreManagerImpl::_Put(const char * key, const void * value, size_t value_size) +{ + VerifyOrReturnError(key, CHIP_ERROR_INVALID_ARGUMENT); + VerifyOrReturnError(value, CHIP_ERROR_INVALID_ARGUMENT); + VerifyOrReturnError(value_size > 0, CHIP_ERROR_INVALID_ARGUMENT); + + return CC32XXConfig::WriteKVS(key, value, value_size); +} + +CHIP_ERROR KeyValueStoreManagerImpl::_Delete(const char * key) +{ + return CC32XXConfig::ClearKVS(key); +} + +} // namespace PersistedStorage +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/KeyValueStoreManagerImpl.h b/src/platform/cc32xx/KeyValueStoreManagerImpl.h new file mode 100644 index 00000000000000..285447bfa543d0 --- /dev/null +++ b/src/platform/cc32xx/KeyValueStoreManagerImpl.h @@ -0,0 +1,75 @@ +/* + * + * 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 for CC32XX + */ + +#pragma once + +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: + CHIP_ERROR _Get(const char * key, void * value, size_t value_size, size_t * read_bytes_size = nullptr, size_t offset = 0) const; + + CHIP_ERROR _Delete(const char * key); + + CHIP_ERROR _Put(const char * key, const void * value, size_t value_size); + +private: + // ===== 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/cc32xx/Logging.cpp b/src/platform/cc32xx/Logging.cpp new file mode 100644 index 00000000000000..fbb0632d230dbf --- /dev/null +++ b/src/platform/cc32xx/Logging.cpp @@ -0,0 +1,151 @@ +/* + * + * 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 implementations for the CHIP and LwIP logging functions + * for the Texas Instruments CC32XX platform. This uses one of the + * UARTs configured with SysConfig. Future implementations may use + * ITM. + * + */ + +#include "ti_drivers_config.h" +#include +#include +#include +#include + +#include + +using namespace ::chip; +using namespace ::chip::DeviceLayer; +using namespace ::chip::DeviceLayer::Internal; + +#define DEVICE_LAYER_LOG_BUFFER_SIZE (256) +static UART2_Handle sDebugUartHandle; +static char sDebugUartBuffer[DEVICE_LAYER_LOG_BUFFER_SIZE]; +//static pthread_mutex_t mutex; + +extern "C" int cc32xxLogInit(void) +{ + UART2_Params uartParams; + + UART2_Params_init(&uartParams); + + uartParams.baudRate = 115200; + sDebugUartHandle = UART2_open(CONFIG_UART2_0, &uartParams); + + /* Remove uart receive from LPDS dependency */ + UART2_rxDisable(sDebugUartHandle); + + /* Enable debug mutex */ + //pthread_mutex_init(&mutex, NULL); + return 0; +} + +extern "C" void cc32xxVLog(const char * msg, va_list v) +{ + int ret; + + //pthread_mutex_lock(&mutex); + ret = vsnprintf(sDebugUartBuffer, sizeof(sDebugUartBuffer), msg, v); + if (0 < ret) + { + // PuTTY likes \r\n + size_t len = (ret + 2U) < sizeof(sDebugUartBuffer) ? (ret + 2) : sizeof(sDebugUartBuffer); + sDebugUartBuffer[len - 2] = '\r'; + sDebugUartBuffer[len - 1] = '\n'; + sDebugUartBuffer[len] = '\0'; + + UART2_write(sDebugUartHandle, sDebugUartBuffer, len, &len); + } + //pthread_mutex_unlock(&mutex); +} + +namespace chip { +namespace DeviceLayer { + +/** + * Called whenever a log message is emitted. + * + * Can be overriden by the device logging file + */ +void __attribute__((weak)) OnLogOutput(void) {} + +} // namespace DeviceLayer +} // namespace chip + +namespace chip { +namespace Logging { +namespace Platform { + +void LogV(const char * module_name, uint8_t category, const char * msg, va_list v) +{ + (void) module_name; + (void) category; + + cc32xxVLog(msg, v); + + DeviceLayer::OnLogOutput(); +} + +void LogV(uint8_t module, uint8_t category, const char * msg, va_list v) +{ + (void) module; + (void) category; + + cc32xxVLog(msg, v); + + DeviceLayer::OnLogOutput(); +} + +} // namespace Platform +} // namespace Logging +} // namespace chip + +/** + * LwIP log output function. + */ +extern "C" void LwIPLog(const char * msg, ...) +{ + va_list v; + + va_start(v, msg); + + cc32xxVLog(msg, v); + + DeviceLayer::OnLogOutput(); + va_end(v); +} + +/** + * Platform log output function. + */ +extern "C" void cc32xxLog(const char * msg, ...) +{ + va_list v; + + va_start(v, msg); + + cc32xxVLog(msg, v); + + DeviceLayer::OnLogOutput(); + va_end(v); +} + +# diff --git a/src/platform/cc32xx/PlatformManagerImpl.cpp b/src/platform/cc32xx/PlatformManagerImpl.cpp new file mode 100644 index 00000000000000..a8795b4891ddcc --- /dev/null +++ b/src/platform/cc32xx/PlatformManagerImpl.cpp @@ -0,0 +1,92 @@ +/* + * + * 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 PlatformManager object + * for the Texas Instruments CC32XX platform. + */ + +/* this file behaves like a config.h, comes first */ +#include + +#include +#include +#include +#include + +#include + +namespace chip { +namespace DeviceLayer { + +PlatformManagerImpl PlatformManagerImpl::sInstance; + +static int app_get_random(uint8_t * aOutput, size_t aLen) +{ + size_t i; + + // TBD add implementation + for (i = 0; i < aLen; i++) + { + aOutput[i] = i * 31 + 17; + } + return 0; +} + +static void app_random_init(void) +{ + return; +} + +static int app_entropy_source(void * data, unsigned char * output, size_t len, size_t * olen) +{ + + app_get_random(reinterpret_cast(output), static_cast(len)); + *olen = len; + + return 0; +} + +CHIP_ERROR PlatformManagerImpl::_InitChipStack(void) +{ + CHIP_ERROR err; + + // Initialize the configuration system. + err = Internal::CC32XXConfig::Init(); + SuccessOrExit(err); + SetConfigurationMgr(&ConfigurationManagerImpl::GetDefaultInstance()); + SetDiagnosticDataProvider(&DiagnosticDataProviderImpl::GetDefaultInstance()); + + // Initialize LwIP. + tcpip_init(NULL, NULL); + + app_random_init(); + err = chip::Crypto::add_entropy_source(app_entropy_source, NULL, 16); + SuccessOrExit(err); + + // Call _InitChipStack() on the generic implementation base class + // to finish the initialization process. + err = Internal::GenericPlatformManagerImpl_FreeRTOS::_InitChipStack(); + SuccessOrExit(err); + +exit: + return err; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/PlatformManagerImpl.h b/src/platform/cc32xx/PlatformManagerImpl.h new file mode 100644 index 00000000000000..077e36b98a535e --- /dev/null +++ b/src/platform/cc32xx/PlatformManagerImpl.h @@ -0,0 +1,90 @@ +/* + * + * 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 PlatformManager object. + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { + +/** + * Concrete implementation of the PlatformManager singleton object for the CC32XX platform. + */ +class PlatformManagerImpl final : public PlatformManager, public Internal::GenericPlatformManagerImpl_FreeRTOS +{ + // Allow the PlatformManager interface class to delegate method calls to + // the implementation methods provided by this class. + friend PlatformManager; + + // Allow the generic implementation base class to call helper methods on + // this class. +#ifndef DOXYGEN_SHOULD_SKIP_THIS + friend Internal::GenericPlatformManagerImpl_FreeRTOS; +#endif + +public: + // ===== Platform-specific members that may be accessed directly by the application. + + /* none so far */ + +private: + // ===== Methods that implement the PlatformManager abstract interface. + + CHIP_ERROR _InitChipStack(void); + + // ===== Members for internal use by the following friends. + + friend PlatformManager & PlatformMgr(void); + friend PlatformManagerImpl & PlatformMgrImpl(void); + friend class Internal::BLEManagerImpl; + + static PlatformManagerImpl sInstance; + + using Internal::GenericPlatformManagerImpl_FreeRTOS::PostEventFromISR; +}; + +/** + * 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 CC32XX SoC. + */ +inline PlatformManagerImpl & PlatformMgrImpl(void) +{ + return PlatformManagerImpl::sInstance; +} + +} // namespace DeviceLayer +} // namespace chip diff --git a/src/platform/cc32xx/README.md b/src/platform/cc32xx/README.md new file mode 100644 index 00000000000000..5729e291cab055 --- /dev/null +++ b/src/platform/cc32xx/README.md @@ -0,0 +1,85 @@ +# Overview of CHIP CC32XX Adaption + +The following is an overview of the CC32XX adaptation of CHIP. Most of this +code will have parallels in any new adaptation. + +(All file names are relative to `connectedhomeip/src/platform/CC32XX...`). + + +`BlePlatformConfig.h` + +- Configuration header for BLE specific configurations +- Required by AutoConf build + +**NOTE** empty for now + +`CC32XXConfig.h`
`CC32XXConfig.cpp` + +- Concrete implementation of the Non-Volatile storage of information for chip + +**NOTE** empty for now + +`CHIPDevicePlatformConfig.h` + +- Configuration for the chip stack for the CC32XX platform + +`CHIPDevicePlatformEvent.h` + +- Definition of platform events to be handled by the chip processing loop +- Currently there are no events that need special handling + +`CHIPPlatformConfig.h`
`InetPlatformConfig.h`
`SystemPlatformConfig.h` + +- Definitions for the chip stack to work with the configurations of the + CC32XX platform + +`ConfigurationManagerImpl.h`
`ConfigurationManagerImpl.cpp` + +- Concrete implementation of ConfigurationManager interface +- Manages storage and retrieval of persistent configuration data +- Relies on GenericConfigurationManagerImpl<> classes to implement most API + functionality +- Delegates low-level reading and writing of persistent values to + `CC32XXConfig` class + +`ConnectivityManagerImpl.h`
`ConnectivityManagerImpl.cpp` + +- Concrete implementation of `ConnectivityManager` interface +- Provides high-level APIs for managing device connectivity +- Relies on `GenericConnectivityManagerImpl_Thread<>` class to provide most of + the implementation + +`Entropy.cpp` + +- Concrete implementation of an entropy source based on the TRNG + +**NOTE** empty for now + +`Logging.cpp` + +- Concrete implementation of the logging functions +- Currently logs out the User UART interface on the XDS110 + +`ThreadStackManagerImpl.h`
`ThreadStackManagerImpl.cpp` + +- Concrete implementation of ThreadStackManager interface +- Supports Thread stack initialization and core event loop processing +- Relies on `GenericThreadStackManagerImpl_OpenThread/FreeRTOS/LwIP<>` classes + to implement most API functionality + +**NOTE** Currently disabled because OpenThread Libraries are not built or +linked in. + +`PlatformManagerImpl.h`
`PlatformManagerImpl.cpp` + +- Concrete implementation of `PlatformManager` interface +- Provides initialization of the CHIP stack and core event loop for the chip + task +- Relies on `GenericPlatformManagerImpl_FreeRTOS<>` class to provide most of the + implementation + +`SoftwareUpdateManagerImpl.cpp` + +- Concrete implementation of the Software Update Manager +- Relies on the `GenericSoftwareUpdateManagerImpl` + diff --git a/src/platform/cc32xx/SoftwareUpdateManagerImpl.cpp b/src/platform/cc32xx/SoftwareUpdateManagerImpl.cpp new file mode 100644 index 00000000000000..4b6f5222e31905 --- /dev/null +++ b/src/platform/cc32xx/SoftwareUpdateManagerImpl.cpp @@ -0,0 +1,41 @@ +/* + * + * 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. + */ + +// XXX: Seth done in generic?? + +#include + +#if CHIP_DEVICE_CONFIG_ENABLE_SOFTWARE_UPDATE_MANAGER + +#include + +namespace chip { +namespace DeviceLayer { + +SoftwareUpdateManagerImpl SoftwareUpdateManagerImpl::sInstance; + +CHIP_ERROR SoftwareUpdateManagerImpl::_Init(void) +{ + Internal::GenericSoftwareUpdateManagerImpl::DoInit(); + + return CHIP_NO_ERROR; +} + +} // namespace DeviceLayer +} // namespace chip + +#endif // CHIP_DEVICE_CONFIG_ENABLE_SOFTWARE_UPDATE_MANAGER diff --git a/src/platform/cc32xx/SystemPlatformConfig.h b/src/platform/cc32xx/SystemPlatformConfig.h new file mode 100644 index 00000000000000..baee83449978b9 --- /dev/null +++ b/src/platform/cc32xx/SystemPlatformConfig.h @@ -0,0 +1,54 @@ +/* + * + * 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 System + * Layer on CC32XX platforms using the Texas Instruments SDK. + * + */ + +#pragma once + +#include + +namespace chip { +namespace DeviceLayer { +struct ChipDeviceEvent; +} // namespace DeviceLayer +} // namespace chip + +// ==================== Platform Adaptations ==================== + +//#define CHIP_SYSTEM_CONFIG_POSIX_LOCKING 0 +//#define CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING 0 +//#define CHIP_SYSTEM_CONFIG_NO_LOCKING 1 +//#define CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_EVENT_FUNCTIONS 1 +#define CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME 1 +//#define CHIP_SYSTEM_CONFIG_LWIP_EVENT_TYPE int +#define CHIP_SYSTEM_CONFIG_LWIP_EVENT_OBJECT_TYPE const struct ::chip::DeviceLayer::ChipDeviceEvent * + +// #define CHIP_SYSTEM_CONFIG_ERROR_TYPE uint32_t +// #define CHIP_SYSTEM_CONFIG_NO_ERROR (0) + +// #define CHIP_SYSTEM_CONFIG_ERROR_MIN 0 +// #define CHIP_SYSTEM_CONFIG_ERROR_MAX 999 +// #define _CHIP_SYSTEM_CONFIG_ERROR(e) (CHIP_SYSTEM_CONFIG_ERROR_MIN + (e)) + +// ========== Platform-specific Configuration Overrides ========= + +/* none yet */ diff --git a/src/platform/cc32xx/args.gni b/src/platform/cc32xx/args.gni new file mode 100755 index 00000000000000..3e604cdeaa73b5 --- /dev/null +++ b/src/platform/cc32xx/args.gni @@ -0,0 +1,36 @@ +# 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/ti_simplelink_sdk.gni") + +# ARM architecture flags will be set based on Device Family +arm_platform_config = + "${ti_simplelink_sdk_build_root}/ti_simplelink_arm_platform_config.gni" + +chip_device_platform = "cc32xx" + +freertos_target = "${chip_root}/third_party/ti_simplelink_sdk:freertos" + +mbedtls_target = "${chip_root}/third_party/ti_simplelink_sdk:mbedtls" + +lwip_platform = "cc32xx" +lwip_ipv6 = true +lwip_ipv4 = true +lwip_api = true + +chip_inet_config_enable_ipv4 = true +chip_inet_config_enable_dns_resolver = false + +chip_build_tests = false diff --git a/src/platform/cc32xx/cc32xx-mbedtls-config.h b/src/platform/cc32xx/cc32xx-mbedtls-config.h new file mode 100755 index 00000000000000..ad08ee6cf1fca8 --- /dev/null +++ b/src/platform/cc32xx/cc32xx-mbedtls-config.h @@ -0,0 +1,99 @@ +/* + * + * 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. + */ + +#pragma once + +#include +#include + +#define MBEDTLS_PLATFORM_SNPRINTF_MACRO snprintf + +#define MBEDTLS_AES_C +#define MBEDTLS_AES_ROM_TABLES +#define MBEDTLS_ASN1_PARSE_C +#define MBEDTLS_ASN1_WRITE_C +#define MBEDTLS_BIGNUM_C +#define MBEDTLS_CCM_C +#define MBEDTLS_CIPHER_C +#define MBEDTLS_CMAC_C +#define MBEDTLS_CTR_DRBG_C +#define MBEDTLS_ECJPAKE_C +#define MBEDTLS_ECP_C +#define MBEDTLS_ECP_DP_SECP256R1_ENABLED +#define MBEDTLS_ECP_NIST_OPTIM +#define MBEDTLS_ENTROPY_C +#define MBEDTLS_HAVE_ASM +#define MBEDTLS_HMAC_DRBG_C +#define MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED +#define MBEDTLS_MD_C +#define MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES +#define MBEDTLS_NO_PLATFORM_ENTROPY +#define MBEDTLS_PK_C +#define MBEDTLS_PK_PARSE_C +#define MBEDTLS_PK_WRITE_C +#define MBEDTLS_PLATFORM_C +#define MBEDTLS_PLATFORM_MEMORY +#define MBEDTLS_PLATFORM_STD_CALLOC calloc +#define MBEDTLS_PLATFORM_STF_FREE free +#define MBEDTLS_PLATFORM_NO_STD_FUNCTIONS +#define MBEDTLS_SHA256_C +#define MBEDTLS_SHA256_SMALLER +#define MBEDTLS_SSL_CLI_C +#define MBEDTLS_SSL_DTLS_ANTI_REPLAY +#define MBEDTLS_SSL_DTLS_HELLO_VERIFY +#define MBEDTLS_SSL_EXPORT_KEYS +#define MBEDTLS_SSL_MAX_FRAGMENT_LENGTH +#define MBEDTLS_SSL_PROTO_TLS1_2 +#define MBEDTLS_SSL_PROTO_DTLS +#define MBEDTLS_SSL_TLS_C +#define MBEDTLS_ERROR_STRERROR_DUMMY +#define MBEDTLS_HKDF_C +#define MBEDTLS_X509_CREATE_C +#define MBEDTLS_X509_CSR_WRITE_C +#define MBEDTLS_BASE64_C +#define MBEDTLS_PEM_WRITE_C + +#define MBEDTLS_SSL_COOKIE_C +#define MBEDTLS_SSL_SRV_C + +#define MBEDTLS_KEY_EXCHANGE_PSK_ENABLED +#define MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED + +#define MBEDTLS_BASE64_C +#define MBEDTLS_ECDH_C +#define MBEDTLS_ECDSA_C +#define MBEDTLS_OID_C +#define MBEDTLS_PEM_PARSE_C +#define MBEDTLS_X509_USE_C +#define MBEDTLS_X509_CRT_PARSE_C +#define MBEDTLS_PKCS5_C + +#define MBEDTLS_MPI_WINDOW_SIZE 1 /**< Maximum windows size used. */ +#define MBEDTLS_MPI_MAX_SIZE 32 /**< Maximum number of bytes for usable MPIs. */ +#define MBEDTLS_ECP_MAX_BITS 256 /**< Maximum bit size of groups */ +#define MBEDTLS_ECP_WINDOW_SIZE 2 /**< Maximum window size used */ +#define MBEDTLS_ECP_FIXED_POINT_OPTIM 0 /**< Enable fixed-point speed-up */ +#define MBEDTLS_ENTROPY_MAX_SOURCES 1 /**< Maximum number of sources supported */ + +#define MBEDTLS_MEMORY_BUFFER_ALLOC_C + +#define MBEDTLS_SSL_MAX_CONTENT_LEN 900 /**< Maxium fragment length in bytes */ + +#define MBEDTLS_SSL_CIPHERSUITES MBEDTLS_TLS_ECJPAKE_WITH_AES_128_CCM_8 + +#include "mbedtls/check_config.h" diff --git a/src/platform/device.gni b/src/platform/device.gni index 2258f01cd22010..9ee61f00972fbe 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, cyw30739, bl602, none. + # Device platform layer: cc13x2_26x2, cc32xx, darwin, efr32, esp32, external, freertos, linux, nrfconnect, k32w0, qpg, tizen, cyw30739, bl602, none. chip_device_platform = "auto" chip_platform_target = "" @@ -60,7 +60,8 @@ declare_args() { chip_device_platform == "linux" || chip_device_platform == "esp32" || chip_device_platform == "mbed" || chip_device_platform == "tizen" || chip_device_platform == "android" || chip_device_platform == "ameba" || - chip_device_platform == "webos" || chip_device_platform == "bl602" + chip_device_platform == "webos" || chip_device_platform == "cc32xx" || + chip_device_platform == "bl602" # Enable ble support. if (chip_device_platform == "fake") { @@ -78,7 +79,8 @@ declare_args() { # Select DNS-SD implementation if (chip_device_platform == "linux" || chip_device_platform == "esp32" || chip_device_platform == "mbed" || chip_device_platform == "p6" || - chip_device_platform == "ameba" || chip_device_platform == "webos") { + chip_device_platform == "ameba" || chip_device_platform == "webos" || + chip_device_platform == "cc32xx") { chip_mdns = "minimal" } else if (chip_device_platform == "darwin" || chip_device_platform == "cc13x2_26x2" || current_os == "android" || @@ -93,6 +95,8 @@ declare_args() { _chip_device_layer = "none" if (chip_device_platform == "cc13x2_26x2") { _chip_device_layer = "cc13x2_26x2" +} else if (chip_device_platform == "cc32xx") { + _chip_device_layer = "cc32xx" } else if (chip_device_platform == "darwin") { _chip_device_layer = "Darwin" } else if (chip_device_platform == "efr32") { @@ -171,9 +175,10 @@ assert( (current_os != "freertos" && chip_device_platform == "none") || chip_device_platform == "fake" || chip_device_platform == "cc13x2_26x2" || - chip_device_platform == "darwin" || chip_device_platform == "efr32" || - chip_device_platform == "esp32" || chip_device_platform == "external" || - chip_device_platform == "linux" || chip_device_platform == "tizen" || + chip_device_platform == "cc32xx" || chip_device_platform == "darwin" || + chip_device_platform == "efr32" || chip_device_platform == "esp32" || + chip_device_platform == "external" || chip_device_platform == "linux" || + chip_device_platform == "tizen" || chip_device_platform == "nrfconnect" || chip_device_platform == "k32w0" || chip_device_platform == "qpg" || chip_device_platform == "telink" || chip_device_platform == "mbed" || diff --git a/third_party/ti_simplelink_sdk/BUILD.gn b/third_party/ti_simplelink_sdk/BUILD.gn index f968324d78170f..8d6ea90cf13f21 100644 --- a/third_party/ti_simplelink_sdk/BUILD.gn +++ b/third_party/ti_simplelink_sdk/BUILD.gn @@ -35,24 +35,34 @@ group("ti_simplelink_sysconfig") { } config("ti_simplelink_mbedtls_config") { - defines = [ "MBEDTLS_CONFIG_FILE=\"cc13x2_26x2-mbedtls-config.h\"" ] + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + defines = [ "MBEDTLS_CONFIG_FILE=\"cc13x2_26x2-mbedtls-config.h\"" ] - include_dirs = [ - "${chip_root}/src/platform/cc13x2_26x2", - "${chip_root}/src/platform/cc13x2_26x2/crypto", - "${ti_simplelink_sdk_root}/source", - ] + include_dirs = [ + "${chip_root}/src/platform/cc13x2_26x2", + "${chip_root}/src/platform/cc13x2_26x2/crypto", + "${ti_simplelink_sdk_root}/source", + ] + } else if (ti_simplelink_device_family == "cc32xx") { + defines = [ "MBEDTLS_CONFIG_FILE=\"cc32xx-mbedtls-config.h\"" ] + + include_dirs = [ "${chip_root}/src/platform/cc32xx" ] + } } mbedtls_target("mbedtls") { # Hardware acceleration - sources = [ - "${chip_root}/src/platform/cc13x2_26x2/crypto/aes_alt.c", - "${chip_root}/src/platform/cc13x2_26x2/crypto/ecdh_alt.c", - "${chip_root}/src/platform/cc13x2_26x2/crypto/ecdsa_alt.c", - "${chip_root}/src/platform/cc13x2_26x2/crypto/ecjpake_alt.c", - "${chip_root}/src/platform/cc13x2_26x2/crypto/sha256_alt.c", - ] + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + sources = [ + "${chip_root}/src/platform/cc13x2_26x2/crypto/aes_alt.c", + "${chip_root}/src/platform/cc13x2_26x2/crypto/ecdh_alt.c", + "${chip_root}/src/platform/cc13x2_26x2/crypto/ecdsa_alt.c", + "${chip_root}/src/platform/cc13x2_26x2/crypto/ecjpake_alt.c", + "${chip_root}/src/platform/cc13x2_26x2/crypto/sha256_alt.c", + ] + } public_configs = [ ":ti_simplelink_mbedtls_config" ] @@ -60,17 +70,33 @@ mbedtls_target("mbedtls") { } config("ti_simplelink_freertos_config") { - include_dirs = [ - "${chip_root}/src/platform/cc13x2_26x2", - "${freertos_root}/repo/portable/GCC/ARM_CM4F", - ] + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + include_dirs = [ + "${chip_root}/src/platform/cc13x2_26x2", + "${freertos_root}/repo/portable/GCC/ARM_CM4F", + ] + } else if (ti_simplelink_device_family == "cc32xx") { + include_dirs = [ + "${chip_root}/src/platform/cc32xx", + "${freertos_root}/repo/portable/GCC/ARM_CM3", + ] + } } freertos_target("freertos") { - sources = [ - "${freertos_root}/repo/portable/GCC/ARM_CM4F/port.c", - #"${freertos_root}/repo/portable/MemMang/heap_4.c", - ] + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + sources = [ + "${freertos_root}/repo/portable/GCC/ARM_CM4F/port.c", + #"${freertos_root}/repo/portable/MemMang/heap_4.c", + ] + } else if (ti_simplelink_device_family == "cc32xx") { + sources = [ + "${freertos_root}/repo/portable/GCC/ARM_CM3/port.c", + "${freertos_root}/repo/portable/MemMang/heap_4.c", + ] + } public_configs = [ ":ti_simplelink_freertos_config" ] @@ -78,5 +104,8 @@ freertos_target("freertos") { # BLE has to have it's own heap config public_deps = [ "${chip_root}/third_party/ti_simplelink_sdk:ti_simplelink_sysconfig" ] + } else if (ti_simplelink_device_family == "cc32xx") { + public_deps = + [ "${chip_root}/third_party/ti_simplelink_sdk:ti_simplelink_sysconfig" ] } } diff --git a/third_party/ti_simplelink_sdk/repo_cc32xx b/third_party/ti_simplelink_sdk/repo_cc32xx new file mode 160000 index 00000000000000..e5fbefba9c3c3a --- /dev/null +++ b/third_party/ti_simplelink_sdk/repo_cc32xx @@ -0,0 +1 @@ +Subproject commit e5fbefba9c3c3afa9c2c967b713c77e282d560fe diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_arm_platform_config.gni b/third_party/ti_simplelink_sdk/ti_simplelink_arm_platform_config.gni index 91cd5911d7df99..2ee40881b23bca 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_arm_platform_config.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_arm_platform_config.gni @@ -22,6 +22,13 @@ if (ti_simplelink_device_family == "cc13x2_26x2" || arm_float_abi = "hard" arm_fpu = "fpv5-sp-d16" arm_use_thumb = true +} else if (ti_simplelink_device_family == "cc32xx") { + arm_arch = "armv7e-m" + arm_abi = "" + arm_cpu = "cortex-m4" + arm_float_abi = "soft" + arm_fpu = "" + arm_use_thumb = true } else { assert(false, "ti_simplelink_device_family must be specified") } diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_board.gni b/third_party/ti_simplelink_sdk/ti_simplelink_board.gni index 782b382b18c590..c6ae89ab2d8d43 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_board.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_board.gni @@ -30,6 +30,8 @@ assert(ti_simplelink_board != "", "ti_simplelink_board must be specified") # | CC1352R1_LAUNCHXL | cc13x2_26x2 | cc1352r1f3 | Thread MTD + no BLE | # | CC2652R1_LAUNCHXL | cc13x2_26x2 | cc2652r1f3 | Thread MTD + no BLE | # | LP_CC2652R7 | cc13x2x7_26x2x7 | cc2652r1f7 | Thread FTD + BLE | +# | CC3220SF_LAUNCHXL | cc32xx | cc3220SF | Wi-Fi | +# | CC3235SF_LAUNCHXL | cc32xx | cc3235SF | Wi-Fi | # XXX: Can we do an array with a case statement? if (ti_simplelink_board == "CC1352R1_LAUNCHXL") { @@ -56,6 +58,18 @@ if (ti_simplelink_board == "CC1352R1_LAUNCHXL") { # set -DDeviceFamily_CC26X2? ti_simplelink_soc = "cc2652r1f7" ti_simplelink_bim_name = "cc2652r7lp" +} else if (ti_simplelink_board == "CC3220SF_LAUNCHXL") { + ti_simplelink_device_family = "cc32xx" + ti_simplelink_soc_family = "cc32xx" + + # set -DDeviceFamily_CC3220 + ti_simplelink_soc = "cc32xxSF" +} else if (ti_simplelink_board == "CC3235SF_LAUNCHXL") { + ti_simplelink_device_family = "cc32xx" + ti_simplelink_soc_family = "cc32xx" + + # set -DDeviceFamily_CC3220 + ti_simplelink_soc = "cc32xxSF" } else { print("Please provide a valid value for TI_SIMPLELINK_BOARD env variable") assert(false, "The board ${ti_simplelink_board} is unsupported as for now.") diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni index 53e3b437876b17..83817187a343f2 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni @@ -46,8 +46,18 @@ template("ti_simplelink_executable") { } output_base_name = get_path_info(invoker.output_name, "name") - objcopy_image_name = output_base_name + ".hex" - objcopy_image_format = "ihex" + #used for OTA image creator for the cc13xx + if (ti_simplelink_device_family == "cc13x2x7_26x2x7") + { + objcopy_image_name = output_base_name + ".hex" + objcopy_image_format = "ihex" + } + #used for Uniflash image creation for the cc32xx + else + { + objcopy_image_name = output_base_name + ".bin" + objcopy_image_format = "binary" + } objcopy = "arm-none-eabi-objcopy" config("${simplelink_target_name}_config") { @@ -79,17 +89,21 @@ template("ti_simplelink_executable") { } else { ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" } + } + else if (ti_simplelink_device_family == "cc32xx") + { + ldscript = "${ti_simplelink_sdk_root}/source/ti/boards/cc32xxsf/cc32xxsf_freertos.lds" + } - inputs = [ ldscript ] + inputs = [ ldscript ] - ldflags = [ - "-L" + rebase_path(ti_simplelink_sdk_root + "/source", root_build_dir), - rebase_path( - "${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", - root_build_dir), - "-T" + rebase_path(ldscript, root_build_dir), - ] - } + ldflags = [ + "-L" + rebase_path(ti_simplelink_sdk_root + "/source", root_build_dir), + rebase_path( + "${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", + root_build_dir), + "-T" + rebase_path(ldscript, root_build_dir), + ] } if (chip_enable_ota_requestor && diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni b/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni index caf6d1ffeefdbd..7072545626bb9f 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni @@ -28,8 +28,18 @@ import("ti_simplelink_board.gni") declare_args() { # Location of the TI SimpleLink SDK. - ti_simplelink_sdk_root = - "${chip_root}/third_party/ti_simplelink_sdk/repo_cc13xx_cc26xx" + + if( (ti_simplelink_device_family == "cc13x2_26x2") || (ti_simplelink_device_family == "cc13x2x7_26x2x7")) + { + ti_simplelink_sdk_root = + "${chip_root}/third_party/ti_simplelink_sdk/repo_cc13xx_cc26xx" + } + else if (ti_simplelink_device_family == "cc32xx") + { + ti_simplelink_sdk_root = + "${chip_root}/third_party/ti_simplelink_sdk/repo_cc32xx" + } + ti_sysconfig_root = "" } @@ -37,7 +47,7 @@ assert(ti_simplelink_sdk_root != "", "ti_simplelink_sdk_root must be specified") assert(ti_sysconfig_root != "", "ti_sysconfig_root must be specified") template("ti_sysconfig") { - assert(ti_sysconfig_root != "", "ti_sysconfig_root must be specified") + assert(ti_sysconfig_root != "", "must be specified") assert(ti_simplelink_sdk_root != "", "ti_simplelink_sdk_root must be specified") @@ -65,6 +75,9 @@ template("ti_sysconfig") { } else if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { ldflags += [ "-nostartfiles" ] defines += [ "DeviceFamily_CC26X2X7" ] + } else if (ti_simplelink_device_family == "cc32xx") { + ldflags += [ "-nostartfiles" ] + defines += [ "CC32XXWARE" ] } if (defined(invoker.cflags)) { cflags = invoker.cflags @@ -73,7 +86,7 @@ template("ti_sysconfig") { ldflags += invoker.ldflags } } - + pw_python_action("${target_name}_gen") { script = "${ti_simplelink_sdk_build_root}/run_sysconfig.py" sources = invoker.sources @@ -130,11 +143,8 @@ template("ti_simplelink_sdk") { # Treat these includes as system includes, so warnings in them are not fatal. include_dirs += [ - "${ti_simplelink_sdk_root}/kernel/freertos/builds/${ti_simplelink_device_family}/release", - "${ti_simplelink_sdk_root}/source", "${ti_simplelink_sdk_root}/source/third_party/CMSIS/Include", - "${chip_root}/third_party/mbedtls/repo/include", ] defines = [] @@ -150,6 +160,25 @@ template("ti_simplelink_sdk") { "${ti_simplelink_sdk_root}/source/ti/drivers/lib/gcc/${ti_simplelink_isa}/drivers_${ti_simplelink_soc_family}.a", "${ti_simplelink_sdk_root}/source/ti/drivers/rf/lib/gcc/${ti_simplelink_isa}/rf_multiMode_${ti_simplelink_soc_family}.a", ] + } else if (ti_simplelink_device_family == "cc32xx") { + assert(ti_simplelink_soc_family != "", + "ti_simplelink_soc_family must be specified") + assert(ti_simplelink_device_family != "", + "ti_simplelink_device_family must be specified") + + defines += [ "DeviceFamily_CC3220" ] + + libs += [ + "${ti_simplelink_sdk_root}/source/ti/drivers/lib/gcc/m4/drivers_cc32xx.a", + "${ti_simplelink_sdk_root}/source/ti/devices/cc32xx/driverlib/gcc/Release/driverlib.a", + "${ti_simplelink_sdk_root}/source/ti/drivers/net/wifi/gcc/rtos/simplelink.a", + "${ti_simplelink_sdk_root}/source/ti/net/lib/gcc/m4/slnetsock_debug.a", + "${ti_simplelink_sdk_root}/source/ti/drivers/net/wifi/slnetif/gcc/Release/slnetifwifi.a", + ] + include_dirs += [ + "${ti_simplelink_sdk_root}/examples/rtos/common/", + "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod", + ] } if (ti_simplelink_device_family == "cc13x2_26x2") { @@ -160,6 +189,15 @@ template("ti_simplelink_sdk") { libs += [ "${ti_simplelink_sdk_root}/source/ti/devices/cc13x2x7_cc26x2x7/driverlib/bin/gcc/driverlib.lib" ] } + if (ti_simplelink_device_family == "cc32xx") { + assert(ti_simplelink_soc_family != "", + "ti_simplelink_soc_family must be specified") + assert(ti_simplelink_device_family != "", + "ti_simplelink_device_family must be specified") + + libs += [ "${ti_simplelink_sdk_root}/source/ti/drivers/lib/gcc/m4/drivers_${ti_simplelink_soc_family}.a" ] + } + if (defined(invoker.defines)) { defines += invoker.defines } @@ -173,19 +211,31 @@ template("ti_simplelink_sdk") { sources = [ "${ti_simplelink_sdk_root}/kernel/freertos/dpl/AppHooks_freertos.c", - "${ti_simplelink_sdk_root}/kernel/freertos/dpl/ClockPCC26X2_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/DebugP_freertos.c", - "${ti_simplelink_sdk_root}/kernel/freertos/dpl/HwiPCC26X2_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/MutexP_freertos.c", - "${ti_simplelink_sdk_root}/kernel/freertos/dpl/PowerCC26X2_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/QueueP_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/SemaphoreP_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/StaticAllocs_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/SwiP_freertos.c", "${ti_simplelink_sdk_root}/kernel/freertos/dpl/SystemP_freertos.c", - "${ti_simplelink_sdk_root}/kernel/freertos/dpl/TimerPCC26XX_freertos.c", - "${ti_simplelink_sdk_root}/kernel/freertos/startup/startup_cc13x2_cc26x2_gcc.c", ] + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + sources += [ + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/ClockPCC26X2_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/HwiPCC26X2_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/PowerCC26X2_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/TimerPCC26XX_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/startup/startup_cc13x2_cc26x2_gcc.c", + ] + } else if (ti_simplelink_device_family == "cc32xx") { + sources += [ + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/ClockP_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/HwiPCC32XX_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/dpl/PowerCC32XX_freertos.c", + "${ti_simplelink_sdk_root}/kernel/freertos/startup/startup_cc32xx_gcc.c", + ] + } if (defined(invoker.sources)) { sources += invoker.sources @@ -233,72 +283,78 @@ template("ti_simplelink_sdk") { public_configs = [ ":${sdk_target_name}_config" ] } - if (chip_openthread_ftd) { - openthread_example = "cli_ftd" - } else { - openthread_example = "cli_mtd" - } + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { + if (chip_openthread_ftd) { + openthread_example = "cli_ftd" + } else { + openthread_example = "cli_mtd" + } - config("${sdk_target_name}_openthread_platform_config") { - defines = [ "NVOCMP_POSIX_MUTEX" ] - include_dirs = [ - "${chip_root}/third_party/openthread/repo/examples/platforms", - "${chip_root}/third_party/openthread/repo/src/core", - "${ti_simplelink_sdk_root}/source/ti/devices/${ti_simplelink_device_family}", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}", - ] + config("${sdk_target_name}_openthread_platform_config") { + defines = [ "NVOCMP_POSIX_MUTEX" ] + include_dirs = [ + "${chip_root}/third_party/openthread/repo/examples/platforms", + "${chip_root}/third_party/openthread/repo/src/core", + "${ti_simplelink_sdk_root}/source/ti/devices/${ti_simplelink_device_family}", + ] - if (ti_simplelink_device_family == "cc13x2_26x2") { - include_dirs += - [ "${ti_simplelink_sdk_root}/source/ti/devices/cc13x2_cc26x2" ] - } else if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { - include_dirs += - [ "${ti_simplelink_sdk_root}/source/ti/devices/cc13x2x7_cc26x2x7" ] + if (ti_simplelink_device_family == "cc13x2_26x2") { + include_dirs += [ + "${ti_simplelink_sdk_root}/source/ti/devices/cc13x2_cc26x2", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}", + ] + } else if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { + include_dirs += [ + "${ti_simplelink_sdk_root}/source/ti/devices/cc13x2x7_cc26x2x7", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}", + ] + } } - } - source_set("${sdk_target_name}_openthread_platform") { - cflags = [ - "-Wno-int-conversion", - "-Wno-address-of-packed-member", - "-Wno-implicit-fallthrough", - "-Wno-unused-label", - ] - public_deps = [ - ":${sdk_target_name}_freertos", - "${chip_root}/third_party/ti_simplelink_sdk:freertos", - "${chip_root}/third_party/ti_simplelink_sdk:mbedtls", - "${chip_root}/third_party/ti_simplelink_sdk:ti_simplelink_sysconfig", - "${openthread_root}/src/core:libopenthread_core_headers", - ] + source_set("${sdk_target_name}_openthread_platform") { + cflags = [ + "-Wno-int-conversion", + "-Wno-address-of-packed-member", + "-Wno-implicit-fallthrough", + "-Wno-unused-label", + ] + public_deps = [ + ":${sdk_target_name}_freertos", + "${chip_root}/third_party/ti_simplelink_sdk:freertos", + "${chip_root}/third_party/ti_simplelink_sdk:mbedtls", + "${chip_root}/third_party/ti_simplelink_sdk:ti_simplelink_sysconfig", + "${openthread_root}/src/core:libopenthread_core_headers", + ] - configs -= [ "${build_root}/config/compiler:std_default" ] - configs += [ ":${sdk_target_name}_posix_config" ] - sources = [ - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/alarm.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/alarm_micro.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/diag.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/entropy.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/misc.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/nv/crc.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/nv/nvocmp.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/radio.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/settings.c", - "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/system.c", - ] + configs -= [ "${build_root}/config/compiler:std_default" ] + configs += [ ":${sdk_target_name}_posix_config" ] + sources = [ + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/alarm.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/alarm_micro.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/diag.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/entropy.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/misc.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/nv/crc.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/nv/nvocmp.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/radio.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/settings.c", + "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/thread/${openthread_example}/platform/system.c", + ] - public_configs = [ - ":${sdk_target_name}_config", - ":${sdk_target_name}_openthread_platform_config", - "${chip_root}/third_party/openthread/repo:openthread_config", - ] + public_configs = [ + ":${sdk_target_name}_config", + ":${sdk_target_name}_openthread_platform_config", + "${chip_root}/third_party/openthread/repo:openthread_config", + ] - if (chip_openthread_ftd) { - public_configs += - [ "${chip_root}/third_party/openthread/repo:openthread_ftd_config" ] - } else { - public_configs += - [ "${chip_root}/third_party/openthread/repo:openthread_mtd_config" ] + if (chip_openthread_ftd) { + public_configs += + [ "${chip_root}/third_party/openthread/repo:openthread_ftd_config" ] + } else { + public_configs += + [ "${chip_root}/third_party/openthread/repo:openthread_mtd_config" ] + } } } From a75ff3106bdfb858580cf5dcc77d818516e6d41a Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 25 May 2022 22:07:06 +0000 Subject: [PATCH 02/12] Restyled by whitespace --- examples/lock-app/cc32xx/main/AppTask.cpp | 6 +++--- examples/lock-app/cc32xx/main/debug_settings.h | 2 +- examples/lock-app/cc32xx/main/main.cpp | 2 +- src/platform/cc32xx/ConnectivityManagerImpl.cpp | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/examples/lock-app/cc32xx/main/AppTask.cpp b/examples/lock-app/cc32xx/main/AppTask.cpp index 265670ea54b702..984aa12da871eb 100755 --- a/examples/lock-app/cc32xx/main/AppTask.cpp +++ b/examples/lock-app/cc32xx/main/AppTask.cpp @@ -43,7 +43,7 @@ /* syscfg */ #include -extern "C" +extern "C" { extern int WiFi_init(); extern void DisplayBanner(); @@ -108,7 +108,7 @@ int AppTask::Init() /* Initial Terminal, and print Application name */ DisplayBanner(); - + // Init Chip memory management before the stack PLAT_LOG("Initialize Memory"); chip::Platform::MemoryInit(); @@ -134,7 +134,7 @@ int AppTask::Init() buttonParams.longPressDuration = 1000U; // ms gButtonRightHandle = Button_open(CONFIG_BTN_RIGHT, &buttonParams); Button_setCallback(gButtonRightHandle, ButtonRightEventHandler); - + PLAT_LOG("Initialize Wi-Fi"); WiFi_init(); diff --git a/examples/lock-app/cc32xx/main/debug_settings.h b/examples/lock-app/cc32xx/main/debug_settings.h index ddf6792794b383..c76eab0dca7e34 100644 --- a/examples/lock-app/cc32xx/main/debug_settings.h +++ b/examples/lock-app/cc32xx/main/debug_settings.h @@ -36,7 +36,7 @@ #if (D_DEBUG_METHOD == D_USER_DEFINED) extern void cc32xxLog(const char * msg, ...); -#define PRINTF(...) cc32xxLog(__VA_ARGS__); +#define PRINTF(...) cc32xxLog(__VA_ARGS__); #endif #endif // DEBUG_SETTINGS_H diff --git a/examples/lock-app/cc32xx/main/main.cpp b/examples/lock-app/cc32xx/main/main.cpp index 41fee94c39fb43..4c74767ef38b31 100755 --- a/examples/lock-app/cc32xx/main/main.cpp +++ b/examples/lock-app/cc32xx/main/main.cpp @@ -58,7 +58,7 @@ int main(void) { Board_init(); GPIO_init(); - + mbedtls_platform_set_calloc_free(CHIPPlatformMemoryCalloc, CHIPPlatformMemoryFree); int ret = GetAppTask().StartAppTask(); diff --git a/src/platform/cc32xx/ConnectivityManagerImpl.cpp b/src/platform/cc32xx/ConnectivityManagerImpl.cpp index e14436152d4f99..ee1b491a6e80b9 100644 --- a/src/platform/cc32xx/ConnectivityManagerImpl.cpp +++ b/src/platform/cc32xx/ConnectivityManagerImpl.cpp @@ -38,7 +38,7 @@ #include -extern "C" +extern "C" { #include From 3a0305703effaf13622d539280f25aa9115ceb1b Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 25 May 2022 22:07:07 +0000 Subject: [PATCH 03/12] Restyled by clang-format --- examples/lock-app/cc32xx/main/AppTask.cpp | 14 ++++---------- examples/lock-app/cc32xx/main/BoltLockManager.cpp | 3 ++- examples/lock-app/cc32xx/main/ZclCallbacks.cpp | 4 ++-- examples/lock-app/cc32xx/main/cc32xxWifiInit.c | 1 - examples/lock-app/cc32xx/main/debug_settings.h | 12 ++++++------ .../cc32xx/main/include/CHIPProjectConfig.h | 1 - examples/lock-app/cc32xx/main/main.cpp | 2 -- examples/lock-app/cc32xx/main/wifi_settings.h | 4 ++-- src/platform/cc32xx/CC32XXConfig.cpp | 6 +++--- src/platform/cc32xx/ConnectivityManagerImpl.cpp | 11 +++++------ src/platform/cc32xx/FreeRTOSConfig.h | 2 +- src/platform/cc32xx/Logging.cpp | 8 ++++---- 12 files changed, 29 insertions(+), 39 deletions(-) mode change 100755 => 100644 examples/lock-app/cc32xx/main/AppTask.cpp mode change 100755 => 100644 examples/lock-app/cc32xx/main/BoltLockManager.cpp mode change 100755 => 100644 examples/lock-app/cc32xx/main/ZclCallbacks.cpp mode change 100755 => 100644 examples/lock-app/cc32xx/main/cc32xxWifiInit.c mode change 100755 => 100644 examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h mode change 100755 => 100644 examples/lock-app/cc32xx/main/main.cpp mode change 100755 => 100644 src/platform/cc32xx/FreeRTOSConfig.h diff --git a/examples/lock-app/cc32xx/main/AppTask.cpp b/examples/lock-app/cc32xx/main/AppTask.cpp old mode 100755 new mode 100644 index 984aa12da871eb..18196a25b751aa --- a/examples/lock-app/cc32xx/main/AppTask.cpp +++ b/examples/lock-app/cc32xx/main/AppTask.cpp @@ -43,15 +43,13 @@ /* syscfg */ #include -extern "C" -{ -extern int WiFi_init(); -extern void DisplayBanner(); +extern "C" { +extern int WiFi_init(); +extern void DisplayBanner(); } /* Application Version and Naming*/ - #define APP_TASK_STACK_SIZE (4096) #define APP_TASK_PRIORITY 4 #define APP_EVENT_QUEUE_SIZE 10 @@ -70,7 +68,6 @@ static QueueHandle_t sAppEventQueue; extern LED_Handle gLedGreenHandle, gLedRedHandle; static Button_Handle gButtonRightHandle; - AppTask AppTask::sAppTask; int AppTask::StartAppTask() @@ -96,8 +93,6 @@ int AppTask::StartAppTask() return ret; } - - int AppTask::Init() { CHIP_ERROR ret; @@ -273,8 +268,7 @@ void AppTask::ActionCompleted(BoltLockManager::Action_t aAction) LED_setOff(gLedRedHandle); state = 0; } - emberAfWriteAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, &state, - ZCL_BOOLEAN_ATTRIBUTE_TYPE); + emberAfWriteAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, &state, ZCL_BOOLEAN_ATTRIBUTE_TYPE); } void AppTask::DispatchEvent(AppEvent * aEvent) diff --git a/examples/lock-app/cc32xx/main/BoltLockManager.cpp b/examples/lock-app/cc32xx/main/BoltLockManager.cpp old mode 100755 new mode 100644 index ee734a69b7b55a..31c995f7d34d4c --- a/examples/lock-app/cc32xx/main/BoltLockManager.cpp +++ b/examples/lock-app/cc32xx/main/BoltLockManager.cpp @@ -35,7 +35,8 @@ int BoltLockManager::Init() if (NULL == mTimerHandle) { PLAT_LOG("failed to create bolt lock timer"); - while (1); + while (1) + ; } mState = kState_UnlockingCompleted; diff --git a/examples/lock-app/cc32xx/main/ZclCallbacks.cpp b/examples/lock-app/cc32xx/main/ZclCallbacks.cpp old mode 100755 new mode 100644 index 553862096ef67e..f3b352607c913e --- a/examples/lock-app/cc32xx/main/ZclCallbacks.cpp +++ b/examples/lock-app/cc32xx/main/ZclCallbacks.cpp @@ -26,8 +26,8 @@ using namespace ::chip; using namespace ::chip::app::Clusters; -void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t type, - uint16_t size, uint8_t * value) +void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath & attributePath, uint8_t type, uint16_t size, + uint8_t * value) { if (attributePath.mClusterId == OnOff::Id && attributePath.mAttributeId == OnOff::Attributes::OnOff::Id) { diff --git a/examples/lock-app/cc32xx/main/cc32xxWifiInit.c b/examples/lock-app/cc32xx/main/cc32xxWifiInit.c old mode 100755 new mode 100644 index a9fa273130761a..03bb5c18369e5b --- a/examples/lock-app/cc32xx/main/cc32xxWifiInit.c +++ b/examples/lock-app/cc32xx/main/cc32xxWifiInit.c @@ -64,7 +64,6 @@ int CHIP_IF_init(); #define APPLICATION_NAME "CC32XX-MATTER:: E-LOCK" #define APPLICATION_VERSION "01.00.00.00" - /* USER's defines */ #define SLNETCONN_TASK_STACK_SIZE (2048) #define DISPLAY_TASK_STACK_SIZE (512) diff --git a/examples/lock-app/cc32xx/main/debug_settings.h b/examples/lock-app/cc32xx/main/debug_settings.h index c76eab0dca7e34..61cefd37e7fb51 100644 --- a/examples/lock-app/cc32xx/main/debug_settings.h +++ b/examples/lock-app/cc32xx/main/debug_settings.h @@ -27,12 +27,12 @@ #define D_DEBUG_METHOD D_USER_DEFINED // Select Sevrity Color -#define _FATAL_CLR_ _CLR_B_RED_ -#define _ERROR_CLR_ _CLR_RED_ -#define _WARNING_CLR_ _CLR_MAGENTA_ -#define _INFO_CLR_ _CLR_GREEN_ -#define _DEBUG_CLR_ _CLR_YELLOW_ -#define _TRACE_CLR_ _CLR_RESET_ +#define _FATAL_CLR_ _CLR_B_RED_ +#define _ERROR_CLR_ _CLR_RED_ +#define _WARNING_CLR_ _CLR_MAGENTA_ +#define _INFO_CLR_ _CLR_GREEN_ +#define _DEBUG_CLR_ _CLR_YELLOW_ +#define _TRACE_CLR_ _CLR_RESET_ #if (D_DEBUG_METHOD == D_USER_DEFINED) extern void cc32xxLog(const char * msg, ...); diff --git a/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h b/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h old mode 100755 new mode 100644 index 94cae7807fb417..d5187cc43a5d49 --- a/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h +++ b/examples/lock-app/cc32xx/main/include/CHIPProjectConfig.h @@ -147,5 +147,4 @@ #define CHIP_CONFIG_EVENT_LOGGING_DEFAULT_IMPORTANCE chip::Profiles::DataManagement::Debug #endif // BUILD_RELEASE - #endif // CHIP_PROJECT_CONFIG_H diff --git a/examples/lock-app/cc32xx/main/main.cpp b/examples/lock-app/cc32xx/main/main.cpp old mode 100755 new mode 100644 index 4c74767ef38b31..4546931d83aba6 --- a/examples/lock-app/cc32xx/main/main.cpp +++ b/examples/lock-app/cc32xx/main/main.cpp @@ -49,8 +49,6 @@ extern "C" void vApplicationStackOverflowHook(void) } } - - // ================================================================================ // Main Code // ================================================================================ diff --git a/examples/lock-app/cc32xx/main/wifi_settings.h b/examples/lock-app/cc32xx/main/wifi_settings.h index f7f6b946b1f0cf..6fdf1f61603476 100644 --- a/examples/lock-app/cc32xx/main/wifi_settings.h +++ b/examples/lock-app/cc32xx/main/wifi_settings.h @@ -82,8 +82,8 @@ * Define AP_SSID and optionally AP_PASSWORD - to connect to local network * Hard-Coded Definition: update AP_SSID and AP_PASSWORD (NULL means OPEN, else is WPA2) */ -#define AP_SSID NULL // "network-name" -#define AP_PASSWORD NULL // "network-password" +#define AP_SSID NULL // "network-name" +#define AP_PASSWORD NULL // "network-password" /* Static Profile setting - Method 2: Configuration file * File format should be: diff --git a/src/platform/cc32xx/CC32XXConfig.cpp b/src/platform/cc32xx/CC32XXConfig.cpp index 87b8a4f94fdd34..cdc59cd6d37ada 100644 --- a/src/platform/cc32xx/CC32XXConfig.cpp +++ b/src/platform/cc32xx/CC32XXConfig.cpp @@ -238,8 +238,8 @@ class CC32XXKVSList bufferLength += (uint16_t) strlen(currentEntry->Key()); // copy value length - list[bufferLength] = (uint8_t) (currentEntry->Len() & 0xFF); - list[bufferLength + 1] = (uint8_t) ((currentEntry->Len() & 0xFF00) >> 8); + list[bufferLength] = (uint8_t)(currentEntry->Len() & 0xFF); + list[bufferLength + 1] = (uint8_t)((currentEntry->Len() & 0xFF00) >> 8); bufferLength = bufferLength + 2; // copy value @@ -275,7 +275,7 @@ class CC32XXKVSList // read in value length uint16_t valueLen = 0; - valueLen = (uint16_t) (list[currentLength] | list[currentLength + 1] << 8); + valueLen = (uint16_t)(list[currentLength] | list[currentLength + 1] << 8); currentLength += 2; // read in value diff --git a/src/platform/cc32xx/ConnectivityManagerImpl.cpp b/src/platform/cc32xx/ConnectivityManagerImpl.cpp index ee1b491a6e80b9..f1b6785bf78535 100644 --- a/src/platform/cc32xx/ConnectivityManagerImpl.cpp +++ b/src/platform/cc32xx/ConnectivityManagerImpl.cpp @@ -38,14 +38,13 @@ #include -extern "C" -{ +extern "C" { #include #define SLNETCONN_TIMEOUT 0xffff // "infinite" Timeout -extern int LWIP_IF_start(); -extern void SlNetConnEventHandler(uint32_t ifID, SlNetConnStatus_e netStatus, void * data); +extern int LWIP_IF_start(); +extern void SlNetConnEventHandler(uint32_t ifID, SlNetConnStatus_e netStatus, void * data); } #if !CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION @@ -163,8 +162,8 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) { // if (event->CommissioningComplete.Status == CHIP_NO_ERROR) // { - ChipLogProgress(AppServer, "Commissioning completed successfully"); - DeviceLayer::Internal::CC32XXConfig::WriteKVSToNV(); + ChipLogProgress(AppServer, "Commissioning completed successfully"); + DeviceLayer::Internal::CC32XXConfig::WriteKVSToNV(); // } // else // { diff --git a/src/platform/cc32xx/FreeRTOSConfig.h b/src/platform/cc32xx/FreeRTOSConfig.h old mode 100755 new mode 100644 index 2dc4874d7a3549..feece6421568b9 --- a/src/platform/cc32xx/FreeRTOSConfig.h +++ b/src/platform/cc32xx/FreeRTOSConfig.h @@ -55,7 +55,7 @@ supported, or if both static and dynamic allocation are supported. */ #define configMINIMAL_STACK_SIZE ((unsigned short) 256) // changed from 128 #define configMAX_TASK_NAME_LEN (12) -#define configTOTAL_HEAP_SIZE ((size_t) (0x14000)) // inreased from 0xe000 +#define configTOTAL_HEAP_SIZE ((size_t)(0x14000)) // inreased from 0xe000 /* Idle task stack size in words */ #define configIDLE_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2) diff --git a/src/platform/cc32xx/Logging.cpp b/src/platform/cc32xx/Logging.cpp index fbb0632d230dbf..6a4e30b0774ba2 100644 --- a/src/platform/cc32xx/Logging.cpp +++ b/src/platform/cc32xx/Logging.cpp @@ -39,7 +39,7 @@ using namespace ::chip::DeviceLayer::Internal; #define DEVICE_LAYER_LOG_BUFFER_SIZE (256) static UART2_Handle sDebugUartHandle; static char sDebugUartBuffer[DEVICE_LAYER_LOG_BUFFER_SIZE]; -//static pthread_mutex_t mutex; +// static pthread_mutex_t mutex; extern "C" int cc32xxLogInit(void) { @@ -54,7 +54,7 @@ extern "C" int cc32xxLogInit(void) UART2_rxDisable(sDebugUartHandle); /* Enable debug mutex */ - //pthread_mutex_init(&mutex, NULL); + // pthread_mutex_init(&mutex, NULL); return 0; } @@ -62,7 +62,7 @@ extern "C" void cc32xxVLog(const char * msg, va_list v) { int ret; - //pthread_mutex_lock(&mutex); + // pthread_mutex_lock(&mutex); ret = vsnprintf(sDebugUartBuffer, sizeof(sDebugUartBuffer), msg, v); if (0 < ret) { @@ -74,7 +74,7 @@ extern "C" void cc32xxVLog(const char * msg, va_list v) UART2_write(sDebugUartHandle, sDebugUartBuffer, len, &len); } - //pthread_mutex_unlock(&mutex); + // pthread_mutex_unlock(&mutex); } namespace chip { From 330e3c484a5b5c4a088a87bbb20e1b4c948f874d Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 25 May 2022 22:07:09 +0000 Subject: [PATCH 04/12] Restyled by gn --- config/cc32xx/toolchain/BUILD.gn | 2 +- examples/lock-app/cc32xx/BUILD.gn | 4 ++-- examples/platform/cc32xx/BUILD.gn | 1 - examples/platform/cc32xx/args.gni | 1 - src/platform/cc32xx/args.gni | 8 ++++---- third_party/ti_simplelink_sdk/BUILD.gn | 2 +- .../ti_simplelink_executable.gni | 16 +++++----------- .../ti_simplelink_sdk/ti_simplelink_sdk.gni | 14 ++++++-------- 8 files changed, 19 insertions(+), 29 deletions(-) diff --git a/config/cc32xx/toolchain/BUILD.gn b/config/cc32xx/toolchain/BUILD.gn index ce58d55fd7dad4..1e7d672c67bd6d 100755 --- a/config/cc32xx/toolchain/BUILD.gn +++ b/config/cc32xx/toolchain/BUILD.gn @@ -22,4 +22,4 @@ arm_toolchain("cc32xx_lock_app") { current_os = "freertos" import("${chip_root}/examples/lock-app/cc32xx/args.gni") } -} \ No newline at end of file +} diff --git a/examples/lock-app/cc32xx/BUILD.gn b/examples/lock-app/cc32xx/BUILD.gn index e1c9993d9cdb50..d8fd3d4cceeef8 100755 --- a/examples/lock-app/cc32xx/BUILD.gn +++ b/examples/lock-app/cc32xx/BUILD.gn @@ -53,11 +53,11 @@ source_set("lock_app_sdk") { sources = [ "${chip_root}/src/platform/cc32xx/Logging.cpp", + "${project_dir}/main/cc32xxWifiInit.c", + "${project_dir}/main/main.cpp", "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/lwip_if.c", "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/utils_if.c", "${ti_simplelink_sdk_root}/examples/rtos/common/ifmod/wifi_if.c", - "${project_dir}/main/main.cpp", - "${project_dir}/main/cc32xxWifiInit.c", ] include_dirs = [ diff --git a/examples/platform/cc32xx/BUILD.gn b/examples/platform/cc32xx/BUILD.gn index 10a6e39455e73d..031d054e190927 100644 --- a/examples/platform/cc32xx/BUILD.gn +++ b/examples/platform/cc32xx/BUILD.gn @@ -17,4 +17,3 @@ import("//build_overrides/chip.gni") config("chip_examples_project_config") { include_dirs = [ "project_include" ] } - diff --git a/examples/platform/cc32xx/args.gni b/examples/platform/cc32xx/args.gni index 009c56bf5a59fe..94754b21ecc522 100644 --- a/examples/platform/cc32xx/args.gni +++ b/examples/platform/cc32xx/args.gni @@ -16,7 +16,6 @@ import("//build_overrides/chip.gni") import("${chip_root}/src/platform/cc32xx/args.gni") - chip_ble_project_config_include = "" chip_device_project_config_include = "" chip_project_config_include = "" diff --git a/src/platform/cc32xx/args.gni b/src/platform/cc32xx/args.gni index 3e604cdeaa73b5..288aa5a1edc188 100755 --- a/src/platform/cc32xx/args.gni +++ b/src/platform/cc32xx/args.gni @@ -26,11 +26,11 @@ freertos_target = "${chip_root}/third_party/ti_simplelink_sdk:freertos" mbedtls_target = "${chip_root}/third_party/ti_simplelink_sdk:mbedtls" lwip_platform = "cc32xx" -lwip_ipv6 = true -lwip_ipv4 = true -lwip_api = true +lwip_ipv6 = true +lwip_ipv4 = true +lwip_api = true -chip_inet_config_enable_ipv4 = true +chip_inet_config_enable_ipv4 = true chip_inet_config_enable_dns_resolver = false chip_build_tests = false diff --git a/third_party/ti_simplelink_sdk/BUILD.gn b/third_party/ti_simplelink_sdk/BUILD.gn index 8d6ea90cf13f21..2451ab80e67195 100644 --- a/third_party/ti_simplelink_sdk/BUILD.gn +++ b/third_party/ti_simplelink_sdk/BUILD.gn @@ -85,7 +85,7 @@ config("ti_simplelink_freertos_config") { } freertos_target("freertos") { - if (ti_simplelink_device_family == "cc13x2_26x2" || + if (ti_simplelink_device_family == "cc13x2_26x2" || ti_simplelink_device_family == "cc13x2x7_26x2x7") { sources = [ "${freertos_root}/repo/portable/GCC/ARM_CM4F/port.c", diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni index 83817187a343f2..650f336c443d22 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni @@ -47,14 +47,10 @@ template("ti_simplelink_executable") { output_base_name = get_path_info(invoker.output_name, "name") #used for OTA image creator for the cc13xx - if (ti_simplelink_device_family == "cc13x2x7_26x2x7") - { + if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { objcopy_image_name = output_base_name + ".hex" objcopy_image_format = "ihex" - } - #used for Uniflash image creation for the cc32xx - else - { + } else { objcopy_image_name = output_base_name + ".bin" objcopy_image_format = "binary" } @@ -89,10 +85,8 @@ template("ti_simplelink_executable") { } else { ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" } - } - else if (ti_simplelink_device_family == "cc32xx") - { - ldscript = "${ti_simplelink_sdk_root}/source/ti/boards/cc32xxsf/cc32xxsf_freertos.lds" + } else if (ti_simplelink_device_family == "cc32xx") { + ldscript = "${ti_simplelink_sdk_root}/source/ti/boards/cc32xxsf/cc32xxsf_freertos.lds" } inputs = [ ldscript ] @@ -103,7 +97,7 @@ template("ti_simplelink_executable") { "${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", root_build_dir), "-T" + rebase_path(ldscript, root_build_dir), - ] + ] } if (chip_enable_ota_requestor && diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni b/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni index 7072545626bb9f..3613a0bb6b6fe7 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_sdk.gni @@ -28,16 +28,14 @@ import("ti_simplelink_board.gni") declare_args() { # Location of the TI SimpleLink SDK. - - if( (ti_simplelink_device_family == "cc13x2_26x2") || (ti_simplelink_device_family == "cc13x2x7_26x2x7")) - { + + if (ti_simplelink_device_family == "cc13x2_26x2" || + ti_simplelink_device_family == "cc13x2x7_26x2x7") { ti_simplelink_sdk_root = "${chip_root}/third_party/ti_simplelink_sdk/repo_cc13xx_cc26xx" - } - else if (ti_simplelink_device_family == "cc32xx") - { + } else if (ti_simplelink_device_family == "cc32xx") { ti_simplelink_sdk_root = - "${chip_root}/third_party/ti_simplelink_sdk/repo_cc32xx" + "${chip_root}/third_party/ti_simplelink_sdk/repo_cc32xx" } ti_sysconfig_root = "" @@ -86,7 +84,7 @@ template("ti_sysconfig") { ldflags += invoker.ldflags } } - + pw_python_action("${target_name}_gen") { script = "${ti_simplelink_sdk_build_root}/run_sysconfig.py" sources = invoker.sources From 708f906459f197bf6c1a4399a6f3bbb6e1157b69 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 25 May 2022 22:07:15 +0000 Subject: [PATCH 05/12] Restyled by prettier-markdown --- examples/lock-app/cc32xx/README.md | 54 ++++++++++++---------- src/platform/cc32xx/README.md | 74 +++++++++++++++--------------- 2 files changed, 67 insertions(+), 61 deletions(-) diff --git a/examples/lock-app/cc32xx/README.md b/examples/lock-app/cc32xx/README.md index 6c61b9c2726077..a043cd14de9393 100644 --- a/examples/lock-app/cc32xx/README.md +++ b/examples/lock-app/cc32xx/README.md @@ -31,22 +31,22 @@ connected door lock device. This uses the open-source CHIP implementation and the Texas Instruments SimpleLink™ Wi-Fi® CC32xx software development kit. By default this example targets the [CC3235SF_LAUNCHXL][cc3235sf_launchxl] -LaunchPad, but the example application is enabled to build on the whole -`CC32XX` family of MCUs. +LaunchPad, but the example application is enabled to build on the whole `CC32XX` +family of MCUs. -The lock example is intended to serve both as a means to explore the workings -of CHIP, as well as a template for creating real products based on the Texas +The lock example is intended to serve both as a means to explore the workings of +CHIP, as well as a template for creating real products based on the Texas Instruments devices. ## Device UI This example application has a simple User Interface to depict the state of the door lock and to control the state. The user LEDs on the LaunchPad are set on -when the lock is locked, and are set off when unlocked. The LEDs will flash -when in the transition state between locked and unlocked. The user buttons are -used for requesting lock and unlock of the door lock. The left button (`BTN-1`) -is used to enable provsioning (provisioning is enabled as "oneshot" by default. -The right button (`BTN-2`) us used to toggle the "Lock" state. +when the lock is locked, and are set off when unlocked. The LEDs will flash when +in the transition state between locked and unlocked. The user buttons are used +for requesting lock and unlock of the door lock. The left button (`BTN-1`) is +used to enable provsioning (provisioning is enabled as "oneshot" by default. The +right button (`BTN-2`) us used to toggle the "Lock" state. ## Building @@ -56,7 +56,9 @@ Some initial setup is necessary for preparing the build environment. This section will need to be done when migrating to new versions of the SDK. This guide assumes that the environment is linux based, and recommends Ubuntu 20.04. -- Download and install [SysConfig][sysconfig] ([recommended version][sysconfig_recommended]). This can be done simply with the following commands. +- Download and install [SysConfig][sysconfig] ([recommended + version][sysconfig_recommended]). This can be done simply with the following + commands. ``` $ cd ~ @@ -85,9 +87,9 @@ Ninja to build the executable. ``` - Run the build to produce a default executable. By default on Linux the - Sysconfig is located in a `ti` folder in the user's - home directory, and you must provide the absolute path for it. For example - `/home/username/ti/sysconfig_1.12.1`. On Windows the default directory is + Sysconfig is located in a `ti` folder in the user's home directory, and you + must provide the absolute path for it. For example + `/home/username/ti/sysconfig_1.12.1`. On Windows the default directory is `C:\ti`. Take note of this install path, as it will be used in the next step. @@ -98,12 +100,11 @@ Ninja to build the executable. $ ninja -C out/debug ``` - ## Programming -Loading the built image onto a LaunchPad is supported through Code Composer Studio (CCS). -Code Composer Studio can be used to load the image and debug the source code. -UniFlash programming (bin) image is not generated currently. +Loading the built image onto a LaunchPad is supported through Code Composer +Studio (CCS). Code Composer Studio can be used to load the image and debug the +source code. UniFlash programming (bin) image is not generated currently. ### Code Composer Studio @@ -136,7 +137,6 @@ Note that the default configuration of the CCXML uses 2-wire cJTAG instead of the full 4-wire JTAG connection to match the default jumper configuration of the LaunchPad. - ## Viewing Logging Output By default the log output will be sent to the Application/User UART. Open a @@ -155,14 +155,20 @@ terminal emulator to that port to see the output with the following options: ### Provisioning The first step to bring the Matter device onto the network is to provision it. -The example accomplishes this through the proprietary SimpleLink provisioning method (AP or Smart Config) using the SimpleLink Starter Pro mobile app. -Once the device is connected to the local AP, commissioning can be triggered using "OnNetwork" configuration. +The example accomplishes this through the proprietary SimpleLink provisioning +method (AP or Smart Config) using the SimpleLink Starter Pro mobile app. Once +the device is connected to the local AP, commissioning can be triggered using +"OnNetwork" configuration. #### Bluetooth LE Provisioning + BLE provisioning is not supported currently. ### CHIP tool changes needed for Wi-Fi example -The timeout for the CHIP tool needs to be increased from 10 to 15 seconds. This can be done in chip::System::Clock::Timeout GetWaitDuration in connectedhomeip/examples/chip-tool/commands/clusters/ModelCommand.h + +The timeout for the CHIP tool needs to be increased from 10 to 15 seconds. This +can be done in chip::System::Clock::Timeout GetWaitDuration in +connectedhomeip/examples/chip-tool/commands/clusters/ModelCommand.h ## TI Support @@ -180,9 +186,11 @@ Additionally, we welcome any feedback. [ccs_manual_method]: https://software-dl.ti.com/ccs/esd/documents/users_guide/ccs_debug-main.html?configuration#manual-method [cc3235sf_launchxl]: https://www.ti.com/tool/LAUNCHXL-CC3235SF -[e2e]: https://e2e.ti.com/support/wireless-connectivity/wi-fi-group/wifi/f/wi-fi-forum +[e2e]: + https://e2e.ti.com/support/wireless-connectivity/wi-fi-group/wifi/f/wi-fi-forum [sysconfig]: https://www.ti.com/tool/SYSCONFIG [sysconfig_recommended]: https://software-dl.ti.com/ccs/esd/sysconfig/sysconfig-1.12.1_2446-setup.run -[ti_cc32xx_matter_request]: https://www.ti.com/tool/download/SIMPLELINK-CC32XX-SDK/5.30.00.08 +[ti_cc32xx_matter_request]: + https://www.ti.com/tool/download/SIMPLELINK-CC32XX-SDK/5.30.00.08 [uniflash]: https://www.ti.com/tool/download/UNIFLASH diff --git a/src/platform/cc32xx/README.md b/src/platform/cc32xx/README.md index 5729e291cab055..d9488eac3aa4ad 100644 --- a/src/platform/cc32xx/README.md +++ b/src/platform/cc32xx/README.md @@ -1,85 +1,83 @@ # Overview of CHIP CC32XX Adaption -The following is an overview of the CC32XX adaptation of CHIP. Most of this -code will have parallels in any new adaptation. +The following is an overview of the CC32XX adaptation of CHIP. Most of this code +will have parallels in any new adaptation. (All file names are relative to `connectedhomeip/src/platform/CC32XX...`). - `BlePlatformConfig.h` -- Configuration header for BLE specific configurations -- Required by AutoConf build +- Configuration header for BLE specific configurations +- Required by AutoConf build **NOTE** empty for now `CC32XXConfig.h`
`CC32XXConfig.cpp` -- Concrete implementation of the Non-Volatile storage of information for chip +- Concrete implementation of the Non-Volatile storage of information for chip **NOTE** empty for now `CHIPDevicePlatformConfig.h` -- Configuration for the chip stack for the CC32XX platform +- Configuration for the chip stack for the CC32XX platform `CHIPDevicePlatformEvent.h` -- Definition of platform events to be handled by the chip processing loop -- Currently there are no events that need special handling +- Definition of platform events to be handled by the chip processing loop +- Currently there are no events that need special handling `CHIPPlatformConfig.h`
`InetPlatformConfig.h`
`SystemPlatformConfig.h` -- Definitions for the chip stack to work with the configurations of the - CC32XX platform +- Definitions for the chip stack to work with the configurations of the CC32XX + platform `ConfigurationManagerImpl.h`
`ConfigurationManagerImpl.cpp` -- Concrete implementation of ConfigurationManager interface -- Manages storage and retrieval of persistent configuration data -- Relies on GenericConfigurationManagerImpl<> classes to implement most API - functionality -- Delegates low-level reading and writing of persistent values to - `CC32XXConfig` class +- Concrete implementation of ConfigurationManager interface +- Manages storage and retrieval of persistent configuration data +- Relies on GenericConfigurationManagerImpl<> classes to implement most API + functionality +- Delegates low-level reading and writing of persistent values to + `CC32XXConfig` class `ConnectivityManagerImpl.h`
`ConnectivityManagerImpl.cpp` -- Concrete implementation of `ConnectivityManager` interface -- Provides high-level APIs for managing device connectivity -- Relies on `GenericConnectivityManagerImpl_Thread<>` class to provide most of - the implementation +- Concrete implementation of `ConnectivityManager` interface +- Provides high-level APIs for managing device connectivity +- Relies on `GenericConnectivityManagerImpl_Thread<>` class to provide most of + the implementation `Entropy.cpp` -- Concrete implementation of an entropy source based on the TRNG +- Concrete implementation of an entropy source based on the TRNG **NOTE** empty for now `Logging.cpp` -- Concrete implementation of the logging functions -- Currently logs out the User UART interface on the XDS110 +- Concrete implementation of the logging functions +- Currently logs out the User UART interface on the XDS110 `ThreadStackManagerImpl.h`
`ThreadStackManagerImpl.cpp` -- Concrete implementation of ThreadStackManager interface -- Supports Thread stack initialization and core event loop processing -- Relies on `GenericThreadStackManagerImpl_OpenThread/FreeRTOS/LwIP<>` classes - to implement most API functionality +- Concrete implementation of ThreadStackManager interface +- Supports Thread stack initialization and core event loop processing +- Relies on `GenericThreadStackManagerImpl_OpenThread/FreeRTOS/LwIP<>` classes + to implement most API functionality -**NOTE** Currently disabled because OpenThread Libraries are not built or -linked in. +**NOTE** Currently disabled because OpenThread Libraries are not built or linked +in. `PlatformManagerImpl.h`
`PlatformManagerImpl.cpp` -- Concrete implementation of `PlatformManager` interface -- Provides initialization of the CHIP stack and core event loop for the chip - task -- Relies on `GenericPlatformManagerImpl_FreeRTOS<>` class to provide most of the - implementation +- Concrete implementation of `PlatformManager` interface +- Provides initialization of the CHIP stack and core event loop for the chip + task +- Relies on `GenericPlatformManagerImpl_FreeRTOS<>` class to provide most of + the implementation `SoftwareUpdateManagerImpl.cpp` -- Concrete implementation of the Software Update Manager -- Relies on the `GenericSoftwareUpdateManagerImpl` - +- Concrete implementation of the Software Update Manager +- Relies on the `GenericSoftwareUpdateManagerImpl` From e4fe0aa798cf928f9efafd811a51226e402deeff Mon Sep 17 00:00:00 2001 From: Anu Biradar Date: Thu, 9 Jun 2022 13:55:58 -0500 Subject: [PATCH 06/12] check-spellcheck and misspell fixes --- examples/lock-app/cc32xx/README.md | 2 +- src/platform/cc32xx/Logging.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/lock-app/cc32xx/README.md b/examples/lock-app/cc32xx/README.md index a043cd14de9393..0f5fd3a6f8a9c4 100644 --- a/examples/lock-app/cc32xx/README.md +++ b/examples/lock-app/cc32xx/README.md @@ -45,7 +45,7 @@ door lock and to control the state. The user LEDs on the LaunchPad are set on when the lock is locked, and are set off when unlocked. The LEDs will flash when in the transition state between locked and unlocked. The user buttons are used for requesting lock and unlock of the door lock. The left button (`BTN-1`) is -used to enable provsioning (provisioning is enabled as "oneshot" by default. The +used to enable provisioning (provisioning is enabled as "oneshot" by default. The right button (`BTN-2`) us used to toggle the "Lock" state. ## Building diff --git a/src/platform/cc32xx/Logging.cpp b/src/platform/cc32xx/Logging.cpp index 6a4e30b0774ba2..4afe6d2db05f8d 100644 --- a/src/platform/cc32xx/Logging.cpp +++ b/src/platform/cc32xx/Logging.cpp @@ -83,7 +83,7 @@ namespace DeviceLayer { /** * Called whenever a log message is emitted. * - * Can be overriden by the device logging file + * Can be overridden by the device logging file */ void __attribute__((weak)) OnLogOutput(void) {} From 7eec2f187b8acdd83a9c82e5e27533d8eedb1ffa Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 14 Jun 2022 16:06:27 +0000 Subject: [PATCH 07/12] Restyled by gn --- src/platform/device.gni | 1 - 1 file changed, 1 deletion(-) diff --git a/src/platform/device.gni b/src/platform/device.gni index da015d1bce7ae4..ab44d84a7c4e2f 100755 --- a/src/platform/device.gni +++ b/src/platform/device.gni @@ -16,7 +16,6 @@ import("//build_overrides/chip.gni") import("${chip_root}/src/ble/ble.gni") declare_args() { - # Device platform layer: cc13x2_26x2, cc32xx, darwin, efr32, esp32, external, freertos, linux, nrfconnect, k32w0, qpg, tizen, cyw30739, bl602, zephyr, none. chip_device_platform = "auto" From 40dd8e1b4381a23b4b5e14e2067c82ffc9d0f802 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 14 Jun 2022 16:06:34 +0000 Subject: [PATCH 08/12] Restyled by prettier-markdown --- examples/lock-app/cc32xx/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/lock-app/cc32xx/README.md b/examples/lock-app/cc32xx/README.md index 0f5fd3a6f8a9c4..43411c36109adf 100644 --- a/examples/lock-app/cc32xx/README.md +++ b/examples/lock-app/cc32xx/README.md @@ -45,8 +45,8 @@ door lock and to control the state. The user LEDs on the LaunchPad are set on when the lock is locked, and are set off when unlocked. The LEDs will flash when in the transition state between locked and unlocked. The user buttons are used for requesting lock and unlock of the door lock. The left button (`BTN-1`) is -used to enable provisioning (provisioning is enabled as "oneshot" by default. The -right button (`BTN-2`) us used to toggle the "Lock" state. +used to enable provisioning (provisioning is enabled as "oneshot" by default. +The right button (`BTN-2`) us used to toggle the "Lock" state. ## Building From c36d2419aaf5a6a00d203eacc5ae5f29638fb78a Mon Sep 17 00:00:00 2001 From: Anu Biradar Date: Mon, 20 Jun 2022 11:41:59 -0500 Subject: [PATCH 09/12] added terms to .wordlist --- .github/.wordlist.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/.wordlist.txt b/.github/.wordlist.txt index 9189db4df34508..629feaa28dd9d9 100644 --- a/.github/.wordlist.txt +++ b/.github/.wordlist.txt @@ -100,6 +100,7 @@ auth AuthMode autoApplyImage autocompletion +AutoConf autoconnect autocrlf autogenerated @@ -553,6 +554,7 @@ GetIP getManualTests getstarted getTests +GetWaitDuration GH ghp githubusercontent @@ -830,6 +832,7 @@ MLD mmevk moal ModeSelect +ModelCommand modprobe Modustoolbox moveMode @@ -1301,6 +1304,7 @@ trackFree TransferSession transitionTime TransportMgrBase +TRNG TrustedRootCertificates tsan TSG @@ -1437,6 +1441,7 @@ xfffff xFFFFFFEFFFFFFFFF xtensa xwayland +XXSF xyz xz xzvf From e2bfd9eded688a404cb6389fe92a952d20be2394 Mon Sep 17 00:00:00 2001 From: Anu Biradar Date: Wed, 22 Jun 2022 11:15:46 -0500 Subject: [PATCH 10/12] backticks for code terms --- .github/.wordlist.txt | 3 --- examples/lock-app/cc32xx/README.md | 6 +++--- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/.github/.wordlist.txt b/.github/.wordlist.txt index 629feaa28dd9d9..2f50a23c2a4fab 100644 --- a/.github/.wordlist.txt +++ b/.github/.wordlist.txt @@ -554,7 +554,6 @@ GetIP getManualTests getstarted getTests -GetWaitDuration GH ghp githubusercontent @@ -832,7 +831,6 @@ MLD mmevk moal ModeSelect -ModelCommand modprobe Modustoolbox moveMode @@ -1441,7 +1439,6 @@ xfffff xFFFFFFEFFFFFFFFF xtensa xwayland -XXSF xyz xz xzvf diff --git a/examples/lock-app/cc32xx/README.md b/examples/lock-app/cc32xx/README.md index 43411c36109adf..c1474a096a6b25 100644 --- a/examples/lock-app/cc32xx/README.md +++ b/examples/lock-app/cc32xx/README.md @@ -1,4 +1,4 @@ -# Matter CC32XXSF Lock Example Application +# Matter `CC32XXSF` Lock Example Application An example application showing the use of [Matter][matter] on the Texas Instruments CC32XX family of Wireless MCUs. @@ -167,8 +167,8 @@ BLE provisioning is not supported currently. ### CHIP tool changes needed for Wi-Fi example The timeout for the CHIP tool needs to be increased from 10 to 15 seconds. This -can be done in chip::System::Clock::Timeout GetWaitDuration in -connectedhomeip/examples/chip-tool/commands/clusters/ModelCommand.h +can be done in `chip::System::Clock::Timeout GetWaitDuration` in +`connectedhomeip/examples/chip-tool/commands/clusters/ModelCommand.h` ## TI Support From 43ee67e4de6a7e78a10d17e254e9d08c0309fea9 Mon Sep 17 00:00:00 2001 From: Anu Biradar Date: Fri, 24 Jun 2022 15:56:39 -0500 Subject: [PATCH 11/12] dummy commit From 47d46728004209b7d986f5fd3263602a2c4a63b5 Mon Sep 17 00:00:00 2001 From: Anu Biradar Date: Mon, 27 Jun 2022 15:40:49 -0500 Subject: [PATCH 12/12] dummy commit