HID: Use module_hid_driver macro

Use the new module_hid_driver macro in all HID drivers that have
a simple register/unregister init/exit.

This also converts the hid drivers that test for a failure of
hid_register_driver() and report the failure. Using module_hid_driver
in those drivers removes the failure message.

Signed-off-by: H Hartley Sweeten <hsweeten@visionengravers.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
H Hartley Sweeten 2012-12-17 15:28:26 -07:00 committed by Jiri Kosina
parent d463f4719a
commit f425458eaf
54 changed files with 54 additions and 691 deletions

View file

@ -146,17 +146,6 @@ static struct hid_driver a4_driver = {
.probe = a4_probe, .probe = a4_probe,
.remove = a4_remove, .remove = a4_remove,
}; };
module_hid_driver(a4_driver);
static int __init a4_init(void)
{
return hid_register_driver(&a4_driver);
}
static void __exit a4_exit(void)
{
hid_unregister_driver(&a4_driver);
}
module_init(a4_init);
module_exit(a4_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -555,23 +555,6 @@ static struct hid_driver apple_driver = {
.input_mapping = apple_input_mapping, .input_mapping = apple_input_mapping,
.input_mapped = apple_input_mapped, .input_mapped = apple_input_mapped,
}; };
module_hid_driver(apple_driver);
static int __init apple_init(void)
{
int ret;
ret = hid_register_driver(&apple_driver);
if (ret)
pr_err("can't register apple driver\n");
return ret;
}
static void __exit apple_exit(void)
{
hid_unregister_driver(&apple_driver);
}
module_init(apple_init);
module_exit(apple_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -37,17 +37,6 @@ static struct hid_driver aureal_driver = {
.id_table = aureal_devices, .id_table = aureal_devices,
.report_fixup = aureal_report_fixup, .report_fixup = aureal_report_fixup,
}; };
module_hid_driver(aureal_driver);
static int __init aureal_init(void)
{
return hid_register_driver(&aureal_driver);
}
static void __exit aureal_exit(void)
{
hid_unregister_driver(&aureal_driver);
}
module_init(aureal_init);
module_exit(aureal_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -192,19 +192,7 @@ static struct hid_driver ax_driver = {
.probe = ax_probe, .probe = ax_probe,
.remove = ax_remove, .remove = ax_remove,
}; };
module_hid_driver(ax_driver);
static int __init ax_init(void)
{
return hid_register_driver(&ax_driver);
}
static void __exit ax_exit(void)
{
hid_unregister_driver(&ax_driver);
}
module_init(ax_init);
module_exit(ax_exit);
MODULE_AUTHOR("Sergei Kolzun"); MODULE_AUTHOR("Sergei Kolzun");
MODULE_DESCRIPTION("Force feedback support for ACRUX game controllers"); MODULE_DESCRIPTION("Force feedback support for ACRUX game controllers");

View file

