blob: 623fc4850af679f3d1b1969900ead8b9d2c9617c [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>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010023#include <linux/sched/signal.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 Cameron33dd94c2017-01-02 19:28:34 +000029#include <linux/iio/buffer_impl.h>
Jonathan Cameron14555b12011-09-21 11:15:57 +010030
31static const char * const iio_endian_prefix[] = {
32 [IIO_BE] = "be",
33 [IIO_LE] = "le",
34};
35
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +010036static bool iio_buffer_is_active(struct iio_buffer *buf)
Jonathan Cameron84b36ce2012-06-30 20:06:00 +010037{
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +010038 return !list_empty(&buf->buffer_list);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +010039}
40
Josselin Costanzi37d34552015-03-22 20:33:38 +020041static size_t iio_buffer_data_available(struct iio_buffer *buf)
Lars-Peter Clausen647cc7b2013-11-25 14:56:00 +000042{
Josselin Costanzi9dd46942014-06-27 17:20:00 +010043 return buf->access->data_available(buf);
Lars-Peter Clausen647cc7b2013-11-25 14:56:00 +000044}
45
Octavian Purdilaf4f46732015-03-22 20:33:39 +020046static int iio_buffer_flush_hwfifo(struct iio_dev *indio_dev,
47 struct iio_buffer *buf, size_t required)
Josselin Costanzi37d34552015-03-22 20:33:38 +020048{
Octavian Purdilaf4f46732015-03-22 20:33:39 +020049 if (!indio_dev->info->hwfifo_flush_to_buffer)
50 return -ENODEV;
51
52 return indio_dev->info->hwfifo_flush_to_buffer(indio_dev, required);
53}
54
55static bool iio_buffer_ready(struct iio_dev *indio_dev, struct iio_buffer *buf,
56 size_t to_wait, int to_flush)
57{
58 size_t avail;
59 int flushed = 0;
60
Josselin Costanzi37d34552015-03-22 20:33:38 +020061 /* wakeup if the device was unregistered */
62 if (!indio_dev->info)
63 return true;
64
65 /* drain the buffer if it was disabled */
Octavian Purdilaf4f46732015-03-22 20:33:39 +020066 if (!iio_buffer_is_active(buf)) {
Josselin Costanzi37d34552015-03-22 20:33:38 +020067 to_wait = min_t(size_t, to_wait, 1);
Octavian Purdilaf4f46732015-03-22 20:33:39 +020068 to_flush = 0;
69 }
Josselin Costanzi37d34552015-03-22 20:33:38 +020070
Octavian Purdilaf4f46732015-03-22 20:33:39 +020071 avail = iio_buffer_data_available(buf);
72
73 if (avail >= to_wait) {
74 /* force a flush for non-blocking reads */
Octavian Purdilac6f67a12015-06-05 15:56:47 +030075 if (!to_wait && avail < to_flush)
76 iio_buffer_flush_hwfifo(indio_dev, buf,
77 to_flush - avail);
Octavian Purdilaf4f46732015-03-22 20:33:39 +020078 return true;
79 }
80
81 if (to_flush)
82 flushed = iio_buffer_flush_hwfifo(indio_dev, buf,
83 to_wait - avail);
84 if (flushed <= 0)
85 return false;
86
87 if (avail + flushed >= to_wait)
Josselin Costanzi37d34552015-03-22 20:33:38 +020088 return true;
89
90 return false;
91}
92
Jonathan Cameron14555b12011-09-21 11:15:57 +010093/**
94 * iio_buffer_read_first_n_outer() - chrdev read for buffer access
Cristina Opriceana01236352015-07-24 16:18:09 +030095 * @filp: File structure pointer for the char device
96 * @buf: Destination buffer for iio buffer read
97 * @n: First n bytes to read
98 * @f_ps: Long offset provided by the user as a seek position
Jonathan Cameron14555b12011-09-21 11:15:57 +010099 *
100 * This function relies on all buffer implementations having an
101 * iio_buffer as their first element.
Cristina Opriceana01236352015-07-24 16:18:09 +0300102 *
103 * Return: negative values corresponding to error codes or ret != 0
104 * for ending the reading activity
Jonathan Cameron14555b12011-09-21 11:15:57 +0100105 **/
106ssize_t iio_buffer_read_first_n_outer(struct file *filp, char __user *buf,
107 size_t n, loff_t *f_ps)
108{
109 struct iio_dev *indio_dev = filp->private_data;
110 struct iio_buffer *rb = indio_dev->buffer;
Brian Norrisfcf68f32016-08-08 17:19:38 -0700111 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Josselin Costanzi37d34552015-03-22 20:33:38 +0200112 size_t datum_size;
Octavian Purdilac6f67a12015-06-05 15:56:47 +0300113 size_t to_wait;
Colin Ian King5dba4b12016-09-05 15:39:06 +0100114 int ret = 0;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100115
Lars-Peter Clausenf18e7a02013-10-04 12:06:00 +0100116 if (!indio_dev->info)
117 return -ENODEV;
118
Jonathan Cameron96e00f12011-10-26 17:27:45 +0100119 if (!rb || !rb->access->read_first_n)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100120 return -EINVAL;
Lars-Peter Clausenee551a12013-11-25 14:56:00 +0000121
Josselin Costanzi37d34552015-03-22 20:33:38 +0200122 datum_size = rb->bytes_per_datum;
Lars-Peter Clausenee551a12013-11-25 14:56:00 +0000123
Josselin Costanzi37d34552015-03-22 20:33:38 +0200124 /*
125 * If datum_size is 0 there will never be anything to read from the
126 * buffer, so signal end of file now.
127 */
128 if (!datum_size)
129 return 0;
130
Octavian Purdilac6f67a12015-06-05 15:56:47 +0300131 if (filp->f_flags & O_NONBLOCK)
132 to_wait = 0;
133 else
134 to_wait = min_t(size_t, n / datum_size, rb->watermark);
Josselin Costanzi37d34552015-03-22 20:33:38 +0200135
Brian Norrisfcf68f32016-08-08 17:19:38 -0700136 add_wait_queue(&rb->pollq, &wait);
Josselin Costanzi37d34552015-03-22 20:33:38 +0200137 do {
Brian Norrisfcf68f32016-08-08 17:19:38 -0700138 if (!indio_dev->info) {
139 ret = -ENODEV;
140 break;
141 }
Josselin Costanzi37d34552015-03-22 20:33:38 +0200142
Brian Norrisfcf68f32016-08-08 17:19:38 -0700143 if (!iio_buffer_ready(indio_dev, rb, to_wait, n / datum_size)) {
144 if (signal_pending(current)) {
145 ret = -ERESTARTSYS;
146 break;
147 }
148
149 wait_woken(&wait, TASK_INTERRUPTIBLE,
150 MAX_SCHEDULE_TIMEOUT);
151 continue;
152 }
Lars-Peter Clausenee551a12013-11-25 14:56:00 +0000153
154 ret = rb->access->read_first_n(rb, n, buf);
155 if (ret == 0 && (filp->f_flags & O_NONBLOCK))
156 ret = -EAGAIN;
Colin Ian King5dba4b12016-09-05 15:39:06 +0100157 } while (ret == 0);
Brian Norrisfcf68f32016-08-08 17:19:38 -0700158 remove_wait_queue(&rb->pollq, &wait);
Lars-Peter Clausenee551a12013-11-25 14:56:00 +0000159
160 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100161}
162
163/**
164 * iio_buffer_poll() - poll the buffer to find out if it has data
Cristina Opriceana01236352015-07-24 16:18:09 +0300165 * @filp: File structure pointer for device access
166 * @wait: Poll table structure pointer for which the driver adds
167 * a wait queue
168 *
169 * Return: (POLLIN | POLLRDNORM) if data is available for reading
170 * or 0 for other cases
Jonathan Cameron14555b12011-09-21 11:15:57 +0100171 */
172unsigned int iio_buffer_poll(struct file *filp,
173 struct poll_table_struct *wait)
174{
175 struct iio_dev *indio_dev = filp->private_data;
176 struct iio_buffer *rb = indio_dev->buffer;
177
Stefan Windfeldt-Prytz9dc40302018-02-15 15:02:53 +0100178 if (!indio_dev->info || rb == NULL)
Cristina Opriceana1bdc0292015-08-03 13:37:40 +0300179 return 0;
Lars-Peter Clausenf18e7a02013-10-04 12:06:00 +0100180
Jonathan Cameron14555b12011-09-21 11:15:57 +0100181 poll_wait(filp, &rb->pollq, wait);
Octavian Purdilaf4f46732015-03-22 20:33:39 +0200182 if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0))
Jonathan Cameron14555b12011-09-21 11:15:57 +0100183 return POLLIN | POLLRDNORM;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100184 return 0;
185}
186
Lars-Peter Clausend2f0a482013-10-04 12:07:00 +0100187/**
188 * iio_buffer_wakeup_poll - Wakes up the buffer waitqueue
189 * @indio_dev: The IIO device
190 *
191 * Wakes up the event waitqueue used for poll(). Should usually
192 * be called when the device is unregistered.
193 */
194void iio_buffer_wakeup_poll(struct iio_dev *indio_dev)
195{
196 if (!indio_dev->buffer)
197 return;
198
199 wake_up(&indio_dev->buffer->pollq);
200}
201
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000202void iio_buffer_init(struct iio_buffer *buffer)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100203{
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000204 INIT_LIST_HEAD(&buffer->demux_list);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100205 INIT_LIST_HEAD(&buffer->buffer_list);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100206 init_waitqueue_head(&buffer->pollq);
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100207 kref_init(&buffer->ref);
Lars-Peter Clausen4a605352015-10-13 18:10:25 +0200208 if (!buffer->watermark)
209 buffer->watermark = 1;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100210}
211EXPORT_SYMBOL(iio_buffer_init);
212
Jonathan Cameron9f466772017-01-02 19:28:26 +0000213/**
214 * iio_buffer_set_attrs - Set buffer specific attributes
215 * @buffer: The buffer for which we are setting attributes
216 * @attrs: Pointer to a null terminated list of pointers to attributes
217 */
218void iio_buffer_set_attrs(struct iio_buffer *buffer,
219 const struct attribute **attrs)
220{
221 buffer->attrs = attrs;
222}
223EXPORT_SYMBOL_GPL(iio_buffer_set_attrs);
224
Jonathan Cameron14555b12011-09-21 11:15:57 +0100225static ssize_t iio_show_scan_index(struct device *dev,
226 struct device_attribute *attr,
227 char *buf)
228{
229 return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
230}
231
232static ssize_t iio_show_fixed_type(struct device *dev,
233 struct device_attribute *attr,
234 char *buf)
235{
236 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
237 u8 type = this_attr->c->scan_type.endianness;
238
239 if (type == IIO_CPU) {
Jonathan Cameron9d5d1152011-10-04 16:02:08 +0100240#ifdef __LITTLE_ENDIAN
241 type = IIO_LE;
242#else
243 type = IIO_BE;
244#endif
Jonathan Cameron14555b12011-09-21 11:15:57 +0100245 }
Srinivas Pandruvada0ee85462014-04-29 00:51:00 +0100246 if (this_attr->c->scan_type.repeat > 1)
247 return sprintf(buf, "%s:%c%d/%dX%d>>%u\n",
248 iio_endian_prefix[type],
249 this_attr->c->scan_type.sign,
250 this_attr->c->scan_type.realbits,
251 this_attr->c->scan_type.storagebits,
252 this_attr->c->scan_type.repeat,
253 this_attr->c->scan_type.shift);
254 else
255 return sprintf(buf, "%s:%c%d/%d>>%u\n",
Jonathan Cameron14555b12011-09-21 11:15:57 +0100256 iio_endian_prefix[type],
257 this_attr->c->scan_type.sign,
258 this_attr->c->scan_type.realbits,
259 this_attr->c->scan_type.storagebits,
260 this_attr->c->scan_type.shift);
261}
262
263static ssize_t iio_scan_el_show(struct device *dev,
264 struct device_attribute *attr,
265 char *buf)
266{
267 int ret;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200268 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100269
Alec Berg2076a202014-03-19 18:50:00 +0000270 /* Ensure ret is 0 or 1. */
271 ret = !!test_bit(to_iio_dev_attr(attr)->address,
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +0000272 indio_dev->buffer->scan_mask);
273
Jonathan Cameron14555b12011-09-21 11:15:57 +0100274 return sprintf(buf, "%d\n", ret);
275}
276
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100277/* Note NULL used as error indicator as it doesn't make sense. */
278static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks,
279 unsigned int masklength,
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200280 const unsigned long *mask,
281 bool strict)
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100282{
283 if (bitmap_empty(mask, masklength))
284 return NULL;
285 while (*av_masks) {
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200286 if (strict) {
287 if (bitmap_equal(mask, av_masks, masklength))
288 return av_masks;
289 } else {
290 if (bitmap_subset(mask, av_masks, masklength))
291 return av_masks;
292 }
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100293 av_masks += BITS_TO_LONGS(masklength);
294 }
295 return NULL;
296}
297
298static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
299 const unsigned long *mask)
300{
301 if (!indio_dev->setup_ops->validate_scan_mask)
302 return true;
303
304 return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask);
305}
306
307/**
308 * iio_scan_mask_set() - set particular bit in the scan mask
309 * @indio_dev: the iio device
310 * @buffer: the buffer whose scan mask we are interested in
311 * @bit: the bit to be set.
312 *
313 * Note that at this point we have no way of knowing what other
314 * buffers might request, hence this code only verifies that the
315 * individual buffers request is plausible.
316 */
317static int iio_scan_mask_set(struct iio_dev *indio_dev,
318 struct iio_buffer *buffer, int bit)
319{
320 const unsigned long *mask;
321 unsigned long *trialmask;
322
Lars-Peter Clausen1ae72972019-02-20 17:11:32 +0200323 trialmask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
324 sizeof(*trialmask), GFP_KERNEL);
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100325 if (trialmask == NULL)
326 return -ENOMEM;
327 if (!indio_dev->masklength) {
Dan Carpenter231bfe52015-11-21 13:33:00 +0300328 WARN(1, "Trying to set scanmask prior to registering buffer\n");
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100329 goto err_invalid_mask;
330 }
331 bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
332 set_bit(bit, trialmask);
333
334 if (!iio_validate_scan_mask(indio_dev, trialmask))
335 goto err_invalid_mask;
336
337 if (indio_dev->available_scan_masks) {
338 mask = iio_scan_mask_match(indio_dev->available_scan_masks,
339 indio_dev->masklength,
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200340 trialmask, false);
Lars-Peter Clausen217a5cf2014-11-26 18:55:09 +0100341 if (!mask)
342 goto err_invalid_mask;
343 }
344 bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
345
346 kfree(trialmask);
347
348 return 0;
349
350err_invalid_mask:
351 kfree(trialmask);
352 return -EINVAL;
353}
354
Jonathan Cameron14555b12011-09-21 11:15:57 +0100355static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
356{
357 clear_bit(bit, buffer->scan_mask);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100358 return 0;
359}
360
Jonathan Cameronc2bf8d52017-01-02 19:28:27 +0000361static int iio_scan_mask_query(struct iio_dev *indio_dev,
362 struct iio_buffer *buffer, int bit)
363{
364 if (bit > indio_dev->masklength)
365 return -EINVAL;
366
367 if (!buffer->scan_mask)
368 return 0;
369
370 /* Ensure return value is 0 or 1. */
371 return !!test_bit(bit, buffer->scan_mask);
372};
373
Jonathan Cameron14555b12011-09-21 11:15:57 +0100374static ssize_t iio_scan_el_store(struct device *dev,
375 struct device_attribute *attr,
376 const char *buf,
377 size_t len)
378{
Jonathan Camerona714af22012-04-21 10:09:32 +0100379 int ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100380 bool state;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200381 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100382 struct iio_buffer *buffer = indio_dev->buffer;
383 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
384
Jonathan Camerona714af22012-04-21 10:09:32 +0100385 ret = strtobool(buf, &state);
386 if (ret < 0)
387 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100388 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100389 if (iio_buffer_is_active(indio_dev->buffer)) {
Jonathan Cameron14555b12011-09-21 11:15:57 +0100390 ret = -EBUSY;
391 goto error_ret;
392 }
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000393 ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100394 if (ret < 0)
395 goto error_ret;
396 if (!state && ret) {
397 ret = iio_scan_mask_clear(buffer, this_attr->address);
398 if (ret)
399 goto error_ret;
400 } else if (state && !ret) {
Jonathan Cameronf79a9092011-12-05 22:18:29 +0000401 ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100402 if (ret)
403 goto error_ret;
404 }
405
406error_ret:
407 mutex_unlock(&indio_dev->mlock);
408
Lars-Peter Clausen5a2a6e12011-12-08 18:35:53 +0100409 return ret < 0 ? ret : len;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100410
411}
412
413static ssize_t iio_scan_el_ts_show(struct device *dev,
414 struct device_attribute *attr,
415 char *buf)
416{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200417 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameronf8c6f4e2011-10-06 17:14:35 +0100418 return sprintf(buf, "%d\n", indio_dev->buffer->scan_timestamp);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100419}
420
421static ssize_t iio_scan_el_ts_store(struct device *dev,
422 struct device_attribute *attr,
423 const char *buf,
424 size_t len)
425{
Jonathan Camerona714af22012-04-21 10:09:32 +0100426 int ret;
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200427 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100428 bool state;
429
Jonathan Camerona714af22012-04-21 10:09:32 +0100430 ret = strtobool(buf, &state);
431 if (ret < 0)
432 return ret;
433
Jonathan Cameron14555b12011-09-21 11:15:57 +0100434 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100435 if (iio_buffer_is_active(indio_dev->buffer)) {
Jonathan Cameron14555b12011-09-21 11:15:57 +0100436 ret = -EBUSY;
437 goto error_ret;
438 }
439 indio_dev->buffer->scan_timestamp = state;
440error_ret:
441 mutex_unlock(&indio_dev->mlock);
442
443 return ret ? ret : len;
444}
445
446static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev,
447 const struct iio_chan_spec *chan)
448{
449 int ret, attrcount = 0;
450 struct iio_buffer *buffer = indio_dev->buffer;
451
452 ret = __iio_add_chan_devattr("index",
453 chan,
454 &iio_show_scan_index,
455 NULL,
456 0,
Jonathan Cameron37044322013-09-08 14:57:00 +0100457 IIO_SEPARATE,
Jonathan Cameron14555b12011-09-21 11:15:57 +0100458 &indio_dev->dev,
459 &buffer->scan_el_dev_attr_list);
460 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000461 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100462 attrcount++;
463 ret = __iio_add_chan_devattr("type",
464 chan,
465 &iio_show_fixed_type,
466 NULL,
467 0,
468 0,
469 &indio_dev->dev,
470 &buffer->scan_el_dev_attr_list);
471 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000472 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100473 attrcount++;
474 if (chan->type != IIO_TIMESTAMP)
475 ret = __iio_add_chan_devattr("en",
476 chan,
477 &iio_scan_el_show,
478 &iio_scan_el_store,
479 chan->scan_index,
480 0,
481 &indio_dev->dev,
482 &buffer->scan_el_dev_attr_list);
483 else
484 ret = __iio_add_chan_devattr("en",
485 chan,
486 &iio_scan_el_ts_show,
487 &iio_scan_el_ts_store,
488 chan->scan_index,
489 0,
490 &indio_dev->dev,
491 &buffer->scan_el_dev_attr_list);
Peter Meerwald95725882013-09-17 23:42:00 +0100492 if (ret)
Hartmut Knaack92825ff2014-02-16 11:53:00 +0000493 return ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100494 attrcount++;
495 ret = attrcount;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100496 return ret;
497}
498
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +0100499static ssize_t iio_buffer_read_length(struct device *dev,
500 struct device_attribute *attr,
501 char *buf)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100502{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200503 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100504 struct iio_buffer *buffer = indio_dev->buffer;
505
Lars-Peter Clausen37495662014-11-26 18:55:17 +0100506 return sprintf(buf, "%d\n", buffer->length);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100507}
Jonathan Cameron14555b12011-09-21 11:15:57 +0100508
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +0100509static ssize_t iio_buffer_write_length(struct device *dev,
510 struct device_attribute *attr,
511 const char *buf, size_t len)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100512{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200513 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100514 struct iio_buffer *buffer = indio_dev->buffer;
Lars-Peter Clausen948ad202012-10-18 14:47:00 +0100515 unsigned int val;
516 int ret;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100517
Lars-Peter Clausen948ad202012-10-18 14:47:00 +0100518 ret = kstrtouint(buf, 10, &val);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100519 if (ret)
520 return ret;
521
Lars-Peter Clausen37495662014-11-26 18:55:17 +0100522 if (val == buffer->length)
523 return len;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100524
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100525 mutex_lock(&indio_dev->mlock);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100526 if (iio_buffer_is_active(indio_dev->buffer)) {
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100527 ret = -EBUSY;
528 } else {
Lars-Peter Clausen8d92db22014-11-26 18:55:16 +0100529 buffer->access->set_length(buffer, val);
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100530 ret = 0;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100531 }
Josselin Costanzi37d34552015-03-22 20:33:38 +0200532 if (ret)
533 goto out;
534 if (buffer->length && buffer->length < buffer->watermark)
535 buffer->watermark = buffer->length;
536out:
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100537 mutex_unlock(&indio_dev->mlock);
Jonathan Cameron14555b12011-09-21 11:15:57 +0100538
Lars-Peter Clausene38c79e2011-12-19 15:23:44 +0100539 return ret ? ret : len;
Jonathan Cameron14555b12011-09-21 11:15:57 +0100540}
Jonathan Cameron14555b12011-09-21 11:15:57 +0100541
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +0100542static ssize_t iio_buffer_show_enable(struct device *dev,
543 struct device_attribute *attr,
544 char *buf)
Jonathan Cameron14555b12011-09-21 11:15:57 +0100545{
Lars-Peter Clausene53f5ac2012-05-12 15:39:33 +0200546 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +0100547 return sprintf(buf, "%d\n", iio_buffer_is_active(indio_dev->buffer));
Jonathan Cameron14555b12011-09-21 11:15:57 +0100548}
Jonathan Cameron14555b12011-09-21 11:15:57 +0100549
Lars-Peter Clausen182b4902016-02-02 16:27:24 +0100550static unsigned int iio_storage_bytes_for_si(struct iio_dev *indio_dev,
551 unsigned int scan_index)
552{
553 const struct iio_chan_spec *ch;
554 unsigned int bytes;
555
556 ch = iio_find_channel_from_si(indio_dev, scan_index);
557 bytes = ch->scan_type.storagebits / 8;
558 if (ch->scan_type.repeat > 1)
559 bytes *= ch->scan_type.repeat;
560 return bytes;
561}
562
563static unsigned int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev)
564{
565 return iio_storage_bytes_for_si(indio_dev,
566 indio_dev->scan_index_timestamp);
567}
568
Peter Meerwald183f4172013-09-18 22:10:00 +0100569static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
570 const unsigned long *mask, bool timestamp)
Jonathan Cameron959d2952011-12-05 21:37:13 +0000571{
Jonathan Cameron959d2952011-12-05 21:37:13 +0000572 unsigned bytes = 0;
Lars Möllendorfca76e5b2019-12-13 14:50:55 +0100573 int length, i, largest = 0;
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100574
575 /* How much space will the demuxed element take? */
576 for_each_set_bit(i, mask,
577 indio_dev->masklength) {
Lars-Peter Clausen182b4902016-02-02 16:27:24 +0100578 length = iio_storage_bytes_for_si(indio_dev, i);
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100579 bytes = ALIGN(bytes, length);
580 bytes += length;
Lars Möllendorfca76e5b2019-12-13 14:50:55 +0100581 largest = max(largest, length);
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100582 }
Lars-Peter Clausen182b4902016-02-02 16:27:24 +0100583
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100584 if (timestamp) {
Lars-Peter Clausen182b4902016-02-02 16:27:24 +0100585 length = iio_storage_bytes_for_timestamp(indio_dev);
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100586 bytes = ALIGN(bytes, length);
587 bytes += length;
Lars Möllendorfca76e5b2019-12-13 14:50:55 +0100588 largest = max(largest, length);
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100589 }
Lars Möllendorfca76e5b2019-12-13 14:50:55 +0100590
591 bytes = ALIGN(bytes, largest);
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +0100592 return bytes;
593}
594
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100595static void iio_buffer_activate(struct iio_dev *indio_dev,
596 struct iio_buffer *buffer)
597{
598 iio_buffer_get(buffer);
599 list_add(&buffer->buffer_list, &indio_dev->buffer_list);
600}
601
602static void iio_buffer_deactivate(struct iio_buffer *buffer)
603{
604 list_del_init(&buffer->buffer_list);
Josselin Costanzi37d34552015-03-22 20:33:38 +0200605 wake_up_interruptible(&buffer->pollq);
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +0100606 iio_buffer_put(buffer);
607}
608
Lars-Peter Clausen12501862015-05-18 13:34:49 +0200609static void iio_buffer_deactivate_all(struct iio_dev *indio_dev)
610{
611 struct iio_buffer *buffer, *_buffer;
612
613 list_for_each_entry_safe(buffer, _buffer,
614 &indio_dev->buffer_list, buffer_list)
615 iio_buffer_deactivate(buffer);
616}
617
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200618static int iio_buffer_enable(struct iio_buffer *buffer,
619 struct iio_dev *indio_dev)
620{
621 if (!buffer->access->enable)
622 return 0;
623 return buffer->access->enable(buffer, indio_dev);
624}
625
626static int iio_buffer_disable(struct iio_buffer *buffer,
627 struct iio_dev *indio_dev)
628{
629 if (!buffer->access->disable)
630 return 0;
631 return buffer->access->disable(buffer, indio_dev);
632}
633
Lars-Peter Clausen8e050992013-10-14 17:49:00 +0100634static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,
635 struct iio_buffer *buffer)
636{
637 unsigned int bytes;
638
639 if (!buffer->access->set_bytes_per_datum)
640 return;
641
642 bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,
643 buffer->scan_timestamp);
644
645 buffer->access->set_bytes_per_datum(buffer, bytes);
646}
647
Lars-Peter Clausenfcc1b2f2015-05-13 16:04:46 +0200648static int iio_buffer_request_update(struct iio_dev *indio_dev,
649 struct iio_buffer *buffer)
650{
651 int ret;
652
653 iio_buffer_update_bytes_per_datum(indio_dev, buffer);
654 if (buffer->access->request_update) {
655 ret = buffer->access->request_update(buffer);
656 if (ret) {
657 dev_dbg(&indio_dev->dev,
658 "Buffer not started: buffer parameter update failed (%d)\n",
659 ret);
660 return ret;
661 }
662 }
663
664 return 0;
665}
666
Lars-Peter Clausen248be5a2015-05-13 16:04:45 +0200667static void iio_free_scan_mask(struct iio_dev *indio_dev,
668 const unsigned long *mask)
669{
670 /* If the mask is dynamically allocated free it, otherwise do nothing */
671 if (!indio_dev->available_scan_masks)
672 kfree(mask);
673}
674
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200675struct iio_device_config {
676 unsigned int mode;
Lars-Peter Clausenf0566c02015-10-13 18:10:24 +0200677 unsigned int watermark;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200678 const unsigned long *scan_mask;
679 unsigned int scan_bytes;
680 bool scan_timestamp;
681};
682
683static int iio_verify_update(struct iio_dev *indio_dev,
684 struct iio_buffer *insert_buffer, struct iio_buffer *remove_buffer,
685 struct iio_device_config *config)
686{
687 unsigned long *compound_mask;
688 const unsigned long *scan_mask;
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200689 bool strict_scanmask = false;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200690 struct iio_buffer *buffer;
691 bool scan_timestamp;
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200692 unsigned int modes;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200693
694 memset(config, 0, sizeof(*config));
Irina Tirdea1bef2c12016-03-24 11:09:45 +0200695 config->watermark = ~0;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200696
697 /*
698 * If there is just one buffer and we are removing it there is nothing
699 * to verify.
700 */
701 if (remove_buffer && !insert_buffer &&
702 list_is_singular(&indio_dev->buffer_list))
703 return 0;
704
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200705 modes = indio_dev->modes;
706
707 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
708 if (buffer == remove_buffer)
709 continue;
710 modes &= buffer->access->modes;
Lars-Peter Clausenf0566c02015-10-13 18:10:24 +0200711 config->watermark = min(config->watermark, buffer->watermark);
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200712 }
713
Lars-Peter Clausenf0566c02015-10-13 18:10:24 +0200714 if (insert_buffer) {
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200715 modes &= insert_buffer->access->modes;
Lars-Peter Clausenf0566c02015-10-13 18:10:24 +0200716 config->watermark = min(config->watermark,
717 insert_buffer->watermark);
718 }
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200719
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200720 /* Definitely possible for devices to support both of these. */
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200721 if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) {
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200722 config->mode = INDIO_BUFFER_TRIGGERED;
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200723 } else if (modes & INDIO_BUFFER_HARDWARE) {
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200724 /*
725 * Keep things simple for now and only allow a single buffer to
726 * be connected in hardware mode.
727 */
728 if (insert_buffer && !list_empty(&indio_dev->buffer_list))
729 return -EINVAL;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200730 config->mode = INDIO_BUFFER_HARDWARE;
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200731 strict_scanmask = true;
Lars-Peter Clausen225d59a2015-05-29 18:14:21 +0200732 } else if (modes & INDIO_BUFFER_SOFTWARE) {
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200733 config->mode = INDIO_BUFFER_SOFTWARE;
734 } else {
735 /* Can only occur on first buffer */
736 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
737 dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n");
738 return -EINVAL;
739 }
740
741 /* What scan mask do we actually have? */
742 compound_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
743 sizeof(long), GFP_KERNEL);
744 if (compound_mask == NULL)
745 return -ENOMEM;
746
747 scan_timestamp = false;
748
749 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
750 if (buffer == remove_buffer)
751 continue;
752 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
753 indio_dev->masklength);
754 scan_timestamp |= buffer->scan_timestamp;
755 }
756
757 if (insert_buffer) {
758 bitmap_or(compound_mask, compound_mask,
759 insert_buffer->scan_mask, indio_dev->masklength);
760 scan_timestamp |= insert_buffer->scan_timestamp;
761 }
762
763 if (indio_dev->available_scan_masks) {
764 scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
765 indio_dev->masklength,
Lars-Peter Clausen1e1ec282015-05-29 18:14:22 +0200766 compound_mask,
767 strict_scanmask);
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +0200768 kfree(compound_mask);
769 if (scan_mask == NULL)
770 return -EINVAL;
771 } else {
772 scan_mask = compound_mask;
773 }
774
775 config->scan_bytes = iio_compute_scan_bytes(indio_dev,
776 scan_mask, scan_timestamp);
777 config->scan_mask = scan_mask;
778 config->scan_timestamp = scan_timestamp;
779
780 return 0;
781}
782
Jonathan Cameron78c99812017-01-02 19:28:24 +0000783/**
784 * struct iio_demux_table - table describing demux memcpy ops
785 * @from: index to copy from
786 * @to: index to copy to
787 * @length: how many bytes to copy
788 * @l: list head used for management
789 */
790struct iio_demux_table {
791 unsigned from;
792 unsigned to;
793 unsigned length;
794 struct list_head l;
795};
796
797static void iio_buffer_demux_free(struct iio_buffer *buffer)
798{
799 struct iio_demux_table *p, *q;
800 list_for_each_entry_safe(p, q, &buffer->demux_list, l) {
801 list_del(&p->l);
802 kfree(p);
803 }
804}
805
806static int iio_buffer_add_demux(struct iio_buffer *buffer,
807 struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
808 unsigned int length)
809{
810
811 if (*p && (*p)->from + (*p)->length == in_loc &&
812 (*p)->to + (*p)->length == out_loc) {
813 (*p)->length += length;
814 } else {
815 *p = kmalloc(sizeof(**p), GFP_KERNEL);
816 if (*p == NULL)
817 return -ENOMEM;
818 (*p)->from = in_loc;
819 (*p)->to = out_loc;
820 (*p)->length = length;
821 list_add_tail(&(*p)->l, &buffer->demux_list);
822 }
823
824 return 0;
825}
826
827static int iio_buffer_update_demux(struct iio_dev *indio_dev,
828 struct iio_buffer *buffer)
829{
830 int ret, in_ind = -1, out_ind, length;
831 unsigned in_loc = 0, out_loc = 0;
832 struct iio_demux_table *p = NULL;
833
834 /* Clear out any old demux */
835 iio_buffer_demux_free(buffer);
836 kfree(buffer->demux_bounce);
837 buffer->demux_bounce = NULL;
838
839 /* First work out which scan mode we will actually have */
840 if (bitmap_equal(indio_dev->active_scan_mask,
841 buffer->scan_mask,
842 indio_dev->masklength))
843 return 0;
844
845 /* Now we have the two masks, work from least sig and build up sizes */
846 for_each_set_bit(out_ind,
847 buffer->scan_mask,
848 indio_dev->masklength) {
849 in_ind = find_next_bit(indio_dev->active_scan_mask,
850 indio_dev->masklength,
851 in_ind + 1);
852 while (in_ind != out_ind) {
Jonathan Cameron78c99812017-01-02 19:28:24 +0000853 length = iio_storage_bytes_for_si(indio_dev, in_ind);
854 /* Make sure we are aligned */
855 in_loc = roundup(in_loc, length) + length;
Nuno Sá894d7792020-11-12 15:43:22 +0100856 in_ind = find_next_bit(indio_dev->active_scan_mask,
857 indio_dev->masklength,
858 in_ind + 1);
Jonathan Cameron78c99812017-01-02 19:28:24 +0000859 }
860 length = iio_storage_bytes_for_si(indio_dev, in_ind);
861 out_loc = roundup(out_loc, length);
862 in_loc = roundup(in_loc, length);
863 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
864 if (ret)
865 goto error_clear_mux_table;
866 out_loc += length;
867 in_loc += length;
868 }
869 /* Relies on scan_timestamp being last */
870 if (buffer->scan_timestamp) {
871 length = iio_storage_bytes_for_timestamp(indio_dev);
872 out_loc = roundup(out_loc, length);
873 in_loc = roundup(in_loc, length);
874 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
875 if (ret)
876 goto error_clear_mux_table;
877 out_loc += length;
878 in_loc += length;
879 }
880 buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
881 if (buffer->demux_bounce == NULL) {
882 ret = -ENOMEM;
883 goto error_clear_mux_table;
884 }
885 return 0;
886
887error_clear_mux_table:
888 iio_buffer_demux_free(buffer);
889
890 return ret;
891}
892
893static int iio_update_demux(struct iio_dev *indio_dev)
894{
895 struct iio_buffer *buffer;
896 int ret;
897
898 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
899 ret = iio_buffer_update_demux(indio_dev, buffer);
900 if (ret < 0)
901 goto error_clear_mux_table;
902 }
903 return 0;
904
905error_clear_mux_table:
906 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list)
907 iio_buffer_demux_free(buffer);
908
909 return ret;
910}
911
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200912static int iio_enable_buffers(struct iio_dev *indio_dev,
913 struct iio_device_config *config)
914{
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200915 struct iio_buffer *buffer;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200916 int ret;
917
918 indio_dev->active_scan_mask = config->scan_mask;
919 indio_dev->scan_timestamp = config->scan_timestamp;
920 indio_dev->scan_bytes = config->scan_bytes;
921
922 iio_update_demux(indio_dev);
923
924 /* Wind up again */
925 if (indio_dev->setup_ops->preenable) {
926 ret = indio_dev->setup_ops->preenable(indio_dev);
927 if (ret) {
928 dev_dbg(&indio_dev->dev,
929 "Buffer not started: buffer preenable failed (%d)\n", ret);
930 goto err_undo_config;
931 }
932 }
933
934 if (indio_dev->info->update_scan_mode) {
935 ret = indio_dev->info
936 ->update_scan_mode(indio_dev,
937 indio_dev->active_scan_mask);
938 if (ret < 0) {
939 dev_dbg(&indio_dev->dev,
940 "Buffer not started: update scan mode failed (%d)\n",
941 ret);
942 goto err_run_postdisable;
943 }
944 }
945
Lars-Peter Clausenf0566c02015-10-13 18:10:24 +0200946 if (indio_dev->info->hwfifo_set_watermark)
947 indio_dev->info->hwfifo_set_watermark(indio_dev,
948 config->watermark);
949
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200950 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
951 ret = iio_buffer_enable(buffer, indio_dev);
952 if (ret)
953 goto err_disable_buffers;
954 }
955
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200956 indio_dev->currentmode = config->mode;
957
958 if (indio_dev->setup_ops->postenable) {
959 ret = indio_dev->setup_ops->postenable(indio_dev);
960 if (ret) {
961 dev_dbg(&indio_dev->dev,
962 "Buffer not started: postenable failed (%d)\n", ret);
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200963 goto err_disable_buffers;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200964 }
965 }
966
967 return 0;
968
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200969err_disable_buffers:
970 list_for_each_entry_continue_reverse(buffer, &indio_dev->buffer_list,
971 buffer_list)
972 iio_buffer_disable(buffer, indio_dev);
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200973err_run_postdisable:
974 indio_dev->currentmode = INDIO_DIRECT_MODE;
975 if (indio_dev->setup_ops->postdisable)
976 indio_dev->setup_ops->postdisable(indio_dev);
977err_undo_config:
978 indio_dev->active_scan_mask = NULL;
979
980 return ret;
981}
982
983static int iio_disable_buffers(struct iio_dev *indio_dev)
984{
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +0200985 struct iio_buffer *buffer;
Lars-Peter Clausen12501862015-05-18 13:34:49 +0200986 int ret = 0;
987 int ret2;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +0200988
989 /* Wind down existing buffers - iff there are any */
990 if (list_empty(&indio_dev->buffer_list))
991 return 0;
992
Lars-Peter Clausen12501862015-05-18 13:34:49 +0200993 /*
994 * If things go wrong at some step in disable we still need to continue
995 * to perform the other steps, otherwise we leave the device in a
996 * inconsistent state. We return the error code for the first error we
997 * encountered.
998 */
999
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001000 if (indio_dev->setup_ops->predisable) {
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001001 ret2 = indio_dev->setup_ops->predisable(indio_dev);
1002 if (ret2 && !ret)
1003 ret = ret2;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001004 }
1005
Lars-Peter Clausene18a2ad2015-10-13 18:10:27 +02001006 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
1007 ret2 = iio_buffer_disable(buffer, indio_dev);
1008 if (ret2 && !ret)
1009 ret = ret2;
1010 }
1011
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001012 indio_dev->currentmode = INDIO_DIRECT_MODE;
1013
1014 if (indio_dev->setup_ops->postdisable) {
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001015 ret2 = indio_dev->setup_ops->postdisable(indio_dev);
1016 if (ret2 && !ret)
1017 ret = ret2;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001018 }
1019
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001020 iio_free_scan_mask(indio_dev, indio_dev->active_scan_mask);
1021 indio_dev->active_scan_mask = NULL;
1022
1023 return ret;
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001024}
1025
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001026static int __iio_update_buffers(struct iio_dev *indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001027 struct iio_buffer *insert_buffer,
1028 struct iio_buffer *remove_buffer)
Jonathan Cameron6b3b58e2012-04-21 10:09:33 +01001029{
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +02001030 struct iio_device_config new_config;
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001031 int ret;
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +02001032
1033 ret = iio_verify_update(indio_dev, insert_buffer, remove_buffer,
1034 &new_config);
1035 if (ret)
1036 return ret;
Jonathan Cameron959d2952011-12-05 21:37:13 +00001037
Lars-Peter Clausenfcc1b2f2015-05-13 16:04:46 +02001038 if (insert_buffer) {
1039 ret = iio_buffer_request_update(indio_dev, insert_buffer);
1040 if (ret)
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +02001041 goto err_free_config;
Lars-Peter Clausenfcc1b2f2015-05-13 16:04:46 +02001042 }
1043
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001044 ret = iio_disable_buffers(indio_dev);
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001045 if (ret)
1046 goto err_deactivate_all;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001047
1048 if (remove_buffer)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +01001049 iio_buffer_deactivate(remove_buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001050 if (insert_buffer)
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +01001051 iio_buffer_activate(indio_dev, insert_buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001052
1053 /* If no buffers in list, we are done */
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001054 if (list_empty(&indio_dev->buffer_list))
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001055 return 0;
Jonathan Cameron959d2952011-12-05 21:37:13 +00001056
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001057 ret = iio_enable_buffers(indio_dev, &new_config);
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001058 if (ret)
1059 goto err_deactivate_all;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001060
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +02001061 return 0;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001062
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001063err_deactivate_all:
1064 /*
1065 * We've already verified that the config is valid earlier. If things go
1066 * wrong in either enable or disable the most likely reason is an IO
1067 * error from the device. In this case there is no good recovery
1068 * strategy. Just make sure to disable everything and leave the device
1069 * in a sane state. With a bit of luck the device might come back to
1070 * life again later and userspace can try again.
1071 */
1072 iio_buffer_deactivate_all(indio_dev);
1073
Lars-Peter Clausen6e509c42015-05-18 13:34:47 +02001074err_free_config:
1075 iio_free_scan_mask(indio_dev, new_config.scan_mask);
1076 return ret;
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001077}
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001078
1079int iio_update_buffers(struct iio_dev *indio_dev,
1080 struct iio_buffer *insert_buffer,
1081 struct iio_buffer *remove_buffer)
1082{
1083 int ret;
1084
Lars-Peter Clausen3909fab2013-10-04 12:07:00 +01001085 if (insert_buffer == remove_buffer)
1086 return 0;
1087
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001088 mutex_lock(&indio_dev->info_exist_lock);
1089 mutex_lock(&indio_dev->mlock);
1090
Lars-Peter Clausen3909fab2013-10-04 12:07:00 +01001091 if (insert_buffer && iio_buffer_is_active(insert_buffer))
1092 insert_buffer = NULL;
1093
1094 if (remove_buffer && !iio_buffer_is_active(remove_buffer))
1095 remove_buffer = NULL;
1096
1097 if (!insert_buffer && !remove_buffer) {
1098 ret = 0;
1099 goto out_unlock;
1100 }
1101
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001102 if (indio_dev->info == NULL) {
1103 ret = -ENODEV;
1104 goto out_unlock;
1105 }
1106
1107 ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer);
1108
1109out_unlock:
1110 mutex_unlock(&indio_dev->mlock);
1111 mutex_unlock(&indio_dev->info_exist_lock);
1112
1113 return ret;
1114}
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001115EXPORT_SYMBOL_GPL(iio_update_buffers);
1116
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001117void iio_disable_all_buffers(struct iio_dev *indio_dev)
1118{
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001119 iio_disable_buffers(indio_dev);
Lars-Peter Clausen12501862015-05-18 13:34:49 +02001120 iio_buffer_deactivate_all(indio_dev);
Lars-Peter Clausen623d74e2015-05-18 13:34:48 +02001121}
1122
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001123static ssize_t iio_buffer_store_enable(struct device *dev,
1124 struct device_attribute *attr,
1125 const char *buf,
1126 size_t len)
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001127{
1128 int ret;
1129 bool requested_state;
1130 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001131 bool inlist;
1132
1133 ret = strtobool(buf, &requested_state);
1134 if (ret < 0)
1135 return ret;
1136
1137 mutex_lock(&indio_dev->mlock);
1138
1139 /* Find out if it is in the list */
Lars-Peter Clausen705ee2c2013-09-15 16:31:00 +01001140 inlist = iio_buffer_is_active(indio_dev->buffer);
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001141 /* Already in desired state */
1142 if (inlist == requested_state)
1143 goto done;
1144
1145 if (requested_state)
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001146 ret = __iio_update_buffers(indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001147 indio_dev->buffer, NULL);
1148 else
Lars-Peter Clausena9519452013-10-04 12:07:00 +01001149 ret = __iio_update_buffers(indio_dev,
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001150 NULL, indio_dev->buffer);
1151
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001152done:
1153 mutex_unlock(&indio_dev->mlock);
1154 return (ret < 0) ? ret : len;
1155}
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001156
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001157static const char * const iio_scan_elements_group_name = "scan_elements";
1158
Josselin Costanzi37d34552015-03-22 20:33:38 +02001159static ssize_t iio_buffer_show_watermark(struct device *dev,
1160 struct device_attribute *attr,
1161 char *buf)
1162{
1163 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1164 struct iio_buffer *buffer = indio_dev->buffer;
1165
1166 return sprintf(buf, "%u\n", buffer->watermark);
1167}
1168
1169static ssize_t iio_buffer_store_watermark(struct device *dev,
1170 struct device_attribute *attr,
1171 const char *buf,
1172 size_t len)
1173{
1174 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1175 struct iio_buffer *buffer = indio_dev->buffer;
1176 unsigned int val;
1177 int ret;
1178
1179 ret = kstrtouint(buf, 10, &val);
1180 if (ret)
1181 return ret;
1182 if (!val)
1183 return -EINVAL;
1184
1185 mutex_lock(&indio_dev->mlock);
1186
1187 if (val > buffer->length) {
1188 ret = -EINVAL;
1189 goto out;
1190 }
1191
1192 if (iio_buffer_is_active(indio_dev->buffer)) {
1193 ret = -EBUSY;
1194 goto out;
1195 }
1196
1197 buffer->watermark = val;
1198out:
1199 mutex_unlock(&indio_dev->mlock);
1200
1201 return ret ? ret : len;
1202}
1203
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001204static DEVICE_ATTR(length, S_IRUGO | S_IWUSR, iio_buffer_read_length,
1205 iio_buffer_write_length);
Lars-Peter Clausen8d92db22014-11-26 18:55:16 +01001206static struct device_attribute dev_attr_length_ro = __ATTR(length,
1207 S_IRUGO, iio_buffer_read_length, NULL);
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001208static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,
1209 iio_buffer_show_enable, iio_buffer_store_enable);
Josselin Costanzi37d34552015-03-22 20:33:38 +02001210static DEVICE_ATTR(watermark, S_IRUGO | S_IWUSR,
1211 iio_buffer_show_watermark, iio_buffer_store_watermark);
Lars-Peter Clausenb4406552015-10-13 18:10:26 +02001212static struct device_attribute dev_attr_watermark_ro = __ATTR(watermark,
1213 S_IRUGO, iio_buffer_show_watermark, NULL);
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001214
Octavian Purdila6da9b382015-01-31 02:00:00 +02001215static struct attribute *iio_buffer_attrs[] = {
1216 &dev_attr_length.attr,
1217 &dev_attr_enable.attr,
Josselin Costanzi37d34552015-03-22 20:33:38 +02001218 &dev_attr_watermark.attr,
Octavian Purdila6da9b382015-01-31 02:00:00 +02001219};
1220
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001221int iio_buffer_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
1222{
1223 struct iio_dev_attr *p;
1224 struct attribute **attr;
1225 struct iio_buffer *buffer = indio_dev->buffer;
1226 int ret, i, attrn, attrcount, attrcount_orig = 0;
1227 const struct iio_chan_spec *channels;
1228
Lars-Peter Clausen629bc022015-05-29 18:14:20 +02001229 channels = indio_dev->channels;
1230 if (channels) {
1231 int ml = indio_dev->masklength;
1232
1233 for (i = 0; i < indio_dev->num_channels; i++)
1234 ml = max(ml, channels[i].scan_index + 1);
1235 indio_dev->masklength = ml;
1236 }
1237
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001238 if (!buffer)
1239 return 0;
1240
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001241 attrcount = 0;
1242 if (buffer->attrs) {
1243 while (buffer->attrs[attrcount] != NULL)
1244 attrcount++;
1245 }
1246
Octavian Purdila6da9b382015-01-31 02:00:00 +02001247 attr = kcalloc(attrcount + ARRAY_SIZE(iio_buffer_attrs) + 1,
1248 sizeof(struct attribute *), GFP_KERNEL);
1249 if (!attr)
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001250 return -ENOMEM;
1251
Octavian Purdila6da9b382015-01-31 02:00:00 +02001252 memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs));
1253 if (!buffer->access->set_length)
1254 attr[0] = &dev_attr_length_ro.attr;
1255
Lars-Peter Clausenb4406552015-10-13 18:10:26 +02001256 if (buffer->access->flags & INDIO_BUFFER_FLAG_FIXED_WATERMARK)
1257 attr[2] = &dev_attr_watermark_ro.attr;
1258
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001259 if (buffer->attrs)
Octavian Purdila6da9b382015-01-31 02:00:00 +02001260 memcpy(&attr[ARRAY_SIZE(iio_buffer_attrs)], buffer->attrs,
1261 sizeof(struct attribute *) * attrcount);
1262
1263 attr[attrcount + ARRAY_SIZE(iio_buffer_attrs)] = NULL;
1264
1265 buffer->buffer_group.name = "buffer";
1266 buffer->buffer_group.attrs = attr;
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001267
1268 indio_dev->groups[indio_dev->groupcounter++] = &buffer->buffer_group;
1269
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001270 if (buffer->scan_el_attrs != NULL) {
1271 attr = buffer->scan_el_attrs->attrs;
1272 while (*attr++ != NULL)
1273 attrcount_orig++;
1274 }
1275 attrcount = attrcount_orig;
1276 INIT_LIST_HEAD(&buffer->scan_el_dev_attr_list);
1277 channels = indio_dev->channels;
1278 if (channels) {
1279 /* new magic */
1280 for (i = 0; i < indio_dev->num_channels; i++) {
1281 if (channels[i].scan_index < 0)
1282 continue;
1283
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001284 ret = iio_buffer_add_channel_sysfs(indio_dev,
1285 &channels[i]);
1286 if (ret < 0)
1287 goto error_cleanup_dynamic;
1288 attrcount += ret;
1289 if (channels[i].type == IIO_TIMESTAMP)
1290 indio_dev->scan_index_timestamp =
1291 channels[i].scan_index;
1292 }
1293 if (indio_dev->masklength && buffer->scan_mask == NULL) {
1294 buffer->scan_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
1295 sizeof(*buffer->scan_mask),
1296 GFP_KERNEL);
1297 if (buffer->scan_mask == NULL) {
1298 ret = -ENOMEM;
1299 goto error_cleanup_dynamic;
1300 }
1301 }
1302 }
1303
1304 buffer->scan_el_group.name = iio_scan_elements_group_name;
1305
1306 buffer->scan_el_group.attrs = kcalloc(attrcount + 1,
1307 sizeof(buffer->scan_el_group.attrs[0]),
1308 GFP_KERNEL);
1309 if (buffer->scan_el_group.attrs == NULL) {
1310 ret = -ENOMEM;
1311 goto error_free_scan_mask;
1312 }
1313 if (buffer->scan_el_attrs)
1314 memcpy(buffer->scan_el_group.attrs, buffer->scan_el_attrs,
1315 sizeof(buffer->scan_el_group.attrs[0])*attrcount_orig);
1316 attrn = attrcount_orig;
1317
1318 list_for_each_entry(p, &buffer->scan_el_dev_attr_list, l)
1319 buffer->scan_el_group.attrs[attrn++] = &p->dev_attr.attr;
1320 indio_dev->groups[indio_dev->groupcounter++] = &buffer->scan_el_group;
1321
1322 return 0;
1323
1324error_free_scan_mask:
1325 kfree(buffer->scan_mask);
1326error_cleanup_dynamic:
1327 iio_free_chan_devattr_list(&buffer->scan_el_dev_attr_list);
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001328 kfree(indio_dev->buffer->buffer_group.attrs);
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001329
1330 return ret;
1331}
1332
1333void iio_buffer_free_sysfs_and_mask(struct iio_dev *indio_dev)
1334{
1335 if (!indio_dev->buffer)
1336 return;
1337
1338 kfree(indio_dev->buffer->scan_mask);
Lars-Peter Clausen08e7e0a2014-11-26 18:55:15 +01001339 kfree(indio_dev->buffer->buffer_group.attrs);
Lars-Peter Clausend967cb62014-11-26 18:55:14 +01001340 kfree(indio_dev->buffer->scan_el_group.attrs);
1341 iio_free_chan_devattr_list(&indio_dev->buffer->scan_el_dev_attr_list);
1342}
1343
Jonathan Cameron14555b12011-09-21 11:15:57 +01001344/**
Lars-Peter Clausen81636632012-07-09 10:00:00 +01001345 * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected
1346 * @indio_dev: the iio device
1347 * @mask: scan mask to be checked
1348 *
1349 * Return true if exactly one bit is set in the scan mask, false otherwise. It
1350 * can be used for devices where only one channel can be active for sampling at
1351 * a time.
1352 */
1353bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
1354 const unsigned long *mask)
1355{
1356 return bitmap_weight(mask, indio_dev->masklength) == 1;
1357}
1358EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
1359
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +01001360static const void *iio_demux(struct iio_buffer *buffer,
1361 const void *datain)
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001362{
1363 struct iio_demux_table *t;
1364
1365 if (list_empty(&buffer->demux_list))
1366 return datain;
1367 list_for_each_entry(t, &buffer->demux_list, l)
1368 memcpy(buffer->demux_bounce + t->to,
1369 datain + t->from, t->length);
1370
1371 return buffer->demux_bounce;
1372}
1373
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +01001374static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001375{
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +01001376 const void *dataout = iio_demux(buffer, data);
Josselin Costanzi37d34552015-03-22 20:33:38 +02001377 int ret;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001378
Josselin Costanzi37d34552015-03-22 20:33:38 +02001379 ret = buffer->access->store_to(buffer, dataout);
1380 if (ret)
1381 return ret;
1382
1383 /*
1384 * We can't just test for watermark to decide if we wake the poll queue
1385 * because read may request less samples than the watermark.
1386 */
1387 wake_up_interruptible_poll(&buffer->pollq, POLLIN | POLLRDNORM);
1388 return 0;
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001389}
Jonathan Cameron5ada4ea2011-12-05 21:37:14 +00001390
Jonathan Cameron315a19e2017-01-02 19:28:28 +00001391/**
1392 * iio_push_to_buffers() - push to a registered buffer.
1393 * @indio_dev: iio_dev structure for device.
1394 * @data: Full scan.
1395 */
Lars-Peter Clausen5d65d922013-09-15 17:50:00 +01001396int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
Jonathan Cameron84b36ce2012-06-30 20:06:00 +01001397{
1398 int ret;
1399 struct iio_buffer *buf;
1400
1401 list_for_each_entry(buf, &indio_dev->buffer_list, buffer_list) {
1402 ret = iio_push_to_buffer(buf, data);
1403 if (ret < 0)
1404 return ret;
1405 }
1406
1407 return 0;
1408}
1409EXPORT_SYMBOL_GPL(iio_push_to_buffers);
1410
Lars-Peter Clausen9e69c932013-10-04 12:06:00 +01001411/**
1412 * iio_buffer_release() - Free a buffer's resources
1413 * @ref: Pointer to the kref embedded in the iio_buffer struct
1414 *
1415 * This function is called when the last reference to the buffer has been
1416 * dropped. It will typically free all resources allocated by the buffer. Do not
1417 * call this function manually, always use iio_buffer_put() when done using a
1418 * buffer.
1419 */
1420static void iio_buffer_release(struct kref *ref)
1421{
1422 struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref);
1423
1424 buffer->access->release(buffer);
1425}
1426
1427/**
1428 * iio_buffer_get() - Grab a reference to the buffer
1429 * @buffer: The buffer to grab a reference for, may be NULL
1430 *
1431 * Returns the pointer to the buffer that was passed into the function.
1432 */
1433struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer)
1434{
1435 if (buffer)
1436 kref_get(&buffer->ref);
1437
1438 return buffer;
1439}
1440EXPORT_SYMBOL_GPL(iio_buffer_get);
1441
1442/**
1443 * iio_buffer_put() - Release the reference to the buffer
1444 * @buffer: The buffer to release the reference for, may be NULL
1445 */
1446void iio_buffer_put(struct iio_buffer *buffer)
1447{
1448 if (buffer)
1449 kref_put(&buffer->ref, iio_buffer_release);
1450}
1451EXPORT_SYMBOL_GPL(iio_buffer_put);
Jonathan Cameron2b827ad2017-01-02 19:28:32 +00001452
1453/**
1454 * iio_device_attach_buffer - Attach a buffer to a IIO device
1455 * @indio_dev: The device the buffer should be attached to
1456 * @buffer: The buffer to attach to the device
1457 *
1458 * This function attaches a buffer to a IIO device. The buffer stays attached to
1459 * the device until the device is freed. The function should only be called at
1460 * most once per device.
1461 */
1462void iio_device_attach_buffer(struct iio_dev *indio_dev,
1463 struct iio_buffer *buffer)
1464{
1465 indio_dev->buffer = iio_buffer_get(buffer);
1466}
1467EXPORT_SYMBOL_GPL(iio_device_attach_buffer);