Core elements¶

The Industrial I/O core offers both a unified framework for writing drivers formany different types of embedded sensors and a standard interface to user spaceapplications manipulating sensors. The implementation can be found underdrivers/iio/industrialio-*

Industrial I/O Devices¶

structiio_dev - industrial I/O device
iio_device_alloc() - allocate aniio_dev from a driver
iio_device_free() - free aniio_dev from a driver
iio_device_register() - register a device with the IIO subsystem
iio_device_unregister() - unregister a device from the IIOsubsystem

An IIO device usually corresponds to a single hardware sensor and itprovides all the information needed by a driver handling a device.Let’s first have a look at the functionality embedded in an IIO devicethen we will show how a device driver makes use of an IIO device.

There are two ways for a user space application to interact with an IIO driver.

/sys/bus/iio/devices/iio:deviceX/, this represents a hardware sensorand groups together the data channels of the same chip.
/dev/iio:deviceX, character device node interface used forbuffered data transfer and for events information retrieval.

A typical IIO driver will register itself as anI2C orSPI driver and will create two routines, probe and remove.

At probe:

Calliio_device_alloc(), which allocates memory for an IIO device.
Initialize IIO device fields with driver specific information (e.g.device name, device channels).
Calliio_device_register(), this registers the device with theIIO core. After this call the device is ready to accept requests from userspace applications.

At remove, we free the resources allocated in probe in reverse order:

iio_device_unregister(), unregister the device from the IIO core.
iio_device_free(), free the memory allocated for the IIO device.

IIO device sysfs interface¶

Attributes are sysfs files used to expose chip info and also allowingapplications to set various configuration parameters. For device withindex X, attributes can be found under /sys/bus/iio/devices/iio:deviceX/directory. Common attributes are:

name, description of the physical chip.
dev, shows the major:minor pair associated with/dev/iio:deviceX node.
sampling_frequency_available, available discrete set of samplingfrequency values for device.
Available standard attributes for IIO devices are described in the:file:Documentation/ABI/testing/sysfs-bus-iio file in the Linux kernelsources.

IIO device channels¶

structiio_chan_spec - specification of a single channel

An IIO device channel is a representation of a data channel. An IIO device canhave one or multiple channels. For example:

a thermometer sensor has one channel representing the temperature measurement.
a light sensor with two channels indicating the measurements in the visibleand infrared spectrum.
an accelerometer can have up to 3 channels representing acceleration on X, Yand Z axes.

An IIO channel is described by thestructiio_chan_spec.A thermometer driver for the temperature sensor in the example above wouldhave to describe its channel as follows:

static const struct iio_chan_spec temp_channel[] = {     {         .type = IIO_TEMP,         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),     },};

Channel sysfs attributes exposed to userspace are specified in the form ofbitmasks. Depending on their shared info, attributes can be set in one of thefollowing masks:

info_mask_separate, attributes will be specific tothis channel
info_mask_shared_by_type, attributes are shared by all channels of thesame type
info_mask_shared_by_dir, attributes are shared by all channels of the samedirection
info_mask_shared_by_all, attributes are shared by all channels

When there are multiple data channels per channel type we have two ways todistinguish between them:

set.modified field ofiio_chan_spec to 1. Modifiers arespecified using.channel2 field of the sameiio_chan_specstructure and are used to indicate a physically unique characteristic of thechannel such as its direction or spectral response. For example, a lightsensor can have two channels, one for infrared light and one for bothinfrared and visible light.
set.indexed field ofiio_chan_spec to 1. In this case thechannel is simply another instance with an index specified by the.channelfield.

Here is how we can make use of the channel’s modifiers:

static const struct iio_chan_spec light_channels[] = {        {                .type = IIO_INTENSITY,                .modified = 1,                .channel2 = IIO_MOD_LIGHT_IR,                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                .info_mask_shared = BIT(IIO_CHAN_INFO_SAMP_FREQ),        },        {                .type = IIO_INTENSITY,                .modified = 1,                .channel2 = IIO_MOD_LIGHT_BOTH,                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                .info_mask_shared = BIT(IIO_CHAN_INFO_SAMP_FREQ),        },        {                .type = IIO_LIGHT,                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),                .info_mask_shared = BIT(IIO_CHAN_INFO_SAMP_FREQ),        },   }

