iio.h

Go to the documentation of this file.

/* The industrial I/O core
 *
 * Copyright (c) 2008 Jonathan Cameron
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
#ifndef _INDUSTRIAL_IO_H_
#define _INDUSTRIAL_IO_H_

#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/iio/types.h>
/* IIO TODO LIST */
/*
 * Provide means of adjusting timer accuracy.
 * Currently assumes nano seconds.
 */

enum iio_chan_info_enum {
    IIO_CHAN_INFO_RAW = 0,
    IIO_CHAN_INFO_PROCESSED,
    IIO_CHAN_INFO_SCALE,
    IIO_CHAN_INFO_OFFSET,
    IIO_CHAN_INFO_CALIBSCALE,
    IIO_CHAN_INFO_CALIBBIAS,
    IIO_CHAN_INFO_PEAK,
    IIO_CHAN_INFO_PEAK_SCALE,
    IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW,
    IIO_CHAN_INFO_AVERAGE_RAW,
    IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY,
    IIO_CHAN_INFO_SAMP_FREQ,
    IIO_CHAN_INFO_FREQUENCY,
    IIO_CHAN_INFO_PHASE,
    IIO_CHAN_INFO_HARDWAREGAIN,
    IIO_CHAN_INFO_HYSTERESIS,
};

#define IIO_CHAN_INFO_SHARED_BIT(type) BIT(type*2)
#define IIO_CHAN_INFO_SEPARATE_BIT(type) BIT(type*2 + 1)
#define IIO_CHAN_INFO_BITS(type) (IIO_CHAN_INFO_SHARED_BIT(type) | \
                    IIO_CHAN_INFO_SEPARATE_BIT(type))

#define IIO_CHAN_INFO_RAW_SEPARATE_BIT          \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_RAW)
#define IIO_CHAN_INFO_PROCESSED_SEPARATE_BIT            \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PROCESSED)
#define IIO_CHAN_INFO_SCALE_SEPARATE_BIT        \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_SCALE)
#define IIO_CHAN_INFO_SCALE_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_SCALE)
#define IIO_CHAN_INFO_OFFSET_SEPARATE_BIT           \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_OFFSET)
#define IIO_CHAN_INFO_OFFSET_SHARED_BIT         \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_OFFSET)
#define IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT           \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_CALIBSCALE)
#define IIO_CHAN_INFO_CALIBSCALE_SHARED_BIT         \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_CALIBSCALE)
#define IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT            \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_CALIBBIAS)
#define IIO_CHAN_INFO_CALIBBIAS_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_CALIBBIAS)
#define IIO_CHAN_INFO_PEAK_SEPARATE_BIT         \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PEAK)
#define IIO_CHAN_INFO_PEAK_SHARED_BIT           \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PEAK)
#define IIO_CHAN_INFO_PEAKSCALE_SEPARATE_BIT            \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PEAKSCALE)
#define IIO_CHAN_INFO_PEAKSCALE_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PEAKSCALE)
#define IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW_SEPARATE_BIT    \
    IIO_CHAN_INFO_SEPARATE_BIT(             \
        IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW)
#define IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW_SHARED_BIT  \
    IIO_CHAN_INFO_SHARED_BIT(               \
        IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW)
#define IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT          \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_AVERAGE_RAW)
#define IIO_CHAN_INFO_AVERAGE_RAW_SHARED_BIT            \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_AVERAGE_RAW)
#define IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT \
    IIO_CHAN_INFO_SHARED_BIT(                  \
        IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY)
#define IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SEPARATE_BIT \
    IIO_CHAN_INFO_SEPARATE_BIT(                \
        IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY)
#define IIO_CHAN_INFO_SAMP_FREQ_SEPARATE_BIT        \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_SAMP_FREQ)
#define IIO_CHAN_INFO_SAMP_FREQ_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_SAMP_FREQ)
#define IIO_CHAN_INFO_FREQUENCY_SEPARATE_BIT            \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_FREQUENCY)
#define IIO_CHAN_INFO_FREQUENCY_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_FREQUENCY)
#define IIO_CHAN_INFO_PHASE_SEPARATE_BIT            \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PHASE)
#define IIO_CHAN_INFO_PHASE_SHARED_BIT          \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PHASE)
#define IIO_CHAN_INFO_HARDWAREGAIN_SEPARATE_BIT         \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_HARDWAREGAIN)
#define IIO_CHAN_INFO_HARDWAREGAIN_SHARED_BIT           \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_HARDWAREGAIN)
#define IIO_CHAN_INFO_HYSTERESIS_SEPARATE_BIT           \
    IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_HYSTERESIS)
