1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Counter interface |
4 | * Copyright (C) 2018 William Breathitt Gray |
5 | */ |
6 | #ifndef _COUNTER_H_ |
7 | #define _COUNTER_H_ |
8 | |
9 | #include <linux/cdev.h> |
10 | #include <linux/device.h> |
11 | #include <linux/kernel.h> |
12 | #include <linux/kfifo.h> |
13 | #include <linux/mutex.h> |
14 | #include <linux/spinlock_types.h> |
15 | #include <linux/types.h> |
16 | #include <linux/wait.h> |
17 | #include <uapi/linux/counter.h> |
18 | |
19 | struct counter_device; |
20 | struct counter_count; |
21 | struct counter_synapse; |
22 | struct counter_signal; |
23 | |
24 | enum counter_comp_type { |
25 | COUNTER_COMP_U8, |
26 | COUNTER_COMP_U64, |
27 | COUNTER_COMP_BOOL, |
28 | COUNTER_COMP_SIGNAL_LEVEL, |
29 | COUNTER_COMP_FUNCTION, |
30 | COUNTER_COMP_SYNAPSE_ACTION, |
31 | COUNTER_COMP_ENUM, |
32 | COUNTER_COMP_COUNT_DIRECTION, |
33 | COUNTER_COMP_COUNT_MODE, |
34 | COUNTER_COMP_SIGNAL_POLARITY, |
35 | COUNTER_COMP_ARRAY, |
36 | }; |
37 | |
38 | /** |
39 | * struct counter_comp - Counter component node |
40 | * @type: Counter component data type |
41 | * @name: device-specific component name |
42 | * @priv: component-relevant data |
43 | * @action_read: Synapse action mode read callback. The read value of the |
44 | * respective Synapse action mode should be passed back via |
45 | * the action parameter. |
46 | * @device_u8_read: Device u8 component read callback. The read value of the |
47 | * respective Device u8 component should be passed back via |
48 | * the val parameter. |
49 | * @count_u8_read: Count u8 component read callback. The read value of the |
50 | * respective Count u8 component should be passed back via |
51 | * the val parameter. |
52 | * @signal_u8_read: Signal u8 component read callback. The read value of the |
53 | * respective Signal u8 component should be passed back via |
54 | * the val parameter. |
55 | * @device_u32_read: Device u32 component read callback. The read value of |
56 | * the respective Device u32 component should be passed |
57 | * back via the val parameter. |
58 | * @count_u32_read: Count u32 component read callback. The read value of the |
59 | * respective Count u32 component should be passed back via |
60 | * the val parameter. |
61 | * @signal_u32_read: Signal u32 component read callback. The read value of |
62 | * the respective Signal u32 component should be passed |
63 | * back via the val parameter. |
64 | * @device_u64_read: Device u64 component read callback. The read value of |
65 | * the respective Device u64 component should be passed |
66 | * back via the val parameter. |
67 | * @count_u64_read: Count u64 component read callback. The read value of the |
68 | * respective Count u64 component should be passed back via |
69 | * the val parameter. |
70 | * @signal_u64_read: Signal u64 component read callback. The read value of |
71 | * the respective Signal u64 component should be passed |
72 | * back via the val parameter. |
73 | * @signal_array_u32_read: Signal u32 array component read callback. The |
74 | * index of the respective Count u32 array |
75 | * component element is passed via the idx |
76 | * parameter. The read value of the respective |
77 | * Count u32 array component element should be |
78 | * passed back via the val parameter. |
79 | * @device_array_u64_read: Device u64 array component read callback. The |
80 | * index of the respective Device u64 array |
81 | * component element is passed via the idx |
82 | * parameter. The read value of the respective |
83 | * Device u64 array component element should be |
84 | * passed back via the val parameter. |
85 | * @count_array_u64_read: Count u64 array component read callback. The |
86 | * index of the respective Count u64 array |
87 | * component element is passed via the idx |
88 | * parameter. The read value of the respective |
89 | * Count u64 array component element should be |
90 | * passed back via the val parameter. |
91 | * @signal_array_u64_read: Signal u64 array component read callback. The |
92 | * index of the respective Count u64 array |
93 | * component element is passed via the idx |
94 | * parameter. The read value of the respective |
95 | * Count u64 array component element should be |
96 | * passed back via the val parameter. |
97 | * @action_write: Synapse action mode write callback. The write value of |
98 | * the respective Synapse action mode is passed via the |
99 | * action parameter. |
100 | * @device_u8_write: Device u8 component write callback. The write value of |
101 | * the respective Device u8 component is passed via the val |
102 | * parameter. |
103 | * @count_u8_write: Count u8 component write callback. The write value of |
104 | * the respective Count u8 component is passed via the val |
105 | * parameter. |
106 | * @signal_u8_write: Signal u8 component write callback. The write value of |
107 | * the respective Signal u8 component is passed via the val |
108 | * parameter. |
109 | * @device_u32_write: Device u32 component write callback. The write value of |
110 | * the respective Device u32 component is passed via the |
111 | * val parameter. |
112 | * @count_u32_write: Count u32 component write callback. The write value of |
113 | * the respective Count u32 component is passed via the val |
114 | * parameter. |
115 | * @signal_u32_write: Signal u32 component write callback. The write value of |
116 | * the respective Signal u32 component is passed via the |
117 | * val parameter. |
118 | * @device_u64_write: Device u64 component write callback. The write value of |
119 | * the respective Device u64 component is passed via the |
120 | * val parameter. |
121 | * @count_u64_write: Count u64 component write callback. The write value of |
122 | * the respective Count u64 component is passed via the val |
123 | * parameter. |
124 | * @signal_u64_write: Signal u64 component write callback. The write value of |
125 | * the respective Signal u64 component is passed via the |
126 | * val parameter. |
127 | * @signal_array_u32_write: Signal u32 array component write callback. The |
128 | * index of the respective Signal u32 array |
129 | * component element is passed via the idx |
130 | * parameter. The write value of the respective |
131 | * Signal u32 array component element is passed via |
132 | * the val parameter. |
133 | * @device_array_u64_write: Device u64 array component write callback. The |
134 | * index of the respective Device u64 array |
135 | * component element is passed via the idx |
136 | * parameter. The write value of the respective |
137 | * Device u64 array component element is passed via |
138 | * the val parameter. |
139 | * @count_array_u64_write: Count u64 array component write callback. The |
140 | * index of the respective Count u64 array |
141 | * component element is passed via the idx |
142 | * parameter. The write value of the respective |
143 | * Count u64 array component element is passed via |
144 | * the val parameter. |
145 | * @signal_array_u64_write: Signal u64 array component write callback. The |
146 | * index of the respective Signal u64 array |
147 | * component element is passed via the idx |
148 | * parameter. The write value of the respective |
149 | * Signal u64 array component element is passed via |
150 | * the val parameter. |
151 | */ |
152 | struct counter_comp { |
153 | enum counter_comp_type type; |
154 | const char *name; |
155 | void *priv; |
156 | union { |
157 | int (*action_read)(struct counter_device *counter, |
158 | struct counter_count *count, |
159 | struct counter_synapse *synapse, |
160 | enum counter_synapse_action *action); |
161 | int (*device_u8_read)(struct counter_device *counter, u8 *val); |
162 | int (*count_u8_read)(struct counter_device *counter, |
163 | struct counter_count *count, u8 *val); |
164 | int (*signal_u8_read)(struct counter_device *counter, |
165 | struct counter_signal *signal, u8 *val); |
166 | int (*device_u32_read)(struct counter_device *counter, |
167 | u32 *val); |
168 | int (*count_u32_read)(struct counter_device *counter, |
169 | struct counter_count *count, u32 *val); |
170 | int (*signal_u32_read)(struct counter_device *counter, |
171 | struct counter_signal *signal, u32 *val); |
172 | int (*device_u64_read)(struct counter_device *counter, |
173 | u64 *val); |
174 | int (*count_u64_read)(struct counter_device *counter, |
175 | struct counter_count *count, u64 *val); |
176 | int (*signal_u64_read)(struct counter_device *counter, |
177 | struct counter_signal *signal, u64 *val); |
178 | int (*signal_array_u32_read)(struct counter_device *counter, |
179 | struct counter_signal *signal, |
180 | size_t idx, u32 *val); |
181 | int (*device_array_u64_read)(struct counter_device *counter, |
182 | size_t idx, u64 *val); |
183 | int (*count_array_u64_read)(struct counter_device *counter, |
184 | struct counter_count *count, |
185 | size_t idx, u64 *val); |
186 | int (*signal_array_u64_read)(struct counter_device *counter, |
187 | struct counter_signal *signal, |
188 | size_t idx, u64 *val); |
189 | }; |
190 | union { |
191 | int (*action_write)(struct counter_device *counter, |
192 | struct counter_count *count, |
193 | struct counter_synapse *synapse, |
194 | enum counter_synapse_action action); |
195 | int (*device_u8_write)(struct counter_device *counter, u8 val); |
196 | int (*count_u8_write)(struct counter_device *counter, |
197 | struct counter_count *count, u8 val); |
198 | int (*signal_u8_write)(struct counter_device *counter, |
199 | struct counter_signal *signal, u8 val); |
200 | int (*device_u32_write)(struct counter_device *counter, |
201 | u32 val); |
202 | int (*count_u32_write)(struct counter_device *counter, |
203 | struct counter_count *count, u32 val); |
204 | int (*signal_u32_write)(struct counter_device *counter, |
205 | struct counter_signal *signal, u32 val); |
206 | int (*device_u64_write)(struct counter_device *counter, |
207 | u64 val); |
208 | int (*count_u64_write)(struct counter_device *counter, |
209 | struct counter_count *count, u64 val); |
210 | int (*signal_u64_write)(struct counter_device *counter, |
211 | struct counter_signal *signal, u64 val); |
212 | int (*signal_array_u32_write)(struct counter_device *counter, |
213 | struct counter_signal *signal, |
214 | size_t idx, u32 val); |
215 | int (*device_array_u64_write)(struct counter_device *counter, |
216 | size_t idx, u64 val); |
217 | int (*count_array_u64_write)(struct counter_device *counter, |
218 | struct counter_count *count, |
219 | size_t idx, u64 val); |
220 | int (*signal_array_u64_write)(struct counter_device *counter, |
221 | struct counter_signal *signal, |
222 | size_t idx, u64 val); |
223 | }; |
224 | }; |
225 | |
226 | /** |
227 | * struct counter_signal - Counter Signal node |
228 | * @id: unique ID used to identify the Signal |
229 | * @name: device-specific Signal name |
230 | * @ext: optional array of Signal extensions |
231 | * @num_ext: number of Signal extensions specified in @ext |
232 | */ |
233 | struct counter_signal { |
234 | int id; |
235 | const char *name; |
236 | |
237 | struct counter_comp *ext; |
238 | size_t num_ext; |
239 | }; |
240 | |
241 | /** |
242 | * struct counter_synapse - Counter Synapse node |
243 | * @actions_list: array of available action modes |
244 | * @num_actions: number of action modes specified in @actions_list |
245 | * @signal: pointer to the associated Signal |
246 | */ |
247 | struct counter_synapse { |
248 | const enum counter_synapse_action *actions_list; |
249 | size_t num_actions; |
250 | |
251 | struct counter_signal *signal; |
252 | }; |
253 | |
254 | /** |
255 | * struct counter_count - Counter Count node |
256 | * @id: unique ID used to identify the Count |
257 | * @name: device-specific Count name |
258 | * @functions_list: array of available function modes |
259 | * @num_functions: number of function modes specified in @functions_list |
260 | * @synapses: array of Synapses for initialization |
261 | * @num_synapses: number of Synapses specified in @synapses |
262 | * @ext: optional array of Count extensions |
263 | * @num_ext: number of Count extensions specified in @ext |
264 | */ |
265 | struct counter_count { |
266 | int id; |
267 | const char *name; |
268 | |
269 | const enum counter_function *functions_list; |
270 | size_t num_functions; |
271 | |
272 | struct counter_synapse *synapses; |
273 | size_t num_synapses; |
274 | |
275 | struct counter_comp *ext; |
276 | size_t num_ext; |
277 | }; |
278 | |
279 | /** |
280 | * struct counter_event_node - Counter Event node |
281 | * @l: list of current watching Counter events |
282 | * @event: event that triggers |
283 | * @channel: event channel |
284 | * @comp_list: list of components to watch when event triggers |
285 | */ |
286 | struct counter_event_node { |
287 | struct list_head l; |
288 | u8 event; |
289 | u8 channel; |
290 | struct list_head comp_list; |
291 | }; |
292 | |
293 | /** |
294 | * struct counter_ops - Callbacks from driver |
295 | * @signal_read: optional read callback for Signals. The read level of |
296 | * the respective Signal should be passed back via the |
297 | * level parameter. |
298 | * @count_read: read callback for Counts. The read value of the |
299 | * respective Count should be passed back via the value |
300 | * parameter. |
301 | * @count_write: optional write callback for Counts. The write value for |
302 | * the respective Count is passed in via the value |
303 | * parameter. |
304 | * @function_read: read callback the Count function modes. The read |
305 | * function mode of the respective Count should be passed |
306 | * back via the function parameter. |
307 | * @function_write: optional write callback for Count function modes. The |
308 | * function mode to write for the respective Count is |
309 | * passed in via the function parameter. |
310 | * @action_read: optional read callback the Synapse action modes. The |
311 | * read action mode of the respective Synapse should be |
312 | * passed back via the action parameter. |
313 | * @action_write: optional write callback for Synapse action modes. The |
314 | * action mode to write for the respective Synapse is |
315 | * passed in via the action parameter. |
316 | * @events_configure: optional write callback to configure events. The list of |
317 | * struct counter_event_node may be accessed via the |
318 | * events_list member of the counter parameter. |
319 | * @watch_validate: optional callback to validate a watch. The Counter |
320 | * component watch configuration is passed in via the watch |
321 | * parameter. A return value of 0 indicates a valid Counter |
322 | * component watch configuration. |
323 | */ |
324 | struct counter_ops { |
325 | int (*signal_read)(struct counter_device *counter, |
326 | struct counter_signal *signal, |
327 | enum counter_signal_level *level); |
328 | int (*count_read)(struct counter_device *counter, |
329 | struct counter_count *count, u64 *value); |
330 | int (*count_write)(struct counter_device *counter, |
331 | struct counter_count *count, u64 value); |
332 | int (*function_read)(struct counter_device *counter, |
333 | struct counter_count *count, |
334 | enum counter_function *function); |
335 | int (*function_write)(struct counter_device *counter, |
336 | struct counter_count *count, |
337 | enum counter_function function); |
338 | int (*action_read)(struct counter_device *counter, |
339 | struct counter_count *count, |
340 | struct counter_synapse *synapse, |
341 | enum counter_synapse_action *action); |
342 | int (*action_write)(struct counter_device *counter, |
343 | struct counter_count *count, |
344 | struct counter_synapse *synapse, |
345 | enum counter_synapse_action action); |
346 | int (*events_configure)(struct counter_device *counter); |
347 | int (*watch_validate)(struct counter_device *counter, |
348 | const struct counter_watch *watch); |
349 | }; |
350 | |
351 | /** |
352 | * struct counter_device - Counter data structure |
353 | * @name: name of the device |
354 | * @parent: optional parent device providing the counters |
355 | * @ops: callbacks from driver |
356 | * @signals: array of Signals |
357 | * @num_signals: number of Signals specified in @signals |
358 | * @counts: array of Counts |
359 | * @num_counts: number of Counts specified in @counts |
360 | * @ext: optional array of Counter device extensions |
361 | * @num_ext: number of Counter device extensions specified in @ext |
362 | * @priv: optional private data supplied by driver |
363 | * @dev: internal device structure |
364 | * @chrdev: internal character device structure |
365 | * @events_list: list of current watching Counter events |
366 | * @events_list_lock: lock to protect Counter events list operations |
367 | * @next_events_list: list of next watching Counter events |
368 | * @n_events_list_lock: lock to protect Counter next events list operations |
369 | * @events: queue of detected Counter events |
370 | * @events_wait: wait queue to allow blocking reads of Counter events |
371 | * @events_in_lock: lock to protect Counter events queue in operations |
372 | * @events_out_lock: lock to protect Counter events queue out operations |
373 | * @ops_exist_lock: lock to prevent use during removal |
374 | */ |
375 | struct counter_device { |
376 | const char *name; |
377 | struct device *parent; |
378 | |
379 | const struct counter_ops *ops; |
380 | |
381 | struct counter_signal *signals; |
382 | size_t num_signals; |
383 | struct counter_count *counts; |
384 | size_t num_counts; |
385 | |
386 | struct counter_comp *ext; |
387 | size_t num_ext; |
388 | |
389 | struct device dev; |
390 | struct cdev chrdev; |
391 | struct list_head events_list; |
392 | spinlock_t events_list_lock; |
393 | struct list_head next_events_list; |
394 | struct mutex n_events_list_lock; |
395 | DECLARE_KFIFO_PTR(events, struct counter_event); |
396 | wait_queue_head_t events_wait; |
397 | spinlock_t events_in_lock; |
398 | struct mutex events_out_lock; |
399 | struct mutex ops_exist_lock; |
400 | }; |
401 | |
402 | void *counter_priv(const struct counter_device *const counter) __attribute_const__; |
403 | |
404 | struct counter_device *counter_alloc(size_t sizeof_priv); |
405 | void counter_put(struct counter_device *const counter); |
406 | int counter_add(struct counter_device *const counter); |
407 | |
408 | void counter_unregister(struct counter_device *const counter); |
409 | struct counter_device *devm_counter_alloc(struct device *dev, |
410 | size_t sizeof_priv); |
411 | int devm_counter_add(struct device *dev, |
412 | struct counter_device *const counter); |
413 | void counter_push_event(struct counter_device *const counter, const u8 event, |
414 | const u8 channel); |
415 | |
416 | #define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \ |
417 | { \ |
418 | .type = COUNTER_COMP_U8, \ |
419 | .name = (_name), \ |
420 | .device_u8_read = (_read), \ |
421 | .device_u8_write = (_write), \ |
422 | } |
423 | #define COUNTER_COMP_COUNT_U8(_name, _read, _write) \ |
424 | { \ |
425 | .type = COUNTER_COMP_U8, \ |
426 | .name = (_name), \ |
427 | .count_u8_read = (_read), \ |
428 | .count_u8_write = (_write), \ |
429 | } |
430 | #define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \ |
431 | { \ |
432 | .type = COUNTER_COMP_U8, \ |
433 | .name = (_name), \ |
434 | .signal_u8_read = (_read), \ |
435 | .signal_u8_write = (_write), \ |
436 | } |
437 | |
438 | #define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \ |
439 | { \ |
440 | .type = COUNTER_COMP_U64, \ |
441 | .name = (_name), \ |
442 | .device_u64_read = (_read), \ |
443 | .device_u64_write = (_write), \ |
444 | } |
445 | #define COUNTER_COMP_COUNT_U64(_name, _read, _write) \ |
446 | { \ |
447 | .type = COUNTER_COMP_U64, \ |
448 | .name = (_name), \ |
449 | .count_u64_read = (_read), \ |
450 | .count_u64_write = (_write), \ |
451 | } |
452 | #define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \ |
453 | { \ |
454 | .type = COUNTER_COMP_U64, \ |
455 | .name = (_name), \ |
456 | .signal_u64_read = (_read), \ |
457 | .signal_u64_write = (_write), \ |
458 | } |
459 | |
460 | #define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \ |
461 | { \ |
462 | .type = COUNTER_COMP_BOOL, \ |
463 | .name = (_name), \ |
464 | .device_u8_read = (_read), \ |
465 | .device_u8_write = (_write), \ |
466 | } |
467 | #define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \ |
468 | { \ |
469 | .type = COUNTER_COMP_BOOL, \ |
470 | .name = (_name), \ |
471 | .count_u8_read = (_read), \ |
472 | .count_u8_write = (_write), \ |
473 | } |
474 | #define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \ |
475 | { \ |
476 | .type = COUNTER_COMP_BOOL, \ |
477 | .name = (_name), \ |
478 | .signal_u8_read = (_read), \ |
479 | .signal_u8_write = (_write), \ |
480 | } |
481 | |
482 | struct counter_available { |
483 | union { |
484 | const u32 *enums; |
485 | const char *const *strs; |
486 | }; |
487 | size_t num_items; |
488 | }; |
489 | |
490 | #define DEFINE_COUNTER_AVAILABLE(_name, _enums) \ |
491 | struct counter_available _name = { \ |
492 | .enums = (_enums), \ |
493 | .num_items = ARRAY_SIZE(_enums), \ |
494 | } |
495 | |
496 | #define DEFINE_COUNTER_ENUM(_name, _strs) \ |
497 | struct counter_available _name = { \ |
498 | .strs = (_strs), \ |
499 | .num_items = ARRAY_SIZE(_strs), \ |
500 | } |
501 | |
502 | #define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \ |
503 | { \ |
504 | .type = COUNTER_COMP_ENUM, \ |
505 | .name = (_name), \ |
506 | .device_u32_read = (_get), \ |
507 | .device_u32_write = (_set), \ |
508 | .priv = &(_available), \ |
509 | } |
510 | #define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \ |
511 | { \ |
512 | .type = COUNTER_COMP_ENUM, \ |
513 | .name = (_name), \ |
514 | .count_u32_read = (_get), \ |
515 | .count_u32_write = (_set), \ |
516 | .priv = &(_available), \ |
517 | } |
518 | #define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \ |
519 | { \ |
520 | .type = COUNTER_COMP_ENUM, \ |
521 | .name = (_name), \ |
522 | .signal_u32_read = (_get), \ |
523 | .signal_u32_write = (_set), \ |
524 | .priv = &(_available), \ |
525 | } |
526 | |
527 | struct counter_array { |
528 | enum counter_comp_type type; |
529 | const struct counter_available *avail; |
530 | union { |
531 | size_t length; |
532 | size_t idx; |
533 | }; |
534 | }; |
535 | |
536 | #define DEFINE_COUNTER_ARRAY_U64(_name, _length) \ |
537 | struct counter_array _name = { \ |
538 | .type = COUNTER_COMP_U64, \ |
539 | .length = (_length), \ |
540 | } |
541 | |
542 | #define DEFINE_COUNTER_ARRAY_CAPTURE(_name, _length) \ |
543 | DEFINE_COUNTER_ARRAY_U64(_name, _length) |
544 | |
545 | #define DEFINE_COUNTER_ARRAY_POLARITY(_name, _available, _length) \ |
546 | struct counter_array _name = { \ |
547 | .type = COUNTER_COMP_SIGNAL_POLARITY, \ |
548 | .avail = &(_available), \ |
549 | .length = (_length), \ |
550 | } |
551 | |
552 | #define COUNTER_COMP_DEVICE_ARRAY_U64(_name, _read, _write, _array) \ |
553 | { \ |
554 | .type = COUNTER_COMP_ARRAY, \ |
555 | .name = (_name), \ |
556 | .device_array_u64_read = (_read), \ |
557 | .device_array_u64_write = (_write), \ |
558 | .priv = &(_array), \ |
559 | } |
560 | #define COUNTER_COMP_COUNT_ARRAY_U64(_name, _read, _write, _array) \ |
561 | { \ |
562 | .type = COUNTER_COMP_ARRAY, \ |
563 | .name = (_name), \ |
564 | .count_array_u64_read = (_read), \ |
565 | .count_array_u64_write = (_write), \ |
566 | .priv = &(_array), \ |
567 | } |
568 | #define COUNTER_COMP_SIGNAL_ARRAY_U64(_name, _read, _write, _array) \ |
569 | { \ |
570 | .type = COUNTER_COMP_ARRAY, \ |
571 | .name = (_name), \ |
572 | .signal_array_u64_read = (_read), \ |
573 | .signal_array_u64_write = (_write), \ |
574 | .priv = &(_array), \ |
575 | } |
576 | |
577 | #define COUNTER_COMP_CAPTURE(_read, _write) \ |
578 | COUNTER_COMP_COUNT_U64("capture", _read, _write) |
579 | |
580 | #define COUNTER_COMP_CEILING(_read, _write) \ |
581 | COUNTER_COMP_COUNT_U64("ceiling", _read, _write) |
582 | |
583 | #define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \ |
584 | { \ |
585 | .type = COUNTER_COMP_COUNT_MODE, \ |
586 | .name = "count_mode", \ |
587 | .count_u32_read = (_read), \ |
588 | .count_u32_write = (_write), \ |
589 | .priv = &(_available), \ |
590 | } |
591 | |
592 | #define COUNTER_COMP_DIRECTION(_read) \ |
593 | { \ |
594 | .type = COUNTER_COMP_COUNT_DIRECTION, \ |
595 | .name = "direction", \ |
596 | .count_u32_read = (_read), \ |
597 | } |
598 | |
599 | #define COUNTER_COMP_ENABLE(_read, _write) \ |
600 | COUNTER_COMP_COUNT_BOOL("enable", _read, _write) |
601 | |
602 | #define COUNTER_COMP_FLOOR(_read, _write) \ |
603 | COUNTER_COMP_COUNT_U64("floor", _read, _write) |
604 | |
605 | #define COUNTER_COMP_POLARITY(_read, _write, _available) \ |
606 | { \ |
607 | .type = COUNTER_COMP_SIGNAL_POLARITY, \ |
608 | .name = "polarity", \ |
609 | .signal_u32_read = (_read), \ |
610 | .signal_u32_write = (_write), \ |
611 | .priv = &(_available), \ |
612 | } |
613 | |
614 | #define COUNTER_COMP_PRESET(_read, _write) \ |
615 | COUNTER_COMP_COUNT_U64("preset", _read, _write) |
616 | |
617 | #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \ |
618 | COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write) |
619 | |
620 | #define COUNTER_COMP_ARRAY_CAPTURE(_read, _write, _array) \ |
621 | COUNTER_COMP_COUNT_ARRAY_U64("capture", _read, _write, _array) |
622 | |
623 | #define COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) \ |
624 | { \ |
625 | .type = COUNTER_COMP_ARRAY, \ |
626 | .name = "polarity", \ |
627 | .signal_array_u32_read = (_read), \ |
628 | .signal_array_u32_write = (_write), \ |
629 | .priv = &(_array), \ |
630 | } |
631 | |
632 | #endif /* _COUNTER_H_ */ |
633 | |