michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers/sensor: iis2dlpc: use common stmemsc routine

Browse source 
This commit aligns iis2dlpc sensor driver to latest multi
instance sensor driver model.

In particular:

    1. make use of some few DT helpers:
        - get bus devices with DEVICE_DT_GET
        - get SPI information with SPI_CONFIG_DT_INST
        - get drdy gpios with GPIO_DT_SPEC_GET

    2. make use of the stmemsc common routines and move ctx
       handler inside struct config, so that the bus_init
       routines can be totally avoided.

Signed-off-by: Armando Visconti <armando.visconti@st.com>
This commit is contained in:
Armando Visconti 2021-04-30 17:51:23 +02:00 • committed by Anas Nashif
commit f0332eb5d3
6 changed files with 120 additions and 380 deletions
Download patch file Download diff file Expand all files Collapse all files

4
drivers/sensor/iis2dlpc/CMakeLists.txt
View file

@ -7,6 +7,6 @@
zephyr_library() zephyr_library()
zephyr_library_sources_ifdef(CONFIG_IIS2DLPC iis2dlpc) zephyr_library_sources_ifdef(CONFIG_IIS2DLPC iis2dlpc)
zephyr_library_sources_ifdef(CONFIG_IIS2DLPC iis2dlpc_i2c.c)
zephyr_library_sources_ifdef(CONFIG_IIS2DLPC iis2dlpc_spi.c)
zephyr_library_sources_ifdef(CONFIG_IIS2DLPC_TRIGGER iis2dlpc_trigger.c) zephyr_library_sources_ifdef(CONFIG_IIS2DLPC_TRIGGER iis2dlpc_trigger.c)
zephyr_library_include_directories(../stmemsc)

190
drivers/sensor/iis2dlpc/iis2dlpc.c
View file

