Contributors: 9
	  
        
          | Author | 
          Tokens | 
          Token Proportion | 
          Commits | 
          Commit Proportion | 
        
	  
	  
        
        
          | Vojtech Pavlik | 
          245 | 
          70.61% | 
          3 | 
          20.00% | 
        
        
          | Dmitry Torokhov | 
          63 | 
          18.16% | 
          4 | 
          26.67% | 
        
        
          | Joe Perches | 
          27 | 
          7.78% | 
          1 | 
          6.67% | 
        
        
          | Adrian Bunk | 
          3 | 
          0.86% | 
          2 | 
          13.33% | 
        
        
          | Patrick Mochel | 
          3 | 
          0.86% | 
          1 | 
          6.67% | 
        
        
          | Thomas Gleixner | 
          2 | 
          0.58% | 
          1 | 
          6.67% | 
        
        
          | Art Haas | 
          2 | 
          0.58% | 
          1 | 
          6.67% | 
        
        
          | Kay Sievers | 
          1 | 
          0.29% | 
          1 | 
          6.67% | 
        
        
          | Eric Sesterhenn / Snakebyte | 
          1 | 
          0.29% | 
          1 | 
          6.67% | 
        
	  
	  
        
          | Total | 
          347 | 
           | 
          15 | 
           | 
	    
	  
    
 
// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Copyright (c) 1999-2001 Vojtech Pavlik
 */
/*
 *  Input driver event debug module - dumps all events into syslog
 */
/*
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/device.h>
MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
MODULE_DESCRIPTION("Input driver event debug module");
MODULE_LICENSE("GPL");
static void evbug_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
	printk(KERN_DEBUG pr_fmt("Event. Dev: %s, Type: %d, Code: %d, Value: %d\n"),
	       dev_name(&handle->dev->dev), type, code, value);
}
static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct input_handle *handle;
	int error;
	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
	if (!handle)
		return -ENOMEM;
	handle->dev = dev;
	handle->handler = handler;
	handle->name = "evbug";
	error = input_register_handle(handle);
	if (error)
		goto err_free_handle;
	error = input_open_device(handle);
	if (error)
		goto err_unregister_handle;
	printk(KERN_DEBUG pr_fmt("Connected device: %s (%s at %s)\n"),
	       dev_name(&dev->dev),
	       dev->name ?: "unknown",
	       dev->phys ?: "unknown");
	return 0;
 err_unregister_handle:
	input_unregister_handle(handle);
 err_free_handle:
	kfree(handle);
	return error;
}
static void evbug_disconnect(struct input_handle *handle)
{
	printk(KERN_DEBUG pr_fmt("Disconnected device: %s\n"),
	       dev_name(&handle->dev->dev));
	input_close_device(handle);
	input_unregister_handle(handle);
	kfree(handle);
}
static const struct input_device_id evbug_ids[] = {
	{ .driver_info = 1 },	/* Matches all devices */
	{ },			/* Terminating zero entry */
};
MODULE_DEVICE_TABLE(input, evbug_ids);
static struct input_handler evbug_handler = {
	.event =	evbug_event,
	.connect =	evbug_connect,
	.disconnect =	evbug_disconnect,
	.name =		"evbug",
	.id_table =	evbug_ids,
};
static int __init evbug_init(void)
{
	return input_register_handler(&evbug_handler);
}
static void __exit evbug_exit(void)
{
	input_unregister_handler(&evbug_handler);
}
module_init(evbug_init);
module_exit(evbug_exit);