Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (55 commits)
  HID: build drivers for all quirky devices by default
  HID: add missing blacklist entry for Apple ATV ircontrol
  HID: add support for Bright ABNT2 brazilian device
  HID: Don't let Avermedia Radio FM800 be handled by usb hid drivers
  HID: fix numlock led on Dell device 0x413c/0x2105
  HID: remove warn() macro from usb hid drivers
  HID: remove info() macro from usb HID drivers
  HID: add appletv IR receiver quirk
  HID: fix a lockup regression when using force feedback on a PID device
  HID: hiddev.h: Fix example code.
  HID: hiddev.h: Fix mixed space and tabs in example code.
  HID: convert to dev_* prints
  HID: remove hid-ff
  HID: move zeroplus FF processing
  HID: move thrustmaster FF processing
  HID: move pantherlord FF processing
  HID: fix incorrent length condition in hidraw_write()
  HID: fix tty<->hid deadlock
  HID: ignore iBuddy devices
  HID: report descriptor fix for remaining MacBook JIS keyboards
  ...

48 files changed, 5503 insertions, 2949 deletions

diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index cc8093c15cf5..4d2566a7d168 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -287,6 +287,13 @@ Who:	Glauber Costa <gcosta@redhat.com>
 
 ---------------------------
 
+What:   remove HID compat support
+When:   2.6.29
+Why:    needed only as a temporary solution until distros fix themselves up
+Who:    Jiri Slaby <jirislaby@gmail.com>
+
+---------------------------
+
 What:   /sys/o2cb symlink
 When:   January 2010
 Why:    /sys/fs/o2cb is the proper location for this information - /sys/o2cb
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index cacf89e65af4..da64108de775 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -17,6 +17,25 @@ config HID
         tristate "Generic HID support"
         depends on INPUT
         default y
+        select HID_A4TECH if !EMBEDDED
+        select HID_APPLE if !EMBEDDED
+        select HID_BELKIN if !EMBEDDED
+        select HID_BRIGHT if !EMBEDDED
+        select HID_CHERRY if !EMBEDDED
+        select HID_CHICONY if !EMBEDDED
+        select HID_CYPRESS if !EMBEDDED
+        select HID_DELL if !EMBEDDED
+        select HID_EZKEY if !EMBEDDED
+        select HID_GYRATION if !EMBEDDED
+        select HID_LOGITECH if !EMBEDDED
+        select HID_MICROSOFT if !EMBEDDED
+        select HID_MONTEREY if !EMBEDDED
+        select HID_PANTHERLORD if !EMBEDDED
+        select HID_PETALYNX if !EMBEDDED
+        select HID_SAMSUNG if !EMBEDDED
+        select HID_SONY if !EMBEDDED
+        select HID_SUNPLUS if !EMBEDDED
+
         ---help---
           A human interface device (HID) is a type of computer device that
           interacts directly with and takes input from humans. The term "HID"
@@ -67,4 +86,206 @@ config HIDRAW
 
 source "drivers/hid/usbhid/Kconfig"
 
+menu "Special HID drivers"
+        depends on HID
+
+config HID_COMPAT
+        bool "Load all HID drivers on hid core load"
+        default y
+        ---help---
+        Compatible option for older userspace. If you have system without udev
+        support of module loading through aliases and also old
+        module-init-tools which can't handle hid bus, choose Y here. Otherwise
+        say N. If you say N and your userspace is old enough, the only
+        functionality you lose is modules autoloading.
+
+        If unsure, say Y.
+
+config HID_A4TECH
+        tristate "A4 tech"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for A4 tech X5 and WOP-35 / Trust 450L mice.
+
+config HID_APPLE
+        tristate "Apple"
+        default m
+        depends on (USB_HID || BT_HIDP)
+        ---help---
+        Support for some Apple devices which less or more break
+        HID specification.
+
+        Say Y here if you want support for the special keys (Fn, Numlock) on
+        Apple iBooks, PowerBooks, MacBooks, MacBook Pros and aluminum USB
+        keyboards.
+
+        If unsure, say M.
+
+config HID_BELKIN
+        tristate "Belkin"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Belkin Flip KVM and Wireless keyboard.
+
+config HID_BRIGHT
+        tristate "Bright"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Bright ABNT-2 keyboard.
+
+config HID_CHERRY
+        tristate "Cherry"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Cherry Cymotion.
+
+config HID_CHICONY
+        tristate "Chicony"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Chicony Tactical pad.
+
+config HID_CYPRESS
+        tristate "Cypress"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Cypress mouse and barcodes.
+
+config HID_DELL
+        tristate "Dell"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Dell W7658.
+
+config HID_EZKEY
+        tristate "Ezkey"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Ezkey mouse and barcodes.
+
+config HID_GYRATION
+        tristate "Gyration"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Gyration remote.
+
+config HID_LOGITECH
+        tristate "Logitech"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for some Logitech devices which breaks less or more
+        HID specification.
+
+config LOGITECH_FF
+        bool "Logitech force feedback"
+        depends on HID_LOGITECH
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have one of these devices:
+          - Logitech WingMan Cordless RumblePad
+          - Logitech WingMan Cordless RumblePad 2
+          - Logitech WingMan Force 3D
+          - Logitech Formula Force EX
+          - Logitech MOMO Force wheel
+
+          and if you want to enable force feedback for them.
+          Note: if you say N here, this device will still be supported, but without
+          force feedback.
+
+config LOGIRUMBLEPAD2_FF
+        bool "Logitech Rumblepad 2 force feedback"
+        depends on HID_LOGITECH
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you want to enable force feedback support for Logitech
+          Rumblepad 2 devices.
+
+config HID_MICROSOFT
+        tristate "Microsoft"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for some Microsoft devices which breaks less or more
+        HID specification.
+
+config HID_MONTEREY
+        tristate "Monterey"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Monterey Genius KB29E.
+
+config HID_PANTHERLORD
+        tristate "Pantherlord devices support"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for PantherLord/GreenAsia based device support.
+
+
+config PANTHERLORD_FF
+        bool "Pantherlord force feedback support"
+        depends on HID_PANTHERLORD
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a PantherLord/GreenAsia based game controller
+          or adapter and want to enable force feedback support for it.
+
+config HID_PETALYNX
+        tristate "Petalynx"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Petalynx Maxter remote.
+
+config HID_SAMSUNG
+        tristate "Samsung"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Samsung IR remote.
+
+config HID_SONY
+        tristate "Sony"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Sony PS3 controller.
+
+config HID_SUNPLUS
+        tristate "Sunplus"
+        default m
+        depends on USB_HID
+        ---help---
+        Support for Sunplus WDesktop input device.
+
+config THRUSTMASTER_FF
+        tristate "ThrustMaster devices support"
+        default m
+        depends on USB_HID
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
+          a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel.
+
+config ZEROPLUS_FF
+        tristate "Zeroplus based game controller support"
+        default m
+        depends on USB_HID
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you have a Zeroplus based game controller.
+
+endmenu
+
 endif # HID_SUPPORT
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 275dc522c738..b09e43e7413e 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -1,13 +1,46 @@
 #
 # Makefile for the HID driver
 #
-hid-objs                        := hid-core.o hid-input.o hid-input-quirks.o
+hid-objs                        := hid-core.o hid-input.o
 
 obj-$(CONFIG_HID)               += hid.o
 
 hid-$(CONFIG_HID_DEBUG)         += hid-debug.o
 hid-$(CONFIG_HIDRAW)            += hidraw.o
 
+ifdef CONFIG_HID_COMPAT
+obj-m                           += hid-dummy.o
+endif
+
+hid-logitech-objs               := hid-lg.o
+ifdef CONFIG_LOGITECH_FF
+        hid-logitech-objs       += hid-lgff.o
+endif
+ifdef CONFIG_LOGIRUMBLEPAD2_FF
+        hid-logitech-objs       += hid-lg2ff.o
+endif
+
+obj-$(CONFIG_HID_A4TECH)        += hid-a4tech.o
+obj-$(CONFIG_HID_APPLE)         += hid-apple.o
+obj-$(CONFIG_HID_BELKIN)        += hid-belkin.o
+obj-$(CONFIG_HID_BRIGHT)        += hid-bright.o
+obj-$(CONFIG_HID_CHERRY)        += hid-cherry.o
+obj-$(CONFIG_HID_CHICONY)       += hid-chicony.o
+obj-$(CONFIG_HID_CYPRESS)       += hid-cypress.o
+obj-$(CONFIG_HID_DELL)          += hid-dell.o
+obj-$(CONFIG_HID_EZKEY)         += hid-ezkey.o
+obj-$(CONFIG_HID_GYRATION)      += hid-gyration.o
+obj-$(CONFIG_HID_LOGITECH)      += hid-logitech.o
+obj-$(CONFIG_HID_MICROSOFT)     += hid-microsoft.o
+obj-$(CONFIG_HID_MONTEREY)      += hid-monterey.o
+obj-$(CONFIG_HID_PANTHERLORD)   += hid-pl.o
+obj-$(CONFIG_HID_PETALYNX)      += hid-petalynx.o
+obj-$(CONFIG_HID_SAMSUNG)       += hid-samsung.o
+obj-$(CONFIG_HID_SONY)          += hid-sony.o
+obj-$(CONFIG_HID_SUNPLUS)       += hid-sunplus.o
+obj-$(CONFIG_THRUSTMASTER_FF)   += hid-tmff.o
+obj-$(CONFIG_ZEROPLUS_FF)       += hid-zpff.o
+
 obj-$(CONFIG_USB_HID)           += usbhid/
 obj-$(CONFIG_USB_MOUSE)         += usbhid/
 obj-$(CONFIG_USB_KBD)           += usbhid/
diff --git a/drivers/hid/hid-a4tech.c b/drivers/hid/hid-a4tech.c
new file mode 100644
index 000000000000..ebca00e6c103
--- /dev/null
+++ b/drivers/hid/hid-a4tech.c
@@ -0,0 +1,162 @@
+/*
+ *  HID driver for some a4tech "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define A4_2WHEEL_MOUSE_HACK_7  0x01
+#define A4_2WHEEL_MOUSE_HACK_B8 0x02
+
+struct a4tech_sc {
+        unsigned long quirks;
+        unsigned int hw_wheel;
+        __s32 delayed_value;
+};
+
+static int a4_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+
+        if (usage->type == EV_REL && usage->code == REL_WHEEL)
+                set_bit(REL_HWHEEL, *bit);
+
+        if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007)
+                return -1;
+
+        return 0;
+}
+
+static int a4_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+        struct input_dev *input;
+
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+
+        input = field->hidinput->input;
+
+        if (a4->quirks & A4_2WHEEL_MOUSE_HACK_B8) {
+                if (usage->type == EV_REL && usage->code == REL_WHEEL) {
+                        a4->delayed_value = value;
+                        return 1;
+                }
+
+                if (usage->hid == 0x000100b8) {
+                        input_event(input, EV_REL, value ? REL_HWHEEL :
+                                        REL_WHEEL, a4->delayed_value);
+                        return 1;
+                }
+        }
+
+        if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007) {
+                a4->hw_wheel = !!value;
+                return 1;
+        }
+
+        if (usage->code == REL_WHEEL && a4->hw_wheel) {
+                input_event(input, usage->type, REL_HWHEEL, value);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int a4_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        struct a4tech_sc *a4;
+        int ret;
+
+        a4 = kzalloc(sizeof(*a4), GFP_KERNEL);
+        if (a4 == NULL) {
+                dev_err(&hdev->dev, "can't alloc device descriptor\n");
+                ret = -ENOMEM;
+                goto err_free;
+        }
+
+        a4->quirks = id->driver_data;
+
+        hid_set_drvdata(hdev, a4);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        kfree(a4);
+        return ret;
+}
+
+static void a4_remove(struct hid_device *hdev)
+{
+        struct a4tech_sc *a4 = hid_get_drvdata(hdev);
+
+        hid_hw_stop(hdev);
+        kfree(a4);
+}
+
+static const struct hid_device_id a4_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU),
+                .driver_data = A4_2WHEEL_MOUSE_HACK_7 },
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D),
+                .driver_data = A4_2WHEEL_MOUSE_HACK_B8 },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, a4_devices);
+
+static struct hid_driver a4_driver = {
+        .name = "a4tech",
+        .id_table = a4_devices,
+        .input_mapped = a4_input_mapped,
+        .event = a4_event,
+        .probe = a4_probe,
+        .remove = a4_remove,
+};
+
+static int a4_init(void)
+{
+        return hid_register_driver(&a4_driver);
+}
+
+static void a4_exit(void)
+{
+        hid_unregister_driver(&a4_driver);
+}
+
+module_init(a4_init);
+module_exit(a4_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(a4tech);
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
new file mode 100644
index 000000000000..fd7f896b34f7
--- /dev/null
+++ b/drivers/hid/hid-apple.c
@@ -0,0 +1,484 @@
+/*
+ *  USB HID quirks 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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#include "hid-ids.h"
+
+#define APPLE_RDESC_JIS         0x0001
+#define APPLE_IGNORE_MOUSE      0x0002
+#define APPLE_HAS_FN            0x0004
+#define APPLE_HIDDEV            0x0008
+#define APPLE_ISO_KEYBOARD      0x0010
+#define APPLE_MIGHTYMOUSE       0x0020
+#define APPLE_INVERT_HWHEEL     0x0040
+#define APPLE_IGNORE_HIDINPUT   0x0080
+#define APPLE_NUMLOCK_EMULATION 0x0100
+
+#define APPLE_FLAG_FKEY         0x01
+
+static unsigned int fnmode = 1;
+module_param(fnmode, uint, 0644);
+MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
+                "[1] = fkeyslast, 2 = fkeysfirst)");
+
+struct apple_sc {
+        unsigned long quirks;
+        unsigned int fn_on;
+        DECLARE_BITMAP(pressed_fn, KEY_CNT);
+        DECLARE_BITMAP(pressed_numlock, KEY_CNT);
+};
+
+struct apple_key_translation {
+        u16 from;
+        u16 to;
+        u8 flags;
+};
+
+static struct apple_key_translation apple_fn_keys[] = {
+        { KEY_BACKSPACE, KEY_DELETE },
+        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
+        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
+        { KEY_F3,       KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Exposé */
+        { KEY_F4,       KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
+        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
+        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
+        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
+        { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
+        { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
+        { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
+        { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
+        { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
+        { KEY_UP,       KEY_PAGEUP },
+        { KEY_DOWN,     KEY_PAGEDOWN },
+        { KEY_LEFT,     KEY_HOME },
+        { KEY_RIGHT,    KEY_END },
+        { }
+};
+
+static struct apple_key_translation powerbook_fn_keys[] = {
+        { KEY_BACKSPACE, KEY_DELETE },
+        { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
+        { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
+        { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
+        { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
+        { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
+        { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
+        { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
+        { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
+        { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
+        { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
+        { KEY_UP,       KEY_PAGEUP },
+        { KEY_DOWN,     KEY_PAGEDOWN },
+        { KEY_LEFT,     KEY_HOME },
+        { KEY_RIGHT,    KEY_END },
+        { }
+};
+
+static struct apple_key_translation powerbook_numlock_keys[] = {
+        { KEY_J,        KEY_KP1 },
+        { KEY_K,        KEY_KP2 },
+        { KEY_L,        KEY_KP3 },
+        { KEY_U,        KEY_KP4 },
+        { KEY_I,        KEY_KP5 },
+        { KEY_O,        KEY_KP6 },
+        { KEY_7,        KEY_KP7 },
+        { KEY_8,        KEY_KP8 },
+        { KEY_9,        KEY_KP9 },
+        { KEY_M,        KEY_KP0 },
+        { KEY_DOT,      KEY_KPDOT },
+        { KEY_SLASH,    KEY_KPPLUS },
+        { KEY_SEMICOLON, KEY_KPMINUS },
+        { KEY_P,        KEY_KPASTERISK },
+        { KEY_MINUS,    KEY_KPEQUAL },
+        { KEY_0,        KEY_KPSLASH },
+        { KEY_F6,       KEY_NUMLOCK },
+        { KEY_KPENTER,  KEY_KPENTER },
+        { KEY_BACKSPACE, KEY_BACKSPACE },
+        { }
+};
+
+static struct apple_key_translation apple_iso_keyboard[] = {
+        { KEY_GRAVE,    KEY_102ND },
+        { KEY_102ND,    KEY_GRAVE },
+        { }
+};
+
+static struct apple_key_translation *apple_find_translation(
+                struct apple_key_translation *table, u16 from)
+{
+        struct apple_key_translation *trans;
+
+        /* Look for the translation */
+        for (trans = table; trans->from; trans++)
+                if (trans->from == from)
+                        return trans;
+
+        return NULL;
+}
+
+static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
+                struct hid_usage *usage, __s32 value)
+{
+        struct apple_sc *asc = hid_get_drvdata(hid);
+        struct apple_key_translation *trans;
+
+        if (usage->code == KEY_FN) {
+                asc->fn_on = !!value;
+                input_event(input, usage->type, usage->code, value);
+                return 1;
+        }
+
+        if (fnmode) {
+                int do_translate;
+
+                trans = apple_find_translation((hid->product < 0x220 ||
+                                        hid->product >= 0x300) ?
+                                        powerbook_fn_keys : apple_fn_keys,
+                                        usage->code);
+                if (trans) {
+                        if (test_bit(usage->code, asc->pressed_fn))
+                                do_translate = 1;
+                        else if (trans->flags & APPLE_FLAG_FKEY)
+                                do_translate = (fnmode == 2 && asc->fn_on) ||
+                                        (fnmode == 1 && !asc->fn_on);
+                        else
+                                do_translate = asc->fn_on;
+
+                        if (do_translate) {
+                                if (value)
+                                        set_bit(usage->code, asc->pressed_fn);
+                                else
+                                        clear_bit(usage->code, asc->pressed_fn);
+
+                                input_event(input, usage->type, trans->to,
+                                                value);
+
+                                return 1;
+                        }
+                }
+
+                if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
+                                (test_bit(usage->code, asc->pressed_numlock) ||
+                                test_bit(LED_NUML, input->led))) {
+                        trans = apple_find_translation(powerbook_numlock_keys,
+                                        usage->code);
+
+                        if (trans) {
+                                if (value)
+                                        set_bit(usage->code,
+                                                        asc->pressed_numlock);
+                                else
+                                        clear_bit(usage->code,
+                                                        asc->pressed_numlock);
+
+                                input_event(input, usage->type, trans->to,
+                                                value);
+                        }
+
+                        return 1;
+                }
+        }
+
+        if (asc->quirks & APPLE_ISO_KEYBOARD) {
+                trans = apple_find_translation(apple_iso_keyboard, usage->code);
+                if (trans) {
+                        input_event(input, usage->type, trans->to, value);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+static int apple_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+
+        if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
+                        usage->code == REL_HWHEEL) {
+                input_event(field->hidinput->input, usage->type, usage->code,
+                                -value);
+                return 1;
+        }
+
+        if ((asc->quirks & APPLE_HAS_FN) &&
+                        hidinput_apple_event(hdev, field->hidinput->input,
+                                usage, value))
+                return 1;
+
+
+        return 0;
+}
+
+/*
+ * MacBook JIS keyboard has wrong logical maximum
+ */
+static void apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+
+        if ((asc->quirks & APPLE_RDESC_JIS) && rsize >= 60 &&
+                        rdesc[53] == 0x65 && rdesc[59] == 0x65) {
+                dev_info(&hdev->dev, "fixing up MacBook JIS keyboard report "
+                                "descriptor\n");
+                rdesc[53] = rdesc[59] = 0xe7;
+        }
+}
+
+static void apple_setup_input(struct input_dev *input)
+{
+        struct apple_key_translation *trans;
+
+        set_bit(KEY_NUMLOCK, input->keybit);
+
+        /* Enable all needed keys */
+        for (trans = apple_fn_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+
+        for (trans = powerbook_fn_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+
+        for (trans = powerbook_numlock_keys; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+
+        for (trans = apple_iso_keyboard; trans->from; trans++)
+                set_bit(trans->to, input->keybit);
+}
+
+static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->hid == (HID_UP_CUSTOM | 0x0003)) {
+                /* The fn key on Apple USB keyboards */
+                set_bit(EV_REP, hi->input->evbit);
+                hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
+                apple_setup_input(hi->input);
+                return 1;
+        }
+
+        /* we want the hid layer to go through standard path (set and ignore) */
+        return 0;
+}
+
+static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct apple_sc *asc = hid_get_drvdata(hdev);
+
+        if (asc->quirks & APPLE_MIGHTYMOUSE) {
+                if (usage->hid == HID_GD_Z)
+                        hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
+                else if (usage->code == BTN_1)
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
+                else if (usage->code == BTN_2)
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
+        }
+
+        return 0;
+}
+
+static int apple_probe(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        struct apple_sc *asc;
+        unsigned int connect_mask = HID_CONNECT_DEFAULT;
+        int ret;
+
+        /* return something else or move to hid layer? device will reside
+           allocated */
+        if (id->bus == BUS_USB && (quirks & APPLE_IGNORE_MOUSE) &&
+                        to_usb_interface(hdev->dev.parent)->cur_altsetting->
+                        desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
+                return -ENODEV;
+
+        asc = kzalloc(sizeof(*asc), GFP_KERNEL);
+        if (asc == NULL) {
+                dev_err(&hdev->dev, "can't alloc apple descriptor\n");
+                return -ENOMEM;
+        }
+
+        asc->quirks = quirks;
+
+        hid_set_drvdata(hdev, asc);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        if (quirks & APPLE_HIDDEV)
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+        if (quirks & APPLE_IGNORE_HIDINPUT)
+                connect_mask &= ~HID_CONNECT_HIDINPUT;
+
+        ret = hid_hw_start(hdev, connect_mask);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        kfree(asc);
+        return ret;
+}
+
+static void apple_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+}
+
+static const struct hid_device_id apple_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL),
+                .driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
+                .driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
+                .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS},
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
+                .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
+                        APPLE_IGNORE_MOUSE },
+
+        /* Apple wireless Mighty Mouse */
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c),
+                .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
+
+        { }
+};
+MODULE_DEVICE_TABLE(hid, apple_devices);
+
+static struct hid_driver apple_driver = {
+        .name = "apple",
+        .id_table = apple_devices,
+        .report_fixup = apple_report_fixup,
+        .probe = apple_probe,
+        .remove = apple_remove,
+        .event = apple_event,
+        .input_mapping = apple_input_mapping,
+        .input_mapped = apple_input_mapped,
+};
+
+static int apple_init(void)
+{
+        int ret;
+
+        ret = hid_register_driver(&apple_driver);
+        if (ret)
+                printk(KERN_ERR "can't register apple driver\n");
+
+        return ret;
+}
+
+static void apple_exit(void)
+{
+        hid_unregister_driver(&apple_driver);
+}
+
+module_init(apple_init);
+module_exit(apple_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(apple);
diff --git a/drivers/hid/hid-belkin.c b/drivers/hid/hid-belkin.c
new file mode 100644
index 000000000000..12c8a9ba6ed6
--- /dev/null
+++ b/drivers/hid/hid-belkin.c
@@ -0,0 +1,105 @@
+/*
+ *  HID driver for some belkin "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define BELKIN_HIDDEV   0x01
+#define BELKIN_WKBD     0x02
+
+#define belkin_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int belkin_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER ||
+                        !(quirks & BELKIN_WKBD))
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x03a: belkin_map_key_clear(KEY_SOUND);            break;
+        case 0x03b: belkin_map_key_clear(KEY_CAMERA);           break;
+        case 0x03c: belkin_map_key_clear(KEY_DOCUMENTS);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int belkin_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+
+        hid_set_drvdata(hdev, (void *)quirks);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
+                ((quirks & BELKIN_HIDDEV) ? HID_CONNECT_HIDDEV_FORCE : 0));
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id belkin_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM),
+                .driver_data = BELKIN_HIDDEV },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD),
+                .driver_data = BELKIN_WKBD },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, belkin_devices);
+
+static struct hid_driver belkin_driver = {
+        .name = "belkin",
+        .id_table = belkin_devices,
+        .input_mapping = belkin_input_mapping,
+        .probe = belkin_probe,
+};
+
+static int belkin_init(void)
+{
+        return hid_register_driver(&belkin_driver);
+}
+
+static void belkin_exit(void)
+{
+        hid_unregister_driver(&belkin_driver);
+}
+
+module_init(belkin_init);
+module_exit(belkin_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(belkin);
diff --git a/drivers/hid/hid-bright.c b/drivers/hid/hid-bright.c
new file mode 100644
index 000000000000..38517a117dfd
--- /dev/null
+++ b/drivers/hid/hid-bright.c
@@ -0,0 +1,71 @@
+/*
+ *  HID driver for some bright "special" devices
+ *
+ *  Copyright (c) 2008 Mauro Carvalho Chehab <mchehab@redhat.com>
+ *
+ * Based on hid-dell driver
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+static int bright_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        usbhid_set_leds(hdev);
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id bright_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, bright_devices);
+
+static struct hid_driver bright_driver = {
+        .name = "bright",
+        .id_table = bright_devices,
+        .probe = bright_probe,
+};
+
+static int bright_init(void)
+{
+        return hid_register_driver(&bright_driver);
+}
+
+static void bright_exit(void)
+{
+        hid_unregister_driver(&bright_driver);
+}
+
+module_init(bright_init);
+module_exit(bright_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(bright);
diff --git a/drivers/hid/hid-cherry.c b/drivers/hid/hid-cherry.c
new file mode 100644
index 000000000000..b833b9769aba
--- /dev/null
+++ b/drivers/hid/hid-cherry.c
@@ -0,0 +1,87 @@
+/*
+ *  HID driver for some cherry "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+/*
+ * Cherry Cymotion keyboard have an invalid HID report descriptor,
+ * that needs fixing before we can parse it.
+ */
+static void ch_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) {
+                dev_info(&hdev->dev, "fixing up Cherry Cymotion report "
+                                "descriptor\n");
+                rdesc[11] = rdesc[16] = 0xff;
+                rdesc[12] = rdesc[17] = 0x03;
+        }
+}
+
+#define ch_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x301: ch_map_key_clear(KEY_PROG1);        break;
+        case 0x302: ch_map_key_clear(KEY_PROG2);        break;
+        case 0x303: ch_map_key_clear(KEY_PROG3);        break;
+        default:
+                return 0;
+        }
+
+        return 1;
+}
+
+static const struct hid_device_id ch_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ch_devices);
+
+static struct hid_driver ch_driver = {
+        .name = "cherry",
+        .id_table = ch_devices,
+        .report_fixup = ch_report_fixup,
+        .input_mapping = ch_input_mapping,
+};
+
+static int ch_init(void)
+{
+        return hid_register_driver(&ch_driver);
+}
+
+static void ch_exit(void)
+{
+        hid_unregister_driver(&ch_driver);
+}
+
+module_init(ch_init);
+module_exit(ch_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(cherry);
diff --git a/drivers/hid/hid-chicony.c b/drivers/hid/hid-chicony.c
new file mode 100644
index 000000000000..a54d4096e0f7
--- /dev/null
+++ b/drivers/hid/hid-chicony.c
@@ -0,0 +1,80 @@
+/*
+ *  HID driver for some chicony "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define ch_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
+                return 0;
+
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        case 0xff01: ch_map_key_clear(BTN_1);   break;
+        case 0xff02: ch_map_key_clear(BTN_2);   break;
+        case 0xff03: ch_map_key_clear(BTN_3);   break;
+        case 0xff04: ch_map_key_clear(BTN_4);   break;
+        case 0xff05: ch_map_key_clear(BTN_5);   break;
+        case 0xff06: ch_map_key_clear(BTN_6);   break;
+        case 0xff07: ch_map_key_clear(BTN_7);   break;
+        case 0xff08: ch_map_key_clear(BTN_8);   break;
+        case 0xff09: ch_map_key_clear(BTN_9);   break;
+        case 0xff0a: ch_map_key_clear(BTN_A);   break;
+        case 0xff0b: ch_map_key_clear(BTN_B);   break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static const struct hid_device_id ch_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ch_devices);
+
+static struct hid_driver ch_driver = {
+        .name = "chicony",
+        .id_table = ch_devices,
+        .input_mapping = ch_input_mapping,
+};
+
+static int ch_init(void)
+{
+        return hid_register_driver(&ch_driver);
+}
+
+static void ch_exit(void)
+{
+        hid_unregister_driver(&ch_driver);
+}
+
+module_init(ch_init);
+module_exit(ch_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(chicony);
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 426ac5add585..8a7d9dbb4d07 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -33,6 +33,8 @@
 #include <linux/hid-debug.h>
 #include <linux/hidraw.h>
 
+#include "hid-ids.h"
+
 /*
  * Version Information
  */
@@ -268,9 +270,9 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
 static u32 item_udata(struct hid_item *item)
 {
         switch (item->size) {
-                case 1: return item->data.u8;
-                case 2: return item->data.u16;
-                case 4: return item->data.u32;
+        case 1: return item->data.u8;
+        case 2: return item->data.u16;
+        case 4: return item->data.u32;
         }
         return 0;
 }
@@ -278,9 +280,9 @@ static u32 item_udata(struct hid_item *item)
 static s32 item_sdata(struct hid_item *item)
 {
         switch (item->size) {
-                case 1: return item->data.s8;
-                case 2: return item->data.s16;
-                case 4: return item->data.s32;
+        case 1: return item->data.s8;
+        case 2: return item->data.s16;
+        case 4: return item->data.s32;
         }
         return 0;
 }
@@ -292,87 +294,91 @@ static s32 item_sdata(struct hid_item *item)
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
         switch (item->tag) {
+        case HID_GLOBAL_ITEM_TAG_PUSH:
 
-                case HID_GLOBAL_ITEM_TAG_PUSH:
-
-                        if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
-                                dbg_hid("global enviroment stack overflow\n");
-                                return -1;
-                        }
+                if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
+                        dbg_hid("global enviroment stack overflow\n");
+                        return -1;
+                }
 
-                        memcpy(parser->global_stack + parser->global_stack_ptr++,
-                                &parser->global, sizeof(struct hid_global));
-                        return 0;
+                memcpy(parser->global_stack + parser->global_stack_ptr++,
+                        &parser->global, sizeof(struct hid_global));
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_POP:
+        case HID_GLOBAL_ITEM_TAG_POP:
 
-                        if (!parser->global_stack_ptr) {
-                                dbg_hid("global enviroment stack underflow\n");
-                                return -1;
-                        }
-
-                        memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
-                                sizeof(struct hid_global));
-                        return 0;
+                if (!parser->global_stack_ptr) {
+                        dbg_hid("global enviroment stack underflow\n");
+                        return -1;
+                }
 
-                case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
-                        parser->global.usage_page = item_udata(item);
-                        return 0;
+                memcpy(&parser->global, parser->global_stack +
+                        --parser->global_stack_ptr, sizeof(struct hid_global));
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
-                        parser->global.logical_minimum = item_sdata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
+                parser->global.usage_page = item_udata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
-                        if (parser->global.logical_minimum < 0)
-                                parser->global.logical_maximum = item_sdata(item);
-                        else
-                                parser->global.logical_maximum = item_udata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
+                parser->global.logical_minimum = item_sdata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
-                        parser->global.physical_minimum = item_sdata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
+                if (parser->global.logical_minimum < 0)
+                        parser->global.logical_maximum = item_sdata(item);
+                else
+                        parser->global.logical_maximum = item_udata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
-                        if (parser->global.physical_minimum < 0)
-                                parser->global.physical_maximum = item_sdata(item);
-                        else
-                                parser->global.physical_maximum = item_udata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
+                parser->global.physical_minimum = item_sdata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
-                        parser->global.unit_exponent = item_sdata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
+                if (parser->global.physical_minimum < 0)
+                        parser->global.physical_maximum = item_sdata(item);
+                else
+                        parser->global.physical_maximum = item_udata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_UNIT:
-                        parser->global.unit = item_udata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
+                parser->global.unit_exponent = item_sdata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
-                        if ((parser->global.report_size = item_udata(item)) > 32) {
-                                dbg_hid("invalid report_size %d\n", parser->global.report_size);
-                                return -1;
-                        }
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_UNIT:
+                parser->global.unit = item_udata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
-                        if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
-                                dbg_hid("invalid report_count %d\n", parser->global.report_count);
-                                return -1;
-                        }
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
+                parser->global.report_size = item_udata(item);
+                if (parser->global.report_size > 32) {
+                        dbg_hid("invalid report_size %d\n",
+                                        parser->global.report_size);
+                        return -1;
+                }
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_REPORT_ID:
-                        if ((parser->global.report_id = item_udata(item)) == 0) {
-                                dbg_hid("report_id 0 is invalid\n");
-                                return -1;
-                        }
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
+                parser->global.report_count = item_udata(item);
+                if (parser->global.report_count > HID_MAX_USAGES) {
+                        dbg_hid("invalid report_count %d\n",
+                                        parser->global.report_count);
+                        return -1;
+                }
+                return 0;
 
-                default:
-                        dbg_hid("unknown global tag 0x%x\n", item->tag);
+        case HID_GLOBAL_ITEM_TAG_REPORT_ID:
+                parser->global.report_id = item_udata(item);
+                if (parser->global.report_id == 0) {
+                        dbg_hid("report_id 0 is invalid\n");
                         return -1;
+                }
+                return 0;
+
+        default:
+                dbg_hid("unknown global tag 0x%x\n", item->tag);
+                return -1;
         }
 }
 
@@ -393,77 +399,76 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
         data = item_udata(item);
 
         switch (item->tag) {
-
-                case HID_LOCAL_ITEM_TAG_DELIMITER:
-
-                        if (data) {
-                                /*
-                                 * We treat items before the first delimiter
-                                 * as global to all usage sets (branch 0).
-                                 * In the moment we process only these global
-                                 * items and the first delimiter set.
-                                 */
-                                if (parser->local.delimiter_depth != 0) {
-                                        dbg_hid("nested delimiters\n");
-                                        return -1;
-                                }
-                                parser->local.delimiter_depth++;
-                                parser->local.delimiter_branch++;
-                        } else {
-                                if (parser->local.delimiter_depth < 1) {
-                                        dbg_hid("bogus close delimiter\n");
-                                        return -1;
-                                }
-                                parser->local.delimiter_depth--;
+        case HID_LOCAL_ITEM_TAG_DELIMITER:
+
+                if (data) {
+                        /*
+                         * We treat items before the first delimiter
+                         * as global to all usage sets (branch 0).
+                         * In the moment we process only these global
+                         * items and the first delimiter set.
+                         */
+                        if (parser->local.delimiter_depth != 0) {
+                                dbg_hid("nested delimiters\n");
+                                return -1;
                         }
-                        return 1;
-
-                case HID_LOCAL_ITEM_TAG_USAGE:
-
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
+                        parser->local.delimiter_depth++;
+                        parser->local.delimiter_branch++;
+                } else {
+                        if (parser->local.delimiter_depth < 1) {
+                                dbg_hid("bogus close delimiter\n");
+                                return -1;
                         }
+                        parser->local.delimiter_depth--;
+                }
+                return 1;
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE:
 
-                        return hid_add_usage(parser, data);
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
+                        return 0;
+                }
 
-                case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
-                        }
+                return hid_add_usage(parser, data);
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 
-                        parser->local.usage_minimum = data;
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
                         return 0;
