dac.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Libre Solar Technologies GmbH
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_DAC_H_
#define ZEPHYR_INCLUDE_DRIVERS_DAC_H_
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif


#define DAC_CHANNEL_BROADCAST   0xFF

struct dac_channel_cfg {
        uint8_t channel_id;
        uint8_t resolution;
        bool buffered: 1;
        bool internal: 1;
};

#define DAC_CHANNEL_CFG_DT(node_id) { \
        .resolution       = DT_PROP_OR(node_id, zephyr_resolution, 0), \
        .buffered         = DT_PROP(node_id, zephyr_buffered),         \
        .internal         = DT_PROP(node_id, zephyr_internal),         \
        .channel_id       = DT_REG_ADDR(node_id),                      \
}

struct dac_dt_spec {
        const struct device *dev;

        uint8_t channel_id;

        bool channel_cfg_dt_node_exists;

        struct dac_channel_cfg channel_cfg;

        uint16_t vref_mv;
};

 
#define DAC_DT_SPEC_STRUCT(ctlr, output) { \
                .dev = DEVICE_DT_GET(ctlr), \
                .channel_id = output, \
                DAC_CHANNEL_CFG_FROM_DT_NODE(\
                        DAC_CHANNEL_DT_NODE(ctlr, output)) \
        }
 
#define DAC_CHANNEL_DT_NODE(ctlr, output) \
        DT_CHILD_BY_UNIT_ADDR_INT(ctlr, output)
 
#define DAC_CHANNEL_CFG_FROM_DT_NODE(node_id) \
        IF_ENABLED(DT_NODE_EXISTS(node_id), \
                (.channel_cfg_dt_node_exists = true, \
                 .channel_cfg  = DAC_CHANNEL_CFG_DT(node_id), \
                 .vref_mv      = DT_PROP_OR(node_id, zephyr_vref_mv, 0),))


#define DAC_DT_SPEC_GET_BY_NAME(node_id, name) \
        DAC_DT_SPEC_STRUCT(DT_IO_CHANNELS_CTLR_BY_NAME(node_id, name), \
                           DT_IO_CHANNELS_OUTPUT_BY_NAME(node_id, name))

#define DAC_DT_SPEC_GET_BY_NAME_OR(node_id, name, default_value) \
        COND_CODE_1(DT_PROP_HAS_NAME(node_id, io_channels, name), \
                    (DAC_DT_SPEC_GET_BY_NAME(node_id, name)), (default_value))

#define DAC_DT_SPEC_INST_GET_BY_NAME(inst, name) \
        DAC_DT_SPEC_GET_BY_NAME(DT_DRV_INST(inst), name)
 

#define DAC_DT_SPEC_INST_GET_BY_NAME_OR(inst, name, default_value) \
        DAC_DT_SPEC_GET_BY_NAME_OR(DT_DRV_INST(inst), name, default_value)

#define DAC_DT_SPEC_GET_BY_IDX(node_id, idx) \
        DAC_DT_SPEC_STRUCT(DT_IO_CHANNELS_CTLR_BY_IDX(node_id, idx), \
                           COND_CODE_1(DT_PHA_HAS_CELL_AT_IDX(node_id, io_channels, idx, output), \
                                       (DT_IO_CHANNELS_OUTPUT_BY_IDX(node_id, idx)), \
                                       (0)))

#define DAC_DT_SPEC_GET_BY_IDX_OR(node_id, idx, default_value) \
        COND_CODE_1(DT_PROP_HAS_IDX(node_id, io_channels, idx), \
                    (DAC_DT_SPEC_GET_BY_IDX(node_id, idx)), (default_value))

#define DAC_DT_SPEC_INST_GET_BY_IDX(inst, idx) \
        DAC_DT_SPEC_GET_BY_IDX(DT_DRV_INST(inst), idx)

#define DAC_DT_SPEC_INST_GET_BY_IDX_OR(inst, idx, default_value) \
        DAC_DT_SPEC_GET_BY_IDX_OR(DT_DRV_INST(inst), idx, default_value)

#define DAC_DT_SPEC_GET(node_id) DAC_DT_SPEC_GET_BY_IDX(node_id, 0)

#define DAC_DT_SPEC_GET_OR(node_id, default_value) \
        DAC_DT_SPEC_GET_BY_IDX_OR(node_id, 0, default_value)

#define DAC_DT_SPEC_INST_GET(inst) DAC_DT_SPEC_GET(DT_DRV_INST(inst))

