1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  Copyright (c) 1999-2001 Vojtech Pavlik
  4 */
  5
  6/*
  7 *  Input driver event debug module - dumps all events into syslog
  8 */
  9
 10/*
 11 */
 12
 13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 14
 15#include <linux/slab.h>
 16#include <linux/module.h>
 17#include <linux/input.h>
 18#include <linux/init.h>
 19#include <linux/device.h>
 20
 21MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 22MODULE_DESCRIPTION("Input driver event debug module");
 23MODULE_LICENSE("GPL");
 24
 25static void evbug_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
 26{
 27	printk(KERN_DEBUG pr_fmt("Event. Dev: %s, Type: %d, Code: %d, Value: %d\n"),
 28	       dev_name(&handle->dev->dev), type, code, value);
 29}
 30
 31static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
 32			 const struct input_device_id *id)
 33{
 34	struct input_handle *handle;
 35	int error;
 36
 37	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
 38	if (!handle)
 39		return -ENOMEM;
 40
 41	handle->dev = dev;
 42	handle->handler = handler;
 43	handle->name = "evbug";
 44
 45	error = input_register_handle(handle);
 46	if (error)
 47		goto err_free_handle;
 48
 49	error = input_open_device(handle);
 50	if (error)
 51		goto err_unregister_handle;
 52
 53	printk(KERN_DEBUG pr_fmt("Connected device: %s (%s at %s)\n"),
 54	       dev_name(&dev->dev),
 55	       dev->name ?: "unknown",
 56	       dev->phys ?: "unknown");
 57
 58	return 0;
 59
 60 err_unregister_handle:
 61	input_unregister_handle(handle);
 62 err_free_handle:
 63	kfree(handle);
 64	return error;
 65}
 66
 67static void evbug_disconnect(struct input_handle *handle)
 68{
 69	printk(KERN_DEBUG pr_fmt("Disconnected device: %s\n"),
 70	       dev_name(&handle->dev->dev));
 71
 72	input_close_device(handle);
 73	input_unregister_handle(handle);
 74	kfree(handle);
 75}
 76
 77static const struct input_device_id evbug_ids[] = {
 78	{ .driver_info = 1 },	/* Matches all devices */
 79	{ },			/* Terminating zero entry */
 80};
 81
 82MODULE_DEVICE_TABLE(input, evbug_ids);
 83
 84static struct input_handler evbug_handler = {
 85	.event =	evbug_event,
 86	.connect =	evbug_connect,
 87	.disconnect =	evbug_disconnect,
 88	.name =		"evbug",
 89	.id_table =	evbug_ids,
 90};
 91
 92static int __init evbug_init(void)
 93{
 94	return input_register_handler(&evbug_handler);
 95}
 96
 97static void __exit evbug_exit(void)
 98{
 99	input_unregister_handler(&evbug_handler);
100}
101
102module_init(evbug_init);
103module_exit(evbug_exit);

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  Copyright (c) 1999-2001 Vojtech Pavlik
  4 */
  5
  6/*
  7 *  Input driver event debug module - dumps all events into syslog
  8 */
  9
 
 
 
 10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 11
 12#include <linux/slab.h>
 13#include <linux/module.h>
 14#include <linux/input.h>
 15#include <linux/init.h>
 16#include <linux/device.h>
 17
 18MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 19MODULE_DESCRIPTION("Input driver event debug module");
 20MODULE_LICENSE("GPL");
 21
 22static void evbug_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
 23{
 24	printk(KERN_DEBUG pr_fmt("Event. Dev: %s, Type: %d, Code: %d, Value: %d\n"),
 25	       dev_name(&handle->dev->dev), type, code, value);
 26}
 27
 28static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
 29			 const struct input_device_id *id)
 30{
 31	struct input_handle *handle;
 32	int error;
 33
 34	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
 35	if (!handle)
 36		return -ENOMEM;
 37
 38	handle->dev = dev;
 39	handle->handler = handler;
 40	handle->name = "evbug";
 41
 42	error = input_register_handle(handle);
 43	if (error)
 44		goto err_free_handle;
 45
 46	error = input_open_device(handle);
 47	if (error)
 48		goto err_unregister_handle;
 49
 50	printk(KERN_DEBUG pr_fmt("Connected device: %s (%s at %s)\n"),
 51	       dev_name(&dev->dev),
 52	       dev->name ?: "unknown",
 53	       dev->phys ?: "unknown");
 54
 55	return 0;
 56
 57 err_unregister_handle:
 58	input_unregister_handle(handle);
 59 err_free_handle:
 60	kfree(handle);
 61	return error;
 62}
 63
 64static void evbug_disconnect(struct input_handle *handle)
 65{
 66	printk(KERN_DEBUG pr_fmt("Disconnected device: %s\n"),
 67	       dev_name(&handle->dev->dev));
 68
 69	input_close_device(handle);
 70	input_unregister_handle(handle);
 71	kfree(handle);
 72}
 73
 74static const struct input_device_id evbug_ids[] = {
 75	{ .driver_info = 1 },	/* Matches all devices */
 76	{ },			/* Terminating zero entry */
 77};
 78
 79MODULE_DEVICE_TABLE(input, evbug_ids);
 80
 81static struct input_handler evbug_handler = {
 82	.event =	evbug_event,
 83	.connect =	evbug_connect,
 84	.disconnect =	evbug_disconnect,
 85	.name =		"evbug",
 86	.id_table =	evbug_ids,
 87};
 88
 89static int __init evbug_init(void)
 90{
 91	return input_register_handler(&evbug_handler);
 92}
 93
 94static void __exit evbug_exit(void)
 95{
 96	input_unregister_handler(&evbug_handler);
 97}
 98
 99module_init(evbug_init);
100module_exit(evbug_exit);