drivers: pwm_nxp_s32_emios: add support for pwm capture

This introduces pwm capture shim driver for NXP S32 EMIOS, the driver uses SAIC mode that is supported for all channels, to capture the counter value on each edge for period/pulse measurement Signed-off-by: Dat Nguyen Duy <dat.nguyenduy@nxp.com>
2023-09-24 00:44:25 +07:00 · 2023-09-24 00:44:25 +07:00 · 0b0988db2d
commit 0b0988db2d
parent 05fd40012f
4 changed files with 440 additions and 21 deletions
--- a/drivers/pwm/pwm_nxp_s32_emios.c
+++ b/drivers/pwm/pwm_nxp_s32_emios.c
@ -12,6 +12,10 @@
 #include <Emios_Mcl_Ip.h>
 #include <Emios_Pwm_Ip.h>

+#ifdef CONFIG_PWM_CAPTURE
+#include <Emios_Icu_Ip.h>
+#endif
+
 #define LOG_MODULE_NAME nxp_s32_emios_pwm
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_PWM_LOG_LEVEL);
@ -26,11 +30,32 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_PWM_LOG_LEVEL);
 extern uint8 eMios_Pwm_Ip_IndexInChState[EMIOS_PWM_IP_INSTANCE_COUNT][EMIOS_PWM_IP_CHANNEL_COUNT];
 #endif

+#ifdef CONFIG_PWM_CAPTURE
+extern uint8 eMios_Icu_Ip_IndexInChState[EMIOS_ICU_IP_INSTANCE_COUNT][EMIOS_ICU_IP_NUM_OF_CHANNELS];
+
+/* We need maximum three edges for measure both period and cycle */
+#define MAX_NUM_EDGE 3
+
+struct pwm_nxp_s32_capture_data {
+	bool continuous;
+	bool inverted;
+	bool pulse_capture;
+	bool period_capture;
+	void *user_data;
+	pwm_capture_callback_handler_t callback;
+	eMios_Icu_ValueType edge_buff[MAX_NUM_EDGE];
+};
+#endif
+
 struct pwm_nxp_s32_data {
 	uint32_t emios_clk;
 #if EMIOS_PWM_IP_USED
 	uint8_t start_pwm_ch;
 #endif
+
+#ifdef CONFIG_PWM_CAPTURE
+	struct pwm_nxp_s32_capture_data capture[EMIOS_ICU_IP_NUM_OF_CHANNELS];
+#endif
 };

 #if EMIOS_PWM_IP_USED
@ -50,6 +75,10 @@ struct pwm_nxp_s32_config {
 #if EMIOS_PWM_IP_USED
 	struct pwm_nxp_s32_pulse_info *pulse_info;
 #endif
+
+#ifdef CONFIG_PWM_CAPTURE
+	eMios_Icu_Ip_ConfigType * icu_cfg;
+#endif
 };

 #if EMIOS_PWM_IP_USED
@ -193,9 +222,178 @@ static int pwm_nxp_s32_set_cycles(const struct device *dev, uint32_t channel,
 }
 #endif

