device.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_SHARED_DEVICE_H_
#define INFUSE_SDK_INCLUDE_INFUSE_SHARED_DEVICE_H_
 
#include <stdint.h>
#include <stdbool.h>
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct shared_device_dt_spec {
        /* Pointer to the shared device */
        const struct device *shared;
        /* State that is being requested */
        uint8_t state;
        /* Priority of the state request */
        uint8_t priority;
};
 
#define SHARED_DEVICE_DT_SPEC_GET_BY_IDX(node_id, prop, idx)                                       \
        {                                                                                          \
                .shared = DEVICE_DT_GET(DT_PHANDLE_BY_IDX(node_id, prop, idx)),                    \
                .state = DT_PHA_BY_IDX(node_id, prop, idx, state),                                 \
                .priority = DT_PHA_BY_IDX(node_id, prop, idx, priority),                           \
        }
 
#define SHARED_DEVICE_DT_SPEC_GET_BY_IDX_OR(node_id, prop, idx, default_value)                     \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop),                                               \
                    (SHARED_DEVICE_DT_SPEC_GET_BY_IDX(node_id, prop, idx)), (default_value))
 
#define SHARED_DEVICE_DT_SPEC_GET(node_id, prop) SHARED_DEVICE_DT_SPEC_GET_BY_IDX(node_id, prop, 0)
 
#define SHARED_DEVICE_DT_SPEC_GET_OR(node_id, prop, default_value)                                 \
        SHARED_DEVICE_DT_SPEC_GET_BY_IDX_OR(node_id, prop, 0, default_value)
 
#define SHARED_DEVICE_DT_SPEC_INST_GET_BY_IDX(inst, prop, idx)                                     \
        SHARED_DEVICE_DT_SPEC_GET_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define SHARED_DEVICE_DT_SPEC_INST_GET_BY_IDX_OR(inst, prop, idx, default_value)                   \
        SHARED_DEVICE_DT_SPEC_GET_BY_IDX_OR(DT_DRV_INST(inst), prop, idx, default_value)
 
#define SHARED_DEVICE_DT_SPEC_INST_GET(inst, prop)                                                 \
        SHARED_DEVICE_DT_SPEC_INST_GET_BY_IDX(inst, prop, 0)
 
#define SHARED_DEVICE_DT_SPEC_INST_GET_OR(inst, prop, default_value)                               \
        SHARED_DEVICE_DT_SPEC_INST_GET_BY_IDX_OR(inst, prop, 0, default_value)
 
struct shared_device_api {
        int (*request)(const struct device *dev, uint8_t state_priority, uint8_t state);
        int (*release)(const struct device *dev, uint8_t state_priority);
};
 
static inline bool shared_device_is_ready_dt(const struct shared_device_dt_spec *spec)
{
        if (spec->shared == NULL) {
                return true;
        }
        return device_is_ready(spec->shared);
}
 
static inline int shared_device_request(const struct device *dev, uint8_t state_priority,
                                        uint8_t state)
{
        const struct shared_device_api *api = dev->api;
 
        return api->request(dev, state_priority, state);
}
 
static inline int shared_device_request_dt(const struct shared_device_dt_spec *spec)
{
        if (spec->shared == NULL) {
                return 0;
        }
        return shared_device_request(spec->shared, spec->priority, spec->state);
}
 
static inline int shared_device_release(const struct device *dev, uint8_t state_priority)
{
        const struct shared_device_api *api = dev->api;
 
        return api->release(dev, state_priority);
}
 
static inline int shared_device_release_dt(const struct shared_device_dt_spec *spec)
{
        if (spec->shared == NULL) {
                return 0;
        }
        return shared_device_release(spec->shared, spec->priority);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_SHARED_DEVICE_H_ */