@ -86,17 +86,6 @@ static struct hid_driver belkin_driver = {
.input_mapping = belkin_input_mapping, .input_mapping = belkin_input_mapping,
.probe = belkin_probe, .probe = belkin_probe,
}; };
module_hid_driver(belkin_driver);
static int __init belkin_init(void)
{
return hid_register_driver(&belkin_driver);
}
static void __exit belkin_exit(void)
{
hid_unregister_driver(&belkin_driver);
}
module_init(belkin_init);
module_exit(belkin_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -69,17 +69,6 @@ static struct hid_driver ch_driver = {
.report_fixup = ch_report_fixup, .report_fixup = ch_report_fixup,
.input_mapping = ch_input_mapping, .input_mapping = ch_input_mapping,
}; };
module_hid_driver(ch_driver);
static int __init ch_init(void)
{
return hid_register_driver(&ch_driver);
}
static void __exit ch_exit(void)
{
hid_unregister_driver(&ch_driver);
}
module_init(ch_init);
module_exit(ch_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -70,17 +70,6 @@ static struct hid_driver ch_driver = {
.id_table = ch_devices, .id_table = ch_devices,
.input_mapping = ch_input_mapping, .input_mapping = ch_input_mapping,
}; };
module_hid_driver(ch_driver);
static int __init ch_init(void)
{
return hid_register_driver(&ch_driver);
}
static void __exit ch_exit(void)
{
hid_unregister_driver(&ch_driver);
}
module_init(ch_init);
module_exit(ch_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -144,17 +144,6 @@ static struct hid_driver cp_driver = {
.event = cp_event, .event = cp_event,
.probe = cp_probe, .probe = cp_probe,
}; };
module_hid_driver(cp_driver);
static int __init cp_init(void)
{
return hid_register_driver(&cp_driver);
}
static void __exit cp_exit(void)
{
hid_unregister_driver(&cp_driver);
}
module_init(cp_init);
module_exit(cp_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -297,17 +297,6 @@ static struct hid_driver dr_driver = {
.report_fixup = dr_report_fixup, .report_fixup = dr_report_fixup,
.probe = dr_probe, .probe = dr_probe,
}; };
module_hid_driver(dr_driver);
static int __init dr_init(void)
{
return hid_register_driver(&dr_driver);
}
static void __exit dr_exit(void)
{
hid_unregister_driver(&dr_driver);
}
module_init(dr_init);
module_exit(dr_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -41,17 +41,6 @@ static struct hid_driver elecom_driver = {
.id_table = elecom_devices, .id_table = elecom_devices,
.report_fixup = elecom_report_fixup .report_fixup = elecom_report_fixup
}; };
module_hid_driver(elecom_driver);
static int __init elecom_init(void)
{
return hid_register_driver(&elecom_driver);
}
static void __exit elecom_exit(void)
{
hid_unregister_driver(&elecom_driver);
}
module_init(elecom_init);
module_exit(elecom_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -150,18 +150,7 @@ static struct hid_driver ems_driver = {
.id_table = ems_devices, .id_table = ems_devices,
.probe = ems_probe, .probe = ems_probe,
}; };
module_hid_driver(ems_driver);
static int ems_init(void)
{
return hid_register_driver(&ems_driver);
}
static void ems_exit(void)
{
hid_unregister_driver(&ems_driver);
}
module_init(ems_init);
module_exit(ems_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -76,17 +76,6 @@ static struct hid_driver ez_driver = {
.input_mapping = ez_input_mapping, .input_mapping = ez_input_mapping,
.event = ez_event, .event = ez_event,
}; };
module_hid_driver(ez_driver);
static int __init ez_init(void)
{
return hid_register_driver(&ez_driver);
}
static void __exit ez_exit(void)
{
hid_unregister_driver(&ez_driver);
}
module_init(ez_init);
module_exit(ez_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -176,17 +176,6 @@ static struct hid_driver ga_driver = {
.id_table = ga_devices, .id_table = ga_devices,
.probe = ga_probe, .probe = ga_probe,
}; };
module_hid_driver(ga_driver);
static int __init ga_init(void)
{
return hid_register_driver(&ga_driver);
}
static void __exit ga_exit(void)
{
hid_unregister_driver(&ga_driver);
}
module_init(ga_init);
module_exit(ga_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -34,19 +34,7 @@ static struct hid_driver hid_generic = {
.name = "hid-generic", .name = "hid-generic",
.id_table = hid_table, .id_table = hid_table,
}; };
module_hid_driver(hid_generic);
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_AUTHOR("Henrik Rydberg");
MODULE_DESCRIPTION("HID generic driver"); MODULE_DESCRIPTION("HID generic driver");

View file

@ -88,17 +88,6 @@ static struct hid_driver gyration_driver = {
.input_mapping = gyration_input_mapping, .input_mapping = gyration_input_mapping,
.event = gyration_event, .event = gyration_event,
}; };
module_hid_driver(gyration_driver);
static int __init gyration_init(void)
{
return hid_register_driver(&gyration_driver);
}
static void __exit gyration_exit(void)
{
hid_unregister_driver(&gyration_driver);
}
module_init(gyration_init);
module_exit(gyration_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -167,17 +167,6 @@ static struct hid_driver holtek_kbd_driver = {
.report_fixup = holtek_kbd_report_fixup, .report_fixup = holtek_kbd_report_fixup,
.probe = holtek_kbd_probe .probe = holtek_kbd_probe
}; };
module_hid_driver(holtek_kbd_driver);
static int __init holtek_kbd_init(void)
{
return hid_register_driver(&holtek_kbd_driver);
}
static void __exit holtek_kbd_exit(void)
{
hid_unregister_driver(&holtek_kbd_driver);
}
module_exit(holtek_kbd_exit);
module_init(holtek_kbd_init);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -224,17 +224,4 @@ static struct hid_driver holtek_driver = {
.id_table = holtek_devices, .id_table = holtek_devices,
.probe = holtek_probe, .probe = holtek_probe,
}; };
module_hid_driver(holtek_driver);
static int __init holtek_init(void)
{
return hid_register_driver(&holtek_driver);
}
static void __exit holtek_exit(void)
{
hid_unregister_driver(&holtek_driver);
}
module_init(holtek_init);
module_exit(holtek_exit);