+#ifdef CONFIG_PWM_CAPTURE
+static ALWAYS_INLINE eMios_Icu_ValueType pwm_nxp_s32_capture_calc(eMios_Icu_ValueType first_cnt,
+								  eMios_Icu_ValueType second_cnt)
+{
+	if (first_cnt < second_cnt) {
+		return second_cnt - first_cnt;
+	}
+
+	/* Counter top value is always 0xFFFF */
+	return EMIOS_ICU_IP_COUNTER_MASK - first_cnt + second_cnt;
+}
+
+static ALWAYS_INLINE eMios_Icu_ValueType pwm_nxp_s32_pulse_calc(bool inverted,
+								eMios_Icu_ValueType *edge_buff,
+								eMios_Icu_Ip_LevelType input_state)
+{
+	eMios_Icu_ValueType first_cnt, second_cnt;
+
+	if (input_state ^ inverted) {
+		 /* 3 edges captured is raise, fall, raise */
+		first_cnt = edge_buff[0];
+		second_cnt = edge_buff[1];
+	} else {
+		 /* 3 edges captured is fall, raise, fall */
+		first_cnt = edge_buff[1];
+		second_cnt = edge_buff[2];
+	}
+
+	return pwm_nxp_s32_capture_calc(first_cnt, second_cnt);
+}
+
+static int pwm_nxp_s32_capture_configure(const struct device *dev,
+					uint32_t channel,
+					pwm_flags_t flags,
+					pwm_capture_callback_handler_t cb,
+					void *user_data)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+	struct pwm_nxp_s32_data *data = dev->data;
+
+	if (channel >= EMIOS_ICU_IP_NUM_OF_CHANNELS) {
+		LOG_ERR("Invalid channel %d", channel);
+		return -EINVAL;
+	}
+
+	if (!flags) {
+		LOG_ERR("Invalid PWM capture flag");
+		return -EINVAL;
+	}
+
+	if (eMios_Icu_Ip_IndexInChState[config->instance][channel] >=
+		EMIOS_ICU_IP_NUM_OF_CHANNELS_USED) {
+		LOG_ERR("Channel %d is not configured for PWM", channel);
+		return -EINVAL;
+	}
+
+	/* If interrupt is enabled --> channel is on-going */
+	if (config->base->CH.UC[channel].C & eMIOS_C_FEN_MASK) {
+		LOG_ERR("Channel %d is busy", channel);
+		return -EBUSY;
+	}
+
+	data->capture[channel].continuous = (flags & PWM_CAPTURE_MODE_MASK);
+	data->capture[channel].inverted = (flags & PWM_POLARITY_MASK);
+	data->capture[channel].pulse_capture = (flags & PWM_CAPTURE_TYPE_PULSE);
+	data->capture[channel].period_capture = (flags & PWM_CAPTURE_TYPE_PERIOD);
+	data->capture[channel].callback = cb;
+	data->capture[channel].user_data = user_data;
+
+	return 0;
+}
+
+static int pwm_nxp_s32_capture_enable(const struct device *dev, uint32_t channel)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+	struct pwm_nxp_s32_data *data = dev->data;
+
+	eMios_Icu_Ip_EdgeType edge;
+	uint8_t num_edge;
+
+	if (channel >= EMIOS_ICU_IP_NUM_OF_CHANNELS) {
+		LOG_ERR("Invalid channel %d", channel);
+		return -EINVAL;
+	}
+
+	if (eMios_Icu_Ip_IndexInChState[config->instance][channel] >=
+		EMIOS_ICU_IP_NUM_OF_CHANNELS_USED) {
+		LOG_ERR("Channel %d is not configured for PWM", channel);
+		return -EINVAL;
+	}
+
+	if (!data->capture[channel].callback) {
+		LOG_ERR("Callback is not configured");
+		return -EINVAL;
+	}
+
+	/* If interrupt is enabled --> channel is on-going */
+	if (config->base->CH.UC[channel].C & eMIOS_C_FEN_MASK) {
+		LOG_ERR("Channel %d is busy", channel);
+		return -EBUSY;
+	}
+
+	/* If just measure period, we just need 2 edges */
+	if (data->capture[channel].period_capture && !data->capture[channel].pulse_capture) {
+		num_edge = 2U;
+		edge = EMIOS_ICU_RISING_EDGE;
+	} else {
+		num_edge = 3U;
+		edge = EMIOS_ICU_BOTH_EDGES;
+	}
+
+	Emios_Icu_Ip_SetActivation(config->instance, channel, edge);
+
+	Emios_Icu_Ip_EnableNotification(config->instance, channel);
+
+	Emios_Icu_Ip_StartTimestamp(config->instance, channel,
+				    data->capture[channel].edge_buff,
+				    MAX_NUM_EDGE, num_edge);
+
+	return 0;
+}
+
+static int pwm_nxp_s32_capture_disable(const struct device *dev, uint32_t channel)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+
+	if (channel >= EMIOS_ICU_IP_NUM_OF_CHANNELS) {
+		LOG_ERR("Invalid channel %d", channel);
+		return -EINVAL;
+	}
+
+	if (eMios_Icu_Ip_IndexInChState[config->instance][channel] >=
+		EMIOS_ICU_IP_NUM_OF_CHANNELS_USED) {
+		LOG_ERR("Channel %d is not configured for PWM", channel);
+		return -EINVAL;
+	}
+
+	Emios_Icu_Ip_StopTimestamp(config->instance, channel);
+
+	return 0;
+}
+
+static int pwm_nxp_s32_get_master_bus(const struct device *dev, uint32_t channel)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+	uint8_t bus_select, master_bus;
+
+	bus_select = (config->base->CH.UC[channel].C & eMIOS_C_BSL_MASK) >> eMIOS_C_BSL_SHIFT;
+
+	switch (bus_select) {
+	case 0:
+		master_bus = 23U;
+		break;
+	case 1:
+		master_bus = (channel < 8U) ? 0U : ((channel < 16U) ? 8U : 16U);
+		break;
+	case 2:
+		master_bus = 22U;
+		break;
+	default:
+		/* Default is internal counter */
+		master_bus = channel;
+		break;
+	}
+
+	return master_bus;
+}
+#endif
+
 static int pwm_nxp_s32_get_cycles_per_sec(const struct device *dev,
 					  uint32_t channel,
-					uint64_t *cycles)
+					  uint64_t *cycles)
 {
 	const struct pwm_nxp_s32_config *config = dev->config;
 	struct pwm_nxp_s32_data *data = dev->data;
@ -205,12 +403,19 @@ static int pwm_nxp_s32_get_cycles_per_sec(const struct device *dev,

 #if EMIOS_PWM_IP_USED
 	if (eMios_Pwm_Ip_IndexInChState[config->instance][channel] <
-		EMIOS_PWM_IP_NUM_OF_CHANNELS_USED) {
+	    EMIOS_PWM_IP_NUM_OF_CHANNELS_USED) {
 		master_bus = Emios_Pwm_Ip_GetMasterBusChannel(config->instance, channel);
 	}
 #endif

-	if (master_bus == 0xFFU) {
+#ifdef CONFIG_PWM_CAPTURE
+	if (eMios_Icu_Ip_IndexInChState[config->instance][channel] <
+	    EMIOS_ICU_IP_NUM_OF_CHANNELS_USED) {
+		master_bus = pwm_nxp_s32_get_master_bus(dev, channel);
+	}
+#endif
+
+	if (master_bus == 0xFF) {
 		LOG_ERR("Channel %d is not configured for PWM", channel);
 		return -EINVAL;
 	}
@ -253,6 +458,61 @@ static int pwm_nxp_s32_pulse_gen_init(const struct device *dev)
 }
 #endif

+#ifdef CONFIG_PWM_CAPTURE
+static int pwm_nxp_s32_pulse_capture_init(const struct device *dev)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+
+	const eMios_Icu_Ip_ChannelConfigType *icu_info;
+
+	uint8_t ch_id;
+	static uint8_t logic_ch;
+
+	for (ch_id = 0; ch_id < config->icu_cfg->nNumChannels; ch_id++) {
+		icu_info = &(*config->icu_cfg->pChannelsConfig)[ch_id];
+		eMios_Icu_Ip_IndexInChState[config->instance][icu_info->hwChannel] = logic_ch++;
+	}
+
+	if (Emios_Icu_Ip_Init(config->instance, config->icu_cfg)) {
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static void pwm_nxp_s32_capture_callback(const struct device *dev, uint32_t channel)
+{
+	const struct pwm_nxp_s32_config *config = dev->config;
+	struct pwm_nxp_s32_data *data = dev->data;
+
+	uint32_t period = 0, pulse = 0;
+
+	if (data->capture[channel].period_capture && !data->capture[channel].pulse_capture) {
+		period = pwm_nxp_s32_capture_calc(data->capture[channel].edge_buff[0],
+						 data->capture[channel].edge_buff[1]);
+	} else {
+		if (data->capture[channel].pulse_capture) {
+			pulse = pwm_nxp_s32_pulse_calc(data->capture[channel].inverted,
+						       data->capture[channel].edge_buff,
+						       Emios_Icu_Ip_GetInputLevel(config->instance,
+										  channel));
+		}
+
+		if (data->capture[channel].period_capture) {
+			period = pwm_nxp_s32_capture_calc(data->capture[channel].edge_buff[0],
+							  data->capture[channel].edge_buff[2]);
+		}
+	}
+
+	if (!data->capture[channel].continuous) {
+		Emios_Icu_Ip_StopTimestamp(config->instance, channel);
+	}
+
+	data->capture[channel].callback(dev, channel, period, pulse, 0,
+					data->capture[channel].user_data);
+}
+#endif
+
 static int pwm_nxp_s32_init(const struct device *dev)
 {
 	const struct pwm_nxp_s32_config *config = dev->config;
@ -281,12 +541,24 @@ static int pwm_nxp_s32_init(const struct device *dev)
 	}
 #endif

+#ifdef CONFIG_PWM_CAPTURE
+	err = pwm_nxp_s32_pulse_capture_init(dev);
+	if (err < 0) {
+		return err;
+	}
+#endif
+
 	return err;
 }

 static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	.set_cycles = pwm_nxp_s32_set_cycles,
 	.get_cycles_per_sec = pwm_nxp_s32_get_cycles_per_sec,
+#ifdef CONFIG_PWM_CAPTURE
+	.configure_capture = pwm_nxp_s32_capture_configure,
+	.enable_capture = pwm_nxp_s32_capture_enable,
+	.disable_capture = pwm_nxp_s32_capture_disable,
+#endif
 };

 /*
@ -307,6 +579,12 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 #define EMIOS_PWM_IS_MODE_OPWMB(node_id)							\
 	DT_ENUM_HAS_VALUE(node_id, pwm_mode, OPWMB)

+#define EMIOS_PWM_IS_MODE_SAIC(node_id)								\
+	DT_ENUM_HAS_VALUE(node_id, pwm_mode, SAIC)
+
+#define EMIOS_PWM_IS_CAPTURE_MODE(node_id)							\
+	EMIOS_PWM_IS_MODE_SAIC(node_id)
+
 #define EMIOS_PWM_LOG(node_id, msg)								\
 	DT_NODE_PATH(node_id) ": " DT_PROP(node_id, pwm_mode) ": " msg				\

@ -319,7 +597,9 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	BUILD_ASSERT(DT_NODE_HAS_PROP(node_id, duty_cycle),					\
 		     EMIOS_PWM_LOG(node_id, "duty-cycle must be configured"));			\
 	BUILD_ASSERT(DT_NODE_HAS_PROP(node_id, polarity),					\
-		     EMIOS_PWM_LOG(node_id, "polarity must be configured"));
+		     EMIOS_PWM_LOG(node_id, "polarity must be configured"));			\
+	BUILD_ASSERT(DT_NODE_HAS_PROP(node_id, input_filter),					\
+		     EMIOS_PWM_LOG(node_id, "input-filter is not used"));

 #define EMIOS_PWM_VERIFY_MODE_OPWFMB(node_id)							\
 	EMIOS_PWM_PULSE_GEN_COMMON_VERIFY(node_id)						\
@ -333,9 +613,9 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, master_bus),					\
 		     EMIOS_PWM_LOG(node_id, "master-bus must not be configured"));		\
 	BUILD_ASSERT(DT_PROP(node_id, dead_time) == 0,						\
-		     EMIOS_PWM_LOG(node_id, "dead-time must not be configured"));		\
+		     EMIOS_PWM_LOG(node_id, "dead-time is not used"));				\
 	BUILD_ASSERT(DT_PROP(node_id, phase_shift) == 0,					\
-		     EMIOS_PWM_LOG(node_id, "phase-shift must not be configured"));
+		     EMIOS_PWM_LOG(node_id, "phase-shift is not used"));

 #define EMIOS_PWM_VERIFY_MODE_OPWMCB(node_id)							\
 	EMIOS_PWM_PULSE_GEN_COMMON_VERIFY(node_id)						\
@ -348,15 +628,15 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	BUILD_ASSERT(DT_PROP(node_id, dead_time) <= DT_PROP(node_id, duty_cycle),		\
 		     EMIOS_PWM_LOG(node_id, "dead-time must <= duty-cycle"));			\
 	BUILD_ASSERT(DT_PROP(node_id, phase_shift) == 0,					\
-		     EMIOS_PWM_LOG(node_id, "phase-shift must not be configured"));		\
+		     EMIOS_PWM_LOG(node_id, "phase-shift is not used"));			\
 	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, period),					\
-		     EMIOS_PWM_LOG(node_id, "period must not be configured,"			\
+		     EMIOS_PWM_LOG(node_id, "period is not used,"				\
 		     " driver takes the value from master bus"));				\
 	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, prescaler),					\
-		     EMIOS_PWM_LOG(node_id, "prescaler must not be configured,"			\
+		     EMIOS_PWM_LOG(node_id, "prescaler is not used,"				\
 		     " driver takes the value from master bus"));				\
 	BUILD_ASSERT(DT_ENUM_HAS_VALUE(node_id, prescaler_src, PRESCALED_CLOCK),		\
-		     EMIOS_PWM_LOG(node_id, "prescaler-src must not be configured,"		\
+		     EMIOS_PWM_LOG(node_id, "prescaler-src is not used,"			\
 		     " always use prescalered source"));					\

 #define EMIOS_PWM_VERIFY_MODE_OPWMB(node_id)							\
@ -364,19 +644,46 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	BUILD_ASSERT(DT_ENUM_HAS_VALUE(DT_PHANDLE(node_id, master_bus),	mode, MCB_UP_COUNTER),	\
 		     EMIOS_PWM_LOG(node_id, "master-bus must be configured in MCB up"));	\
 	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, period),					\
-		     EMIOS_PWM_LOG(node_id, "period must not be configured,"			\
+		     EMIOS_PWM_LOG(node_id, "period is not used,"				\
 		     " driver takes the value from master bus"));				\
 	BUILD_ASSERT((DT_PROP(node_id, duty_cycle) + DT_PROP(node_id, phase_shift)) <=		\
 		     EMIOS_PWM_PERIOD_TIME_BASE(node_id),					\
 		     EMIOS_PWM_LOG(node_id, "duty-cycle + phase-shift must <= period"));	\
 	BUILD_ASSERT(DT_PROP(node_id, dead_time) == 0,						\
-		     EMIOS_PWM_LOG(node_id, "dead-time must not be configured"));		\
+		     EMIOS_PWM_LOG(node_id, "dead-time is not used"));				\
 	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, prescaler),					\
-		     EMIOS_PWM_LOG(node_id, "prescaler must not be configured"));		\
+		     EMIOS_PWM_LOG(node_id, "prescaler is not used"));				\
 	BUILD_ASSERT(DT_ENUM_HAS_VALUE(node_id, prescaler_src, PRESCALED_CLOCK),		\
-		     EMIOS_PWM_LOG(node_id, "prescaler-src must not be configured,"		\
+		     EMIOS_PWM_LOG(node_id, "prescaler-src is not used,"			\
 		     " always use prescalered source"));					\

+#define EMIOS_PWM_VERIFY_MODE_SAIC(node_id)							\
+	IF_ENABLED(DT_NODE_HAS_PROP(node_id, master_bus),					\
+		  (BUILD_ASSERT(								\
+		   DT_ENUM_HAS_VALUE(DT_PHANDLE(node_id, master_bus), mode, MCB_UP_COUNTER),	\
+		   EMIOS_PWM_LOG(node_id, "master-bus must be configured in MCB up"));))	\
+	IF_ENABLED(DT_NODE_HAS_PROP(node_id, master_bus),					\
+		  (BUILD_ASSERT(DT_PROP_BY_PHANDLE(node_id, master_bus, period) == 0xFFFF,	\
+		   EMIOS_PWM_LOG(node_id, "master-bus period must be 0xFFFF"));))		\
+	IF_ENABLED(UTIL_NOT(DT_NODE_HAS_PROP(node_id, master_bus)),				\
+		   (BUILD_ASSERT(								\
+		    BIT(DT_PROP(node_id, channel)) & DT_PROP(DT_GPARENT(node_id), internal_cnt),\
+		    EMIOS_PWM_LOG(node_id, "master-bus must be chosen,"				\
+		    " channel do not have has counter"))));					\
+	IF_ENABLED(UTIL_NOT(DT_NODE_HAS_PROP(node_id, master_bus)),				\
+		   (BUILD_ASSERT(DT_NODE_HAS_PROP(node_id, prescaler),				\
+		    EMIOS_PWM_LOG(node_id, "if use internal counter, prescaler must"		\
+		    " be configured"))));							\
+	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, duty_cycle),					\
+		     EMIOS_PWM_LOG(node_id, "duty-cycle is not used"));				\
+	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, polarity),					\
+		     EMIOS_PWM_LOG(node_id, "polarity is not used"));				\
+	BUILD_ASSERT(!DT_NODE_HAS_PROP(node_id, period),					\
+		     EMIOS_PWM_LOG(node_id, "period is not used"));				\
+	BUILD_ASSERT(DT_ENUM_HAS_VALUE(node_id, prescaler_src, PRESCALED_CLOCK),		\
+		     EMIOS_PWM_LOG(node_id, "prescaler-src is not used,"			\
+		     " always use prescalered source"));
+
 #define _EMIOS_PWM_VERIFY_CONFIG(node_id)							\
 	IF_ENABLED(DT_NODE_HAS_PROP(node_id, master_bus),					\
 		  (EMIOS_PWM_VERIFY_MASTER_BUS(node_id)))					\
@ -386,6 +693,8 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 		  (EMIOS_PWM_VERIFY_MODE_OPWMCB(node_id)))					\
 	IF_ENABLED(EMIOS_PWM_IS_MODE_OPWMB(node_id),						\
 		  (EMIOS_PWM_VERIFY_MODE_OPWMB(node_id)))					\
+	IF_ENABLED(EMIOS_PWM_IS_MODE_SAIC(node_id),						\
+		   (EMIOS_PWM_VERIFY_MODE_SAIC(node_id)))

 #if EMIOS_PWM_IP_USED
 /* Macros used to glue devicetree with RTD's definition */
@ -402,7 +711,8 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 #define EMIOS_PWM_PS_SRC(mode)		DT_CAT(EMIOS_PWM_IP_PS_SRC_, mode)

 #define _EMIOS_PWM_PULSE_GEN_CONFIG(node_id)							\
-	{											\
+	IF_ENABLED(UTIL_NOT(EMIOS_PWM_IS_CAPTURE_MODE(node_id)),				\
+	({											\
 		.ChannelId = DT_PROP(node_id, channel),						\
 		.Mode      = EMIOS_PWM_MODE(DT_STRING_TOKEN(node_id, pwm_mode)),		\
 		.InternalPsSrc = EMIOS_PWM_PS_SRC(DT_STRING_TOKEN(node_id, prescaler_src)),	\
@ -419,7 +729,7 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 		.DebugMode   = DT_PROP(node_id, freeze),					\
 		.PeriodCount = DT_PROP_OR(node_id, period, EMIOS_PWM_PERIOD_TIME_BASE(node_id)),\
 		.DutyCycle   = DT_PROP(node_id, duty_cycle),					\
-	},
+	},))

 #define EMIOS_PWM_PULSE_GEN_CONFIG(n)								\
 	const Emios_Pwm_Ip_ChannelConfigType emios_pwm_##n##_init[] = {				\
@ -437,6 +747,78 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 #define EMIOS_PWM_PULSE_GEN_GET_CONFIG(n)
 #endif

+#ifdef CONFIG_PWM_CAPTURE
+/* Macros used to glue devicetree with RTD's definition */
+#define EMIOS_ICU_BUS_A				EMIOS_ICU_BUS_A
+#define EMIOS_ICU_BUS_B				EMIOS_ICU_BUS_DIVERSE
+#define EMIOS_ICU_BUS_C				EMIOS_ICU_BUS_DIVERSE
+#define EMIOS_ICU_BUS_D				EMIOS_ICU_BUS_DIVERSE
+#define EMIOS_ICU_BUS_E				EMIOS_ICU_BUS_DIVERSE
+#define EMIOS_ICU_BUS_F				EMIOS_ICU_BUS_F
+
+#define DIGITAL_FILTER_0			EMIOS_DIGITAL_FILTER_BYPASSED
+#define DIGITAL_FILTER_2			EMIOS_DIGITAL_FILTER_02
+#define DIGITAL_FILTER_4			EMIOS_DIGITAL_FILTER_04
+#define DIGITAL_FILTER_8			EMIOS_DIGITAL_FILTER_08
+#define DIGITAL_FILTER_16			EMIOS_DIGITAL_FILTER_16
+
+#define EMIOS_PWM_CAPTURE_FILTER(filter)	DT_CAT(DIGITAL_FILTER_, filter)
+#define EMIOS_PWM_CAPTURE_MODE(mode)		DT_CAT(EMIOS_ICU_, mode)
+#define EMIOS_PWM_CAPTURE_BUS(mode)		DT_CAT(EMIOS_ICU_, mode)
+
+#define EMIOS_PWM_CAPTURE_CB(n, ch)								\
+	DT_CAT5(pwm_nxp_s32_, n, _channel_, ch, _capture_callback)
+
+#define EMIOS_PWM_CALLBACK_DECLARE(node_id, n)							\
+	void EMIOS_PWM_CAPTURE_CB(n, DT_PROP(node_id, channel))(void)				\
+	{											\
+		pwm_nxp_s32_capture_callback(DEVICE_DT_INST_GET(n), DT_PROP(node_id, channel));	\
+	}											\
+
+#define _EMIOS_PWM_PULSE_CAPTURE_CONFIG(node_id, n)						\
+	IF_ENABLED(EMIOS_PWM_IS_CAPTURE_MODE(node_id),						\
+	({											\
+		.hwChannel = DT_PROP(node_id, channel),						\
+		.ucMode	   = EMIOS_PWM_CAPTURE_MODE(DT_STRING_TOKEN(node_id, pwm_mode)),	\
+		.FreezeEn  = DT_PROP(node_id, freeze),						\
+		.Prescaler = COND_CODE_1(DT_NODE_HAS_PROP(node_id, master_bus),			\
+					(DT_PROP_BY_PHANDLE(node_id, master_bus, prescaler)),	\
+					(DT_PROP(node_id, prescaler))) - 1,			\
+		.CntBus    = COND_CODE_1(DT_NODE_HAS_PROP(node_id, master_bus),			\
+			     (EMIOS_PWM_CAPTURE_BUS(DT_STRING_TOKEN(				\
+						    DT_PHANDLE(node_id, master_bus), bus_type))),\
+			      (EMIOS_ICU_BUS_INTERNAL_COUNTER)),				\
+		.chMode    = EMIOS_ICU_MODE_TIMESTAMP,						\
+		.chSubMode = EMIOS_ICU_MODE_WITHOUT_DMA,					\
+		.measurementMode = EMIOS_ICU_NO_MEASUREMENT,					\
+		.edgeAlignement  = EMIOS_ICU_BOTH_EDGES,					\
+		.Filter   = EMIOS_PWM_CAPTURE_FILTER(DT_PROP(node_id, input_filter)),		\
+		.callback = NULL_PTR,								\
+		.logicChStateCallback = NULL_PTR,						\
+		.callbackParams      = 255U,							\
+		.bWithoutInterrupt   = FALSE,							\
+		.timestampBufferType = EMIOS_ICU_CIRCULAR_BUFFER,				\
+		.eMiosChannelNotification = EMIOS_PWM_CAPTURE_CB(n, DT_PROP(node_id, channel)),	\
+		.eMiosOverflowNotification = NULL_PTR,						\
+	},))
+
+#define EMIOS_PWM_PULSE_CAPTURE_CONFIG(n)							\
+	DT_INST_FOREACH_CHILD_STATUS_OKAY_VARGS(n, EMIOS_PWM_CALLBACK_DECLARE, n)		\
+	const eMios_Icu_Ip_ChannelConfigType emios_pwm_##n##_capture_init[] = {			\
+		DT_INST_FOREACH_CHILD_STATUS_OKAY_VARGS(n, _EMIOS_PWM_PULSE_CAPTURE_CONFIG, n)	\
+	};											\
+	const eMios_Icu_Ip_ConfigType emios_pwm_##n##_capture_info = {				\
+		.nNumChannels = ARRAY_SIZE(emios_pwm_##n##_capture_init),			\
+		.pChannelsConfig = &emios_pwm_##n##_capture_init,				\
+	};
+
+#define EMIOS_PWM_PULSE_CAPTURE_GET_CONFIG(n)							\
+	.icu_cfg = (eMios_Icu_Ip_ConfigType *)&emios_pwm_##n##_capture_info,
+#else
+#define EMIOS_PWM_PULSE_CAPTURE_CONFIG(n)
+#define EMIOS_PWM_PULSE_CAPTURE_GET_CONFIG(n)
+#endif
+
 #define EMIOS_PWM_VERIFY_CONFIG(n)								\
 	DT_INST_FOREACH_CHILD_STATUS_OKAY(n, _EMIOS_PWM_VERIFY_CONFIG)

