diff --git a/drivers/bluetooth/hci/Kconfig.stm32 b/drivers/bluetooth/hci/Kconfig.stm32 index 52695cba04a4c..e86b89ebcdaf5 100644 --- a/drivers/bluetooth/hci/Kconfig.stm32 +++ b/drivers/bluetooth/hci/Kconfig.stm32 @@ -13,3 +13,290 @@ config BT_STM32WBA_USE_TEMP_BASED_CALIB help Allows the linklayer to calibrate itself on the current temperature read on the ADC4 endmenu + +menu "STM32WBA RT IO DEBUG Configuration" + depends on BT_STM32WBA + +config BT_STM32WBA_RT_DEBUG_DTB + bool "STM32WBA Real Time Debug module for DTB usage activation" + default n + help + Allows to activate STM32WBA Real Time Debug module to probe HW signals from RF PHY activity + +config BT_STM32WBA_RT_DEBUG_GPIO_MODULE + bool "STM32WBA Real Time Debug module activation" + default n + depends on GPIO + help + Allows to activate STM32WBA Real Time Debug module to probe debug signals from Link Layer and system framework + +config BT_STM32WBA_USE_RT_DEBUG_CONFIGURATION_SYSTEM + bool "RT Debug configuration for System purpose" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + select BT_STM32WBA_USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG + select BT_STM32WBA_USE_RT_DEBUG_SCM_SETUP + select BT_STM32WBA_USE_RT_DEBUG_SCM_HSERDY_ISR + select BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE + select BT_STM32WBA_USE_RT_DEBUG_ADC_ACTIVATION + select BT_STM32WBA_USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION + select BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE + help + Probe signal associated to Debug configuration for System purpose + +config BT_STM32WBA_USE_RT_DEBUG_CONFIGURATION_BLE + bool "RT Debug configuration for BLE purpose" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + select BT_STM32WBA_USE_RT_DEBUG_LLWCC_CMN_HG_ISR + select BT_STM32WBA_USE_RT_DEBUG_LLHWC_CMN_LW_ISR + select BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_EXEC + #select BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EVNT_RGSTR + select BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT + select BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE + select BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE + select BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_ISR + help + Probe signal associated to Debug configuration for BLE purpose + +config BT_STM32WBA_USE_RT_DEBUG_CONFIGURATION_MAC + bool "RT Debug configuration for MAC purpose" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to Debug configuration for MAC purpose + +config BT_STM32WBA_USE_RT_DEBUG_CONFIGURATION_COEX + bool "RT Debug configuration for COEX purpose" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to Debug configuration for COEX purpose + +config BT_STM32WBA_USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG + bool "RT Debug of System clock config in System clock manager" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to System clock config in System clock manager + Store GPIOs named 'rt-dbg-scm-sys-clock-config-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-scm-sys-clock-config-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_SCM_SETUP + bool "RT Debug of System clock Setup in System clock manager" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to System clock Setup in System clock manager + Store GPIOs named 'rt-dbg-scm-setup-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-scm-setup-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_SCM_HSERDY_ISR + bool "RT Debug of HSE RDY interrupt handling in System clock manager" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to HSE RDY interrupt handling in System clock manager + Store GPIOs named 'rt-dbg-scm-hse-isr-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-scm-hserdy-isr-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE + bool "RT Debug of Low Power Stop Mode activationr" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to Low Power Stop Mode activation + Store GPIOs named 'rt-dbg-lowpower-stop-mode-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-lowpower-stop-mode-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_ADC_ACTIVATION + bool "RT Debug of ADC activationr" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to ADC activation + Store GPIOs named 'rt-dbg-adc-activation-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-adc-activation-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION + bool "RT Debug of ADC Temperature acquisition" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to ADC Temperature acquisition + Store GPIOs named 'rt-dbg-adc-temp-acquisition-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-adc-temp-acquisition-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE + bool "RT Debug of Low Power Standby Mode activationr" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to Low Power Standby Mode activation + Store GPIOs named 'rt-dbg-lowpower-standby-mode-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-lowpower-standby-mode-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_LLWCC_CMN_HG_ISR + bool "RT Debug of Link Layer time critical interrupt processing" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to time critical interrupt processing in the Link Layer + Store GPIOs named 'rt-dbg-llwcc-cmn-hg-isr-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-llwcc-cmn-hg-isr-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_LLHWC_CMN_LW_ISR + bool "RT Debug of Link Layer interrupt processing with no hard time constraints" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to interrupt processing done in low priority interrupt ISR context in the Link Layer + Store GPIOs named 'rt-dbg-llhwc-cmn-lw-isr-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-llhwc-cmn-lw-isr-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_EXEC + bool "RT Debug of Link Layer PHY Calibration execution" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to PHY Calibration execution in the Link Layer + Store GPIOs named 'rt-dbg-phy-clbr-exec-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-phy-clbr-exec-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EVNT_RGSTR + bool "RT Debug of Link Layer when register an event to the event scheduler" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to registration of an event to the event scheduler in the Link Layer + Store GPIOs named 'rt-dbg-schdr-evnt-rgstr-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-schdr-evnt-rgstr-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + + +config BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT + bool "RT Debug of Link Layer when scheduler handle a missed event" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to the handling of a missed event by the scheduler in the Link Layer + Store GPIOs named 'rt-dbg-schdr-hndl-missed-evnt-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-schdr-hndl-missed-evnt-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + + +config BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE + bool "RT Debug of Link Layer prepares the system to send the next event" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to prepararation by the system to send the next event in the Link Layer + Store GPIOs named 'rt-dbg-schdlr-hndl-nxt-trace-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-schdlr-hndl-nxt-trace-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE + bool "RT Debug of Link Layer searches and schedules the nearest and highest priority event to be on the air" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to the scheduling of the next event on the air in the Link Layer + Store GPIOs named 'rt-dbg-schdlr-exec-evnt-trace-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-schdlr-exec-evnt-trace-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; + +config BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_ISR + bool "RT Debug of Link Layer PHY Calibration ISR activation" + default n + depends on BT_STM32WBA_RT_DEBUG_GPIO_MODULE + help + Probe signal associated to PHY Calibration ISR activation in the Link Layer + Store GPIOs named 'rt-dbg-phy-clbr-isr-gpios' in the ``/zephyr,user`` node + to reconfigure with a devicetree overlay. + For example, with this devicetree overlay: + / { + zephyr,user { + rt-dbg-phy-clbr-isr-gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>; + }; + }; +endmenu \ No newline at end of file diff --git a/drivers/gpio/gpio_stm32.c b/drivers/gpio/gpio_stm32.c index 865f4ae48e0ef..59691bb40b3eb 100644 --- a/drivers/gpio/gpio_stm32.c +++ b/drivers/gpio/gpio_stm32.c @@ -174,6 +174,35 @@ static inline uint32_t stm32_pinval_get(gpio_pin_t pin) return pinval; } +static inline void ll_gpio_pwr_set_standby_retention_config(const struct device *dev,gpio_pin_t pin,uint8_t enable) +{ +#if defined(CONFIG_SOC_SERIES_STM32WBAX) + const struct gpio_stm32_config *cfg = dev->config; + GPIO_TypeDef *gpio = (GPIO_TypeDef *)cfg->base; + uint32_t pin_ll = stm32_pinval_get(pin); + uint32_t pwr_gpio_port = 0; + + if(gpio == GPIOA){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTA;} + else if(gpio == GPIOB){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTB;} + else if(gpio == GPIOC){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTC;} +#if defined(PWR_STOP2_SUPPORT) + else if(gpio == GPIOD){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTD;} + else if(gpio == GPIOE){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTE;} + else if(gpio == GPIOG){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTG;} +#endif + else if(gpio == GPIOH){pwr_gpio_port = LL_PWR_GPIO_STATE_RETENTION_ENABLE_PORTH;} + else return; + if (enable == 1) + { + LL_PWR_EnableGPIOStandbyRetention(pwr_gpio_port, pin_ll); + } + else + { + LL_PWR_DisableGPIOStandbyRetention(pwr_gpio_port, pin_ll); + } +#endif /* CONFIG_SOC_SERIES_STM32WBAX */ +} + static inline void ll_gpio_set_pin_pull(GPIO_TypeDef *GPIOx, uint32_t Pin, uint32_t Pull) { #if defined(CONFIG_SOC_SERIES_STM32WB0X) @@ -536,6 +565,13 @@ static int gpio_stm32_config(const struct device *dev, } #endif /* CONFIG_STM32_WKUP_PINS */ + if (flags & STM32_GPIO_PWR_RETENTION_STANDBY_ON) { + ll_gpio_pwr_set_standby_retention_config(dev,pin,1); + } + else{ + ll_gpio_pwr_set_standby_retention_config(dev,pin,0); + } + /* Decrement GPIO usage count only if pin is now disconnected after being connected */ if (((flags & GPIO_OUTPUT) == 0) && ((flags & GPIO_INPUT) == 0) && (data->pin_has_clock_enabled & BIT(pin))) { diff --git a/include/zephyr/dt-bindings/gpio/stm32-gpio.h b/include/zephyr/dt-bindings/gpio/stm32-gpio.h index 3a31bbc60e0b1..0c4183c5bff5a 100644 --- a/include/zephyr/dt-bindings/gpio/stm32-gpio.h +++ b/include/zephyr/dt-bindings/gpio/stm32-gpio.h @@ -15,6 +15,7 @@ * * - Bit 8: Configure a GPIO pin to power on the system after Poweroff. * - Bit 10..9: Configure the output speed of a GPIO pin. + * - Bit 11: GPIO PWR retention in Standby mode (0=Disable, 1=Enable) * * @ingroup gpio_interface * @{ @@ -46,4 +47,21 @@ /** @} */ +/** + * @name GPIO PWR retention in Standby mode flags + * @brief GPIO PWR retention in Standby mode flags + * @{ + */ + +/** @cond INTERNAL_HIDDEN */ +#define STM32_GPIO_PWR_RETENTION_STANDBY_SHIFT 11 +#define STM32_GPIO_PWR_RETENTION_STANDBY_MASK 0x0800U +/** @endcond */ + +/** Disable GPIO PWR retention in Standby mode */ +#define STM32_GPIO_PWR_RETENTION_STANDBY_OFF (0U << STM32_GPIO_PWR_RETENTION_STANDBY_SHIFT) +/** Enable GPIO PWR retention in Standby mode */ +#define STM32_GPIO_PWR_RETENTION_STANDBY_ON (1U << STM32_GPIO_PWR_RETENTION_STANDBY_SHIFT) +/** @} */ + #endif /* ZEPHYR_INCLUDE_DT_BINDINGS_GPIO_STM32_GPIO_H_ */ diff --git a/soc/st/stm32/stm32wbax/CMakeLists.txt b/soc/st/stm32/stm32wbax/CMakeLists.txt index 6872ff696f95f..ab3dbe3b5685d 100644 --- a/soc/st/stm32/stm32wbax/CMakeLists.txt +++ b/soc/st/stm32/stm32wbax/CMakeLists.txt @@ -19,6 +19,15 @@ if(CONFIG_BT_STM32WBA) zephyr_sources(hci_if/stm32_timer.c) endif() +if(CONFIG_BT_STM32WBA_RT_DEBUG_GPIO_MODULE) + zephyr_include_directories(debug) + zephyr_sources(debug/RTDebug.c) + zephyr_sources(debug/app_debug.c) + zephyr_compile_definitions( -DCFG_RT_DEBUG_GPIO_MODULE=1 ) +else() + zephyr_compile_definitions( -DCFG_RT_DEBUG_GPIO_MODULE=0 ) +endif() + zephyr_include_directories(.) set(SOC_LINKER_SCRIPT ${ZEPHYR_BASE}/include/zephyr/arch/arm/cortex_m/scripts/linker.ld CACHE INTERNAL "") diff --git a/soc/st/stm32/stm32wbax/debug/RTDebug.c b/soc/st/stm32/stm32wbax/debug/RTDebug.c new file mode 100644 index 0000000000000..2e1ead1c7fbe5 --- /dev/null +++ b/soc/st/stm32/stm32wbax/debug/RTDebug.c @@ -0,0 +1,72 @@ +/** + ****************************************************************************** + * @file RTDebug.c + * @author MCD Application Team + * @brief Real Time Debug module API definition + ****************************************************************************** + * @attention + * + * Copyright (c) 2024 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +#include "RTDebug.h" +#include "local_debug_tables.h" +#include + +/***********************/ +/** System debug APIs **/ +/***********************/ + +void SYSTEM_DEBUG_SIGNAL_SET(system_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_SET(signal, system_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} + +void SYSTEM_DEBUG_SIGNAL_RESET(system_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_RESET(signal, system_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} + +void SYSTEM_DEBUG_SIGNAL_TOGGLE(system_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_TOGGLE(signal, system_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} + +/***************************/ +/** Link Layer debug APIs **/ +/***************************/ + +/* Link Layer debug API definition */ +void LINKLAYER_DEBUG_SIGNAL_SET(linklayer_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_SET(signal, linklayer_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} + +void LINKLAYER_DEBUG_SIGNAL_RESET(linklayer_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_RESET(signal, linklayer_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} + +void LINKLAYER_DEBUG_SIGNAL_TOGGLE(linklayer_debug_signal_t signal) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + GENERIC_DEBUG_GPIO_TOGGLE(signal, linklayer_debug_table); +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +} diff --git a/soc/st/stm32/stm32wbax/debug/RTDebug.h b/soc/st/stm32/stm32wbax/debug/RTDebug.h new file mode 100644 index 0000000000000..db80f1ac0ce05 --- /dev/null +++ b/soc/st/stm32/stm32wbax/debug/RTDebug.h @@ -0,0 +1,83 @@ +/** + ****************************************************************************** + * @file RTDebug.h + * @author MCD Application Team + * @brief Real Time Debug module API declaration + ****************************************************************************** + * @attention + * + * Copyright (c) 2024 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +#ifndef SYSTEM_DEBUG_H +#define SYSTEM_DEBUG_H + +#include "debug_config.h" + +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + +//extern const struct gpio_dt_spec general_debug_table[RT_DEBUG_SIGNALS_TOTAL_NUM]; +/**************************************************************/ +/** Generic macros for local signal table index recuperation **/ +/** and global signal table GPIO manipulation **/ +/**************************************************************/ + +#define GENERIC_DEBUG_GPIO_SET(signal, table) do { \ + uint32_t debug_table_idx = 0; \ + if(signal >= sizeof(table)) \ + { \ + return; \ + } \ + debug_table_idx = table[signal]; \ + if(debug_table_idx != RT_DEBUG_SIGNAL_UNUSED) \ + { \ + gpio_pin_set_dt(&general_debug_table[debug_table_idx],1); \ + } \ +} while(0) + +#define GENERIC_DEBUG_GPIO_RESET(signal, table) do { \ + uint32_t debug_table_idx = 0; \ + if(signal >= sizeof(table)) \ + { \ + return; \ + } \ + debug_table_idx = table[signal]; \ + if(debug_table_idx != RT_DEBUG_SIGNAL_UNUSED) \ + { \ + gpio_pin_set_dt(&general_debug_table[debug_table_idx],0); \ + } \ +} while(0) + +#define GENERIC_DEBUG_GPIO_TOGGLE(signal, table) do { \ + uint32_t debug_table_idx = 0; \ + if(signal >= sizeof(table)) \ + { \ + return; \ + } \ + debug_table_idx = table[signal]; \ + if(debug_table_idx != RT_DEBUG_SIGNAL_UNUSED) \ + { \ + gpio_pin_toggle_dt(&general_debug_table[debug_table_idx]); \ + } \ +} while(0) + +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ + +/* System debug API definition */ +void SYSTEM_DEBUG_SIGNAL_SET(system_debug_signal_t signal); +void SYSTEM_DEBUG_SIGNAL_RESET(system_debug_signal_t signal); +void SYSTEM_DEBUG_SIGNAL_TOGGLE(system_debug_signal_t signal); + +/* Link Layer debug API definition */ +void LINKLAYER_DEBUG_SIGNAL_SET(linklayer_debug_signal_t signal); +void LINKLAYER_DEBUG_SIGNAL_RESET(linklayer_debug_signal_t signal); +void LINKLAYER_DEBUG_SIGNAL_TOGGLE(linklayer_debug_signal_t signal); + +#endif /* SYSTEM_DEBUG_H */ diff --git a/soc/st/stm32/stm32wbax/debug/app_debug.c b/soc/st/stm32/stm32wbax/debug/app_debug.c new file mode 100644 index 0000000000000..b4731c2494770 --- /dev/null +++ b/soc/st/stm32/stm32wbax/debug/app_debug.c @@ -0,0 +1,805 @@ +/* USER CODE BEGIN Header */ +/** + ****************************************************************************** + * @file app_debug.c + * @author MCD Application Team + * @brief Real Time Debug module application side APIs + ****************************************************************************** + * @attention + * + * Copyright (c) 2023 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ +/* USER CODE END Header */ +#if (CFG_RT_DEBUG_GPIO_MODULE == 1) +#include "debug_config.h" +#include + +/******************************************************************/ +/** Association table between general debug signal and used gpio **/ +/******************************************************************/ +const struct gpio_dt_spec general_debug_table[RT_DEBUG_SIGNALS_TOTAL_NUM] = { + [RT_DEBUG_SIGNAL_UNUSED] = { 0 }, + +#if (USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG == 1) + [RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG] = GPIO_DEBUG_SCM_SYSTEM_CLOCK_CONFIG, +#endif /* USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG */ + +#if (USE_RT_DEBUG_SCM_SETUP == 1) + [RT_DEBUG_SCM_SETUP] = GPIO_DEBUG_SCM_SETUP, +#endif /* USE_RT_DEBUG_SCM_SETUP */ + +#if (USE_RT_DEBUG_SCM_HSERDY_ISR == 1) + [RT_DEBUG_SCM_HSERDY_ISR] = GPIO_DEBUG_SCM_HSERDY_ISR, +#endif /* USE_RT_DEBUG_SCM_HSERDY_ISR */ + +#if (USE_RT_DEBUG_ADC_ACTIVATION == 1) + [RT_DEBUG_ADC_ACTIVATION] = GPIO_DEBUG_ADC_ACTIVATION, +#endif /* USE_RT_DEBUG_ADC_ACTIVATION */ + +#if (USE_RT_DEBUG_ADC_DEACTIVATION == 1) + [RT_DEBUG_ADC_DEACTIVATION] = GPIO_DEBUG_ADC_DEACTIVATION, +#endif /* USE_RT_DEBUG_ADC_DEACTIVATION */ + +#if (USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION == 1) + [RT_DEBUG_ADC_TEMPERATURE_ACQUISITION] = GPIO_DEBUG_ADC_TEMPERATURE_ACQUISITION, +#endif /* USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION */ + +#if (USE_RT_DEBUG_RNG_ENABLE == 1) + [RT_DEBUG_RNG_ENABLE] = GPIO_DEBUG_RNG_ENABLE, +#endif /* USE_RT_DEBUG_RNG_ENABLE */ + +#if (USE_RT_DEBUG_RNG_DISABLE == 1) + [RT_DEBUG_RNG_DISABLE] = GPIO_DEBUG_RNG_DISABLE, +#endif /* USE_RT_DEBUG_RNG_DISABLE */ + +#if (USE_RT_DEBUG_RNG_GEN_RAND_NUM == 1) + [RT_DEBUG_RNG_GEN_RAND_NUM] = GPIO_DEBUG_RNG_GEN_RAND_NUM, +#endif /* USE_RT_DEBUG_RNG_GEN_RAND_NUM */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER == 1) + [RT_DEBUG_LOW_POWER_STOP_MODE_ENTER] = GPIO_DEBUG_LOW_POWER_STOP_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT == 1) + [RT_DEBUG_LOW_POWER_STOP_MODE_EXIT] = GPIO_DEBUG_LOW_POWER_STOP_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE == 1) + [RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE] = GPIO_DEBUG_LOW_POWER_STOP_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER == 1) + [RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER] = GPIO_DEBUG_LOW_POWER_STOP2_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT == 1) + [RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT] = GPIO_DEBUG_LOW_POWER_STOP2_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE == 1) + [RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE] = GPIO_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER == 1) + [RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER] = GPIO_DEBUG_LOW_POWER_STANDBY_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT == 1) + [RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT] = GPIO_DEBUG_LOW_POWER_STANDBY_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE == 1) + [RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE] = GPIO_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_HCI_READ_DONE == 1) + [RT_DEBUG_HCI_READ_DONE] = GPIO_DEBUG_HCI_READ_DONE, +#endif /* USE_RT_DEBUG_HCI_READ_DONE */ + +#if (USE_RT_DEBUG_HCI_RCVD_CMD == 1) + [RT_DEBUG_HCI_RCVD_CMD] = GPIO_DEBUG_HCI_RCVD_CMD, +#endif /* USE_RT_DEBUG_HCI_RCVD_CMD */ + +#if (USE_RT_DEBUG_HCI_WRITE_DONE == 1) + [RT_DEBUG_HCI_WRITE_DONE] = GPIO_DEBUG_HCI_WRITE_DONE, +#endif /* USE_RT_DEBUG_HCI_WRITE_DONE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_UPDATE == 1) + [RT_DEBUG_SCHDLR_EVNT_UPDATE] = GPIO_DEBUG_SCHDLR_EVNT_UPDATE, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_UPDATE */ + +#if (USE_RT_DEBUG_SCHDLR_TIMER_SET == 1) + [RT_DEBUG_SCHDLR_TIMER_SET] = GPIO_DEBUG_SCHDLR_TIMER_SET, +#endif /* USE_RT_DEBUG_SCHDLR_TIMER_SET */ + +#if (USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER == 1) + [RT_DEBUG_SCHDLR_PHY_CLBR_TIMER] = GPIO_DEBUG_SCHDLR_PHY_CLBR_TIMER, +#endif /* USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED == 1) + [RT_DEBUG_SCHDLR_EVNT_SKIPPED] = GPIO_DEBUG_SCHDLR_EVNT_SKIPPED, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE == 1) + [RT_DEBUG_SCHDLR_HNDL_NXT_TRACE] = GPIO_DEBUG_SCHDLR_HNDL_NXT_TRACE, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED == 1) + [RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED] = GPIO_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK == 1) + [RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK] = GPIO_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK == 1) + [RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK] = GPIO_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE == 1) + [RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE] = GPIO_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_RGSTR == 1) + [RT_DEBUG_SCHDLR_EVNT_RGSTR] = GPIO_DEBUG_SCHDLR_EVNT_RGSTR, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_RGSTR */ + +#if (USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q == 1) + [RT_DEBUG_SCHDLR_ADD_CONFLICT_Q] = GPIO_DEBUG_SCHDLR_ADD_CONFLICT_Q, +#endif /* USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT == 1) + [RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT] = GPIO_DEBUG_SCHDLR_HNDL_MISSED_EVNT, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT == 1) + [RT_DEBUG_SCHDLR_UNRGSTR_EVNT] = GPIO_DEBUG_SCHDLR_UNRGSTR_EVNT, +#endif /* USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE == 1) + [RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE] = GPIO_DEBUG_SCHDLR_EXEC_EVNT_TRACE, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE == 1) + [RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE] = GPIO_DEBUG_SCHDLR_EXEC_EVNT_PROFILE, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR == 1) + [RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR] = GPIO_DEBUG_SCHDLR_EXEC_EVNT_ERROR, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING == 1) + [RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING] = GPIO_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_ISR == 1) + [RT_DEBUG_LLHWC_CMN_CLR_ISR] = GPIO_DEBUG_LLHWC_CMN_CLR_ISR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_ISR */ + +#if (USE_RT_DEBUG_LLWCC_CMN_HG_ISR == 1) + [RT_DEBUG_LLWCC_CMN_HG_ISR] = GPIO_DEBUG_LLWCC_CMN_HG_ISR, +#endif /* USE_RT_DEBUG_LLWCC_CMN_HG_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_LW_ISR == 1) + [RT_DEBUG_LLHWC_CMN_LW_ISR] = GPIO_DEBUG_LLHWC_CMN_LW_ISR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_LW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR == 1) + [RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR] = GPIO_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_LLHWC_LL_ISR == 1) + [RT_DEBUG_LLHWC_LL_ISR] = GPIO_DEBUG_LLHWC_LL_ISR, +#endif /* USE_RT_DEBUG_LLHWC_LL_ISR */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_SET == 1) + [RT_DEBUG_LLHWC_SPLTMR_SET] = GPIO_DEBUG_LLHWC_SPLTMR_SET, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_SET */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_GET == 1) + [RT_DEBUG_LLHWC_SPLTMR_GET] = GPIO_DEBUG_LLHWC_SPLTMR_GET, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_GET */ + +#if (USE_RT_DEBUG_LLHWC_LOW_ISR == 1) + [RT_DEBUG_LLHWC_LOW_ISR] = GPIO_DEBUG_LLHWC_LOW_ISR, +#endif /* USE_RT_DEBUG_LLHWC_LOW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_STOP_SCN == 1) + [RT_DEBUG_LLHWC_STOP_SCN] = GPIO_DEBUG_LLHWC_STOP_SCN, +#endif /* USE_RT_DEBUG_LLHWC_STOP_SCN */ + +#if (USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR == 1) + [RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR] = GPIO_DEBUG_LLHWC_WAIT_ENVT_ON_AIR, +#endif /* USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR */ + +#if (USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM == 1) + [RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM] = GPIO_DEBUG_LLHWC_SET_CONN_EVNT_PARAM, +#endif /* USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM */ + +#if (USE_RT_DEBUG_POST_EVNT == 1) + [RT_DEBUG_POST_EVNT] = GPIO_DEBUG_POST_EVNT, +#endif /* USE_RT_DEBUG_POST_EVNT */ + +#if (USE_RT_DEBUG_HNDL_ALL_EVNTS == 1) + [RT_DEBUG_HNDL_ALL_EVNTS] = GPIO_DEBUG_HNDL_ALL_EVNTS, +#endif /* USE_RT_DEBUG_HNDL_ALL_EVNTS */ + +#if (USE_RT_DEBUG_PROCESS_EVNT == 1) + [RT_DEBUG_PROCESS_EVNT] = GPIO_DEBUG_PROCESS_EVNT, +#endif /* USE_RT_DEBUG_PROCESS_EVNT */ + +#if (USE_RT_DEBUG_PROCESS_ISO_DATA == 1) + [RT_DEBUG_PROCESS_ISO_DATA] = GPIO_DEBUG_PROCESS_ISO_DATA, +#endif /* USE_RT_DEBUG_PROCESS_ISO_DATA */ + +#if (USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT == 1) + [RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT] = GPIO_DEBUG_ALLOC_TX_ISO_EMPTY_PKT, +#endif /* USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT */ + +#if (USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS == 1) + [RT_DEBUG_BIG_FREE_EMPTY_PKTS] = GPIO_DEBUG_BIG_FREE_EMPTY_PKTS, +#endif /* USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK == 1) + [RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK] = GPIO_DEBUG_RECOMBINE_UNFRMD_DATA_OK, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC == 1) + [RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC] = GPIO_DEBUG_RECOMBINE_UNFRMD_DATA_CRC, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX == 1) + [RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX] = GPIO_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE == 1) + [RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE] = GPIO_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE */ + +#if (USE_RT_DEBUG_ISO_HNDL_SDU == 1) + [RT_DEBUG_ISO_HNDL_SDU] = GPIO_DEBUG_ISO_HNDL_SDU, +#endif /* USE_RT_DEBUG_ISO_HNDL_SDU */ + +#if (USE_RT_DEBUG_LL_INTF_INIT == 1) + [RT_DEBUG_LL_INTF_INIT] = GPIO_DEBUG_LL_INTF_INIT, +#endif /* USE_RT_DEBUG_LL_INTF_INIT */ + +#if (USE_RT_DEBUG_DATA_TO_CNTRLR == 1) + [RT_DEBUG_DATA_TO_CNTRLR] = GPIO_DEBUG_DATA_TO_CNTRLR, +#endif /* USE_RT_DEBUG_DATA_TO_CNTRLR */ + +#if (USE_RT_DEBUG_FREE_LL_PKT_HNDLR == 1) + [RT_DEBUG_FREE_LL_PKT_HNDLR] = GPIO_DEBUG_FREE_LL_PKT_HNDLR, +#endif /* USE_RT_DEBUG_FREE_LL_PKT_HNDLR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_TRACE == 1) + [RT_DEBUG_PHY_INIT_CLBR_TRACE] = GPIO_DEBUG_PHY_INIT_CLBR_TRACE, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE == 1) + [RT_DEBUG_PHY_RUNTIME_CLBR_TRACE] = GPIO_DEBUG_PHY_RUNTIME_CLBR_TRACE, +#endif /* USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_CLBR_ISR == 1) + [RT_DEBUG_PHY_CLBR_ISR] = GPIO_DEBUG_PHY_CLBR_ISR, +#endif /* USE_RT_DEBUG_PHY_CLBR_ISR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH == 1) + [RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH] = GPIO_DEBUG_PHY_INIT_CLBR_SINGLE_CH, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH */ + +#if (USE_RT_DEBUG_PHY_CLBR_STRTD == 1) + [RT_DEBUG_PHY_CLBR_STRTD] = GPIO_DEBUG_PHY_CLBR_STRTD, +#endif /* USE_RT_DEBUG_PHY_CLBR_STRTD */ + +#if (USE_RT_DEBUG_PHY_CLBR_EXEC == 1) + [RT_DEBUG_PHY_CLBR_EXEC] = GPIO_DEBUG_PHY_CLBR_EXEC, +#endif /* USE_RT_DEBUG_PHY_CLBR_EXEC */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV == 1) + [RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV] = GPIO_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR == 1) + [RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR] = GPIO_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT == 1) + [RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT] = GPIO_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE == 1) + [RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE] = GPIO_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_TRACE == 1) + [RT_DEBUG_RCO_ISR_TRACE] = GPIO_DEBUG_RCO_ISR_TRACE, +#endif /* USE_RT_DEBUG_RCO_ISR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_COMPENDATE == 1) + [RT_DEBUG_RCO_ISR_COMPENDATE] = GPIO_DEBUG_RCO_ISR_COMPENDATE, +#endif /* USE_RT_DEBUG_RCO_ISR_COMPENDATE */ + +#if (USE_RT_DEBUG_RAL_STRT_TX == 1) + [RT_DEBUG_RAL_STRT_TX] = GPIO_DEBUG_RAL_STRT_TX, +#endif /* USE_RT_DEBUG_RAL_STRT_TX */ + +#if (USE_RT_DEBUG_RAL_ISR_TIMER_ERROR == 1) + [RT_DEBUG_RAL_ISR_TIMER_ERROR] = GPIO_DEBUG_RAL_ISR_TIMER_ERROR, +#endif /* USE_RT_DEBUG_RAL_ISR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_RAL_ISR_TRACE == 1) + [RT_DEBUG_RAL_ISR_TRACE] = GPIO_DEBUG_RAL_ISR_TRACE, +#endif /* USE_RT_DEBUG_RAL_ISR_TRACE */ + +#if (USE_RT_DEBUG_RAL_STOP_OPRTN == 1) + [RT_DEBUG_RAL_STOP_OPRTN] = GPIO_DEBUG_RAL_STOP_OPRTN, +#endif /* USE_RT_DEBUG_RAL_STOP_OPRTN */ + +#if (USE_RT_DEBUG_RAL_STRT_RX == 1) + [RT_DEBUG_RAL_STRT_RX] = GPIO_DEBUG_RAL_STRT_RX, +#endif /* USE_RT_DEBUG_RAL_STRT_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_TX == 1) + [RT_DEBUG_RAL_DONE_CLBK_TX] = GPIO_DEBUG_RAL_DONE_CLBK_TX, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_TX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_RX == 1) + [RT_DEBUG_RAL_DONE_CLBK_RX] = GPIO_DEBUG_RAL_DONE_CLBK_RX, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_ED == 1) + [RT_DEBUG_RAL_DONE_CLBK_ED] = GPIO_DEBUG_RAL_DONE_CLBK_ED, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_ED */ + +#if (USE_RT_DEBUG_RAL_ED_SCAN == 1) + [RT_DEBUG_RAL_ED_SCAN] = GPIO_DEBUG_RAL_ED_SCAN, +#endif /* USE_RT_DEBUG_RAL_ED_SCAN */ + +#if (USE_RT_DEBUG_ERROR_MEM_CAP_EXCED == 1) + [RT_DEBUG_ERROR_MEM_CAP_EXCED] = GPIO_DEBUG_ERROR_MEM_CAP_EXCED, +#endif /* USE_RT_DEBUG_ERROR_MEM_CAP_EXCED */ + +#if (USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED == 1) + [RT_DEBUG_ERROR_COMMAND_DISALLOWED] = GPIO_DEBUG_ERROR_COMMAND_DISALLOWED, +#endif /* USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED */ + +#if (USE_RT_DEBUG_PTA_INIT == 1) + [RT_DEBUG_PTA_INIT] = GPIO_DEBUG_PTA_INIT, +#endif /* USE_RT_DEBUG_PTA_INIT */ + +#if (USE_RT_DEBUG_PTA_EN == 1) + [RT_DEBUG_PTA_EN] = GPIO_DEBUG_PTA_EN, +#endif /* USE_RT_DEBUG_PTA_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_EN == 1) + [RT_DEBUG_LLHWC_PTA_SET_EN] = GPIO_DEBUG_LLHWC_PTA_SET_EN, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS == 1) + [RT_DEBUG_LLHWC_PTA_SET_PARAMS] = GPIO_DEBUG_LLHWC_PTA_SET_PARAMS, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS */ + +#if (USE_RT_DEBUG_COEX_STRT_ON_IDLE == 1) + [RT_DEBUG_COEX_STRT_ON_IDLE] = GPIO_DEBUG_COEX_STRT_ON_IDLE, +#endif /* USE_RT_DEBUG_COEX_STRT_ON_IDLE */ + +#if (USE_RT_DEBUG_COEX_ASK_FOR_AIR == 1) + [RT_DEBUG_COEX_ASK_FOR_AIR] = GPIO_DEBUG_COEX_ASK_FOR_AIR, +#endif /* USE_RT_DEBUG_COEX_ASK_FOR_AIR */ + +#if (USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK == 1) + [RT_DEBUG_COEX_TIMER_EVNT_CLBK] = GPIO_DEBUG_COEX_TIMER_EVNT_CLBK, +#endif /* USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK */ + +#if (USE_RT_DEBUG_COEX_STRT_ONE_SHOT == 1) + [RT_DEBUG_COEX_STRT_ONE_SHOT] = GPIO_DEBUG_COEX_STRT_ONE_SHOT, +#endif /* USE_RT_DEBUG_COEX_STRT_ONE_SHOT */ + +#if (USE_RT_DEBUG_COEX_FORCE_STOP_RX == 1) + [RT_DEBUG_COEX_FORCE_STOP_RX] = GPIO_DEBUG_COEX_FORCE_STOP_RX, +#endif /* USE_RT_DEBUG_COEX_FORCE_STOP_RX */ + +#if (USE_RT_DEBUG_LLHWC_ADV_DONE == 1) + [RT_DEBUG_LLHWC_ADV_DONE] = GPIO_DEBUG_LLHWC_ADV_DONE, +#endif /* USE_RT_DEBUG_LLHWC_ADV_DONE */ + +#if (USE_RT_DEBUG_LLHWC_SCN_DONE == 1) + [RT_DEBUG_LLHWC_SCN_DONE] = GPIO_DEBUG_LLHWC_SCN_DONE, +#endif /* USE_RT_DEBUG_LLHWC_SCN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_INIT_DONE == 1) + [RT_DEBUG_LLHWC_INIT_DONE] = GPIO_DEBUG_LLHWC_INIT_DONE, +#endif /* USE_RT_DEBUG_LLHWC_INIT_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CONN_DONE == 1) + [RT_DEBUG_LLHWC_CONN_DONE] = GPIO_DEBUG_LLHWC_CONN_DONE, +#endif /* USE_RT_DEBUG_LLHWC_CONN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CIG_DONE == 1) + [RT_DEBUG_LLHWC_CIG_DONE] = GPIO_DEBUG_LLHWC_CIG_DONE, +#endif /* USE_RT_DEBUG_LLHWC_CIG_DONE */ + +#if (USE_RT_DEBUG_LLHWC_BIG_DONE == 1) + [RT_DEBUG_LLHWC_BIG_DONE] = GPIO_DEBUG_LLHWC_BIG_DONE, +#endif /* USE_RT_DEBUG_LLHWC_BIG_DONE */ + +#if (USE_RT_DEBUG_OS_TMR_CREATE == 1) + [RT_DEBUG_OS_TMR_CREATE] = GPIO_DEBUG_OS_TMR_CREATE, +#endif /* USE_RT_DEBUG_OS_TMR_CREATE */ + +#if (USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK == 1) + [RT_DEBUG_ADV_EXT_TIMEOUT_CBK] = GPIO_DEBUG_ADV_EXT_TIMEOUT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK == 1) + [RT_DEBUG_ADV_EXT_SCN_DUR_CBK] = GPIO_DEBUG_ADV_EXT_SCN_DUR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK == 1) + [RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK] = GPIO_DEBUG_ADV_EXT_SCN_PERIOD_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK == 1) + [RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK] = GPIO_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK == 1) + [RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK] = GPIO_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TERM_TMR_CBK == 1) + [RT_DEBUG_BIS_TERM_TMR_CBK] = GPIO_DEBUG_BIS_TERM_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_TERM_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_CBK == 1) + [RT_DEBUG_BIS_TST_MODE_CBK] = GPIO_DEBUG_BIS_TST_MODE_CBK, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK == 1) + [RT_DEBUG_BIS_TST_MODE_TMR_CBK] = GPIO_DEBUG_BIS_TST_MODE_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_POST_TMR_CBK == 1) + [RT_DEBUG_ISO_POST_TMR_CBK] = GPIO_DEBUG_ISO_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_ISO_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK == 1) + [RT_DEBUG_ISO_TST_MODE_TMR_CBK] = GPIO_DEBUG_ISO_TST_MODE_TMR_CBK, +#endif /* USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_CONN_POST_TMR_CBK == 1) + [RT_DEBUG_CONN_POST_TMR_CBK] = GPIO_DEBUG_CONN_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_CONN_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK == 1) + [RT_DEBUG_EVNT_SCHDLR_TMR_CBK] = GPIO_DEBUG_EVNT_SCHDLR_TMR_CBK, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK */ + +#if (USE_RT_DEBUG_HCI_POST_TMR_CBK == 1) + [RT_DEBUG_HCI_POST_TMR_CBK] = GPIO_DEBUG_HCI_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_HCI_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLCP_POST_TMR_CBK == 1) + [RT_DEBUG_LLCP_POST_TMR_CBK] = GPIO_DEBUG_LLCP_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_LLCP_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK == 1) + [RT_DEBUG_LLHWC_ENRGY_DETECT_CBK] = GPIO_DEBUG_LLHWC_ENRGY_DETECT_CBK, +#endif /* USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK */ + +#if (USE_RT_DEBUG_PRVCY_POST_TMR_CBK == 1) + [RT_DEBUG_PRVCY_POST_TMR_CBK] = GPIO_DEBUG_PRVCY_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_PRVCY_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ANT_PRPR_TMR_CBK == 1) + [RT_DEBUG_ANT_PRPR_TMR_CBK] = GPIO_DEBUG_ANT_PRPR_TMR_CBK, +#endif /* USE_RT_DEBUG_ANT_PRPR_TMR_CBK */ + +#if (USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK == 1) + [RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK] = GPIO_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK, +#endif /* USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK */ + +#if (USE_RT_DEBUG_MLME_RX_EN_TMR_CBK == 1) + [RT_DEBUG_MLME_RX_EN_TMR_CBK] = GPIO_DEBUG_MLME_RX_EN_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_RX_EN_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_GNRC_TMR_CBK == 1) + [RT_DEBUG_MLME_GNRC_TMR_CBK] = GPIO_DEBUG_MLME_GNRC_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_GNRC_TMR_CBK */ + +#if (USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK == 1) + [RT_DEBUG_MIB_JOIN_LST_TMR_CBK] = GPIO_DEBUG_MIB_JOIN_LST_TMR_CBK, +#endif /* USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK == 1) + [RT_DEBUG_MLME_PWR_PRES_TMR_CBK] = GPIO_DEBUG_MLME_PWR_PRES_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK */ + +#if (USE_RT_DEBUG_PRESISTENCE_TMR_CBK == 1) + [RT_DEBUG_PRESISTENCE_TMR_CBK] = GPIO_DEBUG_PRESISTENCE_TMR_CBK, +#endif /* USE_RT_DEBUG_PRESISTENCE_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK == 1) + [RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK] = GPIO_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR_CBK == 1) + [RT_DEBUG_RADIO_CSMA_TMR_CBK] = GPIO_DEBUG_RADIO_CSMA_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK == 1) + [RT_DEBUG_RADIO_CSL_RCV_TMR_CBK] = GPIO_DEBUG_RADIO_CSL_RCV_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_CBK == 1) + [RT_DEBUG_ED_TMR_CBK] = GPIO_DEBUG_ED_TMR_CBK, +#endif /* USE_RT_DEBUG_ED_TMR_CBK */ + +#if (USE_RT_DEBUG_DIO_EXT_TMR_CBK == 1) + [RT_DEBUG_DIO_EXT_TMR_CBK] = GPIO_DEBUG_DIO_EXT_TMR_CBK, +#endif /* USE_RT_DEBUG_DIO_EXT_TMR_CBK */ + +#if (USE_RT_DEBUG_RCO_CLBR_TMR_CBK == 1) + [RT_DEBUG_RCO_CLBR_TMR_CBK] = GPIO_DEBUG_RCO_CLBR_TMR_CBK, +#endif /* USE_RT_DEBUG_RCO_CLBR_TMR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK == 1) + [RT_DEBUG_ADV_EXT_MNGR_ADV_CBK] = GPIO_DEBUG_ADV_EXT_MNGR_ADV_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK == 1) + [RT_DEBUG_ADV_EXT_MNGR_SCN_CBK] = GPIO_DEBUG_ADV_EXT_MNGR_SCN_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK == 1) + [RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK] = GPIO_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK == 1) + [RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK] = GPIO_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK == 1) + [RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK] = GPIO_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_CBK == 1) + [RT_DEBUG_BIG_ADV_CBK] = GPIO_DEBUG_BIG_ADV_CBK, +#endif /* USE_RT_DEBUG_BIG_ADV_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_ERR_CBK == 1) + [RT_DEBUG_BIG_ADV_ERR_CBK] = GPIO_DEBUG_BIG_ADV_ERR_CBK, +#endif /* USE_RT_DEBUG_BIG_ADV_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_CBK == 1) + [RT_DEBUG_BIG_SYNC_CBK] = GPIO_DEBUG_BIG_SYNC_CBK, +#endif /* USE_RT_DEBUG_BIG_SYNC_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_ERR_CBK == 1) + [RT_DEBUG_BIG_SYNC_ERR_CBK] = GPIO_DEBUG_BIG_SYNC_ERR_CBK, +#endif /* USE_RT_DEBUG_BIG_SYNC_ERR_CBK */ + +#if (USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK == 1) + [RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK] = GPIO_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK, +#endif /* USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_ISO_CIG_ERR_CBK == 1) + [RT_DEBUG_ISO_CIG_ERR_CBK] = GPIO_DEBUG_ISO_CIG_ERR_CBK, +#endif /* USE_RT_DEBUG_ISO_CIG_ERR_CBK */ + +#if (USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK == 1) + [RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK] = GPIO_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK, +#endif /* USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK == 1) + [RT_DEBUG_PRDC_CLBR_EXTRL_CBK] = GPIO_DEBUG_PRDC_CLBR_EXTRL_CBK, +#endif /* USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK */ + +#if (USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK == 1) + [RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK] = GPIO_DEBUG_PTR_PRDC_ADV_SYNC_CBK, +#endif /* USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK */ + +#if (USE_RT_DEBUG_NCONN_SCN_CBK == 1) + [RT_DEBUG_NCONN_SCN_CBK] = GPIO_DEBUG_NCONN_SCN_CBK, +#endif /* USE_RT_DEBUG_NCONN_SCN_CBK */ + +#if (USE_RT_DEBUG_NCONN_ADV_CBK == 1) + [RT_DEBUG_NCONN_ADV_CBK] = GPIO_DEBUG_NCONN_ADV_CBK, +#endif /* USE_RT_DEBUG_NCONN_ADV_CBK */ + +#if (USE_RT_DEBUG_NCONN_INIT_CBK == 1) + [RT_DEBUG_NCONN_INIT_CBK] = GPIO_DEBUG_NCONN_INIT_CBK, +#endif /* USE_RT_DEBUG_NCONN_INIT_CBK */ + +#if (USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK == 1) + [RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK] = GPIO_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK, +#endif /* USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ANT_STACK_EVNT_CBK == 1) + [RT_DEBUG_ANT_STACK_EVNT_CBK] = GPIO_DEBUG_ANT_STACK_EVNT_CBK, +#endif /* USE_RT_DEBUG_ANT_STACK_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK == 1) + [RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK] = GPIO_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT == 1) + [RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT] = GPIO_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT == 1) + [RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT] = GPIO_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT == 1) + [RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT] = GPIO_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT == 1) + [RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT] = GPIO_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT */ + +#if (USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK == 1) + [RT_DEBUG_BIS_MNGR_BIG_TERM_CBK] = GPIO_DEBUG_BIS_MNGR_BIG_TERM_CBK, +#endif /* USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK */ + +#if (USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK == 1) + [RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK] = GPIO_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK, +#endif /* USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK */ + +#if (USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN == 1) + [RT_DEBUG_ISOAL_MNGR_SDU_GEN] = GPIO_DEBUG_ISOAL_MNGR_SDU_GEN, +#endif /* USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN */ + +#if (USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK == 1) + [RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK] = GPIO_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK, +#endif /* USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK == 1) + [RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK] = GPIO_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK, +#endif /* USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK == 1) + [RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK] = GPIO_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK, +#endif /* USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT == 1) + [RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT] = GPIO_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT */ + +#if (USE_RT_DEBUG_HCI_EVENT_HNDLR == 1) + [RT_DEBUG_HCI_EVENT_HNDLR] = GPIO_DEBUG_HCI_EVENT_HNDLR, +#endif /* USE_RT_DEBUG_HCI_EVENT_HNDLR */ + +#if (USE_RT_DEBUG_MLME_TMRS_CBK == 1) + [RT_DEBUG_MLME_TMRS_CBK] = GPIO_DEBUG_MLME_TMRS_CBK, +#endif /* USE_RT_DEBUG_MLME_TMRS_CBK */ + +#if (USE_RT_DEBUG_DIRECT_TX_EVNT_CBK == 1) + [RT_DEBUG_DIRECT_TX_EVNT_CBK] = GPIO_DEBUG_DIRECT_TX_EVNT_CBK, +#endif /* USE_RT_DEBUG_DIRECT_TX_EVNT_CBK */ + +#if (USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK == 1) + [RT_DEBUG_INDIRECT_PKT_TOUR_CBK] = GPIO_DEBUG_INDIRECT_PKT_TOUR_CBK, +#endif /* USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR == 1) + [RT_DEBUG_RADIO_CSMA_TMR] = GPIO_DEBUG_RADIO_CSMA_TMR, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR */ + +#if (USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK == 1) + [RT_DEBUG_RAL_SM_DONE_EVNT_CBK] = GPIO_DEBUG_RAL_SM_DONE_EVNT_CBK, +#endif /* USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_HNDL == 1) + [RT_DEBUG_ED_TMR_HNDL] = GPIO_DEBUG_ED_TMR_HNDL, +#endif /* USE_RT_DEBUG_ED_TMR_HNDL */ + +#if (USE_RT_DEBUG_OS_TMR_EVNT_CBK == 1) + [RT_DEBUG_OS_TMR_EVNT_CBK] = GPIO_DEBUG_OS_TMR_EVNT_CBK, +#endif /* USE_RT_DEBUG_OS_TMR_EVNT_CBK */ + +#if (USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME == 1) + [RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME] = GPIO_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME, +#endif /* USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME */ + +#if (USE_RT_DEBUG_PROFILE_END_DRIFT_TIME == 1) + [RT_DEBUG_PROFILE_END_DRIFT_TIME] = GPIO_DEBUG_PROFILE_END_DRIFT_TIME, +#endif /* USE_RT_DEBUG_PROFILE_END_DRIFT_TIME */ + +#if (USE_RT_DEBUG_PROC_RADIO_RCV == 1) + [RT_DEBUG_PROC_RADIO_RCV] = GPIO_DEBUG_PROC_RADIO_RCV, +#endif /* USE_RT_DEBUG_PROC_RADIO_RCV */ + +#if (USE_RT_DEBUG_EVNT_TIME_UPDT == 1) + [RT_DEBUG_EVNT_TIME_UPDT] = GPIO_DEBUG_EVNT_TIME_UPDT, +#endif /* USE_RT_DEBUG_EVNT_TIME_UPDT */ + +#if (USE_RT_DEBUG_MAC_RECEIVE_DONE == 1) + [RT_DEBUG_MAC_RECEIVE_DONE] = GPIO_DEBUG_MAC_RECEIVE_DONE, +#endif /* USE_RT_DEBUG_MAC_RECEIVE_DONE */ + +#if (USE_RT_DEBUG_MAC_TX_DONE == 1) + [RT_DEBUG_MAC_TX_DONE] = GPIO_DEBUG_MAC_TX_DONE, +#endif /* USE_RT_DEBUG_MAC_TX_DONE */ + +#if (USE_RT_DEBUG_RADIO_APPLY_CSMA == 1) + [RT_DEBUG_RADIO_APPLY_CSMA] = GPIO_DEBUG_RADIO_APPLY_CSMA, +#endif /* USE_RT_DEBUG_RADIO_APPLY_CSMA */ + +#if (USE_RT_DEBUG_RADIO_TRANSMIT == 1) + [RT_DEBUG_RADIO_TRANSMIT] = GPIO_DEBUG_RADIO_TRANSMIT, +#endif /* USE_RT_DEBUG_RADIO_TRANSMIT */ + +#if (USE_RT_DEBUG_PROC_RADIO_TX == 1) + [RT_DEBUG_PROC_RADIO_TX] = GPIO_DEBUG_PROC_RADIO_TX, +#endif /* USE_RT_DEBUG_PROC_RADIO_TX */ + +#if (USE_RT_DEBUG_RAL_TX_DONE == 1) + [RT_DEBUG_RAL_TX_DONE] = GPIO_DEBUG_RAL_TX_DONE, +#endif /* USE_RT_DEBUG_RAL_TX_DONE */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT == 1) + [RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT] = GPIO_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT == 1) + [RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT] = GPIO_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_CONTINUE_RX == 1) + [RT_DEBUG_RAL_CONTINUE_RX] = GPIO_DEBUG_RAL_CONTINUE_RX, +#endif /* USE_RT_DEBUG_RAL_CONTINUE_RX */ + +#if (USE_RT_DEBUG_RAL_PERFORM_CCA == 1) + [RT_DEBUG_RAL_PERFORM_CCA] = GPIO_DEBUG_RAL_PERFORM_CCA, +#endif /* USE_RT_DEBUG_RAL_PERFORM_CCA */ + +#if (USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER == 1) + [RT_DEBUG_RAL_ENABLE_TRANSMITTER] = GPIO_DEBUG_RAL_ENABLE_TRANSMITTER, +#endif /* USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER */ + +#if (USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 == 1) + [RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2] = GPIO_DEBUG_LLHWC_GET_CH_IDX_ALGO_2, +#endif /* USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 */ + +/************************************************/ +/** Application signals in general debug table **/ +/************************************************/ + +#if (USE_RT_DEBUG_APP_APPE_INIT == 1) + [RT_DEBUG_APP_APPE_INIT] = GPIO_DEBUG_APP_APPE_INIT, +#endif /* USE_RT_DEBUG_APP_APPE_INIT */ +}; +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ + + +/*******************************/ +/** Debug GPIO Initialization **/ +/*******************************/ + +void RT_DEBUG_GPIO_Init(void) +{ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + uint32_t general_table_size = sizeof(general_debug_table)/sizeof(general_debug_table[0]); + + if (general_table_size > 1) + { + for(unsigned int cpt = 1; cpt +#include +#include + +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + +/*********************************/ +/** GPIO debug signal selection **/ +/*********************************/ +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG) +#define USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG (1) +#define GPIO_DEBUG_SCM_SYSTEM_CLOCK_CONFIG GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_scm_sys_clock_config_gpios) +#else +#define USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCM_SETUP) +#define USE_RT_DEBUG_SCM_SETUP (1) +#define GPIO_DEBUG_SCM_SETUP GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_scm_setup_gpios) +#else +#define USE_RT_DEBUG_SCM_SETUP (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCM_HSERDY_ISR) +#define USE_RT_DEBUG_SCM_HSERDY_ISR (1) +#define GPIO_DEBUG_SCM_HSERDY_ISR GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_scm_hserdy_isr_gpios) +#else +#define USE_RT_DEBUG_SCM_HSERDY_ISR (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_ADC_ACTIVATION) +#define USE_RT_DEBUG_ADC_ACTIVATION (1) +#define GPIO_DEBUG_ADC_ACTIVATION GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_adc_activation_gpios) +#else +#define USE_RT_DEBUG_ADC_ACTIVATION (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION) +#define USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION (1) +#define GPIO_DEBUG_ADC_TEMPERATURE_ACQUISITION GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_adc_temp_acquisition_gpios) +#else +#define USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE) +#define USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE (1) +#define GPIO_DEBUG_LOW_POWER_STOP_MODE_ACTIVE GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_lowpower_stop_mode_active_gpios) +#else +#define USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE) +#define USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE (1) +#define GPIO_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_lowpower_standby_mode_active_gpios) +#else +#define USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE (0) +#endif + + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE) +#define USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE (1) +#define GPIO_DEBUG_SCHDLR_HNDL_NXT_TRACE GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_schdlr_hndl_nxt_trace_gpios) +#else +#define USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EVNT_RGSTR) +#define USE_RT_DEBUG_SCHDLR_EVNT_RGSTR (1) +#define GPIO_DEBUG_SCHDLR_EVNT_RGSTR GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_schdr_evnt_rgstr_gpios) +#else +#define USE_RT_DEBUG_SCHDLR_EVNT_RGSTR (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT) +#define USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT (1) +#define GPIO_DEBUG_SCHDLR_HNDL_MISSED_EVNT GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_schdr_hndl_missed_evnt_gpios) +#else +#define USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE) +#define USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE (1) +#define GPIO_DEBUG_SCHDLR_EXEC_EVNT_TRACE GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_schdlr_exec_evnt_trace_gpios) +#else +#define USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_LLWCC_CMN_HG_ISR) +#define USE_RT_DEBUG_LLWCC_CMN_HG_ISR (1) +#define GPIO_DEBUG_LLWCC_CMN_HG_ISR GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_llwcc_cmn_hg_isr_gpios) +#else +#define USE_RT_DEBUG_LLWCC_CMN_HG_ISR (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_LLHWC_CMN_LW_ISR) +#define USE_RT_DEBUG_LLHWC_CMN_LW_ISR (1) +#define GPIO_DEBUG_LLHWC_CMN_LW_ISR GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_llhwc_cmn_lw_isr_gpios) +#else +#define USE_RT_DEBUG_LLHWC_CMN_LW_ISR (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_ISR) +#define USE_RT_DEBUG_PHY_CLBR_ISR (1) +#define GPIO_DEBUG_PHY_CLBR_ISR GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_phy_clbr_isr_gpios) +#else +#define USE_RT_DEBUG_PHY_CLBR_ISR (0) +#endif + +#if(CONFIG_BT_STM32WBA_USE_RT_DEBUG_PHY_CLBR_EXEC) +#define USE_RT_DEBUG_PHY_CLBR_EXEC (1) +#define GPIO_DEBUG_PHY_CLBR_EXEC GPIO_DT_SPEC_GET(DT_PATH(zephyr_user),rt_dbg_phy_clbr_exec_gpios) +#else +#define USE_RT_DEBUG_PHY_CLBR_EXEC (0) +#endif + +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ +#include "debug_signals.h" +extern const struct gpio_dt_spec general_debug_table[RT_DEBUG_SIGNALS_TOTAL_NUM]; + +#ifdef __cplusplus +} +#endif + +#endif /* DEBUG_CONFIG_H */ diff --git a/soc/st/stm32/stm32wbax/debug/debug_signals.h b/soc/st/stm32/stm32wbax/debug/debug_signals.h new file mode 100644 index 0000000000000..2cbd1c483340f --- /dev/null +++ b/soc/st/stm32/stm32wbax/debug/debug_signals.h @@ -0,0 +1,819 @@ +/** + ****************************************************************************** + * @file debug_signals.h + * @author MCD Application Team + * @brief Real Time Debug module System and Link Layer signal definition + ****************************************************************************** + * @attention + * + * Copyright (c) 2024 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +#ifndef DEBUG_SIGNALS_H +#define DEBUG_SIGNALS_H + +#include "bsp.h" + +/**************************************************/ +/** Specific Link Layer debug signals definition **/ +/**************************************************/ +typedef Debug_GPIO_t linklayer_debug_signal_t; + +/**********************************************/ +/** Specific System debug signals definition **/ +/**********************************************/ +typedef enum { + ADC_ACTIVATION, + ADC_DEACTIVATION, + ADC_TEMPERATURE_ACQUISITION, + RNG_ENABLE, + RNG_DISABLE, + RNG_GEN_RAND_NUM, + LOW_POWER_STOP_MODE_ENTER, + LOW_POWER_STOP_MODE_EXIT, + LOW_POWER_STOP_MODE_ACTIVE, + LOW_POWER_STOP2_MODE_ENTER, + LOW_POWER_STOP2_MODE_EXIT, + LOW_POWER_STOP2_MODE_ACTIVE, + LOW_POWER_STANDBY_MODE_ENTER, + LOW_POWER_STANDBY_MODE_EXIT, + LOW_POWER_STANDBY_MODE_ACTIVE, + SCM_SETUP, + SCM_SYSTEM_CLOCK_CONFIG, + SCM_HSERDY_ISR, +} system_debug_signal_t; + +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + +/*************************************/ +/** Global debug signals definition **/ +/*************************************/ + +typedef enum { + RT_DEBUG_SIGNAL_UNUSED = 0x0, + +/********************/ +/** System signals **/ +/********************/ + +#if (USE_RT_DEBUG_SCM_SETUP == 1) + RT_DEBUG_SCM_SETUP, +#endif /* USE_RT_DEBUG_SCM_SETUP */ + +#if (USE_RT_DEBUG_SCM_HSERDY_ISR == 1) + RT_DEBUG_SCM_HSERDY_ISR, +#endif /* USE_RT_DEBUG_SCM_HSERDY_ISR */ + +#if (USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG == 1) + RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG, +#endif /* USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG */ + +#if (USE_RT_DEBUG_ADC_ACTIVATION == 1) + RT_DEBUG_ADC_ACTIVATION, +#endif /* USE_RT_DEBUG_ADC_ACTIVATION */ + +#if (USE_RT_DEBUG_ADC_DEACTIVATION == 1) + RT_DEBUG_ADC_DEACTIVATION, +#endif /* USE_RT_DEBUG_ADC_DEACTIVATION */ + +#if (USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION == 1) + RT_DEBUG_ADC_TEMPERATURE_ACQUISITION, +#endif /* USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION */ + +#if (USE_RT_DEBUG_RNG_ENABLE == 1) + RT_DEBUG_RNG_ENABLE, +#endif /* USE_RT_DEBUG_RNG_ENABLE */ + +#if (USE_RT_DEBUG_RNG_DISABLE == 1) + RT_DEBUG_RNG_DISABLE, +#endif /* USE_RT_DEBUG_RNG_DISABLE */ + +#if (USE_RT_DEBUG_RNG_GEN_RAND_NUM == 1) + RT_DEBUG_RNG_GEN_RAND_NUM, +#endif /* USE_RT_DEBUG_RNG_GEN_RAND_NUM */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER == 1) + RT_DEBUG_LOW_POWER_STOP_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT == 1) + RT_DEBUG_LOW_POWER_STOP_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE == 1) + RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER == 1) + RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT == 1) + RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE == 1) + RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER == 1) + RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT == 1) + RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE == 1) + RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE */ + +/************************/ +/** Link Layer signals **/ +/************************/ + +#if (USE_RT_DEBUG_HCI_READ_DONE == 1) + RT_DEBUG_HCI_READ_DONE, +#endif /* USE_RT_DEBUG_HCI_READ_DONE */ + +#if (USE_RT_DEBUG_HCI_RCVD_CMD == 1) + RT_DEBUG_HCI_RCVD_CMD, +#endif /* USE_RT_DEBUG_HCI_RCVD_CMD */ + +#if (USE_RT_DEBUG_HCI_WRITE_DONE == 1) + RT_DEBUG_HCI_WRITE_DONE, +#endif /* USE_RT_DEBUG_HCI_WRITE_DONE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_UPDATE == 1) + RT_DEBUG_SCHDLR_EVNT_UPDATE, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_UPDATE */ + +#if (USE_RT_DEBUG_SCHDLR_TIMER_SET == 1) + RT_DEBUG_SCHDLR_TIMER_SET, +#endif /* USE_RT_DEBUG_SCHDLR_TIMER_SET */ + +#if (USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER == 1) + RT_DEBUG_SCHDLR_PHY_CLBR_TIMER, +#endif /* USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED == 1) + RT_DEBUG_SCHDLR_EVNT_SKIPPED, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE == 1) + RT_DEBUG_SCHDLR_HNDL_NXT_TRACE, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED == 1) + RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK == 1) + RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK == 1) + RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE == 1) + RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_RGSTR == 1) + RT_DEBUG_SCHDLR_EVNT_RGSTR, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_RGSTR */ + +#if (USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q == 1) + RT_DEBUG_SCHDLR_ADD_CONFLICT_Q, +#endif /* USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT == 1) + RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT == 1) + RT_DEBUG_SCHDLR_UNRGSTR_EVNT, +#endif /* USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE == 1) + RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE == 1) + RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR == 1) + RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING == 1) + RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_ISR == 1) + RT_DEBUG_LLHWC_CMN_CLR_ISR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_ISR */ + +#if (USE_RT_DEBUG_LLWCC_CMN_HG_ISR == 1) + RT_DEBUG_LLWCC_CMN_HG_ISR, +#endif /* USE_RT_DEBUG_LLWCC_CMN_HG_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_LW_ISR == 1) + RT_DEBUG_LLHWC_CMN_LW_ISR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_LW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR == 1) + RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_LLHWC_LL_ISR == 1) + RT_DEBUG_LLHWC_LL_ISR, +#endif /* USE_RT_DEBUG_LLHWC_LL_ISR */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_SET == 1) + RT_DEBUG_LLHWC_SPLTMR_SET, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_SET */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_GET == 1) + RT_DEBUG_LLHWC_SPLTMR_GET, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_GET */ + +#if (USE_RT_DEBUG_LLHWC_LOW_ISR == 1) + RT_DEBUG_LLHWC_LOW_ISR, +#endif /* USE_RT_DEBUG_LLHWC_LOW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_STOP_SCN == 1) + RT_DEBUG_LLHWC_STOP_SCN, +#endif /* USE_RT_DEBUG_LLHWC_STOP_SCN */ + +#if (USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR == 1) + RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR, +#endif /* USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR */ + +#if (USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM == 1) + RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM, +#endif /* USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM */ + +#if (USE_RT_DEBUG_POST_EVNT == 1) + RT_DEBUG_POST_EVNT, +#endif /* USE_RT_DEBUG_POST_EVNT */ + +#if (USE_RT_DEBUG_HNDL_ALL_EVNTS == 1) + RT_DEBUG_HNDL_ALL_EVNTS, +#endif /* USE_RT_DEBUG_HNDL_ALL_EVNTS */ + +#if (USE_RT_DEBUG_PROCESS_EVNT == 1) + RT_DEBUG_PROCESS_EVNT, +#endif /* USE_RT_DEBUG_PROCESS_EVNT */ + +#if (USE_RT_DEBUG_PROCESS_ISO_DATA == 1) + RT_DEBUG_PROCESS_ISO_DATA, +#endif /* USE_RT_DEBUG_PROCESS_ISO_DATA */ + +#if (USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT == 1) + RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT, +#endif /* USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT */ + +#if (USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS == 1) + RT_DEBUG_BIG_FREE_EMPTY_PKTS, +#endif /* USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK == 1) + RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC == 1) + RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX == 1) + RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE == 1) + RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE */ + +#if (USE_RT_DEBUG_ISO_HNDL_SDU == 1) + RT_DEBUG_ISO_HNDL_SDU, +#endif /* USE_RT_DEBUG_ISO_HNDL_SDU */ + +#if (USE_RT_DEBUG_LL_INTF_INIT == 1) + RT_DEBUG_LL_INTF_INIT, +#endif /* USE_RT_DEBUG_LL_INTF_INIT */ + +#if (USE_RT_DEBUG_DATA_TO_CNTRLR == 1) + RT_DEBUG_DATA_TO_CNTRLR, +#endif /* USE_RT_DEBUG_DATA_TO_CNTRLR */ + +#if (USE_RT_DEBUG_FREE_LL_PKT_HNDLR == 1) + RT_DEBUG_FREE_LL_PKT_HNDLR, +#endif /* USE_RT_DEBUG_FREE_LL_PKT_HNDLR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_TRACE == 1) + RT_DEBUG_PHY_INIT_CLBR_TRACE, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE == 1) + RT_DEBUG_PHY_RUNTIME_CLBR_TRACE, +#endif /* USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_CLBR_ISR == 1) + RT_DEBUG_PHY_CLBR_ISR, +#endif /* USE_RT_DEBUG_PHY_CLBR_ISR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH == 1) + RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH */ + +#if (USE_RT_DEBUG_PHY_CLBR_STRTD == 1) + RT_DEBUG_PHY_CLBR_STRTD, +#endif /* USE_RT_DEBUG_PHY_CLBR_STRTD */ + +#if (USE_RT_DEBUG_PHY_CLBR_EXEC == 1) + RT_DEBUG_PHY_CLBR_EXEC, +#endif /* USE_RT_DEBUG_PHY_CLBR_EXEC */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV == 1) + RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR == 1) + RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT == 1) + RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE == 1) + RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_TRACE == 1) + RT_DEBUG_RCO_ISR_TRACE, +#endif /* USE_RT_DEBUG_RCO_ISR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_COMPENDATE == 1) + RT_DEBUG_RCO_ISR_COMPENDATE, +#endif /* USE_RT_DEBUG_RCO_ISR_COMPENDATE */ + +#if (USE_RT_DEBUG_RAL_STRT_TX == 1) + RT_DEBUG_RAL_STRT_TX, +#endif /* USE_RT_DEBUG_RAL_STRT_TX */ + +#if (USE_RT_DEBUG_RAL_ISR_TIMER_ERROR == 1) + RT_DEBUG_RAL_ISR_TIMER_ERROR, +#endif /* USE_RT_DEBUG_RAL_ISR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_RAL_ISR_TRACE == 1) + RT_DEBUG_RAL_ISR_TRACE, +#endif /* USE_RT_DEBUG_RAL_ISR_TRACE */ + +#if (USE_RT_DEBUG_RAL_STOP_OPRTN == 1) + RT_DEBUG_RAL_STOP_OPRTN, +#endif /* USE_RT_DEBUG_RAL_STOP_OPRTN */ + +#if (USE_RT_DEBUG_RAL_STRT_RX == 1) + RT_DEBUG_RAL_STRT_RX, +#endif /* USE_RT_DEBUG_RAL_STRT_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_TX == 1) + RT_DEBUG_RAL_DONE_CLBK_TX, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_TX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_RX == 1) + RT_DEBUG_RAL_DONE_CLBK_RX, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_ED == 1) + RT_DEBUG_RAL_DONE_CLBK_ED, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_ED */ + +#if (USE_RT_DEBUG_RAL_ED_SCAN == 1) + RT_DEBUG_RAL_ED_SCAN, +#endif /* USE_RT_DEBUG_RAL_ED_SCAN */ + +#if (USE_RT_DEBUG_ERROR_MEM_CAP_EXCED == 1) + RT_DEBUG_ERROR_MEM_CAP_EXCED, +#endif /* USE_RT_DEBUG_ERROR_MEM_CAP_EXCED */ + +#if (USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED == 1) + RT_DEBUG_ERROR_COMMAND_DISALLOWED, +#endif /* USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED */ + +#if (USE_RT_DEBUG_PTA_INIT == 1) + RT_DEBUG_PTA_INIT, +#endif /* USE_RT_DEBUG_PTA_INIT */ + +#if (USE_RT_DEBUG_PTA_EN == 1) + RT_DEBUG_PTA_EN, +#endif /* USE_RT_DEBUG_PTA_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_EN == 1) + RT_DEBUG_LLHWC_PTA_SET_EN, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS == 1) + RT_DEBUG_LLHWC_PTA_SET_PARAMS, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS */ + +#if (USE_RT_DEBUG_COEX_STRT_ON_IDLE == 1) + RT_DEBUG_COEX_STRT_ON_IDLE, +#endif /* USE_RT_DEBUG_COEX_STRT_ON_IDLE */ + +#if (USE_RT_DEBUG_COEX_ASK_FOR_AIR == 1) + RT_DEBUG_COEX_ASK_FOR_AIR, +#endif /* USE_RT_DEBUG_COEX_ASK_FOR_AIR */ + +#if (USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK == 1) + RT_DEBUG_COEX_TIMER_EVNT_CLBK, +#endif /* USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK */ + +#if (USE_RT_DEBUG_COEX_STRT_ONE_SHOT == 1) + RT_DEBUG_COEX_STRT_ONE_SHOT, +#endif /* USE_RT_DEBUG_COEX_STRT_ONE_SHOT */ + +#if (USE_RT_DEBUG_COEX_FORCE_STOP_RX == 1) + RT_DEBUG_COEX_FORCE_STOP_RX, +#endif /* USE_RT_DEBUG_COEX_FORCE_STOP_RX */ + +#if (USE_RT_DEBUG_LLHWC_ADV_DONE == 1) + RT_DEBUG_LLHWC_ADV_DONE, +#endif /* USE_RT_DEBUG_LLHWC_ADV_DONE */ + +#if (USE_RT_DEBUG_LLHWC_SCN_DONE == 1) + RT_DEBUG_LLHWC_SCN_DONE, +#endif /* USE_RT_DEBUG_LLHWC_SCN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_INIT_DONE == 1) + RT_DEBUG_LLHWC_INIT_DONE, +#endif /* USE_RT_DEBUG_LLHWC_INIT_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CONN_DONE == 1) + RT_DEBUG_LLHWC_CONN_DONE, +#endif /* USE_RT_DEBUG_LLHWC_CONN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CIG_DONE == 1) + RT_DEBUG_LLHWC_CIG_DONE, +#endif /* USE_RT_DEBUG_LLHWC_CIG_DONE */ + +#if (USE_RT_DEBUG_LLHWC_BIG_DONE == 1) + RT_DEBUG_LLHWC_BIG_DONE, +#endif /* USE_RT_DEBUG_LLHWC_BIG_DONE */ + +#if (USE_RT_DEBUG_OS_TMR_CREATE == 1) + RT_DEBUG_OS_TMR_CREATE, +#endif /* USE_RT_DEBUG_OS_TMR_CREATE */ + +#if (USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK == 1) + RT_DEBUG_ADV_EXT_TIMEOUT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK == 1) + RT_DEBUG_ADV_EXT_SCN_DUR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK == 1) + RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK == 1) + RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK == 1) + RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TERM_TMR_CBK == 1) + RT_DEBUG_BIS_TERM_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_TERM_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_CBK == 1) + RT_DEBUG_BIS_TST_MODE_CBK, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK == 1) + RT_DEBUG_BIS_TST_MODE_TMR_CBK, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_POST_TMR_CBK == 1) + RT_DEBUG_ISO_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_ISO_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK == 1) + RT_DEBUG_ISO_TST_MODE_TMR_CBK, +#endif /* USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_CONN_POST_TMR_CBK == 1) + RT_DEBUG_CONN_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_CONN_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK == 1) + RT_DEBUG_EVNT_SCHDLR_TMR_CBK, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK */ + +#if (USE_RT_DEBUG_HCI_POST_TMR_CBK == 1) + RT_DEBUG_HCI_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_HCI_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLCP_POST_TMR_CBK == 1) + RT_DEBUG_LLCP_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_LLCP_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK == 1) + RT_DEBUG_LLHWC_ENRGY_DETECT_CBK, +#endif /* USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK */ + +#if (USE_RT_DEBUG_PRVCY_POST_TMR_CBK == 1) + RT_DEBUG_PRVCY_POST_TMR_CBK, +#endif /* USE_RT_DEBUG_PRVCY_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ANT_PRPR_TMR_CBK == 1) + RT_DEBUG_ANT_PRPR_TMR_CBK, +#endif /* USE_RT_DEBUG_ANT_PRPR_TMR_CBK */ + +#if (USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK == 1) + RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK, +#endif /* USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK */ + +#if (USE_RT_DEBUG_MLME_RX_EN_TMR_CBK == 1) + RT_DEBUG_MLME_RX_EN_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_RX_EN_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_GNRC_TMR_CBK == 1) + RT_DEBUG_MLME_GNRC_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_GNRC_TMR_CBK */ + +#if (USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK == 1) + RT_DEBUG_MIB_JOIN_LST_TMR_CBK, +#endif /* USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK == 1) + RT_DEBUG_MLME_PWR_PRES_TMR_CBK, +#endif /* USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK */ + +#if (USE_RT_DEBUG_PRESISTENCE_TMR_CBK == 1) + RT_DEBUG_PRESISTENCE_TMR_CBK, +#endif /* USE_RT_DEBUG_PRESISTENCE_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK == 1) + RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR_CBK == 1) + RT_DEBUG_RADIO_CSMA_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK == 1) + RT_DEBUG_RADIO_CSL_RCV_TMR_CBK, +#endif /* USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_CBK == 1) + RT_DEBUG_ED_TMR_CBK, +#endif /* USE_RT_DEBUG_ED_TMR_CBK */ + +#if (USE_RT_DEBUG_DIO_EXT_TMR_CBK == 1) + RT_DEBUG_DIO_EXT_TMR_CBK, +#endif /* USE_RT_DEBUG_DIO_EXT_TMR_CBK */ + +#if (USE_RT_DEBUG_RCO_CLBR_TMR_CBK == 1) + RT_DEBUG_RCO_CLBR_TMR_CBK, +#endif /* USE_RT_DEBUG_RCO_CLBR_TMR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK == 1) + RT_DEBUG_ADV_EXT_MNGR_ADV_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK == 1) + RT_DEBUG_ADV_EXT_MNGR_SCN_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK == 1) + RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK == 1) + RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK == 1) + RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_CBK == 1) + RT_DEBUG_BIG_ADV_CBK, +#endif /* USE_RT_DEBUG_BIG_ADV_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_ERR_CBK == 1) + RT_DEBUG_BIG_ADV_ERR_CBK, +#endif /* USE_RT_DEBUG_BIG_ADV_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_CBK == 1) + RT_DEBUG_BIG_SYNC_CBK, +#endif /* USE_RT_DEBUG_BIG_SYNC_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_ERR_CBK == 1) + RT_DEBUG_BIG_SYNC_ERR_CBK, +#endif /* USE_RT_DEBUG_BIG_SYNC_ERR_CBK */ + +#if (USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK == 1) + RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK, +#endif /* USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_ISO_CIG_ERR_CBK == 1) + RT_DEBUG_ISO_CIG_ERR_CBK, +#endif /* USE_RT_DEBUG_ISO_CIG_ERR_CBK */ + +#if (USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK == 1) + RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK, +#endif /* USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK == 1) + RT_DEBUG_PRDC_CLBR_EXTRL_CBK, +#endif /* USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK */ + +#if (USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK == 1) + RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK, +#endif /* USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK */ + +#if (USE_RT_DEBUG_NCONN_SCN_CBK == 1) + RT_DEBUG_NCONN_SCN_CBK, +#endif /* USE_RT_DEBUG_NCONN_SCN_CBK */ + +#if (USE_RT_DEBUG_NCONN_ADV_CBK == 1) + RT_DEBUG_NCONN_ADV_CBK, +#endif /* USE_RT_DEBUG_NCONN_ADV_CBK */ + +#if (USE_RT_DEBUG_NCONN_INIT_CBK == 1) + RT_DEBUG_NCONN_INIT_CBK, +#endif /* USE_RT_DEBUG_NCONN_INIT_CBK */ + +#if (USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK == 1) + RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK, +#endif /* USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ANT_STACK_EVNT_CBK == 1) + RT_DEBUG_ANT_STACK_EVNT_CBK, +#endif /* USE_RT_DEBUG_ANT_STACK_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK == 1) + RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK, +#endif /* USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT == 1) + RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT == 1) + RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT == 1) + RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT == 1) + RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT */ + +#if (USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK == 1) + RT_DEBUG_BIS_MNGR_BIG_TERM_CBK, +#endif /* USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK */ + +#if (USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK == 1) + RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK, +#endif /* USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK */ + +#if (USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN == 1) + RT_DEBUG_ISOAL_MNGR_SDU_GEN, +#endif /* USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN */ + +#if (USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK == 1) + RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK, +#endif /* USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK == 1) + RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK, +#endif /* USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK == 1) + RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK, +#endif /* USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT == 1) + RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT */ + +#if (USE_RT_DEBUG_HCI_EVENT_HNDLR == 1) + RT_DEBUG_HCI_EVENT_HNDLR, +#endif /* USE_RT_DEBUG_HCI_EVENT_HNDLR */ + +#if (USE_RT_DEBUG_MLME_TMRS_CBK == 1) + RT_DEBUG_MLME_TMRS_CBK, +#endif /* USE_RT_DEBUG_MLME_TMRS_CBK */ + +#if (USE_RT_DEBUG_DIRECT_TX_EVNT_CBK == 1) + RT_DEBUG_DIRECT_TX_EVNT_CBK, +#endif /* USE_RT_DEBUG_DIRECT_TX_EVNT_CBK */ + +#if (USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK == 1) + RT_DEBUG_INDIRECT_PKT_TOUR_CBK, +#endif /* USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR == 1) + RT_DEBUG_RADIO_CSMA_TMR, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR */ + +#if (USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK == 1) + RT_DEBUG_RAL_SM_DONE_EVNT_CBK, +#endif /* USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_HNDL == 1) + RT_DEBUG_ED_TMR_HNDL, +#endif /* USE_RT_DEBUG_ED_TMR_HNDL */ + +#if (USE_RT_DEBUG_OS_TMR_EVNT_CBK == 1) + RT_DEBUG_OS_TMR_EVNT_CBK, +#endif /* USE_RT_DEBUG_OS_TMR_EVNT_CBK */ + +#if (USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME == 1) + RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME, +#endif /* USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME */ + +#if (USE_RT_DEBUG_PROFILE_END_DRIFT_TIME == 1) + RT_DEBUG_PROFILE_END_DRIFT_TIME, +#endif /* USE_RT_DEBUG_PROFILE_END_DRIFT_TIME */ + +#if (USE_RT_DEBUG_PROC_RADIO_RCV == 1) + RT_DEBUG_PROC_RADIO_RCV, +#endif /* USE_RT_DEBUG_PROC_RADIO_RCV */ + +#if (USE_RT_DEBUG_EVNT_TIME_UPDT == 1) + RT_DEBUG_EVNT_TIME_UPDT, +#endif /* USE_RT_DEBUG_EVNT_TIME_UPDT */ + +#if (USE_RT_DEBUG_MAC_RECEIVE_DONE == 1) + RT_DEBUG_MAC_RECEIVE_DONE, +#endif /* USE_RT_DEBUG_MAC_RECEIVE_DONE */ + +#if (USE_RT_DEBUG_MAC_TX_DONE == 1) + RT_DEBUG_MAC_TX_DONE, +#endif /* USE_RT_DEBUG_MAC_TX_DONE */ + +#if (USE_RT_DEBUG_RADIO_APPLY_CSMA == 1) + RT_DEBUG_RADIO_APPLY_CSMA, +#endif /* USE_RT_DEBUG_RADIO_APPLY_CSMA */ + +#if (USE_RT_DEBUG_RADIO_TRANSMIT == 1) + RT_DEBUG_RADIO_TRANSMIT, +#endif /* USE_RT_DEBUG_RADIO_TRANSMIT */ + +#if (USE_RT_DEBUG_PROC_RADIO_TX == 1) + RT_DEBUG_PROC_RADIO_TX, +#endif /* USE_RT_DEBUG_PROC_RADIO_TX */ + +#if (USE_RT_DEBUG_RAL_TX_DONE == 1) + RT_DEBUG_RAL_TX_DONE, +#endif /* USE_RT_DEBUG_RAL_TX_DONE */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT == 1) + RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT == 1) + RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_CONTINUE_RX == 1) + RT_DEBUG_RAL_CONTINUE_RX, +#endif /* USE_RT_DEBUG_RAL_CONTINUE_RX */ + +#if (USE_RT_DEBUG_RAL_PERFORM_CCA == 1) + RT_DEBUG_RAL_PERFORM_CCA, +#endif /* USE_RT_DEBUG_RAL_PERFORM_CCA */ + +#if (USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER == 1) + RT_DEBUG_RAL_ENABLE_TRANSMITTER, +#endif /* USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER */ + +#if (USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 == 1) + RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2, +#endif /* USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 */ + + RT_DEBUG_SIGNALS_TOTAL_NUM +} rt_debug_signal_t; + +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ + +#endif /* DEBUG_SIGNALS_H */ diff --git a/soc/st/stm32/stm32wbax/debug/local_debug_tables.h b/soc/st/stm32/stm32wbax/debug/local_debug_tables.h new file mode 100644 index 0000000000000..1afa507916ccb --- /dev/null +++ b/soc/st/stm32/stm32wbax/debug/local_debug_tables.h @@ -0,0 +1,1156 @@ +/** + ****************************************************************************** + * @file local_debug_tables.h + * @author MCD Application Team + * @brief Real Time Debug module System and Link Layer signal + correspondence tables + ****************************************************************************** + * @attention + * + * Copyright (c) 2024 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +#ifndef LOCAL_DEBUG_TABLES_H +#define LOCAL_DEBUG_TABLES_H + +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + +/*******************************/ +/** System local signal table **/ +/*******************************/ + +static const rt_debug_signal_t system_debug_table[] = { +#if (USE_RT_DEBUG_SCM_SETUP == 1) + [SCM_SETUP] = RT_DEBUG_SCM_SETUP, +#else + [SCM_SETUP] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCM_SETUP */ + +#if (USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG == 1) + [SCM_SYSTEM_CLOCK_CONFIG] = RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG, +#else + [SCM_SYSTEM_CLOCK_CONFIG] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCM_SYSTEM_CLOCK_CONFIG */ + +#if (USE_RT_DEBUG_SCM_HSERDY_ISR == 1) + [SCM_HSERDY_ISR] = RT_DEBUG_SCM_HSERDY_ISR, +#else + [SCM_HSERDY_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCM_HSERDY_ISR */ + +#if (USE_RT_DEBUG_ADC_ACTIVATION == 1) + [ADC_ACTIVATION] = RT_DEBUG_ADC_ACTIVATION, +#else + [ADC_ACTIVATION] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADC_ACTIVATION */ + +#if (USE_RT_DEBUG_ADC_DEACTIVATION == 1) + [ADC_DEACTIVATION] = RT_DEBUG_ADC_DEACTIVATION, +#else + [ADC_DEACTIVATION] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADC_DEACTIVATION */ + +#if (USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION == 1) + [ADC_TEMPERATURE_ACQUISITION] = RT_DEBUG_ADC_TEMPERATURE_ACQUISITION, +#else + [ADC_TEMPERATURE_ACQUISITION] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADC_TEMPERATURE_ACQUISITION */ + +#if (USE_RT_DEBUG_RNG_ENABLE == 1) + [RNG_ENABLE] = RT_DEBUG_RNG_ENABLE, +#else + [RNG_ENABLE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RNG_ENABLE */ + +#if (USE_RT_DEBUG_RNG_DISABLE == 1) + [RNG_DISABLE] = RT_DEBUG_RNG_DISABLE, +#else + [RNG_DISABLE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RNG_DISABLE */ + +#if (USE_RT_DEBUG_RNG_GEN_RAND_NUM == 1) + [RNG_GEN_RAND_NUM] = RT_DEBUG_RNG_GEN_RAND_NUM, +#else + [RNG_GEN_RAND_NUM] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RNG_GEN_RAND_NUM */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER == 1) + [LOW_POWER_STOP_MODE_ENTER] = RT_DEBUG_LOW_POWER_STOP_MODE_ENTER, +#else + [LOW_POWER_STOP_MODE_ENTER] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT == 1) + [LOW_POWER_STOP_MODE_EXIT] = RT_DEBUG_LOW_POWER_STOP_MODE_EXIT, +#else + [LOW_POWER_STOP_MODE_EXIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE == 1) + [LOW_POWER_STOP_MODE_ACTIVE] = RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE, +#else + [LOW_POWER_STOP_MODE_ACTIVE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER == 1) + [LOW_POWER_STOP2_MODE_ENTER] = RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER, +#else + [LOW_POWER_STOP2_MODE_ENTER] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT == 1) + [LOW_POWER_STOP2_MODE_EXIT] = RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT, +#else + [LOW_POWER_STOP2_MODE_EXIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE == 1) + [LOW_POWER_STOP2_MODE_ACTIVE] = RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE, +#else + [LOW_POWER_STOP2_MODE_ACTIVE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STOP2_MODE_ACTIVE */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER == 1) + [LOW_POWER_STANDBY_MODE_ENTER] = RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER, +#else + [LOW_POWER_STANDBY_MODE_ENTER] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ENTER */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT == 1) + [LOW_POWER_STANDBY_MODE_EXIT] = RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT, +#else + [LOW_POWER_STANDBY_MODE_EXIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_EXIT */ + +#if (USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE == 1) + [LOW_POWER_STANDBY_MODE_ACTIVE] = RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE, +#else + [LOW_POWER_STANDBY_MODE_ACTIVE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LOW_POWER_STANDBY_MODE_ACTIVE */ + +}; + +/***********************************/ +/** Link Layer local signal table **/ +/***********************************/ + +static const rt_debug_signal_t linklayer_debug_table[] = { +#if (USE_RT_DEBUG_HCI_READ_DONE == 1) + [DBG_IO_HCI_READ_DONE] = RT_DEBUG_HCI_READ_DONE, +#else + [DBG_IO_HCI_READ_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HCI_READ_DONE */ + +#if (USE_RT_DEBUG_HCI_RCVD_CMD == 1) + [DBG_IO_HCI_RCVD_CMD] = RT_DEBUG_HCI_RCVD_CMD, +#else + [DBG_IO_HCI_RCVD_CMD] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HCI_RCVD_CMD */ + +#if (USE_RT_DEBUG_HCI_WRITE_DONE == 1) + [DBG_IO_HCI_WRITE_DONE] = RT_DEBUG_HCI_WRITE_DONE, +#else + [DBG_IO_HCI_WRITE_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HCI_WRITE_DONE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_UPDATE == 1) + [DBG_IO_SCHDLR_EVNT_UPDATE] = RT_DEBUG_SCHDLR_EVNT_UPDATE, +#else + [DBG_IO_SCHDLR_EVNT_UPDATE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_UPDATE */ + +#if (USE_RT_DEBUG_SCHDLR_TIMER_SET == 1) + [DBG_IO_SCHDLR_TIMER_SET] = RT_DEBUG_SCHDLR_TIMER_SET, +#else + [DBG_IO_SCHDLR_TIMER_SET] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_TIMER_SET */ + +#if (USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER == 1) + [DBG_IO_SCHDLR_PHY_CLBR_TIMER] = RT_DEBUG_SCHDLR_PHY_CLBR_TIMER, +#else + [DBG_IO_SCHDLR_PHY_CLBR_TIMER] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_PHY_CLBR_TIMER */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED == 1) + [DBG_IO_SCHDLR_EVNT_SKIPPED] = RT_DEBUG_SCHDLR_EVNT_SKIPPED, +#else + [DBG_IO_SCHDLR_EVNT_SKIPPED] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_SKIPPED */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE == 1) + [DBG_IO_SCHDLR_HNDL_NXT_TRACE] = RT_DEBUG_SCHDLR_HNDL_NXT_TRACE, +#else + [DBG_IO_SCHDLR_HNDL_NXT_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_NXT_TRACE */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED == 1) + [DBG_IO_ACTIVE_SCHDLR_NEAR_DETEDTED] = RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED, +#else + [DBG_IO_ACTIVE_SCHDLR_NEAR_DETEDTED] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_DETEDTED */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK == 1) + [DBG_IO_ACTIVE_SCHDLR_NEAR_GAP_CHECK] = RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK, +#else + [DBG_IO_ACTIVE_SCHDLR_NEAR_GAP_CHECK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_GAP_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK == 1) + [DBG_IO_ACTIVE_SCHDLR_NEAR_TIME_CHECK] = RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK, +#else + [DBG_IO_ACTIVE_SCHDLR_NEAR_TIME_CHECK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TIME_CHECK */ + +#if (USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE == 1) + [DBG_IO_ACTIVE_SCHDLR_NEAR_TRACE] = RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE, +#else + [DBG_IO_ACTIVE_SCHDLR_NEAR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ACTIVE_SCHDLR_NEAR_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EVNT_RGSTR == 1) + [DBG_IO_SCHDLR_EVNT_RGSTR] = RT_DEBUG_SCHDLR_EVNT_RGSTR, +#else + [DBG_IO_SCHDLR_EVNT_RGSTR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EVNT_RGSTR */ + +#if (USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q == 1) + [DBG_IO_SCHDLR_ADD_CONFLICT_Q] = RT_DEBUG_SCHDLR_ADD_CONFLICT_Q, +#else + [DBG_IO_SCHDLR_ADD_CONFLICT_Q] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_ADD_CONFLICT_Q */ + +#if (USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT == 1) + [DBG_IO_SCHDLR_HNDL_MISSED_EVNT] = RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT, +#else + [DBG_IO_SCHDLR_HNDL_MISSED_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_HNDL_MISSED_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT == 1) + [DBG_IO_SCHDLR_UNRGSTR_EVNT] = RT_DEBUG_SCHDLR_UNRGSTR_EVNT, +#else + [DBG_IO_SCHDLR_UNRGSTR_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_UNRGSTR_EVNT */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE == 1) + [DBG_IO_SCHDLR_EXEC_EVNT_TRACE] = RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE, +#else + [DBG_IO_SCHDLR_EXEC_EVNT_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_TRACE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE == 1) + [DBG_IO_SCHDLR_EXEC_EVNT_PROFILE] = RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE, +#else + [DBG_IO_SCHDLR_EXEC_EVNT_PROFILE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_PROFILE */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR == 1) + [DBG_IO_SCHDLR_EXEC_EVNT_ERROR] = RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR, +#else + [DBG_IO_SCHDLR_EXEC_EVNT_ERROR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_ERROR */ + +#if (USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING == 1) + [DBG_IO_SCHDLR_EXEC_EVNT_WINDOW_WIDENING] = RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING, +#else + [DBG_IO_SCHDLR_EXEC_EVNT_WINDOW_WIDENING] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_SCHDLR_EXEC_EVNT_WINDOW_WIDENING */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_ISR == 1) + [DBG_IO_LLHWC_CMN_CLR_ISR] = RT_DEBUG_LLHWC_CMN_CLR_ISR, +#else + [DBG_IO_LLHWC_CMN_CLR_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_ISR */ + +#if (USE_RT_DEBUG_LLWCC_CMN_HG_ISR == 1) + [DBG_IO_LLWCC_CMN_HG_ISR] = RT_DEBUG_LLWCC_CMN_HG_ISR, +#else + [DBG_IO_LLWCC_CMN_HG_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLWCC_CMN_HG_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_LW_ISR == 1) + [DBG_IO_LLHWC_CMN_LW_ISR] = RT_DEBUG_LLHWC_CMN_LW_ISR, +#else + [DBG_IO_LLHWC_CMN_LW_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_CMN_LW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR == 1) + [DBG_IO_LLHWC_CMN_CLR_TIMER_ERROR] = RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR, +#else + [DBG_IO_LLHWC_CMN_CLR_TIMER_ERROR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_CMN_CLR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_LLHWC_LL_ISR == 1) + [DBG_IO_LLHWC_LL_ISR] = RT_DEBUG_LLHWC_LL_ISR, +#else + [DBG_IO_LLHWC_LL_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_LL_ISR */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_SET == 1) + [DBG_IO_LLHWC_SPLTMR_SET] = RT_DEBUG_LLHWC_SPLTMR_SET, +#else + [DBG_IO_LLHWC_SPLTMR_SET] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_SET */ + +#if (USE_RT_DEBUG_LLHWC_SPLTMR_GET == 1) + [DBG_IO_LLHWC_SPLTMR_GET] = RT_DEBUG_LLHWC_SPLTMR_GET, +#else + [DBG_IO_LLHWC_SPLTMR_GET] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_SPLTMR_GET */ + +#if (USE_RT_DEBUG_LLHWC_LOW_ISR == 1) + [DBG_IO_LLHWC_LOW_ISR] = RT_DEBUG_LLHWC_LOW_ISR, +#else + [DBG_IO_LLHWC_LOW_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_LOW_ISR */ + +#if (USE_RT_DEBUG_LLHWC_STOP_SCN == 1) + [DBG_IO_LLHWC_STOP_SCN] = RT_DEBUG_LLHWC_STOP_SCN, +#else + [DBG_IO_LLHWC_STOP_SCN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_STOP_SCN */ + +#if (USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR == 1) + [DBG_IO_LLHWC_WAIT_ENVT_ON_AIR] = RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR, +#else + [DBG_IO_LLHWC_WAIT_ENVT_ON_AIR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_WAIT_ENVT_ON_AIR */ + +#if (USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM == 1) + [DBG_IO_LLHWC_SET_CONN_EVNT_PARAM] = RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM, +#else + [DBG_IO_LLHWC_SET_CONN_EVNT_PARAM] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_SET_CONN_EVNT_PARAM */ + +#if (USE_RT_DEBUG_POST_EVNT == 1) + [DBG_IO_POST_EVNT] = RT_DEBUG_POST_EVNT, +#else + [DBG_IO_POST_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_POST_EVNT */ + +#if (USE_RT_DEBUG_HNDL_ALL_EVNTS == 1) + [DBG_IO_HNDL_ALL_EVNTS] = RT_DEBUG_HNDL_ALL_EVNTS, +#else + [DBG_IO_HNDL_ALL_EVNTS] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HNDL_ALL_EVNTS */ + +#if (USE_RT_DEBUG_PROCESS_EVNT == 1) + [DBG_IO_PROCESS_EVNT] = RT_DEBUG_PROCESS_EVNT, +#else + [DBG_IO_PROCESS_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROCESS_EVNT */ + +#if (USE_RT_DEBUG_PROCESS_ISO_DATA == 1) + [DBG_IO_PROCESS_ISO_DATA] = RT_DEBUG_PROCESS_ISO_DATA, +#else + [DBG_IO_PROCESS_ISO_DATA] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROCESS_ISO_DATA */ + +#if (USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT == 1) + [DBG_IO_ALLOC_TX_ISO_EMPTY_PKT] = RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT, +#else + [DBG_IO_ALLOC_TX_ISO_EMPTY_PKT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ALLOC_TX_ISO_EMPTY_PKT */ + +#if (USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS == 1) + [DBG_IO_BIG_FREE_EMPTY_PKTS] = RT_DEBUG_BIG_FREE_EMPTY_PKTS, +#else + [DBG_IO_BIG_FREE_EMPTY_PKTS] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIG_FREE_EMPTY_PKTS */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK == 1) + [DBG_IO_RECOMBINE_UNFRMD_DATA_OK] = RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK, +#else + [DBG_IO_RECOMBINE_UNFRMD_DATA_OK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_OK */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC == 1) + [DBG_IO_RECOMBINE_UNFRMD_DATA_CRC] = RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC, +#else + [DBG_IO_RECOMBINE_UNFRMD_DATA_CRC] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_CRC */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX == 1) + [DBG_IO_RECOMBINE_UNFRMD_DATA_NoRX] = RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX, +#else + [DBG_IO_RECOMBINE_UNFRMD_DATA_NoRX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_NoRX */ + +#if (USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE == 1) + [DBG_IO_RECOMBINE_UNFRMD_DATA_TRACE] = RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE, +#else + [DBG_IO_RECOMBINE_UNFRMD_DATA_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RECOMBINE_UNFRMD_DATA_TRACE */ + +#if (USE_RT_DEBUG_ISO_HNDL_SDU == 1) + [DBG_IO_ISO_HNDL_SDU] = RT_DEBUG_ISO_HNDL_SDU, +#else + [DBG_IO_ISO_HNDL_SDU] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_HNDL_SDU */ + +#if (USE_RT_DEBUG_LL_INTF_INIT == 1) + [DBG_IO_LL_INTF_INIT] = RT_DEBUG_LL_INTF_INIT, +#else + [DBG_IO_LL_INTF_INIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LL_INTF_INIT */ + +#if (USE_RT_DEBUG_DATA_TO_CNTRLR == 1) + [DBG_IO_DATA_TO_CNTRLR] = RT_DEBUG_DATA_TO_CNTRLR, +#else + [DBG_IO_DATA_TO_CNTRLR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_DATA_TO_CNTRLR */ + +#if (USE_RT_DEBUG_FREE_LL_PKT_HNDLR == 1) + [DBG_IO_FREE_LL_PKT_HNDLR] = RT_DEBUG_FREE_LL_PKT_HNDLR, +#else + [DBG_IO_FREE_LL_PKT_HNDLR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_FREE_LL_PKT_HNDLR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_TRACE == 1) + [DBG_IO_PHY_INIT_CLBR_TRACE] = RT_DEBUG_PHY_INIT_CLBR_TRACE, +#else + [DBG_IO_PHY_INIT_CLBR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE == 1) + [DBG_IO_PHY_RUNTIME_CLBR_TRACE] = RT_DEBUG_PHY_RUNTIME_CLBR_TRACE, +#else + [DBG_IO_PHY_RUNTIME_CLBR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_RUNTIME_CLBR_TRACE */ + +#if (USE_RT_DEBUG_PHY_CLBR_ISR == 1) + [DBG_IO_PHY_CLBR_ISR] = RT_DEBUG_PHY_CLBR_ISR, +#else + [DBG_IO_PHY_CLBR_ISR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_CLBR_ISR */ + +#if (USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH == 1) + [DBG_IO_PHY_INIT_CLBR_SINGLE_CH] = RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH, +#else + [DBG_IO_PHY_INIT_CLBR_SINGLE_CH] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_INIT_CLBR_SINGLE_CH */ + +#if (USE_RT_DEBUG_PHY_CLBR_STRTD == 1) + [DBG_IO_PHY_CLBR_STRTD] = RT_DEBUG_PHY_CLBR_STRTD, +#else + [DBG_IO_PHY_CLBR_STRTD] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_CLBR_STRTD */ + +#if (USE_RT_DEBUG_PHY_CLBR_EXEC == 1) + [DBG_IO_PHY_CLBR_EXEC] = RT_DEBUG_PHY_CLBR_EXEC, +#else + [DBG_IO_PHY_CLBR_EXEC] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PHY_CLBR_EXEC */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV == 1) + [DBG_IO_RCO_STRT_STOP_RUNTIME_CLBR_ACTV] = RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV, +#else + [DBG_IO_RCO_STRT_STOP_RUNTIME_CLBR_ACTV] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_CLBR_ACTV */ + +#if (USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR == 1) + [DBG_IO_RCO_STRT_STOP_RUNTIME_RCO_CLBR] = RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR, +#else + [DBG_IO_RCO_STRT_STOP_RUNTIME_RCO_CLBR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RCO_STRT_STOP_RUNTIME_RCO_CLBR */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT == 1) + [DBG_IO_STRT_STOP_RUNTIME_RCO_CLBR_SWT] = RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT, +#else + [DBG_IO_STRT_STOP_RUNTIME_RCO_CLBR_SWT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_SWT */ + +#if (USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE == 1) + [DBG_IO_STRT_STOP_RUNTIME_RCO_CLBR_TRACE] = RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE, +#else + [DBG_IO_STRT_STOP_RUNTIME_RCO_CLBR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_STRT_STOP_RUNTIME_RCO_CLBR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_TRACE == 1) + [DBG_IO_RCO_ISR_TRACE] = RT_DEBUG_RCO_ISR_TRACE, +#else + [DBG_IO_RCO_ISR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RCO_ISR_TRACE */ + +#if (USE_RT_DEBUG_RCO_ISR_COMPENDATE == 1) + [DBG_IO_RCO_ISR_COMPENDATE] = RT_DEBUG_RCO_ISR_COMPENDATE, +#else + [DBG_IO_RCO_ISR_COMPENDATE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RCO_ISR_COMPENDATE */ + +#if (USE_RT_DEBUG_RAL_STRT_TX == 1) + [DBG_IO_RAL_STRT_TX] = RT_DEBUG_RAL_STRT_TX, +#else + [DBG_IO_RAL_STRT_TX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_STRT_TX */ + +#if (USE_RT_DEBUG_RAL_ISR_TIMER_ERROR == 1) + [DBG_IO_RAL_ISR_TIMER_ERROR] = RT_DEBUG_RAL_ISR_TIMER_ERROR, +#else + [DBG_IO_RAL_ISR_TIMER_ERROR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_ISR_TIMER_ERROR */ + +#if (USE_RT_DEBUG_RAL_ISR_TRACE == 1) + [DBG_IO_RAL_ISR_TRACE] = RT_DEBUG_RAL_ISR_TRACE, +#else + [DBG_IO_RAL_ISR_TRACE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_ISR_TRACE */ + +#if (USE_RT_DEBUG_RAL_STOP_OPRTN == 1) + [DBG_IO_RAL_STOP_OPRTN] = RT_DEBUG_RAL_STOP_OPRTN, +#else + [DBG_IO_RAL_STOP_OPRTN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_STOP_OPRTN */ + +#if (USE_RT_DEBUG_RAL_STRT_RX == 1) + [DBG_IO_RAL_STRT_RX] = RT_DEBUG_RAL_STRT_RX, +#else + [DBG_IO_RAL_STRT_RX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_STRT_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_TX == 1) + [DBG_IO_RAL_DONE_CLBK_TX] = RT_DEBUG_RAL_DONE_CLBK_TX, +#else + [DBG_IO_RAL_DONE_CLBK_TX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_TX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_RX == 1) + [DBG_IO_RAL_DONE_CLBK_RX] = RT_DEBUG_RAL_DONE_CLBK_RX, +#else + [DBG_IO_RAL_DONE_CLBK_RX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_RX */ + +#if (USE_RT_DEBUG_RAL_DONE_CLBK_ED == 1) + [DBG_IO_RAL_DONE_CLBK_ED] = RT_DEBUG_RAL_DONE_CLBK_ED, +#else + [DBG_IO_RAL_DONE_CLBK_ED] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_DONE_CLBK_ED */ + +#if (USE_RT_DEBUG_RAL_ED_SCAN == 1) + [DBG_IO_RAL_ED_SCAN] = RT_DEBUG_RAL_ED_SCAN, +#else + [DBG_IO_RAL_ED_SCAN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_ED_SCAN */ + +#if (USE_RT_DEBUG_ERROR_MEM_CAP_EXCED == 1) + [DBG_IO_ERROR_MEM_CAP_EXCED] = RT_DEBUG_ERROR_MEM_CAP_EXCED, +#else + [DBG_IO_ERROR_MEM_CAP_EXCED] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ERROR_MEM_CAP_EXCED */ + +#if (USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED == 1) + [DBG_IO_ERROR_COMMAND_DISALLOWED] = RT_DEBUG_ERROR_COMMAND_DISALLOWED, +#else + [DBG_IO_ERROR_COMMAND_DISALLOWED] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ERROR_COMMAND_DISALLOWED */ + +#if (USE_RT_DEBUG_PTA_INIT == 1) + [DBG_IO_PTA_INIT] = RT_DEBUG_PTA_INIT, +#else + [DBG_IO_PTA_INIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PTA_INIT */ + +#if (USE_RT_DEBUG_PTA_EN == 1) + [DBG_IO_PTA_EN] = RT_DEBUG_PTA_EN, +#else + [DBG_IO_PTA_EN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PTA_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_EN == 1) + [DBG_IO_LLHWC_PTA_SET_EN] = RT_DEBUG_LLHWC_PTA_SET_EN, +#else + [DBG_IO_LLHWC_PTA_SET_EN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_EN */ + +#if (USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS == 1) + [DBG_IO_LLHWC_PTA_SET_PARAMS] = RT_DEBUG_LLHWC_PTA_SET_PARAMS, +#else + [DBG_IO_LLHWC_PTA_SET_PARAMS] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_PTA_SET_PARAMS */ + +#if (USE_RT_DEBUG_COEX_STRT_ON_IDLE == 1) + [DBG_IO_COEX_STRT_ON_IDLE] = RT_DEBUG_COEX_STRT_ON_IDLE, +#else + [DBG_IO_COEX_STRT_ON_IDLE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_STRT_ON_IDLE */ + +#if (USE_RT_DEBUG_COEX_ASK_FOR_AIR == 1) + [DBG_IO_COEX_ASK_FOR_AIR] = RT_DEBUG_COEX_ASK_FOR_AIR, +#else + [DBG_IO_COEX_ASK_FOR_AIR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_ASK_FOR_AIR */ + +#if (USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK == 1) + [DBG_IO_COEX_TIMER_EVNT_CLBK] = RT_DEBUG_COEX_TIMER_EVNT_CLBK, +#else + [DBG_IO_COEX_TIMER_EVNT_CLBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_TIMER_EVNT_CLBK */ + +#if (USE_RT_DEBUG_COEX_STRT_ONE_SHOT == 1) + [DBG_IO_COEX_STRT_ONE_SHOT] = RT_DEBUG_COEX_STRT_ONE_SHOT, +#else + [DBG_IO_COEX_STRT_ONE_SHOT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_STRT_ONE_SHOT */ + +#if (USE_RT_DEBUG_COEX_FORCE_STOP_RX == 1) + [DBG_IO_COEX_FORCE_STOP_RX] = RT_DEBUG_COEX_FORCE_STOP_RX, +#else + [DBG_IO_COEX_FORCE_STOP_RX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_FORCE_STOP_RX */ + +#if (USE_RT_DEBUG_LLHWC_ADV_DONE == 1) + [DBG_IO_LLHWC_ADV_DONE] = RT_DEBUG_LLHWC_ADV_DONE, +#else + [DBG_IO_LLHWC_ADV_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_ADV_DONE */ + +#if (USE_RT_DEBUG_LLHWC_SCN_DONE == 1) + [DBG_IO_LLHWC_SCN_DONE] = RT_DEBUG_LLHWC_SCN_DONE, +#else + [DBG_IO_LLHWC_SCN_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_SCN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_INIT_DONE == 1) + [DBG_IO_LLHWC_INIT_DONE] = RT_DEBUG_LLHWC_INIT_DONE, +#else + [DBG_IO_LLHWC_INIT_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_INIT_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CONN_DONE == 1) + [DBG_IO_LLHWC_CONN_DONE] = RT_DEBUG_LLHWC_CONN_DONE, +#else + [DBG_IO_LLHWC_CONN_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_CONN_DONE */ + +#if (USE_RT_DEBUG_LLHWC_CIG_DONE == 1) + [DBG_IO_LLHWC_CIG_DONE] = RT_DEBUG_LLHWC_CIG_DONE, +#else + [DBG_IO_LLHWC_CIG_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_CIG_DONE */ + +#if (USE_RT_DEBUG_LLHWC_BIG_DONE == 1) + [DBG_IO_LLHWC_BIG_DONE] = RT_DEBUG_LLHWC_BIG_DONE, +#else + [DBG_IO_LLHWC_BIG_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_BIG_DONE */ + +#if (USE_RT_DEBUG_OS_TMR_CREATE == 1) + [DBG_IO_OS_TMR_CREATE] = RT_DEBUG_OS_TMR_CREATE, +#else + [DBG_IO_OS_TMR_CREATE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_OS_TMR_CREATE */ + +#if (USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK == 1) + [DBG_IO_ADV_EXT_TIMEOUT_CBK] = RT_DEBUG_ADV_EXT_TIMEOUT_CBK, +#else + [DBG_IO_ADV_EXT_TIMEOUT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK == 1) + [DBG_IO_ADV_EXT_SCN_DUR_CBK] = RT_DEBUG_ADV_EXT_SCN_DUR_CBK, +#else + [DBG_IO_ADV_EXT_SCN_DUR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_DUR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK == 1) + [DBG_IO_ADV_EXT_SCN_PERIOD_CBK] = RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK, +#else + [DBG_IO_ADV_EXT_SCN_PERIOD_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_SCN_PERIOD_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK == 1) + [DBG_IO_ADV_EXT_PRDC_SCN_TIMEOUT_CBK] = RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK, +#else + [DBG_IO_ADV_EXT_PRDC_SCN_TIMEOUT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_PRDC_SCN_TIMEOUT_CBK */ + +#if (USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK == 1) + [DBG_IO_BIS_SYNC_TIMEOUT_TMR_CBK] = RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK, +#else + [DBG_IO_BIS_SYNC_TIMEOUT_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_SYNC_TIMEOUT_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TERM_TMR_CBK == 1) + [DBG_IO_BIS_TERM_TMR_CBK] = RT_DEBUG_BIS_TERM_TMR_CBK, +#else + [DBG_IO_BIS_TERM_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_TERM_TMR_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_CBK == 1) + [DBG_IO_BIS_TST_MODE_CBK] = RT_DEBUG_BIS_TST_MODE_CBK, +#else + [DBG_IO_BIS_TST_MODE_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_CBK */ + +#if (USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK == 1) + [DBG_IO_BIS_TST_MODE_TMR_CBK] = RT_DEBUG_BIS_TST_MODE_TMR_CBK, +#else + [DBG_IO_BIS_TST_MODE_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_POST_TMR_CBK == 1) + [DBG_IO_ISO_POST_TMR_CBK] = RT_DEBUG_ISO_POST_TMR_CBK, +#else + [DBG_IO_ISO_POST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK == 1) + [DBG_IO_ISO_TST_MODE_TMR_CBK] = RT_DEBUG_ISO_TST_MODE_TMR_CBK, +#else + [DBG_IO_ISO_TST_MODE_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_TST_MODE_TMR_CBK */ + +#if (USE_RT_DEBUG_CONN_POST_TMR_CBK == 1) + [DBG_IO_CONN_POST_TMR_CBK] = RT_DEBUG_CONN_POST_TMR_CBK, +#else + [DBG_IO_CONN_POST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_CONN_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK == 1) + [DBG_IO_EVNT_SCHDLR_TMR_CBK] = RT_DEBUG_EVNT_SCHDLR_TMR_CBK, +#else + [DBG_IO_EVNT_SCHDLR_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_TMR_CBK */ + +#if (USE_RT_DEBUG_HCI_POST_TMR_CBK == 1) + [DBG_IO_HCI_POST_TMR_CBK] = RT_DEBUG_HCI_POST_TMR_CBK, +#else + [DBG_IO_HCI_POST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HCI_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLCP_POST_TMR_CBK == 1) + [DBG_IO_LLCP_POST_TMR_CBK] = RT_DEBUG_LLCP_POST_TMR_CBK, +#else + [DBG_IO_LLCP_POST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLCP_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK == 1) + [DBG_IO_LLHWC_ENRGY_DETECT_CBK] = RT_DEBUG_LLHWC_ENRGY_DETECT_CBK, +#else + [DBG_IO_LLHWC_ENRGY_DETECT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_ENRGY_DETECT_CBK */ + +#if (USE_RT_DEBUG_PRVCY_POST_TMR_CBK == 1) + [DBG_IO_PRVCY_POST_TMR_CBK] = RT_DEBUG_PRVCY_POST_TMR_CBK, +#else + [DBG_IO_PRVCY_POST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PRVCY_POST_TMR_CBK */ + +#if (USE_RT_DEBUG_ANT_PRPR_TMR_CBK == 1) + [DBG_IO_ANT_PRPR_TMR_CBK] = RT_DEBUG_ANT_PRPR_TMR_CBK, +#else + [DBG_IO_ANT_PRPR_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ANT_PRPR_TMR_CBK */ + +#if (USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK == 1) + [DBG_IO_COEX_TMR_FRC_STOP_AIR_GRANT_CBK] = RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK, +#else + [DBG_IO_COEX_TMR_FRC_STOP_AIR_GRANT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_COEX_TMR_FRC_STOP_AIR_GRANT_CBK */ + +#if (USE_RT_DEBUG_MLME_RX_EN_TMR_CBK == 1) + [DBG_IO_MLME_RX_EN_TMR_CBK] = RT_DEBUG_MLME_RX_EN_TMR_CBK, +#else + [DBG_IO_MLME_RX_EN_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MLME_RX_EN_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_GNRC_TMR_CBK == 1) + [DBG_IO_MLME_GNRC_TMR_CBK] = RT_DEBUG_MLME_GNRC_TMR_CBK, +#else + [DBG_IO_MLME_GNRC_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MLME_GNRC_TMR_CBK */ + +#if (USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK == 1) + [DBG_IO_MIB_JOIN_LST_TMR_CBK] = RT_DEBUG_MIB_JOIN_LST_TMR_CBK, +#else + [DBG_IO_MIB_JOIN_LST_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MIB_JOIN_LST_TMR_CBK */ + +#if (USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK == 1) + [DBG_IO_MLME_PWR_PRES_TMR_CBK] = RT_DEBUG_MLME_PWR_PRES_TMR_CBK, +#else + [DBG_IO_MLME_PWR_PRES_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MLME_PWR_PRES_TMR_CBK */ + +#if (USE_RT_DEBUG_PRESISTENCE_TMR_CBK == 1) + [DBG_IO_PRESISTENCE_TMR_CBK] = RT_DEBUG_PRESISTENCE_TMR_CBK, +#else + [DBG_IO_PRESISTENCE_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PRESISTENCE_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK == 1) + [DBG_IO_RADIO_PHY_PRDC_CLBK_TMR_CBK] = RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK, +#else + [DBG_IO_RADIO_PHY_PRDC_CLBK_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_PHY_PRDC_CLBK_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR_CBK == 1) + [DBG_IO_RADIO_CSMA_TMR_CBK] = RT_DEBUG_RADIO_CSMA_TMR_CBK, +#else + [DBG_IO_RADIO_CSMA_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK == 1) + [DBG_IO_RADIO_CSL_RCV_TMR_CBK] = RT_DEBUG_RADIO_CSL_RCV_TMR_CBK, +#else + [DBG_IO_RADIO_CSL_RCV_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_CSL_RCV_TMR_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_CBK == 1) + [DBG_IO_ED_TMR_CBK] = RT_DEBUG_ED_TMR_CBK, +#else + [DBG_IO_ED_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ED_TMR_CBK */ + +#if (USE_RT_DEBUG_DIO_EXT_TMR_CBK == 1) + [DBG_IO_DIO_EXT_TMR_CBK] = RT_DEBUG_DIO_EXT_TMR_CBK, +#else + [DBG_IO_DIO_EXT_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_DIO_EXT_TMR_CBK */ + +#if (USE_RT_DEBUG_RCO_CLBR_TMR_CBK == 1) + [DBG_IO_RCO_CLBR_TMR_CBK] = RT_DEBUG_RCO_CLBR_TMR_CBK, +#else + [DBG_IO_RCO_CLBR_TMR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RCO_CLBR_TMR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK == 1) + [DBG_IO_ADV_EXT_MNGR_ADV_CBK] = RT_DEBUG_ADV_EXT_MNGR_ADV_CBK, +#else + [DBG_IO_ADV_EXT_MNGR_ADV_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_ADV_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK == 1) + [DBG_IO_ADV_EXT_MNGR_SCN_CBK] = RT_DEBUG_ADV_EXT_MNGR_SCN_CBK, +#else + [DBG_IO_ADV_EXT_MNGR_SCN_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK == 1) + [DBG_IO_ADV_EXT_MNGR_SCN_ERR_CBK] = RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK, +#else + [DBG_IO_ADV_EXT_MNGR_SCN_ERR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK == 1) + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_CBK] = RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK, +#else + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK == 1) + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK] = RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK, +#else + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_CBK == 1) + [DBG_IO_BIG_ADV_CBK] = RT_DEBUG_BIG_ADV_CBK, +#else + [DBG_IO_BIG_ADV_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIG_ADV_CBK */ + +#if (USE_RT_DEBUG_BIG_ADV_ERR_CBK == 1) + [DBG_IO_BIG_ADV_ERR_CBK] = RT_DEBUG_BIG_ADV_ERR_CBK, +#else + [DBG_IO_BIG_ADV_ERR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIG_ADV_ERR_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_CBK == 1) + [DBG_IO_BIG_SYNC_CBK] = RT_DEBUG_BIG_SYNC_CBK, +#else + [DBG_IO_BIG_SYNC_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIG_SYNC_CBK */ + +#if (USE_RT_DEBUG_BIG_SYNC_ERR_CBK == 1) + [DBG_IO_BIG_SYNC_ERR_CBK] = RT_DEBUG_BIG_SYNC_ERR_CBK, +#else + [DBG_IO_BIG_SYNC_ERR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIG_SYNC_ERR_CBK */ + +#if (USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK == 1) + [DBG_IO_ISO_CIS_PKT_TRNSM_RECEIVED_CBK] = RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK, +#else + [DBG_IO_ISO_CIS_PKT_TRNSM_RECEIVED_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_CIS_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_ISO_CIG_ERR_CBK == 1) + [DBG_IO_ISO_CIG_ERR_CBK] = RT_DEBUG_ISO_CIG_ERR_CBK, +#else + [DBG_IO_ISO_CIG_ERR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_CIG_ERR_CBK */ + +#if (USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK == 1) + [DBG_IO_CONN_PKT_TRNSM_RECEIVED_CBK] = RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK, +#else + [DBG_IO_CONN_PKT_TRNSM_RECEIVED_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_CONN_PKT_TRNSM_RECEIVED_CBK */ + +#if (USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK == 1) + [DBG_IO_PRDC_CLBR_EXTRL_CBK] = RT_DEBUG_PRDC_CLBR_EXTRL_CBK, +#else + [DBG_IO_PRDC_CLBR_EXTRL_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PRDC_CLBR_EXTRL_CBK */ + +#if (USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK == 1) + [DBG_IO_PTR_PRDC_ADV_SYNC_CBK] = RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK, +#else + [DBG_IO_PTR_PRDC_ADV_SYNC_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PTR_PRDC_ADV_SYNC_CBK */ + +#if (USE_RT_DEBUG_NCONN_SCN_CBK == 1) + [DBG_IO_NCONN_SCN_CBK] = RT_DEBUG_NCONN_SCN_CBK, +#else + [DBG_IO_NCONN_SCN_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_NCONN_SCN_CBK */ + +#if (USE_RT_DEBUG_NCONN_ADV_CBK == 1) + [DBG_IO_NCONN_ADV_CBK] = RT_DEBUG_NCONN_ADV_CBK, +#else + [DBG_IO_NCONN_ADV_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_NCONN_ADV_CBK */ + +#if (USE_RT_DEBUG_NCONN_INIT_CBK == 1) + [DBG_IO_NCONN_INIT_CBK] = RT_DEBUG_NCONN_INIT_CBK, +#else + [DBG_IO_NCONN_INIT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_NCONN_INIT_CBK */ + +#if (USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK == 1) + [DBG_IO_ANT_RADIO_CMPLT_EVNT_CBK] = RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK, +#else + [DBG_IO_ANT_RADIO_CMPLT_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ANT_RADIO_CMPLT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ANT_STACK_EVNT_CBK == 1) + [DBG_IO_ANT_STACK_EVNT_CBK] = RT_DEBUG_ANT_STACK_EVNT_CBK, +#else + [DBG_IO_ANT_STACK_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ANT_STACK_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK == 1) + [DBG_IO_ADV_EXT_PROCESS_TMOUT_EVNT_CBK] = RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK, +#else + [DBG_IO_ADV_EXT_PROCESS_TMOUT_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_PROCESS_TMOUT_EVNT_CBK */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT == 1) + [DBG_IO_ADV_EXT_MNGR_SCN_DUR_EVNT] = RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT, +#else + [DBG_IO_ADV_EXT_MNGR_SCN_DUR_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_DUR_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT == 1) + [DBG_IO_ADV_EXT_MNGR_SCN_PERIODIC_EVNT] = RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT, +#else + [DBG_IO_ADV_EXT_MNGR_SCN_PERIODIC_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_SCN_PERIODIC_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT == 1) + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT] = RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT, +#else + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_TMOUT_EVNT */ + +#if (USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT == 1) + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT] = RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT, +#else + [DBG_IO_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ADV_EXT_MNGR_PRDC_SCN_CNCEL_EVNT */ + +#if (USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK == 1) + [DBG_IO_BIS_MNGR_BIG_TERM_CBK] = RT_DEBUG_BIS_MNGR_BIG_TERM_CBK, +#else + [DBG_IO_BIS_MNGR_BIG_TERM_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_MNGR_BIG_TERM_CBK */ + +#if (USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK == 1) + [DBG_IO_BIS_MNGR_SYNC_TMOUT_CBK] = RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK, +#else + [DBG_IO_BIS_MNGR_SYNC_TMOUT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_BIS_MNGR_SYNC_TMOUT_CBK */ + +#if (USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN == 1) + [DBG_IO_ISOAL_MNGR_SDU_GEN] = RT_DEBUG_ISOAL_MNGR_SDU_GEN, +#else + [DBG_IO_ISOAL_MNGR_SDU_GEN] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISOAL_MNGR_SDU_GEN */ + +#if (USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK == 1) + [DBG_IO_ISO_MNGR_CIS_PROCESS_EVNT_CBK] = RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK, +#else + [DBG_IO_ISO_MNGR_CIS_PROCESS_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ISO_MNGR_CIS_PROCESS_EVNT_CBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK == 1) + [DBG_IO_CONN_MNGR_PROCESS_EVNT_CLBK] = RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK, +#else + [DBG_IO_CONN_MNGR_PROCESS_EVNT_CLBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_CONN_MNGR_PROCESS_EVNT_CLBK */ + +#if (USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK == 1) + [DBG_IO_CONN_MNGR_UPDT_CONN_PARAM_CBK] = RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK, +#else + [DBG_IO_CONN_MNGR_UPDT_CONN_PARAM_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_CONN_MNGR_UPDT_CONN_PARAM_CBK */ + +#if (USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT == 1) + [DBG_IO_EVNT_SCHDLR_HW_EVNT_CMPLT] = RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT, +#else + [DBG_IO_EVNT_SCHDLR_HW_EVNT_CMPLT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_EVNT_SCHDLR_HW_EVNT_CMPLT */ + +#if (USE_RT_DEBUG_HCI_EVENT_HNDLR == 1) + [DBG_IO_HCI_EVENT_HNDLR] = RT_DEBUG_HCI_EVENT_HNDLR, +#else + [DBG_IO_HCI_EVENT_HNDLR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_HCI_EVENT_HNDLR */ + +#if (USE_RT_DEBUG_MLME_TMRS_CBK == 1) + [DBG_IO_MLME_TMRS_CBK] = RT_DEBUG_MLME_TMRS_CBK, +#else + [DBG_IO_MLME_TMRS_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MLME_TMRS_CBK */ + +#if (USE_RT_DEBUG_DIRECT_TX_EVNT_CBK == 1) + [DBG_IO_DIRECT_TX_EVNT_CBK] = RT_DEBUG_DIRECT_TX_EVNT_CBK, +#else + [DBG_IO_DIRECT_TX_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_DIRECT_TX_EVNT_CBK */ + +#if (USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK == 1) + [DBG_IO_INDIRECT_PKT_TOUR_CBK] = RT_DEBUG_INDIRECT_PKT_TOUR_CBK, +#else + [DBG_IO_INDIRECT_PKT_TOUR_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_INDIRECT_PKT_TOUR_CBK */ + +#if (USE_RT_DEBUG_RADIO_CSMA_TMR == 1) + [DBG_IO_RADIO_CSMA_TMR] = RT_DEBUG_RADIO_CSMA_TMR, +#else + [DBG_IO_RADIO_CSMA_TMR] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_CSMA_TMR */ + +#if (USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK == 1) + [DBG_IO_RAL_SM_DONE_EVNT_CBK] = RT_DEBUG_RAL_SM_DONE_EVNT_CBK, +#else + [DBG_IO_RAL_SM_DONE_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_SM_DONE_EVNT_CBK */ + +#if (USE_RT_DEBUG_ED_TMR_HNDL == 1) + [DBG_IO_ED_TMR_HNDL] = RT_DEBUG_ED_TMR_HNDL, +#else + [DBG_IO_ED_TMR_HNDL] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_ED_TMR_HNDL */ + +#if (USE_RT_DEBUG_OS_TMR_EVNT_CBK == 1) + [DBG_IO_OS_TMR_EVNT_CBK] = RT_DEBUG_OS_TMR_EVNT_CBK, +#else + [DBG_IO_OS_TMR_EVNT_CBK] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_OS_TMR_EVNT_CBK */ + +#if (USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME == 1) + [DBG_IO_PROFILE_MARKER_PHY_WAKEUP_TIME] = RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME, +#else + [DBG_IO_PROFILE_MARKER_PHY_WAKEUP_TIME] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROFILE_MARKER_PHY_WAKEUP_TIME */ + +#if (USE_RT_DEBUG_PROFILE_END_DRIFT_TIME == 1) + [DBG_IO_PROFILE_END_DRIFT_TIME] = RT_DEBUG_PROFILE_END_DRIFT_TIME, +#else + [DBG_IO_PROFILE_END_DRIFT_TIME] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROFILE_END_DRIFT_TIME */ + +#if (USE_RT_DEBUG_PROC_RADIO_RCV == 1) + [DBG_IO_PROC_RADIO_RCV] = RT_DEBUG_PROC_RADIO_RCV, +#else + [DBG_IO_PROC_RADIO_RCV] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROC_RADIO_RCV */ + +#if (USE_RT_DEBUG_EVNT_TIME_UPDT == 1) + [DBG_IO_EVNT_TIME_UPDT] = RT_DEBUG_EVNT_TIME_UPDT, +#else + [DBG_IO_EVNT_TIME_UPDT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_EVNT_TIME_UPDT */ + +#if (USE_RT_DEBUG_MAC_RECEIVE_DONE == 1) + [DBG_IO_MAC_RECEIVE_DONE] = RT_DEBUG_MAC_RECEIVE_DONE, +#else + [DBG_IO_MAC_RECEIVE_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MAC_RECEIVE_DONE */ + +#if (USE_RT_DEBUG_MAC_TX_DONE == 1) + [DBG_IO_MAC_TX_DONE] = RT_DEBUG_MAC_TX_DONE, +#else + [DBG_IO_MAC_TX_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_MAC_TX_DONE */ + +#if (USE_RT_DEBUG_RADIO_APPLY_CSMA == 1) + [DBG_IO_RADIO_APPLY_CSMA] = RT_DEBUG_RADIO_APPLY_CSMA, +#else + [DBG_IO_RADIO_APPLY_CSMA] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_APPLY_CSMA */ + +#if (USE_RT_DEBUG_RADIO_TRANSMIT == 1) + [DBG_IO_RADIO_TRANSMIT] = RT_DEBUG_RADIO_TRANSMIT, +#else + [DBG_IO_RADIO_TRANSMIT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RADIO_TRANSMIT */ + +#if (USE_RT_DEBUG_PROC_RADIO_TX == 1) + [DBG_IO_PROC_RADIO_TX] = RT_DEBUG_PROC_RADIO_TX, +#else + [DBG_IO_PROC_RADIO_TX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_PROC_RADIO_TX */ + +#if (USE_RT_DEBUG_RAL_TX_DONE == 1) + [DBG_IO_RAL_TX_DONE] = RT_DEBUG_RAL_TX_DONE, +#else + [DBG_IO_RAL_TX_DONE] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_TX_DONE */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT == 1) + [DBG_IO_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT] = RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT, +#else + [DBG_IO_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_INCREMENT_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT == 1) + [DBG_IO_RAL_TX_DONE_RST_BACKOFF_COUNT] = RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT, +#else + [DBG_IO_RAL_TX_DONE_RST_BACKOFF_COUNT] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_TX_DONE_RST_BACKOFF_COUNT */ + +#if (USE_RT_DEBUG_RAL_CONTINUE_RX == 1) + [DBG_IO_RAL_CONTINUE_RX] = RT_DEBUG_RAL_CONTINUE_RX, +#else + [DBG_IO_RAL_CONTINUE_RX] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_CONTINUE_RX */ + +#if (USE_RT_DEBUG_RAL_PERFORM_CCA == 1) + [DBG_IO_RAL_PERFORM_CCA] = RT_DEBUG_RAL_PERFORM_CCA, +#else + [DBG_IO_RAL_PERFORM_CCA] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_PERFORM_CCA */ + +#if (USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER == 1) + [DBG_IO_RAL_ENABLE_TRANSMITTER] = RT_DEBUG_RAL_ENABLE_TRANSMITTER, +#else + [DBG_IO_RAL_ENABLE_TRANSMITTER] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_RAL_ENABLE_TRANSMITTER */ + +#if (USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 == 1) + [DBG_IO_LLHWC_GET_CH_IDX_ALGO_2] = RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2, +#else + [DBG_IO_LLHWC_GET_CH_IDX_ALGO_2] = RT_DEBUG_SIGNAL_UNUSED, +#endif /* USE_RT_DEBUG_LLHWC_GET_CH_IDX_ALGO_2 */ +}; + +#endif /* CFG_RT_DEBUG_GPIO_MODULE */ + +#endif /* LOCAL_DEBUG_TABLES_H*/ diff --git a/soc/st/stm32/stm32wbax/hci_if/bleplat.c b/soc/st/stm32/stm32wbax/hci_if/bleplat.c index 12de3b8f4b5ec..bd61b6068b8be 100644 --- a/soc/st/stm32/stm32wbax/hci_if/bleplat.c +++ b/soc/st/stm32/stm32wbax/hci_if/bleplat.c @@ -15,6 +15,9 @@ #include "bleplat.h" #include "bpka.h" #include "linklayer_plat.h" +#if(CFG_RT_DEBUG_DTB == 1) +#include "RTDebug_dtb.h" +#endif /* CFG_RT_DEBUG_DTB */ #define LOG_LEVEL CONFIG_SOC_LOG_LEVEL LOG_MODULE_REGISTER(ble_plat); @@ -30,6 +33,12 @@ struct entropy_stm32_rng_dev_cfg { struct stm32_pclken *pclken; }; +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) +extern void RT_DEBUG_GPIO_Init(void); +#endif /* (CFG_RT_DEBUG_GPIO_MODULE == 1) */ + + + void BLEPLAT_Init(void) { BPKA_Reset(); @@ -38,6 +47,15 @@ void BLEPLAT_Init(void) if (!device_is_ready(rng_dev)) { LOG_ERR("error: random device not ready"); } +#if(CFG_RT_DEBUG_DTB == 1) + /* DTB initialization and configuration */ + RT_DEBUG_DTBInit(); + RT_DEBUG_DTBConfig(); +#endif /* CFG_RT_DEBUG_DTB */ +#if(CFG_RT_DEBUG_GPIO_MODULE == 1) + /* RT DEBUG GPIO_Init */ + RT_DEBUG_GPIO_Init(); +#endif /* (CFG_RT_DEBUG_GPIO_MODULE == 1) */ } void BLEPLAT_RngGet(uint8_t n, uint32_t *val) diff --git a/west.yml b/west.yml index 91d959de4fba7..39ca04e29e2c3 100644 --- a/west.yml +++ b/west.yml @@ -245,7 +245,7 @@ manifest: groups: - hal - name: hal_stm32 - revision: 126cbbee19208b7aaca5ad8b287cf104e8bc837a + revision: pull/296/HEAD path: modules/hal/stm32 groups: - hal