drivers: adc: Adding ADC 16-bit driver support for board EK-RA2A1

Adding ADC 16-bit driver support for board EK-RA2A1

Signed-off-by: Thinh Le Cong <[email protected]>

Author: Thinh Le Cong

drivers/adc/adc_renesas_ra.c

@@ -14,21 +14,36 @@
 #include <zephyr/sys/util_internal.h>
 #include <instances/r_adc.h>
 
+#include "rp_adc.h"
+
 #include <zephyr/irq.h>
 
 LOG_MODULE_REGISTER(adc_ra, CONFIG_ADC_LOG_LEVEL);
 
 #define ADC_CONTEXT_USES_KERNEL_TIMER
 #include "adc_context.h"
 
-#define ADC_RA_MAX_RESOLUTION 12
-#define ADC_AVERAGE_1         ADC_ADD_OFF
-#define ADC_AVERAGE_2         ADC_ADD_AVERAGE_TWO
-#define ADC_AVERAGE_4         ADC_ADD_AVERAGE_FOUR
-#define ADC_AVERAGE_8         ADC_ADD_AVERAGE_EIGHT
-#define ADC_AVERAGE_16        ADC_ADD_AVERAGE_SIXTEEN
+#define ADC_AVERAGE_1  ADC_ADD_OFF
+#define ADC_AVERAGE_2  ADC_ADD_AVERAGE_TWO
+#define ADC_AVERAGE_4  ADC_ADD_AVERAGE_FOUR
+#define ADC_AVERAGE_8  ADC_ADD_AVERAGE_EIGHT
+#define ADC_AVERAGE_16 ADC_ADD_AVERAGE_SIXTEEN
+
+#define ADC_RES_12 ADC_RESOLUTION_12_BIT
+#define ADC_RES_16 ADC_RESOLUTION_16_BIT
 
-void adc_scan_end_isr(void);
+#define ADC_VARIANT_ADC12 12
+#define ADC_VARIANT_ADC16 16
+
+#define ADC_CHANNEL_BIT_MASK (0x01U)
+
+enum ra_adc_reference {
+	RA_ADC_REF_VDD,
+	RA_ADC_REF_INTERNAL,
+	RA_ADC_REF_EXTERNAL,
+};
+
+extern void adc_scan_end_isr(void);
 
 /**
  * @brief RA ADC config
@@ -40,6 +55,14 @@ struct adc_ra_config {
 	uint32_t channel_available_mask;
 	/** pinctrl configs */
 	const struct pinctrl_dev_config *pcfg;
+	/** Variant support ADC16 or ADC12 */
+	uint8_t variant;
+	/** Mapping reference voltage */
+	uint32_t reference;
+	/** Resolution support */
+	uint8_t resolution;
+	/** Sampling time in nanoseconds */
+	uint32_t sampling_time_ns;
 	/** function pointer to irq setup */
 	void (*irq_configure)(void);
 };
@@ -66,8 +89,20 @@ struct adc_ra_data {
 	uint32_t channels;
 	/** Buffer id */
 	uint16_t buf_id;
+	/** Calibration process semaphore */
+	struct k_sem calibrate_sem;
 };
 
+static adc_sample_state_reg_t map_channel_to_sample_state_reg(uint8_t channel_id)
+{
+	if (channel_id <= 15) {
+		return (adc_sample_state_reg_t)channel_id;
+	}
+
+	/* Channel IDs 16–31 share the same sample state register */
+	return ADC_SAMPLE_STATE_CHANNEL_16_TO_31;
+}
+
 /**
  * @brief Setup channels before starting to scan ADC
  *
@@ -83,6 +118,8 @@ static int adc_ra_channel_setup(const struct device *dev, const struct adc_chann
 	fsp_err_t fsp_err = FSP_SUCCESS;
 	struct adc_ra_data *data = dev->data;
 	const struct adc_ra_config *config = dev->config;
+	adc_sample_state_t sample_state;
+	uint32_t sample_states = 0;
 
 	if (!((config->channel_available_mask & (1 << channel_cfg->channel_id)) != 0)) {
 		LOG_ERR("unsupported channel id '%d'", channel_cfg->channel_id);
@@ -104,6 +141,18 @@ static int adc_ra_channel_setup(const struct device *dev, const struct adc_chann
 		return -EINVAL;
 	}
 
+	fsp_err = RP_ADC_SampleStateCalculation(config->sampling_time_ns, &sample_states);
+	if (FSP_SUCCESS != fsp_err) {
+		return -ENOTSUP;
+	}
+
+	sample_state.reg_id = map_channel_to_sample_state_reg(channel_cfg->channel_id);
+	sample_state.num_states = sample_states;
+	fsp_err = R_ADC_SampleStateCountSet(&data->adc, &sample_state);
+	if (FSP_SUCCESS != fsp_err) {
+		return -ENOTSUP;
+	}
+
 	data->f_channel_cfg.scan_mask |= (1U << channel_cfg->channel_id);
 	/* Configure ADC channel specific settings */
 	fsp_err = R_ADC_ScanCfg(&data->adc, &data->f_channel_cfg);