+                }
 
-                case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
-                        }
+                parser->local.usage_minimum = data;
+                return 0;
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 
-                        for (n = parser->local.usage_minimum; n <= data; n++)
-                                if (hid_add_usage(parser, n)) {
-                                        dbg_hid("hid_add_usage failed\n");
-                                        return -1;
-                                }
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
                         return 0;
+                }
 
-                default:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        dbg_hid("unknown local item tag 0x%x\n", item->tag);
-                        return 0;
+                for (n = parser->local.usage_minimum; n <= data; n++)
+                        if (hid_add_usage(parser, n)) {
+                                dbg_hid("hid_add_usage failed\n");
+                                return -1;
+                        }
+                return 0;
+
+        default:
+
+                dbg_hid("unknown local item tag 0x%x\n", item->tag);
+                return 0;
         }
         return 0;
 }
@@ -480,24 +485,24 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
         data = item_udata(item);
 
         switch (item->tag) {
-                case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
-                        ret = open_collection(parser, data & 0xff);
-                        break;
-                case HID_MAIN_ITEM_TAG_END_COLLECTION:
-                        ret = close_collection(parser);
-                        break;
-                case HID_MAIN_ITEM_TAG_INPUT:
-                        ret = hid_add_field(parser, HID_INPUT_REPORT, data);
-                        break;
-                case HID_MAIN_ITEM_TAG_OUTPUT:
-                        ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
-                        break;
-                case HID_MAIN_ITEM_TAG_FEATURE:
-                        ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
-                        break;
-                default:
-                        dbg_hid("unknown main item tag 0x%x\n", item->tag);
-                        ret = 0;
+        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
+                ret = open_collection(parser, data & 0xff);
+                break;
+        case HID_MAIN_ITEM_TAG_END_COLLECTION:
+                ret = close_collection(parser);
+                break;
+        case HID_MAIN_ITEM_TAG_INPUT:
+                ret = hid_add_field(parser, HID_INPUT_REPORT, data);
+                break;
+        case HID_MAIN_ITEM_TAG_OUTPUT:
+                ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
+                break;
+        case HID_MAIN_ITEM_TAG_FEATURE:
+                ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
+                break;
+        default:
+                dbg_hid("unknown main item tag 0x%x\n", item->tag);
+                ret = 0;
         }
 
         memset(&parser->local, 0, sizeof(parser->local));       /* Reset the local parser environment */
@@ -534,9 +539,10 @@ static void hid_free_report(struct hid_report *report)
  * Free a device structure, all reports, and all fields.
  */
 
