From 9fa35bc9a05cbf5c524255a24107e4b554ab2409 Mon Sep 17 00:00:00 2001 From: Al Semjonovs Date: Mon, 13 Feb 2023 11:09:48 -0700 Subject: [PATCH] adc: Add TI ADS7052 SPI driver Add driver for TI ADS7052. Signed-off-by: Al Semjonovs --- .../arm/tdk_robokit1/tdk_robokit1-common.dtsi | 20 +- drivers/adc/CMakeLists.txt | 1 + drivers/adc/Kconfig | 2 + drivers/adc/Kconfig.ads7052 | 36 ++ drivers/adc/adc_ads7052.c | 309 ++++++++++++++++++ dts/bindings/adc/ti,ads7052.yaml | 17 + .../drivers/adc/boards/tdk_robokit1.overlay | 15 + samples/drivers/adc/src/main.c | 5 +- tests/drivers/build_all/adc/app.overlay | 9 + 9 files changed, 411 insertions(+), 3 deletions(-) create mode 100644 drivers/adc/Kconfig.ads7052 create mode 100644 drivers/adc/adc_ads7052.c create mode 100644 dts/bindings/adc/ti,ads7052.yaml create mode 100644 samples/drivers/adc/boards/tdk_robokit1.overlay diff --git a/boards/arm/tdk_robokit1/tdk_robokit1-common.dtsi b/boards/arm/tdk_robokit1/tdk_robokit1-common.dtsi index 33ed93f7a60..364356dd565 100644 --- a/boards/arm/tdk_robokit1/tdk_robokit1-common.dtsi +++ b/boards/arm/tdk_robokit1/tdk_robokit1-common.dtsi @@ -4,6 +4,7 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include "tdk_robokit1-pinctrl.dtsi" / { @@ -90,7 +91,8 @@ pinctrl-names = "default"; dmas = <&xdmac 0 DMA_PERID_SPI0_TX>, <&xdmac 1 DMA_PERID_SPI0_RX>; dma-names = "tx", "rx"; - cs-gpios =<&pioa 31 GPIO_ACTIVE_LOW>; + cs-gpios =<&pioa 31 GPIO_ACTIVE_LOW>, + <&pioc 31 GPIO_ACTIVE_LOW>; status = "okay"; icm42688: icm42688p@0 { @@ -103,6 +105,22 @@ gyro-hz = <32000>; gyro-fs = <2000>; }; + spi_adc: adc@1 { + compatible = "ti,ads7052"; + reg = <1>; + #io-channel-cells = <1>; + #address-cells = <1>; + #size-cells = <0>; + spi-max-frequency = <12000000>; + channel@0 { + reg = <0>; + zephyr,gain = "ADC_GAIN_1"; + zephyr,reference = "ADC_REF_VDD_1"; + zephyr,vref-mv = <3300>; + zephyr,acquisition-time = ; + zephyr,resolution = <14>; + }; + }; }; &spi1 { diff --git a/drivers/adc/CMakeLists.txt b/drivers/adc/CMakeLists.txt index 68950ede8aa..fb8d090aa3d 100644 --- a/drivers/adc/CMakeLists.txt +++ b/drivers/adc/CMakeLists.txt @@ -28,6 +28,7 @@ zephyr_library_sources_ifdef(CONFIG_ADC_TEST adc_test.c) zephyr_library_sources_ifdef(CONFIG_ADC_ADS1X1X adc_ads1x1x.c) zephyr_library_sources_ifdef(CONFIG_ADC_GD32 adc_gd32.c) zephyr_library_sources_ifdef(CONFIG_ADC_ADS1119 adc_ads1119.c) +zephyr_library_sources_ifdef(CONFIG_ADC_ADS7052 adc_ads7052.c) zephyr_library_sources_ifdef(CONFIG_ADC_RPI_PICO adc_rpi_pico.c) zephyr_library_sources_ifdef(CONFIG_ADC_XMC4XXX adc_xmc4xxx.c) zephyr_library_sources_ifdef(CONFIG_ADC_ESP32 adc_esp32.c) diff --git a/drivers/adc/Kconfig b/drivers/adc/Kconfig index 87487ac79f1..a8ef9da9cc0 100644 --- a/drivers/adc/Kconfig +++ b/drivers/adc/Kconfig @@ -84,6 +84,8 @@ source "drivers/adc/Kconfig.gd32" source "drivers/adc/Kconfig.ads1119" +source "drivers/adc/Kconfig.ads7052" + source "drivers/adc/Kconfig.rpi_pico" source "drivers/adc/Kconfig.xmc4xxx" diff --git a/drivers/adc/Kconfig.ads7052 b/drivers/adc/Kconfig.ads7052 new file mode 100644 index 00000000000..3f03962b172 --- /dev/null +++ b/drivers/adc/Kconfig.ads7052 @@ -0,0 +1,36 @@ +# Copyright (c) 2023 Google LLC +# +# SPDX-License-Identifier: Apache-2.0 + +config ADC_ADS7052 + bool "Texas instruments ADS7052 SPI" + default y + depends on DT_HAS_TI_ADS7052_ENABLED + select SPI + select ADC_CONFIGURABLE_INPUTS + help + Enable the driver implementation for the ADS7052 + +if ADC_ADS7052 + +config ADC_ADS7052_INIT_PRIORITY + int "ADS7052 init priority" + default 80 + help + ADS7052 device initialization priority must come + after SPI initialization + +config ADC_ADS7052_ACQUISITION_THREAD_STACK_SIZE + int "Stack size for the ADC data acquisition thread" + default 512 + help + Size of the stack used for the internal data acquisition + thread. + +config ADC_ADS7052_ACQUISITION_THREAD_PRIO + int "Priority for the ADC data acquisition thread" + default 0 + help + Priority level for the internal ADC data acquisition thread. + +endif # ADC_ADS7052 diff --git a/drivers/adc/adc_ads7052.c b/drivers/adc/adc_ads7052.c new file mode 100644 index 00000000000..b022731ba07 --- /dev/null +++ b/drivers/adc/adc_ads7052.c @@ -0,0 +1,309 @@ +/* TI ADS7052 ADC + * + * Copyright (c) 2023 Google, LLC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT ti_ads7052 + +#include +#include +#include +#include +#include + +LOG_MODULE_REGISTER(adc_ads7052); + +#define ADC_CONTEXT_USES_KERNEL_TIMER +#include "adc_context.h" + +#define ADS7052_RESOLUTION 14U + +struct ads7052_config { + struct spi_dt_spec bus; + uint8_t channels; +}; + +struct ads7052_data { + struct adc_context ctx; + const struct device *dev; + uint16_t *buffer; + uint16_t *repeat_buffer; + uint8_t channels; + struct k_thread thread; + struct k_sem sem; + + K_KERNEL_STACK_MEMBER(stack, CONFIG_ADC_ADS7052_ACQUISITION_THREAD_STACK_SIZE); +}; + +static int adc_ads7052_channel_setup(const struct device *dev, + const struct adc_channel_cfg *channel_cfg) +{ + const struct ads7052_config *config = dev->config; + + if (channel_cfg->gain != ADC_GAIN_1) { + LOG_ERR("unsupported channel gain '%d'", channel_cfg->gain); + return -ENOTSUP; + } + + if (channel_cfg->reference != ADC_REF_VDD_1) { + LOG_ERR("unsupported channel reference '%d'", channel_cfg->reference); + return -ENOTSUP; + } + + if (channel_cfg->acquisition_time != ADC_ACQ_TIME_DEFAULT) { + LOG_ERR("unsupported acquisition_time '%d'", channel_cfg->acquisition_time); + return -ENOTSUP; + } + + if (channel_cfg->channel_id >= config->channels) { + LOG_ERR("unsupported channel id '%d'", channel_cfg->channel_id); + return -ENOTSUP; + } + return 0; +} + +static int ads7052_validate_buffer_size(const struct device *dev, + const struct adc_sequence *sequence) +{ + uint8_t channels = 0; + size_t needed; + + channels = POPCOUNT(sequence->channels); + + needed = channels * sizeof(uint16_t); + if (sequence->options) { + needed *= (1 + sequence->options->extra_samplings); + } + + if (sequence->buffer_size < needed) { + return -ENOMEM; + } + + return 0; +} + +/** + * @brief Send ADS7052 Offset calibration request + * + * On power-up, the host must provide 24 SCLKs in the first serial transfer to enter the OFFCAL + * state. During normal operation, the host must provide 64 SCLKs in the serial transfer frame to + * enter the OFFCAL state. + */ +static int ads7052_send_calibration(const struct device *dev, bool power_up) +{ + const struct ads7052_config *config = dev->config; + int err; + uint8_t sclks_needed = power_up ? 24 : 64; + uint8_t num_bytes = sclks_needed / 8; + uint8_t tx_bytes[8] = {0}; + + const struct spi_buf tx_buf = {.buf = tx_bytes, .len = num_bytes}; + const struct spi_buf_set tx = {.buffers = &tx_buf, .count = 1}; + + err = spi_write_dt(&config->bus, &tx); + + return err; +} + +static int ads7052_start_read(const struct device *dev, const struct adc_sequence *sequence) +{ + const struct ads7052_config *config = dev->config; + struct ads7052_data *data = dev->data; + int err; + + if (sequence->resolution != ADS7052_RESOLUTION) { + LOG_ERR("unsupported resolution %d", sequence->resolution); + return -ENOTSUP; + } + + if (find_msb_set(sequence->channels) > config->channels) { + LOG_ERR("unsupported channels in mask: 0x%08x", sequence->channels); + return -ENOTSUP; + } + + if (sequence->calibrate) { + ads7052_send_calibration(dev, false); + } + + err = ads7052_validate_buffer_size(dev, sequence); + if (err) { + LOG_ERR("buffer size too small"); + return err; + } + + data->buffer = sequence->buffer; + adc_context_start_read(&data->ctx, sequence); + + return adc_context_wait_for_completion(&data->ctx); +} + +static int adc_ads7052_read_async(const struct device *dev, const struct adc_sequence *sequence, + struct k_poll_signal *async) +{ + struct ads7052_data *data = dev->data; + int error; + + adc_context_lock(&data->ctx, async ? true : false, async); + error = ads7052_start_read(dev, sequence); + adc_context_release(&data->ctx, error); + + return error; +} + +static int adc_ads7052_read(const struct device *dev, const struct adc_sequence *sequence) +{ + return adc_ads7052_read_async(dev, sequence, NULL); +} + +static void adc_context_start_sampling(struct adc_context *ctx) +{ + struct ads7052_data *data = CONTAINER_OF(ctx, struct ads7052_data, ctx); + + data->channels = ctx->sequence.channels; + data->repeat_buffer = data->buffer; + + k_sem_give(&data->sem); +} + +static void adc_context_update_buffer_pointer(struct adc_context *ctx, bool repeat_sampling) +{ + struct ads7052_data *data = CONTAINER_OF(ctx, struct ads7052_data, ctx); + + if (repeat_sampling) { + data->buffer = data->repeat_buffer; + } +} + +/** + * @brief Get a 14-bit integer from raw ADC data. + * + * @param src Location of the big-endian 14-bit integer to get. + * + * @return 14-bit integer in host endianness. + */ +static inline int ads7052_get_be14(const uint8_t src[2]) +{ + return ((src[0] & 0x7F) << 7) | (src[1] >> 1); +} + +/** + * @brief Read ADS7052 over SPI interface + * + * A leading 0 is output on the SDO pin on the CS falling edge. + * The most significant bit (MSB) of the output data is launched on the SDO pin on the rising edge + * after the first SCLK falling edge. Subsequent output bits are launched on the subsequent rising + * edges provided on SCLK. When all 14 output bits are shifted out, the device outputs 0's on the + * subsequent SCLK rising edges. The device enters the ACQ state after 18 clocks and a minimum time + * of tACQ must be provided for acquiring the next sample. If the device is provided with less than + * 18 SCLK falling edges in the present serial transfer frame, the device provides an invalid + * conversion result in the next serial transfer frame + */ +static int ads7052_read_channel(const struct device *dev, uint8_t channel, uint16_t *result) +{ + const struct ads7052_config *config = dev->config; + int err; + uint8_t rx_bytes[3]; + const struct spi_buf rx_buf[1] = {{.buf = rx_bytes, .len = sizeof(rx_bytes)}}; + const struct spi_buf_set rx = {.buffers = rx_buf, .count = ARRAY_SIZE(rx_buf)}; + + err = spi_read_dt(&config->bus, &rx); + if (err) { + return err; + } + + *result = ads7052_get_be14(rx_bytes); + *result &= BIT_MASK(ADS7052_RESOLUTION); + + return 0; +} + +static void ads7052_acquisition_thread(struct ads7052_data *data) +{ + uint16_t result = 0; + uint8_t channel; + int err = 0; + + err = ads7052_send_calibration(data->dev, true); + if (err) { + LOG_ERR("failed to send powerup sequence (err %d)", err); + } + + while (true) { + k_sem_take(&data->sem, K_FOREVER); + + while (data->channels != 0) { + channel = find_lsb_set(data->channels) - 1; + + LOG_DBG("reading channel %d", channel); + + err = ads7052_read_channel(data->dev, channel, &result); + if (err) { + LOG_ERR("failed to read channel %d (err %d)", channel, err); + adc_context_complete(&data->ctx, err); + break; + } + + LOG_DBG("read channel %d, result = %d", channel, result); + + *data->buffer++ = result; + WRITE_BIT(data->channels, channel, 0); + } + + adc_context_on_sampling_done(&data->ctx, data->dev); + } +} + +static int adc_ads7052_init(const struct device *dev) +{ + const struct ads7052_config *config = dev->config; + struct ads7052_data *data = dev->data; + + data->dev = dev; + + adc_context_init(&data->ctx); + k_sem_init(&data->sem, 0, 1); + + if (!spi_is_ready_dt(&config->bus)) { + LOG_ERR("SPI bus %s not ready", config->bus.bus->name); + return -ENODEV; + } + + k_thread_create(&data->thread, data->stack, + CONFIG_ADC_ADS7052_ACQUISITION_THREAD_STACK_SIZE, + (k_thread_entry_t)ads7052_acquisition_thread, data, NULL, NULL, + CONFIG_ADC_ADS7052_ACQUISITION_THREAD_PRIO, 0, K_NO_WAIT); + + adc_context_unlock_unconditionally(&data->ctx); + + return 0; +} + +static const struct adc_driver_api ads7052_api = { + .channel_setup = adc_ads7052_channel_setup, + .read = adc_ads7052_read, +#ifdef CONFIG_ADC_ASYNC + .read_async = adc_ads7052_read_async, +#endif +}; + +#define ADC_ADS7052_SPI_CFG SPI_OP_MODE_MASTER | SPI_MODE_CPHA | SPI_WORD_SET(8) + +#define ADC_ADS7052_INIT(n) \ + \ + static const struct ads7052_config ads7052_cfg_##n = { \ + .bus = SPI_DT_SPEC_INST_GET(n, ADC_ADS7052_SPI_CFG, 1U), \ + .channels = 1, \ + }; \ + \ + static struct ads7052_data ads7052_data_##n = { \ + ADC_CONTEXT_INIT_TIMER(ads7052_data_##n, ctx), \ + ADC_CONTEXT_INIT_LOCK(ads7052_data_##n, ctx), \ + ADC_CONTEXT_INIT_SYNC(ads7052_data_##n, ctx), \ + }; \ + \ + DEVICE_DT_INST_DEFINE(n, adc_ads7052_init, NULL, &ads7052_data_##n, &ads7052_cfg_##n, \ + POST_KERNEL, CONFIG_ADC_ADS7052_INIT_PRIORITY, &ads7052_api); + +DT_INST_FOREACH_STATUS_OKAY(ADC_ADS7052_INIT) diff --git a/dts/bindings/adc/ti,ads7052.yaml b/dts/bindings/adc/ti,ads7052.yaml new file mode 100644 index 00000000000..ea150a3b604 --- /dev/null +++ b/dts/bindings/adc/ti,ads7052.yaml @@ -0,0 +1,17 @@ +# Copyright (c) 2023, Google LLC +# SPDX-License-Identifier: Apache-2.0 + +description: Texas Instrument Single Channel SPI ADC + +compatible: "ti,ads7052" + +include: [adc-controller.yaml, spi-device.yaml] + +on-bus: spi + +properties: + "#io-channel-cells": + const: 1 + +io-channel-cells: + - input diff --git a/samples/drivers/adc/boards/tdk_robokit1.overlay b/samples/drivers/adc/boards/tdk_robokit1.overlay new file mode 100644 index 00000000000..01f0cd1db92 --- /dev/null +++ b/samples/drivers/adc/boards/tdk_robokit1.overlay @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2023, Google LLC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include + +/ { + zephyr,user { + /* adjust channel number according to pinmux in board.dts */ + io-channels = <&spi_adc 0>; + }; +}; diff --git a/samples/drivers/adc/src/main.c b/samples/drivers/adc/src/main.c index 12050689794..408f35af92a 100644 --- a/samples/drivers/adc/src/main.c +++ b/samples/drivers/adc/src/main.c @@ -32,6 +32,7 @@ static const struct adc_dt_spec adc_channels[] = { void main(void) { int err; + uint32_t count = 0; uint16_t buf; struct adc_sequence sequence = { .buffer = &buf, @@ -42,7 +43,7 @@ void main(void) /* Configure channels individually prior to sampling. */ for (size_t i = 0U; i < ARRAY_SIZE(adc_channels); i++) { if (!device_is_ready(adc_channels[i].dev)) { - printk("ADC controller device not ready\n"); + printk("ADC controller device %s not ready\n", adc_channels[i].dev->name); return; } @@ -54,7 +55,7 @@ void main(void) } while (1) { - printk("ADC reading:\n"); + printk("ADC reading[%u]:\n", count++); for (size_t i = 0U; i < ARRAY_SIZE(adc_channels); i++) { int32_t val_mv; diff --git a/tests/drivers/build_all/adc/app.overlay b/tests/drivers/build_all/adc/app.overlay index 595eca144a6..ff3e0d0786c 100644 --- a/tests/drivers/build_all/adc/app.overlay +++ b/tests/drivers/build_all/adc/app.overlay @@ -100,6 +100,7 @@ <&test_gpio 0 0>, <&test_gpio 0 0>, <&test_gpio 0 0>, + <&test_gpio 0 0>, <&test_gpio 0 0>; test_spi_mcp3204: mcp3204@0 { @@ -172,6 +173,14 @@ drdyb-gpios = <&test_gpio 0 0>; #io-channel-cells = <2>; }; + + test_spi_ads7052: ads7052@9 { + compatible = "ti,ads7052"; + reg = <0x9>; + spi-max-frequency = <12000000>; + #io-channel-cells = <1>; + }; + }; }; };