drivers/lis2dux12: add read_and_decode APIs support

Add RTIO async and RTIO stream functionalities that enables,
among all the other things, the sensor data streaming from FIFO.

RTIO stream supports following triggers:

  - SENSOR_TRIG_FIFO_WATERMARK
  - SENSOR_TRIG_FIFO_FULL
  - SENSOR_TRIG_DATA_READY

Following FIFO parameters has to be defined in device tree to
correctly stream sensor data:

  - fifo-watermark
  - accel-fifo-batch-rate

Currently the driver can decode FIFO content with Accelerometer
16-bit samples.

Signed-off-by: Armando Visconti <armando.visconti@st.com>

Author: avisconti

drivers/sensor/st/lis2dux12/CMakeLists.txt

@@ -6,5 +6,7 @@ zephyr_library_sources(lis2dux12.c)
 zephyr_library_sources_ifdef(CONFIG_LIS2DUX12_TRIGGER    lis2dux12_trigger.c)
 zephyr_library_sources_ifdef(CONFIG_DT_HAS_ST_LIS2DUX12_ENABLED  lis2dux12_api.c )
 zephyr_library_sources_ifdef(CONFIG_DT_HAS_ST_LIS2DUXS12_ENABLED lis2duxs12_api.c )
+zephyr_library_sources_ifdef(CONFIG_SENSOR_ASYNC_API lis2dux12_rtio.c lis2dux12_decoder.c)
+zephyr_library_sources_ifdef(CONFIG_LIS2DUX12_STREAM lis2dux12_rtio_stream.c)
 
 zephyr_library_include_directories(../stmemsc)

drivers/sensor/st/lis2dux12/Kconfig

@@ -15,11 +15,21 @@ menuconfig LIS2DUX12
 	select HAS_STMEMSC
 	select USE_STDC_LIS2DUX12 if DT_HAS_ST_LIS2DUX12_ENABLED
 	select USE_STDC_LIS2DUXS12 if DT_HAS_ST_LIS2DUXS12_ENABLED
+	select RTIO_WORKQ if SENSOR_ASYNC_API
 	help
 	  Enable driver for LIS2DUX12 accelerometer sensor driver
 
 if LIS2DUX12
 
+config LIS2DUX12_STREAM
+	bool "Use hardware FIFO to stream data"
+	select LIS2DUX12_TRIGGER
+	default y
+	depends on I2C_RTIO || SPI_RTIO
+	depends on SENSOR_ASYNC_API
+	help
+	  Use this config option to enable streaming sensor data via RTIO subsystem.
+
 module = LIS2DUX12
 thread_priority = 10
 thread_stack_size = 1024

drivers/sensor/st/lis2dux12/lis2dux12.c

@@ -18,6 +18,8 @@
 #include <zephyr/logging/log.h>
 
 #include "lis2dux12.h"
+#include "lis2dux12_decoder.h"
+#include "lis2dux12_rtio.h"
 
 #if DT_HAS_COMPAT_STATUS_OKAY(st_lis2dux12)
 #include "lis2dux12_api.h"
@@ -243,6 +245,10 @@ static DEVICE_API(sensor, lis2dux12_driver_api) = {
 #endif
 	.sample_fetch = lis2dux12_sample_fetch,
 	.channel_get = lis2dux12_channel_get,
+#ifdef CONFIG_SENSOR_ASYNC_API
+	.get_decoder = lis2dux12_get_decoder,
+	.submit = lis2dux12_submit,
+#endif
 };
 
 /*
@@ -269,16 +275,25 @@ static DEVICE_API(sensor, lis2dux12_driver_api) = {
 	.range = DT_INST_PROP(inst, range),						\
 	.pm = DT_INST_PROP(inst, power_mode),						\
 	.odr = DT_INST_PROP(inst, odr),							\
+	IF_ENABLED(CONFIG_LIS2DUX12_STREAM,						\
+		   (.fifo_wtm = DT_INST_PROP(inst, fifo_watermark),			\
+		    .accel_batch  = DT_INST_PROP(inst, accel_fifo_batch_rate),		\
+		    .ts_batch  = DT_INST_PROP(inst, timestamp_fifo_batch_rate),))	\
 	IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios),			\
 			   DT_INST_NODE_HAS_PROP(inst, int2_gpios)),			\
 		   (LIS2DUX12_CFG_IRQ(inst)))						\
 
-#define LIS2DUX12_SPI_OPERATION								\
-	(SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
-
 /*
  * Instantiation macros used when a device is on a SPI bus.
  */
