debug: ppi_trace: Adapt to use new GPPI API

Adapt module to use GPPI API.

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

include/debug/ppi_trace.h

@@ -10,10 +10,6 @@
 #include <stdint.h>
 #include <nrfx.h>
 
-#if defined(DPPI_PRESENT)
-#include <nrfx_dppi.h>
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -67,14 +63,13 @@ void *ppi_trace_pair_config(uint32_t pin, uint32_t start_evt, uint32_t stop_evt)
  *
  * @param pin		Pin to use for tracing.
  * @param dppi_ch	DPPI channel number to be traced on the pin.
- * @param dppic		Identifies the instance of DPPIC controller that the @c dppi_ch channel
- *			belongs to.
+ * @param p_dppi	Instance of the DPPIC controller that the @c dppi_ch channel belongs to.
  *
  * @retval 0		The configuration succeeded.
  * @retval -ENOMEM	The configuration failed, due to lack of necessary resources.
  * @retval -ENOTSUP	The function is not supported on current hardware platform.
  */
-int ppi_trace_dppi_ch_trace(uint32_t pin, uint32_t dppi_ch, const nrfx_dppi_t *dppic);
+int ppi_trace_dppi_ch_trace(uint32_t pin, uint32_t dppi_ch, NRF_DPPIC_Type *p_dppi);
 
 #endif /* DPPI_PRESENT */
 

subsys/debug/ppi_trace/Kconfig

@@ -8,16 +8,14 @@ config PPI_TRACE
 	bool "Enable PPI trace"
 	select NRFX_GPIOTE
 	select NRFX_GPPI
-	select NRFX_PPI if HAS_HW_NRF_PPI
-	select NRFX_DPPI0 if SOC_SERIES_NRF53X
-	select NRFX_DPPI00 if SOC_SERIES_NRF54LX
-	select NRFX_DPPI10 if SOC_SERIES_NRF54LX
-	select NRFX_DPPI20 if SOC_SERIES_NRF54LX
-	select NRFX_DPPI30 if SOC_SERIES_NRF54LX
 	help
 	  Enable PPI trace module which enables forwarding hardware events to
 	  GPIOs.
 
+config PPI_TRACE_PIN_CNT
+	int "Maximum number of trace pins"
+	default 8
+
 if PPI_TRACE
 module = PPI_TRACE
 module-str = PPI trace

subsys/debug/ppi_trace/ppi_trace.c

@@ -6,9 +6,6 @@
 
 #include <hal/nrf_gpiote.h>
 #include <nrfx_gpiote.h>
-#ifdef DPPI_PRESENT
-#include <nrfx_dppi.h>
-#endif
 #include <helpers/nrfx_gppi.h>
 
 #include <debug/ppi_trace.h>
@@ -54,6 +51,9 @@ typedef struct {
 	uint8_t              gpiote_channel;
 } ppi_trace_gpiote_pin_t;
 
