~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/iio/consumer.h

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Industrial I/O in kernel consumer interface
  3  *
  4  * Copyright (c) 2011 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  */
 10 #ifndef _IIO_INKERN_CONSUMER_H_
 11 #define _IIO_INKERN_CONSUMER_H_
 12 
 13 #include <linux/types.h>
 14 #include <linux/iio/types.h>
 15 
 16 struct iio_dev;
 17 struct iio_chan_spec;
 18 struct device;
 19 
 20 /**
 21  * struct iio_channel - everything needed for a consumer to use a channel
 22  * @indio_dev:          Device on which the channel exists.
 23  * @channel:            Full description of the channel.
 24  * @data:               Data about the channel used by consumer.
 25  */
 26 struct iio_channel {
 27         struct iio_dev *indio_dev;
 28         const struct iio_chan_spec *channel;
 29         void *data;
 30 };
 31 
 32 /**
 33  * iio_channel_get() - get description of all that is needed to access channel.
 34  * @dev:                Pointer to consumer device. Device name must match
 35  *                      the name of the device as provided in the iio_map
 36  *                      with which the desired provider to consumer mapping
 37  *                      was registered.
 38  * @consumer_channel:   Unique name to identify the channel on the consumer
 39  *                      side. This typically describes the channels use within
 40  *                      the consumer. E.g. 'battery_voltage'
 41  */
 42 struct iio_channel *iio_channel_get(struct device *dev,
 43                                     const char *consumer_channel);
 44 
 45 /**
 46  * iio_channel_release() - release channels obtained via iio_channel_get
 47  * @chan:               The channel to be released.
 48  */
 49 void iio_channel_release(struct iio_channel *chan);
 50 
 51 /**
 52  * devm_iio_channel_get() - Resource managed version of iio_channel_get().
 53  * @dev:                Pointer to consumer device. Device name must match
 54  *                      the name of the device as provided in the iio_map
 55  *                      with which the desired provider to consumer mapping
 56  *                      was registered.
 57  * @consumer_channel:   Unique name to identify the channel on the consumer
 58  *                      side. This typically describes the channels use within
 59  *                      the consumer. E.g. 'battery_voltage'
 60  *
 61  * Returns a pointer to negative errno if it is not able to get the iio channel
 62  * otherwise returns valid pointer for iio channel.
 63  *
 64  * The allocated iio channel is automatically released when the device is
 65  * unbound.
 66  */
 67 struct iio_channel *devm_iio_channel_get(struct device *dev,
 68                                          const char *consumer_channel);
 69 /**
 70  * devm_iio_channel_release() - Resource managed version of
 71  *                              iio_channel_release().
 72  * @dev:                Pointer to consumer device for which resource
 73  *                      is allocared.
 74  * @chan:               The channel to be released.
 75  */
 76 void devm_iio_channel_release(struct device *dev, struct iio_channel *chan);
 77 
 78 /**
 79  * iio_channel_get_all() - get all channels associated with a client
 80  * @dev:                Pointer to consumer device.
 81  *
 82  * Returns an array of iio_channel structures terminated with one with
 83  * null iio_dev pointer.
 84  * This function is used by fairly generic consumers to get all the
 85  * channels registered as having this consumer.
 86  */
 87 struct iio_channel *iio_channel_get_all(struct device *dev);
 88 
 89 /**
 90  * iio_channel_release_all() - reverse iio_channel_get_all
 91  * @chan:               Array of channels to be released.
 92  */
 93 void iio_channel_release_all(struct iio_channel *chan);
 94 
 95 /**
 96  * devm_iio_channel_get_all() - Resource managed version of
 97  *                              iio_channel_get_all().
 98  * @dev: Pointer to consumer device.
 99  *
100  * Returns a pointer to negative errno if it is not able to get the iio channel
101  * otherwise returns an array of iio_channel structures terminated with one with
102  * null iio_dev pointer.
103  *
104  * This function is used by fairly generic consumers to get all the
105  * channels registered as having this consumer.
106  *
107  * The allocated iio channels are automatically released when the device is
108  * unbounded.
109  */
110 struct iio_channel *devm_iio_channel_get_all(struct device *dev);
111 
112 /**
113  * devm_iio_channel_release_all() - Resource managed version of
114  *                                  iio_channel_release_all().
115  * @dev:                Pointer to consumer device for which resource
116  *                      is allocared.
117  * @chan:               Array channel to be released.
118  */
119 void devm_iio_channel_release_all(struct device *dev, struct iio_channel *chan);
120 
121 struct iio_cb_buffer;
122 /**
123  * iio_channel_get_all_cb() - register callback for triggered capture
124  * @dev:                Pointer to client device.
125  * @cb:                 Callback function.
126  * @private:            Private data passed to callback.
127  *
128  * NB right now we have no ability to mux data from multiple devices.
129  * So if the channels requested come from different devices this will
130  * fail.
131  */
132 struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev,
133                                              int (*cb)(const void *data,
134                                                        void *private),
135                                              void *private);
136 /**
137  * iio_channel_release_all_cb() - release and unregister the callback.
138  * @cb_buffer:          The callback buffer that was allocated.
139  */
140 void iio_channel_release_all_cb(struct iio_cb_buffer *cb_buffer);
141 
142 /**
143  * iio_channel_start_all_cb() - start the flow of data through callback.
144  * @cb_buff:            The callback buffer we are starting.
145  */
146 int iio_channel_start_all_cb(struct iio_cb_buffer *cb_buff);
147 
148 /**
149  * iio_channel_stop_all_cb() - stop the flow of data through the callback.
150  * @cb_buff:            The callback buffer we are stopping.
151  */
152 void iio_channel_stop_all_cb(struct iio_cb_buffer *cb_buff);
153 
154 /**
155  * iio_channel_cb_get_channels() - get access to the underlying channels.
156  * @cb_buffer:          The callback buffer from whom we want the channel
157  *                      information.
158  *
159  * This function allows one to obtain information about the channels.
160  * Whilst this may allow direct reading if all buffers are disabled, the
161  * primary aim is to allow drivers that are consuming a channel to query
162  * things like scaling of the channel.
163  */
164 struct iio_channel
165 *iio_channel_cb_get_channels(const struct iio_cb_buffer *cb_buffer);
166 
167 /**
168  * iio_channel_cb_get_iio_dev() - get access to the underlying device.
169  * @cb_buffer:          The callback buffer from whom we want the device
170  *                      information.
171  *
172  * This function allows one to obtain information about the device.
173  * The primary aim is to allow drivers that are consuming a device to query
174  * things like current trigger.
175  */
176 struct iio_dev
177 *iio_channel_cb_get_iio_dev(const struct iio_cb_buffer *cb_buffer);
178 
179 /**
180  * iio_read_channel_raw() - read from a given channel
181  * @chan:               The channel being queried.
182  * @val:                Value read back.
183  *
184  * Note raw reads from iio channels are in adc counts and hence
185  * scale will need to be applied if standard units required.
186  */
187 int iio_read_channel_raw(struct iio_channel *chan,
188                          int *val);
189 
190 /**
191  * iio_read_channel_average_raw() - read from a given channel
192  * @chan:               The channel being queried.
193  * @val:                Value read back.
194  *
195  * Note raw reads from iio channels are in adc counts and hence
196  * scale will need to be applied if standard units required.
197  *
198  * In opposit to the normal iio_read_channel_raw this function
199  * returns the average of multiple reads.
200  */
201 int iio_read_channel_average_raw(struct iio_channel *chan, int *val);
202 
203 /**
204  * iio_read_channel_processed() - read processed value from a given channel
205  * @chan:               The channel being queried.
206  * @val:                Value read back.
207  *
208  * Returns an error code or 0.
209  *
210  * This function will read a processed value from a channel. A processed value
211  * means that this value will have the correct unit and not some device internal
212  * representation. If the device does not support reporting a processed value
213  * the function will query the raw value and the channels scale and offset and
214  * do the appropriate transformation.
215  */
216 int iio_read_channel_processed(struct iio_channel *chan, int *val);
217 
218 /**
219  * iio_write_channel_raw() - write to a given channel
220  * @chan:               The channel being queried.
221  * @val:                Value being written.
222  *
223  * Note raw writes to iio channels are in dac counts and hence
224  * scale will need to be applied if standard units required.
225  */
226 int iio_write_channel_raw(struct iio_channel *chan, int val);
227 
228 /**
229  * iio_read_max_channel_raw() - read maximum available raw value from a given
230  *                              channel, i.e. the maximum possible value.
231  * @chan:               The channel being queried.
232  * @val:                Value read back.
233  *
234  * Note raw reads from iio channels are in adc counts and hence
235  * scale will need to be applied if standard units are required.
236  */
237 int iio_read_max_channel_raw(struct iio_channel *chan, int *val);
238 
239 /**
240  * iio_read_avail_channel_raw() - read available raw values from a given channel
241  * @chan:               The channel being queried.
242  * @vals:               Available values read back.
243  * @length:             Number of entries in vals.
244  *
245  * Returns an error code, IIO_AVAIL_RANGE or IIO_AVAIL_LIST.
246  *
247  * For ranges, three vals are always returned; min, step and max.
248  * For lists, all the possible values are enumerated.
249  *
250  * Note raw available values from iio channels are in adc counts and
251  * hence scale will need to be applied if standard units are required.
252  */
253 int iio_read_avail_channel_raw(struct iio_channel *chan,
254                                const int **vals, int *length);
255 
256 /**
257  * iio_get_channel_type() - get the type of a channel
258  * @channel:            The channel being queried.
259  * @type:               The type of the channel.
260  *
261  * returns the enum iio_chan_type of the channel
262  */
263 int iio_get_channel_type(struct iio_channel *channel,
264                          enum iio_chan_type *type);
265 
266 /**
267  * iio_read_channel_offset() - read the offset value for a channel
268  * @chan:               The channel being queried.
269  * @val:                First part of value read back.
270  * @val2:               Second part of value read back.
271  *
272  * Note returns a description of what is in val and val2, such
273  * as IIO_VAL_INT_PLUS_MICRO telling us we have a value of val
274  * + val2/1e6
275  */
276 int iio_read_channel_offset(struct iio_channel *chan, int *val,
277                            int *val2);
278 
279 /**
280  * iio_read_channel_scale() - read the scale value for a channel
281  * @chan:               The channel being queried.
282  * @val:                First part of value read back.
283  * @val2:               Second part of value read back.
284  *
285  * Note returns a description of what is in val and val2, such
286  * as IIO_VAL_INT_PLUS_MICRO telling us we have a value of val
287  * + val2/1e6
288  */
289 int iio_read_channel_scale(struct iio_channel *chan, int *val,
290                            int *val2);
291 
292 /**
293  * iio_convert_raw_to_processed() - Converts a raw value to a processed value
294  * @chan:               The channel being queried
295  * @raw:                The raw IIO to convert
296  * @processed:          The result of the conversion
297  * @scale:              Scale factor to apply during the conversion
298  *
299  * Returns an error code or 0.
300  *
301  * This function converts a raw value to processed value for a specific channel.
302  * A raw value is the device internal representation of a sample and the value
303  * returned by iio_read_channel_raw, so the unit of that value is device
304  * depended. A processed value on the other hand is value has a normed unit
305  * according with the IIO specification.
306  *
307  * The scale factor allows to increase the precession of the returned value. For
308  * a scale factor of 1 the function will return the result in the normal IIO
309  * unit for the channel type. E.g. millivolt for voltage channels, if you want
310  * nanovolts instead pass 1000000 as the scale factor.
311  */
312 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
313         int *processed, unsigned int scale);
314 
315 /**
316  * iio_get_channel_ext_info_count() - get number of ext_info attributes
317  *                                    connected to the channel.
318  * @chan:               The channel being queried
319  *
320  * Returns the number of ext_info attributes
321  */
322 unsigned int iio_get_channel_ext_info_count(struct iio_channel *chan);
323 
324 /**
325  * iio_read_channel_ext_info() - read ext_info attribute from a given channel
326  * @chan:               The channel being queried.
327  * @attr:               The ext_info attribute to read.
328  * @buf:                Where to store the attribute value. Assumed to hold
329  *                      at least PAGE_SIZE bytes.
330  *
331  * Returns the number of bytes written to buf (perhaps w/o zero termination;
332  * it need not even be a string), or an error code.
333  */
334 ssize_t iio_read_channel_ext_info(struct iio_channel *chan,
335                                   const char *attr, char *buf);
336 
337 /**
338  * iio_write_channel_ext_info() - write ext_info attribute from a given channel
339  * @chan:               The channel being queried.
340  * @attr:               The ext_info attribute to read.
341  * @buf:                The new attribute value. Strings needs to be zero-
342  *                      terminated, but the terminator should not be included
343  *                      in the below len.
344  * @len:                The size of the new attribute value.
345  *
346  * Returns the number of accepted bytes, which should be the same as len.
347  * An error code can also be returned.
348  */
349 ssize_t iio_write_channel_ext_info(struct iio_channel *chan, const char *attr,
350                                    const char *buf, size_t len);
351 
352 #endif
353 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp