sensor.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
#define ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_
 
#include <errno.h>
#include <stdlib.h>
 
#include <zephyr/device.h>
#include <zephyr/drivers/sensor_data_types.h>
#include <zephyr/dsp/types.h>
#include <zephyr/rtio/rtio.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct sensor_value {
        int32_t val1;
        int32_t val2;
};
 
enum sensor_channel {
        SENSOR_CHAN_ACCEL_X,
        SENSOR_CHAN_ACCEL_Y,
        SENSOR_CHAN_ACCEL_Z,
        SENSOR_CHAN_ACCEL_XYZ,
        SENSOR_CHAN_GYRO_X,
        SENSOR_CHAN_GYRO_Y,
        SENSOR_CHAN_GYRO_Z,
        SENSOR_CHAN_GYRO_XYZ,
        SENSOR_CHAN_MAGN_X,
        SENSOR_CHAN_MAGN_Y,
        SENSOR_CHAN_MAGN_Z,
        SENSOR_CHAN_MAGN_XYZ,
        SENSOR_CHAN_DIE_TEMP,
        SENSOR_CHAN_AMBIENT_TEMP,
        SENSOR_CHAN_PRESS,
        SENSOR_CHAN_PROX,
        SENSOR_CHAN_HUMIDITY,
        SENSOR_CHAN_LIGHT,
        SENSOR_CHAN_IR,
        SENSOR_CHAN_RED,
        SENSOR_CHAN_GREEN,
        SENSOR_CHAN_BLUE,
        SENSOR_CHAN_ALTITUDE,
 
        SENSOR_CHAN_PM_1_0,
        SENSOR_CHAN_PM_2_5,
        SENSOR_CHAN_PM_10,
        SENSOR_CHAN_DISTANCE,
 
        SENSOR_CHAN_CO2,
        SENSOR_CHAN_O2,
        SENSOR_CHAN_VOC,
        SENSOR_CHAN_GAS_RES,
 
        SENSOR_CHAN_VOLTAGE,
 
        SENSOR_CHAN_VSHUNT,
 
        SENSOR_CHAN_CURRENT,
        SENSOR_CHAN_POWER,
 
        SENSOR_CHAN_RESISTANCE,
 
        SENSOR_CHAN_ROTATION,
 
        SENSOR_CHAN_POS_DX,
        SENSOR_CHAN_POS_DY,
        SENSOR_CHAN_POS_DZ,
        SENSOR_CHAN_POS_DXYZ,
 
        SENSOR_CHAN_RPM,
 
        SENSOR_CHAN_GAUGE_VOLTAGE,
        SENSOR_CHAN_GAUGE_AVG_CURRENT,
        SENSOR_CHAN_GAUGE_STDBY_CURRENT,
        SENSOR_CHAN_GAUGE_MAX_LOAD_CURRENT,
        SENSOR_CHAN_GAUGE_TEMP,
        SENSOR_CHAN_GAUGE_STATE_OF_CHARGE,
        SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY,
        SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY,
        SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY,
        SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY,
        SENSOR_CHAN_GAUGE_AVG_POWER,
        SENSOR_CHAN_GAUGE_STATE_OF_HEALTH,
        SENSOR_CHAN_GAUGE_TIME_TO_EMPTY,
        SENSOR_CHAN_GAUGE_TIME_TO_FULL,
        SENSOR_CHAN_GAUGE_CYCLE_COUNT,
        SENSOR_CHAN_GAUGE_DESIGN_VOLTAGE,
        SENSOR_CHAN_GAUGE_DESIRED_VOLTAGE,
        SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT,
 
        SENSOR_CHAN_ALL,
 
        SENSOR_CHAN_COMMON_COUNT,
 
        SENSOR_CHAN_PRIV_START = SENSOR_CHAN_COMMON_COUNT,
 
        SENSOR_CHAN_MAX = INT16_MAX,
};
 
enum sensor_trigger_type {
        SENSOR_TRIG_TIMER,
        SENSOR_TRIG_DATA_READY,
        SENSOR_TRIG_DELTA,
        SENSOR_TRIG_NEAR_FAR,
        SENSOR_TRIG_THRESHOLD,
 