This channel’s definition will generate two separate sysfs files for raw dataretrieval:

/sys/bus/iio/devices/iio:deviceX/in_intensity_ir_raw
/sys/bus/iio/devices/iio:deviceX/in_intensity_both_raw

one file for processed data:

/sys/bus/iio/devices/iio:deviceX/in_illuminance_input

and one shared sysfs file for sampling frequency:

/sys/bus/iio/devices/iio:deviceX/sampling_frequency.

Here is how we can make use of the channel’s indexing:

static const struct iio_chan_spec light_channels[] = {        {                .type = IIO_VOLTAGE,                .indexed = 1,                .channel = 0,                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),        },        {                .type = IIO_VOLTAGE,                .indexed = 1,                .channel = 1,                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),        },}

This will generate two separate attributes files for raw data retrieval:

/sys/bus/iio/devices/iio:deviceX/in_voltage0_raw, representingvoltage measurement for channel 0.
/sys/bus/iio/devices/iio:deviceX/in_voltage1_raw, representingvoltage measurement for channel 1.

More details¶

structiio_chan_spec_ext_info¶: Extended channel info attribute

Definition:

struct iio_chan_spec_ext_info {    const char *name;    enum iio_shared_by 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;};

Members

name: Info attribute name
shared: Whether this attribute is shared between all channels.
read: Read callback for this info attribute, may be NULL.
write: Write callback for this info attribute, may be NULL.
private: Data private to the driver.

structiio_enum¶: Enum channel info attribute

Definition:

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 *);};

Members

items: An array of strings.
num_items: Length of the item array.
set: Set callback function, may be NULL.
get: Get callback function, may be NULL.

Description

The iio_enumstructcan be used to implementenumstyle channel attributes.Enum style attributes are those which have a set of strings which map tounsigned integer values. The IIOenumhelper code takes care of mappingbetween value and string as well as generating a “_available” file whichcontains a list of all available items. The set callback will be called whenthe attribute is updated. The last parameter is the index to the newlyactivated item. The get callback will be used to query the currently activeitem and is supposed to return the index for it.

IIO_ENUM¶

IIO_ENUM(_name,_shared,_e)

Initializeenumextended channel attribute

Parameters

_name: Attribute name
_shared: Whether the attribute is shared between all channels
_e: Pointer to an iio_enum struct

Description

This should usually be used together withIIO_ENUM_AVAILABLE()

IIO_ENUM_AVAILABLE¶

IIO_ENUM_AVAILABLE(_name,_shared,_e)

Initializeenumavailable extended channel attribute

Parameters

_name: Attribute name (“_available” will be appended to the name)
_shared: Whether the attribute is shared between all channels
_e: Pointer to an iio_enum struct

Description

Creates a read only attribute which lists all the availableenumitems in aspace separated list. This should usually be used together withIIO_ENUM()

structiio_mount_matrix¶: iio mounting matrix

Definition:

struct iio_mount_matrix {    const char *rotation[9];};

Members

rotation: 3 dimensional space rotation matrix defining sensor alignment withmain hardware

IIO_MOUNT_MATRIX¶

IIO_MOUNT_MATRIX(_shared,_get)

Initialize mount matrix extended channel attribute

Parameters

_shared: Whether the attribute is shared between all channels
_get: Pointer to an iio_get_mount_matrix_t accessor

structiio_event_spec¶: specification for a channel event

Definition:

struct iio_event_spec {    enum iio_event_type type;    enum iio_event_direction dir;    unsigned long mask_separate;    unsigned long mask_shared_by_type;    unsigned long mask_shared_by_dir;    unsigned long mask_shared_by_all;};

Members