-void hid_free_device(struct hid_device *device)
+static void hid_device_release(struct device *dev)
 {
-        unsigned i,j;
+        struct hid_device *device = container_of(dev, struct hid_device, dev);
+        unsigned i, j;
 
         for (i = 0; i < HID_REPORT_TYPES; i++) {
                 struct hid_report_enum *report_enum = device->report_enum + i;
@@ -552,7 +558,6 @@ void hid_free_device(struct hid_device *device)
         kfree(device->collection);
         kfree(device);
 }
-EXPORT_SYMBOL_GPL(hid_free_device);
 
 /*
  * Fetch a report description item from the data stream. We support long
@@ -593,47 +598,52 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
         item->size = b & 3;
 
         switch (item->size) {
+        case 0:
+                return start;
 
-                case 0:
-                        return start;
-
-                case 1:
-                        if ((end - start) < 1)
-                                return NULL;
-                        item->data.u8 = *start++;
-                        return start;
+        case 1:
+                if ((end - start) < 1)
+                        return NULL;
+                item->data.u8 = *start++;
+                return start;
 
-                case 2:
-                        if ((end - start) < 2)
-                                return NULL;
-                        item->data.u16 = get_unaligned_le16(start);
-                        start = (__u8 *)((__le16 *)start + 1);
-                        return start;
+        case 2:
+                if ((end - start) < 2)
+                        return NULL;
+                item->data.u16 = get_unaligned_le16(start);
+                start = (__u8 *)((__le16 *)start + 1);
+                return start;
 
-                case 3:
-                        item->size++;
-                        if ((end - start) < 4)
-                                return NULL;
-                        item->data.u32 = get_unaligned_le32(start);
-                        start = (__u8 *)((__le32 *)start + 1);
-                        return start;
+        case 3:
+                item->size++;
+                if ((end - start) < 4)
+                        return NULL;
+                item->data.u32 = get_unaligned_le32(start);
+                start = (__u8 *)((__le32 *)start + 1);
+                return start;
         }
 
         return NULL;
 }
 
-/*
+/**
+ * hid_parse_report - parse device report
+ *
+ * @device: hid device
+ * @start: report start
+ * @size: report size
+ *
  * Parse a report description into a hid_device structure. Reports are
  * enumerated, fields are attached to these reports.
+ * 0 returned on success, otherwise nonzero error value.
  */
-
-struct hid_device *hid_parse_report(__u8 *start, unsigned size)
+int hid_parse_report(struct hid_device *device, __u8 *start,
+                unsigned size)
 {
-        struct hid_device *device;
         struct hid_parser *parser;
         struct hid_item item;
         __u8 *end;
-        unsigned i;
+        int ret;
         static int (*dispatch_type[])(struct hid_parser *parser,
                                       struct hid_item *item) = {
                 hid_parser_main,
@@ -642,76 +652,57 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
                 hid_parser_reserved
         };
 
-        if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
-                return NULL;
+        if (device->driver->report_fixup)
+                device->driver->report_fixup(device, start, size);
 
-        if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
-                                   HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
-                kfree(device);
-                return NULL;
-        }
-        device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
-
-        for (i = 0; i < HID_REPORT_TYPES; i++)
-                INIT_LIST_HEAD(&device->report_enum[i].report_list);
-
-        if (!(device->rdesc = kmalloc(size, GFP_KERNEL))) {
-                kfree(device->collection);
-                kfree(device);
-                return NULL;
-        }
+        device->rdesc = kmalloc(size, GFP_KERNEL);
+        if (device->rdesc == NULL)
+                return -ENOMEM;
         memcpy(device->rdesc, start, size);
         device->rsize = size;
 
-        if (!(parser = vmalloc(sizeof(struct hid_parser)))) {
-                kfree(device->rdesc);
-                kfree(device->collection);
-                kfree(device);
-                return NULL;
+        parser = vmalloc(sizeof(struct hid_parser));
+        if (!parser) {
+                ret = -ENOMEM;
+                goto err;
         }
+
         memset(parser, 0, sizeof(struct hid_parser));
         parser->device = device;
 
         end = start + size;
+        ret = -EINVAL;
         while ((start = fetch_item(start, end, &item)) != NULL) {
 
                 if (item.format != HID_ITEM_FORMAT_SHORT) {
                         dbg_hid("unexpected long global item\n");
-                        hid_free_device(device);
-                        vfree(parser);
-                        return NULL;
+                        goto err;
                 }
 
                 if (dispatch_type[item.type](parser, &item)) {
                         dbg_hid("item %u %u %u %u parsing failed\n",
                                 item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
-                        hid_free_device(device);
-                        vfree(parser);
-                        return NULL;
+                        goto err;
                 }
 
                 if (start == end) {
                         if (parser->collection_stack_ptr) {
                                 dbg_hid("unbalanced collection at end of report description\n");
-                                hid_free_device(device);
-                                vfree(parser);
-                                return NULL;
+                                goto err;
                         }
                         if (parser->local.delimiter_depth) {
                                 dbg_hid("unbalanced delimiter at end of report description\n");
-                                hid_free_device(device);
-                                vfree(parser);
-                                return NULL;
+                                goto err;
                         }
                         vfree(parser);
-                        return device;
+                        return 0;
                 }
         }
 
         dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
-        hid_free_device(device);
+err:
         vfree(parser);
-        return NULL;
+        return ret;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
 
@@ -724,9 +715,9 @@ EXPORT_SYMBOL_GPL(hid_parse_report);
 static s32 snto32(__u32 value, unsigned n)
 {
         switch (n) {
-                case 8:  return ((__s8)value);
-                case 16: return ((__s16)value);
-                case 32: return ((__s32)value);
+        case 8:  return ((__s8)value);
+        case 16: return ((__s16)value);
+        case 32: return ((__s32)value);
         }
         return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
@@ -815,9 +806,73 @@ static __inline__ int search(__s32 *array, __s32 value, unsigned n)
         return -1;
 }
 
-static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt)
+/**
+ * hid_match_report - check if driver's raw_event should be called
+ *
+ * @hid: hid device
+ * @report_type: type to match against
+ *
+ * compare hid->driver->report_table->report_type to report->type
+ */
+static int hid_match_report(struct hid_device *hid, struct hid_report *report)
+{
+        const struct hid_report_id *id = hid->driver->report_table;
+
+        if (!id) /* NULL means all */
+                return 1;
+
+        for (; id->report_type != HID_TERMINATOR; id++)
+                if (id->report_type == HID_ANY_ID ||
+                                id->report_type == report->type)
+                        return 1;
+        return 0;
+}
+
+/**
+ * hid_match_usage - check if driver's event should be called
+ *
+ * @hid: hid device
+ * @usage: usage to match against
+ *
+ * compare hid->driver->usage_table->usage_{type,code} to
+ * usage->usage_{type,code}
+ */
+static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
 {
+        const struct hid_usage_id *id = hid->driver->usage_table;
+
+        if (!id) /* NULL means all */
+                return 1;
+
+        for (; id->usage_type != HID_ANY_ID - 1; id++)
+                if ((id->usage_hid == HID_ANY_ID ||
+                                id->usage_hid == usage->hid) &&
+                                (id->usage_type == HID_ANY_ID ||
+                                id->usage_type == usage->type) &&
+                                (id->usage_code == HID_ANY_ID ||
+                                 id->usage_code == usage->code))
+                        return 1;
+        return 0;
+}
+
+static void hid_process_event(struct hid_device *hid, struct hid_field *field,
+                struct hid_usage *usage, __s32 value, int interrupt)
+{
+        struct hid_driver *hdrv = hid->driver;
+        int ret;
+
         hid_dump_input(usage, value);
+
+        if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
+                ret = hdrv->event(hid, field, usage, value);
+                if (ret != 0) {
+                        if (ret < 0)
+                                dbg_hid("%s's event failed with %d\n",
+                                                hdrv->name, ret);
+                        return;
+                }
+        }
+
         if (hid->claimed & HID_CLAIMED_INPUT)
                 hidinput_hid_event(hid, field, usage, value);
         if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
@@ -946,44 +1001,47 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
 
-int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
+                const u8 *data)
 {
-        struct hid_report_enum *report_enum = hid->report_enum + type;
         struct hid_report *report;
-        int n, rsize, i;
+        unsigned int n = 0;     /* Normally report number is 0 */
 
-        if (!hid)
-                return -ENODEV;
+        /* Device uses numbered reports, data[0] is report number */
+        if (report_enum->numbered)
+                n = *data;
 
-        if (!size) {
-                dbg_hid("empty report\n");
-                return -1;
-        }
+        report = report_enum->report_id_hash[n];
+        if (report == NULL)
+                dbg_hid("undefined report_id %u received\n", n);
 
-        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+        return report;
+}
 
-        n = 0;                          /* Normally report number is 0 */
-        if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
-                n = *data++;
-                size--;
-        }
+void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
+                int interrupt)
+{
+        struct hid_report_enum *report_enum = hid->report_enum + type;
+        struct hid_report *report;
+        unsigned int a;
+        int rsize, csize = size;
+        u8 *cdata = data;
 
-        /* dump the report */
-        dbg_hid("report %d (size %u) = ", n, size);
-        for (i = 0; i < size; i++)
-                dbg_hid_line(" %02x", data[i]);
-        dbg_hid_line("\n");
+        report = hid_get_report(report_enum, data);
+        if (!report)
+                return;
 
-        if (!(report = report_enum->report_id_hash[n])) {
-                dbg_hid("undefined report_id %d received\n", n);
-                return -1;
+        if (report_enum->numbered) {
+                cdata++;
+                csize--;
         }
 
         rsize = ((report->size - 1) >> 3) + 1;
 
-        if (size < rsize) {
-                dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
-                memset(data + size, 0, rsize - size);
+        if (csize < rsize) {
+                dbg_hid("report %d is too short, (%d < %d)\n", report->id,
+                                csize, rsize);
+                memset(cdata + csize, 0, rsize - csize);
         }
 
         if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
@@ -996,24 +1054,661 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                         hidraw_report_event(hid, data, size);
         }
 
-        for (n = 0; n < report->maxfield; n++)
-                hid_input_field(hid, report->field[n], data, interrupt);
+        for (a = 0; a < report->maxfield; a++)
+                hid_input_field(hid, report->field[a], cdata, interrupt);
 
         if (hid->claimed & HID_CLAIMED_INPUT)
                 hidinput_report_event(hid, report);
+}
+EXPORT_SYMBOL_GPL(hid_report_raw_event);
+
+/**
+ * hid_input_report - report data from lower layer (usb, bt...)
+ *
+ * @hid: hid device
+ * @type: HID report type (HID_*_REPORT)
+ * @data: report contents
+ * @size: size of data parameter
+ * @interrupt: called from atomic?
+ *
+ * This is data entry for lower layers.
+ */
+int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+{
+        struct hid_report_enum *report_enum = hid->report_enum + type;
+        struct hid_driver *hdrv = hid->driver;
+        struct hid_report *report;
+        unsigned int i;
+        int ret;
+
+        if (!hid || !hid->driver)
+                return -ENODEV;
+
+        if (!size) {
+                dbg_hid("empty report\n");
+                return -1;
+        }
+
+        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+
+        report = hid_get_report(report_enum, data);
+        if (!report)
+                return -1;
+
+        /* dump the report */
+        dbg_hid("report %d (size %u) = ", report->id, size);
+        for (i = 0; i < size; i++)
+                dbg_hid_line(" %02x", data[i]);
+        dbg_hid_line("\n");
+
+        if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
+                ret = hdrv->raw_event(hid, report, data, size);
+                if (ret != 0)
+                        return ret < 0 ? ret : 0;
+        }
+
+        hid_report_raw_event(hid, type, data, size, interrupt);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
 
+static bool hid_match_one_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        return id->bus == hdev->bus &&
+                (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
+                (id->product == HID_ANY_ID || id->product == hdev->product);
+}
+
+static const struct hid_device_id *hid_match_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        for (; id->bus; id++)
+                if (hid_match_one_id(hdev, id))
+                        return id;
+
+        return NULL;
+}
+
+static const struct hid_device_id hid_hiddev_list[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
+        { }
+};
+
+static bool hid_hiddev(struct hid_device *hdev)
+{
+        return !!hid_match_id(hdev, hid_hiddev_list);
+}
+
+int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
+{
+        static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
+                "Joystick", "Gamepad", "Keyboard", "Keypad",
+                "Multi-Axis Controller"
+        };
+        const char *type, *bus;
+        char buf[64];
+        unsigned int i;
+        int len;
+
+        if (hdev->bus != BUS_USB)
+                connect_mask &= ~HID_CONNECT_HIDDEV;
+        if (hid_hiddev(hdev))
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+
+        if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDINPUT_FORCE))
+                hdev->claimed |= HID_CLAIMED_INPUT;
+        if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
+                        !hdev->hiddev_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDDEV_FORCE))
+                hdev->claimed |= HID_CLAIMED_HIDDEV;
+        if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
+                hdev->claimed |= HID_CLAIMED_HIDRAW;
+
+        if (!hdev->claimed) {
+                dev_err(&hdev->dev, "claimed by neither input, hiddev nor "
+                                "hidraw\n");
+                return -ENODEV;
+        }
+
+        if ((hdev->claimed & HID_CLAIMED_INPUT) &&
+                        (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
+                hdev->ff_init(hdev);
+
+        len = 0;
+        if (hdev->claimed & HID_CLAIMED_INPUT)
+                len += sprintf(buf + len, "input");
+        if (hdev->claimed & HID_CLAIMED_HIDDEV)
+                len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
+                                hdev->minor);
+        if (hdev->claimed & HID_CLAIMED_HIDRAW)
+                len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
+                                ((struct hidraw *)hdev->hidraw)->minor);
+
+        type = "Device";
+        for (i = 0; i < hdev->maxcollection; i++) {
+                struct hid_collection *col = &hdev->collection[i];
+                if (col->type == HID_COLLECTION_APPLICATION &&
+                   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
+                   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
+                        type = types[col->usage & 0xffff];
+                        break;
+                }
+        }
+
+        switch (hdev->bus) {
+        case BUS_USB:
+                bus = "USB";
+                break;
+        case BUS_BLUETOOTH:
+                bus = "BLUETOOTH";
+                break;
+        default:
+                bus = "<UNKNOWN>";
+        }
+
+        dev_info(&hdev->dev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
+                        buf, bus, hdev->version >> 8, hdev->version & 0xff,
+                        type, hdev->name, hdev->phys);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(hid_connect);
+
+static const struct hid_device_id hid_blacklist[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_BRIGHT, USB_DEVICE_ID_BRIGHT_ABNT2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
+
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
+        { }
+};
+
+static int hid_bus_match(struct device *dev, struct device_driver *drv)
+{
+        struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+
+        if (!hid_match_id(hdev, hdrv->id_table))
+                return 0;
+
+        /* generic wants all non-blacklisted */
+        if (!strncmp(hdrv->name, "generic-", 8))
+                return !hid_match_id(hdev, hid_blacklist);
+
+        return 1;
+}
+
+static int hid_device_probe(struct device *dev)
+{
+        struct hid_driver *hdrv = container_of(dev->driver,
+                        struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        const struct hid_device_id *id;
+        int ret = 0;
+
+        if (!hdev->driver) {
+                id = hid_match_id(hdev, hdrv->id_table);
+                if (id == NULL)
+                        return -ENODEV;
+
+                hdev->driver = hdrv;
+                if (hdrv->probe) {
+                        ret = hdrv->probe(hdev, id);
+                } else { /* default probe */
+                        ret = hid_parse(hdev);
+                        if (!ret)
+                                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+                }
+                if (ret)
+                        hdev->driver = NULL;
+        }
+        return ret;
+}
+
+static int hid_device_remove(struct device *dev)
+{
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        struct hid_driver *hdrv = hdev->driver;
+
+        if (hdrv) {
+                if (hdrv->remove)
+                        hdrv->remove(hdev);
+                else /* default remove */
+                        hid_hw_stop(hdev);
+                hdev->driver = NULL;
+        }
+
+        return 0;
+}
+
+static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+
+        if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
+                        hdev->bus, hdev->vendor, hdev->product))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",
+                        hdev->bus, hdev->vendor, hdev->product))
+                return -ENOMEM;
+
+        return 0;
+}
+
+static struct bus_type hid_bus_type = {
+        .name           = "hid",
+        .match          = hid_bus_match,
+        .probe          = hid_device_probe,
+        .remove         = hid_device_remove,
+        .uevent         = hid_uevent,
+};
+
+static const struct hid_device_id hid_ignore_list[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+        { }
+};
+
+static bool hid_ignore(struct hid_device *hdev)
+{
+        switch (hdev->vendor) {
+        case USB_VENDOR_ID_CODEMERCS:
+                /* ignore all Code Mercenaries IOWarrior devices */
+                if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
+                                hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
+                        return true;
+                break;
+        case USB_VENDOR_ID_LOGITECH:
+                if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&
+                                hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
+                        return true;
+                break;
+        }
+
+        return !!hid_match_id(hdev, hid_ignore_list);
+}
+
+int hid_add_device(struct hid_device *hdev)
+{
+        static atomic_t id = ATOMIC_INIT(0);
+        int ret;
+
+        if (WARN_ON(hdev->status & HID_STAT_ADDED))
+                return -EBUSY;
+
+        /* we need to kill them here, otherwise they will stay allocated to
+         * wait for coming driver */
+        if (hid_ignore(hdev))
+                return -ENODEV;
+
+        /* XXX hack, any other cleaner solution < 20 bus_id bytes? */
+        sprintf(hdev->dev.bus_id, "%04X:%04X:%04X.%04X", hdev->bus,
+                        hdev->vendor, hdev->product, atomic_inc_return(&id));
+
+        ret = device_add(&hdev->dev);
+        if (!ret)
+                hdev->status |= HID_STAT_ADDED;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(hid_add_device);
+
+/**
+ * hid_allocate_device - allocate new hid device descriptor
+ *
+ * Allocate and initialize hid device, so that hid_destroy_device might be
+ * used to free it.
+ *
+ * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
+ * error value.
+ */
+struct hid_device *hid_allocate_device(void)
+{
+        struct hid_device *hdev;
+        unsigned int i;
+        int ret = -ENOMEM;
+
+        hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
+        if (hdev == NULL)
+                return ERR_PTR(ret);
+
+        device_initialize(&hdev->dev);
+        hdev->dev.release = hid_device_release;
+        hdev->dev.bus = &hid_bus_type;
+
+        hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
+                        sizeof(struct hid_collection), GFP_KERNEL);
+        if (hdev->collection == NULL)
+                goto err;
+        hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
+
+        for (i = 0; i < HID_REPORT_TYPES; i++)
+                INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
+
+        return hdev;
+err:
+        put_device(&hdev->dev);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(hid_allocate_device);
+
+static void hid_remove_device(struct hid_device *hdev)
+{
+        if (hdev->status & HID_STAT_ADDED) {
+                device_del(&hdev->dev);
+                hdev->status &= ~HID_STAT_ADDED;
+        }
+}
+
+/**
+ * hid_destroy_device - free previously allocated device
+ *
+ * @hdev: hid device
+ *
+ * If you allocate hid_device through hid_allocate_device, you should ever
+ * free by this function.
+ */
+void hid_destroy_device(struct hid_device *hdev)
+{
+        hid_remove_device(hdev);
+        put_device(&hdev->dev);
+}
+EXPORT_SYMBOL_GPL(hid_destroy_device);
+
+int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
+                const char *mod_name)
+{
+        hdrv->driver.name = hdrv->name;
+        hdrv->driver.bus = &hid_bus_type;
+        hdrv->driver.owner = owner;
+        hdrv->driver.mod_name = mod_name;
+
+        return driver_register(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(__hid_register_driver);
+
+void hid_unregister_driver(struct hid_driver *hdrv)
+{
+        driver_unregister(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(hid_unregister_driver);
+
+#ifdef CONFIG_HID_COMPAT
+static void hid_compat_load(struct work_struct *ws)
+{
+        request_module("hid-dummy");
+}
+static DECLARE_WORK(hid_compat_work, hid_compat_load);
+static struct workqueue_struct *hid_compat_wq;
+#endif
+
 static int __init hid_init(void)
 {
-        return hidraw_init();
+        int ret;
+
+        ret = bus_register(&hid_bus_type);
+        if (ret) {
+                printk(KERN_ERR "HID: can't register hid bus\n");
+                goto err;
+        }
+
+        ret = hidraw_init();
+        if (ret)
+                goto err_bus;
+
+#ifdef CONFIG_HID_COMPAT
+        hid_compat_wq = create_workqueue("hid_compat");
+        if (!hid_compat_wq) {
+                hidraw_exit();
+                goto err;
+        }
+        queue_work(hid_compat_wq, &hid_compat_work);
+#endif
+
+        return 0;
+err_bus:
+        bus_unregister(&hid_bus_type);
+err:
+        return ret;
 }
 
 static void __exit hid_exit(void)
 {
+#ifdef CONFIG_HID_COMPAT
+        destroy_workqueue(hid_compat_wq);
+#endif
         hidraw_exit();
+        bus_unregister(&hid_bus_type);
 }
 
 module_init(hid_init);
diff --git a/drivers/hid/hid-cypress.c b/drivers/hid/hid-cypress.c
new file mode 100644
index 000000000000..5d69d27b935d
--- /dev/null
+++ b/drivers/hid/hid-cypress.c
@@ -0,0 +1,158 @@
+/*
+ *  HID driver for some cypress "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define CP_RDESC_SWAPPED_MIN_MAX        0x01
+#define CP_2WHEEL_MOUSE_HACK            0x02
+#define CP_2WHEEL_MOUSE_HACK_ON         0x04
+
+/*
+ * Some USB barcode readers from cypress have usage min and usage max in
+ * the wrong order
+ */
+static void cp_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        unsigned int i;
+
+        if (!(quirks & CP_RDESC_SWAPPED_MIN_MAX))
+                return;
+
+        for (i = 0; i < rsize - 4; i++)
+                if (rdesc[i] == 0x29 && rdesc[i + 2] == 0x19) {
+                        __u8 tmp;
+
+                        rdesc[i] = 0x19;
+                        rdesc[i + 2] = 0x29;
+                        tmp = rdesc[i + 3];
+                        rdesc[i + 3] = rdesc[i + 1];
+                        rdesc[i + 1] = tmp;
+                }
+}
+
+static int cp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if (!(quirks & CP_2WHEEL_MOUSE_HACK))
+                return 0;
+
+        if (usage->type == EV_REL && usage->code == REL_WHEEL)
+                set_bit(REL_HWHEEL, *bit);
+        if (usage->hid == 0x00090005)
+                return -1;
+
+        return 0;
+}
+
+static int cp_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type || !(quirks & CP_2WHEEL_MOUSE_HACK))
+                return 0;
+
+        if (usage->hid == 0x00090005) {
+                if (value)
+                        quirks |=  CP_2WHEEL_MOUSE_HACK_ON;
+                else
+                        quirks &= ~CP_2WHEEL_MOUSE_HACK_ON;
+                hid_set_drvdata(hdev, (void *)quirks);
+                return 1;
+        }
+
+        if (usage->code == REL_WHEEL && (quirks & CP_2WHEEL_MOUSE_HACK_ON)) {
+                struct input_dev *input = field->hidinput->input;
+
+                input_event(input, usage->type, REL_HWHEEL, value);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int cp_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+
+        hid_set_drvdata(hdev, (void *)quirks);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id cp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1),
+                .driver_data = CP_RDESC_SWAPPED_MIN_MAX },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2),
+                .driver_data = CP_RDESC_SWAPPED_MIN_MAX },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE),
+                .driver_data = CP_2WHEEL_MOUSE_HACK },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, cp_devices);
+
+static struct hid_driver cp_driver = {
+        .name = "cypress",
+        .id_table = cp_devices,
+        .report_fixup = cp_report_fixup,
+        .input_mapped = cp_input_mapped,
+        .event = cp_event,
+        .probe = cp_probe,
+};
+
+static int cp_init(void)
+{
+        return hid_register_driver(&cp_driver);
+}
+
+static void cp_exit(void)
+{
+        hid_unregister_driver(&cp_driver);
+}
+
+module_init(cp_init);
+module_exit(cp_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(cypress);
diff --git a/drivers/hid/hid-dell.c b/drivers/hid/hid-dell.c
new file mode 100644
index 000000000000..1a0d0dfc62fc
--- /dev/null
+++ b/drivers/hid/hid-dell.c
@@ -0,0 +1,75 @@
+/*
+ *  HID driver for some dell "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+static int dell_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        usbhid_set_leds(hdev);
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id dell_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_SK8115) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, dell_devices);
+
+static struct hid_driver dell_driver = {
+        .name = "dell",
+        .id_table = dell_devices,
+        .probe = dell_probe,
+};
+
+static int dell_init(void)
+{
+        return hid_register_driver(&dell_driver);
+}
+
+static void dell_exit(void)
+{
+        hid_unregister_driver(&dell_driver);
+}
+
+module_init(dell_init);
+module_exit(dell_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(dell);
diff --git a/drivers/hid/hid-dummy.c b/drivers/hid/hid-dummy.c
new file mode 100644
index 000000000000..e148f86fb58e
--- /dev/null
+++ b/drivers/hid/hid-dummy.c
@@ -0,0 +1,72 @@
+#include <linux/autoconf.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+
+static int __init hid_dummy_init(void)
+{
+#ifdef CONFIG_HID_A4TECH_MODULE
+        HID_COMPAT_CALL_DRIVER(a4tech);
+#endif
+#ifdef CONFIG_HID_APPLE_MODULE
+        HID_COMPAT_CALL_DRIVER(apple);
+#endif
+#ifdef CONFIG_HID_BELKIN_MODULE
+        HID_COMPAT_CALL_DRIVER(belkin);
+#endif
+#ifdef CONFIG_HID_BRIGHT_MODULE
+        HID_COMPAT_CALL_DRIVER(bright);
+#endif
+#ifdef CONFIG_HID_CHERRY_MODULE
+        HID_COMPAT_CALL_DRIVER(cherry);
+#endif
+#ifdef CONFIG_HID_CHICONY_MODULE
+        HID_COMPAT_CALL_DRIVER(chicony);
+#endif
+#ifdef CONFIG_HID_CYPRESS_MODULE
+        HID_COMPAT_CALL_DRIVER(cypress);
+#endif
+#ifdef CONFIG_HID_DELL_MODULE
+        HID_COMPAT_CALL_DRIVER(dell);
+#endif
+#ifdef CONFIG_HID_EZKEY_MODULE
+        HID_COMPAT_CALL_DRIVER(ezkey);
+#endif
+#ifdef CONFIG_HID_GYRATION_MODULE
+        HID_COMPAT_CALL_DRIVER(gyration);
+#endif
+#ifdef CONFIG_HID_LOGITECH_MODULE
+        HID_COMPAT_CALL_DRIVER(logitech);
+#endif
+#ifdef CONFIG_HID_MICROSOFT_MODULE
+        HID_COMPAT_CALL_DRIVER(microsoft);
+#endif
+#ifdef CONFIG_HID_MONTEREY_MODULE
+        HID_COMPAT_CALL_DRIVER(monterey);
+#endif
+#ifdef CONFIG_HID_PANTHERLORD_MODULE
+        HID_COMPAT_CALL_DRIVER(pantherlord);
+#endif
+#ifdef CONFIG_HID_PETALYNX_MODULE
+        HID_COMPAT_CALL_DRIVER(petalynx);
+#endif
+#ifdef CONFIG_HID_SAMSUNG_MODULE
+        HID_COMPAT_CALL_DRIVER(samsung);
+#endif
+#ifdef CONFIG_HID_SONY_MODULE
+        HID_COMPAT_CALL_DRIVER(sony);
+#endif
+#ifdef CONFIG_HID_SUNPLUS_MODULE
+        HID_COMPAT_CALL_DRIVER(sunplus);
+#endif
+#ifdef CONFIG_THRUSTMASTER_FF_MODULE
+        HID_COMPAT_CALL_DRIVER(thrustmaster);
+#endif
+#ifdef CONFIG_ZEROPLUS_FF_MODULE
+        HID_COMPAT_CALL_DRIVER(zeroplus);
+#endif
+
+        return -EIO;
+}
+module_init(hid_dummy_init);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-ezkey.c b/drivers/hid/hid-ezkey.c
new file mode 100644
index 000000000000..deb42f931b7e
--- /dev/null
+++ b/drivers/hid/hid-ezkey.c
@@ -0,0 +1,95 @@
+/*
+ *  HID driver for some ezkey "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define ez_map_rel(c)   hid_map_usage(hi, usage, bit, max, EV_REL, (c))
+#define ez_map_key(c)   hid_map_usage(hi, usage, bit, max, EV_KEY, (c))
+
+static int ez_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x230: ez_map_key(BTN_MOUSE);      break;
+        case 0x231: ez_map_rel(REL_WHEEL);      break;
+        /*
+         * this keyboard has a scrollwheel implemented in
+         * totally broken way. We map this usage temporarily
+         * to HWHEEL and handle it in the event quirk handler
+         */
+        case 0x232: ez_map_rel(REL_HWHEEL);     break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int ez_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+
+        /* handle the temporary quirky mapping to HWHEEL */
+        if (usage->type == EV_REL && usage->code == REL_HWHEEL) {
+                struct input_dev *input = field->hidinput->input;
+                input_event(input, usage->type, REL_WHEEL, -value);
+                return 1;
+        }
+
+        return 0;
+}
+
+static const struct hid_device_id ez_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ez_devices);
+
+static struct hid_driver ez_driver = {
+        .name = "ezkey",
+        .id_table = ez_devices,
+        .input_mapping = ez_input_mapping,
+        .event = ez_event,
+};
+
+static int ez_init(void)
+{
+        return hid_register_driver(&ez_driver);
+}
+
+static void ez_exit(void)
+{
+        hid_unregister_driver(&ez_driver);
+}
+
+module_init(ez_init);
+module_exit(ez_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(ezkey);
diff --git a/drivers/hid/hid-gyration.c b/drivers/hid/hid-gyration.c
new file mode 100644
index 000000000000..ac5120f542cc
--- /dev/null
+++ b/drivers/hid/hid-gyration.c
@@ -0,0 +1,96 @@
+/*
+ *  HID driver for some gyration "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define gy_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int gyration_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
+                return 0;
+
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        /* Reported on Gyration MCE Remote */
+        case 0x00d: gy_map_key_clear(KEY_HOME);         break;
+        case 0x024: gy_map_key_clear(KEY_DVD);          break;
+        case 0x025: gy_map_key_clear(KEY_PVR);          break;
+        case 0x046: gy_map_key_clear(KEY_MEDIA);        break;
+        case 0x047: gy_map_key_clear(KEY_MP3);          break;
+        case 0x049: gy_map_key_clear(KEY_CAMERA);       break;
+        case 0x04a: gy_map_key_clear(KEY_VIDEO);        break;
+
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int gyration_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        struct input_dev *input = field->hidinput->input;
+
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
+                        (usage->hid & 0xff) == 0x82) {
+                input_event(input, usage->type, usage->code, 1);
+                input_sync(input);
+                input_event(input, usage->type, usage->code, 0);
+                input_sync(input);
+                return 1;
+        }
+
+        return 0;
+}
+
+static const struct hid_device_id gyration_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, gyration_devices);
+
+static struct hid_driver gyration_driver = {
+        .name = "gyration",
+        .id_table = gyration_devices,
+        .input_mapping = gyration_input_mapping,
+        .event = gyration_event,
+};
+
+static int gyration_init(void)
+{
+        return hid_register_driver(&gyration_driver);
+}
+
+static void gyration_exit(void)
+{
+        hid_unregister_driver(&gyration_driver);
+}
+
+module_init(gyration_init);
+module_exit(gyration_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(gyration);
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
new file mode 100644
index 000000000000..aad9ed1b406e
--- /dev/null
+++ b/drivers/hid/hid-ids.h
@@ -0,0 +1,404 @@
+/*
+ *  USB HID quirks 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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ */
+
+/*
+ * 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.
+ */
+
+#ifndef HID_IDS_H_FILE
+#define HID_IDS_H_FILE
+
+#define USB_VENDOR_ID_A4TECH            0x09da
+#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
+#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
+
+#define USB_VENDOR_ID_AASHIMA           0x06d6
+#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
+
+#define USB_VENDOR_ID_ACECAD            0x0460
+#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
+#define USB_DEVICE_ID_ACECAD_302        0x0008
+
+#define USB_VENDOR_ID_ADS_TECH          0x06e1
+#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
+
+#define USB_VENDOR_ID_AFATECH           0x15a4
+#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
+
+#define USB_VENDOR_ID_AIPTEK            0x08ca
+#define USB_DEVICE_ID_AIPTEK_01         0x0001
+#define USB_DEVICE_ID_AIPTEK_10         0x0010
+#define USB_DEVICE_ID_AIPTEK_20         0x0020
+#define USB_DEVICE_ID_AIPTEK_21         0x0021
+#define USB_DEVICE_ID_AIPTEK_22         0x0022
+#define USB_DEVICE_ID_AIPTEK_23         0x0023
+#define USB_DEVICE_ID_AIPTEK_24         0x0024
+
+#define USB_VENDOR_ID_AIRCABLE          0x16CA
+#define USB_DEVICE_ID_AIRCABLE1         0x1502
+
+#define USB_VENDOR_ID_ALCOR             0x058f
+#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
+
+#define USB_VENDOR_ID_ALPS              0x0433
+#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
+
+#define USB_VENDOR_ID_APPLE             0x05ac
+#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
+#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
+#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
+#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
+#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
+#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
+#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
+#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
+#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
+#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
+#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
+#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
+#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
+#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI    0x0229
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO     0x022a
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS     0x022b
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI  0x022c
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO   0x022d
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS   0x022e
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
+#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
+#define USB_DEVICE_ID_APPLE_ATV_IRCONTROL       0x8241
+#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
+
+#define USB_VENDOR_ID_ASUS              0x0b05
+#define USB_DEVICE_ID_ASUS_LCM          0x1726
+
+#define USB_VENDOR_ID_ATEN              0x0557
+#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
+#define USB_DEVICE_ID_ATEN_CS124U       0x2202
+#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
+#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
+#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
+
+#define USB_VENDOR_ID_AVERMEDIA         0x07ca
+#define USB_DEVICE_ID_AVER_FM_MR800     0xb800
+
+#define USB_VENDOR_ID_BELKIN           0x050d
+#define USB_DEVICE_ID_FLIP_KVM         0x3201
+
+#define USB_VENDOR_ID_BRIGHT            0x1241
+#define USB_DEVICE_ID_BRIGHT_ABNT2      0x1503
+
+#define USB_VENDOR_ID_BERKSHIRE         0x0c98
+#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
+
+#define USB_VENDOR_ID_CHERRY            0x046a
+#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
+
+#define USB_VENDOR_ID_CHIC              0x05fe
+#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
+
+#define USB_VENDOR_ID_CHICONY           0x04f2
+#define USB_DEVICE_ID_CHICONY_TACTICAL_PAD      0x0418
+
+#define USB_VENDOR_ID_CIDC              0x1677
+
+#define USB_VENDOR_ID_CMEDIA            0x0d8c
+#define USB_DEVICE_ID_CM109             0x000e
+
+#define USB_VENDOR_ID_CODEMERCS         0x07c0
+#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
+#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
+
+#define USB_VENDOR_ID_CYGNAL            0x10c4
+#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
+
+#define USB_VENDOR_ID_CYPRESS           0x04b4
+#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
+#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
+#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
+#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
+#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
+
+#define USB_VENDOR_ID_DELL              0x413c
+#define USB_DEVICE_ID_DELL_W7658        0x2005
+#define USB_DEVICE_ID_DELL_SK8115       0x2105
+
+#define USB_VENDOR_ID_DELORME           0x1163
+#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
+#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
+
+#define USB_VENDOR_ID_DMI               0x0c0b
+#define USB_DEVICE_ID_DMI_ENC           0x5fab
+
+#define USB_VENDOR_ID_ELO               0x04E7
+#define USB_DEVICE_ID_ELO_TS2700        0x0020
+
+#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
+#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
+
+#define USB_VENDOR_ID_EZKEY             0x0518
+#define USB_DEVICE_ID_BTC_8193          0x0002
+
+#define USB_VENDOR_ID_GAMERON           0x0810
+#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
+
+#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+
+#define USB_VENDOR_ID_GLAB              0x06c2
+#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
+#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
+#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
+#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
+#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
+#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
+#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
+#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
+
+#define USB_VENDOR_ID_GOTOP             0x08f2
+#define USB_DEVICE_ID_SUPER_Q2          0x007f
+#define USB_DEVICE_ID_GOGOPEN           0x00ce
+#define USB_DEVICE_ID_PENPOWER          0x00f4
+
+#define USB_VENDOR_ID_GREENASIA         0x0e8f
+
+#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
+#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
+
+#define USB_VENDOR_ID_GRIFFIN           0x077d
+#define USB_DEVICE_ID_POWERMATE         0x0410
+#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
+
+#define USB_VENDOR_ID_GTCO              0x078c
+#define USB_DEVICE_ID_GTCO_90           0x0090
+#define USB_DEVICE_ID_GTCO_100          0x0100
+#define USB_DEVICE_ID_GTCO_101          0x0101
+#define USB_DEVICE_ID_GTCO_103          0x0103
+#define USB_DEVICE_ID_GTCO_104          0x0104
+#define USB_DEVICE_ID_GTCO_105          0x0105
+#define USB_DEVICE_ID_GTCO_106          0x0106
+#define USB_DEVICE_ID_GTCO_107          0x0107
+#define USB_DEVICE_ID_GTCO_108          0x0108
+#define USB_DEVICE_ID_GTCO_200          0x0200
+#define USB_DEVICE_ID_GTCO_201          0x0201
+#define USB_DEVICE_ID_GTCO_202          0x0202
+#define USB_DEVICE_ID_GTCO_203          0x0203
+#define USB_DEVICE_ID_GTCO_204          0x0204
+#define USB_DEVICE_ID_GTCO_205          0x0205
+#define USB_DEVICE_ID_GTCO_206          0x0206
+#define USB_DEVICE_ID_GTCO_207          0x0207
+#define USB_DEVICE_ID_GTCO_300          0x0300
+#define USB_DEVICE_ID_GTCO_301          0x0301
+#define USB_DEVICE_ID_GTCO_302          0x0302
+#define USB_DEVICE_ID_GTCO_303          0x0303
+#define USB_DEVICE_ID_GTCO_304          0x0304
+#define USB_DEVICE_ID_GTCO_305          0x0305
+#define USB_DEVICE_ID_GTCO_306          0x0306
+#define USB_DEVICE_ID_GTCO_307          0x0307
+#define USB_DEVICE_ID_GTCO_308          0x0308
+#define USB_DEVICE_ID_GTCO_309          0x0309
+#define USB_DEVICE_ID_GTCO_400          0x0400
+#define USB_DEVICE_ID_GTCO_401          0x0401
+#define USB_DEVICE_ID_GTCO_402          0x0402
+#define USB_DEVICE_ID_GTCO_403          0x0403
+#define USB_DEVICE_ID_GTCO_404          0x0404
+#define USB_DEVICE_ID_GTCO_405          0x0405
+#define USB_DEVICE_ID_GTCO_500          0x0500
+#define USB_DEVICE_ID_GTCO_501          0x0501
+#define USB_DEVICE_ID_GTCO_502          0x0502
+#define USB_DEVICE_ID_GTCO_503          0x0503
+#define USB_DEVICE_ID_GTCO_504          0x0504
+#define USB_DEVICE_ID_GTCO_1000         0x1000
+#define USB_DEVICE_ID_GTCO_1001         0x1001
+#define USB_DEVICE_ID_GTCO_1002         0x1002
+#define USB_DEVICE_ID_GTCO_1003         0x1003
+#define USB_DEVICE_ID_GTCO_1004         0x1004
+#define USB_DEVICE_ID_GTCO_1005         0x1005
+#define USB_DEVICE_ID_GTCO_1006         0x1006
+#define USB_DEVICE_ID_GTCO_1007         0x1007
+
+#define USB_VENDOR_ID_GYRATION          0x0c16
+#define USB_DEVICE_ID_GYRATION_REMOTE   0x0002
+
+#define USB_VENDOR_ID_HAPP              0x078b
+#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
+#define USB_DEVICE_ID_UGCI_FLYING       0x0020
+#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
+
+#define USB_VENDOR_ID_IMATION           0x0718
+#define USB_DEVICE_ID_DISC_STAKKA       0xd000
+
+#define USB_VENDOR_ID_KBGEAR            0x084e
+#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
+
+#define USB_VENDOR_ID_LABTEC            0x1020
+#define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD  0x0006
+
+#define USB_VENDOR_ID_LD                0x0f11
+#define USB_DEVICE_ID_LD_CASSY          0x1000
+#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
+#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
+#define USB_DEVICE_ID_LD_JWM            0x1080
+#define USB_DEVICE_ID_LD_DMMP           0x1081
+#define USB_DEVICE_ID_LD_UMIP           0x1090
+#define USB_DEVICE_ID_LD_XRAY1          0x1100
+#define USB_DEVICE_ID_LD_XRAY2          0x1101
+#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
+#define USB_DEVICE_ID_LD_COM3LAB        0x2000
+#define USB_DEVICE_ID_LD_TELEPORT       0x2010
+#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
+#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
+#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
+
+#define USB_VENDOR_ID_LOGITECH          0x046d
+#define USB_DEVICE_ID_LOGITECH_LX3      0xc044
+#define USB_DEVICE_ID_LOGITECH_V150     0xc047
+#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
+#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST  0xc110
+#define USB_DEVICE_ID_LOGITECH_HARMONY_LAST 0xc14f
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD        0xc211
+#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2       0xc218
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2     0xc219
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D      0xc283
+#define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO      0xc286
+#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL       0xc295
+#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
+#define USB_DEVICE_ID_LOGITECH_KBD      0xc311
+#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
+#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
+#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
+#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
+#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
+#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
+#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2      0xca03
+
+#define USB_VENDOR_ID_MCC               0x09db
+#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
+#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
+
+#define USB_VENDOR_ID_MGE               0x0463
+#define USB_DEVICE_ID_MGE_UPS           0xffff
+#define USB_DEVICE_ID_MGE_UPS1          0x0001
+
+#define USB_VENDOR_ID_MICROCHIP         0x04d8
+#define USB_DEVICE_ID_PICKIT1           0x0032
+#define USB_DEVICE_ID_PICKIT2           0x0033
+
+#define USB_VENDOR_ID_MICROSOFT         0x045e
+#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
+#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
+#define USB_DEVICE_ID_MS_NE4K           0x00db
+#define USB_DEVICE_ID_MS_LK6K           0x00f9
+#define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
+#define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
+
+
+#define USB_VENDOR_ID_MONTEREY          0x0566
+#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
+
+#define USB_VENDOR_ID_NCR               0x0404
+#define USB_DEVICE_ID_NCR_FIRST         0x0300
+#define USB_DEVICE_ID_NCR_LAST          0x03ff
+
+#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
+#define USB_DEVICE_ID_N_S_HARMONY       0xc359
+
+#define USB_VENDOR_ID_NATSU             0x08b7
+#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
+
+#define USB_VENDOR_ID_NEC               0x073e
+#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
+
+#define USB_VENDOR_ID_ONTRAK            0x0a07
+#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
+
+#define USB_VENDOR_ID_PANJIT            0x134c
+
+#define USB_VENDOR_ID_PANTHERLORD       0x0810
+#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
+
+#define USB_VENDOR_ID_PETALYNX          0x18b1
+#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
+
+#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
+#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
+
+#define USB_VENDOR_ID_SAITEK            0x06a3
+#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
+
+#define USB_VENDOR_ID_SAMSUNG           0x0419
+#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
+
+#define USB_VENDOR_ID_SONY                      0x054c
+#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
+
+#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD       0x0038
+
+#define USB_VENDOR_ID_SUN               0x0430
+#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
+
+#define USB_VENDOR_ID_SUNPLUS           0x04fc
+#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
+
+#define USB_VENDOR_ID_TENX              0x1130
+#define USB_DEVICE_ID_TENX_IBUDDY1      0x0001
+#define USB_DEVICE_ID_TENX_IBUDDY2      0x0002
+
+#define USB_VENDOR_ID_THRUSTMASTER      0x044f
+
+#define USB_VENDOR_ID_TOPMAX            0x0663
+#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
+
+#define USB_VENDOR_ID_TURBOX            0x062a
+#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
+
+#define USB_VENDOR_ID_VERNIER           0x08f7
+#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
+#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
+#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
+#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
+#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
+
+#define USB_VENDOR_ID_WACOM             0x056a
+
+#define USB_VENDOR_ID_WISEGROUP         0x0925
+#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
+#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
+#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
+#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
+#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
+
+#define USB_VENDOR_ID_WISEGROUP_LTD     0x6666
+#define USB_VENDOR_ID_WISEGROUP_LTD2    0x6677
+#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
+
+#define USB_VENDOR_ID_YEALINK           0x6993
+#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
+
+#define USB_VENDOR_ID_ZEROPLUS          0x0c12
+
+#define USB_VENDOR_ID_KYE               0x0458
+#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
+
+#endif
diff --git a/drivers/hid/hid-input-quirks.c b/drivers/hid/hid-input-quirks.c
deleted file mode 100644
index 16feea014494..000000000000
--- a/drivers/hid/hid-input-quirks.c
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- *  HID-input usage mapping quirks
- *
- *  This is used to handle HID-input mappings for devices violating
- *  HUT 1.12 specification.
- *
- * Copyright (c) 2007-2008 Jiri Kosina
- */
-
-/*
- * 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
- */
-
-#include <linux/input.h>
-#include <linux/hid.h>
-
-#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; *bit = input->absbit; *max = ABS_MAX; } while (0)
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; *bit = input->relbit; *max = REL_MAX; } while (0)
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; *bit = input->keybit; *max = KEY_MAX; } while (0)
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; *bit = input->ledbit; *max = LED_MAX; } while (0)
-
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, *bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, *bit); } while (0)
-
-static int quirk_belkin_wkbd(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x03a: map_key_clear(KEY_SOUND);           break;
-                case 0x03b: map_key_clear(KEY_CAMERA);          break;
-                case 0x03c: map_key_clear(KEY_DOCUMENTS);       break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_cherry_cymotion(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x301: map_key_clear(KEY_PROG1);           break;
-                case 0x302: map_key_clear(KEY_PROG2);           break;
-                case 0x303: map_key_clear(KEY_PROG3);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_logitech_ultrax_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                /* Reported on Logitech Ultra X Media Remote */
-                case 0x004: map_key_clear(KEY_AGAIN);           break;
-                case 0x00d: map_key_clear(KEY_HOME);            break;
-                case 0x024: map_key_clear(KEY_SHUFFLE);         break;
-                case 0x025: map_key_clear(KEY_TV);              break;
-                case 0x026: map_key_clear(KEY_MENU);            break;
-                case 0x031: map_key_clear(KEY_AUDIO);           break;
-                case 0x032: map_key_clear(KEY_TEXT);            break;
-                case 0x033: map_key_clear(KEY_LAST);            break;
-                case 0x047: map_key_clear(KEY_MP3);             break;
-                case 0x048: map_key_clear(KEY_DVD);             break;
-                case 0x049: map_key_clear(KEY_MEDIA);           break;
-                case 0x04a: map_key_clear(KEY_VIDEO);           break;
-                case 0x04b: map_key_clear(KEY_ANGLE);           break;
-                case 0x04c: map_key_clear(KEY_LANGUAGE);        break;
-                case 0x04d: map_key_clear(KEY_SUBTITLE);        break;
-                case 0x051: map_key_clear(KEY_RED);             break;
-                case 0x052: map_key_clear(KEY_CLOSE);           break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_gyration_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                /* Reported on Gyration MCE Remote */
-                case 0x00d: map_key_clear(KEY_HOME);            break;
-                case 0x024: map_key_clear(KEY_DVD);             break;
-                case 0x025: map_key_clear(KEY_PVR);             break;
-                case 0x046: map_key_clear(KEY_MEDIA);           break;
-                case 0x047: map_key_clear(KEY_MP3);             break;
-                case 0x049: map_key_clear(KEY_CAMERA);          break;
-                case 0x04a: map_key_clear(KEY_VIDEO);           break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_chicony_tactical_pad(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch (usage->hid & HID_USAGE) {
-                case 0xff01: map_key_clear(BTN_1);              break;
-                case 0xff02: map_key_clear(BTN_2);              break;
-                case 0xff03: map_key_clear(BTN_3);              break;
-                case 0xff04: map_key_clear(BTN_4);              break;
-                case 0xff05: map_key_clear(BTN_5);              break;
-                case 0xff06: map_key_clear(BTN_6);              break;
-                case 0xff07: map_key_clear(BTN_7);              break;
-                case 0xff08: map_key_clear(BTN_8);              break;
-                case 0xff09: map_key_clear(BTN_9);              break;
-                case 0xff0a: map_key_clear(BTN_A);              break;
-                case 0xff0b: map_key_clear(BTN_B);              break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_microsoft_ergonomy_kb(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd06: map_key_clear(KEY_CHAT);           break;
-                case 0xfd07: map_key_clear(KEY_PHONE);          break;
-                case 0xff05:
-                        set_bit(EV_REP, input->evbit);
-                        map_key_clear(KEY_F13);
-                        set_bit(KEY_F14, input->keybit);
-                        set_bit(KEY_F15, input->keybit);
-                        set_bit(KEY_F16, input->keybit);
-                        set_bit(KEY_F17, input->keybit);
-                        set_bit(KEY_F18, input->keybit);
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_microsoft_presenter_8k(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd08: map_key_clear(KEY_FORWARD);        break;
-                case 0xfd09: map_key_clear(KEY_BACK);           break;
-                case 0xfd0b: map_key_clear(KEY_PLAYPAUSE);      break;
-                case 0xfd0e: map_key_clear(KEY_CLOSE);          break;
-                case 0xfd0f: map_key_clear(KEY_PLAY);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_petalynx_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if (((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) &&
-                        ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER))
-                return 0;
-
-        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR)
-                switch(usage->hid & HID_USAGE) {
-                        case 0x05a: map_key_clear(KEY_TEXT);            break;
-                        case 0x05b: map_key_clear(KEY_RED);             break;
-                        case 0x05c: map_key_clear(KEY_GREEN);           break;
-                        case 0x05d: map_key_clear(KEY_YELLOW);          break;
-                        case 0x05e: map_key_clear(KEY_BLUE);            break;
-                        default:
-                                return 0;
-                }
-
-        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
-                switch(usage->hid & HID_USAGE) {
-                        case 0x0f6: map_key_clear(KEY_NEXT);            break;
-                        case 0x0fa: map_key_clear(KEY_BACK);            break;
-                        default:
-                                return 0;
-                }
-        return 1;
-}
-
-static int quirk_logitech_wireless(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x1001: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1003: map_key_clear(KEY_SOUND);          break;
-                case 0x1004: map_key_clear(KEY_VIDEO);          break;
-                case 0x1005: map_key_clear(KEY_AUDIO);          break;
-                case 0x100a: map_key_clear(KEY_DOCUMENTS);      break;
-                case 0x1011: map_key_clear(KEY_PREVIOUSSONG);   break;
-                case 0x1012: map_key_clear(KEY_NEXTSONG);       break;
-                case 0x1013: map_key_clear(KEY_CAMERA);         break;
-                case 0x1014: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1015: map_key_clear(KEY_RECORD);         break;
-                case 0x1016: map_key_clear(KEY_PLAYER);         break;
-                case 0x1017: map_key_clear(KEY_EJECTCD);        break;
-                case 0x1018: map_key_clear(KEY_MEDIA);          break;
-                case 0x1019: map_key_clear(KEY_PROG1);          break;
-                case 0x101a: map_key_clear(KEY_PROG2);          break;
-                case 0x101b: map_key_clear(KEY_PROG3);          break;
-                case 0x101f: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x1020: map_key_clear(KEY_ZOOMOUT);        break;
-                case 0x1021: map_key_clear(KEY_ZOOMRESET);      break;
-                case 0x1023: map_key_clear(KEY_CLOSE);          break;
-                case 0x1027: map_key_clear(KEY_MENU);           break;
-                /* this one is marked as 'Rotate' */
-                case 0x1028: map_key_clear(KEY_ANGLE);          break;
-                case 0x1029: map_key_clear(KEY_SHUFFLE);        break;
-                case 0x102a: map_key_clear(KEY_BACK);           break;
-                case 0x102b: map_key_clear(KEY_CYCLEWINDOWS);   break;
-                case 0x1041: map_key_clear(KEY_BATTERY);        break;
-                case 0x1042: map_key_clear(KEY_WORDPROCESSOR);  break;
-                case 0x1043: map_key_clear(KEY_SPREADSHEET);    break;
-                case 0x1044: map_key_clear(KEY_PRESENTATION);   break;
-                case 0x1045: map_key_clear(KEY_UNDO);           break;
-                case 0x1046: map_key_clear(KEY_REDO);           break;
-                case 0x1047: map_key_clear(KEY_PRINT);          break;
-                case 0x1048: map_key_clear(KEY_SAVE);           break;
-                case 0x1049: map_key_clear(KEY_PROG1);          break;
-                case 0x104a: map_key_clear(KEY_PROG2);          break;
-                case 0x104b: map_key_clear(KEY_PROG3);          break;
-                case 0x104c: map_key_clear(KEY_PROG4);          break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_cherry_genius_29e(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x156: map_key_clear(KEY_WORDPROCESSOR);   break;
-                case 0x157: map_key_clear(KEY_SPREADSHEET);     break;
-                case 0x158: map_key_clear(KEY_PRESENTATION);    break;
-                case 0x15c: map_key_clear(KEY_STOP);            break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_btc_8193(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x230: map_key(BTN_MOUSE);                 break;
-                case 0x231: map_rel(REL_WHEEL);                 break;
-                /* 
-                 * this keyboard has a scrollwheel implemented in
-                 * totally broken way. We map this usage temporarily
-                 * to HWHEEL and handle it in the event quirk handler
-                 */
-                case 0x232: map_rel(REL_HWHEEL);                break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_sunplus_wdesktop(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x2003: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x2103: map_key_clear(KEY_ZOOMOUT);        break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-#define VENDOR_ID_BELKIN                        0x1020
-#define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD      0x0006
-
-#define VENDOR_ID_CHERRY                        0x046a
-#define DEVICE_ID_CHERRY_CYMOTION               0x0023
-
-#define VENDOR_ID_CHICONY                       0x04f2
-#define DEVICE_ID_CHICONY_TACTICAL_PAD          0x0418
-
-#define VENDOR_ID_EZKEY                         0x0518
-#define DEVICE_ID_BTC_8193                      0x0002
-
-#define VENDOR_ID_GYRATION                      0x0c16
-#define DEVICE_ID_GYRATION_REMOTE               0x0002
-
-#define VENDOR_ID_LOGITECH                      0x046d
-#define DEVICE_ID_LOGITECH_RECEIVER             0xc101
-#define DEVICE_ID_S510_RECEIVER                 0xc50c
-#define DEVICE_ID_S510_RECEIVER_2               0xc517
-#define DEVICE_ID_MX3000_RECEIVER               0xc513
-
-#define VENDOR_ID_MICROSOFT                     0x045e
-#define DEVICE_ID_MS4K                          0x00db
-#define DEVICE_ID_MS6K                          0x00f9
-#define DEVICE_IS_MS_PRESENTER_8K_BT            0x0701
-#define DEVICE_ID_MS_PRESENTER_8K_USB           0x0713
-
-#define VENDOR_ID_MONTEREY                      0x0566
-#define DEVICE_ID_GENIUS_KB29E                  0x3004
-
-#define VENDOR_ID_PETALYNX                      0x18b1
-#define DEVICE_ID_PETALYNX_MAXTER_REMOTE        0x0037
-
-#define VENDOR_ID_SUNPLUS                       0x04fc
-#define DEVICE_ID_SUNPLUS_WDESKTOP              0x05d8
-
-static const struct hid_input_blacklist {
-        __u16 idVendor;
-        __u16 idProduct;
-        int (*quirk)(struct hid_usage *, struct input_dev *, unsigned long **, int *);
-} hid_input_blacklist[] = {
-        { VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },
-
-        { VENDOR_ID_CHERRY, DEVICE_ID_CHERRY_CYMOTION, quirk_cherry_cymotion },
-
-        { VENDOR_ID_CHICONY, DEVICE_ID_CHICONY_TACTICAL_PAD, quirk_chicony_tactical_pad },
-
-        { VENDOR_ID_EZKEY, DEVICE_ID_BTC_8193, quirk_btc_8193 },
-
-        { VENDOR_ID_GYRATION, DEVICE_ID_GYRATION_REMOTE, quirk_gyration_remote },
-
-        { VENDOR_ID_LOGITECH, DEVICE_ID_LOGITECH_RECEIVER, quirk_logitech_ultrax_remote },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER_2, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_MX3000_RECEIVER, quirk_logitech_wireless },
-
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS4K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS6K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_IS_MS_PRESENTER_8K_BT, quirk_microsoft_presenter_8k },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS_PRESENTER_8K_USB, quirk_microsoft_presenter_8k },
-
-        { VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },
-
-        { VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },
-
-        { VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop },
-
-        { 0, 0, NULL }
-};
-
-int hidinput_mapping_quirks(struct hid_usage *usage, 
-                                   struct input_dev *input, 
-                                   unsigned long **bit, int *max)
-{
-        struct hid_device *device = input_get_drvdata(input);
-        int i = 0;
-        
-        while (hid_input_blacklist[i].quirk) {
-                if (hid_input_blacklist[i].idVendor == device->vendor &&
-                                hid_input_blacklist[i].idProduct == device->product)
-                        return hid_input_blacklist[i].quirk(usage, input, bit, max);
-                i++;
-        }
-        return 0;
-}
-
-int hidinput_event_quirks(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
-{
-        struct input_dev *input;
-
-        input = field->hidinput->input;
-
-        if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
-                if (value) hid->quirks |=  HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                else       hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL)) {
-                hid->delayed_value = value;
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->hid == 0x000100b8)) {
-                input_event(input, EV_REL, value ? REL_HWHEEL : REL_WHEEL, hid->delayed_value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
-                input_event(input, usage->type, usage->code, -value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
-                input_event(input, usage->type, REL_HWHEEL, value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_APPLE_HAS_FN) && hidinput_apple_event(hid, input, usage, value))
-                return 1;
-
-        /* Handling MS keyboards special buttons */
-        if (hid->quirks & HID_QUIRK_MICROSOFT_KEYS && 
-                        usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
-                int key = 0;
-                static int last_key = 0;
-                switch (value) {
-                        case 0x01: key = KEY_F14; break;
-                        case 0x02: key = KEY_F15; break;
-                        case 0x04: key = KEY_F16; break;
-                        case 0x08: key = KEY_F17; break;
-                        case 0x10: key = KEY_F18; break;
-                        default: break;
-                }
-                if (key) {
-                        input_event(input, usage->type, key, 1);
-                        last_key = key;
-                } else {
-                        input_event(input, usage->type, last_key, 0);
-                }
-        }
-
-        /* handle the temporary quirky mapping to HWHEEL */
-        if (hid->quirks & HID_QUIRK_HWHEEL_WHEEL_INVERT &&
-                        usage->type == EV_REL && usage->code == REL_HWHEEL) {
-                input_event(input, usage->type, REL_WHEEL, -value);
-                return 1;
-        }
-
-        /* Gyration MCE remote "Sleep" key */
-        if (hid->vendor == VENDOR_ID_GYRATION &&
-            hid->product == DEVICE_ID_GYRATION_REMOTE &&
-            (usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
-            (usage->hid & 0xff) == 0x82) {
-                input_event(input, usage->type, usage->code, 1);
-                input_sync(input);
-                input_event(input, usage->type, usage->code, 0);
-                input_sync(input);
-                return 1;
-        }
-        return 0;
-}
-
-
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 1b2e8dc3398d..7f183b7147e1 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -32,11 +32,6 @@
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
 
-static int hid_apple_fnmode = 1;
-module_param_named(pb_fnmode, hid_apple_fnmode, int, 0644);
-MODULE_PARM_DESC(pb_fnmode,
-                "Mode of fn key on Apple keyboards (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
-
 #define unk     KEY_UNKNOWN
 
 static const unsigned char hid_keyboard[256] = {
@@ -58,227 +53,20 @@ static const unsigned char hid_keyboard[256] = {
         150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
 };
 
-/* extended mapping for certain Logitech hardware (Logitech cordless desktop LX500) */
-#define LOGITECH_EXPANDED_KEYMAP_SIZE 80
-static int logitech_expanded_keymap[LOGITECH_EXPANDED_KEYMAP_SIZE] = {
-          0,216,  0,213,175,156,  0,  0,  0,  0,
-        144,  0,  0,  0,  0,  0,  0,  0,  0,212,
-        174,167,152,161,112,  0,  0,  0,154,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,183,184,185,186,187,
-        188,189,190,191,192,193,194,  0,  0,  0
-};
-
 static const struct {
         __s32 x;
         __s32 y;
 }  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
 
-#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
-
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, bit); } while (0)
-
-#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
-
-struct hidinput_key_translation {
-        u16 from;
-        u16 to;
-        u8 flags;
-};
-
-#define APPLE_FLAG_FKEY 0x01
-
-static struct hidinput_key_translation apple_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Exposé */
-        { KEY_F4,       KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
-        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
-        { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-
-static struct hidinput_key_translation powerbook_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
-        { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
-        { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-
-static struct hidinput_key_translation powerbook_numlock_keys[] = {
-        { KEY_J,        KEY_KP1 },
-        { KEY_K,        KEY_KP2 },
-        { KEY_L,        KEY_KP3 },
-        { KEY_U,        KEY_KP4 },
-        { KEY_I,        KEY_KP5 },
-        { KEY_O,        KEY_KP6 },
-        { KEY_7,        KEY_KP7 },
-        { KEY_8,        KEY_KP8 },
-        { KEY_9,        KEY_KP9 },
-        { KEY_M,        KEY_KP0 },
-        { KEY_DOT,      KEY_KPDOT },
-        { KEY_SLASH,    KEY_KPPLUS },
-        { KEY_SEMICOLON, KEY_KPMINUS },
-        { KEY_P,        KEY_KPASTERISK },
-        { KEY_MINUS,    KEY_KPEQUAL },
-        { KEY_0,        KEY_KPSLASH },
-        { KEY_F6,       KEY_NUMLOCK },
-        { KEY_KPENTER,  KEY_KPENTER },
-        { KEY_BACKSPACE, KEY_BACKSPACE },
-        { }
-};
-
-static struct hidinput_key_translation apple_iso_keyboard[] = {
-        { KEY_GRAVE,    KEY_102ND },
-        { KEY_102ND,    KEY_GRAVE },
-        { }
-};
+#define map_abs(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
+#define map_rel(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
+#define map_key(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
+#define map_led(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
 
-static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
-{
-        struct hidinput_key_translation *trans;
-
-        /* Look for the translation */
-        for (trans = table; trans->from; trans++)
-                if (trans->from == from)
-                        return trans;
-
-        return NULL;
-}
-
-int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
-                struct hid_usage *usage, __s32 value)
-{
-        struct hidinput_key_translation *trans;
-
-        if (usage->code == KEY_FN) {
-                if (value) hid->quirks |=  HID_QUIRK_APPLE_FN_ON;
-                else       hid->quirks &= ~HID_QUIRK_APPLE_FN_ON;
-
-                input_event(input, usage->type, usage->code, value);
-
-                return 1;
-        }
-
-        if (hid_apple_fnmode) {
-                int do_translate;
-
-                trans = find_translation((hid->product < 0x220 ||
-                                          hid->product >= 0x300) ?
-                                         powerbook_fn_keys : apple_fn_keys,
-                                         usage->code);
-                if (trans) {
-                        if (test_bit(usage->code, hid->apple_pressed_fn))
-                                do_translate = 1;
-                        else if (trans->flags & APPLE_FLAG_FKEY)
-                                do_translate =
-                                        (hid_apple_fnmode == 2 &&  (hid->quirks & HID_QUIRK_APPLE_FN_ON)) ||
-                                        (hid_apple_fnmode == 1 && !(hid->quirks & HID_QUIRK_APPLE_FN_ON));
-                        else
-                                do_translate = (hid->quirks & HID_QUIRK_APPLE_FN_ON);
-
-                        if (do_translate) {
-                                if (value)
-                                        set_bit(usage->code, hid->apple_pressed_fn);
-                                else
-                                        clear_bit(usage->code, hid->apple_pressed_fn);
-
-                                input_event(input, usage->type, trans->to, value);
-
-                                return 1;
-                        }
-                }
-
-                if (hid->quirks & HID_QUIRK_APPLE_NUMLOCK_EMULATION && (
-                                test_bit(usage->code, hid->pb_pressed_numlock) ||
-                                test_bit(LED_NUML, input->led))) {
-                        trans = find_translation(powerbook_numlock_keys, usage->code);
-
-                        if (trans) {
-                                if (value)
-                                        set_bit(usage->code, hid->pb_pressed_numlock);
-                                else
-                                        clear_bit(usage->code, hid->pb_pressed_numlock);
-
-                                input_event(input, usage->type, trans->to, value);
-                        }
-
-                        return 1;
-                }
-        }
-
-        if (hid->quirks & HID_QUIRK_APPLE_ISO_KEYBOARD) {
-                trans = find_translation(apple_iso_keyboard, usage->code);
-                if (trans) {
-                        input_event(input, usage->type, trans->to, value);
-                        return 1;
-                }
-        }
-
-        return 0;
-}
-
-static void hidinput_apple_setup(struct input_dev *input)
-{
-        struct hidinput_key_translation *trans;
-
-        set_bit(KEY_NUMLOCK, input->keybit);
-
-        /* Enable all needed keys */
-        for (trans = apple_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = powerbook_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = powerbook_numlock_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = apple_iso_keyboard; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-}
-#else
-inline int hidinput_apple_event(struct hid_device *hid,
-                                       struct input_dev *input,
-                                       struct hid_usage *usage, __s32 value)
-{
-        return 0;
-}
-
-static inline void hidinput_apple_setup(struct input_dev *input)
-{
-}
-#endif
+#define map_abs_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
+                &max, EV_ABS, (c))
+#define map_key_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
+                &max, EV_KEY, (c))
 
 static inline int match_scancode(int code, int scancode)
 {
@@ -366,7 +154,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 {
         struct input_dev *input = hidinput->input;
         struct hid_device *device = input_get_drvdata(input);
-        int max = 0, code, ret;
+        int max = 0, code;
         unsigned long *bit = NULL;
 
         field->hidinput = hidinput;
@@ -385,406 +173,345 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 goto ignore;
         }
 
-        /* handle input mappings for quirky devices */
-        ret = hidinput_mapping_quirks(usage, input, &bit, &max);
-        if (ret)
-                goto mapped;
+        if (device->driver->input_mapping) {
+                int ret = device->driver->input_mapping(device, hidinput, field,
+                                usage, &bit, &max);
+                if (ret > 0)
+                        goto mapped;
+                if (ret < 0)
+                        goto ignore;
+        }
 
         switch (usage->hid & HID_USAGE_PAGE) {
+        case HID_UP_UNDEFINED:
+                goto ignore;
 
-                case HID_UP_UNDEFINED:
-                        goto ignore;
-
-                case HID_UP_KEYBOARD:
+        case HID_UP_KEYBOARD:
+                set_bit(EV_REP, input->evbit);
 
-                        set_bit(EV_REP, input->evbit);
+                if ((usage->hid & HID_USAGE) < 256) {
+                        if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
+                        map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
+                } else
+                        map_key(KEY_UNKNOWN);
 
-                        if ((usage->hid & HID_USAGE) < 256) {
-                                if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
-                                map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
-                        } else
-                                map_key(KEY_UNKNOWN);
+                break;
 
-                        break;
+        case HID_UP_BUTTON:
+                code = ((usage->hid - 1) & 0xf);
 
-                case HID_UP_BUTTON:
-
-                        code = ((usage->hid - 1) & 0xf);
-
-                        switch (field->application) {
-                                case HID_GD_MOUSE:
-                                case HID_GD_POINTER:  code += 0x110; break;
-                                case HID_GD_JOYSTICK: code += 0x120; break;
-                                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                default:
-                                        switch (field->physical) {
-                                                case HID_GD_MOUSE:
-                                                case HID_GD_POINTER:  code += 0x110; break;
-                                                case HID_GD_JOYSTICK: code += 0x120; break;
-                                                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                                default:              code += 0x100;
-                                        }
-                        }
-
-                        /* Special handling for Logitech Cordless Desktop */
-                        if (field->application != HID_GD_MOUSE) {
-                                if (device->quirks & HID_QUIRK_LOGITECH_EXPANDED_KEYMAP) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid < LOGITECH_EXPANDED_KEYMAP_SIZE && logitech_expanded_keymap[hid] != 0)
-                                                code = logitech_expanded_keymap[hid];
-                                }
-                        } else {
-                                if (device->quirks & HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid == 7 || hid == 8)
-                                                goto ignore;
-                                }
+                switch (field->application) {
+                case HID_GD_MOUSE:
+                case HID_GD_POINTER:  code += 0x110; break;
+                case HID_GD_JOYSTICK: code += 0x120; break;
+                case HID_GD_GAMEPAD:  code += 0x130; break;
+                default:
+                        switch (field->physical) {
+                        case HID_GD_MOUSE:
+                        case HID_GD_POINTER:  code += 0x110; break;
+                        case HID_GD_JOYSTICK: code += 0x120; break;
+                        case HID_GD_GAMEPAD:  code += 0x130; break;
+                        default:              code += 0x100;
                         }
+                }
 
-                        map_key(code);
-                        break;
-
-
-                case HID_UP_SIMULATION:
-
-                        switch (usage->hid & 0xffff) {
-                                case 0xba: map_abs(ABS_RUDDER);   break;
-                                case 0xbb: map_abs(ABS_THROTTLE); break;
-                                case 0xc4: map_abs(ABS_GAS);      break;
-                                case 0xc5: map_abs(ABS_BRAKE);    break;
-                                case 0xc8: map_abs(ABS_WHEEL);    break;
-                                default:   goto ignore;
+                map_key(code);
+                break;
+
+        case HID_UP_SIMULATION:
+                switch (usage->hid & 0xffff) {
+                case 0xba: map_abs(ABS_RUDDER);   break;
+                case 0xbb: map_abs(ABS_THROTTLE); break;
+                case 0xc4: map_abs(ABS_GAS);      break;
+                case 0xc5: map_abs(ABS_BRAKE);    break;
+                case 0xc8: map_abs(ABS_WHEEL);    break;
+                default:   goto ignore;
+                }
+                break;
+
+        case HID_UP_GENDESK:
+                if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
+                        switch (usage->hid & 0xf) {
+                        case 0x1: map_key_clear(KEY_POWER);  break;
+                        case 0x2: map_key_clear(KEY_SLEEP);  break;
+                        case 0x3: map_key_clear(KEY_WAKEUP); break;
+                        default: goto unknown;
                         }
                         break;
+                }
 
-                case HID_UP_GENDESK:
-
-                        if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
-                                switch (usage->hid & 0xf) {
-                                        case 0x1: map_key_clear(KEY_POWER);  break;
-                                        case 0x2: map_key_clear(KEY_SLEEP);  break;
-                                        case 0x3: map_key_clear(KEY_WAKEUP); break;
-                                        default: goto unknown;
-                                }
-                                break;
-                        }
-
-                        if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
-                                switch (usage->hid) {
-                                        case HID_GD_UP:    usage->hat_dir = 1; break;
-                                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
-                                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
-                                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
-                                        default: goto unknown;
-                                }
-                                if (field->dpad) {
-                                        map_abs(field->dpad);
-                                        goto ignore;
-                                }
-                                map_abs(ABS_HAT0X);
-                                break;
-                        }
-
+                if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
                         switch (usage->hid) {
-
-                                /* These usage IDs map directly to the usage codes. */
-                                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
-                                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
-                                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
-                                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
-                                                map_rel(usage->hid & 0xf);
-                                        else
-                                                map_abs(usage->hid & 0xf);
-                                        break;
-
-                                case HID_GD_HATSWITCH:
-                                        usage->hat_min = field->logical_minimum;
-                                        usage->hat_max = field->logical_maximum;
-                                        map_abs(ABS_HAT0X);
-                                        break;
-
-                                case HID_GD_START:      map_key_clear(BTN_START);       break;
-                                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
-
-                                default: goto unknown;
+                        case HID_GD_UP:    usage->hat_dir = 1; break;
+                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
+                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
+                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
+                        default: goto unknown;
                         }
-
-                        break;
-
-                case HID_UP_LED:
-
-                        switch (usage->hid & 0xffff) {                        /* HID-Value:                   */
-                                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
-                                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
-                                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
-                                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
-                                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
-                                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
-                                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
-                                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
-                                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
-                                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
-                                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
-
-                                default: goto ignore;
+                        if (field->dpad) {
+                                map_abs(field->dpad);
+                                goto ignore;
                         }
+                        map_abs(ABS_HAT0X);
                         break;
+                }
 
-                case HID_UP_DIGITIZER:
-
-                        switch (usage->hid & 0xff) {
-
-                                case 0x30: /* TipPressure */
-                                        if (!test_bit(BTN_TOUCH, input->keybit)) {
-                                                device->quirks |= HID_QUIRK_NOTOUCH;
-                                                set_bit(EV_KEY, input->evbit);
-                                                set_bit(BTN_TOUCH, input->keybit);
-                                        }
-
-                                        map_abs_clear(ABS_PRESSURE);
-                                        break;
-
-                                case 0x32: /* InRange */
-                                        switch (field->physical & 0xff) {
-                                                case 0x21: map_key(BTN_TOOL_MOUSE); break;
-                                                case 0x22: map_key(BTN_TOOL_FINGER); break;
-                                                default: map_key(BTN_TOOL_PEN); break;
-                                        }
-                                        break;
+                switch (usage->hid) {
+                /* These usage IDs map directly to the usage codes. */
+                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
+                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
+                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
+                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
+                                map_rel(usage->hid & 0xf);
+                        else
+                                map_abs(usage->hid & 0xf);
+                        break;
 
-                                case 0x3c: /* Invert */
-                                        map_key_clear(BTN_TOOL_RUBBER);
-                                        break;
+                case HID_GD_HATSWITCH:
+                        usage->hat_min = field->logical_minimum;
+                        usage->hat_max = field->logical_maximum;
+                        map_abs(ABS_HAT0X);
+                        break;
 
-                                case 0x33: /* Touch */
-                                case 0x42: /* TipSwitch */
-                                case 0x43: /* TipSwitch2 */
-                                        device->quirks &= ~HID_QUIRK_NOTOUCH;
-                                        map_key_clear(BTN_TOUCH);
-                                        break;
+                case HID_GD_START:      map_key_clear(BTN_START);       break;
+                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
 
-                                case 0x44: /* BarrelSwitch */
-                                        map_key_clear(BTN_STYLUS);
-                                        break;
+                default: goto unknown;
+                }
 
-                                default:  goto unknown;
+                break;
+
+        case HID_UP_LED:
+                switch (usage->hid & 0xffff) {                /* HID-Value:                   */
+                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
+                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
+                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
+                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
+                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
+                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
+                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
+                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
+                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
+                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
+                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
+
+                default: goto ignore;
+                }
+                break;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid & 0xff) {
+                case 0x30: /* TipPressure */
+                        if (!test_bit(BTN_TOUCH, input->keybit)) {
+                                device->quirks |= HID_QUIRK_NOTOUCH;
+                                set_bit(EV_KEY, input->evbit);
+                                set_bit(BTN_TOUCH, input->keybit);
                         }
+                        map_abs_clear(ABS_PRESSURE);
                         break;
 
-                case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
-
-                        switch (usage->hid & HID_USAGE) {
-                                case 0x000: goto ignore;
-                                case 0x034: map_key_clear(KEY_SLEEP);           break;
-                                case 0x036: map_key_clear(BTN_MISC);            break;
-
-                                case 0x040: map_key_clear(KEY_MENU);            break;
-                                case 0x045: map_key_clear(KEY_RADIO);           break;
-
-                                case 0x083: map_key_clear(KEY_LAST);            break;
-                                case 0x088: map_key_clear(KEY_PC);              break;
-                                case 0x089: map_key_clear(KEY_TV);              break;
-                                case 0x08a: map_key_clear(KEY_WWW);             break;
-                                case 0x08b: map_key_clear(KEY_DVD);             break;
-                                case 0x08c: map_key_clear(KEY_PHONE);           break;
-                                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
-                                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
-                                case 0x08f: map_key_clear(KEY_GAMES);           break;
-                                case 0x090: map_key_clear(KEY_MEMO);            break;
-                                case 0x091: map_key_clear(KEY_CD);              break;
-                                case 0x092: map_key_clear(KEY_VCR);             break;
-                                case 0x093: map_key_clear(KEY_TUNER);           break;
-                                case 0x094: map_key_clear(KEY_EXIT);            break;
-                                case 0x095: map_key_clear(KEY_HELP);            break;
-                                case 0x096: map_key_clear(KEY_TAPE);            break;
-                                case 0x097: map_key_clear(KEY_TV2);             break;
-                                case 0x098: map_key_clear(KEY_SAT);             break;
-                                case 0x09a: map_key_clear(KEY_PVR);             break;
-
-                                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
-                                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
-                                case 0x0a0: map_key_clear(KEY_VCR2);            break;
-
-                                case 0x0b0: map_key_clear(KEY_PLAY);            break;
-                                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
-                                case 0x0b2: map_key_clear(KEY_RECORD);          break;
-                                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
-                                case 0x0b4: map_key_clear(KEY_REWIND);          break;
-                                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
-                                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
-                                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
-                                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
-                                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
-
-                                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
-                                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
-                                case 0x0e2: map_key_clear(KEY_MUTE);            break;
-                                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
-                                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
-                                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
-
-                                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x183: map_key_clear(KEY_CONFIG);          break;
-                                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
-                                case 0x185: map_key_clear(KEY_EDITOR);          break;
-                                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
-                                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
-                                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
-                                case 0x189: map_key_clear(KEY_DATABASE);        break;
-                                case 0x18a: map_key_clear(KEY_MAIL);            break;
-                                case 0x18b: map_key_clear(KEY_NEWS);            break;
-                                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
-                                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
-                                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
-                                case 0x191: map_key_clear(KEY_FINANCE);         break;
-                                case 0x192: map_key_clear(KEY_CALC);            break;
-                                case 0x194: map_key_clear(KEY_FILE);            break;
-                                case 0x196: map_key_clear(KEY_WWW);             break;
-                                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
-                                case 0x19e: map_key_clear(KEY_COFFEE);          break;
-                                case 0x1a6: map_key_clear(KEY_HELP);            break;
-                                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
-                                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
-                                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
-                                case 0x1b7: map_key_clear(KEY_SOUND);           break;
-                                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
-                                case 0x1bd: map_key_clear(KEY_INFO);            break;
-                                case 0x201: map_key_clear(KEY_NEW);             break;
-                                case 0x202: map_key_clear(KEY_OPEN);            break;
-                                case 0x203: map_key_clear(KEY_CLOSE);           break;
-                                case 0x204: map_key_clear(KEY_EXIT);            break;
-                                case 0x207: map_key_clear(KEY_SAVE);            break;
-                                case 0x208: map_key_clear(KEY_PRINT);           break;
-                                case 0x209: map_key_clear(KEY_PROPS);           break;
-                                case 0x21a: map_key_clear(KEY_UNDO);            break;
-                                case 0x21b: map_key_clear(KEY_COPY);            break;
-                                case 0x21c: map_key_clear(KEY_CUT);             break;
-                                case 0x21d: map_key_clear(KEY_PASTE);           break;
-                                case 0x21f: map_key_clear(KEY_FIND);            break;
-                                case 0x221: map_key_clear(KEY_SEARCH);          break;
-                                case 0x222: map_key_clear(KEY_GOTO);            break;
-                                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
-                                case 0x224: map_key_clear(KEY_BACK);            break;
-                                case 0x225: map_key_clear(KEY_FORWARD);         break;
-                                case 0x226: map_key_clear(KEY_STOP);            break;
-                                case 0x227: map_key_clear(KEY_REFRESH);         break;
-                                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
-                                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
-                                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
-                                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
-                                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
-                                case 0x238: map_rel(REL_HWHEEL);                break;
-                                case 0x25f: map_key_clear(KEY_CANCEL);          break;
-                                case 0x279: map_key_clear(KEY_REDO);            break;
-
-                                case 0x289: map_key_clear(KEY_REPLY);           break;
-                                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
-                                case 0x28c: map_key_clear(KEY_SEND);            break;
-
-                                default:    goto ignore;
+                case 0x32: /* InRange */
+                        switch (field->physical & 0xff) {
+                        case 0x21: map_key(BTN_TOOL_MOUSE); break;
+                        case 0x22: map_key(BTN_TOOL_FINGER); break;
+                        default: map_key(BTN_TOOL_PEN); break;
                         }
                         break;
 
-                case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
-
-                        set_bit(EV_REP, input->evbit);
-                        switch (usage->hid & HID_USAGE) {
-                                case 0x021: map_key_clear(KEY_PRINT);           break;
-                                case 0x070: map_key_clear(KEY_HP);              break;
-                                case 0x071: map_key_clear(KEY_CAMERA);          break;
-                                case 0x072: map_key_clear(KEY_SOUND);           break;
-                                case 0x073: map_key_clear(KEY_QUESTION);        break;
-                                case 0x080: map_key_clear(KEY_EMAIL);           break;
-                                case 0x081: map_key_clear(KEY_CHAT);            break;
-                                case 0x082: map_key_clear(KEY_SEARCH);          break;
-                                case 0x083: map_key_clear(KEY_CONNECT);         break;
-                                case 0x084: map_key_clear(KEY_FINANCE);         break;
-                                case 0x085: map_key_clear(KEY_SPORT);           break;
-                                case 0x086: map_key_clear(KEY_SHOP);            break;
-                                default:    goto ignore;
-                        }
+                case 0x3c: /* Invert */
+                        map_key_clear(BTN_TOOL_RUBBER);
                         break;
 
-                case HID_UP_MSVENDOR:
-
-                        goto ignore;
-
-                case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
-
-                        set_bit(EV_REP, input->evbit);
-                        switch(usage->hid & HID_USAGE) {
-                                case 0x003:
-                                        /* The fn key on Apple USB keyboards */
-                                        map_key_clear(KEY_FN);
-                                        hidinput_apple_setup(input);
-                                        break;
+                case 0x33: /* Touch */
+                case 0x42: /* TipSwitch */
+                case 0x43: /* TipSwitch2 */
+                        device->quirks &= ~HID_QUIRK_NOTOUCH;
+                        map_key_clear(BTN_TOUCH);
+                        break;
 
-                                default:    goto ignore;
-                        }
+                case 0x44: /* BarrelSwitch */
+                        map_key_clear(BTN_STYLUS);
                         break;
 
-                case HID_UP_LOGIVENDOR:
+                default:  goto unknown;
+                }
+                break;
+
+        case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
+                switch (usage->hid & HID_USAGE) {
+                case 0x000: goto ignore;
+                case 0x034: map_key_clear(KEY_SLEEP);           break;
+                case 0x036: map_key_clear(BTN_MISC);            break;
+
+                case 0x040: map_key_clear(KEY_MENU);            break;
+                case 0x045: map_key_clear(KEY_RADIO);           break;
+
+                case 0x083: map_key_clear(KEY_LAST);            break;
+                case 0x088: map_key_clear(KEY_PC);              break;
+                case 0x089: map_key_clear(KEY_TV);              break;
+                case 0x08a: map_key_clear(KEY_WWW);             break;
+                case 0x08b: map_key_clear(KEY_DVD);             break;
+                case 0x08c: map_key_clear(KEY_PHONE);           break;
+                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
+                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
+                case 0x08f: map_key_clear(KEY_GAMES);           break;
+                case 0x090: map_key_clear(KEY_MEMO);            break;
+                case 0x091: map_key_clear(KEY_CD);              break;
+                case 0x092: map_key_clear(KEY_VCR);             break;
+                case 0x093: map_key_clear(KEY_TUNER);           break;
+                case 0x094: map_key_clear(KEY_EXIT);            break;
+                case 0x095: map_key_clear(KEY_HELP);            break;
+                case 0x096: map_key_clear(KEY_TAPE);            break;
+                case 0x097: map_key_clear(KEY_TV2);             break;
+                case 0x098: map_key_clear(KEY_SAT);             break;
+                case 0x09a: map_key_clear(KEY_PVR);             break;
+
+                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
+                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
+                case 0x0a0: map_key_clear(KEY_VCR2);            break;
+
+                case 0x0b0: map_key_clear(KEY_PLAY);            break;
+                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
+                case 0x0b2: map_key_clear(KEY_RECORD);          break;
+                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
+                case 0x0b4: map_key_clear(KEY_REWIND);          break;
+                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
+                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
+                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
+                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
+                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
+
+                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
+                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
+                case 0x0e2: map_key_clear(KEY_MUTE);            break;
+                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
+                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
+                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
+
+                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x183: map_key_clear(KEY_CONFIG);          break;
+                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
+                case 0x185: map_key_clear(KEY_EDITOR);          break;
+                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
+                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
+                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
+                case 0x189: map_key_clear(KEY_DATABASE);        break;
+                case 0x18a: map_key_clear(KEY_MAIL);            break;
+                case 0x18b: map_key_clear(KEY_NEWS);            break;
+                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
+                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
+                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
+                case 0x191: map_key_clear(KEY_FINANCE);         break;
+                case 0x192: map_key_clear(KEY_CALC);            break;
+                case 0x194: map_key_clear(KEY_FILE);            break;
+                case 0x196: map_key_clear(KEY_WWW);             break;
+                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
+                case 0x19e: map_key_clear(KEY_COFFEE);          break;
+                case 0x1a6: map_key_clear(KEY_HELP);            break;
+                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
+                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
+                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
+                case 0x1b7: map_key_clear(KEY_SOUND);           break;
+                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
+                case 0x1bd: map_key_clear(KEY_INFO);            break;
+                case 0x201: map_key_clear(KEY_NEW);             break;
+                case 0x202: map_key_clear(KEY_OPEN);            break;
+                case 0x203: map_key_clear(KEY_CLOSE);           break;
+                case 0x204: map_key_clear(KEY_EXIT);            break;
+                case 0x207: map_key_clear(KEY_SAVE);            break;
+                case 0x208: map_key_clear(KEY_PRINT);           break;
+                case 0x209: map_key_clear(KEY_PROPS);           break;
+                case 0x21a: map_key_clear(KEY_UNDO);            break;
+                case 0x21b: map_key_clear(KEY_COPY);            break;
+                case 0x21c: map_key_clear(KEY_CUT);             break;
+                case 0x21d: map_key_clear(KEY_PASTE);           break;
+                case 0x21f: map_key_clear(KEY_FIND);            break;
+                case 0x221: map_key_clear(KEY_SEARCH);          break;
+                case 0x222: map_key_clear(KEY_GOTO);            break;
+                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
+                case 0x224: map_key_clear(KEY_BACK);            break;
+                case 0x225: map_key_clear(KEY_FORWARD);         break;
+                case 0x226: map_key_clear(KEY_STOP);            break;
+                case 0x227: map_key_clear(KEY_REFRESH);         break;
+                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
+                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
+                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
+                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
+                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
+                case 0x238: map_rel(REL_HWHEEL);                break;
+                case 0x25f: map_key_clear(KEY_CANCEL);          break;
+                case 0x279: map_key_clear(KEY_REDO);            break;
+
+                case 0x289: map_key_clear(KEY_REPLY);           break;
+                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
+                case 0x28c: map_key_clear(KEY_SEND);            break;
+
+                default:    goto ignore;
+                }
+                break;
+
+        case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
+                set_bit(EV_REP, input->evbit);
+                switch (usage->hid & HID_USAGE) {
+                case 0x021: map_key_clear(KEY_PRINT);           break;
+                case 0x070: map_key_clear(KEY_HP);              break;
+                case 0x071: map_key_clear(KEY_CAMERA);          break;
+                case 0x072: map_key_clear(KEY_SOUND);           break;
+                case 0x073: map_key_clear(KEY_QUESTION);        break;
+                case 0x080: map_key_clear(KEY_EMAIL);           break;
+                case 0x081: map_key_clear(KEY_CHAT);            break;
+                case 0x082: map_key_clear(KEY_SEARCH);          break;
+                case 0x083: map_key_clear(KEY_CONNECT);         break;
+                case 0x084: map_key_clear(KEY_FINANCE);         break;
+                case 0x085: map_key_clear(KEY_SPORT);           break;
+                case 0x086: map_key_clear(KEY_SHOP);            break;
+                default:    goto ignore;
+                }
+                break;
 
-                        goto ignore;
-                
-                case HID_UP_PID:
+        case HID_UP_MSVENDOR:
+                goto ignore;
 
-                        switch(usage->hid & HID_USAGE) {
-                                case 0xa4: map_key_clear(BTN_DEAD);     break;
-                                default: goto ignore;
-                        }
-                        break;
+        case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
+                set_bit(EV_REP, input->evbit);
+                goto ignore;
 
-                default:
-                unknown:
-                        if (field->report_size == 1) {
-                                if (field->report->type == HID_OUTPUT_REPORT) {
-                                        map_led(LED_MISC);
-                                        break;
-                                }
-                                map_key(BTN_MISC);
-                                break;
-                        }
-                        if (field->flags & HID_MAIN_ITEM_RELATIVE) {
-                                map_rel(REL_MISC);
+        case HID_UP_LOGIVENDOR:
+                goto ignore;
+        
+        case HID_UP_PID:
+                switch (usage->hid & HID_USAGE) {
+                case 0xa4: map_key_clear(BTN_DEAD);     break;
+                default: goto ignore;
+                }
+                break;
+
+        default:
+        unknown:
+                if (field->report_size == 1) {
+                        if (field->report->type == HID_OUTPUT_REPORT) {
+                                map_led(LED_MISC);
                                 break;
                         }
-                        map_abs(ABS_MISC);
+                        map_key(BTN_MISC);
+                        break;
+                }
+                if (field->flags & HID_MAIN_ITEM_RELATIVE) {
+                        map_rel(REL_MISC);
                         break;
+                }
+                map_abs(ABS_MISC);
+                break;
         }
 
 mapped:
-        if (device->quirks & HID_QUIRK_MIGHTYMOUSE) {
-                if (usage->hid == HID_GD_Z)
-                        map_rel(REL_HWHEEL);
-                else if (usage->code == BTN_1)
-                        map_key(BTN_2);
-                else if (usage->code == BTN_2)
-                        map_key(BTN_1);
-        }
-
-        if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5 |
-                        HID_QUIRK_2WHEEL_MOUSE_HACK_B8)) && (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL))
-                set_bit(REL_HWHEEL, bit);
-
-        if (((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007)))
+        if (device->driver->input_mapped && device->driver->input_mapped(device,
+                                hidinput, field, usage, &bit, &max) < 0)
                 goto ignore;
 
-        if ((device->quirks & HID_QUIRK_BAD_RELATIVE_KEYS) &&
-                usage->type == EV_KEY && (field->flags & HID_MAIN_ITEM_RELATIVE))
-                field->flags &= ~HID_MAIN_ITEM_RELATIVE;
-
         set_bit(usage->type, input->evbit);
 
-        if (device->quirks & HID_QUIRK_DUPLICATE_USAGES &&
-                        (usage->type == EV_KEY ||
-                         usage->type == EV_REL ||
-                         usage->type == EV_ABS))
-                clear_bit(usage->code, bit);
-
         while (usage->code <= max && test_and_set_bit(usage->code, bit))
                 usage->code = find_next_zero_bit(bit, max + 1, usage->code);
 
@@ -858,10 +585,6 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
         if (!usage->type)
                 return;
 
-        /* handle input events for quirky devices */
-        if (hidinput_event_quirks(hid, field, usage, value))
-                return;
-
         if (usage->hat_min < usage->hat_max || usage->hat_dir) {
                 int hat_dir = usage->hat_dir;
                 if (!hat_dir)
@@ -961,14 +684,14 @@ static int hidinput_open(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        return hid->hid_open(hid);
+        return hid->ll_driver->open(hid);
 }
 
 static void hidinput_close(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        hid->hid_close(hid);
+        hid->ll_driver->close(hid);
 }
 
 /*
@@ -977,7 +700,7 @@ static void hidinput_close(struct input_dev *dev)
  * Read all reports and initialize the absolute field values.
  */
 
-int hidinput_connect(struct hid_device *hid)
+int hidinput_connect(struct hid_device *hid, unsigned int force)
 {
         struct hid_report *report;
         struct hid_input *hidinput = NULL;
@@ -985,19 +708,20 @@ int hidinput_connect(struct hid_device *hid)
         int i, j, k;
         int max_report_type = HID_OUTPUT_REPORT;
 
-        if (hid->quirks & HID_QUIRK_IGNORE_HIDINPUT)
-                return -1;
-
         INIT_LIST_HEAD(&hid->inputs);
 
-        for (i = 0; i < hid->maxcollection; i++)
-                if (hid->collection[i].type == HID_COLLECTION_APPLICATION ||
-                    hid->collection[i].type == HID_COLLECTION_PHYSICAL)
-                        if (IS_INPUT_APPLICATION(hid->collection[i].usage))
-                                break;
+        if (!force) {
+                for (i = 0; i < hid->maxcollection; i++) {
+                        struct hid_collection *col = &hid->collection[i];
+                        if (col->type == HID_COLLECTION_APPLICATION ||
+                                        col->type == HID_COLLECTION_PHYSICAL)
+                                if (IS_INPUT_APPLICATION(col->usage))
+                                        break;
+                }
 
-        if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDINPUT) == 0)
-                return -1;
+                if (i == hid->maxcollection)
+                        return -1;
+        }
 
         if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
                 max_report_type = HID_INPUT_REPORT;
@@ -1019,7 +743,8 @@ int hidinput_connect(struct hid_device *hid)
                                 }
 
                                 input_set_drvdata(input_dev, hid);
-                                input_dev->event = hid->hidinput_input_event;
+                                input_dev->event =
+                                        hid->ll_driver->hidinput_input_event;
                                 input_dev->open = hidinput_open;
                                 input_dev->close = hidinput_close;
                                 input_dev->setkeycode = hidinput_setkeycode;
@@ -1032,7 +757,7 @@ int hidinput_connect(struct hid_device *hid)
                                 input_dev->id.vendor  = hid->vendor;
                                 input_dev->id.product = hid->product;
                                 input_dev->id.version = hid->version;
-                                input_dev->dev.parent = hid->dev;
+                                input_dev->dev.parent = hid->dev.parent;
                                 hidinput->input = input_dev;
                                 list_add_tail(&hidinput->list, &hid->inputs);
                         }
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
new file mode 100644
index 000000000000..406d8c82abf1
--- /dev/null
+++ b/drivers/hid/hid-lg.c
@@ -0,0 +1,342 @@
+/*
+ *  HID driver for some logitech "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+#include "hid-lg.h"
+
+#define LG_RDESC                0x001
+#define LG_BAD_RELATIVE_KEYS    0x002
+#define LG_DUPLICATE_USAGES     0x004
+#define LG_RESET_LEDS           0x008
+#define LG_EXPANDED_KEYMAP      0x010
+#define LG_IGNORE_DOUBLED_WHEEL 0x020
+#define LG_WIRELESS             0x040
+#define LG_INVERT_HWHEEL        0x080
+#define LG_NOGET                0x100
+#define LG_FF                   0x200
+#define LG_FF2                  0x400
+
+/*
+ * Certain Logitech keyboards send in report #3 keys which are far
+ * above the logical maximum described in descriptor. This extends
+ * the original value of 0x28c of logical maximum to 0x104d
+ */
+static void lg_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((quirks & LG_RDESC) && rsize >= 90 && rdesc[83] == 0x26 &&
+                        rdesc[84] == 0x8c && rdesc[85] == 0x02) {
+                dev_info(&hdev->dev, "fixing up Logitech keyboard report "
+                                "descriptor\n");
+                rdesc[84] = rdesc[89] = 0x4d;
+                rdesc[85] = rdesc[90] = 0x10;
+        }
+}
+
+#define lg_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                EV_KEY, (c))
+
+static int lg_ultrax_remote_mapping(struct hid_input *hi,
+                struct hid_usage *usage, unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
+                return 0;
+
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        /* Reported on Logitech Ultra X Media Remote */
+        case 0x004: lg_map_key_clear(KEY_AGAIN);        break;
+        case 0x00d: lg_map_key_clear(KEY_HOME);         break;
+        case 0x024: lg_map_key_clear(KEY_SHUFFLE);      break;
+        case 0x025: lg_map_key_clear(KEY_TV);           break;
+        case 0x026: lg_map_key_clear(KEY_MENU);         break;
+        case 0x031: lg_map_key_clear(KEY_AUDIO);        break;
+        case 0x032: lg_map_key_clear(KEY_TEXT);         break;
+        case 0x033: lg_map_key_clear(KEY_LAST);         break;
+        case 0x047: lg_map_key_clear(KEY_MP3);          break;
+        case 0x048: lg_map_key_clear(KEY_DVD);          break;
+        case 0x049: lg_map_key_clear(KEY_MEDIA);        break;
+        case 0x04a: lg_map_key_clear(KEY_VIDEO);        break;
+        case 0x04b: lg_map_key_clear(KEY_ANGLE);        break;
+        case 0x04c: lg_map_key_clear(KEY_LANGUAGE);     break;
+        case 0x04d: lg_map_key_clear(KEY_SUBTITLE);     break;
+        case 0x051: lg_map_key_clear(KEY_RED);          break;
+        case 0x052: lg_map_key_clear(KEY_CLOSE);        break;
+
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int lg_wireless_mapping(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x1001: lg_map_key_clear(KEY_MESSENGER);           break;
+        case 0x1003: lg_map_key_clear(KEY_SOUND);               break;
+        case 0x1004: lg_map_key_clear(KEY_VIDEO);               break;
+        case 0x1005: lg_map_key_clear(KEY_AUDIO);               break;
+        case 0x100a: lg_map_key_clear(KEY_DOCUMENTS);           break;
+        case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG);        break;
+        case 0x1012: lg_map_key_clear(KEY_NEXTSONG);            break;
+        case 0x1013: lg_map_key_clear(KEY_CAMERA);              break;
+        case 0x1014: lg_map_key_clear(KEY_MESSENGER);           break;
+        case 0x1015: lg_map_key_clear(KEY_RECORD);              break;
+        case 0x1016: lg_map_key_clear(KEY_PLAYER);              break;
+        case 0x1017: lg_map_key_clear(KEY_EJECTCD);             break;
+        case 0x1018: lg_map_key_clear(KEY_MEDIA);               break;
+        case 0x1019: lg_map_key_clear(KEY_PROG1);               break;
+        case 0x101a: lg_map_key_clear(KEY_PROG2);               break;
+        case 0x101b: lg_map_key_clear(KEY_PROG3);               break;
+        case 0x101f: lg_map_key_clear(KEY_ZOOMIN);              break;
+        case 0x1020: lg_map_key_clear(KEY_ZOOMOUT);             break;
+        case 0x1021: lg_map_key_clear(KEY_ZOOMRESET);           break;
+        case 0x1023: lg_map_key_clear(KEY_CLOSE);               break;
+        case 0x1027: lg_map_key_clear(KEY_MENU);                break;
+        /* this one is marked as 'Rotate' */
+        case 0x1028: lg_map_key_clear(KEY_ANGLE);               break;
+        case 0x1029: lg_map_key_clear(KEY_SHUFFLE);             break;
+        case 0x102a: lg_map_key_clear(KEY_BACK);                break;
+        case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS);        break;
+        case 0x1041: lg_map_key_clear(KEY_BATTERY);             break;
+        case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR);       break;
+        case 0x1043: lg_map_key_clear(KEY_SPREADSHEET);         break;
+        case 0x1044: lg_map_key_clear(KEY_PRESENTATION);        break;
+        case 0x1045: lg_map_key_clear(KEY_UNDO);                break;
+        case 0x1046: lg_map_key_clear(KEY_REDO);                break;
+        case 0x1047: lg_map_key_clear(KEY_PRINT);               break;
+        case 0x1048: lg_map_key_clear(KEY_SAVE);                break;
+        case 0x1049: lg_map_key_clear(KEY_PROG1);               break;
+        case 0x104a: lg_map_key_clear(KEY_PROG2);               break;
+        case 0x104b: lg_map_key_clear(KEY_PROG3);               break;
+        case 0x104c: lg_map_key_clear(KEY_PROG4);               break;
+
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int lg_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        /* extended mapping for certain Logitech hardware (Logitech cordless
+           desktop LX500) */
+        static const u8 e_keymap[] = {
+                  0,216,  0,213,175,156,  0,  0,  0,  0,
+                144,  0,  0,  0,  0,  0,  0,  0,  0,212,
+                174,167,152,161,112,  0,  0,  0,154,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                  0,  0,  0,  0,  0,183,184,185,186,187,
+                188,189,190,191,192,193,194,  0,  0,  0
+        };
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+        unsigned int hid = usage->hid;
+
+        if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER &&
+                        lg_ultrax_remote_mapping(hi, usage, bit, max))
+                return 1;
+
+        if ((quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max))
+                return 1;
+
+        if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
+                return 0;
+
+        hid &= HID_USAGE;
+
+        /* Special handling for Logitech Cordless Desktop */
+        if (field->application == HID_GD_MOUSE) {
+                if ((quirks & LG_IGNORE_DOUBLED_WHEEL) &&
+                                (hid == 7 || hid == 8))
+                        return -1;
+        } else {
+                if ((quirks & LG_EXPANDED_KEYMAP) &&
+                                hid < ARRAY_SIZE(e_keymap) &&
+                                e_keymap[hid] != 0) {
+                        hid_map_usage(hi, usage, bit, max, EV_KEY,
+                                        e_keymap[hid]);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+static int lg_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY &&
+                        (field->flags & HID_MAIN_ITEM_RELATIVE))
+                field->flags &= ~HID_MAIN_ITEM_RELATIVE;
+
+        if ((quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY ||
+                         usage->type == EV_REL || usage->type == EV_ABS))
+                clear_bit(usage->code, *bit);
+
+        return 0;
+}
+
+static int lg_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) {
+                input_event(field->hidinput->input, usage->type, usage->code,
+                                -value);
+                return 1;
+        }
+
+        return 0;
+}
+
+static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        unsigned int connect_mask = HID_CONNECT_DEFAULT;
+        int ret;
+
+        hid_set_drvdata(hdev, (void *)quirks);
+
+        if (quirks & LG_NOGET)
+                hdev->quirks |= HID_QUIRK_NOGET;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        if (quirks & (LG_FF | LG_FF2))
+                connect_mask &= ~HID_CONNECT_FF;
+
+        ret = hid_hw_start(hdev, connect_mask);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        if (quirks & LG_RESET_LEDS)
+                usbhid_set_leds(hdev);
+
+        if (quirks & LG_FF)
+                lgff_init(hdev);
+        if (quirks & LG_FF2)
+                lg2ff_init(hdev);
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id lg_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
+                .driver_data = LG_RDESC | LG_WIRELESS },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
+                .driver_data = LG_BAD_RELATIVE_KEYS },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
+                .driver_data = LG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
+                .driver_data = LG_DUPLICATE_USAGES },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
+                .driver_data = LG_DUPLICATE_USAGES },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD),
+                .driver_data = LG_RESET_LEDS },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
+                .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
+                .driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3),
+                .driver_data = LG_INVERT_HWHEEL },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150),
+                .driver_data = LG_INVERT_HWHEEL },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
+                .driver_data = LG_NOGET },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
+                .driver_data = LG_NOGET | LG_FF },
+
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
+                .driver_data = LG_FF },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
+                .driver_data = LG_FF2 },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, lg_devices);
+
+static struct hid_driver lg_driver = {
+        .name = "logitech",
+        .id_table = lg_devices,
+        .report_fixup = lg_report_fixup,
+        .input_mapping = lg_input_mapping,
+        .input_mapped = lg_input_mapped,
+        .event = lg_event,
+        .probe = lg_probe,
+};
+
+static int lg_init(void)
+{
+        return hid_register_driver(&lg_driver);
+}
+
+static void lg_exit(void)
+{
+        hid_unregister_driver(&lg_driver);
+}
+
+module_init(lg_init);
+module_exit(lg_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(logitech);
diff --git a/drivers/hid/hid-lg.h b/drivers/hid/hid-lg.h
new file mode 100644
index 000000000000..27ae750ca878
--- /dev/null
+++ b/drivers/hid/hid-lg.h
@@ -0,0 +1,18 @@
+#ifndef __HID_LG_H
+#define __HID_LG_H
+
+#include <linux/autoconf.h>
+
+#ifdef CONFIG_LOGITECH_FF
+int lgff_init(struct hid_device *hdev);
+#else
+static inline int lgff_init(struct hid_device *hdev) { return -1; }
+#endif
+
+#ifdef CONFIG_LOGIRUMBLEPAD2_FF
+int lg2ff_init(struct hid_device *hdev);
+#else
+static inline int lg2ff_init(struct hid_device *hdev) { return -1; }
+#endif
+
+#endif
diff --git a/drivers/hid/usbhid/hid-lg2ff.c b/drivers/hid/hid-lg2ff.c
index d469bd0061c9..4e6dc6e26523 100644
--- a/drivers/hid/usbhid/hid-lg2ff.c
+++ b/drivers/hid/hid-lg2ff.c
@@ -24,7 +24,9 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+
+#include "usbhid/usbhid.h"
+#include "hid-lg.h"
 
 struct lg2ff_device {
         struct hid_report *report;
@@ -57,7 +59,7 @@ static int play_effect(struct input_dev *dev, void *data,
         return 0;
 }
 
-int hid_lg2ff_init(struct hid_device *hid)
+int lg2ff_init(struct hid_device *hid)
 {
         struct lg2ff_device *lg2ff;
         struct hid_report *report;
@@ -69,18 +71,18 @@ int hid_lg2ff_init(struct hid_device *hid)
         int error;
 
         if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-lg2ff: no output report found\n");
+                dev_err(&hid->dev, "no output report found\n");
                 return -ENODEV;
         }
 
         report = list_entry(report_list->next, struct hid_report, list);
 
         if (report->maxfield < 1) {
-                printk(KERN_ERR "hid-lg2ff: output report is empty\n");
+                dev_err(&hid->dev, "output report is empty\n");
                 return -ENODEV;
         }
         if (report->field[0]->report_count < 7) {
-                printk(KERN_ERR "hid-lg2ff: not enough values in the field\n");
+                dev_err(&hid->dev, "not enough values in the field\n");
                 return -ENODEV;
         }
 
@@ -107,7 +109,7 @@ int hid_lg2ff_init(struct hid_device *hid)
 
         usbhid_submit_report(hid, report, USB_DIR_OUT);
 
-        printk(KERN_INFO "Force feedback for Logitech Rumblepad 2 by "
+        dev_info(&hid->dev, "Force feedback for Logitech Rumblepad 2 by "
                "Anssi Hannula <anssi.hannula@gmail.com>\n");
 
         return 0;
diff --git a/drivers/hid/usbhid/hid-lgff.c b/drivers/hid/hid-lgff.c
index 4b7ab6a46d93..51aff08e10ce 100644
--- a/drivers/hid/usbhid/hid-lgff.c
+++ b/drivers/hid/hid-lgff.c
@@ -30,7 +30,9 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+
+#include "usbhid/usbhid.h"
+#include "hid-lg.h"
 
 struct dev_type {
         u16 idVendor;
@@ -48,6 +50,12 @@ static const signed short ff_joystick[] = {
         -1
 };
 
+static const signed short ff_wheel[] = {
+        FF_CONSTANT,
+        FF_AUTOCENTER,
+        -1
+};
+
 static const struct dev_type devices[] = {
         { 0x046d, 0xc211, ff_rumble },
         { 0x046d, 0xc219, ff_rumble },
@@ -55,7 +63,7 @@ static const struct dev_type devices[] = {
         { 0x046d, 0xc286, ff_joystick },
         { 0x046d, 0xc294, ff_joystick },
         { 0x046d, 0xc295, ff_joystick },
-        { 0x046d, 0xca03, ff_joystick },
+        { 0x046d, 0xca03, ff_wheel },
 };
 
 static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
@@ -100,7 +108,24 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
         return 0;
 }
 
-int hid_lgff_init(struct hid_device* hid)
+static void hid_lgff_set_autocenter(struct input_dev *dev, u16 magnitude)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
+        __s32 *value = report->field[0]->value;
+        magnitude = (magnitude >> 12) & 0xf;
+        *value++ = 0xfe;
+        *value++ = 0x0d;
+        *value++ = magnitude;   /* clockwise strength */
+        *value++ = magnitude;   /* counter-clockwise strength */
+        *value++ = 0x80;
+        *value++ = 0x00;
+        *value = 0x00;
+        usbhid_submit_report(hid, report, USB_DIR_OUT);
+}
+
+int lgff_init(struct hid_device* hid)
 {
         struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
         struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
@@ -145,6 +170,9 @@ int hid_lgff_init(struct hid_device* hid)
         if (error)
                 return error;
 
+        if ( test_bit(FF_AUTOCENTER, dev->ffbit) )
+                dev->ff->set_autocenter = hid_lgff_set_autocenter;
+
         printk(KERN_INFO "Force feedback for Logitech force feedback devices by Johann Deneux <johann.deneux@it.uu.se>\n");
 
         return 0;
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
new file mode 100644
index 000000000000..d718b1607d0f
--- /dev/null
+++ b/drivers/hid/hid-microsoft.c
@@ -0,0 +1,219 @@
+/*
+ *  HID driver for some microsoft "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+#define MS_HIDINPUT     0x01
+#define MS_ERGONOMY     0x02
+#define MS_PRESENTER    0x04
+#define MS_RDESC        0x08
+#define MS_NOGET        0x10
+
+/*
+ * Microsoft Wireless Desktop Receiver (Model 1028) has several
+ * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
+ */
+static void ms_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((quirks & MS_RDESC) && rsize == 571 && rdesc[284] == 0x19 &&
+                        rdesc[286] == 0x2a && rdesc[304] == 0x19 &&
+                        rdesc[306] == 0x29 && rdesc[352] == 0x1a &&
+                        rdesc[355] == 0x2a && rdesc[557] == 0x19 &&
+                        rdesc[559] == 0x29) {
+                dev_info(&hdev->dev, "fixing up Microsoft Wireless Receiver "
+                                "Model 1028 report descriptor\n");
+                rdesc[284] = rdesc[304] = rdesc[557] = 0x35;
+                rdesc[352] = 0x36;
+                rdesc[286] = rdesc[355] = 0x46;
+                rdesc[306] = rdesc[559] = 0x45;
+        }
+}
+
+#define ms_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct input_dev *input = hi->input;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0xfd06: ms_map_key_clear(KEY_CHAT);        break;
+        case 0xfd07: ms_map_key_clear(KEY_PHONE);       break;
+        case 0xff05:
+                set_bit(EV_REP, input->evbit);
+                ms_map_key_clear(KEY_F13);
+                set_bit(KEY_F14, input->keybit);
+                set_bit(KEY_F15, input->keybit);
+                set_bit(KEY_F16, input->keybit);
+                set_bit(KEY_F17, input->keybit);
+                set_bit(KEY_F18, input->keybit);
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int ms_presenter_8k_quirk(struct hid_input *hi, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        set_bit(EV_REP, hi->input->evbit);
+        switch (usage->hid & HID_USAGE) {
+        case 0xfd08: ms_map_key_clear(KEY_FORWARD);     break;
+        case 0xfd09: ms_map_key_clear(KEY_BACK);        break;
+        case 0xfd0b: ms_map_key_clear(KEY_PLAYPAUSE);   break;
+        case 0xfd0e: ms_map_key_clear(KEY_CLOSE);       break;
+        case 0xfd0f: ms_map_key_clear(KEY_PLAY);        break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static int ms_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
+                return 0;
+
+        if (quirks & MS_ERGONOMY) {
+                int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
+                if (ret)
+                        return ret;
+        }
+
+        if ((quirks & MS_PRESENTER) &&
+                        ms_presenter_8k_quirk(hi, usage, bit, max))
+                return 1;
+
+        return 0;
+}
+
+static int ms_event(struct hid_device *hdev, struct hid_field *field,
+                struct hid_usage *usage, __s32 value)
+{
+        unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
+
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
+                        !usage->type)
+                return 0;
+
+        /* Handling MS keyboards special buttons */
+        if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
+                struct input_dev *input = field->hidinput->input;
+                static unsigned int last_key = 0;
+                unsigned int key = 0;
+                switch (value) {
+                case 0x01: key = KEY_F14; break;
+                case 0x02: key = KEY_F15; break;
+                case 0x04: key = KEY_F16; break;
+                case 0x08: key = KEY_F17; break;
+                case 0x10: key = KEY_F18; break;
+                }
+                if (key) {
+                        input_event(input, usage->type, key, 1);
+                        last_key = key;
+                } else
+                        input_event(input, usage->type, last_key, 0);
+
+                return 1;
+        }
+
+        return 0;
+}
+
+static int ms_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        unsigned long quirks = id->driver_data;
+        int ret;
+
+        hid_set_drvdata(hdev, (void *)quirks);
+
+        if (quirks & MS_NOGET)
+                hdev->quirks |= HID_QUIRK_NOGET;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | ((quirks & MS_HIDINPUT) ?
+                                HID_CONNECT_HIDINPUT_FORCE : 0));
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id ms_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
+                .driver_data = MS_HIDINPUT },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
+                .driver_data = MS_ERGONOMY },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
+                .driver_data = MS_ERGONOMY | MS_RDESC },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
+                .driver_data = MS_PRESENTER },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
+                .driver_data = MS_NOGET },
+
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT),
+                .driver_data = MS_PRESENTER },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ms_devices);
+
+static struct hid_driver ms_driver = {
+        .name = "microsoft",
+        .id_table = ms_devices,
+        .report_fixup = ms_report_fixup,
+        .input_mapping = ms_input_mapping,
+        .event = ms_event,
+        .probe = ms_probe,
+};
+
+static int ms_init(void)
+{
+        return hid_register_driver(&ms_driver);
+}
+
+static void ms_exit(void)
+{
+        hid_unregister_driver(&ms_driver);
+}
+
+module_init(ms_init);
+module_exit(ms_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(microsoft);
diff --git a/drivers/hid/hid-monterey.c b/drivers/hid/hid-monterey.c
new file mode 100644
index 000000000000..f3a85a065f18
--- /dev/null
+++ b/drivers/hid/hid-monterey.c
@@ -0,0 +1,82 @@
+/*
+ *  HID driver for some monterey "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+static void mr_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 30 && rdesc[29] == 0x05 && rdesc[30] == 0x09) {
+                dev_info(&hdev->dev, "fixing up button/consumer in HID report "
+                                "descriptor\n");
+                rdesc[30] = 0x0c;
+        }
+}
+
+#define mr_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int mr_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x156: mr_map_key_clear(KEY_WORDPROCESSOR);        break;
+        case 0x157: mr_map_key_clear(KEY_SPREADSHEET);          break;
+        case 0x158: mr_map_key_clear(KEY_PRESENTATION);         break;
+        case 0x15c: mr_map_key_clear(KEY_STOP);                 break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static const struct hid_device_id mr_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mr_devices);
+
+static struct hid_driver mr_driver = {
+        .name = "monterey",
+        .id_table = mr_devices,
+        .report_fixup = mr_report_fixup,
+        .input_mapping = mr_input_mapping,
+};
+
+static int mr_init(void)
+{
+        return hid_register_driver(&mr_driver);
+}
+
+static void mr_exit(void)
+{
+        hid_unregister_driver(&mr_driver);
+}
+
+module_init(mr_init);
+module_exit(mr_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(monterey);
diff --git a/drivers/hid/hid-petalynx.c b/drivers/hid/hid-petalynx.c
new file mode 100644
index 000000000000..10945fe12d50
--- /dev/null
+++ b/drivers/hid/hid-petalynx.c
@@ -0,0 +1,122 @@
+/*
+ *  HID driver for some petalynx "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+/* Petalynx Maxter Remote has maximum for consumer page set too low */
+static void pl_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 60 && rdesc[39] == 0x2a && rdesc[40] == 0xf5 &&
+                        rdesc[41] == 0x00 && rdesc[59] == 0x26 &&
+                        rdesc[60] == 0xf9 && rdesc[61] == 0x00) {
+                dev_info(&hdev->dev, "fixing up Petalynx Maxter Remote report "
+                                "descriptor\n");
+                rdesc[60] = 0xfa;
+                rdesc[40] = 0xfa;
+        }
+}
+
+#define pl_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                                        EV_KEY, (c))
+static int pl_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR) {
+                switch (usage->hid & HID_USAGE) {
+                case 0x05a: pl_map_key_clear(KEY_TEXT);         break;
+                case 0x05b: pl_map_key_clear(KEY_RED);          break;
+                case 0x05c: pl_map_key_clear(KEY_GREEN);        break;
+                case 0x05d: pl_map_key_clear(KEY_YELLOW);       break;
+                case 0x05e: pl_map_key_clear(KEY_BLUE);         break;
+                default:
+                        return 0;
+                }
+                return 1;
+        }
+
+        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
+                switch (usage->hid & HID_USAGE) {
+                case 0x0f6: pl_map_key_clear(KEY_NEXT);         break;
+                case 0x0fa: pl_map_key_clear(KEY_BACK);         break;
+                default:
+                        return 0;
+                }
+                return 1;
+        }
+
+        return 0;
+}
+
+static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        hdev->quirks |= HID_QUIRK_NOGET;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id pl_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, pl_devices);
+
+static struct hid_driver pl_driver = {
+        .name = "petalynx",
+        .id_table = pl_devices,
+        .report_fixup = pl_report_fixup,
+        .input_mapping = pl_input_mapping,
+        .probe = pl_probe,
+};
+
+static int pl_init(void)
+{
+        return hid_register_driver(&pl_driver);
+}
+
+static void pl_exit(void)
+{
+        hid_unregister_driver(&pl_driver);
+}
+
+module_init(pl_init);
+module_exit(pl_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(petalynx);
diff --git a/drivers/hid/usbhid/hid-plff.c b/drivers/hid/hid-pl.c
index 9eb83cf9d22b..acd815586182 100644
--- a/drivers/hid/usbhid/hid-plff.c
+++ b/drivers/hid/hid-pl.c
@@ -9,7 +9,7 @@
  *   - contains two reports, one for each port (HID_QUIRK_MULTI_INPUT)
  *
  *  0e8f:0003 "GreenAsia Inc.    USB Joystick     "
- *   - tested with Köng Gaming gamepad
+ *   - tested with K??ng Gaming gamepad
  *
  *  Copyright (c) 2007 Anssi Hannula <anssi.hannula@gmail.com>
  */
@@ -38,7 +38,11 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid.h"
+
+#include "hid-ids.h"
+
+#ifdef CONFIG_PANTHERLORD_FF
+#include "usbhid/usbhid.h"
 
 struct plff_device {
         struct hid_report *report;
@@ -66,7 +70,7 @@ static int hid_plff_play(struct input_dev *dev, void *data,
         return 0;
 }
 
-int hid_plff_init(struct hid_device *hid)
+static int plff_init(struct hid_device *hid)
 {
         struct plff_device *plff;
         struct hid_report *report;
@@ -86,7 +90,7 @@ int hid_plff_init(struct hid_device *hid)
            currently unknown. */
 
         if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-plff: no output reports found\n");
+                dev_err(&hid->dev, "no output reports found\n");
                 return -ENODEV;
         }
 
@@ -95,18 +99,19 @@ int hid_plff_init(struct hid_device *hid)
                 report_ptr = report_ptr->next;
 
                 if (report_ptr == report_list) {
-                        printk(KERN_ERR "hid-plff: required output report is missing\n");
+                        dev_err(&hid->dev, "required output report is "
+                                        "missing\n");
                         return -ENODEV;
                 }
 
                 report = list_entry(report_ptr, struct hid_report, list);
                 if (report->maxfield < 1) {
-                        printk(KERN_ERR "hid-plff: no fields in the report\n");
+                        dev_err(&hid->dev, "no fields in the report\n");
                         return -ENODEV;
                 }
 
                 if (report->field[0]->report_count < 4) {
-                        printk(KERN_ERR "hid-plff: not enough values in the field\n");
+                        dev_err(&hid->dev, "not enough values in the field\n");
                         return -ENODEV;
                 }
 
@@ -132,8 +137,70 @@ int hid_plff_init(struct hid_device *hid)
                 usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
         }
 
-        printk(KERN_INFO "hid-plff: Force feedback for PantherLord/GreenAsia "
+        dev_info(&hid->dev, "Force feedback for PantherLord/GreenAsia "
                "devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
 
         return 0;
 }
+#else
+static inline int plff_init(struct hid_device *hid)
+{
+        return 0;
+}
+#endif
+
+static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        if (id->driver_data)
+                hdev->quirks |= HID_QUIRK_MULTI_INPUT;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+
+        plff_init(hdev);
+
+        return 0;
+err:
+        return ret;
+}
+
+static const struct hid_device_id pl_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR),
+                .driver_data = 1 }, /* Twin USB Joystick */
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003), }, /* GreenAsia Inc. USB Joystick */
+        { }
+};
+MODULE_DEVICE_TABLE(hid, pl_devices);
+
+static struct hid_driver pl_driver = {
+        .name = "pantherlord",
+        .id_table = pl_devices,
+        .probe = pl_probe,
+};
+
+static int pl_init(void)
+{
+        return hid_register_driver(&pl_driver);
+}
+
+static void pl_exit(void)
+{
+        hid_unregister_driver(&pl_driver);
+}
+
+module_init(pl_init);
+module_exit(pl_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(pantherlord);
diff --git a/drivers/hid/hid-samsung.c b/drivers/hid/hid-samsung.c
new file mode 100644
index 000000000000..15f3c0492450
--- /dev/null
+++ b/drivers/hid/hid-samsung.c
@@ -0,0 +1,100 @@
+/*
+ *  HID driver for some samsung "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+/*
+ * Samsung IrDA remote controller (reports as Cypress USB Mouse).
+ *
+ * Vendor specific report #4 has a size of 48 bit,
+ * and therefore is not accepted when inspecting the descriptors.
+ * As a workaround we reinterpret the report as:
+ *   Variable type, count 6, size 8 bit, log. maximum 255
+ * The burden to reconstruct the data is moved into user space.
+ */
+static void samsung_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 182 && rdesc[175] == 0x25 && rdesc[176] == 0x40 &&
+                        rdesc[177] == 0x75 && rdesc[178] == 0x30 &&
+                        rdesc[179] == 0x95 && rdesc[180] == 0x01 &&
+                        rdesc[182] == 0x40) {
+                dev_info(&hdev->dev, "fixing up Samsung IrDA report "
+                                "descriptor\n");
+                rdesc[176] = 0xff;
+                rdesc[178] = 0x08;
+                rdesc[180] = 0x06;
+                rdesc[182] = 0x42;
+        }
+}
+
+static int samsung_probe(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, (HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDINPUT) |
+                        HID_CONNECT_HIDDEV_FORCE);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        return 0;
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id samsung_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, samsung_devices);
+
+static struct hid_driver samsung_driver = {
+        .name = "samsung",
+        .id_table = samsung_devices,
+        .report_fixup = samsung_report_fixup,
+        .probe = samsung_probe,
+};
+
+static int samsung_init(void)
+{
+        return hid_register_driver(&samsung_driver);
+}
+
+static void samsung_exit(void)
+{
+        hid_unregister_driver(&samsung_driver);
+}
+
+module_init(samsung_init);
+module_exit(samsung_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(samsung);
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
new file mode 100644
index 000000000000..3af8095a7de1
--- /dev/null
+++ b/drivers/hid/hid-sony.c
@@ -0,0 +1,110 @@
+/*
+ *  HID driver for some sony "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#include "hid-ids.h"
+
+/*
+ * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
+ * to "operational".  Without this, the ps3 controller will not report any
+ * events.
+ */
+static int sony_set_operational(struct hid_device *hdev)
+{
+        struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+        struct usb_device *dev = interface_to_usbdev(intf);
+        __u16 ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
+        int ret;
+        char *buf = kmalloc(18, GFP_KERNEL);
+
+        if (!buf)
+                return -ENOMEM;
+
+        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                                 HID_REQ_GET_REPORT,
+                                 USB_DIR_IN | USB_TYPE_CLASS |
+                                 USB_RECIP_INTERFACE,
+                                 (3 << 8) | 0xf2, ifnum, buf, 17,
+                                 USB_CTRL_GET_TIMEOUT);
+        if (ret < 0)
+                dev_err(&hdev->dev, "can't set operational mode\n");
+
+        kfree(buf);
+
+        return ret;
+}
+
+static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
+                        HID_CONNECT_HIDDEV_FORCE);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
+
+        ret = sony_set_operational(hdev);
+        if (ret)
+                goto err_stop;
+
+        return 0;
+err_stop:
+        hid_hw_stop(hdev);
+err_free:
+        return ret;
+}
+
+static const struct hid_device_id sony_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, sony_devices);
+
+static struct hid_driver sony_driver = {
+        .name = "sony",
+        .id_table = sony_devices,
+        .probe = sony_probe,
+};
+
+static int sony_init(void)
+{
+        return hid_register_driver(&sony_driver);
+}
+
+static void sony_exit(void)
+{
+        hid_unregister_driver(&sony_driver);
+}
+
+module_init(sony_init);
+module_exit(sony_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(sony);
diff --git a/drivers/hid/hid-sunplus.c b/drivers/hid/hid-sunplus.c
new file mode 100644
index 000000000000..5ba68f7dbb78
--- /dev/null
+++ b/drivers/hid/hid-sunplus.c
@@ -0,0 +1,82 @@
+/*
+ *  HID driver for some sunplus "special" devices
+ *
+ *  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) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ *  Copyright (c) 2008 Jiri Slaby
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+static void sp_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 107 && rdesc[104] == 0x26 && rdesc[105] == 0x80 &&
+                        rdesc[106] == 0x03) {
+                dev_info(&hdev->dev, "fixing up Sunplus Wireless Desktop "
+                                "report descriptor\n");
+                rdesc[105] = rdesc[110] = 0x03;
+                rdesc[106] = rdesc[111] = 0x21;
+        }
+}
+
+#define sp_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
+                EV_KEY, (c))
+static int sp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
+                return 0;
+
+        switch (usage->hid & HID_USAGE) {
+        case 0x2003: sp_map_key_clear(KEY_ZOOMIN);              break;
+        case 0x2103: sp_map_key_clear(KEY_ZOOMOUT);     break;
+        default:
+                return 0;
+        }
+        return 1;
+}
+
+static const struct hid_device_id sp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, sp_devices);
+
+static struct hid_driver sp_driver = {
+        .name = "sunplus",
+        .id_table = sp_devices,
+        .report_fixup = sp_report_fixup,
+        .input_mapping = sp_input_mapping,
+};
+
+static int sp_init(void)
+{
+        return hid_register_driver(&sp_driver);
+}
+
+static void sp_exit(void)
+{
+        hid_unregister_driver(&sp_driver);
+}
+
+module_init(sp_init);
+module_exit(sp_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(sunplus);
diff --git a/drivers/hid/usbhid/hid-tmff.c b/drivers/hid/hid-tmff.c
index 144578b1a00c..1b7cba0f7e1f 100644
--- a/drivers/hid/usbhid/hid-tmff.c
+++ b/drivers/hid/hid-tmff.c
@@ -27,23 +27,17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
+#include <linux/hid.h>
 #include <linux/input.h>
-
-#undef DEBUG
 #include <linux/usb.h>
 
-#include <linux/hid.h>
-#include "usbhid.h"
+#include "hid-ids.h"
+
+#include "usbhid/usbhid.h"
 
 /* Usages for thrustmaster devices I know about */
 #define THRUSTMASTER_USAGE_FF   (HID_UP_GENDESK | 0xbb)
 
-struct dev_type {
-        u16 idVendor;
-        u16 idProduct;
-        const signed short *ff;
-};
-
 static const signed short ff_rumble[] = {
         FF_RUMBLE,
         -1
@@ -54,21 +48,13 @@ static const signed short ff_joystick[] = {
         -1
 };
 
-static const struct dev_type devices[] = {
-        { 0x44f, 0xb300, ff_rumble },
-        { 0x44f, 0xb304, ff_rumble },
-        { 0x44f, 0xb651, ff_rumble },   /* FGT Rumble Force Wheel */
-        { 0x44f, 0xb654, ff_joystick }, /* FGT Force Feedback Wheel */
-};
-
 struct tmff_device {
         struct hid_report *report;
         struct hid_field *ff_field;
 };
 
 /* Changes values from 0 to 0xffff into values from minimum to maximum */
-static inline int hid_tmff_scale_u16(unsigned int in,
-                                int minimum, int maximum)
+static inline int tmff_scale_u16(unsigned int in, int minimum, int maximum)
 {
         int ret;
 
@@ -81,8 +67,7 @@ static inline int hid_tmff_scale_u16(unsigned int in,
 }
 
 /* Changes values from -0x80 to 0x7f into values from minimum to maximum */
-static inline int hid_tmff_scale_s8(int in,
-                                    int minimum, int maximum)
+static inline int tmff_scale_s8(int in, int minimum, int maximum)
 {
         int ret;
 
@@ -94,7 +79,8 @@ static inline int hid_tmff_scale_s8(int in,
         return ret;
 }
 
-static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
+static int tmff_play(struct input_dev *dev, void *data,
+                struct ff_effect *effect)
 {
         struct hid_device *hid = input_get_drvdata(dev);
         struct tmff_device *tmff = data;
@@ -104,10 +90,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
 
         switch (effect->type) {
         case FF_CONSTANT:
-                x = hid_tmff_scale_s8(effect->u.ramp.start_level,
+                x = tmff_scale_s8(effect->u.ramp.start_level,
                                         ff_field->logical_minimum,
                                         ff_field->logical_maximum);
-                y = hid_tmff_scale_s8(effect->u.ramp.end_level,
+                y = tmff_scale_s8(effect->u.ramp.end_level,
                                         ff_field->logical_minimum,
                                         ff_field->logical_maximum);
 
@@ -118,10 +104,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
                 break;
 
         case FF_RUMBLE:
-                left = hid_tmff_scale_u16(effect->u.rumble.weak_magnitude,
+                left = tmff_scale_u16(effect->u.rumble.weak_magnitude,
                                         ff_field->logical_minimum,
                                         ff_field->logical_maximum);
-                right = hid_tmff_scale_u16(effect->u.rumble.strong_magnitude,
+                right = tmff_scale_u16(effect->u.rumble.strong_magnitude,
                                         ff_field->logical_minimum,
                                         ff_field->logical_maximum);
 
@@ -134,14 +120,14 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
         return 0;
 }
 
-int hid_tmff_init(struct hid_device *hid)
+static int tmff_init(struct hid_device *hid, const signed short *ff_bits)
 {
         struct tmff_device *tmff;
         struct hid_report *report;
         struct list_head *report_list;
-        struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
+        struct hid_input *hidinput = list_entry(hid->inputs.next,
+                                                        struct hid_input, list);
         struct input_dev *input_dev = hidinput->input;
-        const signed short *ff_bits = ff_joystick;
         int error;
         int i;
 
@@ -163,63 +149,121 @@ int hid_tmff_init(struct hid_device *hid)
                         switch (field->usage[0].hid) {
                         case THRUSTMASTER_USAGE_FF:
                                 if (field->report_count < 2) {
-                                        warn("ignoring FF field with report_count < 2");
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                "with report_count < 2\n");
                                         continue;
                                 }
 
-                                if (field->logical_maximum == field->logical_minimum) {
-                                        warn("ignoring FF field with logical_maximum == logical_minimum");
+                                if (field->logical_maximum ==
+                                                field->logical_minimum) {
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                        "with logical_maximum "
+                                                        "== logical_minimum\n");
                                         continue;
                                 }
 
                                 if (tmff->report && tmff->report != report) {
-                                        warn("ignoring FF field in other report");
+                                        dev_warn(&hid->dev, "ignoring FF field "
+                                                        "in other report\n");
                                         continue;
                                 }
 
                                 if (tmff->ff_field && tmff->ff_field != field) {
-                                        warn("ignoring duplicate FF field");
+                                        dev_warn(&hid->dev, "ignoring "
+                                                        "duplicate FF field\n");
                                         continue;
                                 }
 
                                 tmff->report = report;
                                 tmff->ff_field = field;
 
-                                for (i = 0; i < ARRAY_SIZE(devices); i++) {
-                                        if (input_dev->id.vendor == devices[i].idVendor &&
-                                            input_dev->id.product == devices[i].idProduct) {
-                                                ff_bits = devices[i].ff;
-                                                break;
-                                        }
-                                }
-
                                 for (i = 0; ff_bits[i] >= 0; i++)
                                         set_bit(ff_bits[i], input_dev->ffbit);
 
                                 break;
 
                         default:
-                                warn("ignoring unknown output usage %08x", field->usage[0].hid);
+                                dev_warn(&hid->dev, "ignoring unknown output "
+                                                "usage %08x\n",
+                                                field->usage[0].hid);
                                 continue;
                         }
                 }
         }
 
         if (!tmff->report) {
-                err("cant find FF field in output reports\n");
+                dev_err(&hid->dev, "can't find FF field in output reports\n");
                 error = -ENODEV;
                 goto fail;
         }
 
-        error = input_ff_create_memless(input_dev, tmff, hid_tmff_play);
+        error = input_ff_create_memless(input_dev, tmff, tmff_play);
         if (error)
                 goto fail;
 
-        info("Force feedback for ThrustMaster devices by Zinx Verituse <zinx@epicsol.org>");
+        dev_info(&hid->dev, "force feedback for ThrustMaster devices by Zinx "
+                        "Verituse <zinx@epicsol.org>");
         return 0;
 
- fail:
+fail:
         kfree(tmff);
         return error;
 }
 
+static int tm_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+
+        tmff_init(hdev, (void *)id->driver_data);
+
+        return 0;
+err:
+        return ret;
+}
+
+static const struct hid_device_id tm_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300),
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304),
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651),   /* FGT Rumble Force Wheel */
+                .driver_data = (unsigned long)ff_rumble },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654),   /* FGT Force Feedback Wheel */
+                .driver_data = (unsigned long)ff_joystick },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, tm_devices);
+
+static struct hid_driver tm_driver = {
+        .name = "thrustmaster",
+        .id_table = tm_devices,
+        .probe = tm_probe,
+};
+
+static int tm_init(void)
+{
+        return hid_register_driver(&tm_driver);
+}
+
+static void tm_exit(void)
+{
+        hid_unregister_driver(&tm_driver);
+}
+
+module_init(tm_init);
+module_exit(tm_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(thrustmaster);
diff --git a/drivers/hid/usbhid/hid-zpff.c b/drivers/hid/hid-zpff.c
index 5a688274f6a3..ea82f3718b21 100644
--- a/drivers/hid/usbhid/hid-zpff.c
+++ b/drivers/hid/hid-zpff.c
@@ -21,16 +21,19 @@
  */
 
 
+#include <linux/hid.h>
 #include <linux/input.h>
 #include <linux/usb.h>
-#include <linux/hid.h>
-#include "usbhid.h"
+
+#include "hid-ids.h"
+
+#include "usbhid/usbhid.h"
 
 struct zpff_device {
         struct hid_report *report;
 };
 
-static int hid_zpff_play(struct input_dev *dev, void *data,
+static int zpff_play(struct input_dev *dev, void *data,
                          struct ff_effect *effect)
 {
         struct hid_device *hid = input_get_drvdata(dev);
@@ -58,7 +61,7 @@ static int hid_zpff_play(struct input_dev *dev, void *data,
         return 0;
 }
 
-int hid_zpff_init(struct hid_device *hid)
+static int zpff_init(struct hid_device *hid)
 {
         struct zpff_device *zpff;
         struct hid_report *report;
@@ -70,14 +73,14 @@ int hid_zpff_init(struct hid_device *hid)
         int error;
 
         if (list_empty(report_list)) {
-                printk(KERN_ERR "hid-zpff: no output report found\n");
+                dev_err(&hid->dev, "no output report found\n");
                 return -ENODEV;
         }
 
         report = list_entry(report_list->next, struct hid_report, list);
 
         if (report->maxfield < 4) {
-                printk(KERN_ERR "hid-zpff: not enough fields in report\n");
+                dev_err(&hid->dev, "not enough fields in report\n");
                 return -ENODEV;
         }
 
@@ -87,7 +90,7 @@ int hid_zpff_init(struct hid_device *hid)
 
         set_bit(FF_RUMBLE, dev->ffbit);
 
-        error = input_ff_create_memless(dev, zpff, hid_zpff_play);
+        error = input_ff_create_memless(dev, zpff, zpff_play);
         if (error) {
                 kfree(zpff);
                 return error;
@@ -100,8 +103,60 @@ int hid_zpff_init(struct hid_device *hid)
         zpff->report->field[3]->value[0] = 0x00;
         usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
 
-        printk(KERN_INFO "Force feedback for Zeroplus based devices by "
+        dev_info(&hid->dev, "force feedback for Zeroplus based devices by "
                "Anssi Hannula <anssi.hannula@gmail.com>\n");
 
         return 0;
 }
+
+static int zp_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err;
+        }
+
+        zpff_init(hdev);
+
+        return 0;
+err:
+        return ret;
+}
+
+static const struct hid_device_id zp_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, zp_devices);
+
+static struct hid_driver zp_driver = {
+        .name = "zeroplus",
+        .id_table = zp_devices,
+        .probe = zp_probe,
+};
+
+static int zp_init(void)
+{
+        return hid_register_driver(&zp_driver);
+}
+
+static void zp_exit(void)
+{
+        hid_unregister_driver(&zp_driver);
+}
+
+module_init(zp_init);
+module_exit(zp_exit);
+MODULE_LICENSE("GPL");
+
+HID_COMPAT_LOAD_DRIVER(zeroplus);
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index c40f0403edaf..497e0d1dd3c3 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -113,7 +113,7 @@ static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t
         if (!dev->hid_output_raw_report)
                 return -ENODEV;
 
-        if (count > HID_MIN_BUFFER_SIZE) {
+        if (count > HID_MAX_BUFFER_SIZE) {
                 printk(KERN_WARNING "hidraw: pid %d passed too large report\n",
                                 task_pid_nr(current));
                 return -EINVAL;
@@ -181,7 +181,7 @@ static int hidraw_open(struct inode *inode, struct file *file)
 
         dev = hidraw_table[minor];
         if (!dev->open++)
-                dev->hid->hid_open(dev->hid);
+                dev->hid->ll_driver->open(dev->hid);
 
 out_unlock:
         spin_unlock(&minors_lock);
@@ -207,7 +207,7 @@ static int hidraw_release(struct inode * inode, struct file * file)
         dev = hidraw_table[minor];
         if (!dev->open--) {
                 if (list->hidraw->exist)
-                        dev->hid->hid_close(dev->hid);
+                        dev->hid->ll_driver->close(dev->hid);
                 else
                         kfree(list->hidraw);
         }
@@ -367,7 +367,7 @@ void hidraw_disconnect(struct hid_device *hid)
         device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
 
         if (hidraw->open) {
-                hid->hid_close(hid);
+                hid->ll_driver->close(hid);
                 wake_up_interruptible(&hidraw->wait);
         } else {
                 kfree(hidraw);
diff --git a/drivers/hid/usbhid/Kconfig b/drivers/hid/usbhid/Kconfig
index 18f09104765c..5d9aa95fc3ef 100644
--- a/drivers/hid/usbhid/Kconfig
+++ b/drivers/hid/usbhid/Kconfig
@@ -24,88 +24,13 @@ config USB_HID
 comment "Input core support is needed for USB HID input layer or HIDBP support"
         depends on USB_HID && INPUT=n
 
-config USB_HIDINPUT_POWERBOOK
-        bool "Enable support for Apple laptop/aluminum USB special keys"
-        default n
-        depends on USB_HID
-        help
-          Say Y here if you want support for the special keys (Fn, Numlock) on
-          Apple iBooks, PowerBooks, MacBooks, MacBook Pros and aluminum USB
-          keyboards.
-
-          If unsure, say N.
-
-config HID_FF
-        bool "Force feedback support (EXPERIMENTAL)"
-        depends on USB_HID && EXPERIMENTAL
-        help
-          Say Y here is you want force feedback support for a few HID devices.
-          See below for a list of supported devices.
-
-          See <file:Documentation/input/ff.txt> for a description of the force
-          feedback API.
-
-          If unsure, say N.
-
 config HID_PID
         bool "PID device support"
-        depends on HID_FF
         help
           Say Y here if you have a PID-compliant device and wish to enable force
           feedback for it. Microsoft Sidewinder Force Feedback 2 is one of such
           devices.
 
-config LOGITECH_FF
-        bool "Logitech devices support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have one of these devices:
-          - Logitech WingMan Cordless RumblePad
-          - Logitech WingMan Cordless RumblePad 2
-          - Logitech WingMan Force 3D
-          - Logitech Formula Force EX
-          - Logitech MOMO Force wheel
-
-          and if you want to enable force feedback for them.
-          Note: if you say N here, this device will still be supported, but without
-          force feedback.
-
-config LOGIRUMBLEPAD2_FF
-        bool "Logitech Rumblepad 2 support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you want to enable force feedback support for Logitech
-          Rumblepad 2 devices.
-
-config PANTHERLORD_FF
-        bool "PantherLord/GreenAsia based device support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a PantherLord/GreenAsia based game controller
-          or adapter and want to enable force feedback support for it.
-
-config THRUSTMASTER_FF
-        bool "ThrustMaster devices support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
-          a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel,
-          and want to enable force feedback support for it.
-          Note: if you say N here, this device will still be supported, but without
-          force feedback.
-
-config ZEROPLUS_FF
-        bool "Zeroplus based game controller support"
-        depends on HID_FF
-        select INPUT_FF_MEMLESS if USB_HID
-        help
-          Say Y here if you have a Zeroplus based game controller and want to
-          enable force feedback for it.
-
 config USB_HIDDEV
         bool "/dev/hiddev raw HID device support"
         depends on USB_HID
diff --git a/drivers/hid/usbhid/Makefile b/drivers/hid/usbhid/Makefile
index 00a7b7090192..1329ecb37a1c 100644
--- a/drivers/hid/usbhid/Makefile
+++ b/drivers/hid/usbhid/Makefile
@@ -13,24 +13,6 @@ endif
 ifeq ($(CONFIG_HID_PID),y)
         usbhid-objs     += hid-pidff.o
 endif
-ifeq ($(CONFIG_LOGITECH_FF),y)
-        usbhid-objs     += hid-lgff.o
-endif
-ifeq ($(CONFIG_LOGIRUMBLEPAD2_FF),y)
-        usbhid-objs     += hid-lg2ff.o
-endif
-ifeq ($(CONFIG_PANTHERLORD_FF),y)
-        usbhid-objs     += hid-plff.o
-endif
-ifeq ($(CONFIG_THRUSTMASTER_FF),y)
-        usbhid-objs     += hid-tmff.o
-endif
-ifeq ($(CONFIG_ZEROPLUS_FF),y)
-        usbhid-objs     += hid-zpff.o
-endif
-ifeq ($(CONFIG_HID_FF),y)
-        usbhid-objs     += hid-ff.o
-endif
 
 obj-$(CONFIG_USB_HID)           += usbhid.o
 obj-$(CONFIG_USB_KBD)           += usbkbd.o
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 27fe4d8912cb..1d3b8a394d46 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -44,8 +44,6 @@
 #define DRIVER_DESC "USB HID core driver"
 #define DRIVER_LICENSE "GPL"
 
-static char *hid_types[] = {"Device", "Pointer", "Mouse", "Device", "Joystick",
-                                "Gamepad", "Keyboard", "Keypad", "Multi-Axis Controller"};
 /*
  * Module parameters.
  */
@@ -61,12 +59,6 @@ MODULE_PARM_DESC(quirks, "Add/modify USB HID quirks by specifying "
                 " quirks=vendorID:productID:quirks"
                 " where vendorID, productID, and quirks are all in"
                 " 0x-prefixed hex");
-static char *rdesc_quirks_param[MAX_USBHID_BOOT_QUIRKS] = { [ 0 ... (MAX_USBHID_BOOT_QUIRKS - 1) ] = NULL };
-module_param_array_named(rdesc_quirks, rdesc_quirks_param, charp, NULL, 0444);
-MODULE_PARM_DESC(rdesc_quirks, "Add/modify report descriptor quirks by specifying "
-                " rdesc_quirks=vendorID:productID:rdesc_quirks"
-                " where vendorID, productID, and rdesc_quirks are all in"
-                " 0x-prefixed hex");
 /*
  * Input submission and I/O error handler.
  */
@@ -197,31 +189,32 @@ static void hid_irq_in(struct urb *urb)
         int                     status;
 
         switch (urb->status) {
-                case 0:                 /* success */
-                        usbhid->retry_delay = 0;
-                        hid_input_report(urb->context, HID_INPUT_REPORT,
-                                         urb->transfer_buffer,
-                                         urb->actual_length, 1);
-                        break;
-                case -EPIPE:            /* stall */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        set_bit(HID_CLEAR_HALT, &usbhid->iofl);
-                        schedule_work(&usbhid->reset_work);
-                        return;
-                case -ECONNRESET:       /* unlink */
-                case -ENOENT:
-                case -ESHUTDOWN:        /* unplug */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        return;
-                case -EILSEQ:           /* protocol error or unplug */
-                case -EPROTO:           /* protocol error or unplug */
-                case -ETIME:            /* protocol error or unplug */
-                case -ETIMEDOUT:        /* Should never happen, but... */
-                        clear_bit(HID_IN_RUNNING, &usbhid->iofl);
-                        hid_io_error(hid);
-                        return;
-                default:                /* error */
-                        warn("input irq status %d received", urb->status);
+        case 0:                 /* success */
+                usbhid->retry_delay = 0;
+                hid_input_report(urb->context, HID_INPUT_REPORT,
+                                 urb->transfer_buffer,
+                                 urb->actual_length, 1);
+                break;
+        case -EPIPE:            /* stall */
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                set_bit(HID_CLEAR_HALT, &usbhid->iofl);
+                schedule_work(&usbhid->reset_work);
+                return;
+        case -ECONNRESET:       /* unlink */
+        case -ENOENT:
+        case -ESHUTDOWN:        /* unplug */
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                return;
+        case -EILSEQ:           /* protocol error or unplug */
+        case -EPROTO:           /* protocol error or unplug */
+        case -ETIME:            /* protocol error or unplug */
+        case -ETIMEDOUT:        /* Should never happen, but... */
+                clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                hid_io_error(hid);
+                return;
+        default:                /* error */
+                dev_warn(&urb->dev->dev, "input irq status %d  "
+                                "received\n", urb->status);
         }
 
         status = usb_submit_urb(urb, GFP_ATOMIC);
@@ -240,13 +233,16 @@ static void hid_irq_in(struct urb *urb)
 static int hid_submit_out(struct hid_device *hid)
 {
         struct hid_report *report;
+        char *raw_report;
         struct usbhid_device *usbhid = hid->driver_data;
 
-        report = usbhid->out[usbhid->outtail];
+        report = usbhid->out[usbhid->outtail].report;
+        raw_report = usbhid->out[usbhid->outtail].raw_report;
 
-        hid_output_report(report, usbhid->outbuf);
         usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
         usbhid->urbout->dev = hid_to_usb_dev(hid);
+        memcpy(usbhid->outbuf, raw_report, usbhid->urbout->transfer_buffer_length);
+        kfree(raw_report);
 
         dbg_hid("submitting out urb\n");
 
@@ -262,17 +258,20 @@ static int hid_submit_ctrl(struct hid_device *hid)
 {
         struct hid_report *report;
         unsigned char dir;
+        char *raw_report;
         int len;
         struct usbhid_device *usbhid = hid->driver_data;
 
         report = usbhid->ctrl[usbhid->ctrltail].report;
+        raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
         dir = usbhid->ctrl[usbhid->ctrltail].dir;
 
         len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
         if (dir == USB_DIR_OUT) {
-                hid_output_report(report, usbhid->ctrlbuf);
                 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
                 usbhid->urbctrl->transfer_buffer_length = len;
+                memcpy(usbhid->ctrlbuf, raw_report, len);
+                kfree(raw_report);
         } else {
                 int maxpacket, padlen;
 
@@ -319,17 +318,18 @@ static void hid_irq_out(struct urb *urb)
         int unplug = 0;
 
         switch (urb->status) {
-                case 0:                 /* success */
-                        break;
-                case -ESHUTDOWN:        /* unplug */
-                        unplug = 1;
-                case -EILSEQ:           /* protocol error or unplug */
-                case -EPROTO:           /* protocol error or unplug */
-                case -ECONNRESET:       /* unlink */
-                case -ENOENT:
-                        break;
-                default:                /* error */
-                        warn("output irq status %d received", urb->status);
+        case 0:                 /* success */
+                break;
+        case -ESHUTDOWN:        /* unplug */
+                unplug = 1;
+        case -EILSEQ:           /* protocol error or unplug */
+        case -EPROTO:           /* protocol error or unplug */
+        case -ECONNRESET:       /* unlink */
+        case -ENOENT:
+                break;
+        default:                /* error */
+                dev_warn(&urb->dev->dev, "output irq status %d "
+                                "received\n", urb->status);
         }
 
         spin_lock_irqsave(&usbhid->outlock, flags);
@@ -367,21 +367,23 @@ static void hid_ctrl(struct urb *urb)
         spin_lock_irqsave(&usbhid->ctrllock, flags);
 
         switch (urb->status) {
-                case 0:                 /* success */
-                        if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
-                                hid_input_report(urb->context, usbhid->ctrl[usbhid->ctrltail].report->type,
-                                                urb->transfer_buffer, urb->actual_length, 0);
-                        break;
-                case -ESHUTDOWN:        /* unplug */
-                        unplug = 1;
-                case -EILSEQ:           /* protocol error or unplug */
-                case -EPROTO:           /* protocol error or unplug */
-                case -ECONNRESET:       /* unlink */
-                case -ENOENT:
-                case -EPIPE:            /* report not available */
-                        break;
-                default:                /* error */
-                        warn("ctrl urb status %d received", urb->status);
+        case 0:                 /* success */
+                if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
+                        hid_input_report(urb->context,
+                                usbhid->ctrl[usbhid->ctrltail].report->type,
+                                urb->transfer_buffer, urb->actual_length, 0);
+                break;
+        case -ESHUTDOWN:        /* unplug */
+                unplug = 1;
+        case -EILSEQ:           /* protocol error or unplug */
+        case -EPROTO:           /* protocol error or unplug */
+        case -ECONNRESET:       /* unlink */
+        case -ENOENT:
+        case -EPIPE:            /* report not available */
+                break;
+        default:                /* error */
+                dev_warn(&urb->dev->dev, "ctrl urb status %d "
+                                "received\n", urb->status);
         }
 
         if (unplug)
@@ -408,6 +410,7 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
         int head;
         unsigned long flags;
         struct usbhid_device *usbhid = hid->driver_data;
+        int len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
 
         if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
                 return;
@@ -418,11 +421,18 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
 
                 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
                         spin_unlock_irqrestore(&usbhid->outlock, flags);
-                        warn("output queue full");
+                        dev_warn(&hid->dev, "output queue full\n");
                         return;
                 }
 
-                usbhid->out[usbhid->outhead] = report;
+                usbhid->out[usbhid->outhead].raw_report = kmalloc(len, GFP_ATOMIC);
+                if (!usbhid->out[usbhid->outhead].raw_report) {
+                        spin_unlock_irqrestore(&usbhid->outlock, flags);
+                        warn("output queueing failed");
+                        return;
+                }
+                hid_output_report(report, usbhid->out[usbhid->outhead].raw_report);
+                usbhid->out[usbhid->outhead].report = report;
                 usbhid->outhead = head;
 
                 if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
@@ -437,10 +447,19 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
 
         if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
                 spin_unlock_irqrestore(&usbhid->ctrllock, flags);
-                warn("control queue full");
+                dev_warn(&hid->dev, "control queue full\n");
                 return;
         }
 
+        if (dir == USB_DIR_OUT) {
+                usbhid->ctrl[usbhid->ctrlhead].raw_report = kmalloc(len, GFP_ATOMIC);
+                if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
+                        spin_unlock_irqrestore(&usbhid->ctrllock, flags);
+                        warn("control queueing failed");
+                        return;
+                }
+                hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);
+        }
         usbhid->ctrl[usbhid->ctrlhead].report = report;
         usbhid->ctrl[usbhid->ctrlhead].dir = dir;
         usbhid->ctrlhead = head;
@@ -451,6 +470,7 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
 
         spin_unlock_irqrestore(&usbhid->ctrllock, flags);
 }
+EXPORT_SYMBOL_GPL(usbhid_submit_report);
 
 static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
@@ -465,7 +485,7 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
                 return -1;
 
         if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
-                warn("event field not found");
+                dev_warn(&dev->dev, "event field not found\n");
                 return -1;
         }
 
@@ -568,7 +588,7 @@ void usbhid_init_reports(struct hid_device *hid)
         }
 
         if (err)
-                warn("timeout initializing reports");
+                dev_warn(&hid->dev, "timeout initializing reports\n");
 }
 
 /*
@@ -598,7 +618,7 @@ static int hid_find_field_early(struct hid_device *hid, unsigned int page,
         return -1;
 }
 
-static void usbhid_set_leds(struct hid_device *hid)
+void usbhid_set_leds(struct hid_device *hid)
 {
         struct hid_field *field;
         int offset;
@@ -608,6 +628,7 @@ static void usbhid_set_leds(struct hid_device *hid)
                 usbhid_submit_report(hid, field->report, USB_DIR_OUT);
         }
 }
+EXPORT_SYMBOL_GPL(usbhid_set_leds);
 
 /*
  * Traverse the supplied list of reports and find the longest
@@ -675,43 +696,16 @@ static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
         usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma);
 }
 
-/*
- * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
- * to "operational".  Without this, the ps3 controller will not report any
- * events.
- */
-static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum)
-{
-        int result;
-        char *buf = kmalloc(18, GFP_KERNEL);
-
-        if (!buf)
-                return;
-
-        result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
-                                 HID_REQ_GET_REPORT,
-                                 USB_DIR_IN | USB_TYPE_CLASS |
-                                 USB_RECIP_INTERFACE,
-                                 (3 << 8) | 0xf2, ifnum, buf, 17,
-                                 USB_CTRL_GET_TIMEOUT);
-
-        if (result < 0)
-                err_hid("%s failed: %d\n", __func__, result);
-
-        kfree(buf);
-}
-
-static struct hid_device *usb_hid_configure(struct usb_interface *intf)
+static int usbhid_parse(struct hid_device *hid)
 {
+        struct usb_interface *intf = to_usb_interface(hid->dev.parent);
         struct usb_host_interface *interface = intf->cur_altsetting;
         struct usb_device *dev = interface_to_usbdev (intf);
         struct hid_descriptor *hdesc;
-        struct hid_device *hid;
         u32 quirks = 0;
-        unsigned int insize = 0, rsize = 0;
+        unsigned int rsize = 0;
         char *rdesc;
-        int n, len;
-        struct usbhid_device *usbhid;
+        int ret, n;
 
         quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
                         le16_to_cpu(dev->descriptor.idProduct));
