counter_renesas_ra_agt.c

/*
 * Copyright (c) 2024-2025 Renesas Electronics Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#define DT_DRV_COMPAT renesas_ra_agt_counter

#include <soc.h>
#include <zephyr/kernel.h>
#include <zephyr/irq.h>
#include <zephyr/drivers/counter.h>

#include "r_agt.h"
#include "rp_agt.h"

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(counter_renesas_ra_agt, CONFIG_COUNTER_LOG_LEVEL);

struct counter_renesas_ra_agt_config {
	struct counter_config_info info;
	void (*irq_config_func)(void);
};

struct counter_renesas_ra_agt_data {
	struct st_agt_instance_ctrl agt_ctrl;
	struct st_timer_cfg agt_cfg;
	struct st_agt_extended_cfg agt_extend_cfg;
	IRQn_Type agtcmai_irq;
	uint8_t agtcmai_ipl;
	uint32_t guard_period;
	counter_alarm_callback_t alarm_cb;
	counter_top_callback_t top_cb;
	void *alarm_data;
	void *top_data;
	struct k_spinlock lock;
};

extern void agt_int_isr(void);
extern void agtcmai_isr(void);

static inline bool renesas_ra_agt_is_running(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;

	return data->agt_ctrl.is_agtw ? (data->agt_ctrl.p_reg->AGT32.CTRL.AGTCR_b.TCSTF == 1)
				      : (data->agt_ctrl.p_reg->AGT16.CTRL.AGTCR_b.TCSTF == 1);
}

static inline int renesas_ra_agt_period_set(const struct device *dev, uint32_t period)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	const bool counting = renesas_ra_agt_is_running(dev);
	fsp_err_t err;

	if (counting) {
		err = R_AGT_Stop(&data->agt_ctrl);
		if (err != FSP_SUCCESS) {
			return -EIO;
		}
	}

	err = R_AGT_PeriodSet(&data->agt_ctrl, period);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	if (counting) {
		err = R_AGT_Start(&data->agt_ctrl);
		if (err != FSP_SUCCESS) {
			return -EIO;
		}
	}

	return 0;
}

static inline int renesas_ra_agt_compare_match_set(const struct device *dev, uint32_t val)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	const bool counting = renesas_ra_agt_is_running(dev);
	fsp_err_t err;

	if (counting) {
		err = R_AGT_Stop(&data->agt_ctrl);
		if (err != FSP_SUCCESS) {
			return -EIO;
		}
	}

	err = RP_AGT_CompareMatchSet(&data->agt_ctrl, val, TIMER_COMPARE_MATCH_A);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	if (counting) {
		err = R_AGT_Start(&data->agt_ctrl);
		if (err != FSP_SUCCESS) {
			return -EIO;
		}
	}

	return 0;
}

static inline k_spinlock_key_t counter_renesas_ra_agt_lock(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;

	return k_spin_lock(&data->lock);
}

static inline void counter_renesas_ra_agt_unlock(const struct device *dev, k_spinlock_key_t key)
{
	struct counter_renesas_ra_agt_data *data = dev->data;

	k_spin_unlock(&data->lock, key);
}

static int counter_renesas_ra_agt_start(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	fsp_err_t err;

	err = R_AGT_Start(&data->agt_ctrl);
	if (err != FSP_SUCCESS) {
		LOG_DBG("Counter start failed");
		return -EIO;
	}

	return 0;
}

static int counter_renesas_ra_agt_stop(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	fsp_err_t err;

	err = R_AGT_Stop(&data->agt_ctrl);
	if (err != FSP_SUCCESS) {
		LOG_DBG("Counter stop failed");
		return -EIO;
	}

	return 0;
}

static int counter_renesas_ra_agt_get_value(const struct device *dev, uint32_t *ticks)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	timer_status_t status;
	fsp_err_t err;

	err = R_AGT_StatusGet(&data->agt_ctrl, &status);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	*ticks = status.counter;

	return 0;
}

static uint32_t counter_renesas_ra_agt_get_top_value(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;

	return data->agt_ctrl.period;
}

static int counter_renesas_ra_agt_set_top_value(const struct device *dev,
						const struct counter_top_cfg *cfg)
{
	const struct counter_renesas_ra_agt_config *config = dev->config;
	struct counter_renesas_ra_agt_data *data = dev->data;
	k_spinlock_key_t key = counter_renesas_ra_agt_lock(dev);
	bool reset = false;
	uint32_t now = 0;
	fsp_err_t err;
	int ret = 0;

	if (cfg->ticks > config->info.max_top_value) {
		LOG_DBG("Top value exceed maximum value");
		ret = -EINVAL;
		goto out;
	}

	ret = renesas_ra_agt_period_set(dev, cfg->ticks);
	if (ret != 0) {
		LOG_DBG("Counter period set failed");
		goto out;
	}

	if (cfg->callback != NULL) {
		if (data->agt_cfg.cycle_end_irq == BSP_IRQ_DISABLED) {
			ret = -ENOTSUP;
			goto out;
		}

		irq_enable(data->agt_cfg.cycle_end_irq);
	} else {
		if (data->agt_cfg.cycle_end_ipl != BSP_IRQ_DISABLED) {
			irq_disable(data->agt_cfg.cycle_end_irq);
		}
	}

	data->top_cb = cfg->callback;
	data->top_data = cfg->user_data;

	if ((cfg->flags & COUNTER_TOP_CFG_DONT_RESET) == 0) {
		reset = true;
	} else if ((cfg->flags & COUNTER_TOP_CFG_RESET_WHEN_LATE) != 0) {
		ret = counter_renesas_ra_agt_get_value(dev, &now);
		if (ret != 0) {
			goto out;
		}

		reset = cfg->ticks < now;
	} else {
		;
	}

	if (reset) {
		err = R_AGT_Reset(&data->agt_ctrl);
		if (err != FSP_SUCCESS) {
			LOG_DBG("Counter reset failed");
			ret = -EIO;
			goto out;
		}
	}
out:
	counter_renesas_ra_agt_unlock(dev, key);
	return ret;
}

static inline uint32_t ticks_sub(uint32_t val, uint32_t old, uint32_t top)
{
	if (likely(IS_BIT_MASK(top))) {
		return (val - old) & top;
	}

	/* if top is not 2^n-1 */
	return (val >= old) ? (val - old) : val + top + 1 - old;
}

