iio.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * libiio - Library for interfacing industrial I/O (IIO) devices
 *
 * Copyright (C) 2014 Analog Devices, Inc.
 * Author: Paul Cercueil <paul.cercueil@analog.com>
 */
 
#ifndef __IIO_H__
#define __IIO_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <stddef.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
 
#ifdef _WIN32
#   ifdef LIBIIO_STATIC
#   define __api
#   elif defined(LIBIIO_EXPORTS)
#   define __api __declspec(dllexport)
#   else
#   define __api __declspec(dllimport)
#   endif
#elif __GNUC__ >= 4 && !defined(MATLAB_MEX_FILE) && !defined(MATLAB_LOADLIBRARY)
#   define __api __attribute__((visibility ("default")))
#else
#   define __api
#endif
 
struct iio_context;
struct iio_device;
struct iio_channel;
struct iio_buffer;
 
struct iio_context_info;
struct iio_scan_context;
struct iio_scan_block;
 
/*
 * <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_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,
};
 
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,
};
 
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,
};
 
#endif /* _IIO_TYPES_H_ */
 
/* ---------------------------------------------------------------------------*/
/* ------------------------- Scan functions ----------------------------------*/
__api __check_ret struct iio_scan_context * iio_create_scan_context(
        const char *backend, unsigned int flags);
 
 
__api void iio_scan_context_destroy(struct iio_scan_context *ctx);
 
 
__api __check_ret ssize_t iio_scan_context_get_info_list(struct iio_scan_context *ctx,
        struct iio_context_info ***info);
 
 
__api void iio_context_info_list_free(struct iio_context_info **info);
 
 
__api __check_ret __pure const char * iio_context_info_get_description(
        const struct iio_context_info *info);
 
 
__api __check_ret __pure const char * iio_context_info_get_uri(
        const struct iio_context_info *info);
 
 
__api struct iio_scan_block * iio_create_scan_block(
        const char *backend, unsigned int flags);
 
 
__api void iio_scan_block_destroy(struct iio_scan_block *blk);
 
 
__api ssize_t iio_scan_block_scan(struct iio_scan_block *blk);
 
 
__api struct iio_context_info *iio_scan_block_get_info(
        struct iio_scan_block *blk, unsigned int index);
 
/* ------------------------------------------------------------------*/
/* ------------------------- Top-level functions -----------------------------*/
__api void iio_library_get_version(unsigned int *major,
        unsigned int *minor, char git_tag[8]);
 
 
__api void iio_strerror(int err, char *dst, size_t len);
 
 
__api __check_ret __cnst bool iio_has_backend(const char *backend);
 
 
__api __check_ret __cnst unsigned int iio_get_backends_count(void);
 
 
__api __check_ret __cnst const char * iio_get_backend(unsigned int index);
 
/* ------------------------------------------------------------------*/
/* ------------------------- Context functions -------------------------------*/
__api __check_ret struct iio_context * iio_create_default_context(void);
 
 
__api __check_ret struct iio_context * iio_create_local_context(void);
 
 
__api __check_ret struct iio_context * iio_create_xml_context(const char *xml_file);
 
 
__api __check_ret struct iio_context * iio_create_xml_context_mem(
        const char *xml, size_t len);
 
 
__api __check_ret struct iio_context * iio_create_network_context(const char *host);
 
 
__api __check_ret struct iio_context * iio_create_context_from_uri(const char *uri);
 
 
__api __check_ret struct iio_context * iio_context_clone(const struct iio_context *ctx);
 
 
__api void iio_context_destroy(struct iio_context *ctx);
 
 
__api __check_ret int iio_context_get_version(const struct iio_context *ctx,
        unsigned int *major, unsigned int *minor, char git_tag[8]);
 
 
__api __check_ret __pure const 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 int iio_context_get_attr(
        const struct iio_context *ctx, unsigned int index,
        const char **name, const char **value);
 
 
__api __check_ret const char * iio_context_get_attr_value(
        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, unsigned int timeout_ms);
 
