iio.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
/*
 * libiio - Library for interfacing industrial I/O (IIO) devices
 *
 * Copyright (C) 2014 Analog Devices, Inc.
 * Author: Paul Cercueil <paul.cercueil@analog.com>
 *
 * Note: This header file is released under the MIT License as specified by
 * the SPDX identifier above. However, libiio as a whole includes components
 * under multiple open-source licenses. The license of the final binary
 * depends on the build configuration and may differ from that of this file.
 * Please review the full licensing information and configuration options
 * to ensure compliance with applicable license terms.
 */


 
#ifndef __IIO_H__
#define __IIO_H__
 
#ifndef DOXYGEN
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#if (defined(_WIN32) || defined(__MBED__))
#ifndef _SSIZE_T_DEFINED
typedef ptrdiff_t ssize_t;
#define _SSIZE_T_DEFINED
#endif
#else
#include <sys/types.h>
#endif
 
#if defined(_MSC_VER) && (_MSC_VER < 1800) && !defined(__BOOL_DEFINED)
#undef bool
#undef false
#undef true
#define bool char
#define false 0
#define true 1
#else
#include <stdbool.h>
#endif
 
#if defined(__GNUC__) && !defined(MATLAB_MEX_FILE) && !defined(MATLAB_LOADLIBRARY)
#ifndef __cnst
#define __cnst __attribute__((const))
#endif
#ifndef __pure
#define __pure __attribute__((pure))
#endif
#define __notused __attribute__((unused))
#ifdef IIO_CHECK_RET
#define __check_ret __attribute__((warn_unused_result))
#else
#define __check_ret
#endif
#else
#define __cnst
#define __pure
#define __notused
#define __check_ret
#endif
 
#if !defined(_WIN32) && __GNUC__ >= 4 && !defined(MATLAB_MEX_FILE) && !defined(MATLAB_LOADLIBRARY)
#define __iio_api_export __attribute__((visibility("default")))
#define __iio_api_import
#elif defined(_WIN32) && !defined(LIBIIO_STATIC)
#define __iio_api_export __declspec(dllexport)
#define __iio_api_import __declspec(dllimport)
#else
#define __iio_api_export
#define __iio_api_import
#endif
 
#ifdef LIBIIO_EXPORTS
#define __iio_api __iio_api_export
#else
#define __iio_api __iio_api_import
#endif
 
#define __api __iio_api
 
#endif /* DOXYGEN */
 
struct iio_attr;
struct iio_block;
struct iio_context;
struct iio_device;
struct iio_channel;
struct iio_channels_mask;
struct iio_event_stream;
struct iio_buffer;
struct iio_scan;
struct iio_stream;

enum iio_log_level {
    /* @brief No log output from the library */
    LEVEL_NOLOG = 1,
 
    /* @brief Only print error messages */
    LEVEL_ERROR = 2,
 
    /* @brief Also print warnings */
    LEVEL_WARNING = 3,
 
    /* @brief Also print noteworthy information */
    LEVEL_INFO = 4,
 
    /* @brief Also print debug messages */
    LEVEL_DEBUG = 5,
};

#define IIO_TIMEOUT_BACKEND 0
#define IIO_TIMEOUT_INFINITE (-1)
#define IIO_TIMEOUT_NONBLOCK INT_MIN

enum iio_context_flags {
    IIO_CTX_XML_INCLUDE_VALUES = 1 << 0,
};

struct iio_context_params {
    FILE *out;

    FILE *err;

    enum iio_log_level log_level;

    enum iio_log_level stderr_level;

    enum iio_log_level timestamp_level;

    int timeout_ms;

    unsigned int flags;

    char __rsrv[32];
};
 
/*
 * <linux/iio/types.h> header guard to protect these enums from being defined
 * twice
 */
#ifndef _IIO_TYPES_H_
#define _IIO_TYPES_H_

