drivers/input/input_renesas_rx_ctsu.c

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

#define DT_DRV_COMPAT renesas_rx_ctsu

#include <zephyr/device.h>
#include <zephyr/input/input.h>
#include <zephyr/drivers/pinctrl.h>
#include <r_ctsu_qe_pinset.h>
#include <zephyr/kernel.h>
#include <zephyr/irq.h>
#include <zephyr/logging/log.h>
#include <soc.h>
#include <r_ctsu_qe_if.h>
#include <rm_touch_qe_if.h>
#include <zephyr/input/input_renesas_rx_ctsu.h>
#include <zephyr/dt-bindings/input/input-event-codes.h>

LOG_MODULE_REGISTER(renesas_rx_ctsu, CONFIG_INPUT_LOG_LEVEL);

#define BUTTON_TYPE 0
#define SLIDER_TYPE 1
#define WHEEL_TYPE  2

#define MAX_TUNING_LOOP_COUNT 1024

typedef enum {
	INITIALIZING = 0,
	TUNING = 1,
	SCANNING = 2,
} working_phase_t;

enum touch_event {
	RELEASE = 0, /* state change from TOUCHING to UNTOUCH */
	PRESS = 1,   /* state change from UNTOUCH to TOUCHING */
};

/** Configuration of each TS channel */
typedef struct st_touch_channel_config {
	uint8_t channel_num;
	ctsu_element_cfg_t config;
} touch_channel_cfg_t;

/** Component context */
typedef struct st_buttons_context {
	/** TS channel of button */
	uint8_t element;
	/** Configuration for each button */
	touch_button_cfg_t config;
	/** Event for that will be reported to higher layer */
	uint16_t event;
} touch_button_context_t;

typedef struct st_sliders_context {
	/** Array of TS channels used in slider */
	uint8_t *p_elements;
	/** Configuration for each slider */
	touch_slider_cfg_t config;
	/** Event for that will be reported to higher layer */
	uint16_t event;
} touch_slider_context_t;

typedef struct st_wheels_context {
	/** Array of TS channels used in wheel */
	uint8_t *p_elements;
	/** Configuration for each wheel */
	touch_wheel_cfg_t config;
	/** Event that will be reported to higher layer */
	uint16_t event;
} touch_wheel_context_t;

struct renesas_rx_ctsu_config {
	const struct pinctrl_dev_config *pcfg;
	/** CTSU channels config */
	touch_channel_cfg_t *channel_cfgs;
	uint8_t *channels_index_map;
	uint8_t *button_position_index;
	/** Touch components */
	touch_button_context_t *buttons;
	touch_slider_context_t *sliders;
	touch_wheel_context_t *wheels;
};

struct renesas_rx_ctsu_data {
	const struct device *dev;
	/** Data processing */
	struct k_work data_process_work;
	struct k_work scan_work;
	struct k_timer scan_timer;
	struct k_sem tune_scan_end;
	working_phase_t work_phase;
	/** Touch instances */
	touch_instance_t touch_instance;
#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG
	touch_instance_ctrl_t touch_ctrl;
	touch_cfg_t touch_cfg;
	/** CTSU instances */
	ctsu_instance_t ctsu_instance;
	ctsu_instance_ctrl_t ctsu_ctrl;
	ctsu_cfg_t ctsu_cfg;
#endif /* CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */
	/** Touch driver output data */
	uint64_t curr_buttons_data;
	uint64_t prev_buttons_data;
	uint16_t *curr_sliders_position;
	uint16_t *prev_sliders_position;
	uint16_t *curr_wheels_position;
	uint16_t *prev_wheels_position;
};

void ctsu_ctsuend_isr(void);
void ctsu_ctsuwr_isr(void);
void ctsu_ctsurd_isr(void);

static void ctsuwr_isr(const struct device *dev)
{
	ARG_UNUSED(dev);
	ctsu_ctsuwr_isr();
}

static void ctsurd_isr(const struct device *dev)
{
	ARG_UNUSED(dev);
	ctsu_ctsurd_isr();
}