static int renesas_ra_agt_abs_alarm_set(const struct device *dev, uint32_t val, uint32_t top,
					bool irq_on_late)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	uint32_t max_val;
	uint32_t read_again;
	fsp_err_t err;
	int ret;

	ret = renesas_ra_agt_compare_match_set(dev, val);
	if (ret != 0) {
		return ret;
	}

	ret = counter_renesas_ra_agt_get_value(dev, &read_again);
	if (ret != 0) {
		return ret;
	}

	max_val = ticks_sub(read_again + top, data->guard_period, top);
	if (val > max_val) {
		if (irq_on_late) {
			k_irq_set_pending(data->agtcmai_irq);
		} else {
			data->alarm_cb = NULL;
		}

		ret = -ETIME;
	}

	err = RP_AGT_EventSet(&data->agt_ctrl, TIMER_AGT_AGTCMAI, true);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	irq_enable(data->agtcmai_irq);

	return ret;
}

static int renesas_ra_agt_rel_alarm_set(const struct device *dev, uint32_t val, uint32_t top,
					bool irq_on_late)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	uint32_t max_rel_val = irq_on_late ? (top / 2) : top;
	uint32_t diff;
	uint32_t now;
	fsp_err_t err;
	int ret;

	ret = counter_renesas_ra_agt_get_value(dev, &now);
	if (ret != 0) {
		return ret;
	}

	val = ticks_sub(now, val, top);

	ret = renesas_ra_agt_compare_match_set(dev, val);
	if (ret != 0) {
		return ret;
	}

	ret = counter_renesas_ra_agt_get_value(dev, &now);
	if (ret != 0) {
		return ret;
	}

	diff = ticks_sub(now, val, top);

	if (diff > max_rel_val || diff == 0) {
		if (irq_on_late) {
			k_irq_set_pending(data->agtcmai_irq);
		} else {
			data->alarm_cb = NULL;
		}
	}

	err = RP_AGT_EventSet(&data->agt_ctrl, TIMER_AGT_AGTCMAI, true);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	irq_enable(data->agtcmai_irq);

	return 0;
}

