text stringlengths 9 39.2M | dir stringlengths 25 226 | lang stringclasses 163 values | created_date timestamp[s] | updated_date timestamp[s] | repo_name stringclasses 751 values | repo_full_name stringclasses 752 values | star int64 1.01k 183k | len_tokens int64 1 18.5M |
|---|---|---|---|---|---|---|---|---|
```c
/* ST Microelectronics STTS22H temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_stts22h
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "stts22h.h"
LOG_MODULE_REGISTER(STTS22H, CONFIG_SENSOR_LOG_LEVEL);
static inline int stts22h_set_odr_raw(const struct device *dev, stts22h_odr_temp_t odr)
{
const struct stts22h_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
return stts22h_temp_data_rate_set(ctx, odr);
}
static int stts22h_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct stts22h_data *data = dev->data;
const struct stts22h_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t raw_temp;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
LOG_ERR("Invalid channel: %d", chan);
return -ENOTSUP;
}
if (stts22h_temperature_raw_get(ctx, &raw_temp) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
data->sample_temp = raw_temp;
return 0;
}
static inline void stts22h_temp_convert(struct sensor_value *val, int16_t raw_val)
{
val->val1 = raw_val / 100;
val->val2 = ((int32_t)raw_val % 100) * 10000;
}
static int stts22h_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct stts22h_data *data = dev->data;
if (chan != SENSOR_CHAN_AMBIENT_TEMP) {
LOG_ERR("Invalid channel: %d", chan);
return -ENOTSUP;
}
stts22h_temp_convert(val, data->sample_temp);
return 0;
}
static const uint8_t stts22h_map[6] = {0, 1, 25, 50, 100, 200};
static int stts22h_odr_set(const struct device *dev,
const struct sensor_value *val)
{
int odr;
for (odr = 0; odr < ARRAY_SIZE(stts22h_map); odr++) {
if (val->val1 <= stts22h_map[odr]) {
break;
}
}
switch (odr) {
case 0:
return stts22h_set_odr_raw(dev, STTS22H_POWER_DOWN);
case 1:
return stts22h_set_odr_raw(dev, STTS22H_1Hz);
case 2:
return stts22h_set_odr_raw(dev, STTS22H_25Hz);
case 3:
return stts22h_set_odr_raw(dev, STTS22H_50Hz);
case 4:
return stts22h_set_odr_raw(dev, STTS22H_100Hz);
case 5:
return stts22h_set_odr_raw(dev, STTS22H_200Hz);
default:
LOG_ERR("bad frequency: %d (odr = %d)", val->val1, odr);
return -EINVAL;
}
}
static int stts22h_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_AMBIENT_TEMP) {
LOG_ERR("Invalid channel: %d", chan);
return -ENOTSUP;
}
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return stts22h_odr_set(dev, val);
default:
LOG_ERR("Attribute %d not supported.", attr);
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api stts22h_api_funcs = {
.attr_set = stts22h_attr_set,
.sample_fetch = stts22h_sample_fetch,
.channel_get = stts22h_channel_get,
#if CONFIG_STTS22H_TRIGGER
.trigger_set = stts22h_trigger_set,
#endif
};
static int stts22h_init_chip(const struct device *dev)
{
const struct stts22h_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t chip_id, odr;
if (stts22h_dev_id_get(ctx, &chip_id) < 0) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%02x", chip_id);
if (stts22h_auto_increment_set(ctx, 1) < 0) {
LOG_ERR("Failed to set autoincr");
return -EIO;
}
/* set odr from DT */
odr = cfg->odr;
LOG_INF("sensor odr is %d", odr);
if (stts22h_set_odr_raw(dev, odr) < 0) {
LOG_ERR("Failed to set sampling rate");
return -EIO;
}
return 0;
}
static int stts22h_init(const struct device *dev)
{
struct stts22h_data *data = dev->data;
#ifdef CONFIG_STTS22H_TRIGGER
const struct stts22h_config *cfg = dev->config;
#endif
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (stts22h_init_chip(dev) < 0) {
LOG_ERR("Failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_STTS22H_TRIGGER
if (cfg->int_gpio.port) {
if (stts22h_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
#define STTS22H_DEFINE(inst) \
static struct stts22h_data stts22h_data_##inst; \
\
static const struct stts22h_config stts22h_config_##inst = { \
STMEMSC_CTX_I2C(&stts22h_config_##inst.i2c), \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.temp_hi = DT_INST_PROP(inst, temperature_hi_threshold), \
.temp_lo = DT_INST_PROP(inst, temperature_lo_threshold), \
.odr = DT_INST_PROP(inst, sampling_rate), \
IF_ENABLED(CONFIG_STTS22H_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, stts22h_init, NULL, \
&stts22h_data_##inst, &stts22h_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &stts22h_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(STTS22H_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/stts22h/stts22h.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,633 |
```c
/* ST Microelectronics STTS22H temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_stts22h
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "stts22h.h"
LOG_MODULE_DECLARE(STTS22H, CONFIG_SENSOR_LOG_LEVEL);
/**
* stts22h_trigger_set - link external trigger to event data ready
*/
int stts22h_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct stts22h_data *stts22h = dev->data;
const struct stts22h_config *config = dev->config;
if (!config->int_gpio.port) {
return -ENOTSUP;
}
if (trig->chan != SENSOR_CHAN_ALL &&
trig->chan != SENSOR_CHAN_AMBIENT_TEMP) {
LOG_ERR("Unsupported sensor trigger %d", trig->chan);
return -ENOTSUP;
}
stts22h->thsld_handler = handler;
stts22h->thsld_trigger = trig;
return 0;
}
/**
* stts22h_handle_interrupt - handle the thsld event
* read data and call handler if registered any
*/
static void stts22h_handle_interrupt(const struct device *dev)
{
struct stts22h_data *stts22h = dev->data;
const struct stts22h_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
stts22h_temp_trlhd_src_t status;
stts22h_temp_trshld_src_get(ctx, &status);
if (stts22h->thsld_handler != NULL &&
(status.under_thl || status.over_thh)) {
stts22h->thsld_handler(dev, stts22h->thsld_trigger);
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
static void stts22h_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct stts22h_data *stts22h =
CONTAINER_OF(cb, struct stts22h_data, gpio_cb);
const struct stts22h_config *cfg = stts22h->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_STTS22H_TRIGGER_OWN_THREAD)
k_sem_give(&stts22h->gpio_sem);
#elif defined(CONFIG_STTS22H_TRIGGER_GLOBAL_THREAD)
k_work_submit(&stts22h->work);
#endif /* CONFIG_STTS22H_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_STTS22H_TRIGGER_OWN_THREAD
static void stts22h_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct stts22h_data *stts22h = p1;
while (1) {
k_sem_take(&stts22h->gpio_sem, K_FOREVER);
stts22h_handle_interrupt(stts22h->dev);
}
}
#endif /* CONFIG_STTS22H_TRIGGER_OWN_THREAD */
#ifdef CONFIG_STTS22H_TRIGGER_GLOBAL_THREAD
static void stts22h_work_cb(struct k_work *work)
{
struct stts22h_data *stts22h =
CONTAINER_OF(work, struct stts22h_data, work);
stts22h_handle_interrupt(stts22h->dev);
}
#endif /* CONFIG_STTS22H_TRIGGER_GLOBAL_THREAD */
int stts22h_init_interrupt(const struct device *dev)
{
struct stts22h_data *stts22h = dev->data;
const struct stts22h_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
#if defined(CONFIG_STTS22H_TRIGGER_OWN_THREAD)
k_sem_init(&stts22h->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&stts22h->thread, stts22h->thread_stack,
CONFIG_STTS22H_THREAD_STACK_SIZE,
stts22h_thread, stts22h,
NULL, NULL, K_PRIO_COOP(CONFIG_STTS22H_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&stts22h->thread, dev->name);
#elif defined(CONFIG_STTS22H_TRIGGER_GLOBAL_THREAD)
stts22h->work.handler = stts22h_work_cb;
#endif /* CONFIG_STTS22H_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&stts22h->gpio_cb, stts22h_gpio_callback, BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &stts22h->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* Enable interrupt on high/low temperature threshold */
if (stts22h_temp_trshld_high_set(ctx, cfg->temp_hi) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
if (stts22h_temp_trshld_low_set(ctx, cfg->temp_lo) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/stts22h/stts22h_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,265 |
```unknown
# ST Microelectronics STTS22H temperature sensor
menuconfig STTS22H
bool "STTS22H temperature sensor"
default y
depends on DT_HAS_ST_STTS22H_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C
select HAS_STMEMSC
select USE_STDC_STTS22H
help
Enable driver for STTS22H I2C-based temperature sensor.
if STTS22H
module = STTS22H
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
endif # STTS22H
``` | /content/code_sandbox/drivers/sensor/st/stts22h/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 135 |
```c
/* ST Microelectronics LIS2DUX12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dux12
#include <zephyr/logging/log.h>
#include "lis2dux12.h"
LOG_MODULE_DECLARE(LIS2DUX12, CONFIG_SENSOR_LOG_LEVEL);
static void lis2dux12_gpio_callback(const struct device *dev, struct gpio_callback *cb,
uint32_t pins)
{
struct lis2dux12_data *data = CONTAINER_OF(cb, struct lis2dux12_data, gpio_cb);
int ret;
ARG_UNUSED(pins);
ret = gpio_pin_interrupt_configure_dt(data->drdy_gpio, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
#if defined(CONFIG_LIS2DUX12_TRIGGER_OWN_THREAD)
k_sem_give(&data->trig_sem);
#elif defined(CONFIG_LIS2DUX12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&data->work);
#endif
}
static void lis2dux12_handle_drdy_int(const struct device *dev)
{
struct lis2dux12_data *data = dev->data;
if (data->data_ready_handler != NULL) {
data->data_ready_handler(dev, data->data_ready_trigger);
}
}
static void lis2dux12_handle_int(const struct device *dev)
{
struct lis2dux12_data *lis2dux12 = dev->data;
const struct lis2dux12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dux12_all_sources_t sources;
int ret;
lis2dux12_all_sources_get(ctx, &sources);
if (sources.drdy) {
lis2dux12_handle_drdy_int(dev);
}
ret = gpio_pin_interrupt_configure_dt(lis2dux12->drdy_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
}
#ifdef CONFIG_LIS2DUX12_TRIGGER_OWN_THREAD
static void lis2dux12_thread(struct lis2dux12_data *data)
{
while (1) {
k_sem_take(&data->trig_sem, K_FOREVER);
lis2dux12_handle_int(data->dev);
}
}
#endif
#ifdef CONFIG_LIS2DUX12_TRIGGER_GLOBAL_THREAD
static void lis2dux12_work_cb(struct k_work *work)
{
struct lis2dux12_data *data = CONTAINER_OF(work, struct lis2dux12_data, work);
lis2dux12_handle_int(data->dev);
}
#endif
static int lis2dux12_init_interrupt(const struct device *dev)
{
const struct lis2dux12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dux12_pin_int_route_t route;
int err;
/* Enable pulsed mode */
err = lis2dux12_data_ready_mode_set(ctx, LIS2DUX12_DRDY_PULSED);
if (err < 0) {
return err;
}
/* route data-ready interrupt on int1 */
err = lis2dux12_pin_int1_route_get(ctx, &route);
if (err < 0) {
return err;
}
route.drdy = 1;
err = lis2dux12_pin_int1_route_set(ctx, &route);
if (err < 0) {
return err;
}
return 0;
}
int lis2dux12_trigger_init(const struct device *dev)
{
struct lis2dux12_data *data = dev->data;
const struct lis2dux12_config *cfg = dev->config;
int ret;
data->drdy_gpio = (cfg->drdy_pin == 1) ? (struct gpio_dt_spec *)&cfg->int1_gpio
: (struct gpio_dt_spec *)&cfg->int2_gpio;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(data->drdy_gpio)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -ENODEV;
}
data->dev = dev;
ret = gpio_pin_configure_dt(data->drdy_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&data->gpio_cb, lis2dux12_gpio_callback, BIT(data->drdy_gpio->pin));
ret = gpio_add_callback(data->drdy_gpio->port, &data->gpio_cb);
if (ret < 0) {
LOG_ERR("Could not set gpio callback");
return ret;
}
#if defined(CONFIG_LIS2DUX12_TRIGGER_OWN_THREAD)
k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&data->thread, data->thread_stack, CONFIG_LIS2DUX12_THREAD_STACK_SIZE,
(k_thread_entry_t)lis2dux12_thread, data, NULL, NULL,
K_PRIO_COOP(CONFIG_LIS2DUX12_THREAD_PRIORITY), 0, K_NO_WAIT);
k_thread_name_set(&data->thread, dev->name);
#elif defined(CONFIG_LIS2DUX12_TRIGGER_GLOBAL_THREAD)
data->work.handler = lis2dux12_work_cb;
#endif
return gpio_pin_interrupt_configure_dt(data->drdy_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
int lis2dux12_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lis2dux12_data *data = dev->data;
const struct lis2dux12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dux12_xl_data_t xldata;
lis2dux12_md_t mode = {.fs = cfg->range};
int ret;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (data->drdy_gpio->port == NULL) {
LOG_ERR("trigger_set is not supported");
return -ENOTSUP;
}
ret = gpio_pin_interrupt_configure_dt(data->drdy_gpio, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
return ret;
}
data->data_ready_handler = handler;
if (handler == NULL) {
LOG_WRN("lis2dux12: no handler");
return 0;
}
/* re-trigger lost interrupt */
lis2dux12_xl_data_get(ctx, &mode, &xldata);
data->data_ready_trigger = trig;
lis2dux12_init_interrupt(dev);
return gpio_pin_interrupt_configure_dt(data->drdy_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2dux12/lis2dux12_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,483 |
```objective-c
/* ST Microelectronics LIS2DUX12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DUX12_LIS2DUX12_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DUX12_LIS2DUX12_H_
#include <zephyr/types.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <stmemsc.h>
#include "lis2dux12_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct lis2dux12_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t range;
uint8_t pm;
uint8_t odr;
#ifdef CONFIG_LIS2DUX12_TRIGGER
const struct gpio_dt_spec int1_gpio;
const struct gpio_dt_spec int2_gpio;
uint8_t drdy_pin;
bool trig_enabled;
#endif
};
struct lis2dux12_data {
int sample_x;
int sample_y;
int sample_z;
float gain;
uint8_t range;
uint8_t odr;
#ifdef CONFIG_LIS2DUX12_ENABLE_TEMP
float sample_temp;
#endif
#ifdef CONFIG_LIS2DUX12_TRIGGER
struct gpio_dt_spec *drdy_gpio;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
const struct device *dev;
#if defined(CONFIG_LIS2DUX12_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DUX12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#elif defined(CONFIG_LIS2DUX12_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS2DUX12_TRIGGER */
};
#ifdef CONFIG_LIS2DUX12_TRIGGER
int lis2dux12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis2dux12_trigger_init(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LIS2DUX12_LIS2DUX12_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lis2dux12/lis2dux12.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 574 |
```unknown
# ST Microelectronics LIS2DUX12 3-axis accelerometer driver
menuconfig LIS2DUX12
bool "LIS2DUX12 I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_LIS2DUX12_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DUX12),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DUX12),spi)
select HAS_STMEMSC
select USE_STDC_LIS2DUX12
help
Enable driver for LIS2DUX12 accelerometer sensor driver
if LIS2DUX12
module = LIS2DUX12
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
config LIS2DUX12_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
endif # LIS2DUX12
``` | /content/code_sandbox/drivers/sensor/st/lis2dux12/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 216 |
```c
/* ST Microelectronics LIS2DUX12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dux12
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util_macro.h>
#include <zephyr/logging/log.h>
#include <zephyr/dt-bindings/sensor/lis2dux12.h>
#include "lis2dux12.h"
LOG_MODULE_REGISTER(LIS2DUX12, CONFIG_SENSOR_LOG_LEVEL);
static int lis2dux12_set_odr(const struct device *dev, uint8_t odr)
{
struct lis2dux12_data *data = dev->data;
const struct lis2dux12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dux12_md_t mode = {.odr = odr, .fs = data->range};
data->odr = odr;
return lis2dux12_mode_set(ctx, &mode);
}
static int lis2dux12_set_range(const struct device *dev, uint8_t range)
{
int err;
struct lis2dux12_data *data = dev->data;
const struct lis2dux12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dux12_md_t val = { .odr = data->odr, .fs = range };
err = lis2dux12_mode_set(ctx, &val);
if (err) {
return err;
}
switch (range) {
default:
LOG_ERR("range [%d] not supported.", range);
return -EINVAL;
case LIS2DUX12_DT_FS_2G:
data->gain = lis2dux12_from_fs2g_to_mg(1);
break;
case LIS2DUX12_DT_FS_4G:
data->gain = lis2dux12_from_fs4g_to_mg(1);
break;
case LIS2DUX12_DT_FS_8G:
data->gain = lis2dux12_from_fs8g_to_mg(1);
break;
case LIS2DUX12_DT_FS_16G:
data->gain = lis2dux12_from_fs16g_to_mg(1);
break;
}
data->range = range;
return 0;
}
#define FOREACH_ODR_ENUM(ODR_VAL) \
ODR_VAL(LIS2DUX12_DT_ODR_OFF, 0.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_1Hz_ULP, 1.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_3Hz_ULP, 3.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_25Hz_ULP, 25.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_6Hz, 6.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_12Hz5, 12.50f) \
ODR_VAL(LIS2DUX12_DT_ODR_25Hz, 25.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_50Hz, 50.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_100Hz, 100.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_200Hz, 200.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_400Hz, 400.0f) \
ODR_VAL(LIS2DUX12_DT_ODR_800Hz, 800.0f)
#define GENERATE_VAL(ENUM, VAL) VAL,
static const float lis2dux12_odr_map[LIS2DUX12_DT_ODR_END] = {FOREACH_ODR_ENUM(GENERATE_VAL)};
static int lis2dux12_freq_to_odr_val(const struct device *dev, uint16_t freq)
{
const struct lis2dux12_config *cfg = dev->config;
/* constrain loop to prevent erroneous power mode/odr combinations */
size_t i = (cfg->pm != LIS2DUX12_OPER_MODE_LOW_POWER) ? LIS2DUX12_DT_ODR_6Hz
: LIS2DUX12_DT_ODR_1Hz_ULP;
size_t len = (cfg->pm != LIS2DUX12_OPER_MODE_LOW_POWER) ? LIS2DUX12_DT_ODR_END
: LIS2DUX12_DT_ODR_6Hz;
while (i < len) {
if (freq <= lis2dux12_odr_map[i]) {
return i;
}
++i;
}
return -EINVAL;
}
static int lis2dux12_set_fs(const struct device *dev, int16_t fs)
{
int ret;
uint8_t range;
switch (fs) {
case 2:
range = LIS2DUX12_DT_FS_2G;
break;
case 4:
range = LIS2DUX12_DT_FS_4G;
break;
case 8:
range = LIS2DUX12_DT_FS_8G;
break;
case 16:
range = LIS2DUX12_DT_FS_16G;
break;
default:
LOG_ERR("fs [%d] not supported.", fs);
return -EINVAL;
}
ret = lis2dux12_set_range(dev, range);
if (ret < 0) {
LOG_ERR("%s: range init error %d", dev->name, range);
return ret;
}
LOG_DBG("%s: set fs to %d g", dev->name, fs);
return ret;
}
static int lis2dux12_accel_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
int odr_val;
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lis2dux12_set_fs(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
odr_val = lis2dux12_freq_to_odr_val(dev, val->val1);
if (odr_val < 0) {
LOG_ERR("%d Hz not supported or wrong operating mode.", val->val1);
return odr_val;
}
LOG_DBG("%s: set odr to %d Hz", dev->name, val->val1);
return lis2dux12_set_odr(dev, odr_val);
default:
LOG_ERR("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lis2dux12_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lis2dux12_accel_config(dev, chan, attr, val);
default:
LOG_ERR("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lis2dux12_sample_fetch_accel(const struct device *dev)
{
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;
}
data->sample_x = sys_le16_to_cpu(xzy_data.raw[0]);
data->sample_y = sys_le16_to_cpu(xzy_data.raw[1]);
data->sample_z = sys_le16_to_cpu(xzy_data.raw[2]);
return 0;
}
#ifdef CONFIG_LIS2DUX12_ENABLE_TEMP
static int lis2dux12_sample_fetch_temp(const struct device *dev)
{
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;
lis2dux12_outt_data_t temp_data = {0};
if (lis2dux12_outt_data_get(ctx, &mode, &temp_data) < 0) {
LOG_ERR("Failed to fetch raw temperature data sample");
return -EIO;
}
data->sample_temp = sys_le16_to_cpu(temp_data.heat.deg_c);
return 0;
}
#endif
static int lis2dux12_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2dux12_sample_fetch_accel(dev);
break;
#if defined(CONFIG_LIS2DUX12_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lis2dux12_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lis2dux12_sample_fetch_accel(dev);
#if defined(CONFIG_LIS2DUX12_ENABLE_TEMP)
lis2dux12_sample_fetch_temp(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lis2dux12_convert(struct sensor_value *val, int raw_val, float gain)
{
int64_t dval;
/* Gain is in mg/LSB */
/* Convert to m/s^2 */
dval = ((int64_t)raw_val * gain * SENSOR_G) / 1000;
val->val1 = dval / 1000000LL;
val->val2 = dval % 1000000LL;
}
static inline int lis2dux12_get_channel(enum sensor_channel chan, struct sensor_value *val,
struct lis2dux12_data *data, float gain)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lis2dux12_convert(val, data->sample_x, gain);
break;
case SENSOR_CHAN_ACCEL_Y:
lis2dux12_convert(val, data->sample_y, gain);
break;
case SENSOR_CHAN_ACCEL_Z:
lis2dux12_convert(val, data->sample_z, gain);
break;
case SENSOR_CHAN_ACCEL_XYZ:
lis2dux12_convert(val, data->sample_x, gain);
lis2dux12_convert(val + 1, data->sample_y, gain);
lis2dux12_convert(val + 2, data->sample_z, gain);
break;
#if defined(CONFIG_LIS2DUX12_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
sensor_value_from_float(val, data->sample_temp);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static int lis2dux12_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct lis2dux12_data *data = dev->data;
return lis2dux12_get_channel(chan, val, data, data->gain);
}
static const struct sensor_driver_api lis2dux12_driver_api = {
.attr_set = lis2dux12_attr_set,
#if defined(CONFIG_LIS2DUX12_TRIGGER)
.trigger_set = lis2dux12_trigger_set,
#endif
.sample_fetch = lis2dux12_sample_fetch,
.channel_get = lis2dux12_channel_get,
};
static int lis2dux12_init(const struct device *dev)
{
const struct lis2dux12_config *const cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t chip_id;
int ret;
lis2dux12_exit_deep_power_down(ctx);
k_busy_wait(25000);
/* check chip ID */
ret = lis2dux12_device_id_get(ctx, &chip_id);
if (ret < 0) {
LOG_ERR("%s: Not able to read dev id", dev->name);
return ret;
}
if (chip_id != LIS2DUX12_ID) {
LOG_ERR("%s: Invalid chip ID 0x%02x", dev->name, chip_id);
return -EINVAL;
}
/* reset device */
ret = lis2dux12_init_set(ctx, LIS2DUX12_RESET);
if (ret < 0) {
return ret;
}
k_busy_wait(100);
LOG_INF("%s: chip id 0x%x", dev->name, chip_id);
/* Set bdu and if_inc recommended for driver usage */
lis2dux12_init_set(ctx, LIS2DUX12_SENSOR_ONLY_ON);
lis2dux12_timestamp_set(ctx, PROPERTY_ENABLE);
#ifdef CONFIG_LIS2DUX12_TRIGGER
if (cfg->trig_enabled) {
ret = lis2dux12_trigger_init(dev);
if (ret < 0) {
LOG_ERR("%s: Failed to initialize triggers", dev->name);
return ret;
}
}
#endif
/* set sensor default pm and odr */
LOG_DBG("%s: pm: %d, odr: %d", dev->name, cfg->pm, cfg->odr);
ret = lis2dux12_set_odr(dev, cfg->odr);
if (ret < 0) {
LOG_ERR("%s: odr init error (12.5 Hz)", dev->name);
return ret;
}
/* set sensor default scale (used to convert sample values) */
LOG_DBG("%s: range is %d", dev->name, cfg->range);
ret = lis2dux12_set_range(dev, cfg->range);
if (ret < 0) {
LOG_ERR("%s: range init error %d", dev->name, cfg->range);
return ret;
}
return 0;
}
/*
* Device creation macro, shared by LIS2DUX12_DEFINE_SPI() and
* LIS2DUX12_DEFINE_I2C().
*/
#define LIS2DUX12_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, lis2dux12_init, NULL, &lis2dux12_data_##inst, \
&lis2dux12_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lis2dux12_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2DUX12_TRIGGER
#define LIS2DUX12_CFG_IRQ(inst) \
.trig_enabled = true, \
.int1_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, {0}), \
.int2_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, {0}), \
.drdy_pin = DT_INST_PROP(inst, drdy_pin),
#else
#define LIS2DUX12_CFG_IRQ(inst)
#endif /* CONFIG_LIS2DUX12_TRIGGER */
#define LIS2DUX12_SPI_OPERATION \
(SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)
#define LIS2DUX12_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2dux12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, LIS2DUX12_SPI_OPERATION, 0), \
}, \
.range = DT_INST_PROP(inst, range), \
.pm = DT_INST_PROP(inst, power_mode), \
.odr = DT_INST_PROP(inst, odr), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(LIS2DUX12_CFG_IRQ(inst))) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DUX12_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lis2dux12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
.range = DT_INST_PROP(inst, range), \
.pm = DT_INST_PROP(inst, power_mode), \
.odr = DT_INST_PROP(inst, odr), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(LIS2DUX12_CFG_IRQ(inst))) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DUX12_DEFINE(inst) \
static struct lis2dux12_data lis2dux12_data_##inst; \
static const struct lis2dux12_config lis2dux12_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), (LIS2DUX12_CONFIG_SPI(inst)), \
(LIS2DUX12_CONFIG_I2C(inst))); \
LIS2DUX12_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2DUX12_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2dux12/lis2dux12.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,892 |
```c
/* ST Microelectronics IIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2dh
#include <string.h>
#include "iis2dh.h"
#include <zephyr/logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define IIS2DH_SPI_READM (3 << 6) /* 0xC0 */
#define IIS2DH_SPI_WRITEM (1 << 6) /* 0x40 */
LOG_MODULE_DECLARE(IIS2DH, CONFIG_SENSOR_LOG_LEVEL);
static int iis2dh_spi_read(const struct device *dev, uint8_t reg, uint8_t *data, uint16_t len)
{
const struct iis2dh_device_config *config = dev->config;
uint8_t buffer_tx[2] = { reg | IIS2DH_SPI_READM, 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 = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (spi_transceive_dt(&config->spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int iis2dh_spi_write(const struct device *dev, uint8_t reg, uint8_t *data, uint16_t len)
{
const struct iis2dh_device_config *config = dev->config;
uint8_t buffer_tx[1] = { reg | IIS2DH_SPI_WRITEM };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (spi_write_dt(&config->spi, &tx)) {
return -EIO;
}
return 0;
}
stmdev_ctx_t iis2dh_spi_ctx = {
.read_reg = (stmdev_read_ptr) iis2dh_spi_read,
.write_reg = (stmdev_write_ptr) iis2dh_spi_write,
.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay,
};
int iis2dh_spi_init(const struct device *dev)
{
struct iis2dh_data *data = dev->data;
const struct iis2dh_device_config *config = dev->config;
if (!spi_is_ready_dt(&config->spi)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
data->ctx = &iis2dh_spi_ctx;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/iis2dh_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 702 |
```objective-c
/* ST Microelectronics IIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_IIS2DH_IIS2DH_H_
#define ZEPHYR_DRIVERS_SENSOR_IIS2DH_IIS2DH_H_
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <stmemsc.h>
#include "iis2dh_reg.h"
/*
* Return ODR reg value based on data rate set
*/
#define IIS2DH_ODR_TO_REG_HR(_lp, _odr) \
((_odr == 0) ? IIS2DH_POWER_DOWN : \
((_odr < 10) ? IIS2DH_ODR_1Hz : \
((_odr < 25) ? IIS2DH_ODR_10Hz : \
((_lp == IIS2DH_LP_8bit) && (_odr >= 5376) ? IIS2DH_ODR_5kHz376_LP_1kHz344_NM_HP : \
((_lp != IIS2DH_LP_8bit) && (_odr >= 1344) ? IIS2DH_ODR_5kHz376_LP_1kHz344_NM_HP : \
((_lp == IIS2DH_LP_8bit) && (_odr >= 1600) ? IIS2DH_ODR_1kHz620_LP : \
((_lp != IIS2DH_LP_8bit) && (_odr >= 800) ? IIS2DH_ODR_400Hz : \
((31 - __builtin_clz(_odr / 25))) + 3)))))))
/* FS reg value from Full Scale */
#define IIS2DH_FS_TO_REG(_fs) (30 - __builtin_clz(_fs))
/**
* struct iis2dh_device_config - iis2dh hw configuration
* @spi: SPI bus spec.
* @i2c: I2C bus spec.
* @pm: Power mode (lis2dh_powermode).
* @int_gpio: GPIO spec for sensor pin interrupt.
*/
struct iis2dh_device_config {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
uint8_t pm;
#ifdef CONFIG_IIS2DH_TRIGGER
struct gpio_dt_spec int_gpio;
#endif /* CONFIG_IIS2DH_TRIGGER */
};
/* sensor data */
struct iis2dh_data {
int16_t acc[3];
uint32_t gain;
stmdev_ctx_t *ctx;
#ifdef CONFIG_IIS2DH_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#if defined(CONFIG_IIS2DH_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2DH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif /* CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_IIS2DH_TRIGGER */
};
int iis2dh_i2c_init(const struct device *dev);
int iis2dh_spi_init(const struct device *dev);
#ifdef CONFIG_IIS2DH_TRIGGER
int iis2dh_init_interrupt(const struct device *dev);
int iis2dh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_IIS2DH_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_IIS2DH_IIS2DH_H_ */
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/iis2dh.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 830 |
```c
/* ST Microelectronics IIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2dh
#include <string.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include "iis2dh.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(IIS2DH, CONFIG_SENSOR_LOG_LEVEL);
static int iis2dh_i2c_read(const struct device *dev, uint8_t reg_addr, uint8_t *value, uint16_t len)
{
const struct iis2dh_device_config *config = dev->config;
return i2c_burst_read_dt(&config->i2c, reg_addr | 0x80, value, len);
}
static int iis2dh_i2c_write(const struct device *dev, uint8_t reg_addr, uint8_t *value,
uint16_t len)
{
const struct iis2dh_device_config *config = dev->config;
return i2c_burst_write_dt(&config->i2c, reg_addr | 0x80, value, len);
}
stmdev_ctx_t iis2dh_i2c_ctx = {
.read_reg = (stmdev_read_ptr) iis2dh_i2c_read,
.write_reg = (stmdev_write_ptr) iis2dh_i2c_write,
.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay,
};
int iis2dh_i2c_init(const struct device *dev)
{
struct iis2dh_data *data = dev->data;
const struct iis2dh_device_config *config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
data->ctx = &iis2dh_i2c_ctx;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/iis2dh_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 443 |
```c
/* ST Microelectronics IIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2dh
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis2dh.h"
LOG_MODULE_DECLARE(IIS2DH, CONFIG_SENSOR_LOG_LEVEL);
/**
* iis2dh_enable_int - enable selected int pin to generate interrupt
*/
static int iis2dh_enable_drdy(const struct device *dev,
enum sensor_trigger_type type, int enable)
{
struct iis2dh_data *iis2dh = dev->data;
iis2dh_ctrl_reg3_t reg3;
/* set interrupt for pin INT1 */
iis2dh_pin_int1_config_get(iis2dh->ctx, ®3);
reg3.i1_drdy1 = enable;
return iis2dh_pin_int1_config_set(iis2dh->ctx, ®3);
}
/**
* iis2dh_trigger_set - link external trigger to event data ready
*/
int iis2dh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct iis2dh_data *iis2dh = dev->data;
const struct iis2dh_device_config *cfg = dev->config;
int16_t raw[3];
int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
if (!cfg->int_gpio.port) {
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
iis2dh->drdy_handler = handler;
iis2dh->drdy_trig = trig;
if (state) {
/* dummy read: re-trigger interrupt */
iis2dh_acceleration_raw_get(iis2dh->ctx, raw);
}
return iis2dh_enable_drdy(dev, SENSOR_TRIG_DATA_READY, state);
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
}
static int iis2dh_handle_drdy_int(const struct device *dev)
{
struct iis2dh_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
/**
* iis2dh_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void iis2dh_handle_interrupt(const struct device *dev)
{
const struct iis2dh_device_config *cfg = dev->config;
iis2dh_handle_drdy_int(dev);
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
static void iis2dh_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct iis2dh_data *iis2dh =
CONTAINER_OF(cb, struct iis2dh_data, gpio_cb);
const struct iis2dh_device_config *cfg = iis2dh->dev->config;
if ((pins & BIT(cfg->int_gpio.pin)) == 0U) {
return;
}
gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_IIS2DH_TRIGGER_OWN_THREAD)
k_sem_give(&iis2dh->gpio_sem);
#elif defined(CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis2dh->work);
#endif /* CONFIG_IIS2DH_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_IIS2DH_TRIGGER_OWN_THREAD
static void iis2dh_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis2dh_data *iis2dh = p1;
while (1) {
k_sem_take(&iis2dh->gpio_sem, K_FOREVER);
iis2dh_handle_interrupt(iis2dh->dev);
}
}
#endif /* CONFIG_IIS2DH_TRIGGER_OWN_THREAD */
#ifdef CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD
static void iis2dh_work_cb(struct k_work *work)
{
struct iis2dh_data *iis2dh =
CONTAINER_OF(work, struct iis2dh_data, work);
iis2dh_handle_interrupt(iis2dh->dev);
}
#endif /* CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD */
int iis2dh_init_interrupt(const struct device *dev)
{
struct iis2dh_data *iis2dh = dev->data;
const struct iis2dh_device_config *cfg = dev->config;
int ret;
if (!gpio_is_ready_dt(&cfg->int_gpio)) {
LOG_ERR("%s: device %s is not ready", dev->name, cfg->int_gpio.port->name);
return -ENODEV;
}
iis2dh->dev = dev;
#if defined(CONFIG_IIS2DH_TRIGGER_OWN_THREAD)
k_sem_init(&iis2dh->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis2dh->thread, iis2dh->thread_stack,
CONFIG_IIS2DH_THREAD_STACK_SIZE,
iis2dh_thread, iis2dh,
0, NULL, K_PRIO_COOP(CONFIG_IIS2DH_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD)
iis2dh->work.handler = iis2dh_work_cb;
#endif /* CONFIG_IIS2DH_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->int_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&iis2dh->gpio_cb,
iis2dh_gpio_callback,
BIT(cfg->int_gpio.pin));
if (gpio_add_callback(cfg->int_gpio.port, &iis2dh->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* enable drdy on int1 in pulse mode */
if (iis2dh_int1_pin_notification_mode_set(iis2dh->ctx, IIS2DH_INT1_PULSED)) {
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/iis2dh_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,396 |
```unknown
# ST Microelectronics IIS2DH 3-axis accelerometer driver
menuconfig IIS2DH
bool "IIS2DH I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_IIS2DH_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2DH),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2DH),spi)
select HAS_STMEMSC
select USE_STDC_IIS2DH
help
Enable driver for IIS2DH accelerometer sensor driver
if IIS2DH
choice IIS2DH_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config IIS2DH_TRIGGER_NONE
bool "No trigger"
config IIS2DH_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select IIS2DH_TRIGGER
config IIS2DH_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select IIS2DH_TRIGGER
endchoice
config IIS2DH_TRIGGER
bool
if IIS2DH_TRIGGER
config IIS2DH_THREAD_PRIORITY
int "Thread priority"
depends on IIS2DH_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config IIS2DH_THREAD_STACK_SIZE
int "Thread stack size"
depends on IIS2DH_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # IIS2DH_TRIGGER
config IIS2DH_RANGE
int "Accelerometer Full-scale range setting"
default 0
help
Specify the default accelerometer full-scale range.
Valid values are:
0: Full Scale selected at runtime
2: +/- 2g
4: +/- 4g
8: +/- 8g
16: +/- 16g
config IIS2DH_ODR
int "Accelerometer sampling frequency (ODR)"
range 0 9
default 0
help
Specify the default accelerometer output data rate expressed in
samples per second (Hz).
0: ODR selected at runtime
1: 1 Hz
2: 10 Hz
3: 25 Hz
4: 50 Hz
5: 100 Hz
6: 200 Hz
7: 400 Hz
8: 1620 Hz (only LP)
9: Depends by mode. LP: 5376 Hz - NORM or HR: 1344 Hz
config IIS2DH_POWER_MODE
int "Sensor Power Modes"
range 0 2
default 0
help
Specify the sensor power mode
0: High Resolution mode
1: Normal mode
2: Low Power mode
endif # IIS2DH
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 656 |
```c
/* ST Microelectronics IIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2dh
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util_macro.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#include "iis2dh.h"
LOG_MODULE_REGISTER(IIS2DH, CONFIG_SENSOR_LOG_LEVEL);
/* gains in uG/LSB */
static const uint32_t iis2dh_gain[3][4] = {
{
/* HR mode */
980/16, /* 2G */
1950/16, /* 4G */
3910/16, /* 8G */
11720/16, /* 16G */
},
{
/* NM mode */
3910/64, /* 2G */
7810/64, /* 4G */
15630/64, /* 8G */
46950/64, /* 16G */
},
{
/* LP mode */
15630/256, /* 2G */
31250/256, /* 4G */
62500/256, /* 8G */
188680/256, /* 16G */
},
};
static int iis2dh_set_fs_raw(const struct device *dev, uint8_t fs)
{
struct iis2dh_data *iis2dh = dev->data;
int err;
err = iis2dh_full_scale_set(iis2dh->ctx, fs);
if (!err) {
/* save internally gain for optimization */
iis2dh->gain = iis2dh_gain[IIS2DH_HR_12bit][fs];
}
return err;
}
#if (CONFIG_IIS2DH_RANGE == 0)
/**
* iis2dh_set_range - set full scale range for acc
* @dev: Pointer to instance of struct device (I2C or SPI)
* @range: Full scale range (2, 4, 8 and 16 G)
*/
static int iis2dh_set_range(const struct device *dev, uint16_t range)
{
int err;
uint8_t fs = IIS2DH_FS_TO_REG(range);
err = iis2dh_set_fs_raw(dev, fs);
return err;
}
#endif
#if (CONFIG_IIS2DH_ODR == 0)
/**
* iis2dh_set_odr - set new sampling frequency
* @dev: Pointer to instance of struct device (I2C or SPI)
* @odr: Output data rate
*/
static int iis2dh_set_odr(const struct device *dev, uint16_t odr)
{
struct iis2dh_data *iis2dh = dev->data;
const struct iis2dh_device_config *cfg = dev->config;
iis2dh_odr_t val;
val = IIS2DH_ODR_TO_REG_HR(cfg->pm, odr);
return iis2dh_data_rate_set(iis2dh->ctx, val);
}
#endif
static inline void iis2dh_convert(struct sensor_value *val, int raw_val,
uint32_t gain)
{
int64_t dval;
/* Gain is in ug/LSB */
/* Convert to m/s^2 */
dval = ((int64_t)raw_val * gain * SENSOR_G) / 1000000LL;
val->val1 = dval / 1000000LL;
val->val2 = dval % 1000000LL;
}
static inline void iis2dh_channel_get_acc(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int i;
uint8_t ofs_start, ofs_stop;
struct iis2dh_data *iis2dh = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop ; i++) {
iis2dh_convert(pval++, iis2dh->acc[i], iis2dh->gain);
}
}
static int iis2dh_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
iis2dh_channel_get_acc(dev, chan, val);
return 0;
default:
LOG_DBG("Channel not supported");
break;
}
return -ENOTSUP;
}
static int iis2dh_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#if (CONFIG_IIS2DH_RANGE == 0)
case SENSOR_ATTR_FULL_SCALE:
return iis2dh_set_range(dev, sensor_ms2_to_g(val));
#endif
#if (CONFIG_IIS2DH_ODR == 0)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2dh_set_odr(dev, val->val1);
#endif
default:
LOG_DBG("Acc attribute not supported");
break;
}
return -ENOTSUP;
}
static int iis2dh_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return iis2dh_config(dev, chan, attr, val);
default:
LOG_DBG("Attr not supported on %d channel", chan);
break;
}
return -ENOTSUP;
}
static int iis2dh_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct iis2dh_data *iis2dh = dev->data;
int16_t buf[3];
/* fetch raw data sample */
if (iis2dh_acceleration_raw_get(iis2dh->ctx, buf) < 0) {
LOG_DBG("Failed to fetch raw data sample");
return -EIO;
}
iis2dh->acc[0] = sys_le16_to_cpu(buf[0]);
iis2dh->acc[1] = sys_le16_to_cpu(buf[1]);
iis2dh->acc[2] = sys_le16_to_cpu(buf[2]);
return 0;
}
static const struct sensor_driver_api iis2dh_driver_api = {
.attr_set = iis2dh_attr_set,
#if CONFIG_IIS2DH_TRIGGER
.trigger_set = iis2dh_trigger_set,
#endif /* CONFIG_IIS2DH_TRIGGER */
.sample_fetch = iis2dh_sample_fetch,
.channel_get = iis2dh_channel_get,
};
static int iis2dh_init_interface(const struct device *dev)
{
int res;
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
res = iis2dh_spi_init(dev);
if (res) {
return res;
}
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
res = iis2dh_i2c_init(dev);
if (res) {
return res;
}
#else
#error "BUS MACRO NOT DEFINED IN DTS"
#endif
return 0;
}
static int iis2dh_init(const struct device *dev)
{
struct iis2dh_data *iis2dh = dev->data;
const struct iis2dh_device_config *cfg = dev->config;
uint8_t wai;
if (iis2dh_init_interface(dev)) {
return -EINVAL;
}
/* check chip ID */
if (iis2dh_device_id_get(iis2dh->ctx, &wai) < 0) {
return -EIO;
}
if (wai != IIS2DH_ID) {
LOG_ERR("Invalid chip ID: %02x", wai);
return -EINVAL;
}
if (iis2dh_block_data_update_set(iis2dh->ctx, PROPERTY_ENABLE) < 0) {
return -EIO;
}
if (iis2dh_operating_mode_set(iis2dh->ctx, cfg->pm)) {
return -EIO;
}
#if (CONFIG_IIS2DH_ODR != 0)
/* set default odr and full scale for acc */
if (iis2dh_data_rate_set(iis2dh->ctx, CONFIG_IIS2DH_ODR) < 0) {
return -EIO;
}
#endif
#if (CONFIG_IIS2DH_RANGE != 0)
iis2dh_set_fs_raw(dev, CONFIG_IIS2DH_RANGE);
#endif
#ifdef CONFIG_IIS2DH_TRIGGER
if (cfg->int_gpio.port) {
if (iis2dh_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupts");
return -EIO;
}
}
#endif /* CONFIG_IIS2DH_TRIGGER */
return 0;
}
#define IIS2DH_SPI(inst) \
(.spi = SPI_DT_SPEC_INST_GET( \
0, SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_WORD_SET(8), 0),)
#define IIS2DH_I2C(inst) (.i2c = I2C_DT_SPEC_INST_GET(inst),)
#define IIS2DH_DEFINE(inst) \
static struct iis2dh_data iis2dh_data_##inst; \
\
static const struct iis2dh_device_config iis2dh_device_config_##inst = { \
COND_CODE_1(DT_INST_ON_BUS(inst, i2c), IIS2DH_I2C(inst), ()) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), IIS2DH_SPI(inst), ()) \
.pm = CONFIG_IIS2DH_POWER_MODE, \
IF_ENABLED(CONFIG_IIS2DH_TRIGGER, \
(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, drdy_gpios, { 0 }),)) \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, iis2dh_init, NULL, \
&iis2dh_data_##inst, &iis2dh_device_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &iis2dh_driver_api); \
DT_INST_FOREACH_STATUS_OKAY(IIS2DH_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/iis2dh/iis2dh.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,443 |
```objective-c
/* ST Microelectronics LIS2DE12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DE12_LIS2DE12_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DE12_LIS2DE12_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lis2de12_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LIS2DE12_EN_BIT 0x01
#define LIS2DE12_DIS_BIT 0x00
#define SENSOR_G_DOUBLE (SENSOR_G / 1000000.0)
struct lis2de12_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_pm;
uint8_t accel_odr;
uint8_t accel_range;
uint8_t drdy_pulsed;
#ifdef CONFIG_LIS2DE12_TRIGGER
const struct gpio_dt_spec int1_gpio;
const struct gpio_dt_spec int2_gpio;
bool trig_enabled;
#endif /* CONFIG_LIS2DE12_TRIGGER */
};
union samples {
uint8_t raw[6];
struct {
int16_t axis[3];
};
} __aligned(2);
struct lis2de12_data {
const struct device *dev;
int16_t acc[3];
int16_t temp_sample;
uint32_t acc_gain;
uint8_t accel_freq;
uint8_t accel_fs;
#ifdef CONFIG_LIS2DE12_TRIGGER
struct gpio_dt_spec *drdy_gpio;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
#if defined(CONFIG_LIS2DE12_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DE12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DE12_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS2DE12_TRIGGER */
};
#ifdef CONFIG_LIS2DE12_TRIGGER
int lis2de12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis2de12_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LIS2DE12_LIS2DE12_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lis2de12/lis2de12.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 647 |
```unknown
# ST Microelectronics LIS2DE12 3-axis accelerometer sensor driver
menuconfig LIS2DE12
bool "LIS2DE12 I2C/SPI smartxl Chip"
default y
depends on DT_HAS_ST_LIS2DE12_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DE12),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DE12),spi)
select HAS_STMEMSC
select USE_STDC_LIS2DE12
help
Enable driver for LIS2DE12 smartxl sensor.
if LIS2DE12
module = LIS2DE12
thread_priority = 10
thread_stack_size = 1024
source "drivers/sensor/Kconfig.trigger_template"
config LIS2DE12_ENABLE_TEMP
bool "Die temperature sensor"
help
Enable/disable die temperature sensor
endif # LIS2DE12
``` | /content/code_sandbox/drivers/sensor/st/lis2de12/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 209 |
```c
/* ST Microelectronics LIS2DE12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2de12
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lis2de12.h"
LOG_MODULE_REGISTER(LIS2DE12, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t lis2de12_odr_map[10] = { 0, 1, 10, 25, 50, 100, 200, 400, 1620, 5376};
static int lis2de12_freq_to_odr_val(const struct device *dev, uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lis2de12_odr_map); i++) {
if (freq <= lis2de12_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
typedef struct {
uint16_t fs;
uint32_t gain; /* Accel sensor sensitivity in ug/LSB */
} fs_map;
static const fs_map lis2de12_accel_fs_map[] = {
{2, 15600},
{4, 31200},
{8, 62500},
{16, 187500},
};
static int lis2de12_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lis2de12_accel_fs_map); i++) {
if (range == lis2de12_accel_fs_map[i].fs) {
return i;
}
}
return -EINVAL;
}
static int lis2de12_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2de12_data *data = dev->data;
if (lis2de12_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int lis2de12_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2de12_data *data = dev->data;
if (lis2de12_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = odr;
return 0;
}
static int lis2de12_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lis2de12_freq_to_odr_val(dev, freq);
if (odr < 0) {
return odr;
}
if (lis2de12_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int lis2de12_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lis2de12_data *data = dev->data;
fs = lis2de12_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lis2de12_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = lis2de12_accel_fs_map[fs].gain;
return 0;
}
static int lis2de12_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lis2de12_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lis2de12_accel_odr_set(dev, val->val1);
default:
LOG_WRN("Accel attribute %d not supported.", attr);
return -ENOTSUP;
}
}
static int lis2de12_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lis2de12_accel_config(dev, chan, attr, val);
default:
LOG_WRN("attribute %d not supported on this channel.", chan);
return -ENOTSUP;
}
}
static int lis2de12_sample_fetch_accel(const struct device *dev)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2de12_data *data = dev->data;
if (lis2de12_acceleration_raw_get(ctx, data->acc) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
return 0;
}
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
static int lis2de12_sample_fetch_temp(const struct device *dev)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2de12_data *data = dev->data;
if (lis2de12_temperature_raw_get(ctx, &data->temp_sample) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#endif
static int lis2de12_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2de12_sample_fetch_accel(dev);
break;
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lis2de12_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lis2de12_sample_fetch_accel(dev);
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
lis2de12_sample_fetch_temp(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lis2de12_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val / 256) * sensitivity * SENSOR_G_DOUBLE;
val->val1 = (int32_t)(dval / 1000000);
val->val2 = (int32_t)(dval % 1000000);
}
static inline int lis2de12_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lis2de12_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lis2de12_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lis2de12_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lis2de12_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lis2de12_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lis2de12_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lis2de12_data *data)
{
return lis2de12_accel_get_channel(chan, val, data, data->acc_gain);
}
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
static void lis2de12_temp_channel_get(struct sensor_value *val, struct lis2de12_data *data)
{
int64_t micro_c;
/* convert units to micro Celsius. Raw temperature samples are
* expressed in 256 LSB/deg_C units. And LSB output is 0 at 25 C.
*/
micro_c = ((int64_t)data->temp_sample * 1000000) / 256;
val->val1 = micro_c / 1000000 + 25;
val->val2 = micro_c % 1000000;
}
#endif
static int lis2de12_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lis2de12_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lis2de12_accel_channel_get(chan, val, data);
break;
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lis2de12_temp_channel_get(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lis2de12_driver_api = {
.attr_set = lis2de12_attr_set,
#if CONFIG_LIS2DE12_TRIGGER
.trigger_set = lis2de12_trigger_set,
#endif
.sample_fetch = lis2de12_sample_fetch,
.channel_get = lis2de12_channel_get,
};
static int lis2de12_init_chip(const struct device *dev)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2de12_data *lis2de12 = dev->data;
uint8_t chip_id;
uint8_t odr, fs;
if (lis2de12_device_id_get(ctx, &chip_id) < 0) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
if (chip_id != LIS2DE12_ID) {
LOG_ERR("Invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (lis2de12_block_data_update_set(ctx, 1) < 0) {
LOG_ERR("failed to set BDU");
return -EIO;
}
/* set FS from DT */
fs = cfg->accel_range;
LOG_DBG("accel range is %d", fs);
if (lis2de12_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return -EIO;
}
lis2de12->acc_gain = lis2de12_accel_fs_map[fs].gain;
/* set odr from DT (the only way to go in high performance) */
odr = cfg->accel_odr;
LOG_DBG("accel odr is %d", odr);
if (lis2de12_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer odr %d", odr);
return -EIO;
}
#if defined(CONFIG_LIS2DE12_ENABLE_TEMP)
lis2de12_temperature_meas_set(ctx, LIS2DE12_TEMP_ENABLE);
#endif
return 0;
}
static int lis2de12_init(const struct device *dev)
{
#ifdef CONFIG_LIS2DE12_TRIGGER
const struct lis2de12_config *cfg = dev->config;
#endif
struct lis2de12_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (lis2de12_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_LIS2DE12_TRIGGER
if (cfg->trig_enabled) {
if (lis2de12_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
return 0;
}
/*
* Device creation macro, shared by LIS2DE12_DEFINE_SPI() and
* LIS2DE12_DEFINE_I2C().
*/
#define LIS2DE12_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2de12_init, \
NULL, \
&lis2de12_data_##inst, \
&lis2de12_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2de12_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2DE12_TRIGGER
#define LIS2DE12_CFG_IRQ(inst) \
.trig_enabled = true, \
.int1_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, { 0 }), \
.int2_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, { 0 }), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed)
#else
#define LIS2DE12_CFG_IRQ(inst)
#endif /* CONFIG_LIS2DE12_TRIGGER */
#define LIS2DE12_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LIS2DE12_CONFIG_COMMON(inst) \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(LIS2DE12_CFG_IRQ(inst)))
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#define LIS2DE12_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2de12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, LIS2DE12_SPI_OP, 0), \
}, \
LIS2DE12_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DE12_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C_INCR(&lis2de12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LIS2DE12_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DE12_DEFINE(inst) \
static struct lis2de12_data lis2de12_data_##inst; \
static const struct lis2de12_config lis2de12_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2DE12_CONFIG_SPI(inst)), \
(LIS2DE12_CONFIG_I2C(inst))); \
LIS2DE12_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2DE12_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2de12/lis2de12.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,463 |
```c
/* ST Microelectronics LIS2DE12 3-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2de12
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lis2de12.h"
LOG_MODULE_DECLARE(LIS2DE12, CONFIG_SENSOR_LOG_LEVEL);
/**
* lis2de12_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int lis2de12_enable_xl_int(const struct device *dev, int enable)
{
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2de12_ctrl_reg3_t val = {0};
int ret;
if (enable) {
int16_t xl_data[3];
/* dummy read: re-trigger interrupt */
lis2de12_acceleration_raw_get(ctx, xl_data);
}
/* set interrupt */
ret = lis2de12_pin_int1_config_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.i1_zyxda = 1;
return lis2de12_pin_int1_config_set(ctx, &val);
}
/**
* lis2de12_trigger_set - link external trigger to event data ready
*/
int lis2de12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lis2de12_config *cfg = dev->config;
struct lis2de12_data *lis2de12 = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
switch (trig->chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lis2de12->handler_drdy_acc = handler;
lis2de12->trig_drdy_acc = trig;
if (handler) {
return lis2de12_enable_xl_int(dev, LIS2DE12_EN_BIT);
}
return lis2de12_enable_xl_int(dev, LIS2DE12_DIS_BIT);
default:
return -ENOTSUP;
}
}
/**
* lis2de12_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lis2de12_handle_interrupt(const struct device *dev)
{
struct lis2de12_data *lis2de12 = dev->data;
const struct lis2de12_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2de12_status_reg_t status;
while (1) {
if (lis2de12_status_get(ctx, &status) < 0) {
LOG_ERR("failed reading status reg");
return;
}
if (status.zyxda == 0) {
/* spurious interrupt */
break;
}
if ((status.zyxda) && (lis2de12->handler_drdy_acc != NULL)) {
lis2de12->handler_drdy_acc(dev, lis2de12->trig_drdy_acc);
}
}
gpio_pin_interrupt_configure_dt(lis2de12->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lis2de12_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2de12_data *lis2de12 =
CONTAINER_OF(cb, struct lis2de12_data, gpio_cb);
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(lis2de12->drdy_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_LIS2DE12_TRIGGER_OWN_THREAD)
k_sem_give(&lis2de12->gpio_sem);
#elif defined(CONFIG_LIS2DE12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2de12->work);
#endif /* CONFIG_LIS2DE12_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LIS2DE12_TRIGGER_OWN_THREAD
static void lis2de12_thread(struct lis2de12_data *lis2de12)
{
while (1) {
k_sem_take(&lis2de12->gpio_sem, K_FOREVER);
lis2de12_handle_interrupt(lis2de12->dev);
}
}
#endif /* CONFIG_LIS2DE12_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LIS2DE12_TRIGGER_GLOBAL_THREAD
static void lis2de12_work_cb(struct k_work *work)
{
struct lis2de12_data *lis2de12 =
CONTAINER_OF(work, struct lis2de12_data, work);
lis2de12_handle_interrupt(lis2de12->dev);
}
#endif /* CONFIG_LIS2DE12_TRIGGER_GLOBAL_THREAD */
int lis2de12_init_interrupt(const struct device *dev)
{
struct lis2de12_data *lis2de12 = dev->data;
const struct lis2de12_config *cfg = dev->config;
int ret;
lis2de12->drdy_gpio = (struct gpio_dt_spec *)&cfg->int1_gpio;
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(lis2de12->drdy_gpio)) {
LOG_ERR("Cannot get pointer to drdy_gpio device (%p)",
lis2de12->drdy_gpio);
return -EINVAL;
}
#if defined(CONFIG_LIS2DE12_TRIGGER_OWN_THREAD)
k_sem_init(&lis2de12->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lis2de12->thread, lis2de12->thread_stack,
CONFIG_LIS2DE12_THREAD_STACK_SIZE,
(k_thread_entry_t)lis2de12_thread, lis2de12,
NULL, NULL, K_PRIO_COOP(CONFIG_LIS2DE12_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&lis2de12->thread, dev->name);
#elif defined(CONFIG_LIS2DE12_TRIGGER_GLOBAL_THREAD)
lis2de12->work.handler = lis2de12_work_cb;
#endif /* CONFIG_LIS2DE12_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(lis2de12->drdy_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio: %d", ret);
return ret;
}
gpio_init_callback(&lis2de12->gpio_cb,
lis2de12_gpio_callback,
BIT(lis2de12->drdy_gpio->pin));
if (gpio_add_callback(lis2de12->drdy_gpio->port, &lis2de12->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(lis2de12->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2de12/lis2de12_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,516 |
```unknown
# STM32 vref sensor configuration options
config STM32_VREF
bool "STM32 VREF Sensor"
default y
depends on DT_HAS_ST_STM32_ADC_ENABLED
depends on DT_HAS_ST_STM32_VREF_ENABLED
depends on SOC_FAMILY_STM32 && !SOC_SERIES_STM32F1X
select ADC
help
Enable driver for STM32 Vref sensor.
``` | /content/code_sandbox/drivers/sensor/st/stm32_vref/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 87 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_stm32_vref
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device_runtime.h>
#include <stm32_ll_adc.h>
#if defined(CONFIG_SOC_SERIES_STM32H5X)
#include <stm32_ll_icache.h>
#endif /* CONFIG_SOC_SERIES_STM32H5X */
LOG_MODULE_REGISTER(stm32_vref, CONFIG_SENSOR_LOG_LEVEL);
struct stm32_vref_data {
const struct device *adc;
const struct adc_channel_cfg adc_cfg;
ADC_TypeDef *adc_base;
struct adc_sequence adc_seq;
struct k_mutex mutex;
int16_t sample_buffer;
int16_t raw; /* raw adc Sensor value */
};
struct stm32_vref_config {
uint16_t *cal_addr;
int cal_mv;
};
static int stm32_vref_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct stm32_vref_data *data = dev->data;
struct adc_sequence *sp = &data->adc_seq;
int rc;
uint32_t path;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
pm_device_runtime_get(data->adc);
rc = adc_channel_setup(data->adc, &data->adc_cfg);
if (rc) {
LOG_DBG("Setup AIN%u got %d", data->adc_cfg.channel_id, rc);
goto unlock;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
LL_ADC_PATH_INTERNAL_VREFINT | path);
#ifdef LL_ADC_DELAY_VREFINT_STAB_US
k_usleep(LL_ADC_DELAY_VREFINT_STAB_US);
#endif
rc = adc_read(data->adc, sp);
if (rc == 0) {
data->raw = data->sample_buffer;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
path &= ~LL_ADC_PATH_INTERNAL_VREFINT);
unlock:
pm_device_runtime_put(data->adc);
k_mutex_unlock(&data->mutex);
return rc;
}
static int stm32_vref_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct stm32_vref_data *data = dev->data;
const struct stm32_vref_config *cfg = dev->config;
int32_t vref;
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
if (data->raw == 0) {
LOG_ERR("Raw ADC value is zero");
return -ENODATA;
}
/*
* STM32H5X: accesses to flash RO region must be done with caching disabled.
*/
#if defined(CONFIG_SOC_SERIES_STM32H5X)
LL_ICACHE_Disable();
#endif /* CONFIG_SOC_SERIES_STM32H5X */
/* Calculate VREF+ using VREFINT bandgap voltage and calibration data */
#if defined(CONFIG_SOC_SERIES_STM32U5X)
/*
* The VREF CALIBRATION value is acquired on 14 bits
* and the data acquired is on 12 bits
* since the adc_sequence.resolution is 12
*/
vref = (cfg->cal_mv * (*cfg->cal_addr) >> 2) / data->raw;
#else
vref = cfg->cal_mv * (*cfg->cal_addr) / data->raw;
#endif /* CONFIG_SOC_SERIES_STM32H5X */
#if defined(CONFIG_SOC_SERIES_STM32H5X)
LL_ICACHE_Enable();
#endif /* CONFIG_SOC_SERIES_STM32H5X */
return sensor_value_from_milli(val, vref);
}
static const struct sensor_driver_api stm32_vref_driver_api = {
.sample_fetch = stm32_vref_sample_fetch,
.channel_get = stm32_vref_channel_get,
};
static int stm32_vref_init(const struct device *dev)
{
struct stm32_vref_data *data = dev->data;
struct adc_sequence *asp = &data->adc_seq;
k_mutex_init(&data->mutex);
if (!device_is_ready(data->adc)) {
LOG_ERR("Device %s is not ready", data->adc->name);
return -ENODEV;
}
*asp = (struct adc_sequence){
.channels = BIT(data->adc_cfg.channel_id),
.buffer = &data->sample_buffer,
.buffer_size = sizeof(data->sample_buffer),
.resolution = 12U,
};
return 0;
}
/**
* Verify that the ADC instance which this driver uses to measure internal
* voltage reference is enabled. On STM32 MCUs with more than one ADC, it is
* possible to compile this driver even if the ADC used for measurement is
* disabled. In such cases, fail build with an explicit error message.
*/
#if !DT_NODE_HAS_STATUS(DT_INST_IO_CHANNELS_CTLR(0), okay)
/* Use BUILD_ASSERT to get preprocessing on the message */
BUILD_ASSERT(0, "ADC '" DT_NODE_FULL_NAME(DT_INST_IO_CHANNELS_CTLR(0)) "' needed by "
"Vref sensor '" DT_NODE_FULL_NAME(DT_DRV_INST(0)) "' is not enabled");
/* To reduce noise in the compiler error log, do not attempt
* to instantiate device if the sensor's ADC is not enabled.
*/
#else
static struct stm32_vref_data stm32_vref_dev_data = {
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(0)),
.adc_base = (ADC_TypeDef *)DT_REG_ADDR(DT_INST_IO_CHANNELS_CTLR(0)),
.adc_cfg = {.gain = ADC_GAIN_1,
.reference = ADC_REF_INTERNAL,
.acquisition_time = ADC_ACQ_TIME_MAX,
.channel_id = DT_INST_IO_CHANNELS_INPUT(0),
.differential = 0},
};
static const struct stm32_vref_config stm32_vref_dev_config = {
.cal_addr = (uint16_t *)DT_INST_PROP(0, vrefint_cal_addr),
.cal_mv = DT_INST_PROP(0, vrefint_cal_mv),
};
SENSOR_DEVICE_DT_INST_DEFINE(0, stm32_vref_init, NULL, &stm32_vref_dev_data, &stm32_vref_dev_config,
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &stm32_vref_driver_api);
#endif /* !DT_NODE_HAS_STATUS(DT_INST_IO_CHANNELS_CTLR(0), okay) */
``` | /content/code_sandbox/drivers/sensor/st/stm32_vref/stm32_vref.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,443 |
```objective-c
/* vl53l1_platform.h - Zephyr customization of ST vl53l1x library. */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_PLATFORM_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_PLATFORM_H_
#include <string.h>
#include "vl53l1_ll_def.h"
#include "vl53l1_platform_log.h"
#include "vl53l1_platform_user_data.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Writes the supplied byte buffer to the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param pdata Pointer to uint8_t (byte) buffer containing the data to be written
* @param count Number of bytes in the supplied byte buffer
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WriteMulti(VL53L1_Dev_t *pdev, uint16_t index,
uint8_t *pdata, uint32_t count);
/**
* Reads the requested number of bytes from the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param pdata Pointer to the uint8_t (byte) buffer to store read data
* @param count Number of bytes to read
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_ReadMulti(VL53L1_Dev_t *pdev, uint16_t index,
uint8_t *pdata, uint32_t count);
/**
* Writes a single byte to the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param data Data value to write
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WrByte(VL53L1_Dev_t *pdev, uint16_t index, uint8_t data);
/**
* Writes a single word (16-bit unsigned) to the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param data Data value write
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WrWord(VL53L1_Dev_t *pdev, uint16_t index, uint16_t data);
/**
* Writes a single dword (32-bit unsigned) to the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param data Data value to write
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WrDWord(VL53L1_Dev_t *pdev, uint16_t index, uint32_t data);
/**
* Reads a single byte from the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index
* @param pdata Pointer to uint8_t data value
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_RdByte(VL53L1_Dev_t *pdev, uint16_t index, uint8_t *pdata);
/**
* Reads a single word (16-bit unsigned) from the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param pdata Pointer to uint16_t data value
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_RdWord(VL53L1_Dev_t *pdev, uint16_t index, uint16_t *pdata);
/**
* Reads a single double word (32-bit unsigned) from the device
* @param pdev Pointer to device structure (device handle)
* @param index Register index value
* @param pdata Pointer to uint32_t data value
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_RdDWord(VL53L1_Dev_t *pdev, uint16_t index, uint32_t *pdata);
/**
* Implements a programmable wait in us
* @param pdev Pointer to device structure (device handle)
* @param wait_us Integer wait in micro seconds
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us);
/**
* Implements a programmable wait in ms
* @param pdev Pointer to device structure (device handle)
* @param wait_ms Integer wait in milliseconds
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms);
/**
* Gets current system tick count in [ms]
* @param Pointer to current time in [ms]
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_GetTickCount(uint32_t *ptime_ms);
/**
* Register "wait for value" polling routine
* @param dev Pointer to device structure (device handle)
* @param timeout Timeout in [ms]
* @param i Register index value
* @param val Value to wait for
* @param mask Mask to be applied before comparison with value
* @param delay Polling delay between each read transaction in [ms]
* @return VL53L1_ERROR_NONE Success
* @return "Other error code" See ::VL53L1_Error
*/
VL53L1_Error VL53L1_WaitValueMaskEx(VL53L1_Dev_t *dev, uint32_t timeout, uint16_t i, uint8_t val,
uint8_t mask, uint32_t delay);
#ifdef __cplusplus
}
#endif
#endif
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,460 |
```objective-c
/* vl53l1x_platform_log.h - Zephyr customization of ST vl53l1x library. */
/*
*
*/
#ifndef _VL53L1_PLATFORM_LOG_H_
#define _VL53L1_PLATFORM_LOG_H_
#ifdef VL53L1_LOG_ENABLE
#include "vl53l1_platform_user_config.h"
#ifdef _MSC_VER
# define EWOKPLUS_EXPORTS __declspec(dllexport)
#else
# define EWOKPLUS_EXPORTS
#endif
#include "vl53l1_types.h"
#ifdef __cplusplus
extern "C" {
#endif
#include <time.h>
/**
* @brief Set the level, output and specific functions for module logging.
*
*
* @param filename - full path of output log file, NULL for print to stdout
*
* @param modules - Module or None or All to trace
* VL53L1_TRACE_MODULE_NONE
* VL53L1_TRACE_MODULE_API
* VL53L1_TRACE_MODULE_CORE
* VL53L1_TRACE_MODULE_TUNING
* VL53L1_TRACE_MODULE_CHARACTERISATION
* VL53L1_TRACE_MODULE_PLATFORM
* VL53L1_TRACE_MODULE_ALL
*
* @param level - trace level
* VL53L1_TRACE_LEVEL_NONE
* VL53L1_TRACE_LEVEL_ERRORS
* VL53L1_TRACE_LEVEL_WARNING
* VL53L1_TRACE_LEVEL_INFO
* VL53L1_TRACE_LEVEL_DEBUG
* VL53L1_TRACE_LEVEL_ALL
* VL53L1_TRACE_LEVEL_IGNORE
*
* @param functions - function level to trace;
* VL53L1_TRACE_FUNCTION_NONE
* VL53L1_TRACE_FUNCTION_I2C
* VL53L1_TRACE_FUNCTION_ALL
*
* @return status - always VL53L1_ERROR_NONE
*
*/
#define VL53L1_TRACE_LEVEL_NONE 0x00000000
#define VL53L1_TRACE_LEVEL_ERRORS 0x00000001
#define VL53L1_TRACE_LEVEL_WARNING 0x00000002
#define VL53L1_TRACE_LEVEL_INFO 0x00000004
#define VL53L1_TRACE_LEVEL_DEBUG 0x00000008
#define VL53L1_TRACE_LEVEL_ALL 0x00000010
#define VL53L1_TRACE_LEVEL_IGNORE 0x00000020
#define VL53L1_TRACE_FUNCTION_NONE 0x00000000
#define VL53L1_TRACE_FUNCTION_I2C 0x00000001
#define VL53L1_TRACE_FUNCTION_ALL 0x7fffffff
#define VL53L1_TRACE_MODULE_NONE 0x00000000
#define VL53L1_TRACE_MODULE_API 0x00000001
#define VL53L1_TRACE_MODULE_CORE 0x00000002
#define VL53L1_TRACE_MODULE_PROTECTED 0x00000004
#define VL53L1_TRACE_MODULE_HISTOGRAM 0x00000008
#define VL53L1_TRACE_MODULE_REGISTERS 0x00000010
#define VL53L1_TRACE_MODULE_PLATFORM 0x00000020
#define VL53L1_TRACE_MODULE_NVM 0x00000040
#define VL53L1_TRACE_MODULE_CALIBRATION_DATA 0x00000080
#define VL53L1_TRACE_MODULE_NVM_DATA 0x00000100
#define VL53L1_TRACE_MODULE_HISTOGRAM_DATA 0x00000200
#define VL53L1_TRACE_MODULE_RANGE_RESULTS_DATA 0x00000400
#define VL53L1_TRACE_MODULE_XTALK_DATA 0x00000800
#define VL53L1_TRACE_MODULE_OFFSET_DATA 0x00001000
#define VL53L1_TRACE_MODULE_DATA_INIT 0x00002000
#define VL53L1_TRACE_MODULE_REF_SPAD_CHAR 0x00004000
#define VL53L1_TRACE_MODULE_SPAD_RATE_MAP 0x00008000
#ifdef PAL_EXTENDED
#define VL53L1_TRACE_MODULE_SPAD 0x01000000
#define VL53L1_TRACE_MODULE_FMT 0x02000000
#define VL53L1_TRACE_MODULE_UTILS 0x04000000
#define VL53L1_TRACE_MODULE_BENCH_FUNCS 0x08000000
#endif
#define VL53L1_TRACE_MODULE_CUSTOMER_API 0x40000000
#define VL53L1_TRACE_MODULE_ALL 0x7fffffff
extern uint32_t _trace_level;
/*
* NOTE: dynamically exported if we enable logging.
* this way, Python interfaces can access this function, but we don't
* need to include it in the .def files.
*/
EWOKPLUS_EXPORTS int8_t VL53L1_trace_config(
char *filename,
uint32_t modules,
uint32_t level,
uint32_t functions);
/**
* @brief Print trace module function.
*
* @param module - ??
* @param level - ??
* @param function - ??
* @param format - ??
*
*/
EWOKPLUS_EXPORTS void VL53L1_trace_print_module_function(
uint32_t module,
uint32_t level,
uint32_t function,
const char *format, ...);
/**
* @brief Get global _trace_functions parameter
*
* @return _trace_functions
*/
uint32_t VL53L1_get_trace_functions(void);
/**
* @brief Set global _trace_functions parameter
*
* @param[in] function : new function code
*/
void VL53L1_set_trace_functions(uint32_t function);
/*
* @brief Returns the current system tick count in [ms]
*
* @return time_ms : current time in [ms]
*
*/
uint32_t VL53L1_clock(void);
#define LOG_GET_TIME() \
((int)VL53L1_clock())
#define _LOG_TRACE_PRINT(module, level, function, ...) \
VL53L1_trace_print_module_function(module, level, function, ##__VA_ARGS__);
#define _LOG_FUNCTION_START(module, fmt, ...) \
VL53L1_trace_print_module_function(module, _trace_level, VL53L1_TRACE_FUNCTION_ALL,\
"%6ld <S> %s "fmt"\n", LOG_GET_TIME(), __func__, ##__VA_ARGS__);
#define _LOG_FUNCTION_END(module, status, ...)\
VL53L1_trace_print_module_function(module, _trace_level, VL53L1_TRACE_FUNCTION_ALL,\
"%6ld <E> %s %d\n", LOG_GET_TIME(), __func__, (int)status, ##__VA_ARGS__)
#define _LOG_FUNCTION_END_FMT(module, status, fmt, ...)\
VL53L1_trace_print_module_function(module, _trace_level, VL53L1_TRACE_FUNCTION_ALL,\
"%6ld <E> %s %d "fmt"\n", LOG_GET_TIME(), __func__, (int)status, ##__VA_ARGS__)
#define _LOG_GET_TRACE_FUNCTIONS()\
VL53L1_get_trace_functions()
#define _LOG_SET_TRACE_FUNCTIONS(functions)\
VL53L1_set_trace_functions(functions)
#define _LOG_STRING_BUFFER(x) char x[VL53L1_MAX_STRING_LENGTH]
#ifdef __cplusplus
}
#endif
#else /* VL53L1_LOG_ENABLE - no logging */
#define _LOG_TRACE_PRINT(module, level, function, ...)
#define _LOG_FUNCTION_START(module, fmt, ...)
#define _LOG_FUNCTION_END(module, status, ...)
#define _LOG_FUNCTION_END_FMT(module, status, fmt, ...)
#define _LOG_GET_TRACE_FUNCTIONS() 0
#define _LOG_SET_TRACE_FUNCTIONS(functions)
#define _LOG_STRING_BUFFER(x)
#endif /* VL53L1_LOG_ENABLE */
#endif /* _VL53L1_PLATFORM_LOG_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform_log.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,845 |
```c
/* vl53l1.c - Driver for ST VL53L1X time of flight sensor */
/*
*
*/
#define DT_DRV_COMPAT st_vl53l1x
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/logging/log.h>
#include "vl53l1_api.h"
#include "vl53l1_platform.h"
LOG_MODULE_REGISTER(VL53L1X, CONFIG_SENSOR_LOG_LEVEL);
struct vl53l1x_config {
struct i2c_dt_spec i2c;
#ifdef CONFIG_VL53L1X_XSHUT
struct gpio_dt_spec xshut;
#endif
#ifdef CONFIG_VL53L1X_INTERRUPT_MODE
struct gpio_dt_spec gpio1;
#endif
};
struct vl53l1x_data {
VL53L1_Dev_t vl53l1x;
VL53L1_RangingMeasurementData_t data;
VL53L1_DistanceModes distance_mode;
#ifdef CONFIG_VL53L1X_INTERRUPT_MODE
struct gpio_callback gpio_cb;
struct k_work work;
const struct device *dev;
#endif
};
static VL53L1_Error vl53l1x_read_sensor(struct vl53l1x_data *drv_data)
{
VL53L1_Error ret;
ret = VL53L1_GetRangingMeasurementData(&drv_data->vl53l1x, &drv_data->data);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("VL53L1_GetRangingMeasurementData return error (%d)", ret);
return ret;
}
ret = VL53L1_ClearInterruptAndStartMeasurement(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("VL53L1_ClearInterruptAndStartMeasurement return error (%d)", ret);
return ret;
}
return VL53L1_ERROR_NONE;
}
#ifdef CONFIG_VL53L1X_INTERRUPT_MODE
static void vl53l1x_worker(struct k_work *work)
{
struct vl53l1x_data *drv_data = CONTAINER_OF(work, struct vl53l1x_data, work);
vl53l1x_read_sensor(drv_data);
}
static void vl53l1x_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct vl53l1x_data *drv_data = CONTAINER_OF(cb, struct vl53l1x_data, gpio_cb);
k_work_submit(&drv_data->work);
}
static int vl53l1x_init_interrupt(const struct device *dev)
{
struct vl53l1x_data *drv_data = dev->data;
const struct vl53l1x_config *config = dev->config;
int ret;
drv_data->dev = dev;
if (!gpio_is_ready_dt(&config->gpio1)) {
LOG_ERR("%s: device %s is not ready", dev->name, config->gpio1.port->name);
return -ENODEV;
}
ret = gpio_pin_configure_dt(&config->gpio1, GPIO_INPUT | GPIO_PULL_UP);
if (ret < 0) {
LOG_ERR("[%s] Unable to configure GPIO interrupt", dev->name);
return -EIO;
}
gpio_init_callback(&drv_data->gpio_cb,
vl53l1x_gpio_callback,
BIT(config->gpio1.pin));
ret = gpio_add_callback(config->gpio1.port, &drv_data->gpio_cb);
if (ret < 0) {
LOG_ERR("Failed to set gpio callback!");
return -EIO;
}
drv_data->work.handler = vl53l1x_worker;
return 0;
}
#endif
static int vl53l1x_initialize(const struct device *dev)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
VL53L1_DeviceInfo_t vl53l1x_dev_info;
LOG_DBG("[%s] Initializing ", dev->name);
/* Pull XSHUT high to start the sensor */
#ifdef CONFIG_VL53L1X_XSHUT
const struct vl53l1x_config *const config = dev->config;
if (config->xshut.port) {
int gpio_ret = gpio_pin_set_dt(&config->xshut, 1);
if (gpio_ret < 0) {
LOG_ERR("[%s] Unable to set XSHUT gpio (error %d)", dev->name, gpio_ret);
return -EIO;
}
/* Boot duration is 1.2 ms max */
k_sleep(K_MSEC(2));
}
#endif
/* ONE TIME device initialization.
* To be called ONLY ONCE after device is brought out of reset
*/
ret = VL53L1_DataInit(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1X_DataInit return error (%d)", dev->name, ret);
return -ENOTSUP;
}
/* Do basic device init */
ret = VL53L1_StaticInit(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_StaticInit return error (%d)", dev->name, ret);
return -ENOTSUP;
}
/* Get info from sensor */
(void)memset(&vl53l1x_dev_info, 0, sizeof(VL53L1_DeviceInfo_t));
ret = VL53L1_GetDeviceInfo(&drv_data->vl53l1x, &vl53l1x_dev_info);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_GetDeviceInfo return error (%d)", dev->name, ret);
return -ENODEV;
}
LOG_DBG("[%s] VL53L1X_GetDeviceInfo returned %d", dev->name, ret);
LOG_DBG(" Device Name : %s", vl53l1x_dev_info.Name);
LOG_DBG(" Device Type : %s", vl53l1x_dev_info.Type);
LOG_DBG(" Device ID : %s", vl53l1x_dev_info.ProductId);
LOG_DBG(" ProductRevisionMajor : %d", vl53l1x_dev_info.ProductRevisionMajor);
LOG_DBG(" ProductRevisionMinor : %d", vl53l1x_dev_info.ProductRevisionMinor);
/* Set default distance mode */
drv_data->distance_mode = VL53L1_DISTANCEMODE_LONG;
ret = VL53L1_SetDistanceMode(&drv_data->vl53l1x, drv_data->distance_mode);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_SetDistanceMode return error (%d)", dev->name, ret);
return -EINVAL;
}
return 0;
}
/* Mapping is 1:1 with the API.
* From VL531X datasheet:
* | Max distance | Max distance in
* Mode | in dark (cm) | strong ambient light (cm)
* ----------------------------------------------------
* short | 136 | 135
* medium | 290 | 76
* long | 360 | 73
*/
static int vl53l1x_set_mode(const struct device *dev,
const struct sensor_value *val)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
switch (val->val1) {
/* short */
case 1:
/* medium */
case 2:
/* long */
case 3:
drv_data->distance_mode = val->val1;
break;
default:
drv_data->distance_mode = VL53L1_DISTANCEMODE_LONG;
break;
}
ret = VL53L1_SetDistanceMode(&drv_data->vl53l1x, drv_data->distance_mode);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_SetDistanceMode return error (%d)", dev->name, ret);
return -EINVAL;
}
return 0;
}
/*
* The ROI is a 16x16 grid.
* The bottom left is (0,0), top right is (15, 15), for
* a total of 256 squares (numbered 0 through 255).
* The default ROI is val1 = 240, val2 = 15 (the full grid).
* See UM2356 User Manual (VL531X API doc).
*/
static int vl53l1x_set_roi(const struct device *dev,
const struct sensor_value *val)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
if ((val->val1 < 0) ||
(val->val2 < 0) ||
(val->val1 > 255) ||
(val->val2 > 255) ||
(val->val2 >= val->val1)) {
return -EINVAL;
}
/* Map val to pUserROi */
VL53L1_UserRoi_t pUserROi = {
.TopLeftX = val->val1 % 16,
.TopLeftY = (uint8_t)(val->val1 / 16),
.BotRightX = val->val2 % 16,
.BotRightY = (uint8_t)(val->val2 / 16),
};
ret = VL53L1_SetUserROI(&drv_data->vl53l1x, &pUserROi);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_SetUserROI return error (%d)", dev->name, ret);
return -EINVAL;
}
return 0;
}
static int vl53l1x_get_mode(const struct device *dev,
struct sensor_value *val)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_DistanceModes mode;
VL53L1_Error ret;
ret = VL53L1_GetDistanceMode(&drv_data->vl53l1x, &mode);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_GetDistanceMode return error (%d)", dev->name, ret);
return -ENODATA;
}
/* Mapping is 1:1 with the API */
val->val1 = (int32_t)mode;
val->val2 = 0;
return 0;
}
static int vl53l1x_get_roi(const struct device *dev,
struct sensor_value *val)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
VL53L1_UserRoi_t pUserROi;
ret = VL53L1_GetUserROI(&drv_data->vl53l1x, &pUserROi);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_GetUserROI return error (%d)", dev->name, ret);
return -ENODATA;
}
/* Map pUserROi to val */
val->val1 = (int32_t)((16 * pUserROi.TopLeftY) + pUserROi.TopLeftX);
val->val2 = (int32_t)((16 * pUserROi.BotRightY) + pUserROi.BotRightX);
return 0;
}
static int vl53l1x_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
__ASSERT_NO_MSG((chan == SENSOR_CHAN_ALL)
|| (chan == SENSOR_CHAN_DISTANCE));
/* Will immediately stop current measurement */
ret = VL53L1_StopMeasurement(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("VL53L1_StopMeasurement return error (%d)", ret);
return -EBUSY;
}
#ifdef CONFIG_VL53L1X_INTERRUPT_MODE
const struct vl53l1x_config *config = dev->config;
ret = gpio_pin_interrupt_configure_dt(&config->gpio1, GPIO_INT_EDGE_TO_INACTIVE);
if (ret < 0) {
LOG_ERR("[%s] Unable to config interrupt", dev->name);
return -EIO;
}
#endif
ret = VL53L1_StartMeasurement(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_StartMeasurement return error (%d)", dev->name, ret);
return -EBUSY;
}
return 0;
}
static int vl53l1x_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct vl53l1x_data *drv_data = dev->data;
VL53L1_Error ret;
if (chan != SENSOR_CHAN_DISTANCE) {
return -ENOTSUP;
}
/* Calling VL53L1_WaitMeasurementDataReady regardless of using interrupt or
* polling method ensures user does not have to consider the time between
* calling fetch and get.
*/
ret = VL53L1_WaitMeasurementDataReady(&drv_data->vl53l1x);
if (ret != VL53L1_ERROR_NONE) {
LOG_ERR("[%s] VL53L1_WaitMeasurementDataReady return error (%d)", dev->name, ret);
return -EBUSY;
}
if (IS_ENABLED(CONFIG_VL53L1X_INTERRUPT_MODE) == 0) {
/* Using driver poling mode */
ret = vl53l1x_read_sensor(drv_data);
if (ret != VL53L1_ERROR_NONE) {
return -ENODATA;
}
}
val->val1 = (int32_t)(drv_data->data.RangeMilliMeter);
/* RangeFractionalPart not implemented in API */
val->val2 = 0;
return 0;
}
static int vl53l1x_attr_get(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
struct sensor_value *val)
{
__ASSERT_NO_MSG(chan == SENSOR_CHAN_DISTANCE);
if (attr == SENSOR_ATTR_CONFIGURATION) {
vl53l1x_get_mode(dev, val);
} else if (attr == SENSOR_ATTR_CALIB_TARGET) {
vl53l1x_get_roi(dev, val);
} else {
return -ENOTSUP;
}
return 0;
}
static int vl53l1x_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
__ASSERT_NO_MSG(chan == SENSOR_CHAN_DISTANCE);
if (attr == SENSOR_ATTR_CONFIGURATION) {
vl53l1x_set_mode(dev, val);
} else if (attr == SENSOR_ATTR_CALIB_TARGET) {
vl53l1x_set_roi(dev, val);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api vl53l1x_api_funcs = {
.sample_fetch = vl53l1x_sample_fetch,
.channel_get = vl53l1x_channel_get,
.attr_get = vl53l1x_attr_get,
.attr_set = vl53l1x_attr_set,
};
static int vl53l1x_init(const struct device *dev)
{
int ret = 0;
struct vl53l1x_data *drv_data = dev->data;
const struct vl53l1x_config *config = dev->config;
/* Initialize the HAL i2c peripheral */
drv_data->vl53l1x.i2c = &config->i2c;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus is not ready");
return -ENODEV;
}
/* Configure gpio connected to VL53L1X's XSHUT pin to
* allow deepest sleep mode
*/
#ifdef CONFIG_VL53L1X_XSHUT
if (config->xshut.port) {
ret = gpio_pin_configure_dt(&config->xshut, GPIO_OUTPUT);
if (ret < 0) {
LOG_ERR("[%s] Unable to configure GPIO as output", dev->name);
return -EIO;
}
}
#endif
#ifdef CONFIG_VL53L1X_INTERRUPT_MODE
if (config->gpio1.port) {
ret = vl53l1x_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt!");
return -EIO;
}
}
#endif
ret = vl53l1x_initialize(dev);
if (ret) {
return ret;
}
LOG_DBG("[%s] Initialized", dev->name);
return 0;
}
#define VL53L1X_INIT(i) \
static const struct vl53l1x_config vl53l1x_config_##i = { \
.i2c = I2C_DT_SPEC_INST_GET(i), \
IF_ENABLED(CONFIG_VL53L1X_XSHUT, ( \
.xshut = GPIO_DT_SPEC_INST_GET_OR(i, xshut_gpios, { 0 }),)) \
IF_ENABLED(CONFIG_VL53L1X_INTERRUPT_MODE, ( \
.gpio1 = GPIO_DT_SPEC_INST_GET_OR(i, int_gpios, { 0 }),)) \
}; \
\
static struct vl53l1x_data vl53l1x_data_##i; \
\
SENSOR_DEVICE_DT_INST_DEFINE(i, \
vl53l1x_init, \
NULL, \
&vl53l1x_data_##i, \
&vl53l1x_config_##i, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&vl53l1x_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(VL53L1X_INIT)
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,936 |
```c
/* vl53l1_platform.c - Zephyr customization of ST vl53l1x library.
*/
/*
*
*/
#include "vl53l1_platform.h"
#include "vl53l1_platform_log.h"
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include <zephyr/sys/byteorder.h>
LOG_MODULE_DECLARE(VL53L1X, CONFIG_SENSOR_LOG_LEVEL);
VL53L1_Error VL53L1_WriteMulti(VL53L1_Dev_t *pdev, uint16_t reg,
uint8_t *pdata, uint32_t count)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
int32_t status_int = 0;
uint8_t buffer[count + 2];
/* To be able to write to the 16-bit registers/addresses on the vl53l1x */
buffer[1] = (uint8_t)(reg & 0x00ff);
buffer[0] = (uint8_t)((reg & 0xff00) >> 8);
memcpy(&buffer[2], pdata, count);
status_int = i2c_write_dt(pdev->i2c, buffer, count + 2);
if (status_int < 0) {
status = VL53L1_ERROR_CONTROL_INTERFACE;
LOG_ERR("Failed to write");
}
return status;
}
VL53L1_Error VL53L1_ReadMulti(VL53L1_Dev_t *pdev, uint16_t reg,
uint8_t *pdata, uint32_t count)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
int32_t status_int = 0;
reg = sys_cpu_to_be16(reg);
status_int = i2c_write_read_dt(pdev->i2c, (uint8_t *)(®), 2, pdata, count);
if (status_int < 0) {
status = VL53L1_ERROR_CONTROL_INTERFACE;
LOG_ERR("Failed to read");
return -EIO;
}
return status;
}
VL53L1_Error VL53L1_WrByte(VL53L1_Dev_t *pdev, uint16_t reg, uint8_t data)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
status = VL53L1_WriteMulti(pdev, reg, &data, 1);
return status;
}
VL53L1_Error VL53L1_WrWord(VL53L1_Dev_t *pdev, uint16_t reg, uint16_t data)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
data = sys_cpu_to_be16(data);
status = VL53L1_WriteMulti(pdev, reg, (uint8_t *)(&data), VL53L1_BYTES_PER_WORD);
return status;
}
VL53L1_Error VL53L1_WrDWord(VL53L1_Dev_t *pdev, uint16_t reg, uint32_t data)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
data = sys_cpu_to_be32(data);
status = VL53L1_WriteMulti(pdev, reg, (uint8_t *)(&data), VL53L1_BYTES_PER_DWORD);
return status;
}
VL53L1_Error VL53L1_RdByte(VL53L1_Dev_t *pdev, uint16_t reg, uint8_t *pdata)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
status = VL53L1_ReadMulti(pdev, reg, pdata, 1);
return status;
}
VL53L1_Error VL53L1_RdWord(VL53L1_Dev_t *pdev, uint16_t reg, uint16_t *pdata)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
status = VL53L1_ReadMulti(pdev, reg, (uint8_t *)pdata, 2);
*pdata = sys_be16_to_cpu(*pdata);
return status;
}
VL53L1_Error VL53L1_RdDWord(VL53L1_Dev_t *pdev, uint16_t reg, uint32_t *pdata)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
status = VL53L1_ReadMulti(pdev, reg, (uint8_t *)pdata, 4);
*pdata = sys_be32_to_cpu(*pdata);
return status;
}
VL53L1_Error VL53L1_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us)
{
k_sleep(K_USEC(wait_us));
return VL53L1_ERROR_NONE;
}
VL53L1_Error VL53L1_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms)
{
return VL53L1_WaitUs(pdev, wait_ms * 1000);
}
VL53L1_Error VL53L1_GetTickCount(uint32_t *ptick_count_ms)
{
*ptick_count_ms = k_uptime_get_32();
return VL53L1_ERROR_NONE;
}
VL53L1_Error VL53L1_WaitValueMaskEx(VL53L1_Dev_t *dev, uint32_t timeout, uint16_t i, uint8_t val,
uint8_t mask, uint32_t delay)
{
VL53L1_Error status = VL53L1_ERROR_NONE;
uint32_t start_time_ms = 0;
uint32_t current_time_ms = 0;
uint8_t byte_val = 0;
uint8_t found = 0;
/* calculate time limit in absolute time */
VL53L1_GetTickCount(&start_time_ms);
dev->new_data_ready_poll_duration_ms = 0;
/* wait until val is found, timeout reached on error occurred */
while ((status == VL53L1_ERROR_NONE) &&
(dev->new_data_ready_poll_duration_ms < timeout) &&
(found == 0)) {
status = VL53L1_RdByte(dev, i, &byte_val);
if ((byte_val & mask) == val) {
found = 1;
}
if ((status == VL53L1_ERROR_NONE) && (found == 0) && (delay > 0)) {
/* Allow for other threads to run */
status = VL53L1_WaitMs(dev, delay);
}
/* Update polling time (Compare difference rather than absolute to
* negate 32bit wrap around issue)
*/
VL53L1_GetTickCount(¤t_time_ms);
dev->new_data_ready_poll_duration_ms = current_time_ms - start_time_ms;
}
if (found == 0 && status == VL53L1_ERROR_NONE) {
status = VL53L1_ERROR_TIME_OUT;
}
return status;
}
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,478 |
```objective-c
/* vl53l1x_platform_user_config.h - Zephyr customization of ST vl53l1x library. */
/*
*
*/
#ifndef _VL53L1_PLATFORM_USER_CONFIG_H_
#define _VL53L1_PLATFORM_USER_CONFIG_H_
#define VL53L1_BYTES_PER_WORD 2
#define VL53L1_BYTES_PER_DWORD 4
/* Define polling delays */
#define VL53L1_BOOT_COMPLETION_POLLING_TIMEOUT_MS 500
#define VL53L1_RANGE_COMPLETION_POLLING_TIMEOUT_MS 2000
#define VL53L1_TEST_COMPLETION_POLLING_TIMEOUT_MS 60000
#define VL53L1_POLLING_DELAY_MS 1
/* Define LLD TuningParms Page Base Address
* - Part of Patch_AddedTuningParms_11761
*/
#define VL53L1_TUNINGPARM_PUBLIC_PAGE_BASE_ADDRESS 0x8000
#define VL53L1_TUNINGPARM_PRIVATE_PAGE_BASE_ADDRESS 0xC000
#define VL53L1_GAIN_FACTOR__STANDARD_DEFAULT 0x0800
/*!< Default standard ranging gain correction factor
* 1.11 format. 1.0 = 0x0800, 0.980 = 0x07D7
*/
#define VL53L1_OFFSET_CAL_MIN_EFFECTIVE_SPADS 0x0500
/*!< Lower Limit for the MM1 effective SPAD count during offset
* calibration Format 8.8 0x0500 -> 5.0 effective SPADs
*/
#define VL53L1_OFFSET_CAL_MAX_PRE_PEAK_RATE_MCPS 0x1900
/*!< Max Limit for the pre range peak rate during offset
* calibration Format 9.7 0x1900 -> 50.0 Mcps.
* If larger then in pile up
*/
#define VL53L1_OFFSET_CAL_MAX_SIGMA_MM 0x0040
/*!< Max sigma estimate limit during offset calibration
* Check applies to pre-range, mm1 and mm2 ranges
* Format 14.2 0x0040 -> 16.0mm.
*/
#define VL53L1_MAX_USER_ZONES 1
/*!< Max number of user Zones - maximal limitation from
* FW stream divide - value of 254
*/
#define VL53L1_MAX_RANGE_RESULTS 2
/*!< Allocates storage for return and reference restults */
#define VL53L1_MAX_STRING_LENGTH 512
#endif /* _VL53L1_PLATFORM_USER_CONFIG_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform_user_config.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 561 |
```unknown
# VL53L0X time of flight sensor configuration options
menuconfig VL53L1X
bool "VL53L1X time of flight sensor"
default y
depends on DT_HAS_ST_VL53L1X_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C
select HAS_STLIB
help
Enable driver for VL53L1X I2C-based time of flight sensor.
if VL53L1X
config VL53L1X_INTERRUPT_MODE
bool "Use interrupt mode for VL53L1X time of flight sensor"
default y
depends on GPIO
help
Enable interrupt mode for VL53L1X time of flight sensor. Otherwise,
the driver will use the polling method.
config VL53L1X_XSHUT
bool "Use xshut pin on VL53L1X time of flight sensor"
depends on GPIO
help
Enable to use the xshut pin on the VL53L1X. If not, the pin should be
connected to VDD.
endif # VL53L1X
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 234 |
```objective-c
/* vl53l1_platform_user_data.h - Zephyr customization of ST vl53l1x library. */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_PLATFORM_USER_DATA_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_PLATFORM_USER_DATA_H_
#include "vl53l1_def.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @struct VL53L1_Dev_t
* @brief Generic PAL device type that does link between API and platform
* abstraction layer
*
*/
typedef struct {
/*!< Low Level Driver data structure */
VL53L1_DevData_t Data;
/*!< New data ready poll duration in ms - for debug */
uint32_t new_data_ready_poll_duration_ms;
/*!< I2C device handle */
const struct i2c_dt_spec *i2c;
} VL53L1_Dev_t;
/**
* @brief Declare the device Handle as a pointer of the structure @a VL53L1_Dev_t.
*
*/
typedef VL53L1_Dev_t *VL53L1_DEV;
/**
* @def VL53L1PALDevDataGet
* @brief Get ST private structure @a VL53L1_DevData_t data access
*
* @param Dev Device Handle
* @param field ST structure field name
* It maybe used and as real data "ref" not just as "get" for sub-structure item
* like PALDevDataGet(FilterData.field)[i] or
* PALDevDataGet(FilterData.MeasurementIndex)++
*/
#define VL53L1DevDataGet(Dev, field) (Dev->Data.field)
/**
* @def VL53L1PALDevDataSet(Dev, field, data)
* @brief Set ST private structure @a VL53L1_DevData_t data field
* @param Dev Device Handle
* @param field ST structure field name
* @param data Data to be set
*/
#define VL53L1DevDataSet(Dev, field, data) ((Dev->Data.field) = (data))
/**
* @def VL53L1DevStructGetLLDriverHandle
* @brief Get LL Driver handle @a VL53L0_Dev_t data access
*
* @param Dev Device Handle
*/
#define VL53L1DevStructGetLLDriverHandle(Dev) (&Dev->Data.LLData)
/**
* @def VL53L1DevStructGetLLResultsHandle
* @brief Get LL Results handle @a VL53L0_Dev_t data access
*
* @param Dev Device Handle
*/
#define VL53L1DevStructGetLLResultsHandle(Dev) (&Dev->Data.llresults)
#ifdef __cplusplus
}
#endif
#endif /*ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_PLATFORM_USER_DATA_H_*/
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform_user_data.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 626 |
```objective-c
/* vl53l1_types.h - Zephyr customization of ST vl53l1x library, basic type definition. */
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_TYPES_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_TYPES_H_
/* Zephyr provides stdint.h and stddef.h, so this is enough to include it.
* If it was not the case, we would defined here all signed and unsigned
* basic types...
*/
#include <stdint.h>
#include <stddef.h>
#ifndef NULL
#error "Error NULL definition should be done. Please add required include "
#endif
/** use where fractional values are expected
*
* Given a floating point value f it's .16 bit point is (int)(f*(1<<16))
*/
typedef uint32_t FixPoint1616_t;
#endif /* ZEPHYR_DRIVERS_SENSOR_VL53L1X_VL53L1_TYPES_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_types.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 214 |
```objective-c
/* vl53l1x_platform_user_defines.h - Zephyr customization of ST vl53l1x library. */
/*
*
*/
#ifndef _VL53L1_PLATFORM_USER_DEFINES_H_
#define _VL53L1_PLATFORM_USER_DEFINES_H_
#ifdef __cplusplus
extern "C"
{
#endif
/**
* @file vl53l1_platform_user_defines.h
*
* @brief All end user OS/platform/application definitions
*/
/**
* @def do_division_u
* @brief customer supplied division operation - 64-bit unsigned
*
* @param dividend unsigned 64-bit numerator
* @param divisor unsigned 64-bit denominator
*/
#define do_division_u(dividend, divisor) (dividend / divisor)
/**
* @def do_division_s
* @brief customer supplied division operation - 64-bit signed
*
* @param dividend signed 64-bit numerator
* @param divisor signed 64-bit denominator
*/
#define do_division_s(dividend, divisor) (dividend / divisor)
/**
* @def WARN_OVERRIDE_STATUS
* @brief customer supplied macro to optionally output info when a specific
error has been overridden with success within the EwokPlus driver
*
* @param __X__ the macro which enabled the suppression
*/
#define WARN_OVERRIDE_STATUS(__X__)\
trace_print(VL53L1_TRACE_LEVEL_WARNING, #__X__);
#ifdef _MSC_VER
#define DISABLE_WARNINGS() { \
__pragma(warning(push)); \
__pragma(warning(disable:4127)); \
}
#define ENABLE_WARNINGS() { \
__pragma(warning(pop)); \
}
#else
#define DISABLE_WARNINGS()
#define ENABLE_WARNINGS()
#endif
#ifdef __cplusplus
}
#endif
#endif
``` | /content/code_sandbox/drivers/sensor/st/vl53l1x/vl53l1_platform_user_defines.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 366 |
```unknown
menuconfig LPS22HB
bool "LPS22HB pressure and temperature"
default y
depends on DT_HAS_ST_LPS22HB_PRESS_ENABLED
select I2C
help
Enable driver for LPS22HB I2C-based pressure and temperature
sensor.
config LPS22HB_SAMPLING_RATE
int "Output data rate"
default 25
depends on LPS22HB
help
Sensor output data rate expressed in samples per second.
Data rates supported by the chip are 1, 10, 25, 50, 75.
``` | /content/code_sandbox/drivers/sensor/st/lps22hb/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 124 |
```c
/* lps22hb.c - Driver for LPS22HB pressure and temperature sensor */
/*
*
*/
#define DT_DRV_COMPAT st_lps22hb_press
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lps22hb.h"
LOG_MODULE_REGISTER(LPS22HB, CONFIG_SENSOR_LOG_LEVEL);
static inline int lps22hb_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lps22hb_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LPS22HB_REG_CTRL_REG1,
LPS22HB_MASK_CTRL_REG1_ODR,
odr << LPS22HB_SHIFT_CTRL_REG1_ODR);
}
static int lps22hb_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct lps22hb_data *data = dev->data;
const struct lps22hb_config *config = dev->config;
uint8_t out[5];
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
if (i2c_burst_read_dt(&config->i2c, LPS22HB_REG_PRESS_OUT_XL,
out, 5) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
data->sample_press = (int32_t)((uint32_t)(out[0]) |
((uint32_t)(out[1]) << 8) |
((uint32_t)(out[2]) << 16));
data->sample_temp = (int16_t)((uint16_t)(out[3]) |
((uint16_t)(out[4]) << 8));
return 0;
}
static inline void lps22hb_press_convert(struct sensor_value *val,
int32_t raw_val)
{
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void lps22hb_temp_convert(struct sensor_value *val,
int16_t raw_val)
{
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = ((int32_t)raw_val % 100) * 10000;
}
static int lps22hb_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lps22hb_data *data = dev->data;
if (chan == SENSOR_CHAN_PRESS) {
lps22hb_press_convert(val, data->sample_press);
} else if (chan == SENSOR_CHAN_AMBIENT_TEMP) {
lps22hb_temp_convert(val, data->sample_temp);
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lps22hb_api_funcs = {
.sample_fetch = lps22hb_sample_fetch,
.channel_get = lps22hb_channel_get,
};
static int lps22hb_init_chip(const struct device *dev)
{
const struct lps22hb_config *config = dev->config;
uint8_t chip_id;
if (i2c_reg_read_byte_dt(&config->i2c, LPS22HB_REG_WHO_AM_I,
&chip_id) < 0) {
LOG_DBG("Failed reading chip id");
goto err_poweroff;
}
if (chip_id != LPS22HB_VAL_WHO_AM_I) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
if (lps22hb_set_odr_raw(dev, LPS22HB_DEFAULT_SAMPLING_RATE) < 0) {
LOG_DBG("Failed to set sampling rate");
goto err_poweroff;
}
if (i2c_reg_update_byte_dt(&config->i2c, LPS22HB_REG_CTRL_REG1,
LPS22HB_MASK_CTRL_REG1_BDU,
(1 << LPS22HB_SHIFT_CTRL_REG1_BDU)) < 0) {
LOG_DBG("Failed to set BDU");
goto err_poweroff;
}
return 0;
err_poweroff:
return -EIO;
}
static int lps22hb_init(const struct device *dev)
{
const struct lps22hb_config * const config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
if (lps22hb_init_chip(dev) < 0) {
LOG_DBG("Failed to initialize chip");
return -EIO;
}
return 0;
}
#define LPS22HB_DEFINE(inst) \
static struct lps22hb_data lps22hb_data_##inst; \
\
static const struct lps22hb_config lps22hb_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lps22hb_init, NULL, \
&lps22hb_data_##inst, &lps22hb_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lps22hb_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(LPS22HB_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lps22hb/lps22hb.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,250 |
```objective-c
/* sensor_lps25hb.h - header file for LPS22HB pressure and temperature
* sensor driver
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LPS22HB_LPS22HB_H_
#define ZEPHYR_DRIVERS_SENSOR_LPS22HB_LPS22HB_H_
#include <stdint.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/util.h>
#define LPS22HB_REG_WHO_AM_I 0x0F
#define LPS22HB_VAL_WHO_AM_I 0xB1
#define LPS22HB_REG_INTERRUPT_CFG 0x0B
#define LPS22HB_MASK_INTERRUPT_CFG_AUTORIFP BIT(7)
#define LPS22HB_SHIFT_INTERRUPT_CFG_AUTORIFP 7
#define LPS22HB_MASK_INTERRUPT_CFG_RESET_ARP BIT(6)
#define LPS22HB_SHIFT_INTERRUPT_CFG_RESET_ARP 6
#define LPS22HB_MASK_INTERRUPT_CFG_AUTOZERO BIT(5)
#define LPS22HB_SHIFT_INTERRUPT_CFG_AUTOZERO 5
#define LPS22HB_MASK_INTERRUPT_CFG_RESET_AZ BIT(4)
#define LPS22HB_SHIFT_INTERRUPT_CFG_RESET_AZ 4
#define LPS22HB_MASK_INTERRUPT_CFG_DIFF_EN BIT(3)
#define LPS22HB_SHIFT_INTERRUPT_CFG_DIFF_EN 3
#define LPS22HB_MASK_INTERRUPT_CFG_LIR BIT(2)
#define LPS22HB_SHIFT_INTERRUPT_CFG_LIR 2
#define LPS22HB_MASK_INTERRUPT_CFG_PL_E BIT(1)
#define LPS22HB_SHIFT_INTERRUPT_CFG_PL_E 1
#define LPS22HB_MASK_INTERRUPT_CFG_PH_E BIT(0)
#define LPS22HB_SHIFT_INTERRUPT_CFG_PH_E 0
#define LPS22HB_REG_THS_P_L 0x0C
#define LPS22HB_REG_THS_P_H 0x0D
#define LPS22HB_REG_CTRL_REG1 0x10
#define LPS22HB_MASK_CTRL_REG1_ODR (BIT(6) | BIT(5) | BIT(4))
#define LPS22HB_SHIFT_CTRL_REG1_ODR 4
#define LPS22HB_MASK_CTRL_REG1_EN_LPFP BIT(3)
#define LPS22HB_SHIFT_CTRL_REG1_EN_LPFP 3
#define LPS22HB_MASK_CTRL_REG1_LPFP_CFG BIT(2)
#define LPS22HB_SHIFT_CTRL_REG1_LPFP_CFG 2
#define LPS22HB_MASK_CTRL_REG1_BDU BIT(1)
#define LPS22HB_SHIFT_CTRL_REG1_BDU 1
#define LPS22HB_MASK_CTRL_REG1_SIM BIT(0)
#define LPS22HB_SHIFT_CTRL_REG1_SIM 0
#define LPS22HB_REG_CTRL_REG2 0x11
#define LPS22HB_MASK_CTRL_REG2_BOOT BIT(7)
#define LPS22HB_SHIFT_CTRL_REG2_BOOT 7
#define LPS22HB_MASK_CTRL_REG2_FIFO_EN BIT(6)
#define LPS22HB_SHIFT_CTRL_REG2_FIFO_EN 6
#define LPS22HB_MASK_CTRL_REG2_STOP_ON_FTH BIT(5)
#define LPS22HB_SHIFT_CTRL_REG2_STOP_ON_FTH 5
#define LPS22HB_MASK_CTRL_REG2_IF_ADD_INC BIT(4)
#define LPS22HB_SHIFT_CTRL_REG2_IF_ADD_INC 4
#define LPS22HB_MASK_CTRL_REG2_I2C_DIS BIT(3)
#define LPS22HB_SHIFT_CTRL_REG2_I2C_DIS 3
#define LPS22HB_MASK_CTRL_REG2_SWRESET BIT(2)
#define LPS22HB_SHIFT_CTRL_REG2_SWRESET 2
#define LPS22HB_MASK_CTRL_REG2_ONE_SHOT BIT(0)
#define LPS22HB_SHIFT_CTRL_REG2_ONE_SHOT 0
#define LPS22HB_REG_CTRL_REG3 0x12
#define LPS22HB_MASK_CTRL_REG3_INT_H_L BIT(7)
#define LPS22HB_SHIFT_CTRL_REG3_INT_H_L 7
#define LPS22HB_MASK_CTRL_REG3_PP_OD BIT(6)
#define LPS22HB_SHIFT_CTRL_REG3_PP_OD 6
#define LPS22HB_MASK_CTRL_REG3_F_FSS5 BIT(5)
#define LPS22HB_SHIFT_CTRL_REG3_F_FFS5 5
#define LPS22HB_MASK_CTRL_REG3_F_FTH BIT(4)
#define LPS22HB_SHIFT_CTRL_REG3_F_FTH 4
#define LPS22HB_MASK_CTRL_REG3_F_OVR BIT(3)
#define LPS22HB_SHIFT_CTRL_REG3_F_OVR 3
#define LPS22HB_MASK_CTRL_REG3_DRDY BIT(2)
#define LPS22HB_SHIFT_CTRL_REG3_DRDY 2
#define LPS22HB_MASK_CTRL_REG3_INT_S (BIT(1) | BIT(0))
#define LPS22HB_SHIFT_CTRL_REG_INT_S 0
#define LPS22HB_REG_FIFO_CTRL 0x14
#define LPS22HB_MASK_FIFO_CTRL_F_MODE (BIT(7) | BIT(6) | BIT(5))
#define LPS22HB_SHIFT_FIFO_CTRL_F_MODE 5
#define LPS22HB_MASK_FIFO_CTRL_WTM (BIT(4) | BIT(3) | BIT(2) | \
BIT(2) | BIT(1) | BIT(0))
#define LPS22HB_SHIFT_FIFO_CTRL_WTM 0
#define LPS22HB_REG_REF_P_XL 0x15
#define LPS22HB_REG_REF_P_L 0x16
#define LPS22HB_REG_REF_P_H 0x17
#define LPS22HB_REG_RPDS_L 0x18
#define LPS22HB_REG_RPDS_H 0x19
#define LPS22HB_REG_RES_CONF 0x1A
#define LPS22HB_MASK_RES_CONF_LC_EN BIT(0)
#define LPS22HB_SHIFT_RES_CONF_LC_EN 0
#define LPS22HB_REG_INT_SOURCE 0x25
#define LPS22HB_MASK_INT_SOURCE_IA BIT(2)
#define LPS22HB_SHIFT_INT_SOURCE_IA 2
#define LPS22HB_MASK_INT_SOURCE_PL BIT(1)
#define LPS22HB_SHIFT_INT_SOURCE_PL 1
#define LPS22HB_MASK_INT_SOURCE_PH BIT(0)
#define LPS22HB_SHIFT_INT_SOURCE_PH 0
#define LPS22HB_REG_FIFO_STATUS 0x26
#define LPS22HB_MASK_FIFO_STATUS_FTH_FIFO BIT(7)
#define LPS22HB_SHIFT_FIFO_STATUS_FTH_FIFO 7
#define LPS22HB_MASK_FIFO_STATUS_OVR BIT(6)
#define LPS22HB_SHIFT_FIFO_STATUS_OVR 6
#define LPS22HB_MASK_FIFO_STATUS_EMPTY_FIFO BIT(5)
#define LPS22HB_SHIFT_FIFO_STATUS_EMPTY_FIFO 5
#define LPS22HB_MASK_FIFO_STATUS_FSS (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LPS22HB_SHIFT_FIFO_STATUS_FSS 0
#define LPS22HB_REG_STATUS 0x27
#define LPS22HB_MASK_STATUS_P_OR BIT(5)
#define LPS22HB_SHIFT_STATUS_P_OR 5
#define LPS22HB_MASK_STATUS_T_OR BIT(4)
#define LPS22HB_SHIFT_STATUS_T_OR 4
#define LPS22HB_MASK_STATUS_P_DA BIT(1)
#define LPS22HB_SHIFT_STATUS_P_DA 1
#define LPS22HB_MASK_STATUS_T_DA BIT(0)
#define LPS22HB_SHIFT_STATUS_T_DA 0
#define LPS22HB_REG_PRESS_OUT_XL 0x28
#define LPS22HB_REG_PRESS_OUT_L 0x29
#define LPS22HB_REG_PRESS_OUT_H 0x2A
#define LPS22HB_REG_TEMP_OUT_L 0x2B
#define LPS22HB_REG_TEMP_OUT_H 0x2C
#define LPS22HB_REG_LPFP_RES 0x33
#if CONFIG_LPS22HB_SAMPLING_RATE == 1
#define LPS22HB_DEFAULT_SAMPLING_RATE 1
#elif CONFIG_LPS22HB_SAMPLING_RATE == 10
#define LPS22HB_DEFAULT_SAMPLING_RATE 2
#elif CONFIG_LPS22HB_SAMPLING_RATE == 25
#define LPS22HB_DEFAULT_SAMPLING_RATE 3
#elif CONFIG_LPS22HB_SAMPLING_RATE == 50
#define LPS22HB_DEFAULT_SAMPLING_RATE 4
#elif CONFIG_LPS22HB_SAMPLING_RATE == 75
#define LPS22HB_DEFAULT_SAMPLING_RATE 5
#endif
struct lps22hb_config {
struct i2c_dt_spec i2c;
};
struct lps22hb_data {
int32_t sample_press;
int16_t sample_temp;
};
#endif /* ZEPHYR_DRIVERS_SENSOR_LPS22HB_LPS22HB_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lps22hb/lps22hb.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,978 |
```c
/* ST Microelectronics I3G4250D gyro driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_i3g4250d
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "i3g4250d.h"
#define RAW_TO_MICRODEGREEPERSEC 8750
LOG_MODULE_REGISTER(i3g4250d, CONFIG_SENSOR_LOG_LEVEL);
static int i3g4250d_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct i3g4250d_data *i3g4250d = dev->data;
int ret;
uint8_t reg;
int16_t buf[3] = { 0 };
if ((chan != SENSOR_CHAN_ALL) && (chan != SENSOR_CHAN_GYRO_XYZ)) {
return -ENOTSUP;
}
ret = i3g4250d_flag_data_ready_get(i3g4250d->ctx, ®);
if (ret < 0 || reg != 1) {
return ret;
}
ret = i3g4250d_angular_rate_raw_get(i3g4250d->ctx, buf);
if (ret < 0) {
LOG_ERR("Failed to fetch raw data sample!");
return ret;
}
memcpy(i3g4250d->angular_rate, buf, sizeof(i3g4250d->angular_rate));
return 0;
}
static inline void i3g4250d_convert(struct sensor_value *val, int16_t raw_value)
{
val->val1 = (int16_t)(raw_value * RAW_TO_MICRODEGREEPERSEC / 1000000LL);
val->val2 = (int16_t)(raw_value * RAW_TO_MICRODEGREEPERSEC) % 1000000LL;
}
static void i3g4250d_channel_convert(enum sensor_channel chan,
uint16_t *raw_xyz,
struct sensor_value *val)
{
uint8_t ofs_start, ofs_stop;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_GYRO_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_GYRO_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U;
ofs_stop = 2U;
break;
}
for (int i = ofs_start; i <= ofs_stop; i++) {
i3g4250d_convert(val++, raw_xyz[i]);
}
}
static int i3g4250d_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct i3g4250d_data *i3g4250d = dev->data;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
__fallthrough;
case SENSOR_CHAN_GYRO_Y:
__fallthrough;
case SENSOR_CHAN_GYRO_Z:
__fallthrough;
case SENSOR_CHAN_GYRO_XYZ:
i3g4250d_channel_convert(chan, i3g4250d->angular_rate, val);
return 0;
default:
return -ENOTSUP;
}
}
static i3g4250d_dr_t gyr_odr_to_reg(const struct sensor_value *val)
{
double odr = sensor_value_to_double(val);
i3g4250d_dr_t reg = I3G4250D_ODR_OFF;
if ((odr > 0.0) && (odr < 100.0)) {
reg = I3G4250D_ODR_SLEEP;
} else if ((odr >= 100.0) && (odr < 200.0)) {
reg = I3G4250D_ODR_100Hz;
} else if ((odr >= 200.0) && (odr < 400.0)) {
reg = I3G4250D_ODR_200Hz;
} else if ((odr >= 400.0) && (odr < 800.0)) {
reg = I3G4250D_ODR_400Hz;
} else if (odr >= 800.0) {
reg = I3G4250D_ODR_800Hz;
}
return reg;
}
static int i3g4250d_config_gyro(const struct device *dev,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct i3g4250d_data *i3g4250d = dev->data;
i3g4250d_dr_t dr_reg;
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
dr_reg = gyr_odr_to_reg(val);
return i3g4250d_data_rate_set(i3g4250d->ctx, dr_reg);
default:
LOG_ERR("Gyro attribute not supported");
break;
}
return -ENOTSUP;
}
static int i3g4250d_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_GYRO_XYZ:
return i3g4250d_config_gyro(dev, attr, val);
default:
LOG_ERR("attr_set() not supported on this channel %d.", chan);
break;
}
return -ENOTSUP;
}
static const struct sensor_driver_api i3g4250d_driver_api = {
.attr_set = i3g4250d_attr_set,
.sample_fetch = i3g4250d_sample_fetch,
.channel_get = i3g4250d_channel_get,
};
static int i3g4250d_init(const struct device *dev)
{
struct i3g4250d_data *i3g4250d = dev->data;
uint8_t wai;
int ret = 0;
ret = i3g4250d_spi_init(dev);
if (ret != 0) {
return ret;
}
ret = i3g4250d_device_id_get(i3g4250d->ctx, &wai);
if (ret != 0) {
return ret;
}
if (wai != I3G4250D_ID) {
LOG_ERR("Invalid chip ID: %02x", wai);
return -EIO;
}
/* Configure filtering chain - Gyroscope - High Pass */
ret = i3g4250d_filter_path_set(i3g4250d->ctx, I3G4250D_LPF1_HP_ON_OUT);
if (ret != 0) {
LOG_ERR("Failed setting filter path");
return ret;
}
ret = i3g4250d_hp_bandwidth_set(i3g4250d->ctx, I3G4250D_HP_LEVEL_3);
if (ret != 0) {
LOG_ERR("Failed setting high pass");
return ret;
}
/* Set Output data rate */
ret = i3g4250d_data_rate_set(i3g4250d->ctx, I3G4250D_ODR_100Hz);
if (ret != 0) {
LOG_ERR("Failed setting data rate");
return ret;
}
return 0;
}
#define I3G4250D_DEVICE_INIT(inst) \
static struct i3g4250d_data i3g4250d_data_##inst; \
static const struct i3g4250d_device_config i3g4250d_config_##inst = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
SPI_OP_MODE_MASTER | SPI_MODE_CPOL | \
SPI_MODE_CPHA | SPI_WORD_SET(8) | SPI_LINES_SINGLE, \
0), \
}; \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
i3g4250d_init, \
NULL, \
&i3g4250d_data_##inst, \
&i3g4250d_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&i3g4250d_driver_api);
DT_INST_FOREACH_STATUS_OKAY(I3G4250D_DEVICE_INIT)
``` | /content/code_sandbox/drivers/sensor/st/i3g4250d/i3g4250d.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,810 |
```unknown
# I3G4250D three-axis digital output gyroscope
config I3G4250D
bool "I3G4250D three-axis digital output gyroscope"
default y
depends on DT_HAS_ST_I3G4250D_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select SPI
select HAS_STMEMSC
select USE_STDC_I3G4250D
help
Enable driver for I3G4250D SPI-based three-axis motion tracking device.
``` | /content/code_sandbox/drivers/sensor/st/i3g4250d/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 106 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_i3g4250d
#include <zephyr/logging/log.h>
#include "i3g4250d.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define I3G4250D_SPI_READM (3 << 6) /* 0xC0 */
#define I3G4250D_SPI_WRITEM (1 << 6) /* 0x40 */
LOG_MODULE_DECLARE(i3g4250d, CONFIG_SENSOR_LOG_LEVEL);
static int i3g4250d_spi_read(const struct device *dev, uint8_t reg,
uint8_t *data, uint16_t len)
{
int ret;
const struct i3g4250d_device_config *config = dev->config;
uint8_t buffer_tx[2] = { reg | I3G4250D_SPI_READM, 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 = data,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2,
};
ret = spi_transceive_dt(&config->spi, &tx, &rx);
if (ret < 0) {
return ret;
}
return 0;
}
static int i3g4250d_spi_write(const struct device *dev, uint8_t reg,
uint8_t *data, uint16_t len)
{
int ret;
const struct i3g4250d_device_config *config = dev->config;
uint8_t buffer_tx[2] = { reg | I3G4250D_SPI_WRITEM, 0 };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = data,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2,
};
ret = spi_write_dt(&config->spi, &tx);
if (ret < 0) {
return ret;
}
return 0;
}
stmdev_ctx_t i3g4250d_spi_ctx = {
.read_reg = (stmdev_read_ptr) i3g4250d_spi_read,
.write_reg = (stmdev_write_ptr) i3g4250d_spi_write,
.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay,
};
int i3g4250d_spi_init(const struct device *dev)
{
struct i3g4250d_data *i3g4250d = dev->data;
const struct i3g4250d_device_config *cfg = dev->config;
if (!spi_is_ready_dt(&cfg->spi)) {
LOG_ERR("spi not ready");
return -ENODEV;
}
i3g4250d->ctx = &i3g4250d_spi_ctx;
i3g4250d->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/i3g4250d/i3g4250d_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 742 |
```objective-c
/* ST Microelectronics I3G4250D gyro driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_I3G4250D_I3G4250D_H_
#define ZEPHYR_DRIVERS_SENSOR_I3G4250D_I3G4250D_H_
#include <stdint.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "i3g4250d_reg.h"
struct i3g4250d_device_config {
struct spi_dt_spec spi;
};
/* sensor data */
struct i3g4250d_data {
int16_t angular_rate[3];
stmdev_ctx_t *ctx;
};
int i3g4250d_spi_init(const struct device *dev);
#endif /* __SENSOR_I3G4250D__ */
``` | /content/code_sandbox/drivers/sensor/st/i3g4250d/i3g4250d.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 207 |
```objective-c
/* ST Microelectronics LSM6DSO16IS 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM6DSO16IS_LSM6DSO16IS_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM6DSO16IS_LSM6DSO16IS_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lsm6dso16is_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LSM6DSO16IS_EN_BIT 0x01
#define LSM6DSO16IS_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define GAIN_UNIT_XL (61LL)
/* Gyro sensor sensitivity grain is 4.375 udps/LSB */
#define GAIN_UNIT_G (4375LL)
struct lsm6dso16is_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_pm;
uint8_t accel_odr;
uint8_t accel_range;
uint8_t gyro_pm;
uint8_t gyro_odr;
uint8_t gyro_range;
uint8_t drdy_pulsed;
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
const struct gpio_dt_spec gpio_drdy;
uint8_t drdy_pin;
bool trig_enabled;
#endif /* CONFIG_LSM6DSO16IS_TRIGGER */
};
union samples {
uint8_t raw[6];
struct {
int16_t axis[3];
};
} __aligned(2);
#define LSM6DSO16IS_SHUB_MAX_NUM_TARGETS 3
struct lsm6dso16is_data {
const struct device *dev;
int16_t acc[3];
uint32_t acc_gain;
int16_t gyro[3];
uint32_t gyro_gain;
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
int16_t temp_sample;
#endif
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
uint8_t ext_data[LSM6DSO16IS_SHUB_MAX_NUM_TARGETS][6];
uint16_t magn_gain;
struct hts221_data {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} hts221;
bool shub_inited;
uint8_t num_ext_dev;
uint8_t shub_ext[LSM6DSO16IS_SHUB_MAX_NUM_TARGETS];
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
uint16_t accel_freq;
uint8_t accel_fs;
uint16_t gyro_freq;
uint8_t gyro_fs;
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
sensor_trigger_handler_t handler_drdy_gyr;
const struct sensor_trigger *trig_drdy_gyr;
sensor_trigger_handler_t handler_drdy_temp;
const struct sensor_trigger *trig_drdy_temp;
#if defined(CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSO16IS_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSO16IS_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LSM6DSO16IS_TRIGGER */
};
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
int lsm6dso16is_shub_init(const struct device *dev);
int lsm6dso16is_shub_fetch_external_devs(const struct device *dev);
int lsm6dso16is_shub_get_idx(const struct device *dev, enum sensor_channel type);
int lsm6dso16is_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
int lsm6dso16is_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lsm6dso16is_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM6DSO16IS_LSM6DSO16IS_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso16is/lsm6dso16is.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,104 |
```c
/* ST Microelectronics LSM6DSO16IS 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso16is
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lsm6dso16is.h"
LOG_MODULE_DECLARE(LSM6DSO16IS, CONFIG_SENSOR_LOG_LEVEL);
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
/**
* lsm6dso16is_enable_t_int - TEMP enable selected int pin to generate interrupt
*/
static int lsm6dso16is_enable_t_int(const struct device *dev, int enable)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_pin_int2_route_t val;
int ret;
if (enable) {
int16_t buf;
/* dummy read: re-trigger interrupt */
lsm6dso16is_temperature_raw_get(ctx, &buf);
}
/* set interrupt (TEMP DRDY interrupt is only on INT2) */
if (cfg->drdy_pin == 1) {
return -EIO;
}
ret = lsm6dso16is_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_temp = 1;
return lsm6dso16is_pin_int2_route_set(ctx, val);
}
#endif
/**
* lsm6dso16is_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int lsm6dso16is_enable_xl_int(const struct device *dev, int enable)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dso16is_acceleration_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->drdy_pin == 1) {
lsm6dso16is_pin_int1_route_t val;
ret = lsm6dso16is_pin_int1_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lsm6dso16is_pin_int1_route_set(ctx, val);
} else {
lsm6dso16is_pin_int2_route_t val;
ret = lsm6dso16is_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lsm6dso16is_pin_int2_route_set(ctx, val);
}
return ret;
}
/**
* lsm6dso16is_enable_g_int - Gyro enable selected int pin to generate interrupt
*/
static int lsm6dso16is_enable_g_int(const struct device *dev, int enable)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dso16is_angular_rate_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->drdy_pin == 1) {
lsm6dso16is_pin_int1_route_t val;
ret = lsm6dso16is_pin_int1_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.drdy_gy = 1;
ret = lsm6dso16is_pin_int1_route_set(ctx, val);
} else {
lsm6dso16is_pin_int2_route_t val;
ret = lsm6dso16is_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_gy = 1;
ret = lsm6dso16is_pin_int2_route_set(ctx, val);
}
return ret;
}
/**
* lsm6dso16is_trigger_set - link external trigger to event data ready
*/
int lsm6dso16is_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lsm6dso16is_config *cfg = dev->config;
struct lsm6dso16is_data *lsm6dso16is = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
lsm6dso16is->handler_drdy_acc = handler;
lsm6dso16is->trig_drdy_acc = trig;
if (handler) {
return lsm6dso16is_enable_xl_int(dev, LSM6DSO16IS_EN_BIT);
} else {
return lsm6dso16is_enable_xl_int(dev, LSM6DSO16IS_DIS_BIT);
}
} else if (trig->chan == SENSOR_CHAN_GYRO_XYZ) {
lsm6dso16is->handler_drdy_gyr = handler;
lsm6dso16is->trig_drdy_gyr = trig;
if (handler) {
return lsm6dso16is_enable_g_int(dev, LSM6DSO16IS_EN_BIT);
} else {
return lsm6dso16is_enable_g_int(dev, LSM6DSO16IS_DIS_BIT);
}
}
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
else if (trig->chan == SENSOR_CHAN_DIE_TEMP) {
lsm6dso16is->handler_drdy_temp = handler;
lsm6dso16is->trig_drdy_temp = trig;
if (handler) {
return lsm6dso16is_enable_t_int(dev, LSM6DSO16IS_EN_BIT);
} else {
return lsm6dso16is_enable_t_int(dev, LSM6DSO16IS_DIS_BIT);
}
}
#endif
return -ENOTSUP;
}
/**
* lsm6dso16is_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lsm6dso16is_handle_interrupt(const struct device *dev)
{
struct lsm6dso16is_data *lsm6dso16is = dev->data;
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_status_reg_t status;
while (1) {
if (lsm6dso16is_status_reg_get(ctx, &status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
if ((status.xlda == 0) && (status.gda == 0)
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
&& (status.tda == 0)
#endif
) {
break;
}
if ((status.xlda) && (lsm6dso16is->handler_drdy_acc != NULL)) {
lsm6dso16is->handler_drdy_acc(dev, lsm6dso16is->trig_drdy_acc);
}
if ((status.gda) && (lsm6dso16is->handler_drdy_gyr != NULL)) {
lsm6dso16is->handler_drdy_gyr(dev, lsm6dso16is->trig_drdy_gyr);
}
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
if ((status.tda) && (lsm6dso16is->handler_drdy_temp != NULL)) {
lsm6dso16is->handler_drdy_temp(dev, lsm6dso16is->trig_drdy_temp);
}
#endif
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lsm6dso16is_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lsm6dso16is_data *lsm6dso16is =
CONTAINER_OF(cb, struct lsm6dso16is_data, gpio_cb);
const struct lsm6dso16is_config *cfg = lsm6dso16is->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD)
k_sem_give(&lsm6dso16is->gpio_sem);
#elif defined(CONFIG_LSM6DSO16IS_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lsm6dso16is->work);
#endif /* CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD
static void lsm6dso16is_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lsm6dso16is_data *lsm6dso16is = p1;
while (1) {
k_sem_take(&lsm6dso16is->gpio_sem, K_FOREVER);
lsm6dso16is_handle_interrupt(lsm6dso16is->dev);
}
}
#endif /* CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LSM6DSO16IS_TRIGGER_GLOBAL_THREAD
static void lsm6dso16is_work_cb(struct k_work *work)
{
struct lsm6dso16is_data *lsm6dso16is =
CONTAINER_OF(work, struct lsm6dso16is_data, work);
lsm6dso16is_handle_interrupt(lsm6dso16is->dev);
}
#endif /* CONFIG_LSM6DSO16IS_TRIGGER_GLOBAL_THREAD */
int lsm6dso16is_init_interrupt(const struct device *dev)
{
struct lsm6dso16is_data *lsm6dso16is = dev->data;
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD)
k_sem_init(&lsm6dso16is->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lsm6dso16is->thread, lsm6dso16is->thread_stack,
CONFIG_LSM6DSO16IS_THREAD_STACK_SIZE,
lsm6dso16is_thread, lsm6dso16is,
NULL, NULL, K_PRIO_COOP(CONFIG_LSM6DSO16IS_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&lsm6dso16is->thread, "lsm6dso16is");
#elif defined(CONFIG_LSM6DSO16IS_TRIGGER_GLOBAL_THREAD)
lsm6dso16is->work.handler = lsm6dso16is_work_cb;
#endif /* CONFIG_LSM6DSO16IS_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&lsm6dso16is->gpio_cb,
lsm6dso16is_gpio_callback,
BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(cfg->gpio_drdy.port, &lsm6dso16is->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* set data ready mode on int1/int2 */
LOG_DBG("drdy_pulsed is %d", (int)cfg->drdy_pulsed);
lsm6dso16is_data_ready_mode_t mode = cfg->drdy_pulsed ? LSM6DSO16IS_DRDY_PULSED :
LSM6DSO16IS_DRDY_LATCHED;
ret = lsm6dso16is_data_ready_mode_set(ctx, mode);
if (ret < 0) {
LOG_ERR("drdy_pulsed config error %d", (int)cfg->drdy_pulsed);
return ret;
}
return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso16is/lsm6dso16is_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,004 |
```unknown
# ST Microelectronics LSM6DSO16IS 6-axis IMU sensor driver
menuconfig LSM6DSO16IS
bool "LSM6DSO16IS I2C/SPI accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_LSM6DSO16IS_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSO16IS),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSO16IS),spi)
select HAS_STMEMSC
select USE_STDC_LSM6DSO16IS
help
Enable driver for LSM6DSO16IS accelerometer and gyroscope
sensor.
if LSM6DSO16IS
choice LSM6DSO16IS_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LSM6DSO16IS_TRIGGER_NONE
bool "No trigger"
config LSM6DSO16IS_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LSM6DSO16IS_TRIGGER
config LSM6DSO16IS_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LSM6DSO16IS_TRIGGER
endchoice
config LSM6DSO16IS_TRIGGER
bool
if LSM6DSO16IS_TRIGGER
config LSM6DSO16IS_THREAD_PRIORITY
int "Thread priority"
depends on LSM6DSO16IS_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LSM6DSO16IS_THREAD_STACK_SIZE
int "Thread stack size"
depends on LSM6DSO16IS_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # LSM6DSO16IS_TRIGGER
config LSM6DSO16IS_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config LSM6DSO16IS_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub. You can enable
a maximum of two external sensors (if more than two are enabled
the system would enumerate only the first two found)
if LSM6DSO16IS_SENSORHUB
config LSM6DSO16IS_EXT_LIS2MDL
bool "LIS2MDL as external sensor"
default y
config LSM6DSO16IS_EXT_LPS22HH
bool "LPS22HH as external sensor"
config LSM6DSO16IS_EXT_HTS221
bool "HTS221 as external sensor"
config LSM6DSO16IS_EXT_LPS22HB
bool "LPS22HB as external sensor"
config LSM6DSO16IS_EXT_LPS22DF
bool "LPS22DF as external sensor"
default y
endif # LSM6DSO16IS_SENSORHUB
endif # LSM6DSO16IS
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso16is/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 646 |
```c
/* ST Microelectronics LSM6DSO16IS 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso16is
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lsm6dso16is.h"
LOG_MODULE_REGISTER(LSM6DSO16IS, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t lsm6dso16is_odr_map[] = {0, 12, 26, 52, 104, 208, 416, 833,
1667, 3333, 6667};
static int lsm6dso16is_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso16is_odr_map); i++) {
if (freq <= lsm6dso16is_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lsm6dso16is_odr_to_freq_val(uint16_t odr)
{
/* for valid index, return value from map */
if (odr < ARRAY_SIZE(lsm6dso16is_odr_map)) {
return lsm6dso16is_odr_map[odr & 0xF];
}
/* invalid index, return last entry */
return lsm6dso16is_odr_map[ARRAY_SIZE(lsm6dso16is_odr_map) - 1];
}
static const uint16_t lsm6dso16is_accel_fs_map[] = {2, 16, 4, 8};
static int lsm6dso16is_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso16is_accel_fs_map); i++) {
if (range == lsm6dso16is_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static const uint16_t lsm6dso16is_gyro_fs_map[] = {250, 125, 500, 0, 1000, 0, 2000};
static const uint16_t lsm6dso16is_gyro_fs_sens[] = {2, 1, 4, 0, 8, 0, 16};
static int lsm6dso16is_gyro_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dso16is_gyro_fs_map); i++) {
if (range == lsm6dso16is_gyro_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static inline int lsm6dso16is_reboot(const struct device *dev)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso16is_boot_set(ctx, 1) < 0) {
return -EIO;
}
/* Wait sensor turn-on time as per datasheet */
k_sleep(K_MSEC(35)); /* turn-on time in ms */
return 0;
}
static int lsm6dso16is_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
if (lsm6dso16is_xl_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int lsm6dso16is_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
if (lsm6dso16is_xl_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = lsm6dso16is_odr_to_freq_val(odr);
return 0;
}
static int lsm6dso16is_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso16is_gy_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dso16is_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dso16is_gy_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dso16is_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dso16is_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dso16is_accel_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dso16is_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dso16is_data *data = dev->data;
fs = lsm6dso16is_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dso16is_accel_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = lsm6dso16is_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
return 0;
}
static int lsm6dso16is_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_hm_mode_t mode;
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dso16is_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso16is_accel_odr_set(dev, val->val1);
case SENSOR_ATTR_CONFIGURATION:
switch (val->val1) {
case 0: /* High Performance */
mode = LSM6DSO16IS_HIGH_PERFOMANCE_MODE_ENABLED;
break;
case 1: /* Low Power */
mode = LSM6DSO16IS_HIGH_PERFOMANCE_MODE_DISABLED;
break;
default:
return -EIO;
}
return lsm6dso16is_xl_hm_mode_set(ctx, mode);
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso16is_gyro_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dso16is_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dso16is_gyro_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dso16is_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dso16is_data *data = dev->data;
fs = lsm6dso16is_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dso16is_gyro_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_gain = (lsm6dso16is_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
static int lsm6dso16is_gyro_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_hm_mode_t mode;
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dso16is_gyro_range_set(dev, sensor_rad_to_degrees(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dso16is_gyro_odr_set(dev, val->val1);
case SENSOR_ATTR_CONFIGURATION:
switch (val->val1) {
case 0: /* High Performance */
mode = LSM6DSO16IS_HIGH_PERFOMANCE_MODE_ENABLED;
break;
case 1: /* Low Power */
mode = LSM6DSO16IS_HIGH_PERFOMANCE_MODE_DISABLED;
break;
default:
return -EIO;
}
return lsm6dso16is_xl_hm_mode_set(ctx, mode);
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso16is_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
struct lsm6dso16is_data *data = dev->data;
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm6dso16is_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm6dso16is_gyro_config(dev, chan, attr, val);
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
case SENSOR_CHAN_MAGN_XYZ:
case SENSOR_CHAN_PRESS:
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("shub not inited.");
return -ENOTSUP;
}
return lsm6dso16is_shub_config(dev, chan, attr, val);
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dso16is_sample_fetch_accel(const struct device *dev)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
if (lsm6dso16is_acceleration_raw_get(ctx, data->acc) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
static int lsm6dso16is_sample_fetch_gyro(const struct device *dev)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
if (lsm6dso16is_angular_rate_raw_get(ctx, data->gyro) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
static int lsm6dso16is_sample_fetch_temp(const struct device *dev)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
if (lsm6dso16is_temperature_raw_get(ctx, &data->temp_sample) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#endif
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
static int lsm6dso16is_sample_fetch_shub(const struct device *dev)
{
if (lsm6dso16is_shub_fetch_external_devs(dev) < 0) {
LOG_DBG("failed to read ext shub devices");
return -EIO;
}
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
static int lsm6dso16is_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
struct lsm6dso16is_data *data = dev->data;
#endif /* CONFIG_LSM6DSO16IS_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dso16is_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6dso16is_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dso16is_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm6dso16is_sample_fetch_accel(dev);
lsm6dso16is_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
lsm6dso16is_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
if (data->shub_inited) {
lsm6dso16is_sample_fetch_shub(dev);
}
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dso16is_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int lsm6dso16is_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso16is_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm6dso16is_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm6dso16is_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm6dso16is_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lsm6dso16is_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dso16is_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso16is_data *data)
{
return lsm6dso16is_accel_get_channel(chan, val, data, data->acc_gain);
}
static inline void lsm6dso16is_gyro_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in udps/LSB */
/* So, calculate value in 10 udps unit and then to rad/s */
dval = (int64_t)(raw_val) * sensitivity / 10;
sensor_10udegrees_to_rad(dval, val);
}
static inline int lsm6dso16is_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso16is_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm6dso16is_gyro_convert(val, data->gyro[0], sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
lsm6dso16is_gyro_convert(val, data->gyro[1], sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
lsm6dso16is_gyro_convert(val, data->gyro[2], sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
for (i = 0; i < 3; i++) {
lsm6dso16is_gyro_convert(val++, data->gyro[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dso16is_gyro_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso16is_data *data)
{
return lsm6dso16is_gyro_get_channel(chan, val, data, data->gyro_gain);
}
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
static void lsm6dso16is_gyro_channel_get_temp(struct sensor_value *val,
struct lsm6dso16is_data *data)
{
int32_t micro_c;
/* convert units to micro Celsius. Raw temperature samples are
* expressed in 256 LSB/deg_C units. And LSB output is 0 at 25 C.
*/
micro_c = (data->temp_sample * 1000000) / 256;
val->val1 = micro_c / 1000000 + 25;
val->val2 = micro_c % 1000000;
}
#endif
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
static inline void lsm6dso16is_magn_convert(struct sensor_value *val, int raw_val,
uint16_t sensitivity)
{
double dval;
/* Sensitivity is exposed in ugauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int lsm6dso16is_magn_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dso16is_data *data)
{
int16_t sample[3];
int idx;
idx = lsm6dso16is_shub_get_idx(data->dev, SENSOR_CHAN_MAGN_XYZ);
if (idx < 0) {
LOG_DBG("external magn not supported");
return -ENOTSUP;
}
sample[0] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
sample[1] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][2] |
(data->ext_data[idx][3] << 8)));
sample[2] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][4] |
(data->ext_data[idx][5] << 8)));
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm6dso16is_magn_convert(val, sample[0], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Y:
lsm6dso16is_magn_convert(val, sample[1], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Z:
lsm6dso16is_magn_convert(val, sample[2], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm6dso16is_magn_convert(val, sample[0], data->magn_gain);
lsm6dso16is_magn_convert(val + 1, sample[1], data->magn_gain);
lsm6dso16is_magn_convert(val + 2, sample[2], data->magn_gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dso16is_hum_convert(struct sensor_value *val,
struct lsm6dso16is_data *data)
{
float rh;
int16_t raw_val;
struct hts221_data *ht = &data->hts221;
int idx;
idx = lsm6dso16is_shub_get_idx(data->dev, SENSOR_CHAN_HUMIDITY);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
/* find relative humidty by linear interpolation */
rh = (ht->y1 - ht->y0) * raw_val + ht->x1 * ht->y0 - ht->x0 * ht->y1;
rh /= (ht->x1 - ht->x0);
/* convert humidity to integer and fractional part */
val->val1 = rh;
val->val2 = rh * 1000000;
}
static inline void lsm6dso16is_press_convert(struct sensor_value *val,
struct lsm6dso16is_data *data)
{
int32_t raw_val;
int idx;
idx = lsm6dso16is_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le32_to_cpu((int32_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8) |
(data->ext_data[idx][2] << 16)));
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void lsm6dso16is_temp_convert(struct sensor_value *val,
struct lsm6dso16is_data *data)
{
int16_t raw_val;
int idx;
idx = lsm6dso16is_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][3] |
(data->ext_data[idx][4] << 8)));
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int lsm6dso16is_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm6dso16is_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dso16is_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm6dso16is_gyro_channel_get(chan, val, data);
break;
#if defined(CONFIG_LSM6DSO16IS_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dso16is_gyro_channel_get_temp(val, data);
break;
#endif
#if defined(CONFIG_LSM6DSO16IS_SENSORHUB)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso16is_magn_get_channel(chan, val, data);
break;
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso16is_hum_convert(val, data);
break;
case SENSOR_CHAN_PRESS:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso16is_press_convert(val, data);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dso16is_temp_convert(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm6dso16is_driver_api = {
.attr_set = lsm6dso16is_attr_set,
#if CONFIG_LSM6DSO16IS_TRIGGER
.trigger_set = lsm6dso16is_trigger_set,
#endif
.sample_fetch = lsm6dso16is_sample_fetch,
.channel_get = lsm6dso16is_channel_get,
};
static int lsm6dso16is_init_chip(const struct device *dev)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *lsm6dso16is = dev->data;
uint8_t chip_id;
uint8_t odr, fs;
/* All registers except 0x01 are different between banks, including the WHO_AM_I
* register and the register used for a SW reset. If the lsm6dso16is wasn't on the user
* bank when it reset, then both the chip id check and the sw reset will fail unless we
* set the bank now.
*/
if (lsm6dso16is_mem_bank_set(ctx, LSM6DSO16IS_MAIN_MEM_BANK) < 0) {
LOG_DBG("Failed to set user bank");
return -EIO;
}
if (lsm6dso16is_device_id_get(ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (chip_id != LSM6DSO16IS_ID) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* reset device */
if (lsm6dso16is_software_reset(ctx) < 0) {
return -EIO;
}
fs = cfg->accel_range;
LOG_DBG("accel range is %d", fs);
if (lsm6dso16is_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return -EIO;
}
lsm6dso16is->acc_gain = lsm6dso16is_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
odr = cfg->accel_odr;
LOG_DBG("accel odr is %d", odr);
if (lsm6dso16is_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer odr %d", odr);
return -EIO;
}
fs = cfg->gyro_range;
LOG_DBG("gyro range is %d", fs);
if (lsm6dso16is_gyro_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set gyroscope range %d", fs);
return -EIO;
}
lsm6dso16is->gyro_gain = (lsm6dso16is_gyro_fs_sens[fs] * GAIN_UNIT_G);
odr = cfg->gyro_odr;
LOG_DBG("gyro odr is %d", odr);
lsm6dso16is->gyro_freq = lsm6dso16is_odr_to_freq_val(odr);
if (lsm6dso16is_gyro_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set gyroscope odr %d", odr);
return -EIO;
}
if (lsm6dso16is_block_data_update_set(ctx, 1) < 0) {
LOG_DBG("failed to set BDU mode");
return -EIO;
}
return 0;
}
static int lsm6dso16is_init(const struct device *dev)
{
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
const struct lsm6dso16is_config *cfg = dev->config;
#endif
struct lsm6dso16is_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (lsm6dso16is_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
if (cfg->trig_enabled) {
if (lsm6dso16is_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
#ifdef CONFIG_LSM6DSO16IS_SENSORHUB
data->shub_inited = true;
if (lsm6dso16is_shub_init(dev) < 0) {
LOG_INF("shub: no external chips found");
data->shub_inited = false;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LSM6DSO16IS driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LSM6DSO16IS_DEFINE_SPI() and
* LSM6DSO16IS_DEFINE_I2C().
*/
#define LSM6DSO16IS_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lsm6dso16is_init, \
NULL, \
&lsm6dso16is_data_##inst, \
&lsm6dso16is_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lsm6dso16is_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LSM6DSO16IS_TRIGGER
#define LSM6DSO16IS_CFG_IRQ(inst) \
.trig_enabled = true, \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, irq_gpios), \
.drdy_pin = DT_INST_PROP(inst, drdy_pin)
#else
#define LSM6DSO16IS_CFG_IRQ(inst)
#endif /* CONFIG_LSM6DSO16IS_TRIGGER */
#define LSM6DSO16IS_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LSM6DSO16IS_CONFIG_COMMON(inst) \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
.gyro_odr = DT_INST_PROP(inst, gyro_odr), \
.gyro_range = DT_INST_PROP(inst, gyro_range), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LSM6DSO16IS_CFG_IRQ(inst)), ())
#define LSM6DSO16IS_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lsm6dso16is_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LSM6DSO16IS_SPI_OP, \
0), \
}, \
LSM6DSO16IS_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LSM6DSO16IS_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lsm6dso16is_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LSM6DSO16IS_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LSM6DSO16IS_DEFINE(inst) \
static struct lsm6dso16is_data lsm6dso16is_data_##inst; \
static const struct lsm6dso16is_config lsm6dso16is_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LSM6DSO16IS_CONFIG_SPI(inst)), \
(LSM6DSO16IS_CONFIG_I2C(inst))); \
LSM6DSO16IS_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LSM6DSO16IS_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso16is/lsm6dso16is.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,793 |
```c
/* ST Microelectronics LSM6DSO16IS 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dso16is
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm6dso16is.h"
LOG_MODULE_DECLARE(LSM6DSO16IS, CONFIG_SENSOR_LOG_LEVEL);
static int lsm6dso16is_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static int lsm6dso16is_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static void lsm6dso16is_shub_enable(const struct device *dev, uint8_t enable);
/* ST HAL skips this register, only supports it via the slower lsm6dso16is_sh_status_get() */
static int32_t lsm6dso16is_sh_status_mainpage_get(stmdev_ctx_t *ctx,
lsm6dso16is_status_master_t *val)
{
return lsm6dso16is_read_reg(ctx, LSM6DSO16IS_STATUS_MASTER_MAINPAGE, (uint8_t *)val, 1);
}
/*
* LIS2MDL magn device specific part
*/
#ifdef CONFIG_LSM6DSO16IS_EXT_LIS2MDL
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_ODR_100HZ 0x0C
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int lsm6dso16is_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct lsm6dso16is_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_gain = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int lsm6dso16is_lis2mdl_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lis2mdl_map); odr++) {
if (freq <= lis2mdl_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lis2mdl_map)) {
LOG_DBG("shub: LIS2MDL freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 2);
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, &cfg, 1);
lsm6dso16is_shub_enable(dev, 1);
return 0;
}
static int lsm6dso16is_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 lsm6dso16is_lis2mdl_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_EXT_LIS2MDL */
/*
* HTS221 humidity device specific part
*/
#ifdef CONFIG_LSM6DSO16IS_EXT_HTS221
#define HTS221_AUTOINCREMENT BIT(7)
#define HTS221_REG_CTRL1 0x20
#define HTS221_ODR_1HZ 0x01
#define HTS221_BDU 0x04
#define HTS221_PD 0x80
#define HTS221_REG_CONV_START 0x30
static int lsm6dso16is_hts221_read_conv_data(const struct device *dev,
uint8_t i2c_addr)
{
struct lsm6dso16is_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 (lsm6dso16is_shub_read_target_reg(dev, i2c_addr,
(HTS221_REG_CONV_START + i) |
HTS221_AUTOINCREMENT,
&buf[i], len) < 0) {
LOG_DBG("shub: failed to read hts221 conv data");
return -EIO;
}
}
ht->y0 = buf[0] / 2;
ht->y1 = buf[1] / 2;
ht->x0 = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
ht->x1 = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
return 0;
}
static int lsm6dso16is_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &hum_cfg, 1);
return lsm6dso16is_hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int lsm6dso16is_hts221_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(hts221_map); odr++) {
if (freq <= hts221_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(hts221_map)) {
LOG_DBG("shub: HTS221 freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = odr | HTS221_BDU | HTS221_PD;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &cfg, 1);
lsm6dso16is_shub_enable(dev, 1);
return 0;
}
static int lsm6dso16is_hts221_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 lsm6dso16is_hts221_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: HTS221 attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_EXT_HTS221 */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int lsm6dso16is_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
lsm6dso16is_shub_write_target_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;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22HB */
/*
* LPS22HH baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22HH
#define LPS22HH_CTRL_REG1 0x10
#define LPS22HH_CTRL_REG2 0x11
#define LPS22HH_SW_RESET 0x04
#define LPS22HH_IF_ADD_INC 0x10
#define LPS22HH_ODR_10HZ 0x20
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
static int lsm6dso16is_lps22hh_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HH_SW_RESET;
lsm6dso16is_shub_write_target_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;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22HH_ODR_10HZ | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int lsm6dso16is_lps22hh_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22hh_map); odr++) {
if (freq <= lps22hh_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22hh_map)) {
LOG_DBG("shub: LPS22HH freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, &cfg, 1);
lsm6dso16is_shub_enable(dev, 1);
return 0;
}
static int lsm6dso16is_lps22hh_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 lsm6dso16is_lps22hh_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22HH attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22HH */
/*
* LPS22DF baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22DF
#define LPS22DF_CTRL_REG1 0x10
#define LPS22DF_CTRL_REG2 0x11
#define LPS22DF_SW_RESET 0x04
#define LPS22DF_BDU_EN 0x08
#define LPS22DF_EN_LPFP 0x10
#define LPS22DF_ODR_10HZ 0x18
#define LPS22DF_AVG_16 0x02
static int lsm6dso16is_lps22df_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22DF_SW_RESET;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG2, baro_cfg, 1);
k_busy_wait(50); /* turn-on time in us */
/* configure device */
baro_cfg[0] = LPS22DF_BDU_EN | LPS22DF_EN_LPFP;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22DF_ODR_10HZ | LPS22DF_AVG_16;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22df_map[] = {0, 1, 4, 10, 25, 50, 75, 100, 200};
static int lsm6dso16is_lps22df_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22df_map); odr++) {
if (freq <= lps22df_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22df_map)) {
LOG_DBG("shub: LPS22DF freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 3) | LPS22DF_AVG_16;
lsm6dso16is_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG1, &cfg, 1);
lsm6dso16is_shub_enable(dev, 1);
return 0;
}
static int lsm6dso16is_lps22df_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 lsm6dso16is_lps22df_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22DF attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22DF */
/* List of supported external sensors */
static struct lsm6dso16is_shub_slist {
enum sensor_channel type;
uint8_t i2c_addr[2];
uint8_t ext_i2c_addr;
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
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);
} lsm6dso16is_shub_slist[] = {
#ifdef CONFIG_LSM6DSO16IS_EXT_LIS2MDL
{
/* LIS2MDL */
.type = SENSOR_CHAN_MAGN_XYZ,
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (lsm6dso16is_lis2mdl_init),
.dev_conf = (lsm6dso16is_lis2mdl_conf),
},
#endif /* CONFIG_LSM6DSO16IS_EXT_LIS2MDL */
#ifdef CONFIG_LSM6DSO16IS_EXT_HTS221
{
/* HTS221 */
.type = SENSOR_CHAN_HUMIDITY,
.i2c_addr = { 0x5F },
.wai_addr = 0x0F,
.wai_val = 0xBC,
.out_data_addr = 0x28 | HTS221_AUTOINCREMENT,
.out_data_len = 0x02,
.dev_init = (lsm6dso16is_hts221_init),
.dev_conf = (lsm6dso16is_hts221_conf),
},
#endif /* CONFIG_LSM6DSO16IS_EXT_HTS221 */
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22HB
{
/* LPS22HB */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dso16is_lps22hb_init),
},
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22HB */
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22HH
{
/* LPS22HH */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB3,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dso16is_lps22hh_init),
.dev_conf = (lsm6dso16is_lps22hh_conf),
},
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22HH */
#ifdef CONFIG_LSM6DSO16IS_EXT_LPS22DF
{
/* LPS22DF */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB4,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dso16is_lps22df_init),
.dev_conf = (lsm6dso16is_lps22df_conf),
},
#endif /* CONFIG_LSM6DSO16IS_EXT_LPS22DF */
};
static int lsm6dso16is_shub_wait_completed(stmdev_ctx_t *ctx)
{
lsm6dso16is_status_master_t status;
int tries = 200; /* Should be max ~160 ms, from 2 cycles at slowest ODR 12.5 Hz */
do {
if (!--tries) {
LOG_DBG("shub: Timeout waiting for operation to complete");
return -ETIMEDOUT;
}
k_msleep(1);
lsm6dso16is_sh_status_mainpage_get(ctx, &status);
} while (status.sens_hub_endop == 0);
return 1;
}
static void lsm6dso16is_shub_enable(const struct device *dev, uint8_t enable)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
/* Enable Accel @26hz */
if (!data->accel_freq) {
uint8_t odr = (enable) ? 2 : 0;
if (lsm6dso16is_xl_data_rate_set(ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
if (enable) {
lsm6dso16is_status_master_t status;
/* Clear any pending status flags */
lsm6dso16is_sh_status_mainpage_get(ctx, &status);
}
if (lsm6dso16is_sh_master_set(ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
lsm6dso16is_mem_bank_set(ctx, LSM6DSO16IS_MAIN_MEM_BANK);
return;
}
if (!enable) {
/* wait 300us (necessary per AN5799 6.2.1) */
k_busy_wait(300);
}
}
/* must be called with master on */
static int lsm6dso16is_shub_check_slv0_nack(stmdev_ctx_t *ctx)
{
lsm6dso16is_all_sources_t status;
if (lsm6dso16is_all_sources_get(ctx, &status) < 0) {
LOG_DBG("shub: error reading embedded reg");
return -EIO;
}
if (status.sh_slave0_nack) {
LOG_DBG("shub: TRGT 0 nacked");
return -EIO;
}
return 0;
}
/*
* use TRGT 0 for generic read to target device
*/
static int lsm6dso16is_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_sh_cfg_read_t trgt_cfg;
trgt_cfg.slv_add = trgt_addr;
trgt_cfg.slv_subadd = trgt_reg;
trgt_cfg.slv_len = len;
lsm6dso16is_sh_slv_cfg_read(ctx, 0, &trgt_cfg);
/* turn SH on, wait for shub i2c read to finish */
lsm6dso16is_shub_enable(dev, 1);
lsm6dso16is_shub_wait_completed(ctx);
/* read data from external target */
if (lsm6dso16is_sh_read_data_raw_get(ctx, value, len) < 0) {
LOG_DBG("shub: error reading sensor data");
return -EIO;
}
if (lsm6dso16is_shub_check_slv0_nack(ctx) < 0) {
lsm6dso16is_shub_enable(dev, 0);
return -EIO;
}
lsm6dso16is_shub_enable(dev, 0);
return 0;
}
/*
* use TRGT 0 to configure target device
*/
static int lsm6dso16is_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dso16is_sh_cfg_write_t trgt_cfg;
uint8_t cnt = 0U;
lsm6dso16is_shub_enable(dev, 0);
while (cnt < len) {
trgt_cfg.slv0_add = trgt_addr;
trgt_cfg.slv0_subadd = trgt_reg + cnt;
trgt_cfg.slv0_data = value[cnt];
lsm6dso16is_sh_cfg_write(ctx, &trgt_cfg);
/* turn SH on, wait for shub i2c write to finish */
lsm6dso16is_shub_enable(dev, 1);
lsm6dso16is_shub_wait_completed(ctx);
if (lsm6dso16is_shub_check_slv0_nack(ctx) < 0) {
lsm6dso16is_shub_enable(dev, 0);
return -EIO;
}
lsm6dso16is_shub_enable(dev, 0);
cnt++;
}
/* Put TRGT 0 in IDLE mode */
trgt_cfg.slv0_add = 0x7;
trgt_cfg.slv0_subadd = 0x0;
trgt_cfg.slv0_data = 0x0;
lsm6dso16is_sh_cfg_write(ctx, &trgt_cfg);
return 0;
}
/*
* TARGETs configurations:
*
* - TARGET 0: used for configuring all target devices
* - TARGET 1: used as data read channel for external target device #1
* - TARGET 2: used as data read channel for external target device #2
* - TARGET 3: used for generic reads while data channel is enabled
*/
static int lsm6dso16is_shub_set_data_channel(const struct device *dev)
{
struct lsm6dso16is_data *data = dev->data;
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t n;
struct lsm6dso16is_shub_slist *sp;
lsm6dso16is_sh_cfg_read_t trgt_cfg;
/* Configure shub data channels to access external targets */
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso16is_shub_slist[data->shub_ext[n]];
trgt_cfg.slv_add = sp->ext_i2c_addr;
trgt_cfg.slv_subadd = sp->out_data_addr;
trgt_cfg.slv_len = sp->out_data_len;
if (lsm6dso16is_sh_slv_cfg_read(ctx, n + 1, &trgt_cfg) < 0) {
LOG_DBG("shub: error configuring shub for ext targets");
return -EIO;
}
}
/* Configure the master */
lsm6dso16is_sh_slave_connected_t aux = LSM6DSO16IS_SLV_0_1_2;
if (lsm6dso16is_sh_slave_connected_set(ctx, aux) < 0) {
LOG_DBG("shub: error setting aux sensors");
return -EIO;
}
/* turn SH on, no need to wait for 1st shub i2c read, if any, to complete */
lsm6dso16is_shub_enable(dev, 1);
return 0;
}
int lsm6dso16is_shub_get_idx(const struct device *dev, enum sensor_channel type)
{
uint8_t n;
struct lsm6dso16is_data *data = dev->data;
struct lsm6dso16is_shub_slist *sp;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso16is_shub_slist[data->shub_ext[n]];
if (sp->type == type) {
return n;
}
}
LOG_ERR("shub: dev %s type %d not supported", dev->name, type);
return -ENOTSUP;
}
int lsm6dso16is_shub_fetch_external_devs(const struct device *dev)
{
uint8_t n;
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dso16is_data *data = dev->data;
struct lsm6dso16is_shub_slist *sp;
/* read data from external target */
if (lsm6dso16is_mem_bank_set(ctx, LSM6DSO16IS_SENSOR_HUB_MEM_BANK) < 0) {
LOG_DBG("failed to enter SENSOR_HUB bank");
return -EIO;
}
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso16is_shub_slist[data->shub_ext[n]];
if (lsm6dso16is_read_reg(ctx, sp->sh_out_reg,
data->ext_data[n], sp->out_data_len) < 0) {
LOG_DBG("shub: failed to read sample");
(void) lsm6dso16is_mem_bank_set(ctx, LSM6DSO16IS_MAIN_MEM_BANK);
return -EIO;
}
}
return lsm6dso16is_mem_bank_set(ctx, LSM6DSO16IS_MAIN_MEM_BANK);
}
int lsm6dso16is_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct lsm6dso16is_data *data = dev->data;
struct lsm6dso16is_shub_slist *sp = NULL;
uint8_t n;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso16is_shub_slist[data->shub_ext[n]];
if (sp->type == chan) {
break;
}
}
if (n == data->num_ext_dev) {
LOG_DBG("shub: %s chan %d not supported", dev->name, chan);
return -ENOTSUP;
}
if (sp == NULL || sp->dev_conf == NULL) {
LOG_DBG("shub: chan not configurable");
return -ENOTSUP;
}
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int lsm6dso16is_shub_init(const struct device *dev)
{
struct lsm6dso16is_data *data = dev->data;
const struct lsm6dso16is_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct lsm6dso16is_shub_slist *sp;
LOG_INF("shub: start sensorhub for %s", dev->name);
/*
* This must be set or lsm6dso16is_shub_write_target_reg() will
* repeatedly write the same regi
*/
if (lsm6dso16is_sh_write_mode_set(ctx, LSM6DSO16IS_ONLY_FIRST_CYCLE) < 0) {
LOG_DBG("shub: error setting write once");
return -EIO;
}
for (n = 0; n < ARRAY_SIZE(lsm6dso16is_shub_slist); n++) {
if (data->num_ext_dev >= LSM6DSO16IS_SHUB_MAX_NUM_TARGETS) {
break;
}
chip_id = 0;
sp = &lsm6dso16is_shub_slist[n];
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (lsm6dso16is_shub_read_target_reg(dev,
sp->i2c_addr[i],
sp->wai_addr,
&chip_id, 1) < 0) {
LOG_DBG("shub: failed reading chip id");
continue;
}
if (chip_id == sp->wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(sp->i2c_addr)) {
LOG_DBG("shub: invalid chip id 0x%x", chip_id);
continue;
}
LOG_INF("shub: Ext Device Chip Id: %02x", chip_id);
sp->ext_i2c_addr = sp->i2c_addr[i];
data->shub_ext[data->num_ext_dev++] = n;
}
LOG_DBG("shub: dev %s - num_ext_dev %d", dev->name, data->num_ext_dev);
if (data->num_ext_dev == 0) {
LOG_ERR("shub: no target devices found");
return -EINVAL;
}
/* init external devices */
for (n = 0, regn = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dso16is_shub_slist[data->shub_ext[n]];
sp->sh_out_reg = LSM6DSO16IS_SENSOR_HUB_1 + regn;
regn += sp->out_data_len;
sp->dev_init(dev, sp->ext_i2c_addr);
}
lsm6dso16is_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dso16is/lsm6dso16is_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,829 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_stm32_qdec
/** @file
* @brief STM32 family Quadrature Decoder (QDEC) driver.
*/
#include <errno.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/clock_control/stm32_clock_control.h>
#include <zephyr/logging/log.h>
#include <stm32_ll_tim.h>
LOG_MODULE_REGISTER(qdec_stm32, CONFIG_SENSOR_LOG_LEVEL);
/* Device constant configuration parameters */
struct qdec_stm32_dev_cfg {
const struct pinctrl_dev_config *pin_config;
struct stm32_pclken pclken;
TIM_TypeDef *timer_inst;
uint32_t encoder_mode;
bool is_input_polarity_inverted;
uint8_t input_filtering_level;
uint32_t counts_per_revolution;
};
/* Device run time data */
struct qdec_stm32_dev_data {
int32_t position;
};
static int qdec_stm32_fetch(const struct device *dev, enum sensor_channel chan)
{
struct qdec_stm32_dev_data *dev_data = dev->data;
const struct qdec_stm32_dev_cfg *dev_cfg = dev->config;
uint32_t counter_value;
if ((chan != SENSOR_CHAN_ALL) && (chan != SENSOR_CHAN_ROTATION)) {
return -ENOTSUP;
}
/* We're only interested in the remainder between the current counter value and
* counts_per_revolution. The integer part represents an entire rotation so it
* can be ignored
*/
counter_value = LL_TIM_GetCounter(dev_cfg->timer_inst) % dev_cfg->counts_per_revolution;
dev_data->position = (counter_value * 360) / dev_cfg->counts_per_revolution;
return 0;
}
static int qdec_stm32_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct qdec_stm32_dev_data *const dev_data = dev->data;
if (chan == SENSOR_CHAN_ROTATION) {
val->val1 = dev_data->position;
val->val2 = 0;
} else {
return -ENOTSUP;
}
return 0;
}
static int qdec_stm32_initialize(const struct device *dev)
{
const struct qdec_stm32_dev_cfg *const dev_cfg = dev->config;
int retval;
LL_TIM_ENCODER_InitTypeDef init_props;
uint32_t max_counter_value;
retval = pinctrl_apply_state(dev_cfg->pin_config, PINCTRL_STATE_DEFAULT);
if (retval < 0) {
return retval;
}
if (!device_is_ready(DEVICE_DT_GET(STM32_CLOCK_CONTROL_NODE))) {
LOG_ERR("Clock control device not ready");
return -ENODEV;
}
retval = clock_control_on(DEVICE_DT_GET(STM32_CLOCK_CONTROL_NODE),
(clock_control_subsys_t)&dev_cfg->pclken);
if (retval < 0) {
LOG_ERR("Could not initialize clock");
return retval;
}
if (dev_cfg->counts_per_revolution < 1) {
LOG_ERR("Invalid number of counts per revolution (%d)",
dev_cfg->counts_per_revolution);
return -EINVAL;
}
LL_TIM_ENCODER_StructInit(&init_props);
init_props.EncoderMode = dev_cfg->encoder_mode;
if (dev_cfg->is_input_polarity_inverted) {
init_props.IC1Polarity = LL_TIM_IC_POLARITY_FALLING;
init_props.IC2Polarity = LL_TIM_IC_POLARITY_FALLING;
}
init_props.IC1Filter = dev_cfg->input_filtering_level * LL_TIM_IC_FILTER_FDIV1_N2;
init_props.IC2Filter = dev_cfg->input_filtering_level * LL_TIM_IC_FILTER_FDIV1_N2;
/* Ensure that the counter will always count up to a multiple of counts_per_revolution */
if (IS_TIM_32B_COUNTER_INSTANCE(dev_cfg->timer_inst)) {
max_counter_value = UINT32_MAX - (UINT32_MAX % dev_cfg->counts_per_revolution) - 1;
} else {
max_counter_value = UINT16_MAX - (UINT16_MAX % dev_cfg->counts_per_revolution) - 1;
}
LL_TIM_SetAutoReload(dev_cfg->timer_inst, max_counter_value);
if (LL_TIM_ENCODER_Init(dev_cfg->timer_inst, &init_props) != SUCCESS) {
LOG_ERR("Initalization failed");
return -EIO;
}
LL_TIM_EnableCounter(dev_cfg->timer_inst);
return 0;
}
static const struct sensor_driver_api qdec_stm32_driver_api = {
.sample_fetch = qdec_stm32_fetch,
.channel_get = qdec_stm32_get,
};
#define QDEC_STM32_INIT(n) \
BUILD_ASSERT(!(DT_INST_PROP(n, st_encoder_mode) & ~TIM_SMCR_SMS), \
"Encoder mode is not supported by this MCU"); \
\
PINCTRL_DT_INST_DEFINE(n); \
static const struct qdec_stm32_dev_cfg qdec##n##_stm32_config = { \
.pin_config = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
.timer_inst = ((TIM_TypeDef *)DT_REG_ADDR(DT_INST_PARENT(n))), \
.pclken = {.bus = DT_CLOCKS_CELL(DT_INST_PARENT(n), bus), \
.enr = DT_CLOCKS_CELL(DT_INST_PARENT(n), bits)}, \
.encoder_mode = DT_INST_PROP(n, st_encoder_mode), \
.is_input_polarity_inverted = DT_INST_PROP(n, st_input_polarity_inverted), \
.input_filtering_level = DT_INST_PROP(n, st_input_filter_level), \
.counts_per_revolution = DT_INST_PROP(n, st_counts_per_revolution), \
}; \
\
static struct qdec_stm32_dev_data qdec##n##_stm32_data; \
\
SENSOR_DEVICE_DT_INST_DEFINE(n, qdec_stm32_initialize, NULL, &qdec##n##_stm32_data, \
&qdec##n##_stm32_config, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &qdec_stm32_driver_api);
DT_INST_FOREACH_STATUS_OKAY(QDEC_STM32_INIT)
``` | /content/code_sandbox/drivers/sensor/st/qdec_stm32/qdec_stm32.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,379 |
```unknown
#
config QDEC_STM32
bool "STM32 QDEC driver"
default y
depends on DT_HAS_ST_STM32_QDEC_ENABLED
select USE_STM32_LL_TIM
help
STM32 family Quadrature Decoder driver.
``` | /content/code_sandbox/drivers/sensor/st/qdec_stm32/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 52 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM9DS1_LSM9DS1_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM9DS1_LSM9DS1_H_
#include "lsm9ds1_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define GAIN_UNIT_XL (61LL)
#define GAIN_UNIT_G (8750LL)
#define TEMP_OFFSET 25 /* raw output of zero indicate 25C */
#define TEMP_SENSITIVITY 16 /* 16 LSB / C */
#define GYRO_ODR_MASK 0x7
struct lsm9ds1_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_range;
uint8_t gyro_range;
uint8_t imu_odr;
};
struct lsm9ds1_data {
int16_t acc[3];
uint32_t acc_gain;
int16_t gyro[3];
uint32_t gyro_gain;
uint16_t accel_odr;
uint16_t gyro_odr;
#if defined(CONFIG_LSM9DS1_ENABLE_TEMP)
int16_t temp_sample;
#endif
};
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM9DS1_LSM9DS1_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds1/lsm9ds1.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 374 |
```unknown
menuconfig LSM9DS1
bool "LSM9DS1 I2C accelerometer and gyroscope chip"
default y
depends on DT_HAS_ST_LSM9DS1_ENABLED
select I2C
select HAS_STMEMSC
select USE_STDC_LSM9DS1
if LSM9DS1
config LSM9DS1_ENABLE_TEMP
bool "LSM9DS1 Temperature sensor"
help
Enable/disable temperature
endif #LSM9DS1
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds1/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 101 |
```c
/* ST Microelectronics LIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dh
#include <string.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
#include "lis2dh.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(lis2dh, CONFIG_SENSOR_LOG_LEVEL);
static int lis2dh_i2c_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lis2dh_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->bus_cfg.i2c, reg_addr | LIS2DH_AUTOINCREMENT_ADDR, value,
len);
}
static int lis2dh_i2c_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lis2dh_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->bus_cfg.i2c, reg_addr | LIS2DH_AUTOINCREMENT_ADDR, value,
len);
}
static int lis2dh_i2c_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
const struct lis2dh_config *cfg = dev->config;
return i2c_reg_read_byte_dt(&cfg->bus_cfg.i2c, reg_addr, value);
}
static int lis2dh_i2c_write_reg(const struct device *dev, uint8_t reg_addr,
uint8_t value)
{
const struct lis2dh_config *cfg = dev->config;
return i2c_reg_write_byte_dt(&cfg->bus_cfg.i2c, reg_addr, value);
}
static int lis2dh_i2c_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
const struct lis2dh_config *cfg = dev->config;
return i2c_reg_update_byte_dt(&cfg->bus_cfg.i2c, reg_addr, mask, value);
}
static const struct lis2dh_transfer_function lis2dh_i2c_transfer_fn = {
.read_data = lis2dh_i2c_read_data,
.write_data = lis2dh_i2c_write_data,
.read_reg = lis2dh_i2c_read_reg,
.write_reg = lis2dh_i2c_write_reg,
.update_reg = lis2dh_i2c_update_reg,
};
int lis2dh_i2c_init(const struct device *dev)
{
struct lis2dh_data *data = dev->data;
const struct lis2dh_config *cfg = dev->config;
if (!device_is_ready(cfg->bus_cfg.i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
data->hw_tf = &lis2dh_i2c_transfer_fn;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/lis2dh_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 655 |
```c
/* ST Microelectronics LIS2DH 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dh
#include <string.h>
#include "lis2dh.h"
#include <zephyr/logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
LOG_MODULE_DECLARE(lis2dh, CONFIG_SENSOR_LOG_LEVEL);
#define LIS2DH_SPI_READ_BIT BIT(7)
#define LIS2DH_SPI_AUTOINC BIT(6)
#define LIS2DH_SPI_ADDR_MASK BIT_MASK(6)
static int lis2dh_raw_read(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lis2dh_config *cfg = dev->config;
uint8_t buffer_tx[2] = { reg_addr | LIS2DH_SPI_READ_BIT, 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 = value,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (len > 1) {
buffer_tx[0] |= LIS2DH_SPI_AUTOINC;
}
if (spi_transceive_dt(&cfg->bus_cfg.spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int lis2dh_raw_write(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lis2dh_config *cfg = dev->config;
uint8_t buffer_tx[1] = { reg_addr & ~LIS2DH_SPI_READ_BIT };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = value,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (len > 1) {
buffer_tx[0] |= LIS2DH_SPI_AUTOINC;
}
if (spi_write_dt(&cfg->bus_cfg.spi, &tx)) {
return -EIO;
}
return 0;
}
static int lis2dh_spi_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return lis2dh_raw_read(dev, reg_addr, value, len);
}
static int lis2dh_spi_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return lis2dh_raw_write(dev, reg_addr, value, len);
}
static int lis2dh_spi_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
return lis2dh_raw_read(dev, reg_addr, value, 1);
}
static int lis2dh_spi_write_reg(const struct device *dev, uint8_t reg_addr,
uint8_t value)
{
uint8_t tmp_val = value;
return lis2dh_raw_write(dev, reg_addr, &tmp_val, 1);
}
static int lis2dh_spi_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
uint8_t tmp_val;
lis2dh_raw_read(dev, reg_addr, &tmp_val, 1);
tmp_val = (tmp_val & ~mask) | (value & mask);
return lis2dh_raw_write(dev, reg_addr, &tmp_val, 1);
}
static const struct lis2dh_transfer_function lis2dh_spi_transfer_fn = {
.read_data = lis2dh_spi_read_data,
.write_data = lis2dh_spi_write_data,
.read_reg = lis2dh_spi_read_reg,
.write_reg = lis2dh_spi_write_reg,
.update_reg = lis2dh_spi_update_reg,
};
int lis2dh_spi_init(const struct device *dev)
{
struct lis2dh_data *data = dev->data;
const struct lis2dh_config *cfg = dev->config;
data->hw_tf = &lis2dh_spi_transfer_fn;
if (!spi_is_ready_dt(&cfg->bus_cfg.spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/lis2dh_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,063 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lsm9ds1
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm9ds1.h"
#include <stmemsc.h>
LOG_MODULE_REGISTER(LSM9DS1, CONFIG_SENSOR_LOG_LEVEL);
/* Sensitivity of the accelerometer, indexed by the raw full scale value. Unit is g/ LSB */
static const uint16_t lsm9ds1_accel_fs_sens[] = {61, 732, 122, 244};
/*
* Sensitivity of the gyroscope, indexed by the raw full scale value.
* The value here is just a factor applied to GAIN_UNIT_G, as the sensitivity is
* proportional to the full scale size.
* The index 2 is never used : the value `0` is just a placeholder.
*/
static const uint16_t lsm9ds1_gyro_fs_sens[] = {1, 2, 0, 8};
/*
* Values of the different sampling frequencies of the accelerometer, indexed by the raw odr
* value that the sensor understands.
*/
static const uint16_t lsm9ds1_odr_map[] = {0, 10, 50, 119, 238, 476, 952};
/*
* Value of the different sampling frequencies of the gyroscope, indexed by the raw odr value
* that the sensor understands.
*/
static const uint16_t lsm9ds1_gyro_odr_map[] = {0, 15, 59, 119, 238, 476, 952};
static int lsm9ds1_reboot(const struct device *dev)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm9ds1_ctrl_reg8_t ctrl8_reg;
int ret;
ret = lsm9ds1_read_reg(ctx, LSM9DS1_CTRL_REG8, (uint8_t *)&ctrl8_reg, 1);
if (ret < 0) {
return ret;
}
ctrl8_reg.boot = 1;
ret = lsm9ds1_write_reg(ctx, LSM9DS1_CTRL_REG8, (uint8_t *)&ctrl8_reg, 1);
if (ret < 0) {
return ret;
}
k_msleep(50);
return 0;
}
static int lsm9ds1_accel_range_to_fs_val(int32_t range)
{
switch (range) {
case 2:
return LSM9DS1_2g;
case 4:
return LSM9DS1_4g;
case 8:
return LSM9DS1_8g;
case 16:
return LSM9DS1_16g;
default:
return -EINVAL;
}
}
static int lsm9ds1_gyro_range_to_fs_val(int32_t range)
{
switch (range) {
case 245:
return LSM9DS1_245dps;
case 500:
return LSM9DS1_500dps;
case 2000:
return LSM9DS1_2000dps;
default:
return -EINVAL;
}
}
static int lsm9ds1_accel_fs_val_to_gain(int fs)
{
return lsm9ds1_accel_fs_sens[fs];
}
static int lsm9ds1_accel_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm9ds1_odr_map); i++) {
if (freq <= lsm9ds1_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lsm9ds1_gyro_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm9ds1_gyro_odr_map); i++) {
if (freq <= lsm9ds1_gyro_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lsm9ds1_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int ret;
lsm9ds1_ctrl_reg6_xl_t ctrl_reg6_xl;
ret = lsm9ds1_read_reg(ctx, LSM9DS1_CTRL_REG6_XL, (uint8_t *)&ctrl_reg6_xl, 1);
if (ret < 0) {
return ret;
}
ctrl_reg6_xl.odr_xl = odr;
ret = lsm9ds1_write_reg(ctx, LSM9DS1_CTRL_REG6_XL, (uint8_t *)&ctrl_reg6_xl, 1);
if (ret < 0) {
return ret;
}
data->accel_odr = odr;
return 0;
}
static int lsm9ds1_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int ret;
lsm9ds1_ctrl_reg1_g_t ctrl_reg1;
ret = lsm9ds1_read_reg(ctx, LSM9DS1_CTRL_REG1_G, (uint8_t *)&ctrl_reg1, 1);
if (ret < 0) {
return ret;
}
ctrl_reg1.odr_g = odr;
ret = lsm9ds1_write_reg(ctx, LSM9DS1_CTRL_REG1_G, (uint8_t *)&ctrl_reg1, 1);
if (ret < 0) {
return ret;
}
data->gyro_odr = odr;
return 0;
}
static int lsm9ds1_gyro_odr_set(const struct device *dev, uint16_t freq)
{
struct lsm9ds1_data *data = dev->data;
int odr;
int ret;
odr = lsm9ds1_gyro_freq_to_odr_val(freq);
if (odr == data->gyro_odr) {
return 0;
}
LOG_INF("You are also changing the odr of the accelerometer");
ret = lsm9ds1_gyro_set_odr_raw(dev, odr);
if (ret < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return ret;
}
/*
* When the gyroscope is on, the value of the accelerometer odr must be
* the same as the value of the gyroscope.
*/
ret = lsm9ds1_accel_set_odr_raw(dev, odr);
if (ret < 0) {
LOG_ERR("failed to set accelerometer sampling rate");
return ret;
}
return 0;
}
static int lsm9ds1_accel_odr_set(const struct device *dev, uint16_t freq)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int odr, ret;
lsm9ds1_imu_odr_t old_odr;
ret = lsm9ds1_imu_data_rate_get(ctx, &old_odr);
if (ret < 0) {
return ret;
}
/*
* The gyroscope is on :
* we have to change the odr on both the accelerometer and the gyroscope
*/
if (old_odr & GYRO_ODR_MASK) {
odr = lsm9ds1_gyro_freq_to_odr_val(freq);
if (odr == data->gyro_odr) {
return 0;
}
LOG_INF("You are also changing the odr of the gyroscope");
ret = lsm9ds1_accel_set_odr_raw(dev, odr);
if (ret < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return ret;
}
ret = lsm9ds1_gyro_set_odr_raw(dev, odr);
if (ret < 0) {
LOG_ERR("failed to set gyroscope sampling rate");
return ret;
}
/* The gyroscope is off, we have to change the odr of just the accelerometer */
} else {
odr = lsm9ds1_accel_freq_to_odr_val(freq);
if (odr == data->accel_odr) {
return 0;
}
if (odr < 0) {
return odr;
}
ret = lsm9ds1_accel_set_odr_raw(dev, odr);
if (ret < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return ret;
}
}
return 0;
}
static int lsm9ds1_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm9ds1_data *data = dev->data;
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
fs = lsm9ds1_accel_range_to_fs_val(range);
if (fs < 0) {
LOG_DBG("full scale value not supported");
return fs;
}
ret = lsm9ds1_xl_full_scale_set(ctx, fs);
if (ret < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return ret;
}
data->acc_gain = lsm9ds1_accel_fs_val_to_gain(fs);
return 0;
}
static int lsm9ds1_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm9ds1_data *data = dev->data;
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
fs = lsm9ds1_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
ret = lsm9ds1_gy_full_scale_set(ctx, fs);
if (ret < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return ret;
}
data->gyro_gain = (lsm9ds1_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
static int lsm9ds1_accel_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm9ds1_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm9ds1_accel_odr_set(dev, val->val1);
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm9ds1_gyro_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm9ds1_gyro_range_set(dev, sensor_rad_to_degrees(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm9ds1_gyro_odr_set(dev, val->val1);
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm9ds1_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm9ds1_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm9ds1_gyro_config(dev, chan, attr, val);
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lsm9ds1_sample_fetch_accel(const struct device *dev)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int ret;
ret = lsm9ds1_acceleration_raw_get(ctx, data->acc);
if (ret < 0) {
LOG_DBG("Failed to read sample");
return ret;
}
return 0;
}
static int lsm9ds1_sample_fetch_gyro(const struct device *dev)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int ret;
ret = lsm9ds1_angular_rate_raw_get(ctx, data->gyro);
if (ret < 0) {
LOG_DBG("Failed to read sample");
return ret;
}
return 0;
}
#if IS_ENABLED(CONFIG_LSM9DS1_ENABLE_TEMP)
static int lsm9ds1_sample_fetch_temp(const struct device *dev)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *data = dev->data;
int ret;
ret = lsm9ds1_temperature_raw_get(ctx, &data->temp_sample);
if (ret < 0) {
LOG_DBG("Failed to read sample");
return ret;
}
return 0;
}
#endif
static int lsm9ds1_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm9ds1_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm9ds1_sample_fetch_gyro(dev);
break;
#if IS_ENABLED(CONFIG_LSM9DS1_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm9ds1_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm9ds1_sample_fetch_accel(dev);
lsm9ds1_sample_fetch_gyro(dev);
#if IS_ENABLED(CONFIG_LSM9DS1_ENABLE_TEMP)
lsm9ds1_sample_fetch_temp(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm9ds1_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
sensor_ug_to_ms2(raw_val * sensitivity, val);
}
static inline int lsm9ds1_accel_get_channel(enum sensor_channel chan, struct sensor_value *val,
struct lsm9ds1_data *data, uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm9ds1_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm9ds1_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm9ds1_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lsm9ds1_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm9ds1_accel_channel_get(enum sensor_channel chan, struct sensor_value *val,
struct lsm9ds1_data *data)
{
return lsm9ds1_accel_get_channel(chan, val, data, data->acc_gain);
}
static inline void lsm9ds1_gyro_convert(struct sensor_value *val, int raw_val, uint32_t sensitivity)
{
/* Sensitivity is exposed in udps/LSB */
/* Convert to rad/s */
sensor_10udegrees_to_rad((raw_val * (int32_t)sensitivity) / 10, val);
}
static inline int lsm9ds1_gyro_get_channel(enum sensor_channel chan, struct sensor_value *val,
struct lsm9ds1_data *data, uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm9ds1_gyro_convert(val, data->gyro[0], sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
lsm9ds1_gyro_convert(val, data->gyro[1], sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
lsm9ds1_gyro_convert(val, data->gyro[2], sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
for (i = 0; i < 3; i++) {
lsm9ds1_gyro_convert(val++, data->gyro[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm9ds1_gyro_channel_get(enum sensor_channel chan, struct sensor_value *val,
struct lsm9ds1_data *data)
{
return lsm9ds1_gyro_get_channel(chan, val, data, data->gyro_gain);
}
#if IS_ENABLED(CONFIG_LSM9DS1_ENABLE_TEMP)
static void lsm9ds1_temp_channel_get(struct sensor_value *val, struct lsm9ds1_data *data)
{
val->val1 = data->temp_sample / TEMP_SENSITIVITY + TEMP_OFFSET;
val->val2 = (data->temp_sample % TEMP_SENSITIVITY) * (1000000 / TEMP_SENSITIVITY);
}
#endif
static int lsm9ds1_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm9ds1_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm9ds1_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm9ds1_gyro_channel_get(chan, val, data);
break;
#if IS_ENABLED(CONFIG_LSM9DS1_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm9ds1_temp_channel_get(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm9ds1_api_funcs = {
.sample_fetch = lsm9ds1_sample_fetch,
.channel_get = lsm9ds1_channel_get,
.attr_set = lsm9ds1_attr_set,
};
static int lsm9ds1_init(const struct device *dev)
{
const struct lsm9ds1_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm9ds1_data *lsm9ds1 = dev->data;
uint8_t chip_id, fs;
int ret;
ret = lsm9ds1_reboot(dev);
if (ret < 0) {
LOG_ERR("Failed to reboot device");
return ret;
}
ret = lsm9ds1_read_reg(ctx, LSM9DS1_WHO_AM_I, &chip_id, 1);
if (ret < 0) {
LOG_ERR("failed reading chip id");
return ret;
}
if (chip_id != LSM9DS1_IMU_ID) {
LOG_ERR("Invalid ID : got %x", chip_id);
return -EIO;
}
LOG_DBG("chip_id : %x", chip_id);
LOG_DBG("output data rate is %d\n", cfg->imu_odr);
ret = lsm9ds1_imu_data_rate_set(ctx, cfg->imu_odr);
if (ret < 0) {
LOG_ERR("failed to set IMU odr");
return ret;
}
fs = cfg->accel_range;
LOG_DBG("accel range is %d\n", fs);
ret = lsm9ds1_xl_full_scale_set(ctx, fs);
if (ret < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return ret;
}
lsm9ds1->acc_gain = lsm9ds1_accel_fs_val_to_gain(fs);
fs = cfg->gyro_range;
LOG_DBG("gyro range is %d", fs);
ret = lsm9ds1_gy_full_scale_set(ctx, fs);
if (ret < 0) {
LOG_ERR("failed to set gyroscope range %d\n", fs);
return ret;
}
lsm9ds1->gyro_gain = (lsm9ds1_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
#define LSM9DS1_CONFIG_COMMON(inst) \
.imu_odr = DT_INST_PROP(inst, imu_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
.gyro_range = DT_INST_PROP(inst, gyro_range),
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LSM9DS1_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lsm9ds1_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = \
{ \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LSM9DS1_CONFIG_COMMON(inst) \
}
#define LSM9DS1_DEFINE(inst) \
static struct lsm9ds1_data lsm9ds1_data_##inst = { \
.acc_gain = 0, \
}; \
\
static struct lsm9ds1_config lsm9ds1_config_##inst = LSM9DS1_CONFIG_I2C(inst); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm9ds1_init, NULL, &lsm9ds1_data_##inst, \
&lsm9ds1_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &lsm9ds1_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(LSM9DS1_DEFINE);
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds1/lsm9ds1.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,960 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lis2dh
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#define START_TRIG_INT1 0
#define START_TRIG_INT2 1
#define TRIGGED_INT1 4
#define TRIGGED_INT2 5
LOG_MODULE_DECLARE(lis2dh, CONFIG_SENSOR_LOG_LEVEL);
#include "lis2dh.h"
static const gpio_flags_t gpio_int_cfg[5] = {
GPIO_INT_EDGE_BOTH,
GPIO_INT_EDGE_RISING,
GPIO_INT_EDGE_FALLING,
GPIO_INT_LEVEL_HIGH,
GPIO_INT_LEVEL_LOW,
};
static inline void setup_int1(const struct device *dev,
bool enable)
{
const struct lis2dh_config *cfg = dev->config;
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
enable
? gpio_int_cfg[cfg->int1_mode]
: GPIO_INT_DISABLE);
}
static int lis2dh_trigger_drdy_set(const struct device *dev,
enum sensor_channel chan,
sensor_trigger_handler_t handler,
const struct sensor_trigger *trig)
{
const struct lis2dh_config *cfg = dev->config;
struct lis2dh_data *lis2dh = dev->data;
int status;
if (cfg->gpio_drdy.port == NULL) {
LOG_ERR("trigger_set DRDY int not supported");
return -ENOTSUP;
}
setup_int1(dev, false);
/* cancel potentially pending trigger */
atomic_clear_bit(&lis2dh->trig_flags, TRIGGED_INT1);
status = lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL3,
LIS2DH_EN_DRDY1_INT1, 0);
lis2dh->handler_drdy = handler;
lis2dh->trig_drdy = trig;
if ((handler == NULL) || (status < 0)) {
return status;
}
lis2dh->chan_drdy = chan;
/* serialize start of int1 in thread to synchronize output sampling
* and first interrupt. this avoids concurrent bus context access.
*/
atomic_set_bit(&lis2dh->trig_flags, START_TRIG_INT1);
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dh->gpio_sem);
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dh->work);
#endif
return 0;
}
static int lis2dh_start_trigger_int1(const struct device *dev)
{
int status;
uint8_t raw[LIS2DH_BUF_SZ];
uint8_t ctrl1 = 0U;
struct lis2dh_data *lis2dh = dev->data;
/* power down temporarily to align interrupt & data output sampling */
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_CTRL1, &ctrl1);
if (unlikely(status < 0)) {
return status;
}
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1,
ctrl1 & ~LIS2DH_ODR_MASK);
if (unlikely(status < 0)) {
return status;
}
LOG_DBG("ctrl1=0x%x @tick=%u", ctrl1, k_cycle_get_32());
/* empty output data */
status = lis2dh->hw_tf->read_data(dev, LIS2DH_REG_STATUS,
raw, sizeof(raw));
if (unlikely(status < 0)) {
return status;
}
setup_int1(dev, true);
/* re-enable output sampling */
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1, ctrl1);
if (unlikely(status < 0)) {
return status;
}
return lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL3,
LIS2DH_EN_DRDY1_INT1,
LIS2DH_EN_DRDY1_INT1);
}
#define LIS2DH_ANYM_CFG (LIS2DH_INT_CFG_ZHIE_ZUPE | LIS2DH_INT_CFG_YHIE_YUPE |\
LIS2DH_INT_CFG_XHIE_XUPE)
static inline void setup_int2(const struct device *dev,
bool enable)
{
const struct lis2dh_config *cfg = dev->config;
gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
enable
? gpio_int_cfg[cfg->int2_mode]
: GPIO_INT_DISABLE);
}
/* common handler for any motion and tap triggers */
static int lis2dh_trigger_anym_tap_set(const struct device *dev,
sensor_trigger_handler_t handler,
const struct sensor_trigger *trig)
{
const struct lis2dh_config *cfg = dev->config;
struct lis2dh_data *lis2dh = dev->data;
int status;
uint8_t reg_val;
if (cfg->gpio_int.port == NULL) {
LOG_ERR("trigger_set AnyMotion int not supported");
return -ENOTSUP;
}
setup_int2(dev, false);
/* cancel potentially pending trigger */
atomic_clear_bit(&lis2dh->trig_flags, TRIGGED_INT2);
if (cfg->hw.anym_on_int1) {
status = lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL3,
LIS2DH_EN_DRDY1_INT1, 0);
}
/* disable any movement interrupt events */
status = lis2dh->hw_tf->write_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_CFG :
LIS2DH_REG_INT2_CFG,
0);
/* disable any click interrupt events */
status = lis2dh->hw_tf->write_reg(dev,
LIS2DH_REG_CFG_CLICK,
0);
/* make sure any pending interrupt is cleared */
status = lis2dh->hw_tf->read_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_SRC :
LIS2DH_REG_INT2_SRC,
®_val);
status = lis2dh->hw_tf->read_reg(dev,
LIS2DH_REG_CLICK_SRC,
®_val);
if (trig->type == SENSOR_TRIG_DELTA) {
lis2dh->handler_anymotion = handler;
lis2dh->trig_anymotion = trig;
} else if (trig->type == SENSOR_TRIG_TAP) {
lis2dh->handler_tap = handler;
lis2dh->trig_tap = trig;
}
if ((handler == NULL) || (status < 0)) {
return status;
}
/* serialize start of int2 in thread to synchronize output sampling
* and first interrupt. this avoids concurrent bus context access.
*/
atomic_set_bit(&lis2dh->trig_flags, START_TRIG_INT2);
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dh->gpio_sem);
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dh->work);
#endif
return 0;
}
static int lis2dh_trigger_anym_set(const struct device *dev,
sensor_trigger_handler_t handler,
const struct sensor_trigger *trig)
{
return lis2dh_trigger_anym_tap_set(dev, handler, trig);
}
static int lis2dh_trigger_tap_set(const struct device *dev,
sensor_trigger_handler_t handler,
const struct sensor_trigger *trig)
{
return lis2dh_trigger_anym_tap_set(dev, handler, trig);
}
static int lis2dh_start_trigger_int2(const struct device *dev)
{
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
int status = 0;
uint8_t reg = 0, mask = 0, val = 0;
setup_int2(dev, true);
bool has_anyt = (lis2dh->handler_tap != NULL);
bool has_anym = (lis2dh->handler_anymotion != NULL);
/* configure any motion interrupt */
reg = cfg->hw.anym_on_int1 ? LIS2DH_REG_INT1_CFG : LIS2DH_REG_INT2_CFG;
val = (cfg->hw.anym_mode << LIS2DH_INT_CFG_MODE_SHIFT) | LIS2DH_ANYM_CFG;
status = lis2dh->hw_tf->write_reg(dev, reg, val);
if (status < 0) {
LOG_ERR("Failed to configure any motion interrupt");
return status;
}
/* enable any motion detection on int line */
reg = cfg->hw.anym_on_int1 ? LIS2DH_REG_CTRL3 : LIS2DH_REG_CTRL6;
mask = cfg->hw.anym_on_int1 ? LIS2DH_EN_IA_INT1 : LIS2DH_EN_IA_INT2;
val = has_anym ? mask : 0;
status = lis2dh->hw_tf->update_reg(dev, reg, mask, val);
if (status < 0) {
LOG_ERR("Failed to enable any motion detection on int line");
return status;
}
/* configure tap interrupt on all axes */
reg = LIS2DH_REG_CFG_CLICK;
mask = LIS2DH_EN_CLICK_XS | LIS2DH_EN_CLICK_YS | LIS2DH_EN_CLICK_ZS;
val = has_anyt ? mask : 0;
status = lis2dh->hw_tf->update_reg(dev, reg, mask, val);
if (status < 0) {
LOG_ERR("Failed to configure tap interrupt");
return status;
}
/* set click detection on int line */
reg = cfg->hw.anym_on_int1 ? LIS2DH_REG_CTRL3 : LIS2DH_REG_CTRL6;
mask = cfg->hw.anym_on_int1 ? LIS2DH_EN_CLICK_INT1 : LIS2DH_EN_CLICK_INT2;
val = has_anyt ? mask : 0;
status = lis2dh->hw_tf->update_reg(dev, reg, mask, val);
if (status < 0) {
LOG_ERR("Failed to enable click detection on int line");
return status;
}
return 0;
}
int lis2dh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
if (trig->type == SENSOR_TRIG_DATA_READY &&
trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
return lis2dh_trigger_drdy_set(dev, trig->chan, handler, trig);
} else if (trig->type == SENSOR_TRIG_DELTA) {
return lis2dh_trigger_anym_set(dev, handler, trig);
} else if (trig->type == SENSOR_TRIG_TAP) {
return lis2dh_trigger_tap_set(dev, handler, trig);
}
return -ENOTSUP;
}
int lis2dh_acc_slope_config(const struct device *dev,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
int status;
if (attr == SENSOR_ATTR_SLOPE_TH) {
uint8_t range_g, reg_val;
uint32_t slope_th_ums2;
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_CTRL4,
®_val);
if (status < 0) {
return status;
}
/* fs reg value is in the range 0 (2g) - 3 (16g) */
range_g = 2 * (1 << ((LIS2DH_FS_MASK & reg_val)
>> LIS2DH_FS_SHIFT));
slope_th_ums2 = val->val1 * 1000000 + val->val2;
/* make sure the provided threshold does not exceed range */
if ((slope_th_ums2 - 1) > (range_g * SENSOR_G)) {
return -EINVAL;
}
/* 7 bit full range value */
reg_val = 128 / range_g * (slope_th_ums2 - 1) / SENSOR_G;
LOG_INF("int2_ths=0x%x range_g=%d ums2=%u", reg_val,
range_g, slope_th_ums2 - 1);
/* Configure threshold for the any motion recognition */
status = lis2dh->hw_tf->write_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_THS :
LIS2DH_REG_INT2_THS,
reg_val);
/* Configure threshold for the Click recognition */
status = lis2dh->hw_tf->write_reg(dev,
LIS2DH_REG_CFG_CLICK_THS,
LIS2DH_CLICK_LIR | reg_val);
} else { /* SENSOR_ATTR_SLOPE_DUR */
/*
* slope duration is measured in number of samples:
* N/ODR where N is the register value
*/
if (val->val1 < 0 || val->val1 > 127) {
return -ENOTSUP;
}
LOG_INF("int2_dur=0x%x", val->val1);
/* Configure time limit for the any motion recognition */
status = lis2dh->hw_tf->write_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_DUR :
LIS2DH_REG_INT2_DUR,
val->val1);
/* Configure time limit for the Click recognition */
status = lis2dh->hw_tf->write_reg(dev,
LIS2DH_REG_TIME_LIMIT,
val->val1);
}
return status;
}
#ifdef CONFIG_LIS2DH_ACCEL_HP_FILTERS
int lis2dh_acc_hp_filter_set(const struct device *dev, int32_t val)
{
struct lis2dh_data *lis2dh = dev->data;
int status;
status = lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL2,
LIS2DH_HPIS_EN_MASK, val);
if (status < 0) {
LOG_ERR("Failed to set high pass filters");
}
return status;
}
#endif
static void lis2dh_gpio_int1_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2dh_data *lis2dh =
CONTAINER_OF(cb, struct lis2dh_data, gpio_int1_cb);
ARG_UNUSED(pins);
atomic_set_bit(&lis2dh->trig_flags, TRIGGED_INT1);
/* int is level triggered so disable until processed */
setup_int1(lis2dh->dev, false);
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dh->gpio_sem);
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dh->work);
#endif
}
static void lis2dh_gpio_int2_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2dh_data *lis2dh =
CONTAINER_OF(cb, struct lis2dh_data, gpio_int2_cb);
ARG_UNUSED(pins);
atomic_set_bit(&lis2dh->trig_flags, TRIGGED_INT2);
/* int is level triggered so disable until processed */
setup_int2(lis2dh->dev, false);
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dh->gpio_sem);
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dh->work);
#endif
}
static void lis2dh_thread_cb(const struct device *dev)
{
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
int status;
if (cfg->gpio_drdy.port &&
unlikely(atomic_test_and_clear_bit(&lis2dh->trig_flags,
START_TRIG_INT1))) {
status = lis2dh_start_trigger_int1(dev);
if (unlikely(status < 0)) {
LOG_ERR("lis2dh_start_trigger_int1: %d", status);
}
return;
}
if (cfg->gpio_int.port &&
unlikely(atomic_test_and_clear_bit(&lis2dh->trig_flags,
START_TRIG_INT2))) {
status = lis2dh_start_trigger_int2(dev);
if (unlikely(status < 0)) {
LOG_ERR("lis2dh_start_trigger_int2: %d", status);
}
return;
}
if (cfg->gpio_drdy.port &&
atomic_test_and_clear_bit(&lis2dh->trig_flags,
TRIGGED_INT1)) {
if (likely(lis2dh->handler_drdy != NULL)) {
lis2dh->handler_drdy(dev, lis2dh->trig_drdy);
}
/* Reactivate level triggered interrupt if handler did not
* disable itself
*/
if (likely(lis2dh->handler_drdy != NULL)) {
setup_int1(dev, true);
}
return;
}
if (cfg->gpio_int.port &&
atomic_test_and_clear_bit(&lis2dh->trig_flags,
TRIGGED_INT2)) {
uint8_t reg_val = 0;
/* if necessary also clears an interrupt to de-assert int line */
status = lis2dh->hw_tf->read_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_SRC :
LIS2DH_REG_INT2_SRC,
®_val);
if (status < 0) {
LOG_ERR("clearing interrupt 2 failed: %d", status);
return;
}
if (likely(lis2dh->handler_anymotion != NULL) &&
(reg_val >> LIS2DH_INT_CFG_MODE_SHIFT)) {
lis2dh->handler_anymotion(dev, lis2dh->trig_anymotion);
LOG_DBG("@tick=%u int2_src=0x%x", k_cycle_get_32(), reg_val);
}
/* read click interrupt */
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_CLICK_SRC,
®_val);
if (status < 0) {
LOG_ERR("clearing interrupt 2 failed: %d", status);
return;
}
if (likely(lis2dh->handler_tap != NULL) &&
(reg_val & LIS2DH_CLICK_SRC_SCLICK)) {
lis2dh->handler_tap(dev, lis2dh->trig_tap);
LOG_DBG("@tick=%u click_src=0x%x", k_cycle_get_32(), reg_val);
}
/* Reactivate level triggered interrupt if handler did not
* disable itself
*/
if (lis2dh->handler_anymotion || lis2dh->handler_tap) {
setup_int2(dev, true);
}
return;
}
}
#ifdef CONFIG_LIS2DH_TRIGGER_OWN_THREAD
static void lis2dh_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lis2dh_data *lis2dh = p1;
while (1) {
k_sem_take(&lis2dh->gpio_sem, K_FOREVER);
lis2dh_thread_cb(lis2dh->dev);
}
}
#endif
#ifdef CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD
static void lis2dh_work_cb(struct k_work *work)
{
struct lis2dh_data *lis2dh =
CONTAINER_OF(work, struct lis2dh_data, work);
lis2dh_thread_cb(lis2dh->dev);
}
#endif
int lis2dh_init_interrupt(const struct device *dev)
{
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
int status;
uint8_t raw[2];
lis2dh->dev = dev;
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
k_sem_init(&lis2dh->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lis2dh->thread, lis2dh->thread_stack, CONFIG_LIS2DH_THREAD_STACK_SIZE,
lis2dh_thread, lis2dh, NULL, NULL,
K_PRIO_COOP(CONFIG_LIS2DH_THREAD_PRIORITY), 0, K_NO_WAIT);
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
lis2dh->work.handler = lis2dh_work_cb;
#endif
/*
* Setup INT1 (for DRDY) if defined in DT
*/
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
/* API may return false even when ptr is NULL */
if (cfg->gpio_drdy.port != NULL) {
LOG_ERR("device %s is not ready", cfg->gpio_drdy.port->name);
return -ENODEV;
}
LOG_DBG("gpio_drdy not defined in DT");
status = 0;
goto check_gpio_int;
}
/* data ready int1 gpio configuration */
status = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Could not configure %s.%02u",
cfg->gpio_drdy.port->name, cfg->gpio_drdy.pin);
return status;
}
gpio_init_callback(&lis2dh->gpio_int1_cb,
lis2dh_gpio_int1_callback,
BIT(cfg->gpio_drdy.pin));
status = gpio_add_callback(cfg->gpio_drdy.port, &lis2dh->gpio_int1_cb);
if (status < 0) {
LOG_ERR("Could not add gpio int1 callback");
return status;
}
LOG_INF("%s: int1 on %s.%02u", dev->name,
cfg->gpio_drdy.port->name,
cfg->gpio_drdy.pin);
check_gpio_int:
/*
* Setup Interrupt (for Any Motion) if defined in DT
*/
/* setup any motion gpio interrupt */
if (!gpio_is_ready_dt(&cfg->gpio_int)) {
/* API may return false even when ptr is NULL */
if (cfg->gpio_int.port != NULL) {
LOG_ERR("device %s is not ready", cfg->gpio_int.port->name);
return -ENODEV;
}
LOG_DBG("gpio_int not defined in DT");
status = 0;
goto end;
}
/* any motion int2 gpio configuration */
status = gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
if (status < 0) {
LOG_ERR("Could not configure %s.%02u",
cfg->gpio_int.port->name, cfg->gpio_int.pin);
return status;
}
gpio_init_callback(&lis2dh->gpio_int2_cb,
lis2dh_gpio_int2_callback,
BIT(cfg->gpio_int.pin));
/* callback is going to be enabled by trigger setting function */
status = gpio_add_callback(cfg->gpio_int.port, &lis2dh->gpio_int2_cb);
if (status < 0) {
LOG_ERR("Could not add gpio int2 callback (%d)", status);
return status;
}
LOG_INF("%s: int2 on %s.%02u", dev->name,
cfg->gpio_int.port->name,
cfg->gpio_int.pin);
/* disable interrupt in case of warm (re)boot */
status = lis2dh->hw_tf->write_reg(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_CFG :
LIS2DH_REG_INT2_CFG,
0);
if (status < 0) {
LOG_ERR("Interrupt disable reg write failed (%d)", status);
return status;
}
status = lis2dh->hw_tf->write_reg(dev,
LIS2DH_REG_CFG_CLICK,
0);
if (status < 0) {
LOG_ERR("Interrupt disable reg write failed (%d)", status);
return status;
}
(void)memset(raw, 0, sizeof(raw));
status = lis2dh->hw_tf->write_data(dev,
cfg->hw.anym_on_int1 ?
LIS2DH_REG_INT1_THS :
LIS2DH_REG_INT2_THS,
raw, sizeof(raw));
if (status < 0) {
LOG_ERR("Burst write to THS failed (%d)", status);
return status;
}
if (cfg->hw.anym_latch) {
/* latch line interrupt */
status = lis2dh->hw_tf->write_reg(dev,
LIS2DH_REG_CTRL5,
cfg->hw.anym_on_int1 ?
LIS2DH_EN_LIR_INT1 :
LIS2DH_EN_LIR_INT2);
}
if (status < 0) {
LOG_ERR("enable reg write failed (%d)", status);
return status;
}
end:
return status;
}
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/lis2dh_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,444 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lis2dh
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
LOG_MODULE_REGISTER(lis2dh, CONFIG_SENSOR_LOG_LEVEL);
#include "lis2dh.h"
#define ACCEL_SCALE(sensitivity) \
((SENSOR_G * (sensitivity) >> 14) / 100)
/*
* Use values for low-power mode in DS "Mechanical (Sensor) characteristics",
* multiplied by 100.
*/
static uint32_t lis2dh_reg_val_to_scale[] = {
ACCEL_SCALE(1600),
ACCEL_SCALE(3200),
ACCEL_SCALE(6400),
ACCEL_SCALE(19200),
};
static void lis2dh_convert(int16_t raw_val, uint32_t scale,
struct sensor_value *val)
{
int32_t converted_val;
/*
* maximum converted value we can get is: max(raw_val) * max(scale)
* max(raw_val >> 4) = +/- 2^11
* max(scale) = 114921
* max(converted_val) = 235358208 which is less than 2^31
*/
converted_val = (raw_val >> 4) * scale;
val->val1 = converted_val / 1000000;
val->val2 = converted_val % 1000000;
}
static int lis2dh_sample_fetch_temp(const struct device *dev)
{
int ret = -ENOTSUP;
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
uint8_t raw[sizeof(uint16_t)];
ret = lis2dh->hw_tf->read_data(dev, cfg->temperature.dout_addr, raw,
sizeof(raw));
if (ret < 0) {
LOG_WRN("Failed to fetch raw temperature sample");
ret = -EIO;
} else {
/*
* The result contains a delta value for the
* temperature that must be added to the reference temperature set
* for your board to return an absolute temperature in Celsius.
*
* The data is left aligned. Fixed point after first 8 bits.
*/
lis2dh->temperature.val1 = (int32_t)((int8_t)raw[1]);
if (cfg->temperature.fractional_bits == 0) {
lis2dh->temperature.val2 = 0;
} else {
lis2dh->temperature.val2 =
(raw[0] >> (8 - cfg->temperature.fractional_bits));
lis2dh->temperature.val2 = (lis2dh->temperature.val2 * 1000000);
lis2dh->temperature.val2 >>= cfg->temperature.fractional_bits;
if (lis2dh->temperature.val1 < 0) {
lis2dh->temperature.val2 *= -1;
}
}
}
#else
LOG_WRN("Temperature measurement disabled");
#endif
return ret;
}
static int lis2dh_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lis2dh_data *lis2dh = dev->data;
int ofs_start;
int ofs_end;
int i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_end = 0;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_end = 1;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_end = 2;
break;
case SENSOR_CHAN_ACCEL_XYZ:
ofs_start = 0;
ofs_end = 2;
break;
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
case SENSOR_CHAN_DIE_TEMP:
memcpy(val, &lis2dh->temperature, sizeof(*val));
return 0;
#endif
default:
return -ENOTSUP;
}
for (i = ofs_start; i <= ofs_end; i++, val++) {
lis2dh_convert(lis2dh->sample.xyz[i], lis2dh->scale, val);
}
return 0;
}
static int lis2dh_fetch_xyz(const struct device *dev,
enum sensor_channel chan)
{
struct lis2dh_data *lis2dh = dev->data;
int status = -ENODATA;
size_t i;
/*
* since status and all accel data register addresses are consecutive,
* a burst read can be used to read all the samples
*/
status = lis2dh->hw_tf->read_data(dev, LIS2DH_REG_STATUS,
lis2dh->sample.raw,
sizeof(lis2dh->sample.raw));
if (status < 0) {
LOG_WRN("Could not read accel axis data");
return status;
}
for (i = 0; i < (3 * sizeof(int16_t)); i += sizeof(int16_t)) {
int16_t *sample =
(int16_t *)&lis2dh->sample.raw[1 + i];
*sample = sys_le16_to_cpu(*sample);
}
if (lis2dh->sample.status & LIS2DH_STATUS_DRDY_MASK) {
status = 0;
}
return status;
}
static int lis2dh_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
int status = -ENODATA;
if (chan == SENSOR_CHAN_ALL) {
status = lis2dh_fetch_xyz(dev, chan);
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
if (status == 0) {
status = lis2dh_sample_fetch_temp(dev);
}
#endif
} else if (chan == SENSOR_CHAN_ACCEL_XYZ) {
status = lis2dh_fetch_xyz(dev, chan);
} else if (chan == SENSOR_CHAN_DIE_TEMP) {
status = lis2dh_sample_fetch_temp(dev);
} else {
__ASSERT(false, "Invalid sensor channel in fetch");
}
return status;
}
#ifdef CONFIG_LIS2DH_ODR_RUNTIME
/* 1620 & 5376 are low power only */
static const uint16_t lis2dh_odr_map[] = {0, 1, 10, 25, 50, 100, 200, 400, 1620,
1344, 5376};
static int lis2dh_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lis2dh_odr_map); i++) {
if (freq == lis2dh_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lis2dh_acc_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
int status;
uint8_t value;
struct lis2dh_data *data = dev->data;
odr = lis2dh_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
status = data->hw_tf->read_reg(dev, LIS2DH_REG_CTRL1, &value);
if (status < 0) {
return status;
}
/* some odr values cannot be set in certain power modes */
if ((value & LIS2DH_LP_EN_BIT_MASK) == 0U && odr == LIS2DH_ODR_8) {
return -ENOTSUP;
}
/* adjust odr index for LP enabled mode, see table above */
if (((value & LIS2DH_LP_EN_BIT_MASK) == LIS2DH_LP_EN_BIT_MASK) &&
(odr == LIS2DH_ODR_9 + 1)) {
odr--;
}
return data->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1,
(value & ~LIS2DH_ODR_MASK) |
LIS2DH_ODR_RATE(odr));
}
#endif
#ifdef CONFIG_LIS2DH_ACCEL_RANGE_RUNTIME
#define LIS2DH_RANGE_IDX_TO_VALUE(idx) (1 << ((idx) + 1))
#define LIS2DH_NUM_RANGES 4
static int lis2dh_range_to_reg_val(uint16_t range)
{
int i;
for (i = 0; i < LIS2DH_NUM_RANGES; i++) {
if (range == LIS2DH_RANGE_IDX_TO_VALUE(i)) {
return i;
}
}
return -EINVAL;
}
static int lis2dh_acc_range_set(const struct device *dev, int32_t range)
{
struct lis2dh_data *lis2dh = dev->data;
int fs;
fs = lis2dh_range_to_reg_val(range);
if (fs < 0) {
return fs;
}
lis2dh->scale = lis2dh_reg_val_to_scale[fs];
return lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL4,
LIS2DH_FS_MASK,
(fs << LIS2DH_FS_SHIFT));
}
#endif
static int lis2dh_acc_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#ifdef CONFIG_LIS2DH_ACCEL_RANGE_RUNTIME
case SENSOR_ATTR_FULL_SCALE:
return lis2dh_acc_range_set(dev, sensor_ms2_to_g(val));
#endif
#ifdef CONFIG_LIS2DH_ODR_RUNTIME
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lis2dh_acc_odr_set(dev, val->val1);
#endif
#if defined(CONFIG_LIS2DH_TRIGGER)
case SENSOR_ATTR_SLOPE_TH:
case SENSOR_ATTR_SLOPE_DUR:
return lis2dh_acc_slope_config(dev, attr, val);
#endif
#ifdef CONFIG_LIS2DH_ACCEL_HP_FILTERS
case SENSOR_ATTR_CONFIGURATION:
return lis2dh_acc_hp_filter_set(dev, val->val1);
#endif
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lis2dh_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return lis2dh_acc_config(dev, chan, attr, val);
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lis2dh_driver_api = {
.attr_set = lis2dh_attr_set,
#if CONFIG_LIS2DH_TRIGGER
.trigger_set = lis2dh_trigger_set,
#endif
.sample_fetch = lis2dh_sample_fetch,
.channel_get = lis2dh_channel_get,
};
int lis2dh_init(const struct device *dev)
{
struct lis2dh_data *lis2dh = dev->data;
const struct lis2dh_config *cfg = dev->config;
int status;
uint8_t id;
uint8_t raw[6];
status = cfg->bus_init(dev);
if (status < 0) {
return status;
}
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_WAI, &id);
if (status < 0) {
LOG_ERR("Failed to read chip id.");
return status;
}
if (id != LIS2DH_CHIP_ID) {
LOG_ERR("Invalid chip ID: %02x\n", id);
return -EINVAL;
}
/* Fix LSM303AGR_ACCEL device scale values */
if (cfg->hw.is_lsm303agr_dev) {
lis2dh_reg_val_to_scale[0] = ACCEL_SCALE(1563);
lis2dh_reg_val_to_scale[1] = ACCEL_SCALE(3126);
lis2dh_reg_val_to_scale[2] = ACCEL_SCALE(6252);
lis2dh_reg_val_to_scale[3] = ACCEL_SCALE(18758);
}
if (cfg->hw.disc_pull_up) {
status = lis2dh->hw_tf->update_reg(dev, LIS2DH_REG_CTRL0,
LIS2DH_SDO_PU_DISC_MASK,
LIS2DH_SDO_PU_DISC_MASK);
if (status < 0) {
LOG_ERR("Failed to disconnect SDO/SA0 pull-up.");
return status;
}
}
/* Initialize control register ctrl1 to ctrl 6 to default boot values
* to avoid warm start/reset issues as the accelerometer has no reset
* pin. Register values are retained if power is not removed.
* Default values see LIS2DH documentation page 30, chapter 6.
*/
(void)memset(raw, 0, sizeof(raw));
raw[0] = LIS2DH_ACCEL_EN_BITS;
status = lis2dh->hw_tf->write_data(dev, LIS2DH_REG_CTRL1, raw,
sizeof(raw));
if (status < 0) {
LOG_ERR("Failed to reset ctrl registers.");
return status;
}
/* set full scale range and store it for later conversion */
lis2dh->scale = lis2dh_reg_val_to_scale[LIS2DH_FS_IDX];
#ifdef CONFIG_LIS2DH_BLOCK_DATA_UPDATE
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL4,
LIS2DH_FS_BITS | LIS2DH_HR_BIT | LIS2DH_CTRL4_BDU_BIT);
#else
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL4, LIS2DH_FS_BITS | LIS2DH_HR_BIT);
#endif
if (status < 0) {
LOG_ERR("Failed to set full scale ctrl register.");
return status;
}
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
status = lis2dh->hw_tf->update_reg(dev, cfg->temperature.cfg_addr,
cfg->temperature.enable_mask,
cfg->temperature.enable_mask);
if (status < 0) {
LOG_ERR("Failed to enable temperature measurement");
return status;
}
#endif
#ifdef CONFIG_LIS2DH_TRIGGER
if (cfg->gpio_drdy.port != NULL || cfg->gpio_int.port != NULL) {
status = lis2dh_init_interrupt(dev);
if (status < 0) {
LOG_ERR("Failed to initialize interrupts.");
return status;
}
}
#endif
LOG_INF("fs=%d, odr=0x%x lp_en=0x%x scale=%d", 1 << (LIS2DH_FS_IDX + 1), LIS2DH_ODR_IDX,
(uint8_t)LIS2DH_LP_EN_BIT, lis2dh->scale);
/* enable accel measurements and set power mode and data rate */
return lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1,
LIS2DH_ACCEL_EN_BITS | LIS2DH_LP_EN_BIT |
LIS2DH_ODR_BITS);
}
#ifdef CONFIG_PM_DEVICE
static int lis2dh_pm_action(const struct device *dev,
enum pm_device_action action)
{
int status;
struct lis2dh_data *lis2dh = dev->data;
uint8_t regdata;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* read REFERENCE register (see datasheet rev 6 section 8.9 footnote 1) */
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_REFERENCE, ®data);
if (status < 0) {
LOG_ERR("failed to read reg_reference");
return status;
}
/* Resume previous mode. */
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1,
lis2dh->reg_ctrl1_active_val);
if (status < 0) {
LOG_ERR("failed to write reg_crtl1");
return status;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
/* Store current mode, suspend. */
status = lis2dh->hw_tf->read_reg(dev, LIS2DH_REG_CTRL1,
&lis2dh->reg_ctrl1_active_val);
if (status < 0) {
LOG_ERR("failed to read reg_crtl1");
return status;
}
status = lis2dh->hw_tf->write_reg(dev, LIS2DH_REG_CTRL1,
LIS2DH_SUSPEND);
if (status < 0) {
LOG_ERR("failed to write reg_crtl1");
return status;
}
break;
default:
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_PM_DEVICE */
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LIS2DH driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LIS2DH_DEFINE_SPI() and
* LIS2DH_DEFINE_I2C().
*/
#define LIS2DH_DEVICE_INIT(inst) \
PM_DEVICE_DT_INST_DEFINE(inst, lis2dh_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2dh_init, \
PM_DEVICE_DT_INST_GET(inst), \
&lis2dh_data_##inst, \
&lis2dh_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2dh_driver_api);
#define IS_LSM303AGR_DEV(inst) \
DT_INST_NODE_HAS_COMPAT(inst, st_lsm303agr_accel)
#define DISC_PULL_UP(inst) \
DT_INST_PROP(inst, disconnect_sdo_sa0_pull_up)
#define ANYM_ON_INT1(inst) \
DT_INST_PROP(inst, anym_on_int1)
#define ANYM_LATCH(inst) \
!DT_INST_PROP(inst, anym_no_latch)
#define ANYM_MODE(inst) \
DT_INST_PROP(inst, anym_mode)
#ifdef CONFIG_LIS2DH_TRIGGER
#define GPIO_DT_SPEC_INST_GET_BY_IDX_COND(id, prop, idx) \
COND_CODE_1(DT_INST_PROP_HAS_IDX(id, prop, idx), \
(GPIO_DT_SPEC_INST_GET_BY_IDX(id, prop, idx)), \
({.port = NULL, .pin = 0, .dt_flags = 0}))
#define LIS2DH_CFG_INT(inst) \
.gpio_drdy = \
COND_CODE_1(ANYM_ON_INT1(inst), \
({.port = NULL, .pin = 0, .dt_flags = 0}), \
(GPIO_DT_SPEC_INST_GET_BY_IDX_COND(inst, irq_gpios, 0))), \
.gpio_int = \
COND_CODE_1(ANYM_ON_INT1(inst), \
(GPIO_DT_SPEC_INST_GET_BY_IDX_COND(inst, irq_gpios, 0)), \
(GPIO_DT_SPEC_INST_GET_BY_IDX_COND(inst, irq_gpios, 1))), \
.int1_mode = DT_INST_PROP(inst, int1_gpio_config), \
.int2_mode = DT_INST_PROP(inst, int2_gpio_config),
#else
#define LIS2DH_CFG_INT(inst)
#endif /* CONFIG_LIS2DH_TRIGGER */
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
/* The first 8 bits are the integer portion of the temperature.
* The result is left justified. The remainder of the bits are
* the fractional part.
*
* LIS2DH has 8 total bits.
* LIS2DH12/LIS3DH have 10 bits unless they are in lower power mode.
* compat(lis2dh) cannot be used here because it is the base part.
*/
#define FRACTIONAL_BITS(inst) \
(DT_INST_NODE_HAS_COMPAT(inst, st_lis2dh12) || \
DT_INST_NODE_HAS_COMPAT(inst, st_lis3dh)) ? \
(IS_ENABLED(CONFIG_LIS2DH_OPER_MODE_LOW_POWER) ? 0 : 2) : \
0
#define LIS2DH_CFG_TEMPERATURE(inst) \
.temperature = { .cfg_addr = 0x1F, \
.enable_mask = 0xC0, \
.dout_addr = 0x0C, \
.fractional_bits = FRACTIONAL_BITS(inst) },
#else
#define LIS2DH_CFG_TEMPERATURE(inst)
#endif /* CONFIG_LIS2DH_MEASURE_TEMPERATURE */
#define LIS2DH_CONFIG_SPI(inst) \
{ \
.bus_init = lis2dh_spi_init, \
.bus_cfg = { .spi = SPI_DT_SPEC_INST_GET(inst, \
SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA, \
0) }, \
.hw = { .is_lsm303agr_dev = IS_LSM303AGR_DEV(inst), \
.disc_pull_up = DISC_PULL_UP(inst), \
.anym_on_int1 = ANYM_ON_INT1(inst), \
.anym_latch = ANYM_LATCH(inst), \
.anym_mode = ANYM_MODE(inst), }, \
LIS2DH_CFG_TEMPERATURE(inst) \
LIS2DH_CFG_INT(inst) \
}
#define LIS2DH_DEFINE_SPI(inst) \
static struct lis2dh_data lis2dh_data_##inst; \
static const struct lis2dh_config lis2dh_config_##inst = \
LIS2DH_CONFIG_SPI(inst); \
LIS2DH_DEVICE_INIT(inst)
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DH_CONFIG_I2C(inst) \
{ \
.bus_init = lis2dh_i2c_init, \
.bus_cfg = { .i2c = I2C_DT_SPEC_INST_GET(inst), }, \
.hw = { .is_lsm303agr_dev = IS_LSM303AGR_DEV(inst), \
.disc_pull_up = DISC_PULL_UP(inst), \
.anym_on_int1 = ANYM_ON_INT1(inst), \
.anym_latch = ANYM_LATCH(inst), \
.anym_mode = ANYM_MODE(inst), }, \
LIS2DH_CFG_TEMPERATURE(inst) \
LIS2DH_CFG_INT(inst) \
}
#define LIS2DH_DEFINE_I2C(inst) \
static struct lis2dh_data lis2dh_data_##inst; \
static const struct lis2dh_config lis2dh_config_##inst = \
LIS2DH_CONFIG_I2C(inst); \
LIS2DH_DEVICE_INIT(inst)
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DH_DEFINE(inst) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2DH_DEFINE_SPI(inst)), \
(LIS2DH_DEFINE_I2C(inst)))
DT_INST_FOREACH_STATUS_OKAY(LIS2DH_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/lis2dh.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,057 |
```unknown
# LIS2DH Three Axis Accelerometer configuration options
menuconfig LIS2DH
bool "LIS2DH Three Axis Accelerometer"
default y
depends on DT_HAS_ST_LIS2DH_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DH),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DH),spi)
help
Enable SPI/I2C-based driver for LIS2DH, LIS3DH, LSM303DLHC,
LIS2DH12, LSM303AGR triaxial accelerometer sensors.
if LIS2DH
choice LIS2DH_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LIS2DH_TRIGGER_NONE
bool "No trigger"
config LIS2DH_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LIS2DH_TRIGGER
config LIS2DH_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LIS2DH_TRIGGER
endchoice
config LIS2DH_TRIGGER
bool
config LIS2DH_THREAD_PRIORITY
int "Thread priority"
depends on LIS2DH_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LIS2DH_THREAD_STACK_SIZE
int "Thread stack size"
depends on LIS2DH_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
choice LIS2DH_ACCEL_RANGE
prompt "Acceleration measurement range"
default LIS2DH_ACCEL_RANGE_RUNTIME
help
Initial measurement full scale range for acceleration values.
config LIS2DH_ACCEL_RANGE_RUNTIME
bool "Set at runtime"
config LIS2DH_ACCEL_RANGE_2G
bool "+/-2g"
config LIS2DH_ACCEL_RANGE_4G
bool "+/-4g"
config LIS2DH_ACCEL_RANGE_8G
bool "+/-8g"
config LIS2DH_ACCEL_RANGE_16G
bool "+/-16g"
endchoice
choice LIS2DH_OPER_MODE
prompt "Operation mode"
default LIS2DH_OPER_MODE_NORMAL
help
Choose between high resolution, normal or low power operation
mode for chip at init.
config LIS2DH_OPER_MODE_HIGH_RES
bool "high resolution (12 bit)"
config LIS2DH_OPER_MODE_NORMAL
bool "normal (10 bit)"
config LIS2DH_OPER_MODE_LOW_POWER
bool "low power (8 bit)"
endchoice
choice LIS2DH_ODR
prompt "Output data rate frequency"
default LIS2DH_ODR_RUNTIME
help
Initial data rate frequency of acceleration data at initialization.
Supported values:
1Hz, 10Hz, 25Hz, 50Hz, 100Hz, 200Hz, 400Hz in all power modes
1620Hz, 5376Hz in low power mode only
1344Hz in normal power mode
config LIS2DH_ODR_RUNTIME
bool "Set at runtime"
config LIS2DH_ODR_1
bool "1Hz"
config LIS2DH_ODR_2
bool "10Hz"
config LIS2DH_ODR_3
bool "25Hz"
config LIS2DH_ODR_4
bool "50Hz"
config LIS2DH_ODR_5
bool "100Hz"
config LIS2DH_ODR_6
bool "200Hz"
config LIS2DH_ODR_7
bool "400Hz"
config LIS2DH_ODR_8
bool "1.6KHz"
depends on LIS2DH_OPER_MODE_LOW_POWER
config LIS2DH_ODR_9_NORMAL
bool "1.25KHz"
depends on LIS2DH_OPER_MODE_NORMAL || LIS2DH_OPER_MODE_HIGH_RES
config LIS2DH_ODR_9_LOW
bool "5KHz"
depends on LIS2DH_OPER_MODE_LOW_POWER
endchoice
config LIS2DH_ACCEL_HP_FILTERS
bool "Set High Pass filters for AOI functions on interrupt lines"
config LIS2DH_BLOCK_DATA_UPDATE
bool "Output registers not updated until MSB and LSB read"
config LIS2DH_MEASURE_TEMPERATURE
bool "Temperature measurements"
select LIS2DH_BLOCK_DATA_UPDATE
help
The temperature sensor is most suitable for measuring
relative temperature. For example, it is X degrees C
cooler or warmer.
Each chip has an offset. This offset must be applied
to the result. The offset can be obtained by comparing
the reported temperature to a reference.
This option does not apply to the LSM330DLHC.
endif # LIS2DH
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 992 |
```objective-c
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DH_LIS2DH_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DH_LIS2DH_H_
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/sys/util.h>
#include <stdint.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <string.h>
#define LIS2DH_REG_WAI 0x0f
#define LIS2DH_CHIP_ID 0x33
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LIS2DH_AUTOINCREMENT_ADDR BIT(7)
#define LIS2DH_REG_CTRL0 0x1e
#define LIS2DH_SDO_PU_DISC_MASK BIT(7)
#define LIS2DH_REG_CTRL1 0x20
#define LIS2DH_ACCEL_X_EN_BIT BIT(0)
#define LIS2DH_ACCEL_Y_EN_BIT BIT(1)
#define LIS2DH_ACCEL_Z_EN_BIT BIT(2)
#define LIS2DH_ACCEL_EN_BITS (LIS2DH_ACCEL_X_EN_BIT | \
LIS2DH_ACCEL_Y_EN_BIT | \
LIS2DH_ACCEL_Z_EN_BIT)
#define LIS2DH_ACCEL_XYZ_MASK BIT_MASK(3)
#define LIS2DH_LP_EN_BIT_MASK BIT(3)
#if defined(CONFIG_LIS2DH_OPER_MODE_LOW_POWER)
#define LIS2DH_LP_EN_BIT BIT(3)
#else
#define LIS2DH_LP_EN_BIT 0
#endif
#define LIS2DH_SUSPEND 0
#define LIS2DH_ODR_1 1
#define LIS2DH_ODR_2 2
#define LIS2DH_ODR_3 3
#define LIS2DH_ODR_4 4
#define LIS2DH_ODR_5 5
#define LIS2DH_ODR_6 6
#define LIS2DH_ODR_7 7
#define LIS2DH_ODR_8 8
#define LIS2DH_ODR_9 9
#if defined(CONFIG_LIS2DH_ODR_1)
#define LIS2DH_ODR_IDX LIS2DH_ODR_1
#elif defined(CONFIG_LIS2DH_ODR_2)
#define LIS2DH_ODR_IDX LIS2DH_ODR_2
#elif defined(CONFIG_LIS2DH_ODR_3)
#define LIS2DH_ODR_IDX LIS2DH_ODR_3
#elif defined(CONFIG_LIS2DH_ODR_4) || defined(CONFIG_LIS2DH_ODR_RUNTIME)
#define LIS2DH_ODR_IDX LIS2DH_ODR_4
#elif defined(CONFIG_LIS2DH_ODR_5)
#define LIS2DH_ODR_IDX LIS2DH_ODR_5
#elif defined(CONFIG_LIS2DH_ODR_6)
#define LIS2DH_ODR_IDX LIS2DH_ODR_6
#elif defined(CONFIG_LIS2DH_ODR_7)
#define LIS2DH_ODR_IDX LIS2DH_ODR_7
#elif defined(CONFIG_LIS2DH_ODR_8)
#define LIS2DH_ODR_IDX LIS2DH_ODR_8
#elif defined(CONFIG_LIS2DH_ODR_9_NORMAL) || defined(CONFIG_LIS2DH_ODR_9_LOW)
#define LIS2DH_ODR_IDX LIS2DH_ODR_9
#endif
#define LIS2DH_ODR_SHIFT 4
#define LIS2DH_ODR_RATE(r) ((r) << LIS2DH_ODR_SHIFT)
#define LIS2DH_ODR_BITS (LIS2DH_ODR_RATE(LIS2DH_ODR_IDX))
#define LIS2DH_ODR_MASK (BIT_MASK(4) << LIS2DH_ODR_SHIFT)
#define LIS2DH_REG_CTRL2 0x21
#define LIS2DH_HPIS1_EN_BIT BIT(0)
#define LIS2DH_HPIS2_EN_BIT BIT(1)
#define LIS2DH_FDS_EN_BIT BIT(3)
#define LIS2DH_HPIS_EN_MASK BIT_MASK(2)
#define LIS2DH_REG_CTRL3 0x22
#define LIS2DH_EN_CLICK_INT1 BIT(7)
#define LIS2DH_EN_IA_INT1 BIT(6)
#define LIS2DH_EN_DRDY1_INT1 BIT(4)
#define LIS2DH_REG_CTRL4 0x23
#define LIS2DH_CTRL4_BDU_BIT BIT(7)
#define LIS2DH_FS_SHIFT 4
#define LIS2DH_FS_MASK (BIT_MASK(2) << LIS2DH_FS_SHIFT)
#if defined(CONFIG_LIS2DH_ACCEL_RANGE_2G) ||\
defined(CONFIG_LIS2DH_ACCEL_RANGE_RUNTIME)
#define LIS2DH_FS_IDX 0
#elif defined(CONFIG_LIS2DH_ACCEL_RANGE_4G)
#define LIS2DH_FS_IDX 1
#elif defined(CONFIG_LIS2DH_ACCEL_RANGE_8G)
#define LIS2DH_FS_IDX 2
#elif defined(CONFIG_LIS2DH_ACCEL_RANGE_16G)
#define LIS2DH_FS_IDX 3
#endif
#define LIS2DH_FS_SELECT(fs) ((fs) << LIS2DH_FS_SHIFT)
#define LIS2DH_FS_BITS (LIS2DH_FS_SELECT(LIS2DH_FS_IDX))
#if defined(CONFIG_LIS2DH_OPER_MODE_HIGH_RES)
#define LIS2DH_HR_BIT BIT(3)
#else
#define LIS2DH_HR_BIT 0
#endif
#define LIS2DH_REG_CTRL5 0x24
#define LIS2DH_EN_LIR_INT2 BIT(1)
#define LIS2DH_EN_LIR_INT1 BIT(3)
#define LIS2DH_REG_CTRL6 0x25
#define LIS2DH_EN_CLICK_INT2 BIT(7)
#define LIS2DH_EN_IA_INT2 BIT(5)
#define LIS2DH_REG_REFERENCE 0x26
#define LIS2DH_REG_STATUS 0x27
#define LIS2DH_STATUS_ZYZ_OVR BIT(7)
#define LIS2DH_STATUS_Z_OVR BIT(6)
#define LIS2DH_STATUS_Y_OVR BIT(5)
#define LIS2DH_STATUS_X_OVR BIT(4)
#define LIS2DH_STATUS_OVR_MASK (BIT_MASK(4) << 4)
#define LIS2DH_STATUS_ZYX_DRDY BIT(3)
#define LIS2DH_STATUS_Z_DRDY BIT(2)
#define LIS2DH_STATUS_Y_DRDY BIT(1)
#define LIS2DH_STATUS_X_DRDY BIT(0)
#define LIS2DH_STATUS_DRDY_MASK BIT_MASK(4)
#define LIS2DH_REG_ACCEL_X_LSB 0x28
#define LIS2DH_REG_ACCEL_Y_LSB 0x2A
#define LIS2DH_REG_ACCEL_Z_LSB 0x2C
#define LIS2DH_REG_ACCEL_X_MSB 0x29
#define LIS2DH_REG_ACCEL_Y_MSB 0x2B
#define LIS2DH_REG_ACCEL_Z_MSB 0x2D
#define LIS2DH_REG_INT1_CFG 0x30
#define LIS2DH_REG_INT1_SRC 0x31
#define LIS2DH_REG_INT1_THS 0x32
#define LIS2DH_REG_INT1_DUR 0x33
#define LIS2DH_REG_INT2_CFG 0x34
#define LIS2DH_REG_INT2_SRC 0x35
#define LIS2DH_REG_INT2_THS 0x36
#define LIS2DH_REG_INT2_DUR 0x37
#define LIS2DH_INT_CFG_MODE_SHIFT 6
#define LIS2DH_INT_CFG_AOI_CFG BIT(7)
#define LIS2DH_INT_CFG_6D_CFG BIT(6)
#define LIS2DH_INT_CFG_ZHIE_ZUPE BIT(5)
#define LIS2DH_INT_CFG_ZLIE_ZDOWNE BIT(4)
#define LIS2DH_INT_CFG_YHIE_YUPE BIT(3)
#define LIS2DH_INT_CFG_YLIE_YDOWNE BIT(2)
#define LIS2DH_INT_CFG_XHIE_XUPE BIT(1)
#define LIS2DH_INT_CFG_XLIE_XDOWNE BIT(0)
#define LIS2DH_REG_CFG_CLICK 0x38
#define LIS2DH_EN_CLICK_ZD BIT(5)
#define LIS2DH_EN_CLICK_ZS BIT(4)
#define LIS2DH_EN_CLICK_YD BIT(3)
#define LIS2DH_EN_CLICK_YS BIT(2)
#define LIS2DH_EN_CLICK_XD BIT(1)
#define LIS2DH_EN_CLICK_XS BIT(0)
#define LIS2DH_REG_CLICK_SRC 0x39
#define LIS2DH_CLICK_SRC_DCLICK BIT(5)
#define LIS2DH_CLICK_SRC_SCLICK BIT(4)
#define LIS2DH_REG_CFG_CLICK_THS 0x3A
#define LIS2DH_CLICK_LIR BIT(7)
#define LIS2DH_REG_TIME_LIMIT 0x3B
/* sample buffer size includes status register */
#define LIS2DH_BUF_SZ 7
union lis2dh_sample {
uint8_t raw[LIS2DH_BUF_SZ];
struct {
uint8_t status;
int16_t xyz[3];
} __packed;
};
union lis2dh_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
};
struct temperature {
uint8_t cfg_addr;
uint8_t enable_mask;
uint8_t dout_addr;
uint8_t fractional_bits;
};
struct lis2dh_config {
int (*bus_init)(const struct device *dev);
const union lis2dh_bus_cfg bus_cfg;
#ifdef CONFIG_LIS2DH_TRIGGER
const struct gpio_dt_spec gpio_drdy;
const struct gpio_dt_spec gpio_int;
const uint8_t int1_mode;
const uint8_t int2_mode;
#endif /* CONFIG_LIS2DH_TRIGGER */
struct {
bool is_lsm303agr_dev : 1;
bool disc_pull_up : 1;
bool anym_on_int1 : 1;
bool anym_latch : 1;
uint8_t anym_mode : 2;
} hw;
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
const struct temperature temperature;
#endif
};
struct lis2dh_transfer_function {
int (*read_data)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len);
int (*write_data)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len);
int (*read_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t *value);
int (*write_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t value);
int (*update_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value);
};
struct lis2dh_data {
const struct device *bus;
const struct lis2dh_transfer_function *hw_tf;
union lis2dh_sample sample;
/* current scaling factor, in micro m/s^2 / lsb */
uint32_t scale;
#ifdef CONFIG_LIS2DH_MEASURE_TEMPERATURE
struct sensor_value temperature;
#endif
#ifdef CONFIG_PM_DEVICE
uint8_t reg_ctrl1_active_val;
#endif
#ifdef CONFIG_LIS2DH_TRIGGER
const struct device *dev;
struct gpio_callback gpio_int1_cb;
struct gpio_callback gpio_int2_cb;
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trig_drdy;
sensor_trigger_handler_t handler_anymotion;
const struct sensor_trigger *trig_anymotion;
sensor_trigger_handler_t handler_tap;
const struct sensor_trigger *trig_tap;
atomic_t trig_flags;
enum sensor_channel chan_drdy;
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LIS2DH_TRIGGER */
};
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
int lis2dh_spi_access(struct lis2dh_data *ctx, uint8_t cmd,
void *data, size_t length);
#endif
#ifdef CONFIG_LIS2DH_TRIGGER
int lis2dh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lis2dh_init_interrupt(const struct device *dev);
int lis2dh_acc_slope_config(const struct device *dev,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif
#ifdef CONFIG_LIS2DH_ACCEL_HP_FILTERS
int lis2dh_acc_hp_filter_set(const struct device *dev,
int32_t val);
#endif
int lis2dh_spi_init(const struct device *dev);
int lis2dh_i2c_init(const struct device *dev);
#endif /* __SENSOR_LIS2DH__ */
``` | /content/code_sandbox/drivers/sensor/st/lis2dh/lis2dh.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,932 |
```c
/* ST Microelectronics LSM6DSV16X 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dsv16x
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "lsm6dsv16x.h"
LOG_MODULE_REGISTER(LSM6DSV16X, CONFIG_SENSOR_LOG_LEVEL);
/*
* values taken from lsm6dsv16x_data_rate_t in hal/st module. The mode/accuracy
* should be selected through accel-odr property in DT
*/
static const float lsm6dsv16x_odr_map[3][13] = {
/* High Accuracy off */
{0.0f, 1.875f, 7.5f, 15.0f, 30.0f, 60.0f,
120.0f, 240.0f, 480.0f, 960.0f, 1920.0f,
3840.0f, 7680.0f},
/* High Accuracy 1 */
{0.0f, 1.875f, 7.5f, 15.625f, 31.25f, 62.5f,
125.0f, 250.0f, 500.0f, 1000.0f, 2000.0f,
4000.0f, 8000.0f},
/* High Accuracy 2 */
{0.0f, 1.875f, 7.5f, 12.5f, 25.0f, 50.0f,
100.0f, 200.0f, 400.0f, 800.0f, 1600.0f,
3200.0f, 6400.0f},
};
static int lsm6dsv16x_freq_to_odr_val(const struct device *dev, uint16_t freq)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_data_rate_t odr;
int8_t mode;
size_t i;
if (lsm6dsv16x_xl_data_rate_get(ctx, &odr) < 0) {
return -EINVAL;
}
mode = (odr >> 4) & 0xf;
for (i = 0; i < ARRAY_SIZE(lsm6dsv16x_odr_map[mode]); i++) {
if (freq <= lsm6dsv16x_odr_map[mode][i]) {
LOG_DBG("mode: %d - odr: %d", mode, i);
return i;
}
}
return -EINVAL;
}
static const uint16_t lsm6dsv16x_accel_fs_map[] = {2, 4, 8, 16};
static int lsm6dsv16x_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dsv16x_accel_fs_map); i++) {
if (range == lsm6dsv16x_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static const uint16_t lsm6dsv16x_gyro_fs_map[] = {125, 250, 500, 1000, 2000, 0, 0,
0, 0, 0, 0, 0, 4000};
static const uint16_t lsm6dsv16x_gyro_fs_sens[] = {1, 2, 4, 8, 16, 0, 0, 0, 0, 0, 0, 0, 32};
static int lsm6dsv16x_gyro_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dsv16x_gyro_fs_map); i++) {
if (range == lsm6dsv16x_gyro_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static int lsm6dsv16x_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
lsm6dsv16x_xl_full_scale_t val;
switch (fs) {
case 0:
val = LSM6DSV16X_2g;
break;
case 1:
val = LSM6DSV16X_4g;
break;
case 2:
val = LSM6DSV16X_8g;
break;
case 3:
val = LSM6DSV16X_16g;
break;
default:
return -EIO;
}
if (lsm6dsv16x_xl_full_scale_set(ctx, val) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
static int lsm6dsv16x_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
if (lsm6dsv16x_xl_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = odr;
return 0;
}
static int lsm6dsv16x_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dsv16x_gy_full_scale_set(ctx, fs) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dsv16x_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
if (lsm6dsv16x_gy_data_rate_set(ctx, odr) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dsv16x_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dsv16x_freq_to_odr_val(dev, freq);
if (odr < 0) {
return odr;
}
if (lsm6dsv16x_accel_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dsv16x_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dsv16x_data *data = dev->data;
fs = lsm6dsv16x_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dsv16x_accel_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = lsm6dsv16x_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
return 0;
}
static int lsm6dsv16x_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_xl_mode_t mode;
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dsv16x_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dsv16x_accel_odr_set(dev, val->val1);
case SENSOR_ATTR_CONFIGURATION:
switch (val->val1) {
case 0: /* High Performance */
mode = LSM6DSV16X_XL_HIGH_PERFORMANCE_MD;
break;
case 1: /* High Accuracy */
mode = LSM6DSV16X_XL_HIGH_ACCURACY_ODR_MD;
break;
case 3: /* ODR triggered */
mode = LSM6DSV16X_XL_ODR_TRIGGERED_MD;
break;
case 4: /* Low Power 2 */
mode = LSM6DSV16X_XL_LOW_POWER_2_AVG_MD;
break;
case 5: /* Low Power 4 */
mode = LSM6DSV16X_XL_LOW_POWER_4_AVG_MD;
break;
case 6: /* Low Power 8 */
mode = LSM6DSV16X_XL_LOW_POWER_8_AVG_MD;
break;
case 7: /* Normal */
mode = LSM6DSV16X_XL_NORMAL_MD;
break;
default:
return -EIO;
}
return lsm6dsv16x_xl_mode_set(ctx, mode);
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dsv16x_gyro_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
if (freq < 8) {
return -EIO;
}
odr = lsm6dsv16x_freq_to_odr_val(dev, freq);
if (odr < 0) {
return odr;
}
if (lsm6dsv16x_gyro_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
return 0;
}
static int lsm6dsv16x_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dsv16x_data *data = dev->data;
fs = lsm6dsv16x_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dsv16x_gyro_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_gain = (lsm6dsv16x_gyro_fs_sens[fs] * GAIN_UNIT_G);
return 0;
}
static int lsm6dsv16x_gyro_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_gy_mode_t mode;
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lsm6dsv16x_gyro_range_set(dev, sensor_rad_to_degrees(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dsv16x_gyro_odr_set(dev, val->val1);
case SENSOR_ATTR_CONFIGURATION:
switch (val->val1) {
case 0: /* High Performance */
mode = LSM6DSV16X_GY_HIGH_PERFORMANCE_MD;
break;
case 1: /* High Accuracy */
mode = LSM6DSV16X_GY_HIGH_ACCURACY_ODR_MD;
break;
case 4: /* Sleep */
mode = LSM6DSV16X_GY_SLEEP_MD;
break;
case 5: /* Low Power */
mode = LSM6DSV16X_GY_LOW_POWER_MD;
break;
default:
return -EIO;
}
return lsm6dsv16x_gy_mode_set(ctx, mode);
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dsv16x_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
struct lsm6dsv16x_data *data = dev->data;
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm6dsv16x_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm6dsv16x_gyro_config(dev, chan, attr, val);
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
case SENSOR_CHAN_MAGN_XYZ:
case SENSOR_CHAN_PRESS:
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("shub not inited.");
return -ENOTSUP;
}
return lsm6dsv16x_shub_config(dev, chan, attr, val);
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dsv16x_sample_fetch_accel(const struct device *dev)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
if (lsm6dsv16x_acceleration_raw_get(ctx, data->acc) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
static int lsm6dsv16x_sample_fetch_gyro(const struct device *dev)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
if (lsm6dsv16x_angular_rate_raw_get(ctx, data->gyro) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
static int lsm6dsv16x_sample_fetch_temp(const struct device *dev)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
if (lsm6dsv16x_temperature_raw_get(ctx, &data->temp_sample) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return 0;
}
#endif
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
static int lsm6dsv16x_sample_fetch_shub(const struct device *dev)
{
if (lsm6dsv16x_shub_fetch_external_devs(dev) < 0) {
LOG_DBG("failed to read ext shub devices");
return -EIO;
}
return 0;
}
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
static int lsm6dsv16x_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
struct lsm6dsv16x_data *data = dev->data;
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dsv16x_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6dsv16x_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dsv16x_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm6dsv16x_sample_fetch_accel(dev);
lsm6dsv16x_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
lsm6dsv16x_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
if (data->shub_inited) {
lsm6dsv16x_sample_fetch_shub(dev);
}
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dsv16x_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int lsm6dsv16x_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsv16x_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm6dsv16x_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm6dsv16x_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm6dsv16x_accel_convert(val, data->acc[2], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 3; i++) {
lsm6dsv16x_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dsv16x_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
return lsm6dsv16x_accel_get_channel(chan, val, data, data->acc_gain);
}
static inline void lsm6dsv16x_gyro_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in udps/LSB */
/* So, calculate value in 10 udps unit and then to rad/s */
dval = (int64_t)(raw_val) * sensitivity / 10;
sensor_10udegrees_to_rad(dval, val);
}
static inline int lsm6dsv16x_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsv16x_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm6dsv16x_gyro_convert(val, data->gyro[0], sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
lsm6dsv16x_gyro_convert(val, data->gyro[1], sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
lsm6dsv16x_gyro_convert(val, data->gyro[2], sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
for (i = 0; i < 3; i++) {
lsm6dsv16x_gyro_convert(val++, data->gyro[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dsv16x_gyro_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
return lsm6dsv16x_gyro_get_channel(chan, val, data, data->gyro_gain);
}
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
static void lsm6dsv16x_gyro_channel_get_temp(struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
int32_t micro_c;
/* convert units to micro Celsius. Raw temperature samples are
* expressed in 256 LSB/deg_C units. And LSB output is 0 at 25 C.
*/
micro_c = (data->temp_sample * 1000000) / 256;
val->val1 = micro_c / 1000000 + 25;
val->val2 = micro_c % 1000000;
}
#endif
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
static inline void lsm6dsv16x_magn_convert(struct sensor_value *val, int raw_val,
uint16_t sensitivity)
{
double dval;
/* Sensitivity is exposed in ugauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int lsm6dsv16x_magn_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
int16_t sample[3];
int idx;
idx = lsm6dsv16x_shub_get_idx(data->dev, SENSOR_CHAN_MAGN_XYZ);
if (idx < 0) {
LOG_DBG("external magn not supported");
return -ENOTSUP;
}
sample[0] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
sample[1] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][2] |
(data->ext_data[idx][3] << 8)));
sample[2] = sys_le16_to_cpu((int16_t)(data->ext_data[idx][4] |
(data->ext_data[idx][5] << 8)));
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm6dsv16x_magn_convert(val, sample[0], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Y:
lsm6dsv16x_magn_convert(val, sample[1], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Z:
lsm6dsv16x_magn_convert(val, sample[2], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm6dsv16x_magn_convert(val, sample[0], data->magn_gain);
lsm6dsv16x_magn_convert(val + 1, sample[1], data->magn_gain);
lsm6dsv16x_magn_convert(val + 2, sample[2], data->magn_gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dsv16x_hum_convert(struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
float rh;
int16_t raw_val;
struct hts221_data *ht = &data->hts221;
int idx;
idx = lsm6dsv16x_shub_get_idx(data->dev, SENSOR_CHAN_HUMIDITY);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
/* find relative humidty by linear interpolation */
rh = (ht->y1 - ht->y0) * raw_val + ht->x1 * ht->y0 - ht->x0 * ht->y1;
rh /= (ht->x1 - ht->x0);
/* convert humidity to integer and fractional part */
val->val1 = rh;
val->val2 = rh * 1000000;
}
static inline void lsm6dsv16x_press_convert(struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
int32_t raw_val;
int idx;
idx = lsm6dsv16x_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le32_to_cpu((int32_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8) |
(data->ext_data[idx][2] << 16)));
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void lsm6dsv16x_temp_convert(struct sensor_value *val,
struct lsm6dsv16x_data *data)
{
int16_t raw_val;
int idx;
idx = lsm6dsv16x_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = sys_le16_to_cpu((int16_t)(data->ext_data[idx][3] |
(data->ext_data[idx][4] << 8)));
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int lsm6dsv16x_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm6dsv16x_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dsv16x_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm6dsv16x_gyro_channel_get(chan, val, data);
break;
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dsv16x_gyro_channel_get_temp(val, data);
break;
#endif
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dsv16x_magn_get_channel(chan, val, data);
break;
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dsv16x_hum_convert(val, data);
break;
case SENSOR_CHAN_PRESS:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dsv16x_press_convert(val, data);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
lsm6dsv16x_temp_convert(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm6dsv16x_driver_api = {
.attr_set = lsm6dsv16x_attr_set,
#if CONFIG_LSM6DSV16X_TRIGGER
.trigger_set = lsm6dsv16x_trigger_set,
#endif
.sample_fetch = lsm6dsv16x_sample_fetch,
.channel_get = lsm6dsv16x_channel_get,
};
static int lsm6dsv16x_init_chip(const struct device *dev)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *lsm6dsv16x = dev->data;
uint8_t chip_id;
uint8_t odr, fs;
/* All registers except 0x01 are different between banks, including the WHO_AM_I
* register and the register used for a SW reset. If the lsm6dsv16x wasn't on the user
* bank when it reset, then both the chip id check and the sw reset will fail unless we
* set the bank now.
*/
if (lsm6dsv16x_mem_bank_set(ctx, LSM6DSV16X_MAIN_MEM_BANK) < 0) {
LOG_DBG("Failed to set user bank");
return -EIO;
}
if (lsm6dsv16x_device_id_get(ctx, &chip_id) < 0) {
LOG_DBG("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (chip_id != LSM6DSV16X_ID) {
LOG_DBG("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* reset device (sw_por) */
if (lsm6dsv16x_reset_set(ctx, LSM6DSV16X_GLOBAL_RST) < 0) {
return -EIO;
}
/* wait 30ms as reported in AN5763 */
k_sleep(K_MSEC(30));
fs = cfg->accel_range;
LOG_DBG("accel range is %d", fs);
if (lsm6dsv16x_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer range %d", fs);
return -EIO;
}
lsm6dsv16x->acc_gain = lsm6dsv16x_accel_fs_map[fs] * GAIN_UNIT_XL / 2;
odr = cfg->accel_odr;
LOG_DBG("accel odr is %d", odr);
if (lsm6dsv16x_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer odr %d", odr);
return -EIO;
}
fs = cfg->gyro_range;
LOG_DBG("gyro range is %d", fs);
if (lsm6dsv16x_gyro_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set gyroscope range %d", fs);
return -EIO;
}
lsm6dsv16x->gyro_gain = (lsm6dsv16x_gyro_fs_sens[fs] * GAIN_UNIT_G);
odr = cfg->gyro_odr;
LOG_DBG("gyro odr is %d", odr);
lsm6dsv16x->gyro_freq = odr;
if (lsm6dsv16x_gyro_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set gyroscope odr %d", odr);
return -EIO;
}
if (lsm6dsv16x_block_data_update_set(ctx, 1) < 0) {
LOG_DBG("failed to set BDU mode");
return -EIO;
}
return 0;
}
static int lsm6dsv16x_init(const struct device *dev)
{
#ifdef CONFIG_LSM6DSV16X_TRIGGER
const struct lsm6dsv16x_config *cfg = dev->config;
#endif
struct lsm6dsv16x_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (lsm6dsv16x_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_LSM6DSV16X_TRIGGER
if (cfg->trig_enabled) {
if (lsm6dsv16x_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
#ifdef CONFIG_LSM6DSV16X_SENSORHUB
data->shub_inited = true;
if (lsm6dsv16x_shub_init(dev) < 0) {
LOG_INF("shub: no external chips found");
data->shub_inited = false;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LSM6DSV16X driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LSM6DSV16X_DEFINE_SPI() and
* LSM6DSV16X_DEFINE_I2C().
*/
#define LSM6DSV16X_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lsm6dsv16x_init, \
NULL, \
&lsm6dsv16x_data_##inst, \
&lsm6dsv16x_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lsm6dsv16x_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LSM6DSV16X_TRIGGER
#define LSM6DSV16X_CFG_IRQ(inst) \
.trig_enabled = true, \
.int1_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int1_gpios, { 0 }), \
.int2_gpio = GPIO_DT_SPEC_INST_GET_OR(inst, int2_gpios, { 0 }), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed), \
.drdy_pin = DT_INST_PROP(inst, drdy_pin)
#else
#define LSM6DSV16X_CFG_IRQ(inst)
#endif /* CONFIG_LSM6DSV16X_TRIGGER */
#define LSM6DSV16X_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LSM6DSV16X_CONFIG_COMMON(inst) \
.accel_odr = DT_INST_PROP(inst, accel_odr), \
.accel_range = DT_INST_PROP(inst, accel_range), \
.gyro_odr = DT_INST_PROP(inst, gyro_odr), \
.gyro_range = DT_INST_PROP(inst, gyro_range), \
IF_ENABLED(UTIL_OR(DT_INST_NODE_HAS_PROP(inst, int1_gpios), \
DT_INST_NODE_HAS_PROP(inst, int2_gpios)), \
(LSM6DSV16X_CFG_IRQ(inst)))
#define LSM6DSV16X_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lsm6dsv16x_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LSM6DSV16X_SPI_OP, \
0), \
}, \
LSM6DSV16X_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LSM6DSV16X_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lsm6dsv16x_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LSM6DSV16X_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LSM6DSV16X_DEFINE(inst) \
static struct lsm6dsv16x_data lsm6dsv16x_data_##inst; \
static const struct lsm6dsv16x_config lsm6dsv16x_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LSM6DSV16X_CONFIG_SPI(inst)), \
(LSM6DSV16X_CONFIG_I2C(inst))); \
LSM6DSV16X_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LSM6DSV16X_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsv16x/lsm6dsv16x.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 8,409 |
```c
/* ST Microelectronics LSM6DSV16X 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dsv16x
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm6dsv16x.h"
LOG_MODULE_DECLARE(LSM6DSV16X, CONFIG_SENSOR_LOG_LEVEL);
static int lsm6dsv16x_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static int lsm6dsv16x_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len);
static void lsm6dsv16x_shub_enable(const struct device *dev, uint8_t enable);
/* ST HAL skips this register, only supports it via the slower lsm6dsv16x_sh_status_get() */
static int32_t lsm6dsv16x_sh_status_mainpage_get(stmdev_ctx_t *ctx,
lsm6dsv16x_status_master_t *val)
{
return lsm6dsv16x_read_reg(ctx, LSM6DSV16X_STATUS_MASTER_MAINPAGE, (uint8_t *)val, 1);
}
/*
* LIS2MDL magn device specific part
*/
#ifdef CONFIG_LSM6DSV16X_EXT_LIS2MDL
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_ODR_100HZ 0x0C
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int lsm6dsv16x_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct lsm6dsv16x_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_gain = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int lsm6dsv16x_lis2mdl_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lis2mdl_map); odr++) {
if (freq <= lis2mdl_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lis2mdl_map)) {
LOG_DBG("shub: LIS2MDL freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 2);
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, &cfg, 1);
lsm6dsv16x_shub_enable(dev, 1);
return 0;
}
static int lsm6dsv16x_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 lsm6dsv16x_lis2mdl_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSV16X_EXT_LIS2MDL */
/*
* HTS221 humidity device specific part
*/
#ifdef CONFIG_LSM6DSV16X_EXT_HTS221
#define HTS221_AUTOINCREMENT BIT(7)
#define HTS221_REG_CTRL1 0x20
#define HTS221_ODR_1HZ 0x01
#define HTS221_BDU 0x04
#define HTS221_PD 0x80
#define HTS221_REG_CONV_START 0x30
static int lsm6dsv16x_hts221_read_conv_data(const struct device *dev,
uint8_t i2c_addr)
{
struct lsm6dsv16x_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 (lsm6dsv16x_shub_read_target_reg(dev, i2c_addr,
(HTS221_REG_CONV_START + i) |
HTS221_AUTOINCREMENT,
&buf[i], len) < 0) {
LOG_DBG("shub: failed to read hts221 conv data");
return -EIO;
}
}
ht->y0 = buf[0] / 2;
ht->y1 = buf[1] / 2;
ht->x0 = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
ht->x1 = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
return 0;
}
static int lsm6dsv16x_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &hum_cfg, 1);
return lsm6dsv16x_hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int lsm6dsv16x_hts221_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(hts221_map); odr++) {
if (freq <= hts221_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(hts221_map)) {
LOG_DBG("shub: HTS221 freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = odr | HTS221_BDU | HTS221_PD;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &cfg, 1);
lsm6dsv16x_shub_enable(dev, 1);
return 0;
}
static int lsm6dsv16x_hts221_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 lsm6dsv16x_hts221_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: HTS221 attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSV16X_EXT_HTS221 */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int lsm6dsv16x_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
lsm6dsv16x_shub_write_target_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;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22HB */
/*
* LPS22HH baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22HH
#define LPS22HH_CTRL_REG1 0x10
#define LPS22HH_CTRL_REG2 0x11
#define LPS22HH_SW_RESET 0x04
#define LPS22HH_IF_ADD_INC 0x10
#define LPS22HH_ODR_10HZ 0x20
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
static int lsm6dsv16x_lps22hh_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HH_SW_RESET;
lsm6dsv16x_shub_write_target_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;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22HH_ODR_10HZ | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int lsm6dsv16x_lps22hh_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22hh_map); odr++) {
if (freq <= lps22hh_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22hh_map)) {
LOG_DBG("shub: LPS22HH freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, &cfg, 1);
lsm6dsv16x_shub_enable(dev, 1);
return 0;
}
static int lsm6dsv16x_lps22hh_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 lsm6dsv16x_lps22hh_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22HH attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22HH */
/*
* LPS22DF baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22DF
#define LPS22DF_CTRL_REG1 0x10
#define LPS22DF_CTRL_REG2 0x11
#define LPS22DF_SW_RESET 0x04
#define LPS22DF_BDU_EN 0x08
#define LPS22DF_EN_LPFP 0x10
#define LPS22DF_ODR_10HZ 0x18
#define LPS22DF_AVG_16 0x02
static int lsm6dsv16x_lps22df_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22DF_SW_RESET;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG2, baro_cfg, 1);
k_busy_wait(50); /* turn-on time in us */
/* configure device */
baro_cfg[0] = LPS22DF_BDU_EN | LPS22DF_EN_LPFP;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG2, baro_cfg, 1);
baro_cfg[0] = LPS22DF_ODR_10HZ | LPS22DF_AVG_16;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22df_map[] = {0, 1, 4, 10, 25, 50, 75, 100, 200};
static int lsm6dsv16x_lps22df_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22df_map); odr++) {
if (freq <= lps22df_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22df_map)) {
LOG_DBG("shub: LPS22DF freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 3) | LPS22DF_AVG_16;
lsm6dsv16x_shub_write_target_reg(dev, i2c_addr,
LPS22DF_CTRL_REG1, &cfg, 1);
lsm6dsv16x_shub_enable(dev, 1);
return 0;
}
static int lsm6dsv16x_lps22df_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 lsm6dsv16x_lps22df_odr_set(dev, i2c_addr, val->val1);
default:
LOG_DBG("shub: LPS22DF attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22DF */
/* List of supported external sensors */
static struct lsm6dsv16x_shub_slist {
enum sensor_channel type;
uint8_t i2c_addr[2];
uint8_t ext_i2c_addr;
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
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);
} lsm6dsv16x_shub_slist[] = {
#ifdef CONFIG_LSM6DSV16X_EXT_LIS2MDL
{
/* LIS2MDL */
.type = SENSOR_CHAN_MAGN_XYZ,
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (lsm6dsv16x_lis2mdl_init),
.dev_conf = (lsm6dsv16x_lis2mdl_conf),
},
#endif /* CONFIG_LSM6DSV16X_EXT_LIS2MDL */
#ifdef CONFIG_LSM6DSV16X_EXT_HTS221
{
/* HTS221 */
.type = SENSOR_CHAN_HUMIDITY,
.i2c_addr = { 0x5F },
.wai_addr = 0x0F,
.wai_val = 0xBC,
.out_data_addr = 0x28 | HTS221_AUTOINCREMENT,
.out_data_len = 0x02,
.dev_init = (lsm6dsv16x_hts221_init),
.dev_conf = (lsm6dsv16x_hts221_conf),
},
#endif /* CONFIG_LSM6DSV16X_EXT_HTS221 */
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22HB
{
/* LPS22HB */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dsv16x_lps22hb_init),
},
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22HB */
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22HH
{
/* LPS22HH */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB3,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dsv16x_lps22hh_init),
.dev_conf = (lsm6dsv16x_lps22hh_conf),
},
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22HH */
#ifdef CONFIG_LSM6DSV16X_EXT_LPS22DF
{
/* LPS22DF */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB4,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dsv16x_lps22df_init),
.dev_conf = (lsm6dsv16x_lps22df_conf),
},
#endif /* CONFIG_LSM6DSV16X_EXT_LPS22DF */
};
static int lsm6dsv16x_shub_wait_completed(stmdev_ctx_t *ctx)
{
lsm6dsv16x_status_master_t status;
int tries = 200; /* Should be max ~160 ms, from 2 cycles at slowest ODR 12.5 Hz */
do {
if (!--tries) {
LOG_DBG("shub: Timeout waiting for operation to complete");
return -ETIMEDOUT;
}
k_msleep(1);
lsm6dsv16x_sh_status_mainpage_get(ctx, &status);
} while (status.sens_hub_endop == 0);
return 1;
}
static void lsm6dsv16x_shub_enable(const struct device *dev, uint8_t enable)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
/* Enable Accel @26hz */
if (!data->accel_freq) {
uint8_t odr = (enable) ? 2 : 0;
if (lsm6dsv16x_xl_data_rate_set(ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
if (enable) {
lsm6dsv16x_status_master_t status;
/* Clear any pending status flags */
lsm6dsv16x_sh_status_mainpage_get(ctx, &status);
}
if (lsm6dsv16x_sh_master_set(ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
lsm6dsv16x_mem_bank_set(ctx, LSM6DSV16X_MAIN_MEM_BANK);
return;
}
if (!enable) {
/* wait 300us (necessary per AN5763 7.2.1) */
k_busy_wait(300);
}
}
/* must be called with master on */
static int lsm6dsv16x_shub_check_slv0_nack(stmdev_ctx_t *ctx)
{
lsm6dsv16x_all_sources_t status;
if (lsm6dsv16x_all_sources_get(ctx, &status) < 0) {
LOG_DBG("shub: error reading embedded reg");
return -EIO;
}
if (status.sh_slave0_nack) {
LOG_DBG("shub: TRGT 0 nacked");
return -EIO;
}
return 0;
}
/*
* use TRGT 0 for generic read to target device
*/
static int lsm6dsv16x_shub_read_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_sh_cfg_read_t trgt_cfg;
trgt_cfg.slv_add = trgt_addr;
trgt_cfg.slv_subadd = trgt_reg;
trgt_cfg.slv_len = len;
lsm6dsv16x_sh_slv_cfg_read(ctx, 0, &trgt_cfg);
/* turn SH on, wait for shub i2c read to finish */
lsm6dsv16x_shub_enable(dev, 1);
lsm6dsv16x_shub_wait_completed(ctx);
/* read data from external target */
if (lsm6dsv16x_sh_read_data_raw_get(ctx, value, len) < 0) {
LOG_DBG("shub: error reading sensor data");
return -EIO;
}
if (lsm6dsv16x_shub_check_slv0_nack(ctx) < 0) {
lsm6dsv16x_shub_enable(dev, 0);
return -EIO;
}
lsm6dsv16x_shub_enable(dev, 0);
return 0;
}
/*
* use TRGT 0 to configure target device
*/
static int lsm6dsv16x_shub_write_target_reg(const struct device *dev,
uint8_t trgt_addr, uint8_t trgt_reg,
uint8_t *value, uint16_t len)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_sh_cfg_write_t trgt_cfg;
uint8_t cnt = 0U;
lsm6dsv16x_shub_enable(dev, 0);
while (cnt < len) {
trgt_cfg.slv0_add = trgt_addr;
trgt_cfg.slv0_subadd = trgt_reg + cnt;
trgt_cfg.slv0_data = value[cnt];
lsm6dsv16x_sh_cfg_write(ctx, &trgt_cfg);
/* turn SH on, wait for shub i2c write to finish */
lsm6dsv16x_shub_enable(dev, 1);
lsm6dsv16x_shub_wait_completed(ctx);
if (lsm6dsv16x_shub_check_slv0_nack(ctx) < 0) {
lsm6dsv16x_shub_enable(dev, 0);
return -EIO;
}
lsm6dsv16x_shub_enable(dev, 0);
cnt++;
}
/* Put TRGT 0 in IDLE mode */
trgt_cfg.slv0_add = 0x7;
trgt_cfg.slv0_subadd = 0x0;
trgt_cfg.slv0_data = 0x0;
lsm6dsv16x_sh_cfg_write(ctx, &trgt_cfg);
return 0;
}
/*
* TARGETs configurations:
*
* - TARGET 0: used for configuring all target devices
* - TARGET 1: used as data read channel for external target device #1
* - TARGET 2: used as data read channel for external target device #2
* - TARGET 3: used for generic reads while data channel is enabled
*/
static int lsm6dsv16x_shub_set_data_channel(const struct device *dev)
{
struct lsm6dsv16x_data *data = dev->data;
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t n;
struct lsm6dsv16x_shub_slist *sp;
lsm6dsv16x_sh_cfg_read_t trgt_cfg;
/* Configure shub data channels to access external targets */
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dsv16x_shub_slist[data->shub_ext[n]];
trgt_cfg.slv_add = sp->ext_i2c_addr;
trgt_cfg.slv_subadd = sp->out_data_addr;
trgt_cfg.slv_len = sp->out_data_len;
if (lsm6dsv16x_sh_slv_cfg_read(ctx, n + 1, &trgt_cfg) < 0) {
LOG_DBG("shub: error configuring shub for ext targets");
return -EIO;
}
}
/* Configure the master */
lsm6dsv16x_sh_slave_connected_t aux = LSM6DSV16X_SLV_0_1_2;
if (lsm6dsv16x_sh_slave_connected_set(ctx, aux) < 0) {
LOG_DBG("shub: error setting aux sensors");
return -EIO;
}
/* turn SH on, no need to wait for 1st shub i2c read, if any, to complete */
lsm6dsv16x_shub_enable(dev, 1);
return 0;
}
int lsm6dsv16x_shub_get_idx(const struct device *dev, enum sensor_channel type)
{
uint8_t n;
struct lsm6dsv16x_data *data = dev->data;
struct lsm6dsv16x_shub_slist *sp;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dsv16x_shub_slist[data->shub_ext[n]];
if (sp->type == type) {
return n;
}
}
LOG_ERR("shub: dev %s type %d not supported", dev->name, type);
return -ENOTSUP;
}
int lsm6dsv16x_shub_fetch_external_devs(const struct device *dev)
{
uint8_t n;
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lsm6dsv16x_data *data = dev->data;
struct lsm6dsv16x_shub_slist *sp;
/* read data from external target */
if (lsm6dsv16x_mem_bank_set(ctx, LSM6DSV16X_SENSOR_HUB_MEM_BANK) < 0) {
LOG_DBG("failed to enter SENSOR_HUB bank");
return -EIO;
}
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dsv16x_shub_slist[data->shub_ext[n]];
if (lsm6dsv16x_read_reg(ctx, sp->sh_out_reg,
data->ext_data[n], sp->out_data_len) < 0) {
LOG_DBG("shub: failed to read sample");
(void) lsm6dsv16x_mem_bank_set(ctx, LSM6DSV16X_MAIN_MEM_BANK);
return -EIO;
}
}
return lsm6dsv16x_mem_bank_set(ctx, LSM6DSV16X_MAIN_MEM_BANK);
}
int lsm6dsv16x_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct lsm6dsv16x_data *data = dev->data;
struct lsm6dsv16x_shub_slist *sp = NULL;
uint8_t n;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dsv16x_shub_slist[data->shub_ext[n]];
if (sp->type == chan) {
break;
}
}
if (n == data->num_ext_dev) {
LOG_DBG("shub: %s chan %d not supported", dev->name, chan);
return -ENOTSUP;
}
if (sp == NULL || sp->dev_conf == NULL) {
LOG_DBG("shub: chan not configurable");
return -ENOTSUP;
}
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int lsm6dsv16x_shub_init(const struct device *dev)
{
struct lsm6dsv16x_data *data = dev->data;
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct lsm6dsv16x_shub_slist *sp;
LOG_INF("shub: start sensorhub for %s", dev->name);
/*
* This must be set or lsm6dsv16x_shub_write_target_reg() will
* repeatedly write the same regi
*/
if (lsm6dsv16x_sh_write_mode_set(ctx, LSM6DSV16X_ONLY_FIRST_CYCLE) < 0) {
LOG_DBG("shub: error setting write once");
return -EIO;
}
for (n = 0; n < ARRAY_SIZE(lsm6dsv16x_shub_slist); n++) {
if (data->num_ext_dev >= LSM6DSV16X_SHUB_MAX_NUM_TARGETS) {
break;
}
chip_id = 0;
sp = &lsm6dsv16x_shub_slist[n];
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (lsm6dsv16x_shub_read_target_reg(dev,
sp->i2c_addr[i],
sp->wai_addr,
&chip_id, 1) < 0) {
LOG_DBG("shub: failed reading chip id");
continue;
}
if (chip_id == sp->wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(sp->i2c_addr)) {
LOG_DBG("shub: invalid chip id 0x%x", chip_id);
continue;
}
LOG_INF("shub: Ext Device Chip Id: %02x", chip_id);
sp->ext_i2c_addr = sp->i2c_addr[i];
data->shub_ext[data->num_ext_dev++] = n;
}
LOG_DBG("shub: dev %s - num_ext_dev %d", dev->name, data->num_ext_dev);
if (data->num_ext_dev == 0) {
LOG_ERR("shub: no target devices found");
return -EINVAL;
}
/* init external devices */
for (n = 0, regn = 0; n < data->num_ext_dev; n++) {
sp = &lsm6dsv16x_shub_slist[data->shub_ext[n]];
sp->sh_out_reg = LSM6DSV16X_SENSOR_HUB_1 + regn;
regn += sp->out_data_len;
sp->dev_init(dev, sp->ext_i2c_addr);
}
lsm6dsv16x_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsv16x/lsm6dsv16x_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,823 |
```objective-c
/* ST Microelectronics LSM6DSV16X 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM6DSV16X_LSM6DSV16X_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM6DSV16X_LSM6DSV16X_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lsm6dsv16x_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LSM6DSV16X_EN_BIT 0x01
#define LSM6DSV16X_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define GAIN_UNIT_XL (61LL)
/* Gyro sensor sensitivity grain is 4.375 udps/LSB */
#define GAIN_UNIT_G (4375LL)
struct lsm6dsv16x_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t accel_pm;
uint8_t accel_odr;
uint8_t accel_range;
uint8_t gyro_pm;
uint8_t gyro_odr;
uint8_t gyro_range;
uint8_t drdy_pulsed;
#ifdef CONFIG_LSM6DSV16X_TRIGGER
const struct gpio_dt_spec int1_gpio;
const struct gpio_dt_spec int2_gpio;
uint8_t drdy_pin;
bool trig_enabled;
#endif /* CONFIG_LSM6DSV16X_TRIGGER */
};
union samples {
uint8_t raw[6];
struct {
int16_t axis[3];
};
} __aligned(2);
#define LSM6DSV16X_SHUB_MAX_NUM_TARGETS 3
struct lsm6dsv16x_data {
const struct device *dev;
int16_t acc[3];
uint32_t acc_gain;
int16_t gyro[3];
uint32_t gyro_gain;
#if defined(CONFIG_LSM6DSV16X_ENABLE_TEMP)
int16_t temp_sample;
#endif
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
uint8_t ext_data[LSM6DSV16X_SHUB_MAX_NUM_TARGETS][6];
uint16_t magn_gain;
struct hts221_data {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} hts221;
bool shub_inited;
uint8_t num_ext_dev;
uint8_t shub_ext[LSM6DSV16X_SHUB_MAX_NUM_TARGETS];
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
uint8_t accel_freq;
uint8_t accel_fs;
uint8_t gyro_freq;
uint8_t gyro_fs;
#ifdef CONFIG_LSM6DSV16X_TRIGGER
struct gpio_dt_spec *drdy_gpio;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
sensor_trigger_handler_t handler_drdy_gyr;
const struct sensor_trigger *trig_drdy_gyr;
sensor_trigger_handler_t handler_drdy_temp;
const struct sensor_trigger *trig_drdy_temp;
#if defined(CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSV16X_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSV16X_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LSM6DSV16X_TRIGGER */
};
#if defined(CONFIG_LSM6DSV16X_SENSORHUB)
int lsm6dsv16x_shub_init(const struct device *dev);
int lsm6dsv16x_shub_fetch_external_devs(const struct device *dev);
int lsm6dsv16x_shub_get_idx(const struct device *dev, enum sensor_channel type);
int lsm6dsv16x_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* CONFIG_LSM6DSV16X_SENSORHUB */
#ifdef CONFIG_LSM6DSV16X_TRIGGER
int lsm6dsv16x_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lsm6dsv16x_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM6DSV16X_LSM6DSV16X_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsv16x/lsm6dsv16x.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,121 |
```unknown
# ST Microelectronics LSM6DSV16X 6-axis IMU sensor driver
menuconfig LSM6DSV16X
bool "LSM6DSV16X I2C/SPI accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_LSM6DSV16X_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSV16X),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSV16X),spi)
select HAS_STMEMSC
select USE_STDC_LSM6DSV16X
help
Enable driver for LSM6DSV16X accelerometer and gyroscope
sensor.
if LSM6DSV16X
choice LSM6DSV16X_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LSM6DSV16X_TRIGGER_NONE
bool "No trigger"
config LSM6DSV16X_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LSM6DSV16X_TRIGGER
config LSM6DSV16X_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LSM6DSV16X_TRIGGER
endchoice
config LSM6DSV16X_TRIGGER
bool
if LSM6DSV16X_TRIGGER
config LSM6DSV16X_THREAD_PRIORITY
int "Thread priority"
depends on LSM6DSV16X_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LSM6DSV16X_THREAD_STACK_SIZE
int "Thread stack size"
depends on LSM6DSV16X_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # LSM6DSV16X_TRIGGER
config LSM6DSV16X_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config LSM6DSV16X_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub. You can enable
a maximum of two external sensors (if more than two are enabled
the system would enumerate only the first two found)
if LSM6DSV16X_SENSORHUB
config LSM6DSV16X_EXT_LIS2MDL
bool "LIS2MDL as external sensor"
default y
config LSM6DSV16X_EXT_LPS22HH
bool "LPS22HH as external sensor"
config LSM6DSV16X_EXT_HTS221
bool "HTS221 as external sensor"
config LSM6DSV16X_EXT_LPS22HB
bool "LPS22HB as external sensor"
config LSM6DSV16X_EXT_LPS22DF
bool "LPS22DF as external sensor"
default y
endif # LSM6DSV16X_SENSORHUB
endif # LSM6DSV16X
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsv16x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 646 |
```c
/* ST Microelectronics LSM6DSV16X 6-axis IMU sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lsm6dsv16x
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lsm6dsv16x.h"
LOG_MODULE_DECLARE(LSM6DSV16X, CONFIG_SENSOR_LOG_LEVEL);
/**
* lsm6dsv16x_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int lsm6dsv16x_enable_xl_int(const struct device *dev, int enable)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dsv16x_acceleration_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->drdy_pin == 1) {
lsm6dsv16x_pin_int_route_t val;
ret = lsm6dsv16x_pin_int1_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lsm6dsv16x_pin_int1_route_set(ctx, &val);
} else {
lsm6dsv16x_pin_int_route_t val;
ret = lsm6dsv16x_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_xl = 1;
ret = lsm6dsv16x_pin_int2_route_set(ctx, &val);
}
return ret;
}
/**
* lsm6dsv16x_enable_g_int - Gyro enable selected int pin to generate interrupt
*/
static int lsm6dsv16x_enable_g_int(const struct device *dev, int enable)
{
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
lsm6dsv16x_angular_rate_raw_get(ctx, buf);
}
/* set interrupt */
if (cfg->drdy_pin == 1) {
lsm6dsv16x_pin_int_route_t val;
ret = lsm6dsv16x_pin_int1_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int1_route_get error");
return ret;
}
val.drdy_g = 1;
ret = lsm6dsv16x_pin_int1_route_set(ctx, &val);
} else {
lsm6dsv16x_pin_int_route_t val;
ret = lsm6dsv16x_pin_int2_route_get(ctx, &val);
if (ret < 0) {
LOG_ERR("pint_int2_route_get error");
return ret;
}
val.drdy_g = 1;
ret = lsm6dsv16x_pin_int2_route_set(ctx, &val);
}
return ret;
}
/**
* lsm6dsv16x_trigger_set - link external trigger to event data ready
*/
int lsm6dsv16x_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lsm6dsv16x_config *cfg = dev->config;
struct lsm6dsv16x_data *lsm6dsv16x = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
lsm6dsv16x->handler_drdy_acc = handler;
lsm6dsv16x->trig_drdy_acc = trig;
if (handler) {
return lsm6dsv16x_enable_xl_int(dev, LSM6DSV16X_EN_BIT);
} else {
return lsm6dsv16x_enable_xl_int(dev, LSM6DSV16X_DIS_BIT);
}
} else if (trig->chan == SENSOR_CHAN_GYRO_XYZ) {
lsm6dsv16x->handler_drdy_gyr = handler;
lsm6dsv16x->trig_drdy_gyr = trig;
if (handler) {
return lsm6dsv16x_enable_g_int(dev, LSM6DSV16X_EN_BIT);
} else {
return lsm6dsv16x_enable_g_int(dev, LSM6DSV16X_DIS_BIT);
}
}
return -ENOTSUP;
}
/**
* lsm6dsv16x_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lsm6dsv16x_handle_interrupt(const struct device *dev)
{
struct lsm6dsv16x_data *lsm6dsv16x = dev->data;
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lsm6dsv16x_data_ready_t status;
while (1) {
if (lsm6dsv16x_flag_data_ready_get(ctx, &status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
if ((status.drdy_xl == 0) && (status.drdy_gy == 0)) {
break;
}
if ((status.drdy_xl) && (lsm6dsv16x->handler_drdy_acc != NULL)) {
lsm6dsv16x->handler_drdy_acc(dev, lsm6dsv16x->trig_drdy_acc);
}
if ((status.drdy_gy) && (lsm6dsv16x->handler_drdy_gyr != NULL)) {
lsm6dsv16x->handler_drdy_gyr(dev, lsm6dsv16x->trig_drdy_gyr);
}
}
gpio_pin_interrupt_configure_dt(lsm6dsv16x->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lsm6dsv16x_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lsm6dsv16x_data *lsm6dsv16x =
CONTAINER_OF(cb, struct lsm6dsv16x_data, gpio_cb);
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(lsm6dsv16x->drdy_gpio, GPIO_INT_DISABLE);
#if defined(CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD)
k_sem_give(&lsm6dsv16x->gpio_sem);
#elif defined(CONFIG_LSM6DSV16X_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lsm6dsv16x->work);
#endif /* CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD
static void lsm6dsv16x_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lsm6dsv16x_data *lsm6dsv16x = p1;
while (1) {
k_sem_take(&lsm6dsv16x->gpio_sem, K_FOREVER);
lsm6dsv16x_handle_interrupt(lsm6dsv16x->dev);
}
}
#endif /* CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LSM6DSV16X_TRIGGER_GLOBAL_THREAD
static void lsm6dsv16x_work_cb(struct k_work *work)
{
struct lsm6dsv16x_data *lsm6dsv16x =
CONTAINER_OF(work, struct lsm6dsv16x_data, work);
lsm6dsv16x_handle_interrupt(lsm6dsv16x->dev);
}
#endif /* CONFIG_LSM6DSV16X_TRIGGER_GLOBAL_THREAD */
int lsm6dsv16x_init_interrupt(const struct device *dev)
{
struct lsm6dsv16x_data *lsm6dsv16x = dev->data;
const struct lsm6dsv16x_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
lsm6dsv16x->drdy_gpio = (cfg->drdy_pin == 1) ?
(struct gpio_dt_spec *)&cfg->int1_gpio :
(struct gpio_dt_spec *)&cfg->int2_gpio;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(lsm6dsv16x->drdy_gpio)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD)
k_sem_init(&lsm6dsv16x->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lsm6dsv16x->thread, lsm6dsv16x->thread_stack,
CONFIG_LSM6DSV16X_THREAD_STACK_SIZE,
lsm6dsv16x_thread, lsm6dsv16x,
NULL, NULL, K_PRIO_COOP(CONFIG_LSM6DSV16X_THREAD_PRIORITY),
0, K_NO_WAIT);
k_thread_name_set(&lsm6dsv16x->thread, "lsm6dsv16x");
#elif defined(CONFIG_LSM6DSV16X_TRIGGER_GLOBAL_THREAD)
lsm6dsv16x->work.handler = lsm6dsv16x_work_cb;
#endif /* CONFIG_LSM6DSV16X_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(lsm6dsv16x->drdy_gpio, GPIO_INPUT);
if (ret < 0) {
LOG_DBG("Could not configure gpio");
return ret;
}
gpio_init_callback(&lsm6dsv16x->gpio_cb,
lsm6dsv16x_gpio_callback,
BIT(lsm6dsv16x->drdy_gpio->pin));
if (gpio_add_callback(lsm6dsv16x->drdy_gpio->port, &lsm6dsv16x->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* set data ready mode on int1/int2 */
LOG_DBG("drdy_pulsed is %d", (int)cfg->drdy_pulsed);
lsm6dsv16x_data_ready_mode_t mode = cfg->drdy_pulsed ? LSM6DSV16X_DRDY_PULSED :
LSM6DSV16X_DRDY_LATCHED;
ret = lsm6dsv16x_data_ready_mode_set(ctx, mode);
if (ret < 0) {
LOG_ERR("drdy_pulsed config error %d", (int)cfg->drdy_pulsed);
return ret;
}
return gpio_pin_interrupt_configure_dt(lsm6dsv16x->drdy_gpio,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsv16x/lsm6dsv16x_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,581 |
```objective-c
/* vl53l0x_types.h - Zephyr customization of ST vl53l0x library,
* basic type definition.
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_TYPES_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_TYPES_H_
/* Zephyr provides stdint.h and stddef.h, so this is enough to include it.
* If it was not the case, we would defined here all signed and unsigned
* basic types...
*/
#include <stdint.h>
#include <stddef.h>
#ifndef NULL
#error "Error NULL definition should be done. Please add required include "
#endif
/** use where fractional values are expected
*
* Given a floating point value f it's .16 bit point is (int)(f*(1<<16))
*/
typedef uint32_t FixPoint1616_t;
#endif /* ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_TYPES_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/vl53l0x_types.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 219 |
```c
/* vl53l0x_platform.c - Zephyr customization of ST vl53l0x library.
* (library is located in ext/hal/st/lib/sensor/vl53l0x/)
*/
/*
*
*/
#include "vl53l0x_platform.h"
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/logging/log.h>
LOG_MODULE_DECLARE(VL53L0X, CONFIG_SENSOR_LOG_LEVEL);
VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
uint32_t count)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int = 0;
uint8_t I2CBuffer[count+1];
I2CBuffer[0] = index;
memcpy(&I2CBuffer[1], pdata, count);
status_int = i2c_write(Dev->i2c, I2CBuffer, count+1, Dev->I2cDevAddr);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("Failed to write");
}
return Status;
}
VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
uint32_t count)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
status_int = i2c_burst_read(Dev->i2c, Dev->I2cDevAddr, index, pdata,
count);
if (status_int < 0) {
LOG_ERR("Failed to read");
return -EIO;
}
return Status;
}
VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
status_int = i2c_reg_write_byte(Dev->i2c, Dev->I2cDevAddr, index, data);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("i2c_reg_write_byte failed (%d)", Status);
}
return Status;
}
VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
uint8_t I2CBuffer[3];
I2CBuffer[0] = index;
I2CBuffer[1] = data >> 8;
I2CBuffer[2] = data & 0x00FF;
status_int = i2c_write(Dev->i2c, I2CBuffer, 3, Dev->I2cDevAddr);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("i2c_write failed (%d)", Status);
}
return Status;
}
VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
uint8_t I2CBuffer[5];
I2CBuffer[0] = index;
I2CBuffer[1] = (data >> 24) & 0xFF;
I2CBuffer[2] = (data >> 16) & 0xFF;
I2CBuffer[3] = (data >> 8) & 0xFF;
I2CBuffer[4] = (data >> 0) & 0xFF;
status_int = i2c_write(Dev->i2c, I2CBuffer, 5, Dev->I2cDevAddr);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("i2c_write failed (%d)", Status);
}
return Status;
}
VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index,
uint8_t AndData, uint8_t OrData)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
uint8_t deviceAddress;
uint8_t data;
deviceAddress = Dev->I2cDevAddr;
status_int = VL53L0X_RdByte(Dev, index, &data);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("VL53L0X_RdByte failed (%d)", Status);
}
if (Status == VL53L0X_ERROR_NONE) {
data = (data & AndData) | OrData;
status_int = VL53L0X_WrByte(Dev, index, data);
if (status_int != 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_DBG("VL53L0X_WrByte failed.(%d)", Status);
}
}
return Status;
}
VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
status_int = i2c_reg_read_byte(Dev->i2c, Dev->I2cDevAddr, index, data);
if (status_int < 0) {
Status = VL53L0X_ERROR_CONTROL_INTERFACE;
LOG_ERR("i2c_reg_read_byte failed (%d)", Status);
}
return Status;
}
VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
uint8_t buf[2];
status_int = i2c_burst_read(Dev->i2c, Dev->I2cDevAddr, index, buf, 2);
if (status_int < 0) {
LOG_ERR("i2c_burst_read failed");
return -EIO;
}
*data = ((uint16_t)buf[0]<<8) + (uint16_t)buf[1];
return Status;
}
VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
int32_t status_int;
uint8_t buf[4];
status_int = i2c_burst_read(Dev->i2c, Dev->I2cDevAddr, index, buf, 4);
if (status_int < 0) {
LOG_ERR("i2c_burst_read failed");
return -EIO;
}
*data = ((uint32_t)buf[0]<<24) + ((uint32_t)buf[1]<<16) +
((uint32_t)buf[2]<<8) + (uint32_t)buf[3];
return Status;
}
VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev)
{
k_sleep(K_MSEC(2));
return VL53L0X_ERROR_NONE;
}
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/vl53l0x_platform.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,695 |
```objective-c
/* vl53l0x_platform_log.h - Zephyr customization of ST vl53l0x library,
* logging functions, not implemented
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_LOG_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_LOG_H_
#include <stdio.h>
#include <string.h>
/* LOG Functions */
#ifdef __cplusplus
extern "C" {
#endif
enum {
TRACE_LEVEL_NONE,
TRACE_LEVEL_ERRORS,
TRACE_LEVEL_WARNING,
TRACE_LEVEL_INFO,
TRACE_LEVEL_DEBUG,
TRACE_LEVEL_ALL,
TRACE_LEVEL_IGNORE
};
enum {
TRACE_FUNCTION_NONE = 0,
TRACE_FUNCTION_I2C = 1,
TRACE_FUNCTION_ALL = 0x7fffffff /* all bits except sign */
};
enum {
TRACE_MODULE_NONE = 0x0,
TRACE_MODULE_API = 0x1,
TRACE_MODULE_PLATFORM = 0x2,
TRACE_MODULE_ALL = 0x7fffffff /* all bits except sign */
};
#define _LOG_FUNCTION_START(module, fmt, ...) (void)0
#define _LOG_FUNCTION_END(module, status, ...) (void)0
#define _LOG_FUNCTION_END_FMT(module, status, fmt, ...) (void)0
#define VL53L0X_COPYSTRING(str, ...) strcpy(str, ##__VA_ARGS__)
#ifdef __cplusplus
}
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_LOG_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/vl53l0x_platform_log.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 325 |
```unknown
# VL53L0X time of flight sensor configuration options
menuconfig VL53L0X
bool "VL53L0X time of flight sensor"
default y
depends on DT_HAS_ST_VL53L0X_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C
select HAS_STLIB
help
Enable driver for VL53L0X I2C-based time of flight sensor.
config VL53L0X_PROXIMITY_THRESHOLD
int "Proximity threshold in millimeters"
default 100
depends on VL53L0X
help
Threshold used for proximity detection when sensor is used with SENSOR_CHAN_PROX.
config VL53L0X_RECONFIGURE_ADDRESS
bool "Support reconfigurable sensor address"
depends on VL53L0X
help
Enable support for reconfiguring the sensor address at runtime.
When this option is enabled, all sensors declared in the device tree
must have an xshut-gpio property.
All sensors are disabled during initialization. When reading the first
value from a sensor, it is powered up and its I2C address is reconfigured
from the manufacturer default (0x29) to the address specified in the
device tree.
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 268 |
```objective-c
/* vl53l0x_platform.h - Zephyr customization of ST vl53l0x library.
* (library is located in ext/hal/st/lib/sensor/vl53l0x/)
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_H_
#define ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_H_
#include "vl53l0x_def.h"
#include "vl53l0x_platform_log.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @struct VL53L0X_Dev_t
* @brief Generic PAL device type that does link between API and platform
* abstraction layer
*
*/
typedef struct {
VL53L0X_DevData_t Data; /* embed ST Ewok Dev data as "Data"*/
/*!< user specific field */
uint8_t I2cDevAddr; /* i2c device address user specific field */
uint8_t comms_type; /* VL53L0X_COMMS_I2C or VL53L0X_COMMS_SPI */
uint16_t comms_speed_khz; /* Comms speed [kHz] */
const struct device *i2c;
} VL53L0X_Dev_t;
/**
* @brief Declare the device Handle as a pointer of the structure VL53L0X_Dev_t
*
*/
typedef VL53L0X_Dev_t *VL53L0X_DEV;
/**
* @brief Get ST private structure @a VL53L0X_DevData_t data access
*
* @param Dev Device Handle
* @param field ST structure field name
* It maybe used and as real data "ref" not just as "get" for sub-structure item
* like PALDevDataGet(FilterData.field)[i]
* or PALDevDataGet(FilterData.MeasurementIndex)++
*/
#define PALDevDataGet(Dev, field) (Dev->Data.field)
/**
* @brief Set ST private structure @a VL53L0X_DevData_t data field
* @param Dev Device Handle
* @param field ST structure field name
* @param data Data to be set
*/
#define PALDevDataSet(Dev, field, data) ((Dev->Data.field) = (data))
/**
* @defgroup VL53L0X_registerAccess_group PAL Register Access Functions
* @brief PAL Register Access Functions
* @{
*/
/**
* Writes the supplied byte buffer to the device
* @param Dev Device Handle
* @param index The register index
* @param pdata Pointer to uint8_t buffer containing the data to be written
* @param count Number of bytes in the supplied byte buffer
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
uint32_t count);
/**
* Reads the requested number of bytes from the device
* @param Dev Device Handle
* @param index The register index
* @param pdata Pointer to the uint8_t buffer to store read data
* @param count Number of uint8_t's to read
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
uint32_t count);
/**
* Write single byte register
* @param Dev Device Handle
* @param index The register index
* @param data 8 bit register data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data);
/**
* Write word register
* @param Dev Device Handle
* @param index The register index
* @param data 16 bit register data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data);
/**
* Write double word (4 byte) register
* @param Dev Device Handle
* @param index The register index
* @param data 32 bit register data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data);
/**
* Read single byte register
* @param Dev Device Handle
* @param index The register index
* @param data pointer to 8 bit data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data);
/**
* Read word (2byte) register
* @param Dev Device Handle
* @param index The register index
* @param data pointer to 16 bit data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data);
/**
* Read dword (4byte) register
* @param Dev Device Handle
* @param index The register index
* @param data pointer to 32 bit data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data);
/**
* Threat safe Update (read/modify/write) single byte register
*
* Final_reg = (Initial_reg & and_data) |or_data
*
* @param Dev Device Handle
* @param index The register index
* @param AndData 8 bit and data
* @param OrData 8 bit or data
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index,
uint8_t AndData, uint8_t OrData);
/** @} end of VL53L0X_registerAccess_group */
/**
* @brief execute delay in all polling API call
*
* A typical multi-thread or RTOs implementation is to sleep the task
* for some 5ms (with 100Hz max rate faster polling is not needed)
* if nothing specific is need you can define it as an empty/void macro
* @code
* #define VL53L0X_PollingDelay(...) (void)0
* @endcode
* @param Dev Device Handle
* @return VL53L0X_ERROR_NONE Success
* @return "Other error code" See ::VL53L0X_Error
*/
VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev);
/* usually best implemented as a real function */
/** @} end of VL53L0X_platform_group */
#ifdef __cplusplus
}
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_VL53L0X_VL53L0X_PLATFORM_H_ */
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/vl53l0x_platform.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,827 |
```c
/* vl53l0x.c - Driver for ST VL53L0X time of flight sensor */
#define DT_DRV_COMPAT st_vl53l0x
/*
*
*/
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/init.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/pm/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/logging/log.h>
#include "vl53l0x_api.h"
#include "vl53l0x_platform.h"
LOG_MODULE_REGISTER(VL53L0X, CONFIG_SENSOR_LOG_LEVEL);
/* All the values used in this driver are coming from ST datasheet and examples.
* It can be found here:
* path_to_url
* There are also examples of use in the L4 cube FW:
* path_to_url
*/
#define VL53L0X_INITIAL_ADDR 0x29
#define VL53L0X_REG_WHO_AM_I 0xC0
#define VL53L0X_CHIP_ID 0xEEAA
#define VL53L0X_SETUP_SIGNAL_LIMIT (0.1 * 65536)
#define VL53L0X_SETUP_SIGMA_LIMIT (60 * 65536)
#define VL53L0X_SETUP_MAX_TIME_FOR_RANGING 33000
#define VL53L0X_SETUP_PRE_RANGE_VCSEL_PERIOD 18
#define VL53L0X_SETUP_FINAL_RANGE_VCSEL_PERIOD 14
/* tBOOT (1.2ms max.) VL53L0X firmware boot period */
#define T_BOOT K_USEC(1200)
struct vl53l0x_config {
struct i2c_dt_spec i2c;
struct gpio_dt_spec xshut;
};
struct vl53l0x_data {
bool started;
VL53L0X_Dev_t vl53l0x;
VL53L0X_RangingMeasurementData_t RangingMeasurementData;
};
static int vl53l0x_setup_single_shot(const struct device *dev)
{
struct vl53l0x_data *drv_data = dev->data;
int ret;
uint8_t VhvSettings;
uint8_t PhaseCal;
uint32_t refSpadCount;
uint8_t isApertureSpads;
ret = VL53L0X_StaticInit(&drv_data->vl53l0x);
if (ret) {
LOG_ERR("[%s] VL53L0X_StaticInit failed",
dev->name);
goto exit;
}
ret = VL53L0X_PerformRefCalibration(&drv_data->vl53l0x,
&VhvSettings,
&PhaseCal);
if (ret) {
LOG_ERR("[%s] VL53L0X_PerformRefCalibration failed",
dev->name);
goto exit;
}
ret = VL53L0X_PerformRefSpadManagement(&drv_data->vl53l0x,
&refSpadCount,
&isApertureSpads);
if (ret) {
LOG_ERR("[%s] VL53L0X_PerformRefSpadManagement failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetDeviceMode(&drv_data->vl53l0x,
VL53L0X_DEVICEMODE_SINGLE_RANGING);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetDeviceMode failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetLimitCheckEnable(&drv_data->vl53l0x,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
1);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetLimitCheckEnable sigma failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetLimitCheckEnable(&drv_data->vl53l0x,
VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
1);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetLimitCheckEnable signal rate failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetLimitCheckValue(&drv_data->vl53l0x,
VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
VL53L0X_SETUP_SIGNAL_LIMIT);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetLimitCheckValue signal rate failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetLimitCheckValue(&drv_data->vl53l0x,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
VL53L0X_SETUP_SIGMA_LIMIT);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetLimitCheckValue sigma failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&drv_data->vl53l0x,
VL53L0X_SETUP_MAX_TIME_FOR_RANGING);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetMeasurementTimingBudgetMicroSeconds failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetVcselPulsePeriod(&drv_data->vl53l0x,
VL53L0X_VCSEL_PERIOD_PRE_RANGE,
VL53L0X_SETUP_PRE_RANGE_VCSEL_PERIOD);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetVcselPulsePeriod pre range failed",
dev->name);
goto exit;
}
ret = VL53L0X_SetVcselPulsePeriod(&drv_data->vl53l0x,
VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
VL53L0X_SETUP_FINAL_RANGE_VCSEL_PERIOD);
if (ret) {
LOG_ERR("[%s] VL53L0X_SetVcselPulsePeriod final range failed",
dev->name);
goto exit;
}
exit:
return ret;
}
static int vl53l0x_start(const struct device *dev)
{
const struct vl53l0x_config *const config = dev->config;
struct vl53l0x_data *drv_data = dev->data;
int r;
VL53L0X_Error ret;
uint16_t vl53l0x_id = 0U;
VL53L0X_DeviceInfo_t vl53l0x_dev_info = { 0 };
LOG_DBG("[%s] Starting", dev->name);
if (config->xshut.port) {
r = gpio_pin_configure_dt(&config->xshut, GPIO_OUTPUT_INACTIVE);
if (r < 0) {
LOG_ERR("[%s] Unable to inactivate XSHUT: %d",
dev->name, r);
return -EIO;
}
k_sleep(T_BOOT);
}
#ifdef CONFIG_VL53L0X_RECONFIGURE_ADDRESS
if (config->i2c.addr != VL53L0X_INITIAL_ADDR) {
ret = VL53L0X_SetDeviceAddress(&drv_data->vl53l0x, 2 * config->i2c.addr);
if (ret != 0) {
LOG_ERR("[%s] Unable to reconfigure I2C address",
dev->name);
return -EIO;
}
drv_data->vl53l0x.I2cDevAddr = config->i2c.addr;
LOG_DBG("[%s] I2C address reconfigured", dev->name);
k_sleep(T_BOOT);
}
#endif
ret = VL53L0X_GetDeviceInfo(&drv_data->vl53l0x, &vl53l0x_dev_info);
if (ret < 0) {
LOG_ERR("[%s] Could not get info from device.", dev->name);
return -ENODEV;
}
LOG_DBG("[%s] VL53L0X_GetDeviceInfo = %d", dev->name, ret);
LOG_DBG(" Device Name : %s", vl53l0x_dev_info.Name);
LOG_DBG(" Device Type : %s", vl53l0x_dev_info.Type);
LOG_DBG(" Device ID : %s", vl53l0x_dev_info.ProductId);
LOG_DBG(" ProductRevisionMajor : %d",
vl53l0x_dev_info.ProductRevisionMajor);
LOG_DBG(" ProductRevisionMinor : %d",
vl53l0x_dev_info.ProductRevisionMinor);
ret = VL53L0X_RdWord(&drv_data->vl53l0x,
VL53L0X_REG_WHO_AM_I,
&vl53l0x_id);
if ((ret < 0) || (vl53l0x_id != VL53L0X_CHIP_ID)) {
LOG_ERR("[%s] Issue on device identification", dev->name);
return -ENOTSUP;
}
/* sensor init */
ret = VL53L0X_DataInit(&drv_data->vl53l0x);
if (ret < 0) {
LOG_ERR("[%s] VL53L0X_DataInit return error (%d)",
dev->name, ret);
return -ENOTSUP;
}
ret = vl53l0x_setup_single_shot(dev);
if (ret < 0) {
return -ENOTSUP;
}
drv_data->started = true;
LOG_DBG("[%s] Started", dev->name);
return 0;
}
static int vl53l0x_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct vl53l0x_data *drv_data = dev->data;
VL53L0X_Error ret;
int r;
__ASSERT_NO_MSG((chan == SENSOR_CHAN_ALL)
|| (chan == SENSOR_CHAN_DISTANCE)
|| (chan == SENSOR_CHAN_PROX));
if (!drv_data->started) {
r = vl53l0x_start(dev);
if (r < 0) {
return r;
}
}
ret = VL53L0X_PerformSingleRangingMeasurement(&drv_data->vl53l0x,
&drv_data->RangingMeasurementData);
if (ret < 0) {
LOG_ERR("[%s] Could not perform measurment (error=%d)",
dev->name, ret);
return -EINVAL;
}
return 0;
}
static int vl53l0x_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct vl53l0x_data *drv_data = dev->data;
if (chan == SENSOR_CHAN_PROX) {
if (drv_data->RangingMeasurementData.RangeMilliMeter <=
CONFIG_VL53L0X_PROXIMITY_THRESHOLD) {
val->val1 = 1;
} else {
val->val1 = 0;
}
val->val2 = 0;
} else if (chan == SENSOR_CHAN_DISTANCE) {
val->val1 = drv_data->RangingMeasurementData.RangeMilliMeter / 1000;
val->val2 = (drv_data->RangingMeasurementData.RangeMilliMeter % 1000) * 1000;
} else {
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api vl53l0x_api_funcs = {
.sample_fetch = vl53l0x_sample_fetch,
.channel_get = vl53l0x_channel_get,
};
static int vl53l0x_init(const struct device *dev)
{
int r;
struct vl53l0x_data *drv_data = dev->data;
const struct vl53l0x_config *const config = dev->config;
/* Initialize the HAL peripheral with the default sensor address,
* ie. the address on power up
*/
drv_data->vl53l0x.I2cDevAddr = VL53L0X_INITIAL_ADDR;
drv_data->vl53l0x.i2c = config->i2c.bus;
#if defined(CONFIG_VL53L0X_RECONFIGURE_ADDRESS) || defined(CONFIG_PM_DEVICE)
if (config->xshut.port == NULL) {
LOG_ERR("[%s] Missing XSHUT gpio spec", dev->name);
return -ENOTSUP;
}
#endif
#ifdef CONFIG_VL53L0X_RECONFIGURE_ADDRESS
/*
* Shutdown all vl53l0x sensors so at each sensor's 1st fetch call
* they can be enabled one at a time and programmed with their address.
*/
r = gpio_pin_configure_dt(&config->xshut, GPIO_OUTPUT_ACTIVE);
if (r < 0) {
LOG_ERR("[%s] Unable to shutdown sensor", dev->name);
return -EIO;
}
LOG_DBG("[%s] Shutdown", dev->name);
#else
if (config->i2c.addr != VL53L0X_INITIAL_ADDR) {
LOG_ERR("[%s] Invalid device address (should be 0x%X or "
"CONFIG_VL53L0X_RECONFIGURE_ADDRESS should be enabled)",
dev->name, VL53L0X_INITIAL_ADDR);
return -ENOTSUP;
}
r = vl53l0x_start(dev);
if (r) {
return r;
}
#endif
LOG_DBG("[%s] Initialized", dev->name);
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int vl53l0x_pm_action(const struct device *dev,
enum pm_device_action action)
{
const struct vl53l0x_config *const config = dev->config;
int ret;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
ret = vl53l0x_init(dev);
if (ret != 0) {
LOG_ERR("resume init: %d", ret);
}
break;
case PM_DEVICE_ACTION_SUSPEND:
/* HW Standby */
ret = gpio_pin_set_dt(&config->xshut, 1);
if (ret < 0) {
LOG_ERR("[%s] XSHUT pin active", dev->name);
}
break;
default:
ret = -ENOTSUP;
break;
}
return ret;
}
#endif
#define VL53L0X_INIT(inst) \
static struct vl53l0x_config vl53l0x_##inst##_config = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.xshut = GPIO_DT_SPEC_INST_GET_OR(inst, xshut_gpios, {}) \
}; \
\
static struct vl53l0x_data vl53l0x_##inst##_driver; \
\
PM_DEVICE_DT_INST_DEFINE(inst, vl53l0x_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, vl53l0x_init, \
PM_DEVICE_DT_INST_GET(inst), \
&vl53l0x_##inst##_driver, \
&vl53l0x_##inst##_config, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&vl53l0x_api_funcs);
DT_INST_FOREACH_STATUS_OKAY(VL53L0X_INIT)
``` | /content/code_sandbox/drivers/sensor/st/vl53l0x/vl53l0x.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 3,293 |
```c
/* ST Microelectronics LIS2MDL 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2mdl
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lis2mdl.h"
LOG_MODULE_DECLARE(LIS2MDL, CONFIG_SENSOR_LOG_LEVEL);
static int lis2mdl_enable_int(const struct device *dev, int enable)
{
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
LOG_DBG("Set int with %d", enable);
/* set interrupt on mag */
return lis2mdl_drdy_on_pin_set(ctx, enable);
}
/* link external trigger to event data ready */
int lis2mdl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2mdl_data *lis2mdl = dev->data;
int16_t raw[3];
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_MAGN_XYZ) {
lis2mdl->handler_drdy = handler;
lis2mdl->trig_drdy = trig;
if (handler) {
/* fetch raw data sample: re-trigger lost interrupt */
lis2mdl_magnetic_raw_get(ctx, raw);
return lis2mdl_enable_int(dev, 1);
} else {
return lis2mdl_enable_int(dev, 0);
}
}
return -ENOTSUP;
}
/* handle the drdy event: read data and call handler if registered any */
static void lis2mdl_handle_interrupt(const struct device *dev)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *const cfg = dev->config;
if (lis2mdl->handler_drdy != NULL) {
lis2mdl->handler_drdy(dev, lis2mdl->trig_drdy);
}
if (cfg->single_mode) {
k_sem_give(&lis2mdl->fetch_sem);
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lis2mdl_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2mdl_data *lis2mdl =
CONTAINER_OF(cb, struct lis2mdl_data, gpio_cb);
const struct lis2mdl_config *const cfg = lis2mdl->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_LIS2MDL_TRIGGER_OWN_THREAD)
k_sem_give(&lis2mdl->gpio_sem);
#elif defined(CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2mdl->work);
#endif
}
#ifdef CONFIG_LIS2MDL_TRIGGER_OWN_THREAD
static void lis2mdl_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lis2mdl_data *lis2mdl = p1;
while (1) {
k_sem_take(&lis2mdl->gpio_sem, K_FOREVER);
lis2mdl_handle_interrupt(lis2mdl->dev);
}
}
#endif
#ifdef CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD
static void lis2mdl_work_cb(struct k_work *work)
{
struct lis2mdl_data *lis2mdl =
CONTAINER_OF(work, struct lis2mdl_data, work);
lis2mdl_handle_interrupt(lis2mdl->dev);
}
#endif
int lis2mdl_init_interrupt(const struct device *dev)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *const cfg = dev->config;
int ret;
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_LIS2MDL_TRIGGER_OWN_THREAD)
k_sem_init(&lis2mdl->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lis2mdl->thread, lis2mdl->thread_stack,
CONFIG_LIS2MDL_THREAD_STACK_SIZE,
lis2mdl_thread, lis2mdl,
NULL, NULL, K_PRIO_COOP(CONFIG_LIS2MDL_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD)
lis2mdl->work.handler = lis2mdl_work_cb;
#endif
ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&lis2mdl->gpio_cb,
lis2mdl_gpio_callback,
BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(cfg->gpio_drdy.port, &lis2mdl->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2mdl/lis2mdl_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,208 |
```objective-c
/* ST Microelectronics LIS2MDL 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef __MAG_LIS2MDL_H
#define __MAG_LIS2MDL_H
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "lis2mdl_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct lis2mdl_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
bool cancel_offset;
bool single_mode;
bool spi_4wires;
#ifdef CONFIG_LIS2MDL_TRIGGER
bool trig_enabled;
const struct gpio_dt_spec gpio_drdy;
#endif /* CONFIG_LIS2MDL_TRIGGER */
};
/* Sensor data */
struct lis2mdl_data {
const struct device *dev;
int16_t mag[3];
int16_t temp_sample;
struct k_sem fetch_sem;
#ifdef CONFIG_LIS2MDL_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trig_drdy;
#if defined(CONFIG_LIS2MDL_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2MDL_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif /* CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_LIS2MDL_TRIGGER */
};
#ifdef CONFIG_LIS2MDL_TRIGGER
int lis2mdl_init_interrupt(const struct device *dev);
int lis2mdl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_LIS2MDL_TRIGGER */
#endif /* __MAG_LIS2MDL_H */
``` | /content/code_sandbox/drivers/sensor/st/lis2mdl/lis2mdl.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 516 |
```unknown
menuconfig LIS2MDL
bool "LIS2MDL Magnetometer"
default y
depends on DT_HAS_ST_LIS2MDL_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2MDL),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2MDL),spi)
select HAS_STMEMSC
select USE_STDC_LIS2MDL
help
Enable driver for LIS2MDL I2C-based magnetometer sensor.
if LIS2MDL
choice LIS2MDL_TRIGGER_MODE
prompt "Trigger mode"
default LIS2MDL_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config LIS2MDL_TRIGGER_NONE
bool "No trigger"
config LIS2MDL_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LIS2MDL_TRIGGER
config LIS2MDL_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LIS2MDL_TRIGGER
endchoice # LIS2MDL_TRIGGER_MODE
config LIS2MDL_TRIGGER
bool
config LIS2MDL_THREAD_PRIORITY
int "Thread priority"
depends on LIS2MDL_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LIS2MDL_THREAD_STACK_SIZE
int "Thread stack size"
depends on LIS2MDL_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config LIS2MDL_MAG_ODR_RUNTIME
bool "Set magnetometer sampling frequency (ODR) at runtime (default: 10 Hz)"
default y
endif # LIS2MDL
``` | /content/code_sandbox/drivers/sensor/st/lis2mdl/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 387 |
```c
/* ST Microelectronics LIS2MDL 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2mdl
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/pm/device.h>
#include <string.h>
#include <zephyr/logging/log.h>
#include "lis2mdl.h"
/* Based on the data sheet, the maximum turn-on time is ("9.4 ms + 1/ODR") when
* offset cancellation is on. But in the single mode the ODR is not dependent on
* the configured value in Reg A. It is dependent on the frequency of the I2C
* signal. The slowest value we could measure by I2C frequency of 100000HZ was
* 13 ms. So we chose 20 ms.
*/
#define SAMPLE_FETCH_TIMEOUT_MS 20
struct lis2mdl_data lis2mdl_data;
LOG_MODULE_REGISTER(LIS2MDL, CONFIG_SENSOR_LOG_LEVEL);
#ifdef CONFIG_LIS2MDL_MAG_ODR_RUNTIME
static int lis2mdl_set_odr(const struct device *dev,
const struct sensor_value *val)
{
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2mdl_odr_t odr;
switch (val->val1) {
case 10:
odr = LIS2MDL_ODR_10Hz;
break;
case 20:
odr = LIS2MDL_ODR_20Hz;
break;
case 50:
odr = LIS2MDL_ODR_50Hz;
break;
case 100:
odr = LIS2MDL_ODR_100Hz;
break;
default:
return -EINVAL;
}
if (lis2mdl_data_rate_set(ctx, odr)) {
return -EIO;
}
return 0;
}
#endif /* CONFIG_LIS2MDL_MAG_ODR_RUNTIME */
static int lis2mdl_set_hard_iron(const struct device *dev,
enum sensor_channel chan,
const struct sensor_value *val)
{
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t i;
int16_t offset[3];
for (i = 0U; i < 3; i++) {
offset[i] = sys_cpu_to_le16(val->val1);
val++;
}
return lis2mdl_mag_user_offset_set(ctx, offset);
}
static void lis2mdl_channel_get_mag(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int32_t cval;
int i;
uint8_t ofs_start, ofs_stop;
struct lis2mdl_data *lis2mdl = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_MAGN_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_MAGN_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop; i++) {
cval = lis2mdl->mag[i] * 1500;
pval->val1 = cval / 1000000;
pval->val2 = cval % 1000000;
pval++;
}
}
/* read internal temperature */
static void lis2mdl_channel_get_temp(const struct device *dev,
struct sensor_value *val)
{
struct lis2mdl_data *drv_data = dev->data;
/* formula is temp = 25 + (temp / 8) C */
val->val1 = 25 + drv_data->temp_sample / 8;
val->val2 = (drv_data->temp_sample % 8) * 1000000 / 8;
}
static int lis2mdl_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
lis2mdl_channel_get_mag(dev, chan, val);
break;
case SENSOR_CHAN_DIE_TEMP:
lis2mdl_channel_get_temp(dev, val);
break;
default:
LOG_ERR("Channel not supported");
return -ENOTSUP;
}
return 0;
}
static int lis2mdl_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#ifdef CONFIG_LIS2MDL_MAG_ODR_RUNTIME
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lis2mdl_set_odr(dev, val);
#endif /* CONFIG_LIS2MDL_MAG_ODR_RUNTIME */
case SENSOR_ATTR_OFFSET:
return lis2mdl_set_hard_iron(dev, chan, val);
default:
LOG_ERR("Mag attribute not supported");
return -ENOTSUP;
}
return 0;
}
static int lis2mdl_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ALL:
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
return lis2mdl_config(dev, chan, attr, val);
default:
LOG_ERR("attr_set() not supported on %d channel", chan);
return -ENOTSUP;
}
return 0;
}
static int get_single_mode_raw_data(const struct device *dev,
int16_t *raw_mag)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int rc = 0;
rc = lis2mdl_operating_mode_set(ctx, LIS2MDL_SINGLE_TRIGGER);
if (rc) {
LOG_ERR("set single mode failed");
return rc;
}
if (k_sem_take(&lis2mdl->fetch_sem, K_MSEC(SAMPLE_FETCH_TIMEOUT_MS))) {
LOG_ERR("Magnetometer data not ready within %d ms",
SAMPLE_FETCH_TIMEOUT_MS);
return -EIO;
}
/* fetch raw data sample */
rc = lis2mdl_magnetic_raw_get(ctx, raw_mag);
if (rc) {
LOG_ERR("Failed to read sample");
return rc;
}
return 0;
}
static int lis2mdl_sample_fetch_mag(const struct device *dev)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t raw_mag[3];
int rc = 0;
if (cfg->single_mode) {
rc = get_single_mode_raw_data(dev, raw_mag);
if (rc) {
LOG_ERR("Failed to read raw data");
return rc;
}
lis2mdl->mag[0] = sys_le16_to_cpu(raw_mag[0]);
lis2mdl->mag[1] = sys_le16_to_cpu(raw_mag[1]);
lis2mdl->mag[2] = sys_le16_to_cpu(raw_mag[2]);
if (cfg->cancel_offset) {
/* The second measurement is needed when offset
* cancellation is enabled in the single mode. Then the
* average of the first measurement done above and this
* one would be the final value. This process is not
* needed in continuous mode since it has been taken
* care by lis2mdl itself automatically. Please refer
* to the application note for more details.
*/
rc = get_single_mode_raw_data(dev, raw_mag);
if (rc) {
LOG_ERR("Failed to read raw data");
return rc;
}
lis2mdl->mag[0] += sys_le16_to_cpu(raw_mag[0]);
lis2mdl->mag[1] += sys_le16_to_cpu(raw_mag[1]);
lis2mdl->mag[2] += sys_le16_to_cpu(raw_mag[2]);
lis2mdl->mag[0] /= 2;
lis2mdl->mag[1] /= 2;
lis2mdl->mag[2] /= 2;
}
} else {
/* fetch raw data sample */
rc = lis2mdl_magnetic_raw_get(ctx, raw_mag);
if (rc) {
LOG_ERR("Failed to read sample");
return rc;
}
lis2mdl->mag[0] = sys_le16_to_cpu(raw_mag[0]);
lis2mdl->mag[1] = sys_le16_to_cpu(raw_mag[1]);
lis2mdl->mag[2] = sys_le16_to_cpu(raw_mag[2]);
}
return 0;
}
static int lis2mdl_sample_fetch_temp(const struct device *dev)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int16_t raw_temp;
/* fetch raw temperature sample */
if (lis2mdl_temperature_raw_get(ctx, &raw_temp) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
lis2mdl->temp_sample = (sys_le16_to_cpu(raw_temp));
return 0;
}
static int lis2mdl_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
lis2mdl_sample_fetch_mag(dev);
break;
case SENSOR_CHAN_DIE_TEMP:
lis2mdl_sample_fetch_temp(dev);
break;
case SENSOR_CHAN_ALL:
lis2mdl_sample_fetch_mag(dev);
lis2mdl_sample_fetch_temp(dev);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lis2mdl_driver_api = {
.attr_set = lis2mdl_attr_set,
#if CONFIG_LIS2MDL_TRIGGER
.trigger_set = lis2mdl_trigger_set,
#endif
.sample_fetch = lis2mdl_sample_fetch,
.channel_get = lis2mdl_channel_get,
};
static int lis2mdl_init(const struct device *dev)
{
struct lis2mdl_data *lis2mdl = dev->data;
const struct lis2mdl_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t wai;
int rc = 0;
lis2mdl->dev = dev;
if (cfg->spi_4wires) {
/* Set SPI 4wires if it's the case */
if (lis2mdl_spi_mode_set(ctx, LIS2MDL_SPI_4_WIRE) < 0) {
return -EIO;
}
}
/* check chip ID */
if (lis2mdl_device_id_get(ctx, &wai) < 0) {
return -EIO;
}
if (wai != LIS2MDL_ID) {
LOG_ERR("Invalid chip ID: %02x", wai);
return -EINVAL;
}
/* reset sensor configuration */
if (lis2mdl_reset_set(ctx, PROPERTY_ENABLE) < 0) {
LOG_ERR("s/w reset failed");
return -EIO;
}
k_busy_wait(100);
if (cfg->spi_4wires) {
/* After s/w reset set SPI 4wires again if the case */
if (lis2mdl_spi_mode_set(ctx, LIS2MDL_SPI_4_WIRE) < 0) {
return -EIO;
}
}
/* enable BDU */
if (lis2mdl_block_data_update_set(ctx, PROPERTY_ENABLE) < 0) {
LOG_ERR("setting bdu failed");
return -EIO;
}
/* Set Output Data Rate */
if (lis2mdl_data_rate_set(ctx, LIS2MDL_ODR_10Hz)) {
LOG_ERR("set odr failed");
return -EIO;
}
if (cfg->cancel_offset) {
/* Set offset cancellation, common for both single and
* and continuous mode.
*/
if (lis2mdl_set_rst_mode_set(ctx,
LIS2MDL_SENS_OFF_CANC_EVERY_ODR)) {
LOG_ERR("reset sensor mode failed");
return -EIO;
}
}
/* Enable temperature compensation */
if (lis2mdl_offset_temp_comp_set(ctx, PROPERTY_ENABLE)) {
LOG_ERR("enable temp compensation failed");
return -EIO;
}
if (cfg->cancel_offset && cfg->single_mode) {
/* Set OFF_CANC_ONE_SHOT bit. This setting is only needed in
* the single-mode when offset cancellation is enabled.
*/
rc = lis2mdl_set_rst_sensor_single_set(ctx,
PROPERTY_ENABLE);
if (rc) {
LOG_ERR("Set offset cancellation failed");
return rc;
}
}
if (cfg->single_mode) {
/* Set drdy on pin 7 */
rc = lis2mdl_drdy_on_pin_set(ctx, 1);
if (rc) {
LOG_ERR("set drdy on pin failed!");
return rc;
}
/* Reboot sensor after setting the configuration registers */
rc = lis2mdl_boot_set(ctx, 1);
if (rc) {
LOG_ERR("Reboot failed.");
return rc;
}
k_sem_init(&lis2mdl->fetch_sem, 0, 1);
} else {
/* Set device in continuous mode */
rc = lis2mdl_operating_mode_set(ctx,
LIS2MDL_CONTINUOUS_MODE);
if (rc) {
LOG_ERR("set continuous mode failed");
return rc;
}
}
#ifdef CONFIG_LIS2MDL_TRIGGER
if (cfg->trig_enabled) {
if (lis2mdl_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupts");
return -EIO;
}
}
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int lis2mdl_pm_action(const struct device *dev,
enum pm_device_action action)
{
const struct lis2mdl_config *config = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&config->ctx;
int status = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
if (config->single_mode) {
status = lis2mdl_operating_mode_set(ctx,
LIS2MDL_SINGLE_TRIGGER);
} else {
status = lis2mdl_operating_mode_set(ctx,
LIS2MDL_CONTINUOUS_MODE);
}
if (status) {
LOG_ERR("Power up failed");
}
LOG_DBG("State changed to active");
break;
case PM_DEVICE_ACTION_SUSPEND:
status = lis2mdl_operating_mode_set(ctx, LIS2MDL_POWER_DOWN);
if (status) {
LOG_ERR("Power down failed");
}
LOG_DBG("State changed to inactive");
break;
default:
return -ENOTSUP;
}
return status;
}
#endif /* CONFIG_PM_DEVICE */
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LIS2MDL driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LIS2MDL_DEFINE_SPI() and
* LIS2MDL_DEFINE_I2C().
*/
#define LIS2MDL_DEVICE_INIT(inst) \
PM_DEVICE_DT_INST_DEFINE(inst, lis2mdl_pm_action); \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2mdl_init, \
PM_DEVICE_DT_INST_GET(inst), \
&lis2mdl_data_##inst, \
&lis2mdl_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2mdl_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2MDL_TRIGGER
#define LIS2MDL_CFG_IRQ(inst) \
.trig_enabled = true, \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, irq_gpios)
#else
#define LIS2MDL_CFG_IRQ(inst)
#endif /* CONFIG_LIS2MDL_TRIGGER */
#define LIS2MDL_CONFIG_COMMON(inst) \
.cancel_offset = DT_INST_PROP(inst, cancel_offset), \
.single_mode = DT_INST_PROP(inst, single_mode), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LIS2MDL_CFG_IRQ(inst)), ())
#define LIS2MDL_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LIS2MDL_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2mdl_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LIS2MDL_SPI_OPERATION, \
0), \
}, \
.spi_4wires = DT_INST_PROP(inst, duplex) == \
SPI_FULL_DUPLEX, \
LIS2MDL_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2MDL_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lis2mdl_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LIS2MDL_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2MDL_DEFINE(inst) \
static struct lis2mdl_data lis2mdl_data_##inst; \
static const struct lis2mdl_config lis2mdl_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2MDL_CONFIG_SPI(inst)), \
(LIS2MDL_CONFIG_I2C(inst))); \
LIS2MDL_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2MDL_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2mdl/lis2mdl.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,217 |
```c
/*
*
*/
#define DT_DRV_COMPAT st_lsm6dsl
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm6dsl.h"
LOG_MODULE_DECLARE(LSM6DSL, CONFIG_SENSOR_LOG_LEVEL);
static inline void setup_irq(const struct device *dev, bool enable)
{
const struct lsm6dsl_config *config = dev->config;
unsigned int flags = enable
? GPIO_INT_EDGE_TO_ACTIVE
: GPIO_INT_DISABLE;
gpio_pin_interrupt_configure_dt(&config->int_gpio, flags);
}
static inline void handle_irq(const struct device *dev)
{
struct lsm6dsl_data *drv_data = dev->data;
setup_irq(dev, false);
#if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD)
k_sem_give(&drv_data->gpio_sem);
#elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD)
k_work_submit(&drv_data->work);
#endif
}
int lsm6dsl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lsm6dsl_config *config = dev->config;
struct lsm6dsl_data *drv_data = dev->data;
__ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY);
/* If irq_gpio is not configured in DT just return error */
if (!config->int_gpio.port) {
LOG_ERR("triggers not supported");
return -ENOTSUP;
}
setup_irq(dev, false);
drv_data->data_ready_handler = handler;
if (handler == NULL) {
return 0;
}
drv_data->data_ready_trigger = trig;
setup_irq(dev, true);
if (gpio_pin_get_dt(&config->int_gpio) > 0) {
handle_irq(dev);
}
return 0;
}
static void lsm6dsl_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lsm6dsl_data *drv_data =
CONTAINER_OF(cb, struct lsm6dsl_data, gpio_cb);
ARG_UNUSED(pins);
handle_irq(drv_data->dev);
}
static void lsm6dsl_thread_cb(const struct device *dev)
{
struct lsm6dsl_data *drv_data = dev->data;
if (drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
drv_data->data_ready_trigger);
}
setup_irq(dev, true);
}
#ifdef CONFIG_LSM6DSL_TRIGGER_OWN_THREAD
static void lsm6dsl_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
const struct device *dev = p1;
struct lsm6dsl_data *drv_data = dev->data;
while (1) {
k_sem_take(&drv_data->gpio_sem, K_FOREVER);
lsm6dsl_thread_cb(dev);
}
}
#endif
#ifdef CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD
static void lsm6dsl_work_cb(struct k_work *work)
{
struct lsm6dsl_data *drv_data =
CONTAINER_OF(work, struct lsm6dsl_data, work);
lsm6dsl_thread_cb(drv_data->dev);
}
#endif
int lsm6dsl_init_interrupt(const struct device *dev)
{
const struct lsm6dsl_config *config = dev->config;
struct lsm6dsl_data *drv_data = dev->data;
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("GPIO device not ready");
return -ENODEV;
}
gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
gpio_init_callback(&drv_data->gpio_cb,
lsm6dsl_gpio_callback, BIT(config->int_gpio.pin));
if (gpio_add_callback(config->int_gpio.port, &drv_data->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback.");
return -EIO;
}
/* enable data-ready interrupt */
if (drv_data->hw_tf->update_reg(dev,
LSM6DSL_REG_INT1_CTRL,
LSM6DSL_MASK_INT1_CTRL_DRDY_XL |
LSM6DSL_MASK_INT1_CTRL_DRDY_G,
BIT(LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL) |
BIT(LSM6DSL_SHIFT_INT1_CTRL_DRDY_G)) < 0) {
LOG_ERR("Could not enable data-ready interrupt.");
return -EIO;
}
drv_data->dev = dev;
#if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD)
k_sem_init(&drv_data->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&drv_data->thread, drv_data->thread_stack,
CONFIG_LSM6DSL_THREAD_STACK_SIZE,
lsm6dsl_thread, (void *)dev,
NULL, NULL, K_PRIO_COOP(CONFIG_LSM6DSL_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD)
drv_data->work.handler = lsm6dsl_work_cb;
#endif
setup_irq(dev, true);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,139 |
```c
/* lsm6dsl_spi.c - SPI routines for LSM6DSL driver
*/
/*
*
*/
#define DT_DRV_COMPAT st_lsm6dsl
#include <string.h>
#include <zephyr/logging/log.h>
#include "lsm6dsl.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define LSM6DSL_SPI_READ (1 << 7)
LOG_MODULE_DECLARE(LSM6DSL, CONFIG_SENSOR_LOG_LEVEL);
static int lsm6dsl_raw_read(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lsm6dsl_config *cfg = dev->config;
uint8_t buffer_tx[2] = { reg_addr | LSM6DSL_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 = value,
.len = len,
}
};
const struct spi_buf_set rx = {
.buffers = rx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (spi_transceive_dt(&cfg->bus_cfg.spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int lsm6dsl_raw_write(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lsm6dsl_config *cfg = dev->config;
uint8_t buffer_tx[1] = { reg_addr & ~LSM6DSL_SPI_READ };
const struct spi_buf tx_buf[2] = {
{
.buf = buffer_tx,
.len = 1,
},
{
.buf = value,
.len = len,
}
};
const struct spi_buf_set tx = {
.buffers = tx_buf,
.count = 2
};
if (len > 64) {
return -EIO;
}
if (spi_write_dt(&cfg->bus_cfg.spi, &tx)) {
return -EIO;
}
return 0;
}
static int lsm6dsl_spi_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return lsm6dsl_raw_read(dev, reg_addr, value, len);
}
static int lsm6dsl_spi_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
return lsm6dsl_raw_write(dev, reg_addr, value, len);
}
static int lsm6dsl_spi_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
return lsm6dsl_raw_read(dev, reg_addr, value, 1);
}
static int lsm6dsl_spi_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
uint8_t tmp_val;
lsm6dsl_raw_read(dev, reg_addr, &tmp_val, 1);
tmp_val = (tmp_val & ~mask) | (value & mask);
return lsm6dsl_raw_write(dev, reg_addr, &tmp_val, 1);
}
static const struct lsm6dsl_transfer_function lsm6dsl_spi_transfer_fn = {
.read_data = lsm6dsl_spi_read_data,
.write_data = lsm6dsl_spi_write_data,
.read_reg = lsm6dsl_spi_read_reg,
.update_reg = lsm6dsl_spi_update_reg,
};
int lsm6dsl_spi_init(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
const struct lsm6dsl_config *cfg = dev->config;
data->hw_tf = &lsm6dsl_spi_transfer_fn;
if (!spi_is_ready_dt(&cfg->bus_cfg.spi)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 930 |
```c
/* lsm6dsl.c - Driver for LSM6DSL accelerometer, gyroscope and
* temperature sensor
*/
/*
*
*/
#define DT_DRV_COMPAT st_lsm6dsl
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device.h>
#include "lsm6dsl.h"
LOG_MODULE_REGISTER(LSM6DSL, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t lsm6dsl_odr_map[] = {0, 12, 26, 52, 104, 208, 416, 833,
1666, 3332, 6664, 1};
#if defined(LSM6DSL_ACCEL_ODR_RUNTIME) || defined(LSM6DSL_GYRO_ODR_RUNTIME) ||\
defined(CONFIG_PM_DEVICE)
static int lsm6dsl_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dsl_odr_map); i++) {
if (freq == lsm6dsl_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
#endif
static int lsm6dsl_odr_to_freq_val(uint16_t odr)
{
/* for valid index, return value from map */
if (odr < ARRAY_SIZE(lsm6dsl_odr_map)) {
return lsm6dsl_odr_map[odr];
}
/* invalid index, return the fastest entry (6.66kHz) */
BUILD_ASSERT(ARRAY_SIZE(lsm6dsl_odr_map) > 10);
return lsm6dsl_odr_map[10];
}
#ifdef LSM6DSL_ACCEL_FS_RUNTIME
static const uint16_t lsm6dsl_accel_fs_map[] = {2, 16, 4, 8};
static const uint16_t lsm6dsl_accel_fs_sens[] = {1, 8, 2, 4};
static int lsm6dsl_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dsl_accel_fs_map); i++) {
if (range == lsm6dsl_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
#endif
#ifdef LSM6DSL_GYRO_FS_RUNTIME
static const uint16_t lsm6dsl_gyro_fs_map[] = {250, 500, 1000, 2000, 125};
static const uint16_t lsm6dsl_gyro_fs_sens[] = {2, 4, 8, 16, 1};
static int lsm6dsl_gyro_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(lsm6dsl_gyro_fs_map); i++) {
if (range == lsm6dsl_gyro_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
#endif
static inline int lsm6dsl_reboot(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
if (data->hw_tf->update_reg(dev, LSM6DSL_REG_CTRL3_C,
LSM6DSL_MASK_CTRL3_C_BOOT,
1 << LSM6DSL_SHIFT_CTRL3_C_BOOT) < 0) {
return -EIO;
}
/* Wait sensor turn-on time as per datasheet */
k_busy_wait(USEC_PER_MSEC * 35U);
return 0;
}
static int lsm6dsl_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
struct lsm6dsl_data *data = dev->data;
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL1_XL,
LSM6DSL_MASK_CTRL1_XL_FS_XL,
fs << LSM6DSL_SHIFT_CTRL1_XL_FS_XL) < 0) {
return -EIO;
}
return 0;
}
static int lsm6dsl_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
struct lsm6dsl_data *data = dev->data;
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL1_XL,
LSM6DSL_MASK_CTRL1_XL_ODR_XL,
odr << LSM6DSL_SHIFT_CTRL1_XL_ODR_XL) < 0) {
return -EIO;
}
data->accel_freq = lsm6dsl_odr_to_freq_val(odr);
return 0;
}
static int lsm6dsl_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
struct lsm6dsl_data *data = dev->data;
if (fs == GYRO_FULLSCALE_125) {
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL2_G,
LSM6DSL_MASK_CTRL2_FS125 | LSM6DSL_MASK_CTRL2_G_FS_G,
1 << LSM6DSL_SHIFT_CTRL2_FS125) < 0) {
return -EIO;
}
} else {
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL2_G,
LSM6DSL_MASK_CTRL2_FS125 | LSM6DSL_MASK_CTRL2_G_FS_G,
fs << LSM6DSL_SHIFT_CTRL2_G_FS_G) < 0) {
return -EIO;
}
}
return 0;
}
static int lsm6dsl_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
struct lsm6dsl_data *data = dev->data;
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL2_G,
LSM6DSL_MASK_CTRL2_G_ODR_G,
odr << LSM6DSL_SHIFT_CTRL2_G_ODR_G) < 0) {
return -EIO;
}
data->gyro_freq = lsm6dsl_odr_to_freq_val(odr);
return 0;
}
#ifdef LSM6DSL_ACCEL_ODR_RUNTIME
static int lsm6dsl_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dsl_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dsl_accel_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
#endif
#ifdef LSM6DSL_ACCEL_FS_RUNTIME
static int lsm6dsl_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dsl_data *data = dev->data;
fs = lsm6dsl_accel_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dsl_accel_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->accel_sensitivity = (float)(lsm6dsl_accel_fs_sens[fs]
* SENSI_GRAIN_XL);
return 0;
}
#endif
static int lsm6dsl_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#ifdef LSM6DSL_ACCEL_FS_RUNTIME
case SENSOR_ATTR_FULL_SCALE:
return lsm6dsl_accel_range_set(dev, sensor_ms2_to_g(val));
#endif
#ifdef LSM6DSL_ACCEL_ODR_RUNTIME
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dsl_accel_odr_set(dev, val->val1);
#endif
default:
LOG_DBG("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#ifdef LSM6DSL_GYRO_ODR_RUNTIME
static int lsm6dsl_gyro_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = lsm6dsl_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (lsm6dsl_gyro_set_odr_raw(dev, odr) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
return 0;
}
#endif
#ifdef LSM6DSL_GYRO_FS_RUNTIME
static int lsm6dsl_gyro_range_set(const struct device *dev, int32_t range)
{
int fs;
struct lsm6dsl_data *data = dev->data;
fs = lsm6dsl_gyro_range_to_fs_val(range);
if (fs < 0) {
return fs;
}
if (lsm6dsl_gyro_set_fs_raw(dev, fs) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_sensitivity = (float)(lsm6dsl_gyro_fs_sens[fs]
* SENSI_GRAIN_G);
return 0;
}
#endif
static int lsm6dsl_gyro_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#ifdef LSM6DSL_GYRO_FS_RUNTIME
case SENSOR_ATTR_FULL_SCALE:
return lsm6dsl_gyro_range_set(dev, sensor_rad_to_degrees(val));
#endif
#ifdef LSM6DSL_GYRO_ODR_RUNTIME
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm6dsl_gyro_odr_set(dev, val->val1);
#endif
default:
LOG_DBG("Gyro attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dsl_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return lsm6dsl_accel_config(dev, chan, attr, val);
case SENSOR_CHAN_GYRO_XYZ:
return lsm6dsl_gyro_config(dev, chan, attr, val);
default:
LOG_WRN("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
static int lsm6dsl_sample_fetch_accel(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t buf[6];
if (data->hw_tf->read_data(dev, LSM6DSL_REG_OUTX_L_XL,
buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
data->accel_sample_x = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
data->accel_sample_y = (int16_t)((uint16_t)(buf[2]) |
((uint16_t)(buf[3]) << 8));
data->accel_sample_z = (int16_t)((uint16_t)(buf[4]) |
((uint16_t)(buf[5]) << 8));
return 0;
}
static int lsm6dsl_sample_fetch_gyro(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t buf[6];
if (data->hw_tf->read_data(dev, LSM6DSL_REG_OUTX_L_G,
buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
data->gyro_sample_x = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
data->gyro_sample_y = (int16_t)((uint16_t)(buf[2]) |
((uint16_t)(buf[3]) << 8));
data->gyro_sample_z = (int16_t)((uint16_t)(buf[4]) |
((uint16_t)(buf[5]) << 8));
return 0;
}
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
static int lsm6dsl_sample_fetch_temp(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t buf[2];
if (data->hw_tf->read_data(dev, LSM6DSL_REG_OUT_TEMP_L,
buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read sample");
return -EIO;
}
data->temp_sample = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
return 0;
}
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
static int lsm6dsl_sample_fetch_magn(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t buf[6];
if (lsm6dsl_shub_read_external_chip(dev, buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read ext mag sample");
return -EIO;
}
data->magn_sample_x = (int16_t)((uint16_t)(buf[0]) |
((uint16_t)(buf[1]) << 8));
data->magn_sample_y = (int16_t)((uint16_t)(buf[2]) |
((uint16_t)(buf[3]) << 8));
data->magn_sample_z = (int16_t)((uint16_t)(buf[4]) |
((uint16_t)(buf[5]) << 8));
return 0;
}
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
static int lsm6dsl_sample_fetch_press(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t buf[5];
if (lsm6dsl_shub_read_external_chip(dev, buf, sizeof(buf)) < 0) {
LOG_DBG("failed to read ext press sample");
return -EIO;
}
data->sample_press = (int32_t)((uint32_t)(buf[0]) |
((uint32_t)(buf[1]) << 8) |
((uint32_t)(buf[2]) << 16));
data->sample_temp = (int16_t)((uint16_t)(buf[3]) |
((uint16_t)(buf[4]) << 8));
return 0;
}
#endif
static int lsm6dsl_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dsl_sample_fetch_accel(dev);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6dsl_sample_fetch_gyro(dev);
break;
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dsl_sample_fetch_temp(dev);
break;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
case SENSOR_CHAN_MAGN_XYZ:
lsm6dsl_sample_fetch_magn(dev);
break;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
case SENSOR_CHAN_AMBIENT_TEMP:
case SENSOR_CHAN_PRESS:
lsm6dsl_sample_fetch_press(dev);
break;
#endif
case SENSOR_CHAN_ALL:
lsm6dsl_sample_fetch_accel(dev);
lsm6dsl_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
lsm6dsl_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
lsm6dsl_sample_fetch_magn(dev);
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
lsm6dsl_sample_fetch_press(dev);
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void lsm6dsl_accel_convert(struct sensor_value *val, int raw_val,
float sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)raw_val * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int lsm6dsl_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data,
float sensitivity)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm6dsl_accel_convert(val, data->accel_sample_x, sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm6dsl_accel_convert(val, data->accel_sample_y, sensitivity);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm6dsl_accel_convert(val, data->accel_sample_z, sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dsl_accel_convert(val, data->accel_sample_x, sensitivity);
lsm6dsl_accel_convert(val + 1, data->accel_sample_y,
sensitivity);
lsm6dsl_accel_convert(val + 2, data->accel_sample_z,
sensitivity);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dsl_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data)
{
return lsm6dsl_accel_get_channel(chan, val, data,
data->accel_sensitivity);
}
static inline void lsm6dsl_gyro_convert(struct sensor_value *val, int raw_val,
float sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in udps/LSB */
/* So, calculate value in 10 udps unit and then to rad/s */
dval = (int64_t)raw_val * sensitivity / 10;
sensor_10udegrees_to_rad(dval, val);
}
static inline int lsm6dsl_gyro_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data,
float sensitivity)
{
switch (chan) {
case SENSOR_CHAN_GYRO_X:
lsm6dsl_gyro_convert(val, data->gyro_sample_x, sensitivity);
break;
case SENSOR_CHAN_GYRO_Y:
lsm6dsl_gyro_convert(val, data->gyro_sample_y, sensitivity);
break;
case SENSOR_CHAN_GYRO_Z:
lsm6dsl_gyro_convert(val, data->gyro_sample_z, sensitivity);
break;
case SENSOR_CHAN_GYRO_XYZ:
lsm6dsl_gyro_convert(val, data->gyro_sample_x, sensitivity);
lsm6dsl_gyro_convert(val + 1, data->gyro_sample_y, sensitivity);
lsm6dsl_gyro_convert(val + 2, data->gyro_sample_z, sensitivity);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dsl_gyro_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data)
{
return lsm6dsl_gyro_get_channel(chan, val, data,
data->gyro_sensitivity);
}
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
static void lsm6dsl_gyro_channel_get_temp(struct sensor_value *val,
struct lsm6dsl_data *data)
{
/* val = temp_sample / 256 + 25 */
val->val1 = data->temp_sample / 256 + 25;
val->val2 = (data->temp_sample % 256) * (1000000 / 256);
}
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
static inline void lsm6dsl_magn_convert(struct sensor_value *val, int raw_val,
float sensitivity)
{
double dval;
/* Sensitivity is exposed in mgauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int lsm6dsl_magn_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm6dsl_magn_convert(val,
data->magn_sample_x,
data->magn_sensitivity);
break;
case SENSOR_CHAN_MAGN_Y:
lsm6dsl_magn_convert(val,
data->magn_sample_y,
data->magn_sensitivity);
break;
case SENSOR_CHAN_MAGN_Z:
lsm6dsl_magn_convert(val,
data->magn_sample_z,
data->magn_sensitivity);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm6dsl_magn_convert(val,
data->magn_sample_x,
data->magn_sensitivity);
lsm6dsl_magn_convert(val + 1,
data->magn_sample_y,
data->magn_sensitivity);
lsm6dsl_magn_convert(val + 2,
data->magn_sample_z,
data->magn_sensitivity);
break;
default:
return -ENOTSUP;
}
return 0;
}
static int lsm6dsl_magn_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct lsm6dsl_data *data)
{
return lsm6dsl_magn_get_channel(chan, val, data);
}
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
static inline void lps22hb_press_convert(struct sensor_value *val,
int32_t raw_val)
{
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void lps22hb_temp_convert(struct sensor_value *val,
int16_t raw_val)
{
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int lsm6dsl_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm6dsl_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lsm6dsl_accel_channel_get(chan, val, data);
break;
case SENSOR_CHAN_GYRO_X:
case SENSOR_CHAN_GYRO_Y:
case SENSOR_CHAN_GYRO_Z:
case SENSOR_CHAN_GYRO_XYZ:
lsm6dsl_gyro_channel_get(chan, val, data);
break;
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
lsm6dsl_gyro_channel_get_temp(val, data);
break;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
lsm6dsl_magn_channel_get(chan, val, data);
break;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
case SENSOR_CHAN_PRESS:
lps22hb_press_convert(val, data->sample_press);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
lps22hb_temp_convert(val, data->sample_temp);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api lsm6dsl_driver_api = {
.attr_set = lsm6dsl_attr_set,
#if CONFIG_LSM6DSL_TRIGGER
.trigger_set = lsm6dsl_trigger_set,
#endif
.sample_fetch = lsm6dsl_sample_fetch,
.channel_get = lsm6dsl_channel_get,
};
static int lsm6dsl_init_chip(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint8_t chip_id;
if (lsm6dsl_reboot(dev) < 0) {
LOG_DBG("failed to reboot device");
return -EIO;
}
if (data->hw_tf->read_reg(dev, LSM6DSL_REG_WHO_AM_I, &chip_id) < 0) {
LOG_DBG("failed reading chip id");
return -EIO;
}
if (chip_id != LSM6DSL_VAL_WHO_AM_I) {
LOG_DBG("invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_DBG("chip id 0x%x", chip_id);
if (lsm6dsl_accel_set_fs_raw(dev,
LSM6DSL_DEFAULT_ACCEL_FULLSCALE) < 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
data->accel_sensitivity = LSM6DSL_DEFAULT_ACCEL_SENSITIVITY;
if (lsm6dsl_accel_set_odr_raw(dev, CONFIG_LSM6DSL_ACCEL_ODR) < 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
if (lsm6dsl_gyro_set_fs_raw(dev, LSM6DSL_DEFAULT_GYRO_FULLSCALE) < 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
data->gyro_sensitivity = LSM6DSL_DEFAULT_GYRO_SENSITIVITY;
if (lsm6dsl_gyro_set_odr_raw(dev, CONFIG_LSM6DSL_GYRO_ODR) < 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_FIFO_CTRL5,
LSM6DSL_MASK_FIFO_CTRL5_FIFO_MODE,
0 << LSM6DSL_SHIFT_FIFO_CTRL5_FIFO_MODE) < 0) {
LOG_DBG("failed to set FIFO mode");
return -EIO;
}
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL3_C,
LSM6DSL_MASK_CTRL3_C_BDU |
LSM6DSL_MASK_CTRL3_C_BLE |
LSM6DSL_MASK_CTRL3_C_IF_INC,
(1 << LSM6DSL_SHIFT_CTRL3_C_BDU) |
(0 << LSM6DSL_SHIFT_CTRL3_C_BLE) |
(1 << LSM6DSL_SHIFT_CTRL3_C_IF_INC)) < 0) {
LOG_DBG("failed to set BDU, BLE and burst");
return -EIO;
}
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL6_C,
LSM6DSL_MASK_CTRL6_C_XL_HM_MODE,
(1 << LSM6DSL_SHIFT_CTRL6_C_XL_HM_MODE)) < 0) {
LOG_DBG("failed to disable accelerometer high performance mode");
return -EIO;
}
if (data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL7_G,
LSM6DSL_MASK_CTRL7_G_HM_MODE,
(1 << LSM6DSL_SHIFT_CTRL7_G_HM_MODE)) < 0) {
LOG_DBG("failed to disable gyroscope high performance mode");
return -EIO;
}
return 0;
}
static int lsm6dsl_init(const struct device *dev)
{
int ret;
const struct lsm6dsl_config * const config = dev->config;
ret = config->bus_init(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize sensor bus");
return ret;
}
ret = lsm6dsl_init_chip(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize chip");
return ret;
}
#ifdef CONFIG_LSM6DSL_TRIGGER
ret = lsm6dsl_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupt.");
return ret;
}
#endif
#ifdef CONFIG_LSM6DSL_SENSORHUB
ret = lsm6dsl_shub_init_external_chip(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize external chip");
return ret;
}
#endif
return 0;
}
#ifdef CONFIG_PM_DEVICE
static int lsm6dsl_pm_action(const struct device *dev,
enum pm_device_action action)
{
struct lsm6dsl_data *data = dev->data;
int ret = -EIO;
uint8_t accel_odr = 0;
uint8_t gyro_odr = 0;
switch (action) {
case PM_DEVICE_ACTION_RESUME:
/* Restore saved ODR values */
accel_odr = lsm6dsl_freq_to_odr_val(data->accel_freq);
ret = lsm6dsl_accel_set_odr_raw(dev, accel_odr);
if (ret < 0) {
LOG_ERR("Failed to resume accelerometer");
break;
}
gyro_odr = lsm6dsl_freq_to_odr_val(data->gyro_freq);
ret = lsm6dsl_gyro_set_odr_raw(dev, gyro_odr);
if (ret < 0) {
LOG_ERR("Failed to resume gyro");
break;
}
break;
case PM_DEVICE_ACTION_SUSPEND:
/*
* Set accelerometer ODR to power-down. Don't use the direct
* function to not overwrite the saved value
*/
ret = data->hw_tf->update_reg(dev, LSM6DSL_REG_CTRL1_XL,
LSM6DSL_MASK_CTRL1_XL_ODR_XL, 0);
if (ret < 0) {
LOG_ERR("Failed to suspend accelerometer");
break;
}
/* Set gyro ODR to power-down */
ret = data->hw_tf->update_reg(dev, LSM6DSL_REG_CTRL2_G,
LSM6DSL_MASK_CTRL2_G_ODR_G, 0);
if (ret < 0) {
LOG_ERR("Failed to suspend gyro");
break;
}
break;
default:
return -ENOTSUP;
}
return ret;
}
#endif
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LSM6DSL driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LSM6DSL_DEFINE_SPI() and
* LSM6DSL_DEFINE_I2C().
*/
#define LSM6DSL_DEVICE_INIT(inst) \
PM_DEVICE_DT_INST_DEFINE(inst, lsm6dsl_pm_action); \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lsm6dsl_init, \
PM_DEVICE_DT_INST_GET(inst), \
&lsm6dsl_data_##inst, \
&lsm6dsl_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lsm6dsl_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LSM6DSL_TRIGGER
#define LSM6DSL_CFG_IRQ(inst) \
.int_gpio = GPIO_DT_SPEC_INST_GET(inst, irq_gpios),
#else
#define LSM6DSL_CFG_IRQ(inst)
#endif /* CONFIG_LSM6DSL_TRIGGER */
#define LSM6DSL_CONFIG_SPI(inst) \
{ \
.bus_init = lsm6dsl_spi_init, \
.bus_cfg.spi = SPI_DT_SPEC_INST_GET(inst, SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA, 0), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LSM6DSL_CFG_IRQ(inst)), ()) \
}
#define LSM6DSL_DEFINE_SPI(inst) \
static struct lsm6dsl_data lsm6dsl_data_##inst; \
static const struct lsm6dsl_config lsm6dsl_config_##inst = \
LSM6DSL_CONFIG_SPI(inst); \
LSM6DSL_DEVICE_INIT(inst)
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LSM6DSL_CONFIG_I2C(inst) \
{ \
.bus_init = lsm6dsl_i2c_init, \
.bus_cfg.i2c = I2C_DT_SPEC_INST_GET(inst), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LSM6DSL_CFG_IRQ(inst)), ()) \
}
#define LSM6DSL_DEFINE_I2C(inst) \
static struct lsm6dsl_data lsm6dsl_data_##inst; \
static const struct lsm6dsl_config lsm6dsl_config_##inst = \
LSM6DSL_CONFIG_I2C(inst); \
LSM6DSL_DEVICE_INIT(inst)
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LSM6DSL_DEFINE(inst) \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LSM6DSL_DEFINE_SPI(inst)), \
(LSM6DSL_DEFINE_I2C(inst)))
DT_INST_FOREACH_STATUS_OKAY(LSM6DSL_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,401 |
```c
/* lsm6dsl_i2c.c - I2C routines for LSM6DSL driver
*/
/*
*
*/
#define DT_DRV_COMPAT st_lsm6dsl
#include <string.h>
#include <zephyr/logging/log.h>
#include "lsm6dsl.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(LSM6DSL, CONFIG_SENSOR_LOG_LEVEL);
static int lsm6dsl_i2c_read_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lsm6dsl_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->bus_cfg.i2c, reg_addr, value, len);
}
static int lsm6dsl_i2c_write_data(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
const struct lsm6dsl_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->bus_cfg.i2c, reg_addr, value, len);
}
static int lsm6dsl_i2c_read_reg(const struct device *dev, uint8_t reg_addr,
uint8_t *value)
{
const struct lsm6dsl_config *cfg = dev->config;
return i2c_reg_read_byte_dt(&cfg->bus_cfg.i2c, reg_addr, value);
}
static int lsm6dsl_i2c_update_reg(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value)
{
const struct lsm6dsl_config *cfg = dev->config;
return i2c_reg_update_byte_dt(&cfg->bus_cfg.i2c, reg_addr, mask, value);
}
static const struct lsm6dsl_transfer_function lsm6dsl_i2c_transfer_fn = {
.read_data = lsm6dsl_i2c_read_data,
.write_data = lsm6dsl_i2c_write_data,
.read_reg = lsm6dsl_i2c_read_reg,
.update_reg = lsm6dsl_i2c_update_reg,
};
int lsm6dsl_i2c_init(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
const struct lsm6dsl_config *cfg = dev->config;
data->hw_tf = &lsm6dsl_i2c_transfer_fn;
if (!device_is_ready(cfg->bus_cfg.i2c.bus)) {
return -ENODEV;
}
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 555 |
```unknown
# LSM6DSL accelerometer and gyroscope sensor configuration
# options
menuconfig LSM6DSL
bool "LSM6DSL I2C/SPI accelerometer and gyroscope Chip"
default y
depends on DT_HAS_ST_LSM6DSL_ENABLED
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSL),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LSM6DSL),spi)
help
Enable driver for LSM6DSL accelerometer and gyroscope
sensor.
if LSM6DSL
choice LSM6DSL_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LSM6DSL_TRIGGER_NONE
bool "No trigger"
config LSM6DSL_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LSM6DSL_TRIGGER
config LSM6DSL_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LSM6DSL_TRIGGER
endchoice
config LSM6DSL_TRIGGER
bool
config LSM6DSL_THREAD_PRIORITY
int "Thread priority"
depends on LSM6DSL_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LSM6DSL_THREAD_STACK_SIZE
int "Thread stack size"
depends on LSM6DSL_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config LSM6DSL_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config LSM6DSL_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub
choice LSM6DSL_EXTERNAL_SENSOR_0
prompt "External sensor 0"
depends on LSM6DSL_SENSORHUB
help
Choose the external sensor 0 connected to LSM6DS3.
config LSM6DSL_EXT0_LIS2MDL
bool "LIS2MDL"
config LSM6DSL_EXT0_LIS3MDL
bool "LIS3MDL"
config LSM6DSL_EXT0_LPS22HB
bool "LPS22HB"
endchoice
menu "Attributes"
config LSM6DSL_GYRO_FS
int "Gyroscope full-scale range"
default 0
help
Specify the default gyroscope full-scale range.
An X value for the config represents a range of +/- X degree per
second. Valid values are:
0: Full Scale selected at runtime
125: +/- 125dps
250: +/- 250dps
500: +/- 500dps
1000: +/- 1000dps
2000: +/- 2000dps
config LSM6DSL_GYRO_ODR
int "Gyroscope Output data rate frequency"
range 0 10
default 0
help
Specify the default accelerometer output data rate expressed in
samples per second (Hz).
0: ODR selected at runtime
1: 12.5Hz
2: 26Hz
3: 52Hz
4: 104Hz
5: 208Hz
6: 416Hz
7: 833Hz
8: 1660Hz
9: 3330Hz
10: 6660Hz
config LSM6DSL_ACCEL_FS
int "Accelerometer full-scale range"
default 0
help
Specify the default accelerometer full-scale range.
An X value for the config represents a range of +/- X G. Valid values
are:
0: Full Scale selected at runtime
2: +/- 2g
4: +/- 4g
8: +/- 8g
16: +/- 16g
config LSM6DSL_ACCEL_ODR
int "Accelerometer Output data rate frequency"
range 0 11
default 0
help
Specify the default accelerometer output data rate expressed in
samples per second (Hz).
0: ODR selected at runtime
1: 12.5Hz
2: 26Hz
3: 52Hz
4: 104Hz
5: 208Hz
6: 416Hz
7: 833Hz
8: 1666Hz
9: 3332Hz
10: 6664Hz
11: 1.6Hz
endmenu
endif # LSM6DSL
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 993 |
```objective-c
/* sensor_lsm6dsl.h - header file for LSM6DSL accelerometer, gyroscope and
* temperature sensor driver
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM6DSL_LSM6DSL_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM6DSL_LSM6DSL_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define LSM6DSL_REG_FUNC_CFG_ACCESS 0x01
#define LSM6DSL_MASK_FUNC_CFG_EN BIT(7)
#define LSM6DSL_SHIFT_FUNC_CFG_EN 7
#define LSM6DSL_MASK_FUNC_CFG_EN_B BIT(5)
#define LSM6DSL_SHIFT_FUNC_CFG_EN_B 5
#define LSM6DSL_REG_SENSOR_SYNC_TIME_FRAME 0x04
#define LSM6DSL_MASK_SENSOR_SYNC_TIME_FRAME_TPH (BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_SENSOR_SYNC_TIME_FRAME_TPH 0
#define LSM6DSL_REG_SENSOR_SYNC_RES_RATIO 0x05
#define LSM6DSL_MASK_SENSOR_SYNC_RES_RATIO (BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_SENSOR_SYNC_RES_RATIO 0
#define LSM6DSL_REG_FIFO_CTRL1 0x06
#define LSM6DSL_MASK_FIFO_CTRL1_FTH (BIT(7) | BIT(6) | \
BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_FIFO_CTRL1_FTH 0
#define LSM6DSL_REG_FIFO_CTRL2 0x07
#define LSM6DSL_MASK_FIFO_CTRL2_TIMER_PEDO_FIFO_EN BIT(7)
#define LSM6DSL_SHIFT_FIFO_CTRL2_TIMER_PEDO_FIFO_EN 7
#define LSM6DSL_MASK_FIFO_CTRL2_TIMER_PEDO_FIFO_DRDY BIT(6)
#define LSM6DSL_SHIFT_FIFO_CTRL2_TIMER_PEDO_FIFO_DRDY 6
#define LSM6DSL_MASK_FIFO_CTRL2_FIFO_TEMP_EN BIT(3)
#define LSM6DSL_SHIFT_FIFO_CTRL2_FIFO_TEMP_EN 3
#define LSM6DSL_MASK_FIFO_CTRL2_FTH (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FIFO_CTRL2_FTH 0
#define LSM6DSL_REG_FIFO_CTRL3 0x08
#define LSM6DSL_MASK_FIFO_CTRL3_DEC_FIFO_GYRO (BIT(5) | BIT(4) | \
BIT(3))
#define LSM6DSL_SHIFT_FIFO_CTRL3_DEC_FIFO_GYRO 3
#define LSM6DSL_MASK_FIFO_CTRL3_DEC_FIFO_XL (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FIFO_CTRL3_DEC_FIFO_XL 0
#define LSM6DSL_REG_FIFO_CTRL4 0x09
#define LSM6DSL_MASK_FIFO_CTRL4_STOP_ON_FTH BIT(7)
#define LSM6DSL_SHIFT_FIFO_CTRL4_STOP_ON_FTH 7
#define LSM6DSL_MASK_FIFO_CTRL4_ONLY_HIGH_DATA BIT(6)
#define LSM6DSL_SHIFT_FIFO_CTRL4_ONLY_HIGH_DATA 6
#define LSM6DSL_MASK_FIFO_CTRL4_DEC_DS4_FIFO (BIT(5) | BIT(4) | \
BIT(3))
#define LSM6DSL_SHIFT_FIFO_CTRL4_DEC_DS4_FIFO 3
#define LSM6DSL_MASK_FIFO_CTRL4_DEC_DS3_FIFO (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FIFO_CTRL4_DEC_DS3_FIFO 0
#define LSM6DSL_REG_FIFO_CTRL5 0x0A
#define LSM6DSL_MASK_FIFO_CTRL5_ODR_FIFO (BIT(6) | BIT(5) | \
BIT(4) | BIT(3))
#define LSM6DSL_SHIFT_FIFO_CTRL5_ODR_FIFO 3
#define LSM6DSL_MASK_FIFO_CTRL5_FIFO_MODE (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FIFO_CTRL5_FIFO_MODE 0
#define LSM6DSL_REG_DRDY_PULSE_CFG_G 0x0B
#define LSM6DSL_MASK_DRDY_PULSE_CFG_G_DRDY_PULSED BIT(7)
#define LSM6DSL_SHIFT_DRDY_PULSE_CFG_G_DRDY_PULSED 7
#define LSM6DSL_MASK_DRDY_PULSE_CFG_G_INT2_WRIST_TILT BIT(0)
#define LSM6DSL_SHIFT_DRDY_PULSE_CFG_G_INT2_WRIST_TILT 0
#define LSM6DSL_REG_INT1_CTRL 0x0D
#define LSM6DSL_MASK_INT1_CTRL_STEP_DETECTOR BIT(7)
#define LSM6DSL_SHIFT_INT1_CTRL_STEP_DETECTOR 7
#define LSM6DSL_MASK_INT1_CTRL_SIGN_MOT BIT(6)
#define LSM6DSL_SHIFT_INT1_CTRL_SIGN_MOT 6
#define LSM6DSL_MASK_INT1_CTRL_FULL_FLAG BIT(5)
#define LSM6DSL_SHIFT_INT1_CTRL_FULL_FLAG 5
#define LSM6DSL_MASK_INT1_CTRL_FIFO_OVR BIT(4)
#define LSM6DSL_SHIFT_INT1_CTRL_FIFO_OVR 4
#define LSM6DSL_MASK_INT1_FTH BIT(3)
#define LSM6DSL_SHIFT_INT1_FTH 3
#define LSM6DSL_MASK_INT1_CTRL_BOOT BIT(2)
#define LSM6DSL_SHIFT_INT1_CTRL_BOOT 2
#define LSM6DSL_MASK_INT1_CTRL_DRDY_G BIT(1)
#define LSM6DSL_SHIFT_INT1_CTRL_DRDY_G 1
#define LSM6DSL_MASK_INT1_CTRL_DRDY_XL BIT(0)
#define LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL 0
#define LSM6DSL_REG_INT2_CTRL 0x0E
#define LSM6DSL_MASK_INT2_CTRL_STEP_DELTA BIT(7)
#define LSM6DSL_SHIFT_INT2_CTRL_STEP_DELTA 7
#define LSM6DSL_MASK_INT2_CTRL_STEP_COUNT_OV BIT(6)
#define LSM6DSL_SHIFT_INT2_CTRL_STEP_COUNT_OV 6
#define LSM6DSL_MASK_INT2_CTRL_FULL_FLAG BIT(5)
#define LSM6DSL_SHIFT_INT2_CTRL_FULL_FLAG 5
#define LSM6DSL_MASK_INT2_CTRL_FIFO_OVR BIT(4)
#define LSM6DSL_SHIFT_INT2_CTRL_FIFO_OVR 4
#define LSM6DSL_MASK_INT2_FTH BIT(3)
#define LSM6DSL_SHIFT_INT2_FTH 3
#define LSM6DSL_MASK_INT2_DRDY_TEMP BIT(2)
#define LSM6DSL_SHIFT_INT2_DRDY_TEMP 2
#define LSM6DSL_MASK_INT2_CTRL_DRDY_G BIT(1)
#define LSM6DSL_SHIFT_INT2_CTRL_DRDY_G 1
#define LSM6DSL_MASK_INT2_CTRL_DRDY_XL BIT(0)
#define LSM6DSL_SHIFT_INT2_CTRL_DRDY_XL 0
#define LSM6DSL_REG_WHO_AM_I 0x0F
#define LSM6DSL_VAL_WHO_AM_I 0x6A
#define LSM6DSL_REG_CTRL1_XL 0x10
#define LSM6DSL_MASK_CTRL1_XL_ODR_XL (BIT(7) | BIT(6) | \
BIT(5) | BIT(4))
#define LSM6DSL_SHIFT_CTRL1_XL_ODR_XL 4
#define LSM6DSL_MASK_CTRL1_XL_FS_XL (BIT(3) | BIT(2))
#define LSM6DSL_SHIFT_CTRL1_XL_FS_XL 2
#define LSM6DSL_MASK_CTRL1_XL_LPF1_BW_SEL BIT(1)
#define LSM6DSL_SHIFT_CTRL1_XL_LPF1_BW_SEL 1
#define LSM6DSL_REG_CTRL2_G 0x11
#define LSM6DSL_MASK_CTRL2_G_ODR_G (BIT(7) | BIT(6) | \
BIT(5) | BIT(4))
#define LSM6DSL_SHIFT_CTRL2_G_ODR_G 4
#define LSM6DSL_MASK_CTRL2_G_FS_G (BIT(3) | BIT(2))
#define LSM6DSL_SHIFT_CTRL2_G_FS_G 2
#define LSM6DSL_MASK_CTRL2_FS125 BIT(1)
#define LSM6DSL_SHIFT_CTRL2_FS125 1
#define LSM6DSL_REG_CTRL3_C 0x12
#define LSM6DSL_MASK_CTRL3_C_BOOT BIT(7)
#define LSM6DSL_SHIFT_CTRL3_C_BOOT 7
#define LSM6DSL_MASK_CTRL3_C_BDU BIT(6)
#define LSM6DSL_SHIFT_CTRL3_C_BDU 6
#define LSM6DSL_MASK_CTRL3_C_H_LACTIVE BIT(5)
#define LSM6DSL_SHIFT_CTRL3_C_H_LACTIVE 5
#define LSM6DSL_MASK_CTRL3_C_PP_OD BIT(4)
#define LSM6DSL_SHIFT_CTRL3_C_PP_OD 4
#define LSM6DSL_MASK_CTRL3_C_SIM BIT(3)
#define LSM6DSL_SHIFT_CTRL3_C_SIM 3
#define LSM6DSL_MASK_CTRL3_C_IF_INC BIT(2)
#define LSM6DSL_SHIFT_CTRL3_C_IF_INC 2
#define LSM6DSL_MASK_CTRL3_C_BLE BIT(1)
#define LSM6DSL_SHIFT_CTRL3_C_BLE 1
#define LSM6DSL_MASK_CTRL3_C_SW_RESET BIT(0)
#define LSM6DSL_SHIFT_CTRL3_C_SW_RESET 0
#define LSM6DSL_REG_CTRL4_C 0x13
#define LSM6DSL_MASK_CTRL4_C_DEN_XL_EN BIT(7)
#define LSM6DSL_SHIFT_CTRL4_C_DEN_XL_EN 7
#define LSM6DSL_MASK_CTRL4_C_SLEEP BIT(6)
#define LSM6DSL_SHIFT_CTRL4_C_SLEEP 6
#define LSM6DSL_MASK_CTRL4_C_INT2_ON_INT1 BIT(5)
#define LSM6DSL_SHIFT_CTRL4_C_INT2_ON_INT1 5
#define LSM6DSL_MASK_CTRL4_C_DEN_DRDY_INT1 BIT(4)
#define LSM6DSL_SHIFT_CTRL4_C_DEN_DRDY_INT1 4
#define LSM6DSL_MASK_CTRL4_C_DRDY_MASK BIT(3)
#define LSM6DSL_SHIFT_CTRL4_C_DRDY_MASK 3
#define LSM6DSL_MASK_CTRL4_C_I2C_DISABLE BIT(2)
#define LSM6DSL_SHIFT_CTRL4_C_I2C_DISABLE 2
#define LSM6DSL_MASK_CTRL4_C_LPF1_SEL_G BIT(1)
#define LSM6DSL_SHIFT_CTRL4_C_LPF1_SEL_G 1
#define LSM6DSL_REG_CTRL5_C 0x14
#define LSM6DSL_MASK_CTRL5_C_ROUNDING (BIT(7) | BIT(6) | \
BIT(5))
#define LSM6DSL_SHIFT_CTRL5_C_ROUNDING 5
#define LSM6DSL_MASK_CTRL5_C_DEN_LH BIT(4)
#define LSM6DSL_SHIFT_CTRL5_C_DEN_LH 4
#define LSM6DSL_MASK_CTRL5_C_ST_G (BIT(3) | BIT(2))
#define LSM6DSL_SHIFT_CTRL5_C_ST_G 2
#define LSM6DSL_MASK_CTRL5_C_ST_XL (BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_CTRL5_C_ST_XL 0
#define LSM6DSL_REG_CTRL6_C 0x15
#define LSM6DSL_MASK_CTRL6_C_TRIG_EN BIT(7)
#define LSM6DSL_SHIFT_CTRL6_C_TRIG_EN 7
#define LSM6DSL_MASK_CTRL6_C_LVL_EN BIT(6)
#define LSM6DSL_SHIFT_CTRL6_C_LVL_EN 6
#define LSM6DSL_MASK_CTRL6_C_LVL2_EN BIT(5)
#define LSM6DSL_SHIFT_CTRL6_C_LVL2_EN 5
#define LSM6DSL_MASK_CTRL6_C_XL_HM_MODE BIT(4)
#define LSM6DSL_SHIFT_CTRL6_C_XL_HM_MODE 4
#define LSM6DSL_MASK_CTRL6_C_USR_OFF_W BIT(3)
#define LSM6DSL_SHIFT_CTRL6_C_USR_OFF_W 3
#define LSM6DSL_MASK_CTRL6_C_FTYPE (BIT(0) | BIT(1))
#define LSM6DSL_SHIFT_CTRL6_C_FTYPE 0
#define LSM6DSL_REG_CTRL7_G 0x16
#define LSM6DSL_MASK_CTRL7_G_HM_MODE BIT(7)
#define LSM6DSL_SHIFT_CTRL7_G_HM_MODE 7
#define LSM6DSL_MASK_CTRL7_HP_EN_G BIT(6)
#define LSM6DSL_SHIFT_CTRL7_HP_EN_G 6
#define LSM6DSL_MASK_CTRL7_HPM_G (BIT(5) | BIT(4))
#define LSM6DSL_SHIFT_CTRL7_HPM_G 4
#define LSM6DSL_MASK_CTRL7_ROUNDING_STATUS BIT(2)
#define LSM6DSL_SHIFT_CTRL7_ROUNDING_STATUS 2
#define LSM6DSL_REG_CTRL8_XL 0x17
#define LSM6DSL_MASK_CTRL8_LPF2_XL_EN BIT(7)
#define LSM6DSL_SHIFT_CTRL8_LPF2_XL_EN 7
#define LSM6DSL_MASK_CTRL8_HPCF_XL (BIT(6) | BIT(5))
#define LSM6DSL_SHIFT_CTRL8_HPCF_XL 5
#define LSM6DSL_MASK_CTRL8_HP_REF_MODE BIT(4)
#define LSM6DSL_SHIFT_CTRL8_HP_REF_MODE 4
#define LSM6DSL_MASK_CTRL8_INPUT_COMPOSITE BIT(3)
#define LSM6DSL_SHIFT_CTRL8_INPUT_COMPOSITE 3
#define LSM6DSL_MASK_CTRL8_HP_SLOPE_XL_EN BIT(2)
#define LSM6DSL_SHIFT_CTRL8_HP_SLOPE_XL_EN 2
#define LSM6DSL_MASK_CTRL8_LOW_PASS_ON_6D BIT(0)
#define LSM6DSL_SHIFT_CTRL8_LOW_PASS_ON_6D 0
#define LSM6DSL_REG_CTRL9_XL 0x18
#define LSM6DSL_MASK_CTRL9_XL_DEN_X BIT(7)
#define LSM6DSL_SHIFT_CTRL9_XL_DEN_X 7
#define LSM6DSL_MASK_CTRL9_XL_DEN_Y BIT(6)
#define LSM6DSL_SHIFT_CTRL9_XL_DEN_Y 6
#define LSM6DSL_MASK_CTRL9_XL_DEN_Z BIT(5)
#define LSM6DSL_SHIFT_CTRL9_XL_DEN_Z 5
#define LSM6DSL_MASK_CTRL9_XL_DEN_G BIT(4)
#define LSM6DSL_SHIFT_CTRL9_XL_DEN_G 4
#define LSM6DSL_MASK_CTRL9_XL_SOFT_EN BIT(2)
#define LSM6DSL_SHIFT_CTRL9_XL_SOFT_EN 2
#define LSM6DSL_REG_CTRL10_C 0x19
#define LSM6DSL_MASK_CTRL10_C_WRIST_TILT_EN BIT(7)
#define LSM6DSL_SHIFT_CTRL10_C_WRIST_TILT_EN 7
#define LSM6DSL_MASK_CTRL10_C_TIMER_EN BIT(5)
#define LSM6DSL_SHIFT_CTRL10_C_TIMER_EN 5
#define LSM6DSL_MASK_CTRL10_C_PEDO_EN BIT(4)
#define LSM6DSL_SHIFT_CTRL10_C_PEDO_EN 4
#define LSM6DSL_MASK_CTRL10_C_TILT_EN BIT(3)
#define LSM6DSL_SHIFT_CTRL10_C_TILT_EN 3
#define LSM6DSL_MASK_CTRL10_C_FUNC_EN BIT(2)
#define LSM6DSL_SHIFT_CTRL10_C_FUNC_EN 2
#define LSM6DSL_MASK_CTRL10_C_PEDO_RST_STEP BIT(1)
#define LSM6DSL_SHIFT_CTRL10_C_PEDO_RST_STEP 1
#define LSM6DSL_MASK_CTRL10_C_SIGN_MOTION_EN BIT(0)
#define LSM6DSL_SHIFT_CTRL10_C_SIGN_MOTION_EN 0
#define LSM6DSL_REG_MASTER_CONFIG 0x1A
#define LSM6DSL_MASK_MASTER_CONFIG_DRDY_ON_INT1 BIT(7)
#define LSM6DSL_SHIFT_MASTER_CONFIG_DRDY_ON_INT1 7
#define LSM6DSL_MASK_MASTER_CONFIG_DATA_VALID_SEL_FIFO BIT(6)
#define LSM6DSL_SHIFT_MASTER_CONFIG_DATA_VALID_SEL_FIFO 6
#define LSM6DSL_MASK_MASTER_CONFIG_START_CONFIG BIT(4)
#define LSM6DSL_SHIFT_MASTER_CONFIG_START_CONFIG 4
#define LSM6DSL_MASK_MASTER_CONFIG_PULL_UP_EN BIT(3)
#define LSM6DSL_SHIFT_MASTER_CONFIG_PULL_UP_EN 3
#define LSM6DSL_MASK_MASTER_CONFIG_PASS_THROUGH_MODE BIT(2)
#define LSM6DSL_SHIFT_MASTER_CONFIG_PASS_THROUGH_MODE 2
#define LSM6DSL_MASK_MASTER_CONFIG_IRON_EN BIT(1)
#define LSM6DSL_SHIFT_MASTER_CONFIG_IRON_EN 1
#define LSM6DSL_MASK_MASTER_CONFIG_MASTER_ON BIT(0)
#define LSM6DSL_SHIFT_MASTER_CONFIG_MASTER_ON 0
#define LSM6DSL_REG_WAKE_UP_SRC 0x1B
#define LSM6DSL_MASK_WAKE_UP_SRC_FF_IA BIT(5)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_FF_IA 5
#define LSM6DSL_MASK_WAKE_UP_SRC_SLEEP_STATE_IA BIT(4)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_SLEEP_STATE_IA 4
#define LSM6DSL_MASK_WAKE_UP_SRC_WU_IA BIT(3)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_WU_IA 3
#define LSM6DSL_MASK_WAKE_UP_SRC_X_WU BIT(2)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_X_WU 2
#define LSM6DSL_MASK_WAKE_UP_SRC_Y_WU BIT(1)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_Y_WU 1
#define LSM6DSL_MASK_WAKE_UP_SRC_Z_WU BIT(0)
#define LSM6DSL_SHIFT_WAKE_UP_SRC_Z_WU 0
#define LSM6DSL_REG_TAP_SRC 0x1C
#define LSM6DSL_MASK_TAP_SRC_TAP_IA BIT(6)
#define LSM6DSL_SHIFT_TAP_SRC_TAP_IA 6
#define LSM6DSL_MASK_TAP_SRC_SINGLE_TAP BIT(5)
#define LSM6DSL_SHIFT_TAP_SRC_SINGLE_TAP 5
#define LSM6DSL_MASK_TAP_SRC_DOUBLE_TAP BIT(4)
#define LSM6DSL_SHIFT_TAP_SRC_DOUBLE_TAP 4
#define LSM6DSL_MASK_TAP_SRC_TAP_SIGN BIT(3)
#define LSM6DSL_SHIFT_TAP_SRC_TAP_SIGN 3
#define LSM6DSL_MASK_TAP_SRC_X_TAP BIT(2)
#define LSM6DSL_SHIFT_TAP_SRC_X_TAP 2
#define LSM6DSL_MASK_TAP_SRC_Y_TAP BIT(1)
#define LSM6DSL_SHIFT_TAP_SRC_Y_TAP 1
#define LSM6DSL_MASK_TAP_SRC_Z_TAP BIT(0)
#define LSM6DSL_SHIFT_TAP_SRC_Z_TAP 0
#define LSM6DSL_REG_D6D_SRC 0x1D
#define LSM6DSL_MASK_D6D_SRC_DEN_DRDY BIT(7)
#define LSM6DSL_SHIFT_D6D_SRC_DEN_DRDY 7
#define LSM6DSL_MASK_D6D_SRC_D6D_IA BIT(6)
#define LSM6DSL_SHIFT_D6D_SRC_D6D_IA 6
#define LSM6DSL_MASK_D6D_SRC_ZH BIT(5)
#define LSM6DSL_SHIFT_D6D_SRC_ZH 5
#define LSM6DSL_MASK_D6D_SRC_ZL BIT(4)
#define LSM6DSL_SHIFT_D6D_SRC_ZL 4
#define LSM6DSL_MASK_D6D_SRC_YH BIT(3)
#define LSM6DSL_SHIFT_D6D_SRC_YH 3
#define LSM6DSL_MASK_D6D_SRC_YL BIT(2)
#define LSM6DSL_SHIFT_D6D_SRC_YL 2
#define LSM6DSL_MASK_D6D_SRC_XH BIT(1)
#define LSM6DSL_SHIFT_D6D_SRC_XH 1
#define LSM6DSL_MASK_D6D_SRC_XL BIT(0)
#define LSM6DSL_SHIFT_D6D_SRC_XL 0
#define LSM6DSL_REG_STATUS_REG 0x1E
#define LSM6DSL_MASK_STATUS_REG_TDA BIT(2)
#define LSM6DSL_SHIFT_STATUS_REG_TDA 2
#define LSM6DSL_MASK_STATUS_REG_GDA BIT(1)
#define LSM6DSL_SHIFT_STATUS_REG_GDA 1
#define LSM6DSL_MASK_STATUS_REG_XLDA BIT(0)
#define LSM6DSL_SHIFT_STATUS_REG_XLDA 0
#define LSM6DSL_REG_OUT_TEMP_L 0x20
#define LSM6DSL_REG_OUT_TEMP_H 0x21
#define LSM6DSL_REG_OUTX_L_G 0x22
#define LSM6DSL_REG_OUTX_H_G 0x23
#define LSM6DSL_REG_OUTY_L_G 0x24
#define LSM6DSL_REG_OUTY_H_G 0x25
#define LSM6DSL_REG_OUTZ_L_G 0x26
#define LSM6DSL_REG_OUTZ_H_G 0x27
#define LSM6DSL_REG_OUTX_L_XL 0x28
#define LSM6DSL_REG_OUTX_H_XL 0x29
#define LSM6DSL_REG_OUTY_L_XL 0x2A
#define LSM6DSL_REG_OUTY_H_XL 0x2B
#define LSM6DSL_REG_OUTZ_L_XL 0x2C
#define LSM6DSL_REG_OUTZ_H_XL 0x2D
#define LSM6DSL_REG_SENSORHUB1 0x2E
#define LSM6DSL_REG_SENSORHUB2 0x2F
#define LSM6DSL_REG_SENSORHUB3 0x30
#define LSM6DSL_REG_SENSORHUB4 0x31
#define LSM6DSL_REG_SENSORHUB5 0x32
#define LSM6DSL_REG_SENSORHUB6 0x33
#define LSM6DSL_REG_SENSORHUB7 0x34
#define LSM6DSL_REG_SENSORHUB8 0x35
#define LSM6DSL_REG_SENSORHUB9 0x36
#define LSM6DSL_REG_SENSORHUB10 0x37
#define LSM6DSL_REG_SENSORHUB11 0x38
#define LSM6DSL_REG_SENSORHUB12 0x39
#define LSM6DSL_REG_FIFO_STATUS1 0x3A
#define LSM6DSL_REG_FIFO_STATUS2 0x3B
#define LSM6DSL_MASK_FIFO_STATUS2_WATERM BIT(7)
#define LSM6DSL_SHIFT_FIFO_STATUS2_WATERM 7
#define LSM6DSL_MASK_FIFO_STATUS2_OVER_RUN BIT(6)
#define LSM6DSL_SHIFT_FIFO_STATUS2_OVER_RUN 6
#define LSM6DSL_MASK_FIFO_STATUS2_FIFO_FULL_SMART BIT(5)
#define LSM6DSL_SHIFT_FIFO_STATUS2_FIFO_FULL_SMART 5
#define LSM6DSL_MASK_FIFO_STATUS2_FIFO_EMPTY BIT(4)
#define LSM6DSL_SHIFT_FIFO_STATUS2_FIFO_EMPTY 4
#define LSM6DSL_MASK_FIFO_STATUS2_DIFF_FIFO (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FIFO_STATUS2_DIFF_FIFO 0
#define LSM6DSL_REG_FIFO_STATUS3 0x3C
#define LSM6DSL_MASK_FIFO_STATUS3_FIFO_PATTERN 0xFF
#define LSM6DSL_SHIFT_FIFO_STATUS3_FIFO_PATTERN 0
#define LSM6DSL_REG_FIFO_STATUS4 0x3D
#define LSM6DSL_MASK_FIFO_STATUS4_FIFO_PATTERN (BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_FIFO_STATUS4_FIFO_PATTERN 0
#define LSM6DSL_REG_FIFO_DATA_OUT_L 0x3E
#define LSM6DSL_REG_FIFO_DATA_OUT_H 0x3F
#define LSM6DSL_REG_TIMESTAMP0 0x40
#define LSM6DSL_REG_TIMESTAMP1 0x41
#define LSM6DSL_REG_TIMESTAMP2 0x42
#define LSM6DSL_REG_STEP_TIMESTAMP_L 0x49
#define LSM6DSL_REG_STEP_TIMESTAMP_H 0x4A
#define LSM6DSL_REG_STEP_COUNTER_L 0x4B
#define LSM6DSL_REG_STEP_COUNTER_H 0x4C
#define LSM6DSL_REG_SENSORHUB13 0x4D
#define LSM6DSL_REG_SENSORHUB14 0x4E
#define LSM6DSL_REG_SENSORHUB15 0x4F
#define LSM6DSL_REG_SENSORHUB16 0x50
#define LSM6DSL_REG_SENSORHUB17 0x51
#define LSM6DSL_REG_SENSORHUB18 0x52
#define LSM6DSL_REG_FUNC_SRC1 0x53
#define LSM6DSL_MASK_FUNC_SRC1_STEP_COUNT_DELTA_IA BIT(7)
#define LSM6DSL_SHIFT_FUNC_SRC1_STEP_COUNT_DELTA_IA 7
#define LSM6DSL_MASK_FUNC_SRC1_SIGN_MOTION_IA BIT(6)
#define LSM6DSL_SHIFT_FUNC_SRC1_SIGN_MOTION_IA 6
#define LSM6DSL_MASK_FUNC_SRC1_TILT_IA BIT(5)
#define LSM6DSL_SHIFT_FUNC_SRC1_TILT_IA 5
#define LSM6DSL_MASK_FUNC_SRC1_STEP_DETECTED BIT(4)
#define LSM6DSL_SHIFT_FUNC_SRC1_STEP_DETECTED 4
#define LSM6DSL_MASK_FUNC_SRC1_STEP_OVERFLOW BIT(3)
#define LSM6DSL_SHIFT_FUNC_SRC1_STEP_OVERFLOW 3
#define LSM6DSL_MASK_FUNC_SRC1_HI_FAIL BIT(2)
#define LSM6DSL_SHIFT_FUNC_SRC1_HI_FAIL 2
#define LSM6DSL_MASK_FUNC_SRC1_SI_SEND_OP BIT(1)
#define LSM6DSL_SHIFT_FUNC_SRC1_SI_SEND_OP 1
#define LSM6DSL_MASK_FUNC_SRC1_SENSORHUB_END_OP BIT(0)
#define LSM6DSL_SHIFT_FUNC_SRC1_SENSORHUB_END_OP 0
#define LSM6DSL_REG_FUNC_SRC2 0x54
#define LSM6DSL_MASK_FUNC_SRC2_SLAVE3_NACK BIT(6)
#define LSM6DSL_SHIFT_FUNC_SRC2_SLAVE3_NACK 6
#define LSM6DSL_MASK_FUNC_SRC2_SLAVE2_NACK BIT(5)
#define LSM6DSL_SHIFT_FUNC_SRC2_SLAVE2_NACK 5
#define LSM6DSL_MASK_FUNC_SRC2_SLAVE1_NACK BIT(4)
#define LSM6DSL_SHIFT_FUNC_SRC2_SLAVE1_NACK 4
#define LSM6DSL_MASK_FUNC_SRC2_SLAVE0_NACK BIT(3)
#define LSM6DSL_SHIFT_FUNC_SRC2_SLAVE0_NACK 3
#define LSM6DSL_MASK_FUNC_SRC2_WRIST_TILT_IA BIT(0)
#define LSM6DSL_SHIFT_FUNC_SRC2_WRIST_TILT_IA 0
#define LSM6DSL_REG_WRIST_TILT_IA 0x55
#define LSM6DSL_MASK_WRIST_TILT_IA_XPOS BIT(7)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_XPOS 7
#define LSM6DSL_MASK_WRIST_TILT_IA_XNEG BIT(6)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_XNEG 6
#define LSM6DSL_MASK_WRIST_TILT_IA_YPOS BIT(5)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_YPOS 5
#define LSM6DSL_MASK_WRIST_TILT_IA_YNEG BIT(4)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_YNEG 4
#define LSM6DSL_MASK_WRIST_TILT_IA_ZPOS BIT(3)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_ZPOS 3
#define LSM6DSL_MASK_WRIST_TILT_IA_ZNEG BIT(2)
#define LSM6DSL_SHIFT_WRIST_TILT_IA_ZNEG 2
#define LSM6DSL_REG_TAP_CFG 0x58
#define LSM6DSL_MASK_TAP_CFG_INTERRPUTS_ENABLE BIT(7)
#define LSM6DSL_SHIFT_TAP_CFG_INTERRPUTS_ENABLE 7
#define LSM6DSL_MASK_TAP_CFG_INACT_EN (BIT(6) | BIT(5))
#define LSM6DSL_SHIFT_TAP_CFG_INACT_EN 5
#define LSM6DSL_MASK_TAP_CFG_SLOPE_FDS BIT(4)
#define LSM6DSL_SHIFT_TAP_CFG_SLOPE_FDS 4
#define LSM6DSL_MASK_TAP_CFG_X_EN BIT(3)
#define LSM6DSL_SHIFT_TAP_CFG_X_EN 3
#define LSM6DSL_MASK_TAP_CFG_Y_EN BIT(2)
#define LSM6DSL_SHIFT_TAP_CFG_Y_EN 2
#define LSM6DSL_MASK_TAP_CFG_Z_EN BIT(1)
#define LSM6DSL_SHIFT_TAP_CFG_Z_EN 1
#define LSM6DSL_MASK_TAP_CFG_LIR BIT(0)
#define LSM6DSL_SHIFT_TAP_CFG_LIR 0
#define LSM6DSL_REG_TAP_THS_6D 0x59
#define LSM6DSL_MASK_TAP_THS_6D_D4D_EN BIT(7)
#define LSM6DSL_SHIFT_TAP_THS_6D_D4D_EN 7
#define LSM6DSL_MASK_TAP_THS_6D_SIXD_THS (BIT(6) | BIT(5))
#define LSM6DSL_SHIFT_TAP_THS_6D_SIXD_THS 5
#define LSM6DSL_MASK_TAP_THS_6D_TAP_THS (BIT(4) | BIT(3) | \
BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_TAP_THS_6D_TAP_THS 0
#define LSM6DSL_REG_INT_DUR2 0x5A
#define LSM6DSL_MASK_INT_DUR2_DUR (BIT(7) | BIT(6) | \
BIT(5) | BIT(4))
#define LSM6DSL_SHIFT_INT_DUR2_DUR 4
#define LSM6DSL_MASK_INT_DUR2_QUIET (BIT(3) | BIT(2))
#define LSM6DSL_SHIFT_INT_QUIET 2
#define LSM6DSL_MASK_INT_DUR2_SHOCK (BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_INT_SHOCK 0
#define LSM6DSL_REG_WAKE_UP_THS 0x5B
#define LSM6DSL_MASK_WAKE_UP_THS_SINGLE_DOUBLE_TAP BIT(7)
#define LSM6DSL_SHIFT_WAKE_UP_THS_SINGLE_DOUBLE_TAP 7
#define LSM6DSL_MASK_WAKE_UP_THS_WK_THS (BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_WAKE_UP_THS_WK_THS 0
#define LSM6DSL_REG_WAKE_UP_DUR 0x5C
#define LSM6DSL_MASK_WAKE_UP_DUR_FF_DUR5 BIT(7)
#define LSM6DSL_SHIFT_WAKE_UP_DUR_FF_DUR5 7
#define LSM6DSL_MASK_WAKE_UP_DUR_WAKE_DUR (BIT(6) | BIT(5))
#define LSM6DSL_SHIFT_WAKE_UP_DUAR_WAKE_DUR 5
#define LSM6DSL_MASK_WAKE_UP_DUR_TIMER_HR BIT(4)
#define LSM6DSL_SHIFT_WAKE_UP_DUR_TIMER_HR 4
#define LSM6DSL_MASK_WAKE_UP_DUR_SLEEP_DUR (BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM6DSL_SHIFT_WAKE_UP_DUR_SLEEP_DUR 0
#define LSM6DSL_REG_FREE_FALL 0x5D
#define LSM6DSL_MASK_FREE_FALL_DUR (BIT(7) | BIT(6) | \
BIT(5) | BIT(4) | \
BIT(3))
#define LSM6DSL_SHIFT_FREE_FALL_DUR 4
#define LSM6DSL_MASK_FREE_FALL_THS (BIT(2) | BIT(1) | \
BIT(0))
#define LSM6DSL_SHIFT_FREE_FALL_THS 0
#define LSM6DSL_REG_MD1_CFG 0x5E
#define LSM6DSL_MASK_MD1_CFG_INT1_INACT_STATE BIT(7)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_INACT_STATE 7
#define LSM6DSL_MASK_MD1_CFG_INT1_SINGLE_TAP BIT(6)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_SINGLE_TAP 6
#define LSM6DSL_MASK_MD1_CFG_INT1_WU BIT(5)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_WU 5
#define LSM6DSL_MASK_MD1_CFG_INT1_FF BIT(4)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_FF 4
#define LSM6DSL_MASK_MD1_CFG_INT1_DOUBLE_TAP BIT(3)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_DOUBLE_TAP 3
#define LSM6DSL_MASK_MD1_CFG_INT1_6D BIT(2)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_6D 2
#define LSM6DSL_MASK_MD1_CFG_INT1_TILT BIT(1)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_TILT 1
#define LSM6DSL_MASK_MD1_CFG_INT1_TIMER BIT(0)
#define LSM6DSL_SHIFT_MD1_CFG_INT1_TIMER 0
#define LSM6DSL_REG_MD2_CFG 0x5F
#define LSM6DSL_MASK_MD2_CFG_INT2_INACT_STATE BIT(7)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_INACT_STATE 7
#define LSM6DSL_MASK_MD2_CFG_INT2_SINGLE_TAP BIT(6)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_SINGLE_TAP 6
#define LSM6DSL_MASK_MD2_CFG_INT2_WU BIT(5)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_WU 5
#define LSM6DSL_MASK_MD2_CFG_INT2_FF BIT(4)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_FF 4
#define LSM6DSL_MASK_MD2_CFG_INT2_DOUBLE_TAP BIT(3)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_DOUBLE_TAP 3
#define LSM6DSL_MASK_MD2_CFG_INT2_6D BIT(2)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_6D 2
#define LSM6DSL_MASK_MD2_CFG_INT2_TILT BIT(1)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_TILT 1
#define LSM6DSL_MASK_MD2_CFG_INT2_IRON BIT(0)
#define LSM6DSL_SHIFT_MD2_CFG_INT2_IRON 0
#define LSM6DSL_REG_MASTER_CMD_CODE 0x60
#define LSM6DSL_REG_SENS_SYNC_SPI_ERROR_CODE 0x61
#define LSM6DSL_REG_OUT_MAG_RAW_X_L 0x66
#define LSM6DSL_REG_OUT_MAG_RAW_X_H 0x67
#define LSM6DSL_REG_OUT_MAG_RAW_Y_L 0x68
#define LSM6DSL_REG_OUT_MAG_RAW_Y_H 0x69
#define LSM6DSL_REG_OUT_MAG_RAW_Z_L 0x6A
#define LSM6DSL_REG_OUT_MAG_RAW_Z_H 0x6B
#define LSM6DSL_REG_X_OFS_USR 0x73
#define LSM6DSL_REG_Y_OFS_USR 0x74
#define LSM6DSL_REG_Z_OFS_USR 0x75
/* Accel sensor sensitivity grain is 61 ug/LSB */
#define SENSI_GRAIN_XL 61LL
/* Gyro sensor sensitivity grain is 4375 udps/LSB */
#define SENSI_GRAIN_G 4375LL
#if CONFIG_LSM6DSL_ACCEL_FS == 0
#define LSM6DSL_ACCEL_FS_RUNTIME 1
#define LSM6DSL_DEFAULT_ACCEL_FULLSCALE 0
#define LSM6DSL_DEFAULT_ACCEL_SENSITIVITY SENSI_GRAIN_XL
#elif CONFIG_LSM6DSL_ACCEL_FS == 2
#define LSM6DSL_DEFAULT_ACCEL_FULLSCALE 0
#define LSM6DSL_DEFAULT_ACCEL_SENSITIVITY SENSI_GRAIN_XL
#elif CONFIG_LSM6DSL_ACCEL_FS == 4
#define LSM6DSL_DEFAULT_ACCEL_FULLSCALE 2
#define LSM6DSL_DEFAULT_ACCEL_SENSITIVITY (2.0 * SENSI_GRAIN_XL)
#elif CONFIG_LSM6DSL_ACCEL_FS == 8
#define LSM6DSL_DEFAULT_ACCEL_FULLSCALE 3
#define LSM6DSL_DEFAULT_ACCEL_SENSITIVITY (4.0 * SENSI_GRAIN_XL)
#elif CONFIG_LSM6DSL_ACCEL_FS == 16
#define LSM6DSL_DEFAULT_ACCEL_FULLSCALE 1
#define LSM6DSL_DEFAULT_ACCEL_SENSITIVITY (8.0 * SENSI_GRAIN_XL)
#endif
#if (CONFIG_LSM6DSL_ACCEL_ODR == 0)
#define LSM6DSL_ACCEL_ODR_RUNTIME 1
#endif
#define GYRO_FULLSCALE_125 4
#if CONFIG_LSM6DSL_GYRO_FS == 0
#define LSM6DSL_GYRO_FS_RUNTIME 1
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 4
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY SENSI_GRAIN_G
#elif CONFIG_LSM6DSL_GYRO_FS == 125
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 4
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY SENSI_GRAIN_G
#elif CONFIG_LSM6DSL_GYRO_FS == 250
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 0
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY (2.0 * SENSI_GRAIN_G)
#elif CONFIG_LSM6DSL_GYRO_FS == 500
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 1
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY (4.0 * SENSI_GRAIN_G)
#elif CONFIG_LSM6DSL_GYRO_FS == 1000
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 2
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY (8.0 * SENSI_GRAIN_G)
#elif CONFIG_LSM6DSL_GYRO_FS == 2000
#define LSM6DSL_DEFAULT_GYRO_FULLSCALE 3
#define LSM6DSL_DEFAULT_GYRO_SENSITIVITY (16.0 * SENSI_GRAIN_G)
#endif
#if (CONFIG_LSM6DSL_GYRO_ODR == 0)
#define LSM6DSL_GYRO_ODR_RUNTIME 1
#endif
union lsm6dsl_bus_cfg {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
};
struct lsm6dsl_config {
int (*bus_init)(const struct device *dev);
const union lsm6dsl_bus_cfg bus_cfg;
#ifdef CONFIG_LSM6DSL_TRIGGER
struct gpio_dt_spec int_gpio;
#endif
};
struct lsm6dsl_data;
struct lsm6dsl_transfer_function {
int (*read_data)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len);
int (*write_data)(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint8_t len);
int (*read_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t *value);
int (*update_reg)(const struct device *dev, uint8_t reg_addr,
uint8_t mask, uint8_t value);
};
struct lsm6dsl_data {
int accel_sample_x;
int accel_sample_y;
int accel_sample_z;
float accel_sensitivity;
int gyro_sample_x;
int gyro_sample_y;
int gyro_sample_z;
float gyro_sensitivity;
#if defined(CONFIG_LSM6DSL_ENABLE_TEMP)
int temp_sample;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LIS2MDL) || defined(CONFIG_LSM6DSL_EXT0_LIS3MDL)
int magn_sample_x;
int magn_sample_y;
int magn_sample_z;
float magn_sensitivity;
#endif
#if defined(CONFIG_LSM6DSL_EXT0_LPS22HB)
int sample_press;
int sample_temp;
#endif
const struct lsm6dsl_transfer_function *hw_tf;
uint16_t accel_freq;
uint16_t gyro_freq;
#ifdef CONFIG_LSM6DSL_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSL_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LSM6DSL_TRIGGER */
};
int lsm6dsl_spi_init(const struct device *dev);
int lsm6dsl_i2c_init(const struct device *dev);
#if defined(CONFIG_LSM6DSL_SENSORHUB)
int lsm6dsl_shub_init_external_chip(const struct device *dev);
int lsm6dsl_shub_read_external_chip(const struct device *dev, uint8_t *buf,
uint8_t len);
#endif
#ifdef CONFIG_LSM6DSL_TRIGGER
int lsm6dsl_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lsm6dsl_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM6DSL_LSM6DSL_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 9,159 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device_runtime.h>
#include <stm32_ll_adc.h>
LOG_MODULE_REGISTER(stm32_vbat, CONFIG_SENSOR_LOG_LEVEL);
#if DT_HAS_COMPAT_STATUS_OKAY(st_stm32_vbat)
#define DT_DRV_COMPAT st_stm32_vbat
#else
#error "No compatible devicetree node found"
#endif
struct stm32_vbat_data {
const struct device *adc;
const struct adc_channel_cfg adc_cfg;
ADC_TypeDef *adc_base;
struct adc_sequence adc_seq;
struct k_mutex mutex;
int16_t sample_buffer;
int16_t raw; /* raw adc Sensor value */
};
struct stm32_vbat_config {
int ratio;
};
static int stm32_vbat_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct stm32_vbat_data *data = dev->data;
struct adc_sequence *sp = &data->adc_seq;
int rc;
uint32_t path;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
pm_device_runtime_get(data->adc);
rc = adc_channel_setup(data->adc, &data->adc_cfg);
if (rc) {
LOG_DBG("Setup AIN%u got %d", data->adc_cfg.channel_id, rc);
goto unlock;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
LL_ADC_PATH_INTERNAL_VBAT | path);
rc = adc_read(data->adc, sp);
if (rc == 0) {
data->raw = data->sample_buffer;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
path &= ~LL_ADC_PATH_INTERNAL_VBAT);
unlock:
pm_device_runtime_put(data->adc);
k_mutex_unlock(&data->mutex);
return rc;
}
static int stm32_vbat_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct stm32_vbat_data *data = dev->data;
const struct stm32_vbat_config *cfg = dev->config;
int32_t voltage;
if (chan != SENSOR_CHAN_VOLTAGE) {
return -ENOTSUP;
}
/* Sensor value in millivolts considering the vbat input through a resistor bridge */
voltage = data->raw * adc_ref_internal(data->adc) * cfg->ratio / 0x0FFF;
return sensor_value_from_milli(val, voltage);
}
static const struct sensor_driver_api stm32_vbat_driver_api = {
.sample_fetch = stm32_vbat_sample_fetch,
.channel_get = stm32_vbat_channel_get,
};
static int stm32_vbat_init(const struct device *dev)
{
struct stm32_vbat_data *data = dev->data;
struct adc_sequence *asp = &data->adc_seq;
k_mutex_init(&data->mutex);
if (data->adc == NULL) {
LOG_ERR("ADC is not enabled");
return -ENODEV;
}
if (!device_is_ready(data->adc)) {
LOG_ERR("Device %s is not ready", data->adc->name);
return -ENODEV;
}
*asp = (struct adc_sequence){
.channels = BIT(data->adc_cfg.channel_id),
.buffer = &data->sample_buffer,
.buffer_size = sizeof(data->sample_buffer),
.resolution = 12U,
};
return 0;
}
#define ASSERT_VBAT_ADC_ENABLED(inst) \
BUILD_ASSERT(DT_NODE_HAS_STATUS(DT_INST_IO_CHANNELS_CTLR(inst), okay), \
"ADC instance '" DT_NODE_FULL_NAME(DT_INST_IO_CHANNELS_CTLR(inst)) "' needed " \
"by Vbat sensor '" DT_NODE_FULL_NAME(DT_DRV_INST(inst)) "' is not enabled")
#define STM32_VBAT_DEFINE(inst) \
ASSERT_VBAT_ADC_ENABLED(inst); \
\
static struct stm32_vbat_data stm32_vbat_dev_data_##inst = { \
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(inst)), \
.adc_base = (ADC_TypeDef *)DT_REG_ADDR(DT_INST_IO_CHANNELS_CTLR(inst)), \
.adc_cfg = { \
.gain = ADC_GAIN_1, \
.reference = ADC_REF_INTERNAL, \
.acquisition_time = ADC_ACQ_TIME_MAX, \
.channel_id = DT_INST_IO_CHANNELS_INPUT(inst), \
.differential = 0, \
}, \
}; \
\
static const struct stm32_vbat_config stm32_vbat_dev_config_##inst = { \
.ratio = DT_INST_PROP(inst, ratio), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, stm32_vbat_init, NULL, \
&stm32_vbat_dev_data_##inst, &stm32_vbat_dev_config_##inst, \
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, \
&stm32_vbat_driver_api);
DT_INST_FOREACH_STATUS_OKAY(STM32_VBAT_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/stm32_vbat/stm32_vbat.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,194 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "lsm6dsl.h"
LOG_MODULE_DECLARE(LSM6DSL, CONFIG_SENSOR_LOG_LEVEL);
#define LSM6DSL_EMBEDDED_SLV0_ADDR 0x02
#define LSM6DSL_EMBEDDED_SLV0_SUBADDR 0x03
#define LSM6DSL_EMBEDDED_SLV0_CONFIG 0x04
#define LSM6DSL_EMBEDDED_SLV1_ADDR 0x05
#define LSM6DSL_EMBEDDED_SLV1_SUBADDR 0x06
#define LSM6DSL_EMBEDDED_SLV1_CONFIG 0x07
#define LSM6DSL_EMBEDDED_SLV2_ADDR 0x08
#define LSM6DSL_EMBEDDED_SLV2_SUBADDR 0x09
#define LSM6DSL_EMBEDDED_SLV2_CONFIG 0x0A
#define LSM6DSL_EMBEDDED_SLV3_ADDR 0x0B
#define LSM6DSL_EMBEDDED_SLV3_SUBADDR 0x0C
#define LSM6DSL_EMBEDDED_SLV3_CONFIG 0x0D
#define LSM6DSL_EMBEDDED_SLV0_DATAWRITE 0x0E
#define LSM6DSL_EMBEDDED_SLVX_READ 0x1
#define LSM6DSL_EMBEDDED_SLVX_THREE_SENS 0x20
#define LSM6DSL_EMBEDDED_SLV0_WRITE_IDLE 0x07
static int lsm6dsl_shub_write_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len);
/*
* LIS2MDL magn device specific part
*/
#ifdef CONFIG_LSM6DSL_EXT0_LIS2MDL
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
static int lsm6dsl_lis2mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct lsm6dsl_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_sensitivity = LIS2MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS2MDL_SW_RESET;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
#endif /* CONFIG_LSM6DSL_EXT0_LIS2MDL */
/*
* LIS3MDL magn device specific part
*/
#ifdef CONFIG_LSM6DSL_EXT0_LIS3MDL
#define LIS3MDL_REG_CTRL1 0x20
#define LIS3MDL_REG_CTRL2 0x21
#define LIS3MDL_REG_CTRL3 0x22
#define LIS3MDL_REG_CTRL4 0x23
#define LIS3MDL_REG_CTRL5 0x24
#define LIS3MDL_REG_SAMPLE_START 0x28
#define LIS3MDL_REG_INT_CFG 0x30
#define LIS3MDL_INT_X_EN BIT(7)
#define LIS3MDL_INT_Y_EN BIT(6)
#define LIS3MDL_INT_Z_EN BIT(5)
#define LIS3MDL_INT_XYZ_EN \
(LIS3MDL_INT_X_EN | LIS3MDL_INT_Y_EN | LIS3MDL_INT_Z_EN)
#define LIS3MDL_STATUS_REG 0x27
/* REG_CTRL2 */
#define LIS3MDL_REBOOT_MASK BIT(3)
#define LIS3MDL_SOFT_RST_MASK BIT(2)
/* REG_CTRL1 */
#define LIS3MDL_OM_SHIFT 5
#define LIS3MDL_DO_SHIFT 2
#define LIS3MDL_FAST_ODR_SHIFT 1
#define LIS3MDL_ODR_BITS(om_bits, do_bits, fast_odr) \
(((om_bits) << LIS3MDL_OM_SHIFT) | \
((do_bits) << LIS3MDL_DO_SHIFT) | \
((fast_odr) << LIS3MDL_FAST_ODR_SHIFT))
static const uint8_t lis3mdl_odr_bits[] = {
LIS3MDL_ODR_BITS(0, 0, 0), /* 0.625 Hz */
LIS3MDL_ODR_BITS(0, 1, 0), /* 1.25 Hz */
LIS3MDL_ODR_BITS(0, 2, 0), /* 2.5 Hz */
LIS3MDL_ODR_BITS(0, 3, 0), /* 5 Hz */
LIS3MDL_ODR_BITS(0, 4, 0), /* 10 Hz */
LIS3MDL_ODR_BITS(0, 5, 0), /* 20 Hz */
LIS3MDL_ODR_BITS(0, 6, 0), /* 40 Hz */
LIS3MDL_ODR_BITS(0, 7, 0), /* 80 Hz */
LIS3MDL_ODR_BITS(3, 0, 1), /* 155 Hz */
LIS3MDL_ODR_BITS(2, 0, 1), /* 300 Hz */
LIS3MDL_ODR_BITS(1, 0, 1), /* 560 Hz */
LIS3MDL_ODR_BITS(0, 0, 1) /* 1000 Hz */
};
#define LIS3MDL_ODR lis3mdl_odr_bits[4]
/* REG_CTRL3 */
#define LIS3MDL_MD_CONTINUOUS 0x00
/* Others */
#define LIS3MDL_SENSITIVITY 6842
static int lsm6dsl_lis3mdl_init(const struct device *dev, uint8_t i2c_addr)
{
struct lsm6dsl_data *data = dev->data;
uint8_t mag_cfg[2];
data->magn_sensitivity = LIS3MDL_SENSITIVITY;
/* sw reset device */
mag_cfg[0] = LIS3MDL_REBOOT_MASK | LIS3MDL_SOFT_RST_MASK;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LIS3MDL_REG_CTRL2, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS3MDL_ODR;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LIS3MDL_REG_CTRL1, mag_cfg, 1);
mag_cfg[0] = LIS3MDL_MD_CONTINUOUS;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LIS3MDL_REG_CTRL3, mag_cfg, 1);
return 0;
}
#endif /* CONFIG_LSM6DSL_EXT0_LIS3MDL */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_LSM6DSL_EXT0_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
static int lsm6dsl_lps22hb_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t baro_cfg[2];
/* sw reset device */
baro_cfg[0] = LPS22HB_SW_RESET;
lsm6dsl_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;
lsm6dsl_shub_write_slave_reg(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_LSM6DSL_EXT0_LPS22HB */
/* List of supported external sensors */
static struct lsm6dsl_shub_sens_list {
uint8_t i2c_addr[2];
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
int (*dev_init)(const struct device *dev, uint8_t i2c_addr);
} lsm6dsl_shub_sens_list[] = {
#ifdef CONFIG_LSM6DSL_EXT0_LIS2MDL
{
/* LIS2MDL */
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (lsm6dsl_lis2mdl_init),
},
#endif /* CONFIG_LSM6DSL_EXT0_LIS2MDL */
#ifdef CONFIG_LSM6DSL_EXT0_LIS3MDL
{
/* LIS3MDL */
.i2c_addr = {0x1C, 0x1E},
.wai_addr = 0x0F,
.wai_val = 0x3D,
.out_data_addr = 0x28,
.out_data_len = 0x06,
.dev_init = (lsm6dsl_lis3mdl_init),
},
#endif /* CONFIG_LSM6DSL_EXT0_LIS3MDL */
#ifdef CONFIG_LSM6DSL_EXT0_LPS22HB
{
/* LPS22HB */
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (lsm6dsl_lps22hb_init),
},
#endif /* CONFIG_LSM6DSL_EXT0_LPS22HB */
};
static uint8_t ext_i2c_addr;
static inline void lsm6dsl_shub_wait_completed(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
uint16_t freq;
freq = (data->accel_freq == 0U) ? 26 : data->accel_freq;
k_msleep((2000U / freq) + 1);
}
static inline void lsm6dsl_shub_embedded_en(const struct device *dev, bool on)
{
struct lsm6dsl_data *data = dev->data;
uint8_t func_en = (on) ? 0x1 : 0x0;
data->hw_tf->update_reg(dev, LSM6DSL_REG_FUNC_CFG_ACCESS,
LSM6DSL_MASK_FUNC_CFG_EN,
func_en << LSM6DSL_SHIFT_FUNC_CFG_EN);
k_sleep(K_MSEC(1));
}
#ifdef LSM6DSL_DEBUG
static int lsm6dsl_read_embedded_reg(const struct device *dev,
uint8_t reg_addr, uint8_t *value, int len)
{
struct lsm6dsl_data *data = dev->data;
lsm6dsl_shub_embedded_en(dev, true);
if (data->hw_tf->read_data(dev, reg_addr, value, len) < 0) {
LOG_DBG("failed to read external reg: %02x", reg_addr);
lsm6dsl_shub_embedded_en(dev, false);
return -EIO;
}
lsm6dsl_shub_embedded_en(dev, false);
return 0;
}
#endif
static int lsm6dsl_shub_write_embedded_regs(const struct device *dev,
uint8_t reg_addr,
uint8_t *value, uint8_t len)
{
struct lsm6dsl_data *data = dev->data;
lsm6dsl_shub_embedded_en(dev, true);
if (data->hw_tf->write_data(dev, reg_addr, value, len) < 0) {
LOG_DBG("failed to write external reg: %02x", reg_addr);
lsm6dsl_shub_embedded_en(dev, false);
return -EIO;
}
lsm6dsl_shub_embedded_en(dev, false);
return 0;
}
static void lsm6dsl_shub_enable(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
/* Enable Digital Func */
data->hw_tf->update_reg(dev, LSM6DSL_REG_CTRL10_C,
LSM6DSL_MASK_CTRL10_C_FUNC_EN,
1 << LSM6DSL_SHIFT_CTRL10_C_FUNC_EN);
/* Enable Accel @26hz */
if (!data->accel_freq) {
data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL1_XL,
LSM6DSL_MASK_CTRL1_XL_ODR_XL,
2 << LSM6DSL_SHIFT_CTRL1_XL_ODR_XL);
}
/* Enable Sensor Hub */
data->hw_tf->update_reg(dev, LSM6DSL_REG_MASTER_CONFIG,
LSM6DSL_MASK_MASTER_CONFIG_MASTER_ON,
1 << LSM6DSL_SHIFT_MASTER_CONFIG_MASTER_ON);
}
static void lsm6dsl_shub_disable(const struct device *dev)
{
struct lsm6dsl_data *data = dev->data;
/* Disable Sensor Hub */
data->hw_tf->update_reg(dev, LSM6DSL_REG_MASTER_CONFIG,
LSM6DSL_MASK_MASTER_CONFIG_MASTER_ON,
0 << LSM6DSL_SHIFT_MASTER_CONFIG_MASTER_ON);
/* Disable Accel */
if (!data->accel_freq) {
data->hw_tf->update_reg(dev,
LSM6DSL_REG_CTRL1_XL,
LSM6DSL_MASK_CTRL1_XL_ODR_XL,
0 << LSM6DSL_SHIFT_CTRL1_XL_ODR_XL);
}
/* Disable Digital Func */
data->hw_tf->update_reg(dev, LSM6DSL_REG_CTRL10_C,
LSM6DSL_MASK_CTRL10_C_FUNC_EN,
0 << LSM6DSL_SHIFT_CTRL10_C_FUNC_EN);
}
/*
* use SLV0 for generic read to slave device
*/
static int lsm6dsl_shub_read_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len)
{
struct lsm6dsl_data *data = dev->data;
uint8_t slave[3];
slave[0] = (slv_addr << 1) | LSM6DSL_EMBEDDED_SLVX_READ;
slave[1] = slv_reg;
slave[2] = (len & 0x7);
if (lsm6dsl_shub_write_embedded_regs(dev, LSM6DSL_EMBEDDED_SLV0_ADDR,
slave, 3) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
/* turn SH on */
lsm6dsl_shub_enable(dev);
lsm6dsl_shub_wait_completed(dev);
data->hw_tf->read_data(dev, LSM6DSL_REG_SENSORHUB1, value, len);
lsm6dsl_shub_disable(dev);
return 0;
}
/*
* use SLV0 to configure slave device
*/
static int lsm6dsl_shub_write_slave_reg(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len)
{
uint8_t slv_cfg[3];
uint8_t cnt = 0U;
while (cnt < len) {
slv_cfg[0] = (slv_addr << 1) & ~LSM6DSL_EMBEDDED_SLVX_READ;
slv_cfg[1] = slv_reg + cnt;
if (lsm6dsl_shub_write_embedded_regs(dev,
LSM6DSL_EMBEDDED_SLV0_ADDR,
slv_cfg, 2) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
slv_cfg[0] = value[cnt];
if (lsm6dsl_shub_write_embedded_regs(dev,
LSM6DSL_EMBEDDED_SLV0_DATAWRITE,
slv_cfg, 1) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
/* turn SH on */
lsm6dsl_shub_enable(dev);
lsm6dsl_shub_wait_completed(dev);
lsm6dsl_shub_disable(dev);
cnt++;
}
/* Put master in IDLE mode */
slv_cfg[0] = LSM6DSL_EMBEDDED_SLV0_WRITE_IDLE;
slv_cfg[1] = lsm6dsl_shub_sens_list[0].wai_addr;
slv_cfg[2] = LSM6DSL_EMBEDDED_SLVX_THREE_SENS;
if (lsm6dsl_shub_write_embedded_regs(dev,
LSM6DSL_EMBEDDED_SLV0_ADDR,
slv_cfg, 3) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
return 0;
}
/*
* SLAVEs configurations:
*
* - SLAVE 0: used for configuring the slave device
* - SLAVE 1: used as data read channel to slave device
* - SLAVE 2: used for generic reads while data channel is enabled
*/
static int lsm6dsl_shub_set_data_channel(const struct device *dev)
{
uint8_t slv_cfg[3];
uint8_t slv_i2c_addr = lsm6dsl_shub_sens_list[0].i2c_addr[ext_i2c_addr];
/* SLV0 is used for generic write */
slv_cfg[0] = LSM6DSL_EMBEDDED_SLV0_WRITE_IDLE;
slv_cfg[1] = lsm6dsl_shub_sens_list[0].wai_addr;
slv_cfg[2] = LSM6DSL_EMBEDDED_SLVX_THREE_SENS;
if (lsm6dsl_shub_write_embedded_regs(dev,
LSM6DSL_EMBEDDED_SLV0_ADDR,
slv_cfg, 3) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
/* Set data channel for slave device */
slv_cfg[0] = (slv_i2c_addr << 1) | LSM6DSL_EMBEDDED_SLVX_READ;
slv_cfg[1] = lsm6dsl_shub_sens_list[0].out_data_addr;
slv_cfg[2] = lsm6dsl_shub_sens_list[0].out_data_len;
if (lsm6dsl_shub_write_embedded_regs(dev,
LSM6DSL_EMBEDDED_SLV1_ADDR,
slv_cfg, 3) < 0) {
LOG_DBG("error writing embedded reg");
return -EIO;
}
/* turn SH on */
lsm6dsl_shub_enable(dev);
lsm6dsl_shub_wait_completed(dev);
return 0;
}
int lsm6dsl_shub_read_external_chip(const struct device *dev, uint8_t *buf,
uint8_t len)
{
struct lsm6dsl_data *data = dev->data;
data->hw_tf->read_data(dev, LSM6DSL_REG_SENSORHUB1, buf, len);
return 0;
}
int lsm6dsl_shub_init_external_chip(const struct device *dev)
{
uint8_t i;
uint8_t chip_id = 0U;
uint8_t slv_i2c_addr;
uint8_t slv_wai_addr = lsm6dsl_shub_sens_list[0].wai_addr;
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(lsm6dsl_shub_sens_list[0].i2c_addr); i++) {
slv_i2c_addr = lsm6dsl_shub_sens_list[0].i2c_addr[i];
if (slv_i2c_addr == 0U) {
continue;
}
if (lsm6dsl_shub_read_slave_reg(dev, slv_i2c_addr,
slv_wai_addr,
&chip_id, 1) < 0) {
LOG_DBG("failed reading external chip id");
return -EIO;
}
if (chip_id == lsm6dsl_shub_sens_list[0].wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(lsm6dsl_shub_sens_list[0].i2c_addr)) {
LOG_DBG("invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_DBG("Ext Device Chip Id: %02x", chip_id);
ext_i2c_addr = i;
/* init external device */
lsm6dsl_shub_sens_list[0].dev_init(dev, slv_i2c_addr);
lsm6dsl_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/lsm6dsl/lsm6dsl_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,923 |
```unknown
# STM32 battery sensor configuration options
config STM32_VBAT
bool "STM32 Vbat Sensor"
default y
depends on DT_HAS_ST_STM32_VBAT_ENABLED
depends on DT_HAS_ST_STM32_ADC_ENABLED
depends on SOC_FAMILY_STM32 && !SOC_SERIES_STM32F1X
select ADC
help
Enable driver for STM32 Vbat sensor and then also ADC
``` | /content/code_sandbox/drivers/sensor/st/stm32_vbat/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 90 |
```unknown
# LSM9DS0 accelerometer, magnetometer and temperature configuration options
menuconfig LSM9DS0_MFD
bool "LSM9DS0 I2C accelerometer, magnetometer and temperature sensor chip"
default y
depends on DT_HAS_ST_LSM9DS0_MFD_ENABLED
select I2C
help
Enable driver for LSM9DS0 I2C-based MFD sensor.
if LSM9DS0_MFD
config LSM9DS0_MFD_ACCEL_ENABLE
bool "Accelerometer"
default y
help
Enable/disable accelerometer totally by stripping everything related
in driver.
config LSM9DS0_MFD_MAGN_ENABLE
bool "Magnetometer"
default y
help
Enable/disable magnetometer totally by stripping everything related in
driver.
config LSM9DS0_MFD_TEMP_ENABLE
bool "Temperature sensor"
help
Enable/disable temperature sensor totally by stripping everything
related in driver.
menu "Attributes"
choice
prompt "Accelerometer sampling rate"
default LSM9DS0_MFD_ACCEL_SAMPLING_RATE_25
depends on LSM9DS0_MFD_ACCEL_ENABLE
help
Specify the default sampling rate frequency for accelerometer.
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_0
bool "0 Hz (power down)"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_3_125
bool "3.125 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_6_25
bool "6.25 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_12_5
bool "12.5 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_25
bool "25 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_50
bool "50 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_100
bool "100 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_200
bool "200 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_400
bool "400 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_800
bool "800 Hz"
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_1600
bool "1600 Hz"
endchoice
config LSM9DS0_MFD_ACCEL_SAMPLING_RATE_RUNTIME
bool "Dynamic sampling rate for accelerometer"
depends on LSM9DS0_MFD_ACCEL_ENABLE
help
Enable alteration of accelerometer sampling rate attribute at
runtime.
choice
prompt "Accelerometer full-scale"
default LSM9DS0_MFD_ACCEL_FULL_SCALE_2
depends on LSM9DS0_MFD_ACCEL_ENABLE
help
Specify the default full-scale for accelerometer.
config LSM9DS0_MFD_ACCEL_FULL_SCALE_2
bool "2G"
config LSM9DS0_MFD_ACCEL_FULL_SCALE_4
bool "4G"
config LSM9DS0_MFD_ACCEL_FULL_SCALE_6
bool "6G"
config LSM9DS0_MFD_ACCEL_FULL_SCALE_8
bool "8G"
config LSM9DS0_MFD_ACCEL_FULL_SCALE_16
bool "16G"
endchoice
config LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME
bool "Dynamic full-scale for accelerometer"
depends on LSM9DS0_MFD_ACCEL_ENABLE
help
Enable alteration of accelerometer full-scale attribute at
runtime.
config LSM9DS0_MFD_ACCEL_ENABLE_X
bool "Accelerometer X axis"
depends on LSM9DS0_MFD_ACCEL_ENABLE
default y
config LSM9DS0_MFD_ACCEL_ENABLE_Y
bool "Accelerometer Y axis"
depends on LSM9DS0_MFD_ACCEL_ENABLE
default y
config LSM9DS0_MFD_ACCEL_ENABLE_Z
bool "Accelerometer Z axis"
depends on LSM9DS0_MFD_ACCEL_ENABLE
default y
choice
prompt "Magnetometer sampling rate"
default LSM9DS0_MFD_MAGN_SAMPLING_RATE_25
depends on LSM9DS0_MFD_MAGN_ENABLE
help
Specify the default sampling rate frequency for magnetometer.
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_3_125
bool "3.125 Hz"
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_6_25
bool "6.25 Hz"
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_12_5
bool "12.5 Hz"
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_25
bool "25 Hz"
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_50
bool "50 Hz"
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_100
bool "100 Hz"
endchoice
config LSM9DS0_MFD_MAGN_SAMPLING_RATE_RUNTIME
bool "Dynamic sampling rate for magnetometer"
depends on LSM9DS0_MFD_MAGN_ENABLE
help
Enable alteration of magnetometer sampling rate attribute at
runtime.
choice
prompt "Magnetometer full-scale"
default LSM9DS0_MFD_MAGN_FULL_SCALE_2
depends on LSM9DS0_MFD_MAGN_ENABLE
help
Specify the default full-scale for magnetometer.
config LSM9DS0_MFD_MAGN_FULL_SCALE_2
bool "2 Gauss"
config LSM9DS0_MFD_MAGN_FULL_SCALE_4
bool "4 Gauss"
config LSM9DS0_MFD_MAGN_FULL_SCALE_8
bool "8 Gauss"
config LSM9DS0_MFD_MAGN_FULL_SCALE_12
bool "12 Gauss"
endchoice
config LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME
bool "Dynamic full-scale for magnetometer"
depends on LSM9DS0_MFD_MAGN_ENABLE
help
Enable alteration of magnetometer full-scale attribute at
runtime.
endmenu
endif # LSM9DS0_MFD
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_mfd/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,271 |
```c
/* sensor_lsm9ds0_mfd.c - Driver for LSM9DS0 accelerometer, magnetometer
* and temperature (MFD) sensor driver
*/
/*
*
*/
#define DT_DRV_COMPAT st_lsm9ds0_mfd
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lsm9ds0_mfd.h"
LOG_MODULE_REGISTER(LSM9DS0_MFD, CONFIG_SENSOR_LOG_LEVEL);
static inline int lsm9ds0_mfd_reboot_memory(const struct device *dev)
{
const struct lsm9ds0_mfd_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG0_XM,
LSM9DS0_MFD_MASK_CTRL_REG0_XM_BOOT,
1 << LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_BOOT) < 0) {
return -EIO;
}
k_busy_wait(USEC_PER_MSEC * 50U);
return 0;
}
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
static inline int lsm9ds0_mfd_accel_set_odr_raw(const struct device *dev,
uint8_t odr)
{
const struct lsm9ds0_mfd_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG1_XM,
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AODR,
odr << LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AODR);
}
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_RUNTIME)
static const struct {
int freq_int;
int freq_micro;
} lsm9ds0_mfd_accel_odr_map[] = { {0, 0},
{3, 125000},
{6, 250000},
{12, 500000},
{25, 0},
{50, 0},
{100, 0},
{200, 0},
{400, 0},
{800, 0},
{1600, 0} };
static int lsm9ds0_mfd_accel_set_odr(const struct device *dev,
const struct sensor_value *val)
{
uint8_t i;
for (i = 0U; i < ARRAY_SIZE(lsm9ds0_mfd_accel_odr_map); ++i) {
if (val->val1 < lsm9ds0_mfd_accel_odr_map[i].freq_int ||
(val->val1 == lsm9ds0_mfd_accel_odr_map[i].freq_int &&
val->val2 <= lsm9ds0_mfd_accel_odr_map[i].freq_micro)) {
return lsm9ds0_mfd_accel_set_odr_raw(dev, i);
}
}
return -ENOTSUP;
}
#endif
static inline int lsm9ds0_mfd_accel_set_fs_raw(const struct device *dev,
uint8_t fs)
{
const struct lsm9ds0_mfd_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG2_XM,
LSM9DS0_MFD_MASK_CTRL_REG2_XM_AFS,
fs << LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_AFS) < 0) {
return -EIO;
}
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
data->accel_fs = fs;
#endif
return 0;
}
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
static const struct {
int fs;
} lsm9ds0_mfd_accel_fs_map[] = { {2},
{4},
{6},
{8},
{16} };
static int lsm9ds0_mfd_accel_set_fs(const struct device *dev, int val)
{
uint8_t i;
for (i = 0U; i < ARRAY_SIZE(lsm9ds0_mfd_accel_fs_map); ++i) {
if (val <= lsm9ds0_mfd_accel_fs_map[i].fs) {
return lsm9ds0_mfd_accel_set_fs_raw(dev, i);
}
}
return -ENOTSUP;
}
#endif
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
static inline int lsm9ds0_mfd_magn_set_odr_raw(const struct device *dev,
uint8_t odr)
{
const struct lsm9ds0_mfd_config *config = dev->config;
return i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG5_XM,
LSM9DS0_MFD_MASK_CTRL_REG5_XM_M_ODR,
odr << LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_M_ODR);
}
#if defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_RUNTIME)
static const struct {
int freq_int;
int freq_micro;
} lsm9ds0_mfd_magn_odr_map[] = { {0, 0},
{3, 125000},
{6, 250000},
{12, 500000},
{25, 0},
{50, 0},
{100, 0} };
static int lsm9ds0_mfd_magn_set_odr(const struct device *dev,
const struct sensor_value *val)
{
uint8_t i;
for (i = 0U; i < ARRAY_SIZE(lsm9ds0_mfd_accel_odr_map); ++i) {
if (val->val1 < lsm9ds0_mfd_accel_odr_map[i].freq_int ||
(val->val1 == lsm9ds0_mfd_accel_odr_map[i].freq_int &&
val->val2 <= lsm9ds0_mfd_accel_odr_map[i].freq_micro)) {
return lsm9ds0_mfd_magn_set_odr_raw(dev, i);
}
}
return -ENOTSUP;
}
#endif
static inline int lsm9ds0_mfd_magn_set_fs_raw(const struct device *dev,
uint8_t fs)
{
const struct lsm9ds0_mfd_config *config = dev->config;
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG6_XM,
LSM9DS0_MFD_MASK_CTRL_REG6_XM_MFS,
fs << LSM9DS0_MFD_SHIFT_CTRL_REG6_XM_MFS) < 0) {
return -EIO;
}
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
data->magn_fs = fs;
#endif
return 0;
}
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
static const struct {
int fs;
} lsm9ds0_mfd_magn_fs_map[] = { {2},
{4},
{8},
{12} };
static int lsm9ds0_mfd_magn_set_fs(const struct device *dev,
const struct sensor_value *val)
{
uint8_t i;
for (i = 0U; i < ARRAY_SIZE(lsm9ds0_mfd_magn_fs_map); ++i) {
if (val->val1 <= lsm9ds0_mfd_magn_fs_map[i].fs) {
return lsm9ds0_mfd_magn_set_fs_raw(dev, i);
}
}
return -ENOTSUP;
}
#endif
#endif
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
static inline int lsm9ds0_mfd_sample_fetch_accel(const struct device *dev)
{
struct lsm9ds0_mfd_data *data = dev->data;
const struct lsm9ds0_mfd_config *config = dev->config;
uint8_t out_l, out_h;
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_X)
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_X_L_A, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_X_H_A, &out_h) < 0) {
LOG_DBG("failed to read accel sample (X axis)");
return -EIO;
}
data->sample_accel_x = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Y)
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Y_L_A, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Y_H_A, &out_h) < 0) {
LOG_DBG("failed to read accel sample (Y axis)");
return -EIO;
}
data->sample_accel_y = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Z)
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Z_L_A, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Z_H_A, &out_h) < 0) {
LOG_DBG("failed to read accel sample (Z axis)");
return -EIO;
}
data->sample_accel_z = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
data->sample_accel_fs = data->accel_fs;
#endif
return 0;
}
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
static inline int lsm9ds0_mfd_sample_fetch_magn(const struct device *dev)
{
struct lsm9ds0_mfd_data *data = dev->data;
const struct lsm9ds0_mfd_config *config = dev->config;
uint8_t out_l, out_h;
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_X_L_M, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_X_H_M, &out_h) < 0) {
LOG_DBG("failed to read magn sample (X axis)");
return -EIO;
}
data->sample_magn_x = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Y_L_M, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Y_H_M, &out_h) < 0) {
LOG_DBG("failed to read magn sample (Y axis)");
return -EIO;
}
data->sample_magn_y = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Z_L_M, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_Z_H_M, &out_h) < 0) {
LOG_DBG("failed to read magn sample (Z axis)");
return -EIO;
}
data->sample_magn_z = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
data->sample_magn_fs = data->magn_fs;
#endif
return 0;
}
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
static inline int lsm9ds0_mfd_sample_fetch_temp(const struct device *dev)
{
struct lsm9ds0_mfd_data *data = dev->data;
const struct lsm9ds0_mfd_config *config = dev->config;
uint8_t out_l, out_h;
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_TEMP_L_XM, &out_l) < 0 ||
i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_OUT_TEMP_H_XM, &out_h) < 0) {
LOG_DBG("failed to read temperature sample\n");
return -EIO;
}
data->sample_temp = (int16_t)((uint16_t)(out_l) |
((uint16_t)(out_h) << 8));
return 0;
}
#endif
static inline int lsm9ds0_mfd_sample_fetch_all(const struct device *dev)
{
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
if (lsm9ds0_mfd_sample_fetch_accel(dev) < 0) {
return -EIO;
}
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
if (lsm9ds0_mfd_sample_fetch_magn(dev) < 0) {
return -EIO;
}
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
if (lsm9ds0_mfd_sample_fetch_temp(dev) < 0) {
return -EIO;
}
#endif
return 0;
}
static int lsm9ds0_mfd_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
case SENSOR_CHAN_ACCEL_XYZ:
return lsm9ds0_mfd_sample_fetch_accel(dev);
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
case SENSOR_CHAN_MAGN_XYZ:
return lsm9ds0_mfd_sample_fetch_magn(dev);
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
case SENSOR_CHAN_DIE_TEMP:
return lsm9ds0_mfd_sample_fetch_temp(dev);
#endif
case SENSOR_CHAN_ALL:
return lsm9ds0_mfd_sample_fetch_all(dev);
default:
return -EINVAL;
}
return 0;
}
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
static inline void lsm9ds0_mfd_convert_accel(struct sensor_value *val,
int raw_val,
float scale)
{
double dval;
dval = (double)(raw_val) * (double)scale;
val->val1 = (int32_t)dval;
val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}
static inline int lsm9ds0_mfd_get_accel_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm9ds0_mfd_data *data,
float scale)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
lsm9ds0_mfd_convert_accel(val, data->sample_accel_x, scale);
break;
case SENSOR_CHAN_ACCEL_Y:
lsm9ds0_mfd_convert_accel(val, data->sample_accel_y, scale);
break;
case SENSOR_CHAN_ACCEL_Z:
lsm9ds0_mfd_convert_accel(val, data->sample_accel_z, scale);
break;
case SENSOR_CHAN_ACCEL_XYZ:
lsm9ds0_mfd_convert_accel(val, data->sample_accel_x, scale);
lsm9ds0_mfd_convert_accel(val + 1, data->sample_accel_y, scale);
lsm9ds0_mfd_convert_accel(val + 2, data->sample_accel_z, scale);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline int lsm9ds0_mfd_get_accel(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm9ds0_mfd_data *data = dev->data;
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
switch (data->sample_accel_fs) {
case 0:
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
2.0 * 9.807 / 32767.0);
case 1:
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
4.0 * 9.807 / 32767.0);
case 2:
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
6.0 * 9.807 / 32767.0);
case 3:
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
8.0 * 9.807 / 32767.0);
case 4:
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
16.0 * 9.807 / 32767.0);
default:
return -ENOTSUP;
}
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_2)
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
2.0 * 9.807 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_4)
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
4.0 * 9.807 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_6)
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
6.0 * 9.807 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_8)
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
8.0 * 9.807 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_16)
return lsm9ds0_mfd_get_accel_channel(chan, val, data,
16.0 * 9.807 / 32767.0);
#endif
return 0;
}
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
static inline void lsm9ds0_mfd_convert_magn(struct sensor_value *val,
int raw_val,
float scale)
{
double dval;
dval = (double)(raw_val) * (double)scale;
val->val1 = (int32_t)dval;
val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}
static inline int lsm9ds0_mfd_get_magn_channel(enum sensor_channel chan,
struct sensor_value *val,
struct lsm9ds0_mfd_data *data,
float scale)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
lsm9ds0_mfd_convert_magn(val, data->sample_magn_x, scale);
break;
case SENSOR_CHAN_MAGN_Y:
lsm9ds0_mfd_convert_magn(val, data->sample_magn_y, scale);
break;
case SENSOR_CHAN_MAGN_Z:
lsm9ds0_mfd_convert_magn(val, data->sample_magn_z, scale);
break;
case SENSOR_CHAN_MAGN_XYZ:
lsm9ds0_mfd_convert_magn(val, data->sample_magn_x, scale);
lsm9ds0_mfd_convert_magn(val + 1, data->sample_magn_y, scale);
lsm9ds0_mfd_convert_magn(val + 2, data->sample_magn_z, scale);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline int lsm9ds0_mfd_get_magn(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct lsm9ds0_mfd_data *data = dev->data;
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
switch (data->sample_magn_fs) {
case 0:
return lsm9ds0_mfd_get_magn_channel(chan, val, data,
2.0 / 32767.0);
case 1:
return lsm9ds0_mfd_get_magn_channel(chan, val, data,
4.0 / 32767.0);
case 2:
return lsm9ds0_mfd_get_magn_channel(chan, val, data,
8.0 / 32767.0);
case 3:
return lsm9ds0_mfd_get_magn_channel(chan, val, data,
12.0 / 32767.0);
default:
return -ENOTSUP;
}
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_2)
return lsm9ds0_mfd_get_magn_channel(chan, val, data, 2.0 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_4)
return lsm9ds0_mfd_get_magn_channel(chan, val, data, 4.0 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_8)
return lsm9ds0_mfd_get_magn_channel(chan, val, data, 8.0 / 32767.0);
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_12)
return lsm9ds0_mfd_get_magn_channel(chan, val, data, 12.0 / 32767.0);
#endif
return 0;
}
#endif
static int lsm9ds0_mfd_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
struct lsm9ds0_mfd_data *data = dev->data;
#endif
switch (chan) {
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return lsm9ds0_mfd_get_accel(dev, chan, val);
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
return lsm9ds0_mfd_get_magn(dev, chan, val);
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
case SENSOR_CHAN_DIE_TEMP:
val->val1 = data->sample_temp;
val->val2 = 0;
return 0;
#endif
default:
return -ENOTSUP;
}
}
#if defined(LSM9DS0_MFD_ATTR_SET_ACCEL)
static inline int lsm9ds0_mfd_attr_set_accel(const struct device *dev,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_RUNTIME)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm9ds0_mfd_accel_set_odr(dev, val);
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
case SENSOR_ATTR_FULL_SCALE:
return lsm9ds0_mfd_accel_set_fs(dev, sensor_ms2_to_g(val));
#endif
default:
return -ENOTSUP;
}
return 0;
}
#endif
#if defined(LSM9DS0_MFD_ATTR_SET_MAGN)
static inline int lsm9ds0_mfd_attr_set_magn(const struct device *dev,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#if defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_RUNTIME)
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lsm9ds0_mfd_magn_set_odr(dev, val);
#endif
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
case SENSOR_ATTR_FULL_SCALE:
return lsm9ds0_mfd_magn_set_fs(dev, val);
#endif
default:
return -ENOTSUP;
}
return 0;
}
#endif
#if defined(LSM9DS0_MFD_ATTR_SET)
static int lsm9ds0_mfd_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
#if defined(LSM9DS0_MFD_ATTR_SET_ACCEL)
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return lsm9ds0_mfd_attr_set_accel(dev, attr, val);
#endif
#if defined(LSM9DS0_MFD_ATTR_SET_MAGN)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
return lsm9ds0_mfd_attr_set_magn(dev, attr, val);
#endif
default:
return -ENOTSUP;
}
return 0;
}
#endif
static const struct sensor_driver_api lsm9ds0_mfd_api_funcs = {
.sample_fetch = lsm9ds0_mfd_sample_fetch,
.channel_get = lsm9ds0_mfd_channel_get,
#if defined(LSM9DS0_MFD_ATTR_SET)
.attr_set = lsm9ds0_mfd_attr_set,
#endif
};
static int lsm9ds0_mfd_init_chip(const struct device *dev)
{
const struct lsm9ds0_mfd_config *config = dev->config;
uint8_t chip_id;
if (lsm9ds0_mfd_reboot_memory(dev) < 0) {
LOG_DBG("failed to reset device");
return -EIO;
}
if (i2c_reg_read_byte_dt(&config->i2c, LSM9DS0_MFD_REG_WHO_AM_I_XM, &chip_id) < 0) {
LOG_DBG("failed reading chip id");
return -EIO;
}
if (chip_id != LSM9DS0_MFD_VAL_WHO_AM_I_XM) {
LOG_DBG("invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_DBG("chip id 0x%x", chip_id);
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG1_XM,
LSM9DS0_MFD_MASK_CTRL_REG1_XM_BDU |
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AODR,
(1 << LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_BDU) |
(LSM9DS0_MFD_ACCEL_DEFAULT_AODR <<
LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AODR))) {
LOG_DBG("failed to set AODR and BDU");
return -EIO;
}
if (lsm9ds0_mfd_accel_set_fs_raw(dev, LSM9DS0_MFD_ACCEL_DEFAULT_FS)) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG1_XM,
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AXEN |
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AYEN |
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AZEN,
(LSM9DS0_MFD_ACCEL_ENABLE_X <<
LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AXEN) |
(LSM9DS0_MFD_ACCEL_ENABLE_Y <<
LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AYEN) |
(LSM9DS0_MFD_ACCEL_ENABLE_Z <<
LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AZEN)) < 0) {
LOG_DBG("failed to set accelerometer axis enable bits\n");
return -EIO;
}
#elif !defined(LSM9DS0_MFD_MAGN_DISABLED)
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG1_XM,
LSM9DS0_MFD_MASK_CTRL_REG1_XM_BDU,
1 << LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_BDU) < 0) {
LOG_DBG("failed to set BDU\n");
return -EIO;
}
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG7_XM,
LSM9DS0_MFD_MASK_CTRL_REG7_XM_MD,
(0 << LSM9DS0_MFD_SHIFT_CTRL_REG7_XM_MD)) < 0) {
LOG_DBG("failed to power on magnetometer");
return -EIO;
}
if (lsm9ds0_mfd_magn_set_odr_raw(dev, LSM9DS0_MFD_MAGN_DEFAULT_M_ODR)) {
LOG_DBG("failed to set magnetometer sampling rate");
return -EIO;
}
if (lsm9ds0_mfd_magn_set_fs_raw(dev, LSM9DS0_MFD_MAGN_DEFAULT_FS)) {
LOG_DBG("failed to set magnetometer full-scale");
return -EIO;
}
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
if (i2c_reg_update_byte_dt(&config->i2c, LSM9DS0_MFD_REG_CTRL_REG5_XM,
LSM9DS0_MFD_MASK_CTRL_REG5_XM_TEMP_EN,
1 << LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_TEMP_EN) < 0) {
LOG_DBG("failed to power on temperature sensor");
return -EIO;
}
#endif
return 0;
}
int lsm9ds0_mfd_init(const struct device *dev)
{
const struct lsm9ds0_mfd_config * const config = dev->config;
if (!device_is_ready(config->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
if (lsm9ds0_mfd_init_chip(dev) < 0) {
LOG_DBG("failed to initialize chip");
return -EIO;
}
return 0;
}
#define LSM9DS0_MFD_DEFINE(inst) \
static struct lsm9ds0_mfd_data lsm9ds0_mfd_data_##inst; \
\
static const struct lsm9ds0_mfd_config lsm9ds0_mfd_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm9ds0_mfd_init, NULL, \
&lsm9ds0_mfd_data_##inst, &lsm9ds0_mfd_config_##inst, POST_KERNEL,\
CONFIG_SENSOR_INIT_PRIORITY, &lsm9ds0_mfd_api_funcs); \
DT_INST_FOREACH_STATUS_OKAY(LSM9DS0_MFD_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_mfd/lsm9ds0_mfd.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,050 |
```c
/* ST Microelectronics IIS2MDC 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2mdc
#include <zephyr/init.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/drivers/sensor.h>
#include <string.h>
#include <zephyr/logging/log.h>
#include "iis2mdc.h"
struct iis2mdc_data iis2mdc_data;
LOG_MODULE_REGISTER(IIS2MDC, CONFIG_SENSOR_LOG_LEVEL);
#ifdef CONFIG_IIS2MDC_MAG_ODR_RUNTIME
static int iis2mdc_set_odr(const struct device *dev,
const struct sensor_value *val)
{
struct iis2mdc_data *iis2mdc = dev->data;
iis2mdc_odr_t odr;
switch (val->val1) {
case 10:
odr = IIS2MDC_ODR_10Hz;
break;
case 20:
odr = IIS2MDC_ODR_20Hz;
break;
case 50:
odr = IIS2MDC_ODR_50Hz;
break;
case 100:
odr = IIS2MDC_ODR_100Hz;
break;
default:
return -EINVAL;
}
if (iis2mdc_data_rate_set(iis2mdc->ctx, odr)) {
return -EIO;
}
return 0;
}
#endif /* CONFIG_IIS2MDC_MAG_ODR_RUNTIME */
static int iis2mdc_set_hard_iron(const struct device *dev,
enum sensor_channel chan,
const struct sensor_value *val)
{
struct iis2mdc_data *iis2mdc = dev->data;
uint8_t i;
int16_t offset[3];
for (i = 0U; i < 3; i++) {
offset[i] = sys_cpu_to_le16(val->val1);
val++;
}
return iis2mdc_mag_user_offset_set(iis2mdc->ctx, offset);
}
static void iis2mdc_channel_get_mag(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int32_t cval;
int i;
uint8_t ofs_start, ofs_stop;
struct iis2mdc_data *iis2mdc = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_MAGN_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_MAGN_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop; i++) {
cval = iis2mdc->mag[i] * 1500;
pval->val1 = cval / 1000000;
pval->val2 = cval % 1000000;
pval++;
}
}
/* read internal temperature */
static void iis2mdc_channel_get_temp(const struct device *dev,
struct sensor_value *val)
{
struct iis2mdc_data *drv_data = dev->data;
val->val1 = drv_data->temp_sample / 100;
val->val2 = (drv_data->temp_sample % 100) * 10000;
}
static int iis2mdc_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
iis2mdc_channel_get_mag(dev, chan, val);
break;
case SENSOR_CHAN_DIE_TEMP:
iis2mdc_channel_get_temp(dev, val);
break;
default:
LOG_DBG("Channel not supported");
return -ENOTSUP;
}
return 0;
}
static int iis2mdc_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
#ifdef CONFIG_IIS2MDC_MAG_ODR_RUNTIME
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2mdc_set_odr(dev, val);
#endif /* CONFIG_IIS2MDC_MAG_ODR_RUNTIME */
case SENSOR_ATTR_OFFSET:
return iis2mdc_set_hard_iron(dev, chan, val);
default:
LOG_DBG("Mag attribute not supported");
return -ENOTSUP;
}
return 0;
}
static int iis2mdc_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ALL:
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
return iis2mdc_config(dev, chan, attr, val);
default:
LOG_DBG("attr_set() not supported on %d channel", chan);
return -ENOTSUP;
}
return 0;
}
static int iis2mdc_sample_fetch_mag(const struct device *dev)
{
struct iis2mdc_data *iis2mdc = dev->data;
int16_t raw_mag[3];
/* fetch raw data sample */
if (iis2mdc_magnetic_raw_get(iis2mdc->ctx, raw_mag) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
iis2mdc->mag[0] = sys_le16_to_cpu(raw_mag[0]);
iis2mdc->mag[1] = sys_le16_to_cpu(raw_mag[1]);
iis2mdc->mag[2] = sys_le16_to_cpu(raw_mag[2]);
return 0;
}
static int iis2mdc_sample_fetch_temp(const struct device *dev)
{
struct iis2mdc_data *iis2mdc = dev->data;
int16_t raw_temp;
int32_t temp;
/* fetch raw temperature sample */
if (iis2mdc_temperature_raw_get(iis2mdc->ctx, &raw_temp) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
/* formula is temp = 25 + (temp / 8) C */
temp = sys_le16_to_cpu(raw_temp);
iis2mdc->temp_sample = 2500 + (temp * 100) / 8;
return 0;
}
static int iis2mdc_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
iis2mdc_sample_fetch_mag(dev);
break;
case SENSOR_CHAN_DIE_TEMP:
iis2mdc_sample_fetch_temp(dev);
break;
case SENSOR_CHAN_ALL:
iis2mdc_sample_fetch_mag(dev);
iis2mdc_sample_fetch_temp(dev);
break;
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api iis2mdc_driver_api = {
.attr_set = iis2mdc_attr_set,
#if CONFIG_IIS2MDC_TRIGGER
.trigger_set = iis2mdc_trigger_set,
#endif
.sample_fetch = iis2mdc_sample_fetch,
.channel_get = iis2mdc_channel_get,
};
static int iis2mdc_init(const struct device *dev)
{
const struct iis2mdc_dev_config *const cfg = dev->config;
struct iis2mdc_data *iis2mdc = dev->data;
uint8_t wai;
iis2mdc->dev = dev;
if (cfg->bus_init(dev) < 0) {
return -EINVAL;
}
/* check chip ID */
if (iis2mdc_device_id_get(iis2mdc->ctx, &wai) < 0) {
return -EIO;
}
if (wai != IIS2MDC_ID) {
LOG_DBG("Invalid chip ID: %02x\n", wai);
return -EINVAL;
}
/* reset sensor configuration */
if (iis2mdc_reset_set(iis2mdc->ctx, PROPERTY_ENABLE) < 0) {
LOG_DBG("s/w reset failed\n");
return -EIO;
}
k_busy_wait(100);
/* enable BDU */
if (iis2mdc_block_data_update_set(iis2mdc->ctx, PROPERTY_ENABLE) < 0) {
LOG_DBG("setting bdu failed\n");
return -EIO;
}
/* Set Output Data Rate */
if (iis2mdc_data_rate_set(iis2mdc->ctx, IIS2MDC_ODR_10Hz)) {
LOG_DBG("set odr failed\n");
return -EIO;
}
/* Set / Reset sensor mode */
if (iis2mdc_set_rst_mode_set(iis2mdc->ctx,
IIS2MDC_SENS_OFF_CANC_EVERY_ODR)) {
LOG_DBG("reset sensor mode failed\n");
return -EIO;
}
/* Enable temperature compensation */
if (iis2mdc_offset_temp_comp_set(iis2mdc->ctx, PROPERTY_ENABLE)) {
LOG_DBG("enable temp compensation failed\n");
return -EIO;
}
/* Set device in continuous mode */
if (iis2mdc_operating_mode_set(iis2mdc->ctx, IIS2MDC_CONTINUOUS_MODE)) {
LOG_DBG("set continuous mode failed\n");
return -EIO;
}
#ifdef CONFIG_IIS2MDC_TRIGGER
if (iis2mdc_init_interrupt(dev) < 0) {
LOG_DBG("Failed to initialize interrupts");
return -EIO;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "IIS2MDC driver enabled without any devices"
#endif
/*
* Device creation macro, shared by IIS2MDC_DEFINE_SPI() and
* IIS2MDC_DEFINE_I2C().
*/
#define IIS2MDC_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
iis2mdc_init, \
NULL, \
&iis2mdc_data_##inst, \
&iis2mdc_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&iis2mdc_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_IIS2MDC_TRIGGER
#define IIS2MDC_CFG_IRQ(inst) \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios),
#else
#define IIS2MDC_CFG_IRQ(inst)
#endif /* CONFIG_IIS2MDC_TRIGGER */
#define IIS2MDC_SPI_OP (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define IIS2MDC_CONFIG_SPI(inst) \
{ \
.spi = SPI_DT_SPEC_INST_GET(inst, IIS2MDC_SPI_OP, 0), \
.bus_init = iis2mdc_spi_init, \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(IIS2MDC_CFG_IRQ(inst)), ()) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define IIS2MDC_CONFIG_I2C(inst) \
{ \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
.bus_init = iis2mdc_i2c_init, \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(IIS2MDC_CFG_IRQ(inst)), ()) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define IIS2MDC_DEFINE(inst) \
static struct iis2mdc_data iis2mdc_data_##inst; \
static const struct iis2mdc_dev_config iis2mdc_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(IIS2MDC_CONFIG_SPI(inst)), \
(IIS2MDC_CONFIG_I2C(inst))); \
IIS2MDC_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(IIS2MDC_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/iis2mdc.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,880 |
```c
/* ST Microelectronics IIS2MDC 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2mdc
#include <string.h>
#include "iis2mdc.h"
#include <zephyr/logging/log.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#define IIS2MDC_SPI_READ (1 << 7)
LOG_MODULE_DECLARE(IIS2MDC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2mdc_spi_read(const struct device *dev, uint8_t reg,
uint8_t *val, uint16_t len)
{
const struct iis2mdc_dev_config *cfg = dev->config;
uint8_t buffer_tx[2] = { reg | IIS2MDC_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 (len > 64) {
return -EIO;
}
if (spi_transceive_dt(&cfg->spi, &tx, &rx)) {
return -EIO;
}
return 0;
}
static int iis2mdc_spi_write(const struct device *dev, uint8_t reg,
uint8_t *val, uint16_t len)
{
const struct iis2mdc_dev_config *cfg = dev->config;
uint8_t buffer_tx[1] = { reg & ~IIS2MDC_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 (len > 64) {
return -EIO;
}
if (spi_write_dt(&cfg->spi, &tx)) {
return -EIO;
}
return 0;
}
int iis2mdc_spi_init(const struct device *dev)
{
struct iis2mdc_data *data = dev->data;
const struct iis2mdc_dev_config *const cfg = dev->config;
if (!spi_is_ready_dt(&cfg->spi)) {
LOG_ERR("SPI bus is not ready");
return -ENODEV;
}
data->ctx_spi.read_reg = (stmdev_read_ptr) iis2mdc_spi_read;
data->ctx_spi.write_reg = (stmdev_write_ptr) iis2mdc_spi_write;
data->ctx_spi.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay;
data->ctx = &data->ctx_spi;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/iis2mdc_spi.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 718 |
```c
/* ST Microelectronics IIS2MDC 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2mdc
#include <string.h>
#include <zephyr/logging/log.h>
#include "iis2mdc.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
LOG_MODULE_DECLARE(IIS2MDC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2mdc_i2c_read(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint16_t len)
{
const struct iis2mdc_dev_config *cfg = dev->config;
return i2c_burst_read_dt(&cfg->i2c, reg_addr, value, len);
}
static int iis2mdc_i2c_write(const struct device *dev, uint8_t reg_addr,
uint8_t *value, uint16_t len)
{
const struct iis2mdc_dev_config *cfg = dev->config;
return i2c_burst_write_dt(&cfg->i2c, reg_addr, value, len);
}
int iis2mdc_i2c_init(const struct device *dev)
{
struct iis2mdc_data *data = dev->data;
const struct iis2mdc_dev_config *cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("I2C bus is not ready");
return -ENODEV;
}
data->ctx_i2c.read_reg = (stmdev_read_ptr) iis2mdc_i2c_read;
data->ctx_i2c.write_reg = (stmdev_write_ptr) iis2mdc_i2c_write;
data->ctx_i2c.mdelay = (stmdev_mdelay_ptr) stmemsc_mdelay;
data->ctx = &data->ctx_i2c;
data->ctx->handle = (void *)dev;
return 0;
}
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/iis2mdc_i2c.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 437 |
```objective-c
/* ST Microelectronics IIS2MDC 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef __MAG_IIS2MDC_H
#define __MAG_IIS2MDC_H
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "iis2mdc_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
struct iis2mdc_dev_config {
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
struct spi_dt_spec spi;
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
};
int (*bus_init)(const struct device *dev);
#ifdef CONFIG_IIS2MDC_TRIGGER
const struct gpio_dt_spec gpio_drdy;
#endif /* CONFIG_IIS2MDC_TRIGGER */
};
/* Sensor data */
struct iis2mdc_data {
const struct device *dev;
int16_t mag[3];
int32_t temp_sample;
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_IIS2MDC_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy;
const struct sensor_trigger *trig_drdy;
#if defined(CONFIG_IIS2MDC_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2MDC_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif /* CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_IIS2MDC_TRIGGER */
};
int iis2mdc_spi_init(const struct device *dev);
int iis2mdc_i2c_init(const struct device *dev);
#ifdef CONFIG_IIS2MDC_TRIGGER
int iis2mdc_init_interrupt(const struct device *dev);
int iis2mdc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_IIS2MDC_TRIGGER */
#endif /* __MAG_IIS2MDC_H */
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/iis2mdc.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 605 |
```objective-c
/* sensor_lsm9ds0_mfd.h - header file for LSM9DS0 accelerometer, magnetometer
* and temperature (MFD) sensor driver
*/
/*
*
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LSM9DS0_MFD_LSM9DS0_MFD_H_
#define ZEPHYR_DRIVERS_SENSOR_LSM9DS0_MFD_LSM9DS0_MFD_H_
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/i2c.h>
#define LSM9DS0_MFD_REG_OUT_TEMP_L_XM 0x05
#define LSM9DS0_MFD_REG_OUT_TEMP_H_XM 0x06
#define LSM9DS0_MFD_REG_STATUS_REG_M 0x07
#define LSM9DS0_MFD_MASK_STATUS_REG_M_ZYXMOR BIT(7)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_ZYXMOR 7
#define LSM9DS0_MFD_MASK_STATUS_REG_M_ZMOR BIT(6)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_ZMOR 6
#define LSM9DS0_MFD_MASK_STATUS_REG_M_YMOR BIT(5)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_YMOR 5
#define LSM9DS0_MFD_MASK_STATUS_REG_M_XMOR BIT(4)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_XMOR 4
#define LSM9DS0_MFD_MASK_STATUS_REG_M_ZYXMDA BIT(3)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_ZYXMDA 3
#define LSM9DS0_MFD_MASK_STATUS_REG_M_ZMDA BIT(2)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_ZMDA 2
#define LSM9DS0_MFD_MASK_STATUS_REG_M_YMDA BIT(1)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_M_YMDA 1
#define LSM9DS0_MFD_MASK_STATUS_REG_M_XMDA BIT(0)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_XMDA 0
#define LSM9DS0_MFD_REG_OUT_X_L_M 0x08
#define LSM9DS0_MFD_REG_OUT_X_H_M 0x09
#define LSM9DS0_MFD_REG_OUT_Y_L_M 0x0A
#define LSM9DS0_MFD_REG_OUT_Y_H_M 0x0B
#define LSM9DS0_MFD_REG_OUT_Z_L_M 0x0C
#define LSM9DS0_MFD_REG_OUT_Z_H_M 0x0D
#define LSM9DS0_MFD_REG_WHO_AM_I_XM 0x0F
#define LSM9DS0_MFD_VAL_WHO_AM_I_XM 0x49
#define LSM9DS0_MFD_REG_INT_CTRL_REG_M 0x12
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_XMIEN BIT(7)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_XMIEN 7
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_YMIEN BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_YMIEN 6
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_ZMIEN BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_ZMIEN 5
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_PP_OD BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_PP_OD 4
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_IEA BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_IEA 3
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_IEL BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_IEL 2
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_4D BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_4D 1
#define LSM9DS0_MFD_MASK_INT_CTRL_REG_M_MIEN BIT(0)
#define LSM9DS0_MFD_SHIFT_INT_CTRL_REG_M_MIEN 0
#define LSM9DS0_MFD_REG_INT_SRC_REG_M 0x13
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_PTH_X BIT(7)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_PTH_X 7
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_PTH_Y BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_PTH_Y 6
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_PTH_Z BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_PTH_Z 5
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_NTH_X BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_NTH_X 4
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_NTH_Y BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_NTH_Y 3
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_M_NTH_Z BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_M_NTH_Z 2
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_MROI BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_MROI 1
#define LSM9DS0_MFD_MASK_INT_SRC_REG_M_MINT BIT(0)
#define LSM9DS0_MFD_SHIFT_INT_SRC_REG_M_MINT 0
#define LSM9DS0_MFD_REG_INT_THS_L_M 0x14
#define LSM9DS0_MFD_REG_INT_THS_H_M 0x15
#define LSM9DS0_MFD_REG_OFFSET_X_L_M 0x16
#define LSM9DS0_MFD_REG_OFFSET_X_H_M 0x17
#define LSM9DS0_MFD_REG_OFFSET_Y_L_M 0x18
#define LSM9DS0_MFD_REG_OFFSET_Y_H_M 0x19
#define LSM9DS0_MFD_REG_OFFSET_Z_L_M 0x1A
#define LSM9DS0_MFD_REG_OFFSET_Z_H_M 0x1B
#define LSM9DS0_MFD_REG_REFERENCE_X 0x1C
#define LSM9DS0_MFD_REG_REFERENCE_Y 0x1D
#define LSM9DS0_MFD_REG_REFERENCE_Z 0x1E
#define LSM9DS0_MFD_REG_CTRL_REG0_XM 0x1F
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_BOOT BIT(7)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_BOOT 7
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_FIFO_EN BIT(6)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_FIFO_EN 6
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_WTM_EN BIT(5)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_WTM_EN 5
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_HP_C BIT(2)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_HP_C 2
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_HPIS1 BIT(1)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_HPIS1 1
#define LSM9DS0_MFD_MASK_CTRL_REG0_XM_HPIS2 BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG0_XM_HPIS2 0
#define LSM9DS0_MFD_REG_CTRL_REG1_XM 0x20
#define LSM9DS0_MFD_MASK_CTRL_REG1_XM_AODR (BIT(7) | BIT(6) | BIT(5) | \
BIT(4))
#define LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AODR 4
#define LSM9DS0_MFD_MASK_CTRL_REG1_XM_BDU BIT(3)
#define LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_BDU 3
#define LSM9DS0_MFD_MASK_CTRL_REG1_XM_AZEN BIT(2)
#define LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AZEN 2
#define LSM9DS0_MFD_MASK_CTRL_REG1_XM_AYEN BIT(1)
#define LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AYEN 1
#define LSM9DS0_MFD_MASK_CTRL_REG1_XM_AXEN BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AXEN 0
#define LSM9DS0_MFD_REG_CTRL_REG2_XM 0x21
#define LSM9DS0_MFD_MASK_CTRL_REG2_XM_ABW (BIT(7) | BIT(6))
#define LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_ABW 6
#define LSM9DS0_MFD_MASK_CTRL_REG2_XM_AFS (BIT(5) | BIT(4) | BIT(3))
#define LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_AFS 3
#define LSM9DS0_MFD_MASK_CTRL_REG2_XM_AST (BIT(2) | BIT(1))
#define LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_AST 1
#define LSM9DS0_MFD_MASK_CTRL_REG2_XM_SIM BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_SIM 0
#define LSM9DS0_MFD_REG_CTRL_REG3_XM 0x22
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_BOOT BIT(7)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_BOOT 7
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_TAP BIT(6)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_TAP 6
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_INT1 BIT(5)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_INT1 5
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_INT2 BIT(4)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_INT2 4
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_INTM BIT(3)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_INTM 3
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_DRDYA BIT(2)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_DRDYA 2
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_DRDYM BIT(1)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_DRDYM 1
#define LSM9DS0_MFD_MASK_CTRL_REG3_XM_P1_EMPTY BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG3_XM_P1_EMPTY 0
#define LSM9DS0_MFD_REG_CTRL_REG4_XM 0x23
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_TAP BIT(7)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_TAP 7
#define LMS9DS0_MFD_MASK_CTRL_REG4_XM_P2_INT1 BIT(6)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_INT1 6
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_INT2 BIT(5)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_INT2 5
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_INTM BIT(4)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_INTM 4
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_DRDYA BIT(3)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_DRDYA 3
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_DRDYM BIT(2)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_DRDYM 2
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_OVR BIT(1)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_OVR 1
#define LSM9DS0_MFD_MASK_CTRL_REG4_XM_P2_WTM BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG4_XM_P2_WTM 0
#define LSM9DS0_MFD_REG_CTRL_REG5_XM 0x24
#define LSM9DS0_MFD_MASK_CTRL_REG5_XM_TEMP_EN BIT(7)
#define LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_TEMP_EN 7
#define LSM9DS0_MFD_MASK_CTRL_REG5_XM_M_RES (BIT(6) | BIT(5))
#define LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_M_RES 5
#define LSM9DS0_MFD_MASK_CTRL_REG5_XM_M_ODR (BIT(4) | BIT(3) | BIT(2))
#define LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_M_ODR 2
#define LSM9DS0_MFD_MASK_CTRL_REG5_XM_LIR2 BIT(1)
#define LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_LIR2 1
#define LSM9DS0_MFD_MASK_CTRL_REG5_XM_LIR1 BIT(0)
#define LSM9DS0_MFD_SHIFT_CTRL_REG5_XM_LIR1 0
#define LSM9DS0_MFD_REG_CTRL_REG6_XM 0x25
#define LSM9DS0_MFD_MASK_CTRL_REG6_XM_MFS (BIT(6) | BIT(5))
#define LSM9DS0_MFD_SHIFT_CTRL_REG6_XM_MFS 5
#define LSM9DS0_MFD_REG_CTRL_REG7_XM 0x26
#define LSM9DS0_MFD_MASK_CTRL_REG7_XM_AHPM (BIT(7) | BIT(6))
#define LSM9DS0_MFD_SHIFT_CTRL_REG7_XM_AHPM 6
#define LSM9DS0_MFD_MASK_CTRL_REG7_XM_AFDS BIT(5)
#define LSM9DS0_MFD_SHIFT_CTRL_REG7_XM_AFDS 5
#define LSM9DS0_MFD_MASK_CTRL_REG7_XM_MLP BIT(2)
#define LSM9DS0_MFD_SHIFT_CTRL_REG7_XM_MLP 2
#define LSM9DS0_MFD_MASK_CTRL_REG7_XM_MD (BIT(1) | BIT(0))
#define LSM9DS0_MFD_SHIFT_CTRL_REG7_XM_MD 0
#define LSM9DS0_MFD_REG_STATUS_REG_A 0x27
#define LSM9DS0_MFD_MASK_STATUS_REG_A_ZYXAOR BIT(7)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_ZYXAOR 7
#define LSM9DS0_MFD_MASK_STATUS_REG_A_ZAOR BIT(6)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_ZAOR 6
#define LSM9DS0_MFD_MASK_STATUS_REG_A_YAOR BIT(5)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_YAOR 5
#define LSM9DS0_MFD_MASK_STATUS_REG_A_XAOR BIT(4)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_XAOR 4
#define LSM9DS0_MFD_MASK_STATUS_REG_A_ZYXADA BIT(3)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_ZYXADA 3
#define LSM9DS0_MFD_MASK_STATUS_REG_A_ZADA BIT(2)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_ZADA 2
#define LSM9DS0_MFD_MASK_STATUS_REG_A_YADA BIT(1)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_YADA 1
#define LSM9DS0_MFD_MASK_STATUS_REG_A_XADA BIT(0)
#define LSM9DS0_MFD_SHIFT_STATUS_REG_A_XADA 0
#define LSM9DS0_MFD_REG_OUT_X_L_A 0x28
#define LSM9DS0_MFD_REG_OUT_X_H_A 0x29
#define LSM9DS0_MFD_REG_OUT_Y_L_A 0x2A
#define LSM9DS0_MFD_REG_OUT_Y_H_A 0x2B
#define LSM9DS0_MFD_REG_OUT_Z_L_A 0x2C
#define LSM9DS0_MFD_REG_OUT_Z_H_A 0x2D
#define LSM9DS0_MFD_REG_FIFO_CTRL_REG 0x2E
#define LSM9DS0_MFD_MASK_FIFO_CTRL_REG_FM (BIT(7) | BIT(6) | BIT(5))
#define LSM9DS0_MFD_SHIFT_FIFO_CTRL_REG_FM 5
#define LSM9DS0_MFD_MASK_FIFO_CTRL_REG_FTH (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_MFD_SHIFT_FIFO_CTRL_REG_FTH 0
#define LSM9DS0_MFD_REG_FIFO_SRC_REG 0x2F
#define LSM9DS0_MFD_MASK_FIFO_SRC_REG_WTM BIT(7)
#define LMS9DS0_MFD_SHIFT_FIFO_SRC_REG_WTM 7
#define LSM9DS0_MFD_MASK_FIFO_SRC_REG_OVRN BIT(6)
#define LSM9DS0_MFD_SHIFT_FIFO_SRC_REG_OVRN 6
#define LSM9DS0_MFD_MASK_FIFO_SRC_REG_EMPTY BIT(5)
#define LMS9DS0_MFD_SHIFT_FIFO_SRC_REG_EMPTY 5
#define LSM9DS0_MFD_MASK_FIFO_SRC_REG_FSS (BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_MFD_SHIFT_FIFO_SRC_REG_FSS 0
#define LSM9DS0_MFD_REG_INT_GEN_1_REG 0x30
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_AOI BIT(7)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_AOI 7
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_6D BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_6D 6
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_ZHIE BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_ZHIE 5
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_ZLIE BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_ZLIE 4
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_YHIE BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_YHIE 3
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_YLIE BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_YLIE 2
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_XHIE BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_XHIE 1
#define LSM9DS0_MFD_MASK_INT_GEN_1_REG_XLIE BIT(0)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_REG_XLIE 0
#define LSM9DS0_MFD_REG_INT_GEN_1_SRC 0x31
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_IA BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_IA 6
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_ZH BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_ZH 5
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_ZL BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_ZL 4
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_YH BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_YH 3
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_YL BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_YL 2
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_XH BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_XH 1
#define LSM9DS0_MFD_MASK_INT_GEN_1_SRC_XL BIT(0)
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_SRC_XL 0
#define LSM9DS0_MFD_REG_INT_GEN_1_THS 0x32
#define LSM9DS0_MFD_MASK_INT_GEN_1_THS_THS (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_MFD_SHIFT_INT_GEN_1_THS_THS 0
#define LSM9DS0_MFD_REG_INT_GEN_1_DURATION 0x33
#define LSM9DS0_MFD_MASK_INT_GEN_1_DURATION_D (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LMS9DS0_MFD_SHIFT_INT_GEN_1_DURATION_D 0
#define LSM9DS0_MFD_REG_INT_GEN_2_REG 0x34
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_AOI BIT(7)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_AOI 7
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_6D BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_6D 6
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_ZHIE BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_ZHIE 5
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_ZLIE BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_ZLIE 4
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_YHIE BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_YHIE 3
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_YLIE BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_YLIE 2
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_XHIE BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_REG_XHIE 1
#define LSM9DS0_MFD_MASK_INT_GEN_2_REG_XLIE BIT(0)
#define LMS9Ds0_MFD_SHIFT_INT_GEN_2_REG_XLIE 0
#define LSM9DS0_MFD_REG_INT_GEN_2_SRC 0x35
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_IA BIT(6)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_IA 6
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_ZH BIT(5)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_ZH 5
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_ZL BIT(4)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_ZL 4
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_YH BIT(3)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_YH 3
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_YL BIT(2)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_YL 2
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_XH BIT(1)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_XH 1
#define LSM9DS0_MFD_MASK_INT_GEN_2_SRC_XL BIT(0)
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_SRC_XL 0
#define LSM9DS0_MFD_REG_INT_GEN_2_THS 0x36
#define LSM9DS0_MFD_MASK_INT_GEN_2_THS_THS (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_THS_THS 0
#define LSM9DS0_MFD_REG_INT_GEN_2_DURATION 0x37
#define LSM9DS0_MFD_MASK_INT_GEN_2_DURATION_D (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
ensor_ BIT(0))
#define LSM9DS0_MFD_SHIFT_INT_GEN_2_DURATION_D 0
#define LSM9DS0_MFD_REG_CLICK_CFG 0x38
#define LSM9DS0_MFD_MASK_CLICK_CFG_ZD BIT(5)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_ZD 5
#define LSM9DS0_MFD_MASK_CLICK_CFG_ZS BIT(4)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_ZS 4
#define LSM9DS0_MFD_MASK_CLICK_CFG_YD BIT(3)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_YD 3
#define LSM9DS0_MFD_MASK_CLICK_CFG_YS BIT(2)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_YS 2
#define LSM9DS0_MFD_MASK_CLICK_CFG_XD BIT(1)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_XD 1
#define LSM9DS0_MFD_MASK_CLICK_CFG_XS BIT(0)
#define LSM9DS0_MFD_SHIFT_CLICK_CFG_XS 0
#define LSM9DS0_MFD_REG_CLICK_SRC 0x39
#define LSM9DS0_MFD_MASK_CLICK_SRC_IA BIT(6)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_IA 6
#define LSM9DS0_MFD_MASK_CLICK_SRC_DC BIT(5)
#define LMS9DS0_MFD_SHIFT_CLICK_SRC_DC 5
#define LSM9DS0_MFD_MASK_CLICK_SRC_SC BIT(4)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_SC 4
#define LSM9DS0_MFD_MASK_CLICK_SRC_S BIT(3)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_S 3
#define LSM9DS0_MFD_MASK_CLICK_SRC_Z BIT(2)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_Z 2
#define LSM9DS0_MFD_MASK_CLICK_SRC_Y BIT(1)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_Y 1
#define LSM9DS0_MFD_MASK_CLICK_SRC_X BIT(0)
#define LSM9DS0_MFD_SHIFT_CLICK_SRC_X 0
#define LSM9DS0_MFD_REG_CLICK_THS 0x3A
#define LSM9DS0_MFD_MASK_CLICK_THS_THS (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_MFD_SHIFT_CLICK_THS_THS 0
#define LSM9DS0_MFD_REG_TIME_LIMIT 0x3B
#define LSM9DS0_MFD_MASK_TIME_LIMIT_TLI (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LMS9DS0_MFD_SHIFT_TIME_LIMIT_TLI 0
#define LSM9DS0_MFD_REG_TIME_LATENCY 0x3C
#define LSM9DS0_MFD_MASK_TIME_LATENCY_TLA (BIT(7) | BIT(6) | BIT(5) | \
BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_MFD_SHIFT_TIME_LATENCY_TLA 0
#define LSM9DS0_MFD_REG_TIME_WINDOW 0x3D
#define LSM9DS0_MFD_MASK_TIME_WINDOW_TW (BIT(7) | BIT(6) | BIT(5) | \
BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LSM9DS0_MFD_SHIFT_TIME_WINDOW_TW 0
#define LSM9DS0_MFD_REG_ACT_THS 0x3E
#define LSM9DS0_MFD_MASK_ACT_THS_ACTHS (BIT(6) | BIT(5) | BIT(4) | \
BIT(3) | BIT(2) | BIT(1) | \
BIT(0))
#define LSM9DS0_MFD_SHIFT_ACT_THS_ACTHS 0
#define LSM9DS0_MFD_REG_ACT_DUR 0x3F
#define LSM9DS0_MFD_MASK_ACT_DUR_ACTD (BIT(7) | BIT(6) | BIT(5) | \
BIT(4) | BIT(3) | BIT(2) | \
BIT(1) | BIT(0))
#define LMS9DS0_MFD_SHIFT_ACT_DUR_ACTD 0
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_0)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 0
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_3_125)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 1
#define LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_6_25)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 2
#define LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_12_5)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 3
#define LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_25)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 4
#define LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_50)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 5
#define LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_100)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 6
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_200)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 7
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_400)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 8
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_800)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 9
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_1600)
#define LSM9DS0_MFD_ACCEL_DEFAULT_AODR 10
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_2)
#define LSM9DS0_MFD_ACCEL_DEFAULT_FS 0
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_4)
#define LSM9DS0_MFD_ACCEL_DEFAULT_FS 1
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_6)
#define LSM9DS0_MFD_ACCEL_DEFAULT_FS 2
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_8)
#define LSM9DS0_MFD_ACCEL_DEFAULT_FS 3
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_16)
#define LSM9DS0_MFD_ACCEL_DEFAULT_FS 4
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_X)
#define LSM9DS0_MFD_ACCEL_ENABLE_X 1
#else
#define LSM9DS0_MFD_ACCEL_ENABLE_X 0
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Y)
#define LSM9DS0_MFD_ACCEL_ENABLE_Y 1
#else
#define LSM9DS0_MFD_ACCEL_ENABLE_Y 0
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Z)
#define LSM9DS0_MFD_ACCEL_ENABLE_Z 1
#else
#define LSM9DS0_MFD_ACCEL_ENABLE_Z 0
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_RUNTIME) || \
defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
#define LSM9DS0_MFD_ATTR_SET_ACCEL
#endif
#if defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_3_125)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 0
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_6_25)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 1
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_12_5)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 2
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_25)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 3
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_50)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 4
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_100)
#if defined(LSM9DS0_MFD_ACCEL_FORCE_MAX_MODR_50)
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 4
#else
#define LSM9DS0_MFD_MAGN_DEFAULT_M_ODR 5
#endif
#endif
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_2)
#define LSM9DS0_MFD_MAGN_DEFAULT_FS 0
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_4)
#define LSM9DS0_MFD_MAGN_DEFAULT_FS 1
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_8)
#define LSM9DS0_MFD_MAGN_DEFAULT_FS 2
#elif defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_12)
#define LSM9DS0_MFD_MAGN_DEFAULT_FS 3
#endif
#if defined(CONFIG_LSM9DS0_MFD_MAGN_SAMPLING_RATE_RUNTIME) || \
defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
#define LSM9DS0_MFD_ATTR_SET_MAGN
#endif
#if !defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_X) && \
!defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Y) && \
!defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Z)
#define LSM9DS0_MFD_ACCEL_DISABLED
#elif defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_0) && \
!defined(CONFIG_LSM9DS0_MFD_ACCEL_SAMPLING_RATE_RUNTIME)
#define LSM9DS0_MFD_ACCEL_DISABLED
#elif !defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE)
#define LSM9DS0_MFD_ACCEL_DISABLED
#endif
#if !defined(CONFIG_LSM9DS0_MFD_MAGN_ENABLE)
#define LSM9DS0_MFD_MAGN_DISABLED
#endif
#if !defined(CONFIG_LSM9DS0_MFD_TEMP_ENABLE)
#define LSM9DS0_MFD_TEMP_DISABLED
#endif
#if defined(LSM9DS0_MFD_ATTR_SET_ACCEL) && defined(LSM9DS0_MFD_ACCEL_DISABLED)
#undef LSM9DS0_MFD_ATTR_SET_ACCEL
#endif
#if defined(LSM9DS0_MFD_ATTR_SET_MAGN) && defined(LSM9DS0_MFD_MAGN_DISABLED)
#undef LSM9DS0_MFD_ATTR_SET_MAGN
#endif
#if defined(LSM9DS0_MFD_ATTR_SET_ACCEL) || defined(LSM9DS0_MFD_ATTR_SET_MAGN)
#define LSM9DS0_MFD_ATTR_SET
#endif
struct lsm9ds0_mfd_config {
struct i2c_dt_spec i2c;
};
struct lsm9ds0_mfd_data {
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
int sample_accel_x, sample_accel_y, sample_accel_z;
#endif
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
int sample_magn_x, sample_magn_y, sample_magn_z;
#endif
#if !defined(LSM9DS0_MFD_TEMP_DISABLED)
int sample_temp;
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
#if !defined(LSM9DS0_MFD_ACCEL_DISABLED)
uint8_t accel_fs, sample_accel_fs;
#endif
#endif
#if defined(CONFIG_LSM9DS0_MFD_MAGN_FULL_SCALE_RUNTIME)
#if !defined(LSM9DS0_MFD_MAGN_DISABLED)
uint8_t magn_fs, sample_magn_fs;
#endif
#endif
};
#endif /* ZEPHYR_DRIVERS_SENSOR_LSM9DS0_MFD_LSM9DS0_MFD_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lsm9ds0_mfd/lsm9ds0_mfd.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 8,571 |
```unknown
menuconfig IIS2MDC
bool "IIS2MDC Magnetometer"
default y
depends on DT_HAS_ST_IIS2MDC_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2MDC),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2MDC),spi)
select HAS_STMEMSC
select USE_STDC_IIS2MDC
help
Enable driver for IIS2MDC I2C-based magnetometer sensor.
if IIS2MDC
choice IIS2MDC_TRIGGER_MODE
prompt "Trigger mode"
default IIS2MDC_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config IIS2MDC_TRIGGER_NONE
bool "No trigger"
config IIS2MDC_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select IIS2MDC_TRIGGER
config IIS2MDC_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select IIS2MDC_TRIGGER
endchoice # IIS2MDC_TRIGGER_MODE
config IIS2MDC_TRIGGER
bool
config IIS2MDC_THREAD_PRIORITY
int "Thread priority"
depends on IIS2MDC_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config IIS2MDC_THREAD_STACK_SIZE
int "Thread stack size"
depends on IIS2MDC_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config IIS2MDC_MAG_ODR_RUNTIME
bool "Set magnetometer sampling frequency (ODR) at runtime (default: 10 Hz)"
default y
endif # IIS2MDC
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 405 |
```c
/* ST Microelectronics IIS2MDC 3-axis magnetometer sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2mdc
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis2mdc.h"
LOG_MODULE_DECLARE(IIS2MDC, CONFIG_SENSOR_LOG_LEVEL);
static int iis2mdc_enable_int(const struct device *dev, int enable)
{
struct iis2mdc_data *iis2mdc = dev->data;
/* set interrupt on mag */
return iis2mdc_drdy_on_pin_set(iis2mdc->ctx, enable);
}
/* link external trigger to event data ready */
int iis2mdc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct iis2mdc_data *iis2mdc = dev->data;
int16_t raw[3];
if (trig->chan == SENSOR_CHAN_MAGN_XYZ) {
iis2mdc->handler_drdy = handler;
iis2mdc->trig_drdy = trig;
if (handler) {
/* fetch raw data sample: re-trigger lost interrupt */
iis2mdc_magnetic_raw_get(iis2mdc->ctx, raw);
return iis2mdc_enable_int(dev, 1);
} else {
return iis2mdc_enable_int(dev, 0);
}
}
return -ENOTSUP;
}
/* handle the drdy event: read data and call handler if registered any */
static void iis2mdc_handle_interrupt(const struct device *dev)
{
struct iis2mdc_data *iis2mdc = dev->data;
const struct iis2mdc_dev_config *const config = dev->config;
if (iis2mdc->handler_drdy != NULL) {
iis2mdc->handler_drdy(dev, iis2mdc->trig_drdy);
}
gpio_pin_interrupt_configure_dt(&config->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void iis2mdc_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct iis2mdc_data *iis2mdc =
CONTAINER_OF(cb, struct iis2mdc_data, gpio_cb);
const struct iis2mdc_dev_config *const config = iis2mdc->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&config->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_IIS2MDC_TRIGGER_OWN_THREAD)
k_sem_give(&iis2mdc->gpio_sem);
#elif defined(CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis2mdc->work);
#endif
}
#ifdef CONFIG_IIS2MDC_TRIGGER_OWN_THREAD
static void iis2mdc_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis2mdc_data *iis2mdc = p1;
while (1) {
k_sem_take(&iis2mdc->gpio_sem, K_FOREVER);
iis2mdc_handle_interrupt(iis2mdc->dev);
}
}
#endif
#ifdef CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD
static void iis2mdc_work_cb(struct k_work *work)
{
struct iis2mdc_data *iis2mdc =
CONTAINER_OF(work, struct iis2mdc_data, work);
iis2mdc_handle_interrupt(iis2mdc->dev);
}
#endif
int iis2mdc_init_interrupt(const struct device *dev)
{
struct iis2mdc_data *iis2mdc = dev->data;
const struct iis2mdc_dev_config *const config = dev->config;
int ret;
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&config->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -ENODEV;
}
#if defined(CONFIG_IIS2MDC_TRIGGER_OWN_THREAD)
k_sem_init(&iis2mdc->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis2mdc->thread, iis2mdc->thread_stack,
CONFIG_IIS2MDC_THREAD_STACK_SIZE,
iis2mdc_thread, iis2mdc,
NULL, NULL, K_PRIO_COOP(CONFIG_IIS2MDC_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD)
iis2mdc->work.handler = iis2mdc_work_cb;
#endif
ret = gpio_pin_configure_dt(&config->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&iis2mdc->gpio_cb,
iis2mdc_gpio_callback,
BIT(config->gpio_drdy.pin));
if (gpio_add_callback(config->gpio_drdy.port, &iis2mdc->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&config->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/iis2mdc/iis2mdc_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,214 |
```objective-c
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_IIS2ICLX_IIS2ICLX_H_
#define ZEPHYR_DRIVERS_SENSOR_IIS2ICLX_IIS2ICLX_H_
#include <zephyr/drivers/sensor.h>
#include <zephyr/types.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <stmemsc.h>
#include "iis2iclx_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#define IIS2ICLX_EN_BIT 0x01
#define IIS2ICLX_DIS_BIT 0x00
/* Accel sensor sensitivity grain is 15 ug/LSB */
#define GAIN_UNIT_XL (15LL)
struct iis2iclx_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
uint8_t odr;
uint8_t range;
#ifdef CONFIG_IIS2ICLX_TRIGGER
bool trig_enabled;
uint8_t int_pin;
const struct gpio_dt_spec gpio_drdy;
#endif /* CONFIG_IIS2ICLX_TRIGGER */
};
#define IIS2ICLX_SHUB_MAX_NUM_SLVS 2
struct iis2iclx_data {
const struct device *dev;
int16_t acc[2];
uint32_t acc_gain;
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
int temp_sample;
#endif
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
uint8_t ext_data[2][6];
uint16_t magn_gain;
struct hts221_data {
int16_t x0;
int16_t x1;
int16_t y0;
int16_t y1;
} hts221;
bool shub_inited;
uint8_t num_ext_dev;
uint8_t shub_ext[IIS2ICLX_SHUB_MAX_NUM_SLVS];
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
uint16_t accel_freq;
uint8_t accel_fs;
#ifdef CONFIG_IIS2ICLX_TRIGGER
struct gpio_callback gpio_cb;
sensor_trigger_handler_t handler_drdy_acc;
const struct sensor_trigger *trig_drdy_acc;
sensor_trigger_handler_t handler_drdy_temp;
const struct sensor_trigger *trig_drdy_temp;
#if defined(CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2ICLX_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2ICLX_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_IIS2ICLX_TRIGGER */
};
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
int iis2iclx_shub_init(const struct device *dev);
int iis2iclx_shub_fetch_external_devs(const struct device *dev);
int iis2iclx_shub_get_idx(const struct device *dev, enum sensor_channel type);
int iis2iclx_shub_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val);
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
#ifdef CONFIG_IIS2ICLX_TRIGGER
int iis2iclx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int iis2iclx_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_IIS2ICLX_IIS2ICLX_H_ */
``` | /content/code_sandbox/drivers/sensor/st/iis2iclx/iis2iclx.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 905 |
```c
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2iclx
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis2iclx.h"
LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
/**
* iis2iclx_enable_t_int - TEMP enable selected int pin to generate interrupt
*/
static int iis2iclx_enable_t_int(const struct device *dev, int enable)
{
const struct iis2iclx_config *cfg = dev->config;
iis2iclx_pin_int2_route_t int2_route;
if (enable) {
int16_t buf;
/* dummy read: re-trigger interrupt */
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((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((stmdev_ctx_t *)&cfg->ctx, IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
#endif
/**
* iis2iclx_enable_xl_int - XL enable selected int pin to generate interrupt
*/
static int iis2iclx_enable_xl_int(const struct device *dev, int enable)
{
const struct iis2iclx_config *cfg = dev->config;
if (enable) {
int16_t buf[3];
/* dummy read: re-trigger interrupt */
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((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((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((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((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_INT2_CTRL,
(uint8_t *)&int2_route.int2_ctrl, 1);
}
}
/**
* iis2iclx_trigger_set - link external trigger to event data ready
*/
int iis2iclx_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct iis2iclx_config *cfg = dev->config;
struct iis2iclx_data *iis2iclx = dev->data;
if (!cfg->trig_enabled) {
LOG_ERR("trigger_set op not supported");
return -ENOTSUP;
}
if (trig->chan == SENSOR_CHAN_ACCEL_XYZ) {
iis2iclx->handler_drdy_acc = handler;
iis2iclx->trig_drdy_acc = trig;
if (handler) {
return iis2iclx_enable_xl_int(dev, IIS2ICLX_EN_BIT);
} else {
return iis2iclx_enable_xl_int(dev, IIS2ICLX_DIS_BIT);
}
}
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
else if (trig->chan == SENSOR_CHAN_DIE_TEMP) {
iis2iclx->handler_drdy_temp = handler;
iis2iclx->trig_drdy_temp = trig;
if (handler) {
return iis2iclx_enable_t_int(dev, IIS2ICLX_EN_BIT);
} else {
return iis2iclx_enable_t_int(dev, IIS2ICLX_DIS_BIT);
}
}
#endif
return -ENOTSUP;
}
/**
* iis2iclx_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void iis2iclx_handle_interrupt(const struct device *dev)
{
struct iis2iclx_data *iis2iclx = dev->data;
const struct iis2iclx_config *cfg = dev->config;
iis2iclx_status_reg_t status;
while (1) {
if (iis2iclx_status_reg_get((stmdev_ctx_t *)&cfg->ctx,
&status) < 0) {
LOG_DBG("failed reading status reg");
return;
}
if (status.xlda == 0
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
&& status.tda == 0
#endif
) {
break;
}
if ((status.xlda) && (iis2iclx->handler_drdy_acc != NULL)) {
iis2iclx->handler_drdy_acc(dev, iis2iclx->trig_drdy_acc);
}
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
if ((status.tda) && (iis2iclx->handler_drdy_temp != NULL)) {
iis2iclx->handler_drdy_temp(dev, iis2iclx->trig_drdy_temp);
}
#endif
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void iis2iclx_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct iis2iclx_data *iis2iclx =
CONTAINER_OF(cb, struct iis2iclx_data, gpio_cb);
const struct iis2iclx_config *cfg = iis2iclx->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD)
k_sem_give(&iis2iclx->gpio_sem);
#elif defined(CONFIG_IIS2ICLX_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis2iclx->work);
#endif /* CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD
static void iis2iclx_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis2iclx_data *iis2iclx = p1;
while (1) {
k_sem_take(&iis2iclx->gpio_sem, K_FOREVER);
iis2iclx_handle_interrupt(iis2iclx->dev);
}
}
#endif /* CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD */
#ifdef CONFIG_IIS2ICLX_TRIGGER_GLOBAL_THREAD
static void iis2iclx_work_cb(struct k_work *work)
{
struct iis2iclx_data *iis2iclx =
CONTAINER_OF(work, struct iis2iclx_data, work);
iis2iclx_handle_interrupt(iis2iclx->dev);
}
#endif /* CONFIG_IIS2ICLX_TRIGGER_GLOBAL_THREAD */
int iis2iclx_init_interrupt(const struct device *dev)
{
struct iis2iclx_data *iis2iclx = dev->data;
const struct iis2iclx_config *cfg = dev->config;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD)
k_sem_init(&iis2iclx->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis2iclx->thread, iis2iclx->thread_stack,
CONFIG_IIS2ICLX_THREAD_STACK_SIZE,
iis2iclx_thread,
iis2iclx, NULL, NULL,
K_PRIO_COOP(CONFIG_IIS2ICLX_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_IIS2ICLX_TRIGGER_GLOBAL_THREAD)
iis2iclx->work.handler = iis2iclx_work_cb;
#endif /* CONFIG_IIS2ICLX_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&iis2iclx->gpio_cb,
iis2iclx_gpio_callback,
BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(cfg->gpio_drdy.port, &iis2iclx->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
/* enable interrupt on int1/int2 in pulse mode */
if (iis2iclx_int_notification_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_ALL_INT_PULSED) < 0) {
LOG_ERR("Could not set pulse mode");
return -EIO;
}
if (gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE) < 0) {
LOG_ERR("Could not configure interrupt");
return -EIO;
}
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/iis2iclx/iis2iclx_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,282 |
```c
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2iclx
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/logging/log.h>
#include "iis2iclx.h"
LOG_MODULE_DECLARE(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
#define IIS2ICLX_SHUB_DATA_OUT 0x02
#define IIS2ICLX_SHUB_SLV0_ADDR 0x15
#define IIS2ICLX_SHUB_SLV0_SUBADDR 0x16
#define IIS2ICLX_SHUB_SLV0_CONFIG 0x17
#define IIS2ICLX_SHUB_SLV1_ADDR 0x18
#define IIS2ICLX_SHUB_SLV1_SUBADDR 0x19
#define IIS2ICLX_SHUB_SLV1_CONFIG 0x1A
#define IIS2ICLX_SHUB_SLV2_ADDR 0x1B
#define IIS2ICLX_SHUB_SLV2_SUBADDR 0x1C
#define IIS2ICLX_SHUB_SLV2_CONFIG 0x1D
#define IIS2ICLX_SHUB_SLV3_ADDR 0x1E
#define IIS2ICLX_SHUB_SLV3_SUBADDR 0x1F
#define IIS2ICLX_SHUB_SLV3_CONFIG 0x20
#define IIS2ICLX_SHUB_SLV0_DATAWRITE 0x21
#define IIS2ICLX_SHUB_STATUS_MASTER 0x22
#define IIS2ICLX_SHUB_STATUS_SLV0_NACK BIT(3)
#define IIS2ICLX_SHUB_STATUS_ENDOP BIT(0)
#define IIS2ICLX_SHUB_SLVX_WRITE 0x0
#define IIS2ICLX_SHUB_SLVX_READ 0x1
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(const struct device *dev,
uint8_t slv_addr, uint8_t slv_reg,
uint8_t *value, uint16_t len);
static void iis2iclx_shub_enable(const struct device *dev, uint8_t enable);
/*
* LIS2MDL magn device specific part
*/
#if defined(CONFIG_IIS2ICLX_EXT_LIS2MDL) || defined(CONFIG_IIS2ICLX_EXT_IIS2MDC)
#define LIS2MDL_CFG_REG_A 0x60
#define LIS2MDL_CFG_REG_B 0x61
#define LIS2MDL_CFG_REG_C 0x62
#define LIS2MDL_STATUS_REG 0x67
#define LIS2MDL_SW_RESET 0x20
#define LIS2MDL_ODR_10HZ 0x00
#define LIS2MDL_ODR_100HZ 0x0C
#define LIS2MDL_OFF_CANC 0x02
#define LIS2MDL_SENSITIVITY 1500
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(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 1);
k_sleep(K_MSEC(10)); /* turn-on time in ms */
/* configure mag */
mag_cfg[0] = LIS2MDL_ODR_10HZ;
mag_cfg[1] = LIS2MDL_OFF_CANC;
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, mag_cfg, 2);
return 0;
}
static const uint16_t lis2mdl_map[] = {10, 20, 50, 100};
static int iis2iclx_lis2mdl_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lis2mdl_map); odr++) {
if (freq == lis2mdl_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lis2mdl_map)) {
LOG_ERR("shub: LIS2MDL freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 2);
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LIS2MDL_CFG_REG_A, &cfg, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
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(dev, i2c_addr, val->val1);
default:
LOG_ERR("shub: LIS2MDL attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_IIS2ICLX_EXT_LIS2MDL || CONFIG_IIS2ICLX_EXT_IIS2MDC */
/*
* HTS221 humidity device specific part
*/
#ifdef CONFIG_IIS2ICLX_EXT_HTS221
#define HTS221_AUTOINCREMENT BIT(7)
#define HTS221_REG_CTRL1 0x20
#define HTS221_ODR_1HZ 0x01
#define HTS221_BDU 0x04
#define HTS221_PD 0x80
#define HTS221_REG_CONV_START 0x30
static int hts221_read_conv_data(const struct device *dev,
uint8_t i2c_addr)
{
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(dev, i2c_addr,
(HTS221_REG_CONV_START + i) |
HTS221_AUTOINCREMENT,
&buf[i], len) < 0) {
LOG_ERR("shub: failed to read hts221 conv data");
return -EIO;
}
}
ht->y0 = buf[0] / 2;
ht->y1 = buf[1] / 2;
ht->x0 = sys_le16_to_cpu(buf[6] | (buf[7] << 8));
ht->x1 = sys_le16_to_cpu(buf[10] | (buf[11] << 8));
return 0;
}
static int iis2iclx_hts221_init(const struct device *dev, uint8_t i2c_addr)
{
uint8_t hum_cfg;
/* configure ODR and BDU */
hum_cfg = HTS221_ODR_1HZ | HTS221_BDU | HTS221_PD;
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &hum_cfg, 1);
return hts221_read_conv_data(dev, i2c_addr);
}
static const uint16_t hts221_map[] = {0, 1, 7, 12};
static int iis2iclx_hts221_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(hts221_map); odr++) {
if (freq == hts221_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(hts221_map)) {
LOG_ERR("shub: HTS221 freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = odr | HTS221_BDU | HTS221_PD;
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
HTS221_REG_CTRL1, &cfg, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
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)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2iclx_hts221_odr_set(dev, i2c_addr, val->val1);
default:
LOG_ERR("shub: HTS221 attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_IIS2ICLX_EXT_HTS221 */
/*
* LPS22HB baro/temp device specific part
*/
#ifdef CONFIG_IIS2ICLX_EXT_LPS22HB
#define LPS22HB_CTRL_REG1 0x10
#define LPS22HB_CTRL_REG2 0x11
#define LPS22HB_SW_RESET 0x04
#define LPS22HB_ODR_10HZ 0x20
#define LPS22HB_LPF_EN 0x08
#define LPS22HB_BDU_EN 0x02
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(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(dev, i2c_addr,
LPS22HB_CTRL_REG1, baro_cfg, 1);
return 0;
}
#endif /* CONFIG_IIS2ICLX_EXT_LPS22HB */
/*
* LPS22HH baro/temp device specific part
*/
#ifdef CONFIG_IIS2ICLX_EXT_LPS22HH
#define LPS22HH_CTRL_REG1 0x10
#define LPS22HH_CTRL_REG2 0x11
#define LPS22HH_SW_RESET 0x04
#define LPS22HH_IF_ADD_INC 0x10
#define LPS22HH_ODR_10HZ 0x20
#define LPS22HH_LPF_EN 0x08
#define LPS22HH_BDU_EN 0x02
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(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(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(dev, i2c_addr,
LPS22HH_CTRL_REG1, baro_cfg, 1);
return 0;
}
static const uint16_t lps22hh_map[] = {0, 1, 10, 25, 50, 75, 100, 200};
static int iis2iclx_lps22hh_odr_set(const struct device *dev,
uint8_t i2c_addr, uint16_t freq)
{
uint8_t odr, cfg;
for (odr = 0; odr < ARRAY_SIZE(lps22hh_map); odr++) {
if (freq == lps22hh_map[odr]) {
break;
}
}
if (odr == ARRAY_SIZE(lps22hh_map)) {
LOG_ERR("shub: LPS22HH freq val %d not supported.", freq);
return -ENOTSUP;
}
cfg = (odr << 4) | LPS22HH_LPF_EN | LPS22HH_BDU_EN;
iis2iclx_shub_write_slave_reg(dev, i2c_addr,
LPS22HH_CTRL_REG1, &cfg, 1);
iis2iclx_shub_enable(dev, 1);
return 0;
}
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)
{
switch (attr) {
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2iclx_lps22hh_odr_set(data, i2c_addr, val->val1);
default:
LOG_ERR("shub: LPS22HH attribute not supported.");
return -ENOTSUP;
}
return 0;
}
#endif /* CONFIG_IIS2ICLX_EXT_LPS22HH */
/* List of supported external sensors */
static struct iis2iclx_shub_slist {
enum sensor_channel type;
uint8_t i2c_addr[2];
uint8_t ext_i2c_addr;
uint8_t wai_addr;
uint8_t wai_val;
uint8_t out_data_addr;
uint8_t out_data_len;
uint8_t sh_out_reg;
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[] = {
#if defined(CONFIG_IIS2ICLX_EXT_LIS2MDL) || defined(CONFIG_IIS2ICLX_EXT_IIS2MDC)
{
/* LIS2MDL */
.type = SENSOR_CHAN_MAGN_XYZ,
.i2c_addr = { 0x1E },
.wai_addr = 0x4F,
.wai_val = 0x40,
.out_data_addr = 0x68,
.out_data_len = 0x06,
.dev_init = (iis2iclx_lis2mdl_init),
.dev_conf = (iis2iclx_lis2mdl_conf),
},
#endif /* CONFIG_IIS2ICLX_EXT_LIS2MDL || CONFIG_IIS2ICLX_EXT_IIS2MDC */
#ifdef CONFIG_IIS2ICLX_EXT_HTS221
{
/* HTS221 */
.type = SENSOR_CHAN_HUMIDITY,
.i2c_addr = { 0x5F },
.wai_addr = 0x0F,
.wai_val = 0xBC,
.out_data_addr = 0x28 | HTS221_AUTOINCREMENT,
.out_data_len = 0x02,
.dev_init = (iis2iclx_hts221_init),
.dev_conf = (iis2iclx_hts221_conf),
},
#endif /* CONFIG_IIS2ICLX_EXT_HTS221 */
#ifdef CONFIG_IIS2ICLX_EXT_LPS22HB
{
/* LPS22HB */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB1,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (iis2iclx_lps22hb_init),
},
#endif /* CONFIG_IIS2ICLX_EXT_LPS22HB */
#ifdef CONFIG_IIS2ICLX_EXT_LPS22HH
{
/* LPS22HH */
.type = SENSOR_CHAN_PRESS,
.i2c_addr = { 0x5C, 0x5D },
.wai_addr = 0x0F,
.wai_val = 0xB3,
.out_data_addr = 0x28,
.out_data_len = 0x05,
.dev_init = (iis2iclx_lps22hh_init),
.dev_conf = (iis2iclx_lps22hh_conf),
},
#endif /* CONFIG_IIS2ICLX_EXT_LPS22HH */
};
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((stmdev_ctx_t *)&cfg->ctx, &status);
} while (status.sens_hub_endop == 0);
}
static inline void iis2iclx_shub_embedded_en(const struct iis2iclx_config *cfg,
bool on)
{
if (on) {
(void) iis2iclx_mem_bank_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_SENSOR_HUB_BANK);
} else {
(void) iis2iclx_mem_bank_set((stmdev_ctx_t *)&cfg->ctx,
IIS2ICLX_USER_BANK);
}
k_busy_wait(150);
}
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(cfg, true);
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(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
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(cfg, true);
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(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
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((stmdev_ctx_t *)&cfg->ctx, odr) < 0) {
LOG_DBG("shub: failed to set XL sampling rate");
return;
}
}
iis2iclx_shub_embedded_en(cfg, true);
if (iis2iclx_sh_master_set((stmdev_ctx_t *)&cfg->ctx, enable) < 0) {
LOG_DBG("shub: failed to set master on");
iis2iclx_shub_embedded_en(cfg, false);
return;
}
iis2iclx_shub_embedded_en(cfg, false);
}
/* must be called with master on */
static int iis2iclx_shub_check_slv0_nack(const struct iis2iclx_config *cfg)
{
uint8_t status;
if (iis2iclx_shub_read_embedded_regs(cfg, IIS2ICLX_SHUB_STATUS_MASTER,
&status, 1) < 0) {
LOG_ERR("shub: error reading embedded reg");
return -EIO;
}
if (status & (IIS2ICLX_SHUB_STATUS_SLV0_NACK)) {
LOG_ERR("shub: SLV0 nacked");
return -EIO;
}
return 0;
}
/*
* use SLV0 for generic read to slave device
*/
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(cfg, IIS2ICLX_SHUB_SLV0_ADDR,
slave, 3) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
/* turn SH on */
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
if (iis2iclx_shub_check_slv0_nack(cfg) < 0) {
iis2iclx_shub_enable(dev, 0);
return -EIO;
}
/* read data from external slave */
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(cfg, false);
return -EIO;
}
iis2iclx_shub_embedded_en(cfg, false);
iis2iclx_shub_enable(dev, 0);
return 0;
}
/*
* use SLV0 to configure slave device
*/
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;
while (cnt < len) {
slv_cfg[0] = (slv_addr << 1) & ~IIS2ICLX_SHUB_SLVX_READ;
slv_cfg[1] = slv_reg + cnt;
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV0_ADDR,
slv_cfg, 2) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
slv_cfg[0] = value[cnt];
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV0_DATAWRITE,
slv_cfg, 1) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
/* turn SH on */
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
if (iis2iclx_shub_check_slv0_nack(cfg) < 0) {
iis2iclx_shub_enable(dev, 0);
return -EIO;
}
iis2iclx_shub_enable(dev, 0);
cnt++;
}
/* Put SLV0 in IDLE mode */
slv_cfg[0] = 0x7;
slv_cfg[1] = 0x0;
slv_cfg[2] = 0x0;
if (iis2iclx_shub_write_embedded_regs(cfg, IIS2ICLX_SHUB_SLV0_ADDR,
slv_cfg, 3) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
return 0;
}
/*
* SLAVEs configurations:
*
* - SLAVE 0: used for configuring all slave devices
* - SLAVE 1: used as data read channel for external slave device #1
* - 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(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
const struct iis2iclx_config *cfg = dev->config;
uint8_t n, i, slv_cfg[6];
struct iis2iclx_shub_slist *sp;
/* Set data channel for slave devices */
for (n = 0; n < data->num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[data->shub_ext[n]];
i = n * 3;
slv_cfg[i] = (sp->ext_i2c_addr << 1) | IIS2ICLX_SHUB_SLVX_READ;
slv_cfg[i + 1] = sp->out_data_addr;
slv_cfg[i + 2] = sp->out_data_len;
}
if (iis2iclx_shub_write_embedded_regs(cfg,
IIS2ICLX_SHUB_SLV1_ADDR,
slv_cfg, n*3) < 0) {
LOG_ERR("shub: error writing embedded reg");
return -EIO;
}
/* Configure the master */
iis2iclx_aux_sens_on_t aux = IIS2ICLX_SLV_0_1_2;
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((stmdev_ctx_t *)&cfg->ctx, wo) < 0) {
LOG_ERR("shub: error setting write once");
return -EIO;
}
/* turn SH on */
iis2iclx_shub_enable(dev, 1);
iis2iclx_shub_wait_completed(cfg);
return 0;
}
int iis2iclx_shub_get_idx(const struct device *dev, enum sensor_channel type)
{
uint8_t n;
struct iis2iclx_shub_slist *sp;
struct iis2iclx_data *data = dev->data;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[data->shub_ext[n]];
if (sp->type == type) {
return n;
}
}
return -ENOTSUP;
}
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(cfg, true);
for (n = 0; n < data->num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[data->shub_ext[n]];
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(cfg, false);
return -EIO;
}
}
iis2iclx_shub_embedded_en(cfg, false);
return 0;
}
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;
for (n = 0; n < data->num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[data->shub_ext[n]];
if (sp->type == chan) {
break;
}
}
if (n == data->num_ext_dev) {
LOG_ERR("shub: chan not supported");
return -ENOTSUP;
}
if (sp == NULL || sp->dev_conf == NULL) {
LOG_ERR("shub: chan not configurable");
return -ENOTSUP;
}
return sp->dev_conf(dev, sp->ext_i2c_addr, chan, attr, val);
}
int iis2iclx_shub_init(const struct device *dev)
{
uint8_t i, n = 0, regn;
uint8_t chip_id;
struct iis2iclx_shub_slist *sp;
struct iis2iclx_data *data = dev->data;
LOG_INF("shub: start sensorhub for %s", dev->name);
for (n = 0; n < ARRAY_SIZE(iis2iclx_shub_slist); n++) {
if (data->num_ext_dev >= IIS2ICLX_SHUB_MAX_NUM_SLVS) {
break;
}
chip_id = 0;
sp = &iis2iclx_shub_slist[n];
/*
* The external sensor may have different I2C address.
* So, try them one by one until we read the correct
* chip ID.
*/
for (i = 0U; i < ARRAY_SIZE(sp->i2c_addr); i++) {
if (iis2iclx_shub_read_slave_reg(dev,
sp->i2c_addr[i],
sp->wai_addr,
&chip_id, 1) < 0) {
continue;
}
if (chip_id == sp->wai_val) {
break;
}
}
if (i >= ARRAY_SIZE(sp->i2c_addr)) {
LOG_DBG("shub: invalid chip id 0x%x", chip_id);
continue;
}
LOG_INF("shub: Ext Device Chip Id: 0x%02x", chip_id);
sp->ext_i2c_addr = sp->i2c_addr[i];
data->shub_ext[data->num_ext_dev++] = n;
}
LOG_DBG("shub: dev %s - num_ext_dev %d", dev->name, data->num_ext_dev);
if (data->num_ext_dev == 0) {
LOG_WRN("shub: no slave devices found");
return -ENOTSUP;
}
/* init external devices */
for (n = 0, regn = 0; n < data->num_ext_dev; n++) {
sp = &iis2iclx_shub_slist[data->shub_ext[n]];
sp->sh_out_reg = IIS2ICLX_SHUB_DATA_OUT + regn;
regn += sp->out_data_len;
sp->dev_init(dev, sp->ext_i2c_addr);
}
iis2iclx_shub_set_data_channel(dev);
return 0;
}
``` | /content/code_sandbox/drivers/sensor/st/iis2iclx/iis2iclx_shub.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 7,388 |
```c
/* ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2iclx
#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <string.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
#include "iis2iclx.h"
LOG_MODULE_REGISTER(IIS2ICLX, CONFIG_SENSOR_LOG_LEVEL);
static const uint16_t iis2iclx_odr_map[] = {0, 12, 26, 52, 104, 208, 416, 833,
1660, 3330, 6660};
static int iis2iclx_freq_to_odr_val(uint16_t freq)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(iis2iclx_odr_map); i++) {
if (freq <= iis2iclx_odr_map[i]) {
return i;
}
}
return -EINVAL;
}
static int iis2iclx_odr_to_freq_val(uint16_t odr)
{
/* for valid index, return value from map */
if (odr < ARRAY_SIZE(iis2iclx_odr_map)) {
return iis2iclx_odr_map[odr];
}
/* invalid index, return last entry */
return iis2iclx_odr_map[ARRAY_SIZE(iis2iclx_odr_map) - 1];
}
static const uint16_t iis2iclx_accel_fs_map[] = {500, 3000, 1000, 2000}; /* fs in mg */
static const uint16_t iis2iclx_accel_fs_sens[] = {1, 8, 2, 4};
static int iis2iclx_accel_range_to_fs_val(int32_t range)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(iis2iclx_accel_fs_map); i++) {
if (range == iis2iclx_accel_fs_map[i]) {
return i;
}
}
return -EINVAL;
}
static inline int iis2iclx_reboot(const struct device *dev)
{
const struct iis2iclx_config *cfg = dev->config;
if (iis2iclx_boot_set((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
return -EIO;
}
/* Wait sensor turn-on time as per datasheet */
k_msleep(35);
return 0;
}
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((stmdev_ctx_t *)&cfg->ctx, fs) < 0) {
return -EIO;
}
data->accel_fs = fs;
return 0;
}
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((stmdev_ctx_t *)&cfg->ctx, odr) < 0) {
return -EIO;
}
data->accel_freq = iis2iclx_odr_to_freq_val(odr);
return 0;
}
static int iis2iclx_accel_odr_set(const struct device *dev, uint16_t freq)
{
int odr;
odr = iis2iclx_freq_to_odr_val(freq);
if (odr < 0) {
return odr;
}
if (iis2iclx_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer sampling rate");
return -EIO;
}
return 0;
}
static int iis2iclx_accel_range_set(const struct device *dev, int32_t range)
{
int fs;
struct iis2iclx_data *data = dev->data;
fs = iis2iclx_accel_range_to_fs_val(range * 1000); /* pass range in mg */
if (fs < 0) {
return fs;
}
if (iis2iclx_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer full-scale");
return -EIO;
}
data->acc_gain = (iis2iclx_accel_fs_sens[fs] * GAIN_UNIT_XL);
return 0;
}
static int iis2iclx_accel_config(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return iis2iclx_accel_range_set(dev, sensor_ms2_to_g(val));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return iis2iclx_accel_odr_set(dev, val->val1);
default:
LOG_ERR("Accel attribute not supported.");
return -ENOTSUP;
}
return 0;
}
static int iis2iclx_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
struct iis2iclx_data *data = dev->data;
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
return iis2iclx_accel_config(dev, chan, attr, val);
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
case SENSOR_CHAN_MAGN_XYZ:
case SENSOR_CHAN_PRESS:
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("shub not inited.");
return -ENOTSUP;
}
return iis2iclx_shub_config(dev, chan, attr, val);
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
default:
LOG_ERR("attr_set() not supported on this channel.");
return -ENOTSUP;
}
return 0;
}
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((stmdev_ctx_t *)&cfg->ctx, buf) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
data->acc[0] = sys_le16_to_cpu(buf[0]);
data->acc[1] = sys_le16_to_cpu(buf[1]);
return 0;
}
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
static int iis2iclx_sample_fetch_temp(const struct device *dev)
{
struct iis2iclx_data *data = dev->data;
const struct iis2iclx_config *cfg = dev->config;
int16_t buf;
if (iis2iclx_temperature_raw_get((stmdev_ctx_t *)&cfg->ctx, &buf) < 0) {
LOG_ERR("Failed to read sample");
return -EIO;
}
data->temp_sample = sys_le16_to_cpu(buf);
return 0;
}
#endif
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
static int iis2iclx_sample_fetch_shub(const struct device *dev)
{
if (iis2iclx_shub_fetch_external_devs(dev) < 0) {
LOG_ERR("failed to read ext shub devices");
return -EIO;
}
return 0;
}
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
static int iis2iclx_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
struct iis2iclx_data *data = dev->data;
#endif /* CONFIG_IIS2ICLX_SENSORHUB */
switch (chan) {
case SENSOR_CHAN_ACCEL_XYZ:
iis2iclx_sample_fetch_accel(dev);
break;
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
iis2iclx_sample_fetch_temp(dev);
break;
#endif
case SENSOR_CHAN_ALL:
iis2iclx_sample_fetch_accel(dev);
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
iis2iclx_sample_fetch_temp(dev);
#endif
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
if (data->shub_inited) {
iis2iclx_sample_fetch_shub(dev);
}
#endif
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void iis2iclx_accel_convert(struct sensor_value *val, int raw_val,
uint32_t sensitivity)
{
int64_t dval;
/* Sensitivity is exposed in ug/LSB */
/* Convert to m/s^2 */
dval = (int64_t)(raw_val) * sensitivity;
sensor_ug_to_ms2(dval, val);
}
static inline int iis2iclx_accel_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct iis2iclx_data *data,
uint32_t sensitivity)
{
uint8_t i;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
iis2iclx_accel_convert(val, data->acc[0], sensitivity);
break;
case SENSOR_CHAN_ACCEL_Y:
iis2iclx_accel_convert(val, data->acc[1], sensitivity);
break;
case SENSOR_CHAN_ACCEL_XYZ:
for (i = 0; i < 2; i++) {
iis2iclx_accel_convert(val++, data->acc[i], sensitivity);
}
break;
default:
return -ENOTSUP;
}
return 0;
}
static int iis2iclx_accel_channel_get(enum sensor_channel chan,
struct sensor_value *val,
struct iis2iclx_data *data)
{
return iis2iclx_accel_get_channel(chan, val, data, data->acc_gain);
}
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
static void iis2iclx_temp_channel_get(struct sensor_value *val,
struct iis2iclx_data *data)
{
/* val = temp_sample / 256 + 25 */
val->val1 = data->temp_sample / 256 + 25;
val->val2 = (data->temp_sample % 256) * (1000000 / 256);
}
#endif
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
static inline void iis2iclx_magn_convert(struct sensor_value *val, int raw_val,
uint16_t sensitivity)
{
double dval;
/* Sensitivity is exposed in ugauss/LSB */
dval = (double)(raw_val * sensitivity);
val->val1 = (int32_t)dval / 1000000;
val->val2 = (int32_t)dval % 1000000;
}
static inline int iis2iclx_magn_get_channel(enum sensor_channel chan,
struct sensor_value *val,
struct iis2iclx_data *data)
{
int16_t sample[3];
int idx;
idx = iis2iclx_shub_get_idx(data->dev, SENSOR_CHAN_MAGN_XYZ);
if (idx < 0) {
LOG_ERR("external magn not supported");
return -ENOTSUP;
}
sample[0] = (int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8));
sample[1] = (int16_t)(data->ext_data[idx][2] |
(data->ext_data[idx][3] << 8));
sample[2] = (int16_t)(data->ext_data[idx][4] |
(data->ext_data[idx][5] << 8));
switch (chan) {
case SENSOR_CHAN_MAGN_X:
iis2iclx_magn_convert(val, sample[0], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Y:
iis2iclx_magn_convert(val, sample[1], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_Z:
iis2iclx_magn_convert(val, sample[2], data->magn_gain);
break;
case SENSOR_CHAN_MAGN_XYZ:
iis2iclx_magn_convert(val, sample[0], data->magn_gain);
iis2iclx_magn_convert(val + 1, sample[1], data->magn_gain);
iis2iclx_magn_convert(val + 2, sample[2], data->magn_gain);
break;
default:
return -ENOTSUP;
}
return 0;
}
static inline void iis2iclx_hum_convert(struct sensor_value *val,
struct iis2iclx_data *data)
{
float rh;
int16_t raw_val;
struct hts221_data *ht = &data->hts221;
int idx;
idx = iis2iclx_shub_get_idx(data->dev, SENSOR_CHAN_HUMIDITY);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = ((int16_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8)));
/* find relative humidty by linear interpolation */
rh = (ht->y1 - ht->y0) * raw_val + ht->x1 * ht->y0 - ht->x0 * ht->y1;
rh /= (ht->x1 - ht->x0);
/* convert humidity to integer and fractional part */
val->val1 = rh;
val->val2 = rh * 1000000;
}
static inline void iis2iclx_press_convert(struct sensor_value *val,
struct iis2iclx_data *data)
{
int32_t raw_val;
int idx;
idx = iis2iclx_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = (int32_t)(data->ext_data[idx][0] |
(data->ext_data[idx][1] << 8) |
(data->ext_data[idx][2] << 16));
/* Pressure sensitivity is 4096 LSB/hPa */
/* Convert raw_val to val in kPa */
val->val1 = (raw_val >> 12) / 10;
val->val2 = (raw_val >> 12) % 10 * 100000 +
(((int32_t)((raw_val) & 0x0FFF) * 100000L) >> 12);
}
static inline void iis2iclx_temp_convert(struct sensor_value *val,
struct iis2iclx_data *data)
{
int16_t raw_val;
int idx;
idx = iis2iclx_shub_get_idx(data->dev, SENSOR_CHAN_PRESS);
if (idx < 0) {
LOG_DBG("external press/temp not supported");
return;
}
raw_val = (int16_t)(data->ext_data[idx][3] |
(data->ext_data[idx][4] << 8));
/* Temperature sensitivity is 100 LSB/deg C */
val->val1 = raw_val / 100;
val->val2 = (int32_t)raw_val % 100 * (10000);
}
#endif
static int iis2iclx_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct iis2iclx_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
iis2iclx_accel_channel_get(chan, val, data);
break;
#if defined(CONFIG_IIS2ICLX_ENABLE_TEMP)
case SENSOR_CHAN_DIE_TEMP:
iis2iclx_temp_channel_get(val, data);
break;
#endif
#if defined(CONFIG_IIS2ICLX_SENSORHUB)
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
iis2iclx_magn_get_channel(chan, val, data);
break;
case SENSOR_CHAN_HUMIDITY:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
iis2iclx_hum_convert(val, data);
break;
case SENSOR_CHAN_PRESS:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
iis2iclx_press_convert(val, data);
break;
case SENSOR_CHAN_AMBIENT_TEMP:
if (!data->shub_inited) {
LOG_ERR("attr_set() shub not inited.");
return -ENOTSUP;
}
iis2iclx_temp_convert(val, data);
break;
#endif
default:
return -ENOTSUP;
}
return 0;
}
static const struct sensor_driver_api iis2iclx_driver_api = {
.attr_set = iis2iclx_attr_set,
#if CONFIG_IIS2ICLX_TRIGGER
.trigger_set = iis2iclx_trigger_set,
#endif
.sample_fetch = iis2iclx_sample_fetch,
.channel_get = iis2iclx_channel_get,
};
static int iis2iclx_init_chip(const struct device *dev)
{
const struct iis2iclx_config * const cfg = dev->config;
struct iis2iclx_data *iis2iclx = dev->data;
uint8_t chip_id;
uint8_t odr = cfg->odr;
uint8_t fs = cfg->range;
iis2iclx->dev = dev;
if (iis2iclx_device_id_get((stmdev_ctx_t *)&cfg->ctx, &chip_id) < 0) {
LOG_ERR("Failed reading chip id");
return -EIO;
}
LOG_INF("chip id 0x%x", chip_id);
if (chip_id != IIS2ICLX_ID) {
LOG_ERR("Invalid chip id 0x%x", chip_id);
return -EIO;
}
/* reset device */
if (iis2iclx_reset_set((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
return -EIO;
}
k_usleep(100);
LOG_DBG("range is %d", fs);
if (iis2iclx_accel_set_fs_raw(dev, fs) < 0) {
LOG_ERR("failed to set accelerometer full-scale");
return -EIO;
}
iis2iclx->acc_gain = (iis2iclx_accel_fs_sens[fs] * GAIN_UNIT_XL);
LOG_DBG("odr is %d", odr);
if (iis2iclx_accel_set_odr_raw(dev, odr) < 0) {
LOG_ERR("failed to set accelerometer sampling rate");
return -EIO;
}
/* Set FIFO bypass mode */
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((stmdev_ctx_t *)&cfg->ctx, 1) < 0) {
LOG_ERR("failed to set BDU mode");
return -EIO;
}
return 0;
}
static int iis2iclx_init(const struct device *dev)
{
#ifdef CONFIG_IIS2ICLX_TRIGGER
const struct iis2iclx_config *cfg = dev->config;
#endif
struct iis2iclx_data *data = dev->data;
LOG_INF("Initialize device %s", dev->name);
data->dev = dev;
if (iis2iclx_init_chip(dev) < 0) {
LOG_ERR("failed to initialize chip");
return -EIO;
}
#ifdef CONFIG_IIS2ICLX_TRIGGER
if (cfg->trig_enabled) {
if (iis2iclx_init_interrupt(dev) < 0) {
LOG_ERR("Failed to initialize interrupt.");
return -EIO;
}
}
#endif
#ifdef CONFIG_IIS2ICLX_SENSORHUB
data->shub_inited = true;
if (iis2iclx_shub_init(dev) < 0) {
LOG_INF("shub: no external chips found");
data->shub_inited = false;
}
#endif
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "IIS2ICLX driver enabled without any devices"
#endif
/*
* Device creation macro, shared by IIS2ICLX_DEFINE_SPI() and
* IIS2ICLX_DEFINE_I2C().
*/
#define IIS2ICLX_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
iis2iclx_init, \
NULL, \
&iis2iclx_data_##inst, \
&iis2iclx_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&iis2iclx_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_IIS2ICLX_TRIGGER
#define IIS2ICLX_CFG_IRQ(inst) \
.trig_enabled = true, \
.gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios), \
.int_pin = DT_INST_PROP(inst, int_pin)
#else
#define IIS2ICLX_CFG_IRQ(inst)
#endif /* CONFIG_IIS2ICLX_TRIGGER */
#define IIS2ICLX_CONFIG_COMMON(inst) \
.odr = DT_INST_PROP(inst, odr), \
.range = DT_INST_PROP(inst, range), \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios), \
(IIS2ICLX_CFG_IRQ(inst)), ())
#define IIS2ICLX_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define IIS2ICLX_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&iis2iclx_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
IIS2ICLX_SPI_OPERATION, \
0), \
}, \
IIS2ICLX_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define IIS2ICLX_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&iis2iclx_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
IIS2ICLX_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define IIS2ICLX_DEFINE(inst) \
static struct iis2iclx_data iis2iclx_data_##inst; \
static const struct iis2iclx_config iis2iclx_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(IIS2ICLX_CONFIG_SPI(inst)), \
(IIS2ICLX_CONFIG_I2C(inst))); \
IIS2ICLX_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(IIS2ICLX_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/iis2iclx/iis2iclx.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 5,437 |
```unknown
# ST Microelectronics IIS2ICLX 2-axis accelerometer sensor driver
menuconfig IIS2ICLX
bool "IIS2ICLX I2C/SPI accelerometer Chip"
default y
depends on DT_HAS_ST_IIS2ICLX_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2ICLX),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2ICLX),spi)
select HAS_STMEMSC
select USE_STDC_IIS2ICLX
help
Enable driver for IIS2ICLX accelerometer
sensor.
if IIS2ICLX
choice IIS2ICLX_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config IIS2ICLX_TRIGGER_NONE
bool "No trigger"
config IIS2ICLX_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select IIS2ICLX_TRIGGER
config IIS2ICLX_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select IIS2ICLX_TRIGGER
endchoice
config IIS2ICLX_TRIGGER
bool
if IIS2ICLX_TRIGGER
config IIS2ICLX_THREAD_PRIORITY
int "Thread priority"
depends on IIS2ICLX_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config IIS2ICLX_THREAD_STACK_SIZE
int "Thread stack size"
depends on IIS2ICLX_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # IIS2ICLX_TRIGGER
config IIS2ICLX_ENABLE_TEMP
bool "Temperature"
help
Enable/disable temperature
config IIS2ICLX_SENSORHUB
bool "I2C sensorhub feature"
help
Enable/disable internal sensorhub. You can enable
a maximum of two external sensors (if more than two are enabled
the system would enumerate only the first two found)
if IIS2ICLX_SENSORHUB
config IIS2ICLX_EXT_LIS2MDL
bool "LIS2MDL as external sensor"
config IIS2ICLX_EXT_IIS2MDC
bool "IIS2MDC as external sensor"
config IIS2ICLX_EXT_LPS22HH
bool "LPS22HH as external sensor"
config IIS2ICLX_EXT_HTS221
bool "HTS221 as external sensor"
config IIS2ICLX_EXT_LPS22HB
bool "LPS22HB as external sensor"
endif # IIS2ICLX_SENSORHUB
endif # IIS2ICLX
``` | /content/code_sandbox/drivers/sensor/st/iis2iclx/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 630 |
```objective-c
/* ST Microelectronics LIS2DW12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LIS2DW12_LIS2DW12_H_
#define ZEPHYR_DRIVERS_SENSOR_LIS2DW12_LIS2DW12_H_
#include <zephyr/drivers/spi.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/sensor.h>
#include <stmemsc.h>
#include "lis2dw12_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
/* Return ODR reg value based on data rate set */
#define LIS2DW12_ODR_TO_REG(_odr) \
((_odr <= 1) ? LIS2DW12_XL_ODR_1Hz6_LP_ONLY : \
(_odr <= 12) ? LIS2DW12_XL_ODR_12Hz5 : \
((31 - __builtin_clz(_odr / 25))) + 3)
/* Return data rate in Hz for given register value */
#define LIS2DW12_REG_TO_ODR(_reg) \
((_reg == 0) ? 0 : \
(_reg == 1) ? 1 : \
(_reg == 2) ? 12 : \
(_reg > 9) ? 1600 : \
(1 << (_reg - 3)) * 25)
/* FS reg value from Full Scale */
#define LIS2DW12_FS_TO_REG(_fs) (30 - __builtin_clz(_fs))
/* Acc Gain value in ug/LSB in High Perf mode */
#define LIS2DW12_FS_2G_GAIN 244
#define LIS2DW12_FS_4G_GAIN 488
#define LIS2DW12_FS_8G_GAIN 976
#define LIS2DW12_FS_16G_GAIN 1952
#define LIS2DW12_SHFT_GAIN_NOLP1 2
#define LIS2DW12_ACCEL_GAIN_DEFAULT_VAL LIS2DW12_FS_2G_GAIN
#define LIS2DW12_FS_TO_GAIN(_fs, _lp1) \
(LIS2DW12_FS_2G_GAIN << ((_fs) + (_lp1)))
/* shift value for power mode */
#define LIS2DW12_SHIFT_PM1 4
#define LIS2DW12_SHIFT_PMOTHER 2
/**
* struct lis2dw12_device_config - lis2dw12 hw configuration
* @bus_name: Pointer to bus master identifier.
* @pm: Power mode (lis2dh_powermode).
* @int_pin: Sensor int pin (int1/int2).
*/
struct lis2dw12_device_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
} stmemsc_cfg;
lis2dw12_mode_t pm;
uint16_t odr;
uint8_t range;
uint8_t bw_filt;
bool low_noise;
bool hp_filter_path;
bool hp_ref_mode;
bool drdy_pulsed;
#ifdef CONFIG_LIS2DW12_TRIGGER
struct gpio_dt_spec gpio_int;
uint8_t int_pin;
#ifdef CONFIG_LIS2DW12_TAP
uint8_t tap_mode;
uint8_t tap_threshold[3];
uint8_t tap_shock;
uint8_t tap_latency;
uint8_t tap_quiet;
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_FREEFALL
uint8_t freefall_duration;
uint8_t freefall_threshold;
#endif /* CONFIG_LIS2DW12_FREEFALL */
#ifdef CONFIG_LIS2DW12_THRESHOLD
uint8_t wakeup_duration;
#endif /* CONFIG_LIS2DW12_THRESHOLD */
#endif /* CONFIG_LIS2DW12_TRIGGER */
};
/* sensor data */
struct lis2dw12_data {
int16_t acc[3];
/* save sensitivity */
uint16_t gain;
/* output data rate */
uint16_t odr;
#ifdef CONFIG_LIS2DW12_TRIGGER
const struct device *dev;
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
const struct sensor_trigger *drdy_trig;
#ifdef CONFIG_LIS2DW12_TAP
sensor_trigger_handler_t tap_handler;
const struct sensor_trigger *tap_trig;
sensor_trigger_handler_t double_tap_handler;
const struct sensor_trigger *double_tap_trig;
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_THRESHOLD
sensor_trigger_handler_t threshold_handler;
const struct sensor_trigger *threshold_trig;
#endif /* CONFIG_LIS2DW12_THRESHOLD */
#ifdef CONFIG_LIS2DW12_FREEFALL
sensor_trigger_handler_t freefall_handler;
const struct sensor_trigger *freefall_trig;
#endif /* CONFIG_LIS2DW12_FREEFALL */
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DW12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif /* CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD */
#endif /* CONFIG_LIS2DW12_TRIGGER */
};
#ifdef CONFIG_LIS2DW12_TRIGGER
int lis2dw12_init_interrupt(const struct device *dev);
int lis2dw12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
#endif /* CONFIG_LIS2DW12_TRIGGER */
#endif /* ZEPHYR_DRIVERS_SENSOR_LIS2DW12_LIS2DW12_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lis2dw12/lis2dw12.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,289 |
```unknown
# ST Microelectronics LIS2DW12 3-axis accelerometer driver
menuconfig LIS2DW12
bool "LIS2DW12 I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_LIS2DW12_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DW12),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LIS2DW12),spi)
select HAS_STMEMSC
select USE_STDC_LIS2DW12
help
Enable driver for LIS2DW12 accelerometer sensor driver
if LIS2DW12
choice LIS2DW12_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config LIS2DW12_TRIGGER_NONE
bool "No trigger"
config LIS2DW12_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LIS2DW12_TRIGGER
config LIS2DW12_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LIS2DW12_TRIGGER
endchoice
config LIS2DW12_TRIGGER
bool
if LIS2DW12_TRIGGER
config LIS2DW12_THREAD_PRIORITY
int "Thread priority"
depends on LIS2DW12_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LIS2DW12_THREAD_STACK_SIZE
int "Thread stack size"
depends on LIS2DW12_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config LIS2DW12_TAP
bool "Tap and Tap-Tap detection"
help
Enable tap (single/double) detection
endif # LIS2DW12_TRIGGER
config LIS2DW12_THRESHOLD
bool "Wakeup threshold trigger (via interrupt)"
help
Enable the wakeup threshold trigger feature.
The wake-up interrupt signal is generated if a certain number of
consecutive data exceed the configured threshold (config in DT).
The threshold is applied to both positive and negative data: for
a wake-up interrupt generation at least one of the three axes must
be bigger than the threshold. See ST AN5038 for more details about
the feature.
config LIS2DW12_FREEFALL
bool "Free Fall detection (via interrupt)"
help
Enable freefall detection via interrupt.
endif # LIS2DW12
``` | /content/code_sandbox/drivers/sensor/st/lis2dw12/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 528 |
```c
/* ST Microelectronics LIS2DW12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dw12
#include <zephyr/init.h>
#include <stdlib.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/sensor.h>
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#elif DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif
#include "lis2dw12.h"
LOG_MODULE_REGISTER(LIS2DW12, CONFIG_SENSOR_LOG_LEVEL);
/**
* lis2dw12_set_range - set full scale range for acc
* @dev: Pointer to instance of struct device (I2C or SPI)
* @range: Full scale range (2, 4, 8 and 16 G)
*/
static int lis2dw12_set_range(const struct device *dev, uint8_t fs)
{
int err;
struct lis2dw12_data *lis2dw12 = dev->data;
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t shift_gain = 0U;
err = lis2dw12_full_scale_set(ctx, fs);
if (cfg->pm == LIS2DW12_CONT_LOW_PWR_12bit) {
shift_gain = LIS2DW12_SHFT_GAIN_NOLP1;
}
if (!err) {
/* save internally gain for optimization */
lis2dw12->gain =
LIS2DW12_FS_TO_GAIN(fs, shift_gain);
}
return err;
}
/**
* lis2dw12_set_odr - set new sampling frequency
* @dev: Pointer to instance of struct device (I2C or SPI)
* @odr: Output data rate
*/
static int lis2dw12_set_odr(const struct device *dev, uint16_t odr)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2dw12_data *lis2dw12 = dev->data;
uint8_t val;
/* check if power off */
if (odr == 0U) {
return lis2dw12_data_rate_set(ctx, LIS2DW12_XL_ODR_OFF);
}
val = LIS2DW12_ODR_TO_REG(odr);
if (val > LIS2DW12_XL_ODR_1k6Hz) {
LOG_ERR("ODR too high");
return -ENOTSUP;
}
lis2dw12->odr = odr;
return lis2dw12_data_rate_set(ctx, val);
}
static inline void lis2dw12_convert(struct sensor_value *val, int raw_val,
float gain)
{
int64_t dval;
/* Gain is in ug/LSB */
/* Convert to m/s^2 */
dval = ((int64_t)raw_val * gain * SENSOR_G) / 1000000LL;
val->val1 = dval / 1000000LL;
val->val2 = dval % 1000000LL;
}
static inline void lis2dw12_channel_get_acc(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
int i;
uint8_t ofs_start, ofs_stop;
struct lis2dw12_data *lis2dw12 = dev->data;
struct sensor_value *pval = val;
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
ofs_start = ofs_stop = 0U;
break;
case SENSOR_CHAN_ACCEL_Y:
ofs_start = ofs_stop = 1U;
break;
case SENSOR_CHAN_ACCEL_Z:
ofs_start = ofs_stop = 2U;
break;
default:
ofs_start = 0U; ofs_stop = 2U;
break;
}
for (i = ofs_start; i <= ofs_stop ; i++) {
lis2dw12_convert(pval++, lis2dw12->acc[i], lis2dw12->gain);
}
}
static int lis2dw12_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
lis2dw12_channel_get_acc(dev, chan, val);
return 0;
default:
LOG_DBG("Channel not supported");
break;
}
return -ENOTSUP;
}
static int lis2dw12_config(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
switch (attr) {
case SENSOR_ATTR_FULL_SCALE:
return lis2dw12_set_range(dev,
LIS2DW12_FS_TO_REG(sensor_ms2_to_g(val)));
case SENSOR_ATTR_SAMPLING_FREQUENCY:
return lis2dw12_set_odr(dev, val->val1);
default:
LOG_DBG("Acc attribute not supported");
break;
}
return -ENOTSUP;
}
static inline int32_t sensor_ms2_to_mg(const struct sensor_value *ms2)
{
int64_t nano_ms2 = (ms2->val1 * 1000000LL + ms2->val2) * 1000LL;
if (nano_ms2 > 0) {
return (nano_ms2 + SENSOR_G / 2) / SENSOR_G;
} else {
return (nano_ms2 - SENSOR_G / 2) / SENSOR_G;
}
}
#if CONFIG_LIS2DW12_THRESHOLD
/* Converts a lis2dw12_fs_t range to its value in milli-g
* Range can be 2/4/8/16G
*/
#define FS_RANGE_TO_MG(fs_range) ((2U << fs_range) * 1000U)
/* Converts a range in mg to the lsb value for the WK_THS register
* For the reg value: 1 LSB = 1/64 of FS
* Range can be 2/4/8/16G
*/
#define MG_TO_WK_THS_LSB(range_mg) (range_mg / 64)
/* Calculates the WK_THS reg value
* from the threshold in mg and the lsb value in mg
* with correct integer rounding
*/
#define THRESHOLD_MG_TO_WK_THS_REG(thr_mg, lsb_mg) \
((thr_mg + (lsb_mg / 2)) / lsb_mg)
static int lis2dw12_attr_set_thresh(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
uint8_t reg;
size_t ret;
int lsb_mg;
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
LOG_DBG("%s on channel %d", __func__, chan);
/* can only be set for all directions at once */
if (chan != SENSOR_CHAN_ACCEL_XYZ) {
return -EINVAL;
}
/* Configure wakeup threshold threshold. */
lis2dw12_fs_t range;
int err = lis2dw12_full_scale_get(ctx, &range);
if (err) {
return err;
}
uint32_t thr_mg = abs(sensor_ms2_to_mg(val));
/* Check maximum value: depends on current FS value */
if (thr_mg >= FS_RANGE_TO_MG(range)) {
return -EINVAL;
}
/* The threshold is applied to both positive and negative data:
* for a wake-up interrupt generation at least one of the three axes must be
* bigger than the threshold.
*/
lsb_mg = MG_TO_WK_THS_LSB(FS_RANGE_TO_MG(range));
reg = THRESHOLD_MG_TO_WK_THS_REG(thr_mg, lsb_mg);
LOG_DBG("Threshold %d mg -> fs: %u mg -> reg = %d LSBs",
thr_mg, FS_RANGE_TO_MG(range), reg);
ret = 0;
return lis2dw12_wkup_threshold_set(ctx, reg);
}
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
static int lis2dw12_attr_set_ff_dur(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
int rc;
uint16_t duration;
const struct lis2dw12_device_config *cfg = dev->config;
struct lis2dw12_data *lis2dw12 = dev->data;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
LOG_DBG("%s on channel %d", __func__, chan);
/* can only be set for all directions at once */
if (chan != SENSOR_CHAN_ACCEL_XYZ) {
return -EINVAL;
}
/**
* The given duration in milliseconds with the val
* parameter is converted into register specific value.
*/
duration = (lis2dw12->odr * (uint16_t)sensor_value_to_double(val)) / 1000;
LOG_DBG("Freefall: duration is %d ms", (uint16_t)sensor_value_to_double(val));
rc = lis2dw12_ff_dur_set(ctx, duration);
if (rc != 0) {
LOG_ERR("Failed to set freefall duration");
return -EIO;
}
return rc;
}
#endif
static int lis2dw12_attr_set(const struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
#if CONFIG_LIS2DW12_THRESHOLD
switch (attr) {
case SENSOR_ATTR_UPPER_THRESH:
case SENSOR_ATTR_LOWER_THRESH:
return lis2dw12_attr_set_thresh(dev, chan, attr, val);
default:
/* Do nothing */
break;
}
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
if (attr == SENSOR_ATTR_FF_DUR) {
return lis2dw12_attr_set_ff_dur(dev, chan, attr, val);
}
#endif
switch (chan) {
case SENSOR_CHAN_ACCEL_X:
case SENSOR_CHAN_ACCEL_Y:
case SENSOR_CHAN_ACCEL_Z:
case SENSOR_CHAN_ACCEL_XYZ:
return lis2dw12_config(dev, chan, attr, val);
default:
LOG_DBG("Attr not supported on %d channel", chan);
break;
}
return -ENOTSUP;
}
static int lis2dw12_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct lis2dw12_data *lis2dw12 = dev->data;
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t shift;
int16_t buf[3];
/* fetch raw data sample */
if (lis2dw12_acceleration_raw_get(ctx, buf) < 0) {
LOG_DBG("Failed to fetch raw data sample");
return -EIO;
}
/* adjust to resolution */
if (cfg->pm == LIS2DW12_CONT_LOW_PWR_12bit) {
shift = LIS2DW12_SHIFT_PM1;
} else {
shift = LIS2DW12_SHIFT_PMOTHER;
}
lis2dw12->acc[0] = sys_le16_to_cpu(buf[0]) >> shift;
lis2dw12->acc[1] = sys_le16_to_cpu(buf[1]) >> shift;
lis2dw12->acc[2] = sys_le16_to_cpu(buf[2]) >> shift;
return 0;
}
static const struct sensor_driver_api lis2dw12_driver_api = {
.attr_set = lis2dw12_attr_set,
#if CONFIG_LIS2DW12_TRIGGER
.trigger_set = lis2dw12_trigger_set,
#endif /* CONFIG_LIS2DW12_TRIGGER */
.sample_fetch = lis2dw12_sample_fetch,
.channel_get = lis2dw12_channel_get,
};
static int lis2dw12_set_power_mode(const struct device *dev,
lis2dw12_mode_t pm)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t regval = LIS2DW12_CONT_LOW_PWR_12bit;
switch (pm) {
case LIS2DW12_CONT_LOW_PWR_2:
case LIS2DW12_CONT_LOW_PWR_3:
case LIS2DW12_CONT_LOW_PWR_4:
case LIS2DW12_HIGH_PERFORMANCE:
regval = pm;
break;
default:
LOG_DBG("Apply default Power Mode");
break;
}
return lis2dw12_write_reg(ctx, LIS2DW12_CTRL1, ®val, 1);
}
static int lis2dw12_set_low_noise(const struct device *dev,
bool low_noise)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dw12_ctrl6_t ctrl6;
int ret;
ret = lis2dw12_read_reg(ctx, LIS2DW12_CTRL6, (uint8_t *)&ctrl6, 1);
if (ret < 0) {
return ret;
}
ctrl6.low_noise = low_noise;
return lis2dw12_write_reg(ctx, LIS2DW12_CTRL6, (uint8_t *)&ctrl6, 1);
}
static int lis2dw12_init(const struct device *dev)
{
const struct lis2dw12_device_config *cfg = dev->config;
struct lis2dw12_data *lis2dw12 = dev->data;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint8_t wai;
int ret;
/* check chip ID */
ret = lis2dw12_device_id_get(ctx, &wai);
if (ret < 0) {
LOG_ERR("Not able to read dev id");
return ret;
}
if (wai != LIS2DW12_ID) {
LOG_ERR("Invalid chip ID");
return -EINVAL;
}
/* reset device */
ret = lis2dw12_reset_set(ctx, PROPERTY_ENABLE);
if (ret < 0) {
return ret;
}
k_busy_wait(100);
ret = lis2dw12_block_data_update_set(ctx, PROPERTY_ENABLE);
if (ret < 0) {
LOG_ERR("Not able to set BDU");
return ret;
}
/* set power mode */
LOG_DBG("power-mode is %d", cfg->pm);
ret = lis2dw12_set_power_mode(dev, cfg->pm);
if (ret < 0) {
return ret;
}
LOG_DBG("low noise is %d", cfg->low_noise);
ret = lis2dw12_set_low_noise(dev, cfg->low_noise);
if (ret < 0) {
LOG_ERR("Failed to configure low_noise");
return ret;
}
/* set the output data rate */
ret = lis2dw12_set_odr(dev, cfg->odr);
if (ret < 0) {
LOG_ERR("odr init error %d", cfg->odr);
return ret;
}
lis2dw12->odr = cfg->odr;
LOG_DBG("range is %d", cfg->range);
ret = lis2dw12_set_range(dev, LIS2DW12_FS_TO_REG(cfg->range));
if (ret < 0) {
LOG_ERR("range init error %d", cfg->range);
return ret;
}
LOG_DBG("bandwidth filter is %u", (int)cfg->bw_filt);
lis2dw12_filter_bandwidth_set(ctx, cfg->bw_filt);
#ifdef CONFIG_LIS2DW12_TRIGGER
ret = lis2dw12_init_interrupt(dev);
if (ret < 0) {
LOG_ERR("Failed to initialize interrupts");
return ret;
}
#endif /* CONFIG_LIS2DW12_TRIGGER */
LOG_DBG("high pass reference mode is %d", (int)cfg->hp_ref_mode);
ret = lis2dw12_reference_mode_set(ctx, cfg->hp_ref_mode);
if (ret < 0) {
LOG_ERR("high pass reference mode config error %d", (int)cfg->hp_ref_mode);
return ret;
}
LOG_DBG("high pass filter path is %d", (int)cfg->hp_filter_path);
lis2dw12_fds_t fds = cfg->hp_filter_path ?
LIS2DW12_HIGH_PASS_ON_OUT : LIS2DW12_LPF_ON_OUT;
ret = lis2dw12_filter_path_set(ctx, fds);
if (ret < 0) {
LOG_ERR("filter path config error %d", (int)cfg->hp_filter_path);
return ret;
}
#ifdef CONFIG_LIS2DW12_THRESHOLD
ret = lis2dw12_wkup_dur_set(ctx, cfg->wakeup_duration);
if (ret < 0) {
LOG_ERR("wakeup duration config error %d", ret);
return ret;
}
#endif /* CONFIG_LIS2DW12_THRESHOLD */
return 0;
}
#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "LIS2DW12 driver enabled without any devices"
#endif
/*
* Device creation macro, shared by LIS2DW12_DEFINE_SPI() and
* LIS2DW12_DEFINE_I2C().
*/
#define LIS2DW12_DEVICE_INIT(inst) \
SENSOR_DEVICE_DT_INST_DEFINE(inst, \
lis2dw12_init, \
NULL, \
&lis2dw12_data_##inst, \
&lis2dw12_config_##inst, \
POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&lis2dw12_driver_api);
/*
* Instantiation macros used when a device is on a SPI bus.
*/
#ifdef CONFIG_LIS2DW12_TAP
#define LIS2DW12_CONFIG_TAP(inst) \
.tap_mode = DT_INST_PROP(inst, tap_mode), \
.tap_threshold = DT_INST_PROP(inst, tap_threshold), \
.tap_shock = DT_INST_PROP(inst, tap_shock), \
.tap_latency = DT_INST_PROP(inst, tap_latency), \
.tap_quiet = DT_INST_PROP(inst, tap_quiet),
#else
#define LIS2DW12_CONFIG_TAP(inst)
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_FREEFALL
#define LIS2DW12_CONFIG_FREEFALL(inst) \
.freefall_duration = DT_INST_PROP(inst, ff_duration), \
.freefall_threshold = DT_INST_PROP(inst, ff_threshold),
#else
#define LIS2DW12_CONFIG_FREEFALL(inst)
#endif /* CONFIG_LIS2DW12_FREEFALL */
#ifdef CONFIG_LIS2DW12_THRESHOLD
#define LIS2DW12_CONFIG_THRESHOLD(inst) \
.wakeup_duration = DT_INST_PROP(inst, wakeup_duration),
#else
#define LIS2DW12_CONFIG_THRESHOLD(inst)
#endif
#ifdef CONFIG_LIS2DW12_TRIGGER
#define LIS2DW12_CFG_IRQ(inst) \
.gpio_int = GPIO_DT_SPEC_INST_GET(inst, irq_gpios), \
.int_pin = DT_INST_PROP(inst, int_pin),
#else
#define LIS2DW12_CFG_IRQ(inst)
#endif /* CONFIG_LIS2DW12_TRIGGER */
#define LIS2DW12_CONFIG_COMMON(inst) \
.pm = DT_INST_PROP(inst, power_mode), \
.odr = DT_INST_PROP_OR(inst, odr, 12), \
.range = DT_INST_PROP(inst, range), \
.bw_filt = DT_INST_PROP(inst, bw_filt), \
.low_noise = DT_INST_PROP(inst, low_noise), \
.hp_filter_path = DT_INST_PROP(inst, hp_filter_path), \
.hp_ref_mode = DT_INST_PROP(inst, hp_ref_mode), \
.drdy_pulsed = DT_INST_PROP(inst, drdy_pulsed), \
LIS2DW12_CONFIG_TAP(inst) \
LIS2DW12_CONFIG_FREEFALL(inst) \
LIS2DW12_CONFIG_THRESHOLD(inst) \
COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, irq_gpios), \
(LIS2DW12_CFG_IRQ(inst)), ())
#define LIS2DW12_SPI_OPERATION (SPI_WORD_SET(8) | \
SPI_OP_MODE_MASTER | \
SPI_MODE_CPOL | \
SPI_MODE_CPHA) \
#define LIS2DW12_CONFIG_SPI(inst) \
{ \
STMEMSC_CTX_SPI(&lis2dw12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.spi = SPI_DT_SPEC_INST_GET(inst, \
LIS2DW12_SPI_OPERATION, \
0), \
}, \
LIS2DW12_CONFIG_COMMON(inst) \
}
/*
* Instantiation macros used when a device is on an I2C bus.
*/
#define LIS2DW12_CONFIG_I2C(inst) \
{ \
STMEMSC_CTX_I2C(&lis2dw12_config_##inst.stmemsc_cfg), \
.stmemsc_cfg = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}, \
LIS2DW12_CONFIG_COMMON(inst) \
}
/*
* Main instantiation macro. Use of COND_CODE_1() selects the right
* bus-specific macro at preprocessor time.
*/
#define LIS2DW12_DEFINE(inst) \
static struct lis2dw12_data lis2dw12_data_##inst; \
static const struct lis2dw12_device_config lis2dw12_config_##inst = \
COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
(LIS2DW12_CONFIG_SPI(inst)), \
(LIS2DW12_CONFIG_I2C(inst))); \
LIS2DW12_DEVICE_INIT(inst)
DT_INST_FOREACH_STATUS_OKAY(LIS2DW12_DEFINE)
``` | /content/code_sandbox/drivers/sensor/st/lis2dw12/lis2dw12.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,849 |
```c
/* ST Microelectronics LIS2DW12 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lis2dw12
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lis2dw12.h"
LOG_MODULE_DECLARE(LIS2DW12, CONFIG_SENSOR_LOG_LEVEL);
/**
* lis2dw12_enable_int - enable selected int pin to generate interrupt
*/
static int lis2dw12_enable_int(const struct device *dev,
enum sensor_trigger_type type, int enable)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dw12_reg_t int_route;
switch (type) {
case SENSOR_TRIG_DATA_READY:
if (cfg->int_pin == 1) {
/* set interrupt for pin INT1 */
lis2dw12_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_drdy = enable;
return lis2dw12_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
} else {
/* set interrupt for pin INT2 */
lis2dw12_pin_int2_route_get(ctx,
&int_route.ctrl5_int2_pad_ctrl);
int_route.ctrl5_int2_pad_ctrl.int2_drdy = enable;
return lis2dw12_pin_int2_route_set(ctx,
&int_route.ctrl5_int2_pad_ctrl);
}
break;
#ifdef CONFIG_LIS2DW12_TAP
case SENSOR_TRIG_TAP:
/* set interrupt for pin INT1 */
lis2dw12_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_single_tap = enable;
return lis2dw12_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
case SENSOR_TRIG_DOUBLE_TAP:
/* set interrupt for pin INT1 */
lis2dw12_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_tap = enable;
return lis2dw12_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_THRESHOLD
/**
* Trigger fires when channel reading transitions configured
* thresholds. The thresholds are configured via the @ref
* SENSOR_ATTR_LOWER_THRESH and @ref SENSOR_ATTR_UPPER_THRESH
* attributes.
*/
case SENSOR_TRIG_THRESHOLD:
LOG_DBG("Setting int1_wu: %d\n", enable);
lis2dw12_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_wu = enable;
return lis2dw12_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
/**
* Trigger fires when the readings does not include Earth's
* gravitional force for configured duration and threshold.
* The duration and the threshold can be configured in the
* devicetree source of the accelerometer node.
*/
case SENSOR_TRIG_FREEFALL:
LOG_DBG("Setting int1_ff: %d\n", enable);
lis2dw12_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_ff = enable;
return lis2dw12_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
#endif /* CONFIG_LIS2DW12_FREEFALL */
default:
LOG_ERR("Unsupported trigger interrupt route %d", type);
return -ENOTSUP;
}
}
/**
* lis2dw12_trigger_set - link external trigger to event data ready
*/
int lis2dw12_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
struct lis2dw12_data *lis2dw12 = dev->data;
int16_t raw[3];
int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
if (cfg->gpio_int.port == NULL) {
LOG_ERR("trigger_set is not supported");
return -ENOTSUP;
}
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
lis2dw12->drdy_handler = handler;
lis2dw12->drdy_trig = trig;
if (state) {
/* dummy read: re-trigger interrupt */
lis2dw12_acceleration_raw_get(ctx, raw);
}
return lis2dw12_enable_int(dev, SENSOR_TRIG_DATA_READY, state);
break;
#ifdef CONFIG_LIS2DW12_TAP
case SENSOR_TRIG_TAP:
case SENSOR_TRIG_DOUBLE_TAP:
/* check if tap detection is enabled */
if ((cfg->tap_threshold[0] == 0) &&
(cfg->tap_threshold[1] == 0) &&
(cfg->tap_threshold[2] == 0)) {
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
/* Set single TAP trigger */
if (trig->type == SENSOR_TRIG_TAP) {
lis2dw12->tap_handler = handler;
lis2dw12->tap_trig = trig;
return lis2dw12_enable_int(dev, SENSOR_TRIG_TAP, state);
}
/* Set double TAP trigger */
lis2dw12->double_tap_handler = handler;
lis2dw12->double_tap_trig = trig;
return lis2dw12_enable_int(dev, SENSOR_TRIG_DOUBLE_TAP, state);
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_THRESHOLD
case SENSOR_TRIG_THRESHOLD:
{
LOG_DBG("Set trigger %d (handler: %p)\n", trig->type, handler);
lis2dw12->threshold_handler = handler;
lis2dw12->threshold_trig = trig;
return lis2dw12_enable_int(dev, SENSOR_TRIG_THRESHOLD, state);
}
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
case SENSOR_TRIG_FREEFALL:
LOG_DBG("Set freefall %d (handler: %p)\n", trig->type, handler);
lis2dw12->freefall_handler = handler;
lis2dw12->freefall_trig = trig;
return lis2dw12_enable_int(dev, SENSOR_TRIG_FREEFALL, state);
break;
#endif /* CONFIG_LIS2DW12_FREEFALL */
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
}
static int lis2dw12_handle_drdy_int(const struct device *dev)
{
struct lis2dw12_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
#ifdef CONFIG_LIS2DW12_TAP
static int lis2dw12_handle_single_tap_int(const struct device *dev)
{
struct lis2dw12_data *data = dev->data;
sensor_trigger_handler_t handler = data->tap_handler;
if (handler) {
handler(dev, data->tap_trig);
}
return 0;
}
static int lis2dw12_handle_double_tap_int(const struct device *dev)
{
struct lis2dw12_data *data = dev->data;
sensor_trigger_handler_t handler = data->double_tap_handler;
if (handler) {
handler(dev, data->double_tap_trig);
}
return 0;
}
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_THRESHOLD
static int lis2dw12_handle_wu_ia_int(const struct device *dev)
{
struct lis2dw12_data *lis2dw12 = dev->data;
sensor_trigger_handler_t handler = lis2dw12->threshold_handler;
if (handler) {
handler(dev, lis2dw12->threshold_trig);
}
return 0;
}
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
static int lis2dw12_handle_ff_ia_int(const struct device *dev)
{
struct lis2dw12_data *lis2dw12 = dev->data;
sensor_trigger_handler_t handler = lis2dw12->freefall_handler;
if (handler) {
handler(dev, lis2dw12->freefall_trig);
}
return 0;
}
#endif /* CONFIG_LIS2DW12_FREEFALL */
/**
* lis2dw12_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lis2dw12_handle_interrupt(const struct device *dev)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lis2dw12_all_sources_t sources;
lis2dw12_all_sources_get(ctx, &sources);
if (sources.status_dup.drdy) {
lis2dw12_handle_drdy_int(dev);
}
#ifdef CONFIG_LIS2DW12_TAP
if (sources.status_dup.single_tap) {
lis2dw12_handle_single_tap_int(dev);
}
if (sources.status_dup.double_tap) {
lis2dw12_handle_double_tap_int(dev);
}
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_THRESHOLD
if (sources.all_int_src.wu_ia) {
lis2dw12_handle_wu_ia_int(dev);
}
#endif
#ifdef CONFIG_LIS2DW12_FREEFALL
if (sources.all_int_src.ff_ia) {
lis2dw12_handle_ff_ia_int(dev);
}
#endif /* CONFIG_LIS2DW12_FREEFALL */
gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void lis2dw12_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lis2dw12_data *lis2dw12 =
CONTAINER_OF(cb, struct lis2dw12_data, gpio_cb);
const struct lis2dw12_device_config *cfg = lis2dw12->dev->config;
if ((pins & BIT(cfg->gpio_int.pin)) == 0U) {
return;
}
gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
k_sem_give(&lis2dw12->gpio_sem);
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lis2dw12->work);
#endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_LIS2DW12_TRIGGER_OWN_THREAD
static void lis2dw12_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lis2dw12_data *lis2dw12 = p1;
while (1) {
k_sem_take(&lis2dw12->gpio_sem, K_FOREVER);
lis2dw12_handle_interrupt(lis2dw12->dev);
}
}
#endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD
static void lis2dw12_work_cb(struct k_work *work)
{
struct lis2dw12_data *lis2dw12 =
CONTAINER_OF(work, struct lis2dw12_data, work);
lis2dw12_handle_interrupt(lis2dw12->dev);
}
#endif /* CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD */
#ifdef CONFIG_LIS2DW12_TAP
static int lis2dw12_tap_init(const struct device *dev)
{
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
LOG_DBG("TAP: tap mode is %d", cfg->tap_mode);
if (lis2dw12_tap_mode_set(ctx, cfg->tap_mode) < 0) {
LOG_ERR("Failed to select tap trigger mode");
return -EIO;
}
LOG_DBG("TAP: ths_x is %02x", cfg->tap_threshold[0]);
if (lis2dw12_tap_threshold_x_set(ctx, cfg->tap_threshold[0]) < 0) {
LOG_ERR("Failed to set tap X axis threshold");
return -EIO;
}
LOG_DBG("TAP: ths_y is %02x", cfg->tap_threshold[1]);
if (lis2dw12_tap_threshold_y_set(ctx, cfg->tap_threshold[1]) < 0) {
LOG_ERR("Failed to set tap Y axis threshold");
return -EIO;
}
LOG_DBG("TAP: ths_z is %02x", cfg->tap_threshold[2]);
if (lis2dw12_tap_threshold_z_set(ctx, cfg->tap_threshold[2]) < 0) {
LOG_ERR("Failed to set tap Z axis threshold");
return -EIO;
}
if (cfg->tap_threshold[0] > 0) {
LOG_DBG("TAP: tap_x enabled");
if (lis2dw12_tap_detection_on_x_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on X axis");
return -EIO;
}
}
if (cfg->tap_threshold[1] > 0) {
LOG_DBG("TAP: tap_y enabled");
if (lis2dw12_tap_detection_on_y_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on Y axis");
return -EIO;
}
}
if (cfg->tap_threshold[2] > 0) {
LOG_DBG("TAP: tap_z enabled");
if (lis2dw12_tap_detection_on_z_set(ctx, 1) < 0) {
LOG_ERR("Failed to set tap detection on Z axis");
return -EIO;
}
}
LOG_DBG("TAP: shock is %02x", cfg->tap_shock);
if (lis2dw12_tap_shock_set(ctx, cfg->tap_shock) < 0) {
LOG_ERR("Failed to set tap shock duration");
return -EIO;
}
LOG_DBG("TAP: latency is %02x", cfg->tap_latency);
if (lis2dw12_tap_dur_set(ctx, cfg->tap_latency) < 0) {
LOG_ERR("Failed to set tap latency");
return -EIO;
}
LOG_DBG("TAP: quiet time is %02x", cfg->tap_quiet);
if (lis2dw12_tap_quiet_set(ctx, cfg->tap_quiet) < 0) {
LOG_ERR("Failed to set tap quiet time");
return -EIO;
}
return 0;
}
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_FREEFALL
static int lis2dw12_ff_init(const struct device *dev)
{
int rc;
const struct lis2dw12_device_config *cfg = dev->config;
struct lis2dw12_data *lis2dw12 = dev->data;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint16_t duration;
duration = (lis2dw12->odr * cfg->freefall_duration) / 1000;
LOG_DBG("FREEFALL: duration is %d ms", cfg->freefall_duration);
rc = lis2dw12_ff_dur_set(ctx, duration);
if (rc != 0) {
LOG_ERR("Failed to set freefall duration");
return -EIO;
}
LOG_DBG("FREEFALL: threshold is %02x", cfg->freefall_threshold);
rc = lis2dw12_ff_threshold_set(ctx, cfg->freefall_threshold);
if (rc != 0) {
LOG_ERR("Failed to set freefall thrshold");
return -EIO;
}
return 0;
}
#endif /* CONFIG_LIS2DW12_FREEFALL */
int lis2dw12_init_interrupt(const struct device *dev)
{
struct lis2dw12_data *lis2dw12 = dev->data;
const struct lis2dw12_device_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_int)) {
if (cfg->gpio_int.port) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->gpio_int.port->name);
return -ENODEV;
}
LOG_DBG("%s: gpio_int not defined in DT", dev->name);
return 0;
}
lis2dw12->dev = dev;
LOG_INF("%s: int-pin is on INT%d", dev->name, cfg->int_pin);
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
k_sem_init(&lis2dw12->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lis2dw12->thread, lis2dw12->thread_stack,
CONFIG_LIS2DW12_THREAD_STACK_SIZE,
lis2dw12_thread, lis2dw12,
NULL, NULL, K_PRIO_COOP(CONFIG_LIS2DW12_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)
lis2dw12->work.handler = lis2dw12_work_cb;
#endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
LOG_INF("%s: int on %s.%02u", dev->name, cfg->gpio_int.port->name,
cfg->gpio_int.pin);
gpio_init_callback(&lis2dw12->gpio_cb,
lis2dw12_gpio_callback,
BIT(cfg->gpio_int.pin));
if (gpio_add_callback(cfg->gpio_int.port, &lis2dw12->gpio_cb) < 0) {
LOG_DBG("Could not set gpio callback");
return -EIO;
}
/* set data ready mode on int1/int2 */
LOG_DBG("drdy_pulsed is %d", (int)cfg->drdy_pulsed);
lis2dw12_drdy_pulsed_t mode = cfg->drdy_pulsed ? LIS2DW12_DRDY_PULSED :
LIS2DW12_DRDY_LATCHED;
ret = lis2dw12_data_ready_mode_set(ctx, mode);
if (ret < 0) {
LOG_ERR("drdy_pulsed config error %d", (int)cfg->drdy_pulsed);
return ret;
}
#ifdef CONFIG_LIS2DW12_TAP
ret = lis2dw12_tap_init(dev);
if (ret < 0) {
return ret;
}
#endif /* CONFIG_LIS2DW12_TAP */
#ifdef CONFIG_LIS2DW12_FREEFALL
ret = lis2dw12_ff_init(dev);
if (ret < 0) {
return ret;
}
#endif /* CONFIG_LIS2DW12_FREEFALL */
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lis2dw12/lis2dw12_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 4,357 |
```c
/*
*
*/
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/adc.h>
#include <zephyr/logging/log.h>
#include <zephyr/pm/device_runtime.h>
#include <stm32_ll_adc.h>
#if defined(CONFIG_SOC_SERIES_STM32H5X)
#include <stm32_ll_icache.h>
#endif /* CONFIG_SOC_SERIES_STM32H5X */
LOG_MODULE_REGISTER(stm32_temp, CONFIG_SENSOR_LOG_LEVEL);
#define CAL_RES 12
#if DT_HAS_COMPAT_STATUS_OKAY(st_stm32_temp)
#define DT_DRV_COMPAT st_stm32_temp
#elif DT_HAS_COMPAT_STATUS_OKAY(st_stm32_temp_cal)
#define DT_DRV_COMPAT st_stm32_temp_cal
#define HAS_DUAL_CALIBRATION 1
#elif DT_HAS_COMPAT_STATUS_OKAY(st_stm32c0_temp_cal)
#define DT_DRV_COMPAT st_stm32c0_temp_cal
#define HAS_SINGLE_CALIBRATION 1
#else
#error "No compatible devicetree node found"
#endif
#if defined(HAS_SINGLE_CALIBRATION) || defined(HAS_DUAL_CALIBRATION)
#define HAS_CALIBRATION 1
#endif
struct stm32_temp_data {
const struct device *adc;
const struct adc_channel_cfg adc_cfg;
ADC_TypeDef *adc_base;
struct adc_sequence adc_seq;
struct k_mutex mutex;
int16_t sample_buffer;
int16_t raw; /* raw adc Sensor value */
};
struct stm32_temp_config {
#if HAS_CALIBRATION
uint16_t *cal1_addr;
int cal1_temp;
#if HAS_DUAL_CALIBRATION
uint16_t *cal2_addr;
int cal2_temp;
#else
int avgslope;
#endif
int cal_vrefanalog;
int ts_cal_shift;
#else
int avgslope;
int v25_mv;
#endif
bool is_ntc;
};
static int stm32_temp_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct stm32_temp_data *data = dev->data;
struct adc_sequence *sp = &data->adc_seq;
int rc;
uint32_t path;
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
k_mutex_lock(&data->mutex, K_FOREVER);
pm_device_runtime_get(data->adc);
rc = adc_channel_setup(data->adc, &data->adc_cfg);
if (rc) {
LOG_DBG("Setup AIN%u got %d", data->adc_cfg.channel_id, rc);
goto unlock;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
LL_ADC_PATH_INTERNAL_TEMPSENSOR | path);
k_usleep(LL_ADC_DELAY_TEMPSENSOR_STAB_US);
rc = adc_read(data->adc, sp);
if (rc == 0) {
data->raw = data->sample_buffer;
}
path = LL_ADC_GetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base));
LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(data->adc_base),
path &= ~LL_ADC_PATH_INTERNAL_TEMPSENSOR);
unlock:
pm_device_runtime_put(data->adc);
k_mutex_unlock(&data->mutex);
return rc;
}
static int stm32_temp_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct stm32_temp_data *data = dev->data;
const struct stm32_temp_config *cfg = dev->config;
float temp;
if (chan != SENSOR_CHAN_DIE_TEMP) {
return -ENOTSUP;
}
#if HAS_CALIBRATION
#if defined(CONFIG_SOC_SERIES_STM32H5X)
LL_ICACHE_Disable();
#endif /* CONFIG_SOC_SERIES_STM32H5X */
temp = ((float)data->raw * adc_ref_internal(data->adc)) / cfg->cal_vrefanalog;
temp -= (*cfg->cal1_addr >> cfg->ts_cal_shift);
#if HAS_SINGLE_CALIBRATION
if (cfg->is_ntc) {
temp = -temp;
}
temp /= (cfg->avgslope * 4096) / (cfg->cal_vrefanalog * 1000);
#else
temp *= (cfg->cal2_temp - cfg->cal1_temp);
temp /= ((*cfg->cal2_addr - *cfg->cal1_addr) >> cfg->ts_cal_shift);
#endif
temp += cfg->cal1_temp;
#if defined(CONFIG_SOC_SERIES_STM32H5X)
LL_ICACHE_Enable();
#endif /* CONFIG_SOC_SERIES_STM32H5X */
#else
/* Sensor value in millivolts */
int32_t mv = data->raw * adc_ref_internal(data->adc) / 0x0FFF;
if (cfg->is_ntc) {
temp = (float)(cfg->v25_mv - mv);
} else {
temp = (float)(mv - cfg->v25_mv);
}
temp = (temp / cfg->avgslope) * 10;
temp += 25;
#endif
return sensor_value_from_float(val, temp);
}
static const struct sensor_driver_api stm32_temp_driver_api = {
.sample_fetch = stm32_temp_sample_fetch,
.channel_get = stm32_temp_channel_get,
};
static int stm32_temp_init(const struct device *dev)
{
struct stm32_temp_data *data = dev->data;
struct adc_sequence *asp = &data->adc_seq;
k_mutex_init(&data->mutex);
if (!device_is_ready(data->adc)) {
LOG_ERR("Device %s is not ready", data->adc->name);
return -ENODEV;
}
*asp = (struct adc_sequence){
.channels = BIT(data->adc_cfg.channel_id),
.buffer = &data->sample_buffer,
.buffer_size = sizeof(data->sample_buffer),
.resolution = 12U,
};
return 0;
}
/**
* Verify that the ADC instance which this driver uses to measure temperature
* is enabled. On STM32 MCUs with more than one ADC, it is possible to compile
* this driver even if the ADC used for measurement is disabled. In such cases,
* fail build with an explicit error message.
*/
#if !DT_NODE_HAS_STATUS(DT_INST_IO_CHANNELS_CTLR(0), okay)
/* Use BUILD_ASSERT to get preprocessing on the message */
BUILD_ASSERT(0, "ADC '" DT_NODE_FULL_NAME(DT_INST_IO_CHANNELS_CTLR(0)) "' needed by "
"temperature sensor '" DT_NODE_FULL_NAME(DT_DRV_INST(0)) "' is not enabled");
/* To reduce noise in the compiler error log, do not attempt
* to instantiate device if the sensor's ADC is not enabled.
*/
#else
static struct stm32_temp_data stm32_temp_dev_data = {
.adc = DEVICE_DT_GET(DT_INST_IO_CHANNELS_CTLR(0)),
.adc_base = (ADC_TypeDef *)DT_REG_ADDR(DT_INST_IO_CHANNELS_CTLR(0)),
.adc_cfg = {
.gain = ADC_GAIN_1,
.reference = ADC_REF_INTERNAL,
.acquisition_time = ADC_ACQ_TIME_MAX,
.channel_id = DT_INST_IO_CHANNELS_INPUT(0),
.differential = 0
},
};
static const struct stm32_temp_config stm32_temp_dev_config = {
#if HAS_CALIBRATION
.cal1_addr = (uint16_t *)DT_INST_PROP(0, ts_cal1_addr),
.cal1_temp = DT_INST_PROP(0, ts_cal1_temp),
#if HAS_DUAL_CALIBRATION
.cal2_addr = (uint16_t *)DT_INST_PROP(0, ts_cal2_addr),
.cal2_temp = DT_INST_PROP(0, ts_cal2_temp),
#else
.avgslope = DT_INST_PROP(0, avgslope),
#endif
.ts_cal_shift = (DT_INST_PROP(0, ts_cal_resolution) - CAL_RES),
.cal_vrefanalog = DT_INST_PROP(0, ts_cal_vrefanalog),
#else
.avgslope = DT_INST_PROP(0, avgslope),
.v25_mv = DT_INST_PROP(0, v25),
#endif
.is_ntc = DT_INST_PROP_OR(0, ntc, false)
};
SENSOR_DEVICE_DT_INST_DEFINE(0, stm32_temp_init, NULL,
&stm32_temp_dev_data, &stm32_temp_dev_config,
POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY,
&stm32_temp_driver_api);
#endif /* !DT_NODE_HAS_STATUS(DT_INST_IO_CHANNELS_CTLR(0), okay) */
``` | /content/code_sandbox/drivers/sensor/st/stm32_temp/stm32_temp.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,834 |
```unknown
# STM32 temperature sensor configuration options
config STM32_TEMP
bool "STM32 Temperature Sensor"
default y
depends on SOC_FAMILY_STM32
depends on DT_HAS_ST_STM32_ADC_ENABLED
depends on DT_HAS_ST_STM32_TEMP_ENABLED || \
DT_HAS_ST_STM32_TEMP_CAL_ENABLED || \
DT_HAS_ST_STM32C0_TEMP_CAL_ENABLED
select ADC
help
Enable driver for STM32 temperature sensor.
``` | /content/code_sandbox/drivers/sensor/st/stm32_temp/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 97 |
```objective-c
/* ST Microelectronics LPS22HH pressure and temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_LPS22HH_LPS22HH_H_
#define ZEPHYR_DRIVERS_SENSOR_LPS22HH_LPS22HH_H_
#include <stdint.h>
#include <stmemsc.h>
#include "lps22hh_reg.h"
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
#include <zephyr/drivers/spi.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(spi) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
#include <zephyr/drivers/i2c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
#include <zephyr/drivers/i3c.h>
#endif /* DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c) */
struct lps22hh_config {
stmdev_ctx_t ctx;
union {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
const struct i2c_dt_spec i2c;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
const struct spi_dt_spec spi;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
struct i3c_device_desc **i3c;
#endif
} stmemsc_cfg;
uint8_t odr;
#ifdef CONFIG_LPS22HH_TRIGGER
struct gpio_dt_spec gpio_int;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
struct {
const struct device *bus;
const struct i3c_device_id dev_id;
} i3c;
#endif
};
struct lps22hh_data {
int32_t sample_press;
int16_t sample_temp;
#ifdef CONFIG_LPS22HH_TRIGGER
struct gpio_callback gpio_cb;
const struct sensor_trigger *data_ready_trigger;
sensor_trigger_handler_t handler_drdy;
const struct device *dev;
#if defined(CONFIG_LPS22HH_TRIGGER_OWN_THREAD)
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LPS22HH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem intr_sem;
#elif defined(CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD)
struct k_work work;
#endif
#endif /* CONFIG_LPS22HH_TRIGGER */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
struct i3c_device_desc *i3c_dev;
#endif
};
#ifdef CONFIG_LPS22HH_TRIGGER
int lps22hh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler);
int lps22hh_init_interrupt(const struct device *dev);
#endif
#endif /* ZEPHYR_DRIVERS_SENSOR_LPS22HH_LPS22HH_H_ */
``` | /content/code_sandbox/drivers/sensor/st/lps22hh/lps22hh.h | objective-c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 588 |
```unknown
# ST Microelectronics LPS22HH pressure and temperature sensor
menuconfig LPS22HH
bool "LPS22HH pressure and temperature"
default y
depends on DT_HAS_ST_LPS22HH_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LPS22HH),i2c)
select I3C if $(dt_compat_on_bus,$(DT_COMPAT_ST_LPS22HH),i3c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_LPS22HH),spi)
select HAS_STMEMSC
select USE_STDC_LPS22HH
help
Enable driver for LPS22HH I2C-based pressure and temperature
sensor.
if LPS22HH
choice LPS22HH_TRIGGER_MODE
prompt "Trigger mode"
default LPS22HH_TRIGGER_GLOBAL_THREAD
help
Specify the type of triggering to be used by the driver.
config LPS22HH_TRIGGER_NONE
bool "No trigger"
config LPS22HH_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select LPS22HH_TRIGGER
config LPS22HH_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select LPS22HH_TRIGGER
endchoice # LPS22HH_TRIGGER_MODE
config LPS22HH_TRIGGER
bool
config LPS22HH_THREAD_PRIORITY
int "Thread priority"
depends on LPS22HH_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config LPS22HH_THREAD_STACK_SIZE
int "Thread stack size"
depends on LPS22HH_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
endif # LPS22HH
``` | /content/code_sandbox/drivers/sensor/st/lps22hh/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 389 |
```c
/* ST Microelectronics LPS22HH pressure and temperature sensor
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_lps22hh
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "lps22hh.h"
LOG_MODULE_DECLARE(LPS22HH, CONFIG_SENSOR_LOG_LEVEL);
/**
* lps22hh_enable_int - enable selected int pin to generate interrupt
*/
static int lps22hh_enable_int(const struct device *dev, int enable)
{
const struct lps22hh_config * const cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
lps22hh_pin_int_route_t int_route;
/* set interrupt */
lps22hh_pin_int_route_get(ctx, &int_route);
int_route.drdy_pres = enable;
return lps22hh_pin_int_route_set(ctx, &int_route);
}
/**
* lps22hh_trigger_set - link external trigger to event data ready
*/
int lps22hh_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct lps22hh_data *lps22hh = dev->data;
const struct lps22hh_config * const cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
uint32_t raw_press;
if (trig->chan == SENSOR_CHAN_ALL) {
lps22hh->handler_drdy = handler;
lps22hh->data_ready_trigger = trig;
if (handler) {
/* dummy read: re-trigger interrupt */
if (lps22hh_pressure_raw_get(ctx, &raw_press) < 0) {
LOG_DBG("Failed to read sample");
return -EIO;
}
return lps22hh_enable_int(dev, 1);
} else {
return lps22hh_enable_int(dev, 0);
}
}
return -ENOTSUP;
}
/**
* lps22hh_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void lps22hh_handle_interrupt(const struct device *dev)
{
int ret;
struct lps22hh_data *lps22hh = dev->data;
const struct lps22hh_config *cfg = dev->config;
if (lps22hh->handler_drdy != NULL) {
lps22hh->handler_drdy(dev, lps22hh->data_ready_trigger);
}
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
if (cfg->i3c.bus != NULL) {
/*
* I3C IBI does not rely on GPIO.
* So no need to enable GPIO pin for interrupt trigger.
*/
return;
}
#endif
ret = gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
}
static void lps22hh_intr_callback(struct lps22hh_data *lps22hh)
{
#if defined(CONFIG_LPS22HH_TRIGGER_OWN_THREAD)
k_sem_give(&lps22hh->intr_sem);
#elif defined(CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD)
k_work_submit(&lps22hh->work);
#endif /* CONFIG_LPS22HH_TRIGGER_OWN_THREAD */
}
static void lps22hh_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct lps22hh_data *lps22hh =
CONTAINER_OF(cb, struct lps22hh_data, gpio_cb);
ARG_UNUSED(pins);
const struct lps22hh_config *cfg = lps22hh->dev->config;
int ret;
ret = gpio_pin_interrupt_configure_dt(&cfg->gpio_int, GPIO_INT_DISABLE);
if (ret < 0) {
LOG_ERR("%s: Not able to configure pin_int", dev->name);
}
lps22hh_intr_callback(lps22hh);
}
#ifdef CONFIG_LPS22HH_TRIGGER_OWN_THREAD
static void lps22hh_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct lps22hh_data *lps22hh = p1;
while (1) {
k_sem_take(&lps22hh->intr_sem, K_FOREVER);
lps22hh_handle_interrupt(lps22hh->dev);
}
}
#endif /* CONFIG_LPS22HH_TRIGGER_OWN_THREAD */
#ifdef CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD
static void lps22hh_work_cb(struct k_work *work)
{
struct lps22hh_data *lps22hh =
CONTAINER_OF(work, struct lps22hh_data, work);
lps22hh_handle_interrupt(lps22hh->dev);
}
#endif /* CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
static int lps22hh_ibi_cb(struct i3c_device_desc *target,
struct i3c_ibi_payload *payload)
{
const struct device *dev = target->dev;
struct lps22hh_data *lps22hh = dev->data;
ARG_UNUSED(payload);
lps22hh_intr_callback(lps22hh);
return 0;
}
#endif
int lps22hh_init_interrupt(const struct device *dev)
{
struct lps22hh_data *lps22hh = dev->data;
const struct lps22hh_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
/* setup data ready gpio interrupt */
if (!gpio_is_ready_dt(&cfg->gpio_int)
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
&& (cfg->i3c.bus == NULL)
#endif
) {
if (cfg->gpio_int.port) {
LOG_ERR("%s: device %s is not ready", dev->name,
cfg->gpio_int.port->name);
return -ENODEV;
}
LOG_DBG("%s: gpio_int not defined in DT", dev->name);
return 0;
}
lps22hh->dev = dev;
#if defined(CONFIG_LPS22HH_TRIGGER_OWN_THREAD)
k_sem_init(&lps22hh->intr_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&lps22hh->thread, lps22hh->thread_stack,
CONFIG_LPS22HH_THREAD_STACK_SIZE,
lps22hh_thread, lps22hh,
NULL, NULL, K_PRIO_COOP(CONFIG_LPS22HH_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD)
lps22hh->work.handler = lps22hh_work_cb;
#endif /* CONFIG_LPS22HH_TRIGGER_OWN_THREAD */
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
if (cfg->i3c.bus == NULL)
#endif
{
ret = gpio_pin_configure_dt(&cfg->gpio_int, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
LOG_INF("%s: int on %s.%02u", dev->name, cfg->gpio_int.port->name,
cfg->gpio_int.pin);
gpio_init_callback(&lps22hh->gpio_cb,
lps22hh_gpio_callback,
BIT(cfg->gpio_int.pin));
ret = gpio_add_callback(cfg->gpio_int.port, &lps22hh->gpio_cb);
if (ret < 0) {
LOG_ERR("Could not set gpio callback");
return ret;
}
}
/* enable interrupt in pulse mode */
if (lps22hh_int_notification_set(ctx, LPS22HH_INT_PULSED) < 0) {
return -EIO;
}
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c)
if (cfg->i3c.bus != NULL) {
/* I3C IBI does not utilize GPIO interrupt. */
lps22hh->i3c_dev->ibi_cb = lps22hh_ibi_cb;
if (i3c_ibi_enable(lps22hh->i3c_dev) != 0) {
LOG_DBG("Could not enable I3C IBI");
return -EIO;
}
return 0;
}
#endif
return gpio_pin_interrupt_configure_dt(&cfg->gpio_int,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/lps22hh/lps22hh_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 1,872 |
```c
/* ST Microelectronics IIS2DLPC 3-axis accelerometer driver
*
*
*
* Datasheet:
* path_to_url
*/
#define DT_DRV_COMPAT st_iis2dlpc
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/logging/log.h>
#include "iis2dlpc.h"
LOG_MODULE_DECLARE(IIS2DLPC, CONFIG_SENSOR_LOG_LEVEL);
/**
* iis2dlpc_enable_int - enable selected int pin to generate interrupt
*/
static int iis2dlpc_enable_int(const struct device *dev,
enum sensor_trigger_type type, int enable)
{
const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis2dlpc_reg_t int_route;
switch (type) {
case SENSOR_TRIG_DATA_READY:
if (cfg->drdy_int == 1) {
/* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_drdy = enable;
return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
} else {
/* set interrupt for pin INT2 */
iis2dlpc_pin_int2_route_get(ctx,
&int_route.ctrl5_int2_pad_ctrl);
int_route.ctrl5_int2_pad_ctrl.int2_drdy = enable;
return iis2dlpc_pin_int2_route_set(ctx,
&int_route.ctrl5_int2_pad_ctrl);
}
break;
#ifdef CONFIG_IIS2DLPC_TAP
case SENSOR_TRIG_TAP:
/* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_single_tap = enable;
return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
case SENSOR_TRIG_DOUBLE_TAP:
/* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_tap = enable;
return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
#endif /* CONFIG_IIS2DLPC_TAP */
#ifdef CONFIG_IIS2DLPC_ACTIVITY
case SENSOR_TRIG_DELTA:
/* set interrupt for pin INT1 */
iis2dlpc_pin_int1_route_get(ctx,
&int_route.ctrl4_int1_pad_ctrl);
int_route.ctrl4_int1_pad_ctrl.int1_wu = enable;
iis2dlpc_act_mode_set(ctx, enable ? IIS2DLPC_DETECT_ACT_INACT
: IIS2DLPC_NO_DETECTION);
return iis2dlpc_pin_int1_route_set(ctx,
&int_route.ctrl4_int1_pad_ctrl);
#endif /* CONFIG_IIS2DLPC_ACTIVITY */
default:
LOG_ERR("Unsupported trigger interrupt route %d", type);
return -ENOTSUP;
}
}
/**
* iis2dlpc_trigger_set - link external trigger to event data ready
*/
int iis2dlpc_trigger_set(const struct device *dev,
const struct sensor_trigger *trig,
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;
int16_t raw[3];
int state = (handler != NULL) ? PROPERTY_ENABLE : PROPERTY_DISABLE;
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
iis2dlpc->drdy_handler = handler;
iis2dlpc->drdy_trig = trig;
if (state) {
/* dummy read: re-trigger interrupt */
iis2dlpc_acceleration_raw_get(ctx, raw);
}
return iis2dlpc_enable_int(dev, SENSOR_TRIG_DATA_READY, state);
#ifdef CONFIG_IIS2DLPC_TAP
case SENSOR_TRIG_TAP:
iis2dlpc->tap_handler = handler;
iis2dlpc->tap_trig = trig;
return iis2dlpc_enable_int(dev, SENSOR_TRIG_TAP, state);
case SENSOR_TRIG_DOUBLE_TAP:
iis2dlpc->double_tap_handler = handler;
iis2dlpc->double_tap_trig = trig;
return iis2dlpc_enable_int(dev, SENSOR_TRIG_DOUBLE_TAP, state);
#endif /* CONFIG_IIS2DLPC_TAP */
#ifdef CONFIG_IIS2DLPC_ACTIVITY
case SENSOR_TRIG_DELTA:
iis2dlpc->activity_handler = handler;
iis2dlpc->activity_trig = trig;
return iis2dlpc_enable_int(dev, SENSOR_TRIG_DELTA, state);
#endif /* CONFIG_IIS2DLPC_ACTIVITY */
default:
LOG_ERR("Unsupported sensor trigger");
return -ENOTSUP;
}
}
static int iis2dlpc_handle_drdy_int(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
if (data->drdy_handler) {
data->drdy_handler(dev, data->drdy_trig);
}
return 0;
}
#ifdef CONFIG_IIS2DLPC_ACTIVITY
static int iis2dlpc_handle_activity_int(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
sensor_trigger_handler_t handler = data->activity_handler;
if (handler) {
handler(dev, data->activity_trig);
}
return 0;
}
#endif /* CONFIG_IIS2DLPC_ACTIVITY */
#ifdef CONFIG_IIS2DLPC_TAP
static int iis2dlpc_handle_single_tap_int(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
sensor_trigger_handler_t handler = data->tap_handler;
if (handler) {
handler(dev, data->tap_trig);
}
return 0;
}
static int iis2dlpc_handle_double_tap_int(const struct device *dev)
{
struct iis2dlpc_data *data = dev->data;
sensor_trigger_handler_t handler = data->double_tap_handler;
if (handler) {
handler(dev, data->double_tap_trig);
}
return 0;
}
#endif /* CONFIG_IIS2DLPC_TAP */
/**
* iis2dlpc_handle_interrupt - handle the drdy event
* read data and call handler if registered any
*/
static void iis2dlpc_handle_interrupt(const struct device *dev)
{
const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
iis2dlpc_all_sources_t sources;
iis2dlpc_all_sources_get(ctx, &sources);
if (sources.status_dup.drdy) {
iis2dlpc_handle_drdy_int(dev);
}
#ifdef CONFIG_IIS2DLPC_TAP
if (sources.status_dup.single_tap) {
iis2dlpc_handle_single_tap_int(dev);
}
if (sources.status_dup.double_tap) {
iis2dlpc_handle_double_tap_int(dev);
}
#endif /* CONFIG_IIS2DLPC_TAP */
#ifdef CONFIG_IIS2DLPC_ACTIVITY
if (sources.all_int_src.wu_ia) {
iis2dlpc_handle_activity_int(dev);
}
#endif /* CONFIG_IIS2DLPC_ACTIVITY */
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
static void iis2dlpc_gpio_callback(const struct device *dev,
struct gpio_callback *cb, uint32_t pins)
{
struct iis2dlpc_data *iis2dlpc =
CONTAINER_OF(cb, struct iis2dlpc_data, gpio_cb);
const struct iis2dlpc_config *cfg = iis2dlpc->dev->config;
ARG_UNUSED(pins);
gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy, GPIO_INT_DISABLE);
#if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD)
k_sem_give(&iis2dlpc->gpio_sem);
#elif defined(CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD)
k_work_submit(&iis2dlpc->work);
#endif /* CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD */
}
#ifdef CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD
static void iis2dlpc_thread(void *p1, void *p2, void *p3)
{
ARG_UNUSED(p2);
ARG_UNUSED(p3);
struct iis2dlpc_data *iis2dlpc = p1;
while (1) {
k_sem_take(&iis2dlpc->gpio_sem, K_FOREVER);
iis2dlpc_handle_interrupt(iis2dlpc->dev);
}
}
#endif /* CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD */
#ifdef CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD
static void iis2dlpc_work_cb(struct k_work *work)
{
struct iis2dlpc_data *iis2dlpc =
CONTAINER_OF(work, struct iis2dlpc_data, work);
iis2dlpc_handle_interrupt(iis2dlpc->dev);
}
#endif /* CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD */
int iis2dlpc_init_interrupt(const struct device *dev)
{
struct iis2dlpc_data *iis2dlpc = dev->data;
const struct iis2dlpc_config *cfg = dev->config;
stmdev_ctx_t *ctx = (stmdev_ctx_t *)&cfg->ctx;
int ret;
/* setup data ready gpio interrupt (INT1 or INT2) */
if (!gpio_is_ready_dt(&cfg->gpio_drdy)) {
LOG_ERR("Cannot get pointer to drdy_gpio device");
return -EINVAL;
}
#if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD)
k_sem_init(&iis2dlpc->gpio_sem, 0, K_SEM_MAX_LIMIT);
k_thread_create(&iis2dlpc->thread, iis2dlpc->thread_stack,
CONFIG_IIS2DLPC_THREAD_STACK_SIZE,
iis2dlpc_thread, iis2dlpc,
NULL, NULL, K_PRIO_COOP(CONFIG_IIS2DLPC_THREAD_PRIORITY),
0, K_NO_WAIT);
#elif defined(CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD)
iis2dlpc->work.handler = iis2dlpc_work_cb;
#endif /* CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD */
ret = gpio_pin_configure_dt(&cfg->gpio_drdy, GPIO_INPUT);
if (ret < 0) {
LOG_ERR("Could not configure gpio");
return ret;
}
gpio_init_callback(&iis2dlpc->gpio_cb,
iis2dlpc_gpio_callback,
BIT(cfg->gpio_drdy.pin));
if (gpio_add_callback(cfg->gpio_drdy.port, &iis2dlpc->gpio_cb) < 0) {
LOG_ERR("Could not set gpio callback");
return -EIO;
}
/* enable interrupt on int1/int2 in pulse mode */
if (iis2dlpc_int_notification_set(ctx, IIS2DLPC_INT_PULSED)) {
LOG_ERR("Could not set pulse mode");
return -EIO;
}
return gpio_pin_interrupt_configure_dt(&cfg->gpio_drdy,
GPIO_INT_EDGE_TO_ACTIVE);
}
``` | /content/code_sandbox/drivers/sensor/st/iis2dlpc/iis2dlpc_trigger.c | c | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 2,569 |
```unknown
# ST Microelectronics IIS2DLPC 3-axis accelerometer driver
menuconfig IIS2DLPC
bool "IIS2DLPC I2C/SPI accelerometer sensor driver"
default y
depends on DT_HAS_ST_IIS2DLPC_ENABLED
depends on ZEPHYR_HAL_ST_MODULE
select I2C if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2DLPC),i2c)
select SPI if $(dt_compat_on_bus,$(DT_COMPAT_ST_IIS2DLPC),spi)
select HAS_STMEMSC
select USE_STDC_IIS2DLPC
help
Enable driver for IIS2DLPC accelerometer sensor driver
if IIS2DLPC
choice IIS2DLPC_TRIGGER_MODE
prompt "Trigger mode"
help
Specify the type of triggering to be used by the driver.
config IIS2DLPC_TRIGGER_NONE
bool "No trigger"
config IIS2DLPC_TRIGGER_GLOBAL_THREAD
bool "Use global thread"
depends on GPIO
select IIS2DLPC_TRIGGER
config IIS2DLPC_TRIGGER_OWN_THREAD
bool "Use own thread"
depends on GPIO
select IIS2DLPC_TRIGGER
endchoice
config IIS2DLPC_TRIGGER
bool
if IIS2DLPC_TRIGGER
config IIS2DLPC_THREAD_PRIORITY
int "Thread priority"
depends on IIS2DLPC_TRIGGER_OWN_THREAD
default 10
help
Priority of thread used by the driver to handle interrupts.
config IIS2DLPC_THREAD_STACK_SIZE
int "Thread stack size"
depends on IIS2DLPC_TRIGGER_OWN_THREAD
default 1024
help
Stack size of thread used by the driver to handle interrupts.
config IIS2DLPC_TAP
bool "Tap and Tap-Tap detection"
help
Enable tap (single/double) detection
config IIS2DLPC_ACTIVITY
bool "Activity detection"
help
Enable activity/inactivity detection
endif # IIS2DLPC_TRIGGER
endif # IIS2DLPC
``` | /content/code_sandbox/drivers/sensor/st/iis2dlpc/Kconfig | unknown | 2016-05-26T17:54:19 | 2024-08-16T18:09:06 | zephyr | zephyrproject-rtos/zephyr | 10,307 | 438 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.