diff --git a/include/zephyr/drivers/gpio.h b/include/zephyr/drivers/gpio.h index 4473b49eab6fc..cfe89b1eef7f4 100644 --- a/include/zephyr/drivers/gpio.h +++ b/include/zephyr/drivers/gpio.h @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -550,7 +551,7 @@ struct gpio_dt_spec { * .ngpios = 32, * .gpios_reserved = 0xdeadbeef, * // 0b1101 1110 1010 1101 1011 1110 1110 1111 - * + * }; * static const struct some_config dev_cfg_b = { * .ngpios = 18, * .gpios_reserved = 0xfffc0418, @@ -875,8 +876,12 @@ static inline int z_impl_gpio_pin_interrupt_configure(const struct device *port, (const struct gpio_driver_data *)port->data; enum gpio_int_trig trig; enum gpio_int_mode mode; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, interrupt_configure, port, pin, flags); if (api->pin_interrupt_configure == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, interrupt_configure, port, pin, -ENOSYS); return -ENOSYS; } @@ -921,7 +926,9 @@ static inline int z_impl_gpio_pin_interrupt_configure(const struct device *port, mode = (enum gpio_int_mode)(flags & (GPIO_INT_EDGE | GPIO_INT_DISABLE | GPIO_INT_ENABLE)); #endif /* CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT */ - return api->pin_interrupt_configure(port, pin, mode, trig); + ret = api->pin_interrupt_configure(port, pin, mode, trig); + SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, interrupt_configure, port, pin, ret); + return ret; } /** @@ -972,6 +979,9 @@ static inline int z_impl_gpio_pin_configure(const struct device *port, (const struct gpio_driver_config *)port->config; struct gpio_driver_data *data = (struct gpio_driver_data *)port->data; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, configure, port, pin, flags); __ASSERT((flags & GPIO_INT_MASK) == 0, "Interrupt flags are not supported"); @@ -1011,7 +1021,9 @@ static inline int z_impl_gpio_pin_configure(const struct device *port, data->invert &= ~(gpio_port_pins_t)BIT(pin); } - return api->pin_configure(port, pin, flags); + ret = api->pin_configure(port, pin, flags); + SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, configure, port, pin, ret); + return ret; } /** @@ -1060,12 +1072,18 @@ static inline int z_impl_gpio_port_get_direction(const struct device *port, gpio gpio_port_pins_t *outputs) { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, get_direction, port, map, inputs, outputs); if (api->port_get_direction == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_direction, port, -ENOSYS); return -ENOSYS; } - return api->port_get_direction(port, map, inputs, outputs); + ret = api->port_get_direction(port, map, inputs, outputs); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_direction, port, ret); + return ret; } #endif /* CONFIG_GPIO_GET_DIRECTION */ @@ -1184,11 +1202,18 @@ static inline int z_impl_gpio_pin_get_config(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio_pin, get_config, port, pin, *flags); - if (api->pin_get_config == NULL) + if (api->pin_get_config == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, get_config, port, pin, -ENOSYS); return -ENOSYS; + } - return api->pin_get_config(port, pin, flags); + ret = api->pin_get_config(port, pin, flags); + SYS_PORT_TRACING_FUNC_EXIT(gpio_pin, get_config, port, pin, ret); + return ret; } #endif @@ -1230,13 +1255,16 @@ static inline int gpio_pin_get_config_dt(const struct gpio_dt_spec *spec, __syscall int gpio_port_get_raw(const struct device *port, gpio_port_value_t *value); -static inline int z_impl_gpio_port_get_raw(const struct device *port, - gpio_port_value_t *value) +static inline int z_impl_gpio_port_get_raw(const struct device *port, gpio_port_value_t *value) { - const struct gpio_driver_api *api = - (const struct gpio_driver_api *)port->api; + const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, get_raw, port, value); - return api->port_get_raw(port, value); + ret = api->port_get_raw(port, value); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, get_raw, port, ret); + return ret; } /** @@ -1299,8 +1327,13 @@ static inline int z_impl_gpio_port_set_masked_raw(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; - return api->port_set_masked_raw(port, mask, value); + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, set_masked_raw, port, mask, value); + + ret = api->port_set_masked_raw(port, mask, value); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, set_masked_raw, port, ret); + return ret; } /** @@ -1353,8 +1386,13 @@ static inline int z_impl_gpio_port_set_bits_raw(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; - return api->port_set_bits_raw(port, pins); + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, set_bits_raw, port, pins); + + ret = api->port_set_bits_raw(port, pins); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, set_bits_raw, port, ret); + return ret; } /** @@ -1391,8 +1429,13 @@ static inline int z_impl_gpio_port_clear_bits_raw(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; - return api->port_clear_bits_raw(port, pins); + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, clear_bits_raw, port, pins); + + ret = api->port_clear_bits_raw(port, pins); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, clear_bits_raw, port, ret); + return ret; } /** @@ -1429,8 +1472,13 @@ static inline int z_impl_gpio_port_toggle_bits(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; - return api->port_toggle_bits(port, pins); + SYS_PORT_TRACING_FUNC_ENTER(gpio_port, toggle_bits, port, pins); + + ret = api->port_toggle_bits(port, pins); + SYS_PORT_TRACING_FUNC_EXIT(gpio_port, toggle_bits, port, ret); + return ret; } /** @@ -1693,11 +1741,15 @@ static inline void gpio_init_callback(struct gpio_callback *callback, gpio_callback_handler_t handler, gpio_port_pins_t pin_mask) { + SYS_PORT_TRACING_FUNC_ENTER(gpio, init_callback, callback, handler, pin_mask); + __ASSERT(callback, "Callback pointer should not be NULL"); __ASSERT(handler, "Callback handler pointer should not be NULL"); callback->handler = handler; callback->pin_mask = pin_mask; + + SYS_PORT_TRACING_FUNC_EXIT(gpio, init_callback, callback); } /** @@ -1719,12 +1771,18 @@ static inline int gpio_add_callback(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio, add_callback, port, callback); if (api->manage_callback == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio, add_callback, port, -ENOSYS); return -ENOSYS; } - return api->manage_callback(port, callback, true); + ret = api->manage_callback(port, callback, true); + SYS_PORT_TRACING_FUNC_EXIT(gpio, add_callback, port, ret); + return ret; } /** @@ -1767,12 +1825,18 @@ static inline int gpio_remove_callback(const struct device *port, { const struct gpio_driver_api *api = (const struct gpio_driver_api *)port->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio, remove_callback, port, callback); if (api->manage_callback == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio, remove_callback, port, -ENOSYS); return -ENOSYS; } - return api->manage_callback(port, callback, false); + ret = api->manage_callback(port, callback, false); + SYS_PORT_TRACING_FUNC_EXIT(gpio, remove_callback, port, ret); + return ret; } /** @@ -1812,12 +1876,18 @@ static inline int z_impl_gpio_get_pending_int(const struct device *dev) { const struct gpio_driver_api *api = (const struct gpio_driver_api *)dev->api; + int ret; + + SYS_PORT_TRACING_FUNC_ENTER(gpio, get_pending_int, dev); if (api->get_pending_int == NULL) { + SYS_PORT_TRACING_FUNC_EXIT(gpio, get_pending_int, dev, -ENOSYS); return -ENOSYS; } - return api->get_pending_int(dev); + ret = api->get_pending_int(dev); + SYS_PORT_TRACING_FUNC_EXIT(gpio, get_pending_int, dev, ret); + return ret; } /** diff --git a/include/zephyr/drivers/gpio/gpio_utils.h b/include/zephyr/drivers/gpio/gpio_utils.h index 35e6f5bc4086c..3ee77f3457b88 100644 --- a/include/zephyr/drivers/gpio/gpio_utils.h +++ b/include/zephyr/drivers/gpio/gpio_utils.h @@ -16,6 +16,7 @@ #include #include #include +#include #ifdef __cplusplus extern "C" { @@ -92,10 +93,14 @@ static inline void gpio_fire_callbacks(sys_slist_t *list, { struct gpio_callback *cb, *tmp; + sys_port_trace_gpio_fire_callbacks_enter(list, port, pins); + SYS_SLIST_FOR_EACH_CONTAINER_SAFE(list, cb, tmp, node) { if (cb->pin_mask & pins) { __ASSERT(cb->handler, "No callback handler!"); + cb->handler(port, cb, cb->pin_mask & pins); + sys_port_trace_gpio_fire_callback(port, cb); } } } diff --git a/include/zephyr/tracing/tracing.h b/include/zephyr/tracing/tracing.h index feb69a74ad72d..13cefa7f15191 100644 --- a/include/zephyr/tracing/tracing.h +++ b/include/zephyr/tracing/tracing.h @@ -2394,6 +2394,219 @@ /** @} */ /* end of subsys_tracing_apis_named */ +/** + * @brief GPIO Tracing APIs + * @defgroup subsys_tracing_apis_gpio GPIO Tracing APIs + * @{ + */ + +/** + * @brief Trace GPIO pin interrupt configure enter call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number + * @param flags Interrupt configuration flags as defined by GPIO_INT_* + */ +#define sys_port_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) + +/** + * @brief Trace GPIO pin interrupt configure exit call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number + * @param ret Return value + */ +#define sys_port_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) + +/** + * @brief Trace GPIO single pin configure enter call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number to configure + * @param flags GPIO pin configuration flags + */ +#define sys_port_trace_gpio_pin_configure_enter(port, pin, flags) + +/** + * @brief Trace GPIO single pin configure exit call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number to configure + * @param ret Return value + */ +#define sys_port_trace_gpio_pin_configure_exit(port, pin, ret) + +/** + * @brief Trace GPIO port get direction enter call + * @param port Pointer to device structure for the driver instance + * @param map Bitmap of pin directions to query + * @param inputs Pointer to a variable where input directions will be stored + * @param outputs Pointer to a variable where output directions will be stored + */ +#define sys_port_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) + +/** + * @brief Trace GPIO port get direction exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_get_direction_exit(port, ret) + +/** + * @brief Trace GPIO pin gent config enter call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number to configure + * @param flags GPIO pin configuration flags + */ +#define sys_port_trace_gpio_pin_get_config_enter(port, pin, flags) + +/** + * @brief Trace GPIO pin get config exit call + * @param port Pointer to device structure for the driver instance + * @param pin GPIO pin number to configure + * @param ret Return value + */ +#define sys_port_trace_gpio_pin_get_config_exit(port, pin, ret) + +/** + * @brief Trace GPIO port get raw enter call + * @param port Pointer to device structure for the driver instance + * @param value Pointer to a variable where the raw value will be stored + */ +#define sys_port_trace_gpio_port_get_raw_enter(port, value) + +/** + * @brief Trace GPIO port get raw exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_get_raw_exit(port, ret) + +/** + * @brief Trace GPIO port set masked raw enter call + * @param port Pointer to device structure for the driver instance + * @param mask Mask indicating which pins will be modified + * @param value Value to be written to the output pins + */ +#define sys_port_trace_gpio_port_set_masked_raw_enter(port, mask, value) + +/** + * @brief Trace GPIO port set masked raw exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_set_masked_raw_exit(port, ret) + +/** + * @brief Trace GPIO port set bits raw enter call + * @param port Pointer to device structure for the driver instance + * @param pins Value indicating which pins will be modified + */ +#define sys_port_trace_gpio_port_set_bits_raw_enter(port, pins) + +/** + * @brief Trace GPIO port set bits raw exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_set_bits_raw_exit(port, ret) + +/** + * @brief Trace GPIO port clear bits raw enter call + * @param port Pointer to device structure for the driver instance + * @param pins Value indicating which pins will be modified + */ +#define sys_port_trace_gpio_port_clear_bits_raw_enter(port, pins) + +/** + * @brief Trace GPIO port clear bits raw exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_clear_bits_raw_exit(port, ret) + +/** + * @brief Trace GPIO port toggle bits enter call + * @param port Pointer to device structure for the driver instance + * @param pins Value indicating which pins will be modified + */ +#define sys_port_trace_gpio_port_toggle_bits_enter(port, pins) + +/** + * @brief Trace GPIO port toggle bits exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_port_toggle_bits_exit(port, ret) + +/** + * @brief Trace GPIO init callback enter call + * @param callback A valid application's callback structure pointer + * @param handler A valid handler function pointer + * @param pin_mask A bit mask of relevant pins for the handler + */ +#define sys_port_trace_gpio_init_callback_enter(callback, handler, pin_mask) + +/** + * @brief Trace GPIO init callback exit call + * @param callback A valid application's callback structure pointer + */ +#define sys_port_trace_gpio_init_callback_exit(callback) + +/** + * @brief Trace GPIO add callback enter call + * @param port Pointer to device structure for the driver instance + * @param callback A valid application's callback structure pointer + */ +#define sys_port_trace_gpio_add_callback_enter(port, callback) + +/** + * @brief Trace GPIO add callback exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_add_callback_exit(port, ret) + +/** + * @brief Trace GPIO remove callback enter call + * @param port Pointer to device structure for the driver instance + * @param callback A valid application's callback structure pointer + */ +#define sys_port_trace_gpio_remove_callback_enter(port, callback) + +/** + * @brief Trace GPIO remove callback exit call + * @param port Pointer to device structure for the driver instance + * @param ret Return value + */ +#define sys_port_trace_gpio_remove_callback_exit(port, ret) + +/** + * @brief Trace GPIO get pending interrupt enter call + * @param dev Pointer to the device structure for the device instance + */ +#define sys_port_trace_gpio_get_pending_int_enter(dev) + +/** + * @brief Trace GPIO get pending interrupt exit call + * @param dev Pointer to the device structure for the device instance + * @param ret Return value + */ +#define sys_port_trace_gpio_get_pending_int_exit(dev, ret) + +/** + * @brief + * @param list @ref sys_slist_t representing gpio_callback pointers + * @param port @ref device representing the GPIO port + * @param pins @ref gpio_pin_t representing the pins + */ +#define sys_port_trace_gpio_fire_callbacks_enter(list, port, pins) + +/** + * @brief + * @param port @ref device representing the GPIO port + * @param callback @ref gpio_callback a valid Application's callback structure pointer + */ +#define sys_port_trace_gpio_fire_callback(port, callback) + +/** @} */ /* end of subsys_tracing_apis_gpio */ + #if defined(CONFIG_PERCEPIO_TRACERECORDER) #include "tracing_tracerecorder.h" #else diff --git a/samples/subsys/tracing/CMakeLists.txt b/samples/subsys/tracing/CMakeLists.txt index b42587f68a186..518530b6713b4 100644 --- a/samples/subsys/tracing/CMakeLists.txt +++ b/samples/subsys/tracing/CMakeLists.txt @@ -10,4 +10,5 @@ find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) project(tracing_tests) target_sources(app PRIVATE src/main.c) +target_sources_ifdef(CONFIG_TRACING_GPIO app PRIVATE src/gpio_main.c) target_sources_ifdef(CONFIG_TRACING_USER app PRIVATE src/tracing_user.c) diff --git a/samples/subsys/tracing/README.rst b/samples/subsys/tracing/README.rst index 702eabb784f87..7a3ce8425d3f4 100644 --- a/samples/subsys/tracing/README.rst +++ b/samples/subsys/tracing/README.rst @@ -127,3 +127,17 @@ Build a SystemView-tracing image with the :ref:`snippet-rtt-tracing`: :compact: After the application has run for a while, check the trace output file. + +Usage for GPIO Tracing Backend +******************************* + +Build a GPIO-tracing image with: + +.. zephyr-app-commands:: + :zephyr-app: samples/subsys/tracing + :board: native_sim + :conf: "prj_gpio.conf" + :goals: build + :compact: + +After the application has run for a while, check the trace output file. diff --git a/samples/subsys/tracing/gpio.overlay b/samples/subsys/tracing/gpio.overlay new file mode 100644 index 0000000000000..2879430bab4ae --- /dev/null +++ b/samples/subsys/tracing/gpio.overlay @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2024 Tenstorrent AI ULC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/ { + gpio_emul: gpio_emul { + status = "okay"; + compatible = "zephyr,gpio-emul"; + rising-edge; + falling-edge; + high-level; + low-level; + gpio-controller; + #gpio-cells = < 0x2 >; + phandle = < 0x1 >; + }; +}; diff --git a/samples/subsys/tracing/prj_gpio.conf b/samples/subsys/tracing/prj_gpio.conf new file mode 100644 index 0000000000000..b6ea42a804b54 --- /dev/null +++ b/samples/subsys/tracing/prj_gpio.conf @@ -0,0 +1,10 @@ +CONFIG_GPIO=y +CONFIG_GPIO_GET_CONFIG=y +CONFIG_TRACING=y +CONFIG_TRACING_GPIO=y +CONFIG_TRACING_THREAD=n +CONFIG_GPIO_EMUL=y +CONFIG_TRACING_USER=y +CONFIG_TRACING_TEST=n +CONFIG_TRACING_CTF=n +CONFIG_SEGGER_SYSTEMVIEW=n diff --git a/samples/subsys/tracing/sample.yaml b/samples/subsys/tracing/sample.yaml index e7104292b2dcf..c6fb90b0160f5 100644 --- a/samples/subsys/tracing/sample.yaml +++ b/samples/subsys/tracing/sample.yaml @@ -76,3 +76,13 @@ tests: extra_args: CONF_FILE="prj_percepio.conf" modules: - percepio + sample.tracing.gpio: + depends_on: gpio + harness: ztest + harness_config: + fixture: gpio_loopback + extra_args: + - CONF_FILE="prj_gpio.conf" + - EXTRA_DTC_OVERLAY_FILE="gpio.overlay" + integration_platforms: + - native_sim diff --git a/samples/subsys/tracing/src/gpio_main.c b/samples/subsys/tracing/src/gpio_main.c new file mode 100644 index 0000000000000..f38943c0c4ef8 --- /dev/null +++ b/samples/subsys/tracing/src/gpio_main.c @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2024 Tenstorrent AI ULC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include + +/* size of stack area used by each thread */ +#define STACKSIZE (2048) + +/* scheduling priority used by each thread */ +#define PRIORITY 7 + +void test_handler(const struct device *port, struct gpio_callback *cb, gpio_port_pins_t pins) +{ + printk("Interrupt detected!\n"); +} + +void gpio_sample(void) +{ + const struct device *dev = DEVICE_DT_GET(DT_NODELABEL(gpio_emul)); + + if (!device_is_ready(dev)) { + printk("%s: device not ready.\n", dev->name); + return; + } + + /* Configure pin 0 as output and toggle */ + gpio_pin_configure(dev, 0, GPIO_OUTPUT); + gpio_pin_set(dev, 0, 1); + gpio_pin_set(dev, 0, 0); + + /* Configure pin 1 as input */ + gpio_pin_configure(dev, 1, GPIO_INPUT); + + /* Read pin 1 */ + gpio_emul_input_set(dev, 1, 1); + gpio_pin_get(dev, 1); + gpio_emul_input_set(dev, 1, 0); + gpio_pin_get(dev, 1); + + /* Setup pin 1 for interrupt */ + gpio_pin_interrupt_configure(dev, 1, GPIO_INT_EDGE_RISING); + static struct gpio_callback gpio_cb; + + gpio_init_callback(&gpio_cb, test_handler, BIT(1)); + gpio_add_callback(dev, &gpio_cb); + + /* Trigger interrupt */ + gpio_emul_input_set(dev, 1, 1); + + /* Remove interrupt */ + gpio_remove_callback(dev, &gpio_cb); +} + +static void gpio_thread(void *dummy1, void *dummy2, void *dummy3) +{ + ARG_UNUSED(dummy1); + ARG_UNUSED(dummy2); + ARG_UNUSED(dummy3); + + gpio_sample(); +} + +K_THREAD_DEFINE(thread_gpio, STACKSIZE, gpio_thread, NULL, NULL, NULL, PRIORITY, 0, 0); diff --git a/samples/subsys/tracing/src/main.c b/samples/subsys/tracing/src/main.c index 27a91d00f55a8..cc3a25fc1e0d2 100644 --- a/samples/subsys/tracing/src/main.c +++ b/samples/subsys/tracing/src/main.c @@ -9,6 +9,7 @@ #include #include #include +#include /* * The hello world demo has two threads that utilize semaphores and sleeping diff --git a/samples/subsys/tracing/src/tracing_user.c b/samples/subsys/tracing/src/tracing_user.c index 7f9370c5d2aad..37c27be594887 100644 --- a/samples/subsys/tracing/src/tracing_user.c +++ b/samples/subsys/tracing/src/tracing_user.c @@ -5,6 +5,8 @@ */ #include +#include +#include static int nested_interrupts[CONFIG_MP_MAX_NUM_CPUS]; @@ -56,3 +58,46 @@ void sys_trace_idle_user(void) { printk("%s\n", __func__); } + +void sys_trace_gpio_pin_configure_enter_user(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + printk("port: %s, pin: %d flags: %d\n", port->name, pin, flags); +} + +void sys_trace_gpio_pin_configure_exit_user(const struct device *port, gpio_pin_t pin, int ret) +{ + printk("port: %s, pin: %d ret: %d\n", port->name, pin, ret); +} + +void sys_trace_gpio_port_set_bits_raw_enter_user(const struct device *port, gpio_port_pins_t pins) +{ + printk("port: %s, pins: %d\n", port->name, pins); +} + +void sys_trace_gpio_port_set_bits_raw_exit_user(const struct device *port, int ret) +{ + printk("port: %s, ret: %d\n", port->name, ret); +} + +void sys_trace_gpio_port_clear_bits_raw_enter_user(const struct device *port, gpio_port_pins_t pins) +{ + printk("port: %s, pins: %d\n", port->name, pins); +} + +void sys_trace_gpio_port_clear_bits_raw_exit_user(const struct device *port, int ret) +{ + printk("port: %s, pins: %d\n", port->name, ret); +} + +void sys_trace_gpio_pin_interrupt_configure_enter_user(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + printk("port: %s, pin: %d flags: %d\n", port->name, pin, flags); +} + +void sys_trace_gpio_pin_interrupt_configure_exit_user(const struct device *port, gpio_pin_t pin, + int ret) +{ + printk("port: %s, pin: %d ret: %d\n", port->name, pin, ret); +} diff --git a/subsys/tracing/Kconfig b/subsys/tracing/Kconfig index 4e9abb0515ac2..30be8d5955bbe 100644 --- a/subsys/tracing/Kconfig +++ b/subsys/tracing/Kconfig @@ -349,6 +349,12 @@ config TRACING_NET_CORE Enable tracing core network IP stack, like packet reception and sending. +config TRACING_GPIO + bool "Tracing GPIO" + default n + help + Enable tracing GPIO. + endmenu # Tracing Configuration endif diff --git a/subsys/tracing/ctf/ctf_top.c b/subsys/tracing/ctf/ctf_top.c index 319ead9134e5e..e65acfa8a96f2 100644 --- a/subsys/tracing/ctf/ctf_top.c +++ b/subsys/tracing/ctf/ctf_top.c @@ -757,3 +757,165 @@ void sys_trace_named_event(const char *name, uint32_t arg0, uint32_t arg1) ctf_named_event(ctf_name, arg0, arg1); } + +/* GPIO */ +void sys_port_trace_gpio_pin_interrupt_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + ctf_top_gpio_pin_interrupt_configure_enter((uint32_t)(uintptr_t)port, (uint32_t)pin, + (uint32_t)flags); +} + +void sys_port_trace_gpio_pin_interrupt_configure_exit(const struct device *port, gpio_pin_t pin, + int ret) +{ + ctf_top_gpio_pin_interrupt_configure_exit((uint32_t)(uintptr_t)port, (uint32_t)pin, + (int32_t)ret); +} + +void sys_port_trace_gpio_pin_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + ctf_top_gpio_pin_configure_enter((uint32_t)(uintptr_t)port, (uint32_t)pin, (uint32_t)flags); +} + +void sys_port_trace_gpio_pin_configure_exit(const struct device *port, gpio_pin_t pin, int ret) +{ + ctf_top_gpio_pin_configure_exit((uint32_t)(uintptr_t)port, (uint32_t)pin, (int32_t)ret); +} + +void sys_port_trace_gpio_port_get_direction_enter(const struct device *port, gpio_port_pins_t map, + gpio_port_pins_t *inputs, + gpio_port_pins_t *outputs) +{ + ctf_top_gpio_port_get_direction_enter((uint32_t)(uintptr_t)port, (uint32_t)map, + (uint32_t)(uintptr_t)inputs, + (uint32_t)(uintptr_t)outputs); +} + +void sys_port_trace_gpio_port_get_direction_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_get_direction_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_pin_get_config_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + ctf_top_gpio_pin_get_config_enter((uint32_t)(uintptr_t)port, (uint32_t)pin, + (uint32_t)flags); +} + +void sys_port_trace_gpio_pin_get_config_exit(const struct device *port, gpio_pin_t pin, int ret) +{ + ctf_top_gpio_pin_get_config_exit((uint32_t)(uintptr_t)port, (uint32_t)pin, (int32_t)ret); +} + +void sys_port_trace_gpio_port_get_raw_enter(const struct device *port, gpio_port_value_t *value) +{ + ctf_top_gpio_port_get_raw_enter((uint32_t)(uintptr_t)port, (uint32_t)(uintptr_t)value); +} + +void sys_port_trace_gpio_port_get_raw_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_get_raw_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_port_set_masked_raw_enter(const struct device *port, gpio_port_pins_t mask, + gpio_port_value_t value) +{ + ctf_top_gpio_port_set_masked_raw_enter((uint32_t)(uintptr_t)port, (uint32_t)mask, + (uint32_t)value); +} + +void sys_port_trace_gpio_port_set_masked_raw_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_set_masked_raw_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_port_set_bits_raw_enter(const struct device *port, gpio_port_pins_t pins) +{ + ctf_top_gpio_port_set_bits_raw_enter((uint32_t)(uintptr_t)port, (uint32_t)pins); +} + +void sys_port_trace_gpio_port_set_bits_raw_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_set_bits_raw_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_port_clear_bits_raw_enter(const struct device *port, gpio_port_pins_t pins) +{ + ctf_top_gpio_port_clear_bits_raw_enter((uint32_t)(uintptr_t)port, (uint32_t)pins); +} + +void sys_port_trace_gpio_port_clear_bits_raw_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_clear_bits_raw_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_port_toggle_bits_enter(const struct device *port, gpio_port_pins_t pins) +{ + ctf_top_gpio_port_toggle_bits_enter((uint32_t)(uintptr_t)port, (uint32_t)pins); +} + +void sys_port_trace_gpio_port_toggle_bits_exit(const struct device *port, int ret) +{ + ctf_top_gpio_port_toggle_bits_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_init_callback_enter(struct gpio_callback *callback, + gpio_callback_handler_t handler, + gpio_port_pins_t pin_mask) +{ + ctf_top_gpio_init_callback_enter((uint32_t)(uintptr_t)callback, + (uint32_t)(uintptr_t)handler, (uint32_t)pin_mask); +} + +void sys_port_trace_gpio_init_callback_exit(struct gpio_callback *callback) +{ + ctf_top_gpio_init_callback_exit((uint32_t)(uintptr_t)callback); +} + +void sys_port_trace_gpio_add_callback_enter(const struct device *port, + struct gpio_callback *callback) +{ + ctf_top_gpio_add_callback_enter((uint32_t)(uintptr_t)port, (uint32_t)(uintptr_t)callback); +} + +void sys_port_trace_gpio_add_callback_exit(const struct device *port, int ret) +{ + ctf_top_gpio_add_callback_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_remove_callback_enter(const struct device *port, + struct gpio_callback *callback) +{ + ctf_top_gpio_remove_callback_enter((uint32_t)(uintptr_t)port, + (uint32_t)(uintptr_t)callback); +} + +void sys_port_trace_gpio_remove_callback_exit(const struct device *port, int ret) +{ + ctf_top_gpio_remove_callback_exit((uint32_t)(uintptr_t)port, (int32_t)ret); +} + +void sys_port_trace_gpio_get_pending_int_enter(const struct device *dev) +{ + ctf_top_gpio_get_pending_int_enter((uint32_t)(uintptr_t)dev); +} + +void sys_port_trace_gpio_get_pending_int_exit(const struct device *dev, int ret) +{ + ctf_top_gpio_get_pending_int_exit((uint32_t)(uintptr_t)dev, (int32_t)ret); +} + +void sys_port_trace_gpio_fire_callbacks_enter(sys_slist_t *list, const struct device *port, + gpio_port_pins_t pins) +{ + ctf_top_gpio_fire_callbacks_enter((uint32_t)(uintptr_t)list, (uint32_t)(uintptr_t)port, + (uint32_t)pins); +} + +void sys_port_trace_gpio_fire_callback(const struct device *port, struct gpio_callback *cb) +{ + ctf_top_gpio_fire_callback((uint32_t)(uintptr_t)port, (uint32_t)(uintptr_t)cb); +} diff --git a/subsys/tracing/ctf/ctf_top.h b/subsys/tracing/ctf/ctf_top.h index b8e677ba8bb3b..725602d41a9e4 100644 --- a/subsys/tracing/ctf/ctf_top.h +++ b/subsys/tracing/ctf/ctf_top.h @@ -158,7 +158,34 @@ typedef enum { CTF_EVENT_NET_RX_TIME = 0x60, CTF_EVENT_NET_TX_TIME = 0x61, CTF_EVENT_NAMED_EVENT = 0x62, - + CTF_EVENT_GPIO_PIN_CONFIGURE_INTERRUPT_ENTER = 0x63, + CTF_EVENT_GPIO_PIN_CONFIGURE_INTERRUPT_EXIT = 0x64, + CTF_EVENT_GPIO_PIN_CONFIGURE_ENTER = 0x65, + CTF_EVENT_GPIO_PIN_CONFIGURE_EXIT = 0x66, + CTF_EVENT_GPIO_PORT_GET_DIRECTION_ENTER = 0x67, + CTF_EVENT_GPIO_PORT_GET_DIRECTION_EXIT = 0x68, + CTF_EVENT_GPIO_PIN_GET_CONFIG_ENTER = 0x69, + CTF_EVENT_GPIO_PIN_GET_CONFIG_EXIT = 0x6A, + CTF_EVENT_GPIO_PORT_GET_RAW_ENTER = 0x6B, + CTF_EVENT_GPIO_PORT_GET_RAW_EXIT = 0x6C, + CTF_EVENT_GPIO_PORT_SET_MASKED_RAW_ENTER = 0x6D, + CTF_EVENT_GPIO_PORT_SET_MASKED_RAW_EXIT = 0x6E, + CTF_EVENT_GPIO_PORT_SET_BITS_RAW_ENTER = 0x6F, + CTF_EVENT_GPIO_PORT_SET_BITS_RAW_EXIT = 0x70, + CTF_EVENT_GPIO_PORT_CLEAR_BITS_RAW_ENTER = 0x71, + CTF_EVENT_GPIO_PORT_CLEAR_BITS_RAW_EXIT = 0x72, + CTF_EVENT_GPIO_PORT_TOGGLE_BITS_ENTER = 0x73, + CTF_EVENT_GPIO_PORT_TOGGLE_BITS_EXIT = 0x74, + CTF_EVENT_GPIO_INIT_CALLBACK_ENTER = 0x75, + CTF_EVENT_GPIO_INIT_CALLBACK_EXIT = 0x76, + CTF_EVENT_GPIO_ADD_CALLBACK_ENTER = 0x77, + CTF_EVENT_GPIO_ADD_CALLBACK_EXIT = 0x78, + CTF_EVENT_GPIO_REMOVE_CALLBACK_ENTER = 0x79, + CTF_EVENT_GPIO_REMOVE_CALLBACK_EXIT = 0x7A, + CTF_EVENT_GPIO_GET_PENDING_INT_ENTER = 0x7B, + CTF_EVENT_GPIO_GET_PENDING_INT_EXIT = 0x7C, + CTF_EVENT_GPIO_FIRE_CALLBACKS_ENTER = 0x7D, + CTF_EVENT_GPIO_FIRE_CALLBACK = 0x7E, } ctf_event_t; typedef struct { @@ -616,7 +643,6 @@ static inline void ctf_top_socket_socketpair_exit(int32_t sock_A, int32_t sock_B CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_SOCKET_SOCKETPAIR_EXIT), sock_A, sock_B, ret); } - static inline void ctf_top_net_recv_data_enter(int32_t if_index, uint32_t iface, uint32_t pkt, uint32_t len) { @@ -666,4 +692,155 @@ static inline void ctf_named_event(ctf_bounded_string_t name, uint32_t arg0, arg0, arg1); } +/* GPIO */ +static inline void ctf_top_gpio_pin_interrupt_configure_enter(uint32_t port, uint32_t pin, + uint32_t flags) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_CONFIGURE_INTERRUPT_ENTER), port, pin, + flags); +} + +static inline void ctf_top_gpio_pin_interrupt_configure_exit(uint32_t port, uint32_t pin, + int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_CONFIGURE_INTERRUPT_EXIT), port, pin, + ret); +} + +static inline void ctf_top_gpio_pin_configure_enter(uint32_t port, uint32_t pin, uint32_t flags) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_CONFIGURE_ENTER), port, pin, flags); +} + +static inline void ctf_top_gpio_pin_configure_exit(uint32_t port, uint32_t pin, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_CONFIGURE_EXIT), port, pin, ret); +} + +static inline void ctf_top_gpio_port_get_direction_enter(uint32_t port, uint32_t map, + uint32_t inputs, uint32_t outputs) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_GET_DIRECTION_ENTER), port, map, inputs, + outputs); +} + +static inline void ctf_top_gpio_port_get_direction_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_GET_DIRECTION_EXIT), port, ret); +} + +static inline void ctf_top_gpio_pin_get_config_enter(uint32_t port, uint32_t pin, uint32_t flags) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_GET_CONFIG_ENTER), port, pin, flags); +} + +static inline void ctf_top_gpio_pin_get_config_exit(uint32_t port, uint32_t pin, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PIN_GET_CONFIG_EXIT), port, pin, ret); +} + +static inline void ctf_top_gpio_port_get_raw_enter(uint32_t port, uint32_t value) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_GET_RAW_ENTER), port, value); +} + +static inline void ctf_top_gpio_port_get_raw_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_GET_RAW_EXIT), port, ret); +} + +static inline void ctf_top_gpio_port_set_masked_raw_enter(uint32_t port, uint32_t mask, + uint32_t value) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_SET_MASKED_RAW_ENTER), port, mask, + value); +} + +static inline void ctf_top_gpio_port_set_masked_raw_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_SET_MASKED_RAW_EXIT), port, ret); +} + +static inline void ctf_top_gpio_port_set_bits_raw_enter(uint32_t port, uint32_t pins) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_SET_BITS_RAW_ENTER), port, pins); +} + +static inline void ctf_top_gpio_port_set_bits_raw_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_SET_BITS_RAW_EXIT), port, ret); +} + +static inline void ctf_top_gpio_port_clear_bits_raw_enter(uint32_t port, uint32_t pins) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_CLEAR_BITS_RAW_ENTER), port, pins); +} + +static inline void ctf_top_gpio_port_clear_bits_raw_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_CLEAR_BITS_RAW_EXIT), port, ret); +} + +static inline void ctf_top_gpio_port_toggle_bits_enter(uint32_t port, uint32_t pins) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_TOGGLE_BITS_ENTER), port, pins); +} + +static inline void ctf_top_gpio_port_toggle_bits_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_PORT_TOGGLE_BITS_EXIT), port, ret); +} + +static inline void ctf_top_gpio_init_callback_enter(uint32_t callback, uint32_t handler, + uint32_t pin_mask) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_INIT_CALLBACK_ENTER), callback, handler, + pin_mask); +} + +static inline void ctf_top_gpio_init_callback_exit(uint32_t callback) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_INIT_CALLBACK_EXIT), callback); +} + +static inline void ctf_top_gpio_add_callback_enter(uint32_t port, uint32_t callback) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_ADD_CALLBACK_ENTER), port, callback); +} + +static inline void ctf_top_gpio_add_callback_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_ADD_CALLBACK_EXIT), port, ret); +} + +static inline void ctf_top_gpio_remove_callback_enter(uint32_t port, uint32_t callback) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_REMOVE_CALLBACK_ENTER), port, callback); +} + +static inline void ctf_top_gpio_remove_callback_exit(uint32_t port, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_REMOVE_CALLBACK_EXIT), port, ret); +} + +static inline void ctf_top_gpio_get_pending_int_enter(uint32_t dev) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_GET_PENDING_INT_ENTER), dev); +} + +static inline void ctf_top_gpio_get_pending_int_exit(uint32_t dev, int32_t ret) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_GET_PENDING_INT_EXIT), dev, ret); +} + +static inline void ctf_top_gpio_fire_callbacks_enter(uint32_t list, uint32_t port, uint32_t pins) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_FIRE_CALLBACKS_ENTER), list, port, pins); +} + +static inline void ctf_top_gpio_fire_callback(uint32_t port, uint32_t cb) +{ + CTF_EVENT(CTF_LITERAL(uint8_t, CTF_EVENT_GPIO_FIRE_CALLBACK), port, cb); +} + #endif /* SUBSYS_DEBUG_TRACING_CTF_TOP_H */ diff --git a/subsys/tracing/ctf/tracing_ctf.h b/subsys/tracing/ctf/tracing_ctf.h index ae62d7bf9bc88..99f11c05913af 100644 --- a/subsys/tracing/ctf/tracing_ctf.h +++ b/subsys/tracing/ctf/tracing_ctf.h @@ -174,7 +174,6 @@ extern "C" { #define sys_port_trace_k_timer_status_sync_exit(timer, result) \ sys_trace_k_timer_status_sync_exit(timer, result) - #define sys_port_trace_k_condvar_init(condvar, ret) #define sys_port_trace_k_condvar_signal_enter(condvar) #define sys_port_trace_k_condvar_signal_blocking(condvar, timeout) @@ -594,6 +593,105 @@ void sys_trace_net_tx_time(struct net_pkt *pkt, uint32_t end_time); void sys_trace_named_event(const char *name, uint32_t arg0, uint32_t arg1); +/* GPIO */ +struct gpio_callback; +typedef uint8_t gpio_pin_t; +typedef uint32_t gpio_port_pins_t; +typedef uint32_t gpio_flags_t; +typedef uint32_t gpio_port_value_t; +typedef void (*gpio_callback_handler_t)(const struct device *port, struct gpio_callback *cb, + gpio_port_pins_t pins); + +void sys_trace_gpio_pin_interrupt_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags); +void sys_trace_gpio_pin_interrupt_configure_exit(const struct device *port, gpio_pin_t pin, + int ret); +void sys_trace_gpio_pin_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags); +void sys_trace_gpio_pin_configure_exit(const struct device *port, gpio_pin_t pin, int ret); +void sys_trace_gpio_port_get_direction_enter(const struct device *port, gpio_port_pins_t map, + gpio_port_pins_t *inputs, gpio_port_pins_t *outputs); +void sys_trace_gpio_port_get_direction_exit(const struct device *port, int ret); +void sys_trace_gpio_pin_get_config_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags); +void sys_trace_gpio_pin_get_config_exit(const struct device *port, gpio_pin_t pin, int ret); +void sys_trace_gpio_port_get_raw_enter(const struct device *port, gpio_port_value_t *value); +void sys_trace_gpio_port_get_raw_exit(const struct device *port, int ret); +void sys_trace_gpio_port_set_masked_raw_enter(const struct device *port, gpio_port_pins_t mask, + gpio_port_value_t value); +void sys_trace_gpio_port_set_masked_raw_exit(const struct device *port, int ret); +void sys_trace_gpio_port_set_bits_raw_enter(const struct device *port, gpio_port_pins_t pins); +void sys_trace_gpio_port_set_bits_raw_exit(const struct device *port, int ret); +void sys_trace_gpio_port_clear_bits_raw_enter(const struct device *port, gpio_port_pins_t pins); +void sys_trace_gpio_port_clear_bits_raw_exit(const struct device *port, int ret); +void sys_trace_gpio_port_toggle_bits_enter(const struct device *port, gpio_port_pins_t pins); +void sys_trace_gpio_port_toggle_bits_exit(const struct device *port, int ret); +void sys_trace_gpio_init_callback_enter(struct gpio_callback *callback, + gpio_callback_handler_t handler, gpio_port_pins_t pin_mask); +void sys_trace_gpio_init_callback_exit(struct gpio_callback *callback); +void sys_trace_gpio_add_callback_enter(const struct device *port, struct gpio_callback *callback); +void sys_trace_gpio_add_callback_exit(const struct device *port, int ret); +void sys_trace_gpio_remove_callback_enter(const struct device *port, + struct gpio_callback *callback); +void sys_trace_gpio_remove_callback_exit(const struct device *port, int ret); +void sys_trace_gpio_get_pending_int_enter(const struct device *dev); +void sys_trace_gpio_get_pending_int_exit(const struct device *dev, int ret); +void sys_trace_gpio_fire_callbacks_enter(sys_slist_t *list, const struct device *port, + gpio_port_pins_t pins); +void sys_trace_gpio_fire_callback(const struct device *port, struct gpio_callback *callback); + +#define sys_port_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) \ + sys_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) \ + sys_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_pin_configure_enter(port, pin, flags) \ + sys_trace_gpio_pin_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_configure_exit(port, pin, ret) \ + sys_trace_gpio_pin_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) \ + sys_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) +#define sys_port_trace_gpio_port_get_direction_exit(port, ret) \ + sys_trace_gpio_port_get_direction_exit(port, ret) +#define sys_port_trace_gpio_pin_get_config_enter(port, pin, flags) \ + sys_trace_gpio_pin_get_config_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_get_config_exit(port, pin, ret) \ + sys_trace_gpio_pin_get_config_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_raw_enter(port, value) \ + sys_trace_gpio_port_get_raw_enter(port, value) +#define sys_port_trace_gpio_port_get_raw_exit(port, ret) sys_trace_gpio_port_get_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_masked_raw_enter(port, mask, value) \ + sys_trace_gpio_port_set_masked_raw_enter(port, mask, value) +#define sys_port_trace_gpio_port_set_masked_raw_exit(port, ret) \ + sys_trace_gpio_port_set_masked_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_bits_raw_enter(port, pins) \ + sys_trace_gpio_port_set_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_set_bits_raw_exit(port, ret) \ + sys_trace_gpio_port_set_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_clear_bits_raw_enter(port, pins) \ + sys_trace_gpio_port_clear_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_clear_bits_raw_exit(port, ret) \ + sys_trace_gpio_port_clear_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_toggle_bits_enter(port, pins) \ + sys_trace_gpio_port_toggle_bits_enter(port, pins) +#define sys_port_trace_gpio_port_toggle_bits_exit(port, ret) \ + sys_trace_gpio_port_toggle_bits_exit(port, ret) +#define sys_port_trace_gpio_init_callback_enter(callback, handler, pin_mask) \ + sys_trace_gpio_init_callback_enter(callback, handler, pin_mask) +#define sys_port_trace_gpio_init_callback_exit(callback) sys_trace_gpio_init_callback_exit(callback) +#define sys_port_trace_gpio_add_callback_enter(port, callback) \ + sys_trace_gpio_add_callback_enter(port, callback) +#define sys_port_trace_gpio_add_callback_exit(port, ret) sys_trace_gpio_add_callback_exit(port, ret) +#define sys_port_trace_gpio_remove_callback_enter(port, callback) \ + sys_trace_gpio_remove_callback_enter(port, callback) +#define sys_port_trace_gpio_remove_callback_exit(port, ret) \ + sys_trace_gpio_remove_callback_exit(port, ret) +#define sys_port_trace_gpio_get_pending_int_enter(dev) sys_trace_gpio_get_pending_int_enter(dev) +#define sys_port_trace_gpio_get_pending_int_exit(dev, ret) \ + sys_trace_gpio_get_pending_int_exit(dev, ret) +#define sys_port_trace_gpio_fire_callbacks_enter(list, port, pins) \ + sys_trace_gpio_fire_callbacks_enter(list, port, pins) +#define sys_port_trace_gpio_fire_callback(port, cb) sys_trace_gpio_fire_callback(port, cb) + #ifdef __cplusplus } #endif diff --git a/subsys/tracing/ctf/tsdl/metadata b/subsys/tracing/ctf/tsdl/metadata index c180200337bd3..4e1c07805336e 100644 --- a/subsys/tracing/ctf/tsdl/metadata +++ b/subsys/tracing/ctf/tsdl/metadata @@ -787,3 +787,263 @@ event { uint32_t arg1; }; }; + +event { + name = gpio_pin_configure_interrupt_enter; + id = 0x63; + fields := struct { + uint32_t port; + uint32_t pin; + uint32_t flags; + }; +}; + +event { + name = gpio_pin_configure_interrupt_exit; + id = 0x64; + fields := struct { + uint32_t port; + uint32_t pin; + uint32_t ret; + }; +}; + +event { + name = gpio_pin_configure_enter; + id = 0x65; + fields := struct { + uint32_t port; + uint32_t pin; + uint32_t flags; + }; +}; + +event { + name = gpio_pin_configure_exit; + id = 0x66; + fields := struct { + uint32_t port; + uint32_t pin; + uint32_t ret; + }; +}; + +event { + name = gpio_port_get_direction_enter; + id = 0x67; + fields := struct { + uint32_t port; + uint32_t map; + uint32_t inputs; + uint32_t outputs; + }; +}; + +event { + name = gpio_port_get_direction_exit; + id = 0x68; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_pin_get_config_enter; + id = 0x69; + fields := struct { + uint32_t port; + uint32_t pin; + }; +}; + +event { + name = gpio_pin_get_config_exit; + id = 0x6A; + fields := struct { + uint32_t port; + uint32_t pin; + uint32_t ret; + }; +}; + +event { + name = gpio_port_get_raw_enter; + id = 0x6B; + fields := struct { + uint32_t port; + uint32_t value; + }; +}; + +event { + name = gpio_port_get_raw_exit; + id = 0x6C; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_port_set_masked_raw_enter; + id = 0x6D; + fields := struct { + uint32_t port; + uint32_t mask; + uint32_t value; + }; +}; + +event { + name = gpio_port_set_masked_raw_exit; + id = 0x6E; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_port_set_bits_raw_enter; + id = 0x6F; + fields := struct { + uint32_t port; + uint32_t pins; + }; +}; + +event { + name = gpio_port_set_bits_raw_exit; + id = 0x70; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_port_clear_bits_raw_enter; + id = 0x71; + fields := struct { + uint32_t port; + uint32_t pins; + }; +}; + +event { + name = gpio_port_clear_bits_raw_exit; + id = 0x72; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_port_toggle_bits_enter; + id = 0x73; + fields := struct { + uint32_t port; + uint32_t pins; + }; +}; + +event { + name = gpio_port_toggle_bits_exit; + id = 0x74; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_init_callback_enter; + id = 0x75; + fields := struct { + uint32_t callback; + uint32_t handler; + uint32_t pin_mask; + }; +}; + +event { + name = gpio_init_callback_exit; + id = 0x76; + fields := struct { + uint32_t callback; + }; +}; + +event { + name = gpio_add_callback_enter; + id = 0x77; + fields := struct { + uint32_t port; + uint32_t callback; + }; +}; + +event { + name = gpio_add_callback_exit; + id = 0x78; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_remove_callback_enter; + id = 0x79; + fields := struct { + uint32_t port; + uint32_t callback; + }; +}; + +event { + name = gpio_remove_callback_exit; + id = 0x7A; + fields := struct { + uint32_t port; + uint32_t ret; + }; +}; + +event { + name = gpio_get_pending_int_enter; + id = 0x7B; + fields := struct { + uint32_t dev; + }; +}; + +event { + name = gpio_get_pending_int_exit; + id = 0x7C; + fields := struct { + uint32_t dev; + uint32_t ret; + }; +}; + +event { + name = gpio_fire_callbacks_enter; + id = 0x7D; + fields := struct { + uint32_t list; + uint32_t port; + uint32_t pins; + }; +}; + +event { + name = gpio_fire_callback; + id = 0x7E; + fields := struct { + uint32_t port; + uint32_t cb; + }; +}; diff --git a/subsys/tracing/sysview/tracing_sysview.h b/subsys/tracing/sysview/tracing_sysview.h index 3d60b7448c1a9..6fd0ba9f9048e 100644 --- a/subsys/tracing/sysview/tracing_sysview.h +++ b/subsys/tracing/sysview/tracing_sysview.h @@ -725,6 +725,35 @@ void sys_trace_named_event(const char *name, uint32_t arg0, uint32_t arg1); #define sys_port_trace_net_rx_time(pkt, end_time) #define sys_port_trace_net_tx_time(pkt, end_time) +#define sys_port_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_pin_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) +#define sys_port_trace_gpio_port_get_direction_exit(port, map, ret) +#define sys_port_trace_gpio_pin_get_config_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_get_config_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_raw_enter(port, value) +#define sys_port_trace_gpio_port_get_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_masked_raw_enter(port, mask, value) +#define sys_port_trace_gpio_port_set_masked_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_set_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_clear_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_clear_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_toggle_bits_enter(port, pins) +#define sys_port_trace_gpio_port_toggle_bits_exit(port, ret) +#define sys_port_trace_gpio_init_callback_enter(callback, handler, pin_mask) +#define sys_port_trace_gpio_init_callback_exit(callback) +#define sys_port_trace_gpio_add_callback_enter(port, callback) +#define sys_port_trace_gpio_add_callback_exit(port, ret) +#define sys_port_trace_gpio_remove_callback_enter(port, callback) +#define sys_port_trace_gpio_remove_callback_exit(port, ret) +#define sys_port_trace_gpio_get_pending_int_enter(dev) +#define sys_port_trace_gpio_get_pending_int_exit(dev, ret) +#define sys_port_trace_gpio_fire_callbacks_enter(list, port, pins) +#define sys_port_trace_gpio_fire_callback(port, cb) + #ifdef __cplusplus } #endif diff --git a/subsys/tracing/test/tracing_test.h b/subsys/tracing/test/tracing_test.h index fc3e73e0a0225..ea15f2f473a06 100644 --- a/subsys/tracing/test/tracing_test.h +++ b/subsys/tracing/test/tracing_test.h @@ -743,5 +743,33 @@ void sys_trace_k_event_init(struct k_event *event); #define sys_trace_sys_init_exit(...) #define sys_trace_named_event(name, arg0, arg1) +#define sys_port_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_pin_configure_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_configure_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) +#define sys_port_trace_gpio_port_get_direction_exit(port, map, ret) +#define sys_port_trace_gpio_pin_get_config_enter(port, pin, flags) +#define sys_port_trace_gpio_pin_get_config_exit(port, pin, ret) +#define sys_port_trace_gpio_port_get_raw_enter(port, value) +#define sys_port_trace_gpio_port_get_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_masked_raw_enter(port, mask, value) +#define sys_port_trace_gpio_port_set_masked_raw_exit(port, ret) +#define sys_port_trace_gpio_port_set_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_set_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_clear_bits_raw_enter(port, pins) +#define sys_port_trace_gpio_port_clear_bits_raw_exit(port, ret) +#define sys_port_trace_gpio_port_toggle_bits_enter(port, pins) +#define sys_port_trace_gpio_port_toggle_bits_exit(port, ret) +#define sys_port_trace_gpio_init_callback_enter(callback, handler, pin_mask) +#define sys_port_trace_gpio_init_callback_exit(callback) +#define sys_port_trace_gpio_add_callback_enter(port, callback) +#define sys_port_trace_gpio_add_callback_exit(port, ret) +#define sys_port_trace_gpio_remove_callback_enter(port, callback) +#define sys_port_trace_gpio_remove_callback_exit(port, ret) +#define sys_port_trace_gpio_get_pending_int_enter(dev) +#define sys_port_trace_gpio_get_pending_int_exit(dev, ret) +#define sys_port_trace_gpio_fire_callbacks_enter(list, port, pins) +#define sys_port_trace_gpio_fire_callback(port, cb) #endif /* ZEPHYR_TRACE_TEST_H */ diff --git a/subsys/tracing/user/tracing_user.c b/subsys/tracing/user/tracing_user.c index b17e2fc1d4f99..2453a3e9aad27 100644 --- a/subsys/tracing/user/tracing_user.c +++ b/subsys/tracing/user/tracing_user.c @@ -25,6 +25,55 @@ void __weak sys_trace_isr_exit_user(void) {} void __weak sys_trace_idle_user(void) {} void __weak sys_trace_sys_init_enter_user(const struct init_entry *entry, int level) {} void __weak sys_trace_sys_init_exit_user(const struct init_entry *entry, int level, int result) {} +void __weak sys_trace_gpio_pin_interrupt_configure_enter_user(const struct device *port, + gpio_pin_t pin, gpio_flags_t flags) {} +void __weak sys_trace_gpio_pin_interrupt_configure_exit_user(const struct device *port, + gpio_pin_t pin, int ret) {} +void __weak sys_trace_gpio_pin_configure_enter_user(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) {} +void __weak sys_trace_gpio_pin_configure_exit_user(const struct device *port, gpio_pin_t pin, + int ret) {} +void __weak sys_trace_gpio_port_get_direction_enter_user(const struct device *port, + gpio_port_pins_t map, + gpio_port_pins_t inputs, + gpio_port_pins_t outputs) {} +void __weak sys_trace_gpio_port_get_direction_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_pin_get_config_enter_user(const struct device *port, gpio_pin_t pin, + int ret) {} +void __weak sys_trace_gpio_pin_get_config_exit_user(const struct device *port, gpio_pin_t pin, + int ret) {} +void __weak sys_trace_gpio_port_get_raw_enter_user(const struct device *port, + gpio_port_value_t *value) {} +void __weak sys_trace_gpio_port_get_raw_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_port_set_masked_raw_enter_user(const struct device *port, + gpio_port_pins_t mask, + gpio_port_value_t value) {} +void __weak sys_trace_gpio_port_set_masked_raw_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_port_set_bits_raw_enter_user(const struct device *port, + gpio_port_pins_t pins) {} +void __weak sys_trace_gpio_port_set_bits_raw_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_port_clear_bits_raw_enter_user(const struct device *port, + gpio_port_pins_t pins) {} +void __weak sys_trace_gpio_port_clear_bits_raw_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_port_toggle_bits_enter_user(const struct device *port, + gpio_port_pins_t pins) {} +void __weak sys_trace_gpio_port_toggle_bits_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_init_callback_enter_user(struct gpio_callback *callback, + gpio_callback_handler_t handler, + gpio_port_pins_t pin_mask) {} +void __weak sys_trace_gpio_init_callback_exit_user(struct gpio_callback *callback) {} +void __weak sys_trace_gpio_add_callback_enter_user(const struct device *port, + struct gpio_callback *callback) {} +void __weak sys_trace_gpio_add_callback_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_remove_callback_enter_user(const struct device *port, + struct gpio_callback *callback) {} +void __weak sys_trace_gpio_remove_callback_exit_user(const struct device *port, int ret) {} +void __weak sys_trace_gpio_get_pending_int_enter_user(const struct device *dev) {} +void __weak sys_trace_gpio_get_pending_int_exit_user(const struct device *dev, int ret) {} +void __weak sys_trace_gpio_fire_callbacks_enter_user(sys_slist_t *list, const struct device *port, + gpio_pin_t pins) {} +void __weak sys_trace_gpio_fire_callback_user(const struct device *port, + struct gpio_callback *callback) {} void sys_trace_thread_create(struct k_thread *thread) { @@ -105,3 +154,151 @@ void sys_trace_sys_init_exit(const struct init_entry *entry, int level, int resu { sys_trace_sys_init_exit_user(entry, level, result); } + +void sys_trace_gpio_pin_interrupt_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + sys_trace_gpio_pin_interrupt_configure_enter_user(port, pin, flags); +} + +void sys_trace_gpio_pin_interrupt_configure_exit(const struct device *port, gpio_pin_t pin, + int ret) +{ + sys_trace_gpio_pin_interrupt_configure_exit_user(port, pin, ret); +} + +void sys_trace_gpio_pin_configure_enter(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags) +{ + sys_trace_gpio_pin_configure_enter_user(port, pin, flags); +} + +void sys_trace_gpio_pin_configure_exit(const struct device *port, gpio_pin_t pin, int ret) +{ + sys_trace_gpio_pin_configure_exit_user(port, pin, ret); +} + +void sys_trace_gpio_port_get_direction_enter(const struct device *port, gpio_port_pins_t map, + gpio_port_pins_t inputs, gpio_port_pins_t outputs) +{ + sys_trace_gpio_port_get_direction_enter_user(port, map, inputs, outputs); +} + +void sys_trace_gpio_port_get_direction_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_get_direction_exit_user(port, ret); +} + +void sys_trace_gpio_pin_get_config_enter(const struct device *port, gpio_pin_t pin, int ret) +{ + sys_trace_gpio_pin_get_config_enter_user(port, pin, ret); +} + +void sys_trace_gpio_pin_get_config_exit(const struct device *port, gpio_pin_t pin, int ret) +{ + sys_trace_gpio_pin_get_config_exit_user(port, pin, ret); +} + +void sys_trace_gpio_port_get_raw_enter(const struct device *port, gpio_port_value_t *value) +{ + sys_trace_gpio_port_get_raw_enter_user(port, value); +} + +void sys_trace_gpio_port_get_raw_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_get_raw_exit_user(port, ret); +} + +void sys_trace_gpio_port_set_masked_raw_enter(const struct device *port, gpio_port_pins_t mask, + gpio_port_value_t value) +{ + sys_trace_gpio_port_set_masked_raw_enter_user(port, mask, value); +} + +void sys_trace_gpio_port_set_masked_raw_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_set_masked_raw_exit_user(port, ret); +} + +void sys_trace_gpio_port_set_bits_raw_enter(const struct device *port, gpio_port_pins_t pins) +{ + sys_trace_gpio_port_set_bits_raw_enter_user(port, pins); +} + +void sys_trace_gpio_port_set_bits_raw_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_set_bits_raw_exit_user(port, ret); +} + +void sys_trace_gpio_port_clear_bits_raw_enter(const struct device *port, gpio_port_pins_t pins) +{ + sys_trace_gpio_port_clear_bits_raw_enter_user(port, pins); +} + +void sys_trace_gpio_port_clear_bits_raw_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_clear_bits_raw_exit_user(port, ret); +} + +void sys_trace_gpio_port_toggle_bits_enter(const struct device *port, gpio_port_pins_t pins) +{ + sys_trace_gpio_port_toggle_bits_enter_user(port, pins); +} + +void sys_trace_gpio_port_toggle_bits_exit(const struct device *port, int ret) +{ + sys_trace_gpio_port_toggle_bits_exit_user(port, ret); +} + +void sys_trace_gpio_init_callback_enter(struct gpio_callback *callback, + gpio_callback_handler_t handler, gpio_port_pins_t pin_mask) +{ + sys_trace_gpio_init_callback_enter_user(callback, handler, pin_mask); +} + +void sys_trace_gpio_init_callback_exit(struct gpio_callback *callback) +{ + sys_trace_gpio_init_callback_exit_user(callback); +} + +void sys_trace_gpio_add_callback_enter(const struct device *port, struct gpio_callback *callback) +{ + sys_trace_gpio_add_callback_enter_user(port, callback); +} + +void sys_trace_gpio_add_callback_exit(const struct device *port, int ret) +{ + sys_trace_gpio_add_callback_exit_user(port, ret); +} + +void sys_trace_gpio_remove_callback_enter(const struct device *port, + struct gpio_callback *callback) +{ + sys_trace_gpio_remove_callback_enter_user(port, callback); +} + +void sys_trace_gpio_remove_callback_exit(const struct device *port, int ret) +{ + sys_trace_gpio_remove_callback_exit_user(port, ret); +} + +void sys_trace_gpio_get_pending_int_enter(const struct device *dev) +{ + sys_trace_gpio_get_pending_int_enter_user(dev); +} + +void sys_trace_gpio_get_pending_int_exit(const struct device *dev, int ret) +{ + sys_trace_gpio_get_pending_int_exit_user(dev, ret); +} + +void sys_trace_gpio_fire_callbacks_enter(sys_slist_t *list, const struct device *port, + gpio_pin_t pins) +{ + sys_trace_gpio_fire_callbacks_enter_user(list, port, pins); +} + +void sys_trace_gpio_fire_callback(const struct device *port, struct gpio_callback *callback) +{ + sys_trace_gpio_fire_callback_user(port, callback); +} diff --git a/subsys/tracing/user/tracing_user.h b/subsys/tracing/user/tracing_user.h index 1d3a28032e3b6..28208095537d2 100644 --- a/subsys/tracing/user/tracing_user.h +++ b/subsys/tracing/user/tracing_user.h @@ -7,6 +7,7 @@ #ifndef _TRACE_USER_H #define _TRACE_USER_H +#include #include #include @@ -48,6 +49,54 @@ void sys_trace_idle(void); void sys_trace_sys_init_enter(const struct init_entry *entry, int level); void sys_trace_sys_init_exit(const struct init_entry *entry, int level, int result); +struct gpio_callback; +typedef uint8_t gpio_pin_t; +typedef uint32_t gpio_flags_t; +typedef uint32_t gpio_port_pins_t; +typedef uint32_t gpio_port_value_t; +typedef void (*gpio_callback_handler_t)(const struct device *port, struct gpio_callback *cb, + gpio_port_pins_t pins); +void sys_trace_gpio_pin_interrupt_configure_enter_user(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags); +void sys_trace_gpio_pin_interrupt_configure_exit_user(const struct device *port, gpio_pin_t pin, + int ret); +void sys_trace_gpio_pin_configure_enter_user(const struct device *port, gpio_pin_t pin, + gpio_flags_t flags); +void sys_trace_gpio_pin_configure_exit_user(const struct device *port, gpio_pin_t pin, int ret); +void sys_trace_gpio_port_get_direction_enter_user(const struct device *port, gpio_port_pins_t map, + gpio_port_pins_t inputs, + gpio_port_pins_t outputs); +void sys_trace_gpio_port_get_direction_exit_user(const struct device *port, int ret); +void sys_trace_gpio_pin_get_config_enter_user(const struct device *port, gpio_pin_t pin, int ret); +void sys_trace_gpio_pin_get_config_exit_user(const struct device *port, gpio_pin_t pin, int ret); +void sys_trace_gpio_port_get_raw_enter_user(const struct device *port, gpio_port_value_t *value); +void sys_trace_gpio_port_get_raw_exit_user(const struct device *port, int ret); +void sys_trace_gpio_port_set_masked_raw_enter_user(const struct device *port, gpio_port_pins_t mask, + gpio_port_value_t value); +void sys_trace_gpio_port_set_masked_raw_exit_user(const struct device *port, int ret); +void sys_trace_gpio_port_set_bits_raw_enter_user(const struct device *port, gpio_port_pins_t pins); +void sys_trace_gpio_port_set_bits_raw_exit_user(const struct device *port, int ret); +void sys_trace_gpio_port_clear_bits_raw_enter_user(const struct device *port, + gpio_port_pins_t pins); +void sys_trace_gpio_port_clear_bits_raw_exit_user(const struct device *port, int ret); +void sys_trace_gpio_port_toggle_bits_enter_user(const struct device *port, gpio_port_pins_t pins); +void sys_trace_gpio_port_toggle_bits_exit_user(const struct device *port, int ret); +void sys_trace_gpio_init_callback_enter_user(struct gpio_callback *callback, + gpio_callback_handler_t handler, + gpio_port_pins_t pin_mask); +void sys_trace_gpio_init_callback_exit_user(struct gpio_callback *callback); +void sys_trace_gpio_add_callback_enter_user(const struct device *port, + struct gpio_callback *callback); +void sys_trace_gpio_add_callback_exit_user(const struct device *port, int ret); +void sys_trace_gpio_remove_callback_enter_user(const struct device *port, + struct gpio_callback *callback); +void sys_trace_gpio_remove_callback_exit_user(const struct device *port, int ret); +void sys_trace_gpio_get_pending_int_enter_user(const struct device *dev); +void sys_trace_gpio_get_pending_int_exit_user(const struct device *dev, int ret); +void sys_trace_gpio_fire_callbacks_enter_user(sys_slist_t *list, const struct device *port, + gpio_pin_t pins); +void sys_trace_gpio_fire_callback_user(const struct device *port, struct gpio_callback *callback); + #define sys_port_trace_k_thread_foreach_enter() #define sys_port_trace_k_thread_foreach_exit() #define sys_port_trace_k_thread_foreach_unlocked_enter() @@ -392,6 +441,63 @@ void sys_trace_sys_init_exit(const struct init_entry *entry, int level, int resu #define sys_trace_named_event(name, arg0, arg1) +#define sys_port_trace_gpio_pin_interrupt_configure_enter(port, pin, flags) \ + sys_trace_gpio_pin_interrupt_configure_enter_user(port, pin, flags) +#define sys_port_trace_gpio_pin_interrupt_configure_exit(port, pin, ret) \ + sys_trace_gpio_pin_interrupt_configure_exit_user(port, pin, ret) +#define sys_port_trace_gpio_pin_configure_enter(port, pin, flags) \ + sys_trace_gpio_pin_configure_enter_user(port, pin, flags) +#define sys_port_trace_gpio_pin_configure_exit(port, pin, ret) \ + sys_trace_gpio_pin_configure_exit_user(port, pin, ret) +#define sys_port_trace_gpio_port_get_direction_enter(port, map, inputs, outputs) \ + sys_trace_gpio_port_get_direction_enter_user(port, map, inputs, outputs) +#define sys_port_trace_gpio_port_get_direction_exit(port, ret) \ + sys_trace_gpio_port_get_direction_exit_user(port, ret) +#define sys_port_trace_gpio_pin_get_config_enter(port, pin, ret) \ + sys_trace_gpio_pin_get_config_enter_user(port, pin, ret) +#define sys_port_trace_gpio_pin_get_config_exit(port, pin, ret) \ + sys_trace_gpio_pin_get_config_exit_user(port, pin, ret) +#define sys_port_trace_gpio_port_get_raw_enter(port, value) \ + sys_trace_gpio_port_get_raw_enter_user(port, value) +#define sys_port_trace_gpio_port_get_raw_exit(port, ret) \ + sys_trace_gpio_port_get_raw_exit_user(port, ret) +#define sys_port_trace_gpio_port_set_masked_raw_enter(port, mask, value) \ + sys_trace_gpio_port_set_masked_raw_enter_user(port, mask, value) +#define sys_port_trace_gpio_port_set_masked_raw_exit(port, ret) \ + sys_trace_gpio_port_set_masked_raw_exit_user(port, ret) +#define sys_port_trace_gpio_port_set_bits_raw_enter(port, pins) \ + sys_trace_gpio_port_set_bits_raw_enter_user(port, pins) +#define sys_port_trace_gpio_port_set_bits_raw_exit(port, ret) \ + sys_trace_gpio_port_set_bits_raw_exit_user(port, ret) +#define sys_port_trace_gpio_port_clear_bits_raw_enter(port, pins) \ + sys_trace_gpio_port_clear_bits_raw_enter_user(port, pins) +#define sys_port_trace_gpio_port_clear_bits_raw_exit(port, ret) \ + sys_trace_gpio_port_clear_bits_raw_exit_user(port, ret) +#define sys_port_trace_gpio_port_toggle_bits_enter(port, pins) \ + sys_trace_gpio_port_toggle_bits_enter_user(port, pins) +#define sys_port_trace_gpio_port_toggle_bits_exit(port, ret) \ + sys_trace_gpio_port_toggle_bits_exit_user(port, ret) +#define sys_port_trace_gpio_init_callback_enter(callback, handler, pin_mask) \ + sys_trace_gpio_init_callback_enter_user(callback, handler, pin_mask) +#define sys_port_trace_gpio_init_callback_exit(callback) \ + sys_trace_gpio_init_callback_exit_user(callback) +#define sys_port_trace_gpio_add_callback_enter(port, callback) \ + sys_trace_gpio_add_callback_enter_user(port, callback) +#define sys_port_trace_gpio_add_callback_exit(port, ret) \ + sys_trace_gpio_add_callback_exit_user(port, ret) +#define sys_port_trace_gpio_remove_callback_enter(port, callback) \ + sys_trace_gpio_remove_callback_enter_user(port, callback) +#define sys_port_trace_gpio_remove_callback_exit(port, ret) \ + sys_trace_gpio_remove_callback_exit_user(port, ret) +#define sys_port_trace_gpio_get_pending_int_enter(dev) \ + sys_trace_gpio_get_pending_int_enter_user(dev) +#define sys_port_trace_gpio_get_pending_int_exit(dev, ret) \ + sys_trace_gpio_get_pending_int_exit_user(dev, ret) +#define sys_port_trace_gpio_fire_callbacks_enter(list, port, pins) \ + sys_trace_gpio_fire_callbacks_enter_user(list, port, pins) +#define sys_port_trace_gpio_fire_callback(port, callback) \ + sys_trace_gpio_fire_callback_user(port, callback) + #ifdef __cplusplus } #endif