#define DAC_DT_SPEC_INST_GET_OR(inst, default_value) \
        DAC_DT_SPEC_GET_OR(DT_DRV_INST(inst), default_value)

 
/*
 * Type definition of DAC API function for configuring a channel.
 * See dac_channel_setup() for argument descriptions.
 */
typedef int (*dac_api_channel_setup)(const struct device *dev,
                                     const struct dac_channel_cfg *channel_cfg);
 
/*
 * Type definition of DAC API function for setting a write request.
 * See dac_write_value() for argument descriptions.
 */
typedef int (*dac_api_write_value)(const struct device *dev,
                                    uint8_t channel, uint32_t value);
 
/*
 * DAC driver API
 *
 * This is the mandatory API any DAC driver needs to expose.
 */
__subsystem struct dac_driver_api {
        dac_api_channel_setup channel_setup;
        dac_api_write_value   write_value;
};


__syscall int dac_channel_setup(const struct device *dev,
                                const struct dac_channel_cfg *channel_cfg);
 
static inline int z_impl_dac_channel_setup(const struct device *dev,
                                           const struct dac_channel_cfg *channel_cfg)
{
        const struct dac_driver_api *api =
                                (const struct dac_driver_api *)dev->api;
 
        return api->channel_setup(dev, channel_cfg);
}

static inline int dac_channel_setup_dt(const struct dac_dt_spec *spec)
{
        if (!spec->channel_cfg_dt_node_exists) {
                return -ENOTSUP;
        }
 
        return dac_channel_setup(spec->dev, &spec->channel_cfg);
}

__syscall int dac_write_value(const struct device *dev, uint8_t channel,
                              uint32_t value);
 
static inline int z_impl_dac_write_value(const struct device *dev,
                                                uint8_t channel, uint32_t value)
{
        const struct dac_driver_api *api =
                                (const struct dac_driver_api *)dev->api;
 
        return api->write_value(dev, channel, value);
}

static inline int dac_write_value_dt(const struct dac_dt_spec *spec,
                                     uint32_t value)
{
        if (!spec->channel_cfg_dt_node_exists) {
                return -ENOTSUP;
        }
 
        return dac_write_value(spec->dev, spec->channel_id, value);
}

typedef int (*dac_x_to_raw_fn)(uint32_t ref_mv, uint8_t resolution, uint32_t *valp);

static inline int dac_millivolts_to_raw(uint32_t ref_mv, uint8_t resolution, uint32_t *valp)
{
        uint64_t dac_mv = (((uint64_t)*valp) << resolution) / (uint64_t)ref_mv;
 
        if (dac_mv > (1UL << resolution)) {
                __ASSERT_MSG_INFO("conversion result is out of range");
                return -ERANGE;
        }
 
        *valp = (uint32_t)dac_mv;
 
        return 0;
}

static inline int dac_microvolts_to_raw(uint32_t ref_mv, uint8_t resolution, uint32_t *valp)
{
        uint64_t dac_uv = (((uint64_t)*valp) << resolution) / (uint64_t)ref_mv / (uint64_t)1000;
 
        if (dac_uv > (1UL << resolution)) {
                __ASSERT_MSG_INFO("conversion result is out of range");
                return -ERANGE;
        }
 
        *valp = (uint32_t)dac_uv;
 
        return 0;
}

static inline int dac_x_to_raw_dt_chan(dac_x_to_raw_fn conv_func,
                                            const struct dac_dt_spec *spec,
                                            uint32_t *valp)
{
        if (!spec->channel_cfg_dt_node_exists) {
                return -ENOTSUP;
        }
 
        return conv_func(spec->vref_mv, spec->channel_cfg.resolution, valp);
}

static inline int dac_millivolts_to_raw_dt(const struct dac_dt_spec *spec, uint32_t *valp)
{
        return dac_x_to_raw_dt_chan(dac_millivolts_to_raw, spec, valp);
}

static inline int dac_microvolts_to_raw_dt(const struct dac_dt_spec *spec, uint32_t *valp)
{
        return dac_x_to_raw_dt_chan(dac_microvolts_to_raw, spec, valp);
}

static inline bool dac_is_ready_dt(const struct dac_dt_spec *spec)
{
        return spec->channel_cfg_dt_node_exists && device_is_ready(spec->dev);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/dac.h>
 
#endif  /* ZEPHYR_INCLUDE_DRIVERS_DAC_H_ */