        SENSOR_TRIG_TAP,
 
        SENSOR_TRIG_DOUBLE_TAP,
 
        SENSOR_TRIG_FREEFALL,
 
        SENSOR_TRIG_MOTION,
 
        SENSOR_TRIG_STATIONARY,
 
        SENSOR_TRIG_FIFO_WATERMARK,
 
        SENSOR_TRIG_FIFO_FULL,
        SENSOR_TRIG_COMMON_COUNT,
 
        SENSOR_TRIG_PRIV_START = SENSOR_TRIG_COMMON_COUNT,
 
        SENSOR_TRIG_MAX = INT16_MAX,
};
 
struct sensor_trigger {
        enum sensor_trigger_type type;
        enum sensor_channel chan;
};
 
enum sensor_attribute {
        SENSOR_ATTR_SAMPLING_FREQUENCY,
        SENSOR_ATTR_LOWER_THRESH,
        SENSOR_ATTR_UPPER_THRESH,
        SENSOR_ATTR_SLOPE_TH,
        SENSOR_ATTR_SLOPE_DUR,
        /* Hysteresis for trigger thresholds. */
        SENSOR_ATTR_HYSTERESIS,
        SENSOR_ATTR_OVERSAMPLING,
        SENSOR_ATTR_FULL_SCALE,
        SENSOR_ATTR_OFFSET,
        SENSOR_ATTR_CALIB_TARGET,
        SENSOR_ATTR_CONFIGURATION,
        SENSOR_ATTR_CALIBRATION,
        SENSOR_ATTR_FEATURE_MASK,
        SENSOR_ATTR_ALERT,
        SENSOR_ATTR_FF_DUR,
 
        SENSOR_ATTR_BATCH_DURATION,
 
        SENSOR_ATTR_COMMON_COUNT,
 
        SENSOR_ATTR_PRIV_START = SENSOR_ATTR_COMMON_COUNT,
 
        SENSOR_ATTR_MAX = INT16_MAX,
};
 
typedef void (*sensor_trigger_handler_t)(const struct device *dev,
                                         const struct sensor_trigger *trigger);
 
typedef int (*sensor_attr_set_t)(const struct device *dev,
                                 enum sensor_channel chan,
                                 enum sensor_attribute attr,
                                 const struct sensor_value *val);
 
typedef int (*sensor_attr_get_t)(const struct device *dev,
                                 enum sensor_channel chan,
                                 enum sensor_attribute attr,
                                 struct sensor_value *val);
 
typedef int (*sensor_trigger_set_t)(const struct device *dev,
                                    const struct sensor_trigger *trig,
                                    sensor_trigger_handler_t handler);
typedef int (*sensor_sample_fetch_t)(const struct device *dev,
                                     enum sensor_channel chan);
typedef int (*sensor_channel_get_t)(const struct device *dev,
                                    enum sensor_channel chan,
                                    struct sensor_value *val);
 
struct sensor_chan_spec {
        uint16_t chan_type; 
        uint16_t chan_idx;  
};
 
/* Ensure sensor_chan_spec is sensibly sized to pass by value */
BUILD_ASSERT(sizeof(struct sensor_chan_spec) <= sizeof(uintptr_t),
             "sensor_chan_spec size should be equal or less than the size of a machine word");
static inline bool sensor_chan_spec_eq(struct sensor_chan_spec chan_spec0,
                                       struct sensor_chan_spec chan_spec1)
{
        return chan_spec0.chan_type == chan_spec1.chan_type &&
                chan_spec0.chan_idx == chan_spec1.chan_idx;
}
 
struct sensor_decoder_api {
        int (*get_frame_count)(const uint8_t *buffer, struct sensor_chan_spec channel,
                               uint16_t *frame_count);
 
        int (*get_size_info)(struct sensor_chan_spec channel, size_t *base_size,
                             size_t *frame_size);
 
        int (*decode)(const uint8_t *buffer, struct sensor_chan_spec channel, uint32_t *fit,
                      uint16_t max_count, void *data_out);
 
