drivers/counter/counter-chrdev.c

7 #include <linux/counter.h>
24 #include "counter-chrdev.h"
68 	struct counter_device *const counter = filp->private_data;
72 	if (!counter->ops)
79 		if (kfifo_is_empty(&counter->events)) {
83 			err = wait_event_interruptible(counter->events_wait,
84 					!kfifo_is_empty(&counter->events) ||
85 					!counter->ops);
88 			if (!counter->ops)
92 		if (mutex_lock_interruptible(&counter->events_out_lock))
94 		err = kfifo_to_user(&counter->events, buf, len, &copied);
95 		mutex_unlock(&counter->events_out_lock);
106 	struct counter_device *const counter = filp->private_data;
109 	if (!counter->ops)
112 	poll_wait(filp, &counter->events_wait, pollt);
114 	if (!kfifo_is_empty(&counter->events))
138 static int counter_set_event_node(struct counter_device *const counter,
147 	list_for_each_entry(event_node, &counter->next_events_list, l)
153 	if (&event_node->l == &counter->next_events_list) {
163 		list_add(&event_node->l, &counter->next_events_list);
195 static int counter_enable_events(struct counter_device *const counter)
200 	mutex_lock(&counter->n_events_list_lock);
201 	spin_lock_irqsave(&counter->events_list_lock, flags);
203 	counter_events_list_free(&counter->events_list);
204 	list_replace_init(&counter->next_events_list,
205 			  &counter->events_list);
207 	if (counter->ops->events_configure)
208 		err = counter->ops->events_configure(counter);
210 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
211 	mutex_unlock(&counter->n_events_list_lock);
216 static int counter_disable_events(struct counter_device *const counter)
221 	spin_lock_irqsave(&counter->events_list_lock, flags);
223 	counter_events_list_free(&counter->events_list);
225 	if (counter->ops->events_configure)
226 		err = counter->ops->events_configure(counter);
228 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
230 	mutex_lock(&counter->n_events_list_lock);
232 	counter_events_list_free(&counter->next_events_list);
234 	mutex_unlock(&counter->n_events_list_lock);
264 static int counter_add_watch(struct counter_device *const counter,
287 		ext = counter->ext;
288 		num_ext = counter->num_ext;
291 		if (parent >= counter->num_signals)
293 		parent = array_index_nospec(parent, counter->num_signals);
295 		comp_node.parent = counter->signals + parent;
297 		ext = counter->signals[parent].ext;
298 		num_ext = counter->signals[parent].num_ext;
301 		if (parent >= counter->num_counts)
303 		parent = array_index_nospec(parent, counter->num_counts);
305 		comp_node.parent = counter->counts + parent;
307 		ext = counter->counts[parent].ext;
308 		num_ext = counter->counts[parent].num_ext;
323 		comp_node.comp.signal_u32_read = counter->ops->signal_read;
330 		comp_node.comp.count_u64_read = counter->ops->count_read;
337 		comp_node.comp.count_u32_read = counter->ops->function_read;
342 		if (id >= counter->counts[parent].num_synapses)
344 		id = array_index_nospec(id, counter->counts[parent].num_synapses);
347 		comp_node.comp.action_read = counter->ops->action_read;
348 		comp_node.comp.priv = counter->counts[parent].synapses + id;
364 	mutex_lock(&counter->n_events_list_lock);
366 	if (counter->ops->watch_validate) {
367 		err = counter->ops->watch_validate(counter, &watch);
374 	err = counter_set_event_node(counter, &watch, &comp_node);
377 	mutex_unlock(&counter->n_events_list_lock);
385 	struct counter_device *const counter = filp->private_data;
388 	mutex_lock(&counter->ops_exist_lock);
390 	if (!counter->ops)
395 		ret = counter_add_watch(counter, arg);
398 		ret = counter_enable_events(counter);
401 		ret = counter_disable_events(counter);
409 	mutex_unlock(&counter->ops_exist_lock);
416 	struct counter_device *const counter = container_of(inode->i_cdev,
417 							    typeof(*counter),
420 	get_device(&counter->dev);
421 	filp->private_data = counter;
428 	struct counter_device *const counter = filp->private_data;
431 	mutex_lock(&counter->ops_exist_lock);
433 	if (!counter->ops) {
435 		counter_events_list_free(&counter->events_list);
436 		counter_events_list_free(&counter->next_events_list);
441 	ret = counter_disable_events(counter);
443 		mutex_unlock(&counter->ops_exist_lock);
448 	mutex_unlock(&counter->ops_exist_lock);
450 	put_device(&counter->dev);
465 int counter_chrdev_add(struct counter_device *const counter)
468 	INIT_LIST_HEAD(&counter->events_list);
469 	INIT_LIST_HEAD(&counter->next_events_list);
470 	spin_lock_init(&counter->events_list_lock);
471 	mutex_init(&counter->n_events_list_lock);
472 	init_waitqueue_head(&counter->events_wait);
473 	spin_lock_init(&counter->events_in_lock);
474 	mutex_init(&counter->events_out_lock);
477 	cdev_init(&counter->chrdev, &counter_fops);
480 	return kfifo_alloc(&counter->events, 64, GFP_KERNEL);
483 void counter_chrdev_remove(struct counter_device *const counter)
485 	kfifo_free(&counter->events);
488 static int counter_get_array_data(struct counter_device *const counter,
502 		ret = comp->signal_array_u32_read(counter, parent, idx,
509 			return comp->device_array_u64_read(counter, idx, value);
511 			return comp->signal_array_u64_read(counter, parent, idx,
514 			return comp->count_array_u64_read(counter, parent, idx,
524 static int counter_get_data(struct counter_device *const counter,
548 			ret = comp->device_u8_read(counter, &value_u8);
551 			ret = comp->signal_u8_read(counter, signal, &value_u8);
554 			ret = comp->count_u8_read(counter, count, &value_u8);
569 			ret = comp->device_u32_read(counter, &value_u32);
572 			ret = comp->signal_u32_read(counter, signal,
576 			ret = comp->count_u32_read(counter, count, &value_u32);
586 			return comp->device_u64_read(counter, value);
588 			return comp->signal_u64_read(counter, signal, value);
590 			return comp->count_u64_read(counter, count, value);
595 		ret = comp->action_read(counter, count, comp->priv, &value_u32);
601 			ext = counter->ext;
602 			num_ext = counter->num_ext;
619 		return counter_get_array_data(counter, scope, comp_node->parent,
628  * @counter:	pointer to Counter structure
635 void counter_push_event(struct counter_device *const counter, const u8 event,
649 	spin_lock_irqsave(&counter->events_list_lock, flags);
652 	list_for_each_entry(event_node, &counter->events_list, l)
658 	if (&event_node->l == &counter->events_list)
664 		ev.status = -counter_get_data(counter, comp_node, &ev.value);
666 		copied += kfifo_in_spinlocked_noirqsave(&counter->events, &ev,
667 							1, &counter->events_in_lock);
671 	spin_unlock_irqrestore(&counter->events_list_lock, flags);
674 		wake_up_poll(&counter->events_wait, EPOLLIN);