@@ -114,32 +163,86 @@ static int adc_ra_channel_setup(const struct device *dev, const struct adc_chann
 	return 0;
 }
 
-/**
- * Interrupt handler
- */
-static void adc_ra_isr(const struct device *dev)
+static void renesas_ra_adc_callback(adc_callback_args_t *p_args)
 {
+	const struct device *dev = p_args->p_context;
 	struct adc_ra_data *data = dev->data;
 	fsp_err_t fsp_err = FSP_SUCCESS;
 	adc_channel_t channel_id = 0;
 	uint32_t channels = 0;
 	int16_t *sample_buffer = (int16_t *)data->buf;
 
-	channels = data->channels;
-	for (channel_id = 0; channels > 0; channel_id++) {
-		/* Check if it is right channel id */
-		if ((channels & 0x01) != 0) {
-			fsp_err = R_ADC_Read(&data->adc, channel_id, &sample_buffer[data->buf_id]);
-			if (FSP_SUCCESS != fsp_err) {
-				break;
+	if (p_args->event == ADC_EVENT_SCAN_COMPLETE) {
+		channels = data->channels;
+		for (channel_id = 0; channels > 0; channel_id++) {
+			/* Check if it is right channel id */
+			if ((channels & ADC_CHANNEL_BIT_MASK) != 0) {
+				fsp_err = R_ADC_Read(&data->adc, channel_id,
+						     &sample_buffer[data->buf_id]);
+				if (FSP_SUCCESS != fsp_err) {
+					break;
+				}
+				/* Do not return negative value for single-ended configuration */
+				if (sample_buffer[data->buf_id] < 0) {
+					sample_buffer[data->buf_id] = 0;
+				}
+				data->buf_id = data->buf_id + 1;
+
+				fsp_err = R_ADC_ScanStop(&data->adc);
+				if (FSP_SUCCESS != fsp_err) {
+					break;
+				}
 			}
-			data->buf_id = data->buf_id + 1;
+
+			channels = channels >> 1;
 		}
+		adc_context_on_sampling_done(&data->ctx, dev);
+	}
 
-		channels = channels >> 1;
+	else if (p_args->event == ADC_EVENT_CALIBRATION_COMPLETE) {
+		k_sem_give(&data->calibrate_sem);
+	}
+}
+
+/**
+ * Voltage reference covert handler
+ */
+static int adc_map_vref(const struct adc_ra_config *cfg, adc_extended_cfg_t *extend)
+{
+	switch (cfg->variant) {
+	case ADC_VARIANT_ADC16:
+		switch (cfg->reference) {
+		case RA_ADC_REF_INTERNAL:
+			extend->adc_vref_control = ADC_VREF_CONTROL_2_5V_OUTPUT;
+			return 0;
+		case RA_ADC_REF_EXTERNAL:
+			extend->adc_vref_control = ADC_VREF_CONTROL_VREFH;
+			return 0;
+		default:
+			LOG_ERR("Reference %d not supported", cfg->reference);
+			return -ENOTSUP;
+		}
+
+	case ADC_VARIANT_ADC12:
+		switch (cfg->reference) {
+		case RA_ADC_REF_VDD:
+			extend->adc_vref_control = ADC_VREF_CONTROL_AVCC0_AVSS0;
+			return 0;
+		case RA_ADC_REF_EXTERNAL:
+			extend->adc_vref_control = ADC_VREF_CONTROL_VREFH0_VREFL0;
+			return 0;
+		case RA_ADC_REF_INTERNAL:
+			extend->adc_vref_control = ADC_VREF_CONTROL_IVREF_AVSS0;
+			return 0;
+		default:
+			LOG_ERR("Reference %d not supported", cfg->reference);
+			return -ENOTSUP;
+		}
+
+	default:
+		LOG_ERR("Variant %d not supported", cfg->variant);
+		return -ENOTSUP;
 	}
-	adc_scan_end_isr();
-	adc_context_on_sampling_done(&data->ctx, dev);
 }
 
 /**
@@ -187,9 +290,18 @@ static int adc_ra_start_read(const struct device *dev, const struct adc_sequence
 {
 	const struct adc_ra_config *config = dev->config;
 	struct adc_ra_data *data = dev->data;
+	fsp_err_t fsp_err = FSP_SUCCESS;
 	int err;
 
-	if (sequence->resolution > ADC_RA_MAX_RESOLUTION || sequence->resolution == 0) {
+	if (config->variant == ADC_VARIANT_ADC16) {
+		uint8_t expected = config->resolution - 1;
+
+		if (sequence->resolution != expected) {
+			LOG_ERR("unsupported resolution %d for single-ended mode, must be %d",
+				sequence->resolution, expected);
+			return -ENOTSUP;
+		}
+	} else if (sequence->resolution != config->resolution) {
 		LOG_ERR("unsupported resolution %d", sequence->resolution);
 		return -ENOTSUP;
 	}
@@ -207,6 +319,21 @@ static int adc_ra_start_read(const struct device *dev, const struct adc_sequence
 
 	data->buf_id = 0;
 	data->buf = sequence->buffer;
+
+	if (config->variant == ADC_VARIANT_ADC16) {
+		if (!sequence->calibrate) {
+			return -ENOTSUP;
+		}
+
+		/* Start calibration process */
+		k_sem_reset(&data->calibrate_sem);
+		fsp_err = R_ADC_Calibrate(&data->adc, NULL);
+		if (FSP_SUCCESS != fsp_err) {
+			return -EIO;
+		}
+		k_sem_take(&data->calibrate_sem, K_FOREVER);
+	}
+
 	adc_context_start_read(&data->ctx, sequence);
 
 	adc_context_wait_for_completion(&data->ctx);
@@ -293,12 +420,21 @@ static int adc_ra_init(const struct device *dev)
 	struct adc_ra_data *data = dev->data;
 	int ret;
 	fsp_err_t fsp_err = FSP_SUCCESS;
+	adc_extended_cfg_t *extend = (adc_extended_cfg_t *)data->f_config.p_extend;
+
+	/* Override reference voltage */
+	ret = adc_map_vref(config, extend);
+	if (ret < 0) {
+		return ret;
+	}
 
 	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
 	if (ret < 0) {
 		return ret;
 	}
 
+	k_sem_init(&data->calibrate_sem, 0, 1);
+
 	/* Open ADC module */
 	fsp_err = R_ADC_Open(&data->adc, &data->f_config);
 	if (FSP_SUCCESS != fsp_err) {
@@ -307,19 +443,29 @@ static int adc_ra_init(const struct device *dev)
 
 	config->irq_configure();
 
+	if (config->variant == ADC_VARIANT_ADC16) {
+		/* Start calibration process */
+		fsp_err = R_ADC_Calibrate(&data->adc, NULL);
+		if (FSP_SUCCESS != fsp_err) {
+			return -EIO;
+		}
+		k_sem_take(&data->calibrate_sem, K_FOREVER);
+	}
+
 	adc_context_unlock_unconditionally(&data->ctx);
 	return 0;
 }
 
-#define EVENT_ADC_SCAN_END(idx) BSP_PRV_IELS_ENUM(CONCAT(EVENT_ADC, idx, _SCAN_END))
+#define EVENT_ADC_SCAN_END(unit) BSP_PRV_IELS_ENUM(CONCAT(EVENT_ADC, unit, _SCAN_END))
 
 #define IRQ_CONFIGURE_FUNC(idx)                                                                    \
 	static void adc_ra_configure_func_##idx(void)                                              \
 	{                                                                                          \
-		R_ICU->IELSR[DT_INST_IRQ_BY_NAME(idx, scanend, irq)] = EVENT_ADC_SCAN_END(idx);    \
+		R_ICU->IELSR[DT_INST_IRQ_BY_NAME(idx, scanend, irq)] =                             \
+			EVENT_ADC_SCAN_END(DT_PROP(DT_DRV_INST(idx), unit));                       \
 		IRQ_CONNECT(DT_INST_IRQ_BY_NAME(idx, scanend, irq),                                \
-			    DT_INST_IRQ_BY_NAME(idx, scanend, priority), adc_ra_isr,               \
-			    DEVICE_DT_INST_GET(idx), 0);                                           \
+			    DT_INST_IRQ_BY_NAME(idx, scanend, priority), adc_scan_end_isr, NULL,   \
+			    0);                                                                    \
 		irq_enable(DT_INST_IRQ_BY_NAME(idx, scanend, irq));                                \
 	}
 
@@ -328,7 +474,7 @@ static int adc_ra_init(const struct device *dev)
 #define ADC_RA_INIT(idx)                                                                           \
 	IRQ_CONFIGURE_FUNC(idx)                                                                    \
 	PINCTRL_DT_INST_DEFINE(idx);                                                               \
-	static const adc_extended_cfg_t g_adc_cfg_extend_##idx = {                                 \
+	static adc_extended_cfg_t g_adc_cfg_extend_##idx = {                                       \
 		.add_average_count = UTIL_CAT(ADC_AVERAGE_, DT_INST_PROP(idx, average_count)),     \
 		.clearing = ADC_CLEAR_AFTER_READ_ON,                                               \
 		.trigger_group_b = ADC_START_SOURCE_DISABLED,                                      \
@@ -345,9 +491,13 @@ static int adc_ra_init(const struct device *dev)
 		.channel_setup = adc_ra_channel_setup,                                             \
 		.read = adc_ra_read,                                                               \
 		.ref_internal = DT_INST_PROP(idx, vref_mv),                                        \
-		IF_ENABLED(CONFIG_ADC_ASYNC, (.read_async = adc_ra_read_async))};                  \
+		IF_ENABLED(CONFIG_ADC_ASYNC, (.read_async = adc_ra_read_async))};                     \
 	static const struct adc_ra_config adc_ra_config_##idx = {                                  \
 		.channel_available_mask = DT_INST_PROP(idx, channel_available_mask),               \