enum iio_chan_type {
    IIO_VOLTAGE,
    IIO_CURRENT,
    IIO_POWER,
    IIO_ACCEL,
    IIO_ANGL_VEL,
    IIO_MAGN,
    IIO_LIGHT,
    IIO_INTENSITY,
    IIO_PROXIMITY,
    IIO_TEMP,
    IIO_INCLI,
    IIO_ROT,
    IIO_ANGL,
    IIO_TIMESTAMP,
    IIO_CAPACITANCE,
    IIO_ALTVOLTAGE,
    IIO_CCT,
    IIO_PRESSURE,
    IIO_HUMIDITYRELATIVE,
    IIO_ACTIVITY,
    IIO_STEPS,
    IIO_ENERGY,
    IIO_DISTANCE,
    IIO_VELOCITY,
    IIO_CONCENTRATION,
    IIO_RESISTANCE,
    IIO_PH,
    IIO_UVINDEX,
    IIO_ELECTRICALCONDUCTIVITY,
    IIO_COUNT,
    IIO_INDEX,
    IIO_GRAVITY,
    IIO_POSITIONRELATIVE,
    IIO_PHASE,
    IIO_MASSCONCENTRATION,
    IIO_DELTA_ANGL,
    IIO_DELTA_VELOCITY,
    IIO_COLORTEMP,
    IIO_CHROMATICITY,
    IIO_ATTENTION,
    IIO_ALTCURRENT,
    IIO_COVERAGE,
    IIO_VOLUMEFLOW,
    IIO_CHAN_TYPE_UNKNOWN = INT_MAX,
};

enum iio_modifier {
    IIO_NO_MOD,
    IIO_MOD_X,
    IIO_MOD_Y,
    IIO_MOD_Z,
    IIO_MOD_X_AND_Y,
    IIO_MOD_X_AND_Z,
    IIO_MOD_Y_AND_Z,
    IIO_MOD_X_AND_Y_AND_Z,
    IIO_MOD_X_OR_Y,
    IIO_MOD_X_OR_Z,
    IIO_MOD_Y_OR_Z,
    IIO_MOD_X_OR_Y_OR_Z,
    IIO_MOD_LIGHT_BOTH,
    IIO_MOD_LIGHT_IR,
    IIO_MOD_ROOT_SUM_SQUARED_X_Y,
    IIO_MOD_SUM_SQUARED_X_Y_Z,
    IIO_MOD_LIGHT_CLEAR,
    IIO_MOD_LIGHT_RED,
    IIO_MOD_LIGHT_GREEN,
    IIO_MOD_LIGHT_BLUE,
    IIO_MOD_QUATERNION,
    IIO_MOD_TEMP_AMBIENT,
    IIO_MOD_TEMP_OBJECT,
    IIO_MOD_NORTH_MAGN,
    IIO_MOD_NORTH_TRUE,
    IIO_MOD_NORTH_MAGN_TILT_COMP,
    IIO_MOD_NORTH_TRUE_TILT_COMP,
    IIO_MOD_RUNNING,
    IIO_MOD_JOGGING,
    IIO_MOD_WALKING,
    IIO_MOD_STILL,
    IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
    IIO_MOD_I,
    IIO_MOD_Q,
    IIO_MOD_CO2,
    IIO_MOD_VOC,
    IIO_MOD_LIGHT_UV,
    IIO_MOD_LIGHT_DUV,
    IIO_MOD_PM1,
    IIO_MOD_PM2P5,
    IIO_MOD_PM4,
    IIO_MOD_PM10,
    IIO_MOD_ETHANOL,
    IIO_MOD_H2,
    IIO_MOD_O2,
    IIO_MOD_LINEAR_X,
    IIO_MOD_LINEAR_Y,
    IIO_MOD_LINEAR_Z,
    IIO_MOD_PITCH,
    IIO_MOD_YAW,
    IIO_MOD_ROLL,
    IIO_MOD_LIGHT_UVA,
    IIO_MOD_LIGHT_UVB,
    IIO_MOD_RMS,
    IIO_MOD_ACTIVE,
    IIO_MOD_REACTIVE,
    IIO_MOD_APPARENT,
    IIO_MOD_QUATERNION_AXIS,
};

enum iio_event_type {
    IIO_EV_TYPE_THRESH,
    IIO_EV_TYPE_MAG,
    IIO_EV_TYPE_ROC,
    IIO_EV_TYPE_THRESH_ADAPTIVE,
    IIO_EV_TYPE_MAG_ADAPTIVE,
    IIO_EV_TYPE_CHANGE,
    IIO_EV_TYPE_MAG_REFERENCED,
    IIO_EV_TYPE_GESTURE,
    IIO_EV_TYPE_FAULT,
};

enum iio_event_direction {
    IIO_EV_DIR_EITHER,
    IIO_EV_DIR_RISING,
    IIO_EV_DIR_FALLING,
    IIO_EV_DIR_NONE,
    IIO_EV_DIR_SINGLETAP,
    IIO_EV_DIR_DOUBLETAP,
    IIO_EV_DIR_FAULT_OPENWIRE,
};
 
