drivers: adc: adc driver

Add adc driver for ENE KB106X

Signed-off-by: Steven Chang <steven@ene.com.tw>

drivers/adc/CMakeLists.txt

@@ -55,6 +55,7 @@ zephyr_library_sources_ifdef(CONFIG_ADC_MAX11102_17	adc_max11102_17.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_AD559X	        adc_ad559x.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_LTC2451 adc_ltc2451.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_NUMAKER         adc_numaker.c)
+zephyr_library_sources_ifdef(CONFIG_ADC_ENE_KB106X	adc_ene_kb106x.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_ENE_KB1200	adc_ene_kb1200.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_MCUX_GAU	adc_mcux_gau_adc.c)
 zephyr_library_sources_ifdef(CONFIG_ADC_AMBIQ           adc_ambiq.c)

drivers/adc/Kconfig.ene

@@ -8,3 +8,11 @@ config ADC_ENE_KB1200
 	select PINCTRL
 	help
 	  Enable ADC driver for ENE KB1200.
+
+config ADC_ENE_KB106X
+	bool "ENE KB106X ADC driver"
+	default y
+	depends on DT_HAS_ENE_KB106X_ADC_ENABLED
+	select PINCTRL
+	help
+	  Enable ADC driver for ENE KB106X.

drivers/adc/adc_ene_kb106x.c