@@ -724,63 +718,75 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                                 quirks |= HID_QUIRK_NOGET;
         }
 
-        if (quirks & HID_QUIRK_IGNORE)
-                return NULL;
-
-        if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
-                (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
-                        return NULL;
-
-
         if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
             (!interface->desc.bNumEndpoints ||
              usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
                 dbg_hid("class descriptor not present\n");
-                return NULL;
+                return -ENODEV;
         }
 
+        hid->version = le16_to_cpu(hdesc->bcdHID);
+        hid->country = hdesc->bCountryCode;
+
         for (n = 0; n < hdesc->bNumDescriptors; n++)
                 if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT)
                         rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);
 
         if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
                 dbg_hid("weird size of report descriptor (%u)\n", rsize);
-                return NULL;
+                return -EINVAL;
         }
 
         if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
                 dbg_hid("couldn't allocate rdesc memory\n");
-                return NULL;
+                return -ENOMEM;
         }
 
         hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);
 
-        if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
+        ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,
+                        HID_DT_REPORT, rdesc, rsize);
+        if (ret < 0) {
                 dbg_hid("reading report descriptor failed\n");
                 kfree(rdesc);
-                return NULL;
+                goto err;
         }
 
-        usbhid_fixup_report_descriptor(le16_to_cpu(dev->descriptor.idVendor),
-                        le16_to_cpu(dev->descriptor.idProduct), rdesc,
-                        rsize, rdesc_quirks_param);
-
         dbg_hid("report descriptor (size %u, read %d) = ", rsize, n);
         for (n = 0; n < rsize; n++)
                 dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
         dbg_hid_line("\n");
 