static void ctsufn_isr(const struct device *dev)
{
	ARG_UNUSED(dev);
	ctsu_ctsuend_isr();
}

static void ctsu_scan_callback(ctsu_callback_args_t *p_arg)
{
	const struct device *dev = p_arg->p_context;
	struct renesas_rx_ctsu_data *data = dev->data;

	if (data->work_phase == TUNING) {
		k_sem_give(&data->tune_scan_end);
		return;
	}

	if (data->work_phase != SCANNING || p_arg->event != CTSU_EVENT_SCAN_COMPLETE) {
		return;
	}

	k_work_submit(&data->data_process_work);
}

static void process_data(struct k_work *work)
{
	struct renesas_rx_ctsu_data *data =
		CONTAINER_OF(work, struct renesas_rx_ctsu_data, data_process_work);
	const struct device *dev = data->dev;
	const struct renesas_rx_ctsu_config *config = dev->config;
	fsp_err_t ret;

	ret = RM_TOUCH_DataGet(data->touch_instance.p_ctrl, &data->curr_buttons_data,
			       data->curr_sliders_position, data->curr_wheels_position);
	if (ret != FSP_SUCCESS) {
		LOG_ERR("CTSU: Failed to get data %d", ret);
		return;
	}

	/** Buttons */
	int changed_buttons = data->curr_buttons_data ^ data->prev_buttons_data;
	int button_position = 0;

	while (changed_buttons != 0) {
		if (changed_buttons & BIT(0)) {
			int index = config->button_position_index[button_position];

			input_report_key(dev, config->buttons[index].event,
					 data->curr_buttons_data & BIT(button_position), true,
					 K_FOREVER);
		}
		button_position++;
		changed_buttons = changed_buttons >> 1;
	}
	data->prev_buttons_data = data->curr_buttons_data;

	/** Sliders */
	for (int i = 0; i < data->touch_instance.p_cfg->num_sliders; i++) {
		if (data->curr_sliders_position[i] != data->prev_sliders_position[i]) {
			input_report_abs(dev, config->sliders[i].event,
					 data->curr_sliders_position[i], true, K_FOREVER);
		}
		data->prev_sliders_position[i] = data->curr_sliders_position[i];
	}

	/** Wheels */
	for (int i = 0; i < data->touch_instance.p_cfg->num_wheels; i++) {
		if (data->curr_wheels_position[i] != data->prev_wheels_position[i]) {
			input_report_abs(dev, config->wheels[i].event,
					 data->curr_wheels_position[i], true, K_FOREVER);
		}
		data->prev_wheels_position[i] = data->curr_wheels_position[i];
	}
}

static void timer_callback(struct k_timer *timer)
{
	struct renesas_rx_ctsu_data *data =
		CONTAINER_OF(timer, struct renesas_rx_ctsu_data, scan_timer);
	k_work_submit(&data->scan_work);
}

static void trigger_scan(struct k_work *work)
{
	struct renesas_rx_ctsu_data *data =
		CONTAINER_OF(work, struct renesas_rx_ctsu_data, scan_work);

	/** Start next scan */
	RM_TOUCH_ScanStart(data->touch_instance.p_ctrl);
}

#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG
static inline int set_scan_channel(const struct device *dev)
{
	struct renesas_rx_ctsu_data *data = dev->data;
	const struct renesas_rx_ctsu_config *config = dev->config;
	touch_channel_cfg_t *channel_cfgs = config->channel_cfgs;

	for (int i = 0; i < data->ctsu_cfg.num_rx; i++) {
		int cha_reg = channel_cfgs[i].channel_num / 8;
		int cha_pos = channel_cfgs[i].channel_num % 8;

		switch (cha_reg) {
		case 0:
			data->ctsu_cfg.ctsuchac0 |= (1 << cha_pos);
			break;
		case 1:
			data->ctsu_cfg.ctsuchac1 |= (1 << cha_pos);
			break;
		case 2:
			data->ctsu_cfg.ctsuchac2 |= (1 << cha_pos);
			break;
		case 3:
			data->ctsu_cfg.ctsuchac3 |= (1 << cha_pos);
			break;
		case 4:
			data->ctsu_cfg.ctsuchac4 |= (1 << cha_pos);
			break;
		default:
			LOG_ERR("Invalid TS channel");
			return -EINVAL;
		}
	}

	return 0;
}
#endif /* !CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */

static int input_renesas_rx_ctsu_configure(const struct device *dev,
					   const struct renesas_rx_ctsu_touch_cfg *cfg)
{
	struct renesas_rx_ctsu_data *data = dev->data;
	fsp_err_t ret;
	int tuning_loop_count = 0;

	data->touch_instance = cfg->touch_instance;

	k_sem_init(&data->tune_scan_end, 0, 1);

	/** Set initial states */
	for (int i = 0; i < data->touch_instance.p_cfg->num_sliders; i++) {
		data->prev_sliders_position[i] = TOUCH_OFF_VALUE;
		data->curr_sliders_position[i] = TOUCH_OFF_VALUE;
	}
	for (int i = 0; i < data->touch_instance.p_cfg->num_wheels; i++) {
		data->prev_wheels_position[i] = TOUCH_OFF_VALUE;
		data->curr_wheels_position[i] = TOUCH_OFF_VALUE;
	}

	data->work_phase = INITIALIZING;
	ret = RM_TOUCH_Open(data->touch_instance.p_ctrl, data->touch_instance.p_cfg);
	if (ret != FSP_SUCCESS) {
		LOG_ERR("CTSU Open failed");
		return -EIO;
	}

	ret = RM_TOUCH_CallbackSet(data->touch_instance.p_ctrl, ctsu_scan_callback, (void *)dev,
				   NULL);
	if (ret != FSP_SUCCESS) {
		LOG_ERR("CTSU Failed to set callback");
		return -EIO;
	}

	data->work_phase = TUNING;

	do {
		ret = RM_TOUCH_ScanStart(data->touch_instance.p_ctrl);
		if (ret != FSP_SUCCESS) {
			LOG_ERR("CTSU: Failed to start scan");
			return -EIO;
		}
		k_sem_take(&data->tune_scan_end, K_FOREVER);
		ret = RM_TOUCH_DataGet(data->touch_instance.p_ctrl, &data->curr_buttons_data,
				       data->curr_sliders_position, data->curr_wheels_position);
		tuning_loop_count++;
	} while (ret != FSP_SUCCESS && tuning_loop_count < MAX_TUNING_LOOP_COUNT);

	if (tuning_loop_count >= MAX_TUNING_LOOP_COUNT) {
		LOG_ERR("CTSU: Failed to tune the touch sensor");
		return -EIO;
	}

	data->dev = dev;

	/* Processing data handler */
	k_work_init(&data->data_process_work, process_data);

	/* Scanning trigger */
	k_work_init(&data->scan_work, trigger_scan);

	/* Timer for to set scanning work */
	k_timer_init(&data->scan_timer, timer_callback, NULL);

	/* Start first scan to ensure the scanning can run normally */
	data->work_phase = SCANNING;
	ret = RM_TOUCH_ScanStart(data->touch_instance.p_ctrl);
	if (ret != FSP_SUCCESS) {
		LOG_ERR("CTSU: Failed to start scan");
		return -EIO;
	}

	/* Start timer to periodically run scanning work */
	k_timer_start(&data->scan_timer, K_MSEC(CONFIG_INPUT_RENESAS_RX_CTSU_SCAN_INTERVAL_MS),
		      K_MSEC(CONFIG_INPUT_RENESAS_RX_CTSU_SCAN_INTERVAL_MS));

	return 0;
}

int z_impl_renesas_rx_ctsu_group_configure(const struct device *dev,
					   const struct renesas_rx_ctsu_touch_cfg *cfg)
{
#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG
	ARG_UNUSED(dev);
	ARG_UNUSED(cfg);
	return -ENOSYS;
#else
	return input_renesas_rx_ctsu_configure(dev, cfg);
#endif /* CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */
}

