driver/sensor: lis2ds12: make use of STdC definitions

Port the lis2ds12 sensor driver on top of the lis2ds12_StdC
HAL interface (in modules/hal/st/sensor/stmemsc/).

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

drivers/sensor/lis2ds12/Kconfig

@@ -6,6 +6,8 @@
 menuconfig LIS2DS12
 	bool "LIS2DS12 I2C/SPI accelerometer sensor driver"
 	depends on I2C || SPI
+	select HAS_STMEMSC
+	select USE_STDC_LIS2DS12
 	help
 	  Enable driver for LIS2DS12 accelerometer sensor driver
 

drivers/sensor/lis2ds12/lis2ds12.c

@@ -41,83 +41,54 @@ static struct lis2ds12_config lis2ds12_config = {
 #endif
 };
 
-#if defined(LIS2DS12_ODR_RUNTIME)
-static const uint16_t lis2ds12_hr_odr_map[] = {0, 12, 25, 50, 100, 200, 400, 800};
-
-static int lis2ds12_freq_to_odr_val(uint16_t freq)
-{
-	size_t i;
-
-	for (i = 0; i < ARRAY_SIZE(lis2ds12_hr_odr_map); i++) {
-		if (freq == lis2ds12_hr_odr_map[i]) {
-			return i;
-		}
-	}
-
-	return -EINVAL;
-}
-
-static int lis2ds12_accel_odr_set(const struct device *dev, uint16_t freq)
+static int lis2ds12_set_odr(const struct device *dev, uint16_t odr)
 {
-	struct lis2ds12_data *data = dev->data;
-	int odr;
+	const struct lis2ds12_data *data = dev->data;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
+	uint8_t val;
 
-	odr = lis2ds12_freq_to_odr_val(freq);
-	if (odr < 0) {
-		return odr;
+	/* check if power off */
+	if (odr == 0U) {
+		return lis2ds12_xl_data_rate_set(ctx, LIS2DS12_XL_ODR_OFF);
 	}
 
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL1,
-				    LIS2DS12_MASK_CTRL1_ODR,
-				    odr << LIS2DS12_SHIFT_CTRL1_ODR) < 0) {
-		LOG_DBG("failed to set accelerometer sampling rate");
-		return -EIO;
-	}
-
-	return 0;
-}
-#endif
-
-#ifdef LIS2DS12_FS_RUNTIME
-static const uint16_t lis2ds12_accel_fs_map[] = {2, 16, 4, 8};
-static const uint16_t lis2ds12_accel_fs_sens[] = {1, 8, 2, 4};
-
-static int lis2ds12_accel_range_to_fs_val(int32_t range)
-{
-	size_t i;
-
-	for (i = 0; i < ARRAY_SIZE(lis2ds12_accel_fs_map); i++) {
-		if (range == lis2ds12_accel_fs_map[i]) {
-			return i;
-		}
+	val = LIS2DS12_HR_ODR_TO_REG(odr);
+	if (val > LIS2DS12_XL_ODR_800Hz_HR) {
+		LOG_ERR("ODR too high");
+		return -EINVAL;
 	}
 
-	return -EINVAL;
+	return lis2ds12_xl_data_rate_set(ctx, val);
 }
 
-static int lis2ds12_accel_range_set(const struct device *dev, int32_t range)
+static int lis2ds12_set_range(const struct device *dev, uint8_t range)
 {
-	int fs;
+	int err;
 	struct lis2ds12_data *data = dev->data;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
 
-	fs = lis2ds12_accel_range_to_fs_val(range);
-	if (fs < 0) {
-		return fs;
-	}
-
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL1,
-				    LIS2DS12_MASK_CTRL1_FS,
-				    fs << LIS2DS12_SHIFT_CTRL1_FS) < 0) {
-		LOG_DBG("failed to set accelerometer full-scale");
-		return -EIO;
+	switch (range) {
+	default:
+	case 2U:
+		err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_2g);
+		data->gain = lis2ds12_from_fs2g_to_mg(1);
+		break;
+	case 4U:
+		err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_4g);
+		data->gain = lis2ds12_from_fs4g_to_mg(1);
+		break;
+	case 8U:
+		err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_8g);
+		data->gain = lis2ds12_from_fs8g_to_mg(1);
+		break;
+	case 16U:
+		err = lis2ds12_xl_full_scale_set(ctx, LIS2DS12_16g);
+		data->gain = lis2ds12_from_fs16g_to_mg(1);
+		break;
 	}
 