-        if (!(hid = hid_parse_report(rdesc, n))) {
+        ret = hid_parse_report(hid, rdesc, rsize);
+        kfree(rdesc);
+        if (ret) {
                 dbg_hid("parsing report descriptor failed\n");
-                kfree(rdesc);
-                return NULL;
+                goto err;
         }
 
-        kfree(rdesc);
         hid->quirks = quirks;
 
-        if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL)))
-                goto fail_no_usbhid;
+        return 0;
+err:
+        return ret;
+}
+
+static int usbhid_start(struct hid_device *hid)
+{
+        struct usb_interface *intf = to_usb_interface(hid->dev.parent);
+        struct usb_host_interface *interface = intf->cur_altsetting;
+        struct usb_device *dev = interface_to_usbdev(intf);
+        struct usbhid_device *usbhid;
+        unsigned int n, insize = 0;
+        int ret;
+
+        WARN_ON(hid->driver_data);
+
+        usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL);
+        if (usbhid == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
 
         hid->driver_data = usbhid;
         usbhid->hid = hid;
@@ -799,28 +805,11 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                 insize = HID_MAX_BUFFER_SIZE;
 
         if (hid_alloc_buffers(dev, hid)) {
-                hid_free_buffers(dev, hid);
+                ret = -ENOMEM;
                 goto fail;
         }
 
-        hid->name[0] = 0;
-
-        if (dev->manufacturer)
-                strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
-
-        if (dev->product) {
-                if (dev->manufacturer)
-                        strlcat(hid->name, " ", sizeof(hid->name));
-                strlcat(hid->name, dev->product, sizeof(hid->name));
-        }
-
-        if (!strlen(hid->name))
-                snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
-                         le16_to_cpu(dev->descriptor.idVendor),
-                         le16_to_cpu(dev->descriptor.idProduct));
-
         for (n = 0; n < interface->desc.bNumEndpoints; n++) {
-
                 struct usb_endpoint_descriptor *endpoint;
                 int pipe;
                 int interval;
@@ -832,7 +821,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                 interval = endpoint->bInterval;
 
                 /* Some vendors give fullspeed interval on highspeed devides */
-                if (quirks & HID_QUIRK_FULLSPEED_INTERVAL  &&
+                if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
                     dev->speed == USB_SPEED_HIGH) {
                         interval = fls(endpoint->bInterval*8);
                         printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
@@ -843,6 +832,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                 if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
                         interval = hid_mousepoll_interval;
 
+                ret = -ENOMEM;
                 if (usb_endpoint_dir_in(endpoint)) {
                         if (usbhid->urbin)
                                 continue;
@@ -868,6 +858,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 
         if (!usbhid->urbin) {
                 err_hid("couldn't find an input interrupt endpoint");
+                ret = -ENODEV;
                 goto fail;
         }
 
@@ -879,44 +870,25 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         spin_lock_init(&usbhid->outlock);
         spin_lock_init(&usbhid->ctrllock);
 
-        hid->version = le16_to_cpu(hdesc->bcdHID);
-        hid->country = hdesc->bCountryCode;
-        hid->dev = &intf->dev;
         usbhid->intf = intf;
         usbhid->ifnum = interface->desc.bInterfaceNumber;
 
-        hid->bus = BUS_USB;
-        hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
-        hid->product = le16_to_cpu(dev->descriptor.idProduct);
-
-        usb_make_path(dev, hid->phys, sizeof(hid->phys));
-        strlcat(hid->phys, "/input", sizeof(hid->phys));
-        len = strlen(hid->phys);
-        if (len < sizeof(hid->phys) - 1)
-                snprintf(hid->phys + len, sizeof(hid->phys) - len,
-                         "%d", intf->altsetting[0].desc.bInterfaceNumber);
-
-        if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
-                hid->uniq[0] = 0;
-
         usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
-        if (!usbhid->urbctrl)
+        if (!usbhid->urbctrl) {
+                ret = -ENOMEM;
                 goto fail;
+        }
 
         usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
                              usbhid->ctrlbuf, 1, hid_ctrl, hid);
         usbhid->urbctrl->setup_dma = usbhid->cr_dma;
         usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
         usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
-        hid->hidinput_input_event = usb_hidinput_input_event;
-        hid->hid_open = usbhid_open;
-        hid->hid_close = usbhid_close;
-#ifdef CONFIG_USB_HIDDEV
-        hid->hiddev_hid_event = hiddev_hid_event;
-        hid->hiddev_report_event = hiddev_report_event;
-#endif
-        hid->hid_output_raw_report = usbhid_output_raw_report;
-        return hid;
+
+        usbhid_init_reports(hid);
+        hid_dump_device(hid);
+
+        return 0;
 
 fail:
         usb_free_urb(usbhid->urbin);
@@ -924,24 +896,18 @@ fail:
         usb_free_urb(usbhid->urbctrl);
         hid_free_buffers(dev, hid);
         kfree(usbhid);
-fail_no_usbhid:
-        hid_free_device(hid);
-
-        return NULL;
+err:
+        return ret;
 }
 
-static void hid_disconnect(struct usb_interface *intf)
+static void usbhid_stop(struct hid_device *hid)
 {
-        struct hid_device *hid = usb_get_intfdata (intf);
-        struct usbhid_device *usbhid;
+        struct usbhid_device *usbhid = hid->driver_data;
 
-        if (!hid)
+        if (WARN_ON(!usbhid))
                 return;
 
-        usbhid = hid->driver_data;
-
         spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
-        usb_set_intfdata(intf, NULL);
         set_bit(HID_DISCONNECTED, &usbhid->iofl);
         spin_unlock_irq(&usbhid->inlock);
         usb_kill_urb(usbhid->urbin);
@@ -958,86 +924,100 @@ static void hid_disconnect(struct usb_interface *intf)
         if (hid->claimed & HID_CLAIMED_HIDRAW)
                 hidraw_disconnect(hid);
 
+        hid->claimed = 0;
+
         usb_free_urb(usbhid->urbin);
         usb_free_urb(usbhid->urbctrl);
         usb_free_urb(usbhid->urbout);
 
         hid_free_buffers(hid_to_usb_dev(hid), hid);
         kfree(usbhid);
-        hid_free_device(hid);
+        hid->driver_data = NULL;
 }
 
+static struct hid_ll_driver usb_hid_driver = {
+        .parse = usbhid_parse,
+        .start = usbhid_start,
+        .stop = usbhid_stop,
+        .open = usbhid_open,
+        .close = usbhid_close,
+        .hidinput_input_event = usb_hidinput_input_event,
+};
+
 static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
+        struct usb_device *dev = interface_to_usbdev(intf);
         struct hid_device *hid;
-        char path[64];
-        int i;
-        char *c;
+        size_t len;
+        int ret;
 
         dbg_hid("HID probe called for ifnum %d\n",
                         intf->altsetting->desc.bInterfaceNumber);
 
-        if (!(hid = usb_hid_configure(intf)))
-                return -ENODEV;
-
-        usbhid_init_reports(hid);
-        hid_dump_device(hid);
-        if (hid->quirks & HID_QUIRK_RESET_LEDS)
-                usbhid_set_leds(hid);
-
-        if (!hidinput_connect(hid))
-                hid->claimed |= HID_CLAIMED_INPUT;
-        if (!hiddev_connect(hid))
-                hid->claimed |= HID_CLAIMED_HIDDEV;
-        if (!hidraw_connect(hid))
-                hid->claimed |= HID_CLAIMED_HIDRAW;
+        hid = hid_allocate_device();
+        if (IS_ERR(hid))
+                return PTR_ERR(hid);
 
         usb_set_intfdata(intf, hid);
+        hid->ll_driver = &usb_hid_driver;
+        hid->hid_output_raw_report = usbhid_output_raw_report;
+        hid->ff_init = hid_pidff_init;
+#ifdef CONFIG_USB_HIDDEV
+        hid->hiddev_connect = hiddev_connect;
+        hid->hiddev_hid_event = hiddev_hid_event;
+        hid->hiddev_report_event = hiddev_report_event;
+#endif
+        hid->dev.parent = &intf->dev;
+        hid->bus = BUS_USB;
+        hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
+        hid->product = le16_to_cpu(dev->descriptor.idProduct);
+        hid->name[0] = 0;
 
-        if (!hid->claimed) {
-                printk ("HID device claimed by neither input, hiddev nor hidraw\n");
-                hid_disconnect(intf);
-                return -ENODEV;
+        if (dev->manufacturer)
+                strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
+
+        if (dev->product) {
+                if (dev->manufacturer)
+                        strlcat(hid->name, " ", sizeof(hid->name));
+                strlcat(hid->name, dev->product, sizeof(hid->name));
         }
 
-        if ((hid->claimed & HID_CLAIMED_INPUT))
-                hid_ff_init(hid);
+        if (!strlen(hid->name))
+                snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
+                         le16_to_cpu(dev->descriptor.idVendor),
+                         le16_to_cpu(dev->descriptor.idProduct));
 
-        if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER)
-                hid_fixup_sony_ps3_controller(interface_to_usbdev(intf),
-                        intf->cur_altsetting->desc.bInterfaceNumber);
+        usb_make_path(dev, hid->phys, sizeof(hid->phys));
+        strlcat(hid->phys, "/input", sizeof(hid->phys));
+        len = strlen(hid->phys);
+        if (len < sizeof(hid->phys) - 1)
+                snprintf(hid->phys + len, sizeof(hid->phys) - len,
+                         "%d", intf->altsetting[0].desc.bInterfaceNumber);
 