type: Type of the event
dir: Direction of the event
mask_separate: Bit mask ofenumiio_event_info values. Attributesset in this mask will be registered per channel.
mask_shared_by_type: Bit mask ofenumiio_event_info values. Attributesset in this mask will be shared by channel type.
mask_shared_by_dir: Bit mask ofenumiio_event_info values. Attributesset in this mask will be shared by channel type anddirection.
mask_shared_by_all: Bit mask ofenumiio_event_info values. Attributesset in this mask will be shared by all channels.

structiio_scan_type¶: specification for channel data format in buffer

Definition:

struct iio_scan_type {    char sign;    u8 realbits;    u8 storagebits;    u8 shift;    u8 repeat;    enum iio_endian endianness;};

Members

sign: ‘s’ or ‘u’ to specify signed or unsigned
realbits: Number of valid bits of data
storagebits: Realbits + padding
shift: Shift right by this before masking out realbits.
repeat: Number of times real/storage bits repeats. When therepeat element is more than 1, then the type element insysfs will show a repeat value. Otherwise, the numberof repetitions is omitted.
endianness: little or big endian

structiio_chan_spec¶: specification of a single channel

Definition:

struct iio_chan_spec {    enum iio_chan_type      type;    int channel;    int channel2;    unsigned long           address;    int scan_index;    union {        struct iio_scan_type scan_type;        struct {            const struct iio_scan_type *ext_scan_type;            unsigned int num_ext_scan_type;        };    };    unsigned long                   info_mask_separate;    unsigned long                   info_mask_separate_available;    unsigned long                   info_mask_shared_by_type;    unsigned long                   info_mask_shared_by_type_available;    unsigned long                   info_mask_shared_by_dir;    unsigned long                   info_mask_shared_by_dir_available;    unsigned long                   info_mask_shared_by_all;    unsigned long                   info_mask_shared_by_all_available;    const struct iio_event_spec *event_spec;    unsigned int            num_event_specs;    const struct iio_chan_spec_ext_info *ext_info;    const char              *extend_name;    const char              *datasheet_name;    unsigned int            modified:1;    unsigned int            indexed:1;    unsigned int            output:1;    unsigned int            differential:1;    unsigned int            has_ext_scan_type:1;};

Members

type: What type of measurement is the channel making.
channel: What number do we wish to assign the channel.
channel2: If there is a second number for a differentialchannel then this is it. If modified is set then thevalue here specifies the modifier.
address: Driver specific identifier.
scan_index: Monotonic index to give ordering in scans when readfrom a buffer.
{unnamed_union}: anonymous
scan_type: structdescribing the scan type - mutually exclusivewith ext_scan_type.
{unnamed_struct}: anonymous
ext_scan_type: Used in rare cases where there is more than one scanformat for a channel. When this is used, the flaghas_ext_scan_type must be set and the driver mustimplement get_current_scan_type instructiio_info.
num_ext_scan_type: Number of elements in ext_scan_type.
info_mask_separate: What information is to be exported that is specific tothis channel.
info_mask_separate_available: What availability information is to beexported that is specific to this channel.
info_mask_shared_by_type: What information is to be exported that is sharedby all channels of the same type.
info_mask_shared_by_type_available: What availability information is to beexported that is shared by all channels of the sametype.
info_mask_shared_by_dir: What information is to be exported that is sharedby all channels of the same direction.
info_mask_shared_by_dir_available: What availability information is to beexported that is shared by all channels of the samedirection.
info_mask_shared_by_all: What information is to be exported that is sharedby all channels.
info_mask_shared_by_all_available: What availability information is to beexported that is shared by all channels.
event_spec: Array of events which should be registered for thischannel.
num_event_specs: Size of the event_spec array.
ext_info: Array of extended info attributes for this channel.The array is NULL terminated, the last element shouldhave its name field set to NULL.
extend_name: Allows labeling of channel attributes with aninformative name. Note this has no effect codes etc,unlike modifiers.This field is deprecated in favour of providingiio_info->read_label() to override the label, whichunlikeextend_name does not affect sysfs filenames.
datasheet_name: A name used in in-kernel mapping of channels. It shouldcorrespond to the first name that the channel is referredto by in the datasheet (e.g. IND), or the nearestpossible compound name (e.g. IND-INC).
modified: Does a modifier apply to this channel. What these aredepends on the channel type. Modifier is set inchannel2. Examples are IIO_MOD_X for axial sensors aboutthe ‘x’ axis.
indexed: Specify the channel has a numerical index. If not,the channel index number will be suppressed for sysfsattributes but not for event codes.
output: Channel is output.
differential: Channel is differential.
has_ext_scan_type: True if ext_scan_type is used instead of scan_type.

