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/array_size.h>
10#include <linux/cdev.h>
11#include <linux/device.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
18#include <uapi/linux/counter.h>
19
20struct counter_device;
21struct counter_count;
22struct counter_synapse;
23struct counter_signal;
24
25enum counter_comp_type {
26 COUNTER_COMP_U8,
27 COUNTER_COMP_U64,
28 COUNTER_COMP_BOOL,
29 COUNTER_COMP_SIGNAL_LEVEL,
30 COUNTER_COMP_FUNCTION,
31 COUNTER_COMP_SYNAPSE_ACTION,
32 COUNTER_COMP_ENUM,
33 COUNTER_COMP_COUNT_DIRECTION,
34 COUNTER_COMP_COUNT_MODE,
35 COUNTER_COMP_SIGNAL_POLARITY,
36 COUNTER_COMP_ARRAY,
37};
38
39/**
40 * struct counter_comp - Counter component node
41 * @type: Counter component data type
42 * @name: device-specific component name
43 * @priv: component-relevant data
44 * @action_read: Synapse action mode read callback. The read value of the
45 * respective Synapse action mode should be passed back via
46 * the action parameter.
47 * @device_u8_read: Device u8 component read callback. The read value of the
48 * respective Device u8 component should be passed back via
49 * the val parameter.
50 * @count_u8_read: Count u8 component read callback. The read value of the
51 * respective Count u8 component should be passed back via
52 * the val parameter.
53 * @signal_u8_read: Signal u8 component read callback. The read value of the
54 * respective Signal u8 component should be passed back via
55 * the val parameter.
56 * @device_u32_read: Device u32 component read callback. The read value of
57 * the respective Device u32 component should be passed
58 * back via the val parameter.
59 * @count_u32_read: Count u32 component read callback. The read value of the
60 * respective Count u32 component should be passed back via
61 * the val parameter.
62 * @signal_u32_read: Signal u32 component read callback. The read value of
63 * the respective Signal u32 component should be passed
64 * back via the val parameter.
65 * @device_u64_read: Device u64 component read callback. The read value of
66 * the respective Device u64 component should be passed
67 * back via the val parameter.
68 * @count_u64_read: Count u64 component read callback. The read value of the
69 * respective Count u64 component should be passed back via
70 * the val parameter.
71 * @signal_u64_read: Signal u64 component read callback. The read value of
72 * the respective Signal u64 component should be passed
73 * back via the val parameter.
74 * @signal_array_u32_read: Signal u32 array component read callback. The
75 * index of the respective Count u32 array
76 * component element is passed via the idx
77 * parameter. The read value of the respective
78 * Count u32 array component element should be
79 * passed back via the val parameter.
80 * @device_array_u64_read: Device u64 array component read callback. The
81 * index of the respective Device u64 array
82 * component element is passed via the idx
83 * parameter. The read value of the respective
84 * Device u64 array component element should be
85 * passed back via the val parameter.
86 * @count_array_u64_read: Count u64 array component read callback. The
87 * index of the respective Count u64 array
88 * component element is passed via the idx
89 * parameter. The read value of the respective
90 * Count u64 array component element should be
91 * passed back via the val parameter.
92 * @signal_array_u64_read: Signal u64 array component read callback. The
93 * index of the respective Count u64 array
94 * component element is passed via the idx
95 * parameter. The read value of the respective
96 * Count u64 array component element should be
97 * passed back via the val parameter.
98 * @action_write: Synapse action mode write callback. The write value of
99 * the respective Synapse action mode is passed via the
100 * action parameter.
101 * @device_u8_write: Device u8 component write callback. The write value of
102 * the respective Device u8 component is passed via the val
103 * parameter.
104 * @count_u8_write: Count u8 component write callback. The write value of
105 * the respective Count u8 component is passed via the val
106 * parameter.
107 * @signal_u8_write: Signal u8 component write callback. The write value of
108 * the respective Signal u8 component is passed via the val
109 * parameter.
110 * @device_u32_write: Device u32 component write callback. The write value of
111 * the respective Device u32 component is passed via the
112 * val parameter.
113 * @count_u32_write: Count u32 component write callback. The write value of
114 * the respective Count u32 component is passed via the val
115 * parameter.
116 * @signal_u32_write: Signal u32 component write callback. The write value of
117 * the respective Signal u32 component is passed via the
118 * val parameter.
119 * @device_u64_write: Device u64 component write callback. The write value of
120 * the respective Device u64 component is passed via the
121 * val parameter.
122 * @count_u64_write: Count u64 component write callback. The write value of
123 * the respective Count u64 component is passed via the val
124 * parameter.
125 * @signal_u64_write: Signal u64 component write callback. The write value of
126 * the respective Signal u64 component is passed via the
127 * val parameter.
128 * @signal_array_u32_write: Signal u32 array component write callback. The
129 * index of the respective Signal u32 array
130 * component element is passed via the idx
131 * parameter. The write value of the respective
132 * Signal u32 array component element is passed via
133 * the val parameter.
134 * @device_array_u64_write: Device u64 array component write callback. The
135 * index of the respective Device u64 array
136 * component element is passed via the idx
137 * parameter. The write value of the respective
138 * Device u64 array component element is passed via
139 * the val parameter.
140 * @count_array_u64_write: Count u64 array component write callback. The
141 * index of the respective Count u64 array
142 * component element is passed via the idx
143 * parameter. The write value of the respective
144 * Count u64 array component element is passed via
145 * the val parameter.
146 * @signal_array_u64_write: Signal u64 array component write callback. The
147 * index of the respective Signal u64 array
148 * component element is passed via the idx
149 * parameter. The write value of the respective
150 * Signal u64 array component element is passed via
151 * the val parameter.
152 */
153struct counter_comp {
154 enum counter_comp_type type;
155 const char *name;
156 void *priv;
157 union {
158 int (*action_read)(struct counter_device *counter,
159 struct counter_count *count,
160 struct counter_synapse *synapse,
161 enum counter_synapse_action *action);
162 int (*device_u8_read)(struct counter_device *counter, u8 *val);
163 int (*count_u8_read)(struct counter_device *counter,
164 struct counter_count *count, u8 *val);
165 int (*signal_u8_read)(struct counter_device *counter,
166 struct counter_signal *signal, u8 *val);
167 int (*device_u32_read)(struct counter_device *counter,
168 u32 *val);
169 int (*count_u32_read)(struct counter_device *counter,
170 struct counter_count *count, u32 *val);
171 int (*signal_u32_read)(struct counter_device *counter,
172 struct counter_signal *signal, u32 *val);
173 int (*device_u64_read)(struct counter_device *counter,
174 u64 *val);
175 int (*count_u64_read)(struct counter_device *counter,
176 struct counter_count *count, u64 *val);
177 int (*signal_u64_read)(struct counter_device *counter,
178 struct counter_signal *signal, u64 *val);
179 int (*signal_array_u32_read)(struct counter_device *counter,
180 struct counter_signal *signal,
181 size_t idx, u32 *val);
182 int (*device_array_u64_read)(struct counter_device *counter,
183 size_t idx, u64 *val);
184 int (*count_array_u64_read)(struct counter_device *counter,
185 struct counter_count *count,
186 size_t idx, u64 *val);
187 int (*signal_array_u64_read)(struct counter_device *counter,
188 struct counter_signal *signal,
189 size_t idx, u64 *val);
190 };
191 union {
192 int (*action_write)(struct counter_device *counter,
193 struct counter_count *count,
194 struct counter_synapse *synapse,
195 enum counter_synapse_action action);
196 int (*device_u8_write)(struct counter_device *counter, u8 val);
197 int (*count_u8_write)(struct counter_device *counter,
198 struct counter_count *count, u8 val);
199 int (*signal_u8_write)(struct counter_device *counter,
200 struct counter_signal *signal, u8 val);
201 int (*device_u32_write)(struct counter_device *counter,
202 u32 val);
203 int (*count_u32_write)(struct counter_device *counter,
204 struct counter_count *count, u32 val);
205 int (*signal_u32_write)(struct counter_device *counter,
206 struct counter_signal *signal, u32 val);
207 int (*device_u64_write)(struct counter_device *counter,
208 u64 val);
209 int (*count_u64_write)(struct counter_device *counter,
210 struct counter_count *count, u64 val);
211 int (*signal_u64_write)(struct counter_device *counter,
212 struct counter_signal *signal, u64 val);
213 int (*signal_array_u32_write)(struct counter_device *counter,
214 struct counter_signal *signal,
215 size_t idx, u32 val);
216 int (*device_array_u64_write)(struct counter_device *counter,
217 size_t idx, u64 val);
218 int (*count_array_u64_write)(struct counter_device *counter,
219 struct counter_count *count,
220 size_t idx, u64 val);
221 int (*signal_array_u64_write)(struct counter_device *counter,
222 struct counter_signal *signal,
223 size_t idx, u64 val);
224 };
225};
226
227/**
228 * struct counter_signal - Counter Signal node
229 * @id: unique ID used to identify the Signal
230 * @name: device-specific Signal name
231 * @ext: optional array of Signal extensions
232 * @num_ext: number of Signal extensions specified in @ext
233 */
234struct counter_signal {
235 int id;
236 const char *name;
237
238 struct counter_comp *ext;
239 size_t num_ext;
240};
241
242/**
243 * struct counter_synapse - Counter Synapse node
244 * @actions_list: array of available action modes
245 * @num_actions: number of action modes specified in @actions_list
246 * @signal: pointer to the associated Signal
247 */
248struct counter_synapse {
249 const enum counter_synapse_action *actions_list;
250 size_t num_actions;
251
252 struct counter_signal *signal;
253};
254
255/**
256 * struct counter_count - Counter Count node
257 * @id: unique ID used to identify the Count
258 * @name: device-specific Count name
259 * @functions_list: array of available function modes
260 * @num_functions: number of function modes specified in @functions_list
261 * @synapses: array of Synapses for initialization
262 * @num_synapses: number of Synapses specified in @synapses
263 * @ext: optional array of Count extensions
264 * @num_ext: number of Count extensions specified in @ext
265 */
266struct counter_count {
267 int id;
268 const char *name;
269
270 const enum counter_function *functions_list;
271 size_t num_functions;
272
273 struct counter_synapse *synapses;
274 size_t num_synapses;
275
276 struct counter_comp *ext;
277 size_t num_ext;
278};
279
280/**
281 * struct counter_event_node - Counter Event node
282 * @l: list of current watching Counter events
283 * @event: event that triggers
284 * @channel: event channel
285 * @comp_list: list of components to watch when event triggers
286 */
287struct counter_event_node {
288 struct list_head l;
289 u8 event;
290 u8 channel;
291 struct list_head comp_list;
292};
293
294/**
295 * struct counter_ops - Callbacks from driver
296 * @signal_read: optional read callback for Signals. The read level of
297 * the respective Signal should be passed back via the
298 * level parameter.
299 * @count_read: read callback for Counts. The read value of the
300 * respective Count should be passed back via the value
301 * parameter.
302 * @count_write: optional write callback for Counts. The write value for
303 * the respective Count is passed in via the value
304 * parameter.
305 * @function_read: read callback the Count function modes. The read
306 * function mode of the respective Count should be passed
307 * back via the function parameter.
308 * @function_write: optional write callback for Count function modes. The
309 * function mode to write for the respective Count is
310 * passed in via the function parameter.
311 * @action_read: optional read callback the Synapse action modes. The
312 * read action mode of the respective Synapse should be
313 * passed back via the action parameter.
314 * @action_write: optional write callback for Synapse action modes. The
315 * action mode to write for the respective Synapse is
316 * passed in via the action parameter.
317 * @events_configure: optional write callback to configure events. The list of
318 * struct counter_event_node may be accessed via the
319 * events_list member of the counter parameter.
320 * @watch_validate: optional callback to validate a watch. The Counter
321 * component watch configuration is passed in via the watch
322 * parameter. A return value of 0 indicates a valid Counter
323 * component watch configuration.
324 */
325struct counter_ops {
326 int (*signal_read)(struct counter_device *counter,
327 struct counter_signal *signal,
328 enum counter_signal_level *level);
329 int (*count_read)(struct counter_device *counter,
330 struct counter_count *count, u64 *value);
331 int (*count_write)(struct counter_device *counter,
332 struct counter_count *count, u64 value);
333 int (*function_read)(struct counter_device *counter,
334 struct counter_count *count,
335 enum counter_function *function);
336 int (*function_write)(struct counter_device *counter,
337 struct counter_count *count,
338 enum counter_function function);
339 int (*action_read)(struct counter_device *counter,
340 struct counter_count *count,
341 struct counter_synapse *synapse,
342 enum counter_synapse_action *action);
343 int (*action_write)(struct counter_device *counter,
344 struct counter_count *count,
345 struct counter_synapse *synapse,
346 enum counter_synapse_action action);
347 int (*events_configure)(struct counter_device *counter);
348 int (*watch_validate)(struct counter_device *counter,
349 const struct counter_watch *watch);
350};
351
352/**
353 * struct counter_device - Counter data structure
354 * @name: name of the device
355 * @parent: optional parent device providing the counters
356 * @ops: callbacks from driver
357 * @signals: array of Signals
358 * @num_signals: number of Signals specified in @signals
359 * @counts: array of Counts
360 * @num_counts: number of Counts specified in @counts
361 * @ext: optional array of Counter device extensions
362 * @num_ext: number of Counter device extensions specified in @ext
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 */
375struct 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
402void *counter_priv(const struct counter_device *const counter) __attribute_const__;
403
404struct counter_device *counter_alloc(size_t sizeof_priv);
405void counter_put(struct counter_device *const counter);
406int counter_add(struct counter_device *const counter);
407
408void counter_unregister(struct counter_device *const counter);
409struct counter_device *devm_counter_alloc(struct device *dev,
410 size_t sizeof_priv);
411int devm_counter_add(struct device *dev,
412 struct counter_device *const counter);
413void 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
482struct 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
527struct 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_COMPARE(_read, _write) \
584 COUNTER_COMP_COUNT_U64("compare", _read, _write)
585
586#define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \
587{ \
588 .type = COUNTER_COMP_COUNT_MODE, \
589 .name = "count_mode", \
590 .count_u32_read = (_read), \
591 .count_u32_write = (_write), \
592 .priv = &(_available), \
593}
594
595#define COUNTER_COMP_DIRECTION(_read) \
596{ \
597 .type = COUNTER_COMP_COUNT_DIRECTION, \
598 .name = "direction", \
599 .count_u32_read = (_read), \
600}
601
602#define COUNTER_COMP_ENABLE(_read, _write) \
603 COUNTER_COMP_COUNT_BOOL("enable", _read, _write)
604
605#define COUNTER_COMP_FLOOR(_read, _write) \
606 COUNTER_COMP_COUNT_U64("floor", _read, _write)
607
608#define COUNTER_COMP_FREQUENCY(_read) \
609 COUNTER_COMP_SIGNAL_U64("frequency", _read, NULL)
610
611#define COUNTER_COMP_POLARITY(_read, _write, _available) \
612{ \
613 .type = COUNTER_COMP_SIGNAL_POLARITY, \
614 .name = "polarity", \
615 .signal_u32_read = (_read), \
616 .signal_u32_write = (_write), \
617 .priv = &(_available), \
618}
619
620#define COUNTER_COMP_PRESET(_read, _write) \
621 COUNTER_COMP_COUNT_U64("preset", _read, _write)
622
623#define COUNTER_COMP_PRESET_ENABLE(_read, _write) \
624 COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write)
625
626#define COUNTER_COMP_ARRAY_CAPTURE(_read, _write, _array) \
627 COUNTER_COMP_COUNT_ARRAY_U64("capture", _read, _write, _array)
628
629#define COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) \
630{ \
631 .type = COUNTER_COMP_ARRAY, \
632 .name = "polarity", \
633 .signal_array_u32_read = (_read), \
634 .signal_array_u32_write = (_write), \
635 .priv = &(_array), \
636}
637
638#endif /* _COUNTER_H_ */
639

source code of linux/include/linux/counter.h

Morty Proxy This is a proxified and sanitized view of the page, visit original site.