#define IIO_CHAN_INFO_HYSTERESIS_SHARED_BIT         \
    IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_HYSTERESIS)

enum iio_endian {
    IIO_CPU,
    IIO_BE,
    IIO_LE,
};

struct iio_chan_spec;
struct iio_dev;

struct iio_chan_spec_ext_info {
    const char *name;
    bool shared;
    ssize_t (*read)(struct iio_dev *, uintptr_t private,
            struct iio_chan_spec const *, char *buf);
    ssize_t (*write)(struct iio_dev *, uintptr_t private,
             struct iio_chan_spec const *, const char *buf,
             size_t len);
    uintptr_t private;
};

struct iio_enum {
    const char * const *items;
    unsigned int num_items;
    int (*set)(struct iio_dev *, const struct iio_chan_spec *, unsigned int);
    int (*get)(struct iio_dev *, const struct iio_chan_spec *);
};

ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
    uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
ssize_t iio_enum_read(struct iio_dev *indio_dev,
    uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
ssize_t iio_enum_write(struct iio_dev *indio_dev,
    uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
    size_t len);

#define IIO_ENUM(_name, _shared, _e) \
{ \
    .name = (_name), \
    .shared = (_shared), \
    .read = iio_enum_read, \
    .write = iio_enum_write, \
    .private = (uintptr_t)(_e), \
}

#define IIO_ENUM_AVAILABLE(_name, _e) \
{ \
    .name = (_name "_available"), \
    .shared = true, \
    .read = iio_enum_available_read, \
    .private = (uintptr_t)(_e), \
}

struct iio_chan_spec {
    enum iio_chan_type  type;
    int         channel;
    int         channel2;
    unsigned long       address;
    int         scan_index;
    struct {
        char    sign;
        u8  realbits;
        u8  storagebits;
        u8  shift;
        enum iio_endian endianness;
    } scan_type;
    long            info_mask;
    long            event_mask;
    const struct iio_chan_spec_ext_info *ext_info;
    const char      *extend_name;
    const char      *datasheet_name;
    unsigned        modified:1;
    unsigned        indexed:1;
    unsigned        output:1;
    unsigned        differential:1;
};


static inline bool iio_channel_has_info(const struct iio_chan_spec *chan,
    enum iio_chan_info_enum type)
{
    return chan->info_mask & IIO_CHAN_INFO_BITS(type);
}

#define IIO_ST(si, rb, sb, sh)                      \
    { .sign = si, .realbits = rb, .storagebits = sb, .shift = sh }

#define IIO_CHAN_SOFT_TIMESTAMP(_si)                    \
    { .type = IIO_TIMESTAMP, .channel = -1,             \
            .scan_index = _si, .scan_type = IIO_ST('s', 64, 64, 0) }

static inline s64 iio_get_time_ns(void)
{
    struct timespec ts;
    /*
     * calls getnstimeofday.
     * If hrtimers then up to ns accurate, if not microsecond.
     */
    ktime_get_real_ts(&ts);

    return timespec_to_ns(&ts);
}

/* Device operating modes */
#define INDIO_DIRECT_MODE       0x01
#define INDIO_BUFFER_TRIGGERED      0x02
#define INDIO_BUFFER_HARDWARE       0x08

#define INDIO_ALL_BUFFER_MODES                  \
    (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)

struct iio_trigger; /* forward declaration */
struct iio_dev;

struct iio_info {
    struct module           *driver_module;
    struct attribute_group      *event_attrs;
    const struct attribute_group    *attrs;

    int (*read_raw)(struct iio_dev *indio_dev,
            struct iio_chan_spec const *chan,
            int *val,
            int *val2,
            long mask);

    int (*write_raw)(struct iio_dev *indio_dev,
             struct iio_chan_spec const *chan,
             int val,
             int val2,
             long mask);

    int (*write_raw_get_fmt)(struct iio_dev *indio_dev,
             struct iio_chan_spec const *chan,
             long mask);

    int (*read_event_config)(struct iio_dev *indio_dev,
                 u64 event_code);

    int (*write_event_config)(struct iio_dev *indio_dev,
                  u64 event_code,
                  int state);

    int (*read_event_value)(struct iio_dev *indio_dev,
                u64 event_code,
                int *val);
    int (*write_event_value)(struct iio_dev *indio_dev,
                 u64 event_code,
                 int val);
    int (*validate_trigger)(struct iio_dev *indio_dev,
                struct iio_trigger *trig);
    int (*update_scan_mode)(struct iio_dev *indio_dev,
                const unsigned long *scan_mask);
    int (*debugfs_reg_access)(struct iio_dev *indio_dev,
                  unsigned reg, unsigned writeval,
                  unsigned *readval);
};

struct iio_buffer_setup_ops {
    int (*preenable)(struct iio_dev *);
    int (*postenable)(struct iio_dev *);
    int (*predisable)(struct iio_dev *);
    int (*postdisable)(struct iio_dev *);
    bool (*validate_scan_mask)(struct iio_dev *indio_dev,
                   const unsigned long *scan_mask);
};

struct iio_dev {
    int             id;

    int             modes;
    int             currentmode;
    struct device           dev;

    struct iio_event_interface  *event_interface;

    struct iio_buffer       *buffer;
    int             scan_bytes;
    struct mutex            mlock;

    const unsigned long     *available_scan_masks;
    unsigned            masklength;
    const unsigned long     *active_scan_mask;
    bool                scan_timestamp;
    unsigned            scan_index_timestamp;
    struct iio_trigger      *trig;
    struct iio_poll_func        *pollfunc;

    struct iio_chan_spec const  *channels;
    int             num_channels;

    struct list_head        channel_attr_list;
    struct attribute_group      chan_attr_group;
    const char          *name;
    const struct iio_info       *info;
    struct mutex            info_exist_lock;
    const struct iio_buffer_setup_ops   *setup_ops;
    struct cdev         chrdev;
#define IIO_MAX_GROUPS 6
    const struct attribute_group    *groups[IIO_MAX_GROUPS + 1];
    int             groupcounter;

    unsigned long           flags;
#if defined(CONFIG_DEBUG_FS)
    struct dentry           *debugfs_dentry;
    unsigned            cached_reg_addr;
#endif
};

const struct iio_chan_spec
*iio_find_channel_from_si(struct iio_dev *indio_dev, int si);

int iio_device_register(struct iio_dev *indio_dev);

void iio_device_unregister(struct iio_dev *indio_dev);

int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp);