booliio_channel_has_info(conststructiio_chan_spec*chan,enumiio_chan_info_enumtype)¶: Checks whether a channel supports a info attribute

Parameters

conststructiio_chan_spec*chan: The channel to be queried
enumiio_chan_info_enumtype: Type of the info attribute to be checked

Description

Returns true if the channels supports reporting values for the given infoattribute type, false otherwise.

booliio_channel_has_available(conststructiio_chan_spec*chan,enumiio_chan_info_enumtype)¶: Checks if a channel has an available attribute

Parameters

conststructiio_chan_spec*chan: The channel to be queried
enumiio_chan_info_enumtype: Type of the available attribute to be checked

Description

Returns true if the channel supports reporting available values for thegiven attribute type, false otherwise.

structiio_info¶: constant information about device

Definition:

struct iio_info {    const 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 (*read_raw_multi)(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int max_len, int *vals, int *val_len, long mask);    int (*read_avail)(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, const int **vals, int *type, int *length, long mask);    int (*write_raw)(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask);    int (*read_label)(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, char *label);    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, const struct iio_chan_spec *chan, enum iio_event_type type, enum iio_event_direction dir);    int (*write_event_config)(struct iio_dev *indio_dev, const struct iio_chan_spec *chan, enum iio_event_type type, enum iio_event_direction dir, bool state);    int (*read_event_value)(struct iio_dev *indio_dev, const struct iio_chan_spec *chan, enum iio_event_type type, enum iio_event_direction dir, enum iio_event_info info, int *val, int *val2);    int (*write_event_value)(struct iio_dev *indio_dev, const struct iio_chan_spec *chan, enum iio_event_type type, enum iio_event_direction dir, enum iio_event_info info, int val, int val2);    int (*read_event_label)(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, enum iio_event_type type, enum iio_event_direction dir, char *label);    int (*validate_trigger)(struct iio_dev *indio_dev, struct iio_trigger *trig);    int (*get_current_scan_type)(const struct iio_dev *indio_dev, const struct iio_chan_spec *chan);    int (*update_scan_mode)(struct iio_dev *indio_dev, const unsigned long *scan_mask);    int (*debugfs_reg_access)(struct iio_dev *indio_dev, unsigned int reg, unsigned int writeval, unsigned int *readval);    int (*fwnode_xlate)(struct iio_dev *indio_dev, const struct fwnode_reference_args *iiospec);    int (*hwfifo_set_watermark)(struct iio_dev *indio_dev, unsigned int val);    int (*hwfifo_flush_to_buffer)(struct iio_dev *indio_dev, unsigned int count);};

Members

