1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/kernel.h>
17#include <linux/device.h>
18#include <linux/interrupt.h>
19#include <linux/fs.h>
20#include <linux/poll.h>
21#include <linux/module.h>
22#include <linux/cdev.h>
23#include <linux/idr.h>
24
25#include "iio.h"
26#include "ring_generic.h"
27
28
29static DEFINE_IDR(iio_ring_idr);
30
31static DEFINE_IDR(iio_ring_event_idr);
32
33static DEFINE_IDR(iio_ring_access_idr);
34
35int iio_push_ring_event(struct iio_ring_buffer *ring_buf,
36 int event_code,
37 s64 timestamp)
38{
39 return __iio_push_event(&ring_buf->ev_int,
40 event_code,
41 timestamp,
42 &ring_buf->shared_ev_pointer);
43}
44EXPORT_SYMBOL(iio_push_ring_event);
45
46int iio_push_or_escallate_ring_event(struct iio_ring_buffer *ring_buf,
47 int event_code,
48 s64 timestamp)
49{
50 if (ring_buf->shared_ev_pointer.ev_p)
51 __iio_change_event(ring_buf->shared_ev_pointer.ev_p,
52 event_code,
53 timestamp);
54 else
55 return iio_push_ring_event(ring_buf,
56 event_code,
57 timestamp);
58 return 0;
59}
60EXPORT_SYMBOL(iio_push_or_escallate_ring_event);
61
62
63
64
65
66
67
68int iio_ring_open(struct inode *inode, struct file *filp)
69{
70 struct iio_handler *hand
71 = container_of(inode->i_cdev, struct iio_handler, chrdev);
72 struct iio_ring_buffer *rb = hand->private;
73
74 filp->private_data = hand->private;
75 if (rb->access.mark_in_use)
76 rb->access.mark_in_use(rb);
77
78 return 0;
79}
80
81
82
83
84
85
86
87int iio_ring_release(struct inode *inode, struct file *filp)
88{
89 struct cdev *cd = inode->i_cdev;
90 struct iio_handler *hand = iio_cdev_to_handler(cd);
91 struct iio_ring_buffer *rb = hand->private;
92
93 clear_bit(IIO_BUSY_BIT_POS, &rb->access_handler.flags);
94 if (rb->access.unmark_in_use)
95 rb->access.unmark_in_use(rb);
96
97 return 0;
98}
99
100
101
102
103
104
105
106ssize_t iio_ring_rip_outer(struct file *filp,
107 char *buf,
108 size_t count,
109 loff_t *f_ps)
110{
111 struct iio_ring_buffer *rb = filp->private_data;
112 int ret, dead_offset, copied;
113 u8 *data;
114
115 if (!rb->access.rip_lots)
116 return -EINVAL;
117 copied = rb->access.rip_lots(rb, count, &data, &dead_offset);
118
119 if (copied < 0) {
120 ret = copied;
121 goto error_ret;
122 }
123 if (copy_to_user(buf, data + dead_offset, copied)) {
124 ret = -EFAULT;
125 goto error_free_data_cpy;
126 }
127
128
129
130 kfree(data);
131
132 return copied;
133
134error_free_data_cpy:
135 kfree(data);
136error_ret:
137 return ret;
138}
139
140static const struct file_operations iio_ring_fileops = {
141 .read = iio_ring_rip_outer,
142 .release = iio_ring_release,
143 .open = iio_ring_open,
144 .owner = THIS_MODULE,
145};
146
147
148
149
150
151
152
153static inline int
154__iio_request_ring_buffer_event_chrdev(struct iio_ring_buffer *buf,
155 int id,
156 struct module *owner,
157 struct device *dev)
158{
159 int ret;
160 ret = iio_get_new_idr_val(&iio_ring_event_idr);
161 if (ret < 0)
162 goto error_ret;
163 else
164 buf->ev_int.id = ret;
165
166 snprintf(buf->ev_int._name, 20,
167 "ring_event_line%d",
168 buf->ev_int.id);
169 ret = iio_setup_ev_int(&(buf->ev_int),
170 buf->ev_int._name,
171 owner,
172 dev);
173 if (ret)
174 goto error_free_id;
175 return 0;
176
177error_free_id:
178 iio_free_idr_val(&iio_ring_event_idr, buf->ev_int.id);
179error_ret:
180 return ret;
181}
182
183static inline void
184__iio_free_ring_buffer_event_chrdev(struct iio_ring_buffer *buf)
185{
186 iio_free_ev_int(&(buf->ev_int));
187 iio_free_idr_val(&iio_ring_event_idr, buf->ev_int.id);
188}
189
190static void iio_ring_access_release(struct device *dev)
191{
192 struct iio_ring_buffer *buf
193 = access_dev_to_iio_ring_buffer(dev);
194 cdev_del(&buf->access_handler.chrdev);
195 iio_device_free_chrdev_minor(MINOR(dev->devt));
196}
197
198static struct device_type iio_ring_access_type = {
199 .release = iio_ring_access_release,
200};
201
202static inline int
203__iio_request_ring_buffer_access_chrdev(struct iio_ring_buffer *buf,
204 int id,
205 struct module *owner)
206{
207 int ret, minor;
208
209 buf->access_handler.flags = 0;
210
211 buf->access_dev.parent = &buf->dev;
212 buf->access_dev.class = &iio_class;
213 buf->access_dev.type = &iio_ring_access_type;
214 device_initialize(&buf->access_dev);
215
216 minor = iio_device_get_chrdev_minor();
217 if (minor < 0) {
218 ret = minor;
219 goto error_device_put;
220 }
221 buf->access_dev.devt = MKDEV(MAJOR(iio_devt), minor);
222
223 ret = iio_get_new_idr_val(&iio_ring_access_idr);
224 if (ret < 0)
225 goto error_device_put;
226 else
227 buf->access_id = ret;
228 dev_set_name(&buf->access_dev, "ring_access%d", buf->access_id);
229 ret = device_add(&buf->access_dev);
230 if (ret < 0) {
231 printk(KERN_ERR "failed to add the ring access dev\n");
232 goto error_free_idr;
233 }
234
235 cdev_init(&buf->access_handler.chrdev, &iio_ring_fileops);
236 buf->access_handler.chrdev.owner = owner;
237
238 ret = cdev_add(&buf->access_handler.chrdev, buf->access_dev.devt, 1);
239 if (ret) {
240 printk(KERN_ERR "failed to allocate ring access chrdev\n");
241 goto error_device_unregister;
242 }
243 return 0;
244error_device_unregister:
245 device_unregister(&buf->access_dev);
246error_free_idr:
247 iio_free_idr_val(&iio_ring_access_idr, buf->access_id);
248error_device_put:
249 put_device(&buf->access_dev);
250
251 return ret;
252}
253
254static void __iio_free_ring_buffer_access_chrdev(struct iio_ring_buffer *buf)
255{
256 iio_free_idr_val(&iio_ring_access_idr, buf->access_id);
257 device_unregister(&buf->access_dev);
258}
259
260void iio_ring_buffer_init(struct iio_ring_buffer *ring,
261 struct iio_dev *dev_info)
262{
263 if (ring->access.mark_param_change)
264 ring->access.mark_param_change(ring);
265 ring->indio_dev = dev_info;
266 ring->ev_int.private = ring;
267 ring->access_handler.private = ring;
268}
269EXPORT_SYMBOL(iio_ring_buffer_init);
270
271int iio_ring_buffer_register(struct iio_ring_buffer *ring)
272{
273 int ret;
274 ret = iio_get_new_idr_val(&iio_ring_idr);
275 if (ret < 0)
276 goto error_ret;
277 else
278 ring->id = ret;
279
280 dev_set_name(&ring->dev, "ring_buffer%d", ring->id);
281 ret = device_add(&ring->dev);
282 if (ret)
283 goto error_free_id;
284
285 ret = __iio_request_ring_buffer_event_chrdev(ring,
286 0,
287 ring->owner,
288 &ring->dev);
289 if (ret)
290 goto error_remove_device;
291
292 ret = __iio_request_ring_buffer_access_chrdev(ring,
293 0,
294 ring->owner);
295
296 if (ret)
297 goto error_free_ring_buffer_event_chrdev;
298
299 return ret;
300error_free_ring_buffer_event_chrdev:
301 __iio_free_ring_buffer_event_chrdev(ring);
302error_remove_device:
303 device_del(&ring->dev);
304error_free_id:
305 iio_free_idr_val(&iio_ring_idr, ring->id);
306error_ret:
307 return ret;
308}
309EXPORT_SYMBOL(iio_ring_buffer_register);
310
311void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
312{
313 __iio_free_ring_buffer_access_chrdev(ring);
314 __iio_free_ring_buffer_event_chrdev(ring);
315 device_del(&ring->dev);
316 iio_free_idr_val(&iio_ring_idr, ring->id);
317}
318EXPORT_SYMBOL(iio_ring_buffer_unregister);
319
320ssize_t iio_read_ring_length(struct device *dev,
321 struct device_attribute *attr,
322 char *buf)
323{
324 int len = 0;
325 struct iio_ring_buffer *ring = dev_get_drvdata(dev);
326
327 if (ring->access.get_length)
328 len = sprintf(buf, "%d\n",
329 ring->access.get_length(ring));
330
331 return len;
332}
333EXPORT_SYMBOL(iio_read_ring_length);
334
335 ssize_t iio_write_ring_length(struct device *dev,
336 struct device_attribute *attr,
337 const char *buf,
338 size_t len)
339{
340 int ret;
341 ulong val;
342 struct iio_ring_buffer *ring = dev_get_drvdata(dev);
343 ret = strict_strtoul(buf, 10, &val);
344 if (ret)
345 return ret;
346
347 if (ring->access.get_length)
348 if (val == ring->access.get_length(ring))
349 return len;
350
351 if (ring->access.set_length) {
352 ring->access.set_length(ring, val);
353 if (ring->access.mark_param_change)
354 ring->access.mark_param_change(ring);
355 }
356
357 return len;
358}
359EXPORT_SYMBOL(iio_write_ring_length);
360
361ssize_t iio_read_ring_bps(struct device *dev,
362 struct device_attribute *attr,
363 char *buf)
364{
365 int len = 0;
366 struct iio_ring_buffer *ring = dev_get_drvdata(dev);
367
368 if (ring->access.get_bpd)
369 len = sprintf(buf, "%d\n",
370 ring->access.get_bpd(ring));
371
372 return len;
373}
374EXPORT_SYMBOL(iio_read_ring_bps);
375
376ssize_t iio_store_ring_enable(struct device *dev,
377 struct device_attribute *attr,
378 const char *buf,
379 size_t len)
380{
381 int ret;
382 bool requested_state, current_state;
383 int previous_mode;
384 struct iio_ring_buffer *ring = dev_get_drvdata(dev);
385 struct iio_dev *dev_info = ring->indio_dev;
386
387 mutex_lock(&dev_info->mlock);
388 previous_mode = dev_info->currentmode;
389 requested_state = !(buf[0] == '0');
390 current_state = !!(previous_mode & INDIO_ALL_RING_MODES);
391 if (current_state == requested_state) {
392 printk(KERN_INFO "iio-ring, current state requested again\n");
393 goto done;
394 }
395 if (requested_state) {
396 if (ring->preenable) {
397 ret = ring->preenable(dev_info);
398 if (ret) {
399 printk(KERN_ERR
400 "Buffer not started:"
401 "ring preenable failed\n");
402 goto error_ret;
403 }
404 }
405 if (ring->access.request_update) {
406 ret = ring->access.request_update(ring);
407 if (ret) {
408 printk(KERN_INFO
409 "Buffer not started:"
410 "ring parameter update failed\n");
411 goto error_ret;
412 }
413 }
414 if (ring->access.mark_in_use)
415 ring->access.mark_in_use(ring);
416
417 if (dev_info->modes & INDIO_RING_TRIGGERED) {
418 if (!dev_info->trig) {
419 printk(KERN_INFO
420 "Buffer not started: no trigger\n");
421 ret = -EINVAL;
422 if (ring->access.unmark_in_use)
423 ring->access.unmark_in_use(ring);
424 goto error_ret;
425 }
426 dev_info->currentmode = INDIO_RING_TRIGGERED;
427 } else if (dev_info->modes & INDIO_RING_HARDWARE_BUFFER)
428 dev_info->currentmode = INDIO_RING_HARDWARE_BUFFER;
429 else {
430 ret = -EINVAL;
431 goto error_ret;
432 }
433
434 if (ring->postenable) {
435
436 ret = ring->postenable(dev_info);
437 if (ret) {
438 printk(KERN_INFO
439 "Buffer not started:"
440 "postenable failed\n");
441 if (ring->access.unmark_in_use)
442 ring->access.unmark_in_use(ring);
443 dev_info->currentmode = previous_mode;
444 if (ring->postdisable)
445 ring->postdisable(dev_info);
446 goto error_ret;
447 }
448 }
449 } else {
450 if (ring->predisable) {
451 ret = ring->predisable(dev_info);
452 if (ret)
453 goto error_ret;
454 }
455 if (ring->access.unmark_in_use)
456 ring->access.unmark_in_use(ring);
457 dev_info->currentmode = INDIO_DIRECT_MODE;
458 if (ring->postdisable) {
459 ret = ring->postdisable(dev_info);
460 if (ret)
461 goto error_ret;
462 }
463 }
464done:
465 mutex_unlock(&dev_info->mlock);
466 return len;
467
468error_ret:
469 mutex_unlock(&dev_info->mlock);
470 return ret;
471}
472EXPORT_SYMBOL(iio_store_ring_enable);
473ssize_t iio_show_ring_enable(struct device *dev,
474 struct device_attribute *attr,
475 char *buf)
476{
477 struct iio_ring_buffer *ring = dev_get_drvdata(dev);
478 return sprintf(buf, "%d\n", !!(ring->indio_dev->currentmode
479 & INDIO_ALL_RING_MODES));
480}
481EXPORT_SYMBOL(iio_show_ring_enable);
482
483ssize_t iio_scan_el_show(struct device *dev,
484 struct device_attribute *attr,
485 char *buf)
486{
487 int ret;
488 struct iio_dev *indio_dev = dev_get_drvdata(dev);
489 struct iio_scan_el *this_el = to_iio_scan_el(attr);
490
491 ret = iio_scan_mask_query(indio_dev, this_el->number);
492 if (ret < 0)
493 return ret;
494 return sprintf(buf, "%d\n", ret);
495}
496EXPORT_SYMBOL(iio_scan_el_show);
497
498ssize_t iio_scan_el_store(struct device *dev,
499 struct device_attribute *attr,
500 const char *buf,
501 size_t len)
502{
503 int ret = 0;
504 bool state;
505 struct iio_dev *indio_dev = dev_get_drvdata(dev);
506 struct iio_scan_el *this_el = to_iio_scan_el(attr);
507
508 state = !(buf[0] == '0');
509 mutex_lock(&indio_dev->mlock);
510 if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
511 ret = -EBUSY;
512 goto error_ret;
513 }
514 ret = iio_scan_mask_query(indio_dev, this_el->number);
515 if (ret < 0)
516 goto error_ret;
517 if (!state && ret) {
518 ret = iio_scan_mask_clear(indio_dev, this_el->number);
519 if (ret)
520 goto error_ret;
521 indio_dev->scan_count--;
522 } else if (state && !ret) {
523 ret = iio_scan_mask_set(indio_dev, this_el->number);
524 if (ret)
525 goto error_ret;
526 indio_dev->scan_count++;
527 }
528 if (this_el->set_state)
529 ret = this_el->set_state(this_el, indio_dev, state);
530error_ret:
531 mutex_unlock(&indio_dev->mlock);
532
533 return ret ? ret : len;
534
535}
536EXPORT_SYMBOL(iio_scan_el_store);
537
538ssize_t iio_scan_el_ts_show(struct device *dev,
539 struct device_attribute *attr,
540 char *buf)
541{
542 struct iio_dev *indio_dev = dev_get_drvdata(dev);
543 return sprintf(buf, "%d\n", indio_dev->scan_timestamp);
544}
545EXPORT_SYMBOL(iio_scan_el_ts_show);
546
547ssize_t iio_scan_el_ts_store(struct device *dev,
548 struct device_attribute *attr,
549 const char *buf,
550 size_t len)
551{
552 int ret = 0;
553 struct iio_dev *indio_dev = dev_get_drvdata(dev);
554 bool state;
555 state = !(buf[0] == '0');
556 mutex_lock(&indio_dev->mlock);
557 if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
558 ret = -EBUSY;
559 goto error_ret;
560 }
561 indio_dev->scan_timestamp = state;
562error_ret:
563 mutex_unlock(&indio_dev->mlock);
564
565 return ret ? ret : len;
566}
567EXPORT_SYMBOL(iio_scan_el_ts_store);
568
569