-        printk(KERN_INFO);
+        if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
+                hid->uniq[0] = 0;
 
-        if (hid->claimed & HID_CLAIMED_INPUT)
-                printk("input");
-        if ((hid->claimed & HID_CLAIMED_INPUT) && ((hid->claimed & HID_CLAIMED_HIDDEV) ||
-                                hid->claimed & HID_CLAIMED_HIDRAW))
-                printk(",");
-        if (hid->claimed & HID_CLAIMED_HIDDEV)
-                printk("hiddev%d", hid->minor);
-        if ((hid->claimed & HID_CLAIMED_INPUT) && (hid->claimed & HID_CLAIMED_HIDDEV) &&
-                        (hid->claimed & HID_CLAIMED_HIDRAW))
-                printk(",");
-        if (hid->claimed & HID_CLAIMED_HIDRAW)
-                printk("hidraw%d", ((struct hidraw*)hid->hidraw)->minor);
-
-        c = "Device";
-        for (i = 0; i < hid->maxcollection; i++) {
-                if (hid->collection[i].type == HID_COLLECTION_APPLICATION &&
-                    (hid->collection[i].usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
-                    (hid->collection[i].usage & 0xffff) < ARRAY_SIZE(hid_types)) {
-                        c = hid_types[hid->collection[i].usage & 0xffff];
-                        break;
-                }
+        ret = hid_add_device(hid);
+        if (ret) {
+                if (ret != -ENODEV)
+                        dev_err(&intf->dev, "can't add hid device: %d\n", ret);
+                goto err;
         }
 
-        usb_make_path(interface_to_usbdev(intf), path, 63);
+        return 0;
+err:
+        hid_destroy_device(hid);
+        return ret;
+}
 
-        printk(": USB HID v%x.%02x %s [%s] on %s\n",
-                hid->version >> 8, hid->version & 0xff, c, hid->name, path);
+static void hid_disconnect(struct usb_interface *intf)
+{
+        struct hid_device *hid = usb_get_intfdata(intf);
 
-        return 0;
+        if (WARN_ON(!hid))
+                return;
+
+        hid_destroy_device(hid);
 }
 
 static int hid_suspend(struct usb_interface *intf, pm_message_t message)
@@ -1107,9 +1087,22 @@ static struct usb_driver hid_driver = {
         .supports_autosuspend = 1,
 };
 
+static const struct hid_device_id hid_usb_table[] = {
+        { HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
+        { }
+};
+
+static struct hid_driver hid_usb_driver = {
+        .name = "generic-usb",
+        .id_table = hid_usb_table,
+};
+
 static int __init hid_init(void)
 {
         int retval;
+        retval = hid_register_driver(&hid_usb_driver);
+        if (retval)
+                goto hid_register_fail;
         retval = usbhid_quirks_init(quirks_param);
         if (retval)
                 goto usbhid_quirks_init_fail;
@@ -1119,7 +1112,8 @@ static int __init hid_init(void)
         retval = usb_register(&hid_driver);
         if (retval)
                 goto usb_register_fail;
-        info(DRIVER_VERSION ":" DRIVER_DESC);
+        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                        DRIVER_DESC "\n");
 
         return 0;
 usb_register_fail:
@@ -1127,6 +1121,8 @@ usb_register_fail:
 hiddev_init_fail:
         usbhid_quirks_exit();
 usbhid_quirks_init_fail:
+        hid_unregister_driver(&hid_usb_driver);
+hid_register_fail:
         return retval;
 }
 
@@ -1135,6 +1131,7 @@ static void __exit hid_exit(void)
         usb_deregister(&hid_driver);
         hiddev_exit();
         usbhid_quirks_exit();
+        hid_unregister_driver(&hid_usb_driver);
 }
 
 module_init(hid_init);