event_attrs: event control attributes
attrs: general purpose device attributes
read_raw: function to request a value from the device.mask specifies which value. Note 0 means a reading ofthe channel in question. Return value will specify thetype of value returned by the device. val and val2 willcontain the elements making up the returned value.
read_raw_multi: function to return values from the device.mask specifies which value. Note 0 means a reading ofthe channel in question. Return value will specify thetype of value returned by the device. vals pointercontain the elements making up the returned value.max_len specifies maximum number of elementsvals pointer can contain. val_len is used to returnlength of valid elements in vals.
read_avail: function to return the available values from the device.mask specifies which value. Note 0 means the availablevalues for the channel in question. Return valuespecifies if a IIO_AVAIL_LIST or a IIO_AVAIL_RANGE isreturned in vals. The type of the vals are returned intype and the number of vals is returned in length. Forranges, there are always three vals returned; min, stepand max. For lists, all possible values are enumerated.
write_raw: function to write a value to the device.Parameters are the same as for read_raw.
read_label: function to request label name for a specified label,for better channel identification.
write_raw_get_fmt: callback function to query the expectedformat/precision. If not set by the driver, write_rawreturns IIO_VAL_INT_PLUS_MICRO.
read_event_config: find out if the event is enabled.
write_event_config: set if the event is enabled.
read_event_value: read a configuration value associated with the event.
write_event_value: write a configuration value for the event.
read_event_label: function to request label name for a specified label,for better event identification.
validate_trigger: function to validate the trigger when thecurrent trigger gets changed.
get_current_scan_type: must be implemented by drivers that use ext_scan_typein the channel spec to return the index of the currentlyactive ext_scan type for a channel.
update_scan_mode: function to configure device and scan buffer whenchannels have changed
debugfs_reg_access: function to read or write register value of device
fwnode_xlate: fwnode based function pointer to obtain channel specifier index.
hwfifo_set_watermark: function pointer to set the current hardwarefifo watermark level; see hwfifo_* entries inABI file testing/sysfs-bus-iio for details onhow the hardware fifo operates
hwfifo_flush_to_buffer: function pointer to flush the samples storedin the hardware fifo to the device buffer. The drivershould not flush more than count samples. The functionmust return the number of samples flushed, 0 if nosamples were flushed or a negative integer if no sampleswere flushed and there was an error.

structiio_buffer_setup_ops¶: buffer setup related callbacks

Definition:

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);};

Members

preenable: [DRIVER] function to run prior to marking buffer enabled
postenable: [DRIVER] function to run after marking buffer enabled
predisable: [DRIVER] function to run prior to marking bufferdisabled
postdisable: [DRIVER] function to run after marking buffer disabled
validate_scan_mask: [DRIVER] function callback to check whether a givenscan mask is valid for the device.

structiio_dev¶: industrial I/O device

Definition:

struct iio_dev {    int modes;    struct device                   dev;    struct iio_buffer               *buffer;    int scan_bytes;    const unsigned long             *available_scan_masks;    unsigned int  masklength;    const unsigned long             *active_scan_mask;    bool scan_timestamp;    struct iio_trigger              *trig;    struct iio_poll_func            *pollfunc;    struct iio_poll_func            *pollfunc_event;    struct iio_chan_spec const      *channels;    int num_channels;    const char                      *name;    const char                      *label;    const struct iio_info           *info;    const struct iio_buffer_setup_ops       *setup_ops;    void *  priv;};

Members

modes: [DRIVER] bitmask listing all the operating modessupported by the IIO device. This list should beinitialized before registering the IIO device. It canalso be filed up by the IIO core, as a result ofenabling particular features in the driver(seeiio_triggered_event_setup()).
dev: [DRIVER] device structure, should be assigned a parentand owner
buffer: [DRIVER] any buffer present
scan_bytes: [INTERN] num bytes captured to be fed to buffer demux
available_scan_masks: [DRIVER] optional array of allowed bitmasks. Sort thearray in order of preference, the most preferredmasks first.
masklength: [INTERN] the length of the mask established fromchannels
active_scan_mask: [INTERN]unionof all scan masks requested by buffers
scan_timestamp: [INTERN] set if any buffers have requested timestamp
trig: [INTERN] current device trigger (buffer modes)
pollfunc: [DRIVER] function run on trigger being received
pollfunc_event: [DRIVER] function run on events trigger being received
channels: [DRIVER] channel specification structure table
num_channels: [DRIVER] number of channels specified inchannels.
name: [DRIVER] name of the device.
label: [DRIVER] unique name to identify which device this is
info: [DRIVER] callbacks and constant info from driver
setup_ops: [DRIVER] callbacks to call before and after bufferenable/disable
priv: [DRIVER] reference to driver’s private informationMUST be accessedONLY viaiio_priv() helper

