blob: f971f79103ecd9bf1cf74a279c2a24f96029e66d [file] [log] [blame]
Jonathan Cameron14555b12011-09-21 11:15:57 +01001/* The industrial I/O core
2 *
3 * Copyright (c) 2008 Jonathan Cameron
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * Handling of buffer allocation / resizing.
10 *
11 *
12 * Things to look at here.
13 * - Better memory allocation techniques?
14 * - Alternative access techniques?
15 */
16#include <linux/kernel.h>
Paul Gortmaker8e336a72011-07-10 13:09:12 -040017#include <linux/export.h>
Jonathan Cameron14555b12011-09-21 11:15:57 +010018#include <linux/device.h>
19#include <linux/fs.h>
20#include <linux/cdev.h>
21#include <linux/slab.h>
22#include <linux/poll.h>
Lars-Peter Clausend2f0a482013-10-04 12:07:00 +010023#include <linux/sched.h>
Jonathan Cameron14555b12011-09-21 11:15:57 +010024
Jonathan Cameron06458e22012-04-25 15:54:58 +010025#include <linux/iio/iio.h>
Jonathan Cameron14555b12011-09-21 11:15:57 +010026#include "iio_core.h"
Jonathan Cameron06458e22012-04-25 15:54:58 +010027#include <linux/iio/sysfs.h>
28#include <linux/iio/buffer.h>
Jonathan Cameron14555b12011-09-21 11:15:57 +010029
30static const char * const iio_endian_prefix[] = {
31 [IIO_BE] = "be",
32 [IIO_LE] = "le",
33};
34
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +010035static bool iio_buffer_is_active(struct iio_buffer *buf)
Jonathan Cameron84b36ce2012-06-30 20:06:00 +010036{
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +010037 return !list_empty(&buf->buffer_list);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +010038}
39
Lars-Peter Clausen647cc7b2013-11-25 14:56:00 +000040static bool iio_buffer_data_available(struct iio_buffer *buf)
41{
Josselin Costanzi9dd46942014-06-27 17:20:00 +010042 return buf->access->data_available(buf);
Lars-Peter Clausen647cc7b2013-11-25 14:56:00 +000043}
44
Jonathan Cameron14555b12011-09-21 11:15:57 +010045/**
46 * iio_buffer_read_first_n_outer() - chrdev read for buffer access
47 *
48 * This function relies on all buffer implementations having an
49 * iio_buffer as their first element.
50 **/
51ssize_t iio_buffer_read_first_n_outer(struct file *filp, char __user *buf,
52 size_t n, loff_t *f_ps)
53{
54 struct iio_dev *indio_dev = filp->private_data;
55 struct iio_buffer *rb = indio_dev->buffer;
Lars-Peter Clausenee551a12013-11-25 14:56:00 +000056 int ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +010057
Lars-Peter Clausenf18e7a02013-10-04 12:06:00 +010058 if (!indio_dev->info)
59 return -ENODEV;
60
Jonathan Cameron96e00f12011-10-26 17:27:45 +010061 if (!rb || !rb->access->read_first_n)
Jonathan Cameron14555b12011-09-21 11:15:57 +010062 return -EINVAL;
Lars-Peter Clausenee551a12013-11-25 14:56:00 +000063
64 do {
65 if (!iio_buffer_data_available(rb)) {
66 if (filp->f_flags & O_NONBLOCK)
67 return -EAGAIN;
68
69 ret = wait_event_interruptible(rb->pollq,
70 iio_buffer_data_available(rb) ||
71 indio_dev->info == NULL);
72 if (ret)
73 return ret;
74 if (indio_dev->info == NULL)
75 return -ENODEV;
76 }
77
78 ret = rb->access->read_first_n(rb, n, buf);
79 if (ret == 0 && (filp->f_flags & O_NONBLOCK))
80 ret = -EAGAIN;
81 } while (ret == 0);
82
83 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +010084}
85
86/**
87 * iio_buffer_poll() - poll the buffer to find out if it has data
88 */
89unsigned int iio_buffer_poll(struct file *filp,
90 struct poll_table_struct *wait)
91{
92 struct iio_dev *indio_dev = filp->private_data;
93 struct iio_buffer *rb = indio_dev->buffer;
94
Lars-Peter Clausenf18e7a02013-10-04 12:06:00 +010095 if (!indio_dev->info)
96 return -ENODEV;
97
Jonathan Cameron14555b12011-09-21 11:15:57 +010098 poll_wait(filp, &rb->pollq, wait);
Lars-Peter Clausen647cc7b2013-11-25 14:56:00 +000099 if (iio_buffer_data_available(rb))
Jonathan Cameron14555b12011-09-21 11:15:57 +0100100 return POLLIN | POLLRDNORM;
101 /* need a way of knowing if there may be enough data... */
102 return 0;
103}
104
Lars-Peter Clausend2f0a482013-10-04 12:07:00 +0100105/**
106 * iio_buffer_wakeup_poll - Wakes up the buffer waitqueue
107 * @indio_dev: The IIO device
108 *
109 * Wakes up the event waitqueue used for poll(). Should usually
110 * be called when the device is unregistered.
111 */
112void iio_buffer_wakeup_poll(struct iio_dev *indio_dev)
113{
114 if (!indio_dev->buffer)
115 return;
116
117 wake_up(&indio_dev->buffer->pollq);
118}
119
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000120void iio_buffer_init(struct iio_buffer *buffer)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100121{
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000122 INIT_LIST_HEAD(&buffer->demux_list);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100123 INIT_LIST_HEAD(&buffer->buffer_list);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100124 init_waitqueue_head(&buffer->pollq);
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100125 kref_init(&buffer->ref);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100126}
127EXPORT_SYMBOL(iio_buffer_init);
128
129static ssize_t iio_show_scan_index(struct device *dev,
130 struct device_attribute *attr,
131 char *buf)
132{
133 return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
134}
135
136static ssize_t iio_show_fixed_type(struct device *dev,
137 struct device_attribute *attr,
138 char *buf)
139{
140 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
141 u8 type = this_attr->c->scan_type.endianness;
142
143 if (type == IIO_CPU) {
Jonathan Cameron9d5d1152011-10-04 16:02:08 +0100144#ifdef __LITTLE_ENDIAN
145 type = IIO_LE;
146#else
147 type = IIO_BE;
148#endif
Jonathan Cameron14555b12011-09-21 11:15:57 +0100149 }
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +0100150 if (this_attr->c->scan_type.repeat > 1)
151 return sprintf(buf, "%s:%c%d/%dX%d>>%u\n",
152 iio_endian_prefix[type],
153 this_attr->c->scan_type.sign,
154 this_attr->c->scan_type.realbits,
155 this_attr->c->scan_type.storagebits,
156 this_attr->c->scan_type.repeat,
157 this_attr->c->scan_type.shift);
158 else
159 return sprintf(buf, "%s:%c%d/%d>>%u\n",
Jonathan Cameron14555b12011-09-21 11:15:57 +0100160 iio_endian_prefix[type],
161 this_attr->c->scan_type.sign,
162 this_attr->c->scan_type.realbits,
163 this_attr->c->scan_type.storagebits,
164 this_attr->c->scan_type.shift);
165}
166
167static ssize_t iio_scan_el_show(struct device *dev,
168 struct device_attribute *attr,
169 char *buf)
170{
171 int ret;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200172 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100173
Alec Berg2076a202014-03-19 18:50:00 +0000174 /* Ensure ret is 0 or 1. */
175 ret = !!test_bit(to_iio_dev_attr(attr)->address,
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000176 indio_dev->buffer->scan_mask);
177
Jonathan Cameron14555b12011-09-21 11:15:57 +0100178 return sprintf(buf, "%d\n", ret);
179}
180
181static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
182{
183 clear_bit(bit, buffer->scan_mask);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100184 return 0;
185}
186
187static ssize_t iio_scan_el_store(struct device *dev,
188 struct device_attribute *attr,
189 const char *buf,
190 size_t len)
191{
Jonathan Camerona714af22012-04-21 10:09:32 +0100192 int ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100193 bool state;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200194 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100195 struct iio_buffer *buffer = indio_dev->buffer;
196 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
197
Jonathan Camerona714af22012-04-21 10:09:32 +0100198 ret = strtobool(buf, &state);
199 if (ret < 0)
200 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100201 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100202 if (iio_buffer_is_active(indio_dev->buffer)) {
Jonathan Cameron14555b12011-09-21 11:15:57 +0100203 ret = -EBUSY;
204 goto error_ret;
205 }
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000206 ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100207 if (ret < 0)
208 goto error_ret;
209 if (!state && ret) {
210 ret = iio_scan_mask_clear(buffer, this_attr->address);
211 if (ret)
212 goto error_ret;
213 } else if (state && !ret) {
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000214 ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100215 if (ret)
216 goto error_ret;
217 }
218
219error_ret:
220 mutex_unlock(&indio_dev->mlock);
221
Lars-Peter Clausen5a2a6e12011-12-08 18:35:53 +0100222 return ret < 0 ? ret : len;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100223
224}
225
226static ssize_t iio_scan_el_ts_show(struct device *dev,
227 struct device_attribute *attr,
228 char *buf)
229{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200230 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100231 return sprintf(buf, "%d\n", indio_dev->buffer->scan_timestamp);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100232}
233
234static ssize_t iio_scan_el_ts_store(struct device *dev,
235 struct device_attribute *attr,
236 const char *buf,
237 size_t len)
238{
Jonathan Camerona714af22012-04-21 10:09:32 +0100239 int ret;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200240 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100241 bool state;
242
Jonathan Camerona714af22012-04-21 10:09:32 +0100243 ret = strtobool(buf, &state);
244 if (ret < 0)
245 return ret;
246
Jonathan Cameron14555b12011-09-21 11:15:57 +0100247 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100248 if (iio_buffer_is_active(indio_dev->buffer)) {
Jonathan Cameron14555b12011-09-21 11:15:57 +0100249 ret = -EBUSY;
250 goto error_ret;
251 }
252 indio_dev->buffer->scan_timestamp = state;
253error_ret:
254 mutex_unlock(&indio_dev->mlock);
255
256 return ret ? ret : len;
257}
258
259static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev,
260 const struct iio_chan_spec *chan)
261{
262 int ret, attrcount = 0;
263 struct iio_buffer *buffer = indio_dev->buffer;
264
265 ret = __iio_add_chan_devattr("index",
266 chan,
267 &iio_show_scan_index,
268 NULL,
269 0,
Jonathan Cameron37044322013-09-08 14:57:00 +0100270 IIO_SEPARATE,
Jonathan Cameron14555b12011-09-21 11:15:57 +0100271 &indio_dev->dev,
272 &buffer->scan_el_dev_attr_list);
273 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000274 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100275 attrcount++;
276 ret = __iio_add_chan_devattr("type",
277 chan,
278 &iio_show_fixed_type,
279 NULL,
280 0,
281 0,
282 &indio_dev->dev,
283 &buffer->scan_el_dev_attr_list);
284 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000285 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100286 attrcount++;
287 if (chan->type != IIO_TIMESTAMP)
288 ret = __iio_add_chan_devattr("en",
289 chan,
290 &iio_scan_el_show,
291 &iio_scan_el_store,
292 chan->scan_index,
293 0,
294 &indio_dev->dev,
295 &buffer->scan_el_dev_attr_list);
296 else
297 ret = __iio_add_chan_devattr("en",
298 chan,
299 &iio_scan_el_ts_show,
300 &iio_scan_el_ts_store,
301 chan->scan_index,
302 0,
303 &indio_dev->dev,
304 &buffer->scan_el_dev_attr_list);
Peter Meerwald95725882013-09-17 23:42:00 +0100305 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000306 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100307 attrcount++;
308 ret = attrcount;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100309 return ret;
310}
311
Jonathan Cameron14555b12011-09-21 11:15:57 +0100312static const char * const iio_scan_elements_group_name = "scan_elements";
313
314int iio_buffer_register(struct iio_dev *indio_dev,
315 const struct iio_chan_spec *channels,
316 int num_channels)
317{
318 struct iio_dev_attr *p;
319 struct attribute **attr;
320 struct iio_buffer *buffer = indio_dev->buffer;
321 int ret, i, attrn, attrcount, attrcount_orig = 0;
322
323 if (buffer->attrs)
324 indio_dev->groups[indio_dev->groupcounter++] = buffer->attrs;
325
326 if (buffer->scan_el_attrs != NULL) {
327 attr = buffer->scan_el_attrs->attrs;
328 while (*attr++ != NULL)
329 attrcount_orig++;
330 }
331 attrcount = attrcount_orig;
332 INIT_LIST_HEAD(&buffer->scan_el_dev_attr_list);
333 if (channels) {
334 /* new magic */
335 for (i = 0; i < num_channels; i++) {
Lars-Peter Clausenf5b81dd2012-06-18 18:33:47 +0200336 if (channels[i].scan_index < 0)
337 continue;
338
Jonathan Cameron14555b12011-09-21 11:15:57 +0100339 /* Establish necessary mask length */
340 if (channels[i].scan_index >
341 (int)indio_dev->masklength - 1)
342 indio_dev->masklength
Lars-Peter Clausene1dc7be2012-07-02 14:52:56 +0200343 = channels[i].scan_index + 1;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100344
345 ret = iio_buffer_add_channel_sysfs(indio_dev,
346 &channels[i]);
347 if (ret < 0)
348 goto error_cleanup_dynamic;
349 attrcount += ret;
Jonathan Cameronbeb80602011-12-05 21:37:11 +0000350 if (channels[i].type == IIO_TIMESTAMP)
Jonathan Cameronf1264802012-04-21 10:09:34 +0100351 indio_dev->scan_index_timestamp =
Jonathan Cameronbeb80602011-12-05 21:37:11 +0000352 channels[i].scan_index;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100353 }
354 if (indio_dev->masklength && buffer->scan_mask == NULL) {
Thomas Meyerd83fb182011-11-29 22:08:00 +0100355 buffer->scan_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
356 sizeof(*buffer->scan_mask),
357 GFP_KERNEL);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100358 if (buffer->scan_mask == NULL) {
359 ret = -ENOMEM;
360 goto error_cleanup_dynamic;
361 }
362 }
363 }
364
365 buffer->scan_el_group.name = iio_scan_elements_group_name;
366
Thomas Meyerd83fb182011-11-29 22:08:00 +0100367 buffer->scan_el_group.attrs = kcalloc(attrcount + 1,
368 sizeof(buffer->scan_el_group.attrs[0]),
369 GFP_KERNEL);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100370 if (buffer->scan_el_group.attrs == NULL) {
371 ret = -ENOMEM;
372 goto error_free_scan_mask;
373 }
374 if (buffer->scan_el_attrs)
375 memcpy(buffer->scan_el_group.attrs, buffer->scan_el_attrs,
376 sizeof(buffer->scan_el_group.attrs[0])*attrcount_orig);
377 attrn = attrcount_orig;
378
379 list_for_each_entry(p, &buffer->scan_el_dev_attr_list, l)
380 buffer->scan_el_group.attrs[attrn++] = &p->dev_attr.attr;
381 indio_dev->groups[indio_dev->groupcounter++] = &buffer->scan_el_group;
382
383 return 0;
384
385error_free_scan_mask:
386 kfree(buffer->scan_mask);
387error_cleanup_dynamic:
Lars-Peter Clausen84088eb2013-10-07 12:50:00 +0100388 iio_free_chan_devattr_list(&buffer->scan_el_dev_attr_list);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100389
390 return ret;
391}
392EXPORT_SYMBOL(iio_buffer_register);
393
394void iio_buffer_unregister(struct iio_dev *indio_dev)
395{
396 kfree(indio_dev->buffer->scan_mask);
397 kfree(indio_dev->buffer->scan_el_group.attrs);
Lars-Peter Clausen84088eb2013-10-07 12:50:00 +0100398 iio_free_chan_devattr_list(&indio_dev->buffer->scan_el_dev_attr_list);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100399}
400EXPORT_SYMBOL(iio_buffer_unregister);
401
402ssize_t iio_buffer_read_length(struct device *dev,
403 struct device_attribute *attr,
404 char *buf)
405{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200406 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100407 struct iio_buffer *buffer = indio_dev->buffer;
408
409 if (buffer->access->get_length)
410 return sprintf(buf, "%d\n",
411 buffer->access->get_length(buffer));
412
413 return 0;
414}
415EXPORT_SYMBOL(iio_buffer_read_length);
416
417ssize_t iio_buffer_write_length(struct device *dev,
418 struct device_attribute *attr,
419 const char *buf,
420 size_t len)
421{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200422 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100423 struct iio_buffer *buffer = indio_dev->buffer;
Lars-Peter Clausen948ad202012-10-18 14:47:00 +0100424 unsigned int val;
425 int ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100426
Lars-Peter Clausen948ad202012-10-18 14:47:00 +0100427 ret = kstrtouint(buf, 10, &val);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100428 if (ret)
429 return ret;
430
431 if (buffer->access->get_length)
432 if (val == buffer->access->get_length(buffer))
433 return len;
434
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100435 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100436 if (iio_buffer_is_active(indio_dev->buffer)) {
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100437 ret = -EBUSY;
438 } else {
Lars-Peter Clausen869871b2011-12-19 15:23:48 +0100439 if (buffer->access->set_length)
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100440 buffer->access->set_length(buffer, val);
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100441 ret = 0;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100442 }
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100443 mutex_unlock(&indio_dev->mlock);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100444
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100445 return ret ? ret : len;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100446}
447EXPORT_SYMBOL(iio_buffer_write_length);
448
Jonathan Cameron14555b12011-09-21 11:15:57 +0100449ssize_t iio_buffer_show_enable(struct device *dev,
450 struct device_attribute *attr,
451 char *buf)
452{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200453 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100454 return sprintf(buf, "%d\n", iio_buffer_is_active(indio_dev->buffer));
Jonathan Cameron14555b12011-09-21 11:15:57 +0100455}
456EXPORT_SYMBOL(iio_buffer_show_enable);
457
Peter Meerwald95725882013-09-17 23:42:00 +0100458/* Note NULL used as error indicator as it doesn't make sense. */
Michael Hennerichcd4361c2012-02-22 13:16:49 +0100459static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks,
Jonathan Cameron14555b12011-09-21 11:15:57 +0100460 unsigned int masklength,
Michael Hennerichcd4361c2012-02-22 13:16:49 +0100461 const unsigned long *mask)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100462{
463 if (bitmap_empty(mask, masklength))
464 return NULL;
465 while (*av_masks) {
466 if (bitmap_subset(mask, av_masks, masklength))
467 return av_masks;
468 av_masks += BITS_TO_LONGS(masklength);
469 }
470 return NULL;
471}
472
Peter Meerwald183f4172013-09-18 22:10:00 +0100473static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
474 const unsigned long *mask, bool timestamp)
Jonathan Cameron959d2952011-12-05 21:37:13 +0000475{
Jonathan Cameron959d2952011-12-05 21:37:13 +0000476 const struct iio_chan_spec *ch;
477 unsigned bytes = 0;
478 int length, i;
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100479
480 /* How much space will the demuxed element take? */
481 for_each_set_bit(i, mask,
482 indio_dev->masklength) {
483 ch = iio_find_channel_from_si(indio_dev, i);
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +0100484 if (ch->scan_type.repeat > 1)
485 length = ch->scan_type.storagebits / 8 *
486 ch->scan_type.repeat;
487 else
488 length = ch->scan_type.storagebits / 8;
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100489 bytes = ALIGN(bytes, length);
490 bytes += length;
491 }
492 if (timestamp) {
493 ch = iio_find_channel_from_si(indio_dev,
Jonathan Cameronf1264802012-04-21 10:09:34 +0100494 indio_dev->scan_index_timestamp);
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +0100495 if (ch->scan_type.repeat > 1)
496 length = ch->scan_type.storagebits / 8 *
497 ch->scan_type.repeat;
498 else
499 length = ch->scan_type.storagebits / 8;
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100500 bytes = ALIGN(bytes, length);
501 bytes += length;
502 }
503 return bytes;
504}
505
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100506static void iio_buffer_activate(struct iio_dev *indio_dev,
507 struct iio_buffer *buffer)
508{
509 iio_buffer_get(buffer);
510 list_add(&buffer->buffer_list, &indio_dev->buffer_list);
511}
512
513static void iio_buffer_deactivate(struct iio_buffer *buffer)
514{
515 list_del_init(&buffer->buffer_list);
516 iio_buffer_put(buffer);
517}
518
Lars-Peter Clausena87c82e2013-09-18 21:02:00 +0100519void iio_disable_all_buffers(struct iio_dev *indio_dev)
520{
521 struct iio_buffer *buffer, *_buffer;
522
523 if (list_empty(&indio_dev->buffer_list))
524 return;
525
526 if (indio_dev->setup_ops->predisable)
527 indio_dev->setup_ops->predisable(indio_dev);
528
529 list_for_each_entry_safe(buffer, _buffer,
530 &indio_dev->buffer_list, buffer_list)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100531 iio_buffer_deactivate(buffer);
Lars-Peter Clausena87c82e2013-09-18 21:02:00 +0100532
533 indio_dev->currentmode = INDIO_DIRECT_MODE;
534 if (indio_dev->setup_ops->postdisable)
535 indio_dev->setup_ops->postdisable(indio_dev);
Lars-Peter Clausene086ed72013-10-15 09:38:00 +0100536
537 if (indio_dev->available_scan_masks == NULL)
538 kfree(indio_dev->active_scan_mask);
Lars-Peter Clausena87c82e2013-09-18 21:02:00 +0100539}
540
Lars-Peter Clausen8e050992013-10-14 17:49:00 +0100541static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,
542 struct iio_buffer *buffer)
543{
544 unsigned int bytes;
545
546 if (!buffer->access->set_bytes_per_datum)
547 return;
548
549 bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,
550 buffer->scan_timestamp);
551
552 buffer->access->set_bytes_per_datum(buffer, bytes);
553}
554
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100555static int __iio_update_buffers(struct iio_dev *indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100556 struct iio_buffer *insert_buffer,
557 struct iio_buffer *remove_buffer)
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100558{
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100559 int ret;
560 int success = 0;
561 struct iio_buffer *buffer;
562 unsigned long *compound_mask;
563 const unsigned long *old_mask;
Jonathan Cameron959d2952011-12-05 21:37:13 +0000564
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100565 /* Wind down existing buffers - iff there are any */
566 if (!list_empty(&indio_dev->buffer_list)) {
567 if (indio_dev->setup_ops->predisable) {
568 ret = indio_dev->setup_ops->predisable(indio_dev);
569 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000570 return ret;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100571 }
572 indio_dev->currentmode = INDIO_DIRECT_MODE;
573 if (indio_dev->setup_ops->postdisable) {
574 ret = indio_dev->setup_ops->postdisable(indio_dev);
575 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000576 return ret;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100577 }
578 }
579 /* Keep a copy of current setup to allow roll back */
580 old_mask = indio_dev->active_scan_mask;
581 if (!indio_dev->available_scan_masks)
582 indio_dev->active_scan_mask = NULL;
583
584 if (remove_buffer)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100585 iio_buffer_deactivate(remove_buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100586 if (insert_buffer)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100587 iio_buffer_activate(indio_dev, insert_buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100588
589 /* If no buffers in list, we are done */
590 if (list_empty(&indio_dev->buffer_list)) {
591 indio_dev->currentmode = INDIO_DIRECT_MODE;
592 if (indio_dev->available_scan_masks == NULL)
593 kfree(old_mask);
594 return 0;
595 }
Jonathan Cameron959d2952011-12-05 21:37:13 +0000596
Peter Meerwald95725882013-09-17 23:42:00 +0100597 /* What scan mask do we actually have? */
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100598 compound_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
599 sizeof(long), GFP_KERNEL);
600 if (compound_mask == NULL) {
601 if (indio_dev->available_scan_masks == NULL)
602 kfree(old_mask);
603 return -ENOMEM;
604 }
605 indio_dev->scan_timestamp = 0;
606
607 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
608 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
609 indio_dev->masklength);
610 indio_dev->scan_timestamp |= buffer->scan_timestamp;
611 }
612 if (indio_dev->available_scan_masks) {
Jonathan Cameron959d2952011-12-05 21:37:13 +0000613 indio_dev->active_scan_mask =
614 iio_scan_mask_match(indio_dev->available_scan_masks,
615 indio_dev->masklength,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100616 compound_mask);
617 if (indio_dev->active_scan_mask == NULL) {
618 /*
619 * Roll back.
620 * Note can only occur when adding a buffer.
621 */
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100622 iio_buffer_deactivate(insert_buffer);
Peter Meerwaldd66e0452013-09-18 22:10:00 +0100623 if (old_mask) {
624 indio_dev->active_scan_mask = old_mask;
625 success = -EINVAL;
626 }
627 else {
628 kfree(compound_mask);
629 ret = -EINVAL;
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000630 return ret;
Peter Meerwaldd66e0452013-09-18 22:10:00 +0100631 }
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100632 }
633 } else {
634 indio_dev->active_scan_mask = compound_mask;
635 }
Lars-Peter Clausenaff1eb42012-06-15 18:08:59 +0200636
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000637 iio_update_demux(indio_dev);
638
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100639 /* Wind up again */
640 if (indio_dev->setup_ops->preenable) {
641 ret = indio_dev->setup_ops->preenable(indio_dev);
642 if (ret) {
643 printk(KERN_ERR
Michał Mirosławbec18892013-05-04 14:19:00 +0100644 "Buffer not started: buffer preenable failed (%d)\n", ret);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100645 goto error_remove_inserted;
646 }
647 }
648 indio_dev->scan_bytes =
649 iio_compute_scan_bytes(indio_dev,
650 indio_dev->active_scan_mask,
651 indio_dev->scan_timestamp);
Lars-Peter Clausen8e050992013-10-14 17:49:00 +0100652 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
653 iio_buffer_update_bytes_per_datum(indio_dev, buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100654 if (buffer->access->request_update) {
655 ret = buffer->access->request_update(buffer);
656 if (ret) {
657 printk(KERN_INFO
Michał Mirosławbec18892013-05-04 14:19:00 +0100658 "Buffer not started: buffer parameter update failed (%d)\n", ret);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100659 goto error_run_postdisable;
660 }
661 }
Lars-Peter Clausen8e050992013-10-14 17:49:00 +0100662 }
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100663 if (indio_dev->info->update_scan_mode) {
664 ret = indio_dev->info
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000665 ->update_scan_mode(indio_dev,
666 indio_dev->active_scan_mask);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100667 if (ret < 0) {
Michał Mirosławbec18892013-05-04 14:19:00 +0100668 printk(KERN_INFO "Buffer not started: update scan mode failed (%d)\n", ret);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100669 goto error_run_postdisable;
670 }
671 }
Peter Meerwald95725882013-09-17 23:42:00 +0100672 /* Definitely possible for devices to support both of these. */
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100673 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) {
674 if (!indio_dev->trig) {
675 printk(KERN_INFO "Buffer not started: no trigger\n");
676 ret = -EINVAL;
677 /* Can only occur on first buffer */
678 goto error_run_postdisable;
679 }
680 indio_dev->currentmode = INDIO_BUFFER_TRIGGERED;
681 } else if (indio_dev->modes & INDIO_BUFFER_HARDWARE) {
682 indio_dev->currentmode = INDIO_BUFFER_HARDWARE;
Peter Meerwald95725882013-09-17 23:42:00 +0100683 } else { /* Should never be reached */
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100684 ret = -EINVAL;
685 goto error_run_postdisable;
686 }
687
688 if (indio_dev->setup_ops->postenable) {
689 ret = indio_dev->setup_ops->postenable(indio_dev);
690 if (ret) {
691 printk(KERN_INFO
Michał Mirosławbec18892013-05-04 14:19:00 +0100692 "Buffer not started: postenable failed (%d)\n", ret);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100693 indio_dev->currentmode = INDIO_DIRECT_MODE;
694 if (indio_dev->setup_ops->postdisable)
695 indio_dev->setup_ops->postdisable(indio_dev);
696 goto error_disable_all_buffers;
697 }
698 }
699
700 if (indio_dev->available_scan_masks)
701 kfree(compound_mask);
702 else
703 kfree(old_mask);
704
705 return success;
706
707error_disable_all_buffers:
708 indio_dev->currentmode = INDIO_DIRECT_MODE;
709error_run_postdisable:
710 if (indio_dev->setup_ops->postdisable)
711 indio_dev->setup_ops->postdisable(indio_dev);
712error_remove_inserted:
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100713 if (insert_buffer)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100714 iio_buffer_deactivate(insert_buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100715 indio_dev->active_scan_mask = old_mask;
716 kfree(compound_mask);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100717 return ret;
718}
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100719
720int iio_update_buffers(struct iio_dev *indio_dev,
721 struct iio_buffer *insert_buffer,
722 struct iio_buffer *remove_buffer)
723{
724 int ret;
725
Lars-Peter Clausen3909fab2013-10-04 12:07:00 +0100726 if (insert_buffer == remove_buffer)
727 return 0;
728
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100729 mutex_lock(&indio_dev->info_exist_lock);
730 mutex_lock(&indio_dev->mlock);
731
Lars-Peter Clausen3909fab2013-10-04 12:07:00 +0100732 if (insert_buffer && iio_buffer_is_active(insert_buffer))
733 insert_buffer = NULL;
734
735 if (remove_buffer && !iio_buffer_is_active(remove_buffer))
736 remove_buffer = NULL;
737
738 if (!insert_buffer && !remove_buffer) {
739 ret = 0;
740 goto out_unlock;
741 }
742
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100743 if (indio_dev->info == NULL) {
744 ret = -ENODEV;
745 goto out_unlock;
746 }
747
748 ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer);
749
750out_unlock:
751 mutex_unlock(&indio_dev->mlock);
752 mutex_unlock(&indio_dev->info_exist_lock);
753
754 return ret;
755}
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100756EXPORT_SYMBOL_GPL(iio_update_buffers);
757
758ssize_t iio_buffer_store_enable(struct device *dev,
759 struct device_attribute *attr,
760 const char *buf,
761 size_t len)
762{
763 int ret;
764 bool requested_state;
765 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100766 bool inlist;
767
768 ret = strtobool(buf, &requested_state);
769 if (ret < 0)
770 return ret;
771
772 mutex_lock(&indio_dev->mlock);
773
774 /* Find out if it is in the list */
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100775 inlist = iio_buffer_is_active(indio_dev->buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100776 /* Already in desired state */
777 if (inlist == requested_state)
778 goto done;
779
780 if (requested_state)
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100781 ret = __iio_update_buffers(indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100782 indio_dev->buffer, NULL);
783 else
Lars-Peter Clausena9519452013-10-04 12:07:00 +0100784 ret = __iio_update_buffers(indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100785 NULL, indio_dev->buffer);
786
787 if (ret < 0)
788 goto done;
789done:
790 mutex_unlock(&indio_dev->mlock);
791 return (ret < 0) ? ret : len;
792}
793EXPORT_SYMBOL(iio_buffer_store_enable);
794
Jonathan Cameron14555b12011-09-21 11:15:57 +0100795/**
Lars-Peter Clausen81636632012-07-09 10:00:00 +0100796 * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected
797 * @indio_dev: the iio device
798 * @mask: scan mask to be checked
799 *
800 * Return true if exactly one bit is set in the scan mask, false otherwise. It
801 * can be used for devices where only one channel can be active for sampling at
802 * a time.
803 */
804bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
805 const unsigned long *mask)
806{
807 return bitmap_weight(mask, indio_dev->masklength) == 1;
808}
809EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
810
Lars-Peter Clausen939546d2012-07-09 10:00:00 +0100811static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
812 const unsigned long *mask)
813{
814 if (!indio_dev->setup_ops->validate_scan_mask)
815 return true;
816
817 return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask);
818}
819
Jonathan Cameron14555b12011-09-21 11:15:57 +0100820/**
821 * iio_scan_mask_set() - set particular bit in the scan mask
Peter Meerwald95725882013-09-17 23:42:00 +0100822 * @indio_dev: the iio device
Jonathan Cameron14555b12011-09-21 11:15:57 +0100823 * @buffer: the buffer whose scan mask we are interested in
824 * @bit: the bit to be set.
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100825 *
826 * Note that at this point we have no way of knowing what other
827 * buffers might request, hence this code only verifies that the
828 * individual buffers request is plausible.
829 */
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000830int iio_scan_mask_set(struct iio_dev *indio_dev,
831 struct iio_buffer *buffer, int bit)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100832{
Michael Hennerichcd4361c2012-02-22 13:16:49 +0100833 const unsigned long *mask;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100834 unsigned long *trialmask;
835
836 trialmask = kmalloc(sizeof(*trialmask)*
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100837 BITS_TO_LONGS(indio_dev->masklength),
Jonathan Cameron14555b12011-09-21 11:15:57 +0100838 GFP_KERNEL);
839
840 if (trialmask == NULL)
841 return -ENOMEM;
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100842 if (!indio_dev->masklength) {
Peter Meerwald95725882013-09-17 23:42:00 +0100843 WARN_ON("Trying to set scanmask prior to registering buffer\n");
Lars-Peter Clausen939546d2012-07-09 10:00:00 +0100844 goto err_invalid_mask;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100845 }
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100846 bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100847 set_bit(bit, trialmask);
848
Lars-Peter Clausen939546d2012-07-09 10:00:00 +0100849 if (!iio_validate_scan_mask(indio_dev, trialmask))
850 goto err_invalid_mask;
851
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100852 if (indio_dev->available_scan_masks) {
853 mask = iio_scan_mask_match(indio_dev->available_scan_masks,
854 indio_dev->masklength,
Jonathan Cameron14555b12011-09-21 11:15:57 +0100855 trialmask);
Lars-Peter Clausen939546d2012-07-09 10:00:00 +0100856 if (!mask)
857 goto err_invalid_mask;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100858 }
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100859 bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100860
861 kfree(trialmask);
862
863 return 0;
Lars-Peter Clausen939546d2012-07-09 10:00:00 +0100864
865err_invalid_mask:
866 kfree(trialmask);
867 return -EINVAL;
868}
Jonathan Cameron14555b12011-09-21 11:15:57 +0100869EXPORT_SYMBOL_GPL(iio_scan_mask_set);
870
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000871int iio_scan_mask_query(struct iio_dev *indio_dev,
872 struct iio_buffer *buffer, int bit)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100873{
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100874 if (bit > indio_dev->masklength)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100875 return -EINVAL;
876
877 if (!buffer->scan_mask)
878 return 0;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100879
Alec Berg2076a202014-03-19 18:50:00 +0000880 /* Ensure return value is 0 or 1. */
881 return !!test_bit(bit, buffer->scan_mask);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100882};
883EXPORT_SYMBOL_GPL(iio_scan_mask_query);
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000884
885/**
886 * struct iio_demux_table() - table describing demux memcpy ops
887 * @from: index to copy from
Peter Meerwald99698b42012-08-26 13:43:00 +0100888 * @to: index to copy to
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000889 * @length: how many bytes to copy
890 * @l: list head used for management
891 */
892struct iio_demux_table {
893 unsigned from;
894 unsigned to;
895 unsigned length;
896 struct list_head l;
897};
898
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +0100899static const void *iio_demux(struct iio_buffer *buffer,
900 const void *datain)
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000901{
902 struct iio_demux_table *t;
903
904 if (list_empty(&buffer->demux_list))
905 return datain;
906 list_for_each_entry(t, &buffer->demux_list, l)
907 memcpy(buffer->demux_bounce + t->to,
908 datain + t->from, t->length);
909
910 return buffer->demux_bounce;
911}
912
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +0100913static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000914{
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +0100915 const void *dataout = iio_demux(buffer, data);
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000916
Lars-Peter Clausence56ade2012-09-04 13:38:00 +0100917 return buffer->access->store_to(buffer, dataout);
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000918}
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000919
Jonathan Cameron842cd102012-04-21 10:09:45 +0100920static void iio_buffer_demux_free(struct iio_buffer *buffer)
921{
922 struct iio_demux_table *p, *q;
923 list_for_each_entry_safe(p, q, &buffer->demux_list, l) {
924 list_del(&p->l);
925 kfree(p);
926 }
927}
928
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100929
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +0100930int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100931{
932 int ret;
933 struct iio_buffer *buf;
934
935 list_for_each_entry(buf, &indio_dev->buffer_list, buffer_list) {
936 ret = iio_push_to_buffer(buf, data);
937 if (ret < 0)
938 return ret;
939 }
940
941 return 0;
942}
943EXPORT_SYMBOL_GPL(iio_push_to_buffers);
944
Lars-Peter Clausencbe88bc2014-07-17 16:59:00 +0100945static int iio_buffer_add_demux(struct iio_buffer *buffer,
946 struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
947 unsigned int length)
948{
949
950 if (*p && (*p)->from + (*p)->length == in_loc &&
951 (*p)->to + (*p)->length == out_loc) {
952 (*p)->length += length;
953 } else {
Jonathan Cameron7cdca1782014-08-08 09:43:00 +0100954 *p = kmalloc(sizeof(**p), GFP_KERNEL);
Lars-Peter Clausencbe88bc2014-07-17 16:59:00 +0100955 if (*p == NULL)
956 return -ENOMEM;
957 (*p)->from = in_loc;
958 (*p)->to = out_loc;
959 (*p)->length = length;
960 list_add_tail(&(*p)->l, &buffer->demux_list);
961 }
962
963 return 0;
964}
965
Jonathan Cameron84b36ce2012-06-30 20:06:00 +0100966static int iio_buffer_update_demux(struct iio_dev *indio_dev,
967 struct iio_buffer *buffer)
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000968{
969 const struct iio_chan_spec *ch;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000970 int ret, in_ind = -1, out_ind, length;
971 unsigned in_loc = 0, out_loc = 0;
Lars-Peter Clausencbe88bc2014-07-17 16:59:00 +0100972 struct iio_demux_table *p = NULL;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000973
974 /* Clear out any old demux */
Jonathan Cameron842cd102012-04-21 10:09:45 +0100975 iio_buffer_demux_free(buffer);
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000976 kfree(buffer->demux_bounce);
977 buffer->demux_bounce = NULL;
978
979 /* First work out which scan mode we will actually have */
980 if (bitmap_equal(indio_dev->active_scan_mask,
981 buffer->scan_mask,
982 indio_dev->masklength))
983 return 0;
984
985 /* Now we have the two masks, work from least sig and build up sizes */
986 for_each_set_bit(out_ind,
Lars-Peter Clausen61bd55c2014-07-17 16:59:00 +0100987 buffer->scan_mask,
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000988 indio_dev->masklength) {
989 in_ind = find_next_bit(indio_dev->active_scan_mask,
990 indio_dev->masklength,
991 in_ind + 1);
992 while (in_ind != out_ind) {
993 in_ind = find_next_bit(indio_dev->active_scan_mask,
994 indio_dev->masklength,
995 in_ind + 1);
996 ch = iio_find_channel_from_si(indio_dev, in_ind);
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +0100997 if (ch->scan_type.repeat > 1)
998 length = ch->scan_type.storagebits / 8 *
999 ch->scan_type.repeat;
1000 else
1001 length = ch->scan_type.storagebits / 8;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001002 /* Make sure we are aligned */
Lars-Peter Clausen61072db2014-07-17 16:59:00 +01001003 in_loc = roundup(in_loc, length) + length;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001004 }
1005 ch = iio_find_channel_from_si(indio_dev, in_ind);
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +01001006 if (ch->scan_type.repeat > 1)
1007 length = ch->scan_type.storagebits / 8 *
1008 ch->scan_type.repeat;
1009 else
1010 length = ch->scan_type.storagebits / 8;
Lars-Peter Clausen61072db2014-07-17 16:59:00 +01001011 out_loc = roundup(out_loc, length);
1012 in_loc = roundup(in_loc, length);
Lars-Peter Clausencbe88bc2014-07-17 16:59:00 +01001013 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1014 if (ret)
1015 goto error_clear_mux_table;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001016 out_loc += length;
1017 in_loc += length;
1018 }
1019 /* Relies on scan_timestamp being last */
1020 if (buffer->scan_timestamp) {
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001021 ch = iio_find_channel_from_si(indio_dev,
Jonathan Cameronf1264802012-04-21 10:09:34 +01001022 indio_dev->scan_index_timestamp);
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +01001023 if (ch->scan_type.repeat > 1)
1024 length = ch->scan_type.storagebits / 8 *
1025 ch->scan_type.repeat;
1026 else
1027 length = ch->scan_type.storagebits / 8;
Lars-Peter Clausen61072db2014-07-17 16:59:00 +01001028 out_loc = roundup(out_loc, length);
1029 in_loc = roundup(in_loc, length);
Lars-Peter Clausencbe88bc2014-07-17 16:59:00 +01001030 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1031 if (ret)
1032 goto error_clear_mux_table;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001033 out_loc += length;
1034 in_loc += length;
1035 }
1036 buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
1037 if (buffer->demux_bounce == NULL) {
1038 ret = -ENOMEM;
1039 goto error_clear_mux_table;
1040 }
1041 return 0;
1042
1043error_clear_mux_table:
Jonathan Cameron842cd102012-04-21 10:09:45 +01001044 iio_buffer_demux_free(buffer);
1045
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001046 return ret;
1047}
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001048
1049int iio_update_demux(struct iio_dev *indio_dev)
1050{
1051 struct iio_buffer *buffer;
1052 int ret;
1053
1054 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
1055 ret = iio_buffer_update_demux(indio_dev, buffer);
1056 if (ret < 0)
1057 goto error_clear_mux_table;
1058 }
1059 return 0;
1060
1061error_clear_mux_table:
1062 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list)
1063 iio_buffer_demux_free(buffer);
1064
1065 return ret;
1066}
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001067EXPORT_SYMBOL_GPL(iio_update_demux);
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +01001068
1069/**
1070 * iio_buffer_release() - Free a buffer's resources
1071 * @ref: Pointer to the kref embedded in the iio_buffer struct
1072 *
1073 * This function is called when the last reference to the buffer has been
1074 * dropped. It will typically free all resources allocated by the buffer. Do not
1075 * call this function manually, always use iio_buffer_put() when done using a
1076 * buffer.
1077 */
1078static void iio_buffer_release(struct kref *ref)
1079{
1080 struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref);
1081
1082 buffer->access->release(buffer);
1083}
1084
1085/**
1086 * iio_buffer_get() - Grab a reference to the buffer
1087 * @buffer: The buffer to grab a reference for, may be NULL
1088 *
1089 * Returns the pointer to the buffer that was passed into the function.
1090 */
1091struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer)
1092{
1093 if (buffer)
1094 kref_get(&buffer->ref);
1095
1096 return buffer;
1097}
1098EXPORT_SYMBOL_GPL(iio_buffer_get);
1099
1100/**
1101 * iio_buffer_put() - Release the reference to the buffer
1102 * @buffer: The buffer to release the reference for, may be NULL
1103 */
1104void iio_buffer_put(struct iio_buffer *buffer)
1105{
1106 if (buffer)
1107 kref_put(&buffer->ref, iio_buffer_release);
1108}
1109EXPORT_SYMBOL_GPL(iio_buffer_put);