static int renesas_rx_ctsu_init(const struct device *dev)
{
#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG
	struct renesas_rx_ctsu_data *data = dev->data;
#endif /* !CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */
	const struct renesas_rx_ctsu_config *config = dev->config;
	int err;

	err = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
	if (err < 0) {
		LOG_ERR("CTSU: Failed to set pinctrl");
		return err;
	}

#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG

	err = set_scan_channel(dev);
	if (err < 0) {
		LOG_ERR("CTSU: Failed to set scan channel");
		return err;
	}

	data->ctsu_instance.p_ctrl = &data->ctsu_ctrl;
	data->ctsu_instance.p_cfg = &data->ctsu_cfg;
	data->ctsu_instance.p_api = &g_ctsu_on_ctsu;

	data->touch_cfg.p_ctsu_instance = &data->ctsu_instance;
	data->touch_instance.p_ctrl = &data->touch_ctrl;
	data->touch_instance.p_cfg = &data->touch_cfg;
	data->touch_instance.p_api = &g_touch_on_ctsu;

	return input_renesas_rx_ctsu_configure(
		dev, (const struct renesas_rx_ctsu_touch_cfg *)&data->touch_instance);
#else
	return 0;
#endif /* !CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */
}

#define CHANNEL_GET_CONFIG(node_id, prop, idx)                                                     \
	{                                                                                          \
		.channel_num = DT_PROP_BY_IDX(node_id, prop, idx),                                 \
		.config =                                                                          \
			{                                                                          \
				.ssdiv = DT_PROP(node_id, ssdiv),                                  \
				.so = DT_PROP(node_id, so),                                        \
				.snum = DT_PROP(node_id, snum),                                    \
				.sdpa = DT_PROP(node_id, sdpa),                                    \
			},                                                                         \
	},

#define CTSU_CHANNEL_CFG_INIT(node_id)                                                             \
	DT_FOREACH_PROP_ELEM(node_id, channels_num, CHANNEL_GET_CONFIG)

#define CTSU_GET_CHANNELS_COUNT(node_id) DT_PROP_LEN(node_id, channels_num)

#define BUTTON_GET_CONTEXT(node_id)                                                                \
	IF_ENABLED(IS_EQ(DT_ENUM_IDX(node_id, component_type), BUTTON_TYPE),                       \
	({                                                                                         \
		.element = DT_PROP_BY_IDX(node_id, channels_num, 0),                               \
		.config = {                                                                        \
			.elem_index = 0,                                                           \
			.threshold = DT_PROP(node_id, touch_count_threshold),                      \
			.hysteresis = DT_PROP(node_id, threshold_range),                           \
		},                                                                                 \
		.event = DT_PROP(node_id, zephyr_code),                                            \
	},))

#define SLIDER_GET_CONTEXT(node_id)                                                                \
	IF_ENABLED(IS_EQ(DT_ENUM_IDX(node_id, component_type), SLIDER_TYPE),                       \
	({                                                                                         \
		.p_elements = (uint8_t[])DT_PROP(node_id, channels_num),                           \
		.config = {                                                                        \
			.p_elem_index = NULL,                                                      \
			.num_elements = DT_PROP_LEN(node_id, channels_num),                        \
			.threshold = DT_PROP(node_id, touch_count_threshold),                      \
		},                                                                                 \
		.event = DT_PROP(node_id, zephyr_code),                                            \
	},))

#define WHEEL_GET_CONTEXT(node_id)                                                                 \
	IF_ENABLED(IS_EQ(DT_ENUM_IDX(node_id, component_type), WHEEL_TYPE),                        \
	({                                                                                         \
		.p_elements = (uint8_t[])DT_PROP(node_id, channels_num),                           \
		.config = {                                                                        \
			.p_elem_index = NULL,                                                      \
			.num_elements = DT_PROP_LEN(node_id, channels_num),                        \
			.threshold = DT_PROP(node_id, touch_count_threshold),                      \
		},                                                                                 \
		.event = DT_PROP(node_id, zephyr_code),                                            \
	},))

#define NUM_ELEMENTS(idx) DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(idx, CTSU_GET_CHANNELS_COUNT, (+))

#define COMPONENT_COUNT(node_id, type) IS_EQ(DT_ENUM_IDX(node_id, component_type), type)

