xref: /openbmc/linux/include/linux/counter.h (revision 30dc493b)
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  * @dev:		internal device structure
363  * @chrdev:		internal character device structure
364  * @events_list:	list of current watching Counter events
365  * @events_list_lock:	lock to protect Counter events list operations
366  * @next_events_list:	list of next watching Counter events
367  * @n_events_list_lock:	lock to protect Counter next events list operations
368  * @events:		queue of detected Counter events
369  * @events_wait:	wait queue to allow blocking reads of Counter events
370  * @events_in_lock:	lock to protect Counter events queue in operations
371  * @events_out_lock:	lock to protect Counter events queue out operations
372  * @ops_exist_lock:	lock to prevent use during removal
373  */
374 struct counter_device {
375 	const char *name;
376 	struct device *parent;
377 
378 	const struct counter_ops *ops;
379 
380 	struct counter_signal *signals;
381 	size_t num_signals;
382 	struct counter_count *counts;
383 	size_t num_counts;
384 
385 	struct counter_comp *ext;
386 	size_t num_ext;
387 
388 	struct device dev;
389 	struct cdev chrdev;
390 	struct list_head events_list;
391 	spinlock_t events_list_lock;
392 	struct list_head next_events_list;
393 	struct mutex n_events_list_lock;
394 	DECLARE_KFIFO_PTR(events, struct counter_event);
395 	wait_queue_head_t events_wait;
396 	spinlock_t events_in_lock;
397 	struct mutex events_out_lock;
398 	struct mutex ops_exist_lock;
399 };
400 
401 void *counter_priv(const struct counter_device *const counter) __attribute_const__;
402 
403 struct counter_device *counter_alloc(size_t sizeof_priv);
404 void counter_put(struct counter_device *const counter);
405 int counter_add(struct counter_device *const counter);
406 
407 void counter_unregister(struct counter_device *const counter);
408 struct counter_device *devm_counter_alloc(struct device *dev,
409 					  size_t sizeof_priv);
410 int devm_counter_add(struct device *dev,
411 		     struct counter_device *const counter);
412 void counter_push_event(struct counter_device *const counter, const u8 event,
413 			const u8 channel);
414 
415 #define COUNTER_COMP_DEVICE_U8(_name, _read, _write) \
416 { \
417 	.type = COUNTER_COMP_U8, \
418 	.name = (_name), \
419 	.device_u8_read = (_read), \
420 	.device_u8_write = (_write), \
421 }
422 #define COUNTER_COMP_COUNT_U8(_name, _read, _write) \
423 { \
424 	.type = COUNTER_COMP_U8, \
425 	.name = (_name), \
426 	.count_u8_read = (_read), \
427 	.count_u8_write = (_write), \
428 }
429 #define COUNTER_COMP_SIGNAL_U8(_name, _read, _write) \
430 { \
431 	.type = COUNTER_COMP_U8, \
432 	.name = (_name), \
433 	.signal_u8_read = (_read), \
434 	.signal_u8_write = (_write), \
435 }
436 
437 #define COUNTER_COMP_DEVICE_U64(_name, _read, _write) \
438 { \
439 	.type = COUNTER_COMP_U64, \
440 	.name = (_name), \
441 	.device_u64_read = (_read), \
442 	.device_u64_write = (_write), \
443 }
444 #define COUNTER_COMP_COUNT_U64(_name, _read, _write) \
445 { \
446 	.type = COUNTER_COMP_U64, \
447 	.name = (_name), \
448 	.count_u64_read = (_read), \
449 	.count_u64_write = (_write), \
450 }
451 #define COUNTER_COMP_SIGNAL_U64(_name, _read, _write) \
452 { \
453 	.type = COUNTER_COMP_U64, \
454 	.name = (_name), \
455 	.signal_u64_read = (_read), \
456 	.signal_u64_write = (_write), \
457 }
458 
459 #define COUNTER_COMP_DEVICE_BOOL(_name, _read, _write) \
460 { \
461 	.type = COUNTER_COMP_BOOL, \
462 	.name = (_name), \
463 	.device_u8_read = (_read), \
464 	.device_u8_write = (_write), \
465 }
466 #define COUNTER_COMP_COUNT_BOOL(_name, _read, _write) \
467 { \
468 	.type = COUNTER_COMP_BOOL, \
469 	.name = (_name), \
470 	.count_u8_read = (_read), \
471 	.count_u8_write = (_write), \
472 }
473 #define COUNTER_COMP_SIGNAL_BOOL(_name, _read, _write) \
474 { \
475 	.type = COUNTER_COMP_BOOL, \
476 	.name = (_name), \
477 	.signal_u8_read = (_read), \
478 	.signal_u8_write = (_write), \
479 }
480 
481 struct counter_available {
482 	union {
483 		const u32 *enums;
484 		const char *const *strs;
485 	};
486 	size_t num_items;
487 };
488 
489 #define DEFINE_COUNTER_AVAILABLE(_name, _enums) \
490 	struct counter_available _name = { \
491 		.enums = (_enums), \
492 		.num_items = ARRAY_SIZE(_enums), \
493 	}
494 
495 #define DEFINE_COUNTER_ENUM(_name, _strs) \
496 	struct counter_available _name = { \
497 		.strs = (_strs), \
498 		.num_items = ARRAY_SIZE(_strs), \
499 	}
500 
501 #define COUNTER_COMP_DEVICE_ENUM(_name, _get, _set, _available) \
502 { \
503 	.type = COUNTER_COMP_ENUM, \
504 	.name = (_name), \
505 	.device_u32_read = (_get), \
506 	.device_u32_write = (_set), \
507 	.priv = &(_available), \
508 }
509 #define COUNTER_COMP_COUNT_ENUM(_name, _get, _set, _available) \
510 { \
511 	.type = COUNTER_COMP_ENUM, \
512 	.name = (_name), \
513 	.count_u32_read = (_get), \
514 	.count_u32_write = (_set), \
515 	.priv = &(_available), \
516 }
517 #define COUNTER_COMP_SIGNAL_ENUM(_name, _get, _set, _available) \
518 { \
519 	.type = COUNTER_COMP_ENUM, \
520 	.name = (_name), \
521 	.signal_u32_read = (_get), \
522 	.signal_u32_write = (_set), \
523 	.priv = &(_available), \
524 }
525 
526 struct counter_array {
527 	enum counter_comp_type type;
528 	const struct counter_available *avail;
529 	union {
530 		size_t length;
531 		size_t idx;
532 	};
533 };
534 
535 #define DEFINE_COUNTER_ARRAY_U64(_name, _length) \
536 	struct counter_array _name = { \
537 		.type = COUNTER_COMP_U64, \
538 		.length = (_length), \
539 	}
540 
541 #define DEFINE_COUNTER_ARRAY_CAPTURE(_name, _length) \
542 	DEFINE_COUNTER_ARRAY_U64(_name, _length)
543 
544 #define DEFINE_COUNTER_ARRAY_POLARITY(_name, _available, _length) \
545 	struct counter_array _name = { \
546 		.type = COUNTER_COMP_SIGNAL_POLARITY, \
547 		.avail = &(_available), \
548 		.length = (_length), \
549 	}
550 
551 #define COUNTER_COMP_DEVICE_ARRAY_U64(_name, _read, _write, _array) \
552 { \
553 	.type = COUNTER_COMP_ARRAY, \
554 	.name = (_name), \
555 	.device_array_u64_read = (_read), \
556 	.device_array_u64_write = (_write), \
557 	.priv = &(_array), \
558 }
559 #define COUNTER_COMP_COUNT_ARRAY_U64(_name, _read, _write, _array) \
560 { \
561 	.type = COUNTER_COMP_ARRAY, \
562 	.name = (_name), \
563 	.count_array_u64_read = (_read), \
564 	.count_array_u64_write = (_write), \
565 	.priv = &(_array), \
566 }
567 #define COUNTER_COMP_SIGNAL_ARRAY_U64(_name, _read, _write, _array) \
568 { \
569 	.type = COUNTER_COMP_ARRAY, \
570 	.name = (_name), \
571 	.signal_array_u64_read = (_read), \
572 	.signal_array_u64_write = (_write), \
573 	.priv = &(_array), \
574 }
575 
576 #define COUNTER_COMP_CAPTURE(_read, _write) \
577 	COUNTER_COMP_COUNT_U64("capture", _read, _write)
578 
579 #define COUNTER_COMP_CEILING(_read, _write) \
580 	COUNTER_COMP_COUNT_U64("ceiling", _read, _write)
581 
582 #define COUNTER_COMP_COUNT_MODE(_read, _write, _available) \
583 { \
584 	.type = COUNTER_COMP_COUNT_MODE, \
585 	.name = "count_mode", \
586 	.count_u32_read = (_read), \
587 	.count_u32_write = (_write), \
588 	.priv = &(_available), \
589 }
590 
591 #define COUNTER_COMP_DIRECTION(_read) \
592 { \
593 	.type = COUNTER_COMP_COUNT_DIRECTION, \
594 	.name = "direction", \
595 	.count_u32_read = (_read), \
596 }
597 
598 #define COUNTER_COMP_ENABLE(_read, _write) \
599 	COUNTER_COMP_COUNT_BOOL("enable", _read, _write)
600 
601 #define COUNTER_COMP_FLOOR(_read, _write) \
602 	COUNTER_COMP_COUNT_U64("floor", _read, _write)
603 
604 #define COUNTER_COMP_POLARITY(_read, _write, _available) \
605 { \
606 	.type = COUNTER_COMP_SIGNAL_POLARITY, \
607 	.name = "polarity", \
608 	.signal_u32_read = (_read), \
609 	.signal_u32_write = (_write), \
610 	.priv = &(_available), \
611 }
612 
613 #define COUNTER_COMP_PRESET(_read, _write) \
614 	COUNTER_COMP_COUNT_U64("preset", _read, _write)
615 
616 #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \
617 	COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write)
618 
619 #define COUNTER_COMP_ARRAY_CAPTURE(_read, _write, _array) \
620 	COUNTER_COMP_COUNT_ARRAY_U64("capture", _read, _write, _array)
621 
622 #define COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) \
623 { \
624 	.type = COUNTER_COMP_ARRAY, \
625 	.name = "polarity", \
626 	.signal_array_u32_read = (_read), \
627 	.signal_array_u32_write = (_write), \
628 	.priv = &(_array), \
629 }
630 
631 #endif /* _COUNTER_H_ */
632