iio_device_register¶

iio_device_register(indio_dev)

register a device with the IIO subsystem

Parameters

indio_dev: Device structure filled by the device driver

devm_iio_device_register¶

devm_iio_device_register(dev,indio_dev)

Resource-managediio_device_register()

Parameters

dev: Device to allocate iio_dev for
indio_dev: Device structure filled by the device driver

Description

Managed iio_device_register. The IIO device registered with thisfunction is automatically unregistered on driver detach. This functioncallsiio_device_register() internally. Refer to that function for moreinformation.

Return

0 on success, negative error number on failure.

voidiio_device_put(structiio_dev*indio_dev)¶: reference counted deallocation ofstructdevice

Parameters

structiio_dev*indio_dev: IIO device structure containing the device

structiio_dev*dev_to_iio_dev(structdevice*dev)¶: Get IIO devicestructfrom a device struct

Parameters

structdevice*dev: The device embedded in the IIO device

Note

The device must be a IIO device, otherwise the result is undefined.

structiio_dev*iio_device_get(structiio_dev*indio_dev)¶: increment reference count for the device

Parameters

structiio_dev*indio_dev: IIO device structure

Return

The passed IIO device

voidiio_device_set_parent(structiio_dev*indio_dev,structdevice*parent)¶: assign parent device to the IIO device object

Parameters

structiio_dev*indio_dev: IIO device structure
structdevice*parent: reference to parent device object

Description

This utility must be called between IIO device allocation(viadevm_iio_device_alloc()) & IIO device registration(viaiio_device_register() anddevm_iio_device_register())).By default, the device allocation will also assign a parent device tothe IIO device object. In cases wheredevm_iio_device_alloc() is used,sometimes the parent device must be different than the device used tomanage the allocation.In that case, this helper should be used to change the parent, hence therequirement to call this between allocation & registration.

voidiio_device_set_drvdata(structiio_dev*indio_dev,void*data)¶: Set device driver data

Parameters

structiio_dev*indio_dev: IIO device structure
void*data: Driver specific data

Description

Allows to attach an arbitrary pointer to an IIO device, which can later beretrieved byiio_device_get_drvdata().

void*iio_device_get_drvdata(conststructiio_dev*indio_dev)¶: Get device driver data

Parameters

conststructiio_dev*indio_dev: IIO device structure

Description

Returns the data previously set withiio_device_set_drvdata()

IIO_DECLARE_BUFFER_WITH_TS¶

IIO_DECLARE_BUFFER_WITH_TS(type,name,count)

Declare a buffer with timestamp

Parameters

type: element type of the buffer
name: identifier name of the buffer
count: number of elements in the buffer

Description

Declares a buffer that is safe to use withiio_push_to_buffers_with_ts(). Inaddition to allocating enough space forcount elements oftype, it alsoallocates space for a s64 timestamp at the end of the buffer and ensuresproper alignment of the timestamp.

IIO_DECLARE_DMA_BUFFER_WITH_TS¶

IIO_DECLARE_DMA_BUFFER_WITH_TS(type,name,count)

Declare a DMA-aligned buffer with timestamp

Parameters

type: element type of the buffer
name: identifier name of the buffer
count: number of elements in the buffer

Description

Same asIIO_DECLARE_BUFFER_WITH_TS(), but is uses __aligned(IIO_DMA_MINALIGN)to ensure that the buffer doesn’t share cachelines with anything that comesbefore it in a struct. This should not be used for stack-allocated buffersas stack memory cannot generally be used for DMA.

structdentry*iio_get_debugfs_dentry(structiio_dev*indio_dev)¶: helper function to get the debugfs_dentry

Parameters

structiio_dev*indio_dev: IIO device structure for device

intiio_device_suspend_triggering(structiio_dev*indio_dev)¶: suspend trigger attached to an iio_dev

Parameters

structiio_dev*indio_dev: iio_dev associated with the device that will have triggers suspended