#define COMPONENT_GET_COUNT_BY_TYPE(idx, type)                                                     \
	DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(idx, COMPONENT_COUNT, (+), type)

#ifndef CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG
#define CTSU_HAL_CONFIG_DEFINE(idx)                                                                \
	.ctsu_cfg =                                                                                \
		{                                                                                  \
			.cap = CTSU_CAP_SOFTWARE,                                                  \
			.md = CTSU_MODE_SELF_MULTI_SCAN,                                           \
			.num_rx = NUM_ELEMENTS(idx),                                               \
			.num_moving_average = CONFIG_INPUT_RENESAS_RX_CTSU_NUM_MOVING_AVERAGE,     \
			.atune1 = CONFIG_INPUT_RENESAS_RX_CTSU_POWER_SUPPLY_CAPACITY,              \
			.txvsel = CONFIG_INPUT_RENESAS_RX_CTSU_TRANSMISSION_POWER_SUPPLY,          \
			.ctsuchac0 = 0,                                                            \
			.ctsuchac1 = 0,                                                            \
			.ctsuchac2 = 0,                                                            \
			.ctsuchac3 = 0,                                                            \
			.ctsuchac4 = 0,                                                            \
			.ctsuchtrc0 = 0,                                                           \
			.ctsuchtrc1 = 0,                                                           \
			.ctsuchtrc2 = 0,                                                           \
			.ctsuchtrc3 = 0,                                                           \
			.ctsuchtrc4 = 0,                                                           \
			.tuning_enable = true,                                                     \
			.p_elements = ctsu_element_cfgs_##idx,                                     \
			.p_callback = ctsu_scan_callback,                                          \
			.p_context = NULL,                                                         \
	},                                                                                         \
	.touch_cfg = {                                                                             \
		.p_buttons = button_cfgs_##idx,                                                    \
		.num_buttons = COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE),                      \
		.p_sliders = slider_cfgs_##idx,                                                    \
		.num_sliders = COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE),                      \
		.p_wheels = wheel_cfgs_##idx,                                                      \
		.num_wheels = COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE),                        \
		.on_freq = CONFIG_INPUT_RENESAS_RX_CTSU_ON_FREQ,                                   \
		.off_freq = CONFIG_INPUT_RENESAS_RX_CTSU_OFF_FREQ,                                 \
		.drift_freq = CONFIG_INPUT_RENESAS_RX_CTSU_DRIFT_FREQ,                             \
		.cancel_freq = CONFIG_INPUT_RENESAS_RX_CTSU_CANCEL_FREQ,                           \
	},
#else
#define CTSU_HAL_CONFIG_DEFINE(idx)
#endif /* !CONFIG_INPUT_RENESAS_RX_QE_TOUCH_CFG */