View file

@ -235,25 +235,8 @@ static struct hid_driver icade_driver = {
.input_mapped = icade_input_mapped, .input_mapped = icade_input_mapped,
.input_mapping = icade_input_mapping, .input_mapping = icade_input_mapping,
}; };
module_hid_driver(icade_driver);
static int __init icade_init(void)
{
int ret;
ret = hid_register_driver(&icade_driver);
if (ret)
pr_err("can't register icade driver\n");
return ret;
}
static void __exit icade_exit(void)
{
hid_unregister_driver(&icade_driver);
}
module_init(icade_init);
module_exit(icade_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>"); MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
MODULE_DESCRIPTION("ION iCade input driver"); MODULE_DESCRIPTION("ION iCade input driver");

View file

@ -47,17 +47,6 @@ static struct hid_driver ks_driver = {
.id_table = ks_devices, .id_table = ks_devices,
.input_mapping = ks_input_mapping, .input_mapping = ks_input_mapping,
}; };
module_hid_driver(ks_driver);
static int __init ks_init(void)
{
return hid_register_driver(&ks_driver);
}
static void __exit ks_exit(void)
{
hid_unregister_driver(&ks_driver);
}
module_init(ks_init);
module_exit(ks_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -49,18 +49,7 @@ static struct hid_driver keytouch_driver = {
.id_table = keytouch_devices, .id_table = keytouch_devices,
.report_fixup = keytouch_report_fixup, .report_fixup = keytouch_report_fixup,
}; };
module_hid_driver(keytouch_driver);
static int __init keytouch_init(void)
{
return hid_register_driver(&keytouch_driver);
}
static void __exit keytouch_exit(void)
{
hid_unregister_driver(&keytouch_driver);
}
module_init(keytouch_init);
module_exit(keytouch_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jiri Kosina"); MODULE_AUTHOR("Jiri Kosina");

View file

@ -419,17 +419,6 @@ static struct hid_driver kye_driver = {
.probe = kye_probe, .probe = kye_probe,
.report_fixup = kye_report_fixup, .report_fixup = kye_report_fixup,
}; };
module_hid_driver(kye_driver);
static int __init kye_init(void)
{
return hid_register_driver(&kye_driver);
}
static void __exit kye_exit(void)
{
hid_unregister_driver(&kye_driver);
}
module_init(kye_init);
module_exit(kye_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -54,17 +54,6 @@ static struct hid_driver ts_driver = {
.id_table = ts_devices, .id_table = ts_devices,
.input_mapping = ts_input_mapping, .input_mapping = ts_input_mapping,
}; };
module_hid_driver(ts_driver);
static int __init ts_init(void)
{
return hid_register_driver(&ts_driver);
}
static void __exit ts_exit(void)
{
hid_unregister_driver(&ts_driver);
}
module_init(ts_init);
module_exit(ts_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -468,18 +468,6 @@ static struct hid_driver tpkbd_driver = {
.probe = tpkbd_probe, .probe = tpkbd_probe,
.remove = tpkbd_remove, .remove = tpkbd_remove,
}; };
module_hid_driver(tpkbd_driver);
static int __init tpkbd_init(void)
{
return hid_register_driver(&tpkbd_driver);
}
static void __exit tpkbd_exit(void)
{
hid_unregister_driver(&tpkbd_driver);
}
module_init(tpkbd_init);
module_exit(tpkbd_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -503,17 +503,6 @@ static struct hid_driver lg_driver = {
.probe = lg_probe, .probe = lg_probe,
.remove = lg_remove, .remove = lg_remove,
}; };
module_hid_driver(lg_driver);
static int __init lg_init(void)
{
return hid_register_driver(&lg_driver);
}
static void __exit lg_exit(void)
{
hid_unregister_driver(&lg_driver);
}
module_init(lg_init);
module_exit(lg_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -569,23 +569,6 @@ static struct hid_driver magicmouse_driver = {
.raw_event = magicmouse_raw_event, .raw_event = magicmouse_raw_event,
.input_mapping = magicmouse_input_mapping, .input_mapping = magicmouse_input_mapping,
}; };
module_hid_driver(magicmouse_driver);
static int __init magicmouse_init(void)
{
int ret;
ret = hid_register_driver(&magicmouse_driver);
if (ret)
pr_err("can't register magicmouse driver\n");
return ret;
}
static void __exit magicmouse_exit(void)
{
hid_unregister_driver(&magicmouse_driver);
}
module_init(magicmouse_init);
module_exit(magicmouse_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -221,17 +221,6 @@ static struct hid_driver ms_driver = {
.event = ms_event, .event = ms_event,
.probe = ms_probe, .probe = ms_probe,
}; };
module_hid_driver(ms_driver);
static int __init ms_init(void)
{
return hid_register_driver(&ms_driver);
}
static void __exit ms_exit(void)
{
hid_unregister_driver(&ms_driver);
}
module_init(ms_init);
module_exit(ms_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -63,17 +63,6 @@ static struct hid_driver mr_driver = {
.report_fixup = mr_report_fixup, .report_fixup = mr_report_fixup,
.input_mapping = mr_input_mapping, .input_mapping = mr_input_mapping,
}; };
module_hid_driver(mr_driver);
static int __init mr_init(void)
{
return hid_register_driver(&mr_driver);
}
static void __exit mr_exit(void)
{
hid_unregister_driver(&mr_driver);
}
module_init(mr_init);
module_exit(mr_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -1198,16 +1198,4 @@ static struct hid_driver mt_driver = {
.resume = mt_resume, .resume = mt_resume,
#endif #endif
}; };
module_hid_driver(mt_driver);
static int __init mt_init(void)
{
return hid_register_driver(&mt_driver);
}
static void __exit mt_exit(void)
{
hid_unregister_driver(&mt_driver);
}
module_init(mt_init);
module_exit(mt_exit);