static int counter_renesas_ra_agt_set_alarm(const struct device *dev, uint8_t chan,
					    const struct counter_alarm_cfg *alarm_cfg)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	const uint32_t top = counter_renesas_ra_agt_get_top_value(dev);
	const bool absolute = (alarm_cfg->flags & COUNTER_ALARM_CFG_ABSOLUTE) != 0;
	const bool irq_on_late =
		absolute ? (alarm_cfg->flags & COUNTER_ALARM_CFG_EXPIRE_WHEN_LATE) != 0
			 : alarm_cfg->ticks < (top / 2);
	int ret = 0;

	if (chan != 0) {
		ret = -EINVAL;
		goto out;
	}

	if (alarm_cfg->ticks > top) {
		ret = -EINVAL;
		goto out;
	}

	if (data->alarm_cb != NULL) {
		ret = -EBUSY;
		goto out;
	}

	if (data->agtcmai_irq == BSP_IRQ_DISABLED) {
		return -ENOTSUP;
	}

	data->alarm_cb = alarm_cfg->callback;
	data->alarm_data = alarm_cfg->user_data;

	if (absolute) {
		ret = renesas_ra_agt_abs_alarm_set(dev, alarm_cfg->ticks, top, irq_on_late);
	} else {
		ret = renesas_ra_agt_rel_alarm_set(dev, alarm_cfg->ticks, top, irq_on_late);
	}
out:
	return ret;
}

static int counter_renesas_ra_agt_cancel_alarm(const struct device *dev, uint8_t chan)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	k_spinlock_key_t key = counter_renesas_ra_agt_lock(dev);
	fsp_err_t err;
	int ret = 0;

	if (data->agtcmai_irq == BSP_IRQ_DISABLED) {
		ret = -ENOTSUP;
		goto out;
	}

	err = RP_AGT_EventSet(&data->agt_ctrl, TIMER_AGT_AGTCMAI, false);
	if (err != FSP_SUCCESS) {
		ret = -EIO;
		goto out;
	}

	irq_disable(data->agtcmai_irq);
	k_irq_clear_pending(data->agtcmai_irq);
	data->alarm_cb = NULL;
	data->alarm_data = NULL;
out:
	counter_renesas_ra_agt_unlock(dev, key);
	return ret;
}

static uint32_t counter_renesas_ra_agt_get_guard_period(const struct device *dev, uint32_t flags)
{
	struct counter_renesas_ra_agt_data *data = dev->data;

	return data->guard_period;
}

static int counter_renesas_ra_agt_set_guard_period(const struct device *dev, uint32_t guard,
						   uint32_t flags)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	k_spinlock_key_t key = counter_renesas_ra_agt_lock(dev);
	int ret = 0;

	if (counter_renesas_ra_agt_get_top_value(dev) < guard) {
		LOG_DBG("Invalid guard rate");
		ret = -EINVAL;
		goto out;
	}

	data->guard_period = guard;
out:
	counter_renesas_ra_agt_unlock(dev, key);
	return 0;
}

static uint32_t counter_renesas_ra_agt_get_pending_int(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	uint8_t event = 0;
	fsp_err_t err;

	err = RP_AGT_EventGet(&data->agt_ctrl, &event);
	if (err != FSP_SUCCESS) {
		LOG_DBG("Counter get status failed");
		return 0;
	}

	return (uint32_t)!!(
		event & (R_AGTX0_AGT16_CTRL_AGTCR_TCMAF_Msk | R_AGTX0_AGT16_CTRL_AGTCR_TUNDF_Msk));
}