/* ------------------------------------------------------------------*/
/* ------------------------- 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_buffer_attrs_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 char * iio_device_get_attr(
        const struct iio_device *dev, unsigned int index);
 
__api __check_ret __pure const char * iio_device_get_buffer_attr(
        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 char * iio_device_find_attr(
        const struct iio_device *dev, const char *name);
 
__api __check_ret __pure const char * iio_device_find_buffer_attr(
        const struct iio_device *dev, const char *name);
 
__api __check_ret ssize_t iio_device_attr_read(const struct iio_device *dev,
        const char *attr, char *dst, size_t len);
 
 
__api __check_ret int iio_device_attr_read_all(struct iio_device *dev,
        int (*cb)(struct iio_device *dev, const char *attr,
            const char *value, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_device_attr_read_bool(const struct iio_device *dev,
        const char *attr, bool *val);
 
 
__api __check_ret int iio_device_attr_read_longlong(const struct iio_device *dev,
        const char *attr, long long *val);
 
 
__api __check_ret int iio_device_attr_read_double(const struct iio_device *dev,
        const char *attr, double *val);
 
 
__api __check_ret ssize_t iio_device_attr_write(const struct iio_device *dev,
        const char *attr, const char *src);
 
 
__api __check_ret ssize_t iio_device_attr_write_raw(const struct iio_device *dev,
        const char *attr, const void *src, size_t len);
 
 
__api __check_ret int iio_device_attr_write_all(struct iio_device *dev,
        ssize_t (*cb)(struct iio_device *dev,
            const char *attr, void *buf, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_device_attr_write_bool(const struct iio_device *dev,
        const char *attr, bool val);
 
 
__api __check_ret int iio_device_attr_write_longlong(const struct iio_device *dev,
        const char *attr, long long val);
 
 
__api __check_ret int iio_device_attr_write_double(const struct iio_device *dev,
        const char *attr, double val);
 
__api __check_ret ssize_t iio_device_buffer_attr_read(const struct iio_device *dev,
        const char *attr, char *dst, size_t len);
 
__api __check_ret int iio_device_buffer_attr_read_all(struct iio_device *dev,
        int (*cb)(struct iio_device *dev, const char *attr,
            const char *value, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_device_buffer_attr_read_bool(const struct iio_device *dev,
        const char *attr, bool *val);
 
 
__api __check_ret int iio_device_buffer_attr_read_longlong(const struct iio_device *dev,
        const char *attr, long long *val);
 
 
__api __check_ret int iio_device_buffer_attr_read_double(const struct iio_device *dev,
        const char *attr, double *val);
 
 
__api __check_ret ssize_t iio_device_buffer_attr_write(const struct iio_device *dev,
        const char *attr, const char *src);
 
 
__api __check_ret ssize_t iio_device_buffer_attr_write_raw(const struct iio_device *dev,
        const char *attr, const void *src, size_t len);
 
 
__api __check_ret int iio_device_buffer_attr_write_all(struct iio_device *dev,
        ssize_t (*cb)(struct iio_device *dev,
            const char *attr, void *buf, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_device_buffer_attr_write_bool(const struct iio_device *dev,
        const char *attr, bool val);
 
 
__api __check_ret int iio_device_buffer_attr_write_longlong(const struct iio_device *dev,
        const char *attr, long long val);
 
 
__api __check_ret int iio_device_buffer_attr_write_double(const struct iio_device *dev,
        const char *attr, double val);
 
 
__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 int iio_device_get_trigger(const struct iio_device *dev,
        const struct iio_device **trigger);
 
 
__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);
 
__api __check_ret int iio_device_set_kernel_buffers_count(const struct iio_device *dev,
        unsigned int nb_buffers);
/* ------------------------------------------------------------------*/
/* ------------------------- 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 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 char * iio_channel_get_attr(
        const struct iio_channel *chn, unsigned int index);
 
 
__api __check_ret __pure const char * iio_channel_find_attr(
        const struct iio_channel *chn, const char *name);
 
 
__api __check_ret __pure const char * iio_channel_attr_get_filename(
        const struct iio_channel *chn, const char *attr);
 
 
__api __check_ret ssize_t iio_channel_attr_read(const struct iio_channel *chn,
        const char *attr, char *dst, size_t len);
 
 
__api __check_ret int iio_channel_attr_read_all(struct iio_channel *chn,
        int (*cb)(struct iio_channel *chn,
            const char *attr, const char *val, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_channel_attr_read_bool(const struct iio_channel *chn,
        const char *attr, bool *val);
 
 
__api __check_ret int iio_channel_attr_read_longlong(const struct iio_channel *chn,
        const char *attr, long long *val);
 
 
__api __check_ret int iio_channel_attr_read_double(const struct iio_channel *chn,
        const char *attr, double *val);
 
 
__api __check_ret ssize_t iio_channel_attr_write(const struct iio_channel *chn,
        const char *attr, const char *src);
 
 
__api __check_ret ssize_t iio_channel_attr_write_raw(const struct iio_channel *chn,
        const char *attr, const void *src, size_t len);
 
 
__api __check_ret int iio_channel_attr_write_all(struct iio_channel *chn,
        ssize_t (*cb)(struct iio_channel *chn,
            const char *attr, void *buf, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_channel_attr_write_bool(const struct iio_channel *chn,
        const char *attr, bool val);
 
 
__api __check_ret int iio_channel_attr_write_longlong(const struct iio_channel *chn,
        const char *attr, long long val);
 
 
__api __check_ret int iio_channel_attr_write_double(const struct iio_channel *chn,
        const char *attr, double val);
 
 
__api void iio_channel_enable(struct iio_channel *chn);
 
 
__api void iio_channel_disable(struct iio_channel *chn);
 
 
__api __check_ret bool iio_channel_is_enabled(const struct iio_channel *chn);
 
 
__api __check_ret size_t iio_channel_read_raw(const struct iio_channel *chn,
        struct iio_buffer *buffer, void *dst, size_t len);
 
 
__api __check_ret size_t iio_channel_read(const struct iio_channel *chn,
        struct iio_buffer *buffer, void *dst, size_t len);
 
 
__api __check_ret size_t iio_channel_write_raw(const struct iio_channel *chn,
        struct iio_buffer *buffer, const void *src, size_t len);
 
 
__api __check_ret size_t iio_channel_write(const struct iio_channel *chn,
        struct iio_buffer *buffer, const void *src, size_t len);
 
 
__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 struct iio_buffer * iio_device_create_buffer(const struct iio_device *dev,
        size_t samples_count, bool cyclic);
 
 
__api void iio_buffer_destroy(struct iio_buffer *buf);
 
__api __check_ret int iio_buffer_get_poll_fd(struct iio_buffer *buf);
 
__api __check_ret int iio_buffer_set_blocking_mode(struct iio_buffer *buf, bool blocking);
 
 
__api __check_ret ssize_t iio_buffer_refill(struct iio_buffer *buf);
 
 
__api __check_ret ssize_t iio_buffer_push(struct iio_buffer *buf);
 
 
__api __check_ret ssize_t iio_buffer_push_partial(struct iio_buffer *buf,
        size_t samples_count);
 
__api void iio_buffer_cancel(struct iio_buffer *buf);
 
 
__api void * iio_buffer_start(const struct iio_buffer *buf);
 
 
__api void * iio_buffer_first(const struct iio_buffer *buf,
        const struct iio_channel *chn);
 
 
__api __check_ret ptrdiff_t iio_buffer_step(const struct iio_buffer *buf);
 
 
__api void * iio_buffer_end(const struct iio_buffer *buf);
 
 
__api __check_ret ssize_t iio_buffer_foreach_sample(struct iio_buffer *buf,
        ssize_t (*callback)(const struct iio_channel *chn,
            void *src, size_t bytes, void *d), void *data);
 
 
__api void iio_buffer_set_data(struct iio_buffer *buf, void *data);
 
 
__api void * iio_buffer_get_data(const struct iio_buffer *buf);
/* ------------------------------------------------------------------*/
/* ---------------------------- 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';
}
 
/* ------------------------------------------------------------------*/
/* ------------------------- 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;
};
 
 
__api __check_ret ssize_t iio_device_get_sample_size(const struct iio_device *dev);
 
 
__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 __pure unsigned int iio_device_get_debug_attrs_count(
        const struct iio_device *dev);
 
 
__api __check_ret __pure const char * iio_device_get_debug_attr(
        const struct iio_device *dev, unsigned int index);
 
 
__api __check_ret __pure const char * iio_device_find_debug_attr(
        const struct iio_device *dev, const char *name);
 
 
__api __check_ret ssize_t iio_device_debug_attr_read(const struct iio_device *dev,
        const char *attr, char *dst, size_t len);
 
 
__api __check_ret int iio_device_debug_attr_read_all(struct iio_device *dev,
        int (*cb)(struct iio_device *dev, const char *attr,
            const char *value, size_t len, void *d),
        void *data);
 
 
__api __check_ret ssize_t iio_device_debug_attr_write(const struct iio_device *dev,
        const char *attr, const char *src);
 
 
__api __check_ret ssize_t iio_device_debug_attr_write_raw(const struct iio_device *dev,
        const char *attr, const void *src, size_t len);
 
 
__api __check_ret int iio_device_debug_attr_write_all(struct iio_device *dev,
        ssize_t (*cb)(struct iio_device *dev,
            const char *attr, void *buf, size_t len, void *d),
        void *data);
 
 
__api __check_ret int iio_device_debug_attr_read_bool(const struct iio_device *dev,
        const char *attr, bool *val);
 
 
__api __check_ret int iio_device_debug_attr_read_longlong(const struct iio_device *dev,
        const char *attr, long long *val);
 
 
__api __check_ret int iio_device_debug_attr_read_double(const struct iio_device *dev,
        const char *attr, double *val);
 
 
__api __check_ret int iio_device_debug_attr_write_bool(const struct iio_device *dev,
        const char *attr, bool val);
 
 
__api __check_ret int iio_device_debug_attr_write_longlong(const struct iio_device *dev,
        const char *attr, long long val);
 
 
__api __check_ret int iio_device_debug_attr_write_double(const struct iio_device *dev,
        const char *attr, double val);
 
 
__api __check_ret int iio_device_identify_filename(const struct iio_device *dev,
        const char *filename, struct iio_channel **chn,
        const char **attr);
 
 
__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);
 
 
#ifdef __cplusplus
}
#endif
 
#undef __api
 
#endif /* __IIO_H__ */