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
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
|
/* The industrial I/O core
*
* 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 _INDUSTRIAL_IO_H_
#define _INDUSTRIAL_IO_H_
#include <linux/device.h>
#include <linux/cdev.h>
#include "sysfs.h"
#include "chrdev.h"
/* IIO TODO LIST */
/*
* Provide means of adjusting timer accuracy.
* Currently assumes nano seconds.
*/
/* Event interface flags */
#define IIO_BUSY_BIT_POS 1
struct iio_dev;
/**
* iio_get_time_ns() - utility function to get a time stamp for events etc
**/
static inline s64 iio_get_time_ns(void)
{
struct timespec ts;
/*
* calls getnstimeofday.
* If hrtimers then up to ns accurate, if not microsecond.
*/
ktime_get_real_ts(&ts);
return timespec_to_ns(&ts);
}
/**
* iio_add_event_to_list() - Wraps adding to event lists
* @el: the list element of the event to be handled.
* @head: the list associated with the event handler being used.
*
* Does reference counting to allow shared handlers.
**/
void iio_add_event_to_list(struct iio_event_handler_list *el,
struct list_head *head);
/**
* iio_remove_event_from_list() - Wraps removing from event list
* @el: element to be removed
* @head: associate list head for the interrupt handler.
*
* Does reference counting to allow shared handlers.
**/
void iio_remove_event_from_list(struct iio_event_handler_list *el,
struct list_head *head);
/* Device operating modes */
#define INDIO_DIRECT_MODE 0x01
#define INDIO_RING_TRIGGERED 0x02
#define INDIO_RING_HARDWARE_BUFFER 0x08
#define INDIO_ALL_RING_MODES (INDIO_RING_TRIGGERED | INDIO_RING_HARDWARE_BUFFER)
/* Vast majority of this is set by the industrialio subsystem on a
* call to iio_device_register. */
/**
* struct iio_dev - industrial I/O device
* @id: [INTERN] used to identify device internally
* @dev_data: [DRIVER] device specific data
* @modes: [DRIVER] operating modes supported by device
* @currentmode: [DRIVER] current operating mode
* @dev: [DRIVER] device structure, should be assigned a parent
* and owner
* @attrs: [DRIVER] general purpose device attributes
* @driver_module: [DRIVER] module structure used to ensure correct
* ownership of chrdevs etc
* @num_interrupt_lines:[DRIVER] number of physical interrupt lines from device
* @interrupts: [INTERN] interrupt line specific event lists etc
* @event_attrs: [DRIVER] event control attributes
* @event_conf_attrs: [DRIVER] event configuration attributes
* @event_interfaces: [INTERN] event chrdevs associated with interrupt lines
* @ring: [DRIVER] any ring buffer present
* @mlock: [INTERN] lock used to prevent simultaneous device state
* changes
* @available_scan_masks: [DRIVER] optional array of allowed bitmasks
* @trig: [INTERN] current device trigger (ring buffer modes)
* @pollfunc: [DRIVER] function run on trigger being received
**/
struct iio_dev {
int id;
void *dev_data;
int modes;
int currentmode;
struct device dev;
const struct attribute_group *attrs;
struct module *driver_module;
int num_interrupt_lines;
struct iio_interrupt **interrupts;
struct attribute_group *event_attrs;
struct attribute_group *event_conf_attrs;
struct iio_event_interface *event_interfaces;
struct iio_ring_buffer *ring;
struct mutex mlock;
u32 *available_scan_masks;
struct iio_trigger *trig;
struct iio_poll_func *pollfunc;
};
/**
* iio_device_register() - register a device with the IIO subsystem
* @dev_info: Device structure filled by the device driver
**/
int iio_device_register(struct iio_dev *dev_info);
/**
* iio_device_unregister() - unregister a device from the IIO subsystem
* @dev_info: Device structure representing the device.
**/
void iio_device_unregister(struct iio_dev *dev_info);
/**
* struct iio_interrupt - wrapper used to allow easy handling of multiple
* physical interrupt lines
* @dev_info: the iio device for which the is an interrupt line
* @line_number: associated line number
* @id: ida allocated unique id number
* @irq: associate interrupt number
* @ev_list: event handler list for associated events
* @ev_list_lock: ensure only one access to list at a time
**/
struct iio_interrupt {
struct iio_dev *dev_info;
int line_number;
int id;
int irq;
struct list_head ev_list;
spinlock_t ev_list_lock;
};
#define to_iio_interrupt(i) container_of(i, struct iio_interrupt, ev_list)
/**
* iio_register_interrupt_line() - Tell IIO about interrupt lines
*
* @irq: Typically provided via platform data
* @dev_info: IIO device info structure for device
* @line_number: Which interrupt line of the device is this?
* @type: Interrupt type (e.g. edge triggered etc)
* @name: Identifying name.
**/
int iio_register_interrupt_line(unsigned int irq,
struct iio_dev *dev_info,
int line_number,
unsigned long type,
const char *name);
void iio_unregister_interrupt_line(struct iio_dev *dev_info,
int line_number);
/**
* iio_push_event() - try to add event to the list for userspace reading
* @dev_info: IIO device structure
* @ev_line: Which event line (hardware interrupt)
* @ev_code: What event
* @timestamp: When the event occurred
**/
int iio_push_event(struct iio_dev *dev_info,
int ev_line,
int ev_code,
s64 timestamp);
/**
* __iio_push_event() - tries to add an event to the list associated with a chrdev
* @ev_int: the event interface to which we are pushing the event
* @ev_code: the outgoing event code
* @timestamp: timestamp of the event
* @shared_pointer_p: the shared event pointer
**/
int __iio_push_event(struct iio_event_interface *ev_int,
int ev_code,
s64 timestamp,
struct iio_shared_ev_pointer*
shared_pointer_p);
/**
* __iio_change_event() - change an event code in case of event escalation
* @ev: the event to be changed
* @ev_code: new event code
* @timestamp: new timestamp
**/
void __iio_change_event(struct iio_detected_event_list *ev,
int ev_code,
s64 timestamp);
/**
* iio_setup_ev_int() - configure an event interface (chrdev)
* @name: name used for resulting sysfs directory etc.
* @ev_int: interface we are configuring
* @owner: module that is responsible for registering this ev_int
* @dev: device whose ev_int this is
**/
int iio_setup_ev_int(struct iio_event_interface *ev_int,
const char *name,
struct module *owner,
struct device *dev);
void iio_free_ev_int(struct iio_event_interface *ev_int);
/**
* iio_allocate_chrdev() - Allocate a chrdev
* @handler: struct that contains relevant file handling for chrdev
* @dev_info: iio_dev for which chrdev is being created
**/
int iio_allocate_chrdev(struct iio_handler *handler, struct iio_dev *dev_info);
void iio_deallocate_chrdev(struct iio_handler *handler);
/* Used to distinguish between bipolar and unipolar scan elemenents.
* Whilst this may seem obvious, we may well want to change the representation
* in the future!*/
#define IIO_SIGNED(a) -(a)
#define IIO_UNSIGNED(a) (a)
extern dev_t iio_devt;
extern struct bus_type iio_bus_type;
/**
* iio_put_device() - reference counted deallocation of struct device
* @dev: the iio_device containing the device
**/
static inline void iio_put_device(struct iio_dev *dev)
{
if (dev)
put_device(&dev->dev);
};
/**
* to_iio_dev() - get iio_dev for which we have the struct device
* @d: the struct device
**/
static inline struct iio_dev *to_iio_dev(struct device *d)
{
return container_of(d, struct iio_dev, dev);
};
/**
* iio_dev_get_devdata() - helper function gets device specific data
* @d: the iio_dev associated with the device
**/
static inline void *iio_dev_get_devdata(struct iio_dev *d)
{
return d->dev_data;
}
/**
* iio_allocate_device() - allocate an iio_dev from a driver
**/
struct iio_dev *iio_allocate_device(void);
/**
* iio_free_device() - free an iio_dev from a driver
* @dev: the iio_dev associated with the device
**/
void iio_free_device(struct iio_dev *dev);
/**
* iio_put() - internal module reference count reduce
**/
void iio_put(void);
/**
* iio_get() - internal module reference count increase
**/
void iio_get(void);
/**
* iio_device_get_chrdev_minor() - get an unused minor number
**/
int iio_device_get_chrdev_minor(void);
void iio_device_free_chrdev_minor(int val);
/**
* iio_ring_enabled() - helper function to test if any form of ring is enabled
* @dev_info: IIO device info structure for device
**/
static inline bool iio_ring_enabled(struct iio_dev *dev_info)
{
return dev_info->currentmode
& (INDIO_RING_TRIGGERED
| INDIO_RING_HARDWARE_BUFFER);
};
struct ida;
int iio_get_new_ida_val(struct ida *this_ida);
void iio_free_ida_val(struct ida *this_ida, int id);
#endif /* _INDUSTRIAL_IO_H_ */
|