        bool (*has_trigger)(const uint8_t *buffer, enum sensor_trigger_type trigger);
};
 
struct sensor_decode_context {
        const struct sensor_decoder_api *decoder;
        const uint8_t *buffer;
        struct sensor_chan_spec channel;
        uint32_t fit;
};
 
#define SENSOR_DECODE_CONTEXT_INIT(decoder_, buffer_, channel_type_, channel_index_)               \
        {                                                                                          \
                .decoder = (decoder_),                                                             \
                .buffer = (buffer_),                                                               \
                .channel = {.chan_type = (channel_type_), .chan_idx = (channel_index_)},           \
                .fit = 0,                                                                          \
        }
 
static inline int sensor_decode(struct sensor_decode_context *ctx, void *out, uint16_t max_count)
{
        return ctx->decoder->decode(ctx->buffer, ctx->channel, &ctx->fit, max_count, out);
}
 
int sensor_natively_supported_channel_size_info(struct sensor_chan_spec channel, size_t *base_size,
                                                size_t *frame_size);
 
typedef int (*sensor_get_decoder_t)(const struct device *dev,
                                    const struct sensor_decoder_api **api);
 
enum sensor_stream_data_opt {
        SENSOR_STREAM_DATA_INCLUDE = 0,
        SENSOR_STREAM_DATA_NOP = 1,
        SENSOR_STREAM_DATA_DROP = 2,
};
 
struct sensor_stream_trigger {
        enum sensor_trigger_type trigger;
        enum sensor_stream_data_opt opt;
};
 
#define SENSOR_STREAM_TRIGGER_PREP(_trigger, _opt)                                                 \
        {                                                                                          \
                .trigger = (_trigger), .opt = (_opt),                                              \
        }
 
/*
 * Internal data structure used to store information about the IODevice for async reading and
 * streaming sensor data.
 */
struct sensor_read_config {
        const struct device *sensor;
        const bool is_streaming;
        union {
                struct sensor_chan_spec *const channels;
                struct sensor_stream_trigger *const triggers;
        };
        size_t count;
        const size_t max;
};
 
#define SENSOR_DT_READ_IODEV(name, dt_node, ...)                                                   \
        static struct sensor_chan_spec _CONCAT(__channel_array_, name)[] = {__VA_ARGS__};          \
        static struct sensor_read_config _CONCAT(__sensor_read_config_, name) = {                  \
                .sensor = DEVICE_DT_GET(dt_node),                                                  \
                .is_streaming = false,                                                             \
                .channels = _CONCAT(__channel_array_, name),                                       \
                .count = ARRAY_SIZE(_CONCAT(__channel_array_, name)),                              \
                .max = ARRAY_SIZE(_CONCAT(__channel_array_, name)),                                \
        };                                                                                         \
        RTIO_IODEV_DEFINE(name, &__sensor_iodev_api, _CONCAT(&__sensor_read_config_, name))
 
#define SENSOR_DT_STREAM_IODEV(name, dt_node, ...)                                                 \
        static struct sensor_stream_trigger _CONCAT(__trigger_array_, name)[] = {__VA_ARGS__};     \
        static struct sensor_read_config _CONCAT(__sensor_read_config_, name) = {                  \
                .sensor = DEVICE_DT_GET(dt_node),                                                  \
                .is_streaming = true,                                                              \
                .triggers = _CONCAT(__trigger_array_, name),                                       \
                .count = ARRAY_SIZE(_CONCAT(__trigger_array_, name)),                              \
                .max = ARRAY_SIZE(_CONCAT(__trigger_array_, name)),                                \
        };                                                                                         \
        RTIO_IODEV_DEFINE(name, &__sensor_iodev_api, &_CONCAT(__sensor_read_config_, name))
 
/* Used to submit an RTIO sqe to the sensor's iodev */
typedef void (*sensor_submit_t)(const struct device *sensor, struct rtio_iodev_sqe *sqe);
 
/* The default decoder API */
extern const struct sensor_decoder_api __sensor_default_decoder;
 
/* The default sensor iodev API */
extern const struct rtio_iodev_api __sensor_iodev_api;
 
