blob: 2afbb6f01afc14a27e6b6ab44df3d471a4e01afe [file] [log] [blame]
Jonathan Cameron7d438172011-08-12 17:47:53 +01001
Jonathan Cameron847ec802009-08-18 18:06:19 +01002/* The industrial I/O core
3 *
4 * Copyright (c) 2008 Jonathan Cameron
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
9 */
Jonathan Cameron847ec802009-08-18 18:06:19 +010010#ifndef _INDUSTRIAL_IO_H_
11#define _INDUSTRIAL_IO_H_
12
13#include <linux/device.h>
14#include <linux/cdev.h>
Jonathan Cameron06458e22012-04-25 15:54:58 +010015#include <linux/iio/types.h>
Jonathan Cameron847ec802009-08-18 18:06:19 +010016/* IIO TODO LIST */
Jonathan Cameron751a3702010-06-26 12:54:19 +010017/*
Jonathan Cameron847ec802009-08-18 18:06:19 +010018 * Provide means of adjusting timer accuracy.
19 * Currently assumes nano seconds.
20 */
21
Jonathan Cameron1d892712011-05-18 14:40:51 +010022enum iio_chan_info_enum {
Jonathan Cameron5ccb3ad2012-04-15 17:41:16 +010023 IIO_CHAN_INFO_RAW = 0,
24 IIO_CHAN_INFO_PROCESSED,
25 IIO_CHAN_INFO_SCALE,
Jonathan Cameronc8a9f802011-10-26 17:41:36 +010026 IIO_CHAN_INFO_OFFSET,
27 IIO_CHAN_INFO_CALIBSCALE,
28 IIO_CHAN_INFO_CALIBBIAS,
29 IIO_CHAN_INFO_PEAK,
30 IIO_CHAN_INFO_PEAK_SCALE,
31 IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW,
32 IIO_CHAN_INFO_AVERAGE_RAW,
Jonathan Camerondf94aba2011-11-27 11:39:12 +000033 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY,
Laxman Dewangance85a1c2012-04-13 16:03:31 +053034 IIO_CHAN_INFO_SAMP_FREQ,
Michael Hennericha6b12852012-04-27 10:58:34 +020035 IIO_CHAN_INFO_FREQUENCY,
36 IIO_CHAN_INFO_PHASE,
Michael Hennerichb65d6212012-05-11 11:36:53 +020037 IIO_CHAN_INFO_HARDWAREGAIN,
Jonathan Cameron1d892712011-05-18 14:40:51 +010038};
39
Jonathan Cameronc8a9f802011-10-26 17:41:36 +010040#define IIO_CHAN_INFO_SHARED_BIT(type) BIT(type*2)
41#define IIO_CHAN_INFO_SEPARATE_BIT(type) BIT(type*2 + 1)
42
Jonathan Cameron5ccb3ad2012-04-15 17:41:16 +010043#define IIO_CHAN_INFO_RAW_SEPARATE_BIT \
44 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_RAW)
45#define IIO_CHAN_INFO_PROCESSED_SEPARATE_BIT \
46 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PROCESSED)
Jonathan Cameronc8a9f802011-10-26 17:41:36 +010047#define IIO_CHAN_INFO_SCALE_SEPARATE_BIT \
48 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_SCALE)
49#define IIO_CHAN_INFO_SCALE_SHARED_BIT \
50 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_SCALE)
51#define IIO_CHAN_INFO_OFFSET_SEPARATE_BIT \
52 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_OFFSET)
53#define IIO_CHAN_INFO_OFFSET_SHARED_BIT \
54 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_OFFSET)
55#define IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT \
56 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_CALIBSCALE)
57#define IIO_CHAN_INFO_CALIBSCALE_SHARED_BIT \
58 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_CALIBSCALE)
59#define IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT \
60 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_CALIBBIAS)
61#define IIO_CHAN_INFO_CALIBBIAS_SHARED_BIT \
62 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_CALIBBIAS)
63#define IIO_CHAN_INFO_PEAK_SEPARATE_BIT \
64 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PEAK)
65#define IIO_CHAN_INFO_PEAK_SHARED_BIT \
66 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PEAK)
67#define IIO_CHAN_INFO_PEAKSCALE_SEPARATE_BIT \
68 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PEAKSCALE)
69#define IIO_CHAN_INFO_PEAKSCALE_SHARED_BIT \
70 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PEAKSCALE)
71#define IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW_SEPARATE_BIT \
72 IIO_CHAN_INFO_SEPARATE_BIT( \
73 IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW)
74#define IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW_SHARED_BIT \
75 IIO_CHAN_INFO_SHARED_BIT( \
76 IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW)
77#define IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT \
78 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_AVERAGE_RAW)
79#define IIO_CHAN_INFO_AVERAGE_RAW_SHARED_BIT \
80 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_AVERAGE_RAW)
Jonathan Camerondf94aba2011-11-27 11:39:12 +000081#define IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SHARED_BIT \
82 IIO_CHAN_INFO_SHARED_BIT( \
83 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY)
84#define IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY_SEPARATE_BIT \
85 IIO_CHAN_INFO_SEPARATE_BIT( \
86 IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY)
Laxman Dewangance85a1c2012-04-13 16:03:31 +053087#define IIO_CHAN_INFO_SAMP_FREQ_SEPARATE_BIT \
88 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_SAMP_FREQ)
89#define IIO_CHAN_INFO_SAMP_FREQ_SHARED_BIT \
90 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_SAMP_FREQ)
Michael Hennericha6b12852012-04-27 10:58:34 +020091#define IIO_CHAN_INFO_FREQUENCY_SEPARATE_BIT \
92 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_FREQUENCY)
93#define IIO_CHAN_INFO_FREQUENCY_SHARED_BIT \
94 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_FREQUENCY)
95#define IIO_CHAN_INFO_PHASE_SEPARATE_BIT \
96 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_PHASE)
97#define IIO_CHAN_INFO_PHASE_SHARED_BIT \
98 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_PHASE)
Michael Hennerichb65d6212012-05-11 11:36:53 +020099#define IIO_CHAN_INFO_HARDWAREGAIN_SEPARATE_BIT \
100 IIO_CHAN_INFO_SEPARATE_BIT(IIO_CHAN_INFO_HARDWAREGAIN)
101#define IIO_CHAN_INFO_HARDWAREGAIN_SHARED_BIT \
102 IIO_CHAN_INFO_SHARED_BIT(IIO_CHAN_INFO_HARDWAREGAIN)
Jonathan Cameronc8a9f802011-10-26 17:41:36 +0100103
Jonathan Cameron8310b862011-09-02 17:14:36 +0100104enum iio_endian {
105 IIO_CPU,
106 IIO_BE,
107 IIO_LE,
108};
109
Lars-Peter Clausen5f420b42012-02-21 18:38:12 +0100110struct iio_chan_spec;
111struct iio_dev;
112
113/**
114 * struct iio_chan_spec_ext_info - Extended channel info attribute
115 * @name: Info attribute name
116 * @shared: Whether this attribute is shared between all channels.
117 * @read: Read callback for this info attribute, may be NULL.
118 * @write: Write callback for this info attribute, may be NULL.
Michael Hennerichfc6d1132012-04-27 10:58:36 +0200119 * @private: Data private to the driver.
Lars-Peter Clausen5f420b42012-02-21 18:38:12 +0100120 */
121struct iio_chan_spec_ext_info {
122 const char *name;
123 bool shared;
Michael Hennerichfc6d1132012-04-27 10:58:36 +0200124 ssize_t (*read)(struct iio_dev *, uintptr_t private,
125 struct iio_chan_spec const *, char *buf);
126 ssize_t (*write)(struct iio_dev *, uintptr_t private,
127 struct iio_chan_spec const *, const char *buf,
128 size_t len);
129 uintptr_t private;
Lars-Peter Clausen5f420b42012-02-21 18:38:12 +0100130};
131
Jonathan Cameron1d892712011-05-18 14:40:51 +0100132/**
Lars-Peter Clausen5212cc82012-06-04 11:36:11 +0200133 * struct iio_enum - Enum channel info attribute
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200134 * @items: An array of strings.
135 * @num_items: Length of the item array.
136 * @set: Set callback function, may be NULL.
137 * @get: Get callback function, may be NULL.
Lars-Peter Clausen5212cc82012-06-04 11:36:11 +0200138 *
139 * The iio_enum struct can be used to implement enum style channel attributes.
140 * Enum style attributes are those which have a set of strings which map to
141 * unsigned integer values. The IIO enum helper code takes care of mapping
142 * between value and string as well as generating a "_available" file which
143 * contains a list of all available items. The set callback will be called when
144 * the attribute is updated. The last parameter is the index to the newly
145 * activated item. The get callback will be used to query the currently active
146 * item and is supposed to return the index for it.
147 */
148struct iio_enum {
149 const char * const *items;
150 unsigned int num_items;
151 int (*set)(struct iio_dev *, const struct iio_chan_spec *, unsigned int);
152 int (*get)(struct iio_dev *, const struct iio_chan_spec *);
153};
154
155ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
156 uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
157ssize_t iio_enum_read(struct iio_dev *indio_dev,
158 uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
159ssize_t iio_enum_write(struct iio_dev *indio_dev,
160 uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
161 size_t len);
162
163/**
164 * IIO_ENUM() - Initialize enum extended channel attribute
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200165 * @_name: Attribute name
166 * @_shared: Whether the attribute is shared between all channels
167 * @_e: Pointer to a iio_enum struct
Lars-Peter Clausen5212cc82012-06-04 11:36:11 +0200168 *
169 * This should usually be used together with IIO_ENUM_AVAILABLE()
170 */
171#define IIO_ENUM(_name, _shared, _e) \
172{ \
173 .name = (_name), \
174 .shared = (_shared), \
175 .read = iio_enum_read, \
176 .write = iio_enum_write, \
177 .private = (uintptr_t)(_e), \
178}
179
180/**
181 * IIO_ENUM_AVAILABLE() - Initialize enum available extended channel attribute
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200182 * @_name: Attribute name ("_available" will be appended to the name)
183 * @_e: Pointer to a iio_enum struct
Lars-Peter Clausen5212cc82012-06-04 11:36:11 +0200184 *
185 * Creates a read only attribute which list all the available enum items in a
186 * space separated list. This should usually be used together with IIO_ENUM()
187 */
188#define IIO_ENUM_AVAILABLE(_name, _e) \
189{ \
190 .name = (_name "_available"), \
191 .shared = true, \
192 .read = iio_enum_available_read, \
193 .private = (uintptr_t)(_e), \
194}
195
196/**
Jonathan Cameron1d892712011-05-18 14:40:51 +0100197 * struct iio_chan_spec - specification of a single channel
198 * @type: What type of measurement is the channel making.
Peter Meerwalda16561c2012-06-12 15:38:46 +0200199 * @channel: What number do we wish to assign the channel.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100200 * @channel2: If there is a second number for a differential
201 * channel then this is it. If modified is set then the
202 * value here specifies the modifier.
203 * @address: Driver specific identifier.
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200204 * @scan_index: Monotonic index to give ordering in scans when read
Jonathan Cameron1d892712011-05-18 14:40:51 +0100205 * from a buffer.
206 * @scan_type: Sign: 's' or 'u' to specify signed or unsigned
207 * realbits: Number of valid bits of data
208 * storage_bits: Realbits + padding
209 * shift: Shift right by this before masking out
210 * realbits.
Jonathan Cameron8310b862011-09-02 17:14:36 +0100211 * endianness: little or big endian
Jonathan Cameron1d892712011-05-18 14:40:51 +0100212 * @info_mask: What information is to be exported about this channel.
213 * This includes calibbias, scale etc.
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200214 * @event_mask: What events can this channel produce.
Lars-Peter Clausen5f420b42012-02-21 18:38:12 +0100215 * @ext_info: Array of extended info attributes for this channel.
216 * The array is NULL terminated, the last element should
Peter Meerwald9cc113bc2012-06-18 20:33:01 +0200217 * have its name field set to NULL.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100218 * @extend_name: Allows labeling of channel attributes with an
219 * informative name. Note this has no effect codes etc,
220 * unlike modifiers.
Peter Meerwald17879482012-06-12 15:38:45 +0200221 * @datasheet_name: A name used in in-kernel mapping of channels. It should
Justin P. Mattock4abf6f82012-02-29 22:00:38 -0800222 * correspond to the first name that the channel is referred
Jonathan Cameron6c63dde2011-12-05 21:56:00 +0000223 * to by in the datasheet (e.g. IND), or the nearest
224 * possible compound name (e.g. IND-INC).
Jonathan Cameron1d892712011-05-18 14:40:51 +0100225 * @modified: Does a modifier apply to this channel. What these are
226 * depends on the channel type. Modifier is set in
227 * channel2. Examples are IIO_MOD_X for axial sensors about
228 * the 'x' axis.
229 * @indexed: Specify the channel has a numerical index. If not,
Peter Meerwalda16561c2012-06-12 15:38:46 +0200230 * the channel index number will be suppressed for sysfs
231 * attributes but not for event codes.
Jonathan Cameronade7ef72011-09-02 17:14:45 +0100232 * @differential: Channel is differential.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100233 */
234struct iio_chan_spec {
235 enum iio_chan_type type;
236 int channel;
237 int channel2;
238 unsigned long address;
239 int scan_index;
240 struct {
241 char sign;
242 u8 realbits;
243 u8 storagebits;
244 u8 shift;
Jonathan Cameron8310b862011-09-02 17:14:36 +0100245 enum iio_endian endianness;
Jonathan Cameron1d892712011-05-18 14:40:51 +0100246 } scan_type;
Michael Hennerich1c5e6a32011-07-20 15:03:07 +0200247 long info_mask;
248 long event_mask;
Lars-Peter Clausen5f420b42012-02-21 18:38:12 +0100249 const struct iio_chan_spec_ext_info *ext_info;
Jonathan Cameron344692b2012-04-13 10:24:21 +0100250 const char *extend_name;
Jonathan Cameron6c63dde2011-12-05 21:56:00 +0000251 const char *datasheet_name;
Jonathan Cameron1d892712011-05-18 14:40:51 +0100252 unsigned modified:1;
253 unsigned indexed:1;
Jonathan Cameronc6fc8062011-09-02 17:14:34 +0100254 unsigned output:1;
Jonathan Cameronade7ef72011-09-02 17:14:45 +0100255 unsigned differential:1;
Jonathan Cameron1d892712011-05-18 14:40:51 +0100256};
Jonathan Camerondf9c1c42011-08-12 17:56:03 +0100257
Jonathan Cameron1d892712011-05-18 14:40:51 +0100258#define IIO_ST(si, rb, sb, sh) \
259 { .sign = si, .realbits = rb, .storagebits = sb, .shift = sh }
260
Jonathan Cameron1d892712011-05-18 14:40:51 +0100261#define IIO_CHAN_SOFT_TIMESTAMP(_si) \
262 { .type = IIO_TIMESTAMP, .channel = -1, \
263 .scan_index = _si, .scan_type = IIO_ST('s', 64, 64, 0) }
264
Jonathan Cameron847ec802009-08-18 18:06:19 +0100265/**
266 * iio_get_time_ns() - utility function to get a time stamp for events etc
267 **/
268static inline s64 iio_get_time_ns(void)
269{
270 struct timespec ts;
271 /*
272 * calls getnstimeofday.
273 * If hrtimers then up to ns accurate, if not microsecond.
274 */
275 ktime_get_real_ts(&ts);
276
277 return timespec_to_ns(&ts);
278}
279
Jonathan Cameron847ec802009-08-18 18:06:19 +0100280/* Device operating modes */
281#define INDIO_DIRECT_MODE 0x01
Jonathan Cameronec3afa42011-09-21 11:15:54 +0100282#define INDIO_BUFFER_TRIGGERED 0x02
283#define INDIO_BUFFER_HARDWARE 0x08
Jonathan Cameron847ec802009-08-18 18:06:19 +0100284
Jonathan Cameronec3afa42011-09-21 11:15:54 +0100285#define INDIO_ALL_BUFFER_MODES \
286 (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
Jonathan Cameron847ec802009-08-18 18:06:19 +0100287
Michael Hennerich43a43602011-06-27 13:07:09 +0100288struct iio_trigger; /* forward declaration */
Jonathan Cameron7ae8cf62011-08-30 12:32:44 +0100289struct iio_dev;
Michael Hennerich43a43602011-06-27 13:07:09 +0100290
Jonathan Cameron847ec802009-08-18 18:06:19 +0100291/**
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100292 * struct iio_info - constant information about device
293 * @driver_module: module structure used to ensure correct
Jonathan Cameron847ec802009-08-18 18:06:19 +0100294 * ownership of chrdevs etc
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100295 * @event_attrs: event control attributes
296 * @attrs: general purpose device attributes
297 * @read_raw: function to request a value from the device.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100298 * mask specifies which value. Note 0 means a reading of
299 * the channel in question. Return value will specify the
300 * type of value returned by the device. val and val2 will
301 * contain the elements making up the returned value.
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100302 * @write_raw: function to write a value to the device.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100303 * Parameters are the same as for read_raw.
Michael Hennerich5c04af02011-06-27 13:07:10 +0100304 * @write_raw_get_fmt: callback function to query the expected
305 * format/precision. If not set by the driver, write_raw
306 * returns IIO_VAL_INT_PLUS_MICRO.
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100307 * @read_event_config: find out if the event is enabled.
308 * @write_event_config: set if the event is enabled.
309 * @read_event_value: read a value associated with the event. Meaning
Jonathan Cameron1d892712011-05-18 14:40:51 +0100310 * is event dependant. event_code specifies which event.
Justin P. Mattock4abf6f82012-02-29 22:00:38 -0800311 * @write_event_value: write the value associated with the event.
Jonathan Cameron1d892712011-05-18 14:40:51 +0100312 * Meaning is event dependent.
Michael Hennerich43a43602011-06-27 13:07:09 +0100313 * @validate_trigger: function to validate the trigger when the
314 * current trigger gets changed.
Jonathan Cameron847ec802009-08-18 18:06:19 +0100315 **/
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100316struct iio_info {
Jonathan Cameron847ec802009-08-18 18:06:19 +0100317 struct module *driver_module;
Jonathan Cameron847ec802009-08-18 18:06:19 +0100318 struct attribute_group *event_attrs;
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100319 const struct attribute_group *attrs;
Jonathan Cameron847ec802009-08-18 18:06:19 +0100320
Jonathan Cameron1d892712011-05-18 14:40:51 +0100321 int (*read_raw)(struct iio_dev *indio_dev,
322 struct iio_chan_spec const *chan,
323 int *val,
324 int *val2,
325 long mask);
326
327 int (*write_raw)(struct iio_dev *indio_dev,
328 struct iio_chan_spec const *chan,
329 int val,
330 int val2,
331 long mask);
332
Michael Hennerich5c04af02011-06-27 13:07:10 +0100333 int (*write_raw_get_fmt)(struct iio_dev *indio_dev,
334 struct iio_chan_spec const *chan,
335 long mask);
336
Jonathan Cameron1d892712011-05-18 14:40:51 +0100337 int (*read_event_config)(struct iio_dev *indio_dev,
Jonathan Cameron330c6c52011-09-02 17:14:39 +0100338 u64 event_code);
Jonathan Cameron1d892712011-05-18 14:40:51 +0100339
340 int (*write_event_config)(struct iio_dev *indio_dev,
Jonathan Cameron330c6c52011-09-02 17:14:39 +0100341 u64 event_code,
Jonathan Cameron1d892712011-05-18 14:40:51 +0100342 int state);
343
344 int (*read_event_value)(struct iio_dev *indio_dev,
Jonathan Cameron330c6c52011-09-02 17:14:39 +0100345 u64 event_code,
Jonathan Cameron1d892712011-05-18 14:40:51 +0100346 int *val);
347 int (*write_event_value)(struct iio_dev *indio_dev,
Jonathan Cameron330c6c52011-09-02 17:14:39 +0100348 u64 event_code,
Jonathan Cameron1d892712011-05-18 14:40:51 +0100349 int val);
Michael Hennerich43a43602011-06-27 13:07:09 +0100350 int (*validate_trigger)(struct iio_dev *indio_dev,
351 struct iio_trigger *trig);
Jonathan Cameron4d5f8d32011-12-05 21:37:12 +0000352 int (*update_scan_mode)(struct iio_dev *indio_dev,
353 const unsigned long *scan_mask);
Michael Henneriche553f182012-03-01 10:51:03 +0100354 int (*debugfs_reg_access)(struct iio_dev *indio_dev,
355 unsigned reg, unsigned writeval,
356 unsigned *readval);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100357};
358
Jonathan Cameron847ec802009-08-18 18:06:19 +0100359/**
Jonathan Cameron16122442011-12-05 22:18:14 +0000360 * struct iio_buffer_setup_ops - buffer setup related callbacks
361 * @preenable: [DRIVER] function to run prior to marking buffer enabled
362 * @postenable: [DRIVER] function to run after marking buffer enabled
363 * @predisable: [DRIVER] function to run prior to marking buffer
364 * disabled
365 * @postdisable: [DRIVER] function to run after marking buffer disabled
366 */
367struct iio_buffer_setup_ops {
368 int (*preenable)(struct iio_dev *);
369 int (*postenable)(struct iio_dev *);
370 int (*predisable)(struct iio_dev *);
371 int (*postdisable)(struct iio_dev *);
372};
373
374/**
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100375 * struct iio_dev - industrial I/O device
376 * @id: [INTERN] used to identify device internally
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100377 * @modes: [DRIVER] operating modes supported by device
378 * @currentmode: [DRIVER] current operating mode
379 * @dev: [DRIVER] device structure, should be assigned a parent
380 * and owner
Jonathan Cameron5aa96182011-08-30 12:41:06 +0100381 * @event_interface: [INTERN] event chrdevs associated with interrupt lines
Jonathan Cameron14555b12011-09-21 11:15:57 +0100382 * @buffer: [DRIVER] any buffer present
Jonathan Cameron420fe2e2012-04-21 10:09:35 +0100383 * @scan_bytes: [INTERN] num bytes captured to be fed to buffer demux
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100384 * @mlock: [INTERN] lock used to prevent simultaneous device state
385 * changes
386 * @available_scan_masks: [DRIVER] optional array of allowed bitmasks
Jonathan Cameron32b5eec2011-09-02 17:14:38 +0100387 * @masklength: [INTERN] the length of the mask established from
388 * channels
Jonathan Cameron959d2952011-12-05 21:37:13 +0000389 * @active_scan_mask: [INTERN] union of all scan masks requested by buffers
Jonathan Cameronfd6487f2012-04-21 10:09:44 +0100390 * @scan_timestamp: [INTERN] set if any buffers have requested timestamp
Jonathan Cameronf1264802012-04-21 10:09:34 +0100391 * @scan_index_timestamp:[INTERN] cache of the index to the timestamp
Jonathan Cameron14555b12011-09-21 11:15:57 +0100392 * @trig: [INTERN] current device trigger (buffer modes)
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100393 * @pollfunc: [DRIVER] function run on trigger being received
394 * @channels: [DRIVER] channel specification structure table
Peter Meerwald17879482012-06-12 15:38:45 +0200395 * @num_channels: [DRIVER] number of channels specified in @channels.
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100396 * @channel_attr_list: [INTERN] keep track of automatically created channel
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100397 * attributes
Jonathan Cameron26d25ae2011-09-02 17:14:40 +0100398 * @chan_attr_group: [INTERN] group for all attrs in base directory
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100399 * @name: [DRIVER] name of the device.
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100400 * @info: [DRIVER] callbacks and constant info from driver
Jonathan Cameronac917a82012-02-15 19:48:00 +0000401 * @info_exist_lock: [INTERN] lock to prevent use during removal
Jonathan Cameronecbf20c2012-04-10 21:11:06 +0100402 * @setup_ops: [DRIVER] callbacks to call before and after buffer
403 * enable/disable
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100404 * @chrdev: [INTERN] associated character device
Jonathan Cameron26d25ae2011-09-02 17:14:40 +0100405 * @groups: [INTERN] attribute groups
406 * @groupcounter: [INTERN] index of next attribute group
Lars-Peter Clausenbb014432011-12-19 15:23:45 +0100407 * @flags: [INTERN] file ops related flags including busy flag.
Michael Henneriche553f182012-03-01 10:51:03 +0100408 * @debugfs_dentry: [INTERN] device specific debugfs dentry.
409 * @cached_reg_addr: [INTERN] cached register address for debugfs reads.
410 */
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100411struct iio_dev {
412 int id;
Jonathan Cameron4024bc72011-08-12 17:08:53 +0100413
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100414 int modes;
415 int currentmode;
416 struct device dev;
417
Jonathan Cameron5aa96182011-08-30 12:41:06 +0100418 struct iio_event_interface *event_interface;
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100419
Jonathan Cameron14555b12011-09-21 11:15:57 +0100420 struct iio_buffer *buffer;
Jonathan Cameron420fe2e2012-04-21 10:09:35 +0100421 int scan_bytes;
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100422 struct mutex mlock;
423
Michael Hennerichcd4361c2012-02-22 13:16:49 +0100424 const unsigned long *available_scan_masks;
Jonathan Cameron32b5eec2011-09-02 17:14:38 +0100425 unsigned masklength;
Michael Hennerichcd4361c2012-02-22 13:16:49 +0100426 const unsigned long *active_scan_mask;
Jonathan Cameronfd6487f2012-04-21 10:09:44 +0100427 bool scan_timestamp;
Jonathan Cameronf1264802012-04-21 10:09:34 +0100428 unsigned scan_index_timestamp;
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100429 struct iio_trigger *trig;
430 struct iio_poll_func *pollfunc;
431
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100432 struct iio_chan_spec const *channels;
433 int num_channels;
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100434
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100435 struct list_head channel_attr_list;
Jonathan Cameron26d25ae2011-09-02 17:14:40 +0100436 struct attribute_group chan_attr_group;
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100437 const char *name;
438 const struct iio_info *info;
Jonathan Cameronac917a82012-02-15 19:48:00 +0000439 struct mutex info_exist_lock;
Jonathan Cameron16122442011-12-05 22:18:14 +0000440 const struct iio_buffer_setup_ops *setup_ops;
Jonathan Cameron1a25e592011-08-30 12:41:12 +0100441 struct cdev chrdev;
Jonathan Cameron26d25ae2011-09-02 17:14:40 +0100442#define IIO_MAX_GROUPS 6
443 const struct attribute_group *groups[IIO_MAX_GROUPS + 1];
444 int groupcounter;
Lars-Peter Clausenbb014432011-12-19 15:23:45 +0100445
446 unsigned long flags;
Michael Henneriche553f182012-03-01 10:51:03 +0100447#if defined(CONFIG_DEBUG_FS)
448 struct dentry *debugfs_dentry;
449 unsigned cached_reg_addr;
450#endif
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100451};
452
453/**
Jonathan Cameron5fb21c82011-12-05 21:37:10 +0000454 * iio_find_channel_from_si() - get channel from its scan index
455 * @indio_dev: device
456 * @si: scan index to match
457 */
458const struct iio_chan_spec
459*iio_find_channel_from_si(struct iio_dev *indio_dev, int si);
460
461/**
Jonathan Cameron847ec802009-08-18 18:06:19 +0100462 * iio_device_register() - register a device with the IIO subsystem
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100463 * @indio_dev: Device structure filled by the device driver
Jonathan Cameron847ec802009-08-18 18:06:19 +0100464 **/
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100465int iio_device_register(struct iio_dev *indio_dev);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100466
467/**
468 * iio_device_unregister() - unregister a device from the IIO subsystem
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100469 * @indio_dev: Device structure representing the device.
Jonathan Cameron847ec802009-08-18 18:06:19 +0100470 **/
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100471void iio_device_unregister(struct iio_dev *indio_dev);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100472
473/**
Jonathan Cameron847ec802009-08-18 18:06:19 +0100474 * iio_push_event() - try to add event to the list for userspace reading
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100475 * @indio_dev: IIO device structure
Jonathan Cameron847ec802009-08-18 18:06:19 +0100476 * @ev_code: What event
Randy Dunlap4c572602009-10-04 19:34:02 -0700477 * @timestamp: When the event occurred
Jonathan Cameron847ec802009-08-18 18:06:19 +0100478 **/
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100479int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100480
Jonathan Cameron5aaaeba2010-05-04 14:43:00 +0100481extern struct bus_type iio_bus_type;
Jonathan Cameron847ec802009-08-18 18:06:19 +0100482
483/**
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200484 * iio_device_put() - reference counted deallocation of struct device
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200485 * @indio_dev: IIO device structure containing the device
Jonathan Cameron847ec802009-08-18 18:06:19 +0100486 **/
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200487static inline void iio_device_put(struct iio_dev *indio_dev)
Jonathan Cameron847ec802009-08-18 18:06:19 +0100488{
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100489 if (indio_dev)
490 put_device(&indio_dev->dev);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100491};
492
Lars-Peter Clausen7a7913f2012-05-12 15:39:32 +0200493/**
494 * dev_to_iio_dev() - Get IIO device struct from a device struct
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200495 * @dev: The device embedded in the IIO device
Lars-Peter Clausen7a7913f2012-05-12 15:39:32 +0200496 *
497 * Note: The device must be a IIO device, otherwise the result is undefined.
498 */
499static inline struct iio_dev *dev_to_iio_dev(struct device *dev)
500{
501 return container_of(dev, struct iio_dev, dev);
502}
503
Lars-Peter Clausene4e8b772012-06-04 10:50:02 +0200504/**
505 * iio_device_get() - increment reference count for the device
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200506 * @indio_dev: IIO device structure
Lars-Peter Clausene4e8b772012-06-04 10:50:02 +0200507 *
508 * Returns: The passed IIO device
509 **/
510static inline struct iio_dev *iio_device_get(struct iio_dev *indio_dev)
511{
512 return indio_dev ? dev_to_iio_dev(get_device(&indio_dev->dev)) : NULL;
513}
514
Jonathan Cameron6f7c8ee2011-04-15 18:55:56 +0100515/* Can we make this smaller? */
516#define IIO_ALIGN L1_CACHE_BYTES
Jonathan Cameron847ec802009-08-18 18:06:19 +0100517/**
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200518 * iio_device_alloc() - allocate an iio_dev from a driver
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200519 * @sizeof_priv: Space to allocate for private structure.
Jonathan Cameron847ec802009-08-18 18:06:19 +0100520 **/
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200521struct iio_dev *iio_device_alloc(int sizeof_priv);
Jonathan Cameron6f7c8ee2011-04-15 18:55:56 +0100522
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100523static inline void *iio_priv(const struct iio_dev *indio_dev)
Jonathan Cameron6f7c8ee2011-04-15 18:55:56 +0100524{
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100525 return (char *)indio_dev + ALIGN(sizeof(struct iio_dev), IIO_ALIGN);
Jonathan Cameron6f7c8ee2011-04-15 18:55:56 +0100526}
527
528static inline struct iio_dev *iio_priv_to_dev(void *priv)
529{
530 return (struct iio_dev *)((char *)priv -
531 ALIGN(sizeof(struct iio_dev), IIO_ALIGN));
532}
Jonathan Cameron847ec802009-08-18 18:06:19 +0100533
534/**
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200535 * iio_device_free() - free an iio_dev from a driver
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200536 * @indio_dev: the iio_dev associated with the device
Jonathan Cameron847ec802009-08-18 18:06:19 +0100537 **/
Lars-Peter Clausen7cbb7532012-04-26 13:35:01 +0200538void iio_device_free(struct iio_dev *indio_dev);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100539
540/**
Jonathan Cameron14555b12011-09-21 11:15:57 +0100541 * iio_buffer_enabled() - helper function to test if the buffer is enabled
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200542 * @indio_dev: IIO device structure for device
Jonathan Cameron847ec802009-08-18 18:06:19 +0100543 **/
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100544static inline bool iio_buffer_enabled(struct iio_dev *indio_dev)
Jonathan Cameron847ec802009-08-18 18:06:19 +0100545{
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100546 return indio_dev->currentmode
Jonathan Cameronec3afa42011-09-21 11:15:54 +0100547 & (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE);
Jonathan Cameron847ec802009-08-18 18:06:19 +0100548};
549
Michael Henneriche553f182012-03-01 10:51:03 +0100550/**
551 * iio_get_debugfs_dentry() - helper function to get the debugfs_dentry
Peter Meerwald7dcd7b62012-06-12 15:38:48 +0200552 * @indio_dev: IIO device structure for device
Michael Henneriche553f182012-03-01 10:51:03 +0100553 **/
554#if defined(CONFIG_DEBUG_FS)
555static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
556{
557 return indio_dev->debugfs_dentry;
558};
559#else
560static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
561{
562 return NULL;
563};
564#endif
565
Jonathan Cameron847ec802009-08-18 18:06:19 +0100566#endif /* _INDUSTRIAL_IO_H_ */