static uint32_t counter_renesas_ra_agt_get_freq(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	timer_info_t info;
	fsp_err_t err;

	err = R_AGT_InfoGet(&data->agt_ctrl, &info);
	if (err != FSP_SUCCESS) {
		LOG_DBG("Counter get freq failed");
		return -EIO;
	}

	return info.clock_frequency;
}

static int counter_renesas_ra_agt_init(const struct device *dev)
{
	const struct counter_renesas_ra_agt_config *cfg = dev->config;
	struct counter_renesas_ra_agt_data *data = dev->data;
	fsp_err_t err;

	err = R_AGT_Open(&data->agt_ctrl, &data->agt_cfg);
	if (err != FSP_SUCCESS) {
		return -EIO;
	}

	if (data->agtcmai_irq != BSP_IRQ_DISABLED) {
		R_FSP_IsrContextSet(data->agtcmai_irq, &data->agt_ctrl);
	}

	cfg->irq_config_func();

	return 0;
}

static void counter_renesas_ra_agt_agti_isr(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	counter_top_callback_t cb = data->top_cb;
	void *usr_data = data->top_data;

	if (cb != NULL) {
		cb(dev, usr_data);
	}

	agt_int_isr();
}

static void counter_renesas_ra_agt_agtcmai_isr(const struct device *dev)
{
	struct counter_renesas_ra_agt_data *data = dev->data;
	counter_alarm_callback_t cb = data->alarm_cb;
	void *usr_data = data->alarm_data;
	uint32_t now;

	if (cb != NULL) {
		data->alarm_cb = NULL;
		data->alarm_data = NULL;

		if (counter_renesas_ra_agt_get_value(dev, &now) != 0) {
			LOG_DBG("Error in counter alarm");
			return;
		}

		cb(dev, 0, now, usr_data);
	}

	agtcmai_isr();
}

static DEVICE_API(counter, agt_renesas_ra_driver_api) = {
	.start = counter_renesas_ra_agt_start,
	.stop = counter_renesas_ra_agt_stop,
	.get_value = counter_renesas_ra_agt_get_value,
	.set_alarm = counter_renesas_ra_agt_set_alarm,
	.cancel_alarm = counter_renesas_ra_agt_cancel_alarm,
	.set_top_value = counter_renesas_ra_agt_set_top_value,
	.get_pending_int = counter_renesas_ra_agt_get_pending_int,
	.get_top_value = counter_renesas_ra_agt_get_top_value,
	.get_freq = counter_renesas_ra_agt_get_freq,
	.get_guard_period = counter_renesas_ra_agt_get_guard_period,
	.set_guard_period = counter_renesas_ra_agt_set_guard_period,
};

#define TIMER(idx) DT_INST_PARENT(idx)

#define EVENT_AGT_INT(channel)       BSP_PRV_IELS_ENUM(CONCAT(EVENT_AGT, channel, _INT))
#define EVENT_AGT_COMPARE_A(channel) BSP_PRV_IELS_ENUM(CONCAT(EVENT_AGT, channel, _COMPARE_A))

#define AGT_IRQ_GET_BY_NAME(inst, name, cell)                                                      \
	COND_CODE_1(DT_IRQ_HAS_NAME(TIMER(inst), name), (DT_IRQ_BY_NAME(TIMER(inst), name, cell)), \
		    ((IRQn_Type) BSP_IRQ_DISABLED))

#define AGT_IRQ_CONFIG(inst, name, event, isr)                                                     \
	IF_ENABLED(DT_IRQ_HAS_NAME(TIMER(inst), name),                                             \
		   (R_ICU->IELSR[DT_IRQ_BY_NAME(TIMER(inst), name, irq)] = event;                  \
		    BSP_ASSIGN_EVENT_TO_CURRENT_CORE(event);                                       \
		    IRQ_CONNECT(DT_IRQ_BY_NAME(TIMER(inst), name, irq),                            \
				DT_IRQ_BY_NAME(TIMER(inst), name, priority),                       \
				isr, DEVICE_DT_INST_GET(inst), 0);                                 \
				irq_disable(DT_IRQ_BY_NAME(TIMER(inst), name, irq));))