Description

Return 0 if successful, negative otherwise

intiio_device_resume_triggering(structiio_dev*indio_dev)¶: resume trigger attached to an iio_dev that was previously suspended withiio_device_suspend_triggering()

Parameters

structiio_dev*indio_dev: iio_dev associated with the device that will have triggers resumed

Description

Return 0 if successful, negative otherwise

conststructiio_scan_type*iio_get_current_scan_type(conststructiio_dev*indio_dev,conststructiio_chan_spec*chan)¶: Get the current scan type for a channel

Parameters

conststructiio_dev*indio_dev: the IIO device to get the scan type for
conststructiio_chan_spec*chan: the channel to get the scan type for

Description

Most devices only have one scan type per channel and can just access itdirectly without calling this function. Core IIO code and drivers thatimplement ext_scan_type in the channel spec should use this function toget the current scan type for a channel.

Return

the current scan type for the channel or error.

unsignedintiio_get_masklength(conststructiio_dev*indio_dev)¶: Get length of the channels mask

Parameters

conststructiio_dev*indio_dev: the IIO device to get the masklength for

iio_for_each_active_channel¶

iio_for_each_active_channel(indio_dev,chan)

Iterated over active channels

Parameters

indio_dev: the IIO device
chan: Holds the index of the enabled channel

IIO_DEGREE_TO_RAD¶

IIO_DEGREE_TO_RAD(deg)

Convert degree to rad

Parameters

deg: A value in degree

Description

Returns the given value converted from degree to rad

IIO_RAD_TO_DEGREE¶

IIO_RAD_TO_DEGREE(rad)

Convert rad to degree

Parameters

rad: A value in rad

Description

Returns the given value converted from rad to degree

IIO_G_TO_M_S_2¶

IIO_G_TO_M_S_2(g)

Convert g to meter / second**2

Parameters

g: A value in g

Description

Returns the given value converted from g to meter / second**2

IIO_M_S_2_TO_G¶

IIO_M_S_2_TO_G(ms2)

Convert meter / second**2 to g

Parameters

ms2: A value in meter / second**2

Description

Returns the given value converted from meter / second**2 to g

intiio_device_id(structiio_dev*indio_dev)¶: query the unique ID for the device

Parameters

structiio_dev*indio_dev: Device structure whose ID is being queried

Description

The IIO device ID is a unique index used for example for the namingof the character device /dev/iio:device[ID].

Return

Unique ID for the device.

booliio_buffer_enabled(structiio_dev*indio_dev)¶: helper function to test if the buffer is enabled

Parameters

structiio_dev*indio_dev: IIO device structure for device

Return

True, if the buffer is enabled.

intiio_device_set_clock(structiio_dev*indio_dev,clockid_tclock_id)¶: Set current timestamping clock for the device

Parameters

structiio_dev*indio_dev: IIO device structure containing the device
clockid_tclock_id: timestamping clock POSIX identifier to set.

Return

0 on success, or a negative error code.

clockid_tiio_device_get_clock(conststructiio_dev*indio_dev)¶: Retrieve current timestamping clock for the device

Parameters

conststructiio_dev*indio_dev: IIO device structure containing the device

Return

Clock ID of the current timestamping clock for the device.

s64iio_get_time_ns(conststructiio_dev*indio_dev)¶: utility function to get a time stamp for events etc

Parameters

conststructiio_dev*indio_dev: device

Return

Timestamp of the event in nanoseconds.

intiio_read_mount_matrix(structdevice*dev,structiio_mount_matrix*matrix)¶: retrieve iio device mounting matrix from device “mount-matrix” property

Parameters

structdevice*dev: device the mounting matrix property is assigned to
structiio_mount_matrix*matrix: where to store retrieved matrix

Description

If device is assigned no mounting matrix property, a default 3x3 identitymatrix will be filled in.

Return

0 if success, or a negative error code on failure.

ssize_tiio_format_value(char*buf,unsignedinttype,intsize,int*vals)¶: Formats a IIO value into its string representation