View file

@ -1026,17 +1026,6 @@ static struct hid_driver ntrig_driver = {
.usage_table = ntrig_grabbed_usages, .usage_table = ntrig_grabbed_usages,
.event = ntrig_event, .event = ntrig_event,
}; };
module_hid_driver(ntrig_driver);
static int __init ntrig_init(void)
{
return hid_register_driver(&ntrig_driver);
}
static void __exit ntrig_exit(void)
{
hid_unregister_driver(&ntrig_driver);
}
module_init(ntrig_init);
module_exit(ntrig_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -50,17 +50,6 @@ static struct hid_driver ortek_driver = {
.id_table = ortek_devices, .id_table = ortek_devices,
.report_fixup = ortek_report_fixup .report_fixup = ortek_report_fixup
}; };
module_hid_driver(ortek_driver);
static int __init ortek_init(void)
{
return hid_register_driver(&ortek_driver);
}
static void __exit ortek_exit(void)
{
hid_unregister_driver(&ortek_driver);
}
module_init(ortek_init);
module_exit(ortek_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -103,17 +103,6 @@ static struct hid_driver pl_driver = {
.input_mapping = pl_input_mapping, .input_mapping = pl_input_mapping,
.probe = pl_probe, .probe = pl_probe,
}; };
module_hid_driver(pl_driver);
static int __init pl_init(void)
{
return hid_register_driver(&pl_driver);
}
static void __exit pl_exit(void)
{
hid_unregister_driver(&pl_driver);
}
module_init(pl_init);
module_exit(pl_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -672,18 +672,7 @@ static struct hid_driver picolcd_driver = {
.reset_resume = picolcd_reset_resume, .reset_resume = picolcd_reset_resume,
#endif #endif
}; };
module_hid_driver(picolcd_driver);
static int __init picolcd_init(void)
{
return hid_register_driver(&picolcd_driver);
}
static void __exit picolcd_exit(void)
{
hid_unregister_driver(&picolcd_driver);
}
module_init(picolcd_init);
module_exit(picolcd_exit);
MODULE_DESCRIPTION("Minibox graphics PicoLCD Driver"); MODULE_DESCRIPTION("Minibox graphics PicoLCD Driver");
MODULE_LICENSE("GPL v2"); MODULE_LICENSE("GPL v2");