#endif /* _IIO_TYPES_H_ */
 
/* ---------------------------------------------------------------------------*/
/* ---------------------------- Error handling -------------------------------*/
static inline __check_ret void *iio_ptr(int err)
{
    return (void *)(intptr_t)err;
}

static inline __check_ret int iio_err(const void *ptr)
{
    return (uintptr_t)ptr >= (uintptr_t)-4095 ? (int)(intptr_t)ptr : 0;
}

static inline __check_ret void *iio_err_cast(const void *ptr)
{
    return (void *)ptr;
}
 /* ------------------------------------------------------------------*/
/* ------------------------- Attributes functions ----------------------------*/

__api __check_ret ssize_t iio_attr_read_raw(const struct iio_attr *attr, char *dst, size_t len);

#ifndef __cplusplus
#define iio_attr_read(attr, ptr) \
    _Generic((ptr), \
            bool *: iio_attr_read_bool, \
            long long *: iio_attr_read_longlong, \
            double *: iio_attr_read_double)(attr, ptr)
#endif /* __cplusplus */

__api __check_ret ssize_t iio_attr_write_raw(
        const struct iio_attr *attr, const void *src, size_t len);

#ifndef __cplusplus
#define iio_attr_write(attr, val) \
    _Generic((val), \
            const char *: iio_attr_write_string, \
            char *: iio_attr_write_string, \
            bool: iio_attr_write_bool, \
            long long: iio_attr_write_longlong, \
            double: iio_attr_write_double)(attr, val)
#endif /* __cplusplus */

__api __pure const char *iio_attr_get_name(const struct iio_attr *attr);

__api __check_ret __pure const char *iio_attr_get_filename(const struct iio_attr *attr);

__api __pure const char *iio_attr_get_static_value(const struct iio_attr *attr);

__api int iio_attr_get_range(const struct iio_attr *attr, double *min, double *step, double *max);

__api int iio_attr_get_available(const struct iio_attr *attr, char ***list, size_t *count);

__api int iio_attr_get_available_buf(
        const struct iio_attr *attr, char *buf, size_t buflen, char **list, size_t *count);

__api void iio_available_list_free(char **list, size_t count);
 /* ------------------------------------------------------------------*/
/* ------------------------- Scan functions ----------------------------------*/

__api __check_ret struct iio_scan *iio_scan(
        const struct iio_context_params *params, const char *backends);

__api void iio_scan_destroy(struct iio_scan *ctx);

__api __check_ret __pure size_t iio_scan_get_results_count(const struct iio_scan *ctx);

__api __check_ret __pure const char *iio_scan_get_description(
        const struct iio_scan *ctx, size_t idx);

__api __check_ret __pure const char *iio_scan_get_uri(const struct iio_scan *ctx, size_t idx);
 /* ------------------------------------------------------------------*/
/* ------------------------- Top-level functions -----------------------------*/

__api void iio_strerror(int err, char *dst, size_t len);

__api __check_ret bool iio_has_backend(
        const struct iio_context_params *params, const char *backend);

__api __check_ret __cnst unsigned int iio_get_builtin_backends_count(void);

__api __check_ret __cnst const char *iio_get_builtin_backend(unsigned int index);
 /* ------------------------------------------------------------------*/
/* ------------------------- Context functions -------------------------------*/

__api __check_ret struct iio_context *iio_create_context(
        const struct iio_context_params *params, const char *uri);

__api void iio_context_destroy(struct iio_context *ctx);

__api __pure unsigned int iio_context_get_version_major(const struct iio_context *ctx);

__api __pure unsigned int iio_context_get_version_minor(const struct iio_context *ctx);

__api __pure unsigned int iio_context_get_version_patch(const struct iio_context *ctx);

__api __pure const char *iio_context_get_version_tag(const struct iio_context *ctx);

__api __check_ret char *iio_context_get_xml(const struct iio_context *ctx);

__api __check_ret __pure const char *iio_context_get_name(const struct iio_context *ctx);

__api __check_ret __pure const char *iio_context_get_description(const struct iio_context *ctx);

__api __check_ret __pure unsigned int iio_context_get_attrs_count(const struct iio_context *ctx);