extern struct bus_type iio_bus_type;

static inline void iio_device_put(struct iio_dev *indio_dev)
{
    if (indio_dev)
        put_device(&indio_dev->dev);
};

static inline struct iio_dev *dev_to_iio_dev(struct device *dev)
{
    return container_of(dev, struct iio_dev, dev);
}

static inline struct iio_dev *iio_device_get(struct iio_dev *indio_dev)
{
    return indio_dev ? dev_to_iio_dev(get_device(&indio_dev->dev)) : NULL;
}


static inline void iio_device_set_drvdata(struct iio_dev *indio_dev, void *data)
{
    dev_set_drvdata(&indio_dev->dev, data);
}

static inline void *iio_device_get_drvdata(struct iio_dev *indio_dev)
{
    return dev_get_drvdata(&indio_dev->dev);
}

/* Can we make this smaller? */
#define IIO_ALIGN L1_CACHE_BYTES

struct iio_dev *iio_device_alloc(int sizeof_priv);

static inline void *iio_priv(const struct iio_dev *indio_dev)
{
    return (char *)indio_dev + ALIGN(sizeof(struct iio_dev), IIO_ALIGN);
}

static inline struct iio_dev *iio_priv_to_dev(void *priv)
{
    return (struct iio_dev *)((char *)priv -
                  ALIGN(sizeof(struct iio_dev), IIO_ALIGN));
}

void iio_device_free(struct iio_dev *indio_dev);

static inline bool iio_buffer_enabled(struct iio_dev *indio_dev)
{
    return indio_dev->currentmode
        & (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE);
};

#if defined(CONFIG_DEBUG_FS)
static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
{
    return indio_dev->debugfs_dentry;
};
#else
static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
{
    return NULL;
};
#endif

#define IIO_DEGREE_TO_RAD(deg) (((deg) * 314159ULL + 9000000ULL) / 18000000ULL)

#define IIO_G_TO_M_S_2(g) ((g) * 980665ULL / 100000ULL)

#endif /* _INDUSTRIAL_IO_H_ */