View file

@ -216,17 +216,6 @@ static struct hid_driver pl_driver = {
.id_table = pl_devices, .id_table = pl_devices,
.probe = pl_probe, .probe = pl_probe,
}; };
module_hid_driver(pl_driver);
static int __init pl_init(void)
{
return hid_register_driver(&pl_driver);
}
static void __exit pl_exit(void)
{
hid_unregister_driver(&pl_driver);
}
module_init(pl_init);
module_exit(pl_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -75,18 +75,7 @@ static struct hid_driver px_driver = {
.id_table = px_devices, .id_table = px_devices,
.raw_event = px_raw_event, .raw_event = px_raw_event,
}; };
module_hid_driver(px_driver);
static int __init px_init(void)
{
return hid_register_driver(&px_driver);
}
static void __exit px_exit(void)
{
hid_unregister_driver(&px_driver);
}
module_init(px_init);
module_exit(px_exit);
MODULE_AUTHOR("Terry Lambert <tlambert@google.com>"); MODULE_AUTHOR("Terry Lambert <tlambert@google.com>");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -889,23 +889,6 @@ static struct hid_driver pk_driver = {
.probe = pk_probe, .probe = pk_probe,
.remove = pk_remove, .remove = pk_remove,
}; };
module_hid_driver(pk_driver);
static int pk_init(void)
{
int ret;
ret = hid_register_driver(&pk_driver);
if (ret)
pr_err("can't register prodikeys driver\n");
return ret;
}
static void pk_exit(void)
{
hid_unregister_driver(&pk_driver);
}
module_init(pk_init);
module_exit(pk_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -198,18 +198,7 @@ static struct hid_driver ps3remote_driver = {
.report_fixup = ps3remote_fixup, .report_fixup = ps3remote_fixup,
.input_mapping = ps3remote_mapping, .input_mapping = ps3remote_mapping,
}; };
module_hid_driver(ps3remote_driver);
static int __init ps3remote_init(void)
{
return hid_register_driver(&ps3remote_driver);
}
static void __exit ps3remote_exit(void)
{
hid_unregister_driver(&ps3remote_driver);
}
module_init(ps3remote_init);
module_exit(ps3remote_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Dillow <dave@thedillows.org>, Antonio Ospite <ospite@studenti.unina.it>"); MODULE_AUTHOR("David Dillow <dave@thedillows.org>, Antonio Ospite <ospite@studenti.unina.it>");

View file

@ -208,19 +208,7 @@ static struct hid_driver lua_driver = {
.probe = lua_probe, .probe = lua_probe,
.remove = lua_remove .remove = lua_remove
}; };
module_hid_driver(lua_driver);
static int __init lua_init(void)
{
return hid_register_driver(&lua_driver);
}
static void __exit lua_exit(void)
{
hid_unregister_driver(&lua_driver);
}
module_init(lua_init);
module_exit(lua_exit);
MODULE_AUTHOR("Stefan Achatz"); MODULE_AUTHOR("Stefan Achatz");
MODULE_DESCRIPTION("USB Roccat Lua driver"); MODULE_DESCRIPTION("USB Roccat Lua driver");

View file

@ -54,17 +54,6 @@ static struct hid_driver saitek_driver = {
.id_table = saitek_devices, .id_table = saitek_devices,
.report_fixup = saitek_report_fixup .report_fixup = saitek_report_fixup
}; };
module_hid_driver(saitek_driver);
static int __init saitek_init(void)
{
return hid_register_driver(&saitek_driver);
}
static void __exit saitek_exit(void)
{
hid_unregister_driver(&saitek_driver);
}
module_init(saitek_init);
module_exit(saitek_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -196,17 +196,6 @@ static struct hid_driver samsung_driver = {
.input_mapping = samsung_input_mapping, .input_mapping = samsung_input_mapping,
.probe = samsung_probe, .probe = samsung_probe,
}; };
module_hid_driver(samsung_driver);
static int __init samsung_init(void)
{
return hid_register_driver(&samsung_driver);
}
static void __exit samsung_exit(void)
{
hid_unregister_driver(&samsung_driver);
}
module_init(samsung_init);
module_exit(samsung_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -627,19 +627,7 @@ static struct hid_driver sensor_hub_driver = {
.reset_resume = sensor_hub_reset_resume, .reset_resume = sensor_hub_reset_resume,
#endif #endif
}; };
module_hid_driver(sensor_hub_driver);
static int __init sensor_hub_init(void)
{
return hid_register_driver(&sensor_hub_driver);
}
static void __exit sensor_hub_exit(void)
{
hid_unregister_driver(&sensor_hub_driver);
}
module_init(sensor_hub_init);
module_exit(sensor_hub_exit);
MODULE_DESCRIPTION("HID Sensor Hub driver"); MODULE_DESCRIPTION("HID Sensor Hub driver");
MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>"); MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");