diff --git a/drivers/hid/usbhid/hid-ff.c b/drivers/hid/usbhid/hid-ff.c
deleted file mode 100644
index 1d0dac52f166..000000000000
--- a/drivers/hid/usbhid/hid-ff.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- *  Force feedback support for hid devices.
- *  Not all hid devices use the same protocol. For example, some use PID,
- *  other use their own proprietary procotol.
- *
- *  Copyright (c) 2002-2004 Johann Deneux
- */
-
-/*
- * 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.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- * Should you need to contact me, the author, you can do so by
- * e-mail - mail your message to <johann.deneux@it.uu.se>
- */
-
-#include <linux/input.h>
-
-#undef DEBUG
-#include <linux/usb.h>
-
-#include <linux/hid.h>
-#include "usbhid.h"
-
-/*
- * This table contains pointers to initializers. To add support for new
- * devices, you need to add the USB vendor and product ids here.
- */
-struct hid_ff_initializer {
-        u16 idVendor;
-        u16 idProduct;
-        int (*init)(struct hid_device*);
-};
-
-/*
- * We try pidff when no other driver is found because PID is the
- * standards compliant way of implementing force feedback in HID.
- * pidff_init() will quickly abort if the device doesn't appear to
- * be a PID device
- */
-static struct hid_ff_initializer inits[] = {
-#ifdef CONFIG_LOGITECH_FF
-        { 0x46d, 0xc211, hid_lgff_init }, /* Logitech Cordless rumble pad */
-        { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */
-        { 0x46d, 0xc283, hid_lgff_init }, /* Logitech Wingman Force 3d */
-        { 0x46d, 0xc286, hid_lgff_init }, /* Logitech Force 3D Pro Joystick */
-        { 0x46d, 0xc294, hid_lgff_init }, /* Logitech Formula Force EX */
-        { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */
-        { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */
-#endif
-#ifdef CONFIG_LOGIRUMBLEPAD2_FF
-        { 0x46d, 0xc218, hid_lg2ff_init }, /* Logitech Rumblepad 2 */
-#endif
-#ifdef CONFIG_PANTHERLORD_FF
-        { 0x810, 0x0001, hid_plff_init }, /* "Twin USB Joystick" */
-        { 0xe8f, 0x0003, hid_plff_init }, /* "GreenAsia Inc.    USB Joystick     " */
-#endif
-#ifdef CONFIG_THRUSTMASTER_FF
-        { 0x44f, 0xb300, hid_tmff_init },
-        { 0x44f, 0xb304, hid_tmff_init },
-        { 0x44f, 0xb651, hid_tmff_init }, /* FGT Rumble Force Wheel */
-        { 0x44f, 0xb654, hid_tmff_init }, /* FGT Force Feedback Wheel */
-#endif
-#ifdef CONFIG_ZEROPLUS_FF
-        { 0xc12, 0x0005, hid_zpff_init },
-        { 0xc12, 0x0030, hid_zpff_init },
-#endif
-        { 0,     0,      hid_pidff_init}  /* Matches anything */
-};
-
-int hid_ff_init(struct hid_device* hid)
-{
-        struct hid_ff_initializer *init;
-        int vendor = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idVendor);
-        int product = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idProduct);
-
-        for (init = inits; init->idVendor; init++)
-                if (init->idVendor == vendor && init->idProduct == product)
-                        break;
-
-        return init->init(hid);
-}
-EXPORT_SYMBOL_GPL(hid_ff_init);
-
diff --git a/drivers/hid/usbhid/hid-pidff.c b/drivers/hid/usbhid/hid-pidff.c
index 011326178c06..484e3eec2f88 100644
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -397,7 +397,6 @@ static void pidff_set_condition_report(struct pidff_device *pidff,
                           effect->u.condition[i].left_saturation);
                 pidff_set(&pidff->set_condition[PID_DEAD_BAND],
                           effect->u.condition[i].deadband);
-                usbhid_wait_io(pidff->hid);
                 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],
                                   USB_DIR_OUT);
         }
@@ -512,7 +511,6 @@ static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)
                 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
         }
 
-        usbhid_wait_io(pidff->hid);
         usbhid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
                           USB_DIR_OUT);
 }
@@ -548,6 +546,9 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id)
         int pid_id = pidff->pid_id[effect_id];
 
         debug("starting to erase %d/%d", effect_id, pidff->pid_id[effect_id]);
+        /* Wait for the queue to clear. We do not want a full fifo to
+           prevent the effect removal. */
+        usbhid_wait_io(pidff->hid);
         pidff_playback_pid(pidff, pid_id, 0);
         pidff_erase_pid(pidff, pid_id);
 
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index b15f88249639..47ebe045f9b5 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -17,412 +17,7 @@
 
 #include <linux/hid.h>
 
-#define USB_VENDOR_ID_A4TECH            0x09da
-#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
-#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
-
-#define USB_VENDOR_ID_AASHIMA           0x06d6
-#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
-#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
-
-#define USB_VENDOR_ID_ACECAD            0x0460
-#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
-#define USB_DEVICE_ID_ACECAD_302        0x0008
-
-#define USB_VENDOR_ID_ADS_TECH          0x06e1
-#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
-
-#define USB_VENDOR_ID_AFATECH           0x15a4
-#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
-
-#define USB_VENDOR_ID_AIPTEK            0x08ca
-#define USB_DEVICE_ID_AIPTEK_01         0x0001
-#define USB_DEVICE_ID_AIPTEK_10         0x0010
-#define USB_DEVICE_ID_AIPTEK_20         0x0020
-#define USB_DEVICE_ID_AIPTEK_21         0x0021
-#define USB_DEVICE_ID_AIPTEK_22         0x0022
-#define USB_DEVICE_ID_AIPTEK_23         0x0023
-#define USB_DEVICE_ID_AIPTEK_24         0x0024
-
-#define USB_VENDOR_ID_AIRCABLE          0x16CA
-#define USB_DEVICE_ID_AIRCABLE1         0x1502
-
-#define USB_VENDOR_ID_ALCOR             0x058f
-#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
-
-#define USB_VENDOR_ID_ALPS              0x0433
-#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
-
-#define USB_VENDOR_ID_APPLE             0x05ac
-#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
-#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
-#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
-#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
-#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
-#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
-#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
-#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
-#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
-#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
-#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
-#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
-#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
-#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
-#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
-#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI    0x0229
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO     0x022a
-#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS     0x022b
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI  0x022c
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO   0x022d
-#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS   0x022e
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
-#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
-#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
-#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
-#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
-
-#define USB_VENDOR_ID_ASUS              0x0b05
-#define USB_DEVICE_ID_ASUS_LCM          0x1726
-
-#define USB_VENDOR_ID_ATEN              0x0557
-#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
-#define USB_DEVICE_ID_ATEN_CS124U       0x2202
-#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
-#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
-#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
-
-#define USB_VENDOR_ID_BELKIN           0x050d
-#define USB_DEVICE_ID_FLIP_KVM         0x3201
-
-#define USB_VENDOR_ID_BERKSHIRE         0x0c98
-#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
-
-#define USB_VENDOR_ID_CHERRY            0x046a
-#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
-
-#define USB_VENDOR_ID_CHIC              0x05fe
-#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
-
-#define USB_VENDOR_ID_CIDC              0x1677
-
-#define USB_VENDOR_ID_CMEDIA            0x0d8c
-#define USB_DEVICE_ID_CM109             0x000e
-
-#define USB_VENDOR_ID_CODEMERCS         0x07c0
-#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
-#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
-
-#define USB_VENDOR_ID_CYGNAL            0x10c4
-#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
-
-#define USB_VENDOR_ID_CYPRESS           0x04b4
-#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
-#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
-#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
-#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
-#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
-
-#define USB_VENDOR_ID_DELL              0x413c
-#define USB_DEVICE_ID_DELL_W7658        0x2005
-
-#define USB_VENDOR_ID_DELORME           0x1163
-#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
-#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
-
-#define USB_VENDOR_ID_DMI               0x0c0b
-#define USB_DEVICE_ID_DMI_ENC           0x5fab
-
-#define USB_VENDOR_ID_ELO               0x04E7
-#define USB_DEVICE_ID_ELO_TS2700        0x0020
-
-#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
-#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
-
-#define USB_VENDOR_ID_EZKEY             0x0518
-#define USB_DEVICE_ID_BTC_8193          0x0002
-
-#define USB_VENDOR_ID_GAMERON           0x0810
-#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
-
-#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
-
-#define USB_VENDOR_ID_GLAB              0x06c2
-#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
-#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
-#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
-#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
-#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
-#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
-#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
-#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
-
-#define USB_VENDOR_ID_GOTOP             0x08f2
-#define USB_DEVICE_ID_SUPER_Q2          0x007f
-#define USB_DEVICE_ID_GOGOPEN           0x00ce
-#define USB_DEVICE_ID_PENPOWER          0x00f4
-
-#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
-#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
-
-#define USB_VENDOR_ID_GRIFFIN           0x077d
-#define USB_DEVICE_ID_POWERMATE         0x0410
-#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
-
-#define USB_VENDOR_ID_GTCO              0x078c
-#define USB_DEVICE_ID_GTCO_90           0x0090
-#define USB_DEVICE_ID_GTCO_100          0x0100
-#define USB_DEVICE_ID_GTCO_101          0x0101
-#define USB_DEVICE_ID_GTCO_103          0x0103
-#define USB_DEVICE_ID_GTCO_104          0x0104
-#define USB_DEVICE_ID_GTCO_105          0x0105
-#define USB_DEVICE_ID_GTCO_106          0x0106
-#define USB_DEVICE_ID_GTCO_107          0x0107
-#define USB_DEVICE_ID_GTCO_108          0x0108
-#define USB_DEVICE_ID_GTCO_200          0x0200
-#define USB_DEVICE_ID_GTCO_201          0x0201
-#define USB_DEVICE_ID_GTCO_202          0x0202
-#define USB_DEVICE_ID_GTCO_203          0x0203
-#define USB_DEVICE_ID_GTCO_204          0x0204
-#define USB_DEVICE_ID_GTCO_205          0x0205
-#define USB_DEVICE_ID_GTCO_206          0x0206
-#define USB_DEVICE_ID_GTCO_207          0x0207
-#define USB_DEVICE_ID_GTCO_300          0x0300
-#define USB_DEVICE_ID_GTCO_301          0x0301
-#define USB_DEVICE_ID_GTCO_302          0x0302
-#define USB_DEVICE_ID_GTCO_303          0x0303
-#define USB_DEVICE_ID_GTCO_304          0x0304
-#define USB_DEVICE_ID_GTCO_305          0x0305
-#define USB_DEVICE_ID_GTCO_306          0x0306
-#define USB_DEVICE_ID_GTCO_307          0x0307
-#define USB_DEVICE_ID_GTCO_308          0x0308
-#define USB_DEVICE_ID_GTCO_309          0x0309
-#define USB_DEVICE_ID_GTCO_400          0x0400
-#define USB_DEVICE_ID_GTCO_401          0x0401
-#define USB_DEVICE_ID_GTCO_402          0x0402
-#define USB_DEVICE_ID_GTCO_403          0x0403
-#define USB_DEVICE_ID_GTCO_404          0x0404
-#define USB_DEVICE_ID_GTCO_405          0x0405
-#define USB_DEVICE_ID_GTCO_500          0x0500
-#define USB_DEVICE_ID_GTCO_501          0x0501
-#define USB_DEVICE_ID_GTCO_502          0x0502
-#define USB_DEVICE_ID_GTCO_503          0x0503
-#define USB_DEVICE_ID_GTCO_504          0x0504
-#define USB_DEVICE_ID_GTCO_1000         0x1000
-#define USB_DEVICE_ID_GTCO_1001         0x1001
-#define USB_DEVICE_ID_GTCO_1002         0x1002
-#define USB_DEVICE_ID_GTCO_1003         0x1003
-#define USB_DEVICE_ID_GTCO_1004         0x1004
-#define USB_DEVICE_ID_GTCO_1005         0x1005
-#define USB_DEVICE_ID_GTCO_1006         0x1006
-#define USB_DEVICE_ID_GTCO_1007         0x1007
-#define USB_VENDOR_ID_HAPP              0x078b
-#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
-#define USB_DEVICE_ID_UGCI_FLYING       0x0020
-#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
-
-#define USB_VENDOR_ID_IMATION           0x0718
-#define USB_DEVICE_ID_DISC_STAKKA       0xd000
-
-#define USB_VENDOR_ID_KBGEAR            0x084e
-#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
-
-#define USB_VENDOR_ID_LD                0x0f11
-#define USB_DEVICE_ID_LD_CASSY          0x1000
-#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
-#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
-#define USB_DEVICE_ID_LD_JWM            0x1080
-#define USB_DEVICE_ID_LD_DMMP           0x1081
-#define USB_DEVICE_ID_LD_UMIP           0x1090
-#define USB_DEVICE_ID_LD_XRAY1          0x1100
-#define USB_DEVICE_ID_LD_XRAY2          0x1101
-#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
-#define USB_DEVICE_ID_LD_COM3LAB        0x2000
-#define USB_DEVICE_ID_LD_TELEPORT       0x2010
-#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
-#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
-#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
-
-#define USB_VENDOR_ID_LOGITECH          0x046d
-#define USB_DEVICE_ID_LOGITECH_LX3      0xc044
-#define USB_DEVICE_ID_LOGITECH_V150     0xc047
-#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
-#define USB_DEVICE_ID_LOGITECH_HARMONY  0xc110
-#define USB_DEVICE_ID_LOGITECH_HARMONY_2 0xc111
-#define USB_DEVICE_ID_LOGITECH_HARMONY_3 0xc112
-#define USB_DEVICE_ID_LOGITECH_HARMONY_4 0xc113
-#define USB_DEVICE_ID_LOGITECH_HARMONY_5 0xc114
-#define USB_DEVICE_ID_LOGITECH_HARMONY_6 0xc115
-#define USB_DEVICE_ID_LOGITECH_HARMONY_7 0xc116
-#define USB_DEVICE_ID_LOGITECH_HARMONY_8 0xc117
-#define USB_DEVICE_ID_LOGITECH_HARMONY_9 0xc118
-#define USB_DEVICE_ID_LOGITECH_HARMONY_10 0xc119
-#define USB_DEVICE_ID_LOGITECH_HARMONY_11 0xc11a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_12 0xc11b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_13 0xc11c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_14 0xc11d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_15 0xc11e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_16 0xc11f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_17 0xc120
-#define USB_DEVICE_ID_LOGITECH_HARMONY_18 0xc121
-#define USB_DEVICE_ID_LOGITECH_HARMONY_19 0xc122
-#define USB_DEVICE_ID_LOGITECH_HARMONY_20 0xc123
-#define USB_DEVICE_ID_LOGITECH_HARMONY_21 0xc124
-#define USB_DEVICE_ID_LOGITECH_HARMONY_22 0xc125
-#define USB_DEVICE_ID_LOGITECH_HARMONY_23 0xc126
-#define USB_DEVICE_ID_LOGITECH_HARMONY_24 0xc127
-#define USB_DEVICE_ID_LOGITECH_HARMONY_25 0xc128
-#define USB_DEVICE_ID_LOGITECH_HARMONY_26 0xc129
-#define USB_DEVICE_ID_LOGITECH_HARMONY_27 0xc12a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_28 0xc12b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_29 0xc12c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_30 0xc12d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_31 0xc12e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_32 0xc12f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_33 0xc130
-#define USB_DEVICE_ID_LOGITECH_HARMONY_34 0xc131
-#define USB_DEVICE_ID_LOGITECH_HARMONY_35 0xc132
-#define USB_DEVICE_ID_LOGITECH_HARMONY_36 0xc133
-#define USB_DEVICE_ID_LOGITECH_HARMONY_37 0xc134
-#define USB_DEVICE_ID_LOGITECH_HARMONY_38 0xc135
-#define USB_DEVICE_ID_LOGITECH_HARMONY_39 0xc136
-#define USB_DEVICE_ID_LOGITECH_HARMONY_40 0xc137
-#define USB_DEVICE_ID_LOGITECH_HARMONY_41 0xc138
-#define USB_DEVICE_ID_LOGITECH_HARMONY_42 0xc139
-#define USB_DEVICE_ID_LOGITECH_HARMONY_43 0xc13a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_44 0xc13b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_45 0xc13c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_46 0xc13d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_47 0xc13e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_48 0xc13f
-#define USB_DEVICE_ID_LOGITECH_HARMONY_49 0xc140
-#define USB_DEVICE_ID_LOGITECH_HARMONY_50 0xc141
-#define USB_DEVICE_ID_LOGITECH_HARMONY_51 0xc142
-#define USB_DEVICE_ID_LOGITECH_HARMONY_52 0xc143
-#define USB_DEVICE_ID_LOGITECH_HARMONY_53 0xc144
-#define USB_DEVICE_ID_LOGITECH_HARMONY_54 0xc145
-#define USB_DEVICE_ID_LOGITECH_HARMONY_55 0xc146
-#define USB_DEVICE_ID_LOGITECH_HARMONY_56 0xc147
-#define USB_DEVICE_ID_LOGITECH_HARMONY_57 0xc148
-#define USB_DEVICE_ID_LOGITECH_HARMONY_58 0xc149
-#define USB_DEVICE_ID_LOGITECH_HARMONY_59 0xc14a
-#define USB_DEVICE_ID_LOGITECH_HARMONY_60 0xc14b
-#define USB_DEVICE_ID_LOGITECH_HARMONY_61 0xc14c
-#define USB_DEVICE_ID_LOGITECH_HARMONY_62 0xc14d
-#define USB_DEVICE_ID_LOGITECH_HARMONY_63 0xc14e
-#define USB_DEVICE_ID_LOGITECH_HARMONY_64 0xc14f
-#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
-#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
-#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
-#define USB_DEVICE_ID_LOGITECH_KBD      0xc311
-#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
-#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
-#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
-#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
-#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
-#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
-#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
-
-#define USB_VENDOR_ID_MCC               0x09db
-#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
-#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
-
-#define USB_VENDOR_ID_MGE               0x0463
-#define USB_DEVICE_ID_MGE_UPS           0xffff
-#define USB_DEVICE_ID_MGE_UPS1          0x0001
-
-#define USB_VENDOR_ID_MICROCHIP         0x04d8
-#define USB_DEVICE_ID_PICKIT1           0x0032
-#define USB_DEVICE_ID_PICKIT2           0x0033
-
-#define USB_VENDOR_ID_MICROSOFT         0x045e
-#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
-#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
-#define USB_DEVICE_ID_DESKTOP_RECV_1028 0x00f9
-#define USB_DEVICE_ID_MS_NE4K           0x00db
-#define USB_DEVICE_ID_MS_LK6K           0x00f9
-
-#define USB_VENDOR_ID_MONTEREY          0x0566
-#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
-
-#define USB_VENDOR_ID_NCR               0x0404
-#define USB_DEVICE_ID_NCR_FIRST         0x0300
-#define USB_DEVICE_ID_NCR_LAST          0x03ff
-
-#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
-#define USB_DEVICE_ID_N_S_HARMONY       0xc359
-
-#define USB_VENDOR_ID_NATSU             0x08b7
-#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
-
-#define USB_VENDOR_ID_NEC               0x073e
-#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
-
-#define USB_VENDOR_ID_ONTRAK            0x0a07
-#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
-
-#define USB_VENDOR_ID_PANJIT            0x134c
-
-#define USB_VENDOR_ID_PANTHERLORD       0x0810
-#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
-
-#define USB_VENDOR_ID_PETALYNX          0x18b1
-#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
-
-#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
-#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
-
-#define USB_VENDOR_ID_SAITEK            0x06a3
-#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
-
-#define USB_VENDOR_ID_SAMSUNG           0x0419
-#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
-
-#define USB_VENDOR_ID_SONY                      0x054c
-#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
-
-#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
-#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD       0x0038
-
-#define USB_VENDOR_ID_SUN               0x0430
-#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
-
-#define USB_VENDOR_ID_SUNPLUS           0x04fc
-#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
-
-#define USB_VENDOR_ID_TOPMAX            0x0663
-#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
-
-#define USB_VENDOR_ID_TURBOX            0x062a
-#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
-
-#define USB_VENDOR_ID_VERNIER           0x08f7
-#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
-#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
-#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
-#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
-#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
-
-#define USB_VENDOR_ID_WACOM             0x056a
-
-#define USB_VENDOR_ID_WISEGROUP         0x0925
-#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
-#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
-#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
-#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
-#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
-
-#define USB_VENDOR_ID_WISEGROUP_LTD     0x6677
-#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
-
-#define USB_VENDOR_ID_YEALINK           0x6993
-#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
-
-#define USB_VENDOR_ID_KYE               0x0458
-#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
+#include "../hid-ids.h"
 
 /*
  * Alphabetically sorted blacklist by quirk type.
@@ -433,18 +28,10 @@ static const struct hid_blacklist {
         __u16 idProduct;
         __u32 quirks;
 } hid_blacklist[] = {
-
-        { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 },
-        { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D, HID_QUIRK_2WHEEL_MOUSE_HACK_B8 },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 },
-
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS },
-
         { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
-        { USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
@@ -453,169 +40,11 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD },
 
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP, HID_QUIRK_DUPLICATE_USAGES },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE, HID_QUIRK_DUPLICATE_USAGES },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI, HID_QUIRK_DUPLICATE_USAGES },
-
         { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 
-        { USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM, HID_QUIRK_HIDDEV },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT },
-        { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV, HID_QUIRK_HIDINPUT },
-
-        { USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193, HID_QUIRK_HWHEEL_WHEEL_INVERT },
-
-        { USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM, HID_QUIRK_IGNORE},
-        { USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CIDC, 0x0103, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GENERAL_TOUCH, 0x0004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0003, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_PANJIT, 0x0004, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K, HID_QUIRK_IGNORE },
-
-        { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302, HID_QUIRK_IGNORE },
-
-        { USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2, HID_QUIRK_IGNORE },
-
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD, HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL | HID_QUIRK_LOGITECH_EXPANDED_KEYMAP },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500, HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL | HID_QUIRK_LOGITECH_EXPANDED_KEYMAP },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_LX3, HID_QUIRK_INVERT_HWHEEL },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150, HID_QUIRK_INVERT_HWHEEL },
-
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K, HID_QUIRK_MICROSOFT_KEYS },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K, HID_QUIRK_MICROSOFT_KEYS },
-
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
-
         { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
 
-        { USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER, HID_QUIRK_SONY_PS3_CONTROLLER | HID_QUIRK_HIDDEV },
-
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },
@@ -623,144 +52,13 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0, HID_QUIRK_NOGET },
-        { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 
         { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
-
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_APPLE_ISO_KEYBOARD},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS, HID_QUIRK_APPLE_HAS_FN  | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
-
-        { USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658, HID_QUIRK_RESET_LEDS },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_KBD, HID_QUIRK_RESET_LEDS },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_2, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_3, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_4, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_5, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_6, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_7, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_8, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_9, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_10, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_11, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_12, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_13, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_14, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_15, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_16, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_17, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_18, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_19, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_20, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_21, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_22, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_23, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_24, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_25, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_26, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_27, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_28, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_29, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_30, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_31, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_32, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_33, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_34, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_35, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_36, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_37, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_38, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_39, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_40, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_41, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_42, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_43, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_44, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_45, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_46, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_47, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_48, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_49, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_50, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_51, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_52, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_53, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_54, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_55, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_56, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_57, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_58, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_59, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_60, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_61, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_62, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_63, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_64, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY, HID_QUIRK_IGNORE },
-        { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560, HID_QUIRK_IGNORE },
-
-        { 0, 0 }
-};
-
-/* Quirks for devices which require report descriptor fixup go here */
-static const struct hid_rdesc_blacklist {
-        __u16 idVendor;
-        __u16 idProduct;
-        __u32 quirks;
-} hid_rdesc_blacklist[] = {
-
-        { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_RDESC_CYMOTION },
-
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2, HID_QUIRK_RDESC_LOGITECH },
-        { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_DESKTOP_RECV_1028, HID_QUIRK_RDESC_MICROSOFT_RECV_1028 },
-
-        { USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E, HID_QUIRK_RDESC_BUTTON_CONSUMER },
-
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_RDESC_MACBOOK_JIS },
-
-        { USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_RDESC_PETALYNX },
-
-        { USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_RDESC_SAMSUNG_REMOTE },
-
-        { USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP, HID_QUIRK_RDESC_SUNPLUS_WDESKTOP },
-
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1, HID_QUIRK_RDESC_SWAPPED_MIN_MAX },
-        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2, HID_QUIRK_RDESC_SWAPPED_MIN_MAX },
+        { USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 
         { 0, 0 }
 };
@@ -974,16 +272,6 @@ u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
         u32 quirks = 0;
         const struct hid_blacklist *bl_entry = NULL;
 
-        /* Ignore all Wacom devices */
-        if (idVendor == USB_VENDOR_ID_WACOM)
-                return HID_QUIRK_IGNORE;
-
-        /* ignore all Code Mercenaries IOWarrior devices */
-        if (idVendor == USB_VENDOR_ID_CODEMERCS)
-                if (idProduct >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
-                                idProduct <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
-                        return HID_QUIRK_IGNORE;
-
         /* NCR devices must not be queried for reports */
         if (idVendor == USB_VENDOR_ID_NCR &&
                         idProduct >= USB_DEVICE_ID_NCR_FIRST &&
@@ -1002,221 +290,3 @@ u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
 }
 
 EXPORT_SYMBOL_GPL(usbhid_lookup_quirk);
-
-/*
- * Cherry Cymotion keyboard have an invalid HID report descriptor,
- * that needs fixing before we can parse it.
- */
-static void usbhid_fixup_cymotion_descriptor(char *rdesc, int rsize)
-{
-        if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) {
-                printk(KERN_INFO "Fixing up Cherry Cymotion report descriptor\n");
-                rdesc[11] = rdesc[16] = 0xff;
-                rdesc[12] = rdesc[17] = 0x03;
-        }
-}
-
-
-/*
- * Certain Logitech keyboards send in report #3 keys which are far
- * above the logical maximum described in descriptor. This extends
- * the original value of 0x28c of logical maximum to 0x104d
- */
-static void usbhid_fixup_logitech_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 90 && rdesc[83] == 0x26
-                        && rdesc[84] == 0x8c
-                        && rdesc[85] == 0x02) {
-                printk(KERN_INFO "Fixing up Logitech keyboard report descriptor\n");
-                rdesc[84] = rdesc[89] = 0x4d;
-                rdesc[85] = rdesc[90] = 0x10;
-        }
-}
-
-static void usbhid_fixup_sunplus_wdesktop(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 107 && rdesc[104] == 0x26
-                         && rdesc[105] == 0x80
-                         && rdesc[106] == 0x03) {
-                printk(KERN_INFO "Fixing up Sunplus Wireless Desktop report descriptor\n");
-                rdesc[105] = rdesc[110] = 0x03;
-                rdesc[106] = rdesc[111] = 0x21;
-        }
-}
-
-/*
- * Samsung IrDA remote controller (reports as Cypress USB Mouse).
- *
- * Vendor specific report #4 has a size of 48 bit,
- * and therefore is not accepted when inspecting the descriptors.
- * As a workaround we reinterpret the report as:
- *   Variable type, count 6, size 8 bit, log. maximum 255
- * The burden to reconstruct the data is moved into user space.
- */
-static void usbhid_fixup_samsung_irda_descriptor(unsigned char *rdesc,
-                                                  int rsize)
-{
-        if (rsize >= 182 && rdesc[175] == 0x25
-                         && rdesc[176] == 0x40
-                         && rdesc[177] == 0x75
-                         && rdesc[178] == 0x30
-                         && rdesc[179] == 0x95
-                         && rdesc[180] == 0x01
-                         && rdesc[182] == 0x40) {
-                printk(KERN_INFO "Fixing up Samsung IrDA report descriptor\n");
-                rdesc[176] = 0xff;
-                rdesc[178] = 0x08;
-                rdesc[180] = 0x06;
-                rdesc[182] = 0x42;
-        }
-}
-
-/* Petalynx Maxter Remote has maximum for consumer page set too low */
-static void usbhid_fixup_petalynx_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 60 && rdesc[39] == 0x2a
-                        && rdesc[40] == 0xf5
-                        && rdesc[41] == 0x00
-                        && rdesc[59] == 0x26
-                        && rdesc[60] == 0xf9
-                        && rdesc[61] == 0x00) {
-                printk(KERN_INFO "Fixing up Petalynx Maxter Remote report descriptor\n");
-                rdesc[60] = 0xfa;
-                rdesc[40] = 0xfa;
-        }
-}
-
-/*
- * Some USB barcode readers from cypress have usage min and usage max in
- * the wrong order
- */
-static void usbhid_fixup_cypress_descriptor(unsigned char *rdesc, int rsize)
-{
-        short fixed = 0;
-        int i;
-
-        for (i = 0; i < rsize - 4; i++) {
-                if (rdesc[i] == 0x29 && rdesc [i+2] == 0x19) {
-                        unsigned char tmp;
-
-                        rdesc[i] = 0x19; rdesc[i+2] = 0x29;
-                        tmp = rdesc[i+3];
-                        rdesc[i+3] = rdesc[i+1];
-                        rdesc[i+1] = tmp;
-                }
-        }
-
-        if (fixed)
-                printk(KERN_INFO "Fixing up Cypress report descriptor\n");
-}
-
-/*
- * MacBook JIS keyboard has wrong logical maximum
- */
-static void usbhid_fixup_macbook_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 60 && rdesc[53] == 0x65
-                        && rdesc[59] == 0x65) {
-                printk(KERN_INFO "Fixing up MacBook JIS keyboard report descriptor\n");
-                rdesc[53] = rdesc[59] = 0xe7;
-        }
-}
-
-static void usbhid_fixup_button_consumer_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize >= 30 && rdesc[29] == 0x05
-                        && rdesc[30] == 0x09) {
-                printk(KERN_INFO "Fixing up button/consumer in HID report descriptor\n");
-                rdesc[30] = 0x0c;
-        }
-}
-
-/*
- * Microsoft Wireless Desktop Receiver (Model 1028) has several
- * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
- */
-static void usbhid_fixup_microsoft_descriptor(unsigned char *rdesc, int rsize)
-{
-        if (rsize == 571 && rdesc[284] == 0x19
-                         && rdesc[286] == 0x2a
-                         && rdesc[304] == 0x19
-                         && rdesc[306] == 0x29
-                         && rdesc[352] == 0x1a
-                         && rdesc[355] == 0x2a
-                         && rdesc[557] == 0x19
-                         && rdesc[559] == 0x29) {
-                printk(KERN_INFO "Fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n");
-                rdesc[284] = rdesc[304] = rdesc[557] = 0x35;
-                rdesc[352] = 0x36;
-                rdesc[286] = rdesc[355] = 0x46;
-                rdesc[306] = rdesc[559] = 0x45;
-        }
-}
-
-static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned rsize)
-{
-        if ((quirks & HID_QUIRK_RDESC_CYMOTION))
-                usbhid_fixup_cymotion_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_LOGITECH)
-                usbhid_fixup_logitech_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_SWAPPED_MIN_MAX)
-                usbhid_fixup_cypress_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_PETALYNX)
-                usbhid_fixup_petalynx_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_MACBOOK_JIS)
-                usbhid_fixup_macbook_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_BUTTON_CONSUMER)
-                usbhid_fixup_button_consumer_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_SAMSUNG_REMOTE)
-                usbhid_fixup_samsung_irda_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_MICROSOFT_RECV_1028)
-                usbhid_fixup_microsoft_descriptor(rdesc, rsize);
-
-        if (quirks & HID_QUIRK_RDESC_SUNPLUS_WDESKTOP)
-                usbhid_fixup_sunplus_wdesktop(rdesc, rsize);
-}
-
-/**
- * usbhid_fixup_report_descriptor: check if report descriptor needs fixup
- *
- * Description:
- *      Walks the hid_rdesc_blacklist[] array and checks whether the device
- *      is known to have broken report descriptor that needs to be fixed up
- *      prior to entering the HID parser
- *
- * Returns: nothing
- */
-void usbhid_fixup_report_descriptor(const u16 idVendor, const u16 idProduct,
-                                    char *rdesc, unsigned rsize, char **quirks_param)
-{
-        int n, m;
-        u16 paramVendor, paramProduct;
-        u32 quirks;
-
-        /* static rdesc quirk entries */
-        for (n = 0; hid_rdesc_blacklist[n].idVendor; n++)
-                if (hid_rdesc_blacklist[n].idVendor == idVendor &&
-                                hid_rdesc_blacklist[n].idProduct == idProduct)
-                        __usbhid_fixup_report_descriptor(hid_rdesc_blacklist[n].quirks,
-                                        rdesc, rsize);
-
-        /* runtime rdesc quirk entries handling */
-        for (n = 0; quirks_param[n] && n < MAX_USBHID_BOOT_QUIRKS; n++) {
-                m = sscanf(quirks_param[n], "0x%hx:0x%hx:0x%x",
-                                &paramVendor, &paramProduct, &quirks);
-
-                if (m != 3)
-                        printk(KERN_WARNING
-                                "Could not parse HID quirk module param %s\n",
-                                quirks_param[n]);
-                else if (paramVendor == idVendor && paramProduct == idProduct)
-                        __usbhid_fixup_report_descriptor(quirks, rdesc, rsize);
-        }
-}
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 842e9edb888e..babd65dd46ad 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -790,21 +790,23 @@ static struct usb_class_driver hiddev_class = {
 /*
  * This is where hid.c calls us to connect a hid device to the hiddev driver
  */
-int hiddev_connect(struct hid_device *hid)
+int hiddev_connect(struct hid_device *hid, unsigned int force)
 {
         struct hiddev *hiddev;
         struct usbhid_device *usbhid = hid->driver_data;
-        int i;
         int retval;
 
-        for (i = 0; i < hid->maxcollection; i++)
-                if (hid->collection[i].type ==
-                    HID_COLLECTION_APPLICATION &&
-                    !IS_INPUT_APPLICATION(hid->collection[i].usage))
-                        break;
+        if (!force) {
+                unsigned int i;
+                for (i = 0; i < hid->maxcollection; i++)
+                        if (hid->collection[i].type ==
+                            HID_COLLECTION_APPLICATION &&
+                            !IS_INPUT_APPLICATION(hid->collection[i].usage))
+                                break;
 
-        if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDDEV) == 0)
-                return -1;
+                if (i == hid->maxcollection)
+                        return -1;
+        }
 
         if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
                 return -1;
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 62d2d7c925bd..abedb13c623e 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -67,7 +67,7 @@ struct usbhid_device {
         spinlock_t ctrllock;                                            /* Control fifo spinlock */
 
         struct urb *urbout;                                             /* Output URB */
-        struct hid_report *out[HID_CONTROL_FIFO_SIZE];                  /* Output pipe fifo */
+        struct hid_output_fifo out[HID_CONTROL_FIFO_SIZE];              /* Output pipe fifo */
         unsigned char outhead, outtail;                                 /* Output pipe fifo head & tail */
         char *outbuf;                                                   /* Output buffer */
         dma_addr_t outbuf_dma;                                          /* Output buffer dma */
@@ -82,7 +82,7 @@ struct usbhid_device {
 };
 
 #define hid_to_usb_dev(hid_dev) \
-        container_of(hid_dev->dev->parent, struct usb_device, dev)
+        container_of(hid_dev->dev.parent->parent, struct usb_device, dev)
 
 #endif
 
diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index 0caaafe01843..b342926dd7fc 100644
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -105,14 +105,16 @@ static void usb_kbd_irq(struct urb *urb)
                         if (usb_kbd_keycode[kbd->old[i]])
                                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
                         else
-                                info("Unknown key (scancode %#x) released.", kbd->old[i]);
+                                dev_info(&urb->dev->dev,
+                                                "Unknown key (scancode %#x) released.\n", kbd->old[i]);
                 }
 
                 if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
                         if (usb_kbd_keycode[kbd->new[i]])
                                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
                         else