__subsystem struct sensor_driver_api {
        sensor_attr_set_t attr_set;
        sensor_attr_get_t attr_get;
        sensor_trigger_set_t trigger_set;
        sensor_sample_fetch_t sample_fetch;
        sensor_channel_get_t channel_get;
        sensor_get_decoder_t get_decoder;
        sensor_submit_t submit;
};
 
__syscall int sensor_attr_set(const struct device *dev,
                              enum sensor_channel chan,
                              enum sensor_attribute attr,
                              const struct sensor_value *val);
 
static inline int z_impl_sensor_attr_set(const struct device *dev,
                                         enum sensor_channel chan,
                                         enum sensor_attribute attr,
                                         const struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->attr_set == NULL) {
                return -ENOSYS;
        }
 
        return api->attr_set(dev, chan, attr, val);
}
 
__syscall int sensor_attr_get(const struct device *dev,
                              enum sensor_channel chan,
                              enum sensor_attribute attr,
                              struct sensor_value *val);
 
static inline int z_impl_sensor_attr_get(const struct device *dev,
                                         enum sensor_channel chan,
                                         enum sensor_attribute attr,
                                         struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->attr_get == NULL) {
                return -ENOSYS;
        }
 
        return api->attr_get(dev, chan, attr, val);
}
 
static inline int sensor_trigger_set(const struct device *dev,
                                     const struct sensor_trigger *trig,
                                     sensor_trigger_handler_t handler)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        if (api->trigger_set == NULL) {
                return -ENOSYS;
        }
 
        return api->trigger_set(dev, trig, handler);
}
 
__syscall int sensor_sample_fetch(const struct device *dev);
 
static inline int z_impl_sensor_sample_fetch(const struct device *dev)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->sample_fetch(dev, SENSOR_CHAN_ALL);
}
 
__syscall int sensor_sample_fetch_chan(const struct device *dev,
                                       enum sensor_channel type);
 
static inline int z_impl_sensor_sample_fetch_chan(const struct device *dev,
                                                  enum sensor_channel type)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->sample_fetch(dev, type);
}
 
__syscall int sensor_channel_get(const struct device *dev,
                                 enum sensor_channel chan,
                                 struct sensor_value *val);
 
static inline int z_impl_sensor_channel_get(const struct device *dev,
                                            enum sensor_channel chan,
                                            struct sensor_value *val)
{
        const struct sensor_driver_api *api =
                (const struct sensor_driver_api *)dev->api;
 
        return api->channel_get(dev, chan, val);
}
 
#if defined(CONFIG_SENSOR_ASYNC_API) || defined(__DOXYGEN__)
 
/*
 * Generic data structure used for encoding the sample timestamp and number of channels sampled.
 */
struct __attribute__((__packed__)) sensor_data_generic_header {
        /* The timestamp at which the data was collected from the sensor */
        uint64_t timestamp_ns;
 
        /*
         * The number of channels present in the frame. This will be the true number of elements in
         * channel_info and in the q31 values that follow the header.
         */
        uint32_t num_channels;
 
        /* Shift value for all samples in the frame */
        int8_t shift;
 
        /* This padding is needed to make sure that the 'channels' field is aligned */
        int8_t _padding[sizeof(struct sensor_chan_spec) - 1];
 
        /* Channels present in the frame */
        struct sensor_chan_spec channels[0];
};
 
#define SENSOR_CHANNEL_3_AXIS(chan)                                                                \
        ((chan) == SENSOR_CHAN_ACCEL_XYZ || (chan) == SENSOR_CHAN_GYRO_XYZ ||                      \
         (chan) == SENSOR_CHAN_MAGN_XYZ || (chan) == SENSOR_CHAN_POS_DXYZ)
 
__syscall int sensor_get_decoder(const struct device *dev,
                                 const struct sensor_decoder_api **decoder);
 
static inline int z_impl_sensor_get_decoder(const struct device *dev,
                                            const struct sensor_decoder_api **decoder)
{
        const struct sensor_driver_api *api = (const struct sensor_driver_api *)dev->api;
 
        __ASSERT_NO_MSG(api != NULL);
 
        if (api->get_decoder == NULL) {
                *decoder = &__sensor_default_decoder;
                return 0;
        }
 
        return api->get_decoder(dev, decoder);
}
 