View file

@ -177,19 +177,8 @@ static struct hid_driver sjoy_driver = {
.id_table = sjoy_devices, .id_table = sjoy_devices,
.probe = sjoy_probe, .probe = sjoy_probe,
}; };
module_hid_driver(sjoy_driver);
static int __init sjoy_init(void)
{
return hid_register_driver(&sjoy_driver);
}
static void __exit sjoy_exit(void)
{
hid_unregister_driver(&sjoy_driver);
}
module_init(sjoy_init);
module_exit(sjoy_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jussi Kivilinna"); MODULE_AUTHOR("Jussi Kivilinna");

View file

@ -229,17 +229,6 @@ static struct hid_driver sony_driver = {
.report_fixup = sony_report_fixup, .report_fixup = sony_report_fixup,
.raw_event = sony_raw_event .raw_event = sony_raw_event
}; };
module_hid_driver(sony_driver);
static int __init sony_init(void)
{
return hid_register_driver(&sony_driver);
}
static void __exit sony_exit(void)
{
hid_unregister_driver(&sony_driver);
}
module_init(sony_init);
module_exit(sony_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -73,17 +73,6 @@ static struct hid_driver speedlink_driver = {
.input_mapping = speedlink_input_mapping, .input_mapping = speedlink_input_mapping,
.event = speedlink_event, .event = speedlink_event,
}; };
module_hid_driver(speedlink_driver);
static int __init speedlink_init(void)
{
return hid_register_driver(&speedlink_driver);
}
static void __exit speedlink_exit(void)
{
hid_unregister_driver(&speedlink_driver);
}
module_init(speedlink_init);
module_exit(speedlink_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -63,17 +63,6 @@ static struct hid_driver sp_driver = {
.report_fixup = sp_report_fixup, .report_fixup = sp_report_fixup,
.input_mapping = sp_input_mapping, .input_mapping = sp_input_mapping,
}; };
module_hid_driver(sp_driver);
static int __init sp_init(void)
{
return hid_register_driver(&sp_driver);
}
static void __exit sp_exit(void)
{
hid_unregister_driver(&sp_driver);
}
module_init(sp_init);
module_exit(sp_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -73,18 +73,7 @@ static struct hid_driver tivo_driver = {
.id_table = tivo_devices, .id_table = tivo_devices,
.input_mapping = tivo_input_mapping, .input_mapping = tivo_input_mapping,
}; };
module_hid_driver(tivo_driver);
static int __init tivo_init(void)
{
return hid_register_driver(&tivo_driver);
}
static void __exit tivo_exit(void)
{
hid_unregister_driver(&tivo_driver);
}
module_init(tivo_init);
module_exit(tivo_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <jarod@redhat.com>"); MODULE_AUTHOR("Jarod Wilson <jarod@redhat.com>");

View file

@ -261,17 +261,6 @@ static struct hid_driver tm_driver = {
.id_table = tm_devices, .id_table = tm_devices,
.probe = tm_probe, .probe = tm_probe,
}; };
module_hid_driver(tm_driver);
static int __init tm_init(void)
{
return hid_register_driver(&tm_driver);
}
static void __exit tm_exit(void)
{
hid_unregister_driver(&tm_driver);
}
module_init(tm_init);
module_exit(tm_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -76,17 +76,6 @@ static struct hid_driver ts_driver = {
.id_table = ts_devices, .id_table = ts_devices,
.input_mapping = ts_input_mapping, .input_mapping = ts_input_mapping,
}; };
module_hid_driver(ts_driver);
static int __init ts_init(void)
{
return hid_register_driver(&ts_driver);
}
static void __exit ts_exit(void)
{
hid_unregister_driver(&ts_driver);
}
module_init(ts_init);
module_exit(ts_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -131,17 +131,6 @@ static struct hid_driver twinhan_driver = {
.id_table = twinhan_devices, .id_table = twinhan_devices,
.input_mapping = twinhan_input_mapping, .input_mapping = twinhan_input_mapping,
}; };
module_hid_driver(twinhan_driver);
static int __init twinhan_init(void)
{
return hid_register_driver(&twinhan_driver);
}
static void __exit twinhan_exit(void)
{
hid_unregister_driver(&twinhan_driver);
}
module_init(twinhan_init);
module_exit(twinhan_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -650,17 +650,6 @@ static struct hid_driver uclogic_driver = {
.id_table = uclogic_devices, .id_table = uclogic_devices,
.report_fixup = uclogic_report_fixup, .report_fixup = uclogic_report_fixup,
}; };
module_hid_driver(uclogic_driver);
static int __init uclogic_init(void)
{
return hid_register_driver(&uclogic_driver);
}
static void __exit uclogic_exit(void)
{
hid_unregister_driver(&uclogic_driver);
}
module_init(uclogic_init);
module_exit(uclogic_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -953,23 +953,7 @@ static struct hid_driver wacom_driver = {
.raw_event = wacom_raw_event, .raw_event = wacom_raw_event,
.input_mapped = wacom_input_mapped, .input_mapped = wacom_input_mapped,
}; };
module_hid_driver(wacom_driver);
static int __init wacom_init(void)
{
int ret;
ret = hid_register_driver(&wacom_driver);
if (ret)
pr_err("can't register wacom driver\n");
return ret;
}
static void __exit wacom_exit(void)
{
hid_unregister_driver(&wacom_driver);
}
module_init(wacom_init);
module_exit(wacom_exit);
MODULE_DESCRIPTION("Driver for Wacom Graphire Bluetooth and Wacom Intuos4 WL"); MODULE_DESCRIPTION("Driver for Wacom Graphire Bluetooth and Wacom Intuos4 WL");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -779,17 +779,6 @@ static struct hid_driver waltop_driver = {
.report_fixup = waltop_report_fixup, .report_fixup = waltop_report_fixup,
.raw_event = waltop_raw_event, .raw_event = waltop_raw_event,
}; };
module_hid_driver(waltop_driver);
static int __init waltop_init(void)
{
return hid_register_driver(&waltop_driver);
}
static void __exit waltop_exit(void)
{
hid_unregister_driver(&waltop_driver);
}
module_init(waltop_init);
module_exit(waltop_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -1294,25 +1294,8 @@ static struct hid_driver wiimote_hid_driver = {
.remove = wiimote_hid_remove, .remove = wiimote_hid_remove,
.raw_event = wiimote_hid_event, .raw_event = wiimote_hid_event,
}; };
module_hid_driver(wiimote_hid_driver);
static int __init wiimote_init(void)
{
int ret;
ret = hid_register_driver(&wiimote_hid_driver);
if (ret)
pr_err("Can't register wiimote hid driver\n");
return ret;
}
static void __exit wiimote_exit(void)
{
hid_unregister_driver(&wiimote_hid_driver);
}
module_init(wiimote_init);
module_exit(wiimote_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>"); MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver"); MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");

View file

@ -152,17 +152,6 @@ static struct hid_driver zp_driver = {
.id_table = zp_devices, .id_table = zp_devices,
.probe = zp_probe, .probe = zp_probe,
}; };
module_hid_driver(zp_driver);
static int __init zp_init(void)
{
return hid_register_driver(&zp_driver);
}
static void __exit zp_exit(void)
{
hid_unregister_driver(&zp_driver);
}
module_init(zp_init);
module_exit(zp_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

View file

@ -219,17 +219,6 @@ static struct hid_driver zc_driver = {
.probe = zc_probe, .probe = zc_probe,
.remove = zc_remove, .remove = zc_remove,
}; };
module_hid_driver(zc_driver);
static int __init zc_init(void)
{
return hid_register_driver(&zc_driver);
}
static void __exit zc_exit(void)
{
hid_unregister_driver(&zc_driver);
}
module_init(zc_init);
module_exit(zc_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");