-                                info("Unknown key (scancode %#x) pressed.", kbd->new[i]);
+                                dev_info(&urb->dev->dev,
+                                                "Unknown key (scancode %#x) released.\n", kbd->new[i]);
                 }
         }
 
@@ -159,7 +161,8 @@ static void usb_kbd_led(struct urb *urb)
         struct usb_kbd *kbd = urb->context;
 
         if (urb->status)
-                warn("led urb status %d received", urb->status);
+                dev_warn(&urb->dev->dev, "led urb status %d received\n",
+                         urb->status);
 
         if (*(kbd->leds) == kbd->newleds)
                 return;
@@ -352,7 +355,8 @@ static int __init usb_kbd_init(void)
 {
         int result = usb_register(&usb_kbd_driver);
         if (result == 0)
-                info(DRIVER_VERSION ":" DRIVER_DESC);
+                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                                DRIVER_DESC "\n");
         return result;
 }
 
diff --git a/drivers/hid/usbhid/usbmouse.c b/drivers/hid/usbhid/usbmouse.c
index 35689ef172cc..72ab4b268096 100644
--- a/drivers/hid/usbhid/usbmouse.c
+++ b/drivers/hid/usbhid/usbmouse.c
@@ -31,6 +31,11 @@
 #include <linux/usb/input.h>
 #include <linux/hid.h>
 
+/* for apple IDs */
+#ifdef CONFIG_USB_HID_MODULE
+#include "../hid-ids.h"
+#endif
+
 /*
  * Version Information
  */
@@ -240,7 +245,8 @@ static int __init usb_mouse_init(void)
 {
         int retval = usb_register(&usb_mouse_driver);
         if (retval == 0)
-                info(DRIVER_VERSION ":" DRIVER_DESC);
+                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
+                                DRIVER_DESC "\n");
         return retval;
 }
 
diff --git a/include/linux/hid.h b/include/linux/hid.h
index ac4e678a04ed..f13bca2dd53b 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -67,6 +67,7 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/list.h>
+#include <linux/mod_devicetable.h> /* hid_device_id */
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/input.h>
@@ -246,6 +247,19 @@ struct hid_item {
 #define HID_FEATURE_REPORT      2
 
 /*
+ * HID connect requests
+ */
+
+#define HID_CONNECT_HIDINPUT            0x01
+#define HID_CONNECT_HIDINPUT_FORCE      0x02
+#define HID_CONNECT_HIDRAW              0x04
+#define HID_CONNECT_HIDDEV              0x08
+#define HID_CONNECT_HIDDEV_FORCE        0x10
+#define HID_CONNECT_FF                  0x20
+#define HID_CONNECT_DEFAULT     (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
+                HID_CONNECT_HIDDEV|HID_CONNECT_FF)
+
+/*
  * HID device quirks.
  */
 
@@ -256,48 +270,11 @@ struct hid_item {
 
 #define HID_QUIRK_INVERT                        0x00000001
 #define HID_QUIRK_NOTOUCH                       0x00000002
-#define HID_QUIRK_IGNORE                        0x00000004
 #define HID_QUIRK_NOGET                         0x00000008
-#define HID_QUIRK_HIDDEV                        0x00000010
 #define HID_QUIRK_BADPAD                        0x00000020
 #define HID_QUIRK_MULTI_INPUT                   0x00000040
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_7           0x00000080
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_5           0x00000100
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_ON          0x00000200
-#define HID_QUIRK_MIGHTYMOUSE                   0x00000400
-#define HID_QUIRK_APPLE_HAS_FN                  0x00000800
-#define HID_QUIRK_APPLE_FN_ON                   0x00001000
-#define HID_QUIRK_INVERT_HWHEEL                 0x00002000
-#define HID_QUIRK_APPLE_ISO_KEYBOARD            0x00004000
-#define HID_QUIRK_BAD_RELATIVE_KEYS             0x00008000
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
-#define HID_QUIRK_IGNORE_MOUSE                  0x00020000
-#define HID_QUIRK_SONY_PS3_CONTROLLER           0x00040000
-#define HID_QUIRK_DUPLICATE_USAGES              0x00080000
-#define HID_QUIRK_RESET_LEDS                    0x00100000
-#define HID_QUIRK_HIDINPUT                      0x00200000
-#define HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL 0x00400000
-#define HID_QUIRK_LOGITECH_EXPANDED_KEYMAP      0x00800000
-#define HID_QUIRK_IGNORE_HIDINPUT               0x01000000
-#define HID_QUIRK_2WHEEL_MOUSE_HACK_B8          0x02000000
-#define HID_QUIRK_HWHEEL_WHEEL_INVERT           0x04000000
-#define HID_QUIRK_MICROSOFT_KEYS                0x08000000
 #define HID_QUIRK_FULLSPEED_INTERVAL            0x10000000
-#define HID_QUIRK_APPLE_NUMLOCK_EMULATION       0x20000000
-
-/*
- * Separate quirks for runtime report descriptor fixup
- */
-
-#define HID_QUIRK_RDESC_CYMOTION                0x00000001
-#define HID_QUIRK_RDESC_LOGITECH                0x00000002
-#define HID_QUIRK_RDESC_SWAPPED_MIN_MAX         0x00000004
-#define HID_QUIRK_RDESC_PETALYNX                0x00000008
-#define HID_QUIRK_RDESC_MACBOOK_JIS             0x00000010
-#define HID_QUIRK_RDESC_BUTTON_CONSUMER         0x00000020
-#define HID_QUIRK_RDESC_SAMSUNG_REMOTE          0x00000040
-#define HID_QUIRK_RDESC_MICROSOFT_RECV_1028     0x00000080
-#define HID_QUIRK_RDESC_SUNPLUS_WDESKTOP        0x00000100
 
 /*
  * This is the global environment of the parser. This information is
@@ -411,12 +388,21 @@ struct hid_report_enum {
 struct hid_control_fifo {
         unsigned char dir;
         struct hid_report *report;
+        char *raw_report;
+};
+
+struct hid_output_fifo {
+        struct hid_report *report;
+        char *raw_report;
 };
 
 #define HID_CLAIMED_INPUT       1
 #define HID_CLAIMED_HIDDEV      2
 #define HID_CLAIMED_HIDRAW      4
 
+#define HID_STAT_ADDED          1
+#define HID_STAT_PARSED         2
+
 #define HID_CTRL_RUNNING        1
 #define HID_OUT_RUNNING         2
 #define HID_IN_RUNNING          3
@@ -431,22 +417,28 @@ struct hid_input {
         struct input_dev *input;
 };
 
+struct hid_driver;
+struct hid_ll_driver;
+
 struct hid_device {                                                     /* device report descriptor */
-         __u8 *rdesc;
+        __u8 *rdesc;
         unsigned rsize;
         struct hid_collection *collection;                              /* List of HID collections */
         unsigned collection_size;                                       /* Number of allocated hid_collections */
         unsigned maxcollection;                                         /* Number of parsed collections */
         unsigned maxapplication;                                        /* Number of applications */
-        unsigned short bus;                                             /* BUS ID */
-        unsigned short vendor;                                          /* Vendor ID */
-        unsigned short product;                                         /* Product ID */
-        unsigned version;                                               /* HID version */
+        __u16 bus;                                                      /* BUS ID */
+        __u32 vendor;                                                   /* Vendor ID */
+        __u32 product;                                                  /* Product ID */
+        __u32 version;                                                  /* HID version */
         unsigned country;                                               /* HID country */
         struct hid_report_enum report_enum[HID_REPORT_TYPES];
 
-        struct device *dev;                                             /* device */
+        struct device dev;                                              /* device */
+        struct hid_driver *driver;
+        struct hid_ll_driver *ll_driver;
 
+        unsigned int status;                                            /* see STAT flags above */
         unsigned claimed;                                               /* Claimed by hidinput, hiddev? */
         unsigned quirks;                                                /* Various quirks the device can pull on us */
 
@@ -462,26 +454,29 @@ struct hid_device {							/* device report descriptor */
 
         void *driver_data;
 
-        __s32 delayed_value;                                            /* For A4 Tech mice hwheel quirk */
-
-        /* device-specific function pointers */
-        int (*hidinput_input_event) (struct input_dev *, unsigned int, unsigned int, int);
-        int (*hid_open) (struct hid_device *);
-        void (*hid_close) (struct hid_device *);
+        /* temporary hid_ff handling (until moved to the drivers) */
+        int (*ff_init)(struct hid_device *);
 
         /* hiddev event handler */
+        int (*hiddev_connect)(struct hid_device *, unsigned int);
         void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
                                   struct hid_usage *, __s32);
         void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
 
         /* handler for raw output data, used by hidraw */
         int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t);
-#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
-        unsigned long apple_pressed_fn[BITS_TO_LONGS(KEY_CNT)];
-        unsigned long pb_pressed_numlock[BITS_TO_LONGS(KEY_CNT)];
-#endif
 };
 
+static inline void *hid_get_drvdata(struct hid_device *hdev)
+{
+        return dev_get_drvdata(&hdev->dev);
+}
+
+static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
+{
+        dev_set_drvdata(&hdev->dev, data);
+}
+
 #define HID_GLOBAL_STACK_SIZE 4
 #define HID_COLLECTION_STACK_SIZE 4
 
@@ -510,6 +505,107 @@ struct hid_descriptor {
         struct hid_class_descriptor desc[1];
 } __attribute__ ((packed));
 
+#define HID_DEVICE(b, ven, prod) \
+        .bus = (b), \
+        .vendor = (ven), .product = (prod)
+
+#define HID_USB_DEVICE(ven, prod)       HID_DEVICE(BUS_USB, ven, prod)
+#define HID_BLUETOOTH_DEVICE(ven, prod) HID_DEVICE(BUS_BLUETOOTH, ven, prod)
+
+#define HID_REPORT_ID(rep) \
+        .report_type = (rep)
+#define HID_USAGE_ID(uhid, utype, ucode) \
+        .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
+/* we don't want to catch types and codes equal to 0 */
+#define HID_TERMINATOR          (HID_ANY_ID - 1)
+
+struct hid_report_id {
+        __u32 report_type;
+};
+struct hid_usage_id {
+        __u32 usage_hid;
+        __u32 usage_type;
+        __u32 usage_code;
+};
+
+/**
+ * struct hid_driver
+ * @name: driver name (e.g. "Footech_bar-wheel")
+ * @id_table: which devices is this driver for (must be non-NULL for probe
+ *            to be called)
+ * @probe: new device inserted
+ * @remove: device removed (NULL if not a hot-plug capable driver)
+ * @report_table: on which reports to call raw_event (NULL means all)
+ * @raw_event: if report in report_table, this hook is called (NULL means nop)
+ * @usage_table: on which events to call event (NULL means all)
+ * @event: if usage in usage_table, this hook is called (NULL means nop)
+ * @report_fixup: called before report descriptor parsing (NULL means nop)
+ * @input_mapping: invoked on input registering before mapping an usage
+ * @input_mapped: invoked on input registering after mapping an usage
+ *
+ * raw_event and event should return 0 on no action performed, 1 when no
+ * further processing should be done and negative on error
+ *
+ * input_mapping shall return a negative value to completely ignore this usage
+ * (e.g. doubled or invalid usage), zero to continue with parsing of this
+ * usage by generic code (no special handling needed) or positive to skip
+ * generic parsing (needed special handling which was done in the hook already)
+ * input_mapped shall return negative to inform the layer that this usage
+ * should not be considered for further processing or zero to notify that
+ * no processing was performed and should be done in a generic manner
+ * Both these functions may be NULL which means the same behavior as returning
+ * zero from them.
+ */
+struct hid_driver {
+        char *name;
+        const struct hid_device_id *id_table;
+
+        int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
+        void (*remove)(struct hid_device *dev);
+
+        const struct hid_report_id *report_table;
+        int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
+                        u8 *data, int size);
+        const struct hid_usage_id *usage_table;
+        int (*event)(struct hid_device *hdev, struct hid_field *field,
+                        struct hid_usage *usage, __s32 value);
+
+        void (*report_fixup)(struct hid_device *hdev, __u8 *buf,
+                        unsigned int size);
+
+        int (*input_mapping)(struct hid_device *hdev,
+                        struct hid_input *hidinput, struct hid_field *field,
+                        struct hid_usage *usage, unsigned long **bit, int *max);
+        int (*input_mapped)(struct hid_device *hdev,
+                        struct hid_input *hidinput, struct hid_field *field,
+                        struct hid_usage *usage, unsigned long **bit, int *max);
+/* private: */
+        struct device_driver driver;
+};
+
+/**
+ * hid_ll_driver - low level driver callbacks
+ * @start: called on probe to start the device
+ * @stop: called on remove
+ * @open: called by input layer on open
+ * @close: called by input layer on close
+ * @hidinput_input_event: event input event (e.g. ff or leds)
+ * @parse: this method is called only once to parse the device data,
+ *         shouldn't allocate anything to not leak memory
+ */
+struct hid_ll_driver {
+        int (*start)(struct hid_device *hdev);
+        void (*stop)(struct hid_device *hdev);
+
+        int (*open)(struct hid_device *hdev);
+        void (*close)(struct hid_device *hdev);
+
+        int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
+                        unsigned int code, int value);
+
+        int (*parse)(struct hid_device *hdev);
+};
+
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
 #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
@@ -520,43 +616,157 @@ struct hid_descriptor {
 extern int hid_debug;
 #endif
 
+extern int hid_add_device(struct hid_device *);
+extern void hid_destroy_device(struct hid_device *);
+
+extern int __must_check __hid_register_driver(struct hid_driver *,
+                struct module *, const char *mod_name);
+static inline int __must_check hid_register_driver(struct hid_driver *driver)
+{
+        return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
+}
+extern void hid_unregister_driver(struct hid_driver *);
+
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
-extern int hidinput_connect(struct hid_device *);
+extern int hidinput_connect(struct hid_device *hid, unsigned int force);
 extern void hidinput_disconnect(struct hid_device *);
 
 int hid_set_field(struct hid_field *, unsigned, __s32);
 int hid_input_report(struct hid_device *, int type, u8 *, int, int);
 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
-int hidinput_mapping_quirks(struct hid_usage *, struct input_dev *, unsigned long **, int *);
-int hidinput_event_quirks(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
-int hidinput_apple_event(struct hid_device *, struct input_dev *, struct hid_usage *, __s32);
 void hid_output_report(struct hid_report *report, __u8 *data);
-void hid_free_device(struct hid_device *device);
-struct hid_device *hid_parse_report(__u8 *start, unsigned size);
+struct hid_device *hid_allocate_device(void);
+int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
+int hid_connect(struct hid_device *hid, unsigned int connect_mask);
+
+/**
+ * hid_map_usage - map usage input bits
+ *
+ * @hidinput: hidinput which we are interested in
+ * @usage: usage to fill in
+ * @bit: pointer to input->{}bit (out parameter)
+ * @max: maximal valid usage->code to consider later (out parameter)
+ * @type: input event type (EV_KEY, EV_REL, ...)
+ * @c: code which corresponds to this usage and type
+ */
+static inline void hid_map_usage(struct hid_input *hidinput,
+                struct hid_usage *usage, unsigned long **bit, int *max,
+                __u8 type, __u16 c)
+{
+        struct input_dev *input = hidinput->input;
+
+        usage->type = type;
+        usage->code = c;
+
+        switch (type) {
+        case EV_ABS:
+                *bit = input->absbit;
+                *max = ABS_MAX;
+                break;
+        case EV_REL:
+                *bit = input->relbit;
+                *max = REL_MAX;
+                break;
+        case EV_KEY:
+                *bit = input->keybit;
+                *max = KEY_MAX;
+                break;
+        case EV_LED:
+                *bit = input->ledbit;
+                *max = LED_MAX;
+                break;
+        }
+}
+
+/**
+ * hid_map_usage_clear - map usage input bits and clear the input bit
+ *
+ * The same as hid_map_usage, except the @c bit is also cleared in supported
+ * bits (@bit).
+ */
+static inline void hid_map_usage_clear(struct hid_input *hidinput,
+                struct hid_usage *usage, unsigned long **bit, int *max,
+                __u8 type, __u16 c)
+{
+        hid_map_usage(hidinput, usage, bit, max, type, c);
+        clear_bit(c, *bit);
+}
+
+/**
+ * hid_parse - parse HW reports
+ *
+ * @hdev: hid device
+ *
+ * Call this from probe after you set up the device (if needed). Your
+ * report_fixup will be called (if non-NULL) after reading raw report from
+ * device before passing it to hid layer for real parsing.
+ */
+static inline int __must_check hid_parse(struct hid_device *hdev)
+{
+        int ret;
+
+        if (hdev->status & HID_STAT_PARSED)
+                return 0;
+
+        ret = hdev->ll_driver->parse(hdev);
+        if (!ret)
+                hdev->status |= HID_STAT_PARSED;
+
+        return ret;
+}
+
+/**
+ * hid_hw_start - start underlaying HW
+ *
+ * @hdev: hid device
+ * @connect_mask: which outputs to connect, see HID_CONNECT_*
+ *
+ * Call this in probe function *after* hid_parse. This will setup HW buffers
+ * and start the device (if not deffered to device open). hid_hw_stop must be
+ * called if this was successfull.
+ */
+static inline int __must_check hid_hw_start(struct hid_device *hdev,
+                unsigned int connect_mask)
+{
+        int ret = hdev->ll_driver->start(hdev);
+        if (ret || !connect_mask)
+                return ret;
+        ret = hid_connect(hdev, connect_mask);
+        if (ret)
+                hdev->ll_driver->stop(hdev);
+        return ret;
+}
+
+/**
+ * hid_hw_stop - stop underlaying HW
+ *
+ * @hdev: hid device
+ *
+ * This is usually called from remove function or from probe when something
+ * failed and hid_hw_start was called already.
+ */
+static inline void hid_hw_stop(struct hid_device *hdev)
+{
+        hdev->ll_driver->stop(hdev);
+}
+
+void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
+                int interrupt);
+
+extern int hid_generic_init(void);
+extern void hid_generic_exit(void);
 
 /* HID quirks API */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
 int usbhid_quirks_init(char **quirks_param);
 void usbhid_quirks_exit(void);
-void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char **);
-
-#ifdef CONFIG_HID_FF
-int hid_ff_init(struct hid_device *hid);
+void usbhid_set_leds(struct hid_device *hid);
 
-int hid_lgff_init(struct hid_device *hid);
-int hid_lg2ff_init(struct hid_device *hid);
-int hid_plff_init(struct hid_device *hid);
-int hid_tmff_init(struct hid_device *hid);
-int hid_zpff_init(struct hid_device *hid);
 #ifdef CONFIG_HID_PID
 int hid_pidff_init(struct hid_device *hid);
 #else
-static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
-#endif
-
-#else
-static inline int hid_ff_init(struct hid_device *hid) { return -1; }
+#define hid_pidff_init NULL
 #endif
 
 #ifdef CONFIG_HID_DEBUG
@@ -572,10 +782,23 @@ dbg_hid(const char *fmt, ...)
         return 0;
 }
 #define dbg_hid_line dbg_hid
-#endif
+#endif /* HID_DEBUG */
 
 #define err_hid(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
                 __FILE__ , ## arg)
-#endif
+#endif /* HID_FF */
+
+#ifdef CONFIG_HID_COMPAT
+#define HID_COMPAT_LOAD_DRIVER(name)    \
+void hid_compat_##name(void) { }        \
+EXPORT_SYMBOL(hid_compat_##name)
+#else
+#define HID_COMPAT_LOAD_DRIVER(name)
+#endif /* HID_COMPAT */
+#define HID_COMPAT_CALL_DRIVER(name)    do {    \
+        extern void hid_compat_##name(void);    \
+        hid_compat_##name();                    \
+} while (0)
+
 #endif
 
diff --git a/include/linux/hiddev.h b/include/linux/hiddev.h
index a416b904ba90..c760ae0eb6a1 100644
--- a/include/linux/hiddev.h
+++ b/include/linux/hiddev.h
@@ -182,26 +182,28 @@ struct hiddev_usage_ref_multi {
 /* To traverse the input report descriptor info for a HID device, perform the 
  * following:
  *
- *  rinfo.report_type = HID_REPORT_TYPE_INPUT;
- *  rinfo.report_id = HID_REPORT_ID_FIRST;
- *  ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ * rinfo.report_type = HID_REPORT_TYPE_INPUT;
+ * rinfo.report_id = HID_REPORT_ID_FIRST;
+ * ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
  *
- *  while (ret >= 0) {
- *      for (i = 0; i < rinfo.num_fields; i++) { 
- *          finfo.report_type = rinfo.report_type;
- *          finfo.report_id = rinfo.report_id;
- *          finfo.field_index = i;
- *          ioctl(fd, HIDIOCGFIELDINFO, &finfo);
- *          for (j = 0; j < finfo.maxusage; j++) {
- *              uref.field_index = i;
- *              uref.usage_index = j;
- *              ioctl(fd, HIDIOCGUCODE, &uref);
- *              ioctl(fd, HIDIOCGUSAGE, &uref);
- *          }
- *      }
- *      rinfo.report_id |= HID_REPORT_ID_NEXT;
- *      ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
- *  }
+ * while (ret >= 0) {
+ *      for (i = 0; i < rinfo.num_fields; i++) {
+ *              finfo.report_type = rinfo.report_type;
+ *              finfo.report_id = rinfo.report_id;
+ *              finfo.field_index = i;
+ *              ioctl(fd, HIDIOCGFIELDINFO, &finfo);
+ *              for (j = 0; j < finfo.maxusage; j++) {
+ *                      uref.report_type = rinfo.report_type;
+ *                      uref.report_id = rinfo.report_id;
+ *                      uref.field_index = i;
+ *                      uref.usage_index = j;
+ *                      ioctl(fd, HIDIOCGUCODE, &uref);
+ *                      ioctl(fd, HIDIOCGUSAGE, &uref);
+ *              }
+ *      }
+ *      rinfo.report_id |= HID_REPORT_ID_NEXT;
+ *      ret = ioctl(fd, HIDIOCGREPORTINFO, &rinfo);
+ * }
  */
 
 
@@ -217,7 +219,7 @@ struct hid_field;
 struct hid_report;
 
 #ifdef CONFIG_USB_HIDDEV
-int hiddev_connect(struct hid_device *);
+int hiddev_connect(struct hid_device *hid, unsigned int force);
 void hiddev_disconnect(struct hid_device *);
 void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
                       struct hid_usage *usage, __s32 value);
@@ -225,7 +227,9 @@ void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
 int __init hiddev_init(void);
 void hiddev_exit(void);
 #else
-static inline int hiddev_connect(struct hid_device *hid) { return -1; }
+static inline int hiddev_connect(struct hid_device *hid,
+                unsigned int force)
+{ return -1; }
 static inline void hiddev_disconnect(struct hid_device *hid) { }
 static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
                       struct hid_usage *usage, __s32 value) { }
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 3481a7d5bc0a..d6a3f47e95cb 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -131,6 +131,16 @@ struct usb_device_id {
 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
 
+#define HID_ANY_ID                              (~0)
+
+struct hid_device_id {
+        __u16 bus;
+        __u32 vendor;
+        __u32 product;
+        kernel_ulong_t driver_data
+                __attribute__((aligned(sizeof(kernel_ulong_t))));
+};
+
 /* s390 CCW devices */
 struct ccw_device_id {
         __u16   match_flags;    /* which fields to match against */
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 96434d774c84..acdeab3d9807 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -578,7 +578,7 @@ static int hidp_session(void *arg)
         if (session->hid) {
                 if (session->hid->claimed & HID_CLAIMED_INPUT)
                         hidinput_disconnect(session->hid);
-                hid_free_device(session->hid);
+                hid_destroy_device(session->hid);
         }
 
         /* Wakeup user-space polling for socket errors */
@@ -623,9 +623,15 @@ static struct device *hidp_get_device(struct hidp_session *session)
 static int hidp_setup_input(struct hidp_session *session,
                                 struct hidp_connadd_req *req)
 {
-        struct input_dev *input = session->input;
+        struct input_dev *input;
         int i;
 
+        input = input_allocate_device();
+        if (!input)
+                return -ENOMEM;
+
+        session->input = input;
+
         input_set_drvdata(input, session);
 
         input->name = "Bluetooth HID Boot Protocol Device";
@@ -677,67 +683,114 @@ static void hidp_close(struct hid_device *hid)
 {
 }
 
-static const struct {
-        __u16 idVendor;
-        __u16 idProduct;
-        unsigned quirks;
-} hidp_blacklist[] = {
-        /* Apple wireless Mighty Mouse */
-        { 0x05ac, 0x030c, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL },
+static int hidp_parse(struct hid_device *hid)
+{
+        struct hidp_session *session = hid->driver_data;
+        struct hidp_connadd_req *req = session->req;
+        unsigned char *buf;
+        int ret;
 
-        { }     /* Terminating entry */
-};
+        buf = kmalloc(req->rd_size, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        if (copy_from_user(buf, req->rd_data, req->rd_size)) {
+                kfree(buf);
+                return -EFAULT;
+        }
+
+        ret = hid_parse_report(session->hid, buf, req->rd_size);
+
+        kfree(buf);
+
+        if (ret)
+                return ret;
+
+        session->req = NULL;
+
+        return 0;
+}
+
+static int hidp_start(struct hid_device *hid)
+{
+        struct hidp_session *session = hid->driver_data;
+        struct hid_report *report;
 
-static void hidp_setup_quirks(struct hid_device *hid)
+        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].
+                        report_list, list)
+                hidp_send_report(session, report);
+
+        list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].
+                        report_list, list)
+                hidp_send_report(session, report);
+
+        return 0;
+}
+
+static void hidp_stop(struct hid_device *hid)
 {
-        unsigned int n;
+        struct hidp_session *session = hid->driver_data;
+
+        skb_queue_purge(&session->ctrl_transmit);
+        skb_queue_purge(&session->intr_transmit);
 
-        for (n = 0; hidp_blacklist[n].idVendor; n++)
-                if (hidp_blacklist[n].idVendor == le16_to_cpu(hid->vendor) &&
-                                hidp_blacklist[n].idProduct == le16_to_cpu(hid->product))
-                        hid->quirks = hidp_blacklist[n].quirks;
+        if (hid->claimed & HID_CLAIMED_INPUT)
+                hidinput_disconnect(hid);
+        hid->claimed = 0;
 }
 
-static void hidp_setup_hid(struct hidp_session *session,
+static struct hid_ll_driver hidp_hid_driver = {
+        .parse = hidp_parse,
+        .start = hidp_start,
+        .stop = hidp_stop,
+        .open  = hidp_open,
+        .close = hidp_close,
+        .hidinput_input_event = hidp_hidinput_event,
+};
+
+static int hidp_setup_hid(struct hidp_session *session,
                                 struct hidp_connadd_req *req)
 {
-        struct hid_device *hid = session->hid;
-        struct hid_report *report;
+        struct hid_device *hid;
         bdaddr_t src, dst;
+        int ret;
 
-        baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
-        baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
+        hid = hid_allocate_device();
+        if (IS_ERR(hid)) {
+                ret = PTR_ERR(session->hid);
+                goto err;
+        }
 
+        session->hid = hid;
+        session->req = req;
         hid->driver_data = session;
 
-        hid->country = req->country;
+        baswap(&src, &bt_sk(session->ctrl_sock->sk)->src);
+        baswap(&dst, &bt_sk(session->ctrl_sock->sk)->dst);
 
         hid->bus     = BUS_BLUETOOTH;
         hid->vendor  = req->vendor;
         hid->product = req->product;
         hid->version = req->version;
+        hid->country = req->country;
 
         strncpy(hid->name, req->name, 128);
         strncpy(hid->phys, batostr(&src), 64);
         strncpy(hid->uniq, batostr(&dst), 64);
 
-        hid->dev = hidp_get_device(session);
-
-        hid->hid_open  = hidp_open;
-        hid->hid_close = hidp_close;
-
-        hid->hidinput_input_event = hidp_hidinput_event;
+        hid->dev.parent = hidp_get_device(session);
+        hid->ll_driver = &hidp_hid_driver;
 
-        hidp_setup_quirks(hid);
+        ret = hid_add_device(hid);
+        if (ret)
+                goto err_hid;
 
-        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
-                hidp_send_report(session, report);
-
-        list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
-                hidp_send_report(session, report);
-
-        if (hidinput_connect(hid) == 0)
-                hid->claimed |= HID_CLAIMED_INPUT;
+        return 0;
+err_hid:
+        hid_destroy_device(hid);
+        session->hid = NULL;
+err:
+        return ret;
 }
 
 int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock, struct socket *intr_sock)
@@ -757,38 +810,6 @@ int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock,
 
         BT_DBG("rd_data %p rd_size %d", req->rd_data, req->rd_size);
 
-        if (req->rd_size > 0) {
-                unsigned char *buf = kmalloc(req->rd_size, GFP_KERNEL);
-
-                if (!buf) {
-                        kfree(session);
-                        return -ENOMEM;
-                }
-
-                if (copy_from_user(buf, req->rd_data, req->rd_size)) {
-                        kfree(buf);
-                        kfree(session);
-                        return -EFAULT;
-                }
-
-                session->hid = hid_parse_report(buf, req->rd_size);
-
-                kfree(buf);
-
-                if (!session->hid) {
-                        kfree(session);
-                        return -EINVAL;
-                }
-        }
-
-        if (!session->hid) {
-                session->input = input_allocate_device();
-                if (!session->input) {
-                        kfree(session);
-                        return -ENOMEM;
-                }
-        }
-
         down_write(&hidp_session_sem);
 
         s = __hidp_get_session(&bt_sk(ctrl_sock->sk)->dst);
@@ -816,15 +837,18 @@ int hidp_add_connection(struct hidp_connadd_req *req, struct socket *ctrl_sock,
         session->flags   = req->flags & (1 << HIDP_BLUETOOTH_VENDOR_ID);
         session->idle_to = req->idle_to;
 
-        if (session->input) {
+        if (req->rd_size > 0) {
+                err = hidp_setup_hid(session, req);
+                if (err && err != -ENODEV)
+                        goto err_skb;
+        }
+
+        if (!session->hid) {
                 err = hidp_setup_input(session, req);
                 if (err < 0)
-                        goto failed;
+                        goto err_skb;
         }
 
-        if (session->hid)
-                hidp_setup_hid(session, req);
-
         __hidp_link_session(session);
 
         hidp_set_timer(session);
@@ -850,17 +874,16 @@ unlink:
 
         __hidp_unlink_session(session);
 
-        if (session->input) {
+        if (session->input)
                 input_unregister_device(session->input);
-                session->input = NULL; /* don't try to free it here */
-        }
-
+        if (session->hid)
+                hid_destroy_device(session->hid);
+err_skb:
+        skb_queue_purge(&session->ctrl_transmit);
+        skb_queue_purge(&session->intr_transmit);
 failed:
         up_write(&hidp_session_sem);
 
-        if (session->hid)
-                hid_free_device(session->hid);
-
         input_free_device(session->input);
         kfree(session);
         return err;
@@ -950,18 +973,43 @@ int hidp_get_conninfo(struct hidp_conninfo *ci)
         return err;
 }
 
+static const struct hid_device_id hidp_table[] = {
+        { HID_BLUETOOTH_DEVICE(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)
 {
+        int ret;
+
         l2cap_load();
 
         BT_INFO("HIDP (Human Interface Emulation) ver %s", VERSION);
 
-        return hidp_init_sockets();
+        ret = hid_register_driver(&hidp_driver);
+        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)
 {
         hidp_cleanup_sockets();
+        hid_unregister_driver(&hidp_driver);
 }
 
 module_init(hidp_init);
diff --git a/net/bluetooth/hidp/hidp.h b/net/bluetooth/hidp/hidp.h
index 343fb0566b3e..e503c89057ad 100644
--- a/net/bluetooth/hidp/hidp.h
+++ b/net/bluetooth/hidp/hidp.h
@@ -151,6 +151,8 @@ struct hidp_session {
 
         struct sk_buff_head ctrl_transmit;
         struct sk_buff_head intr_transmit;
+
+        struct hidp_connadd_req *req;
 };
 
 static inline void hidp_schedule(struct hidp_session *session)
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index 473f94e56ead..d4dc222a74f3 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -206,6 +206,20 @@ static void do_usb_table(void *symval, unsigned long size,
                 do_usb_entry_multi(symval + i, mod);
 }
 
+/* Looks like: hid:bNvNpN */
+static int do_hid_entry(const char *filename,
+                             struct hid_device_id *id, char *alias)
+{
+        id->vendor = TO_NATIVE(id->vendor);
+        id->product = TO_NATIVE(id->product);
+
+        sprintf(alias, "hid:b%04X", id->bus);
+        ADD(alias, "v", id->vendor != HID_ANY_ID, id->vendor);
+        ADD(alias, "p", id->product != HID_ANY_ID, id->product);
+
+        return 1;
+}
+
 /* Looks like: ieee1394:venNmoNspNverN */
 static int do_ieee1394_entry(const char *filename,
                              struct ieee1394_device_id *id, char *alias)
@@ -745,6 +759,10 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
         else if (sym_is(symname, "__mod_usb_device_table"))
                 /* special case to handle bcdDevice ranges */
                 do_usb_table(symval, sym->st_size, mod);
+        else if (sym_is(symname, "__mod_hid_device_table"))
+                do_table(symval, sym->st_size,
+                         sizeof(struct hid_device_id), "hid",
+                         do_hid_entry, mod);
         else if (sym_is(symname, "__mod_ieee1394_device_table"))
                 do_table(symval, sym->st_size,
                          sizeof(struct ieee1394_device_id), "ieee1394",