#define COUNTER_AGT_DEVICE_INIT(inst)                                                              \
	static void counter_renesas_ra_agt##inst##_irq_config_func(void)                           \
	{                                                                                          \
		AGT_IRQ_CONFIG(inst, agti, EVENT_AGT_INT(DT_PROP(TIMER(inst), channel)),           \
			       counter_renesas_ra_agt_agti_isr);                                   \
		AGT_IRQ_CONFIG(inst, agtcmai, EVENT_AGT_COMPARE_A(DT_PROP(TIMER(inst), channel)),  \
			       counter_renesas_ra_agt_agtcmai_isr);                                \
	}                                                                                          \
                                                                                                   \
	struct counter_renesas_ra_agt_config counter_renesas_ra_agt_config##inst = {               \
		.info.max_top_value =                                                              \
			DT_PROP(TIMER(inst), renesas_resolution) >= 32                             \
				? UINT32_MAX                                                       \
				: BIT_MASK(DT_PROP(TIMER(inst), renesas_resolution)),              \
		.info.flags = (uint8_t)0U,                                                         \
		.info.channels = 1,                                                                \
		.irq_config_func = counter_renesas_ra_agt##inst##_irq_config_func,                 \
	};                                                                                         \
                                                                                                   \
	static struct counter_renesas_ra_agt_data counter_renesas_ra_agt_data##inst = {            \
		.agt_cfg =                                                                         \
			{                                                                          \
				.mode = TIMER_MODE_PERIODIC,                                       \
				.period_counts = DT_PROP(TIMER(inst), renesas_resolution) >= 32    \
							 ? UINT32_MAX                              \
							 : BIT_MASK(DT_PROP(TIMER(inst),           \
									    renesas_resolution)),  \
				.source_div = DT_PROP(TIMER(inst), renesas_prescaler),             \
				.channel = DT_PROP(TIMER(inst), channel),                          \
				.cycle_end_irq = AGT_IRQ_GET_BY_NAME(inst, agti, irq),             \
				.cycle_end_ipl = AGT_IRQ_GET_BY_NAME(inst, agti, priority),        \
				.p_extend = &counter_renesas_ra_agt_data##inst.agt_extend_cfg,     \
			},                                                                         \
		.agt_extend_cfg =                                                                  \
			{                                                                          \
				.count_source = DT_STRING_TOKEN_OR(                                \
					TIMER(inst), renesas_count_source, AGT_CLOCK_LOCO),        \
				.agtoab_settings_b.agtoa = AGT_PIN_CFG_DISABLED,                   \
				.agtoab_settings_b.agtob = AGT_PIN_CFG_DISABLED,                   \
				.agto = AGT_PIN_CFG_DISABLED,                                      \
				.measurement_mode = AGT_MEASURE_DISABLED,                          \
				.agtio_filter = AGT_AGTIO_FILTER_NONE,                             \
				.enable_pin = AGT_ENABLE_PIN_NOT_USED,                             \
				.trigger_edge = AGT_TRIGGER_EDGE_RISING,                           \
			},                                                                         \
		.agtcmai_irq = AGT_IRQ_GET_BY_NAME(inst, agtcmai, irq),                            \
		.agtcmai_ipl = AGT_IRQ_GET_BY_NAME(inst, agtcmai, priority),                       \
		.guard_period = 0,                                                                 \
	};                                                                                         \
                                                                                                   \
	DEVICE_DT_INST_DEFINE(inst, counter_renesas_ra_agt_init, NULL,                             \
			      &counter_renesas_ra_agt_data##inst,                                  \
			      &counter_renesas_ra_agt_config##inst, POST_KERNEL,                   \
			      CONFIG_COUNTER_INIT_PRIORITY, &agt_renesas_ra_driver_api);

DT_INST_FOREACH_STATUS_OKAY(COUNTER_AGT_DEVICE_INIT)