__syscall int sensor_reconfigure_read_iodev(struct rtio_iodev *iodev, const struct device *sensor,
                                            const struct sensor_chan_spec *channels,
                                            size_t num_channels);
 
static inline int z_impl_sensor_reconfigure_read_iodev(struct rtio_iodev *iodev,
                                                       const struct device *sensor,
                                                       const struct sensor_chan_spec *channels,
                                                       size_t num_channels)
{
        struct sensor_read_config *cfg = (struct sensor_read_config *)iodev->data;
 
        if (cfg->max < num_channels || cfg->is_streaming) {
                return -ENOMEM;
        }
 
        cfg->sensor = sensor;
        memcpy(cfg->channels, channels, num_channels * sizeof(struct sensor_chan_spec));
        cfg->count = num_channels;
        return 0;
}
 
static inline int sensor_stream(struct rtio_iodev *iodev, struct rtio *ctx, void *userdata,
                                struct rtio_sqe **handle)
{
        if (IS_ENABLED(CONFIG_USERSPACE)) {
                struct rtio_sqe sqe;
 
                rtio_sqe_prep_read_multishot(&sqe, iodev, RTIO_PRIO_NORM, userdata);
                rtio_sqe_copy_in_get_handles(ctx, &sqe, handle, 1);
        } else {
                struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
 
                if (sqe == NULL) {
                        return -ENOMEM;
                }
                if (handle != NULL) {
                        *handle = sqe;
                }
                rtio_sqe_prep_read_multishot(sqe, iodev, RTIO_PRIO_NORM, userdata);
        }
        rtio_submit(ctx, 0);
        return 0;
}
 
static inline int sensor_read(struct rtio_iodev *iodev, struct rtio *ctx, uint8_t *buf,
                              size_t buf_len)
{
        if (IS_ENABLED(CONFIG_USERSPACE)) {
                struct rtio_sqe sqe;
 
                rtio_sqe_prep_read(&sqe, iodev, RTIO_PRIO_NORM, buf, buf_len, buf);
                rtio_sqe_copy_in(ctx, &sqe, 1);
        } else {
                struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
 
                if (sqe == NULL) {
                        return -ENOMEM;
                }
                rtio_sqe_prep_read(sqe, iodev, RTIO_PRIO_NORM, buf, buf_len, buf);
        }
        rtio_submit(ctx, 0);
 
        struct rtio_cqe *cqe = rtio_cqe_consume_block(ctx);
        int res = cqe->result;
 
        __ASSERT(cqe->userdata != buf,
                 "consumed non-matching completion for sensor read into buffer %p\n", buf);
 
        rtio_cqe_release(ctx, cqe);
 
        return res;
}
 
static inline int sensor_read_async_mempool(struct rtio_iodev *iodev, struct rtio *ctx,
                                            void *userdata)
{
        if (IS_ENABLED(CONFIG_USERSPACE)) {
                struct rtio_sqe sqe;
 
                rtio_sqe_prep_read_with_pool(&sqe, iodev, RTIO_PRIO_NORM, userdata);
                rtio_sqe_copy_in(ctx, &sqe, 1);
        } else {
                struct rtio_sqe *sqe = rtio_sqe_acquire(ctx);
 
                if (sqe == NULL) {
                        return -ENOMEM;
                }
                rtio_sqe_prep_read_with_pool(sqe, iodev, RTIO_PRIO_NORM, userdata);
        }
        rtio_submit(ctx, 0);
        return 0;
}
 
typedef void (*sensor_processing_callback_t)(int result, uint8_t *buf, uint32_t buf_len,
                                             void *userdata);
 
void sensor_processing_with_callback(struct rtio *ctx, sensor_processing_callback_t cb);
 
#endif /* defined(CONFIG_SENSOR_ASYNC_API) || defined(__DOXYGEN__) */
 
#define SENSOR_G                9806650LL
 
