HID: Create a common generic driver (8215d557) · Commits · 戴 / test

drivers/hid/Kconfig

+12 −0

Original line number	Original line	Diff line number	Diff line
	@@ -60,6 +60,18 @@ source "drivers/hid/usbhid/Kconfig"
	menu "Special HID drivers"		menu "Special HID drivers"
	depends on HID		depends on HID

			config HID_GENERIC
			tristate "Generic HID driver"
			depends on HID
			default y
			---help---
			Support for generic HID devices.

			To compile this driver as a module, choose M here: the module
			will be called hid-generic.

			If unsure, say Y.

	config HID_A4TECH		config HID_A4TECH
	tristate "A4 tech mice" if EXPERT		tristate "A4 tech mice" if EXPERT
	depends on USB_HID		depends on USB_HID

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,8 @@ endif

	obj-$(CONFIG_HID) += hid.o		obj-$(CONFIG_HID) += hid.o

			obj-$(CONFIG_HID_GENERIC) += hid-generic.o

	hid-$(CONFIG_HIDRAW) += hidraw.o		hid-$(CONFIG_HIDRAW) += hidraw.o

	hid-logitech-y := hid-lg.o		hid-logitech-y := hid-lg.o

0 → 100644

+53 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* HID support for Linux
			*
			* Copyright (c) 1999 Andreas Gal
			* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
			* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
			* Copyright (c) 2007-2008 Oliver Neukum
			* Copyright (c) 2006-2012 Jiri Kosina
			* Copyright (c) 2012 Henrik Rydberg
			*/

			/*
			* This program is free software; you can redistribute it and/or modify it
			* under the terms of the GNU General Public License as published by the Free
			* Software Foundation; either version 2 of the License, or (at your option)
			* any later version.
			*/

			#include <linux/module.h>
			#include <linux/slab.h>
			#include <linux/kernel.h>
			#include <asm/unaligned.h>
			#include <asm/byteorder.h>

			#include <linux/hid.h>

			static const struct hid_device_id hid_table[] = {
			{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_GENERIC, HID_ANY_ID, HID_ANY_ID) },
			{ }
			};
			MODULE_DEVICE_TABLE(hid, hid_table);

			static struct hid_driver hid_generic = {
			.name = "hid-generic",
			.id_table = hid_table,
			};

			static int __init hid_init(void)
			{
			return hid_register_driver(&hid_generic);
			}

			static void __exit hid_exit(void)
			{
			hid_unregister_driver(&hid_generic);
			}

			module_init(hid_init);
			module_exit(hid_exit);

			MODULE_AUTHOR("Henrik Rydberg");
			MODULE_DESCRIPTION("HID generic driver");
			MODULE_LICENSE("GPL");

+0 −16

Original line number	Original line	Diff line number	Diff line
	@@ -1504,28 +1504,15 @@ static struct usb_driver hid_driver = {
	.supports_autosuspend = 1,		.supports_autosuspend = 1,
	};		};

	static const struct hid_device_id hid_usb_table[] = {
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, HID_ANY_ID, HID_ANY_ID) },
	{ }
	};

	struct usb_interface *usbhid_find_interface(int minor)		struct usb_interface *usbhid_find_interface(int minor)
	{		{
	return usb_find_interface(&hid_driver, minor);		return usb_find_interface(&hid_driver, minor);
	}		}

	static struct hid_driver hid_usb_driver = {
	.name = "generic-usb",
	.id_table = hid_usb_table,
	};

	static int __init hid_init(void)		static int __init hid_init(void)
	{		{
	int retval = -ENOMEM;		int retval = -ENOMEM;

	retval = hid_register_driver(&hid_usb_driver);
	if (retval)
	goto hid_register_fail;
	retval = usbhid_quirks_init(quirks_param);		retval = usbhid_quirks_init(quirks_param);
	if (retval)		if (retval)
	goto usbhid_quirks_init_fail;		goto usbhid_quirks_init_fail;
	@@ -1538,8 +1525,6 @@ static int __init hid_init(void)
	usb_register_fail:		usb_register_fail:
	usbhid_quirks_exit();		usbhid_quirks_exit();
	usbhid_quirks_init_fail:		usbhid_quirks_init_fail:
	hid_unregister_driver(&hid_usb_driver);
	hid_register_fail:
	return retval;		return retval;
	}		}

	@@ -1547,7 +1532,6 @@ static void __exit hid_exit(void)
	{		{
	usb_deregister(&hid_driver);		usb_deregister(&hid_driver);
	usbhid_quirks_exit();		usbhid_quirks_exit();
	hid_unregister_driver(&hid_usb_driver);
	}		}

	module_init(hid_init);		module_init(hid_init);

+1 −26

Original line number	Original line	Diff line number	Diff line
	@@ -1195,41 +1195,16 @@ int hidp_get_conninfo(struct hidp_conninfo *ci)
	return err;		return err;
	}		}

	static const struct hid_device_id hidp_table[] = {
	{ HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_GENERIC, HID_ANY_ID, HID_ANY_ID) },
	{ }
	};

	static struct hid_driver hidp_driver = {
	.name = "generic-bluetooth",
	.id_table = hidp_table,
	};

	static int __init hidp_init(void)		static int __init hidp_init(void)
	{		{
	int ret;

	BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);		BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);

	ret = hid_register_driver(&hidp_driver);		return hidp_init_sockets();
	if (ret)
	goto err;

	ret = hidp_init_sockets();
	if (ret)
	goto err_drv;

	return 0;
	err_drv:
	hid_unregister_driver(&hidp_driver);
	err:
	return ret;
	}		}

	static void __exit hidp_exit(void)		static void __exit hidp_exit(void)
	{		{
	hidp_cleanup_sockets();		hidp_cleanup_sockets();
	hid_unregister_driver(&hidp_driver);
	}		}

	module_init(hidp_init);		module_init(hidp_init);