-	data->gain = (float)(lis2ds12_accel_fs_sens[fs] * GAIN_XL);
-	return 0;
+	return err;
 }
-#endif
 
 static int lis2ds12_accel_config(const struct device *dev,
 				 enum sensor_channel chan,
@@ -125,14 +96,10 @@ static int lis2ds12_accel_config(const struct device *dev,
 				 const struct sensor_value *val)
 {
 	switch (attr) {
-#ifdef LIS2DS12_FS_RUNTIME
 	case SENSOR_ATTR_FULL_SCALE:
-		return lis2ds12_accel_range_set(dev, sensor_ms2_to_g(val));
-#endif
-#ifdef LIS2DS12_ODR_RUNTIME
+		return lis2ds12_set_range(dev, sensor_ms2_to_g(val));
 	case SENSOR_ATTR_SAMPLING_FREQUENCY:
-		return lis2ds12_accel_odr_set(dev, val->val1);
-#endif
+		return lis2ds12_set_odr(dev, val->val1);
 	default:
 		LOG_DBG("Accel attribute not supported.");
 		return -ENOTSUP;
@@ -160,17 +127,18 @@ static int lis2ds12_attr_set(const struct device *dev,
 static int lis2ds12_sample_fetch_accel(const struct device *dev)
 {
 	struct lis2ds12_data *data = dev->data;
-	uint8_t buf[6];
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
+	int16_t buf[3];
 
-	if (data->hw_tf->read_data(data, LIS2DS12_REG_OUTX_L,
-				   buf, sizeof(buf)) < 0) {
-		LOG_DBG("failed to read sample");
+	/* fetch raw data sample */
+	if (lis2ds12_acceleration_raw_get(ctx, buf) < 0) {
+		LOG_ERR("Failed to fetch raw data sample");
 		return -EIO;
 	}
 
-	data->sample_x = (int16_t)((uint16_t)(buf[0]) | ((uint16_t)(buf[1]) << 8));
-	data->sample_y = (int16_t)((uint16_t)(buf[2]) | ((uint16_t)(buf[3]) << 8));
-	data->sample_z = (int16_t)((uint16_t)(buf[4]) | ((uint16_t)(buf[5]) << 8));
+	data->sample_x = sys_le16_to_cpu(buf[0]);
+	data->sample_y = sys_le16_to_cpu(buf[1]);
+	data->sample_z = sys_le16_to_cpu(buf[2]);
 
 	return 0;
 }
@@ -265,35 +233,40 @@ static int lis2ds12_init(const struct device *dev)
 {
 	const struct lis2ds12_config * const config = dev->config;
 	struct lis2ds12_data *data = dev->data;
+	stmdev_ctx_t *ctx;
 	uint8_t chip_id;
+	int ret;
 
 	data->comm_master = device_get_binding(config->comm_master_dev_name);
 	if (!data->comm_master) {
-		LOG_DBG("master not found: %s",
+		LOG_ERR("master not found: %s",
 			    config->comm_master_dev_name);
 		return -EINVAL;
 	}
 
 	config->bus_init(dev);
 
-	/* s/w reset the sensor */
-	if (data->hw_tf->write_reg(data,
-				    LIS2DS12_REG_CTRL2,
-				    LIS2DS12_SOFT_RESET) < 0) {
-		LOG_DBG("s/w reset fail");
-		return -EIO;
+	ctx = (stmdev_ctx_t *)data->ctx;
+	/* check chip ID */
+	ret = lis2ds12_device_id_get(ctx, &chip_id);
+	if (ret < 0) {
+		LOG_ERR("Not able to read dev id");
+		return ret;
 	}
 
-	if (data->hw_tf->read_reg(data, LIS2DS12_REG_WHO_AM_I, &chip_id) < 0) {
-		LOG_DBG("failed reading chip id");
-		return -EIO;
+	if (chip_id != LIS2DS12_ID) {
+		LOG_ERR("Invalid chip ID 0x%02x", chip_id);
+		return -EINVAL;
 	}
 
-	if (chip_id != LIS2DS12_VAL_WHO_AM_I) {
-		LOG_DBG("invalid chip id 0x%x", chip_id);
-		return -EIO;
+	/* reset device */
+	ret = lis2ds12_reset_set(ctx, PROPERTY_ENABLE);
+	if (ret < 0) {
+		return ret;
 	}
 
+	k_busy_wait(100);
+
 	LOG_DBG("chip id 0x%x", chip_id);
 
 #ifdef CONFIG_LIS2DS12_TRIGGER
@@ -304,23 +277,18 @@ static int lis2ds12_init(const struct device *dev)
 #endif
 
 	/* set sensor default odr */
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL1,
-				    LIS2DS12_MASK_CTRL1_ODR,
-				    LIS2DS12_DEFAULT_ODR) < 0) {
-		LOG_DBG("failed setting odr");
-		return -EIO;
+	ret = lis2ds12_set_odr(dev, 12);
+	if (ret < 0) {
+		LOG_ERR("odr init error (12.5 Hz)");
+		return ret;
 	}
 
 	/* set sensor default scale */
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL1,
-				    LIS2DS12_MASK_CTRL1_FS,
-				    LIS2DS12_DEFAULT_FS) < 0) {
-		LOG_DBG("failed setting scale");
-		return -EIO;
+	ret = lis2ds12_set_range(dev, CONFIG_LIS2DS12_FS);
+	if (ret < 0) {
+		LOG_ERR("range init error %d", CONFIG_LIS2DS12_FS);
+		return ret;
 	}
-	data->gain = LIS2DS12_DEFAULT_GAIN;
 
 	return 0;
 }

drivers/sensor/lis2ds12/lis2ds12.h

@@ -14,72 +14,12 @@
 #include <zephyr/types.h>
 #include <drivers/sensor.h>
 #include <drivers/gpio.h>
+#include "lis2ds12_reg.h"
 
-#define LIS2DS12_REG_WHO_AM_I			0x0F
-#define LIS2DS12_VAL_WHO_AM_I			0x43
-
-#define LIS2DS12_REG_CTRL1			0x20
-#define LIS2DS12_MASK_CTRL1_ODR			(BIT(7) | BIT(6) | \
-						 BIT(5) | BIT(4))
-#define LIS2DS12_SHIFT_CTRL1_ODR		4
-#define LIS2DS12_MASK_CTRL1_FS			(BIT(3) | BIT(2))
-#define LIS2DS12_SHIFT_CTRL1_FS			2
-#define LIS2DS12_MASK_CTRL1_HF_ODR		BIT(1)
-#define LIS2DS12_MASK_CTRL1_HF_BDU		BIT(0)
-
-#define LIS2DS12_REG_CTRL2			0x21
-#define LIS2DS12_SOFT_RESET			0x40
-
-#define LIS2DS12_REG_CTRL3			0x22
-#define LIS2DS12_SHIFT_LIR			0x02
-#define LIS2DS12_MASK_LIR			0x04
-
-#define LIS2DS12_REG_CTRL4			0x23
-#define LIS2DS12_SHIFT_INT1_DRDY		0x00
-#define LIS2DS12_MASK_INT1_DRDY			0x01
-
-#define LIS2DS12_REG_OUT_T			0x26
-
-#define LIS2DS12_REG_STATUS			0x27
-#define LIS2DS12_INT_DRDY			0x01
-
-#define LIS2DS12_REG_OUTX_L			0x28
-#define LIS2DS12_REG_OUTX_H			0x29
-#define LIS2DS12_REG_OUTY_L			0x2A
-#define LIS2DS12_REG_OUTY_H			0x2B
-#define LIS2DS12_REG_OUTZ_L			0x2C
-#define LIS2DS12_REG_OUTZ_H			0x2D
-
-
-#if (CONFIG_LIS2DS12_ODR == 0)
-#define LIS2DS12_ODR_RUNTIME			1
-#define LIS2DS12_DEFAULT_ODR			0
-#else
-#define LIS2DS12_DEFAULT_ODR			(CONFIG_LIS2DS12_ODR << 4)
-#endif
-
-/* Accel sensor sensitivity unit is 0.061 mg/LSB */
-#define GAIN_XL				(61LL / 1000.0)
-
-#if CONFIG_LIS2DS12_FS == 0
-#define LIS2DS12_FS_RUNTIME 1
-#define LIS2DS12_DEFAULT_FS			(0 << 2)
-#define LIS2DS12_DEFAULT_GAIN			GAIN_XL
-#elif CONFIG_LIS2DS12_FS == 2
-#define LIS2DS12_DEFAULT_FS			(0 << 2)
-#define LIS2DS12_DEFAULT_GAIN			GAIN_XL
-#elif CONFIG_LIS2DS12_FS == 4
-#define LIS2DS12_DEFAULT_FS			(2 << 2)
-#define LIS2DS12_DEFAULT_GAIN			(2.0 * GAIN_XL)
-#elif CONFIG_LIS2DS12_FS == 8
-#define LIS2DS12_DEFAULT_FS			(3 << 2)
-#define LIS2DS12_DEFAULT_GAIN			(4.0 * GAIN_XL)
-#elif CONFIG_LIS2DS12_FS == 16
-#define LIS2DS12_DEFAULT_FS			(1 << 2)
-#define LIS2DS12_DEFAULT_GAIN			(8.0 * GAIN_XL)
-#else
-#error "Bad LIS2DS12 FS value (should be 0, 2, 4, 8, 16)"
-#endif
+/* Return ODR reg value based on data rate set */
+#define LIS2DS12_HR_ODR_TO_REG(_odr) \
+	((_odr <= 12) ? LIS2DS12_XL_ODR_12Hz5_HR : \
+	 ((31 - __builtin_clz(_odr / 25))) + 2)
 
 struct lis2ds12_config {
 	char *comm_master_dev_name;
@@ -91,28 +31,13 @@ struct lis2ds12_config {
 #endif
 };
 
-struct lis2ds12_data;
-
-struct lis2ds12_transfer_function {
-	int (*read_data)(struct lis2ds12_data *data, uint8_t reg_addr,
-			 uint8_t *value, uint8_t len);
-	int (*write_data)(struct lis2ds12_data *data, uint8_t reg_addr,
-			  uint8_t *value, uint8_t len);
-	int (*read_reg)(struct lis2ds12_data *data, uint8_t reg_addr,
-			uint8_t *value);
-	int (*write_reg)(struct lis2ds12_data *data, uint8_t reg_addr,
-			uint8_t value);
-	int (*update_reg)(struct lis2ds12_data *data, uint8_t reg_addr,
-			  uint8_t mask, uint8_t value);
-};
-
 struct lis2ds12_data {
+	stmdev_ctx_t *ctx;
 	const struct device *comm_master;
 	int sample_x;
 	int sample_y;
 	int sample_z;
 	float gain;
-	const struct lis2ds12_transfer_function *hw_tf;
 
 #ifdef CONFIG_LIS2DS12_TRIGGER
 	const struct device *gpio;

drivers/sensor/lis2ds12/lis2ds12_i2c.c

@@ -22,54 +22,31 @@ static uint16_t lis2ds12_i2c_slave_addr = DT_INST_REG_ADDR(0);
 
 LOG_MODULE_DECLARE(LIS2DS12, CONFIG_SENSOR_LOG_LEVEL);
 
-static int lis2ds12_i2c_read_data(struct lis2ds12_data *data, uint8_t reg_addr,
-				 uint8_t *value, uint8_t len)
+static int lis2ds12_i2c_read(struct lis2ds12_data *data, uint8_t reg_addr,
+				 uint8_t *value, uint16_t len)
 {
 	return i2c_burst_read(data->comm_master, lis2ds12_i2c_slave_addr,
 			      reg_addr, value, len);
 }
 
-static int lis2ds12_i2c_write_data(struct lis2ds12_data *data, uint8_t reg_addr,
-				  uint8_t *value, uint8_t len)
+static int lis2ds12_i2c_write(struct lis2ds12_data *data, uint8_t reg_addr,
+				  uint8_t *value, uint16_t len)
 {
 	return i2c_burst_write(data->comm_master, lis2ds12_i2c_slave_addr,
 			       reg_addr, value, len);
 }
 
-static int lis2ds12_i2c_read_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				uint8_t *value)
-{
-	return i2c_reg_read_byte(data->comm_master, lis2ds12_i2c_slave_addr,
-				 reg_addr, value);
-}
-
-static int lis2ds12_i2c_write_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				uint8_t value)
-{
-	return i2c_reg_write_byte(data->comm_master, lis2ds12_i2c_slave_addr,
-				 reg_addr, value);
-}
-
-static int lis2ds12_i2c_update_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				  uint8_t mask, uint8_t value)
-{
-	return i2c_reg_update_byte(data->comm_master, lis2ds12_i2c_slave_addr,
-				   reg_addr, mask, value);
-}
-
-static const struct lis2ds12_transfer_function lis2ds12_i2c_transfer_fn = {
-	.read_data = lis2ds12_i2c_read_data,
-	.write_data = lis2ds12_i2c_write_data,
-	.read_reg  = lis2ds12_i2c_read_reg,
-	.write_reg  = lis2ds12_i2c_write_reg,
-	.update_reg = lis2ds12_i2c_update_reg,
+stmdev_ctx_t lis2ds12_i2c_ctx = {
+	.read_reg = (stmdev_read_ptr) lis2ds12_i2c_read,
+	.write_reg = (stmdev_write_ptr) lis2ds12_i2c_write,
 };
 
 int lis2ds12_i2c_init(const struct device *dev)
 {
 	struct lis2ds12_data *data = dev->data;
 
-	data->hw_tf = &lis2ds12_i2c_transfer_fn;
+	data->ctx = &lis2ds12_i2c_ctx;
+	data->ctx->handle = data;
 
 	return 0;
 }

drivers/sensor/lis2ds12/lis2ds12_spi.c

@@ -34,11 +34,11 @@ static struct spi_config lis2ds12_spi_conf = {
 	.cs        = NULL,
 };
 
-static int lis2ds12_raw_read(struct lis2ds12_data *data, uint8_t reg_addr,
-			    uint8_t *value, uint8_t len)
+static int lis2ds12_spi_read(struct lis2ds12_data *data, uint8_t reg,
+			     uint8_t *value, uint16_t len)
 {
 	struct spi_config *spi_cfg = &lis2ds12_spi_conf;
-	uint8_t buffer_tx[2] = { reg_addr | LIS2DS12_SPI_READ, 0 };
+	uint8_t buffer_tx[2] = { reg | LIS2DS12_SPI_READ, 0 };
 	const struct spi_buf tx_buf = {
 			.buf = buffer_tx,
 			.len = 2,
@@ -63,10 +63,6 @@ static int lis2ds12_raw_read(struct lis2ds12_data *data, uint8_t reg_addr,
 	};
 
 
-	if (len > 64) {
-		return -EIO;
-	}
-
 	if (spi_transceive(data->comm_master, spi_cfg, &tx, &rx)) {
 		return -EIO;
 	}
@@ -74,11 +70,11 @@ static int lis2ds12_raw_read(struct lis2ds12_data *data, uint8_t reg_addr,
 	return 0;
 }
 
-static int lis2ds12_raw_write(struct lis2ds12_data *data, uint8_t reg_addr,
-			     uint8_t *value, uint8_t len)
+static int lis2ds12_spi_write(struct lis2ds12_data *data, uint8_t reg,
+			      uint8_t *value, uint16_t len)
 {
 	struct spi_config *spi_cfg = &lis2ds12_spi_conf;
-	uint8_t buffer_tx[1] = { reg_addr & ~LIS2DS12_SPI_READ };
+	uint8_t buffer_tx[1] = { reg & ~LIS2DS12_SPI_READ };
 	const struct spi_buf tx_buf[2] = {
 		{
 			.buf = buffer_tx,
@@ -94,11 +90,6 @@ static int lis2ds12_raw_write(struct lis2ds12_data *data, uint8_t reg_addr,
 		.count = 2
 	};
 
-
-	if (len > 64) {
-		return -EIO;
-	}
-
 	if (spi_write(data->comm_master, spi_cfg, &tx)) {
 		return -EIO;
 	}
@@ -106,56 +97,17 @@ static int lis2ds12_raw_write(struct lis2ds12_data *data, uint8_t reg_addr,
 	return 0;
 }
 
-static int lis2ds12_spi_read_data(struct lis2ds12_data *data, uint8_t reg_addr,
-				 uint8_t *value, uint8_t len)
-{
-	return lis2ds12_raw_read(data, reg_addr, value, len);
-}
-
-static int lis2ds12_spi_write_data(struct lis2ds12_data *data, uint8_t reg_addr,
-				  uint8_t *value, uint8_t len)
-{
-	return lis2ds12_raw_write(data, reg_addr, value, len);
-}
-
-static int lis2ds12_spi_read_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				uint8_t *value)
-{
-	return lis2ds12_raw_read(data, reg_addr, value, 1);
-}
-
-static int lis2ds12_spi_write_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				uint8_t value)
-{
-	uint8_t tmp_val = value;
-
-	return lis2ds12_raw_write(data, reg_addr, &tmp_val, 1);
-}
-
-static int lis2ds12_spi_update_reg(struct lis2ds12_data *data, uint8_t reg_addr,
-				  uint8_t mask, uint8_t value)
-{
-	uint8_t tmp_val;
-
-	lis2ds12_raw_read(data, reg_addr, &tmp_val, 1);
-	tmp_val = (tmp_val & ~mask) | (value & mask);
-
-	return lis2ds12_raw_write(data, reg_addr, &tmp_val, 1);
-}
-
-static const struct lis2ds12_transfer_function lis2ds12_spi_transfer_fn = {
-	.read_data = lis2ds12_spi_read_data,
-	.write_data = lis2ds12_spi_write_data,
-	.read_reg  = lis2ds12_spi_read_reg,
-	.write_reg  = lis2ds12_spi_write_reg,
-	.update_reg = lis2ds12_spi_update_reg,
+stmdev_ctx_t lis2ds12_spi_ctx = {
+	.read_reg = (stmdev_read_ptr)lis2ds12_spi_read,
+	.write_reg = (stmdev_write_ptr)lis2ds12_spi_write,
 };
 
 int lis2ds12_spi_init(const struct device *dev)
 {
 	struct lis2ds12_data *data = dev->data;
 
-	data->hw_tf = &lis2ds12_spi_transfer_fn;
+	data->ctx = &lis2ds12_spi_ctx;
+	data->ctx->handle = data;
 
 #if DT_INST_SPI_DEV_HAS_CS_GPIOS(0)
 	/* handle SPI CS thru GPIO if it is the case */

drivers/sensor/lis2ds12/lis2ds12_trigger.c

@@ -51,14 +51,12 @@ static void lis2ds12_handle_int(const struct device *dev)
 {
 	struct lis2ds12_data *data = dev->data;
 	const struct lis2ds12_config *cfg = dev->config;
-	uint8_t status;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
+	lis2ds12_all_sources_t sources;
 
-	if (data->hw_tf->read_reg(data, LIS2DS12_REG_STATUS, &status) < 0) {
-		LOG_ERR("status reading error");
-		return;
-	}
+	lis2ds12_all_sources_get(ctx, &sources);
 
-	if (status & LIS2DS12_INT_DRDY) {
+	if (sources.status_dup.drdy) {
 		lis2ds12_handle_drdy_int(dev);
 	}
 
@@ -89,23 +87,27 @@ static void lis2ds12_work_cb(struct k_work *work)
 static int lis2ds12_init_interrupt(const struct device *dev)
 {
 	struct lis2ds12_data *data = dev->data;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
+	lis2ds12_pin_int1_route_t route;
+	int err;
+
+	/* Enable pulsed mode */
+	err = lis2ds12_int_notification_set(ctx, LIS2DS12_INT_PULSED);
+	if (err < 0) {
+		return err;
+	}
 
-	/* Enable latched mode */
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL3,
-				    LIS2DS12_MASK_LIR,
-				    (1 << LIS2DS12_SHIFT_LIR)) < 0) {
-		LOG_ERR("Could not enable LIR mode.");
-		return -EIO;
+	/* route data-ready interrupt on int1 */
+	err = lis2ds12_pin_int1_route_get(ctx, &route);
+	if (err < 0) {
+		return err;
 	}
 
-	/* enable data-ready interrupt */
-	if (data->hw_tf->update_reg(data,
-				    LIS2DS12_REG_CTRL4,
-				    LIS2DS12_MASK_INT1_DRDY,
-				    (1 << LIS2DS12_SHIFT_INT1_DRDY)) < 0) {
-		LOG_ERR("Could not enable data-ready interrupt.");
-		return -EIO;
+	route.int1_drdy = 1;
+
+	err = lis2ds12_pin_int1_route_set(ctx, route);
+	if (err < 0) {
+		return err;
 	}
 
 	return 0;
@@ -160,8 +162,9 @@ int lis2ds12_trigger_set(const struct device *dev,
 			 sensor_trigger_handler_t handler)
 {
 	struct lis2ds12_data *data = dev->data;
+	stmdev_ctx_t *ctx = (stmdev_ctx_t *)data->ctx;
 	const struct lis2ds12_config *cfg = dev->config;
-	uint8_t buf[6];
+	int16_t raw[3];
 
 	__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
 
@@ -175,11 +178,7 @@ int lis2ds12_trigger_set(const struct device *dev,
 	}
 
 	/* re-trigger lost interrupt */
-	if (data->hw_tf->read_data(data, LIS2DS12_REG_OUTX_L,
-				   buf, sizeof(buf)) < 0) {
-		LOG_ERR("status reading error");
-		return -EIO;
-	}
+	lis2ds12_acceleration_raw_get(ctx, raw);
 
 	data->data_ready_trigger = *trig;