+#define LIS2DUX12_SPI_OPERATION								\
+	(SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
+
+#define LIS2DUX12_SPI_RTIO_DEFINE(inst, name)				\
+	SPI_DT_IODEV_DEFINE(lis2dux12_iodev_##name##_##inst,		\
+		DT_DRV_INST(inst), LIS2DUX12_SPI_OPERATION, 0U);	\
+	RTIO_DEFINE(lis2dux12_rtio_ctx_##name##_##inst, 4, 4);
+
 #define LIS2DUX12_CONFIG_SPI(inst, name)						\
 	{										\
 		STMEMSC_CTX_SPI(&lis2dux12_config_##name##_##inst.stmemsc_cfg),		\
@@ -288,9 +303,27 @@ static DEVICE_API(sensor, lis2dux12_driver_api) = {
 		LIS2DUX12_CONFIG_COMMON(inst, name)					\
 	}
 
+#define LIS2DUX12_DEFINE_SPI(inst, name)				\
+	IF_ENABLED(UTIL_AND(CONFIG_LIS2DUX12_STREAM,			\
+			    CONFIG_SPI_RTIO),				\
+		   (LIS2DUX12_SPI_RTIO_DEFINE(inst, name)));		\
+	static struct lis2dux12_data lis2dux12_data_##name##_##inst = {	\
+		IF_ENABLED(UTIL_AND(CONFIG_LIS2DUX12_STREAM,		\
+				    CONFIG_SPI_RTIO),			\
+			(.rtio_ctx = &lis2dux12_rtio_ctx_##name##_##inst,	\
+			 .iodev = &lis2dux12_iodev_##name##_##inst,		\
+			 .bus_type = BUS_SPI,))				\
+	};								\
+	static const struct lis2dux12_config lis2dux12_config_##name##_##inst =	\
+		LIS2DUX12_CONFIG_SPI(inst, name);
+
 /*
  * Instantiation macros used when a device is on an I2C bus.
  */
+#define LIS2DUX12_I2C_RTIO_DEFINE(inst, name)				\
+	I2C_DT_IODEV_DEFINE(lis2dux12_iodev_##name##_##inst, DT_DRV_INST(inst));	\
+	RTIO_DEFINE(lis2dux12_rtio_ctx_##name##_##inst, 4, 4);
+
 #define LIS2DUX12_CONFIG_I2C(inst, name)						\
 	{										\
 		STMEMSC_CTX_I2C(&lis2dux12_config_##name##_##inst.stmemsc_cfg),		\
@@ -300,17 +333,29 @@ static DEVICE_API(sensor, lis2dux12_driver_api) = {
 		LIS2DUX12_CONFIG_COMMON(inst, name)					\
 	}
 
+#define LIS2DUX12_DEFINE_I2C(inst, name)				\
+	IF_ENABLED(UTIL_AND(CONFIG_LIS2DUX12_STREAM,			\
+			    CONFIG_I2C_RTIO),				\
+		   (LIS2DUX12_I2C_RTIO_DEFINE(inst, name)));		\
+	static struct lis2dux12_data lis2dux12_data_##name##_##inst = {	\
+		IF_ENABLED(UTIL_AND(CONFIG_LIS2DUX12_STREAM,		\
+				    CONFIG_I2C_RTIO),			\
+			(.rtio_ctx = &lis2dux12_rtio_ctx_##name##_##inst,	\
+			 .iodev = &lis2dux12_iodev_##name##_##inst,		\
+			 .bus_type = BUS_I2C,))				\
+	};								\
+	static const struct lis2dux12_config lis2dux12_config_##name##_##inst =	\
+		LIS2DUX12_CONFIG_I2C(inst, name);
+
 /*
  * Main instantiation macro. Use of COND_CODE_1() selects the right
  * bus-specific macro at preprocessor time.
  */
 
 #define LIS2DUX12_DEFINE(inst, name)							\
-	static struct lis2dux12_data lis2dux12_data_##name##_##inst;			\
-	static const struct lis2dux12_config lis2dux12_config_##name##_##inst =		\
 		COND_CODE_1(DT_INST_ON_BUS(inst, spi),					\
-			    (LIS2DUX12_CONFIG_SPI(inst, name)),				\
-			    (LIS2DUX12_CONFIG_I2C(inst, name)));			\
+			    (LIS2DUX12_DEFINE_SPI(inst, name)),				\
+			    (LIS2DUX12_DEFINE_I2C(inst, name)));			\
 											\
 	SENSOR_DEVICE_DT_INST_DEFINE(inst, name##_init, NULL,				\
 				     &lis2dux12_data_##name##_##inst,			\

drivers/sensor/st/lis2dux12/lis2dux12.h

@@ -34,12 +34,33 @@
 #include <zephyr/drivers/i2c.h>
 #endif
 
+/* Accel sensor sensitivity grain is 61 ug/LSB */
+#define GAIN_UNIT (61LL)
+
+#ifdef CONFIG_LIS2DUX12_STREAM
+struct trigger_config {
+	uint8_t int_fifo_th : 1;
+	uint8_t int_fifo_full : 1;
+	uint8_t int_drdy : 1;
+};
+#endif
+
 typedef int32_t (*api_lis2dux12_set_odr_raw)(const struct device *dev, uint8_t odr);
 typedef int32_t (*api_lis2dux12_set_range)(const struct device *dev, uint8_t range);
 typedef int32_t (*api_lis2dux12_sample_fetch_accel)(const struct device *dev);
 #ifdef CONFIG_LIS2DUX12_ENABLE_TEMP
 typedef int32_t (*api_lis2dux12_sample_fetch_temp)(const struct device *dev);
 #endif
+#ifdef CONFIG_SENSOR_ASYNC_API
+typedef int32_t (*api_lis2dux12_rtio_read_accel)(const struct device *dev, int16_t *acc);
+typedef int32_t (*api_lis2dux12_rtio_read_temp)(const struct device *dev, int16_t *temp);
+#endif
+#ifdef CONFIG_LIS2DUX12_STREAM
+typedef void (*api_lis2dux12_stream_config_fifo)(const struct device *dev,
+						 struct trigger_config trig_cfg);
+typedef void (*api_lis2dux12_stream_config_drdy)(const struct device *dev,
+						 struct trigger_config trig_cfg);
+#endif
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 typedef void (*api_lis2dux12_handle_interrupt)(const struct device *dev);
 typedef int32_t (*api_lis2dux12_init_interrupt)(const struct device *dev);
@@ -52,6 +73,14 @@ struct lis2dux12_chip_api {
 #ifdef CONFIG_LIS2DUX12_ENABLE_TEMP
 	api_lis2dux12_sample_fetch_temp sample_fetch_temp;
 #endif
+#ifdef CONFIG_SENSOR_ASYNC_API
+	api_lis2dux12_rtio_read_accel rtio_read_accel;
+	api_lis2dux12_rtio_read_temp rtio_read_temp;
+#endif
+#ifdef CONFIG_LIS2DUX12_STREAM
+	api_lis2dux12_stream_config_fifo stream_config_fifo;
+	api_lis2dux12_stream_config_drdy stream_config_drdy;
+#endif
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 	api_lis2dux12_handle_interrupt handle_interrupt;
 	api_lis2dux12_init_interrupt init_interrupt;
@@ -73,6 +102,12 @@ struct lis2dux12_config {
 	uint8_t range;
 	uint8_t pm;
 	uint8_t odr;
+#ifdef CONFIG_LIS2DUX12_STREAM
+	uint8_t fifo_wtm;
+	uint8_t accel_batch : 3;
+	uint8_t ts_batch : 2;
+	uint8_t reserved : 3;
+#endif
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 	const struct gpio_dt_spec int1_gpio;
 	const struct gpio_dt_spec int2_gpio;
@@ -95,6 +130,21 @@ struct lis2dux12_data {
 	float sample_temp;
 #endif
 
+ #ifdef CONFIG_LIS2DUX12_STREAM
+	struct rtio_iodev_sqe *streaming_sqe;
+	struct rtio *rtio_ctx;
+	struct rtio_iodev *iodev;
+	uint64_t timestamp;
+	uint8_t status;
+	uint8_t fifo_status[2];
+	uint16_t fifo_count;
+	struct trigger_config trig_cfg;
+	uint8_t accel_batch_odr : 3;
+	uint8_t ts_batch_odr : 2;
+	uint8_t bus_type : 1; /* I2C is 0, SPI is 1 */
+	uint8_t reserved : 2;
+ #endif
+
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 	struct gpio_dt_spec *drdy_gpio;
 	struct gpio_callback gpio_cb;
@@ -114,6 +164,19 @@ struct lis2dux12_data {
 #endif /* CONFIG_LIS2DUX12_TRIGGER */
 };
 
+#ifdef CONFIG_LIS2DUX12_STREAM
+#define BUS_I2C 0
+#define BUS_SPI 1
+
+static inline uint8_t lis2dux12_bus_reg(struct lis2dux12_data *data, uint8_t x)
+{
+	return (data->bus_type == BUS_SPI) ? x | 0x80 : x;
+}
+
+#define LIS2DUX12_FIFO_ITEM_LEN 7
+#define LIS2DUX12_FIFO_SIZE(x) (x * LIS2DUX12_FIFO_ITEM_LEN)
+#endif
+
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 int lis2dux12_trigger_set(const struct device *dev,
 			 const struct sensor_trigger *trig,

drivers/sensor/st/lis2dux12/lis2dux12_api.c

@@ -101,6 +101,121 @@ static int32_t st_lis2dux12_sample_fetch_temp(const struct device *dev)
 }
 #endif
 
+#ifdef CONFIG_SENSOR_ASYNC_API
+static int32_t st_lis2dux12_rtio_read_accel(const struct device *dev, int16_t *acc)
+{
+	struct lis2dux12_data *data = dev->data;
+	const struct lis2dux12_config *cfg = dev->config;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
+
+	/* fetch raw data sample */
+	lis2dux12_md_t mode = {.fs = data->range};
+	lis2dux12_xl_data_t xzy_data = {0};
+
+	if (lis2dux12_xl_data_get(ctx, &mode, &xzy_data) < 0) {
+		LOG_ERR("Failed to fetch raw data sample");
+		return -EIO;
+	}
+
+	acc[0] = xzy_data.raw[0];
+	acc[1] = xzy_data.raw[1];
+	acc[2] = xzy_data.raw[2];
+
+	return 0;
+}
+
+static int32_t st_lis2dux12_rtio_read_temp(const struct device *dev, int16_t *temp)
+{
+	const struct lis2dux12_config *cfg = dev->config;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
+
+	/* fetch raw data sample */
+	lis2dux12_outt_data_t temp_data = {0};
+
+	if (lis2dux12_outt_data_get(ctx, &temp_data) < 0) {
+		LOG_ERR("Failed to fetch raw temperature data sample");
+		return -EIO;
+	}
+
+	*temp = temp_data.heat.raw;
+
+	return 0;
+}
+#endif
+
+#ifdef CONFIG_LIS2DUX12_STREAM
+static void st_lis2dux12_stream_config_fifo(const struct device *dev,
+					    struct trigger_config trig_cfg)
+{
+	struct lis2dux12_data *lis2dux12 = dev->data;
+	const struct lis2dux12_config *config = dev->config;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)&config->ctx;
+	lis2dux12_pin_int_route_t pin_int = { 0 };
+	lis2dux12_fifo_mode_t fifo_mode;
+
+	/* disable FIFO as first thing */
+	fifo_mode.store = LIS2DUX12_FIFO_1X;
+	fifo_mode.xl_only = 1;
+	fifo_mode.watermark = 0;
+	fifo_mode.operation = LIS2DUX12_BYPASS_MODE;
+	fifo_mode.batch.dec_ts = LIS2DUX12_DEC_TS_OFF;
+	fifo_mode.batch.bdr_xl = LIS2DUX12_BDR_XL_ODR_OFF;
+
+	pin_int.fifo_th = PROPERTY_DISABLE;
+	pin_int.fifo_full = PROPERTY_DISABLE;
+
+	if (trig_cfg.int_fifo_th || trig_cfg.int_fifo_full) {
+		pin_int.fifo_th = (trig_cfg.int_fifo_th) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
+		pin_int.fifo_full = (trig_cfg.int_fifo_full) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
+
+		fifo_mode.operation = LIS2DUX12_STREAM_MODE;
+		fifo_mode.batch.dec_ts = config->ts_batch;
+		fifo_mode.batch.bdr_xl = config->accel_batch;
+		fifo_mode.watermark = config->fifo_wtm;
+	}
+
+	/*
+	 * Set FIFO watermark (number of unread sensor data TAG + 6 bytes
+	 * stored in FIFO) to FIFO_WATERMARK samples
+	 */
+	lis2dux12_fifo_mode_set(ctx, fifo_mode);
+
+	/* Set FIFO batch rates */
+	lis2dux12->accel_batch_odr = fifo_mode.batch.bdr_xl;
+	lis2dux12->ts_batch_odr = fifo_mode.batch.dec_ts;
+
+	/* Set pin interrupt (fifo_th could be on or off) */
+	if (config->drdy_pin == 1) {
+		lis2dux12_pin_int1_route_set(ctx, &pin_int);
+	} else {
+		lis2dux12_pin_int2_route_set(ctx, &pin_int);
+	}
+}
+
+static void st_lis2dux12_stream_config_drdy(const struct device *dev,
+					    struct trigger_config trig_cfg)
+{
+	const struct lis2dux12_config *config = dev->config;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)&config->ctx;
+	lis2dux12_pin_int_route_t pin_int = { 0 };
+
+	/* dummy read: re-trigger interrupt */
+	lis2dux12_md_t md = {.fs = LIS2DUX12_2g};
+	lis2dux12_xl_data_t buf;
+
+	lis2dux12_xl_data_get(ctx, &md, &buf);
+
+	pin_int.drdy = PROPERTY_ENABLE;
+
+	/* Set pin interrupt */
+	if (config->drdy_pin == 1) {
+		lis2dux12_pin_int1_route_set(ctx, &pin_int);
+	} else {
+		lis2dux12_pin_int2_route_set(ctx, &pin_int);
+	}
+}
+#endif
+
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 static void st_lis2dux12_handle_interrupt(const struct device *dev)
 {
@@ -164,6 +279,14 @@ const struct lis2dux12_chip_api st_lis2dux12_chip_api = {
 #ifdef CONFIG_LIS2DUX12_ENABLE_TEMP
 	.sample_fetch_temp = st_lis2dux12_sample_fetch_temp,
 #endif
+#ifdef CONFIG_SENSOR_ASYNC_API
+	.rtio_read_accel = st_lis2dux12_rtio_read_accel,
+	.rtio_read_temp = st_lis2dux12_rtio_read_temp,
+#endif
+#ifdef CONFIG_LIS2DUX12_STREAM
+	.stream_config_fifo = st_lis2dux12_stream_config_fifo,
+	.stream_config_drdy = st_lis2dux12_stream_config_drdy,
+#endif
 #ifdef CONFIG_LIS2DUX12_TRIGGER
 	.handle_interrupt = st_lis2dux12_handle_interrupt,
 	.init_interrupt = st_lis2dux12_init_interrupt,