#define SENSOR_PI               3141592LL
 
static inline int32_t sensor_ms2_to_g(const struct sensor_value *ms2)
{
        int64_t micro_ms2 = ms2->val1 * 1000000LL + ms2->val2;
 
        if (micro_ms2 > 0) {
                return (micro_ms2 + SENSOR_G / 2) / SENSOR_G;
        } else {
                return (micro_ms2 - SENSOR_G / 2) / SENSOR_G;
        }
}
 
static inline void sensor_g_to_ms2(int32_t g, struct sensor_value *ms2)
{
        ms2->val1 = ((int64_t)g * SENSOR_G) / 1000000LL;
        ms2->val2 = ((int64_t)g * SENSOR_G) % 1000000LL;
}
 
static inline int32_t sensor_ms2_to_ug(const struct sensor_value *ms2)
{
        int64_t micro_ms2 = (ms2->val1 * INT64_C(1000000)) + ms2->val2;
 
        return (micro_ms2 * 1000000LL) / SENSOR_G;
}
 
static inline void sensor_ug_to_ms2(int32_t ug, struct sensor_value *ms2)
{
        ms2->val1 = ((int64_t)ug * SENSOR_G / 1000000LL) / 1000000LL;
        ms2->val2 = ((int64_t)ug * SENSOR_G / 1000000LL) % 1000000LL;
}
 
static inline int32_t sensor_rad_to_degrees(const struct sensor_value *rad)
{
        int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
 
        if (micro_rad_s > 0) {
                return (micro_rad_s * 180LL + SENSOR_PI / 2) / SENSOR_PI;
        } else {
                return (micro_rad_s * 180LL - SENSOR_PI / 2) / SENSOR_PI;
        }
}
 
static inline void sensor_degrees_to_rad(int32_t d, struct sensor_value *rad)
{
        rad->val1 = ((int64_t)d * SENSOR_PI / 180LL) / 1000000LL;
        rad->val2 = ((int64_t)d * SENSOR_PI / 180LL) % 1000000LL;
}
 
static inline int32_t sensor_rad_to_10udegrees(const struct sensor_value *rad)
{
        int64_t micro_rad_s = rad->val1 * 1000000LL + rad->val2;
 
        return (micro_rad_s * 180LL * 100000LL) / SENSOR_PI;
}
 
static inline void sensor_10udegrees_to_rad(int32_t d, struct sensor_value *rad)
{
        rad->val1 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) / 1000000LL;
        rad->val2 = ((int64_t)d * SENSOR_PI / 180LL / 100000LL) % 1000000LL;
}
 
static inline double sensor_value_to_double(const struct sensor_value *val)
{
        return (double)val->val1 + (double)val->val2 / 1000000;
}
 
static inline float sensor_value_to_float(const struct sensor_value *val)
{
        return (float)val->val1 + (float)val->val2 / 1000000;
}
 
static inline int sensor_value_from_double(struct sensor_value *val, double inp)
{
        if (inp < INT32_MIN || inp > INT32_MAX) {
                return -ERANGE;
        }
 
        double val2 = (inp - (int32_t)inp) * 1000000.0;
 
        if (val2 < INT32_MIN || val2 > INT32_MAX) {
                return -ERANGE;
        }
 
        val->val1 = (int32_t)inp;
        val->val2 = (int32_t)val2;
 
        return 0;
}
 
static inline int sensor_value_from_float(struct sensor_value *val, float inp)
{
        float val2 = (inp - (int32_t)inp) * 1000000.0f;
 
        if (val2 < INT32_MIN || val2 > (float)(INT32_MAX - 1)) {
                return -ERANGE;
        }
 
        val->val1 = (int32_t)inp;
        val->val2 = (int32_t)val2;
 
        return 0;
}
 
#ifdef CONFIG_SENSOR_INFO
 
struct sensor_info {
        const struct device *dev;
        const char *vendor;
        const char *model;
        const char *friendly_name;
};
 
#define SENSOR_INFO_INITIALIZER(_dev, _vendor, _model, _friendly_name)  \
        {                                                               \
                .dev = _dev,                                            \
                .vendor = _vendor,                                      \
                .model = _model,                                        \
                .friendly_name = _friendly_name,                        \
        }
 
