drivers/input/input_analog_axis.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright 2023 Google LLC
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT analog_axis

 #include <stdlib.h>
 #include <zephyr/device.h>
 #include <zephyr/drivers/adc.h>
 #include <zephyr/input/input.h>
 #include <zephyr/input/input_analog_axis.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/pm/device.h>
 #include <zephyr/pm/device_runtime.h>
 #include <zephyr/sys/atomic.h>
 #include <zephyr/sys/util.h>

 LOG_MODULE_REGISTER(analog_axis, CONFIG_INPUT_LOG_LEVEL);

 struct analog_axis_channel_config {
 	struct adc_dt_spec adc;
 	int16_t out_min;
 	int16_t out_max;
 	uint16_t axis;
 	bool invert_input;
 	bool invert_output;
 };

 struct analog_axis_channel_data {
 	int last_out;
 };

 struct analog_axis_config {
 	uint32_t poll_period_ms;
 	const struct analog_axis_channel_config *channel_cfg;
 	struct analog_axis_channel_data *channel_data;
 	struct analog_axis_calibration *calibration;
 	const uint8_t num_channels;
 };

 struct analog_axis_data {
 	struct k_sem cal_lock;
 	analog_axis_raw_data_t raw_data_cb;
 	struct k_timer timer;
 	struct k_thread thread;

 	K_KERNEL_STACK_MEMBER(thread_stack,
 			      CONFIG_INPUT_ANALOG_AXIS_THREAD_STACK_SIZE);

 #ifdef CONFIG_PM_DEVICE
 	atomic_t suspended;
 	struct k_sem wakeup;
 #endif
 };

 int analog_axis_num_axes(const struct device *dev)
 {
 	const struct analog_axis_config *cfg = dev->config;

 	return cfg->num_channels;
 }

 int analog_axis_calibration_get(const struct device *dev,
 				int channel,
 				struct analog_axis_calibration *out_cal)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	struct analog_axis_data *data = dev->data;
 	struct analog_axis_calibration *cal = &cfg->calibration[channel];

 	if (channel >= cfg->num_channels) {
 		return -EINVAL;
 	}

 	k_sem_take(&data->cal_lock, K_FOREVER);
 	memcpy(out_cal, cal, sizeof(struct analog_axis_calibration));
 	k_sem_give(&data->cal_lock);

 	return 0;
 }

 void analog_axis_set_raw_data_cb(const struct device *dev, analog_axis_raw_data_t cb)
 {
 	struct analog_axis_data *data = dev->data;

 	k_sem_take(&data->cal_lock, K_FOREVER);
 	data->raw_data_cb = cb;
 	k_sem_give(&data->cal_lock);
 }

 int analog_axis_calibration_set(const struct device *dev,
 				int channel,
 				struct analog_axis_calibration *new_cal)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	struct analog_axis_data *data = dev->data;
 	struct analog_axis_calibration *cal = &cfg->calibration[channel];

 	if (channel >= cfg->num_channels) {
 		return -EINVAL;
 	}

 	k_sem_take(&data->cal_lock, K_FOREVER);
 	memcpy(cal, new_cal, sizeof(struct analog_axis_calibration));
 	k_sem_give(&data->cal_lock);

 	return 0;
 }

 static int32_t analog_axis_out_deadzone(const struct device *dev,
 					int channel,
 					int32_t raw_val)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[channel];
 	struct analog_axis_calibration *cal = &cfg->calibration[channel];

 	int16_t in_range = cal->in_max - cal->in_min;
 	int16_t out_range = axis_cfg->out_max - axis_cfg->out_min;
 	int16_t in_mid = DIV_ROUND_CLOSEST(cal->in_min + cal->in_max, 2);
 	int16_t in_min = cal->in_min;

 	if (abs(raw_val - in_mid) < cal->in_deadzone) {
 		return DIV_ROUND_CLOSEST(axis_cfg->out_max + axis_cfg->out_min, 2);
 	}

 	in_range -= cal->in_deadzone * 2;
 	in_min += cal->in_deadzone;
 	if (raw_val < in_mid) {
 		raw_val += cal->in_deadzone;
 	} else {
 		raw_val -= cal->in_deadzone;
 	}

 	return DIV_ROUND_CLOSEST((raw_val - in_min) * out_range, in_range) + axis_cfg->out_min;
 }

 static int32_t analog_axis_out_linear(const struct device *dev,
 				      int channel,
 				      int32_t raw_val)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[channel];
 	struct analog_axis_calibration *cal = &cfg->calibration[channel];

 	int16_t in_range = cal->in_max - cal->in_min;
 	int16_t out_range = axis_cfg->out_max - axis_cfg->out_min;

 	return DIV_ROUND_CLOSEST((raw_val - cal->in_min) * out_range, in_range) + axis_cfg->out_min;
 }

 static void analog_axis_loop(const struct device *dev)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	struct analog_axis_data *data = dev->data;
 	int16_t bufs[cfg->num_channels];
 	int32_t out;
 	struct adc_sequence sequence = {
 		.buffer = bufs,
 		.buffer_size = sizeof(bufs),
 	};
 	const struct analog_axis_channel_config *axis_cfg_0 = &cfg->channel_cfg[0];
 	int err;
 	int i;

 	adc_sequence_init_dt(&axis_cfg_0->adc, &sequence);

 	for (i = 0; i < cfg->num_channels; i++) {
 		const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];

 		sequence.channels |= BIT(axis_cfg->adc.channel_id);
 	}

 	err = adc_read(axis_cfg_0->adc.dev, &sequence);
 	if (err < 0) {
 		LOG_ERR("Could not read (%d)", err);
 		return;
 	}

 	k_sem_take(&data->cal_lock, K_FOREVER);

 	for (i = 0; i < cfg->num_channels; i++) {
 		const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];
 		struct analog_axis_channel_data *axis_data = &cfg->channel_data[i];
 		struct analog_axis_calibration *cal = &cfg->calibration[i];
 		int32_t raw_val = bufs[i];

 		if (axis_cfg->invert_input) {
 			raw_val *= -1;
 		}

 		if (data->raw_data_cb != NULL) {
 			data->raw_data_cb(dev, i, raw_val);
 		}

 		LOG_DBG("%s: ch %d: raw_val: %d", dev->name, i, raw_val);

 		if (cal->in_deadzone > 0) {
 			out = analog_axis_out_deadzone(dev, i, raw_val);
 		} else {
 			out = analog_axis_out_linear(dev, i, raw_val);
 		}

 		out = CLAMP(out, axis_cfg->out_min, axis_cfg->out_max);

 		if (axis_cfg->invert_output) {
 			out = axis_cfg->out_max - out;
 		}

 		if (axis_data->last_out != out) {
 			input_report_abs(dev, axis_cfg->axis, out, true, K_FOREVER);
 		}
 		axis_data->last_out = out;
 	}

 	k_sem_give(&data->cal_lock);
 }

 static void analog_axis_thread(void *arg1, void *arg2, void *arg3)
 {
 	const struct device *dev = arg1;
 	const struct analog_axis_config *cfg = dev->config;
 	struct analog_axis_data *data = dev->data;
 	int err;
 	int i;

 	for (i = 0; i < cfg->num_channels; i++) {
 		const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];

 		if (!adc_is_ready_dt(&axis_cfg->adc)) {
 			LOG_ERR("ADC controller device not ready");
 			return;
 		}

 		err = adc_channel_setup_dt(&axis_cfg->adc);
 		if (err < 0) {
 			LOG_ERR("Could not setup channel #%d (%d)", i, err);
 			return;
 		}
 	}

 	while (true) {
 #ifdef CONFIG_PM_DEVICE
 		if (atomic_get(&data->suspended) == 1) {
 			k_sem_take(&data->wakeup, K_FOREVER);
 		}
 #endif

 		analog_axis_loop(dev);
 		k_timer_status_sync(&data->timer);
 	}
 }

 static int analog_axis_init(const struct device *dev)
 {
 	struct analog_axis_data *data = dev->data;
 	k_tid_t tid;

 	k_sem_init(&data->cal_lock, 1, 1);
 	k_timer_init(&data->timer, NULL, NULL);

 #ifdef CONFIG_PM_DEVICE
 	k_sem_init(&data->wakeup, 0, 1);
 #endif

 	tid = k_thread_create(&data->thread, data->thread_stack,
 			      K_KERNEL_STACK_SIZEOF(data->thread_stack),
 			      analog_axis_thread, (void *)dev, NULL, NULL,
 			      CONFIG_INPUT_ANALOG_AXIS_THREAD_PRIORITY,
 			      0, K_NO_WAIT);
 	if (!tid) {
 		LOG_ERR("thread creation failed");
 		return -ENODEV;
 	}

 	k_thread_name_set(&data->thread, dev->name);

 #ifndef CONFIG_PM_DEVICE_RUNTIME
 	const struct analog_axis_config *cfg = dev->config;

 	k_timer_start(&data->timer,
 		      K_MSEC(cfg->poll_period_ms), K_MSEC(cfg->poll_period_ms));
 #else
 	int ret;

 	atomic_set(&data->suspended, 1);

 	pm_device_init_suspended(dev);
 	ret = pm_device_runtime_enable(dev);
 	if (ret < 0) {
 		LOG_ERR("Failed to enable runtime power management");
 		return ret;
 	}
 #endif

 	return 0;
 }

 #ifdef CONFIG_PM_DEVICE
 static int analog_axis_pm_action(const struct device *dev,
 				 enum pm_device_action action)
 {
 	const struct analog_axis_config *cfg = dev->config;
 	struct analog_axis_data *data = dev->data;

 	switch (action) {
 	case PM_DEVICE_ACTION_SUSPEND:
 		atomic_set(&data->suspended, 1);
 		k_timer_stop(&data->timer);
 		break;
 	case PM_DEVICE_ACTION_RESUME:
 		k_timer_start(&data->timer,
 			      K_MSEC(cfg->poll_period_ms),
 			      K_MSEC(cfg->poll_period_ms));
 		atomic_set(&data->suspended, 0);
 		k_sem_give(&data->wakeup);
 		break;
 	default:
 		return -ENOTSUP;
 	}

 	return 0;
 }
 #endif

 #define ANALOG_AXIS_CHANNEL_CFG_DEF(node_id) \
 	{ \
 		.adc = ADC_DT_SPEC_GET(node_id), \
 		.out_min = (int16_t)DT_PROP(node_id, out_min), \
 		.out_max = (int16_t)DT_PROP(node_id, out_max), \
 		.axis = DT_PROP(node_id, zephyr_axis), \
 		.invert_input = DT_PROP(node_id, invert_input), \
 		.invert_output = DT_PROP(node_id, invert_output), \
 	}

 #define ANALOG_AXIS_CHANNEL_CAL_DEF(node_id) \
 	{ \
 		.in_min = (int16_t)DT_PROP(node_id, in_min), \
 		.in_max = (int16_t)DT_PROP(node_id, in_max), \
 		.in_deadzone = DT_PROP(node_id, in_deadzone), \
 	}

 #define ANALOG_AXIS_INIT(inst)									\
 	static const struct analog_axis_channel_config analog_axis_channel_cfg_##inst[] = {	\
 		DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(inst, ANALOG_AXIS_CHANNEL_CFG_DEF, (,))	\
 	};											\
 												\
 	static struct analog_axis_channel_data							\
 		analog_axis_channel_data_##inst[ARRAY_SIZE(analog_axis_channel_cfg_##inst)];	\
 												\
 	static struct analog_axis_calibration							\
 		analog_axis_calibration_##inst[ARRAY_SIZE(analog_axis_channel_cfg_##inst)] = {	\
 			DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(					\
 				inst, ANALOG_AXIS_CHANNEL_CAL_DEF, (,))				\
 		};										\
 												\
 	static const struct analog_axis_config analog_axis_cfg_##inst = {			\
 		.poll_period_ms = DT_INST_PROP(inst, poll_period_ms),				\
 		.channel_cfg = analog_axis_channel_cfg_##inst,					\
 		.channel_data = analog_axis_channel_data_##inst,				\
 		.calibration = analog_axis_calibration_##inst,					\
 		.num_channels = ARRAY_SIZE(analog_axis_channel_cfg_##inst),			\
 	};											\
 												\
 	static struct analog_axis_data analog_axis_data_##inst;					\
 												\
 	PM_DEVICE_DT_INST_DEFINE(inst, analog_axis_pm_action);					\
 												\
 	DEVICE_DT_INST_DEFINE(inst, analog_axis_init, PM_DEVICE_DT_INST_GET(inst),		\
 			      &analog_axis_data_##inst, &analog_axis_cfg_##inst,		\
 			      POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, NULL);

 DT_INST_FOREACH_STATUS_OKAY(ANALOG_AXIS_INIT)
	/*
	* Copyright 2023 Google LLC
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT analog_axis

	#include <stdlib.h>
	#include <zephyr/device.h>
	#include <zephyr/drivers/adc.h>
	#include <zephyr/input/input.h>
	#include <zephyr/input/input_analog_axis.h>
	#include <zephyr/kernel.h>
	#include <zephyr/logging/log.h>
	#include <zephyr/pm/device.h>
	#include <zephyr/pm/device_runtime.h>
	#include <zephyr/sys/atomic.h>
	#include <zephyr/sys/util.h>

	LOG_MODULE_REGISTER(analog_axis, CONFIG_INPUT_LOG_LEVEL);

	struct analog_axis_channel_config {
	struct adc_dt_spec adc;
	int16_t out_min;
	int16_t out_max;
	uint16_t axis;
	bool invert_input;
	bool invert_output;
	};

	struct analog_axis_channel_data {
	int last_out;
	};

	struct analog_axis_config {
	uint32_t poll_period_ms;
	const struct analog_axis_channel_config *channel_cfg;
	struct analog_axis_channel_data *channel_data;
	struct analog_axis_calibration *calibration;
	const uint8_t num_channels;
	};

	struct analog_axis_data {
	struct k_sem cal_lock;
	analog_axis_raw_data_t raw_data_cb;
	struct k_timer timer;
	struct k_thread thread;

	K_KERNEL_STACK_MEMBER(thread_stack,
	CONFIG_INPUT_ANALOG_AXIS_THREAD_STACK_SIZE);

	#ifdef CONFIG_PM_DEVICE
	atomic_t suspended;
	struct k_sem wakeup;
	#endif
	};

	int analog_axis_num_axes(const struct device *dev)
	{
	const struct analog_axis_config *cfg = dev->config;

	return cfg->num_channels;
	}

	int analog_axis_calibration_get(const struct device *dev,
	int channel,
	struct analog_axis_calibration *out_cal)
	{
	const struct analog_axis_config *cfg = dev->config;
	struct analog_axis_data *data = dev->data;
	struct analog_axis_calibration *cal = &cfg->calibration[channel];

	if (channel >= cfg->num_channels) {
	return -EINVAL;
	}

	k_sem_take(&data->cal_lock, K_FOREVER);
	memcpy(out_cal, cal, sizeof(struct analog_axis_calibration));
	k_sem_give(&data->cal_lock);

	return 0;
	}

	void analog_axis_set_raw_data_cb(const struct device *dev, analog_axis_raw_data_t cb)
	{
	struct analog_axis_data *data = dev->data;

	k_sem_take(&data->cal_lock, K_FOREVER);
	data->raw_data_cb = cb;
	k_sem_give(&data->cal_lock);
	}

	int analog_axis_calibration_set(const struct device *dev,
	int channel,
	struct analog_axis_calibration *new_cal)
	{
	const struct analog_axis_config *cfg = dev->config;
	struct analog_axis_data *data = dev->data;
	struct analog_axis_calibration *cal = &cfg->calibration[channel];

	if (channel >= cfg->num_channels) {
	return -EINVAL;
	}

	k_sem_take(&data->cal_lock, K_FOREVER);
	memcpy(cal, new_cal, sizeof(struct analog_axis_calibration));
	k_sem_give(&data->cal_lock);

	return 0;
	}

	static int32_t analog_axis_out_deadzone(const struct device *dev,
	int channel,
	int32_t raw_val)
	{
	const struct analog_axis_config *cfg = dev->config;
	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[channel];
	struct analog_axis_calibration *cal = &cfg->calibration[channel];

	int16_t in_range = cal->in_max - cal->in_min;
	int16_t out_range = axis_cfg->out_max - axis_cfg->out_min;
	int16_t in_mid = DIV_ROUND_CLOSEST(cal->in_min + cal->in_max, 2);
	int16_t in_min = cal->in_min;

	if (abs(raw_val - in_mid) < cal->in_deadzone) {
	return DIV_ROUND_CLOSEST(axis_cfg->out_max + axis_cfg->out_min, 2);
	}

	in_range -= cal->in_deadzone * 2;
	in_min += cal->in_deadzone;
	if (raw_val < in_mid) {
	raw_val += cal->in_deadzone;
	} else {
	raw_val -= cal->in_deadzone;
	}

	return DIV_ROUND_CLOSEST((raw_val - in_min) * out_range, in_range) + axis_cfg->out_min;
	}

	static int32_t analog_axis_out_linear(const struct device *dev,
	int channel,
	int32_t raw_val)
	{
	const struct analog_axis_config *cfg = dev->config;
	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[channel];
	struct analog_axis_calibration *cal = &cfg->calibration[channel];

	int16_t in_range = cal->in_max - cal->in_min;
	int16_t out_range = axis_cfg->out_max - axis_cfg->out_min;

	return DIV_ROUND_CLOSEST((raw_val - cal->in_min) * out_range, in_range) + axis_cfg->out_min;
	}

	static void analog_axis_loop(const struct device *dev)
	{
	const struct analog_axis_config *cfg = dev->config;
	struct analog_axis_data *data = dev->data;
	int16_t bufs[cfg->num_channels];
	int32_t out;
	struct adc_sequence sequence = {
	.buffer = bufs,
	.buffer_size = sizeof(bufs),
	};
	const struct analog_axis_channel_config *axis_cfg_0 = &cfg->channel_cfg[0];
	int err;
	int i;

	adc_sequence_init_dt(&axis_cfg_0->adc, &sequence);

	for (i = 0; i < cfg->num_channels; i++) {
	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];

	sequence.channels \|= BIT(axis_cfg->adc.channel_id);
	}

	err = adc_read(axis_cfg_0->adc.dev, &sequence);
	if (err < 0) {
	LOG_ERR("Could not read (%d)", err);
	return;
	}

	k_sem_take(&data->cal_lock, K_FOREVER);

	for (i = 0; i < cfg->num_channels; i++) {
	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];
	struct analog_axis_channel_data *axis_data = &cfg->channel_data[i];
	struct analog_axis_calibration *cal = &cfg->calibration[i];
	int32_t raw_val = bufs[i];

	if (axis_cfg->invert_input) {
	raw_val *= -1;
	}

	if (data->raw_data_cb != NULL) {
	data->raw_data_cb(dev, i, raw_val);
	}

	LOG_DBG("%s: ch %d: raw_val: %d", dev->name, i, raw_val);

	if (cal->in_deadzone > 0) {
	out = analog_axis_out_deadzone(dev, i, raw_val);
	} else {
	out = analog_axis_out_linear(dev, i, raw_val);
	}

	out = CLAMP(out, axis_cfg->out_min, axis_cfg->out_max);

	if (axis_cfg->invert_output) {
	out = axis_cfg->out_max - out;
	}

	if (axis_data->last_out != out) {
	input_report_abs(dev, axis_cfg->axis, out, true, K_FOREVER);
	}
	axis_data->last_out = out;
	}

	k_sem_give(&data->cal_lock);
	}

	static void analog_axis_thread(void arg1, void arg2, void *arg3)
	{
	const struct device *dev = arg1;
	const struct analog_axis_config *cfg = dev->config;
	struct analog_axis_data *data = dev->data;
	int err;
	int i;

	for (i = 0; i < cfg->num_channels; i++) {
	const struct analog_axis_channel_config *axis_cfg = &cfg->channel_cfg[i];

	if (!adc_is_ready_dt(&axis_cfg->adc)) {
	LOG_ERR("ADC controller device not ready");
	return;
	}

	err = adc_channel_setup_dt(&axis_cfg->adc);
	if (err < 0) {
	LOG_ERR("Could not setup channel #%d (%d)", i, err);
	return;
	}
	}

	while (true) {
	#ifdef CONFIG_PM_DEVICE
	if (atomic_get(&data->suspended) == 1) {
	k_sem_take(&data->wakeup, K_FOREVER);
	}
	#endif

	analog_axis_loop(dev);
	k_timer_status_sync(&data->timer);
	}
	}

	static int analog_axis_init(const struct device *dev)
	{
	struct analog_axis_data *data = dev->data;
	k_tid_t tid;

	k_sem_init(&data->cal_lock, 1, 1);
	k_timer_init(&data->timer, NULL, NULL);

	#ifdef CONFIG_PM_DEVICE
	k_sem_init(&data->wakeup, 0, 1);
	#endif

	tid = k_thread_create(&data->thread, data->thread_stack,
	K_KERNEL_STACK_SIZEOF(data->thread_stack),
	analog_axis_thread, (void *)dev, NULL, NULL,
	CONFIG_INPUT_ANALOG_AXIS_THREAD_PRIORITY,
	0, K_NO_WAIT);
	if (!tid) {
	LOG_ERR("thread creation failed");
	return -ENODEV;
	}

	k_thread_name_set(&data->thread, dev->name);

	#ifndef CONFIG_PM_DEVICE_RUNTIME
	const struct analog_axis_config *cfg = dev->config;

	k_timer_start(&data->timer,
	K_MSEC(cfg->poll_period_ms), K_MSEC(cfg->poll_period_ms));
	#else
	int ret;

	atomic_set(&data->suspended, 1);

	pm_device_init_suspended(dev);
	ret = pm_device_runtime_enable(dev);
	if (ret < 0) {
	LOG_ERR("Failed to enable runtime power management");
	return ret;
	}
	#endif

	return 0;
	}

	#ifdef CONFIG_PM_DEVICE
	static int analog_axis_pm_action(const struct device *dev,
	enum pm_device_action action)
	{
	const struct analog_axis_config *cfg = dev->config;
	struct analog_axis_data *data = dev->data;

	switch (action) {
	case PM_DEVICE_ACTION_SUSPEND:
	atomic_set(&data->suspended, 1);
	k_timer_stop(&data->timer);
	break;
	case PM_DEVICE_ACTION_RESUME:
	k_timer_start(&data->timer,
	K_MSEC(cfg->poll_period_ms),
	K_MSEC(cfg->poll_period_ms));
	atomic_set(&data->suspended, 0);
	k_sem_give(&data->wakeup);
	break;
	default:
	return -ENOTSUP;
	}

	return 0;
	}
	#endif

	#define ANALOG_AXIS_CHANNEL_CFG_DEF(node_id) \
	{ \
	.adc = ADC_DT_SPEC_GET(node_id), \
	.out_min = (int16_t)DT_PROP(node_id, out_min), \
	.out_max = (int16_t)DT_PROP(node_id, out_max), \
	.axis = DT_PROP(node_id, zephyr_axis), \
	.invert_input = DT_PROP(node_id, invert_input), \
	.invert_output = DT_PROP(node_id, invert_output), \
	}

	#define ANALOG_AXIS_CHANNEL_CAL_DEF(node_id) \
	{ \
	.in_min = (int16_t)DT_PROP(node_id, in_min), \
	.in_max = (int16_t)DT_PROP(node_id, in_max), \
	.in_deadzone = DT_PROP(node_id, in_deadzone), \
	}

	#define ANALOG_AXIS_INIT(inst) \
	static const struct analog_axis_channel_config analog_axis_channel_cfg_##inst[] = { \
	DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(inst, ANALOG_AXIS_CHANNEL_CFG_DEF, (,)) \
	}; \
	\
	static struct analog_axis_channel_data \
	analog_axis_channel_data_##inst[ARRAY_SIZE(analog_axis_channel_cfg_##inst)]; \
	\
	static struct analog_axis_calibration \
	analog_axis_calibration_##inst[ARRAY_SIZE(analog_axis_channel_cfg_##inst)] = { \
	DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP( \
	inst, ANALOG_AXIS_CHANNEL_CAL_DEF, (,)) \
	}; \
	\
	static const struct analog_axis_config analog_axis_cfg_##inst = { \
	.poll_period_ms = DT_INST_PROP(inst, poll_period_ms), \
	.channel_cfg = analog_axis_channel_cfg_##inst, \
	.channel_data = analog_axis_channel_data_##inst, \
	.calibration = analog_axis_calibration_##inst, \
	.num_channels = ARRAY_SIZE(analog_axis_channel_cfg_##inst), \
	}; \
	\
	static struct analog_axis_data analog_axis_data_##inst; \
	\
	PM_DEVICE_DT_INST_DEFINE(inst, analog_axis_pm_action); \
	\
	DEVICE_DT_INST_DEFINE(inst, analog_axis_init, PM_DEVICE_DT_INST_GET(inst), \
	&analog_axis_data_##inst, &analog_axis_cfg_##inst, \
	POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, NULL);

	DT_INST_FOREACH_STATUS_OKAY(ANALOG_AXIS_INIT)