michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers/sensor: iis2iclx: move ctx structure inside config

Browse source 
Move ctx structure from struct data to struct config, so that
it can be filled at compile time and we could get rid of the bus
init routines.

Signed-off-by: Armando Visconti <armando.visconti@st.com>
This commit is contained in:
Armando Visconti 2021-04-16 12:12:02 +02:00 • committed by Anas Nashif
commit 8717654c1d
7 changed files with 157 additions and 199 deletions
Download patch file Download diff file Expand all files Collapse all files

2
drivers/sensor/iis2iclx/CMakeLists.txt
View file

@ -7,8 +7,6 @@
zephyr_library()
zephyr_library_sources_ifdef(CONFIG_IIS2ICLX iis2iclx.c)
zephyr_library_sources_ifdef(CONFIG_IIS2ICLX iis2iclx_i2c.c)
zephyr_library_sources_ifdef(CONFIG_IIS2ICLX iis2iclx_spi.c)
zephyr_library_sources_ifdef(CONFIG_IIS2ICLX_SENSORHUB iis2iclx_shub.c)
zephyr_library_sources_ifdef(CONFIG_IIS2ICLX_TRIGGER iis2iclx_trigger.c)

59
drivers/sensor/iis2iclx/iis2iclx.c
View file

@ -68,9 +68,9 @@ static int iis2iclx_accel_range_to_fs_val(int32_t range)
static inline int iis2iclx_reboot(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
const struct iis2iclx_config *cfg = dev->config;
if (iis2iclx_boot_set(&data->ctx, 1) < 0) {
if (iis2iclx_boot_set((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
return -EIO;
}
@ -82,9 +82,10 @@ static inline int iis2iclx_reboot(const struct device *dev)
static int iis2iclx_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
if (iis2iclx_xl_full_scale_set(&data->ctx, fs) < 0) {
if (iis2iclx_xl_full_scale_set((stmdev_ctx_t *)&cfg->ctx, fs) < 0) {
return -EIO;
}
@ -95,9 +96,10 @@ static int iis2iclx_accel_set_fs_raw(const struct device *dev, uint8_t fs)
static int iis2iclx_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
if (iis2iclx_xl_data_rate_set(&data->ctx, odr) < 0) {
if (iis2iclx_xl_data_rate_set((stmdev_ctx_t *)&cfg->ctx, odr) < 0) {
return -EIO;
}
@ -193,10 +195,11 @@ static int iis2iclx_attr_set(const struct device *dev,
static int iis2iclx_sample_fetch_accel(const struct device *dev)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
int16_t buf[2];
if (iis2iclx_acceleration_raw_get(&data->ctx, buf) < 0) {
if (iis2iclx_acceleration_raw_get((stmdev_ctx_t *)&cfg->ctx, buf) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
@ -540,7 +543,7 @@ static int iis2iclx_init_chip(const struct device *dev)
iis2iclx->dev = dev;
if (iis2iclx_device_id_get(&iis2iclx->ctx, &chip_id) < 0) {
if (iis2iclx_device_id_get((stmdev_ctx_t *)&cfg->ctx, &chip_id) < 0) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
@ -553,7 +556,7 @@ static int iis2iclx_init_chip(const struct device *dev)
}
/* reset device */
if (iis2iclx_reset_set(&iis2iclx->ctx, 1) < 0) {
if (iis2iclx_reset_set((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
return -EIO;
}
@ -573,12 +576,13 @@ static int iis2iclx_init_chip(const struct device *dev)
}
/* Set FIFO bypass mode */
if (iis2iclx_fifo_mode_set(&iis2iclx->ctx, IIS2ICLX_BYPASS_MODE) < 0) {
if (iis2iclx_fifo_mode_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_BYPASS_MODE) < 0) {
LOG_ERR("failed to set FIFO mode");
return -EIO;
}
if (iis2iclx_block_data_update_set(&iis2iclx->ctx, 1) < 0) {
if (iis2iclx_block_data_update_set((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
LOG_ERR("failed to set BDU mode");
return -EIO;
}
@ -588,16 +592,10 @@ static int iis2iclx_init_chip(const struct device *dev)
static int iis2iclx_init(const struct device *dev)
{
const struct iis2iclx_config * const config = dev->config;
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
struct iis2iclx_data *data = dev->data;
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
if (config->bus_init(dev) < 0) {
LOG_ERR("failed to initialize bus");
return -EIO;
}
if (iis2iclx_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
@ -659,12 +657,20 @@ static int iis2iclx_init(const struct device *dev)
#define IIS2ICLX_CONFIG_SPI(inst) \
{ \
.stmemsc_cfg.spi.bus = DEVICE_DT_GET(DT_INST_BUS(inst)),\
.stmemsc_cfg.spi.spi_cfg = \
SPI_CONFIG_DT_INST(inst, \
.ctx = { \
.read_reg = \
(stmdev_read_ptr) stmemsc_spi_read, \
.write_reg = \
(stmdev_write_ptr) stmemsc_spi_write, \
.handle = \
(void *)&iis2iclx_config_##inst.stmemsc_cfg, \
}, \
.stmemsc_cfg.spi = { \
.bus = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.spi_cfg = SPI_CONFIG_DT_INST(inst, \
IIS2ICLX_SPI_OPERATION, \
0), \
.bus_init = iis2iclx_spi_init, \
}, \
.odr = DT_INST_PROP(inst, odr), \
.range = DT_INST_PROP(inst, range), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
@ -677,9 +683,18 @@ static int iis2iclx_init(const struct device *dev)
#define IIS2ICLX_CONFIG_I2C(inst) \
{ \
.stmemsc_cfg.i2c.bus = DEVICE_DT_GET(DT_INST_BUS(inst)),\
.stmemsc_cfg.i2c.i2c_slv_addr = DT_INST_REG_ADDR(inst), \
.bus_init = iis2iclx_i2c_init, \
.ctx = { \
.read_reg = \
(stmdev_read_ptr) stmemsc_i2c_read, \
.write_reg = \
(stmdev_write_ptr) stmemsc_i2c_write, \
.handle = \
(void *)&iis2iclx_config_##inst.stmemsc_cfg, \
}, \
.stmemsc_cfg.i2c = { \
.bus = DEVICE_DT_GET(DT_INST_BUS(inst)), \
.i2c_slv_addr = DT_INST_REG_ADDR(inst), \
}, \
.odr = DT_INST_PROP(inst, odr), \
.range = DT_INST_PROP(inst, range), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \

4
drivers/sensor/iis2iclx/iis2iclx.h
View file

@ -37,6 +37,7 @@
#define SENSOR_G_DOUBLE (SENSOR_G / 1000000.0)
struct iis2iclx_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct stmemsc_cfg_i2c i2c;
@ -45,7 +46,6 @@ struct iis2iclx_config {
const struct stmemsc_cfg_spi spi;
#endif
} stmemsc_cfg;
int (*bus_init)(const struct device *dev);
uint8_t odr;
uint8_t range;
#ifdef CONFIG_IIS2ICLX_TRIGGER
@ -80,8 +80,6 @@ struct iis2iclx_data {
bool shub_inited;
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
stmdev_ctx_t ctx;
uint16_t accel_freq;
uint8_t accel_fs;

33
drivers/sensor/iis2iclx/iis2iclx_i2c.c
View file

@ -1,33 +0,0 @@
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
* Copyright (c) 2020 STMicroelectronics
*
* SPDX-License-Identifier: Apache-2.0
*
* Datasheet:
* https://www.st.com/resource/en/datasheet/iis2iclx.pdf
*/
#define DT_DRV_COMPAT st_iis2iclx
#include <logging/log.h>
#include "iis2iclx.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
int iis2iclx_i2c_init(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
const struct iis2iclx_config *cfg = dev->config;
/* Use generic stmemsc routine for read/write I2C bus */
data->ctx.read_reg = (stmdev_read_ptr) stmemsc_i2c_read;
data->ctx.write_reg = (stmdev_write_ptr) stmemsc_i2c_write;
data->ctx.handle = (void *)&cfg->stmemsc_cfg.i2c;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */

196
drivers/sensor/iis2iclx/iis2iclx_shub.c
View file

@ -49,13 +49,13 @@ LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
static uint8_t num_ext_dev;
static uint8_t shub_ext[IIS2ICLX_SHUB_MAX_NUM_SLVS];
static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
static int iis2iclx_shub_write_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len);
static int iis2iclx_shub_read_slave_reg(struct iis2iclx_data *data,
static int iis2iclx_shub_read_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len);
static void iis2iclx_shub_enable(struct iis2iclx_data *data, uint8_t enable);
static void iis2iclx_shub_enable(const struct device *dev, uint8_t enable);
/*
* LIS2MDL magn device specific part
@ -73,15 +73,16 @@ static void iis2iclx_shub_enable(struct iis2iclx_data *data, uint8_t enable);
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int iis2iclx_lis2mdl_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static int iis2iclx_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct iis2iclx_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_gain = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
@ -89,7 +90,7 @@ static int iis2iclx_lis2mdl_init(struct iis2iclx_data *data, uint8_t i2c_addr)
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
@ -97,7 +98,7 @@ static int iis2iclx_lis2mdl_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int iis2iclx_lis2mdl_odr_set(struct iis2iclx_data *data,
static int iis2iclx_lis2mdl_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
@ -114,21 +115,21 @@ static int iis2iclx_lis2mdl_odr_set(struct iis2iclx_data *data,
}
cfg = (odr << 2);
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, &cfg, 1);
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
static int iis2iclx_lis2mdl_conf(struct iis2iclx_data *data, uint8_t i2c_addr,
static int iis2iclx_lis2mdl_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2iclx_lis2mdl_odr_set(data, i2c_addr, val->val1);
return iis2iclx_lis2mdl_odr_set(dev, i2c_addr, val->val1);
default:
LOG_ERR("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
@ -152,16 +153,18 @@ static int iis2iclx_lis2mdl_conf(struct iis2iclx_data *data, uint8_t i2c_addr,
#define HTS221_REG_CONV_START 0x30
static int lsmdso_hts221_read_conv_data(struct iis2iclx_data *data,
static int hts221_read_conv_data(const struct device *dev,
uint8_t i2c_addr)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
uint8_t buf[16], i;
struct hts221_data *ht = &data->hts221;
for (i = 0; i < sizeof(buf); i += 7) {
unsigned char len = MIN(7, sizeof(buf) - i);
if (iis2iclx_shub_read_slave_reg(data, i2c_addr,
if (iis2iclx_shub_read_slave_reg(dev, i2c_addr,
(HTS221_REG_CONV_START + i) |
HTS221_AUTOINCREMENT,
&buf[i], len) < 0) {
@ -178,21 +181,22 @@ static int lsmdso_hts221_read_conv_data(struct iis2iclx_data *data,
return 0;
}
static int iis2iclx_hts221_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static int iis2iclx_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
const struct iis2iclx_config *cfg = dev->config;
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &hum_cfg, 1);
return lsmdso_hts221_read_conv_data(data, i2c_addr);
return hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int iis2iclx_hts221_odr_set(struct iis2iclx_data *data,
static int iis2iclx_hts221_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
@ -209,14 +213,14 @@ static int iis2iclx_hts221_odr_set(struct iis2iclx_data *data,
}
cfg = odr | HTS221_BDU | HTS221_PD;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &cfg, 1);
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
static int iis2iclx_hts221_conf(struct iis2iclx_data *data, uint8_t i2c_addr,
static int iis2iclx_hts221_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
@ -246,20 +250,20 @@ static int iis2iclx_hts221_conf(struct iis2iclx_data *data, uint8_t i2c_addr,
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int iis2iclx_lps22hb_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static int iis2iclx_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HB_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(1)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HB_ODR_10HZ | LPS22HB_LPF_EN | LPS22HB_BDU_EN;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
@ -280,24 +284,24 @@ static int iis2iclx_lps22hb_init(struct iis2iclx_data *data, uint8_t i2c_addr)
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
static int iis2iclx_lps22hh_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static int iis2iclx_lps22hh_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HH_SW_RESET;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
k_sleep(K_MSEC(100)); /* turn-on time in ms */
/* configure device */
baro_cfg[0] = LPS22HH_IF_ADD_INC;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22HH_ODR_10HZ | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
@ -305,7 +309,7 @@ static int iis2iclx_lps22hh_init(struct iis2iclx_data *data, uint8_t i2c_addr)
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int iis2iclx_lps22hh_odr_set(struct iis2iclx_data *data,
static int iis2iclx_lps22hh_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
@ -322,14 +326,14 @@ static int iis2iclx_lps22hh_odr_set(struct iis2iclx_data *data,
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
iis2iclx_shub_write_slave_reg(data, i2c_addr,
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, &cfg, 1);
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
static int iis2iclx_lps22hh_conf(struct iis2iclx_data *data, uint8_t i2c_addr,
static int iis2iclx_lps22hh_conf(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
@ -356,8 +360,8 @@ static struct iis2iclx_shub_slist {
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
int (*dev_init)(struct iis2iclx_data *data, uint8_t i2c_addr);
int (*dev_conf)(struct iis2iclx_data *data, uint8_t i2c_addr,
int (*dev_init)(const struct device *dev, uint8_t i2c_addr);
int (*dev_conf)(const struct device *dev, uint8_t i2c_addr,
enum sensor_channel chan, enum sensor_attribute attr,
const struct sensor_value *val);
} iis2iclx_shub_slist[] = {
@ -417,90 +421,96 @@ static struct iis2iclx_shub_slist {
#endif /* CONFIG_IIS2ICLX_EXT_LPS22HH */
};
static inline void iis2iclx_shub_wait_completed(struct iis2iclx_data *data)
static inline void iis2iclx_shub_wait_completed(const struct iis2iclx_config *cfg)
{
iis2iclx_status_master_t status;
do {
k_msleep(1);
iis2iclx_sh_status_get(&data->ctx, &status);
iis2iclx_sh_status_get((stmdev_ctx_t *)&cfg->ctx, &status);
} while (status.sens_hub_endop == 0);
}
static inline void iis2iclx_shub_embedded_en(struct iis2iclx_data *data, bool on)
static inline void iis2iclx_shub_embedded_en(const struct iis2iclx_config *cfg,
bool on)
{
if (on) {
(void) iis2iclx_mem_bank_set(&data->ctx, IIS2ICLX_SENSOR_HUB_BANK);
(void) iis2iclx_mem_bank_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_SENSOR_HUB_BANK);
} else {
(void) iis2iclx_mem_bank_set(&data->ctx, IIS2ICLX_USER_BANK);
(void) iis2iclx_mem_bank_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_USER_BANK);
}
k_busy_wait(150);
}
static int iis2iclx_shub_read_embedded_regs(struct iis2iclx_data *data,
static int iis2iclx_shub_read_embedded_regs(const struct iis2iclx_config *cfg,
uint8_t reg_addr,
uint8_t *value, int len)
{
iis2iclx_shub_embedded_en(data, true);
iis2iclx_shub_embedded_en(cfg, true);
if (iis2iclx_read_reg(&data->ctx, reg_addr, value, len) < 0) {
if (iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, reg_addr, value, len) < 0) {
LOG_ERR("shub: failed to read external reg: %02x", reg_addr);
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
static int iis2iclx_shub_write_embedded_regs(struct iis2iclx_data *data,
static int iis2iclx_shub_write_embedded_regs(const struct iis2iclx_config *cfg,
uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
iis2iclx_shub_embedded_en(data, true);
iis2iclx_shub_embedded_en(cfg, true);
if (iis2iclx_write_reg(&data->ctx, reg_addr, value, len) < 0) {
if (iis2iclx_write_reg((stmdev_ctx_t *)&cfg->ctx, reg_addr, value, len) < 0) {
LOG_ERR("shub: failed to write external reg: %02x", reg_addr);
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
static void iis2iclx_shub_enable(struct iis2iclx_data *data, uint8_t enable)
static void iis2iclx_shub_enable(const struct device *dev, uint8_t enable)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
/* Enable Accel @26hz */
if (!data->accel_freq) {
uint8_t odr = (enable) ? 2 : 0;
if (iis2iclx_xl_data_rate_set(&data->ctx, odr) < 0) {
if (iis2iclx_xl_data_rate_set((stmdev_ctx_t *)&cfg->ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
iis2iclx_shub_embedded_en(data, true);
iis2iclx_shub_embedded_en(cfg, true);
if (iis2iclx_sh_master_set(&data->ctx, enable) < 0) {
if (iis2iclx_sh_master_set((stmdev_ctx_t *)&cfg->ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return;
}
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
}
/* must be called with master on */
static int iis2iclx_shub_check_slv0_nack(struct iis2iclx_data *data)
static int iis2iclx_shub_check_slv0_nack(const struct iis2iclx_config *cfg)
{
uint8_t status;
if (iis2iclx_shub_read_embedded_regs(data, IIS2ICLX_SHUB_STATUS_MASTER,
if (iis2iclx_shub_read_embedded_regs(cfg, IIS2ICLX_SHUB_STATUS_MASTER,
&status, 1) < 0) {
LOG_ERR("shub: error reading embedded reg");
return -EIO;
@ -517,52 +527,54 @@ static int iis2iclx_shub_check_slv0_nack(struct iis2iclx_data *data)
/*
* use SLV0 for generic read to slave device
*/
static int iis2iclx_shub_read_slave_reg(struct iis2iclx_data *data,
static int iis2iclx_shub_read_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len)
{
const struct iis2iclx_config *cfg = dev->config;
uint8_t slave[3];
slave[0] = (slv_addr << 1) | IIS2ICLX_SHUB_SLVX_READ;
slave[1] = slv_reg;
slave[2] = (len & 0x7);
if (iis2iclx_shub_write_embedded_regs(data, IIS2ICLX_SHUB_SLV0_ADDR,
if (iis2iclx_shub_write_embedded_regs(cfg, IIS2ICLX_SHUB_SLV0_ADDR,
slave, 3) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
/* turn SH on */
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_wait_completed(data);
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
if (iis2iclx_shub_check_slv0_nack(data) < 0) {
iis2iclx_shub_enable(data, 0);
if (iis2iclx_shub_check_slv0_nack(cfg) < 0) {
iis2iclx_shub_enable(dev, 0);
return -EIO;
}
/* read data from external slave */
iis2iclx_shub_embedded_en(data, true);
if (iis2iclx_read_reg(&data->ctx, IIS2ICLX_SHUB_DATA_OUT,
iis2iclx_shub_embedded_en(cfg, true);
if (iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_SHUB_DATA_OUT,
value, len) < 0) {
LOG_ERR("shub: error reading sensor data");
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
iis2iclx_shub_enable(data, 0);
iis2iclx_shub_enable(dev, 0);
return 0;
}
/*
* use SLV0 to configure slave device
*/
static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
static int iis2iclx_shub_write_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len)
{
const struct iis2iclx_config *cfg = dev->config;
uint8_t slv_cfg[3];
uint8_t cnt = 0U;
@ -570,7 +582,7 @@ static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
slv_cfg[0] = (slv_addr << 1) & ~IIS2ICLX_SHUB_SLVX_READ;
slv_cfg[1] = slv_reg + cnt;
if (iis2iclx_shub_write_embedded_regs(data,
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV0_ADDR,
slv_cfg, 2) < 0) {
LOG_ERR("shub: error writing embedded reg");
@ -578,7 +590,7 @@ static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
}
slv_cfg[0] = value[cnt];
if (iis2iclx_shub_write_embedded_regs(data,
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV0_DATAWRITE,
slv_cfg, 1) < 0) {
LOG_ERR("shub: error writing embedded reg");
@ -586,15 +598,15 @@ static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
}
/* turn SH on */
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_wait_completed(data);
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
if (iis2iclx_shub_check_slv0_nack(data) < 0) {
iis2iclx_shub_enable(data, 0);
if (iis2iclx_shub_check_slv0_nack(cfg) < 0) {
iis2iclx_shub_enable(dev, 0);
return -EIO;
}
iis2iclx_shub_enable(data, 0);
iis2iclx_shub_enable(dev, 0);
cnt++;
}
@ -603,7 +615,7 @@ static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
slv_cfg[0] = 0x7;
slv_cfg[1] = 0x0;
slv_cfg[2] = 0x0;
if (iis2iclx_shub_write_embedded_regs(data, IIS2ICLX_SHUB_SLV0_ADDR,
if (iis2iclx_shub_write_embedded_regs(cfg, IIS2ICLX_SHUB_SLV0_ADDR,
slv_cfg, 3) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
@ -620,8 +632,9 @@ static int iis2iclx_shub_write_slave_reg(struct iis2iclx_data *data,
* - SLAVE 2: used as data read channel for external slave device #2
* - SLAVE 3: used for generic reads while data channel is enabled
*/
static int iis2iclx_shub_set_data_channel(struct iis2iclx_data *data)
static int iis2iclx_shub_set_data_channel(const struct device *dev)
{
const struct iis2iclx_config *cfg = dev->config;
uint8_t n, i, slv_cfg[6];
struct iis2iclx_shub_slist *sp;
@ -635,7 +648,7 @@ static int iis2iclx_shub_set_data_channel(struct iis2iclx_data *data)
slv_cfg[i + 2] = sp->out_data_len;
}
if (iis2iclx_shub_write_embedded_regs(data,
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV1_ADDR,
slv_cfg, n*3) < 0) {
LOG_ERR("shub: error writing embedded reg");
@ -645,22 +658,22 @@ static int iis2iclx_shub_set_data_channel(struct iis2iclx_data *data)
/* Configure the master */
iis2iclx_aux_sens_on_t aux = IIS2ICLX_SLV_0_1_2;
if (iis2iclx_sh_slave_connected_set(&data->ctx, aux) < 0) {
if (iis2iclx_sh_slave_connected_set((stmdev_ctx_t *)&cfg->ctx, aux) < 0) {
LOG_ERR("shub: error setting aux sensors");
return -EIO;
}
iis2iclx_write_once_t wo = IIS2ICLX_ONLY_FIRST_CYCLE;
if (iis2iclx_sh_write_mode_set(&data->ctx, wo) < 0) {
if (iis2iclx_sh_write_mode_set((stmdev_ctx_t *)&cfg->ctx, wo) < 0) {
LOG_ERR("shub: error setting write once");
return -EIO;
}
/* turn SH on */
iis2iclx_shub_enable(data, 1);
iis2iclx_shub_wait_completed(data);
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
return 0;
}
@ -683,24 +696,25 @@ int iis2iclx_shub_get_idx(enum sensor_channel type)
int iis2iclx_shub_fetch_external_devs(const struct device *dev)
{
uint8_t n;
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *data = dev->data;
struct iis2iclx_shub_slist *sp;
/* read data from external slave */
iis2iclx_shub_embedded_en(data, true);
iis2iclx_shub_embedded_en(cfg, true);
for (n = 0; n < num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[shub_ext[n]];
if (iis2iclx_read_reg(&data->ctx, sp->sh_out_reg,
if (iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, sp->sh_out_reg,
data->ext_data[n], sp->out_data_len) < 0) {
LOG_ERR("shub: failed to read sample");
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return -EIO;
}
}
iis2iclx_shub_embedded_en(data, false);
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
@ -709,7 +723,6 @@ int iis2iclx_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct iis2iclx_data *data = dev->data;
struct iis2iclx_shub_slist *sp = NULL;
uint8_t n;
@ -730,12 +743,11 @@ int iis2iclx_shub_config(const struct device *dev, enum sensor_channel chan,
return -ENOTSUP;
}
return sp->dev_conf(data, sp->ext_i2c_addr, chan, attr, val);
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int iis2iclx_shub_init(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct iis2iclx_shub_slist *sp;
@ -753,7 +765,7 @@ int iis2iclx_shub_init(const struct device *dev)
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (iis2iclx_shub_read_slave_reg(data,
if (iis2iclx_shub_read_slave_reg(dev,
sp->i2c_addr[i],
sp->wai_addr,
&chip_id, 1) < 0) {
@ -784,10 +796,10 @@ int iis2iclx_shub_init(const struct device *dev)
sp = &iis2iclx_shub_slist[shub_ext[n]];
sp->sh_out_reg = IIS2ICLX_SHUB_DATA_OUT + regn;
regn += sp->out_data_len;
sp->dev_init(data, sp->ext_i2c_addr);
sp->dev_init(dev, sp->ext_i2c_addr);
}
iis2iclx_shub_set_data_channel(data);
iis2iclx_shub_set_data_channel(dev);
return 0;
}

33
drivers/sensor/iis2iclx/iis2iclx_spi.c
View file

@ -1,33 +0,0 @@
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
* Copyright (c) 2020 STMicroelectronics
*
* SPDX-License-Identifier: Apache-2.0
*
* Datasheet:
* https://www.st.com/resource/en/datasheet/iis2iclx.pdf
*/
#define DT_DRV_COMPAT st_iis2iclx
#include "iis2iclx.h"
#include <logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
int iis2iclx_spi_init(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
const struct iis2iclx_config *cfg = dev->config;
/* Use generic stmemsc routine for read/write SPI bus */
data->ctx.read_reg = (stmdev_read_ptr) stmemsc_spi_read;
data->ctx.write_reg = (stmdev_write_ptr) stmemsc_spi_write;
data->ctx.handle = (void *)&cfg->stmemsc_cfg.spi;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */

29
drivers/sensor/iis2iclx/iis2iclx_trigger.c
View file

@ -26,25 +26,24 @@ LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
static int iis2iclx_enable_t_int(const struct device *dev, int enable)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *iis2iclx = dev->data;
iis2iclx_pin_int2_route_t int2_route;
if (enable) {
int16_t buf;
/* dummy read: re-trigger interrupt */
iis2iclx_temperature_raw_get(&iis2iclx->ctx, &buf);
iis2iclx_temperature_raw_get((stmdev_ctx_t *)&cfg->ctx, &buf);
}
/* set interrupt (TEMP DRDY interrupt is only on INT2) */
if (cfg->int_pin == 1)
return -EIO;
iis2iclx_read_reg(&iis2iclx->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
int2_route.int2_ctrl.int2_drdy_temp = enable;
return iis2iclx_write_reg(&iis2iclx->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
return iis2iclx_write_reg((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
#endif
@ -54,32 +53,33 @@ static int iis2iclx_enable_t_int(const struct device *dev, int enable)
static int iis2iclx_enable_xl_int(const struct device *dev, int enable)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *iis2iclx = dev->data;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
iis2iclx_acceleration_raw_get(&iis2iclx->ctx, buf);
iis2iclx_acceleration_raw_get((stmdev_ctx_t *)&cfg->ctx, buf);
}
/* set interrupt */
if (cfg->int_pin == 1) {
iis2iclx_pin_int1_route_t int1_route;
iis2iclx_read_reg(&iis2iclx->ctx, IIS2ICLX_INT1_CTRL,
iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
int1_route.int1_ctrl.int1_drdy_xl = enable;
return iis2iclx_write_reg(&iis2iclx->ctx, IIS2ICLX_INT1_CTRL,
return iis2iclx_write_reg((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_INT1_CTRL,
(uint8_t *)&int1_route.int1_ctrl, 1);
} else {
iis2iclx_pin_int2_route_t int2_route;
iis2iclx_read_reg(&iis2iclx->ctx, IIS2ICLX_INT2_CTRL,
iis2iclx_read_reg((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
int2_route.int2_ctrl.int2_drdy_xl = enable;
return iis2iclx_write_reg(&iis2iclx->ctx, IIS2ICLX_INT2_CTRL,
return iis2iclx_write_reg((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
}
@ -129,7 +129,8 @@ static void iis2iclx_handle_interrupt(const struct device *dev)
iis2iclx_status_reg_t status;
while (1) {
if (iis2iclx_status_reg_get(&iis2iclx->ctx, &status) < 0) {
if (iis2iclx_status_reg_get((stmdev_ctx_t *)&cfg->ctx,
&status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
@ -236,7 +237,7 @@ int iis2iclx_init_interrupt(const struct device *dev)
}
/* enable interrupt on int1/int2 in pulse mode */
if (iis2iclx_int_notification_set(&iis2iclx->ctx,
if (iis2iclx_int_notification_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_ALL_INT_PULSED) < 0) {
LOG_ERR("Could not set pulse mode");
return -EIO;