+static atomic_t alloc_cnt;
+static uint32_t handle[CONFIG_PPI_TRACE_PIN_CNT];
+
 static const nrfx_gpiote_t *get_gpiote(nrfx_gpiote_pin_t pin)
 {
 	static const nrfx_gpiote_t gpiote[GPIO_COUNT] = {
@@ -98,174 +98,120 @@ static bool ppi_trace_gpiote_pin_init(
 
 void *ppi_trace_config(uint32_t pin, uint32_t evt)
 {
-	uint8_t gppi_ch = UINT8_MAX;
+	uint32_t idx = atomic_inc(&alloc_cnt);
+	nrfx_gppi_handle_t *handle = (nrfx_gppi_handle_t *)&handle[idx];
+	ppi_trace_gpiote_pin_t ppi_trace_gpiote_pin = {};
 
-	if (NRFX_SUCCESS != nrfx_gppi_channel_alloc(&gppi_ch)) {
-		LOG_ERR("Failed to allocate GPPI channel.");
+	/* All slots taken. */
+	if (alloc_cnt > CONFIG_PPI_TRACE_PIN_CNT) {
 		return NULL;
 	}
 
-	ppi_trace_gpiote_pin_t ppi_trace_gpiote_pin = {};
-
 	if (!ppi_trace_gpiote_pin_init(&ppi_trace_gpiote_pin, pin)) {
-		nrfx_gppi_channel_free(gppi_ch);
 		return NULL;
 	}
 
 	uint32_t tep = nrf_gpiote_task_address_get(ppi_trace_gpiote_pin.gpiote->p_reg,
 				nrf_gpiote_out_task_get(ppi_trace_gpiote_pin.gpiote_channel));
-	nrfx_gppi_channel_endpoints_setup(gppi_ch, evt, tep);
 
-	return HANDLE_ENCODE(gppi_ch);
+	if (nrfx_gppi_conn_alloc(evt, tep, handle) < 0) {
+		LOG_ERR("Failed to allocate GPPI channel.");
+		return NULL;
+	}
+	return handle;
 }
 
 void *ppi_trace_pair_config(uint32_t pin, uint32_t start_evt, uint32_t stop_evt)
 {
+	uint32_t idx = atomic_add(&alloc_cnt, 2);
+	nrfx_gppi_handle_t *handle1 = (nrfx_gppi_handle_t *)&handle[idx];
+	nrfx_gppi_handle_t *handle2 = (nrfx_gppi_handle_t *)&handle[idx + 1];
+
+	/* All slots taken. */
+	if (alloc_cnt > CONFIG_PPI_TRACE_PIN_CNT) {
+		return NULL;
+	}
+
 #if !defined(GPIOTE_FEATURE_SET_PRESENT) || \
     !defined(GPIOTE_FEATURE_CLR_PRESENT)
 	__ASSERT(0, "Function not supported on this platform.");
 	return NULL;
 #else
-	uint8_t gppi_ch_start_evt = UINT8_MAX;
-
-	if (NRFX_SUCCESS != nrfx_gppi_channel_alloc(&gppi_ch_start_evt)) {
-		LOG_ERR("Failed to allocate GPPI channel.");
-		return NULL;
-	}
-
-	uint8_t gppi_ch_stop_evt = UINT8_MAX;
-
-	if (NRFX_SUCCESS != nrfx_gppi_channel_alloc(&gppi_ch_stop_evt)) {
-		LOG_ERR("Failed to allocate GPPI channel.");
-		nrfx_gppi_channel_free(gppi_ch_start_evt);
-		return NULL;
-	}
-
 	ppi_trace_gpiote_pin_t ppi_trace_gpiote_pin = {};
 
 	if (!ppi_trace_gpiote_pin_init(&ppi_trace_gpiote_pin, pin)) {
-		nrfx_gppi_channel_free(gppi_ch_stop_evt);
-		nrfx_gppi_channel_free(gppi_ch_start_evt);
 		return NULL;
 	}
 
 	uint32_t tep;
 
 	tep = nrf_gpiote_task_address_get(ppi_trace_gpiote_pin.gpiote->p_reg,
 			nrf_gpiote_set_task_get(ppi_trace_gpiote_pin.gpiote_channel));
-	nrfx_gppi_channel_endpoints_setup(gppi_ch_start_evt, start_evt, tep);
+	if (nrfx_gppi_conn_alloc(start_evt, tep, handle1) < 0) {
+		LOG_ERR("Failed to allocate GPPI channel.");
+		return NULL;
+	}
 
 	tep = nrf_gpiote_task_address_get(ppi_trace_gpiote_pin.gpiote->p_reg,
 			nrf_gpiote_clr_task_get(ppi_trace_gpiote_pin.gpiote_channel));
-	nrfx_gppi_channel_endpoints_setup(gppi_ch_stop_evt, stop_evt, tep);
-
-	return HANDLE_ENCODE(PACK_CHANNELS(gppi_ch_start_evt, gppi_ch_stop_evt));
-#endif
-}
-
-#if defined(DPPI_PRESENT)
-
-static const nrfx_dppi_t *get_dppic_for_gpiote(const nrfx_gpiote_t *gpiote)
-{
-	/* The Device Tree does not provide information about the DPPIC controller for which
-	 * the given GPIOTE instance can subscribe to. That's why we need to provide the
-	 * matching DPPIC instance ourselves.
-	 */
-
-#if (!defined(DPPIC_COUNT) || (DPPIC_COUNT == 1))
-	static const nrfx_dppi_t dppic = NRFX_DPPI_INSTANCE(0);
-
-	return &dppic;
-#elif defined(CONFIG_SOC_SERIES_NRF54LX)
-	if (gpiote->p_reg == NRF_GPIOTE20) {
-		static const nrfx_dppi_t dppic20 = NRFX_DPPI_INSTANCE(20);
-
-		return &dppic20;
-	} else if (gpiote->p_reg == NRF_GPIOTE30) {
-		static const nrfx_dppi_t dppic30 = NRFX_DPPI_INSTANCE(30);
-
-		return &dppic30;
-	} else {
+	if (nrfx_gppi_conn_alloc(stop_evt, tep, handle2) < 0) {
+		LOG_ERR("Failed to allocate GPPI channel.");
 		return NULL;
 	}
-#else
-#error Unsupported SoC series
-	return NULL;
+
+	/* Address to aligned 32 bit variable will always have 0 on last two bits. Last bit is
+	 * used to indicated that it is a pair.
+	 */
+	return (void *)((uintptr_t)handle1 | 0x1);
 #endif
 }
 
-int ppi_trace_dppi_ch_trace(uint32_t pin, uint32_t dppi_ch, const nrfx_dppi_t *dppic)
+#if defined(DPPI_PRESENT)
+int ppi_trace_dppi_ch_trace(uint32_t pin, uint32_t dppi_ch, NRF_DPPIC_Type *p_dppi)
 {
+	nrfx_gppi_handle_t handle;
 	ppi_trace_gpiote_pin_t ppi_trace_gpiote_pin = {};
 
 	if (!ppi_trace_gpiote_pin_init(&ppi_trace_gpiote_pin, pin)) {
 		return -ENOMEM;
 	}
 
-	const nrfx_dppi_t *dppic_for_gpiote = get_dppic_for_gpiote(ppi_trace_gpiote_pin.gpiote);
+	uint32_t tep = nrf_gpiote_task_address_get(ppi_trace_gpiote_pin.gpiote->p_reg,
+				nrf_gpiote_out_task_get(ppi_trace_gpiote_pin.gpiote_channel));
+	uint32_t dst_domain = nrfx_gppi_domain_id_get(ppi_trace_gpiote_pin.gpiote->p_reg);
+	nrfx_gppi_resource_t resource = {
+		.domain_id = nrfx_gppi_domain_id_get(p_dppi),
+		.channel = dppi_ch
+	};
 
-	if (dppic_for_gpiote == NULL) {
-		LOG_ERR("For given GPIO pin, the GPIOTE has no associated DPPIC.");
+	if (nrfx_gppi_ext_conn_alloc(evt, tep, &handle, &resource) < 0) {
+		LOG_ERR("Failed to allocate GPPI channel.");
 		return -ENOMEM;
 	}
+	nrfx_gppi_conn_enable(handle);
 
-	if (dppic_for_gpiote->p_reg == dppic->p_reg) {
-		/* The GPIOTE can directly subscribe to DPPI channels of `dppic` */
-		nrf_gpiote_subscribe_set(ppi_trace_gpiote_pin.gpiote->p_reg,
-			nrf_gpiote_out_task_get(ppi_trace_gpiote_pin.gpiote_channel),
-			dppi_ch);
-	} else {
-		/* Let the GPIOTE channel subscribe to a local dppi_channel_for_gpiote of
-		 * ppi_trace_gpiote_pin.dppic first.
-		 */
-		uint8_t dppi_channel_for_gpiote = UINT8_MAX;
-
-		if (nrfx_dppi_channel_alloc(dppic_for_gpiote,
-			&dppi_channel_for_gpiote) != NRFX_SUCCESS) {
-			return -ENOMEM;
-		}
-
-		nrf_gpiote_subscribe_set(ppi_trace_gpiote_pin.gpiote->p_reg,
-			nrf_gpiote_out_task_get(ppi_trace_gpiote_pin.gpiote_channel),
-			dppi_channel_for_gpiote);
-
-		(void)nrfx_dppi_channel_enable(dppic_for_gpiote, dppi_channel_for_gpiote);
-
-		/* Then, let the dppi_ch channel of dppic controller passed by parameters
-		 * trigger the local dppi_channel_for_gpiote.
-		 */
-		uint8_t gppi_ch = UINT8_MAX;
-
-		if (NRFX_SUCCESS != nrfx_gppi_channel_alloc(&gppi_ch)) {
-			LOG_ERR("Failed to allocate GPPI channel.");
-			return -ENOMEM;
-		}
-
-		if (NRFX_SUCCESS != nrfx_gppi_edge_connection_setup(gppi_ch,
-			dppic, dppi_ch, dppic_for_gpiote, dppi_channel_for_gpiote)) {
-			LOG_ERR("Failed to setup a GPPI edge connection.");
-			return -ENOMEM;
-		}
-
-		nrfx_gppi_channels_enable(1U << gppi_ch);
-	}
 	return 0;
 }
 #endif /* defined(DPPI_PRESENT) */
 
-static uint32_t ppi_channel_mask_get(void *handle)
-{
-	return IS_PAIR(handle) ?
-			BIT(GET_START_CH(handle)) | BIT(GET_STOP_CH(handle)) :
-			BIT(GET_CH(handle));
-}
-
 void ppi_trace_enable(void *handle)
 {
-	nrfx_gppi_channels_enable(ppi_channel_mask_get(handle));
+	nrfx_gppi_handle_t *handles = (nrfx_gppi_handle_t *)((uintptr_t)handle & 0x1);
+
+	nrfx_gppi_conn_enable(handles[0]);
+	/* If LSB bit is set it indicates that handle is for pair of connections. */
+	if ((uintptr_t)handle & 0x1) {
+		nrfx_gppi_conn_enable(handles[1]);
+	}
 }
 
 void ppi_trace_disable(void *handle)
 {
-	nrfx_gppi_channels_disable(ppi_channel_mask_get(handle));
+	nrfx_gppi_handle_t *handles = (nrfx_gppi_handle_t *)((uintptr_t)handle & 0x1);
+
+	nrfx_gppi_conn_disable(handles[0]);
+	/* If LSB bit is set it indicates that handle is for pair of connections. */
+	if ((uintptr_t)handle & 0x1) {
+		nrfx_gppi_conn_disable(handles[1]);
+	}
 }