#define RENESAS_RX_CTSU_INIT(idx)                                                                  \
	PINCTRL_DT_INST_DEFINE(idx);                                                               \
	static void ctsu_irq_config_func_##idx(void)                                               \
	{                                                                                          \
		IRQ_CONNECT(DT_INST_IRQ_BY_NAME(idx, ctsuwr, irq),                                 \
			    DT_INST_IRQ_BY_NAME(idx, ctsuwr, priority), ctsuwr_isr,                \
			    DEVICE_DT_INST_GET(idx), 0);                                           \
		IRQ_CONNECT(DT_INST_IRQ_BY_NAME(idx, ctsurd, irq),                                 \
			    DT_INST_IRQ_BY_NAME(idx, ctsurd, priority), ctsurd_isr,                \
			    DEVICE_DT_INST_GET(idx), 0);                                           \
		IRQ_CONNECT(DT_INST_IRQ_BY_NAME(idx, ctsufn, irq),                                 \
			    DT_INST_IRQ_BY_NAME(idx, ctsufn, priority), ctsufn_isr,                \
			    DEVICE_DT_INST_GET(idx), 0);                                           \
		irq_enable(DT_INST_IRQ_BY_NAME(idx, ctsuwr, irq));                                 \
		irq_enable(DT_INST_IRQ_BY_NAME(idx, ctsurd, irq));                                 \
		irq_enable(DT_INST_IRQ_BY_NAME(idx, ctsufn, irq));                                 \
	}                                                                                          \
                                                                                                   \
	static touch_channel_cfg_t ctsu_channel_cfgs_##idx[] = {                                   \
		DT_INST_FOREACH_CHILD_STATUS_OKAY(idx, CTSU_CHANNEL_CFG_INIT)};                    \
	static uint8_t channels_index_map_##idx[DT_PROP(DT_DRV_INST(idx), max_num_sensors)];       \
                                                                                                   \
	static ctsu_element_cfg_t ctsu_element_cfgs_##idx[NUM_ELEMENTS(idx)];                      \
                                                                                                   \
	static void sort_configs_by_channel_num##idx(void)                                         \
	{                                                                                          \
		memset(channels_index_map_##idx, 0xff, sizeof(channels_index_map_##idx));          \
		for (int i = 0; i < NUM_ELEMENTS(idx); i++) {                                      \
			int min_idx = i;                                                           \
			for (int j = i + 1; j < NUM_ELEMENTS(idx); j++) {                          \
				if (ctsu_channel_cfgs_##idx[j].channel_num <                       \
				    ctsu_channel_cfgs_##idx[min_idx].channel_num) {                \
					min_idx = j;                                               \
				}                                                                  \
			}                                                                          \
			if (min_idx != i) {                                                        \
				touch_channel_cfg_t tmp = ctsu_channel_cfgs_##idx[i];              \
				ctsu_channel_cfgs_##idx[i] = ctsu_channel_cfgs_##idx[min_idx];     \
				ctsu_channel_cfgs_##idx[min_idx] = tmp;                            \
			}                                                                          \
			ctsu_element_cfgs_##idx[i] = ctsu_channel_cfgs_##idx[i].config;            \
			channels_index_map_##idx[ctsu_channel_cfgs_##idx[i].channel_num] = i;      \
		}                                                                                  \
	}                                                                                          \
                                                                                                   \
	static touch_button_context_t buttons_##idx[] = {                                          \
		DT_INST_FOREACH_CHILD_STATUS_OKAY(idx, BUTTON_GET_CONTEXT)};                       \
	static touch_slider_context_t sliders_##idx[] = {                                          \
		DT_INST_FOREACH_CHILD_STATUS_OKAY(idx, SLIDER_GET_CONTEXT)};                       \
	static touch_wheel_context_t wheels_##idx[] = {                                            \
		DT_INST_FOREACH_CHILD_STATUS_OKAY(idx, WHEEL_GET_CONTEXT)};                        \
                                                                                                   \
	static touch_button_cfg_t                                                                  \
		button_cfgs_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE)];                  \
	static touch_slider_cfg_t                                                                  \
		slider_cfgs_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE)];                  \
	static touch_wheel_cfg_t wheel_cfgs_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE)];   \
                                                                                                   \
	static uint8_t sliders_element_index[COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE)]        \
					    [DT_PROP(DT_DRV_INST(idx), max_num_sensors)];          \
	static uint8_t wheels_element_index[COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE)]          \
					   [DT_PROP(DT_DRV_INST(idx), max_num_sensors)];           \
                                                                                                   \
	static uint8_t button_position_to_cfg_index##idx[COMPONENT_GET_COUNT_BY_TYPE(              \
		idx, BUTTON_TYPE)] = {0};                                                          \
                                                                                                   \
	static void map_component_cfgs##idx(void)                                                  \
	{                                                                                          \
		uint8_t temp[COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE)];                       \
		for (int i = 0; i < COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE); i++) {          \
			button_cfgs_##idx[i] = buttons_##idx[i].config;                            \
			button_cfgs_##idx[i].elem_index =                                          \
				channels_index_map_##idx[buttons_##idx[i].element];                \
			temp[i] = button_cfgs_##idx[i].elem_index;                                 \
			button_position_to_cfg_index##idx[i] = i;                                  \
		}                                                                                  \
		for (int i = 0; i < COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE) - 1; i++) {      \
			for (int j = i + 1; j < COMPONENT_GET_COUNT_BY_TYPE(idx, BUTTON_TYPE);     \
			     j++) {                                                                \
				if (temp[i] > temp[j]) {                                           \
					int tmp = temp[i];                                         \
					temp[i] = temp[j];                                         \
					temp[j] = tmp;                                             \
					tmp = button_position_to_cfg_index##idx[i];                \
					button_position_to_cfg_index##idx[i] =                     \
						button_position_to_cfg_index##idx[j];              \
					button_position_to_cfg_index##idx[j] = tmp;                \
				}                                                                  \
			}                                                                          \
		}                                                                                  \
		for (int i = 0; i < COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE); i++) {          \
			slider_cfgs_##idx[i] = sliders_##idx[i].config;                            \
			for (int j = 0; j < slider_cfgs_##idx[i].num_elements; j++) {              \
				sliders_element_index[i][j] =                                      \
					channels_index_map_##idx[sliders_##idx[i].p_elements[j]];  \
			}                                                                          \
			slider_cfgs_##idx[i].p_elem_index = sliders_element_index[i];              \
		}                                                                                  \
		for (int i = 0; i < COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE); i++) {           \
			wheel_cfgs_##idx[i] = wheels_##idx[i].config;                              \
			for (int j = 0; j < wheel_cfgs_##idx[i].num_elements; j++) {               \
				wheels_element_index[i][j] =                                       \
					channels_index_map_##idx[wheels_##idx[i].p_elements[j]];   \
			}                                                                          \
			wheel_cfgs_##idx[i].p_elem_index = wheels_element_index[i];                \
		}                                                                                  \
	}                                                                                          \
                                                                                                   \
	static const struct renesas_rx_ctsu_config renesas_rx_ctsu_config_##idx = {                \
		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(idx),                                       \
		.channel_cfgs = ctsu_channel_cfgs_##idx,                                           \
		.channels_index_map = channels_index_map_##idx,                                    \
		.button_position_index = button_position_to_cfg_index##idx,                        \
		.buttons = buttons_##idx,                                                          \
		.sliders = sliders_##idx,                                                          \
		.wheels = wheels_##idx,                                                            \
	};                                                                                         \
                                                                                                   \
	static uint16_t slider_prev_position_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE)]; \
	static uint16_t slider_curr_position_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, SLIDER_TYPE)]; \
	static uint16_t prev_wheels_position_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE)];  \
	static uint16_t curr_wheels_position_##idx[COMPONENT_GET_COUNT_BY_TYPE(idx, WHEEL_TYPE)];  \
                                                                                                   \
	static struct renesas_rx_ctsu_data renesas_rx_ctsu_data_##idx = {                          \
		.prev_buttons_data = 0,                                                            \
		.curr_buttons_data = 0,                                                            \
		.prev_sliders_position = slider_prev_position_##idx,                               \
		.curr_sliders_position = slider_curr_position_##idx,                               \
		.prev_wheels_position = prev_wheels_position_##idx,                                \
		.curr_wheels_position = curr_wheels_position_##idx,                                \
		.work_phase = INITIALIZING,                                                        \
		CTSU_HAL_CONFIG_DEFINE(idx)};                                                      \
                                                                                                   \
	static int renesas_rx_ctsu_init_##idx(const struct device *dev)                            \
	{                                                                                          \
		sort_configs_by_channel_num##idx();                                                \
		map_component_cfgs##idx();                                                         \
		ctsu_irq_config_func_##idx();                                                      \
		return renesas_rx_ctsu_init(dev);                                                  \
	}                                                                                          \
                                                                                                   \
	DEVICE_DT_INST_DEFINE(idx, &renesas_rx_ctsu_init_##idx, NULL, &renesas_rx_ctsu_data_##idx, \
			      &renesas_rx_ctsu_config_##idx, POST_KERNEL,                          \
			      CONFIG_INPUT_INIT_PRIORITY, NULL);

DT_INST_FOREACH_STATUS_OKAY(RENESAS_RX_CTSU_INIT)