+		.variant = DT_INST_PROP(idx, variant),                                             \
+		.reference = DT_INST_ENUM_IDX(idx, reference),                                     \
+		.resolution = DT_INST_PROP(idx, variant),                                          \
+		.sampling_time_ns = DT_INST_PROP_OR(idx, sampling_time_ns, UNSPECIFIED),           \
 		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(idx),                                       \
 		IRQ_CONFIGURE_DEFINE(idx),                                                         \
 	};                                                                                         \
@@ -358,13 +508,13 @@ static int adc_ra_init(const struct device *dev)
 		.dev = DEVICE_DT_INST_GET(idx),                                                    \
 		.f_config =                                                                        \
 			{                                                                          \
-				.unit = idx,                                                       \
+				.unit = DT_INST_PROP(idx, unit),                                   \
 				.mode = ADC_MODE_SINGLE_SCAN,                                      \
-				.resolution = ADC_RESOLUTION_12_BIT,                               \
+				.resolution = UTIL_CAT(ADC_RES_, DT_INST_PROP(idx, variant)),      \
 				.alignment = (adc_alignment_t)ADC_ALIGNMENT_RIGHT,                 \
 				.trigger = 0,                                                      \
-				.p_callback = NULL,                                                \
-				.p_context = NULL,                                                 \
+				.p_callback = renesas_ra_adc_callback,                             \
+				.p_context = (void *)DEVICE_DT_GET(DT_DRV_INST(idx)),              \
 				.p_extend = &g_adc_cfg_extend_##idx,                               \
 				.scan_end_irq = DT_INST_IRQ_BY_NAME(idx, scanend, irq),            \
 				.scan_end_ipl = DT_INST_IRQ_BY_NAME(idx, scanend, priority),       \

dts/bindings/adc/renesas,ra-adc.yaml

@@ -32,5 +32,35 @@ properties:
       The ADC module will take multiple samples of an analog signal
       and averages them to reduce noise and enhance accuracy
 
+  reference:
+    type: string
+    enum:
+      - vdd
+      - internal
+      - external
+    default: vdd
+    description: |
+      ADC reference voltage source:
+        - vdd: use VDD as reference
+        - internal: use internal reference
+        - external: use external reference
+
+  variant:
+    type: int
+    enum: [12, 16]
+    default: 12
+    description: Select ADC variant for RA SoC
+
+  sampling-time-ns:
+    type: int
+    description: |
+      Sampling time in nanoseconds, i.e. the duration the ADC input
+      signal is sampled before conversion starts.
+
+  unit:
+    type: int
+    required: true
+    description: Indicates the unit number of the ADC device.
+
 io-channel-cells:
   - input