@ -35,10 +35,11 @@ static int iis2dlpc_set_range(const struct device *dev, uint8_t fs)
{ {
int err; int err;
struct iis2dlpc_data *iis2dlpc = dev->data; struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config; const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t shift_gain = 0U; uint8_t shift_gain = 0U;
err = iis2dlpc_full_scale_set(iis2dlpc->ctx, fs); err = iis2dlpc_full_scale_set(ctx, fs);
if (cfg->pm == IIS2DLPC_CONT_LOW_PWR_12bit) { if (cfg->pm == IIS2DLPC_CONT_LOW_PWR_12bit) {
shift_gain = IIS2DLPC_SHFT_GAIN_NOLP1; shift_gain = IIS2DLPC_SHFT_GAIN_NOLP1;
@ -46,8 +47,7 @@ static int iis2dlpc_set_range(const struct device *dev, uint8_t fs)
if (!err) { if (!err) {
/* save internally gain for optimization */ /* save internally gain for optimization */
iis2dlpc->gain = iis2dlpc->gain = IIS2DLPC_FS_TO_GAIN(fs, shift_gain);
IIS2DLPC_FS_TO_GAIN(fs, shift_gain);
} }
return err; return err;
@ -60,13 +60,13 @@ static int iis2dlpc_set_range(const struct device *dev, uint8_t fs)
*/ */
static int iis2dlpc_set_odr(const struct device *dev, uint16_t odr) static int iis2dlpc_set_odr(const struct device *dev, uint16_t odr)
{ {
struct iis2dlpc_data *iis2dlpc = dev->data; const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t val; uint8_t val;
/* check if power off */ /* check if power off */
if (odr == 0U) { if (odr == 0U) {
return iis2dlpc_data_rate_set(iis2dlpc->ctx, return iis2dlpc_data_rate_set(ctx, IIS2DLPC_XL_ODR_OFF);
IIS2DLPC_XL_ODR_OFF);
} }
val = IIS2DLPC_ODR_TO_REG(odr); val = IIS2DLPC_ODR_TO_REG(odr);
@ -75,7 +75,7 @@ static int iis2dlpc_set_odr(const struct device *dev, uint16_t odr)
return -ENOTSUP; return -ENOTSUP;
} }
return iis2dlpc_data_rate_set(iis2dlpc->ctx, val); return iis2dlpc_data_rate_set(ctx, val);
} }
static inline void iis2dlpc_convert(struct sensor_value *val, int raw_val, static inline void iis2dlpc_convert(struct sensor_value *val, int raw_val,
@ -138,9 +138,10 @@ static int iis2dlpc_channel_get(const struct device *dev,
return -ENOTSUP; return -ENOTSUP;
} }
static int iis2dlpc_config(const struct device *dev, enum sensor_channel chan, static int iis2dlpc_dev_config(const struct device *dev,
enum sensor_attribute attr, enum sensor_channel chan,
const struct sensor_value *val) enum sensor_attribute attr,
const struct sensor_value *val)
{ {
switch (attr) { switch (attr) {
case SENSOR_ATTR_FULL_SCALE: case SENSOR_ATTR_FULL_SCALE:
@ -166,7 +167,7 @@ static int iis2dlpc_attr_set(const struct device *dev,
case SENSOR_CHAN_ACCEL_Y: case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z: case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ: case SENSOR_CHAN_ACCEL_XYZ:
return iis2dlpc_config(dev, chan, attr, val); return iis2dlpc_dev_config(dev, chan, attr, val);
default: default:
LOG_DBG("Attr not supported on %d channel", chan); LOG_DBG("Attr not supported on %d channel", chan);
break; break;
@ -179,12 +180,13 @@ static int iis2dlpc_sample_fetch(const struct device *dev,
enum sensor_channel chan) enum sensor_channel chan)
{ {
struct iis2dlpc_data *iis2dlpc = dev->data; struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config; const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t shift; uint8_t shift;
int16_t buf[3]; int16_t buf[3];
/* fetch raw data sample */ /* fetch raw data sample */
if (iis2dlpc_acceleration_raw_get(iis2dlpc->ctx, buf) < 0) { if (iis2dlpc_acceleration_raw_get(ctx, buf) < 0) {
LOG_DBG("Failed to fetch raw data sample"); LOG_DBG("Failed to fetch raw data sample");
return -EIO; return -EIO;
} }
@ -212,23 +214,7 @@ static const struct sensor_driver_api iis2dlpc_driver_api = {
.channel_get = iis2dlpc_channel_get, .channel_get = iis2dlpc_channel_get,
}; };
static int iis2dlpc_init_interface(const struct device *dev) static int iis2dlpc_set_power_mode(stmdev_ctx_t *ctx, iis2dlpc_mode_t pm)
{
struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config;
LOG_INF("bus name %s", cfg->bus_name);
iis2dlpc->bus = device_get_binding(cfg->bus_name);
if (!iis2dlpc->bus) {
LOG_DBG("master bus not found: %s", cfg->bus_name);
return -EINVAL;
}
return cfg->bus_init(dev);
}
static int iis2dlpc_set_power_mode(struct iis2dlpc_data *iis2dlpc,
iis2dlpc_mode_t pm)
{ {
uint8_t regval = IIS2DLPC_CONT_LOW_PWR_12bit; uint8_t regval = IIS2DLPC_CONT_LOW_PWR_12bit;
@ -244,23 +230,20 @@ static int iis2dlpc_set_power_mode(struct iis2dlpc_data *iis2dlpc,
break; break;
} }
return iis2dlpc_write_reg(iis2dlpc->ctx, IIS2DLPC_CTRL1, &regval, 1); return iis2dlpc_write_reg(ctx, IIS2DLPC_CTRL1, &regval, 1);
} }
static int iis2dlpc_init(const struct device *dev) static int iis2dlpc_init(const struct device *dev)
{ {
struct iis2dlpc_data *iis2dlpc = dev->data; struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config; const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t wai; uint8_t wai;
iis2dlpc->dev = dev; iis2dlpc->dev = dev;
if (iis2dlpc_init_interface(dev)) {
return -EINVAL;
}
/* check chip ID */ /* check chip ID */
if (iis2dlpc_device_id_get(iis2dlpc->ctx, &wai) < 0) { if (iis2dlpc_device_id_get(ctx, &wai) < 0) {
return -EIO; return -EIO;
} }
@ -270,20 +253,19 @@ static int iis2dlpc_init(const struct device *dev)
} }
/* reset device */ /* reset device */
if (iis2dlpc_reset_set(iis2dlpc->ctx, PROPERTY_ENABLE) < 0) { if (iis2dlpc_reset_set(ctx, PROPERTY_ENABLE) < 0) {
return -EIO; return -EIO;
} }
k_busy_wait(100); k_busy_wait(100);
if (iis2dlpc_block_data_update_set(iis2dlpc->ctx, if (iis2dlpc_block_data_update_set(ctx, PROPERTY_ENABLE) < 0) {
PROPERTY_ENABLE) < 0) {
return -EIO; return -EIO;
} }
/* set power mode */ /* set power mode */
LOG_INF("power-mode is %d", cfg->pm); LOG_INF("power-mode is %d", cfg->pm);
if (iis2dlpc_set_power_mode(iis2dlpc, cfg->pm)) { if (iis2dlpc_set_power_mode(ctx, cfg->pm)) {
return -EIO; return -EIO;
} }
@ -307,35 +289,32 @@ static int iis2dlpc_init(const struct device *dev)
#ifdef CONFIG_IIS2DLPC_TAP #ifdef CONFIG_IIS2DLPC_TAP
LOG_INF("TAP: tap mode is %d", cfg->tap_mode); LOG_INF("TAP: tap mode is %d", cfg->tap_mode);
if (iis2dlpc_tap_mode_set(iis2dlpc->ctx, cfg->tap_mode) < 0) { if (iis2dlpc_tap_mode_set(ctx, cfg->tap_mode) < 0) {
LOG_ERR("Failed to select tap trigger mode"); LOG_ERR("Failed to select tap trigger mode");
return -EIO; return -EIO;
} }
LOG_INF("TAP: ths_x is %02x", cfg->tap_threshold[0]); LOG_INF("TAP: ths_x is %02x", cfg->tap_threshold[0]);
if (iis2dlpc_tap_threshold_x_set(iis2dlpc->ctx, if (iis2dlpc_tap_threshold_x_set(ctx, cfg->tap_threshold[0]) < 0) {
cfg->tap_threshold[0]) < 0) {
LOG_ERR("Failed to set tap X axis threshold"); LOG_ERR("Failed to set tap X axis threshold");
return -EIO; return -EIO;
} }
LOG_INF("TAP: ths_y is %02x", cfg->tap_threshold[1]); LOG_INF("TAP: ths_y is %02x", cfg->tap_threshold[1]);
if (iis2dlpc_tap_threshold_y_set(iis2dlpc->ctx, if (iis2dlpc_tap_threshold_y_set(ctx, cfg->tap_threshold[1]) < 0) {
cfg->tap_threshold[1]) < 0) {
LOG_ERR("Failed to set tap Y axis threshold"); LOG_ERR("Failed to set tap Y axis threshold");
return -EIO; return -EIO;
} }
LOG_INF("TAP: ths_z is %02x", cfg->tap_threshold[2]); LOG_INF("TAP: ths_z is %02x", cfg->tap_threshold[2]);
if (iis2dlpc_tap_threshold_z_set(iis2dlpc->ctx, if (iis2dlpc_tap_threshold_z_set(ctx, cfg->tap_threshold[2]) < 0) {
cfg->tap_threshold[2]) < 0) {
LOG_ERR("Failed to set tap Z axis threshold"); LOG_ERR("Failed to set tap Z axis threshold");
return -EIO; return -EIO;
} }
if (cfg->tap_threshold[0] > 0) { if (cfg->tap_threshold[0] > 0) {
LOG_INF("TAP: tap_x enabled"); LOG_INF("TAP: tap_x enabled");
if (iis2dlpc_tap_detection_on_x_set(iis2dlpc->ctx, 1) < 0) { if (iis2dlpc_tap_detection_on_x_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on X axis"); LOG_ERR("Failed to set tap detection on X axis");
return -EIO; return -EIO;
} }
@ -343,7 +322,7 @@ static int iis2dlpc_init(const struct device *dev)
if (cfg->tap_threshold[1] > 0) { if (cfg->tap_threshold[1] > 0) {
LOG_INF("TAP: tap_y enabled"); LOG_INF("TAP: tap_y enabled");
if (iis2dlpc_tap_detection_on_y_set(iis2dlpc->ctx, 1) < 0) { if (iis2dlpc_tap_detection_on_y_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on Y axis"); LOG_ERR("Failed to set tap detection on Y axis");
return -EIO; return -EIO;
} }
@ -351,26 +330,26 @@ static int iis2dlpc_init(const struct device *dev)
if (cfg->tap_threshold[2] > 0) { if (cfg->tap_threshold[2] > 0) {
LOG_INF("TAP: tap_z enabled"); LOG_INF("TAP: tap_z enabled");
if (iis2dlpc_tap_detection_on_z_set(iis2dlpc->ctx, 1) < 0) { if (iis2dlpc_tap_detection_on_z_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on Z axis"); LOG_ERR("Failed to set tap detection on Z axis");
return -EIO; return -EIO;
} }
} }
LOG_INF("TAP: shock is %02x", cfg->tap_shock); LOG_INF("TAP: shock is %02x", cfg->tap_shock);
if (iis2dlpc_tap_shock_set(iis2dlpc->ctx, cfg->tap_shock) < 0) { if (iis2dlpc_tap_shock_set(ctx, cfg->tap_shock) < 0) {
LOG_ERR("Failed to set tap shock duration"); LOG_ERR("Failed to set tap shock duration");
return -EIO; return -EIO;
} }
LOG_INF("TAP: latency is %02x", cfg->tap_latency); LOG_INF("TAP: latency is %02x", cfg->tap_latency);
if (iis2dlpc_tap_dur_set(iis2dlpc->ctx, cfg->tap_latency) < 0) { if (iis2dlpc_tap_dur_set(ctx, cfg->tap_latency) < 0) {
LOG_ERR("Failed to set tap latency"); LOG_ERR("Failed to set tap latency");
return -EIO; return -EIO;
} }
LOG_INF("TAP: quiet time is %02x", cfg->tap_quiet); LOG_INF("TAP: quiet time is %02x", cfg->tap_quiet);
if (iis2dlpc_tap_quiet_set(iis2dlpc->ctx, cfg->tap_quiet) < 0) { if (iis2dlpc_tap_quiet_set(ctx, cfg->tap_quiet) < 0) {
LOG_ERR("Failed to set tap quiet time"); LOG_ERR("Failed to set tap quiet time");
return -EIO; return -EIO;
} }
@ -403,45 +382,6 @@ static int iis2dlpc_init(const struct device *dev)
* Instantiation macros used when a device is on a SPI bus. * Instantiation macros used when a device is on a SPI bus.
*/ */
#define IIS2DLPC_HAS_CS(inst) DT_INST_SPI_DEV_HAS_CS_GPIOS(inst)
#define IIS2DLPC_DATA_SPI_CS(inst) \
{ .cs_ctrl = { \
.gpio_pin = DT_INST_SPI_DEV_CS_GPIOS_PIN(inst), \
.gpio_dt_flags = DT_INST_SPI_DEV_CS_GPIOS_FLAGS(inst), \
}, \
}
#define IIS2DLPC_DATA_SPI(inst) \
COND_CODE_1(IIS2DLPC_HAS_CS(inst), \
(IIS2DLPC_DATA_SPI_CS(inst)), \
({}))
#define IIS2DLPC_SPI_CS_PTR(inst) \
COND_CODE_1(IIS2DLPC_HAS_CS(inst), \
(&(iis2dlpc_data_##inst.cs_ctrl)), \
(NULL))
#define IIS2DLPC_SPI_CS_LABEL(inst) \
COND_CODE_1(IIS2DLPC_HAS_CS(inst), \
(DT_INST_SPI_DEV_CS_GPIOS_LABEL(inst)), (NULL))
#define IIS2DLPC_SPI_CFG(inst) \
(&(struct iis2dlpc_spi_cfg) { \
.spi_conf = { \
.frequency = \
DT_INST_PROP(inst, spi_max_frequency), \
.operation = (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_LINES_SINGLE | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA), \
.slave = DT_INST_REG_ADDR(inst), \
.cs = IIS2DLPC_SPI_CS_PTR(inst), \
}, \
.cs_gpios_label = IIS2DLPC_SPI_CS_LABEL(inst), \
})
#ifdef CONFIG_IIS2DLPC_TAP #ifdef CONFIG_IIS2DLPC_TAP
#define IIS2DLPC_CONFIG_TAP(inst) \ #define IIS2DLPC_CONFIG_TAP(inst) \
.tap_mode = DT_INST_PROP(inst, tap_mode), \ .tap_mode = DT_INST_PROP(inst, tap_mode), \
@ -455,62 +395,76 @@ static int iis2dlpc_init(const struct device *dev)
#ifdef CONFIG_IIS2DLPC_TRIGGER #ifdef CONFIG_IIS2DLPC_TRIGGER
#define IIS2DLPC_CFG_IRQ(inst) \ #define IIS2DLPC_CFG_IRQ(inst) \
.irq_dev_name = DT_INST_GPIO_LABEL(inst, drdy_gpios), \ .gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios), \
.irq_pin = DT_INST_GPIO_PIN(inst, drdy_gpios), \ .drdy_int = DT_INST_PROP(inst, drdy_int),
.irq_flags = DT_INST_GPIO_FLAGS(inst, drdy_gpios), \
.drdy_int = DT_INST_PROP(inst, drdy_int),
#else #else
#define IIS2DLPC_CFG_IRQ(inst) #define IIS2DLPC_CFG_IRQ(inst)
#endif /* CONFIG_IIS2DLPC_TRIGGER */ #endif /* CONFIG_IIS2DLPC_TRIGGER */
#define IIS2DLPC_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define IIS2DLPC_CONFIG_SPI(inst) \ #define IIS2DLPC_CONFIG_SPI(inst) \
{ \ { \
.ctx = { \
.read_reg = \
(stmdev_read_ptr) stmemsc_spi_read, \
.write_reg = \
(stmdev_write_ptr) stmemsc_spi_write, \
.handle = \
(void *)&iis2dlpc_config_##inst.stmemsc_cfg, \
}, \
.stmemsc_cfg.spi = { \
.bus = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.spi_cfg = SPI_CONFIG_DT_INST(inst, \
IIS2DLPC_SPI_OPERATION, \
0), \
}, \
.pm = DT_INST_PROP(inst, power_mode), \ .pm = DT_INST_PROP(inst, power_mode), \
.range = DT_INST_PROP(inst, range), \ .range = DT_INST_PROP(inst, range), \
.bus_name = DT_INST_BUS_LABEL(inst), \
.bus_init = iis2dlpc_spi_init, \
.bus_cfg = { .spi_cfg = IIS2DLPC_SPI_CFG(inst) }, \
IIS2DLPC_CONFIG_TAP(inst) \ IIS2DLPC_CONFIG_TAP(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \ COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(IIS2DLPC_CFG_IRQ(inst)), ()) \ (IIS2DLPC_CFG_IRQ(inst)), ()) \
} }
#define IIS2DLPC_DEFINE_SPI(inst) \
static struct iis2dlpc_data iis2dlpc_data_##inst = \
IIS2DLPC_DATA_SPI(inst); \
static const struct iis2dlpc_dev_config iis2dlpc_config_##inst =\
IIS2DLPC_CONFIG_SPI(inst); \
IIS2DLPC_DEVICE_INIT(inst)
/* /*
* Instantiation macros used when a device is on an I2C bus. * Instantiation macros used when a device is on an I2C bus.
*/ */
#define IIS2DLPC_CONFIG_I2C(inst) \ #define IIS2DLPC_CONFIG_I2C(inst) \
{ \ { \
.ctx = { \
.read_reg = \
(stmdev_read_ptr) stmemsc_i2c_read, \
.write_reg = \
(stmdev_write_ptr) stmemsc_i2c_write, \
.handle = \
(void *)&iis2dlpc_config_##inst.stmemsc_cfg, \
}, \
.stmemsc_cfg.i2c = { \
.bus = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.i2c_slv_addr = DT_INST_REG_ADDR(inst), \
}, \
.pm = DT_INST_PROP(inst, power_mode), \ .pm = DT_INST_PROP(inst, power_mode), \
.range = DT_INST_PROP(inst, range), \ .range = DT_INST_PROP(inst, range), \
.bus_name = DT_INST_BUS_LABEL(inst), \
.bus_init = iis2dlpc_i2c_init, \
.bus_cfg = { .i2c_slv_addr = DT_INST_REG_ADDR(inst), }, \
IIS2DLPC_CONFIG_TAP(inst) \ IIS2DLPC_CONFIG_TAP(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \ COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(IIS2DLPC_CFG_IRQ(inst)), ()) \ (IIS2DLPC_CFG_IRQ(inst)), ()) \
} }
#define IIS2DLPC_DEFINE_I2C(inst) \
static struct iis2dlpc_data iis2dlpc_data_##inst; \
static const struct iis2dlpc_dev_config iis2dlpc_config_##inst =\
IIS2DLPC_CONFIG_I2C(inst); \
IIS2DLPC_DEVICE_INIT(inst)
/* /*
* Main instantiation macro. Use of COND_CODE_1() selects the right * Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time. * bus-specific macro at preprocessor time.
*/ */
#define IIS2DLPC_DEFINE(inst) \ #define IIS2DLPC_DEFINE(inst) \
static struct iis2dlpc_data iis2dlpc_data_##inst; \
static const struct iis2dlpc_config iis2dlpc_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \ COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(IIS2DLPC_DEFINE_SPI(inst)), \ (IIS2DLPC_CONFIG_SPI(inst)), \
(IIS2DLPC_DEFINE_I2C(inst))) (IIS2DLPC_CONFIG_I2C(inst))); \
IIS2DLPC_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(IIS2DLPC_DEFINE) DT_INST_FOREACH_STATUS_OKAY(IIS2DLPC_DEFINE)

57
drivers/sensor/iis2dlpc/iis2dlpc.h
View file

@ -14,6 +14,7 @@
#include <drivers/gpio.h> #include <drivers/gpio.h>
#include <sys/util.h> #include <sys/util.h>
#include <drivers/sensor.h> #include <drivers/sensor.h>
#include <stmemsc.h>
#include "iis2dlpc_reg.h" #include "iis2dlpc_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) #if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
@ -24,11 +25,6 @@
#include <drivers/i2c.h> #include <drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */ #endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
union axis3bit16_t {
int16_t i16bit[3];
uint8_t u8bit[6];
};
/* Return ODR reg value based on data rate set */ /* Return ODR reg value based on data rate set */
#define IIS2DLPC_ODR_TO_REG(_odr) \ #define IIS2DLPC_ODR_TO_REG(_odr) \
((_odr <= 1) ? IIS2DLPC_XL_ODR_1Hz6_LP_ONLY : \ ((_odr <= 1) ? IIS2DLPC_XL_ODR_1Hz6_LP_ONLY : \
@ -53,23 +49,6 @@ union axis3bit16_t {
#define IIS2DLPC_SHIFT_PM1 4 #define IIS2DLPC_SHIFT_PM1 4
#define IIS2DLPC_SHIFT_PMOTHER 2 #define IIS2DLPC_SHIFT_PMOTHER 2
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct iis2dlpc_spi_cfg {
struct spi_config spi_conf;
const char *cs_gpios_label;
};
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
union iis2dlpc_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
uint16_t i2c_slv_addr;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct iis2dlpc_spi_cfg *spi_cfg;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
};
/** /**
* struct iis2dlpc_dev_config - iis2dlpc hw configuration * struct iis2dlpc_dev_config - iis2dlpc hw configuration
* @bus_name: Pointer to bus master identifier. * @bus_name: Pointer to bus master identifier.
@ -78,16 +57,20 @@ union iis2dlpc_bus_cfg {
* @irq_pin: GPIO pin number connecter to sensor int pin. * @irq_pin: GPIO pin number connecter to sensor int pin.
* @drdy_int: Sensor drdy int (int1/int2). * @drdy_int: Sensor drdy int (int1/int2).
*/ */
struct iis2dlpc_dev_config { struct iis2dlpc_config {
const char *bus_name; stmdev_ctx_t ctx;
int (*bus_init)(const struct device *dev); union {
const union iis2dlpc_bus_cfg bus_cfg; #if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct stmemsc_cfg_i2c i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct stmemsc_cfg_spi spi;
#endif
} stmemsc_cfg;
iis2dlpc_mode_t pm; iis2dlpc_mode_t pm;
uint8_t range; uint8_t range;
#ifdef CONFIG_IIS2DLPC_TRIGGER #ifdef CONFIG_IIS2DLPC_TRIGGER
const char *irq_dev_name; const struct gpio_dt_spec gpio_drdy;
gpio_pin_t irq_pin;
gpio_flags_t irq_flags;
uint8_t drdy_int; uint8_t drdy_int;
#ifdef CONFIG_IIS2DLPC_TAP #ifdef CONFIG_IIS2DLPC_TAP
uint8_t tap_mode; uint8_t tap_mode;
@ -102,21 +85,11 @@ struct iis2dlpc_dev_config {
/* sensor data */ /* sensor data */
struct iis2dlpc_data { struct iis2dlpc_data {
const struct device *dev; const struct device *dev;
const struct device *bus;
int16_t acc[3]; int16_t acc[3];
/* save sensitivity */ /* save sensitivity */
uint16_t gain; uint16_t gain;
stmdev_ctx_t *ctx;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
stmdev_ctx_t ctx_i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
stmdev_ctx_t ctx_spi;
#endif
#ifdef CONFIG_IIS2DLPC_TRIGGER #ifdef CONFIG_IIS2DLPC_TRIGGER
const struct device *gpio; const struct device *gpio;
uint8_t gpio_pin; uint8_t gpio_pin;
@ -134,14 +107,8 @@ struct iis2dlpc_data {
struct k_work work; struct k_work work;
#endif /* CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD */ #endif /* CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_IIS2DLPC_TRIGGER */ #endif /* CONFIG_IIS2DLPC_TRIGGER */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_cs_control cs_ctrl;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
}; };
int iis2dlpc_i2c_init(const struct device *dev);
int iis2dlpc_spi_init(const struct device *dev);
#ifdef CONFIG_IIS2DLPC_TRIGGER #ifdef CONFIG_IIS2DLPC_TRIGGER
int iis2dlpc_init_interrupt(const struct device *dev); int iis2dlpc_init_interrupt(const struct device *dev);
int iis2dlpc_trigger_set(const struct device *dev, int iis2dlpc_trigger_set(const struct device *dev,

54
drivers/sensor/iis2dlpc/iis2dlpc_i2c.c
View file

@ -1,54 +0,0 @@
/* ST Microelectronics IIS2DLPC 3-axis accelerometer driver
*
* Copyright (c) 2020 STMicroelectronics
*
* SPDX-License-Identifier: Apache-2.0
*
* Datasheet:
* https://www.st.com/resource/en/datasheet/iis2dlpc.pdf
*/
#define DT_DRV_COMPAT st_iis2dlpc
#include <string.h>
#include <logging/log.h>
#include "iis2dlpc.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(IIS2DLPC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2dlpc_i2c_read(struct iis2dlpc_data *data, uint8_t reg_addr,
uint8_t *value, uint16_t len)
{
const struct device *dev = data->dev;
const struct iis2dlpc_dev_config *cfg = dev->config;
return i2c_burst_read(data->bus, cfg->bus_cfg.i2c_slv_addr,
reg_addr, value, len);
}
static int iis2dlpc_i2c_write(struct iis2dlpc_data *data, uint8_t reg_addr,
uint8_t *value, uint16_t len)
{
const struct device *dev = data->dev;
const struct iis2dlpc_dev_config *cfg = dev->config;
return i2c_burst_write(data->bus, cfg->bus_cfg.i2c_slv_addr,
reg_addr, value, len);
}
int iis2dlpc_i2c_init(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
data->ctx_i2c.read_reg = (stmdev_read_ptr) iis2dlpc_i2c_read,
data->ctx_i2c.write_reg = (stmdev_write_ptr) iis2dlpc_i2c_write,
data->ctx = &data->ctx_i2c;
data->ctx->handle = data;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */

122
drivers/sensor/iis2dlpc/iis2dlpc_spi.c
View file

@ -1,122 +0,0 @@
/* ST Microelectronics IIS2DLPC 3-axis accelerometer driver
*
* Copyright (c) 2020 STMicroelectronics
*
* SPDX-License-Identifier: Apache-2.0
*
* Datasheet:
* https://www.st.com/resource/en/datasheet/iis2dlpc.pdf
*/
#define DT_DRV_COMPAT st_iis2dlpc
#include <string.h>
#include "iis2dlpc.h"
#include <logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define IIS2DLPC_SPI_READ (1 << 7)
LOG_MODULE_DECLARE(IIS2DLPC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2dlpc_spi_read(struct iis2dlpc_data *data, uint8_t reg,
uint8_t *val, uint16_t len)
{
const struct device *dev = data->dev;
const struct iis2dlpc_dev_config *cfg = dev->config;
const struct spi_config *spi_cfg = &cfg->bus_cfg.spi_cfg->spi_conf;
uint8_t buffer_tx[2] = { reg | IIS2DLPC_SPI_READ, 0 };
const struct spi_buf tx_buf = {
.buf = buffer_tx,
.len = 2,
};
const struct spi_buf_set tx = {
.buffers = &tx_buf,
.count = 1
};
const struct spi_buf rx_buf[2] = {
{
.buf = NULL,
.len = 1,
},
{
.buf = val,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (spi_transceive(data->bus, spi_cfg, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int iis2dlpc_spi_write(struct iis2dlpc_data *data, uint8_t reg,
uint8_t *val, uint16_t len)
{
const struct device *dev = data->dev;
const struct iis2dlpc_dev_config *cfg = dev->config;
const struct spi_config *spi_cfg = &cfg->bus_cfg.spi_cfg->spi_conf;
uint8_t buffer_tx[1] = { reg & ~IIS2DLPC_SPI_READ };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = val,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (spi_write(data->bus, spi_cfg, &tx)) {
return -EIO;
}
return 0;
}
stmdev_ctx_t iis2dlpc_spi_ctx = {
.read_reg = (stmdev_read_ptr) iis2dlpc_spi_read,
.write_reg = (stmdev_write_ptr) iis2dlpc_spi_write,
};
int iis2dlpc_spi_init(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config;
const struct iis2dlpc_spi_cfg *spi_cfg = cfg->bus_cfg.spi_cfg;
data->ctx_spi.read_reg = (stmdev_read_ptr) iis2dlpc_spi_read;
data->ctx_spi.write_reg = (stmdev_write_ptr) iis2dlpc_spi_write;
data->ctx = &data->ctx_spi;
data->ctx->handle = data;
if (spi_cfg->cs_gpios_label != NULL) {
/* handle SPI CS thru GPIO if it is the case */
data->cs_ctrl.gpio_dev =
device_get_binding(spi_cfg->cs_gpios_label);
if (!data->cs_ctrl.gpio_dev) {
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
LOG_DBG("SPI GPIO CS configured on %s:%u",
spi_cfg->cs_gpios_label, data->cs_ctrl.gpio_pin);
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */

73
drivers/sensor/iis2dlpc/iis2dlpc_trigger.c
View file

@ -25,46 +25,46 @@ LOG_MODULE_DECLARE(IIS2DLPC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2dlpc_enable_int(const struct device *dev, static int iis2dlpc_enable_int(const struct device *dev,
enum sensor_trigger_type type, int enable) enum sensor_trigger_type type, int enable)
{ {
const struct iis2dlpc_dev_config *cfg = dev->config; const struct iis2dlpc_config *cfg = dev->config;
struct iis2dlpc_data *iis2dlpc = dev->data; stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis2dlpc_reg_t int_route; iis2dlpc_reg_t int_route;
switch (type) { switch (type) {
case SENSOR_TRIG_DATA_READY: case SENSOR_TRIG_DATA_READY:
if (cfg->drdy_int == 1) { if (cfg->drdy_int == 1) {
/* set interrupt for pin INT1 */ /* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(iis2dlpc->ctx, iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_drdy = enable; int_route.ctrl4_int1_pad_ctrl.int1_drdy = enable;
return iis2dlpc_pin_int1_route_set(iis2dlpc->ctx, return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
} else { } else {
/* set interrupt for pin INT2 */ /* set interrupt for pin INT2 */
iis2dlpc_pin_int2_route_get(iis2dlpc->ctx, iis2dlpc_pin_int2_route_get(ctx,
&int_route.ctrl5_int2_pad_ctrl); &int_route.ctrl5_int2_pad_ctrl);
int_route.ctrl5_int2_pad_ctrl.int2_drdy = enable; int_route.ctrl5_int2_pad_ctrl.int2_drdy = enable;
return iis2dlpc_pin_int2_route_set(iis2dlpc->ctx, return iis2dlpc_pin_int2_route_set(ctx,
&int_route.ctrl5_int2_pad_ctrl); &int_route.ctrl5_int2_pad_ctrl);
} }
break; break;
#ifdef CONFIG_IIS2DLPC_TAP #ifdef CONFIG_IIS2DLPC_TAP
case SENSOR_TRIG_TAP: case SENSOR_TRIG_TAP:
/* set interrupt for pin INT1 */ /* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(iis2dlpc->ctx, iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_single_tap = enable; int_route.ctrl4_int1_pad_ctrl.int1_single_tap = enable;
return iis2dlpc_pin_int1_route_set(iis2dlpc->ctx, return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
case SENSOR_TRIG_DOUBLE_TAP: case SENSOR_TRIG_DOUBLE_TAP:
/* set interrupt for pin INT1 */ /* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(iis2dlpc->ctx, iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_tap = enable; int_route.ctrl4_int1_pad_ctrl.int1_tap = enable;
return iis2dlpc_pin_int1_route_set(iis2dlpc->ctx, return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl); &int_route.ctrl4_int1_pad_ctrl);
#endif /* CONFIG_IIS2DLPC_TAP */ #endif /* CONFIG_IIS2DLPC_TAP */
default: default:
@ -80,6 +80,8 @@ int iis2dlpc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler) sensor_trigger_handler_t handler)
{ {
const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct iis2dlpc_data *iis2dlpc = dev->data; struct iis2dlpc_data *iis2dlpc = dev->data;
int16_t raw[3]; int16_t raw[3];
int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE; int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
@ -89,7 +91,7 @@ int iis2dlpc_trigger_set(const struct device *dev,
iis2dlpc->drdy_handler = handler; iis2dlpc->drdy_handler = handler;
if (state) { if (state) {
/* dummy read: re-trigger interrupt */ /* dummy read: re-trigger interrupt */
iis2dlpc_acceleration_raw_get(iis2dlpc->ctx, raw); iis2dlpc_acceleration_raw_get(ctx, raw);
} }
return iis2dlpc_enable_int(dev, SENSOR_TRIG_DATA_READY, state); return iis2dlpc_enable_int(dev, SENSOR_TRIG_DATA_READY, state);
#ifdef CONFIG_IIS2DLPC_TAP #ifdef CONFIG_IIS2DLPC_TAP
@ -164,11 +166,11 @@ static int iis2dlpc_handle_double_tap_int(const struct device *dev)
*/ */
static void iis2dlpc_handle_interrupt(const struct device *dev) static void iis2dlpc_handle_interrupt(const struct device *dev)
{ {
struct iis2dlpc_data *iis2dlpc = dev->data; const struct iis2dlpc_config *cfg = dev->config;
const struct iis2dlpc_dev_config *cfg = dev->config; stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis2dlpc_all_sources_t sources; iis2dlpc_all_sources_t sources;
iis2dlpc_all_sources_get(iis2dlpc->ctx, &sources); iis2dlpc_all_sources_get(ctx, &sources);
if (sources.status_dup.drdy) { if (sources.status_dup.drdy) {
iis2dlpc_handle_drdy_int(dev); iis2dlpc_handle_drdy_int(dev);
@ -182,8 +184,8 @@ static void iis2dlpc_handle_interrupt(const struct device *dev)
} }
#endif /* CONFIG_IIS2DLPC_TAP */ #endif /* CONFIG_IIS2DLPC_TAP */
gpio_pin_interrupt_configure(iis2dlpc->gpio, cfg->irq_pin, gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE); GPIO_INT_EDGE_TO_ACTIVE);
} }
static void iis2dlpc_gpio_callback(const struct device *dev, static void iis2dlpc_gpio_callback(const struct device *dev,
@ -191,13 +193,11 @@ static void iis2dlpc_gpio_callback(const struct device *dev,
{ {
struct iis2dlpc_data *iis2dlpc = struct iis2dlpc_data *iis2dlpc =
CONTAINER_OF(cb, struct iis2dlpc_data, gpio_cb); CONTAINER_OF(cb, struct iis2dlpc_data, gpio_cb);
const struct iis2dlpc_config *cfg = iis2dlpc->dev->config;
if ((pins & BIT(iis2dlpc->gpio_pin)) == 0U) { ARG_UNUSED(pins);
return;
}
gpio_pin_interrupt_configure(dev, iis2dlpc->gpio_pin, gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
GPIO_INT_DISABLE);
#if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD) #if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD)
k_sem_give(&iis2dlpc->gpio_sem); k_sem_give(&iis2dlpc->gpio_sem);
@ -229,19 +229,16 @@ static void iis2dlpc_work_cb(struct k_work *work)
int iis2dlpc_init_interrupt(const struct device *dev) int iis2dlpc_init_interrupt(const struct device *dev)
{ {
struct iis2dlpc_data *iis2dlpc = dev->data; struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_dev_config *cfg = dev->config; const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret; int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */ /* setup data ready gpio interrupt (INT1 or INT2) */
iis2dlpc->gpio = device_get_binding(cfg->irq_dev_name); if (!device_is_ready(cfg->gpio_drdy.port)) {
if (iis2dlpc->gpio == NULL) { LOG_ERR("Cannot get pointer to drdy_gpio device");
LOG_DBG("Cannot get pointer to %s device",
cfg->irq_dev_name);
return -EINVAL; return -EINVAL;
} }
iis2dlpc->dev = dev;
#if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD) #if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD)
k_sem_init(&iis2dlpc->gpio_sem, 0, K_SEM_MAX_LIMIT); k_sem_init(&iis2dlpc->gpio_sem, 0, K_SEM_MAX_LIMIT);
@ -254,29 +251,27 @@ int iis2dlpc_init_interrupt(const struct device *dev)
iis2dlpc->work.handler = iis2dlpc_work_cb; iis2dlpc->work.handler = iis2dlpc_work_cb;
#endif /* CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD */ #endif /* CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD */
iis2dlpc->gpio_pin = cfg->irq_pin; ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
ret = gpio_pin_configure(iis2dlpc->gpio, cfg->irq_pin,
GPIO_INPUT | cfg->irq_flags);
if (ret < 0) { if (ret < 0) {
LOG_DBG("Could not configure gpio"); LOG_ERR("Could not configure gpio");
return ret; return ret;
} }
gpio_init_callback(&iis2dlpc->gpio_cb, gpio_init_callback(&iis2dlpc->gpio_cb,
iis2dlpc_gpio_callback, iis2dlpc_gpio_callback,
BIT(cfg->irq_pin)); BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(iis2dlpc->gpio, &iis2dlpc->gpio_cb) < 0) { if (gpio_add_callback(cfg->gpio_drdy.port, &iis2dlpc->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback"); LOG_ERR("Could not set gpio callback");
return -EIO; return -EIO;
} }
/* enable interrupt on int1/int2 in pulse mode */ /* enable interrupt on int1/int2 in pulse mode */
if (iis2dlpc_int_notification_set(iis2dlpc->ctx, IIS2DLPC_INT_PULSED)) { if (iis2dlpc_int_notification_set(ctx, IIS2DLPC_INT_PULSED)) {
LOG_ERR("Could not set pulse mode");
return -EIO; return -EIO;
} }
return gpio_pin_interrupt_configure(iis2dlpc->gpio, cfg->irq_pin, return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE); GPIO_INT_EDGE_TO_ACTIVE);
} }