#define SENSOR_INFO_DEFINE(name, ...)                                   \
        static const STRUCT_SECTION_ITERABLE(sensor_info, name) =       \
                SENSOR_INFO_INITIALIZER(__VA_ARGS__)
 
#define SENSOR_INFO_DT_NAME(node_id)                                    \
        _CONCAT(__sensor_info, DEVICE_DT_NAME_GET(node_id))
 
#define SENSOR_INFO_DT_DEFINE(node_id)                                  \
        SENSOR_INFO_DEFINE(SENSOR_INFO_DT_NAME(node_id),                \
                           DEVICE_DT_GET(node_id),                      \
                           DT_NODE_VENDOR_OR(node_id, NULL),            \
                           DT_NODE_MODEL_OR(node_id, NULL),             \
                           DT_PROP_OR(node_id, friendly_name, NULL))    \
 
#else
 
#define SENSOR_INFO_DEFINE(name, ...)
#define SENSOR_INFO_DT_DEFINE(node_id)
 
#endif /* CONFIG_SENSOR_INFO */
 
#define SENSOR_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,            \
                                data_ptr, cfg_ptr, level, prio,         \
                                api_ptr, ...)                           \
        DEVICE_DT_DEFINE(node_id, init_fn, pm_device,                   \
                         data_ptr, cfg_ptr, level, prio,                \
                         api_ptr, __VA_ARGS__);                         \
                                                                        \
        SENSOR_INFO_DT_DEFINE(node_id);
 
#define SENSOR_DEVICE_DT_INST_DEFINE(inst, ...)                         \
        SENSOR_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
static inline int64_t sensor_value_to_milli(const struct sensor_value *val)
{
        return ((int64_t)val->val1 * 1000) + val->val2 / 1000;
}
 
static inline int64_t sensor_value_to_micro(const struct sensor_value *val)
{
        return ((int64_t)val->val1 * 1000000) + val->val2;
}
 
static inline int sensor_value_from_milli(struct sensor_value *val, int64_t milli)
{
        if (milli < ((int64_t)INT32_MIN - 1) * 1000LL ||
                        milli > ((int64_t)INT32_MAX + 1) * 1000LL) {
                return -ERANGE;
        }
 
        val->val1 = (int32_t)(milli / 1000);
        val->val2 = (int32_t)(milli % 1000) * 1000;
 
        return 0;
}
 
static inline int sensor_value_from_micro(struct sensor_value *val, int64_t micro)
{
        if (micro < ((int64_t)INT32_MIN - 1) * 1000000LL ||
                        micro > ((int64_t)INT32_MAX + 1) * 1000000LL) {
                return -ERANGE;
        }
 
        val->val1 = (int32_t)(micro / 1000000LL);
        val->val2 = (int32_t)(micro % 1000000LL);
 
        return 0;
}
 
#define SENSOR_DECODER_NAME() UTIL_CAT(DT_DRV_COMPAT, __decoder_api)
 
#define SENSOR_DECODER_DT_GET(node_id)                                                             \
        &UTIL_CAT(DT_STRING_TOKEN_BY_IDX(node_id, compatible, 0), __decoder_api)
 
#define SENSOR_DECODER_API_DT_DEFINE()                                                             \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT), (), (static))                        \
        const STRUCT_SECTION_ITERABLE(sensor_decoder_api, SENSOR_DECODER_NAME())
 
#define Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL_IDX(node_id, prop, idx)                            \
        extern const struct sensor_decoder_api UTIL_CAT(                                           \
                DT_STRING_TOKEN_BY_IDX(node_id, prop, idx), __decoder_api);
 
#define Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL(node_id)                                           \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, compatible),                                         \
                    (DT_FOREACH_PROP_ELEM(node_id, compatible,                                     \
                                          Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL_IDX)),           \
                    ())
 
DT_FOREACH_STATUS_OKAY_NODE(Z_MAYBE_SENSOR_DECODER_DECLARE_INTERNAL)
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/sensor.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_SENSOR_H_ */