Parameters

char*buf: The buffer to which the formatted value gets writtenwhich is assumed to be big enough (i.e. PAGE_SIZE).
unsignedinttype: One of the IIO_VAL_* constants. This decides how the valand val2 parameters are formatted.
intsize: Number of IIO value entries contained in vals
int*vals: Pointer to the values, exact meaning depends on thetype parameter.

Return

0 by default, a negative number on failure or the total number of characterswritten for a type that belongs to the IIO_VAL_* constant.

intiio_str_to_fixpoint(constchar*str,intfract_mult,int*integer,int*fract)¶: Parse a fixed-point number from a string

Parameters

constchar*str: The string to parse
intfract_mult: Multiplier for the first decimal place, should be a power of 10
int*integer: The integer part of the number
int*fract: The fractional part of the number

Return

0 on success, or a negative error code if the string could not be parsed.

structiio_dev*iio_device_alloc(structdevice*parent,intsizeof_priv)¶: allocate an iio_dev from a driver

Parameters

structdevice*parent: Parent device.
intsizeof_priv: Space to allocate for private structure.

Return

Pointer to allocated iio_dev on success, NULL on failure.

voidiio_device_free(structiio_dev*dev)¶: free an iio_dev from a driver

Parameters

structiio_dev*dev: the iio_dev associated with the device

structiio_dev*devm_iio_device_alloc(structdevice*parent,intsizeof_priv)¶: Resource-managediio_device_alloc()

Parameters

structdevice*parent: Device to allocate iio_dev for, and parent for this IIO device
intsizeof_priv: Space to allocate for private structure.

Description

Managed iio_device_alloc. iio_dev allocated with this function isautomatically freed on driver detach.

Return

Pointer to allocated iio_dev on success, NULL on failure.

intiio_active_scan_mask_index(structiio_dev*indio_dev)¶: Get index of the active scan mask inside the available scan masks array

Parameters

structiio_dev*indio_dev: the IIO device containing the active and available scan masks

Return

the index or -EINVAL if active_scan_mask is not set

voidiio_device_unregister(structiio_dev*indio_dev)¶: unregister a device from the IIO subsystem

Parameters

structiio_dev*indio_dev: Device structure representing the device.

bool__iio_device_claim_direct(structiio_dev*indio_dev)¶: Keep device in direct mode

Parameters

structiio_dev*indio_dev: the iio_dev associated with the device

Description

If the device is in direct mode it is guaranteed to staythat way until__iio_device_release_direct() is called.

Use with__iio_device_release_direct().

Drivers should only calliio_device_claim_direct().

Return

true on success, false on failure.

void__iio_device_release_direct(structiio_dev*indio_dev)¶: releases claim on direct mode

Parameters

structiio_dev*indio_dev: the iio_dev associated with the device

Description

Release the claim. Device is no longer guaranteed to stayin direct mode.

Drivers should only calliio_device_release_direct().

Use with__iio_device_claim_direct()

intiio_device_claim_buffer_mode(structiio_dev*indio_dev)¶: Keep device in buffer mode

Parameters

structiio_dev*indio_dev: the iio_dev associated with the device

Description

If the device is in buffer mode it is guaranteed to staythat way untiliio_device_release_buffer_mode() is called.

Use withiio_device_release_buffer_mode().

Return

0 on success, -EBUSY on failure.

voidiio_device_release_buffer_mode(structiio_dev*indio_dev)¶: releases claim on buffer mode

Parameters

structiio_dev*indio_dev: the iio_dev associated with the device

Description

Release the claim. Device is no longer guaranteed to stayin buffer mode.

Use withiio_device_claim_buffer_mode().

intiio_device_get_current_mode(structiio_dev*indio_dev)¶: helper function providing read-only access to the opaquecurrentmode variable

Parameters

structiio_dev*indio_dev: IIO device structure for device

Movatterモバイル変換

Core elements¶

Industrial I/O Devices¶

IIO device sysfs interface¶

IIO device channels¶

More details¶