@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2025 ENE Technology Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define DT_DRV_COMPAT ene_kb106x_adc
+
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/adc.h>
+#include <zephyr/drivers/pinctrl.h>
+#include <errno.h>
+#include <reg/adc.h>
+#include <zephyr/logging/log.h>
+
+#define ADC_CONTEXT_USES_KERNEL_TIMER
+#include "adc_context.h"
+
+LOG_MODULE_REGISTER(adc_ene_kb106x, CONFIG_ADC_LOG_LEVEL);
+
+struct adc_kb106x_config {
+	/* ADC Register base address */
+	struct adc_regs *adc;
+	/* Pin control */
+	const struct pinctrl_dev_config *pcfg;
+};
+
+struct adc_kb106x_data {
+	struct adc_context ctx;
+	const struct device *adc_dev;
+	uint16_t *buffer;
+	uint16_t *repeat_buffer;
+	uint16_t *buf_end;
+};
+
+/* ADC local functions */
+static bool adc_kb106x_validate_buffer_size(const struct adc_sequence *sequence)
+{
+	int chan_count = 0;
+	size_t buff_need;
+	uint32_t chan_mask;
+
+	for (chan_mask = 0x80; chan_mask != 0; chan_mask >>= 1) {
+		if (chan_mask & sequence->channels) {
+			chan_count++;
+		}
+	}
+
+	buff_need = chan_count * sizeof(uint16_t);
+
+	if (sequence->options) {
+		buff_need *= 1 + sequence->options->extra_samplings;
+	}
+
+	if (buff_need > sequence->buffer_size) {
+		return false;
+	}
+
+	return true;
+}
+
+/* ADC Sample Flow (by using adc_context.h api function)
+ *  1. Start ADC sampling (set up flag ctx->sync)
+ *     adc_context_start_read() -> adc_context_start_sampling()
+ *  2. Wait ADC sample finish (by monitor flag ctx->sync)
+ *     adc_context_wait_for_completion
+ *  3. Finish ADC sample (isr clear flag ctx->sync)
+ *     adc_context_on_sampling_done -> adc_context_complete
+ */
+static int adc_kb106x_start_read(const struct device *dev, const struct adc_sequence *sequence)
+{
+	const struct adc_kb106x_config *config = dev->config;
+	struct adc_kb106x_data *data = dev->data;
+	int error = 0;
+
+	if (!sequence->channels || (sequence->channels & ~BIT_MASK(ADC_MAX_CHAN))) {
+		LOG_ERR("Invalid ADC channels.");
+		return -EINVAL;
+	}
+	/* Fixed 10 bit resolution of ene ADC */
+	if (sequence->resolution != ADC_RESOLUTION) {
+		LOG_ERR("Unfixed 10 bit ADC resolution.");
+		return -ENOTSUP;
+	}
+	/* Check sequence->buffer_size is enough */
+	if (!adc_kb106x_validate_buffer_size(sequence)) {
+		LOG_ERR("ADC buffer size too small.");
+		return -ENOMEM;
+	}
+	/* Only support single sampling */
+	if (sequence->options != NULL) {
+		LOG_ERR("ADC only support single sampling.");
+		return -ENOTSUP;
+	}
+
+	/* assign record buffer pointer */
+	data->buffer = sequence->buffer;
+	data->buf_end = data->buffer + sequence->buffer_size / sizeof(uint16_t);
+	/* store device for adc_context_start_read() */
+	data->adc_dev = dev;
+	/* Inform adc start sampling */
+	adc_context_start_read(&data->ctx, sequence);
+	/* Since kb106x adc has no irq. So need polling the adc conversion
+	 * flag to be valid, then record adc value.
+	 */
+	uint32_t channels = (config->adc->ADCCFG & ADC_CHANNEL_BIT_MASK) >> ADC_CHANNEL_BIT_POS;
+
+	while (channels) {
+		int count;
+		int ch_num;
+
+		count = 0;
+		ch_num = find_lsb_set(channels) - 1;
+		/* wait valid flag */
+		while (config->adc->ADCDAT[ch_num] & ADC_INVALID_VALUE) {
+			k_busy_wait(ADC_WAIT_TIME);
+			count++;
+			if (count >= ADC_WAIT_CNT) {
+				LOG_ERR("ADC busy timeout...");
+				error = -EBUSY;
+				break;
+			}
+		}
+		/* check buffer size is enough then record adc value */
+		if (data->buffer < data->buf_end) {
+			*data->buffer = (uint16_t)(config->adc->ADCDAT[ch_num]);
+			data->buffer++;
+		} else {
+			error = -EINVAL;
+			break;
+		}
+
+		/* clear completed channel */
+		channels &= ~BIT(ch_num);
+	}
+	/* Besause polling the adc conversion flag. don't need wait_for_completion*/
+
+	/* Inform adc sampling is done */
+	adc_context_on_sampling_done(&data->ctx, dev);
+	return error;
+}
+
+/* ADC api functions */
+static int adc_kb106x_channel_setup(const struct device *dev,
+				    const struct adc_channel_cfg *channel_cfg)
+{
+	if (channel_cfg->channel_id >= ADC_MAX_CHAN) {
+		LOG_ERR("Invalid channel %d.", channel_cfg->channel_id);
+		return -EINVAL;
+	}
+
+	if (channel_cfg->acquisition_time != ADC_ACQ_TIME_DEFAULT) {
+		LOG_ERR("Unsupported channel acquisition time.");
+		return -ENOTSUP;
+	}
+
+	if (channel_cfg->differential) {
+		LOG_ERR("Differential channels are not supported.");
+		return -ENOTSUP;
+	}
+
+	if (channel_cfg->gain != ADC_GAIN_1) {
+		LOG_ERR("Unsupported channel gain %d.", channel_cfg->gain);
+		return -ENOTSUP;
+	}
+
+	if (channel_cfg->reference != ADC_REF_INTERNAL) {
+		LOG_ERR("Unsupported channel reference.");
+		return -ENOTSUP;
+	}
+	LOG_DBG("ADC channel %d configured.", channel_cfg->channel_id);
+	return 0;
+}
+
+static int adc_kb106x_read(const struct device *dev, const struct adc_sequence *sequence)
+{
+	struct adc_kb106x_data *data = dev->data;
+	int error;
+
+	adc_context_lock(&data->ctx, false, NULL);
+	error = adc_kb106x_start_read(dev, sequence);
+	adc_context_release(&data->ctx, error);
+
+	return error;
+}
+
+#if defined(CONFIG_ADC_ASYNC)
+static int adc_kb106x_read_async(const struct device *dev, const struct adc_sequence *sequence,
+				 struct k_poll_signal *async)
+{
+	struct adc_kb106x_data *data = dev->data;
+	int error;
+
+	adc_context_lock(&data->ctx, true, async);
+	error = adc_kb106x_start_read(dev, sequence);
+	adc_context_release(&data->ctx, error);
+
+	return error;
+}
+#endif /* CONFIG_ADC_ASYNC */
+
+/* ADC api function (using by adc_context.H function) */
+static void adc_context_start_sampling(struct adc_context *ctx)
+{
+	struct adc_kb106x_data *data = CONTAINER_OF(ctx, struct adc_kb106x_data, ctx);
+	const struct device *dev = data->adc_dev;
+	const struct adc_kb106x_config *config = dev->config;
+
+	data->repeat_buffer = data->buffer;
+	config->adc->ADCCFG = (config->adc->ADCCFG & ~ADC_CHANNEL_BIT_MASK) |
+			      (ctx->sequence.channels << ADC_CHANNEL_BIT_POS);
+	config->adc->ADCCFG |= ADC_FUNCTION_ENABLE;
+}
+
+static void adc_context_update_buffer_pointer(struct adc_context *ctx, bool repeat_sampling)
+{
+	struct adc_kb106x_data *data = CONTAINER_OF(ctx, struct adc_kb106x_data, ctx);
+
+	if (repeat_sampling) {
+		data->buffer = data->repeat_buffer;
+	}
+}
+
+static DEVICE_API(adc, adc_kb106x_api) = {
+	.channel_setup = adc_kb106x_channel_setup,
+	.read = adc_kb106x_read,
+	.ref_internal = ADC_VREF_ANALOG,
+#if defined(CONFIG_ADC_ASYNC)
+	.read_async = adc_kb106x_read_async,
+#endif
+};
+
+static int adc_kb106x_init(const struct device *dev)
+{
+	const struct adc_kb106x_config *config = dev->config;
+	struct adc_kb106x_data *data = dev->data;
+	int ret;
+
+	adc_context_unlock_unconditionally(&data->ctx);
+	/* Configure pin-mux for ADC device */
+	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
+	if (ret < 0) {
+		LOG_ERR("ADC pinctrl setup failed (%d).", ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+#define ADC_KB106X_DEVICE(inst)                                                                    \
+	PINCTRL_DT_INST_DEFINE(inst);                                                              \
+	static struct adc_kb106x_data adc_kb106x_data_##inst = {                                   \
+		ADC_CONTEXT_INIT_TIMER(adc_kb106x_data_##inst, ctx),                               \
+		ADC_CONTEXT_INIT_LOCK(adc_kb106x_data_##inst, ctx),                                \
+		ADC_CONTEXT_INIT_SYNC(adc_kb106x_data_##inst, ctx),                                \
+	};                                                                                         \
+	static const struct adc_kb106x_config adc_kb106x_config_##inst = {                         \
+		.adc = (struct adc_regs *)DT_INST_REG_ADDR(inst),                                  \
+		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst),                                      \
+	};                                                                                         \
+	DEVICE_DT_INST_DEFINE(inst, &adc_kb106x_init, NULL, &adc_kb106x_data_##inst,               \
+			      &adc_kb106x_config_##inst, PRE_KERNEL_1,                             \
+			      CONFIG_KERNEL_INIT_PRIORITY_DEVICE, &adc_kb106x_api);
+
+DT_INST_FOREACH_STATUS_OKAY(ADC_KB106X_DEVICE)

dts/arm/ene/kb106x/kb106x.dtsi

@@ -118,6 +118,13 @@
 			interrupts = <18 3>;
 			status = "disabled";
 		};
+
+		adc0: adc@40130000 {
+			compatible = "ene,kb106x-adc";
+			reg = <0x40130000 0x100>;
+			status = "disabled";
+			#io-channel-cells = <1>;
+		};
 	};
 };
 