__api __check_ret __pure const struct iio_attr *iio_context_get_attr(
        const struct iio_context *ctx, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_context_find_attr(
        const struct iio_context *ctx, const char *name);

__api __check_ret __pure unsigned int iio_context_get_devices_count(const struct iio_context *ctx);

__api __check_ret __pure struct iio_device *iio_context_get_device(
        const struct iio_context *ctx, unsigned int index);

__api __check_ret __pure struct iio_device *iio_context_find_device(
        const struct iio_context *ctx, const char *name);

__api __check_ret int iio_context_set_timeout(struct iio_context *ctx, int timeout_ms);

__api __cnst const struct iio_context_params *iio_context_get_params(const struct iio_context *ctx);

__api void iio_context_set_data(struct iio_context *ctx, void *data);

__api void *iio_context_get_data(const struct iio_context *ctx);

__api __check_ret int iio_context_ping(struct iio_context *ctx);
 /* ------------------------------------------------------------------*/
/* ------------------------- Device functions --------------------------------*/

__api __check_ret __pure const struct iio_context *iio_device_get_context(
        const struct iio_device *dev);

__api __check_ret __pure const char *iio_device_get_id(const struct iio_device *dev);

__api __check_ret __pure const char *iio_device_get_name(const struct iio_device *dev);

__api __check_ret __pure const char *iio_device_get_label(const struct iio_device *dev);

__api __check_ret __pure unsigned int iio_device_get_channels_count(const struct iio_device *dev);

__api __check_ret __pure unsigned int iio_device_get_attrs_count(const struct iio_device *dev);

__api __check_ret __pure unsigned int iio_device_get_buffers_count(const struct iio_device *dev);

__api __check_ret __pure struct iio_channel *iio_device_get_channel(
        const struct iio_device *dev, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_device_get_attr(
        const struct iio_device *dev, unsigned int index);

__api __check_ret __pure struct iio_buffer *iio_device_get_buffer(
        const struct iio_device *dev, unsigned int index);

__api __check_ret __pure struct iio_channel *iio_device_find_channel(
        const struct iio_device *dev, const char *name, bool output);

__api __check_ret __pure const struct iio_attr *iio_device_find_attr(
        const struct iio_device *dev, const char *name);

__api void iio_device_set_data(struct iio_device *dev, void *data);

__api void *iio_device_get_data(const struct iio_device *dev);

__api __check_ret const struct iio_device *iio_device_get_trigger(const struct iio_device *dev);

__api __check_ret int iio_device_set_trigger(
        const struct iio_device *dev, const struct iio_device *trigger);

__api __check_ret __pure bool iio_device_is_trigger(const struct iio_device *dev);
 /* ------------------------------------------------------------------*/
/* ------------------------- Channel functions -------------------------------*/

__api __check_ret __pure const struct iio_device *iio_channel_get_device(
        const struct iio_channel *chn);

__api __check_ret __pure const char *iio_channel_get_id(const struct iio_channel *chn);

__api __check_ret __pure const char *iio_channel_get_name(const struct iio_channel *chn);

__api __check_ret __pure const char *iio_channel_get_label(const struct iio_channel *chn);

__api __check_ret __pure bool iio_channel_is_output(const struct iio_channel *chn);

__api __check_ret __pure bool iio_channel_is_scan_element(const struct iio_channel *chn);

__api __check_ret __pure unsigned int iio_channel_get_attrs_count(const struct iio_channel *chn);

__api __check_ret __pure const struct iio_attr *iio_channel_get_attr(
        const struct iio_channel *chn, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_channel_find_attr(
        const struct iio_channel *chn, const char *name);

__api __check_ret __pure unsigned int iio_channel_get_event_attrs_count(
        const struct iio_channel *chn);

__api __check_ret __pure const struct iio_attr *iio_channel_get_event_attr(
        const struct iio_channel *chn, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_channel_find_event_attr(
        const struct iio_channel *chn, const char *name);

__api void iio_channel_enable(const struct iio_channel *chn, struct iio_channels_mask *mask);

__api void iio_channel_disable(const struct iio_channel *chn, struct iio_channels_mask *mask);

__api __check_ret bool iio_channel_is_enabled(
        const struct iio_channel *chn, const struct iio_channels_mask *mask);

__api __check_ret size_t iio_channel_read(const struct iio_channel *chn,
        const struct iio_block *block, void *dst, size_t len, bool raw);

__api __check_ret size_t iio_channel_write(const struct iio_channel *chn, struct iio_block *block,
        const void *src, size_t len, bool raw);

__api void iio_channel_set_data(struct iio_channel *chn, void *data);

__api void *iio_channel_get_data(const struct iio_channel *chn);

__api __check_ret __pure enum iio_chan_type iio_channel_get_type(const struct iio_channel *chn);

__api __check_ret __pure enum iio_modifier iio_channel_get_modifier(const struct iio_channel *chn);
 /* ------------------------------------------------------------------*/
/* ------------------------- Buffer functions --------------------------------*/

__api __check_ret __pure const struct iio_device *iio_buffer_get_device(
        const struct iio_buffer *buf);

__api __check_ret __pure unsigned int iio_buffer_get_attrs_count(const struct iio_buffer *buf);

__api __check_ret __pure const struct iio_attr *iio_buffer_get_attr(
        const struct iio_buffer *buf, unsigned int index);

__api __check_ret __pure unsigned int iio_buffer_get_scan_elements_count(
        const struct iio_buffer *buf);

__api __check_ret __pure const struct iio_channel *iio_buffer_get_scan_element(
        const struct iio_buffer *buf, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_buffer_find_attr(
        const struct iio_buffer *buf, const char *name);

__api __check_ret __pure bool iio_buffer_is_output(const struct iio_buffer *buf);

__api void iio_buffer_set_data(struct iio_buffer *buf, void *data);

__api void *iio_buffer_get_data(const struct iio_buffer *buf);
 /* ------------------------------------------------------------------*/
/* ------------------------- Buffer Stream functions -------------------------*/

__api __check_ret struct iio_buffer_stream *iio_buffer_open(
        struct iio_buffer *buf, const struct iio_channels_mask *mask);

__api void iio_buffer_close(struct iio_buffer_stream *buf_stream);

__api void iio_buffer_stream_cancel(struct iio_buffer_stream *buf_stream);

__api __check_ret int iio_buffer_stream_start(struct iio_buffer_stream *buf_stream);

__api int iio_buffer_stream_stop(struct iio_buffer_stream *buf_stream);

__api const struct iio_channels_mask *iio_buffer_stream_get_channels_mask(
        const struct iio_buffer_stream *buf_stream);
 /* ------------------------------------------------------------------*/
/* -------------------------- Block functions --------------------------------*/

__api __check_ret struct iio_block *iio_buffer_stream_create_block(
        struct iio_buffer_stream *buf_stream, size_t size);

__api void iio_block_destroy(struct iio_block *block);

__api __check_ret int iio_block_get_dmabuf_fd(const struct iio_block *block);

__api int iio_block_disable_cpu_access(struct iio_block *block, bool disable);

__api void *iio_block_start(const struct iio_block *block);

__api void *iio_block_first(const struct iio_block *block, const struct iio_channel *chn);

__api void *iio_block_end(const struct iio_block *block);

__api __check_ret ssize_t iio_block_foreach_sample(const struct iio_block *block,
        const struct iio_channels_mask *mask,
        ssize_t (*callback)(
                const struct iio_channel *chn, void *src, size_t bytes, void *d),
        void *data);

__api int iio_block_enqueue(struct iio_block *block, size_t bytes_used, bool cyclic);

__api int iio_block_dequeue(struct iio_block *block, bool nonblock);

__api struct iio_buffer_stream *iio_block_get_buffer_stream(const struct iio_block *block);
 /* ------------------------------------------------------------------*/
/* ------------------------- Stream functions --------------------------------*/

__api __check_ret struct iio_stream *iio_buffer_create_stream(struct iio_buffer *buffer,
        size_t nb_blocks, size_t samples_count, struct iio_channels_mask *mask);

__api void iio_stream_cancel(struct iio_stream *stream);

__api void iio_stream_destroy(struct iio_stream *stream);

__api __check_ret const struct iio_block *iio_stream_get_next_block(struct iio_stream *stream);
 /* ------------------------------------------------------------------*/
/* ---------------------------- HWMON support --------------------------------*/
enum hwmon_chan_type {
    HWMON_VOLTAGE,
    HWMON_FAN,
    HWMON_PWM,
    HWMON_TEMP,
    HWMON_CURRENT,
    HWMON_POWER,
    HWMON_ENERGY,
    HWMON_HUMIDITY,
    HWMON_INTRUSION,
    HWMON_CHAN_TYPE_UNKNOWN = IIO_CHAN_TYPE_UNKNOWN,
};

static inline enum hwmon_chan_type hwmon_channel_get_type(const struct iio_channel *chn)
{
    return (enum hwmon_chan_type)iio_channel_get_type(chn);
}

static inline bool iio_device_is_hwmon(const struct iio_device *dev)
{
    const char *id = iio_device_get_id(dev);
 
    return id[0] == 'h';
}
 /* ------------------------------------------------------------------*/
/* ---------------------------- IIO events support ---------------------------*/
struct iio_event {
    uint64_t id;
    int64_t timestamp;
};

static inline enum iio_event_type iio_event_get_type(const struct iio_event *event)
{
    return (enum iio_event_type)((event->id >> 56) & 0xff);
}

static inline enum iio_event_direction iio_event_get_direction(const struct iio_event *event)
{
    return (enum iio_event_direction)((event->id >> 48) & 0x7f);
}

__api __check_ret const struct iio_channel *iio_event_get_channel(
        const struct iio_event *event, const struct iio_device *dev, bool diff);

__api __check_ret struct iio_event_stream *iio_device_create_event_stream(
        const struct iio_device *dev);

__api void iio_event_stream_destroy(struct iio_event_stream *stream);

__api int iio_event_stream_read(
        struct iio_event_stream *stream, struct iio_event *out_event, bool nonblock);
 /* ------------------------------------------------------------------*/
/* ------------------------- Low-level functions -----------------------------*/
struct iio_data_format {
    unsigned int length;

    unsigned int bits;

    unsigned int shift;

    bool is_signed;

    bool is_fully_defined;

    bool is_be;

    bool with_scale;

    double scale;

    unsigned int repeat;

    double offset;

    bool is_float;
};

__api struct iio_channels_mask *iio_create_channels_mask(unsigned int nb_channels);

__api void iio_channels_mask_destroy(struct iio_channels_mask *mask);

__api __check_ret ssize_t iio_device_get_sample_size(
        const struct iio_device *dev, const struct iio_channels_mask *mask);

__api __check_ret __pure long iio_channel_get_index(const struct iio_channel *chn);

__api __check_ret __cnst const struct iio_data_format *iio_channel_get_data_format(
        const struct iio_channel *chn);

__api void iio_channel_convert(const struct iio_channel *chn, void *dst, const void *src);

__api void iio_channel_convert_inverse(const struct iio_channel *chn, void *dst, const void *src);

__api __check_ret int iio_channel_refresh_format(struct iio_channel *chn);

__api __check_ret __pure unsigned int iio_device_get_event_attrs_count(
        const struct iio_device *dev);

__api __check_ret __pure const struct iio_attr *iio_device_get_event_attr(
        const struct iio_device *dev, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_device_find_event_attr(
        const struct iio_device *dev, const char *name);

__api __check_ret __pure unsigned int iio_device_get_debug_attrs_count(
        const struct iio_device *dev);

__api __check_ret __pure const struct iio_attr *iio_device_get_debug_attr(
        const struct iio_device *dev, unsigned int index);

__api __check_ret __pure const struct iio_attr *iio_device_find_debug_attr(
        const struct iio_device *dev, const char *name);

__api __check_ret int iio_device_reg_write(
        struct iio_device *dev, uint32_t address, uint32_t value);

__api __check_ret int iio_device_reg_read(
        struct iio_device *dev, uint32_t address, uint32_t *value);

 
#ifndef DOXYGEN
/* These functions can be used directly, but should be used through the generic
 * macros iio_attr_{read,write}() */
 
__api __check_ret int iio_attr_read_bool(const struct iio_attr *attr, bool *val);
 
__api __check_ret int iio_attr_read_longlong(const struct iio_attr *attr, long long *val);
 
__api __check_ret int iio_attr_read_double(const struct iio_attr *attr, double *val);
 
__api __check_ret ssize_t iio_attr_write_string(const struct iio_attr *attr, const char *src);
 
__api __check_ret int iio_attr_write_bool(const struct iio_attr *attr, bool val);
 
__api __check_ret int iio_attr_write_longlong(const struct iio_attr *attr, long long val);
 
__api __check_ret int iio_attr_write_double(const struct iio_attr *attr, double val);
 
#endif /* DOXYGEN */
 
#ifdef __cplusplus
}
#endif
 
#undef __api
 
#endif /* __IIO_H__ */