1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/* The industrial I/O core - generic ring buffer interfaces.
*
* Copyright (c) 2008 Jonathan Cameron
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#ifndef _IIO_BUFFER_GENERIC_H_
#define _IIO_BUFFER_GENERIC_H_
#include <linux/sysfs.h>
#include "iio.h"
#include "chrdev.h"
#ifdef CONFIG_IIO_BUFFER
struct iio_ring_buffer;
/**
* struct iio_ring_access_funcs - access functions for ring buffers.
* @mark_in_use: reference counting, typically to prevent module removal
* @unmark_in_use: reduce reference count when no longer using ring buffer
* @store_to: actually store stuff to the ring buffer
* @read_last: get the last element stored
* @read_first_n: try to get a specified number of elements (must exist)
* @mark_param_change: notify ring that some relevant parameter has changed
* Often this means the underlying storage may need to
* change.
* @request_update: if a parameter change has been marked, update underlying
* storage.
* @get_bytes_per_datum:get current bytes per datum
* @set_bytes_per_datum:set number of bytes per datum
* @get_length: get number of datums in ring
* @set_length: set number of datums in ring
* @is_enabled: query if ring is currently being used
* @enable: enable the ring
*
* The purpose of this structure is to make the ring buffer element
* modular as event for a given driver, different usecases may require
* different ring designs (space efficiency vs speed for example).
*
* It is worth noting that a given ring implementation may only support a small
* proportion of these functions. The core code 'should' cope fine with any of
* them not existing.
**/
struct iio_ring_access_funcs {
void (*mark_in_use)(struct iio_ring_buffer *ring);
void (*unmark_in_use)(struct iio_ring_buffer *ring);
int (*store_to)(struct iio_ring_buffer *ring, u8 *data, s64 timestamp);
int (*read_last)(struct iio_ring_buffer *ring, u8 *data);
int (*read_first_n)(struct iio_ring_buffer *ring,
size_t n,
char __user *buf);
int (*mark_param_change)(struct iio_ring_buffer *ring);
int (*request_update)(struct iio_ring_buffer *ring);
int (*get_bytes_per_datum)(struct iio_ring_buffer *ring);
int (*set_bytes_per_datum)(struct iio_ring_buffer *ring, size_t bpd);
int (*get_length)(struct iio_ring_buffer *ring);
int (*set_length)(struct iio_ring_buffer *ring, int length);
int (*is_enabled)(struct iio_ring_buffer *ring);
int (*enable)(struct iio_ring_buffer *ring);
};
/**
* struct iio_ring_setup_ops - buffer setup related callbacks
* @preenable: [DRIVER] function to run prior to marking ring enabled
* @postenable: [DRIVER] function to run after marking ring enabled
* @predisable: [DRIVER] function to run prior to marking ring disabled
* @postdisable: [DRIVER] function to run after marking ring disabled
*/
struct iio_ring_setup_ops {
int (*preenable)(struct iio_dev *);
int (*postenable)(struct iio_dev *);
int (*predisable)(struct iio_dev *);
int (*postdisable)(struct iio_dev *);
};
/**
* struct iio_ring_buffer - general ring buffer structure
* @dev: ring buffer device struct
* @indio_dev: industrial I/O device structure
* @owner: module that owns the ring buffer (for ref counting)
* @length: [DEVICE] number of datums in ring
* @bytes_per_datum: [DEVICE] size of individual datum including timestamp
* @bpe: [DEVICE] size of individual channel value
* @scan_el_attrs: [DRIVER] control of scan elements if that scan mode
* control method is used
* @scan_count: [INTERN] the number of elements in the current scan mode
* @scan_mask: [INTERN] bitmask used in masking scan mode elements
* @scan_timestamp: [INTERN] does the scan mode include a timestamp
* @access: [DRIVER] ring access functions associated with the
* implementation.
* @flags: [INTERN] file ops related flags including busy flag.
**/
struct iio_ring_buffer {
struct iio_dev *indio_dev;
struct module *owner;
int length;
int bytes_per_datum;
int bpe;
struct attribute_group *scan_el_attrs;
int scan_count;
long *scan_mask;
bool scan_timestamp;
const struct iio_ring_access_funcs *access;
const struct iio_ring_setup_ops *setup_ops;
struct list_head scan_el_dev_attr_list;
struct attribute_group scan_el_group;
wait_queue_head_t pollq;
bool stufftoread;
unsigned long flags;
const struct attribute_group *attrs;
};
/**
* iio_ring_buffer_init() - Initialize the buffer structure
* @ring: buffer to be initialized
* @dev_info: the iio device the buffer is assocated with
**/
void iio_ring_buffer_init(struct iio_ring_buffer *ring,
struct iio_dev *dev_info);
void iio_ring_buffer_deinit(struct iio_ring_buffer *ring);
/**
* __iio_update_ring_buffer() - update common elements of ring buffers
* @ring: ring buffer that is the event source
* @bytes_per_datum: size of individual datum including timestamp
* @length: number of datums in ring
**/
static inline void __iio_update_ring_buffer(struct iio_ring_buffer *ring,
int bytes_per_datum, int length)
{
ring->bytes_per_datum = bytes_per_datum;
ring->length = length;
}
int iio_scan_mask_query(struct iio_ring_buffer *ring, int bit);
/**
* iio_scan_mask_set() - set particular bit in the scan mask
* @ring: the ring buffer whose scan mask we are interested in
* @bit: the bit to be set.
**/
int iio_scan_mask_set(struct iio_ring_buffer *ring, int bit);
#define to_iio_ring_buffer(d) \
container_of(d, struct iio_ring_buffer, dev)
/**
* iio_ring_buffer_register() - register the buffer with IIO core
* @indio_dev: device with the buffer to be registered
**/
int iio_ring_buffer_register(struct iio_dev *indio_dev,
const struct iio_chan_spec *channels,
int num_channels);
/**
* iio_ring_buffer_unregister() - unregister the buffer from IIO core
* @indio_dev: the device with the buffer to be unregistered
**/
void iio_ring_buffer_unregister(struct iio_dev *indio_dev);
/**
* iio_read_ring_length() - attr func to get number of datums in the buffer
**/
ssize_t iio_read_ring_length(struct device *dev,
struct device_attribute *attr,
char *buf);
/**
* iio_write_ring_length() - attr func to set number of datums in the buffer
**/
ssize_t iio_write_ring_length(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t len);
/**
* iio_read_ring_bytes_per_datum() - attr for number of bytes in whole datum
**/
ssize_t iio_read_ring_bytes_per_datum(struct device *dev,
struct device_attribute *attr,
char *buf);
/**
* iio_store_ring_enable() - attr to turn the buffer on
**/
ssize_t iio_store_ring_enable(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t len);
/**
* iio_show_ring_enable() - attr to see if the buffer is on
**/
ssize_t iio_show_ring_enable(struct device *dev,
struct device_attribute *attr,
char *buf);
#define IIO_RING_LENGTH_ATTR DEVICE_ATTR(length, S_IRUGO | S_IWUSR, \
iio_read_ring_length, \
iio_write_ring_length)
#define IIO_RING_BYTES_PER_DATUM_ATTR DEVICE_ATTR(bytes_per_datum, S_IRUGO | S_IWUSR, \
iio_read_ring_bytes_per_datum, NULL)
#define IIO_RING_ENABLE_ATTR DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, \
iio_show_ring_enable, \
iio_store_ring_enable)
int iio_sw_ring_preenable(struct iio_dev *indio_dev);
#else /* CONFIG_IIO_BUFFER */
static inline int iio_ring_buffer_register(struct iio_dev *indio_dev,
struct iio_chan_spec *channels,
int num_channels)
{
return 0;
}
static inline void iio_ring_buffer_unregister(struct iio_dev *indio_dev)
{};
#endif /* CONFIG_IIO_BUFFER */
#endif /* _IIO_BUFFER_GENERIC_H_ */
|