@ -450,6 +832,7 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 	PINCTRL_DT_INST_DEFINE(n);								\
 	EMIOS_PWM_VERIFY_CONFIG(n)								\
 	EMIOS_PWM_PULSE_GEN_CONFIG(n)								\
+	EMIOS_PWM_PULSE_CAPTURE_CONFIG(n)							\
 	static const struct pwm_nxp_s32_config pwm_nxp_s32_config_##n = {			\
 		.base = (eMIOS_Type *)DT_REG_ADDR(DT_INST_PARENT(n)),				\
 		.instance = EMIOS_NXP_S32_GET_INSTANCE(DT_INST_PARENT(n)),			\
@ -457,6 +840,7 @@ static const struct pwm_driver_api pwm_nxp_s32_driver_api = {
 		.clock_subsys = (clock_control_subsys_t)DT_CLOCKS_CELL(DT_INST_PARENT(n), name),\
 		.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n),					\
 		EMIOS_PWM_PULSE_GEN_GET_CONFIG(n)						\
+		EMIOS_PWM_PULSE_CAPTURE_GET_CONFIG(n)						\
 	};											\
 	static struct pwm_nxp_s32_data pwm_nxp_s32_data_##n;					\
 	DEVICE_DT_INST_DEFINE(n,								\
--- a/dts/arm/nxp/nxp_s32k344_m7.dtsi
+++ b/dts/arm/nxp/nxp_s32k344_m7.dtsi
@ -626,6 +626,7 @@
 					<64 0>, <65 0>, <66 0>;
 			interrupt-names = "0_0", "0_1", "0_2",
 					"0_3", "0_4", "0_5";
+			internal-cnt = <0xC101FF>;
 			status = "disabled";

 			master_bus {
@ -680,6 +681,7 @@
 					<72 0>, <73 0>, <74 0>;
 			interrupt-names = "1_0", "1_1", "1_2",
 					"1_3", "1_4", "1_5";
+			internal-cnt = <0xC10101>;
 			status = "disabled";

 			master_bus {
@ -734,6 +736,7 @@
 					<80 0>, <81 0>, <82 0>;
 			interrupt-names = "2_0", "2_1", "2_2",
 					"2_3", "2_4", "2_5";
+			internal-cnt = <0xC10101>;
 			status = "disabled";

 			master_bus {
--- a/dts/bindings/misc/nxp,s32-emios.yaml
+++ b/dts/bindings/misc/nxp,s32-emios.yaml
@ -30,6 +30,12 @@ properties:
    description: |
      Clock divider value for the global prescaler. Could be in range [1 ... 256]

+  internal-cnt:
+    type: int
+    required: true
+    description: |
+      A mask for channels that have internal counter, lsb is channel 0.
+
 child-binding:
  child-binding:
    description: |
--- a/dts/bindings/pwm/nxp,s32-emios-pwm.yaml
+++ b/dts/bindings/pwm/nxp,s32-emios-pwm.yaml
@ -7,8 +7,12 @@ description: |
  some modes only support on channels that have internal counter, some modes
  require to use a reference timebase from a master bus.

-  For example to configuring eMIOS instance 0 with channel 0 for mode OPWFMB, channel 1
-  for mode OPWMB and channel 2 for mode OPWMCB with deadtime inserted at leading edge:
+  For example to configuring eMIOS instance 0 with:
+    - Channel 0 for mode OPWFMB
+    - Channel 1 for mode OPWMB
+    - Channel 2 for mode OPWMCB with deadtime inserted at leading edge
+    - Channel 3 for mode SAIC, use internal timebase with input filter = 2 eMIOS clock
+
    emios0_pwm: pwm {
      pwm_0 {
        channel = <0>;
@ -36,6 +40,13 @@ description: |
        dead-time = <100>;
        polarity = "ACTIVE_LOW";
      };
+
+      pwm_3 {
+        channel = <3>;
+        pwm-mode = "SAIC";
+        prescaler = <8>;
+        input-filter = <2>;
+      };
    };

  OPWMB and OPWMCB modes use reference timebase, the master bus is chosen over
@ -79,7 +90,9 @@ child-binding:
      description: |
        A phandle to master-bus node that will be used as external timebase
        for current channel, this can be bypassed if internal counter is used
-        for PWM operation.
+        for PWM operation. A master bus must be used exclusively, such as if
+        is used as a timebase for a channel in SAIC mode, do not use that
+        master bus as a timebase for generate PWM pulse.

    pwm-mode:
      type: string
@ -100,15 +113,19 @@ child-binding:
                  an external counter driven in MCB Up Down Mode. Changing PWM period
                  at runtime will impact to all channels share the same timebase,
                  The new period and cycle take effect in next period boundary.
+
+        - SAIC: single action input capture mode, the eMIOS captures events as soon as
+                they occur. The value of latest captured event is stored and can be read
+                by software.
      enum:
        - "OPWFMB"
        - "OPWMB"
        - "OPWMCB_TRAIL_EDGE"
        - "OPWMCB_LEAD_EDGE"
+        - "SAIC"

    polarity:
      type: string
-      required: true
      description: |
        Output polarity for PWM channel.
      enum:
@ -117,7 +134,6 @@ child-binding:

    duty-cycle:
      type: int
-      required: true
      description: |
        Duty-cycle (in ticks) for PWM channel at boot time.

@ -157,3 +173,13 @@ child-binding:
      default: 0
      description: |
        Phase Shift (in ticks) for PWM channel in OPWMB mode.
+
+    input-filter:
+      type: int
+      default: 0
+      enum: [0, 2, 4, 8, 16]
+      description: |
+        Select the minimim input pulse width, in filter clock cycles that can pass
+        through the input filter. The filter latency - the difference in time between
+        the input and the response is three clock edges. Default 0 means the filter
+        is bypassed. The clock source for programmable input filter is eMIOS clock.