dts/bindings/adc/ene,kb106x-adc.yaml

@@ -0,0 +1,24 @@
+# Copyright (c) 2025 ENE Technology Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+description: ENE KB106X ADC controller
+
+compatible: "ene,kb106x-adc"
+
+include: [adc-controller.yaml, pinctrl-device.yaml]
+
+properties:
+  reg:
+    required: true
+
+  "#io-channel-cells":
+    const: 1
+
+  pinctrl-0:
+    required: true
+
+  pinctrl-names:
+    required: true
+
+io-channel-cells:
+  - input

soc/ene/kb106x/common/reg/adc.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025 ENE Technology Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ENE_KB106X_ADC_H
+#define ENE_KB106X_ADC_H
+
+/**
+ * Structure type to access Analog to Digital Converter (ADC).
+ */
+struct adc_regs {
+	volatile uint32_t ADCCFG;      /* Configuration Register */
+	volatile uint32_t Reserved[3]; /* Reserved */
+	volatile uint32_t ADCDAT[10];  /* Data Register */
+};
+
+#define ADC_CHANNEL_BIT_POS  16
+#define ADC_CHANNEL_BIT_MASK 0x03FF0000
+
+#define ADC_RESOLUTION  10   /* Unit:bits */
+#define ADC_VREF_ANALOG 3300 /* Unit:mV */
+#define ADC_MAX_CHAN    10
+
+#define ADC_FUNCTION_ENABLE 0x0001
+#define ADC_INVALID_VALUE   0x8000
+
+#define ADC_WAIT_TIME 100
+#define ADC_WAIT_CNT  100
+
+#endif /* ENE_KB106X_ADDA_H */