Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 28023d2a8e9121b1b06c3b46e523c3c7a3e8b530

Authored by Linus Torvalds 2015-01-10 13:18:48 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

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

Pull HID updates from Jiri Kosina:

 - bounds checking fixes in logitech and roccat drivers, from Peter Wu
   and Dan Carpenter

 - double-kfree fix in i2c-hid driver on bus shutdown, from Mika
   Westerberg

 - a couple of various small driver fixes

 - a few device id additions

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid:
  HID: roccat: potential out of bounds in pyra_sysfs_write_settings()
  HID: Add a new id 0x501a for Genius MousePen i608X
  HID: logitech-hidpp: prefix the name with "Logitech"
  HID: logitech-hidpp: avoid unintended fall-through
  HID: Allow HID_BATTERY_STRENGTH to be enabled
  HID: i2c-hid: Do not free buffers in i2c_hid_stop()
  HID: add battery quirk for USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO keyboard
  HID: logitech-hidpp: check WTP report length
  HID: logitech-dj: check report length

Showing 10 changed files Inline Diff

drivers/hid/Kconfig
drivers/hid/hid-core.c
drivers/hid/hid-ids.h
drivers/hid/hid-input.c
drivers/hid/hid-kye.c
drivers/hid/hid-logitech-dj.c
drivers/hid/hid-logitech-hidpp.c
drivers/hid/hid-roccat-pyra.c
drivers/hid/i2c-hid/i2c-hid.c
drivers/hid/usbhid/hid-quirks.c

drivers/hid/Kconfig

Diff comments View file @ 28023d2

 #
 # HID driver configuration
 #
 menu "HID support"
      depends on INPUT
 config HID
 	tristate "HID bus support"
 	depends on INPUT
 	default y
 	---help---
 	  A human interface device (HID) is a type of computer device that
 	  interacts directly with and takes input from humans. The term "HID"
 	  most commonly used to refer to the USB-HID specification, but other
 	  devices (such as, but not strictly limited to, Bluetooth) are
 	  designed using HID specification (this involves certain keyboards,
 	  mice, tablets, etc). This option adds the HID bus to the kernel,
 	  together with generic HID layer code. The HID devices are added and
 	  removed from the HID bus by the transport-layer drivers, such as
 	  usbhid (USB_HID) and hidp (BT_HIDP).
 	  For docs and specs, see http://www.usb.org/developers/hidpage/
 	  If unsure, say Y.
 if HID
 config HID_BATTERY_STRENGTH
 	bool "Battery level reporting for HID devices"
-	depends on HID && POWER_SUPPLY && HID = POWER_SUPPLY
+	depends on HID
+	select POWER_SUPPLY
 	default n
 	---help---
 	This option adds support of reporting battery strength (for HID devices
 	that support this feature) through power_supply class so that userspace
 	tools, such as upower, can display it.
 config HIDRAW
 	bool "/dev/hidraw raw HID device support"
 	depends on HID
 	---help---
 	Say Y here if you want to support HID devices (from the USB
 	specification standpoint) that aren't strictly user interface
 	devices, like monitor controls and Uninterruptable Power Supplies.
 	This module supports these devices separately using a separate
 	event interface on /dev/hidraw.
 	There is also a /dev/hiddev configuration option in the USB HID
 	configuration menu. In comparison to hiddev, this device does not process
 	the hid events at all (no parsing, no lookups). This lets applications
 	to work on raw hid events when they want to, and avoid using transport-specific
 	userspace libhid/libusb libraries.
 	If unsure, say Y.
 config UHID
 	tristate "User-space I/O driver support for HID subsystem"
 	depends on HID
 	default n
 	---help---
 	Say Y here if you want to provide HID I/O Drivers from user-space.
 	This allows to write I/O drivers in user-space and feed the data from
 	the device into the kernel. The kernel parses the HID reports, loads the
 	corresponding HID Device Driver or provides input devices on top of your
 	user-space device.
 	This driver cannot be used to parse HID-reports in user-space and write
 	special HID-drivers. You should use hidraw for that.
 	Instead, this driver allows to write the transport-layer driver in
 	user-space like USB-HID and Bluetooth-HID do in kernel-space.
 	If unsure, say N.
 	To compile this driver as a module, choose M here: the
 	module will be called uhid.
 config HID_GENERIC
 	tristate "Generic HID driver"
 	depends on HID
 	default HID
 	---help---
 	Support for generic devices on the HID bus. This includes most
 	keyboards and mice, joysticks, tablets and digitizers.
 	To compile this driver as a module, choose M here: the module
 	will be called hid-generic.
 	If unsure, say Y.
 menu "Special HID drivers"
 	depends on HID
 config HID_A4TECH
 	tristate "A4 tech mice" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for A4 tech X5 and WOP-35 / Trust 450L mice.
 config HID_ACRUX
 	tristate "ACRUX game controller support"
 	depends on HID
 	---help---
 	Say Y here if you want to enable support for ACRUX game controllers.
 config HID_ACRUX_FF
 	bool "ACRUX force feedback support"
 	depends on HID_ACRUX
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for ACRUX
 	game controllers.
 config HID_APPLE
 	tristate "Apple {i,Power,Mac}Books" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for some Apple devices which less or more break
 	HID specification.
 	Say Y here if you want support for keyboards of	Apple iBooks, PowerBooks,
 	MacBooks, MacBook Pros and Apple Aluminum.
 config HID_APPLEIR
 	tristate "Apple infrared receiver"
 	depends on (USB_HID)
 	---help---
 	Support for Apple infrared remote control. All the Apple computers from
 	  2005 onwards include such a port, except the unibody Macbook (2009),
 	  and Mac Pros. This receiver is also used in the Apple TV set-top box
 	  prior to the 2010 model.
 	Say Y here if you want support for Apple infrared remote control.
 config HID_AUREAL
 	tristate "Aureal"
 	depends on HID
 	---help---
 	Support for Aureal Cy se W-01RN Remote Controller and other Aureal derived remotes.
 config HID_BELKIN
 	tristate "Belkin Flip KVM and Wireless keyboard" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Belkin Flip KVM and Wireless keyboard.
 config HID_CHERRY
 	tristate "Cherry Cymotion keyboard" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Cherry Cymotion keyboard.
 config HID_CHICONY
 	tristate "Chicony Tactical pad" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Chicony Tactical pad.
 config HID_PRODIKEYS
 	tristate "Prodikeys PC-MIDI Keyboard support"
 	depends on HID && SND
 	select SND_RAWMIDI
 	---help---
 	Support for Prodikeys PC-MIDI Keyboard device support.
 	Say Y here to enable support for this device.
 	- Prodikeys PC-MIDI keyboard.
 	  The Prodikeys PC-MIDI acts as a USB Audio device, with one MIDI
 	  input and one MIDI output. These MIDI jacks appear as
 	  a sound "card" in the ALSA sound system.
 	  Note: if you say N here, this device will still function as a basic
 	  multimedia keyboard, but will lack support for the musical keyboard
 	  and some additional multimedia keys.
 config HID_CP2112
 	tristate "Silicon Labs CP2112 HID USB-to-SMBus Bridge support"
 	depends on USB_HID && I2C && GPIOLIB
 	---help---
 	Support for Silicon Labs CP2112 HID USB to SMBus Master Bridge.
 	This is a HID device driver which registers as an i2c adapter
 	and gpiochip to expose these functions of the CP2112. The
 	customizable USB descriptor fields are exposed as sysfs attributes.
 config HID_CYPRESS
 	tristate "Cypress mouse and barcode readers" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for cypress mouse and barcode readers.
 config HID_DRAGONRISE
 	tristate "DragonRise Inc. game controller"
 	depends on HID
 	---help---
 	Say Y here if you have DragonRise Inc. game controllers.
 	These might be branded as:
 	- Tesun USB-703
 	- Media-tech MT1504 "Rogue"
 	- DVTech JS19 "Gear"
 	- Defender Game Master
 config DRAGONRISE_FF
 	bool "DragonRise Inc. force feedback"
 	depends on HID_DRAGONRISE
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for DragonRise Inc.
 	game controllers.
 config HID_EMS_FF
 	tristate "EMS Production Inc. force feedback support"
 	depends on HID
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for devices by
 	EMS Production Ltd.
 	Currently the following devices are known to be supported:
 	 - Trio Linker Plus II
 config HID_ELECOM
 	tristate "ELECOM BM084 bluetooth mouse"
 	depends on HID
 	---help---
 	Support for the ELECOM BM084 (bluetooth mouse).
 config HID_ELO
 	tristate "ELO USB 4000/4500 touchscreen"
 	depends on USB_HID
 	---help---
 	Support for the ELO USB 4000/4500 touchscreens. Note that this is for
 	different devices than those handled by CONFIG_TOUCHSCREEN_USB_ELO.
 config HID_EZKEY
 	tristate "Ezkey BTC 8193 keyboard" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Ezkey BTC 8193 keyboard.
 config HID_HOLTEK
 	tristate "Holtek HID devices"
 	depends on USB_HID
 	---help---
 	Support for Holtek based devices:
 	  - Holtek On Line Grip based game controller
 	  - Trust GXT 18 Gaming Keyboard
 	  - Sharkoon Drakonia / Perixx MX-2000 gaming mice
 	  - Tracer Sniper TRM-503 / NOVA Gaming Slider X200 /
 	    Zalman ZM-GM1
 	  - SHARKOON DarkGlider Gaming mouse
 	  - LEETGION Hellion Gaming Mouse
 config HOLTEK_FF
 	bool "Holtek On Line Grip force feedback support"
 	depends on HID_HOLTEK
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a Holtek On Line Grip based game controller
 	  and want to have force feedback support for it.
 config HID_GT683R
 	tristate "MSI GT68xR LED support"
 	depends on LEDS_CLASS && USB_HID
 	---help---
 	Say Y here if you want to enable support for the three MSI GT68xR LEDs
 	This driver support following modes:
 	  - Normal: LEDs are fully on when enabled
 	  - Audio:  LEDs brightness depends on sound level
 	  - Breathing: LEDs brightness varies at human breathing rate
 	Currently the following devices are know to be supported:
 	  - MSI GT683R
 config HID_HUION
 	tristate "Huion tablets"
 	depends on USB_HID
 	---help---
 	Support for Huion 580 tablet.
 config HID_KEYTOUCH
 	tristate "Keytouch HID devices"
 	depends on HID
 	---help---
 	Support for Keytouch HID devices not fully compliant with
 	the specification. Currently supported:
 		- Keytouch IEC 60945
 config HID_KYE
 	tristate "KYE/Genius devices"
 	depends on HID
 	---help---
 	Support for KYE/Genius devices not fully compliant with HID standard:
 	- Ergo Mouse
 	- EasyPen i405X tablet
 	- MousePen i608X tablet
 	- EasyPen M610X tablet
 config HID_UCLOGIC
 	tristate "UC-Logic"
 	depends on HID
 	---help---
 	Support for UC-Logic tablets.
 config HID_WALTOP
 	tristate "Waltop"
 	depends on HID
 	---help---
 	Support for Waltop tablets.
 config HID_GYRATION
 	tristate "Gyration remote control"
 	depends on HID
 	---help---
 	Support for Gyration remote control.
 config HID_ICADE
 	tristate "ION iCade arcade controller"
 	depends on HID
 	---help---
 	Support for the ION iCade arcade controller to work as a joystick.
 	To compile this driver as a module, choose M here: the
 	module will be called hid-icade.
 config HID_TWINHAN
 	tristate "Twinhan IR remote control"
 	depends on HID
 	---help---
 	Support for Twinhan IR remote control.
 config HID_KENSINGTON
 	tristate "Kensington Slimblade Trackball" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Kensington Slimblade Trackball.
 config HID_LCPOWER
 	tristate "LC-Power"
 	depends on HID
 	---help---
 	Support for LC-Power RC1000MCE RF remote control.
 config HID_LENOVO
 	tristate "Lenovo / Thinkpad devices"
 	depends on HID
 	select NEW_LEDS
 	select LEDS_CLASS
 	---help---
 	Support for Lenovo devices that are not fully compliant with HID standard.
 	Say Y if you want support for the non-compliant features of the Lenovo
 	Thinkpad standalone keyboards, e.g:
 	- ThinkPad USB Keyboard with TrackPoint (supports extra LEDs and trackpoint
 	  configuration)
 	- ThinkPad Compact Bluetooth Keyboard with TrackPoint (supports Fn keys)
 	- ThinkPad Compact USB Keyboard with TrackPoint (supports Fn keys)
 config HID_LOGITECH
 	tristate "Logitech devices" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Logitech devices that are not fully compliant with HID standard.
 config HID_LOGITECH_DJ
 	tristate "Logitech Unifying receivers full support"
 	depends on HIDRAW
 	depends on HID_LOGITECH
 	select HID_LOGITECH_HIDPP
 	---help---
 	Say Y if you want support for Logitech Unifying receivers and devices.
 	Unifying receivers are capable of pairing up to 6 Logitech compliant
 	devices to the same receiver. Without this driver it will be handled by
 	generic USB_HID driver and all incoming events will be multiplexed
 	into a single mouse and a single keyboard device.
 config HID_LOGITECH_HIDPP
 	tristate "Logitech HID++ devices support"
 	depends on HID_LOGITECH
 	---help---
 	Support for Logitech devices relyingon the HID++ Logitech specification
 	Say Y if you want support for Logitech devices relying on the HID++
 	specification. Such devices are the various Logitech Touchpads (T650,
 	T651, TK820), some mice (Zone Touch mouse), or even keyboards (Solar
 	Keayboard).
 config LOGITECH_FF
 	bool "Logitech force feedback support"
 	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 WingMan Formula Force GP
 	  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 force feedback support (variant 2)"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you want to enable force feedback support for:
 	  - Logitech RumblePad
 	  - Logitech Rumblepad 2
 	  - Logitech Formula Vibration Feedback Wheel
 config LOGIG940_FF
 	bool "Logitech Flight System G940 force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	help
 	  Say Y here if you want to enable force feedback support for Logitech
 	  Flight System G940 devices.
 config LOGIWHEELS_FF
 	bool "Logitech wheels configuration and force feedback support"
 	depends on HID_LOGITECH
 	select INPUT_FF_MEMLESS
 	default LOGITECH_FF
 	help
 	  Say Y here if you want to enable force feedback and range setting
 	  support for following Logitech wheels:
 	  - Logitech Driving Force
 	  - Logitech Driving Force Pro
 	  - Logitech Driving Force GT
 	  - Logitech G25
 	  - Logitech G27
 	  - Logitech MOMO/MOMO 2
 	  - Logitech Formula Force EX
 config HID_MAGICMOUSE
 	tristate "Apple Magic Mouse/Trackpad multi-touch support"
 	depends on HID
 	---help---
 	Support for the Apple Magic Mouse/Trackpad multi-touch.
 	Say Y here if you want support for the multi-touch features of the
 	Apple Wireless "Magic" Mouse and the Apple Wireless "Magic" Trackpad.
 config HID_MICROSOFT
 	tristate "Microsoft non-fully HID-compliant devices" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Microsoft devices that are not fully compliant with HID standard.
 config HID_MONTEREY
 	tristate "Monterey Genius KB29E keyboard" if EXPERT
 	depends on HID
 	default !EXPERT
 	---help---
 	Support for Monterey Genius KB29E.
 config HID_MULTITOUCH
 	tristate "HID Multitouch panels"
 	depends on HID
 	---help---
 	  Generic support for HID multitouch panels.
 	  Say Y here if you have one of the following devices:
 	  - 3M PCT touch screens
 	  - ActionStar dual touch panels
 	  - Atmel panels
 	  - Cando dual touch panels
 	  - Chunghwa panels
 	  - CVTouch panels
 	  - Cypress TrueTouch panels
 	  - Elan Microelectronics touch panels
 	  - Elo TouchSystems IntelliTouch Plus panels
 	  - GeneralTouch 'Sensing Win7-TwoFinger' panels
 	  - GoodTouch panels
 	  - Hanvon dual touch panels
 	  - Ilitek dual touch panels
 	  - IrTouch Infrared USB panels
 	  - LG Display panels (Dell ST2220Tc)
 	  - Lumio CrystalTouch panels
 	  - MosArt dual-touch panels
 	  - Panasonic multitouch panels
 	  - PenMount dual touch panels
 	  - Perixx Peripad 701 touchpad
 	  - PixArt optical touch screen
 	  - Pixcir dual touch panels
 	  - Quanta panels
 	  - eGalax dual-touch panels, including the Joojoo and Wetab tablets
 	  - SiS multitouch panels
 	  - Stantum multitouch panels
 	  - Touch International Panels
 	  - Unitec Panels
 	  - Wistron optical touch panels
 	  - XAT optical touch panels
 	  - Xiroku optical touch panels
 	  - Zytronic touch panels
 	  If unsure, say N.
 	  To compile this driver as a module, choose M here: the
 	  module will be called hid-multitouch.
 config HID_NTRIG
 	tristate "N-Trig touch screen"
 	depends on USB_HID
 	---help---
 	Support for N-Trig touch screen.
 config HID_ORTEK
 	tristate "Ortek PKB-1700/WKB-2000/Skycable wireless keyboard and mouse trackpad"
 	depends on HID
 	---help---
 	There are certain devices which have LogicalMaximum wrong in the keyboard
 	usage page of their report descriptor. The most prevailing ones so far
 	are manufactured by Ortek, thus the name of the driver. Currently
 	supported devices by this driver are
 	   - Ortek PKB-1700
 	   - Ortek WKB-2000
 	   - Skycable wireless presenter
 config HID_PANTHERLORD
 	tristate "Pantherlord/GreenAsia game controller"
 	depends on HID
 	---help---
 	  Say Y here if you have a PantherLord/GreenAsia based game controller
 	  or adapter.
 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_PENMOUNT
 	tristate "Penmount touch device"
 	depends on USB_HID
 	---help---
 	  This selects a driver for the PenMount 6000 touch controller.
 	  The driver works around a problem in the report descript allowing
 	  the userspace to touch events instead of mouse events.
 	  Say Y here if you have a Penmount based touch controller.
 config HID_PETALYNX
 	tristate "Petalynx Maxter remote control"
 	depends on HID
 	---help---
 	Support for Petalynx Maxter remote control.
 config HID_PICOLCD
 	tristate "PicoLCD (graphic version)"
 	depends on HID
 	---help---
 	  This provides support for Minibox PicoLCD devices, currently
 	  only the graphical ones are supported.
 	  This includes support for the following device features:
 	  - Keypad
 	  - Switching between Firmware and Flash mode
 	  - EEProm / Flash access     (via debugfs)
 	  Features selectively enabled:
 	  - Framebuffer for monochrome 256x64 display
 	  - Backlight control
 	  - Contrast control
 	  - General purpose outputs
 	  Features that are not (yet) supported:
 	  - IR
 config HID_PICOLCD_FB
 	bool "Framebuffer support" if EXPERT
 	default !EXPERT
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=FB || FB=y
 	select FB_DEFERRED_IO
 	select FB_SYS_FILLRECT
 	select FB_SYS_COPYAREA
 	select FB_SYS_IMAGEBLIT
 	select FB_SYS_FOPS
 	---help---
 	  Provide access to PicoLCD's 256x64 monochrome display via a
 	  framebuffer device.
 config HID_PICOLCD_BACKLIGHT
 	bool "Backlight control" if EXPERT
 	default !EXPERT
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=BACKLIGHT_CLASS_DEVICE || BACKLIGHT_CLASS_DEVICE=y
 	---help---
 	  Provide access to PicoLCD's backlight control via backlight
 	  class.
 config HID_PICOLCD_LCD
 	bool "Contrast control" if EXPERT
 	default !EXPERT
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=LCD_CLASS_DEVICE || LCD_CLASS_DEVICE=y
 	---help---
 	  Provide access to PicoLCD's LCD contrast via lcd class.
 config HID_PICOLCD_LEDS
 	bool "GPO via leds class" if EXPERT
 	default !EXPERT
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=LEDS_CLASS || LEDS_CLASS=y
 	---help---
 	  Provide access to PicoLCD's GPO pins via leds class.
 config HID_PICOLCD_CIR
 	bool "CIR via RC class" if EXPERT
 	default !EXPERT
 	depends on HID_PICOLCD
 	depends on HID_PICOLCD=RC_CORE || RC_CORE=y
 	---help---
 	  Provide access to PicoLCD's CIR interface via remote control (LIRC).
 config HID_PLANTRONICS
 	tristate "Plantronics USB HID Driver"
 	default !EXPERT
 	depends on HID
 	---help---
 	Provides HID support for Plantronics telephony devices.
 config HID_PRIMAX
 	tristate "Primax non-fully HID-compliant devices"
 	depends on HID
 	---help---
 	Support for Primax devices that are not fully compliant with the
 	HID standard.
 config HID_ROCCAT
 	tristate "Roccat device support"
 	depends on USB_HID
 	---help---
 	Support for Roccat devices.
 	Say Y here if you have a Roccat mouse or keyboard and want
 	support for its special functionalities.
 config HID_SAITEK
 	tristate "Saitek (Mad Catz) non-fully HID-compliant devices"
 	depends on HID
 	---help---
 	Support for Saitek devices that are not fully compliant with the
 	HID standard.
 	Supported devices:
 	- PS1000 Dual Analog Pad
 	- R.A.T.9 Gaming Mouse
 	- R.A.T.7 Gaming Mouse
 	- M.M.O.7 Gaming Mouse
 config HID_SAMSUNG
 	tristate "Samsung InfraRed remote control or keyboards"
 	depends on HID
 	---help---
 	Support for Samsung InfraRed remote control or keyboards.
 config HID_SONY
 	tristate "Sony PS2/3/4 accessories"
 	depends on USB_HID
 	depends on NEW_LEDS
 	depends on LEDS_CLASS
 	select POWER_SUPPLY
 	---help---
 	Support for
 	  * Sony PS3 6-axis controllers
 	  * Sony PS4 DualShock 4 controllers
 	  * Buzz controllers
 	  * Sony PS3 Blue-ray Disk Remote Control (Bluetooth)
 	  * Logitech Harmony adapter for Sony Playstation 3 (Bluetooth)
 config SONY_FF
 	bool "Sony PS2/3/4 accessories force feedback support"
 	depends on HID_SONY
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you have a Sony PS2/3/4 accessory and want to enable
 	force feedback support for it.
 config HID_SPEEDLINK
 	tristate "Speedlink VAD Cezanne mouse support"
 	depends on HID
 	---help---
 	Support for Speedlink Vicious and Divine Cezanne mouse.
 config HID_STEELSERIES
 	tristate "Steelseries SRW-S1 steering wheel support"
 	depends on HID
 	---help---
 	Support for Steelseries SRW-S1 steering wheel
 config HID_SUNPLUS
 	tristate "Sunplus wireless desktop"
 	depends on HID
 	---help---
 	Support for Sunplus wireless desktop.
 config HID_RMI
 	tristate "Synaptics RMI4 device support"
 	depends on HID
 	---help---
 	Support for Synaptics RMI4 touchpads.
 	Say Y here if you have a Synaptics RMI4 touchpads over i2c-hid or usbhid
 	and want support for its special functionalities.
 config HID_GREENASIA
 	tristate "GreenAsia (Product ID 0x12) game controller support"
 	depends on HID
 	---help---
 	  Say Y here if you have a GreenAsia (Product ID 0x12) based game
 	  controller or adapter.
 config GREENASIA_FF
 	bool "GreenAsia (Product ID 0x12) force feedback support"
 	depends on HID_GREENASIA
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you have a GreenAsia (Product ID 0x12) based game controller
 	(like MANTA Warrior MM816 and SpeedLink Strike2 SL-6635) or adapter
 	and want to enable force feedback support for it.
 config HID_HYPERV_MOUSE
 	tristate "Microsoft Hyper-V mouse driver"
 	depends on HYPERV
 	---help---
 	Select this option to enable the Hyper-V mouse driver.
 config HID_SMARTJOYPLUS
 	tristate "SmartJoy PLUS PS2/USB adapter support"
 	depends on HID
 	---help---
 	Support for SmartJoy PLUS PS2/USB adapter, Super Dual Box,
 	Super Joy Box 3 Pro, Super Dual Box Pro, and Super Joy Box 5 Pro.
 	Note that DDR (Dance Dance Revolution) mode is not supported, nor
 	is pressure sensitive buttons on the pro models.
 config SMARTJOYPLUS_FF
 	bool "SmartJoy PLUS PS2/USB adapter force feedback support"
 	depends on HID_SMARTJOYPLUS
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you have a SmartJoy PLUS PS2/USB adapter and want to
 	enable force feedback support for it.
 config HID_TIVO
 	tristate "TiVo Slide Bluetooth remote control support"
 	depends on HID
 	---help---
 	Say Y if you have a TiVo Slide Bluetooth remote control.
 config HID_TOPSEED
 	tristate "TopSeed Cyberlink, BTC Emprex, Conceptronic remote control support"
 	depends on HID
 	---help---
 	Say Y if you have a TopSeed Cyberlink or BTC Emprex or Conceptronic
 	CLLRCMCE remote control.
 config HID_THINGM
 	tristate "ThingM blink(1) USB RGB LED"
 	depends on HID
 	depends on LEDS_CLASS
 	---help---
 	Support for the ThingM blink(1) USB RGB LED. This driver registers a
 	Linux LED class instance, plus additional sysfs attributes to control
 	RGB colors, fade time and playing. The device is exposed through hidraw
 	to access other functions.
 config HID_THRUSTMASTER
 	tristate "ThrustMaster devices support"
 	depends on HID
 	---help---
 	  Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
 	  a THRUSTMASTER Ferrari GT Rumble Wheel.
 config THRUSTMASTER_FF
 	bool "ThrustMaster devices force feedback support"
 	depends on HID_THRUSTMASTER
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or 3,
 	  a THRUSTMASTER Dual Trigger 3-in-1 or a THRUSTMASTER Ferrari GT
 	  Rumble Force or Force Feedback Wheel.
 config HID_WACOM
 	tristate "Wacom Intuos/Graphire tablet support (USB)"
 	depends on HID
 	select POWER_SUPPLY
 	select NEW_LEDS
 	select LEDS_CLASS
 	help
 	  Say Y here if you want to use the USB or BT version of the Wacom Intuos
 	  or Graphire tablet.
 	  To compile this driver as a module, choose M here: the
 	  module will be called wacom.
 config HID_WIIMOTE
 	tristate "Nintendo Wii / Wii U peripherals"
 	depends on HID
 	depends on LEDS_CLASS
 	select POWER_SUPPLY
 	select INPUT_FF_MEMLESS
 	---help---
 	Support for Nintendo Wii and Wii U Bluetooth peripherals. Supported
 	devices are the Wii Remote and its extension devices, but also devices
 	based on the Wii Remote like the Wii U Pro Controller or the
 	Wii Balance Board.
 	Support for all official Nintendo extensions is available, however, 3rd
 	party extensions might not be supported. Please report these devices to:
 	  http://github.com/dvdhrm/xwiimote/issues
 	Other Nintendo Wii U peripherals that are IEEE 802.11 based (including
 	the Wii U Gamepad) might be supported in the future. But currently
 	support is limited to Bluetooth based devices.
 	If unsure, say N.
 	To compile this driver as a module, choose M here: the
 	module will be called hid-wiimote.
 config HID_XINMO
 	tristate "Xin-Mo non-fully compliant devices"
 	depends on HID
 	---help---
 	Support for Xin-Mo devices that are not fully compliant with the HID
 	standard. Currently only supports the Xin-Mo Dual Arcade. Say Y here
 	if you have a Xin-Mo Dual Arcade controller.
 config HID_ZEROPLUS
 	tristate "Zeroplus based game controller support"
 	depends on HID
 	---help---
 	  Say Y here if you have a Zeroplus based game controller.
 config ZEROPLUS_FF
 	bool "Zeroplus based game controller force feedback support"
 	depends on HID_ZEROPLUS
 	select INPUT_FF_MEMLESS
 	---help---
 	  Say Y here if you have a Zeroplus based game controller and want
 	  to have force feedback support for it.
 config HID_ZYDACRON
 	tristate "Zydacron remote control support"
 	depends on HID
 	---help---
 	Support for Zydacron remote control.
 config HID_SENSOR_HUB
 	tristate "HID Sensors framework support"
 	depends on HID && HAS_IOMEM
 	select MFD_CORE
 	default n
 	---help---
 	  Support for HID Sensor framework. This creates a MFD instance
 	  for a sensor hub and identifies all the sensors connected to it.
 	  Each sensor is registered as a MFD cell, so that sensor specific
 	  processing can be done in a separate driver. Each sensor
 	  drivers can use the service provided by this driver to register
 	  for events and handle data streams. Each sensor driver can format
 	  data and present to user mode using input or IIO interface.
 endmenu
 endif # HID
 source "drivers/hid/usbhid/Kconfig"
 source "drivers/hid/i2c-hid/Kconfig"
 endmenu

drivers/hid/hid-core.c

Diff comments View file @ 28023d2

 /*
  *  HID support for Linux
  *
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2006-2012 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, or (at your option)
  * any later version.
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mm.h>
 #include <linux/spinlock.h>
 #include <asm/unaligned.h>
 #include <asm/byteorder.h>
 #include <linux/input.h>
 #include <linux/wait.h>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/semaphore.h>
 #include <linux/hid.h>
 #include <linux/hiddev.h>
 #include <linux/hid-debug.h>
 #include <linux/hidraw.h>
 #include "hid-ids.h"
 /*
  * Version Information
  */
 #define DRIVER_DESC "HID core driver"
 #define DRIVER_LICENSE "GPL"
 int hid_debug = 0;
 module_param_named(debug, hid_debug, int, 0600);
 MODULE_PARM_DESC(debug, "toggle HID debugging messages");
 EXPORT_SYMBOL_GPL(hid_debug);
 static int hid_ignore_special_drivers = 0;
 module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
 MODULE_PARM_DESC(ignore_special_drivers, "Ignore any special drivers and handle all devices by generic driver");
 /*
  * Register a new report for a device.
  */
 struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
 {
 	struct hid_report_enum *report_enum = device->report_enum + type;
 	struct hid_report *report;
 	if (id >= HID_MAX_IDS)
 		return NULL;
 	if (report_enum->report_id_hash[id])
 		return report_enum->report_id_hash[id];
 	report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
 	if (!report)
 		return NULL;
 	if (id != 0)
 		report_enum->numbered = 1;
 	report->id = id;
 	report->type = type;
 	report->size = 0;
 	report->device = device;
 	report_enum->report_id_hash[id] = report;
 	list_add_tail(&report->list, &report_enum->report_list);
 	return report;
 }
 EXPORT_SYMBOL_GPL(hid_register_report);
 /*
  * Register a new field for this report.
  */
 static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
 {
 	struct hid_field *field;
 	if (report->maxfield == HID_MAX_FIELDS) {
 		hid_err(report->device, "too many fields in report\n");
 		return NULL;
 	}
 	field = kzalloc((sizeof(struct hid_field) +
 			 usages * sizeof(struct hid_usage) +
 			 values * sizeof(unsigned)), GFP_KERNEL);
 	if (!field)
 		return NULL;
 	field->index = report->maxfield++;
 	report->field[field->index] = field;
 	field->usage = (struct hid_usage *)(field + 1);
 	field->value = (s32 *)(field->usage + usages);
 	field->report = report;
 	return field;
 }
 /*
  * Open a collection. The type/usage is pushed on the stack.
  */
 static int open_collection(struct hid_parser *parser, unsigned type)
 {
 	struct hid_collection *collection;
 	unsigned usage;
 	usage = parser->local.usage[0];
 	if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
 		hid_err(parser->device, "collection stack overflow\n");
 		return -EINVAL;
 	}
 	if (parser->device->maxcollection == parser->device->collection_size) {
 		collection = kmalloc(sizeof(struct hid_collection) *
 				parser->device->collection_size * 2, GFP_KERNEL);
 		if (collection == NULL) {
 			hid_err(parser->device, "failed to reallocate collection array\n");
 			return -ENOMEM;
 		}
 		memcpy(collection, parser->device->collection,
 			sizeof(struct hid_collection) *
 			parser->device->collection_size);
 		memset(collection + parser->device->collection_size, 0,
 			sizeof(struct hid_collection) *
 			parser->device->collection_size);
 		kfree(parser->device->collection);
 		parser->device->collection = collection;
 		parser->device->collection_size *= 2;
 	}
 	parser->collection_stack[parser->collection_stack_ptr++] =
 		parser->device->maxcollection;
 	collection = parser->device->collection +
 		parser->device->maxcollection++;
 	collection->type = type;
 	collection->usage = usage;
 	collection->level = parser->collection_stack_ptr - 1;
 	if (type == HID_COLLECTION_APPLICATION)
 		parser->device->maxapplication++;
 	return 0;
 }
 /*
  * Close a collection.
  */
 static int close_collection(struct hid_parser *parser)
 {
 	if (!parser->collection_stack_ptr) {
 		hid_err(parser->device, "collection stack underflow\n");
 		return -EINVAL;
 	}
 	parser->collection_stack_ptr--;
 	return 0;
 }
 /*
  * Climb up the stack, search for the specified collection type
  * and return the usage.
  */
 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 {
 	struct hid_collection *collection = parser->device->collection;
 	int n;
 	for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
 		unsigned index = parser->collection_stack[n];
 		if (collection[index].type == type)
 			return collection[index].usage;
 	}
 	return 0; /* we know nothing about this usage type */
 }
 /*
  * Add a usage to the temporary parser table.
  */
 static int hid_add_usage(struct hid_parser *parser, unsigned usage)
 {
 	if (parser->local.usage_index >= HID_MAX_USAGES) {
 		hid_err(parser->device, "usage index exceeded\n");
 		return -1;
 	}
 	parser->local.usage[parser->local.usage_index] = usage;
 	parser->local.collection_index[parser->local.usage_index] =
 		parser->collection_stack_ptr ?
 		parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
 	parser->local.usage_index++;
 	return 0;
 }
 /*
  * Register a new field for this report.
  */
 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
 {
 	struct hid_report *report;
 	struct hid_field *field;
 	unsigned usages;
 	unsigned offset;
 	unsigned i;
 	report = hid_register_report(parser->device, report_type, parser->global.report_id);
 	if (!report) {
 		hid_err(parser->device, "hid_register_report failed\n");
 		return -1;
 	}
 	/* Handle both signed and unsigned cases properly */
 	if ((parser->global.logical_minimum < 0 &&
 		parser->global.logical_maximum <
 		parser->global.logical_minimum) ||
 		(parser->global.logical_minimum >= 0 &&
 		(__u32)parser->global.logical_maximum <
 		(__u32)parser->global.logical_minimum)) {
 		dbg_hid("logical range invalid 0x%x 0x%x\n",
 			parser->global.logical_minimum,
 			parser->global.logical_maximum);
 		return -1;
 	}
 	offset = report->size;
 	report->size += parser->global.report_size * parser->global.report_count;
 	if (!parser->local.usage_index) /* Ignore padding fields */
 		return 0;
 	usages = max_t(unsigned, parser->local.usage_index,
 				 parser->global.report_count);
 	field = hid_register_field(report, usages, parser->global.report_count);
 	if (!field)
 		return 0;
 	field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
 	field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
 	field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
 	for (i = 0; i < usages; i++) {
 		unsigned j = i;
 		/* Duplicate the last usage we parsed if we have excess values */
 		if (i >= parser->local.usage_index)
 			j = parser->local.usage_index - 1;
 		field->usage[i].hid = parser->local.usage[j];
 		field->usage[i].collection_index =
 			parser->local.collection_index[j];
 		field->usage[i].usage_index = i;
 	}
 	field->maxusage = usages;
 	field->flags = flags;
 	field->report_offset = offset;
 	field->report_type = report_type;
 	field->report_size = parser->global.report_size;
 	field->report_count = parser->global.report_count;
 	field->logical_minimum = parser->global.logical_minimum;
 	field->logical_maximum = parser->global.logical_maximum;
 	field->physical_minimum = parser->global.physical_minimum;
 	field->physical_maximum = parser->global.physical_maximum;
 	field->unit_exponent = parser->global.unit_exponent;
 	field->unit = parser->global.unit;
 	return 0;
 }
 /*
  * Read data value from item.
  */
 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;
 	}
 	return 0;
 }
 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;
 	}
 	return 0;
 }
 /*
  * Process a global item.
  */
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
 	__s32 raw_value;
 	switch (item->tag) {
 	case HID_GLOBAL_ITEM_TAG_PUSH:
 		if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 			hid_err(parser->device, "global environment stack overflow\n");
 			return -1;
 		}
 		memcpy(parser->global_stack + parser->global_stack_ptr++,
 			&parser->global, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_POP:
 		if (!parser->global_stack_ptr) {
 			hid_err(parser->device, "global environment stack underflow\n");
 			return -1;
 		}
 		memcpy(&parser->global, parser->global_stack +
 			--parser->global_stack_ptr, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 		parser->global.usage_page = 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_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_MINIMUM:
 		parser->global.physical_minimum = 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_EXPONENT:
 		/* Many devices provide unit exponent as a two's complement
 		 * nibble due to the common misunderstanding of HID
 		 * specification 1.11, 6.2.2.7 Global Items. Attempt to handle
 		 * both this and the standard encoding. */
 		raw_value = item_sdata(item);
 		if (!(raw_value & 0xfffffff0))
 			parser->global.unit_exponent = hid_snto32(raw_value, 4);
 		else
 			parser->global.unit_exponent = raw_value;
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_UNIT:
 		parser->global.unit = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 		parser->global.report_size = item_udata(item);
 		if (parser->global.report_size > 128) {
 			hid_err(parser->device, "invalid report_size %d\n",
 					parser->global.report_size);
 			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) {
 			hid_err(parser->device, "invalid report_count %d\n",
 					parser->global.report_count);
 			return -1;
 		}
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 		parser->global.report_id = item_udata(item);
 		if (parser->global.report_id == 0 ||
 		    parser->global.report_id >= HID_MAX_IDS) {
 			hid_err(parser->device, "report_id %u is invalid\n",
 				parser->global.report_id);
 			return -1;
 		}
 		return 0;
 	default:
 		hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
 		return -1;
 	}
 }
 /*
  * Process a local item.
  */
 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	unsigned n;
 	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) {
 				hid_err(parser->device, "nested delimiters\n");
 				return -1;
 			}
 			parser->local.delimiter_depth++;
 			parser->local.delimiter_branch++;
 		} else {
 			if (parser->local.delimiter_depth < 1) {
 				hid_err(parser->device, "bogus close delimiter\n");
 				return -1;
 			}
 			parser->local.delimiter_depth--;
 		}
 		return 0;
 	case HID_LOCAL_ITEM_TAG_USAGE:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		return hid_add_usage(parser, data);
 	case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		parser->local.usage_minimum = data;
 		return 0;
 	case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		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;
 }
 /*
  * Process a main item.
  */
 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	int ret;
 	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:
 		hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);
 		ret = 0;
 	}
 	memset(&parser->local, 0, sizeof(parser->local));	/* Reset the local parser environment */
 	return ret;
 }
 /*
  * Process a reserved item.
  */
 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 {
 	dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 	return 0;
 }
 /*
  * Free a report and all registered fields. The field->usage and
  * field->value table's are allocated behind the field, so we need
  * only to free(field) itself.
  */
 static void hid_free_report(struct hid_report *report)
 {
 	unsigned n;
 	for (n = 0; n < report->maxfield; n++)
 		kfree(report->field[n]);
 	kfree(report);
 }
 /*
  * Close report. This function returns the device
  * state to the point prior to hid_open_report().
  */
 static void hid_close_report(struct hid_device *device)
 {
 	unsigned i, j;
 	for (i = 0; i < HID_REPORT_TYPES; i++) {
 		struct hid_report_enum *report_enum = device->report_enum + i;
 		for (j = 0; j < HID_MAX_IDS; j++) {
 			struct hid_report *report = report_enum->report_id_hash[j];
 			if (report)
 				hid_free_report(report);
 		}
 		memset(report_enum, 0, sizeof(*report_enum));
 		INIT_LIST_HEAD(&report_enum->report_list);
 	}
 	kfree(device->rdesc);
 	device->rdesc = NULL;
 	device->rsize = 0;
 	kfree(device->collection);
 	device->collection = NULL;
 	device->collection_size = 0;
 	device->maxcollection = 0;
 	device->maxapplication = 0;
 	device->status &= ~HID_STAT_PARSED;
 }
 /*
  * Free a device structure, all reports, and all fields.
  */
 static void hid_device_release(struct device *dev)
 {
 	struct hid_device *hid = container_of(dev, struct hid_device, dev);
 	hid_close_report(hid);
 	kfree(hid->dev_rdesc);
 	kfree(hid);
 }
 /*
  * Fetch a report description item from the data stream. We support long
  * items, though they are not used yet.
  */
 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
 {
 	u8 b;
 	if ((end - start) <= 0)
 		return NULL;
 	b = *start++;
 	item->type = (b >> 2) & 3;
 	item->tag  = (b >> 4) & 15;
 	if (item->tag == HID_ITEM_TAG_LONG) {
 		item->format = HID_ITEM_FORMAT_LONG;
 		if ((end - start) < 2)
 			return NULL;
 		item->size = *start++;
 		item->tag  = *start++;
 		if ((end - start) < item->size)
 			return NULL;
 		item->data.longdata = start;
 		start += item->size;
 		return start;
 	}
 	item->format = HID_ITEM_FORMAT_SHORT;
 	item->size = b & 3;
 	switch (item->size) {
 	case 0:
 		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 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;
 }
 static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
 {
 	struct hid_device *hid = parser->device;
 	if (usage == HID_DG_CONTACTID)
 		hid->group = HID_GROUP_MULTITOUCH;
 }
 static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
 {
 	if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
 	    parser->global.report_size == 8)
 		parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
 }
 static void hid_scan_collection(struct hid_parser *parser, unsigned type)
 {
 	struct hid_device *hid = parser->device;
 	if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
 	    type == HID_COLLECTION_PHYSICAL)
 		hid->group = HID_GROUP_SENSOR_HUB;
 	if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
 	    hid->product == USB_DEVICE_ID_MS_TYPE_COVER_3 &&
 	    hid->group == HID_GROUP_MULTITOUCH)
 		hid->group = HID_GROUP_GENERIC;
 }
 static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	int i;
 	data = item_udata(item);
 	switch (item->tag) {
 	case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 		hid_scan_collection(parser, data & 0xff);
 		break;
 	case HID_MAIN_ITEM_TAG_END_COLLECTION:
 		break;
 	case HID_MAIN_ITEM_TAG_INPUT:
 		/* ignore constant inputs, they will be ignored by hid-input */
 		if (data & HID_MAIN_ITEM_CONSTANT)
 			break;
 		for (i = 0; i < parser->local.usage_index; i++)
 			hid_scan_input_usage(parser, parser->local.usage[i]);
 		break;
 	case HID_MAIN_ITEM_TAG_OUTPUT:
 		break;
 	case HID_MAIN_ITEM_TAG_FEATURE:
 		for (i = 0; i < parser->local.usage_index; i++)
 			hid_scan_feature_usage(parser, parser->local.usage[i]);
 		break;
 	}
 	/* Reset the local parser environment */
 	memset(&parser->local, 0, sizeof(parser->local));
 	return 0;
 }
 /*
  * Scan a report descriptor before the device is added to the bus.
  * Sets device groups and other properties that determine what driver
  * to load.
  */
 static int hid_scan_report(struct hid_device *hid)
 {
 	struct hid_parser *parser;
 	struct hid_item item;
 	__u8 *start = hid->dev_rdesc;
 	__u8 *end = start + hid->dev_rsize;
 	static int (*dispatch_type[])(struct hid_parser *parser,
 				      struct hid_item *item) = {
 		hid_scan_main,
 		hid_parser_global,
 		hid_parser_local,
 		hid_parser_reserved
 	};
 	parser = vzalloc(sizeof(struct hid_parser));
 	if (!parser)
 		return -ENOMEM;
 	parser->device = hid;
 	hid->group = HID_GROUP_GENERIC;
 	/*
 	 * The parsing is simpler than the one in hid_open_report() as we should
 	 * be robust against hid errors. Those errors will be raised by
 	 * hid_open_report() anyway.
 	 */
 	while ((start = fetch_item(start, end, &item)) != NULL)
 		dispatch_type[item.type](parser, &item);
 	/*
 	 * Handle special flags set during scanning.
 	 */
 	if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
 	    (hid->group == HID_GROUP_MULTITOUCH))
 		hid->group = HID_GROUP_MULTITOUCH_WIN_8;
 	/*
 	 * Vendor specific handlings
 	 */
 	switch (hid->vendor) {
 	case USB_VENDOR_ID_WACOM:
 		hid->group = HID_GROUP_WACOM;
 		break;
 	case USB_VENDOR_ID_SYNAPTICS:
 		if ((hid->group == HID_GROUP_GENERIC) &&
 		    (hid->bus != BUS_USB || hid->type == HID_TYPE_USBMOUSE))
 			/* hid-rmi should only bind to the mouse interface of
 			 * composite USB devices */
 			hid->group = HID_GROUP_RMI;
 		break;
 	}
 	vfree(parser);
 	return 0;
 }
 /**
  * hid_parse_report - parse device report
  *
  * @device: hid device
  * @start: report start
  * @size: report size
  *
  * Allocate the device report as read by the bus driver. This function should
  * only be called from parse() in ll drivers.
  */
 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
 {
 	hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
 	if (!hid->dev_rdesc)
 		return -ENOMEM;
 	hid->dev_rsize = size;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
 static const char * const hid_report_names[] = {
 	"HID_INPUT_REPORT",
 	"HID_OUTPUT_REPORT",
 	"HID_FEATURE_REPORT",
 };
 /**
  * hid_validate_values - validate existing device report's value indexes
  *
  * @device: hid device
  * @type: which report type to examine
  * @id: which report ID to examine (0 for first)
  * @field_index: which report field to examine
  * @report_counts: expected number of values
  *
  * Validate the number of values in a given field of a given report, after
  * parsing.
  */
 struct hid_report *hid_validate_values(struct hid_device *hid,
 				       unsigned int type, unsigned int id,
 				       unsigned int field_index,
 				       unsigned int report_counts)
 {
 	struct hid_report *report;
 	if (type > HID_FEATURE_REPORT) {
 		hid_err(hid, "invalid HID report type %u\n", type);
 		return NULL;
 	}
 	if (id >= HID_MAX_IDS) {
 		hid_err(hid, "invalid HID report id %u\n", id);
 		return NULL;
 	}
 	/*
 	 * Explicitly not using hid_get_report() here since it depends on
 	 * ->numbered being checked, which may not always be the case when
 	 * drivers go to access report values.
 	 */
 	if (id == 0) {
 		/*
 		 * Validating on id 0 means we should examine the first
 		 * report in the list.
 		 */
 		report = list_entry(
 				hid->report_enum[type].report_list.next,
 				struct hid_report, list);
 	} else {
 		report = hid->report_enum[type].report_id_hash[id];
 	}
 	if (!report) {
 		hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
 		return NULL;
 	}
 	if (report->maxfield <= field_index) {
 		hid_err(hid, "not enough fields in %s %u\n",
 			hid_report_names[type], id);
 		return NULL;
 	}
 	if (report->field[field_index]->report_count < report_counts) {
 		hid_err(hid, "not enough values in %s %u field %u\n",
 			hid_report_names[type], id, field_index);
 		return NULL;
 	}
 	return report;
 }
 EXPORT_SYMBOL_GPL(hid_validate_values);
 /**
  * hid_open_report - open a driver-specific device report
  *
  * @device: hid device
  *
  * 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.
  *
  * This function (or the equivalent hid_parse() macro) should only be
  * called from probe() in drivers, before starting the device.
  */
 int hid_open_report(struct hid_device *device)
 {
 	struct hid_parser *parser;
 	struct hid_item item;
 	unsigned int size;
 	__u8 *start;
 	__u8 *buf;
 	__u8 *end;
 	int ret;
 	static int (*dispatch_type[])(struct hid_parser *parser,
 				      struct hid_item *item) = {
 		hid_parser_main,
 		hid_parser_global,
 		hid_parser_local,
 		hid_parser_reserved
 	};
 	if (WARN_ON(device->status & HID_STAT_PARSED))
 		return -EBUSY;
 	start = device->dev_rdesc;
 	if (WARN_ON(!start))
 		return -ENODEV;
 	size = device->dev_rsize;
 	buf = kmemdup(start, size, GFP_KERNEL);
 	if (buf == NULL)
 		return -ENOMEM;
 	if (device->driver->report_fixup)
 		start = device->driver->report_fixup(device, buf, &size);
 	else
 		start = buf;
 	start = kmemdup(start, size, GFP_KERNEL);
 	kfree(buf);
 	if (start == NULL)
 		return -ENOMEM;
 	device->rdesc = start;
 	device->rsize = size;
 	parser = vzalloc(sizeof(struct hid_parser));
 	if (!parser) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	parser->device = device;
 	end = start + size;
 	device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
 				     sizeof(struct hid_collection), GFP_KERNEL);
 	if (!device->collection) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
 	ret = -EINVAL;
 	while ((start = fetch_item(start, end, &item)) != NULL) {
 		if (item.format != HID_ITEM_FORMAT_SHORT) {
 			hid_err(device, "unexpected long global item\n");
 			goto err;
 		}
 		if (dispatch_type[item.type](parser, &item)) {
 			hid_err(device, "item %u %u %u %u parsing failed\n",
 				item.format, (unsigned)item.size,
 				(unsigned)item.type, (unsigned)item.tag);
 			goto err;
 		}
 		if (start == end) {
 			if (parser->collection_stack_ptr) {
 				hid_err(device, "unbalanced collection at end of report description\n");
 				goto err;
 			}
 			if (parser->local.delimiter_depth) {
 				hid_err(device, "unbalanced delimiter at end of report description\n");
 				goto err;
 			}
 			vfree(parser);
 			device->status |= HID_STAT_PARSED;
 			return 0;
 		}
 	}
 	hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
 err:
 	vfree(parser);
 	hid_close_report(device);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_open_report);
 /*
  * Convert a signed n-bit integer to signed 32-bit integer. Common
  * cases are done through the compiler, the screwed things has to be
  * done by hand.
  */
 static s32 snto32(__u32 value, unsigned n)
 {
 	switch (n) {
 	case 8:  return ((__s8)value);
 	case 16: return ((__s16)value);
 	case 32: return ((__s32)value);
 	}
 	return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
 s32 hid_snto32(__u32 value, unsigned n)
 {
 	return snto32(value, n);
 }
 EXPORT_SYMBOL_GPL(hid_snto32);
 /*
  * Convert a signed 32-bit integer to a signed n-bit integer.
  */
 static u32 s32ton(__s32 value, unsigned n)
 {
 	s32 a = value >> (n - 1);
 	if (a && a != -1)
 		return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
 	return value & ((1 << n) - 1);
 }
 /*
  * Extract/implement a data field from/to a little endian report (bit array).
  *
  * Code sort-of follows HID spec:
  *     http://www.usb.org/developers/devclass_docs/HID1_11.pdf
  *
  * While the USB HID spec allows unlimited length bit fields in "report
  * descriptors", most devices never use more than 16 bits.
  * One model of UPS is claimed to report "LINEV" as a 32-bit field.
  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
  */
 static __u32 extract(const struct hid_device *hid, __u8 *report,
 		     unsigned offset, unsigned n)
 {
 	u64 x;
 	if (n > 32)
 		hid_warn(hid, "extract() called with n (%d) > 32! (%s)\n",
 			 n, current->comm);
 	report += offset >> 3;  /* adjust byte index */
 	offset &= 7;            /* now only need bit offset into one byte */
 	x = get_unaligned_le64(report);
 	x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
 	return (u32) x;
 }
 /*
  * "implement" : set bits in a little endian bit stream.
  * Same concepts as "extract" (see comments above).
  * The data mangled in the bit stream remains in little endian
  * order the whole time. It make more sense to talk about
  * endianness of register values by considering a register
  * a "cached" copy of the little endiad bit stream.
  */
 static void implement(const struct hid_device *hid, __u8 *report,
 		      unsigned offset, unsigned n, __u32 value)
 {
 	u64 x;
 	u64 m = (1ULL << n) - 1;
 	if (n > 32)
 		hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
 			 __func__, n, current->comm);
 	if (value > m)
 		hid_warn(hid, "%s() called with too large value %d! (%s)\n",
 			 __func__, value, current->comm);
 	WARN_ON(value > m);
 	value &= m;
 	report += offset >> 3;
 	offset &= 7;
 	x = get_unaligned_le64(report);
 	x &= ~(m << offset);
 	x |= ((u64)value) << offset;
 	put_unaligned_le64(x, report);
 }
 /*
  * Search an array for a value.
  */
 static int search(__s32 *array, __s32 value, unsigned n)
 {
 	while (n--) {
 		if (*array++ == value)
 			return 0;
 	}
 	return -1;
 }
 /**
  * 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;
 	if (!list_empty(&hid->debug_list))
 		hid_dump_input(hid, usage, value);
 	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
 		ret = hdrv->event(hid, field, usage, value);
 		if (ret != 0) {
 			if (ret < 0)
 				hid_err(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)
 		hid->hiddev_hid_event(hid, field, usage, value);
 }
 /*
  * Analyse a received field, and fetch the data from it. The field
  * content is stored for next report processing (we do differential
  * reporting to the layer).
  */
 static void hid_input_field(struct hid_device *hid, struct hid_field *field,
 			    __u8 *data, int interrupt)
 {
 	unsigned n;
 	unsigned count = field->report_count;
 	unsigned offset = field->report_offset;
 	unsigned size = field->report_size;
 	__s32 min = field->logical_minimum;
 	__s32 max = field->logical_maximum;
 	__s32 *value;
 	value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
 	if (!value)
 		return;
 	for (n = 0; n < count; n++) {
 		value[n] = min < 0 ?
 			snto32(extract(hid, data, offset + n * size, size),
 			       size) :
 			extract(hid, data, offset + n * size, size);
 		/* Ignore report if ErrorRollOver */
 		if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
 		    value[n] >= min && value[n] <= max &&
 		    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
 			goto exit;
 	}
 	for (n = 0; n < count; n++) {
 		if (HID_MAIN_ITEM_VARIABLE & field->flags) {
 			hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
 			continue;
 		}
 		if (field->value[n] >= min && field->value[n] <= max
 			&& field->usage[field->value[n] - min].hid
 			&& search(value, field->value[n], count))
 				hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
 		if (value[n] >= min && value[n] <= max
 			&& field->usage[value[n] - min].hid
 			&& search(field->value, value[n], count))
 				hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
 	}
 	memcpy(field->value, value, count * sizeof(__s32));
 exit:
 	kfree(value);
 }
 /*
  * Output the field into the report.
  */
 static void hid_output_field(const struct hid_device *hid,
 			     struct hid_field *field, __u8 *data)
 {
 	unsigned count = field->report_count;
 	unsigned offset = field->report_offset;
 	unsigned size = field->report_size;
 	unsigned n;
 	for (n = 0; n < count; n++) {
 		if (field->logical_minimum < 0)	/* signed values */
 			implement(hid, data, offset + n * size, size,
 				  s32ton(field->value[n], size));
 		else				/* unsigned values */
 			implement(hid, data, offset + n * size, size,
 				  field->value[n]);
 	}
 }
 /*
  * Create a report. 'data' has to be allocated using
  * hid_alloc_report_buf() so that it has proper size.
  */
 void hid_output_report(struct hid_report *report, __u8 *data)
 {
 	unsigned n;
 	if (report->id > 0)
 		*data++ = report->id;
 	memset(data, 0, ((report->size - 1) >> 3) + 1);
 	for (n = 0; n < report->maxfield; n++)
 		hid_output_field(report->device, report->field[n], data);
 }
 EXPORT_SYMBOL_GPL(hid_output_report);
 /*
  * Allocator for buffer that is going to be passed to hid_output_report()
  */
 u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
 {
 	/*
 	 * 7 extra bytes are necessary to achieve proper functionality
 	 * of implement() working on 8 byte chunks
 	 */
 	int len = hid_report_len(report) + 7;
 	return kmalloc(len, flags);
 }
 EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
 /*
  * Set a field value. The report this field belongs to has to be
  * created and transferred to the device, to set this value in the
  * device.
  */
 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 {
 	unsigned size;
 	if (!field)
 		return -1;
 	size = field->report_size;
 	hid_dump_input(field->report->device, field->usage + offset, value);
 	if (offset >= field->report_count) {
 		hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
 				offset, field->report_count);
 		return -1;
 	}
 	if (field->logical_minimum < 0) {
 		if (value != snto32(s32ton(value, size), size)) {
 			hid_err(field->report->device, "value %d is out of range\n", value);
 			return -1;
 		}
 	}
 	field->value[offset] = value;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
 static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
 		const u8 *data)
 {
 	struct hid_report *report;
 	unsigned int n = 0;	/* Normally report number is 0 */
 	/* Device uses numbered reports, data[0] is report number */
 	if (report_enum->numbered)
 		n = *data;
 	report = report_enum->report_id_hash[n];
 	if (report == NULL)
 		dbg_hid("undefined report_id %u received\n", n);
 	return report;
 }
 /*
  * Implement a generic .request() callback, using .raw_request()
  * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
  */
 void __hid_request(struct hid_device *hid, struct hid_report *report,
 		int reqtype)
 {
 	char *buf;
 	int ret;
 	int len;
 	buf = hid_alloc_report_buf(report, GFP_KERNEL);
 	if (!buf)
 		return;
 	len = hid_report_len(report);
 	if (reqtype == HID_REQ_SET_REPORT)
 		hid_output_report(report, buf);
 	ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
 					  report->type, reqtype);
 	if (ret < 0) {
 		dbg_hid("unable to complete request: %d\n", ret);
 		goto out;
 	}
 	if (reqtype == HID_REQ_GET_REPORT)
 		hid_input_report(hid, report->type, buf, ret, 0);
 out:
 	kfree(buf);
 }
 EXPORT_SYMBOL_GPL(__hid_request);
 int 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;
 	struct hid_driver *hdrv;
 	unsigned int a;
 	int rsize, csize = size;
 	u8 *cdata = data;
 	int ret = 0;
 	report = hid_get_report(report_enum, data);
 	if (!report)
 		goto out;
 	if (report_enum->numbered) {
 		cdata++;
 		csize--;
 	}
 	rsize = ((report->size - 1) >> 3) + 1;
 	if (rsize > HID_MAX_BUFFER_SIZE)
 		rsize = HID_MAX_BUFFER_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)
 		hid->hiddev_report_event(hid, report);
 	if (hid->claimed & HID_CLAIMED_HIDRAW) {
 		ret = hidraw_report_event(hid, data, size);
 		if (ret)
 			goto out;
 	}
 	if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
 		for (a = 0; a < report->maxfield; a++)
 			hid_input_field(hid, report->field[a], cdata, interrupt);
 		hdrv = hid->driver;
 		if (hdrv && hdrv->report)
 			hdrv->report(hid, report);
 	}
 	if (hid->claimed & HID_CLAIMED_INPUT)
 		hidinput_report_event(hid, report);
 out:
 	return ret;
 }
 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: distinguish between interrupt and control transfers
  *
  * 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;
 	struct hid_driver *hdrv;
 	struct hid_report *report;
 	int ret = 0;
 	if (!hid)
 		return -ENODEV;
 	if (down_trylock(&hid->driver_input_lock))
 		return -EBUSY;
 	if (!hid->driver) {
 		ret = -ENODEV;
 		goto unlock;
 	}
 	report_enum = hid->report_enum + type;
 	hdrv = hid->driver;
 	if (!size) {
 		dbg_hid("empty report\n");
 		ret = -1;
 		goto unlock;
 	}
 	/* Avoid unnecessary overhead if debugfs is disabled */
 	if (!list_empty(&hid->debug_list))
 		hid_dump_report(hid, type, data, size);
 	report = hid_get_report(report_enum, data);
 	if (!report) {
 		ret = -1;
 		goto unlock;
 	}
 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
 		ret = hdrv->raw_event(hid, report, data, size);
 		if (ret < 0)
 			goto unlock;
 	}
 	ret = hid_report_raw_event(hid, type, data, size, interrupt);
 unlock:
 	up(&hid->driver_input_lock);
 	return ret;
 }
 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 == HID_BUS_ANY || id->bus == hdev->bus) &&
 		(id->group == HID_GROUP_ANY || id->group == hdev->group) &&
 		(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
 		(id->product == HID_ANY_ID || id->product == hdev->product);
 }
 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);
 }
 static ssize_t
 read_report_descriptor(struct file *filp, struct kobject *kobj,
 		struct bin_attribute *attr,
 		char *buf, loff_t off, size_t count)
 {
 	struct device *dev = container_of(kobj, struct device, kobj);
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	if (off >= hdev->rsize)
 		return 0;
 	if (off + count > hdev->rsize)
 		count = hdev->rsize - off;
 	memcpy(buf, hdev->rdesc + off, count);
 	return count;
 }
 static struct bin_attribute dev_bin_attr_report_desc = {
 	.attr = { .name = "report_descriptor", .mode = 0444 },
 	.read = read_report_descriptor,
 	.size = HID_MAX_DESCRIPTOR_SIZE,
 };
 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;
 	int ret;
 	if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
 		connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
 	if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
 		connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
 	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 (connect_mask & HID_CONNECT_DRIVER)
 		hdev->claimed |= HID_CLAIMED_DRIVER;
 	/* Drivers with the ->raw_event callback set are not required to connect
 	 * to any other listener. */
 	if (!hdev->claimed && !hdev->driver->raw_event) {
 		hid_err(hdev, "device has no listeners, quitting\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>";
 	}
 	ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
 	if (ret)
 		hid_warn(hdev,
 			 "can't create sysfs report descriptor attribute err: %d\n", ret);
 	hid_info(hdev, "%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);
 void hid_disconnect(struct hid_device *hdev)
 {
 	device_remove_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
 	if (hdev->claimed & HID_CLAIMED_INPUT)
 		hidinput_disconnect(hdev);
 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
 		hdev->hiddev_disconnect(hdev);
 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
 		hidraw_disconnect(hdev);
 	hdev->claimed = 0;
 }
 EXPORT_SYMBOL_GPL(hid_disconnect);
 /*
  * A list of devices for which there is a specialized driver on HID bus.
  *
  * Please note that for multitouch devices (driven by hid-multitouch driver),
  * there is a proper autodetection and autoloading in place (based on presence
  * of HID_DG_CONTACTID), so those devices don't need to be added to this list,
  * as we are doing the right thing in hid_scan_usage().
  *
  * Autodetection for (USB) HID sensor hubs exists too. If a collection of type
  * physical is found inside a usage page of type sensor, hid-sensor-hub will be
  * used as a driver. See hid_scan_report().
  */
 static const struct hid_device_id hid_have_special_driver[] = {
 	{ 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_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0xf705) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
 	{ 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_MINI_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_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_IRCONTROL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
 	{ HID_BLUETOOTH_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_WELLSPRING3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_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_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
 	{ 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_BARCODE_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A070) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_MANTICORE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
 #if IS_ENABLED(CONFIG_HID_LENOVO)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
 #endif
 	{ 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_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
 	{ 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_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_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_CORD) },
 	{ 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_WINGMAN_FFG ) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
 	{ 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_VIBRATION_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
 #if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
 #endif
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
 	{ 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_NE4K_JP) },
 	{ 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_MS_DIGITAL_MEDIA_3K) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_6000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
 #if IS_ENABLED(CONFIG_HID_ROCCAT)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEXTD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_LUA) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_GLOW) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) },
 #endif
 #if IS_ENABLED(CONFIG_HID_SAITEK)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },
 #endif
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
 	{ }
 };
 struct hid_dynid {
 	struct list_head list;
 	struct hid_device_id id;
 };
 /**
  * store_new_id - add a new HID device ID to this driver and re-probe devices
  * @driver: target device driver
  * @buf: buffer for scanning device ID data
  * @count: input size
  *
  * Adds a new dynamic hid device ID to this driver,
  * and causes the driver to probe for all devices again.
  */
 static ssize_t store_new_id(struct device_driver *drv, const char *buf,
 		size_t count)
 {
 	struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
 	struct hid_dynid *dynid;
 	__u32 bus, vendor, product;
 	unsigned long driver_data = 0;
 	int ret;
 	ret = sscanf(buf, "%x %x %x %lx",
 			&bus, &vendor, &product, &driver_data);
 	if (ret < 3)
 		return -EINVAL;
 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 	dynid->id.bus = bus;
 	dynid->id.group = HID_GROUP_ANY;
 	dynid->id.vendor = vendor;
 	dynid->id.product = product;
 	dynid->id.driver_data = driver_data;
 	spin_lock(&hdrv->dyn_lock);
 	list_add_tail(&dynid->list, &hdrv->dyn_list);
 	spin_unlock(&hdrv->dyn_lock);
 	ret = driver_attach(&hdrv->driver);
 	return ret ? : count;
 }
 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 static void hid_free_dynids(struct hid_driver *hdrv)
 {
 	struct hid_dynid *dynid, *n;
 	spin_lock(&hdrv->dyn_lock);
 	list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
 		list_del(&dynid->list);
 		kfree(dynid);
 	}
 	spin_unlock(&hdrv->dyn_lock);
 }
 static const struct hid_device_id *hid_match_device(struct hid_device *hdev,
 		struct hid_driver *hdrv)
 {
 	struct hid_dynid *dynid;
 	spin_lock(&hdrv->dyn_lock);
 	list_for_each_entry(dynid, &hdrv->dyn_list, list) {
 		if (hid_match_one_id(hdev, &dynid->id)) {
 			spin_unlock(&hdrv->dyn_lock);
 			return &dynid->id;
 		}
 	}
 	spin_unlock(&hdrv->dyn_lock);
 	return hid_match_id(hdev, hdrv->id_table);
 }
 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);
 	return hid_match_device(hdev, hdrv) != NULL;
 }
 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 (down_interruptible(&hdev->driver_lock))
 		return -EINTR;
 	if (down_interruptible(&hdev->driver_input_lock)) {
 		ret = -EINTR;
 		goto unlock_driver_lock;
 	}
 	hdev->io_started = false;
 	if (!hdev->driver) {
 		id = hid_match_device(hdev, hdrv);
 		if (id == NULL) {
 			ret = -ENODEV;
 			goto unlock;
 		}
 		hdev->driver = hdrv;
 		if (hdrv->probe) {
 			ret = hdrv->probe(hdev, id);
 		} else { /* default probe */
 			ret = hid_open_report(hdev);
 			if (!ret)
 				ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 		}
 		if (ret) {
 			hid_close_report(hdev);
 			hdev->driver = NULL;
 		}
 	}
 unlock:
 	if (!hdev->io_started)
 		up(&hdev->driver_input_lock);
 unlock_driver_lock:
 	up(&hdev->driver_lock);
 	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;
 	int ret = 0;
 	if (down_interruptible(&hdev->driver_lock))
 		return -EINTR;
 	if (down_interruptible(&hdev->driver_input_lock)) {
 		ret = -EINTR;
 		goto unlock_driver_lock;
 	}
 	hdev->io_started = false;
 	hdrv = hdev->driver;
 	if (hdrv) {
 		if (hdrv->remove)
 			hdrv->remove(hdev);
 		else /* default remove */
 			hid_hw_stop(hdev);
 		hid_close_report(hdev);
 		hdev->driver = NULL;
 	}
 	if (!hdev->io_started)
 		up(&hdev->driver_input_lock);
 unlock_driver_lock:
 	up(&hdev->driver_lock);
 	return ret;
 }
 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 			     char *buf)
 {
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	int len;
 	len = snprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
 		       hdev->bus, hdev->group, hdev->vendor, hdev->product);
 	return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 }
 static DEVICE_ATTR_RO(modalias);
 static struct attribute *hid_dev_attrs[] = {
 	&dev_attr_modalias.attr,
 	NULL,
 };
 ATTRIBUTE_GROUPS(hid_dev);
 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%04Xg%04Xv%08Xp%08X",
 			   hdev->bus, hdev->group, hdev->vendor, hdev->product))
 		return -ENOMEM;
 	return 0;
 }
 static struct bus_type hid_bus_type = {
 	.name		= "hid",
 	.dev_groups	= hid_dev_groups,
 	.match		= hid_bus_match,
 	.probe		= hid_device_probe,
 	.remove		= hid_device_remove,
 	.uevent		= hid_uevent,
 };
 /* a list of devices that shouldn't be handled by HID core at all */
 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_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_AXENTIA, USB_DEVICE_ID_AXENTIA_FM_RADIO) },
 	{ 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_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI4713) },
 	{ 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_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
 	{ 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_DREAM_CHEEKY, 0x0004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
 	{ 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, 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_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_GRIFFIN, USB_DEVICE_ID_RADIOSHARK) },
 	{ 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_JABRA, USB_DEVICE_ID_JABRA_SPEAK_410) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_510) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_GN9350E) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
 	{ 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_UMIC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
 	{ 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_MOTOR) },
 	{ 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_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
 	{ 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_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
 #if defined(CONFIG_MOUSE_SYNAPTICS_USB) || defined(CONFIG_MOUSE_SYNAPTICS_USB_MODULE)
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
 #endif
 	{ 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_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_RISO_KAGAKU, USB_DEVICE_ID_RI_KA_WEBMAIL) },
 	{ }
 };
 /**
  * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
  *
  * There are composite devices for which we want to ignore only a certain
  * interface. This is a list of devices for which only the mouse interface will
  * be ignored. This allows a dedicated driver to take care of the interface.
  */
 static const struct hid_device_id hid_mouse_ignore_list[] = {
 	/* appletouch driver */
 	{ 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_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_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_WELLSPRING3_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_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) },
 	{ }
 };
 bool hid_ignore(struct hid_device *hdev)
 {
 	if (hdev->quirks & HID_QUIRK_NO_IGNORE)
 		return false;
 	if (hdev->quirks & HID_QUIRK_IGNORE)
 		return true;
 	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;
 		/*
 		 * The Keene FM transmitter USB device has the same USB ID as
 		 * the Logitech AudioHub Speaker, but it should ignore the hid.
 		 * Check if the name is that of the Keene device.
 		 * For reference: the name of the AudioHub is
 		 * "HOLTEK  AudioHub Speaker".
 		 */
 		if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&
 			!strcmp(hdev->name, "HOLTEK  B-LINK USB Audio  "))
 				return true;
 		break;
 	case USB_VENDOR_ID_SOUNDGRAPH:
 		if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
 		    hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
 			return true;
 		break;
 	case USB_VENDOR_ID_HANWANG:
 		if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&
 		    hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)
 			return true;
 		break;
 	case USB_VENDOR_ID_JESS:
 		if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&
 				hdev->type == HID_TYPE_USBNONE)
 			return true;
 		break;
 	case USB_VENDOR_ID_VELLEMAN:
 		/* These are not HID devices.  They are handled by comedi. */
 		if ((hdev->product >= USB_DEVICE_ID_VELLEMAN_K8055_FIRST &&
 		     hdev->product <= USB_DEVICE_ID_VELLEMAN_K8055_LAST) ||
 		    (hdev->product >= USB_DEVICE_ID_VELLEMAN_K8061_FIRST &&
 		     hdev->product <= USB_DEVICE_ID_VELLEMAN_K8061_LAST))
 			return true;
 		break;
 	case USB_VENDOR_ID_ATMEL_V_USB:
 		/* Masterkit MA901 usb radio based on Atmel tiny85 chip and
 		 * it has the same USB ID as many Atmel V-USB devices. This
 		 * usb radio is handled by radio-ma901.c driver so we want
 		 * ignore the hid. Check the name, bus, product and ignore
 		 * if we have MA901 usb radio.
 		 */
 		if (hdev->product == USB_DEVICE_ID_ATMEL_V_USB &&
 			hdev->bus == BUS_USB &&
 			strncmp(hdev->name, "www.masterkit.ru MA901", 22) == 0)
 			return true;
 		break;
 	}
 	if (hdev->type == HID_TYPE_USBMOUSE &&
 			hid_match_id(hdev, hid_mouse_ignore_list))
 		return true;
 	return !!hid_match_id(hdev, hid_ignore_list);
 }
 EXPORT_SYMBOL_GPL(hid_ignore);
 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;
 	/*
 	 * Check for the mandatory transport channel.
 	 */
 	 if (!hdev->ll_driver->raw_request) {
 		hid_err(hdev, "transport driver missing .raw_request()\n");
 		return -EINVAL;
 	 }
 	/*
 	 * Read the device report descriptor once and use as template
 	 * for the driver-specific modifications.
 	 */
 	ret = hdev->ll_driver->parse(hdev);
 	if (ret)
 		return ret;
 	if (!hdev->dev_rdesc)
 		return -ENODEV;
 	/*
 	 * Scan generic devices for group information
 	 */
 	if (hid_ignore_special_drivers ||
 	    (!hdev->group &&
 	     !hid_match_id(hdev, hid_have_special_driver))) {
 		ret = hid_scan_report(hdev);
 		if (ret)
 			hid_warn(hdev, "bad device descriptor (%d)\n", ret);
 	}
 	/* XXX hack, any other cleaner solution after the driver core
 	 * is converted to allow more than 20 bytes as the device name? */
 	dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
 		     hdev->vendor, hdev->product, atomic_inc_return(&id));
 	hid_debug_register(hdev, dev_name(&hdev->dev));
 	ret = device_add(&hdev->dev);
 	if (!ret)
 		hdev->status |= HID_STAT_ADDED;
 	else
 		hid_debug_unregister(hdev);
 	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;
 	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;
 	hid_close_report(hdev);
 	init_waitqueue_head(&hdev->debug_wait);
 	INIT_LIST_HEAD(&hdev->debug_list);
 	spin_lock_init(&hdev->debug_list_lock);
 	sema_init(&hdev->driver_lock, 1);
 	sema_init(&hdev->driver_input_lock, 1);
 	return hdev;
 }
 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);
 		hid_debug_unregister(hdev);
 		hdev->status &= ~HID_STAT_ADDED;
 	}
 	kfree(hdev->dev_rdesc);
 	hdev->dev_rdesc = NULL;
 	hdev->dev_rsize = 0;
 }
 /**
  * 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)
 {
 	int ret;
 	hdrv->driver.name = hdrv->name;
 	hdrv->driver.bus = &hid_bus_type;
 	hdrv->driver.owner = owner;
 	hdrv->driver.mod_name = mod_name;
 	INIT_LIST_HEAD(&hdrv->dyn_list);
 	spin_lock_init(&hdrv->dyn_lock);
 	ret = driver_register(&hdrv->driver);
 	if (ret)
 		return ret;
 	ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);
 	if (ret)
 		driver_unregister(&hdrv->driver);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(__hid_register_driver);
 void hid_unregister_driver(struct hid_driver *hdrv)
 {
 	driver_remove_file(&hdrv->driver, &driver_attr_new_id);
 	driver_unregister(&hdrv->driver);
 	hid_free_dynids(hdrv);
 }
 EXPORT_SYMBOL_GPL(hid_unregister_driver);
 int hid_check_keys_pressed(struct hid_device *hid)
 {
 	struct hid_input *hidinput;
 	int i;
 	if (!(hid->claimed & HID_CLAIMED_INPUT))
 		return 0;
 	list_for_each_entry(hidinput, &hid->inputs, list) {
 		for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
 			if (hidinput->input->key[i])
 				return 1;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
 static int __init hid_init(void)
 {
 	int ret;
 	if (hid_debug)
 		pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
 			"debugfs is now used for inspecting the device (report descriptor, reports)\n");
 	ret = bus_register(&hid_bus_type);
 	if (ret) {
 		pr_err("can't register hid bus\n");
 		goto err;
 	}
 	ret = hidraw_init();
 	if (ret)
 		goto err_bus;
 	hid_debug_init();
 	return 0;
 err_bus:
 	bus_unregister(&hid_bus_type);
 err:
 	return ret;
 }
 static void __exit hid_exit(void)
 {
 	hid_debug_exit();
 	hidraw_exit();
 	bus_unregister(&hid_bus_type);
 }
 module_init(hid_init);
 module_exit(hid_exit);
 MODULE_AUTHOR("Andreas Gal");
 MODULE_AUTHOR("Vojtech Pavlik");
 MODULE_AUTHOR("Jiri Kosina");
 MODULE_LICENSE(DRIVER_LICENSE);

drivers/hid/hid-ids.h

Diff comments View file @ 28023d2

 /*
  *  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
  */
 /*
  * 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_3M		0x0596
 #define USB_DEVICE_ID_3M1968		0x0500
 #define USB_DEVICE_ID_3M2256		0x0502
 #define USB_DEVICE_ID_3M3266		0x0506
 #define USB_VENDOR_ID_A4TECH		0x09da
 #define USB_DEVICE_ID_A4TECH_WCP32PU	0x0006
 #define USB_DEVICE_ID_A4TECH_X5_005D	0x000a
 #define USB_DEVICE_ID_A4TECH_RP_649	0x001a
 #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_ACRUX		0x1a34
 #define USB_VENDOR_ID_ACTIONSTAR	0x2101
 #define USB_DEVICE_ID_ACTIONSTAR_1011	0x1011
 #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_AIREN		0x1a2c
 #define USB_DEVICE_ID_AIREN_SLIMPLUS	0x0002
 #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_ANTON		0x1130
 #define USB_DEVICE_ID_ANTON_TOUCH_PAD	0x3101
 #define USB_VENDOR_ID_APPLE		0x05ac
 #define USB_DEVICE_ID_APPLE_MIGHTYMOUSE	0x0304
 #define USB_DEVICE_ID_APPLE_MAGICMOUSE	0x030d
 #define USB_DEVICE_ID_APPLE_MAGICTRACKPAD	0x030e
 #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_MINI_ANSI	0x021d
 #define USB_DEVICE_ID_APPLE_ALU_MINI_ISO	0x021e
 #define USB_DEVICE_ID_APPLE_ALU_MINI_JIS	0x021f
 #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_WELLSPRING3_ANSI	0x0236
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO	0x0237
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS	0x0238
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI	0x023f
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO	0x0240
 #define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS	0x0241
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI	0x0242
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO	0x0243
 #define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS	0x0244
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI	0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO	0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS	0x0247
 #define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI	0x024f
 #define USB_DEVICE_ID_APPLE_ALU_REVB_ISO	0x0250
 #define USB_DEVICE_ID_APPLE_ALU_REVB_JIS	0x0251
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI	0x0252
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO	0x0253
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS	0x0254
 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI	0x0259
 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO	0x025a
 #define USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS	0x025b
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI	0x0249
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO	0x024a
 #define USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS	0x024b
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI	0x024c
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO	0x024d
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS	0x024e
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI	0x0262
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO	0x0263
 #define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS	0x0264
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI  0x0255
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO   0x0256
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS   0x0257
 #define USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI	0x0290
 #define USB_DEVICE_ID_APPLE_WELLSPRING8_ISO	0x0291
 #define USB_DEVICE_ID_APPLE_WELLSPRING8_JIS	0x0292
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY	0x030a
 #define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY	0x030b
 #define USB_DEVICE_ID_APPLE_IRCONTROL	0x8240
 #define USB_DEVICE_ID_APPLE_IRCONTROL2	0x1440
 #define USB_DEVICE_ID_APPLE_IRCONTROL3	0x8241
 #define USB_DEVICE_ID_APPLE_IRCONTROL4	0x8242
 #define USB_DEVICE_ID_APPLE_IRCONTROL5	0x8243
 #define USB_VENDOR_ID_ASUS		0x0486
 #define USB_DEVICE_ID_ASUS_T91MT	0x0185
 #define USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO	0x0186
 #define USB_VENDOR_ID_ASUSTEK		0x0b05
 #define USB_DEVICE_ID_ASUSTEK_LCM	0x1726
 #define USB_DEVICE_ID_ASUSTEK_LCM2	0x175b
 #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_ATMEL		0x03eb
 #define USB_DEVICE_ID_ATMEL_MULTITOUCH	0x211c
 #define USB_DEVICE_ID_ATMEL_MXT_DIGITIZER	0x2118
 #define USB_VENDOR_ID_ATMEL_V_USB	0x16c0
 #define USB_DEVICE_ID_ATMEL_V_USB	0x05df
 #define USB_VENDOR_ID_AUREAL		0x0755
 #define USB_DEVICE_ID_AUREAL_W01RN	0x2626
 #define USB_VENDOR_ID_AVERMEDIA		0x07ca
 #define USB_DEVICE_ID_AVER_FM_MR800	0xb800
 #define USB_VENDOR_ID_AXENTIA		0x12cf
 #define USB_DEVICE_ID_AXENTIA_FM_RADIO	0x7111
 #define USB_VENDOR_ID_BAANTO		0x2453
 #define USB_DEVICE_ID_BAANTO_MT_190W2	0x0100
 #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_BTC		0x046e
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE	0x5578
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE_2	0x5577
 #define USB_VENDOR_ID_CANDO		0x2087
 #define USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH 0x0703
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH	0x0a01
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1 0x0a02
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
 #define USB_VENDOR_ID_CH		0x068e
 #define USB_DEVICE_ID_CH_PRO_THROTTLE	0x00f1
 #define USB_DEVICE_ID_CH_PRO_PEDALS	0x00f2
 #define USB_DEVICE_ID_CH_FIGHTERSTICK	0x00f3
 #define USB_DEVICE_ID_CH_COMBATSTICK	0x00f4
 #define USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE       0x0051
 #define USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE	0x00ff
 #define USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK	0x00d3
 #define USB_DEVICE_ID_CH_AXIS_295	0x001c
 #define USB_VENDOR_ID_CHERRY		0x046a
 #define USB_DEVICE_ID_CHERRY_CYMOTION	0x0023
 #define USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR	0x0027
 #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_DEVICE_ID_CHICONY_MULTI_TOUCH	0xb19d
 #define USB_DEVICE_ID_CHICONY_WIRELESS	0x0618
 #define USB_DEVICE_ID_CHICONY_WIRELESS2	0x1123
 #define USB_DEVICE_ID_CHICONY_AK1D	0x1125
 #define USB_VENDOR_ID_CHUNGHWAT		0x2247
 #define USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH	0x0001
 #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_CREATIVELABS	0x041e
 #define USB_DEVICE_ID_PRODIKEYS_PCMIDI	0x2801
 #define USB_VENDOR_ID_CVTOUCH		0x1ff7
 #define USB_DEVICE_ID_CVTOUCH_SCREEN	0x0013
 #define USB_VENDOR_ID_CYGNAL		0x10c4
 #define USB_DEVICE_ID_CYGNAL_RADIO_SI470X	0x818a
 #define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH	0x81b9
 #define USB_DEVICE_ID_CYGNAL_CP2112	0xea90
 #define USB_DEVICE_ID_CYGNAL_RADIO_SI4713       0x8244
 #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_DEVICE_ID_CYPRESS_BARCODE_3	0xbca1
 #define USB_DEVICE_ID_CYPRESS_BARCODE_4	0xed81
 #define USB_DEVICE_ID_CYPRESS_TRUETOUCH	0xc001
 #define USB_VENDOR_ID_DATA_MODUL	0x7374
 #define USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH	0x1201
 #define USB_VENDOR_ID_DEALEXTREAME	0x10c5
 #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701	0x819a
 #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_DRAGONRISE	0x0079
 #define USB_VENDOR_ID_DWAV		0x0eef
 #define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER	0x0001
 #define USB_DEVICE_ID_DWAV_TOUCHCONTROLLER	0x0002
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D	0x480d
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E	0x480e
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207	0x7207
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C	0x720c
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224	0x7224
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A	0x722A
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E	0x725e
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262	0x7262
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B	0x726b
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1	0x72a1
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA	0x72aa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4	0x72c4
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0	0x72d0
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA	0x72fa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302	0x7302
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349	0x7349
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7	0x73f7
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001	0xa001
 #define USB_VENDOR_ID_ELAN		0x04f3
 #define USB_DEVICE_ID_ELAN_TOUCHSCREEN	0x0089
 #define USB_DEVICE_ID_ELAN_TOUCHSCREEN_009B	0x009b
 #define USB_DEVICE_ID_ELAN_TOUCHSCREEN_0103	0x0103
 #define USB_DEVICE_ID_ELAN_TOUCHSCREEN_010c	0x010c
 #define USB_DEVICE_ID_ELAN_TOUCHSCREEN_016F	0x016f
 #define USB_VENDOR_ID_ELECOM		0x056e
 #define USB_DEVICE_ID_ELECOM_BM084	0x0061
 #define USB_VENDOR_ID_DREAM_CHEEKY	0x1d34
 #define USB_VENDOR_ID_ELITEGROUP	0x03fc
 #define USB_DEVICE_ID_ELITEGROUP_05D8	0x05d8
 #define USB_VENDOR_ID_ELO		0x04E7
 #define USB_DEVICE_ID_ELO_TS2515	0x0022
 #define USB_DEVICE_ID_ELO_TS2700	0x0020
 #define USB_VENDOR_ID_EMS		0x2006
 #define USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II 0x0118
 #define USB_VENDOR_ID_FLATFROG		0x25b5
 #define USB_DEVICE_ID_MULTITOUCH_3200	0x0002
 #define USB_VENDOR_ID_ESSENTIAL_REALITY	0x0d7f
 #define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
 #define USB_VENDOR_ID_ETT		0x0664
 #define USB_DEVICE_ID_TC5UH		0x0309
 #define USB_DEVICE_ID_TC4UM		0x0306
 #define USB_VENDOR_ID_ETURBOTOUCH	0x22b9
 #define USB_DEVICE_ID_ETURBOTOUCH	0x0006
 #define USB_DEVICE_ID_ETURBOTOUCH_2968	0x2968
 #define USB_VENDOR_ID_EZKEY		0x0518
 #define USB_DEVICE_ID_BTC_8193		0x0002
 #define USB_VENDOR_ID_FORMOSA          0x147a
 #define USB_DEVICE_ID_FORMOSA_IR_RECEIVER      0xe03e
 #define USB_VENDOR_ID_FREESCALE		0x15A2
 #define USB_DEVICE_ID_FREESCALE_MX28	0x004F
 #define USB_VENDOR_ID_FRUCTEL	0x25B6
 #define USB_DEVICE_ID_GAMETEL_MT_MODE	0x0002
 #define USB_VENDOR_ID_GAMERON		0x0810
 #define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR	0x0001
 #define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR	0x0002
 #define USB_VENDOR_ID_GENERAL_TOUCH	0x0dfc
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0003
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PWT_TENFINGERS 0x0100
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0101 0x0101
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0102 0x0102
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_0106 0x0106
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A 0x010a
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100 0xe100
 #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_GOODTOUCH		0x1aad
 #define USB_DEVICE_ID_GOODTOUCH_000f	0x000f
 #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_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD	0x3013
 #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_DEVICE_ID_RADIOSHARK	0x627a
 #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_DEVICE_ID_GYRATION_REMOTE_2 0x0003
 #define USB_DEVICE_ID_GYRATION_REMOTE_3 0x0008
 #define USB_VENDOR_ID_HANWANG		0x0b57
 #define USB_DEVICE_ID_HANWANG_TABLET_FIRST	0x5000
 #define USB_DEVICE_ID_HANWANG_TABLET_LAST	0x8fff
 #define USB_VENDOR_ID_HANVON		0x20b3
 #define USB_DEVICE_ID_HANVON_MULTITOUCH	0x0a18
 #define USB_VENDOR_ID_HANVON_ALT	0x22ed
 #define USB_DEVICE_ID_HANVON_ALT_MULTITOUCH	0x1010
 #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_HUION		0x256c
 #define USB_DEVICE_ID_HUION_TABLET	0x006e
 #define USB_VENDOR_ID_IDEACOM		0x1cb6
 #define USB_DEVICE_ID_IDEACOM_IDC6650	0x6650
 #define USB_DEVICE_ID_IDEACOM_IDC6651	0x6651
 #define USB_VENDOR_ID_ILITEK		0x222a
 #define USB_DEVICE_ID_ILITEK_MULTITOUCH	0x0001
 #define USB_VENDOR_ID_INTEL_0		0x8086
 #define USB_VENDOR_ID_INTEL_1		0x8087
 #define USB_DEVICE_ID_INTEL_HID_SENSOR_0	0x09fa
 #define USB_DEVICE_ID_INTEL_HID_SENSOR_1	0x0a04
 #define USB_VENDOR_ID_STM_0             0x0483
 #define USB_DEVICE_ID_STM_HID_SENSOR    0x91d1
 #define USB_DEVICE_ID_STM_HID_SENSOR_1  0x9100
 #define USB_VENDOR_ID_ION		0x15e4
 #define USB_DEVICE_ID_ICADE		0x0132
 #define USB_VENDOR_ID_HOLTEK		0x1241
 #define USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP	0x5015
 #define USB_VENDOR_ID_HOLTEK_ALT		0x04d9
 #define USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD	0xa055
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A	0xa04a
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067	0xa067
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A070	0xa070
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072	0xa072
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081	0xa081
 #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2	0xa0c2
 #define USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD_A096	0xa096
 #define USB_VENDOR_ID_IMATION		0x0718
 #define USB_DEVICE_ID_DISC_STAKKA	0xd000
 #define USB_VENDOR_ID_IRTOUCHSYSTEMS	0x6615
 #define USB_DEVICE_ID_IRTOUCH_INFRARED_USB	0x0070
 #define USB_VENDOR_ID_JABRA		0x0b0e
 #define USB_DEVICE_ID_JABRA_SPEAK_410	0x0412
 #define USB_DEVICE_ID_JABRA_SPEAK_510	0x0420
 #define USB_DEVICE_ID_JABRA_GN9350E	0x9350
 #define USB_VENDOR_ID_JESS		0x0c45
 #define USB_DEVICE_ID_JESS_YUREX	0x1010
 #define USB_VENDOR_ID_JESS2		0x0f30
 #define USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD 0x0111
 #define USB_VENDOR_ID_KBGEAR		0x084e
 #define USB_DEVICE_ID_KBGEAR_JAMSTUDIO	0x1001
 #define USB_VENDOR_ID_KENSINGTON	0x047d
 #define USB_DEVICE_ID_KS_SLIMBLADE	0x2041
 #define USB_VENDOR_ID_KWORLD		0x1b80
 #define USB_DEVICE_ID_KWORLD_RADIO_FM700	0xd700
 #define USB_VENDOR_ID_KEYTOUCH		0x0926
 #define USB_DEVICE_ID_KEYTOUCH_IEC	0x3333
 #define USB_VENDOR_ID_KYE		0x0458
 #define USB_DEVICE_ID_KYE_ERGO_525V	0x0087
 #define USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE	0x0138
 #define USB_DEVICE_ID_GENIUS_MANTICORE	0x0153
 #define USB_DEVICE_ID_GENIUS_GX_IMPERATOR	0x4018
 #define USB_DEVICE_ID_KYE_GPEN_560	0x5003
 #define USB_DEVICE_ID_KYE_EASYPEN_I405X	0x5010
 #define USB_DEVICE_ID_KYE_MOUSEPEN_I608X	0x5011
+#define USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2	0x501a
 #define USB_DEVICE_ID_KYE_EASYPEN_M610X	0x5013
 #define USB_VENDOR_ID_LABTEC		0x1020
 #define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD	0x0006
 #define USB_VENDOR_ID_LCPOWER		0x1241
 #define USB_DEVICE_ID_LCPOWER_LC1000	0xf767
 #define USB_VENDOR_ID_LD		0x0f11
 #define USB_DEVICE_ID_LD_CASSY		0x1000
 #define USB_DEVICE_ID_LD_CASSY2		0x1001
 #define USB_DEVICE_ID_LD_POCKETCASSY	0x1010
 #define USB_DEVICE_ID_LD_POCKETCASSY2	0x1011
 #define USB_DEVICE_ID_LD_MOBILECASSY	0x1020
 #define USB_DEVICE_ID_LD_MOBILECASSY2	0x1021
 #define USB_DEVICE_ID_LD_MICROCASSYVOLTAGE	0x1031
 #define USB_DEVICE_ID_LD_MICROCASSYCURRENT	0x1032
 #define USB_DEVICE_ID_LD_MICROCASSYTIME		0x1033
 #define USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE	0x1035
 #define USB_DEVICE_ID_LD_MICROCASSYPH		0x1038
 #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_UMIC		0x10A0
 #define USB_DEVICE_ID_LD_UMIB		0x10B0
 #define USB_DEVICE_ID_LD_XRAY		0x1100
 #define USB_DEVICE_ID_LD_XRAY2		0x1101
 #define USB_DEVICE_ID_LD_XRAYCT		0x1110
 #define USB_DEVICE_ID_LD_VIDEOCOM	0x1200
 #define USB_DEVICE_ID_LD_MOTOR		0x1210
 #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_DEVICE_ID_LD_MOSTANALYSER	0x2050
 #define USB_DEVICE_ID_LD_MOSTANALYSER2	0x2051
 #define USB_DEVICE_ID_LD_ABSESP		0x2060
 #define USB_DEVICE_ID_LD_AUTODATABUS	0x2070
 #define USB_DEVICE_ID_LD_MCT		0x2080
 #define USB_DEVICE_ID_LD_HYBRID		0x2090
 #define USB_DEVICE_ID_LD_HEATCONTROL	0x20A0
 #define USB_VENDOR_ID_LENOVO		0x17ef
 #define USB_DEVICE_ID_LENOVO_TPKBD	0x6009
 #define USB_DEVICE_ID_LENOVO_CUSBKBD	0x6047
 #define USB_DEVICE_ID_LENOVO_CBTKBD	0x6048
 #define USB_VENDOR_ID_LG		0x1fd2
 #define USB_DEVICE_ID_LG_MULTITOUCH	0x0064
 #define USB_VENDOR_ID_LOGITECH		0x046d
 #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e
 #define USB_DEVICE_ID_LOGITECH_T651	0xb00c
 #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_HARMONY_PS3 0x0306
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD	0xc20a
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD	0xc211
 #define USB_DEVICE_ID_LOGITECH_EXTREME_3D	0xc215
 #define USB_DEVICE_ID_LOGITECH_DUAL_ACTION	0xc216
 #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_FLIGHT_SYSTEM_G940	0xc287
 #define USB_DEVICE_ID_LOGITECH_WINGMAN_FFG	0xc293
 #define USB_DEVICE_ID_LOGITECH_WHEEL	0xc294
 #define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL	0xc295
 #define USB_DEVICE_ID_LOGITECH_DFP_WHEEL	0xc298
 #define USB_DEVICE_ID_LOGITECH_G25_WHEEL	0xc299
 #define USB_DEVICE_ID_LOGITECH_DFGT_WHEEL	0xc29a
 #define USB_DEVICE_ID_LOGITECH_G27_WHEEL	0xc29b
 #define USB_DEVICE_ID_LOGITECH_WII_WHEEL	0xc29c
 #define USB_DEVICE_ID_LOGITECH_ELITE_KBD	0xc30a
 #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_LOGITECH_UNIFYING_RECEIVER	0xc52b
 #define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2	0xc532
 #define USB_DEVICE_ID_SPACETRAVELLER	0xc623
 #define USB_DEVICE_ID_SPACENAVIGATOR	0xc626
 #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_DEVICE_ID_LOGITECH_VIBRATION_WHEEL	0xca04
 #define USB_VENDOR_ID_LUMIO		0x202e
 #define USB_DEVICE_ID_CRYSTALTOUCH	0x0006
 #define USB_DEVICE_ID_CRYSTALTOUCH_DUAL	0x0007
 #define USB_VENDOR_ID_MADCATZ		0x0738
 #define USB_DEVICE_ID_MADCATZ_BEATPAD	0x4540
 #define USB_DEVICE_ID_MADCATZ_RAT9	0x1709
 #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_DEVICE_ID_PICOLCD		0xc002
 #define USB_DEVICE_ID_PICOLCD_BOOTLOADER	0xf002
 #define USB_VENDOR_ID_MICROSOFT		0x045e
 #define USB_DEVICE_ID_SIDEWINDER_GV	0x003b
 #define USB_DEVICE_ID_MS_OFFICE_KB	0x0048
 #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
 #define USB_DEVICE_ID_MS_NE4K		0x00db
 #define USB_DEVICE_ID_MS_NE4K_JP	0x00dc
 #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_DEVICE_ID_MS_DIGITAL_MEDIA_3K	0x0730
 #define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500	0x076c
 #define USB_DEVICE_ID_MS_SURFACE_PRO_2   0x0799
 #define USB_DEVICE_ID_MS_TOUCH_COVER_2   0x07a7
 #define USB_DEVICE_ID_MS_TYPE_COVER_2    0x07a9
 #define USB_DEVICE_ID_MS_TYPE_COVER_3    0x07dc
 #define USB_VENDOR_ID_MOJO		0x8282
 #define USB_DEVICE_ID_RETRO_ADAPTER	0x3201
 #define USB_VENDOR_ID_MONTEREY		0x0566
 #define USB_DEVICE_ID_GENIUS_KB29E	0x3004
 #define USB_VENDOR_ID_MSI		0x1770
 #define USB_DEVICE_ID_MSI_GT683R_LED_PANEL 0xff00
 #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_NCR		0x0404
 #define USB_DEVICE_ID_NCR_FIRST		0x0300
 #define USB_DEVICE_ID_NCR_LAST		0x03ff
 #define USB_VENDOR_ID_NEC		0x073e
 #define USB_DEVICE_ID_NEC_USB_GAME_PAD	0x0301
 #define USB_VENDOR_ID_NEXIO		0x1870
 #define USB_DEVICE_ID_NEXIO_MULTITOUCH_420	0x010d
 #define USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750	0x0110
 #define USB_VENDOR_ID_NEXTWINDOW	0x1926
 #define USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN	0x0003
 #define USB_VENDOR_ID_NINTENDO		0x057e
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE	0x0306
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE2	0x0330
 #define USB_VENDOR_ID_NOVATEK		0x0603
 #define USB_DEVICE_ID_NOVATEK_PCT	0x0600
 #define USB_DEVICE_ID_NOVATEK_MOUSE	0x1602
 #define USB_VENDOR_ID_NTRIG		0x1b96
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1   0x0003
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2   0x0004
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3   0x0005
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4   0x0006
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5   0x0007
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6   0x0008
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7   0x0009
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8   0x000A
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9   0x000B
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10   0x000C
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11   0x000D
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12   0x000E
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13   0x000F
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14   0x0010
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15   0x0011
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16   0x0012
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17   0x0013
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
 #define USB_DEVICE_ID_NTRIG_DUOSENSE 0x1500
 #define USB_VENDOR_ID_ONTRAK		0x0a07
 #define USB_DEVICE_ID_ONTRAK_ADU100	0x0064
 #define USB_VENDOR_ID_ORTEK		0x05a4
 #define USB_DEVICE_ID_ORTEK_PKB1700	0x1700
 #define USB_DEVICE_ID_ORTEK_WKB2000	0x2000
 #define USB_VENDOR_ID_PLANTRONICS	0x047f
 #define USB_VENDOR_ID_PANASONIC		0x04da
 #define USB_DEVICE_ID_PANABOARD_UBT780	0x1044
 #define USB_DEVICE_ID_PANABOARD_UBT880	0x104d
 #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_PENMOUNT		0x14e1
 #define USB_DEVICE_ID_PENMOUNT_PCI	0x3500
 #define USB_DEVICE_ID_PENMOUNT_1610	0x1610
 #define USB_DEVICE_ID_PENMOUNT_1640	0x1640
 #define USB_DEVICE_ID_PENMOUNT_6000	0x6000
 #define USB_VENDOR_ID_PETALYNX		0x18b1
 #define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE	0x0037
 #define USB_VENDOR_ID_PHILIPS		0x0471
 #define USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE 0x0617
 #define USB_VENDOR_ID_PI_ENGINEERING	0x05f3
 #define USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL	0xff
 #define USB_VENDOR_ID_PIXART				0x093a
 #define USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2	0x0137
 #define USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE		0x2510
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN	0x8001
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1	0x8002
 #define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2	0x8003
 #define USB_VENDOR_ID_PLAYDOTCOM	0x0b43
 #define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII	0x0003
 #define USB_VENDOR_ID_POWERCOM		0x0d9f
 #define USB_DEVICE_ID_POWERCOM_UPS	0x0002
 #define USB_VENDOR_ID_PRODIGE		0x05af
 #define USB_DEVICE_ID_PRODIGE_CORDLESS	0x3062
 #define USB_VENDOR_ID_QUANTA		0x0408
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH		0x3000
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001		0x3001
 #define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008		0x3008
 #define USB_VENDOR_ID_REALTEK		0x0bda
 #define USB_DEVICE_ID_REALTEK_READER	0x0152
 #define USB_VENDOR_ID_ROCCAT		0x1e7d
 #define USB_DEVICE_ID_ROCCAT_ARVO	0x30d4
 #define USB_DEVICE_ID_ROCCAT_ISKU	0x319c
 #define USB_DEVICE_ID_ROCCAT_ISKUFX	0x3264
 #define USB_DEVICE_ID_ROCCAT_KONE	0x2ced
 #define USB_DEVICE_ID_ROCCAT_KONEPLUS	0x2d51
 #define USB_DEVICE_ID_ROCCAT_KONEPURE	0x2dbe
 #define USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL	0x2db4
 #define USB_DEVICE_ID_ROCCAT_KONEXTD	0x2e22
 #define USB_DEVICE_ID_ROCCAT_KOVAPLUS	0x2d50
 #define USB_DEVICE_ID_ROCCAT_LUA	0x2c2e
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRED	0x2c24
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS	0x2cf6
 #define USB_DEVICE_ID_ROCCAT_RYOS_MK	0x3138
 #define USB_DEVICE_ID_ROCCAT_RYOS_MK_GLOW	0x31ce
 #define USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO	0x3232
 #define USB_DEVICE_ID_ROCCAT_SAVU	0x2d5a
 #define USB_VENDOR_ID_SAITEK		0x06a3
 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD	0xff17
 #define USB_DEVICE_ID_SAITEK_PS1000	0x0621
 #define USB_DEVICE_ID_SAITEK_RAT7	0x0cd7
 #define USB_DEVICE_ID_SAITEK_MMO7	0x0cd0
 #define USB_VENDOR_ID_SAMSUNG		0x0419
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE	0x0001
 #define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE	0x0600
 #define USB_VENDOR_ID_SEMICO			0x1a2c
 #define USB_DEVICE_ID_SEMICO_USB_KEYKOARD	0x0023
 #define USB_VENDOR_ID_SENNHEISER	0x1395
 #define USB_DEVICE_ID_SENNHEISER_BTD500USB	0x002c
 #define USB_VENDOR_ID_SIGMA_MICRO	0x1c4f
 #define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD	0x0002
 #define USB_VENDOR_ID_SIGMATEL		0x066F
 #define USB_DEVICE_ID_SIGMATEL_STMP3780	0x3780
 #define USB_VENDOR_ID_SIS_TOUCH		0x0457
 #define USB_DEVICE_ID_SIS9200_TOUCH	0x9200
 #define USB_DEVICE_ID_SIS817_TOUCH	0x0817
 #define USB_DEVICE_ID_SIS_TS		0x1013
 #define USB_DEVICE_ID_SIS1030_TOUCH	0x1030
 #define USB_VENDOR_ID_SKYCABLE			0x1223
 #define	USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER	0x3F07
 #define USB_VENDOR_ID_SMK		0x0609
 #define USB_DEVICE_ID_SMK_PS3_BDREMOTE	0x0306
 #define USB_VENDOR_ID_SONY			0x054c
 #define USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE	0x024b
 #define USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE	0x0374
 #define USB_DEVICE_ID_SONY_PS3_BDREMOTE		0x0306
 #define USB_DEVICE_ID_SONY_PS3_CONTROLLER	0x0268
 #define USB_DEVICE_ID_SONY_PS4_CONTROLLER	0x05c4
 #define USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER	0x042f
 #define USB_DEVICE_ID_SONY_BUZZ_CONTROLLER		0x0002
 #define USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER	0x1000
 #define USB_VENDOR_ID_SOUNDGRAPH	0x15c2
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST	0x0034
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST	0x0046
 #define USB_VENDOR_ID_STANTUM		0x1f87
 #define USB_DEVICE_ID_MTP		0x0002
 #define USB_VENDOR_ID_STANTUM_STM		0x0483
 #define USB_DEVICE_ID_MTP_STM		0x3261
 #define USB_VENDOR_ID_STANTUM_SITRONIX		0x1403
 #define USB_DEVICE_ID_MTP_SITRONIX		0x5001
 #define USB_VENDOR_ID_STEELSERIES	0x1038
 #define USB_DEVICE_ID_STEELSERIES_SRWS1	0x1410
 #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_SYMBOL		0x05e0
 #define USB_DEVICE_ID_SYMBOL_SCANNER_1	0x0800
 #define USB_DEVICE_ID_SYMBOL_SCANNER_2	0x1300
 #define USB_VENDOR_ID_SYNAPTICS		0x06cb
 #define USB_DEVICE_ID_SYNAPTICS_TP	0x0001
 #define USB_DEVICE_ID_SYNAPTICS_INT_TP	0x0002
 #define USB_DEVICE_ID_SYNAPTICS_CPAD	0x0003
 #define USB_DEVICE_ID_SYNAPTICS_TS	0x0006
 #define USB_DEVICE_ID_SYNAPTICS_STICK	0x0007
 #define USB_DEVICE_ID_SYNAPTICS_WP	0x0008
 #define USB_DEVICE_ID_SYNAPTICS_COMP_TP	0x0009
 #define USB_DEVICE_ID_SYNAPTICS_WTP	0x0010
 #define USB_DEVICE_ID_SYNAPTICS_DPAD	0x0013
 #define USB_DEVICE_ID_SYNAPTICS_LTS1	0x0af8
 #define USB_DEVICE_ID_SYNAPTICS_LTS2	0x1d10
 #define USB_DEVICE_ID_SYNAPTICS_HD	0x0ac3
 #define USB_DEVICE_ID_SYNAPTICS_QUAD_HD	0x1ac3
 #define USB_DEVICE_ID_SYNAPTICS_TP_V103	0x5710
 #define USB_VENDOR_ID_TEXAS_INSTRUMENTS	0x2047
 #define USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA	0x0855
 #define USB_VENDOR_ID_THINGM		0x27b8
 #define USB_DEVICE_ID_BLINK1		0x01ed
 #define USB_VENDOR_ID_THRUSTMASTER	0x044f
 #define USB_VENDOR_ID_TIVO		0x150a
 #define USB_DEVICE_ID_TIVO_SLIDE_BT	0x1200
 #define USB_DEVICE_ID_TIVO_SLIDE	0x1201
 #define USB_VENDOR_ID_TOPSEED		0x0766
 #define USB_DEVICE_ID_TOPSEED_CYBERLINK	0x0204
 #define USB_VENDOR_ID_TOPSEED2		0x1784
 #define USB_DEVICE_ID_TOPSEED2_RF_COMBO	0x0004
 #define USB_DEVICE_ID_TOPSEED2_PERIPAD_701	0x0016
 #define USB_VENDOR_ID_TOPMAX		0x0663
 #define USB_DEVICE_ID_TOPMAX_COBRAPAD	0x0103
 #define USB_VENDOR_ID_TOUCH_INTL	0x1e5e
 #define USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH	0x0313
 #define USB_VENDOR_ID_TOUCHPACK		0x1bfd
 #define USB_DEVICE_ID_TOUCHPACK_RTS	0x1688
 #define USB_VENDOR_ID_TPV		0x25aa
 #define USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN	0x8883
 #define USB_VENDOR_ID_TURBOX		0x062a
 #define USB_DEVICE_ID_TURBOX_KEYBOARD	0x0201
 #define USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART	0x7100
 #define USB_VENDOR_ID_TWINHAN		0x6253
 #define USB_DEVICE_ID_TWINHAN_IR_REMOTE	0x0100
 #define USB_VENDOR_ID_UCLOGIC		0x5543
 #define USB_DEVICE_ID_UCLOGIC_TABLET_PF1209	0x0042
 #define USB_DEVICE_ID_UCLOGIC_TABLET_KNA5	0x6001
 #define USB_DEVICE_ID_UCLOGIC_TABLET_TWA60	0x0064
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U	0x0003
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U	0x0004
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U	0x0005
 #define USB_DEVICE_ID_UCLOGIC_TABLET_WP1062	0x0064
 #define USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850	0x0522
 #define USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60	0x0781
 #define USB_VENDOR_ID_UNITEC	0x227d
 #define USB_DEVICE_ID_UNITEC_USB_TOUCH_0709	0x0709
 #define USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19	0x0a19
 #define USB_VENDOR_ID_VELLEMAN		0x10cf
 #define USB_DEVICE_ID_VELLEMAN_K8055_FIRST	0x5500
 #define USB_DEVICE_ID_VELLEMAN_K8055_LAST	0x5503
 #define USB_DEVICE_ID_VELLEMAN_K8061_FIRST	0x8061
 #define USB_DEVICE_ID_VELLEMAN_K8061_LAST	0x8068
 #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_VTL		0x0306
 #define USB_DEVICE_ID_VTL_MULTITOUCH_FF3F	0xff3f
 #define USB_VENDOR_ID_WACOM		0x056a
 #define USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH	0x81
 #define USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH   0x00BD
 #define USB_VENDOR_ID_WALTOP				0x172f
 #define USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH	0x0032
 #define USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH	0x0034
 #define USB_DEVICE_ID_WALTOP_Q_PAD			0x0037
 #define USB_DEVICE_ID_WALTOP_PID_0038			0x0038
 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH	0x0501
 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH	0x0500
 #define USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET	0x0502
 #define USB_VENDOR_ID_WISEGROUP		0x0925
 #define USB_DEVICE_ID_SMARTJOY_PLUS	0x0005
 #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_SUPER_JOY_BOX_3	0x8888
 #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_DEVICE_ID_SUPER_JOY_BOX_3_PRO 0x8801
 #define USB_DEVICE_ID_SUPER_DUAL_BOX_PRO 0x8802
 #define USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO 0x8804
 #define USB_VENDOR_ID_WISTRON		0x0fb8
 #define USB_DEVICE_ID_WISTRON_OPTICAL_TOUCH		0x1109
 #define USB_VENDOR_ID_X_TENSIONS               0x1ae7
 #define USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE    0x9001
 #define USB_VENDOR_ID_XAT	0x2505
 #define USB_DEVICE_ID_XAT_CSR	0x0220
 #define USB_VENDOR_ID_XIN_MO			0x16c0
 #define USB_DEVICE_ID_XIN_MO_DUAL_ARCADE	0x05e1
 #define USB_VENDOR_ID_XIROKU		0x1477
 #define USB_DEVICE_ID_XIROKU_SPX	0x1006
 #define USB_DEVICE_ID_XIROKU_MPX	0x1007
 #define USB_DEVICE_ID_XIROKU_CSR	0x100e
 #define USB_DEVICE_ID_XIROKU_SPX1	0x1021
 #define USB_DEVICE_ID_XIROKU_CSR1	0x1022
 #define USB_DEVICE_ID_XIROKU_MPX1	0x1023
 #define USB_DEVICE_ID_XIROKU_SPX2	0x1024
 #define USB_DEVICE_ID_XIROKU_CSR2	0x1025
 #define USB_DEVICE_ID_XIROKU_MPX2	0x1026
 #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_ZYDACRON	0x13EC
 #define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL	0x0006
 #define USB_VENDOR_ID_ZYTRONIC		0x14c8
 #define USB_DEVICE_ID_ZYTRONIC_ZXY100	0x0005
 #define USB_VENDOR_ID_PRIMAX	0x0461
 #define USB_DEVICE_ID_PRIMAX_KEYBOARD	0x4e05
 #define USB_VENDOR_ID_RISO_KAGAKU	0x1294	/* Riso Kagaku Corp. */
 #define USB_DEVICE_ID_RI_KA_WEBMAIL	0x1320	/* Webmail Notifier */
 #endif

drivers/hid/hid-input.c

Diff comments View file @ 28023d2

 /*
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *  Copyright (c) 2006-2010 Jiri Kosina
  *
  *  HID to Linux Input mapping
  */
 /*
  * 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 either by
  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
 #include "hid-ids.h"
 #define unk	KEY_UNKNOWN
 static const unsigned char hid_keyboard[256] = {
 	  0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
 	 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
 	  4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
 	 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
 	 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
 	105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
 	 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
 	191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
 	115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
 	122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,
 	unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
 	unk,unk,unk,unk,unk,unk,179,180,unk,unk,unk,unk,unk,unk,unk,unk,
 	unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
 	unk,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,unk,unk,unk,unk,
 	 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
 	150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
 };
 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)	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))
 #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 bool match_scancode(struct hid_usage *usage,
 			   unsigned int cur_idx, unsigned int scancode)
 {
 	return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
 }
 static bool match_keycode(struct hid_usage *usage,
 			  unsigned int cur_idx, unsigned int keycode)
 {
 	/*
 	 * We should exclude unmapped usages when doing lookup by keycode.
 	 */
 	return (usage->type == EV_KEY && usage->code == keycode);
 }
 static bool match_index(struct hid_usage *usage,
 			unsigned int cur_idx, unsigned int idx)
 {
 	return cur_idx == idx;
 }
 typedef bool (*hid_usage_cmp_t)(struct hid_usage *usage,
 				unsigned int cur_idx, unsigned int val);
 static struct hid_usage *hidinput_find_key(struct hid_device *hid,
 					   hid_usage_cmp_t match,
 					   unsigned int value,
 					   unsigned int *usage_idx)
 {
 	unsigned int i, j, k, cur_idx = 0;
 	struct hid_report *report;
 	struct hid_usage *usage;
 	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
 			for (i = 0; i < report->maxfield; i++) {
 				for (j = 0; j < report->field[i]->maxusage; j++) {
 					usage = report->field[i]->usage + j;
 					if (usage->type == EV_KEY || usage->type == 0) {
 						if (match(usage, cur_idx, value)) {
 							if (usage_idx)
 								*usage_idx = cur_idx;
 							return usage;
 						}
 						cur_idx++;
 					}
 				}
 			}
 		}
 	}
 	return NULL;
 }
 static struct hid_usage *hidinput_locate_usage(struct hid_device *hid,
 					const struct input_keymap_entry *ke,
 					unsigned int *index)
 {
 	struct hid_usage *usage;
 	unsigned int scancode;
 	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
 		usage = hidinput_find_key(hid, match_index, ke->index, index);
 	else if (input_scancode_to_scalar(ke, &scancode) == 0)
 		usage = hidinput_find_key(hid, match_scancode, scancode, index);
 	else
 		usage = NULL;
 	return usage;
 }
 static int hidinput_getkeycode(struct input_dev *dev,
 			       struct input_keymap_entry *ke)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	struct hid_usage *usage;
 	unsigned int scancode, index;
 	usage = hidinput_locate_usage(hid, ke, &index);
 	if (usage) {
 		ke->keycode = usage->type == EV_KEY ?
 				usage->code : KEY_RESERVED;
 		ke->index = index;
 		scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE);
 		ke->len = sizeof(scancode);
 		memcpy(ke->scancode, &scancode, sizeof(scancode));
 		return 0;
 	}
 	return -EINVAL;
 }
 static int hidinput_setkeycode(struct input_dev *dev,
 			       const struct input_keymap_entry *ke,
 			       unsigned int *old_keycode)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	struct hid_usage *usage;
 	usage = hidinput_locate_usage(hid, ke, NULL);
 	if (usage) {
 		*old_keycode = usage->type == EV_KEY ?
 				usage->code : KEY_RESERVED;
 		usage->code = ke->keycode;
 		clear_bit(*old_keycode, dev->keybit);
 		set_bit(usage->code, dev->keybit);
 		dbg_hid("Assigned keycode %d to HID usage code %x\n",
 			usage->code, usage->hid);
 		/*
 		 * Set the keybit for the old keycode if the old keycode is used
 		 * by another key
 		 */
 		if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL))
 			set_bit(*old_keycode, dev->keybit);
 		return 0;
 	}
 	return -EINVAL;
 }
 /**
  * hidinput_calc_abs_res - calculate an absolute axis resolution
  * @field: the HID report field to calculate resolution for
  * @code: axis code
  *
  * The formula is:
  *                         (logical_maximum - logical_minimum)
  * resolution = ----------------------------------------------------------
  *              (physical_maximum - physical_minimum) * 10 ^ unit_exponent
  *
  * as seen in the HID specification v1.11 6.2.2.7 Global Items.
  *
  * Only exponent 1 length units are processed. Centimeters and inches are
  * converted to millimeters. Degrees are converted to radians.
  */
 __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
 {
 	__s32 unit_exponent = field->unit_exponent;
 	__s32 logical_extents = field->logical_maximum -
 					field->logical_minimum;
 	__s32 physical_extents = field->physical_maximum -
 					field->physical_minimum;
 	__s32 prev;
 	/* Check if the extents are sane */
 	if (logical_extents <= 0 || physical_extents <= 0)
 		return 0;
 	/*
 	 * Verify and convert units.
 	 * See HID specification v1.11 6.2.2.7 Global Items for unit decoding
 	 */
 	switch (code) {
 	case ABS_X:
 	case ABS_Y:
 	case ABS_Z:
 	case ABS_MT_POSITION_X:
 	case ABS_MT_POSITION_Y:
 	case ABS_MT_TOOL_X:
 	case ABS_MT_TOOL_Y:
 	case ABS_MT_TOUCH_MAJOR:
 	case ABS_MT_TOUCH_MINOR:
 		if (field->unit == 0x11) {		/* If centimeters */
 			/* Convert to millimeters */
 			unit_exponent += 1;
 		} else if (field->unit == 0x13) {	/* If inches */
 			/* Convert to millimeters */
 			prev = physical_extents;
 			physical_extents *= 254;
 			if (physical_extents < prev)
 				return 0;
 			unit_exponent -= 1;
 		} else {
 			return 0;
 		}
 		break;
 	case ABS_RX:
 	case ABS_RY:
 	case ABS_RZ:
 	case ABS_TILT_X:
 	case ABS_TILT_Y:
 		if (field->unit == 0x14) {		/* If degrees */
 			/* Convert to radians */
 			prev = logical_extents;
 			logical_extents *= 573;
 			if (logical_extents < prev)
 				return 0;
 			unit_exponent += 1;
 		} else if (field->unit != 0x12) {	/* If not radians */
 			return 0;
 		}
 		break;
 	default:
 		return 0;
 	}
 	/* Apply negative unit exponent */
 	for (; unit_exponent < 0; unit_exponent++) {
 		prev = logical_extents;
 		logical_extents *= 10;
 		if (logical_extents < prev)
 			return 0;
 	}
 	/* Apply positive unit exponent */
 	for (; unit_exponent > 0; unit_exponent--) {
 		prev = physical_extents;
 		physical_extents *= 10;
 		if (physical_extents < prev)
 			return 0;
 	}
 	/* Calculate resolution */
 	return DIV_ROUND_CLOSEST(logical_extents, physical_extents);
 }
 EXPORT_SYMBOL_GPL(hidinput_calc_abs_res);
 #ifdef CONFIG_HID_BATTERY_STRENGTH
 static enum power_supply_property hidinput_battery_props[] = {
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_ONLINE,
 	POWER_SUPPLY_PROP_CAPACITY,
 	POWER_SUPPLY_PROP_MODEL_NAME,
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_SCOPE,
 };
 #define HID_BATTERY_QUIRK_PERCENT	(1 << 0) /* always reports percent */
 #define HID_BATTERY_QUIRK_FEATURE	(1 << 1) /* ask for feature report */
 static const struct hid_device_id hid_battery_quirks[] = {
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 			USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
 	HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 			       USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
 	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
+			       USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
+	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 		USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
 	  HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
 	{}
 };
 static unsigned find_battery_quirk(struct hid_device *hdev)
 {
 	unsigned quirks = 0;
 	const struct hid_device_id *match;
 	match = hid_match_id(hdev, hid_battery_quirks);
 	if (match != NULL)
 		quirks = match->driver_data;
 	return quirks;
 }
 static int hidinput_get_battery_property(struct power_supply *psy,
 					 enum power_supply_property prop,
 					 union power_supply_propval *val)
 {
 	struct hid_device *dev = container_of(psy, struct hid_device, battery);
 	int ret = 0;
 	__u8 *buf;
 	switch (prop) {
 	case POWER_SUPPLY_PROP_PRESENT:
 	case POWER_SUPPLY_PROP_ONLINE:
 		val->intval = 1;
 		break;
 	case POWER_SUPPLY_PROP_CAPACITY:
 		buf = kmalloc(2 * sizeof(__u8), GFP_KERNEL);
 		if (!buf) {
 			ret = -ENOMEM;
 			break;
 		}
 		ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 2,
 					 dev->battery_report_type,
 					 HID_REQ_GET_REPORT);
 		if (ret != 2) {
 			ret = -ENODATA;
 			kfree(buf);
 			break;
 		}
 		ret = 0;
 		if (dev->battery_min < dev->battery_max &&
 		    buf[1] >= dev->battery_min &&
 		    buf[1] <= dev->battery_max)
 			val->intval = (100 * (buf[1] - dev->battery_min)) /
 				(dev->battery_max - dev->battery_min);
 		kfree(buf);
 		break;
 	case POWER_SUPPLY_PROP_MODEL_NAME:
 		val->strval = dev->name;
 		break;
 	case POWER_SUPPLY_PROP_STATUS:
 		val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 		break;
 	case POWER_SUPPLY_PROP_SCOPE:
 		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
 		break;
 	default:
 		ret = -EINVAL;
 		break;
 	}
 	return ret;
 }
 static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type, struct hid_field *field)
 {
 	struct power_supply *battery = &dev->battery;
 	int ret;
 	unsigned quirks;
 	s32 min, max;
 	if (field->usage->hid != HID_DC_BATTERYSTRENGTH)
 		return false;	/* no match */
 	if (battery->name != NULL)
 		goto out;	/* already initialized? */
 	battery->name = kasprintf(GFP_KERNEL, "hid-%s-battery", dev->uniq);
 	if (battery->name == NULL)
 		goto out;
 	battery->type = POWER_SUPPLY_TYPE_BATTERY;
 	battery->properties = hidinput_battery_props;
 	battery->num_properties = ARRAY_SIZE(hidinput_battery_props);
 	battery->use_for_apm = 0;
 	battery->get_property = hidinput_get_battery_property;
 	quirks = find_battery_quirk(dev);
 	hid_dbg(dev, "device %x:%x:%x %d quirks %d\n",
 		dev->bus, dev->vendor, dev->product, dev->version, quirks);
 	min = field->logical_minimum;
 	max = field->logical_maximum;
 	if (quirks & HID_BATTERY_QUIRK_PERCENT) {
 		min = 0;
 		max = 100;
 	}
 	if (quirks & HID_BATTERY_QUIRK_FEATURE)
 		report_type = HID_FEATURE_REPORT;
 	dev->battery_min = min;
 	dev->battery_max = max;
 	dev->battery_report_type = report_type;
 	dev->battery_report_id = field->report->id;
 	ret = power_supply_register(&dev->dev, battery);
 	if (ret != 0) {
 		hid_warn(dev, "can't register power supply: %d\n", ret);
 		kfree(battery->name);
 		battery->name = NULL;
 	}
 	power_supply_powers(battery, &dev->dev);
 out:
 	return true;
 }
 static void hidinput_cleanup_battery(struct hid_device *dev)
 {
 	if (!dev->battery.name)
 		return;
 	power_supply_unregister(&dev->battery);
 	kfree(dev->battery.name);
 	dev->battery.name = NULL;
 }
 #else  /* !CONFIG_HID_BATTERY_STRENGTH */
 static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
 				   struct hid_field *field)
 {
 	return false;
 }
 static void hidinput_cleanup_battery(struct hid_device *dev)
 {
 }
 #endif	/* CONFIG_HID_BATTERY_STRENGTH */
 static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
 				     struct hid_usage *usage)
 {
 	struct input_dev *input = hidinput->input;
 	struct hid_device *device = input_get_drvdata(input);
 	int max = 0, code;
 	unsigned long *bit = NULL;
 	field->hidinput = hidinput;
 	if (field->flags & HID_MAIN_ITEM_CONSTANT)
 		goto ignore;
 	/* Ignore if report count is out of bounds. */
 	if (field->report_count < 1)
 		goto ignore;
 	/* only LED usages are supported in output fields */
 	if (field->report_type == HID_OUTPUT_REPORT &&
 			(usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
 		goto ignore;
 	}
 	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_KEYBOARD:
 		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);
 		break;
 	case HID_UP_BUTTON:
 		code = ((usage->hid - 1) & HID_USAGE);
 		switch (field->application) {
 		case HID_GD_MOUSE:
 		case HID_GD_POINTER:  code += BTN_MOUSE; break;
 		case HID_GD_JOYSTICK:
 				if (code <= 0xf)
 					code += BTN_JOYSTICK;
 				else
 					code += BTN_TRIGGER_HAPPY - 0x10;
 				break;
 		case HID_GD_GAMEPAD:
 				if (code <= 0xf)
 					code += BTN_GAMEPAD;
 				else
 					code += BTN_TRIGGER_HAPPY - 0x10;
 				break;
 		default:
 			switch (field->physical) {
 			case HID_GD_MOUSE:
 			case HID_GD_POINTER:  code += BTN_MOUSE; break;
 			case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;
 			case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
 			default:              code += BTN_MISC;
 			}
 		}
 		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;
 			case 0x4: map_key_clear(KEY_CONTEXT_MENU); break;
 			case 0x5: map_key_clear(KEY_MENU); break;
 			case 0x6: map_key_clear(KEY_PROG1); break;
 			case 0x7: map_key_clear(KEY_HELP); break;
 			case 0x8: map_key_clear(KEY_EXIT); break;
 			case 0x9: map_key_clear(KEY_SELECT); break;
 			case 0xa: map_key_clear(KEY_RIGHT); break;
 			case 0xb: map_key_clear(KEY_LEFT); break;
 			case 0xc: map_key_clear(KEY_UP); break;
 			case 0xd: map_key_clear(KEY_DOWN); break;
 			case 0xe: map_key_clear(KEY_POWER2); break;
 			case 0xf: map_key_clear(KEY_RESTART); 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;
 		}
 		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:
 			if (field->flags & HID_MAIN_ITEM_RELATIVE)
 				map_rel(usage->hid & 0xf);
 			else
 				map_abs_clear(usage->hid & 0xf);
 			break;
 		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;
 		}
 		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 0x00: /* Undefined */
 			goto ignore;
 		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;
 		case 0x3c: /* Invert */
 			map_key_clear(BTN_TOOL_RUBBER);
 			break;
 		case 0x3d: /* X Tilt */
 			map_abs_clear(ABS_TILT_X);
 			break;
 		case 0x3e: /* Y Tilt */
 			map_abs_clear(ABS_TILT_Y);
 			break;
 		case 0x33: /* Touch */
 		case 0x42: /* TipSwitch */
 		case 0x43: /* TipSwitch2 */
 			device->quirks &= ~HID_QUIRK_NOTOUCH;
 			map_key_clear(BTN_TOUCH);
 			break;
 		case 0x44: /* BarrelSwitch */
 			map_key_clear(BTN_STYLUS);
 			break;
 		case 0x46: /* TabletPick */
 		case 0x5a: /* SecondaryBarrelSwitch */
 			map_key_clear(BTN_STYLUS2);
 			break;
 		case 0x5b: /* TransducerSerialNumber */
 			usage->type = EV_MSC;
 			usage->code = MSC_SERIAL;
 			bit = input->mscbit;
 			max = MSC_MAX;
 			break;
 		default:  goto unknown;
 		}
 		break;
 	case HID_UP_CONSUMER:	/* USB HUT v1.12, pages 75-84 */
 		switch (usage->hid & HID_USAGE) {
 		case 0x000: goto ignore;
 		case 0x030: map_key_clear(KEY_POWER);		break;
 		case 0x031: map_key_clear(KEY_RESTART);		break;
 		case 0x032: map_key_clear(KEY_SLEEP);		break;
 		case 0x034: map_key_clear(KEY_SLEEP);		break;
 		case 0x035: map_key_clear(KEY_KBDILLUMTOGGLE);	break;
 		case 0x036: map_key_clear(BTN_MISC);		break;
 		case 0x040: map_key_clear(KEY_MENU);		break; /* Menu */
 		case 0x041: map_key_clear(KEY_SELECT);		break; /* Menu Pick */
 		case 0x042: map_key_clear(KEY_UP);		break; /* Menu Up */
 		case 0x043: map_key_clear(KEY_DOWN);		break; /* Menu Down */
 		case 0x044: map_key_clear(KEY_LEFT);		break; /* Menu Left */
 		case 0x045: map_key_clear(KEY_RIGHT);		break; /* Menu Right */
 		case 0x046: map_key_clear(KEY_ESC);		break; /* Menu Escape */
 		case 0x047: map_key_clear(KEY_KPPLUS);		break; /* Menu Value Increase */
 		case 0x048: map_key_clear(KEY_KPMINUS);		break; /* Menu Value Decrease */
 		case 0x060: map_key_clear(KEY_INFO);		break; /* Data On Screen */
 		case 0x061: map_key_clear(KEY_SUBTITLE);	break; /* Closed Caption */
 		case 0x063: map_key_clear(KEY_VCR);		break; /* VCR/TV */
 		case 0x065: map_key_clear(KEY_CAMERA);		break; /* Snapshot */
 		case 0x069: map_key_clear(KEY_RED);		break;
 		case 0x06a: map_key_clear(KEY_GREEN);		break;
 		case 0x06b: map_key_clear(KEY_BLUE);		break;
 		case 0x06c: map_key_clear(KEY_YELLOW);		break;
 		case 0x06d: map_key_clear(KEY_ZOOM);		break;
 		case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);		break;
 		case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);		break;
 		case 0x072: map_key_clear(KEY_BRIGHTNESS_TOGGLE);	break;
 		case 0x073: map_key_clear(KEY_BRIGHTNESS_MIN);		break;
 		case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);		break;
 		case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);		break;
 		case 0x082: map_key_clear(KEY_VIDEO_NEXT);	break;
 		case 0x083: map_key_clear(KEY_LAST);		break;
 		case 0x084: map_key_clear(KEY_ENTER);		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 0x0b9: map_key_clear(KEY_SHUFFLE);		break;
 		case 0x0bf: map_key_clear(KEY_SLOW);		break;
 		case 0x0cd: map_key_clear(KEY_PLAYPAUSE);	break;
 		case 0x0cf: map_key_clear(KEY_VOICECOMMAND);	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 0x0f5: map_key_clear(KEY_SLOW);		break;
 		case 0x181: map_key_clear(KEY_BUTTONCONFIG);	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 0x18f: map_key_clear(KEY_TASKMANAGER);	break;
 		case 0x190: map_key_clear(KEY_JOURNAL);		break;
 		case 0x191: map_key_clear(KEY_FINANCE);		break;
 		case 0x192: map_key_clear(KEY_CALC);		break;
 		case 0x193: map_key_clear(KEY_PLAYER);		break;
 		case 0x194: map_key_clear(KEY_FILE);		break;
 		case 0x196: map_key_clear(KEY_WWW);		break;
 		case 0x199: map_key_clear(KEY_CHAT);		break;
 		case 0x19c: map_key_clear(KEY_LOGOFF);		break;
 		case 0x19e: map_key_clear(KEY_COFFEE);		break;
 		case 0x19f: map_key_clear(KEY_CONTROLPANEL);		break;
 		case 0x1a2: map_key_clear(KEY_APPSELECT);		break;
 		case 0x1a3: map_key_clear(KEY_NEXT);		break;
 		case 0x1a4: map_key_clear(KEY_PREVIOUS);	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 0x1ae: map_key_clear(KEY_KEYBOARD);	break;
 		case 0x1b1: map_key_clear(KEY_SCREENSAVER);		break;
 		case 0x1b4: map_key_clear(KEY_FILE);		break;
 		case 0x1b6: map_key_clear(KEY_IMAGES);		break;
 		case 0x1b7: map_key_clear(KEY_AUDIO);		break;
 		case 0x1b8: map_key_clear(KEY_VIDEO);		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 0x23d: map_key_clear(KEY_EDIT);		break;
 		case 0x25f: map_key_clear(KEY_CANCEL);		break;
 		case 0x269: map_key_clear(KEY_INSERT);		break;
 		case 0x26a: map_key_clear(KEY_DELETE);		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;
 		case 0x2c7: map_key_clear(KEY_KBDINPUTASSIST_PREV);		break;
 		case 0x2c8: map_key_clear(KEY_KBDINPUTASSIST_NEXT);		break;
 		case 0x2c9: map_key_clear(KEY_KBDINPUTASSIST_PREVGROUP);		break;
 		case 0x2ca: map_key_clear(KEY_KBDINPUTASSIST_NEXTGROUP);		break;
 		case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);	break;
 		case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);	break;
 		default: map_key_clear(KEY_UNKNOWN);
 		}
 		break;
 	case HID_UP_GENDEVCTRLS:
 		if (hidinput_setup_battery(device, HID_INPUT_REPORT, field))
 			goto ignore;
 		else
 			goto unknown;
 		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;
 	case HID_UP_HPVENDOR2:
 		set_bit(EV_REP, input->evbit);
 		switch (usage->hid & HID_USAGE) {
 		case 0x003: map_key_clear(KEY_BRIGHTNESSDOWN);	break;
 		case 0x004: map_key_clear(KEY_BRIGHTNESSUP);	break;
 		default:    goto ignore;
 		}
 		break;
 	case HID_UP_MSVENDOR:
 		goto ignore;
 	case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
 		set_bit(EV_REP, input->evbit);
 		goto ignore;
 	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_key(BTN_MISC);
 			break;
 		}
 		if (field->flags & HID_MAIN_ITEM_RELATIVE) {
 			map_rel(REL_MISC);
 			break;
 		}
 		map_abs(ABS_MISC);
 		break;
 	}
 mapped:
 	if (device->driver->input_mapped && device->driver->input_mapped(device,
 				hidinput, field, usage, &bit, &max) < 0)
 		goto ignore;
 	set_bit(usage->type, input->evbit);
 	while (usage->code <= max && test_and_set_bit(usage->code, bit))
 		usage->code = find_next_zero_bit(bit, max + 1, usage->code);
 	if (usage->code > max)
 		goto ignore;
 	if (usage->type == EV_ABS) {
 		int a = field->logical_minimum;
 		int b = field->logical_maximum;
 		if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
 			a = field->logical_minimum = 0;
 			b = field->logical_maximum = 255;
 		}
 		if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
 			input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
 		else	input_set_abs_params(input, usage->code, a, b, 0, 0);
 		input_abs_set_res(input, usage->code,
 				  hidinput_calc_abs_res(field, usage->code));
 		/* use a larger default input buffer for MT devices */
 		if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
 			input_set_events_per_packet(input, 60);
 	}
 	if (usage->type == EV_ABS &&
 	    (usage->hat_min < usage->hat_max || usage->hat_dir)) {
 		int i;
 		for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
 			input_set_abs_params(input, i, -1, 1, 0, 0);
 			set_bit(i, input->absbit);
 		}
 		if (usage->hat_dir && !field->dpad)
 			field->dpad = usage->code;
 	}
 	/* for those devices which produce Consumer volume usage as relative,
 	 * we emulate pressing volumeup/volumedown appropriate number of times
 	 * in hidinput_hid_event()
 	 */
 	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
 			(usage->code == ABS_VOLUME)) {
 		set_bit(KEY_VOLUMEUP, input->keybit);
 		set_bit(KEY_VOLUMEDOWN, input->keybit);
 	}
 	if (usage->type == EV_KEY) {
 		set_bit(EV_MSC, input->evbit);
 		set_bit(MSC_SCAN, input->mscbit);
 	}
 ignore:
 	return;
 }
 void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
 {
 	struct input_dev *input;
 	unsigned *quirks = &hid->quirks;
 	if (!field->hidinput)
 		return;
 	input = field->hidinput->input;
 	if (!usage->type)
 		return;
 	if (usage->hat_min < usage->hat_max || usage->hat_dir) {
 		int hat_dir = usage->hat_dir;
 		if (!hat_dir)
 			hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
 		if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
 		input_event(input, usage->type, usage->code    , hid_hat_to_axis[hat_dir].x);
 		input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
 		return;
 	}
 	if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
 		*quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
 		return;
 	}
 	if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
 		if (value) {
 			input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
 			return;
 		}
 		input_event(input, usage->type, usage->code, 0);
 		input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
 		return;
 	}
 	if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
 		int a = field->logical_minimum;
 		int b = field->logical_maximum;
 		input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
 	}
 	if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
 		dbg_hid("Maximum Effects - %d\n",value);
 		return;
 	}
 	if (usage->hid == (HID_UP_PID | 0x7fUL)) {
 		dbg_hid("PID Pool Report\n");
 		return;
 	}
 	if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
 		return;
 	if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
 			(usage->code == ABS_VOLUME)) {
 		int count = abs(value);
 		int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
 		int i;
 		for (i = 0; i < count; i++) {
 			input_event(input, EV_KEY, direction, 1);
 			input_sync(input);
 			input_event(input, EV_KEY, direction, 0);
 			input_sync(input);
 		}
 		return;
 	}
 	/*
 	 * Ignore out-of-range values as per HID specification,
 	 * section 5.10 and 6.2.25.
 	 *
 	 * The logical_minimum < logical_maximum check is done so that we
 	 * don't unintentionally discard values sent by devices which
 	 * don't specify logical min and max.
 	 */
 	if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
 	    (field->logical_minimum < field->logical_maximum) &&
 	    (value < field->logical_minimum ||
 	     value > field->logical_maximum)) {
 		dbg_hid("Ignoring out-of-range value %x\n", value);
 		return;
 	}
 	/* report the usage code as scancode if the key status has changed */
 	if (usage->type == EV_KEY && !!test_bit(usage->code, input->key) != value)
 		input_event(input, EV_MSC, MSC_SCAN, usage->hid);
 	input_event(input, usage->type, usage->code, value);
 	if ((field->flags & HID_MAIN_ITEM_RELATIVE) && (usage->type == EV_KEY))
 		input_event(input, usage->type, usage->code, 0);
 }
 void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
 {
 	struct hid_input *hidinput;
 	if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
 		return;
 	list_for_each_entry(hidinput, &hid->inputs, list)
 		input_sync(hidinput->input);
 }
 EXPORT_SYMBOL_GPL(hidinput_report_event);
 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
 {
 	struct hid_report *report;
 	int i, j;
 	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
 		for (i = 0; i < report->maxfield; i++) {
 			*field = report->field[i];
 			for (j = 0; j < (*field)->maxusage; j++)
 				if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
 					return j;
 		}
 	}
 	return -1;
 }
 EXPORT_SYMBOL_GPL(hidinput_find_field);
 struct hid_field *hidinput_get_led_field(struct hid_device *hid)
 {
 	struct hid_report *report;
 	struct hid_field *field;
 	int i, j;
 	list_for_each_entry(report,
 			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
 			    list) {
 		for (i = 0; i < report->maxfield; i++) {
 			field = report->field[i];
 			for (j = 0; j < field->maxusage; j++)
 				if (field->usage[j].type == EV_LED)
 					return field;
 		}
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(hidinput_get_led_field);
 unsigned int hidinput_count_leds(struct hid_device *hid)
 {
 	struct hid_report *report;
 	struct hid_field *field;
 	int i, j;
 	unsigned int count = 0;
 	list_for_each_entry(report,
 			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
 			    list) {
 		for (i = 0; i < report->maxfield; i++) {
 			field = report->field[i];
 			for (j = 0; j < field->maxusage; j++)
 				if (field->usage[j].type == EV_LED &&
 				    field->value[j])
 					count += 1;
 		}
 	}
 	return count;
 }
 EXPORT_SYMBOL_GPL(hidinput_count_leds);
 static void hidinput_led_worker(struct work_struct *work)
 {
 	struct hid_device *hid = container_of(work, struct hid_device,
 					      led_work);
 	struct hid_field *field;
 	struct hid_report *report;
 	int len, ret;
 	__u8 *buf;
 	field = hidinput_get_led_field(hid);
 	if (!field)
 		return;
 	/*
 	 * field->report is accessed unlocked regarding HID core. So there might
 	 * be another incoming SET-LED request from user-space, which changes
 	 * the LED state while we assemble our outgoing buffer. However, this
 	 * doesn't matter as hid_output_report() correctly converts it into a
 	 * boolean value no matter what information is currently set on the LED
 	 * field (even garbage). So the remote device will always get a valid
 	 * request.
 	 * And in case we send a wrong value, a next led worker is spawned
 	 * for every SET-LED request so the following worker will send the
 	 * correct value, guaranteed!
 	 */
 	report = field->report;
 	/* use custom SET_REPORT request if possible (asynchronous) */
 	if (hid->ll_driver->request)
 		return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
 	/* fall back to generic raw-output-report */
 	len = hid_report_len(report);
 	buf = hid_alloc_report_buf(report, GFP_KERNEL);
 	if (!buf)
 		return;
 	hid_output_report(report, buf);
 	/* synchronous output report */
 	ret = hid_hw_output_report(hid, buf, len);
 	if (ret == -ENOSYS)
 		hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
 				HID_REQ_SET_REPORT);
 	kfree(buf);
 }
 static int hidinput_input_event(struct input_dev *dev, unsigned int type,
 				unsigned int code, int value)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	struct hid_field *field;
 	int offset;
 	if (type == EV_FF)
 		return input_ff_event(dev, type, code, value);
 	if (type != EV_LED)
 		return -1;
 	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
 		hid_warn(dev, "event field not found\n");
 		return -1;
 	}
 	hid_set_field(field, offset, value);
 	schedule_work(&hid->led_work);
 	return 0;
 }
 static int hidinput_open(struct input_dev *dev)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	return hid_hw_open(hid);
 }
 static void hidinput_close(struct input_dev *dev)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	hid_hw_close(hid);
 }
 static void report_features(struct hid_device *hid)
 {
 	struct hid_driver *drv = hid->driver;
 	struct hid_report_enum *rep_enum;
 	struct hid_report *rep;
 	int i, j;
 	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
 	list_for_each_entry(rep, &rep_enum->report_list, list)
 		for (i = 0; i < rep->maxfield; i++) {
 			/* Ignore if report count is out of bounds. */
 			if (rep->field[i]->report_count < 1)
 				continue;
 			for (j = 0; j < rep->field[i]->maxusage; j++) {
 				/* Verify if Battery Strength feature is available */
 				hidinput_setup_battery(hid, HID_FEATURE_REPORT, rep->field[i]);
 				if (drv->feature_mapping)
 					drv->feature_mapping(hid, rep->field[i],
 							     rep->field[i]->usage + j);
 			}
 		}
 }
 static struct hid_input *hidinput_allocate(struct hid_device *hid)
 {
 	struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
 	struct input_dev *input_dev = input_allocate_device();
 	if (!hidinput || !input_dev) {
 		kfree(hidinput);
 		input_free_device(input_dev);
 		hid_err(hid, "Out of memory during hid input probe\n");
 		return NULL;
 	}
 	input_set_drvdata(input_dev, hid);
 	input_dev->event = hidinput_input_event;
 	input_dev->open = hidinput_open;
 	input_dev->close = hidinput_close;
 	input_dev->setkeycode = hidinput_setkeycode;
 	input_dev->getkeycode = hidinput_getkeycode;
 	input_dev->name = hid->name;
 	input_dev->phys = hid->phys;
 	input_dev->uniq = hid->uniq;
 	input_dev->id.bustype = hid->bus;
 	input_dev->id.vendor  = hid->vendor;
 	input_dev->id.product = hid->product;
 	input_dev->id.version = hid->version;
 	input_dev->dev.parent = &hid->dev;
 	hidinput->input = input_dev;
 	list_add_tail(&hidinput->list, &hid->inputs);
 	return hidinput;
 }
 static bool hidinput_has_been_populated(struct hid_input *hidinput)
 {
 	int i;
 	unsigned long r = 0;
 	for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
 		r |= hidinput->input->evbit[i];
 	for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
 		r |= hidinput->input->keybit[i];
 	for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
 		r |= hidinput->input->relbit[i];
 	for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
 		r |= hidinput->input->absbit[i];
 	for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
 		r |= hidinput->input->mscbit[i];
 	for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
 		r |= hidinput->input->ledbit[i];
 	for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
 		r |= hidinput->input->sndbit[i];
 	for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
 		r |= hidinput->input->ffbit[i];
 	for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
 		r |= hidinput->input->swbit[i];
 	return !!r;
 }
 static void hidinput_cleanup_hidinput(struct hid_device *hid,
 		struct hid_input *hidinput)
 {
 	struct hid_report *report;
 	int i, k;
 	list_del(&hidinput->list);
 	input_free_device(hidinput->input);
 	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
 		if (k == HID_OUTPUT_REPORT &&
 			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
 			continue;
 		list_for_each_entry(report, &hid->report_enum[k].report_list,
 				    list) {
 			for (i = 0; i < report->maxfield; i++)
 				if (report->field[i]->hidinput == hidinput)
 					report->field[i]->hidinput = NULL;
 		}
 	}
 	kfree(hidinput);
 }
 /*
  * Register the input device; print a message.
  * Configure the input layer interface
  * Read all reports and initialize the absolute field values.
  */
 int hidinput_connect(struct hid_device *hid, unsigned int force)
 {
 	struct hid_driver *drv = hid->driver;
 	struct hid_report *report;
 	struct hid_input *hidinput = NULL;
 	int i, j, k;
 	INIT_LIST_HEAD(&hid->inputs);
 	INIT_WORK(&hid->led_work, hidinput_led_worker);
 	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)
 			return -1;
 	}
 	report_features(hid);
 	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
 		if (k == HID_OUTPUT_REPORT &&
 			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
 			continue;
 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
 			if (!report->maxfield)
 				continue;
 			if (!hidinput) {
 				hidinput = hidinput_allocate(hid);
 				if (!hidinput)
 					goto out_unwind;
 			}
 			for (i = 0; i < report->maxfield; i++)
 				for (j = 0; j < report->field[i]->maxusage; j++)
 					hidinput_configure_usage(hidinput, report->field[i],
 								 report->field[i]->usage + j);
 			if ((hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) &&
 			    !hidinput_has_been_populated(hidinput))
 				continue;
 			if (hid->quirks & HID_QUIRK_MULTI_INPUT) {
 				/* This will leave hidinput NULL, so that it
 				 * allocates another one if we have more inputs on
 				 * the same interface. Some devices (e.g. Happ's
 				 * UGCI) cram a lot of unrelated inputs into the
 				 * same interface. */
 				hidinput->report = report;
 				if (drv->input_configured)
 					drv->input_configured(hid, hidinput);
 				if (input_register_device(hidinput->input))
 					goto out_cleanup;
 				hidinput = NULL;
 			}
 		}
 	}
 	if (hidinput && (hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) &&
 	    !hidinput_has_been_populated(hidinput)) {
 		/* no need to register an input device not populated */
 		hidinput_cleanup_hidinput(hid, hidinput);
 		hidinput = NULL;
 	}
 	if (list_empty(&hid->inputs)) {
 		hid_err(hid, "No inputs registered, leaving\n");
 		goto out_unwind;
 	}
 	if (hidinput) {
 		if (drv->input_configured)
 			drv->input_configured(hid, hidinput);
 		if (input_register_device(hidinput->input))
 			goto out_cleanup;
 	}
 	return 0;
 out_cleanup:
 	list_del(&hidinput->list);
 	input_free_device(hidinput->input);
 	kfree(hidinput);
 out_unwind:
 	/* unwind the ones we already registered */
 	hidinput_disconnect(hid);
 	return -1;
 }
 EXPORT_SYMBOL_GPL(hidinput_connect);
 void hidinput_disconnect(struct hid_device *hid)
 {
 	struct hid_input *hidinput, *next;
 	hidinput_cleanup_battery(hid);
 	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
 		list_del(&hidinput->list);
 		input_unregister_device(hidinput->input);
 		kfree(hidinput);
 	}
 	/* led_work is spawned by input_dev callbacks, but doesn't access the
 	 * parent input_dev at all. Once all input devices are removed, we
 	 * know that led_work will never get restarted, so we can cancel it
 	 * synchronously and are safe. */
 	cancel_work_sync(&hid->led_work);
 }
 EXPORT_SYMBOL_GPL(hidinput_disconnect);

drivers/hid/hid-kye.c

Diff comments View file @ 28023d2

 /*
  *  HID driver for Kye/Genius devices not fully compliant with HID standard
  *
  *  Copyright (c) 2009 Jiri Kosina
  *  Copyright (c) 2009 Tomas Hanak
  *  Copyright (c) 2012 Nikolai Kondrashov
  */
 /*
  * 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"
 /*
  * See EasyPen i405X description, device and HID report descriptors at
  * http://sf.net/apps/mediawiki/digimend/?title=KYE_EasyPen_i405X
  */
 /* Original EasyPen i405X report descriptor size */
 #define EASYPEN_I405X_RDESC_ORIG_SIZE	476
 /* Fixed EasyPen i405X report descriptor */
 static __u8 easypen_i405x_rdesc_fixed[] = {
 	0x06, 0x00, 0xFF, /*  Usage Page (FF00h),             */
 	0x09, 0x01,       /*  Usage (01h),                    */
 	0xA1, 0x01,       /*  Collection (Application),       */
 	0x85, 0x05,       /*    Report ID (5),                */
 	0x09, 0x01,       /*    Usage (01h),                  */
 	0x15, 0x80,       /*    Logical Minimum (-128),       */
 	0x25, 0x7F,       /*    Logical Maximum (127),        */
 	0x75, 0x08,       /*    Report Size (8),              */
 	0x95, 0x07,       /*    Report Count (7),             */
 	0xB1, 0x02,       /*    Feature (Variable),           */
 	0xC0,             /*  End Collection,                 */
 	0x05, 0x0D,       /*  Usage Page (Digitizer),         */
 	0x09, 0x02,       /*  Usage (Pen),                    */
 	0xA1, 0x01,       /*  Collection (Application),       */
 	0x85, 0x10,       /*    Report ID (16),               */
 	0x09, 0x20,       /*    Usage (Stylus),               */
 	0xA0,             /*    Collection (Physical),        */
 	0x14,             /*      Logical Minimum (0),        */
 	0x25, 0x01,       /*      Logical Maximum (1),        */
 	0x75, 0x01,       /*      Report Size (1),            */
 	0x09, 0x42,       /*      Usage (Tip Switch),         */
 	0x09, 0x44,       /*      Usage (Barrel Switch),      */
 	0x09, 0x46,       /*      Usage (Tablet Pick),        */
 	0x95, 0x03,       /*      Report Count (3),           */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x95, 0x04,       /*      Report Count (4),           */
 	0x81, 0x03,       /*      Input (Constant, Variable), */
 	0x09, 0x32,       /*      Usage (In Range),           */
 	0x95, 0x01,       /*      Report Count (1),           */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x75, 0x10,       /*      Report Size (16),           */
 	0x95, 0x01,       /*      Report Count (1),           */
 	0xA4,             /*      Push,                       */
 	0x05, 0x01,       /*      Usage Page (Desktop),       */
 	0x55, 0xFD,       /*      Unit Exponent (-3),         */
 	0x65, 0x13,       /*      Unit (Inch),                */
 	0x34,             /*      Physical Minimum (0),       */
 	0x09, 0x30,       /*      Usage (X),                  */
 	0x46, 0x7C, 0x15, /*      Physical Maximum (5500),    */
 	0x26, 0x00, 0x37, /*      Logical Maximum (14080),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x09, 0x31,       /*      Usage (Y),                  */
 	0x46, 0xA0, 0x0F, /*      Physical Maximum (4000),    */
 	0x26, 0x00, 0x28, /*      Logical Maximum (10240),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0xB4,             /*      Pop,                        */
 	0x09, 0x30,       /*      Usage (Tip Pressure),       */
 	0x26, 0xFF, 0x03, /*      Logical Maximum (1023),     */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0xC0,             /*    End Collection,               */
 	0xC0              /*  End Collection                  */
 };
 /*
  * See MousePen i608X description, device and HID report descriptors at
  * http://sf.net/apps/mediawiki/digimend/?title=KYE_MousePen_i608X
  */
 /* Original MousePen i608X report descriptor size */
 #define MOUSEPEN_I608X_RDESC_ORIG_SIZE	476
 /* Fixed MousePen i608X report descriptor */
 static __u8 mousepen_i608x_rdesc_fixed[] = {
 	0x06, 0x00, 0xFF, /*  Usage Page (FF00h),             */
 	0x09, 0x01,       /*  Usage (01h),                    */
 	0xA1, 0x01,       /*  Collection (Application),       */
 	0x85, 0x05,       /*    Report ID (5),                */
 	0x09, 0x01,       /*    Usage (01h),                  */
 	0x15, 0x80,       /*    Logical Minimum (-128),       */
 	0x25, 0x7F,       /*    Logical Maximum (127),        */
 	0x75, 0x08,       /*    Report Size (8),              */
 	0x95, 0x07,       /*    Report Count (7),             */
 	0xB1, 0x02,       /*    Feature (Variable),           */
 	0xC0,             /*  End Collection,                 */
 	0x05, 0x0D,       /*  Usage Page (Digitizer),         */
 	0x09, 0x02,       /*  Usage (Pen),                    */
 	0xA1, 0x01,       /*  Collection (Application),       */
 	0x85, 0x10,       /*    Report ID (16),               */
 	0x09, 0x20,       /*    Usage (Stylus),               */
 	0xA0,             /*    Collection (Physical),        */
 	0x14,             /*      Logical Minimum (0),        */
 	0x25, 0x01,       /*      Logical Maximum (1),        */
 	0x75, 0x01,       /*      Report Size (1),            */
 	0x09, 0x42,       /*      Usage (Tip Switch),         */
 	0x09, 0x44,       /*      Usage (Barrel Switch),      */
 	0x09, 0x46,       /*      Usage (Tablet Pick),        */
 	0x95, 0x03,       /*      Report Count (3),           */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x95, 0x04,       /*      Report Count (4),           */
 	0x81, 0x03,       /*      Input (Constant, Variable), */
 	0x09, 0x32,       /*      Usage (In Range),           */
 	0x95, 0x01,       /*      Report Count (1),           */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x75, 0x10,       /*      Report Size (16),           */
 	0x95, 0x01,       /*      Report Count (1),           */
 	0xA4,             /*      Push,                       */
 	0x05, 0x01,       /*      Usage Page (Desktop),       */
 	0x55, 0xFD,       /*      Unit Exponent (-3),         */
 	0x65, 0x13,       /*      Unit (Inch),                */
 	0x34,             /*      Physical Minimum (0),       */
 	0x09, 0x30,       /*      Usage (X),                  */
 	0x46, 0x40, 0x1F, /*      Physical Maximum (8000),    */
 	0x26, 0x00, 0x50, /*      Logical Maximum (20480),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x09, 0x31,       /*      Usage (Y),                  */
 	0x46, 0x70, 0x17, /*      Physical Maximum (6000),    */
 	0x26, 0x00, 0x3C, /*      Logical Maximum (15360),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0xB4,             /*      Pop,                        */
 	0x09, 0x30,       /*      Usage (Tip Pressure),       */
 	0x26, 0xFF, 0x03, /*      Logical Maximum (1023),     */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0xC0,             /*    End Collection,               */
 	0xC0,             /*  End Collection,                 */
 	0x05, 0x01,       /*  Usage Page (Desktop),           */
 	0x09, 0x02,       /*  Usage (Mouse),                  */
 	0xA1, 0x01,       /*  Collection (Application),       */
 	0x85, 0x11,       /*    Report ID (17),               */
 	0x09, 0x01,       /*    Usage (Pointer),              */
 	0xA0,             /*    Collection (Physical),        */
 	0x14,             /*      Logical Minimum (0),        */
 	0xA4,             /*      Push,                       */
 	0x05, 0x09,       /*      Usage Page (Button),        */
 	0x75, 0x01,       /*      Report Size (1),            */
 	0x19, 0x01,       /*      Usage Minimum (01h),        */
 	0x29, 0x03,       /*      Usage Maximum (03h),        */
 	0x25, 0x01,       /*      Logical Maximum (1),        */
 	0x95, 0x03,       /*      Report Count (3),           */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x95, 0x05,       /*      Report Count (5),           */
 	0x81, 0x01,       /*      Input (Constant),           */
 	0xB4,             /*      Pop,                        */
 	0x95, 0x01,       /*      Report Count (1),           */
 	0xA4,             /*      Push,                       */
 	0x55, 0xFD,       /*      Unit Exponent (-3),         */
 	0x65, 0x13,       /*      Unit (Inch),                */
 	0x34,             /*      Physical Minimum (0),       */
 	0x75, 0x10,       /*      Report Size (16),           */
 	0x09, 0x30,       /*      Usage (X),                  */
 	0x46, 0x40, 0x1F, /*      Physical Maximum (8000),    */
 	0x26, 0x00, 0x50, /*      Logical Maximum (20480),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0x09, 0x31,       /*      Usage (Y),                  */
 	0x46, 0x70, 0x17, /*      Physical Maximum (6000),    */
 	0x26, 0x00, 0x3C, /*      Logical Maximum (15360),    */
 	0x81, 0x02,       /*      Input (Variable),           */
 	0xB4,             /*      Pop,                        */
 	0x75, 0x08,       /*      Report Size (8),            */
 	0x09, 0x38,       /*      Usage (Wheel),              */
 	0x15, 0xFF,       /*      Logical Minimum (-1),       */
 	0x25, 0x01,       /*      Logical Maximum (1),        */
 	0x81, 0x06,       /*      Input (Variable, Relative), */
 	0x81, 0x01,       /*      Input (Constant),           */
 	0xC0,             /*    End Collection,               */
 	0xC0              /*  End Collection                  */
 };
 /*
  * See EasyPen M610X description, device and HID report descriptors at
  * http://sf.net/apps/mediawiki/digimend/?title=KYE_EasyPen_M610X
  */
 /* Original EasyPen M610X report descriptor size */
 #define EASYPEN_M610X_RDESC_ORIG_SIZE	476
 /* Fixed EasyPen M610X report descriptor */
 static __u8 easypen_m610x_rdesc_fixed[] = {
 	0x06, 0x00, 0xFF,             /*  Usage Page (FF00h),             */
 	0x09, 0x01,                   /*  Usage (01h),                    */
 	0xA1, 0x01,                   /*  Collection (Application),       */
 	0x85, 0x05,                   /*    Report ID (5),                */
 	0x09, 0x01,                   /*    Usage (01h),                  */
 	0x15, 0x80,                   /*    Logical Minimum (-128),       */
 	0x25, 0x7F,                   /*    Logical Maximum (127),        */
 	0x75, 0x08,                   /*    Report Size (8),              */
 	0x95, 0x07,                   /*    Report Count (7),             */
 	0xB1, 0x02,                   /*    Feature (Variable),           */
 	0xC0,                         /*  End Collection,                 */
 	0x05, 0x0D,                   /*  Usage Page (Digitizer),         */
 	0x09, 0x02,                   /*  Usage (Pen),                    */
 	0xA1, 0x01,                   /*  Collection (Application),       */
 	0x85, 0x10,                   /*    Report ID (16),               */
 	0x09, 0x20,                   /*    Usage (Stylus),               */
 	0xA0,                         /*    Collection (Physical),        */
 	0x14,                         /*      Logical Minimum (0),        */
 	0x25, 0x01,                   /*      Logical Maximum (1),        */
 	0x75, 0x01,                   /*      Report Size (1),            */
 	0x09, 0x42,                   /*      Usage (Tip Switch),         */
 	0x09, 0x44,                   /*      Usage (Barrel Switch),      */
 	0x09, 0x46,                   /*      Usage (Tablet Pick),        */
 	0x95, 0x03,                   /*      Report Count (3),           */
 	0x81, 0x02,                   /*      Input (Variable),           */
 	0x95, 0x04,                   /*      Report Count (4),           */
 	0x81, 0x03,                   /*      Input (Constant, Variable), */
 	0x09, 0x32,                   /*      Usage (In Range),           */
 	0x95, 0x01,                   /*      Report Count (1),           */
 	0x81, 0x02,                   /*      Input (Variable),           */
 	0x75, 0x10,                   /*      Report Size (16),           */
 	0x95, 0x01,                   /*      Report Count (1),           */
 	0xA4,                         /*      Push,                       */
 	0x05, 0x01,                   /*      Usage Page (Desktop),       */
 	0x55, 0xFD,                   /*      Unit Exponent (-3),         */
 	0x65, 0x13,                   /*      Unit (Inch),                */
 	0x34,                         /*      Physical Minimum (0),       */
 	0x09, 0x30,                   /*      Usage (X),                  */
 	0x46, 0x10, 0x27,             /*      Physical Maximum (10000),   */
 	0x27, 0x00, 0xA0, 0x00, 0x00, /*      Logical Maximum (40960),    */
 	0x81, 0x02,                   /*      Input (Variable),           */
 	0x09, 0x31,                   /*      Usage (Y),                  */
 	0x46, 0x6A, 0x18,             /*      Physical Maximum (6250),    */
 	0x26, 0x00, 0x64,             /*      Logical Maximum (25600),    */
 	0x81, 0x02,                   /*      Input (Variable),           */
 	0xB4,                         /*      Pop,                        */
 	0x09, 0x30,                   /*      Usage (Tip Pressure),       */
 	0x26, 0xFF, 0x03,             /*      Logical Maximum (1023),     */
 	0x81, 0x02,                   /*      Input (Variable),           */
 	0xC0,                         /*    End Collection,               */
 	0xC0,                         /*  End Collection,                 */
 	0x05, 0x0C,                   /*  Usage Page (Consumer),          */
 	0x09, 0x01,                   /*  Usage (Consumer Control),       */
 	0xA1, 0x01,                   /*  Collection (Application),       */
 	0x85, 0x12,                   /*    Report ID (18),               */
 	0x14,                         /*    Logical Minimum (0),          */
 	0x25, 0x01,                   /*    Logical Maximum (1),          */
 	0x75, 0x01,                   /*    Report Size (1),              */
 	0x95, 0x04,                   /*    Report Count (4),             */
 	0x0A, 0x1A, 0x02,             /*    Usage (AC Undo),              */
 	0x0A, 0x79, 0x02,             /*    Usage (AC Redo Or Repeat),    */
 	0x0A, 0x2D, 0x02,             /*    Usage (AC Zoom In),           */
 	0x0A, 0x2E, 0x02,             /*    Usage (AC Zoom Out),          */
 	0x81, 0x02,                   /*    Input (Variable),             */
 	0x95, 0x01,                   /*    Report Count (1),             */
 	0x75, 0x14,                   /*    Report Size (20),             */
 	0x81, 0x03,                   /*    Input (Constant, Variable),   */
 	0x75, 0x20,                   /*    Report Size (32),             */
 	0x81, 0x03,                   /*    Input (Constant, Variable),   */
 	0xC0                          /*  End Collection                  */
 };
 static __u8 *kye_consumer_control_fixup(struct hid_device *hdev, __u8 *rdesc,
 		unsigned int *rsize, int offset, const char *device_name) {
 	/*
 	 * the fixup that need to be done:
 	 *   - change Usage Maximum in the Comsumer Control
 	 *     (report ID 3) to a reasonable value
 	 */
 	if (*rsize >= offset + 31 &&
 	    /* Usage Page (Consumer Devices) */
 	    rdesc[offset] == 0x05 && rdesc[offset + 1] == 0x0c &&
 	    /* Usage (Consumer Control) */
 	    rdesc[offset + 2] == 0x09 && rdesc[offset + 3] == 0x01 &&
 	    /*   Usage Maximum > 12287 */
 	    rdesc[offset + 10] == 0x2a && rdesc[offset + 12] > 0x2f) {
 		hid_info(hdev, "fixing up %s report descriptor\n", device_name);
 		rdesc[offset + 12] = 0x2f;
 	}
 	return rdesc;
 }
 static __u8 *kye_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 		unsigned int *rsize)
 {
 	switch (hdev->product) {
 	case USB_DEVICE_ID_KYE_ERGO_525V:
 		/* the fixups that need to be done:
 		 *   - change led usage page to button for extra buttons
 		 *   - report size 8 count 1 must be size 1 count 8 for button
 		 *     bitfield
 		 *   - change the button usage range to 4-7 for the extra
 		 *     buttons
 		 */
 		if (*rsize >= 75 &&
 			rdesc[61] == 0x05 && rdesc[62] == 0x08 &&
 			rdesc[63] == 0x19 && rdesc[64] == 0x08 &&
 			rdesc[65] == 0x29 && rdesc[66] == 0x0f &&
 			rdesc[71] == 0x75 && rdesc[72] == 0x08 &&
 			rdesc[73] == 0x95 && rdesc[74] == 0x01) {
 			hid_info(hdev,
 				 "fixing up Kye/Genius Ergo Mouse "
 				 "report descriptor\n");
 			rdesc[62] = 0x09;
 			rdesc[64] = 0x04;
 			rdesc[66] = 0x07;
 			rdesc[72] = 0x01;
 			rdesc[74] = 0x08;
 		}
 		break;
 	case USB_DEVICE_ID_KYE_EASYPEN_I405X:
 		if (*rsize == EASYPEN_I405X_RDESC_ORIG_SIZE) {
 			rdesc = easypen_i405x_rdesc_fixed;
 			*rsize = sizeof(easypen_i405x_rdesc_fixed);
 		}
 		break;
 	case USB_DEVICE_ID_KYE_MOUSEPEN_I608X:
+	case USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2:
 		if (*rsize == MOUSEPEN_I608X_RDESC_ORIG_SIZE) {
 			rdesc = mousepen_i608x_rdesc_fixed;
 			*rsize = sizeof(mousepen_i608x_rdesc_fixed);
 		}
 		break;
 	case USB_DEVICE_ID_KYE_EASYPEN_M610X:
 		if (*rsize == EASYPEN_M610X_RDESC_ORIG_SIZE) {
 			rdesc = easypen_m610x_rdesc_fixed;
 			*rsize = sizeof(easypen_m610x_rdesc_fixed);
 		}
 		break;
 	case USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE:
 		rdesc = kye_consumer_control_fixup(hdev, rdesc, rsize, 104,
 					"Genius Gila Gaming Mouse");
 		break;
 	case USB_DEVICE_ID_GENIUS_GX_IMPERATOR:
 		rdesc = kye_consumer_control_fixup(hdev, rdesc, rsize, 83,
 					"Genius Gx Imperator Keyboard");
 		break;
 	case USB_DEVICE_ID_GENIUS_MANTICORE:
 		rdesc = kye_consumer_control_fixup(hdev, rdesc, rsize, 104,
 					"Genius Manticore Keyboard");
 		break;
 	}
 	return rdesc;
 }
 /**
  * Enable fully-functional tablet mode by setting a special feature report.
  *
  * @hdev:	HID device
  *
  * The specific report ID and data were discovered by sniffing the
  * Windows driver traffic.
  */
 static int kye_tablet_enable(struct hid_device *hdev)
 {
 	struct list_head *list;
 	struct list_head *head;
 	struct hid_report *report;
 	__s32 *value;
 	list = &hdev->report_enum[HID_FEATURE_REPORT].report_list;
 	list_for_each(head, list) {
 		report = list_entry(head, struct hid_report, list);
 		if (report->id == 5)
 			break;
 	}
 	if (head == list) {
 		hid_err(hdev, "tablet-enabling feature report not found\n");
 		return -ENODEV;
 	}
 	if (report->maxfield < 1 || report->field[0]->report_count < 7) {
 		hid_err(hdev, "invalid tablet-enabling feature report\n");
 		return -ENODEV;
 	}
 	value = report->field[0]->value;
 	value[0] = 0x12;
 	value[1] = 0x10;
 	value[2] = 0x11;
 	value[3] = 0x12;
 	value[4] = 0x00;
 	value[5] = 0x00;
 	value[6] = 0x00;
 	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	return 0;
 }
 static int kye_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
 	int ret;
 	ret = hid_parse(hdev);
 	if (ret) {
 		hid_err(hdev, "parse failed\n");
 		goto err;
 	}
 	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (ret) {
 		hid_err(hdev, "hw start failed\n");
 		goto err;
 	}
 	switch (id->product) {
 	case USB_DEVICE_ID_KYE_EASYPEN_I405X:
 	case USB_DEVICE_ID_KYE_MOUSEPEN_I608X:
+	case USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2:
 	case USB_DEVICE_ID_KYE_EASYPEN_M610X:
 		ret = kye_tablet_enable(hdev);
 		if (ret) {
 			hid_err(hdev, "tablet enabling failed\n");
 			goto enabling_err;
 		}
 		break;
 	case USB_DEVICE_ID_GENIUS_MANTICORE:
 		/*
 		 * The manticore keyboard needs to have all the interfaces
 		 * opened at least once to be fully functional.
 		 */
 		if (hid_hw_open(hdev))
 			hid_hw_close(hdev);
 		break;
 	}
 	return 0;
 enabling_err:
 	hid_hw_stop(hdev);
 err:
 	return ret;
 }
 static const struct hid_device_id kye_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_KYE_EASYPEN_I405X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
+				USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_KYE_EASYPEN_M610X) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
 				USB_DEVICE_ID_GENIUS_MANTICORE) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, kye_devices);
 static struct hid_driver kye_driver = {
 	.name = "kye",
 	.id_table = kye_devices,
 	.probe = kye_probe,
 	.report_fixup = kye_report_fixup,
 };
 module_hid_driver(kye_driver);
 MODULE_LICENSE("GPL");

drivers/hid/hid-logitech-dj.c

Diff comments View file @ 28023d2

 /*
  *  HID driver for Logitech Unifying receivers
  *
  *  Copyright (c) 2011 Logitech
  */
 /*
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * 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
  *
  */
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/kfifo.h>
 #include <asm/unaligned.h>
 #include "hid-ids.h"
 #define DJ_MAX_PAIRED_DEVICES			6
 #define DJ_MAX_NUMBER_NOTIFICATIONS		8
 #define DJ_RECEIVER_INDEX			0
 #define DJ_DEVICE_INDEX_MIN			1
 #define DJ_DEVICE_INDEX_MAX			6
 #define DJREPORT_SHORT_LENGTH			15
 #define DJREPORT_LONG_LENGTH			32
 #define REPORT_ID_DJ_SHORT			0x20
 #define REPORT_ID_DJ_LONG			0x21
 #define REPORT_ID_HIDPP_SHORT			0x10
 #define REPORT_ID_HIDPP_LONG			0x11
 #define HIDPP_REPORT_SHORT_LENGTH		7
 #define HIDPP_REPORT_LONG_LENGTH		20
 #define HIDPP_RECEIVER_INDEX			0xff
 #define REPORT_TYPE_RFREPORT_FIRST		0x01
 #define REPORT_TYPE_RFREPORT_LAST		0x1F
 /* Command Switch to DJ mode */
 #define REPORT_TYPE_CMD_SWITCH			0x80
 #define CMD_SWITCH_PARAM_DEVBITFIELD		0x00
 #define CMD_SWITCH_PARAM_TIMEOUT_SECONDS	0x01
 #define TIMEOUT_NO_KEEPALIVE			0x00
 /* Command to Get the list of Paired devices */
 #define REPORT_TYPE_CMD_GET_PAIRED_DEVICES	0x81
 /* Device Paired Notification */
 #define REPORT_TYPE_NOTIF_DEVICE_PAIRED		0x41
 #define SPFUNCTION_MORE_NOTIF_EXPECTED		0x01
 #define SPFUNCTION_DEVICE_LIST_EMPTY		0x02
 #define DEVICE_PAIRED_PARAM_SPFUNCTION		0x00
 #define DEVICE_PAIRED_PARAM_EQUAD_ID_LSB	0x01
 #define DEVICE_PAIRED_PARAM_EQUAD_ID_MSB	0x02
 #define DEVICE_PAIRED_RF_REPORT_TYPE		0x03
 /* Device Un-Paired Notification */
 #define REPORT_TYPE_NOTIF_DEVICE_UNPAIRED	0x40
 /* Connection Status Notification */
 #define REPORT_TYPE_NOTIF_CONNECTION_STATUS	0x42
 #define CONNECTION_STATUS_PARAM_STATUS		0x00
 #define STATUS_LINKLOSS				0x01
 /* Error Notification */
 #define REPORT_TYPE_NOTIF_ERROR			0x7F
 #define NOTIF_ERROR_PARAM_ETYPE			0x00
 #define ETYPE_KEEPALIVE_TIMEOUT			0x01
 /* supported DJ HID && RF report types */
 #define REPORT_TYPE_KEYBOARD			0x01
 #define REPORT_TYPE_MOUSE			0x02
 #define REPORT_TYPE_CONSUMER_CONTROL		0x03
 #define REPORT_TYPE_SYSTEM_CONTROL		0x04
 #define REPORT_TYPE_MEDIA_CENTER		0x08
 #define REPORT_TYPE_LEDS			0x0E
 /* RF Report types bitfield */
 #define STD_KEYBOARD				0x00000002
 #define STD_MOUSE				0x00000004
 #define MULTIMEDIA				0x00000008
 #define POWER_KEYS				0x00000010
 #define MEDIA_CENTER				0x00000100
 #define KBD_LEDS				0x00004000
 struct dj_report {
 	u8 report_id;
 	u8 device_index;
 	u8 report_type;
 	u8 report_params[DJREPORT_SHORT_LENGTH - 3];
 };
 struct dj_receiver_dev {
 	struct hid_device *hdev;
 	struct dj_device *paired_dj_devices[DJ_MAX_PAIRED_DEVICES +
 					    DJ_DEVICE_INDEX_MIN];
 	struct work_struct work;
 	struct kfifo notif_fifo;
 	spinlock_t lock;
 	bool querying_devices;
 };
 struct dj_device {
 	struct hid_device *hdev;
 	struct dj_receiver_dev *dj_receiver_dev;
 	u32 reports_supported;
 	u8 device_index;
 };
 /* Keyboard descriptor (1) */
 static const char kbd_descriptor[] = {
 	0x05, 0x01,		/* USAGE_PAGE (generic Desktop)     */
 	0x09, 0x06,		/* USAGE (Keyboard)         */
 	0xA1, 0x01,		/* COLLECTION (Application)     */
 	0x85, 0x01,		/* REPORT_ID (1)            */
 	0x95, 0x08,		/*   REPORT_COUNT (8)           */
 	0x75, 0x01,		/*   REPORT_SIZE (1)            */
 	0x15, 0x00,		/*   LOGICAL_MINIMUM (0)        */
 	0x25, 0x01,		/*   LOGICAL_MAXIMUM (1)        */
 	0x05, 0x07,		/*   USAGE_PAGE (Keyboard)      */
 	0x19, 0xE0,		/*   USAGE_MINIMUM (Left Control)   */
 	0x29, 0xE7,		/*   USAGE_MAXIMUM (Right GUI)      */
 	0x81, 0x02,		/*   INPUT (Data,Var,Abs)       */
 	0x95, 0x06,		/*   REPORT_COUNT (6)           */
 	0x75, 0x08,		/*   REPORT_SIZE (8)            */
 	0x15, 0x00,		/*   LOGICAL_MINIMUM (0)        */
 	0x26, 0xFF, 0x00,	/*   LOGICAL_MAXIMUM (255)      */
 	0x05, 0x07,		/*   USAGE_PAGE (Keyboard)      */
 	0x19, 0x00,		/*   USAGE_MINIMUM (no event)       */
 	0x2A, 0xFF, 0x00,	/*   USAGE_MAXIMUM (reserved)       */
 	0x81, 0x00,		/*   INPUT (Data,Ary,Abs)       */
 	0x85, 0x0e,		/* REPORT_ID (14)               */
 	0x05, 0x08,		/*   USAGE PAGE (LED page)      */
 	0x95, 0x05,		/*   REPORT COUNT (5)           */
 	0x75, 0x01,		/*   REPORT SIZE (1)            */
 	0x15, 0x00,		/*   LOGICAL_MINIMUM (0)        */
 	0x25, 0x01,		/*   LOGICAL_MAXIMUM (1)        */
 	0x19, 0x01,		/*   USAGE MINIMUM (1)          */
 	0x29, 0x05,		/*   USAGE MAXIMUM (5)          */
 	0x91, 0x02,		/*   OUTPUT (Data, Variable, Absolute)  */
 	0x95, 0x01,		/*   REPORT COUNT (1)           */
 	0x75, 0x03,		/*   REPORT SIZE (3)            */
 	0x91, 0x01,		/*   OUTPUT (Constant)          */
 	0xC0
 };
 /* Mouse descriptor (2)     */
 static const char mse_descriptor[] = {
 	0x05, 0x01,		/*  USAGE_PAGE (Generic Desktop)        */
 	0x09, 0x02,		/*  USAGE (Mouse)                       */
 	0xA1, 0x01,		/*  COLLECTION (Application)            */
 	0x85, 0x02,		/*    REPORT_ID = 2                     */
 	0x09, 0x01,		/*    USAGE (pointer)                   */
 	0xA1, 0x00,		/*    COLLECTION (physical)             */
 	0x05, 0x09,		/*      USAGE_PAGE (buttons)            */
 	0x19, 0x01,		/*      USAGE_MIN (1)                   */
 	0x29, 0x10,		/*      USAGE_MAX (16)                  */
 	0x15, 0x00,		/*      LOGICAL_MIN (0)                 */
 	0x25, 0x01,		/*      LOGICAL_MAX (1)                 */
 	0x95, 0x10,		/*      REPORT_COUNT (16)               */
 	0x75, 0x01,		/*      REPORT_SIZE (1)                 */
 	0x81, 0x02,		/*      INPUT (data var abs)            */
 	0x05, 0x01,		/*      USAGE_PAGE (generic desktop)    */
 	0x16, 0x01, 0xF8,	/*      LOGICAL_MIN (-2047)             */
 	0x26, 0xFF, 0x07,	/*      LOGICAL_MAX (2047)              */
 	0x75, 0x0C,		/*      REPORT_SIZE (12)                */
 	0x95, 0x02,		/*      REPORT_COUNT (2)                */
 	0x09, 0x30,		/*      USAGE (X)                       */
 	0x09, 0x31,		/*      USAGE (Y)                       */
 	0x81, 0x06,		/*      INPUT                           */
 	0x15, 0x81,		/*      LOGICAL_MIN (-127)              */
 	0x25, 0x7F,		/*      LOGICAL_MAX (127)               */
 	0x75, 0x08,		/*      REPORT_SIZE (8)                 */
 	0x95, 0x01,		/*      REPORT_COUNT (1)                */
 	0x09, 0x38,		/*      USAGE (wheel)                   */
 	0x81, 0x06,		/*      INPUT                           */
 	0x05, 0x0C,		/*      USAGE_PAGE(consumer)            */
 	0x0A, 0x38, 0x02,	/*      USAGE(AC Pan)                   */
 	0x95, 0x01,		/*      REPORT_COUNT (1)                */
 	0x81, 0x06,		/*      INPUT                           */
 	0xC0,			/*    END_COLLECTION                    */
 	0xC0,			/*  END_COLLECTION                      */
 };
 /* Consumer Control descriptor (3) */
 static const char consumer_descriptor[] = {
 	0x05, 0x0C,		/* USAGE_PAGE (Consumer Devices)       */
 	0x09, 0x01,		/* USAGE (Consumer Control)            */
 	0xA1, 0x01,		/* COLLECTION (Application)            */
 	0x85, 0x03,		/* REPORT_ID = 3                       */
 	0x75, 0x10,		/* REPORT_SIZE (16)                    */
 	0x95, 0x02,		/* REPORT_COUNT (2)                    */
 	0x15, 0x01,		/* LOGICAL_MIN (1)                     */
 	0x26, 0x8C, 0x02,	/* LOGICAL_MAX (652)                   */
 	0x19, 0x01,		/* USAGE_MIN (1)                       */
 	0x2A, 0x8C, 0x02,	/* USAGE_MAX (652)                     */
 	0x81, 0x00,		/* INPUT (Data Ary Abs)                */
 	0xC0,			/* END_COLLECTION                      */
 };				/*                                     */
 /* System control descriptor (4) */
 static const char syscontrol_descriptor[] = {
 	0x05, 0x01,		/*   USAGE_PAGE (Generic Desktop)      */
 	0x09, 0x80,		/*   USAGE (System Control)            */
 	0xA1, 0x01,		/*   COLLECTION (Application)          */
 	0x85, 0x04,		/*   REPORT_ID = 4                     */
 	0x75, 0x02,		/*   REPORT_SIZE (2)                   */
 	0x95, 0x01,		/*   REPORT_COUNT (1)                  */
 	0x15, 0x01,		/*   LOGICAL_MIN (1)                   */
 	0x25, 0x03,		/*   LOGICAL_MAX (3)                   */
 	0x09, 0x82,		/*   USAGE (System Sleep)              */
 	0x09, 0x81,		/*   USAGE (System Power Down)         */
 	0x09, 0x83,		/*   USAGE (System Wake Up)            */
 	0x81, 0x60,		/*   INPUT (Data Ary Abs NPrf Null)    */
 	0x75, 0x06,		/*   REPORT_SIZE (6)                   */
 	0x81, 0x03,		/*   INPUT (Cnst Var Abs)              */
 	0xC0,			/*   END_COLLECTION                    */
 };
 /* Media descriptor (8) */
 static const char media_descriptor[] = {
 	0x06, 0xbc, 0xff,	/* Usage Page 0xffbc                   */
 	0x09, 0x88,		/* Usage 0x0088                        */
 	0xa1, 0x01,		/* BeginCollection                     */
 	0x85, 0x08,		/*   Report ID 8                       */
 	0x19, 0x01,		/*   Usage Min 0x0001                  */
 	0x29, 0xff,		/*   Usage Max 0x00ff                  */
 	0x15, 0x01,		/*   Logical Min 1                     */
 	0x26, 0xff, 0x00,	/*   Logical Max 255                   */
 	0x75, 0x08,		/*   Report Size 8                     */
 	0x95, 0x01,		/*   Report Count 1                    */
 	0x81, 0x00,		/*   Input                             */
 	0xc0,			/* EndCollection                       */
 };				/*                                     */
 /* HIDPP descriptor */
 static const char hidpp_descriptor[] = {
 	0x06, 0x00, 0xff,	/* Usage Page (Vendor Defined Page 1)  */
 	0x09, 0x01,		/* Usage (Vendor Usage 1)              */
 	0xa1, 0x01,		/* Collection (Application)            */
 	0x85, 0x10,		/*   Report ID (16)                    */
 	0x75, 0x08,		/*   Report Size (8)                   */
 	0x95, 0x06,		/*   Report Count (6)                  */
 	0x15, 0x00,		/*   Logical Minimum (0)               */
 	0x26, 0xff, 0x00,	/*   Logical Maximum (255)             */
 	0x09, 0x01,		/*   Usage (Vendor Usage 1)            */
 	0x81, 0x00,		/*   Input (Data,Arr,Abs)              */
 	0x09, 0x01,		/*   Usage (Vendor Usage 1)            */
 	0x91, 0x00,		/*   Output (Data,Arr,Abs)             */
 	0xc0,			/* End Collection                      */
 	0x06, 0x00, 0xff,	/* Usage Page (Vendor Defined Page 1)  */
 	0x09, 0x02,		/* Usage (Vendor Usage 2)              */
 	0xa1, 0x01,		/* Collection (Application)            */
 	0x85, 0x11,		/*   Report ID (17)                    */
 	0x75, 0x08,		/*   Report Size (8)                   */
 	0x95, 0x13,		/*   Report Count (19)                 */
 	0x15, 0x00,		/*   Logical Minimum (0)               */
 	0x26, 0xff, 0x00,	/*   Logical Maximum (255)             */
 	0x09, 0x02,		/*   Usage (Vendor Usage 2)            */
 	0x81, 0x00,		/*   Input (Data,Arr,Abs)              */
 	0x09, 0x02,		/*   Usage (Vendor Usage 2)            */
 	0x91, 0x00,		/*   Output (Data,Arr,Abs)             */
 	0xc0,			/* End Collection                      */
 	0x06, 0x00, 0xff,	/* Usage Page (Vendor Defined Page 1)  */
 	0x09, 0x04,		/* Usage (Vendor Usage 0x04)           */
 	0xa1, 0x01,		/* Collection (Application)            */
 	0x85, 0x20,		/*   Report ID (32)                    */
 	0x75, 0x08,		/*   Report Size (8)                   */
 	0x95, 0x0e,		/*   Report Count (14)                 */
 	0x15, 0x00,		/*   Logical Minimum (0)               */
 	0x26, 0xff, 0x00,	/*   Logical Maximum (255)             */
 	0x09, 0x41,		/*   Usage (Vendor Usage 0x41)         */
 	0x81, 0x00,		/*   Input (Data,Arr,Abs)              */
 	0x09, 0x41,		/*   Usage (Vendor Usage 0x41)         */
 	0x91, 0x00,		/*   Output (Data,Arr,Abs)             */
 	0x85, 0x21,		/*   Report ID (33)                    */
 	0x95, 0x1f,		/*   Report Count (31)                 */
 	0x15, 0x00,		/*   Logical Minimum (0)               */
 	0x26, 0xff, 0x00,	/*   Logical Maximum (255)             */
 	0x09, 0x42,		/*   Usage (Vendor Usage 0x42)         */
 	0x81, 0x00,		/*   Input (Data,Arr,Abs)              */
 	0x09, 0x42,		/*   Usage (Vendor Usage 0x42)         */
 	0x91, 0x00,		/*   Output (Data,Arr,Abs)             */
 	0xc0,			/* End Collection                      */
 };
 /* Maximum size of all defined hid reports in bytes (including report id) */
 #define MAX_REPORT_SIZE 8
 /* Make sure all descriptors are present here */
 #define MAX_RDESC_SIZE				\
 	(sizeof(kbd_descriptor) +		\
 	 sizeof(mse_descriptor) +		\
 	 sizeof(consumer_descriptor) +		\
 	 sizeof(syscontrol_descriptor) +	\
 	 sizeof(media_descriptor) +	\
 	 sizeof(hidpp_descriptor))
 /* Number of possible hid report types that can be created by this driver.
  *
  * Right now, RF report types have the same report types (or report id's)
  * than the hid report created from those RF reports. In the future
  * this doesnt have to be true.
  *
  * For instance, RF report type 0x01 which has a size of 8 bytes, corresponds
  * to hid report id 0x01, this is standard keyboard. Same thing applies to mice
  * reports and consumer control, etc. If a new RF report is created, it doesn't
  * has to have the same report id as its corresponding hid report, so an
  * translation may have to take place for future report types.
  */
 #define NUMBER_OF_HID_REPORTS 32
 static const u8 hid_reportid_size_map[NUMBER_OF_HID_REPORTS] = {
 	[1] = 8,		/* Standard keyboard */
 	[2] = 8,		/* Standard mouse */
 	[3] = 5,		/* Consumer control */
 	[4] = 2,		/* System control */
 	[8] = 2,		/* Media Center */
 };
 #define LOGITECH_DJ_INTERFACE_NUMBER 0x02
 static struct hid_ll_driver logi_dj_ll_driver;
 static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev);
 static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev,
 						struct dj_report *dj_report)
 {
 	/* Called in delayed work context */
 	struct dj_device *dj_dev;
 	unsigned long flags;
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
 	djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
 	spin_unlock_irqrestore(&djrcv_dev->lock, flags);
 	if (dj_dev != NULL) {
 		hid_destroy_device(dj_dev->hdev);
 		kfree(dj_dev);
 	} else {
 		dev_err(&djrcv_dev->hdev->dev, "%s: can't destroy a NULL device\n",
 			__func__);
 	}
 }
 static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
 					  struct dj_report *dj_report)
 {
 	/* Called in delayed work context */
 	struct hid_device *djrcv_hdev = djrcv_dev->hdev;
 	struct usb_interface *intf = to_usb_interface(djrcv_hdev->dev.parent);
 	struct usb_device *usbdev = interface_to_usbdev(intf);
 	struct hid_device *dj_hiddev;
 	struct dj_device *dj_dev;
 	/* Device index goes from 1 to 6, we need 3 bytes to store the
 	 * semicolon, the index, and a null terminator
 	 */
 	unsigned char tmpstr[3];
 	if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
 	    SPFUNCTION_DEVICE_LIST_EMPTY) {
 		dbg_hid("%s: device list is empty\n", __func__);
 		djrcv_dev->querying_devices = false;
 		return;
 	}
 	if (djrcv_dev->paired_dj_devices[dj_report->device_index]) {
 		/* The device is already known. No need to reallocate it. */
 		dbg_hid("%s: device is already known\n", __func__);
 		return;
 	}
 	dj_hiddev = hid_allocate_device();
 	if (IS_ERR(dj_hiddev)) {
 		dev_err(&djrcv_hdev->dev, "%s: hid_allocate_device failed\n",
 			__func__);
 		return;
 	}
 	dj_hiddev->ll_driver = &logi_dj_ll_driver;
 	dj_hiddev->dev.parent = &djrcv_hdev->dev;
 	dj_hiddev->bus = BUS_USB;
 	dj_hiddev->vendor = le16_to_cpu(usbdev->descriptor.idVendor);
 	dj_hiddev->product =
 		(dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB]
 									<< 8) |
 		dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB];
 	snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
 		"Logitech Unifying Device. Wireless PID:%04x",
 		dj_hiddev->product);
 	dj_hiddev->group = HID_GROUP_LOGITECH_DJ_DEVICE;
 	usb_make_path(usbdev, dj_hiddev->phys, sizeof(dj_hiddev->phys));
 	snprintf(tmpstr, sizeof(tmpstr), ":%d", dj_report->device_index);
 	strlcat(dj_hiddev->phys, tmpstr, sizeof(dj_hiddev->phys));
 	dj_dev = kzalloc(sizeof(struct dj_device), GFP_KERNEL);
 	if (!dj_dev) {
 		dev_err(&djrcv_hdev->dev, "%s: failed allocating dj_device\n",
 			__func__);
 		goto dj_device_allocate_fail;
 	}
 	dj_dev->reports_supported = get_unaligned_le32(
 		dj_report->report_params + DEVICE_PAIRED_RF_REPORT_TYPE);
 	dj_dev->hdev = dj_hiddev;
 	dj_dev->dj_receiver_dev = djrcv_dev;
 	dj_dev->device_index = dj_report->device_index;
 	dj_hiddev->driver_data = dj_dev;
 	djrcv_dev->paired_dj_devices[dj_report->device_index] = dj_dev;
 	if (hid_add_device(dj_hiddev)) {
 		dev_err(&djrcv_hdev->dev, "%s: failed adding dj_device\n",
 			__func__);
 		goto hid_add_device_fail;
 	}
 	return;
 hid_add_device_fail:
 	djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
 	kfree(dj_dev);
 dj_device_allocate_fail:
 	hid_destroy_device(dj_hiddev);
 }
 static void delayedwork_callback(struct work_struct *work)
 {
 	struct dj_receiver_dev *djrcv_dev =
 		container_of(work, struct dj_receiver_dev, work);
 	struct dj_report dj_report;
 	unsigned long flags;
 	int count;
 	int retval;
 	dbg_hid("%s\n", __func__);
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 	count = kfifo_out(&djrcv_dev->notif_fifo, &dj_report,
 				sizeof(struct dj_report));
 	if (count != sizeof(struct dj_report)) {
 		dev_err(&djrcv_dev->hdev->dev, "%s: workitem triggered without "
 			"notifications available\n", __func__);
 		spin_unlock_irqrestore(&djrcv_dev->lock, flags);
 		return;
 	}
 	if (!kfifo_is_empty(&djrcv_dev->notif_fifo)) {
 		if (schedule_work(&djrcv_dev->work) == 0) {
 			dbg_hid("%s: did not schedule the work item, was "
 				"already queued\n", __func__);
 		}
 	}
 	spin_unlock_irqrestore(&djrcv_dev->lock, flags);
 	switch (dj_report.report_type) {
 	case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
 		logi_dj_recv_add_djhid_device(djrcv_dev, &dj_report);
 		break;
 	case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
 		logi_dj_recv_destroy_djhid_device(djrcv_dev, &dj_report);
 		break;
 	default:
 	/* A normal report (i. e. not belonging to a pair/unpair notification)
 	 * arriving here, means that the report arrived but we did not have a
 	 * paired dj_device associated to the report's device_index, this
 	 * means that the original "device paired" notification corresponding
 	 * to this dj_device never arrived to this driver. The reason is that
 	 * hid-core discards all packets coming from a device while probe() is
 	 * executing. */
 	if (!djrcv_dev->paired_dj_devices[dj_report.device_index]) {
 		/* ok, we don't know the device, just re-ask the
 		 * receiver for the list of connected devices. */
 		retval = logi_dj_recv_query_paired_devices(djrcv_dev);
 		if (!retval) {
 			/* everything went fine, so just leave */
 			break;
 		}
 		dev_err(&djrcv_dev->hdev->dev,
 			"%s:logi_dj_recv_query_paired_devices "
 			"error:%d\n", __func__, retval);
 		}
 		dbg_hid("%s: unexpected report type\n", __func__);
 	}
 }
 static void logi_dj_recv_queue_notification(struct dj_receiver_dev *djrcv_dev,
 					   struct dj_report *dj_report)
 {
 	/* We are called from atomic context (tasklet && djrcv->lock held) */
 	kfifo_in(&djrcv_dev->notif_fifo, dj_report, sizeof(struct dj_report));
 	if (schedule_work(&djrcv_dev->work) == 0) {
 		dbg_hid("%s: did not schedule the work item, was already "
 			"queued\n", __func__);
 	}
 }
 static void logi_dj_recv_forward_null_report(struct dj_receiver_dev *djrcv_dev,
 					     struct dj_report *dj_report)
 {
 	/* We are called from atomic context (tasklet && djrcv->lock held) */
 	unsigned int i;
 	u8 reportbuffer[MAX_REPORT_SIZE];
 	struct dj_device *djdev;
 	djdev = djrcv_dev->paired_dj_devices[dj_report->device_index];
 	memset(reportbuffer, 0, sizeof(reportbuffer));
 	for (i = 0; i < NUMBER_OF_HID_REPORTS; i++) {
 		if (djdev->reports_supported & (1 << i)) {
 			reportbuffer[0] = i;
 			if (hid_input_report(djdev->hdev,
 					     HID_INPUT_REPORT,
 					     reportbuffer,
 					     hid_reportid_size_map[i], 1)) {
 				dbg_hid("hid_input_report error sending null "
 					"report\n");
 			}
 		}
 	}
 }
 static void logi_dj_recv_forward_report(struct dj_receiver_dev *djrcv_dev,
 					struct dj_report *dj_report)
 {
 	/* We are called from atomic context (tasklet && djrcv->lock held) */
 	struct dj_device *dj_device;
 	dj_device = djrcv_dev->paired_dj_devices[dj_report->device_index];
 	if ((dj_report->report_type > ARRAY_SIZE(hid_reportid_size_map) - 1) ||
 	    (hid_reportid_size_map[dj_report->report_type] == 0)) {
 		dbg_hid("invalid report type:%x\n", dj_report->report_type);
 		return;
 	}
 	if (hid_input_report(dj_device->hdev,
 			HID_INPUT_REPORT, &dj_report->report_type,
 			hid_reportid_size_map[dj_report->report_type], 1)) {
 		dbg_hid("hid_input_report error\n");
 	}
 }
 static void logi_dj_recv_forward_hidpp(struct dj_device *dj_dev, u8 *data,
 				       int size)
 {
 	/* We are called from atomic context (tasklet && djrcv->lock held) */
 	if (hid_input_report(dj_dev->hdev, HID_INPUT_REPORT, data, size, 1))
 		dbg_hid("hid_input_report error\n");
 }
 static int logi_dj_recv_send_report(struct dj_receiver_dev *djrcv_dev,
 				    struct dj_report *dj_report)
 {
 	struct hid_device *hdev = djrcv_dev->hdev;
 	struct hid_report *report;
 	struct hid_report_enum *output_report_enum;
 	u8 *data = (u8 *)(&dj_report->device_index);
 	unsigned int i;
 	output_report_enum = &hdev->report_enum[HID_OUTPUT_REPORT];
 	report = output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];
 	if (!report) {
 		dev_err(&hdev->dev, "%s: unable to find dj report\n", __func__);
 		return -ENODEV;
 	}
 	for (i = 0; i < DJREPORT_SHORT_LENGTH - 1; i++)
 		report->field[0]->value[i] = data[i];
 	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	return 0;
 }
 static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev)
 {
 	struct dj_report *dj_report;
 	int retval;
 	/* no need to protect djrcv_dev->querying_devices */
 	if (djrcv_dev->querying_devices)
 		return 0;
 	dj_report = kzalloc(sizeof(struct dj_report), GFP_KERNEL);
 	if (!dj_report)
 		return -ENOMEM;
 	dj_report->report_id = REPORT_ID_DJ_SHORT;
 	dj_report->device_index = 0xFF;
 	dj_report->report_type = REPORT_TYPE_CMD_GET_PAIRED_DEVICES;
 	retval = logi_dj_recv_send_report(djrcv_dev, dj_report);
 	kfree(dj_report);
 	return retval;
 }
 static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
 					  unsigned timeout)
 {
 	struct hid_device *hdev = djrcv_dev->hdev;
 	struct dj_report *dj_report;
 	u8 *buf;
 	int retval;
 	dj_report = kzalloc(sizeof(struct dj_report), GFP_KERNEL);
 	if (!dj_report)
 		return -ENOMEM;
 	dj_report->report_id = REPORT_ID_DJ_SHORT;
 	dj_report->device_index = 0xFF;
 	dj_report->report_type = REPORT_TYPE_CMD_SWITCH;
 	dj_report->report_params[CMD_SWITCH_PARAM_DEVBITFIELD] = 0x3F;
 	dj_report->report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] = (u8)timeout;
 	retval = logi_dj_recv_send_report(djrcv_dev, dj_report);
 	/*
 	 * Ugly sleep to work around a USB 3.0 bug when the receiver is still
 	 * processing the "switch-to-dj" command while we send an other command.
 	 * 50 msec should gives enough time to the receiver to be ready.
 	 */
 	msleep(50);
 	/*
 	 * Magical bits to set up hidpp notifications when the dj devices
 	 * are connected/disconnected.
 	 *
 	 * We can reuse dj_report because HIDPP_REPORT_SHORT_LENGTH is smaller
 	 * than DJREPORT_SHORT_LENGTH.
 	 */
 	buf = (u8 *)dj_report;
 	memset(buf, 0, HIDPP_REPORT_SHORT_LENGTH);
 	buf[0] = REPORT_ID_HIDPP_SHORT;
 	buf[1] = 0xFF;
 	buf[2] = 0x80;
 	buf[3] = 0x00;
 	buf[4] = 0x00;
 	buf[5] = 0x09;
 	buf[6] = 0x00;
 	hid_hw_raw_request(hdev, REPORT_ID_HIDPP_SHORT, buf,
 			HIDPP_REPORT_SHORT_LENGTH, HID_OUTPUT_REPORT,
 			HID_REQ_SET_REPORT);
 	kfree(dj_report);
 	return retval;
 }
 static int logi_dj_ll_open(struct hid_device *hid)
 {
 	dbg_hid("%s:%s\n", __func__, hid->phys);
 	return 0;
 }
 static void logi_dj_ll_close(struct hid_device *hid)
 {
 	dbg_hid("%s:%s\n", __func__, hid->phys);
 }
 static u8 unifying_name_query[]  = {0x10, 0xff, 0x83, 0xb5, 0x40, 0x00, 0x00};
 static u8 unifying_name_answer[] = {0x11, 0xff, 0x83, 0xb5};
 static int logi_dj_ll_raw_request(struct hid_device *hid,
 				  unsigned char reportnum, __u8 *buf,
 				  size_t count, unsigned char report_type,
 				  int reqtype)
 {
 	struct dj_device *djdev = hid->driver_data;
 	struct dj_receiver_dev *djrcv_dev = djdev->dj_receiver_dev;
 	u8 *out_buf;
 	int ret;
 	if ((buf[0] == REPORT_ID_HIDPP_SHORT) ||
 	    (buf[0] == REPORT_ID_HIDPP_LONG)) {
 		if (count < 2)
 			return -EINVAL;
 		/* special case where we should not overwrite
 		 * the device_index */
 		if (count == 7 && !memcmp(buf, unifying_name_query,
 					  sizeof(unifying_name_query)))
 			buf[4] |= djdev->device_index - 1;
 		else
 			buf[1] = djdev->device_index;
 		return hid_hw_raw_request(djrcv_dev->hdev, reportnum, buf,
 				count, report_type, reqtype);
 	}
 	if (buf[0] != REPORT_TYPE_LEDS)
 		return -EINVAL;
 	out_buf = kzalloc(DJREPORT_SHORT_LENGTH, GFP_ATOMIC);
 	if (!out_buf)
 		return -ENOMEM;
 	if (count > DJREPORT_SHORT_LENGTH - 2)
 		count = DJREPORT_SHORT_LENGTH - 2;
 	out_buf[0] = REPORT_ID_DJ_SHORT;
 	out_buf[1] = djdev->device_index;
 	memcpy(out_buf + 2, buf, count);
 	ret = hid_hw_raw_request(djrcv_dev->hdev, out_buf[0], out_buf,
 		DJREPORT_SHORT_LENGTH, report_type, reqtype);
 	kfree(out_buf);
 	return ret;
 }
 static void rdcat(char *rdesc, unsigned int *rsize, const char *data, unsigned int size)
 {
 	memcpy(rdesc + *rsize, data, size);
 	*rsize += size;
 }
 static int logi_dj_ll_parse(struct hid_device *hid)
 {
 	struct dj_device *djdev = hid->driver_data;
 	unsigned int rsize = 0;
 	char *rdesc;
 	int retval;
 	dbg_hid("%s\n", __func__);
 	djdev->hdev->version = 0x0111;
 	djdev->hdev->country = 0x00;
 	rdesc = kmalloc(MAX_RDESC_SIZE, GFP_KERNEL);
 	if (!rdesc)
 		return -ENOMEM;
 	if (djdev->reports_supported & STD_KEYBOARD) {
 		dbg_hid("%s: sending a kbd descriptor, reports_supported: %x\n",
 			__func__, djdev->reports_supported);
 		rdcat(rdesc, &rsize, kbd_descriptor, sizeof(kbd_descriptor));
 	}
 	if (djdev->reports_supported & STD_MOUSE) {
 		dbg_hid("%s: sending a mouse descriptor, reports_supported: "
 			"%x\n", __func__, djdev->reports_supported);
 		rdcat(rdesc, &rsize, mse_descriptor, sizeof(mse_descriptor));
 	}
 	if (djdev->reports_supported & MULTIMEDIA) {
 		dbg_hid("%s: sending a multimedia report descriptor: %x\n",
 			__func__, djdev->reports_supported);
 		rdcat(rdesc, &rsize, consumer_descriptor, sizeof(consumer_descriptor));
 	}
 	if (djdev->reports_supported & POWER_KEYS) {
 		dbg_hid("%s: sending a power keys report descriptor: %x\n",
 			__func__, djdev->reports_supported);
 		rdcat(rdesc, &rsize, syscontrol_descriptor, sizeof(syscontrol_descriptor));
 	}
 	if (djdev->reports_supported & MEDIA_CENTER) {
 		dbg_hid("%s: sending a media center report descriptor: %x\n",
 			__func__, djdev->reports_supported);
 		rdcat(rdesc, &rsize, media_descriptor, sizeof(media_descriptor));
 	}
 	if (djdev->reports_supported & KBD_LEDS) {
 		dbg_hid("%s: need to send kbd leds report descriptor: %x\n",
 			__func__, djdev->reports_supported);
 	}
 	rdcat(rdesc, &rsize, hidpp_descriptor, sizeof(hidpp_descriptor));
 	retval = hid_parse_report(hid, rdesc, rsize);
 	kfree(rdesc);
 	return retval;
 }
 static int logi_dj_ll_start(struct hid_device *hid)
 {
 	dbg_hid("%s\n", __func__);
 	return 0;
 }
 static void logi_dj_ll_stop(struct hid_device *hid)
 {
 	dbg_hid("%s\n", __func__);
 }
 static struct hid_ll_driver logi_dj_ll_driver = {
 	.parse = logi_dj_ll_parse,
 	.start = logi_dj_ll_start,
 	.stop = logi_dj_ll_stop,
 	.open = logi_dj_ll_open,
 	.close = logi_dj_ll_close,
 	.raw_request = logi_dj_ll_raw_request,
 };
 static int logi_dj_dj_event(struct hid_device *hdev,
 			     struct hid_report *report, u8 *data,
 			     int size)
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
 	unsigned long flags;
 	/*
 	 * Here we receive all data coming from iface 2, there are 3 cases:
 	 *
 	 * 1) Data is intended for this driver i. e. data contains arrival,
 	 * departure, etc notifications, in which case we queue them for delayed
 	 * processing by the work queue. We return 1 to hid-core as no further
 	 * processing is required from it.
 	 *
 	 * 2) Data informs a connection change, if the change means rf link
 	 * loss, then we must send a null report to the upper layer to discard
 	 * potentially pressed keys that may be repeated forever by the input
 	 * layer. Return 1 to hid-core as no further processing is required.
 	 *
 	 * 3) Data is an actual input event from a paired DJ device in which
 	 * case we forward it to the correct hid device (via hid_input_report()
 	 * ) and return 1 so hid-core does not anything else with it.
 	 */
 	if ((dj_report->device_index < DJ_DEVICE_INDEX_MIN) ||
 	    (dj_report->device_index > DJ_DEVICE_INDEX_MAX)) {
 		/*
 		 * Device index is wrong, bail out.
 		 * This driver can ignore safely the receiver notifications,
 		 * so ignore those reports too.
 		 */
 		if (dj_report->device_index != DJ_RECEIVER_INDEX)
 			dev_err(&hdev->dev, "%s: invalid device index:%d\n",
 				__func__, dj_report->device_index);
 		return false;
 	}
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
 		goto out;
 	}
 	switch (dj_report->report_type) {
 	case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
 		/* pairing notifications are handled above the switch */
 		break;
 	case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
 		break;
 	case REPORT_TYPE_NOTIF_CONNECTION_STATUS:
 		if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
 		}
 		break;
 	default:
 		logi_dj_recv_forward_report(djrcv_dev, dj_report);
 	}
 out:
 	spin_unlock_irqrestore(&djrcv_dev->lock, flags);
 	return true;
 }
 static int logi_dj_hidpp_event(struct hid_device *hdev,
 			     struct hid_report *report, u8 *data,
 			     int size)
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
 	unsigned long flags;
 	u8 device_index = dj_report->device_index;
 	if (device_index == HIDPP_RECEIVER_INDEX) {
 		/* special case were the device wants to know its unifying
 		 * name */
 		if (size == HIDPP_REPORT_LONG_LENGTH &&
 		    !memcmp(data, unifying_name_answer,
 			    sizeof(unifying_name_answer)) &&
 		    ((data[4] & 0xF0) == 0x40))
 			device_index = (data[4] & 0x0F) + 1;
 		else
 			return false;
 	}
 	/*
 	 * Data is from the HID++ collection, in this case, we forward the
 	 * data to the corresponding child dj device and return 0 to hid-core
 	 * so he data also goes to the hidraw device of the receiver. This
 	 * allows a user space application to implement the full HID++ routing
 	 * via the receiver.
 	 */
 	if ((device_index < DJ_DEVICE_INDEX_MIN) ||
 	    (device_index > DJ_DEVICE_INDEX_MAX)) {
 		/*
 		 * Device index is wrong, bail out.
 		 * This driver can ignore safely the receiver notifications,
 		 * so ignore those reports too.
 		 */
 		dev_err(&hdev->dev, "%s: invalid device index:%d\n",
 				__func__, dj_report->device_index);
 		return false;
 	}
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 	if (!djrcv_dev->paired_dj_devices[device_index])
 		/* received an event for an unknown device, bail out */
 		goto out;
 	logi_dj_recv_forward_hidpp(djrcv_dev->paired_dj_devices[device_index],
 				   data, size);
 out:
 	spin_unlock_irqrestore(&djrcv_dev->lock, flags);
 	return false;
 }
 static int logi_dj_raw_event(struct hid_device *hdev,
 			     struct hid_report *report, u8 *data,
 			     int size)
 {
 	dbg_hid("%s, size:%d\n", __func__, size);
 	switch (data[0]) {
 	case REPORT_ID_DJ_SHORT:
+		if (size != DJREPORT_SHORT_LENGTH) {
+			dev_err(&hdev->dev, "DJ report of bad size (%d)", size);
+			return false;
+		}
 		return logi_dj_dj_event(hdev, report, data, size);
 	case REPORT_ID_HIDPP_SHORT:
-		/* intentional fallthrough */
+		if (size != HIDPP_REPORT_SHORT_LENGTH) {
+			dev_err(&hdev->dev,
+				"Short HID++ report of bad size (%d)", size);
+			return false;
+		}
+		return logi_dj_hidpp_event(hdev, report, data, size);
 	case REPORT_ID_HIDPP_LONG:
+		if (size != HIDPP_REPORT_LONG_LENGTH) {
+			dev_err(&hdev->dev,
+				"Long HID++ report of bad size (%d)", size);
+			return false;
+		}
 		return logi_dj_hidpp_event(hdev, report, data, size);
 	}
 	return false;
 }
 static int logi_dj_probe(struct hid_device *hdev,
 			 const struct hid_device_id *id)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct dj_receiver_dev *djrcv_dev;
 	int retval;
 	dbg_hid("%s called for ifnum %d\n", __func__,
 		intf->cur_altsetting->desc.bInterfaceNumber);
 	/* Ignore interfaces 0 and 1, they will not carry any data, dont create
 	 * any hid_device for them */
 	if (intf->cur_altsetting->desc.bInterfaceNumber !=
 	    LOGITECH_DJ_INTERFACE_NUMBER) {
 		dbg_hid("%s: ignoring ifnum %d\n", __func__,
 			intf->cur_altsetting->desc.bInterfaceNumber);
 		return -ENODEV;
 	}
 	/* Treat interface 2 */
 	djrcv_dev = kzalloc(sizeof(struct dj_receiver_dev), GFP_KERNEL);
 	if (!djrcv_dev) {
 		dev_err(&hdev->dev,
 			"%s:failed allocating dj_receiver_dev\n", __func__);
 		return -ENOMEM;
 	}
 	djrcv_dev->hdev = hdev;
 	INIT_WORK(&djrcv_dev->work, delayedwork_callback);
 	spin_lock_init(&djrcv_dev->lock);
 	if (kfifo_alloc(&djrcv_dev->notif_fifo,
 			DJ_MAX_NUMBER_NOTIFICATIONS * sizeof(struct dj_report),
 			GFP_KERNEL)) {
 		dev_err(&hdev->dev,
 			"%s:failed allocating notif_fifo\n", __func__);
 		kfree(djrcv_dev);
 		return -ENOMEM;
 	}
 	hid_set_drvdata(hdev, djrcv_dev);
 	/* Call  to usbhid to fetch the HID descriptors of interface 2 and
 	 * subsequently call to the hid/hid-core to parse the fetched
 	 * descriptors, this will in turn create the hidraw and hiddev nodes
 	 * for interface 2 of the receiver */
 	retval = hid_parse(hdev);
 	if (retval) {
 		dev_err(&hdev->dev,
 			"%s:parse of interface 2 failed\n", __func__);
 		goto hid_parse_fail;
 	}
 	if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, REPORT_ID_DJ_SHORT,
 				 0, DJREPORT_SHORT_LENGTH - 1)) {
 		retval = -ENODEV;
 		goto hid_parse_fail;
 	}
 	/* Starts the usb device and connects to upper interfaces hiddev and
 	 * hidraw */
 	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (retval) {
 		dev_err(&hdev->dev,
 			"%s:hid_hw_start returned error\n", __func__);
 		goto hid_hw_start_fail;
 	}
 	retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
 	if (retval < 0) {
 		dev_err(&hdev->dev,
 			"%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
 			__func__, retval);
 		goto switch_to_dj_mode_fail;
 	}
 	/* This is enabling the polling urb on the IN endpoint */
 	retval = hid_hw_open(hdev);
 	if (retval < 0) {
 		dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
 			__func__, retval);
 		goto llopen_failed;
 	}
 	/* Allow incoming packets to arrive: */
 	hid_device_io_start(hdev);
 	retval = logi_dj_recv_query_paired_devices(djrcv_dev);
 	if (retval < 0) {
 		dev_err(&hdev->dev, "%s:logi_dj_recv_query_paired_devices "
 			"error:%d\n", __func__, retval);
 		goto logi_dj_recv_query_paired_devices_failed;
 	}
 	return retval;
 logi_dj_recv_query_paired_devices_failed:
 	hid_hw_close(hdev);
 llopen_failed:
 switch_to_dj_mode_fail:
 	hid_hw_stop(hdev);
 hid_hw_start_fail:
 hid_parse_fail:
 	kfifo_free(&djrcv_dev->notif_fifo);
 	kfree(djrcv_dev);
 	hid_set_drvdata(hdev, NULL);
 	return retval;
 }
 #ifdef CONFIG_PM
 static int logi_dj_reset_resume(struct hid_device *hdev)
 {
 	int retval;
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
 	if (retval < 0) {
 		dev_err(&hdev->dev,
 			"%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
 			__func__, retval);
 	}
 	return 0;
 }
 #endif
 static void logi_dj_remove(struct hid_device *hdev)
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_device *dj_dev;
 	int i;
 	dbg_hid("%s\n", __func__);
 	cancel_work_sync(&djrcv_dev->work);
 	hid_hw_close(hdev);
 	hid_hw_stop(hdev);
 	/* I suppose that at this point the only context that can access
 	 * the djrecv_data is this thread as the work item is guaranteed to
 	 * have finished and no more raw_event callbacks should arrive after
 	 * the remove callback was triggered so no locks are put around the
 	 * code below */
 	for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
 		dj_dev = djrcv_dev->paired_dj_devices[i];
 		if (dj_dev != NULL) {
 			hid_destroy_device(dj_dev->hdev);
 			kfree(dj_dev);
 			djrcv_dev->paired_dj_devices[i] = NULL;
 		}
 	}
 	kfifo_free(&djrcv_dev->notif_fifo);
 	kfree(djrcv_dev);
 	hid_set_drvdata(hdev, NULL);
 }
 static const struct hid_device_id logi_dj_receivers[] = {
 	{HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 		USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER)},
 	{HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
 		USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2)},
 	{}
 };
 MODULE_DEVICE_TABLE(hid, logi_dj_receivers);
 static struct hid_driver logi_djreceiver_driver = {
 	.name = "logitech-djreceiver",
 	.id_table = logi_dj_receivers,
 	.probe = logi_dj_probe,
 	.remove = logi_dj_remove,
 	.raw_event = logi_dj_raw_event,
 #ifdef CONFIG_PM
 	.reset_resume = logi_dj_reset_resume,
 #endif
 };
 module_hid_driver(logi_djreceiver_driver);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Logitech");
 MODULE_AUTHOR("Nestor Lopez Casado");
 MODULE_AUTHOR("nlopezcasad@logitech.com");

drivers/hid/hid-logitech-hidpp.c

Diff comments View file @ 28023d2

 /*
  *  HIDPP protocol for Logitech Unifying receivers
  *
  *  Copyright (c) 2011 Logitech (c)
  *  Copyright (c) 2012-2013 Google (c)
  *  Copyright (c) 2013-2014 Red Hat Inc.
  */
 /*
  * 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; version 2 of the License.
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/kfifo.h>
 #include <linux/input/mt.h>
 #include <asm/unaligned.h>
 #include "hid-ids.h"
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
 MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
 #define REPORT_ID_HIDPP_SHORT			0x10
 #define REPORT_ID_HIDPP_LONG			0x11
 #define HIDPP_REPORT_SHORT_LENGTH		7
 #define HIDPP_REPORT_LONG_LENGTH		20
 #define HIDPP_QUIRK_CLASS_WTP			BIT(0)
 /* bits 1..20 are reserved for classes */
 #define HIDPP_QUIRK_DELAYED_INIT		BIT(21)
 #define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS	BIT(22)
 #define HIDPP_QUIRK_MULTI_INPUT			BIT(23)
 /*
  * There are two hidpp protocols in use, the first version hidpp10 is known
  * as register access protocol or RAP, the second version hidpp20 is known as
  * feature access protocol or FAP
  *
  * Most older devices (including the Unifying usb receiver) use the RAP protocol
  * where as most newer devices use the FAP protocol. Both protocols are
  * compatible with the underlying transport, which could be usb, Unifiying, or
  * bluetooth. The message lengths are defined by the hid vendor specific report
  * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and
  * the HIDPP_LONG report type (total message length 20 bytes)
  *
  * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG
  * messages. The Unifying receiver itself responds to RAP messages (device index
  * is 0xFF for the receiver), and all messages (short or long) with a device
  * index between 1 and 6 are passed untouched to the corresponding paired
  * Unifying device.
  *
  * The paired device can be RAP or FAP, it will receive the message untouched
  * from the Unifiying receiver.
  */
 struct fap {
 	u8 feature_index;
 	u8 funcindex_clientid;
 	u8 params[HIDPP_REPORT_LONG_LENGTH - 4U];
 };
 struct rap {
 	u8 sub_id;
 	u8 reg_address;
 	u8 params[HIDPP_REPORT_LONG_LENGTH - 4U];
 };
 struct hidpp_report {
 	u8 report_id;
 	u8 device_index;
 	union {
 		struct fap fap;
 		struct rap rap;
 		u8 rawbytes[sizeof(struct fap)];
 	};
 } __packed;
 struct hidpp_device {
 	struct hid_device *hid_dev;
 	struct mutex send_mutex;
 	void *send_receive_buf;
 	wait_queue_head_t wait;
 	bool answer_available;
 	u8 protocol_major;
 	u8 protocol_minor;
 	void *private_data;
 	struct work_struct work;
 	struct kfifo delayed_work_fifo;
 	atomic_t connected;
 	struct input_dev *delayed_input;
 	unsigned long quirks;
 };
 #define HIDPP_ERROR				0x8f
 #define HIDPP_ERROR_SUCCESS			0x00
 #define HIDPP_ERROR_INVALID_SUBID		0x01
 #define HIDPP_ERROR_INVALID_ADRESS		0x02
 #define HIDPP_ERROR_INVALID_VALUE		0x03
 #define HIDPP_ERROR_CONNECT_FAIL		0x04
 #define HIDPP_ERROR_TOO_MANY_DEVICES		0x05
 #define HIDPP_ERROR_ALREADY_EXISTS		0x06
 #define HIDPP_ERROR_BUSY			0x07
 #define HIDPP_ERROR_UNKNOWN_DEVICE		0x08
 #define HIDPP_ERROR_RESOURCE_ERROR		0x09
 #define HIDPP_ERROR_REQUEST_UNAVAILABLE		0x0a
 #define HIDPP_ERROR_INVALID_PARAM_VALUE		0x0b
 #define HIDPP_ERROR_WRONG_PIN_CODE		0x0c
 static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
 static int __hidpp_send_report(struct hid_device *hdev,
 				struct hidpp_report *hidpp_report)
 {
 	int fields_count, ret;
 	switch (hidpp_report->report_id) {
 	case REPORT_ID_HIDPP_SHORT:
 		fields_count = HIDPP_REPORT_SHORT_LENGTH;
 		break;
 	case REPORT_ID_HIDPP_LONG:
 		fields_count = HIDPP_REPORT_LONG_LENGTH;
 		break;
 	default:
 		return -ENODEV;
 	}
 	/*
 	 * set the device_index as the receiver, it will be overwritten by
 	 * hid_hw_request if needed
 	 */
 	hidpp_report->device_index = 0xff;
 	ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
 		(u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
 		HID_REQ_SET_REPORT);
 	return ret == fields_count ? 0 : -1;
 }
 /**
  * hidpp_send_message_sync() returns 0 in case of success, and something else
  * in case of a failure.
  * - If ' something else' is positive, that means that an error has been raised
  *   by the protocol itself.
  * - If ' something else' is negative, that means that we had a classic error
  *   (-ENOMEM, -EPIPE, etc...)
  */
 static int hidpp_send_message_sync(struct hidpp_device *hidpp,
 	struct hidpp_report *message,
 	struct hidpp_report *response)
 {
 	int ret;
 	mutex_lock(&hidpp->send_mutex);
 	hidpp->send_receive_buf = response;
 	hidpp->answer_available = false;
 	/*
 	 * So that we can later validate the answer when it arrives
 	 * in hidpp_raw_event
 	 */
 	*response = *message;
 	ret = __hidpp_send_report(hidpp->hid_dev, message);
 	if (ret) {
 		dbg_hid("__hidpp_send_report returned err: %d\n", ret);
 		memset(response, 0, sizeof(struct hidpp_report));
 		goto exit;
 	}
 	if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
 				5*HZ)) {
 		dbg_hid("%s:timeout waiting for response\n", __func__);
 		memset(response, 0, sizeof(struct hidpp_report));
 		ret = -ETIMEDOUT;
 	}
 	if (response->report_id == REPORT_ID_HIDPP_SHORT &&
 	    response->fap.feature_index == HIDPP_ERROR) {
 		ret = response->fap.params[1];
 		dbg_hid("__hidpp_send_report got hidpp error %02X\n", ret);
 		goto exit;
 	}
 exit:
 	mutex_unlock(&hidpp->send_mutex);
 	return ret;
 }
 static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
 	u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
 	struct hidpp_report *response)
 {
 	struct hidpp_report *message;
 	int ret;
 	if (param_count > sizeof(message->fap.params))
 		return -EINVAL;
 	message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
 	if (!message)
 		return -ENOMEM;
 	message->report_id = REPORT_ID_HIDPP_LONG;
 	message->fap.feature_index = feat_index;
 	message->fap.funcindex_clientid = funcindex_clientid;
 	memcpy(&message->fap.params, params, param_count);
 	ret = hidpp_send_message_sync(hidpp, message, response);
 	kfree(message);
 	return ret;
 }
 static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
 	u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
 	struct hidpp_report *response)
 {
 	struct hidpp_report *message;
 	int ret;
 	if ((report_id != REPORT_ID_HIDPP_SHORT) &&
 	    (report_id != REPORT_ID_HIDPP_LONG))
 		return -EINVAL;
 	if (param_count > sizeof(message->rap.params))
 		return -EINVAL;
 	message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
 	if (!message)
 		return -ENOMEM;
 	message->report_id = report_id;
 	message->rap.sub_id = sub_id;
 	message->rap.reg_address = reg_address;
 	memcpy(&message->rap.params, params, param_count);
 	ret = hidpp_send_message_sync(hidpp_dev, message, response);
 	kfree(message);
 	return ret;
 }
 static void delayed_work_cb(struct work_struct *work)
 {
 	struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
 							work);
 	hidpp_connect_event(hidpp);
 }
 static inline bool hidpp_match_answer(struct hidpp_report *question,
 		struct hidpp_report *answer)
 {
 	return (answer->fap.feature_index == question->fap.feature_index) &&
 	   (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
 }
 static inline bool hidpp_match_error(struct hidpp_report *question,
 		struct hidpp_report *answer)
 {
 	return (answer->fap.feature_index == HIDPP_ERROR) &&
 	    (answer->fap.funcindex_clientid == question->fap.feature_index) &&
 	    (answer->fap.params[0] == question->fap.funcindex_clientid);
 }
 static inline bool hidpp_report_is_connect_event(struct hidpp_report *report)
 {
 	return (report->report_id == REPORT_ID_HIDPP_SHORT) &&
 		(report->rap.sub_id == 0x41);
 }
+/**
+ * hidpp_prefix_name() prefixes the current given name with "Logitech ".
+ */
+static void hidpp_prefix_name(char **name, int name_length)
+{
+#define PREFIX_LENGTH 9 /* "Logitech " */
+	int new_length;
+	char *new_name;
+	if (name_length > PREFIX_LENGTH &&
+	    strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
+		/* The prefix has is already in the name */
+		return;
+	new_length = PREFIX_LENGTH + name_length;
+	new_name = kzalloc(new_length, GFP_KERNEL);
+	if (!new_name)
+		return;
+	snprintf(new_name, new_length, "Logitech %s", *name);
+	kfree(*name);
+	*name = new_name;
+}
 /* -------------------------------------------------------------------------- */
 /* HIDP++ 1.0 commands                                                        */
 /* -------------------------------------------------------------------------- */
 #define HIDPP_SET_REGISTER				0x80
 #define HIDPP_GET_REGISTER				0x81
 #define HIDPP_SET_LONG_REGISTER				0x82
 #define HIDPP_GET_LONG_REGISTER				0x83
 #define HIDPP_REG_PAIRING_INFORMATION			0xB5
 #define DEVICE_NAME					0x40
 static char *hidpp_get_unifying_name(struct hidpp_device *hidpp_dev)
 {
 	struct hidpp_report response;
 	int ret;
 	/* hid-logitech-dj is in charge of setting the right device index */
 	u8 params[1] = { DEVICE_NAME };
 	char *name;
 	int len;
 	ret = hidpp_send_rap_command_sync(hidpp_dev,
 					REPORT_ID_HIDPP_SHORT,
 					HIDPP_GET_LONG_REGISTER,
 					HIDPP_REG_PAIRING_INFORMATION,
 					params, 1, &response);
 	if (ret)
 		return NULL;
 	len = response.rap.params[1];
 	if (2 + len > sizeof(response.rap.params))
 		return NULL;
 	name = kzalloc(len + 1, GFP_KERNEL);
 	if (!name)
 		return NULL;
 	memcpy(name, &response.rap.params[2], len);
+	/* include the terminating '\0' */
+	hidpp_prefix_name(&name, len + 1);
 	return name;
 }
 /* -------------------------------------------------------------------------- */
 /* 0x0000: Root                                                               */
 /* -------------------------------------------------------------------------- */
 #define HIDPP_PAGE_ROOT					0x0000
 #define HIDPP_PAGE_ROOT_IDX				0x00
 #define CMD_ROOT_GET_FEATURE				0x01
 #define CMD_ROOT_GET_PROTOCOL_VERSION			0x11
 static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
 	u8 *feature_index, u8 *feature_type)
 {
 	struct hidpp_report response;
 	int ret;
 	u8 params[2] = { feature >> 8, feature & 0x00FF };
 	ret = hidpp_send_fap_command_sync(hidpp,
 			HIDPP_PAGE_ROOT_IDX,
 			CMD_ROOT_GET_FEATURE,
 			params, 2, &response);
 	if (ret)
 		return ret;
 	*feature_index = response.fap.params[0];
 	*feature_type = response.fap.params[1];
 	return ret;
 }
 static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
 {
 	struct hidpp_report response;
 	int ret;
 	ret = hidpp_send_fap_command_sync(hidpp,
 			HIDPP_PAGE_ROOT_IDX,
 			CMD_ROOT_GET_PROTOCOL_VERSION,
 			NULL, 0, &response);
 	if (ret == HIDPP_ERROR_INVALID_SUBID) {
 		hidpp->protocol_major = 1;
 		hidpp->protocol_minor = 0;
 		return 0;
 	}
 	/* the device might not be connected */
 	if (ret == HIDPP_ERROR_RESOURCE_ERROR)
 		return -EIO;
 	if (ret > 0) {
 		hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
 			__func__, ret);
 		return -EPROTO;
 	}
 	if (ret)
 		return ret;
 	hidpp->protocol_major = response.fap.params[0];
 	hidpp->protocol_minor = response.fap.params[1];
 	return ret;
 }
 static bool hidpp_is_connected(struct hidpp_device *hidpp)
 {
 	int ret;
 	ret = hidpp_root_get_protocol_version(hidpp);
 	if (!ret)
 		hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
 			hidpp->protocol_major, hidpp->protocol_minor);
 	return ret == 0;
 }
 /* -------------------------------------------------------------------------- */
 /* 0x0005: GetDeviceNameType                                                  */
 /* -------------------------------------------------------------------------- */
 #define HIDPP_PAGE_GET_DEVICE_NAME_TYPE			0x0005
 #define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT		0x01
 #define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME	0x11
 #define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE		0x21
 static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
 	u8 feature_index, u8 *nameLength)
 {
 	struct hidpp_report response;
 	int ret;
 	ret = hidpp_send_fap_command_sync(hidpp, feature_index,
 		CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
 	if (ret > 0) {
 		hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
 			__func__, ret);
 		return -EPROTO;
 	}
 	if (ret)
 		return ret;
 	*nameLength = response.fap.params[0];
 	return ret;
 }
 static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
 	u8 feature_index, u8 char_index, char *device_name, int len_buf)
 {
 	struct hidpp_report response;
 	int ret, i;
 	int count;
 	ret = hidpp_send_fap_command_sync(hidpp, feature_index,
 		CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
 		&response);
 	if (ret > 0) {
 		hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
 			__func__, ret);
 		return -EPROTO;
 	}
 	if (ret)
 		return ret;
 	if (response.report_id == REPORT_ID_HIDPP_LONG)
 		count = HIDPP_REPORT_LONG_LENGTH - 4;
 	else
 		count = HIDPP_REPORT_SHORT_LENGTH - 4;
 	if (len_buf < count)
 		count = len_buf;
 	for (i = 0; i < count; i++)
 		device_name[i] = response.fap.params[i];
 	return count;
 }
 static char *hidpp_get_device_name(struct hidpp_device *hidpp)
 {
 	u8 feature_type;
 	u8 feature_index;
 	u8 __name_length;
 	char *name;
 	unsigned index = 0;
 	int ret;
 	ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
 		&feature_index, &feature_type);
 	if (ret)
 		return NULL;
 	ret = hidpp_devicenametype_get_count(hidpp, feature_index,
 		&__name_length);
 	if (ret)
 		return NULL;
 	name = kzalloc(__name_length + 1, GFP_KERNEL);
 	if (!name)
 		return NULL;
 	while (index < __name_length) {
 		ret = hidpp_devicenametype_get_device_name(hidpp,
 			feature_index, index, name + index,
 			__name_length - index);
 		if (ret <= 0) {
 			kfree(name);
 			return NULL;
 		}
 		index += ret;
 	}
+	/* include the terminating '\0' */
+	hidpp_prefix_name(&name, __name_length + 1);
 	return name;
 }
 /* -------------------------------------------------------------------------- */
 /* 0x6100: TouchPadRawXY                                                      */
 /* -------------------------------------------------------------------------- */
 #define HIDPP_PAGE_TOUCHPAD_RAW_XY			0x6100
 #define CMD_TOUCHPAD_GET_RAW_INFO			0x01
 #define CMD_TOUCHPAD_SET_RAW_REPORT_STATE		0x21
 #define EVENT_TOUCHPAD_RAW_XY				0x00
 #define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT		0x01
 #define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT		0x03
 struct hidpp_touchpad_raw_info {
 	u16 x_size;
 	u16 y_size;
 	u8 z_range;
 	u8 area_range;
 	u8 timestamp_unit;
 	u8 maxcontacts;
 	u8 origin;
 	u16 res;
 };
 struct hidpp_touchpad_raw_xy_finger {
 	u8 contact_type;
 	u8 contact_status;
 	u16 x;
 	u16 y;
 	u8 z;
 	u8 area;
 	u8 finger_id;
 };
 struct hidpp_touchpad_raw_xy {
 	u16 timestamp;
 	struct hidpp_touchpad_raw_xy_finger fingers[2];
 	u8 spurious_flag;
 	u8 end_of_frame;
 	u8 finger_count;
 	u8 button;
 };
 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
 	u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
 {
 	struct hidpp_report response;
 	int ret;
 	u8 *params = (u8 *)response.fap.params;
 	ret = hidpp_send_fap_command_sync(hidpp, feature_index,
 		CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
 	if (ret > 0) {
 		hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
 			__func__, ret);
 		return -EPROTO;
 	}
 	if (ret)
 		return ret;
 	raw_info->x_size = get_unaligned_be16(&params[0]);
 	raw_info->y_size = get_unaligned_be16(&params[2]);
 	raw_info->z_range = params[4];
 	raw_info->area_range = params[5];
 	raw_info->maxcontacts = params[7];
 	raw_info->origin = params[8];
 	/* res is given in unit per inch */
 	raw_info->res = get_unaligned_be16(&params[13]) * 2 / 51;
 	return ret;
 }
 static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
 		u8 feature_index, bool send_raw_reports,
 		bool sensor_enhanced_settings)
 {
 	struct hidpp_report response;
 	/*
 	 * Params:
 	 *   bit 0 - enable raw
 	 *   bit 1 - 16bit Z, no area
 	 *   bit 2 - enhanced sensitivity
 	 *   bit 3 - width, height (4 bits each) instead of area
 	 *   bit 4 - send raw + gestures (degrades smoothness)
 	 *   remaining bits - reserved
 	 */
 	u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
 	return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
 		CMD_TOUCHPAD_SET_RAW_REPORT_STATE, &params, 1, &response);
 }
 static void hidpp_touchpad_touch_event(u8 *data,
 	struct hidpp_touchpad_raw_xy_finger *finger)
 {
 	u8 x_m = data[0] << 2;
 	u8 y_m = data[2] << 2;
 	finger->x = x_m << 6 | data[1];
 	finger->y = y_m << 6 | data[3];
 	finger->contact_type = data[0] >> 6;
 	finger->contact_status = data[2] >> 6;
 	finger->z = data[4];
 	finger->area = data[5];
 	finger->finger_id = data[6] >> 4;
 }
 static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
 		u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
 {
 	memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
 	raw_xy->end_of_frame = data[8] & 0x01;
 	raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
 	raw_xy->finger_count = data[15] & 0x0f;
 	raw_xy->button = (data[8] >> 2) & 0x01;
 	if (raw_xy->finger_count) {
 		hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
 		hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
 	}
 }
 /* ************************************************************************** */
 /*                                                                            */
 /* Device Support                                                             */
 /*                                                                            */
 /* ************************************************************************** */
 /* -------------------------------------------------------------------------- */
 /* Touchpad HID++ devices                                                     */
 /* -------------------------------------------------------------------------- */
 #define WTP_MANUAL_RESOLUTION				39
 struct wtp_data {
 	struct input_dev *input;
 	u16 x_size, y_size;
 	u8 finger_count;
 	u8 mt_feature_index;
 	u8 button_feature_index;
 	u8 maxcontacts;
 	bool flip_y;
 	unsigned int resolution;
 };
 static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 		struct hid_field *field, struct hid_usage *usage,
 		unsigned long **bit, int *max)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	if ((hidpp->quirks & HIDPP_QUIRK_MULTI_INPUT) &&
 	    (field->application == HID_GD_KEYBOARD))
 		return 0;
 	return -1;
 }
 static void wtp_populate_input(struct hidpp_device *hidpp,
 		struct input_dev *input_dev, bool origin_is_hid_core)
 {
 	struct wtp_data *wd = hidpp->private_data;
 	if ((hidpp->quirks & HIDPP_QUIRK_MULTI_INPUT) && origin_is_hid_core)
 		/* this is the generic hid-input call */
 		return;
 	__set_bit(EV_ABS, input_dev->evbit);
 	__set_bit(EV_KEY, input_dev->evbit);
 	__clear_bit(EV_REL, input_dev->evbit);
 	__clear_bit(EV_LED, input_dev->evbit);
 	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
 	input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
 	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
 	input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
 	/* Max pressure is not given by the devices, pick one */
 	input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
 	input_set_capability(input_dev, EV_KEY, BTN_LEFT);
 	if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
 		input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
 	else
 		__set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
 	input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
 		INPUT_MT_DROP_UNUSED);
 	wd->input = input_dev;
 }
 static void wtp_touch_event(struct wtp_data *wd,
 	struct hidpp_touchpad_raw_xy_finger *touch_report)
 {
 	int slot;
 	if (!touch_report->finger_id || touch_report->contact_type)
 		/* no actual data */
 		return;
 	slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id);
 	input_mt_slot(wd->input, slot);
 	input_mt_report_slot_state(wd->input, MT_TOOL_FINGER,
 					touch_report->contact_status);
 	if (touch_report->contact_status) {
 		input_event(wd->input, EV_ABS, ABS_MT_POSITION_X,
 				touch_report->x);
 		input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y,
 				wd->flip_y ? wd->y_size - touch_report->y :
 					     touch_report->y);
 		input_event(wd->input, EV_ABS, ABS_MT_PRESSURE,
 				touch_report->area);
 	}
 }
 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
 		struct hidpp_touchpad_raw_xy *raw)
 {
 	struct wtp_data *wd = hidpp->private_data;
 	int i;
 	for (i = 0; i < 2; i++)
 		wtp_touch_event(wd, &(raw->fingers[i]));
 	if (raw->end_of_frame &&
 	    !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
 		input_event(wd->input, EV_KEY, BTN_LEFT, raw->button);
 	if (raw->end_of_frame || raw->finger_count <= 2) {
 		input_mt_sync_frame(wd->input);
 		input_sync(wd->input);
 	}
 }
 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
 {
 	struct wtp_data *wd = hidpp->private_data;
 	u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
 		      (data[7] >> 4) * (data[7] >> 4)) / 2;
 	u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
 		      (data[13] >> 4) * (data[13] >> 4)) / 2;
 	struct hidpp_touchpad_raw_xy raw = {
 		.timestamp = data[1],
 		.fingers = {
 			{
 				.contact_type = 0,
 				.contact_status = !!data[7],
 				.x = get_unaligned_le16(&data[3]),
 				.y = get_unaligned_le16(&data[5]),
 				.z = c1_area,
 				.area = c1_area,
 				.finger_id = data[2],
 			}, {
 				.contact_type = 0,
 				.contact_status = !!data[13],
 				.x = get_unaligned_le16(&data[9]),
 				.y = get_unaligned_le16(&data[11]),
 				.z = c2_area,
 				.area = c2_area,
 				.finger_id = data[8],
 			}
 		},
 		.finger_count = wd->maxcontacts,
 		.spurious_flag = 0,
 		.end_of_frame = (data[0] >> 7) == 0,
 		.button = data[0] & 0x01,
 	};
 	wtp_send_raw_xy_event(hidpp, &raw);
 	return 1;
 }
 static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	struct wtp_data *wd = hidpp->private_data;
 	struct hidpp_report *report = (struct hidpp_report *)data;
 	struct hidpp_touchpad_raw_xy raw;
 	if (!wd || !wd->input)
 		return 1;
 	switch (data[0]) {
 	case 0x02:
+		if (size < 2) {
+			hid_err(hdev, "Received HID report of bad size (%d)",
+				size);
+			return 1;
+		}
 		if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
 			input_event(wd->input, EV_KEY, BTN_LEFT,
 					!!(data[1] & 0x01));
 			input_event(wd->input, EV_KEY, BTN_RIGHT,
 					!!(data[1] & 0x02));
 			input_sync(wd->input);
+			return 0;
 		} else {
 			if (size < 21)
 				return 1;
 			return wtp_mouse_raw_xy_event(hidpp, &data[7]);
 		}
 	case REPORT_ID_HIDPP_LONG:
+		/* size is already checked in hidpp_raw_event. */
 		if ((report->fap.feature_index != wd->mt_feature_index) ||
 		    (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
 			return 1;
 		hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
 		wtp_send_raw_xy_event(hidpp, &raw);
 		return 0;
 	}
 	return 0;
 }
 static int wtp_get_config(struct hidpp_device *hidpp)
 {
 	struct wtp_data *wd = hidpp->private_data;
 	struct hidpp_touchpad_raw_info raw_info = {0};
 	u8 feature_type;
 	int ret;
 	ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
 		&wd->mt_feature_index, &feature_type);
 	if (ret)
 		/* means that the device is not powered up */
 		return ret;
 	ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
 		&raw_info);
 	if (ret)
 		return ret;
 	wd->x_size = raw_info.x_size;
 	wd->y_size = raw_info.y_size;
 	wd->maxcontacts = raw_info.maxcontacts;
 	wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
 	wd->resolution = raw_info.res;
 	if (!wd->resolution)
 		wd->resolution = WTP_MANUAL_RESOLUTION;
 	return 0;
 }
 static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	struct wtp_data *wd;
 	wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
 			GFP_KERNEL);
 	if (!wd)
 		return -ENOMEM;
 	hidpp->private_data = wd;
 	return 0;
 };
 static void wtp_connect(struct hid_device *hdev, bool connected)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	struct wtp_data *wd = hidpp->private_data;
 	int ret;
 	if (!connected)
 		return;
 	if (!wd->x_size) {
 		ret = wtp_get_config(hidpp);
 		if (ret) {
 			hid_err(hdev, "Can not get wtp config: %d\n", ret);
 			return;
 		}
 	}
 	hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
 			true, true);
 }
 /* -------------------------------------------------------------------------- */
 /* Generic HID++ devices                                                      */
 /* -------------------------------------------------------------------------- */
 static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 		struct hid_field *field, struct hid_usage *usage,
 		unsigned long **bit, int *max)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
 		return wtp_input_mapping(hdev, hi, field, usage, bit, max);
 	return 0;
 }
 static void hidpp_populate_input(struct hidpp_device *hidpp,
 		struct input_dev *input, bool origin_is_hid_core)
 {
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
 		wtp_populate_input(hidpp, input, origin_is_hid_core);
 }
 static void hidpp_input_configured(struct hid_device *hdev,
 				struct hid_input *hidinput)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	struct input_dev *input = hidinput->input;
 	hidpp_populate_input(hidpp, input, true);
 }
 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
 		int size)
 {
 	struct hidpp_report *question = hidpp->send_receive_buf;
 	struct hidpp_report *answer = hidpp->send_receive_buf;
 	struct hidpp_report *report = (struct hidpp_report *)data;
 	/*
 	 * If the mutex is locked then we have a pending answer from a
 	 * previoulsly sent command
 	 */
 	if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
 		/*
 		 * Check for a correct hidpp20 answer or the corresponding
 		 * error
 		 */
 		if (hidpp_match_answer(question, report) ||
 				hidpp_match_error(question, report)) {
 			*answer = *report;
 			hidpp->answer_available = true;
 			wake_up(&hidpp->wait);
 			/*
 			 * This was an answer to a command that this driver sent
 			 * We return 1 to hid-core to avoid forwarding the
 			 * command upstream as it has been treated by the driver
 			 */
 			return 1;
 		}
 	}
 	if (unlikely(hidpp_report_is_connect_event(report))) {
 		atomic_set(&hidpp->connected,
 				!(report->rap.params[0] & (1 << 6)));
 		if ((hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) &&
 		    (schedule_work(&hidpp->work) == 0))
 			dbg_hid("%s: connect event already queued\n", __func__);
 		return 1;
 	}
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
 		return wtp_raw_event(hidpp->hid_dev, data, size);
 	return 0;
 }
 static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
 		u8 *data, int size)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	switch (data[0]) {
 	case REPORT_ID_HIDPP_LONG:
 		if (size != HIDPP_REPORT_LONG_LENGTH) {
 			hid_err(hdev, "received hid++ report of bad size (%d)",
 				size);
 			return 1;
 		}
 		return hidpp_raw_hidpp_event(hidpp, data, size);
 	case REPORT_ID_HIDPP_SHORT:
 		if (size != HIDPP_REPORT_SHORT_LENGTH) {
 			hid_err(hdev, "received hid++ report of bad size (%d)",
 				size);
 			return 1;
 		}
 		return hidpp_raw_hidpp_event(hidpp, data, size);
 	}
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
 		return wtp_raw_event(hdev, data, size);
 	return 0;
 }
 static void hidpp_overwrite_name(struct hid_device *hdev, bool use_unifying)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	char *name;
 	if (use_unifying)
 		/*
 		 * the device is connected through an Unifying receiver, and
 		 * might not be already connected.
 		 * Ask the receiver for its name.
 		 */
 		name = hidpp_get_unifying_name(hidpp);
 	else
 		name = hidpp_get_device_name(hidpp);
 	if (!name)
 		hid_err(hdev, "unable to retrieve the name of the device");
 	else
 		snprintf(hdev->name, sizeof(hdev->name), "%s", name);
 	kfree(name);
 }
 static int hidpp_input_open(struct input_dev *dev)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	return hid_hw_open(hid);
 }
 static void hidpp_input_close(struct input_dev *dev)
 {
 	struct hid_device *hid = input_get_drvdata(dev);
 	hid_hw_close(hid);
 }
 static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
 {
 	struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
 	if (!input_dev)
 		return NULL;
 	input_set_drvdata(input_dev, hdev);
 	input_dev->open = hidpp_input_open;
 	input_dev->close = hidpp_input_close;
 	input_dev->name = hdev->name;
 	input_dev->phys = hdev->phys;
 	input_dev->uniq = hdev->uniq;
 	input_dev->id.bustype = hdev->bus;
 	input_dev->id.vendor  = hdev->vendor;
 	input_dev->id.product = hdev->product;
 	input_dev->id.version = hdev->version;
 	input_dev->dev.parent = &hdev->dev;
 	return input_dev;
 }
 static void hidpp_connect_event(struct hidpp_device *hidpp)
 {
 	struct hid_device *hdev = hidpp->hid_dev;
 	int ret = 0;
 	bool connected = atomic_read(&hidpp->connected);
 	struct input_dev *input;
 	char *name, *devm_name;
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
 		wtp_connect(hdev, connected);
 	if (!connected || hidpp->delayed_input)
 		return;
 	if (!hidpp->protocol_major) {
 		ret = !hidpp_is_connected(hidpp);
 		if (ret) {
 			hid_err(hdev, "Can not get the protocol version.\n");
 			return;
 		}
 	}
 	/* the device is already connected, we can ask for its name and
 	 * protocol */
 	hid_info(hdev, "HID++ %u.%u device connected.\n",
 		 hidpp->protocol_major, hidpp->protocol_minor);
 	input = hidpp_allocate_input(hdev);
 	if (!input) {
 		hid_err(hdev, "cannot allocate new input device: %d\n", ret);
 		return;
 	}
 	name = hidpp_get_device_name(hidpp);
 	if (!name) {
 		hid_err(hdev, "unable to retrieve the name of the device");
 	} else {
 		devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name);
 		if (devm_name)
 			input->name = devm_name;
 		kfree(name);
 	}
 	hidpp_populate_input(hidpp, input, false);
 	ret = input_register_device(input);
 	if (ret)
 		input_free_device(input);
 	hidpp->delayed_input = input;
 }
 static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
 	struct hidpp_device *hidpp;
 	int ret;
 	bool connected;
 	unsigned int connect_mask = HID_CONNECT_DEFAULT;
 	hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device),
 			GFP_KERNEL);
 	if (!hidpp)
 		return -ENOMEM;
 	hidpp->hid_dev = hdev;
 	hid_set_drvdata(hdev, hidpp);
 	hidpp->quirks = id->driver_data;
 	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
 		ret = wtp_allocate(hdev, id);
 		if (ret)
 			goto wtp_allocate_fail;
 	}
 	INIT_WORK(&hidpp->work, delayed_work_cb);
 	mutex_init(&hidpp->send_mutex);
 	init_waitqueue_head(&hidpp->wait);
 	ret = hid_parse(hdev);
 	if (ret) {
 		hid_err(hdev, "%s:parse failed\n", __func__);
 		goto hid_parse_fail;
 	}
 	/* Allow incoming packets */
 	hid_device_io_start(hdev);
 	connected = hidpp_is_connected(hidpp);
 	if (id->group != HID_GROUP_LOGITECH_DJ_DEVICE) {
 		if (!connected) {
 			hid_err(hdev, "Device not connected");
 			hid_device_io_stop(hdev);
 			goto hid_parse_fail;
 		}
 		hid_info(hdev, "HID++ %u.%u device connected.\n",
 			 hidpp->protocol_major, hidpp->protocol_minor);
 	}
 	hidpp_overwrite_name(hdev, id->group == HID_GROUP_LOGITECH_DJ_DEVICE);
 	atomic_set(&hidpp->connected, connected);
 	if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
 		ret = wtp_get_config(hidpp);
 		if (ret)
 			goto hid_parse_fail;
 	}
 	/* Block incoming packets */
 	hid_device_io_stop(hdev);
 	if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT)
 		connect_mask &= ~HID_CONNECT_HIDINPUT;
 	/* Re-enable hidinput for multi-input devices */
 	if (hidpp->quirks & HIDPP_QUIRK_MULTI_INPUT)
 		connect_mask |= HID_CONNECT_HIDINPUT;
 	ret = hid_hw_start(hdev, connect_mask);
 	if (ret) {
 		hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
 		goto hid_hw_start_fail;
 	}
 	if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) {
 		/* Allow incoming packets */
 		hid_device_io_start(hdev);
 		hidpp_connect_event(hidpp);
 	}
 	return ret;
 hid_hw_start_fail:
 hid_parse_fail:
 	cancel_work_sync(&hidpp->work);
 	mutex_destroy(&hidpp->send_mutex);
 wtp_allocate_fail:
 	hid_set_drvdata(hdev, NULL);
 	return ret;
 }
 static void hidpp_remove(struct hid_device *hdev)
 {
 	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
 	cancel_work_sync(&hidpp->work);
 	mutex_destroy(&hidpp->send_mutex);
 	hid_hw_stop(hdev);
 }
 static const struct hid_device_id hidpp_devices[] = {
 	{ /* wireless touchpad */
 	  HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
 		USB_VENDOR_ID_LOGITECH, 0x4011),
 	  .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
 			 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
 	{ /* wireless touchpad T650 */
 	  HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
 		USB_VENDOR_ID_LOGITECH, 0x4101),
 	  .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
 	{ /* wireless touchpad T651 */
 	  HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
 		USB_DEVICE_ID_LOGITECH_T651),
 	  .driver_data = HIDPP_QUIRK_CLASS_WTP },
 	{ /* Keyboard TK820 */
 	  HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
 		USB_VENDOR_ID_LOGITECH, 0x4102),
 	  .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_MULTI_INPUT |
 			 HIDPP_QUIRK_CLASS_WTP },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
 		USB_VENDOR_ID_LOGITECH, HID_ANY_ID)},
 	{}
 };
 MODULE_DEVICE_TABLE(hid, hidpp_devices);
 static struct hid_driver hidpp_driver = {
 	.name = "logitech-hidpp-device",
 	.id_table = hidpp_devices,
 	.probe = hidpp_probe,
 	.remove = hidpp_remove,
 	.raw_event = hidpp_raw_event,
 	.input_configured = hidpp_input_configured,
 	.input_mapping = hidpp_input_mapping,
 };
 module_hid_driver(hidpp_driver);

drivers/hid/hid-roccat-pyra.c

Diff comments View file @ 28023d2

 /*
  * Roccat Pyra driver for Linux
  *
  * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
  */
 /*
  * 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.
  */
 /*
  * Roccat Pyra is a mobile gamer mouse which comes in wired and wireless
  * variant. Wireless variant is not tested.
  * Userland tools can be found at http://sourceforge.net/projects/roccat
  */
 #include <linux/device.h>
 #include <linux/input.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/hid-roccat.h>
 #include "hid-ids.h"
 #include "hid-roccat-common.h"
 #include "hid-roccat-pyra.h"
 static uint profile_numbers[5] = {0, 1, 2, 3, 4};
 /* pyra_class is used for creating sysfs attributes via roccat char device */
 static struct class *pyra_class;
 static void profile_activated(struct pyra_device *pyra,
 		unsigned int new_profile)
 {
+	if (new_profile >= ARRAY_SIZE(pyra->profile_settings))
+		return;
 	pyra->actual_profile = new_profile;
 	pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi;
 }
 static int pyra_send_control(struct usb_device *usb_dev, int value,
 		enum pyra_control_requests request)
 {
 	struct roccat_common2_control control;
 	if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS ||
 			request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) &&
 			(value < 0 || value > 4))
 		return -EINVAL;
 	control.command = ROCCAT_COMMON_COMMAND_CONTROL;
 	control.value = value;
 	control.request = request;
 	return roccat_common2_send(usb_dev, ROCCAT_COMMON_COMMAND_CONTROL,
 			&control, sizeof(struct roccat_common2_control));
 }
 static int pyra_get_profile_settings(struct usb_device *usb_dev,
 		struct pyra_profile_settings *buf, int number)
 {
 	int retval;
 	retval = pyra_send_control(usb_dev, number,
 			PYRA_CONTROL_REQUEST_PROFILE_SETTINGS);
 	if (retval)
 		return retval;
 	return roccat_common2_receive(usb_dev, PYRA_COMMAND_PROFILE_SETTINGS,
 			buf, PYRA_SIZE_PROFILE_SETTINGS);
 }
 static int pyra_get_settings(struct usb_device *usb_dev,
 		struct pyra_settings *buf)
 {
 	return roccat_common2_receive(usb_dev, PYRA_COMMAND_SETTINGS,
 			buf, PYRA_SIZE_SETTINGS);
 }
 static int pyra_set_settings(struct usb_device *usb_dev,
 		struct pyra_settings const *settings)
 {
 	return roccat_common2_send_with_status(usb_dev,
 			PYRA_COMMAND_SETTINGS, settings,
 			PYRA_SIZE_SETTINGS);
 }
 static ssize_t pyra_sysfs_read(struct file *fp, struct kobject *kobj,
 		char *buf, loff_t off, size_t count,
 		size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off >= real_size)
 		return 0;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&pyra->pyra_lock);
 	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
 	mutex_unlock(&pyra->pyra_lock);
 	if (retval)
 		return retval;
 	return real_size;
 }
 static ssize_t pyra_sysfs_write(struct file *fp, struct kobject *kobj,
 		void const *buf, loff_t off, size_t count,
 		size_t real_size, uint command)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
 	if (off != 0 || count != real_size)
 		return -EINVAL;
 	mutex_lock(&pyra->pyra_lock);
 	retval = roccat_common2_send_with_status(usb_dev, command, (void *)buf, real_size);
 	mutex_unlock(&pyra->pyra_lock);
 	if (retval)
 		return retval;
 	return real_size;
 }
 #define PYRA_SYSFS_W(thingy, THINGY) \
 static ssize_t pyra_sysfs_write_ ## thingy(struct file *fp, \
 		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
 		loff_t off, size_t count) \
 { \
 	return pyra_sysfs_write(fp, kobj, buf, off, count, \
 			PYRA_SIZE_ ## THINGY, PYRA_COMMAND_ ## THINGY); \
 }
 #define PYRA_SYSFS_R(thingy, THINGY) \
 static ssize_t pyra_sysfs_read_ ## thingy(struct file *fp, \
 		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
 		loff_t off, size_t count) \
 { \
 	return pyra_sysfs_read(fp, kobj, buf, off, count, \
 			PYRA_SIZE_ ## THINGY, PYRA_COMMAND_ ## THINGY); \
 }
 #define PYRA_SYSFS_RW(thingy, THINGY) \
 PYRA_SYSFS_W(thingy, THINGY) \
 PYRA_SYSFS_R(thingy, THINGY)
 #define PYRA_BIN_ATTRIBUTE_RW(thingy, THINGY) \
 PYRA_SYSFS_RW(thingy, THINGY); \
 static struct bin_attribute bin_attr_##thingy = { \
 	.attr = { .name = #thingy, .mode = 0660 }, \
 	.size = PYRA_SIZE_ ## THINGY, \
 	.read = pyra_sysfs_read_ ## thingy, \
 	.write = pyra_sysfs_write_ ## thingy \
 }
 #define PYRA_BIN_ATTRIBUTE_R(thingy, THINGY) \
 PYRA_SYSFS_R(thingy, THINGY); \
 static struct bin_attribute bin_attr_##thingy = { \
 	.attr = { .name = #thingy, .mode = 0440 }, \
 	.size = PYRA_SIZE_ ## THINGY, \
 	.read = pyra_sysfs_read_ ## thingy, \
 }
 #define PYRA_BIN_ATTRIBUTE_W(thingy, THINGY) \
 PYRA_SYSFS_W(thingy, THINGY); \
 static struct bin_attribute bin_attr_##thingy = { \
 	.attr = { .name = #thingy, .mode = 0220 }, \
 	.size = PYRA_SIZE_ ## THINGY, \
 	.write = pyra_sysfs_write_ ## thingy \
 }
 PYRA_BIN_ATTRIBUTE_W(control, CONTROL);
 PYRA_BIN_ATTRIBUTE_RW(info, INFO);
 PYRA_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS);
 PYRA_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS);
 static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	ssize_t retval;
 	retval = pyra_send_control(usb_dev, *(uint *)(attr->private),
 			PYRA_CONTROL_REQUEST_PROFILE_SETTINGS);
 	if (retval)
 		return retval;
 	return pyra_sysfs_read(fp, kobj, buf, off, count,
 			PYRA_SIZE_PROFILE_SETTINGS,
 			PYRA_COMMAND_PROFILE_SETTINGS);
 }
 static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	ssize_t retval;
 	retval = pyra_send_control(usb_dev, *(uint *)(attr->private),
 			PYRA_CONTROL_REQUEST_PROFILE_BUTTONS);
 	if (retval)
 		return retval;
 	return pyra_sysfs_read(fp, kobj, buf, off, count,
 			PYRA_SIZE_PROFILE_BUTTONS,
 			PYRA_COMMAND_PROFILE_BUTTONS);
 }
 #define PROFILE_ATTR(number)						\
 static struct bin_attribute bin_attr_profile##number##_settings = {	\
 	.attr = { .name = "profile" #number "_settings", .mode = 0440 },	\
 	.size = PYRA_SIZE_PROFILE_SETTINGS,				\
 	.read = pyra_sysfs_read_profilex_settings,			\
 	.private = &profile_numbers[number-1],				\
 };									\
 static struct bin_attribute bin_attr_profile##number##_buttons = {	\
 	.attr = { .name = "profile" #number "_buttons", .mode = 0440 },	\
 	.size = PYRA_SIZE_PROFILE_BUTTONS,				\
 	.read = pyra_sysfs_read_profilex_buttons,			\
 	.private = &profile_numbers[number-1],				\
 };
 PROFILE_ATTR(1);
 PROFILE_ATTR(2);
 PROFILE_ATTR(3);
 PROFILE_ATTR(4);
 PROFILE_ATTR(5);
 static ssize_t pyra_sysfs_write_settings(struct file *fp,
 		struct kobject *kobj, struct bin_attribute *attr, char *buf,
 		loff_t off, size_t count)
 {
 	struct device *dev =
 			container_of(kobj, struct device, kobj)->parent->parent;
 	struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval = 0;
 	struct pyra_roccat_report roccat_report;
 	struct pyra_settings const *settings;
 	if (off != 0 || count != PYRA_SIZE_SETTINGS)
 		return -EINVAL;
-	mutex_lock(&pyra->pyra_lock);
 	settings = (struct pyra_settings const *)buf;
+	if (settings->startup_profile >= ARRAY_SIZE(pyra->profile_settings))
+		return -EINVAL;
+	mutex_lock(&pyra->pyra_lock);
 	retval = pyra_set_settings(usb_dev, settings);
 	if (retval) {
 		mutex_unlock(&pyra->pyra_lock);
 		return retval;
 	}
 	profile_activated(pyra, settings->startup_profile);
 	roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2;
 	roccat_report.value = settings->startup_profile + 1;
 	roccat_report.key = 0;
 	roccat_report_event(pyra->chrdev_minor,
 			(uint8_t const *)&roccat_report);
 	mutex_unlock(&pyra->pyra_lock);
 	return PYRA_SIZE_SETTINGS;
 }
 PYRA_SYSFS_R(settings, SETTINGS);
 static struct bin_attribute bin_attr_settings =
 	__BIN_ATTR(settings, (S_IWUSR | S_IRUGO),
 		   pyra_sysfs_read_settings, pyra_sysfs_write_settings,
 		   PYRA_SIZE_SETTINGS);
 static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct pyra_device *pyra =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_cpi);
 }
 static DEVICE_ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL);
 static ssize_t pyra_sysfs_show_actual_profile(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct pyra_device *pyra =
 			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	struct pyra_settings settings;
 	mutex_lock(&pyra->pyra_lock);
 	roccat_common2_receive(usb_dev, PYRA_COMMAND_SETTINGS,
 			&settings, PYRA_SIZE_SETTINGS);
 	mutex_unlock(&pyra->pyra_lock);
 	return snprintf(buf, PAGE_SIZE, "%d\n", settings.startup_profile);
 }
 static DEVICE_ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL);
 static DEVICE_ATTR(startup_profile, 0440, pyra_sysfs_show_actual_profile, NULL);
 static ssize_t pyra_sysfs_show_firmware_version(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct pyra_device *pyra;
 	struct usb_device *usb_dev;
 	struct pyra_info info;
 	dev = dev->parent->parent;
 	pyra = hid_get_drvdata(dev_get_drvdata(dev));
 	usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	mutex_lock(&pyra->pyra_lock);
 	roccat_common2_receive(usb_dev, PYRA_COMMAND_INFO,
 			&info, PYRA_SIZE_INFO);
 	mutex_unlock(&pyra->pyra_lock);
 	return snprintf(buf, PAGE_SIZE, "%d\n", info.firmware_version);
 }
 static DEVICE_ATTR(firmware_version, 0440, pyra_sysfs_show_firmware_version,
 		   NULL);
 static struct attribute *pyra_attrs[] = {
 	&dev_attr_actual_cpi.attr,
 	&dev_attr_actual_profile.attr,
 	&dev_attr_firmware_version.attr,
 	&dev_attr_startup_profile.attr,
 	NULL,
 };
 static struct bin_attribute *pyra_bin_attributes[] = {
 	&bin_attr_control,
 	&bin_attr_info,
 	&bin_attr_profile_settings,
 	&bin_attr_profile_buttons,
 	&bin_attr_settings,
 	&bin_attr_profile1_settings,
 	&bin_attr_profile2_settings,
 	&bin_attr_profile3_settings,
 	&bin_attr_profile4_settings,
 	&bin_attr_profile5_settings,
 	&bin_attr_profile1_buttons,
 	&bin_attr_profile2_buttons,
 	&bin_attr_profile3_buttons,
 	&bin_attr_profile4_buttons,
 	&bin_attr_profile5_buttons,
 	NULL,
 };
 static const struct attribute_group pyra_group = {
 	.attrs = pyra_attrs,
 	.bin_attrs = pyra_bin_attributes,
 };
 static const struct attribute_group *pyra_groups[] = {
 	&pyra_group,
 	NULL,
 };
 static int pyra_init_pyra_device_struct(struct usb_device *usb_dev,
 		struct pyra_device *pyra)
 {
 	struct pyra_settings settings;
 	int retval, i;
 	mutex_init(&pyra->pyra_lock);
 	retval = pyra_get_settings(usb_dev, &settings);
 	if (retval)
 		return retval;
 	for (i = 0; i < 5; ++i) {
 		retval = pyra_get_profile_settings(usb_dev,
 				&pyra->profile_settings[i], i);
 		if (retval)
 			return retval;
 	}
 	profile_activated(pyra, settings.startup_profile);
 	return 0;
 }
 static int pyra_init_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct usb_device *usb_dev = interface_to_usbdev(intf);
 	struct pyra_device *pyra;
 	int retval;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_MOUSE) {
 		pyra = kzalloc(sizeof(*pyra), GFP_KERNEL);
 		if (!pyra) {
 			hid_err(hdev, "can't alloc device descriptor\n");
 			return -ENOMEM;
 		}
 		hid_set_drvdata(hdev, pyra);
 		retval = pyra_init_pyra_device_struct(usb_dev, pyra);
 		if (retval) {
 			hid_err(hdev, "couldn't init struct pyra_device\n");
 			goto exit_free;
 		}
 		retval = roccat_connect(pyra_class, hdev,
 				sizeof(struct pyra_roccat_report));
 		if (retval < 0) {
 			hid_err(hdev, "couldn't init char dev\n");
 		} else {
 			pyra->chrdev_minor = retval;
 			pyra->roccat_claimed = 1;
 		}
 	} else {
 		hid_set_drvdata(hdev, NULL);
 	}
 	return 0;
 exit_free:
 	kfree(pyra);
 	return retval;
 }
 static void pyra_remove_specials(struct hid_device *hdev)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct pyra_device *pyra;
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			== USB_INTERFACE_PROTOCOL_MOUSE) {
 		pyra = hid_get_drvdata(hdev);
 		if (pyra->roccat_claimed)
 			roccat_disconnect(pyra->chrdev_minor);
 		kfree(hid_get_drvdata(hdev));
 	}
 }
 static int pyra_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
 	int retval;
 	retval = hid_parse(hdev);
 	if (retval) {
 		hid_err(hdev, "parse failed\n");
 		goto exit;
 	}
 	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (retval) {
 		hid_err(hdev, "hw start failed\n");
 		goto exit;
 	}
 	retval = pyra_init_specials(hdev);
 	if (retval) {
 		hid_err(hdev, "couldn't install mouse\n");
 		goto exit_stop;
 	}
 	return 0;
 exit_stop:
 	hid_hw_stop(hdev);
 exit:
 	return retval;
 }
 static void pyra_remove(struct hid_device *hdev)
 {
 	pyra_remove_specials(hdev);
 	hid_hw_stop(hdev);
 }
 static void pyra_keep_values_up_to_date(struct pyra_device *pyra,
 		u8 const *data)
 {
 	struct pyra_mouse_event_button const *button_event;
 	switch (data[0]) {
 	case PYRA_MOUSE_REPORT_NUMBER_BUTTON:
 		button_event = (struct pyra_mouse_event_button const *)data;
 		switch (button_event->type) {
 		case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:
 			profile_activated(pyra, button_event->data1 - 1);
 			break;
 		case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:
 			pyra->actual_cpi = button_event->data1;
 			break;
 		}
 		break;
 	}
 }
 static void pyra_report_to_chrdev(struct pyra_device const *pyra,
 		u8 const *data)
 {
 	struct pyra_roccat_report roccat_report;
 	struct pyra_mouse_event_button const *button_event;
 	if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON)
 		return;
 	button_event = (struct pyra_mouse_event_button const *)data;
 	switch (button_event->type) {
 	case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2:
 	case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI:
 		roccat_report.type = button_event->type;
 		roccat_report.value = button_event->data1;
 		roccat_report.key = 0;
 		roccat_report_event(pyra->chrdev_minor,
 				(uint8_t const *)&roccat_report);
 		break;
 	case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO:
 	case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT:
 	case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH:
 		if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) {
 			roccat_report.type = button_event->type;
 			roccat_report.key = button_event->data1;
 			/*
 			 * pyra reports profile numbers with range 1-5.
 			 * Keeping this behaviour.
 			 */
 			roccat_report.value = pyra->actual_profile + 1;
 			roccat_report_event(pyra->chrdev_minor,
 					(uint8_t const *)&roccat_report);
 		}
 		break;
 	}
 }
 static int pyra_raw_event(struct hid_device *hdev, struct hid_report *report,
 		u8 *data, int size)
 {
 	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 	struct pyra_device *pyra = hid_get_drvdata(hdev);
 	if (intf->cur_altsetting->desc.bInterfaceProtocol
 			!= USB_INTERFACE_PROTOCOL_MOUSE)
 		return 0;
 	if (pyra == NULL)
 		return 0;
 	pyra_keep_values_up_to_date(pyra, data);
 	if (pyra->roccat_claimed)
 		pyra_report_to_chrdev(pyra, data);
 	return 0;
 }
 static const struct hid_device_id pyra_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT,
 			USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT,
 			USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, pyra_devices);
 static struct hid_driver pyra_driver = {
 		.name = "pyra",
 		.id_table = pyra_devices,
 		.probe = pyra_probe,
 		.remove = pyra_remove,
 		.raw_event = pyra_raw_event
 };
 static int __init pyra_init(void)
 {
 	int retval;
 	/* class name has to be same as driver name */
 	pyra_class = class_create(THIS_MODULE, "pyra");
 	if (IS_ERR(pyra_class))
 		return PTR_ERR(pyra_class);
 	pyra_class->dev_groups = pyra_groups;
 	retval = hid_register_driver(&pyra_driver);
 	if (retval)
 		class_destroy(pyra_class);
 	return retval;
 }
 static void __exit pyra_exit(void)
 {
 	hid_unregister_driver(&pyra_driver);
 	class_destroy(pyra_class);
 }
 module_init(pyra_init);
 module_exit(pyra_exit);
 MODULE_AUTHOR("Stefan Achatz");
 MODULE_DESCRIPTION("USB Roccat Pyra driver");

drivers/hid/i2c-hid/i2c-hid.c

Diff comments View file @ 28023d2

 /*
  * HID over I2C protocol implementation
  *
  * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
  * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
  * Copyright (c) 2012 Red Hat, Inc
  *
  * This code is partly based on "USB HID support for Linux":
  *
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2007-2008 Oliver Neukum
  *  Copyright (c) 2006-2010 Jiri Kosina
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive for
  * more details.
  */
 #include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/device.h>
 #include <linux/wait.h>
 #include <linux/err.h>
 #include <linux/string.h>
 #include <linux/list.h>
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/hid.h>
 #include <linux/mutex.h>
 #include <linux/acpi.h>
 #include <linux/of.h>
 #include <linux/i2c/i2c-hid.h>
 /* flags */
 #define I2C_HID_STARTED		(1 << 0)
 #define I2C_HID_RESET_PENDING	(1 << 1)
 #define I2C_HID_READ_PENDING	(1 << 2)
 #define I2C_HID_PWR_ON		0x00
 #define I2C_HID_PWR_SLEEP	0x01
 /* debug option */
 static bool debug;
 module_param(debug, bool, 0444);
 MODULE_PARM_DESC(debug, "print a lot of debug information");
 #define i2c_hid_dbg(ihid, fmt, arg...)					  \
 do {									  \
 	if (debug)							  \
 		dev_printk(KERN_DEBUG, &(ihid)->client->dev, fmt, ##arg); \
 } while (0)
 struct i2c_hid_desc {
 	__le16 wHIDDescLength;
 	__le16 bcdVersion;
 	__le16 wReportDescLength;
 	__le16 wReportDescRegister;
 	__le16 wInputRegister;
 	__le16 wMaxInputLength;
 	__le16 wOutputRegister;
 	__le16 wMaxOutputLength;
 	__le16 wCommandRegister;
 	__le16 wDataRegister;
 	__le16 wVendorID;
 	__le16 wProductID;
 	__le16 wVersionID;
 	__le32 reserved;
 } __packed;
 struct i2c_hid_cmd {
 	unsigned int registerIndex;
 	__u8 opcode;
 	unsigned int length;
 	bool wait;
 };
 union command {
 	u8 data[0];
 	struct cmd {
 		__le16 reg;
 		__u8 reportTypeID;
 		__u8 opcode;
 	} __packed c;
 };
 #define I2C_HID_CMD(opcode_) \
 	.opcode = opcode_, .length = 4, \
 	.registerIndex = offsetof(struct i2c_hid_desc, wCommandRegister)
 /* fetch HID descriptor */
 static const struct i2c_hid_cmd hid_descr_cmd = { .length = 2 };
 /* fetch report descriptors */
 static const struct i2c_hid_cmd hid_report_descr_cmd = {
 		.registerIndex = offsetof(struct i2c_hid_desc,
 			wReportDescRegister),
 		.opcode = 0x00,
 		.length = 2 };
 /* commands */
 static const struct i2c_hid_cmd hid_reset_cmd =		{ I2C_HID_CMD(0x01),
 							  .wait = true };
 static const struct i2c_hid_cmd hid_get_report_cmd =	{ I2C_HID_CMD(0x02) };
 static const struct i2c_hid_cmd hid_set_report_cmd =	{ I2C_HID_CMD(0x03) };
 static const struct i2c_hid_cmd hid_set_power_cmd =	{ I2C_HID_CMD(0x08) };
 static const struct i2c_hid_cmd hid_no_cmd =		{ .length = 0 };
 /*
  * These definitions are not used here, but are defined by the spec.
  * Keeping them here for documentation purposes.
  *
  * static const struct i2c_hid_cmd hid_get_idle_cmd = { I2C_HID_CMD(0x04) };
  * static const struct i2c_hid_cmd hid_set_idle_cmd = { I2C_HID_CMD(0x05) };
  * static const struct i2c_hid_cmd hid_get_protocol_cmd = { I2C_HID_CMD(0x06) };
  * static const struct i2c_hid_cmd hid_set_protocol_cmd = { I2C_HID_CMD(0x07) };
  */
 static DEFINE_MUTEX(i2c_hid_open_mut);
 /* The main device structure */
 struct i2c_hid {
 	struct i2c_client	*client;	/* i2c client */
 	struct hid_device	*hid;	/* pointer to corresponding HID dev */
 	union {
 		__u8 hdesc_buffer[sizeof(struct i2c_hid_desc)];
 		struct i2c_hid_desc hdesc;	/* the HID Descriptor */
 	};
 	__le16			wHIDDescRegister; /* location of the i2c
 						   * register of the HID
 						   * descriptor. */
 	unsigned int		bufsize;	/* i2c buffer size */
 	char			*inbuf;		/* Input buffer */
 	char			*rawbuf;	/* Raw Input buffer */
 	char			*cmdbuf;	/* Command buffer */
 	char			*argsbuf;	/* Command arguments buffer */
 	unsigned long		flags;		/* device flags */
 	wait_queue_head_t	wait;		/* For waiting the interrupt */
 	struct i2c_hid_platform_data pdata;
 };
 static int __i2c_hid_command(struct i2c_client *client,
 		const struct i2c_hid_cmd *command, u8 reportID,
 		u8 reportType, u8 *args, int args_len,
 		unsigned char *buf_recv, int data_len)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	union command *cmd = (union command *)ihid->cmdbuf;
 	int ret;
 	struct i2c_msg msg[2];
 	int msg_num = 1;
 	int length = command->length;
 	bool wait = command->wait;
 	unsigned int registerIndex = command->registerIndex;
 	/* special case for hid_descr_cmd */
 	if (command == &hid_descr_cmd) {
 		cmd->c.reg = ihid->wHIDDescRegister;
 	} else {
 		cmd->data[0] = ihid->hdesc_buffer[registerIndex];
 		cmd->data[1] = ihid->hdesc_buffer[registerIndex + 1];
 	}
 	if (length > 2) {
 		cmd->c.opcode = command->opcode;
 		cmd->c.reportTypeID = reportID | reportType << 4;
 	}
 	memcpy(cmd->data + length, args, args_len);
 	length += args_len;
 	i2c_hid_dbg(ihid, "%s: cmd=%*ph\n", __func__, length, cmd->data);
 	msg[0].addr = client->addr;
 	msg[0].flags = client->flags & I2C_M_TEN;
 	msg[0].len = length;
 	msg[0].buf = cmd->data;
 	if (data_len > 0) {
 		msg[1].addr = client->addr;
 		msg[1].flags = client->flags & I2C_M_TEN;
 		msg[1].flags |= I2C_M_RD;
 		msg[1].len = data_len;
 		msg[1].buf = buf_recv;
 		msg_num = 2;
 		set_bit(I2C_HID_READ_PENDING, &ihid->flags);
 	}
 	if (wait)
 		set_bit(I2C_HID_RESET_PENDING, &ihid->flags);
 	ret = i2c_transfer(client->adapter, msg, msg_num);
 	if (data_len > 0)
 		clear_bit(I2C_HID_READ_PENDING, &ihid->flags);
 	if (ret != msg_num)
 		return ret < 0 ? ret : -EIO;
 	ret = 0;
 	if (wait) {
 		i2c_hid_dbg(ihid, "%s: waiting...\n", __func__);
 		if (!wait_event_timeout(ihid->wait,
 				!test_bit(I2C_HID_RESET_PENDING, &ihid->flags),
 				msecs_to_jiffies(5000)))
 			ret = -ENODATA;
 		i2c_hid_dbg(ihid, "%s: finished.\n", __func__);
 	}
 	return ret;
 }
 static int i2c_hid_command(struct i2c_client *client,
 		const struct i2c_hid_cmd *command,
 		unsigned char *buf_recv, int data_len)
 {
 	return __i2c_hid_command(client, command, 0, 0, NULL, 0,
 				buf_recv, data_len);
 }
 static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
 		u8 reportID, unsigned char *buf_recv, int data_len)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	u8 args[3];
 	int ret;
 	int args_len = 0;
 	u16 readRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
 	i2c_hid_dbg(ihid, "%s\n", __func__);
 	if (reportID >= 0x0F) {
 		args[args_len++] = reportID;
 		reportID = 0x0F;
 	}
 	args[args_len++] = readRegister & 0xFF;
 	args[args_len++] = readRegister >> 8;
 	ret = __i2c_hid_command(client, &hid_get_report_cmd, reportID,
 		reportType, args, args_len, buf_recv, data_len);
 	if (ret) {
 		dev_err(&client->dev,
 			"failed to retrieve report from device.\n");
 		return ret;
 	}
 	return 0;
 }
 /**
  * i2c_hid_set_or_send_report: forward an incoming report to the device
  * @client: the i2c_client of the device
  * @reportType: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
  * @reportID: the report ID
  * @buf: the actual data to transfer, without the report ID
  * @len: size of buf
  * @use_data: true: use SET_REPORT HID command, false: send plain OUTPUT report
  */
 static int i2c_hid_set_or_send_report(struct i2c_client *client, u8 reportType,
 		u8 reportID, unsigned char *buf, size_t data_len, bool use_data)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	u8 *args = ihid->argsbuf;
 	const struct i2c_hid_cmd *hidcmd;
 	int ret;
 	u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
 	u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
 	u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
 	/* hid_hw_* already checked that data_len < HID_MAX_BUFFER_SIZE */
 	u16 size =	2			/* size */ +
 			(reportID ? 1 : 0)	/* reportID */ +
 			data_len		/* buf */;
 	int args_len =	(reportID >= 0x0F ? 1 : 0) /* optional third byte */ +
 			2			/* dataRegister */ +
 			size			/* args */;
 	int index = 0;
 	i2c_hid_dbg(ihid, "%s\n", __func__);
 	if (!use_data && maxOutputLength == 0)
 		return -ENOSYS;
 	if (reportID >= 0x0F) {
 		args[index++] = reportID;
 		reportID = 0x0F;
 	}
 	/*
 	 * use the data register for feature reports or if the device does not
 	 * support the output register
 	 */
 	if (use_data) {
 		args[index++] = dataRegister & 0xFF;
 		args[index++] = dataRegister >> 8;
 		hidcmd = &hid_set_report_cmd;
 	} else {
 		args[index++] = outputRegister & 0xFF;
 		args[index++] = outputRegister >> 8;
 		hidcmd = &hid_no_cmd;
 	}
 	args[index++] = size & 0xFF;
 	args[index++] = size >> 8;
 	if (reportID)
 		args[index++] = reportID;
 	memcpy(&args[index], buf, data_len);
 	ret = __i2c_hid_command(client, hidcmd, reportID,
 		reportType, args, args_len, NULL, 0);
 	if (ret) {
 		dev_err(&client->dev, "failed to set a report to device.\n");
 		return ret;
 	}
 	return data_len;
 }
 static int i2c_hid_set_power(struct i2c_client *client, int power_state)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	int ret;
 	i2c_hid_dbg(ihid, "%s\n", __func__);
 	ret = __i2c_hid_command(client, &hid_set_power_cmd, power_state,
 		0, NULL, 0, NULL, 0);
 	if (ret)
 		dev_err(&client->dev, "failed to change power setting.\n");
 	return ret;
 }
 static int i2c_hid_hwreset(struct i2c_client *client)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	int ret;
 	i2c_hid_dbg(ihid, "%s\n", __func__);
 	ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
 	if (ret)
 		return ret;
 	i2c_hid_dbg(ihid, "resetting...\n");
 	ret = i2c_hid_command(client, &hid_reset_cmd, NULL, 0);
 	if (ret) {
 		dev_err(&client->dev, "failed to reset device.\n");
 		i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
 		return ret;
 	}
 	return 0;
 }
 static void i2c_hid_get_input(struct i2c_hid *ihid)
 {
 	int ret, ret_size;
 	int size = ihid->bufsize;
 	ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
 	if (ret != size) {
 		if (ret < 0)
 			return;
 		dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n",
 			__func__, ret, size);
 		return;
 	}
 	ret_size = ihid->inbuf[0] | ihid->inbuf[1] << 8;
 	if (!ret_size) {
 		/* host or device initiated RESET completed */
 		if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags))
 			wake_up(&ihid->wait);
 		return;
 	}
 	if (ret_size > size) {
 		dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
 			__func__, size, ret_size);
 		return;
 	}
 	i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);
 	if (test_bit(I2C_HID_STARTED, &ihid->flags))
 		hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2,
 				ret_size - 2, 1);
 	return;
 }
 static irqreturn_t i2c_hid_irq(int irq, void *dev_id)
 {
 	struct i2c_hid *ihid = dev_id;
 	if (test_bit(I2C_HID_READ_PENDING, &ihid->flags))
 		return IRQ_HANDLED;
 	i2c_hid_get_input(ihid);
 	return IRQ_HANDLED;
 }
 static int i2c_hid_get_report_length(struct hid_report *report)
 {
 	return ((report->size - 1) >> 3) + 1 +
 		report->device->report_enum[report->type].numbered + 2;
 }
 static void i2c_hid_init_report(struct hid_report *report, u8 *buffer,
 	size_t bufsize)
 {
 	struct hid_device *hid = report->device;
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	unsigned int size, ret_size;
 	size = i2c_hid_get_report_length(report);
 	if (i2c_hid_get_report(client,
 			report->type == HID_FEATURE_REPORT ? 0x03 : 0x01,
 			report->id, buffer, size))
 		return;
 	i2c_hid_dbg(ihid, "report (len=%d): %*ph\n", size, size, buffer);
 	ret_size = buffer[0] | (buffer[1] << 8);
 	if (ret_size != size) {
 		dev_err(&client->dev, "error in %s size:%d / ret_size:%d\n",
 			__func__, size, ret_size);
 		return;
 	}
 	/* hid->driver_lock is held as we are in probe function,
 	 * we just need to setup the input fields, so using
 	 * hid_report_raw_event is safe. */
 	hid_report_raw_event(hid, report->type, buffer + 2, size - 2, 1);
 }
 /*
  * Initialize all reports
  */
 static void i2c_hid_init_reports(struct hid_device *hid)
 {
 	struct hid_report *report;
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	u8 *inbuf = kzalloc(ihid->bufsize, GFP_KERNEL);
 	if (!inbuf) {
 		dev_err(&client->dev, "can not retrieve initial reports\n");
 		return;
 	}
 	/*
 	 * The device must be powered on while we fetch initial reports
 	 * from it.
 	 */
 	pm_runtime_get_sync(&client->dev);
 	list_for_each_entry(report,
 		&hid->report_enum[HID_FEATURE_REPORT].report_list, list)
 		i2c_hid_init_report(report, inbuf, ihid->bufsize);
 	pm_runtime_put(&client->dev);
 	kfree(inbuf);
 }
 /*
  * Traverse the supplied list of reports and find the longest
  */
 static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
 		unsigned int *max)
 {
 	struct hid_report *report;
 	unsigned int size;
 	/* We should not rely on wMaxInputLength, as some devices may set it to
 	 * a wrong length. */
 	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
 		size = i2c_hid_get_report_length(report);
 		if (*max < size)
 			*max = size;
 	}
 }
 static void i2c_hid_free_buffers(struct i2c_hid *ihid)
 {
 	kfree(ihid->inbuf);
 	kfree(ihid->rawbuf);
 	kfree(ihid->argsbuf);
 	kfree(ihid->cmdbuf);
 	ihid->inbuf = NULL;
 	ihid->rawbuf = NULL;
 	ihid->cmdbuf = NULL;
 	ihid->argsbuf = NULL;
 	ihid->bufsize = 0;
 }
 static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size)
 {
 	/* the worst case is computed from the set_report command with a
 	 * reportID > 15 and the maximum report length */
 	int args_len = sizeof(__u8) + /* optional ReportID byte */
 		       sizeof(__u16) + /* data register */
 		       sizeof(__u16) + /* size of the report */
 		       report_size; /* report */
 	ihid->inbuf = kzalloc(report_size, GFP_KERNEL);
 	ihid->rawbuf = kzalloc(report_size, GFP_KERNEL);
 	ihid->argsbuf = kzalloc(args_len, GFP_KERNEL);
 	ihid->cmdbuf = kzalloc(sizeof(union command) + args_len, GFP_KERNEL);
 	if (!ihid->inbuf || !ihid->rawbuf || !ihid->argsbuf || !ihid->cmdbuf) {
 		i2c_hid_free_buffers(ihid);
 		return -ENOMEM;
 	}
 	ihid->bufsize = report_size;
 	return 0;
 }
 static int i2c_hid_get_raw_report(struct hid_device *hid,
 		unsigned char report_number, __u8 *buf, size_t count,
 		unsigned char report_type)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	size_t ret_count, ask_count;
 	int ret;
 	if (report_type == HID_OUTPUT_REPORT)
 		return -EINVAL;
 	/* +2 bytes to include the size of the reply in the query buffer */
 	ask_count = min(count + 2, (size_t)ihid->bufsize);
 	ret = i2c_hid_get_report(client,
 			report_type == HID_FEATURE_REPORT ? 0x03 : 0x01,
 			report_number, ihid->rawbuf, ask_count);
 	if (ret < 0)
 		return ret;
 	ret_count = ihid->rawbuf[0] | (ihid->rawbuf[1] << 8);
 	if (ret_count <= 2)
 		return 0;
 	ret_count = min(ret_count, ask_count);
 	/* The query buffer contains the size, dropping it in the reply */
 	count = min(count, ret_count - 2);
 	memcpy(buf, ihid->rawbuf + 2, count);
 	return count;
 }
 static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
 		size_t count, unsigned char report_type, bool use_data)
 {
 	struct i2c_client *client = hid->driver_data;
 	int report_id = buf[0];
 	int ret;
 	if (report_type == HID_INPUT_REPORT)
 		return -EINVAL;
 	if (report_id) {
 		buf++;
 		count--;
 	}
 	ret = i2c_hid_set_or_send_report(client,
 				report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
 				report_id, buf, count, use_data);
 	if (report_id && ret >= 0)
 		ret++; /* add report_id to the number of transfered bytes */
 	return ret;
 }
 static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
 		size_t count)
 {
 	return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
 			false);
 }
 static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
 			       __u8 *buf, size_t len, unsigned char rtype,
 			       int reqtype)
 {
 	switch (reqtype) {
 	case HID_REQ_GET_REPORT:
 		return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
 	case HID_REQ_SET_REPORT:
 		if (buf[0] != reportnum)
 			return -EINVAL;
 		return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
 	default:
 		return -EIO;
 	}
 }
 static int i2c_hid_parse(struct hid_device *hid)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct i2c_hid_desc *hdesc = &ihid->hdesc;
 	unsigned int rsize;
 	char *rdesc;
 	int ret;
 	int tries = 3;
 	i2c_hid_dbg(ihid, "entering %s\n", __func__);
 	rsize = le16_to_cpu(hdesc->wReportDescLength);
 	if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
 		dbg_hid("weird size of report descriptor (%u)\n", rsize);
 		return -EINVAL;
 	}
 	do {
 		ret = i2c_hid_hwreset(client);
 		if (ret)
 			msleep(1000);
 	} while (tries-- > 0 && ret);
 	if (ret)
 		return ret;
 	rdesc = kzalloc(rsize, GFP_KERNEL);
 	if (!rdesc) {
 		dbg_hid("couldn't allocate rdesc memory\n");
 		return -ENOMEM;
 	}
 	i2c_hid_dbg(ihid, "asking HID report descriptor\n");
 	ret = i2c_hid_command(client, &hid_report_descr_cmd, rdesc, rsize);
 	if (ret) {
 		hid_err(hid, "reading report descriptor failed\n");
 		kfree(rdesc);
 		return -EIO;
 	}
 	i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
 	ret = hid_parse_report(hid, rdesc, rsize);
 	kfree(rdesc);
 	if (ret) {
 		dbg_hid("parsing report descriptor failed\n");
 		return ret;
 	}
 	return 0;
 }
 static int i2c_hid_start(struct hid_device *hid)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	int ret;
 	unsigned int bufsize = HID_MIN_BUFFER_SIZE;
 	i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
 	i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
 	i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
 	if (bufsize > ihid->bufsize) {
 		i2c_hid_free_buffers(ihid);
 		ret = i2c_hid_alloc_buffers(ihid, bufsize);
 		if (ret)
 			return ret;
 	}
 	if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
 		i2c_hid_init_reports(hid);
 	return 0;
 }
 static void i2c_hid_stop(struct hid_device *hid)
 {
-	struct i2c_client *client = hid->driver_data;
-	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	hid->claimed = 0;
-	i2c_hid_free_buffers(ihid);
 }
 static int i2c_hid_open(struct hid_device *hid)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	int ret = 0;
 	mutex_lock(&i2c_hid_open_mut);
 	if (!hid->open++) {
 		ret = pm_runtime_get_sync(&client->dev);
 		if (ret < 0) {
 			hid->open--;
 			goto done;
 		}
 		set_bit(I2C_HID_STARTED, &ihid->flags);
 	}
 done:
 	mutex_unlock(&i2c_hid_open_mut);
 	return ret < 0 ? ret : 0;
 }
 static void i2c_hid_close(struct hid_device *hid)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	/* protecting hid->open to make sure we don't restart
 	 * data acquistion due to a resumption we no longer
 	 * care about
 	 */
 	mutex_lock(&i2c_hid_open_mut);
 	if (!--hid->open) {
 		clear_bit(I2C_HID_STARTED, &ihid->flags);
 		/* Save some power */
 		pm_runtime_put(&client->dev);
 	}
 	mutex_unlock(&i2c_hid_open_mut);
 }
 static int i2c_hid_power(struct hid_device *hid, int lvl)
 {
 	struct i2c_client *client = hid->driver_data;
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl);
 	switch (lvl) {
 	case PM_HINT_FULLON:
 		pm_runtime_get_sync(&client->dev);
 		break;
 	case PM_HINT_NORMAL:
 		pm_runtime_put(&client->dev);
 		break;
 	}
 	return 0;
 }
 static struct hid_ll_driver i2c_hid_ll_driver = {
 	.parse = i2c_hid_parse,
 	.start = i2c_hid_start,
 	.stop = i2c_hid_stop,
 	.open = i2c_hid_open,
 	.close = i2c_hid_close,
 	.power = i2c_hid_power,
 	.output_report = i2c_hid_output_report,
 	.raw_request = i2c_hid_raw_request,
 };
 static int i2c_hid_init_irq(struct i2c_client *client)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	int ret;
 	dev_dbg(&client->dev, "Requesting IRQ: %d\n", client->irq);
 	ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq,
 			IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 			client->name, ihid);
 	if (ret < 0) {
 		dev_warn(&client->dev,
 			"Could not register for %s interrupt, irq = %d,"
 			" ret = %d\n",
 			client->name, client->irq, ret);
 		return ret;
 	}
 	return 0;
 }
 static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
 {
 	struct i2c_client *client = ihid->client;
 	struct i2c_hid_desc *hdesc = &ihid->hdesc;
 	unsigned int dsize;
 	int ret;
 	/* i2c hid fetch using a fixed descriptor size (30 bytes) */
 	i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
 	ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer,
 				sizeof(struct i2c_hid_desc));
 	if (ret) {
 		dev_err(&client->dev, "hid_descr_cmd failed\n");
 		return -ENODEV;
 	}
 	/* Validate the length of HID descriptor, the 4 first bytes:
 	 * bytes 0-1 -> length
 	 * bytes 2-3 -> bcdVersion (has to be 1.00) */
 	/* check bcdVersion == 1.0 */
 	if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
 		dev_err(&client->dev,
 			"unexpected HID descriptor bcdVersion (0x%04hx)\n",
 			le16_to_cpu(hdesc->bcdVersion));
 		return -ENODEV;
 	}
 	/* Descriptor length should be 30 bytes as per the specification */
 	dsize = le16_to_cpu(hdesc->wHIDDescLength);
 	if (dsize != sizeof(struct i2c_hid_desc)) {
 		dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
 			dsize);
 		return -ENODEV;
 	}
 	i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer);
 	return 0;
 }
 #ifdef CONFIG_ACPI
 static int i2c_hid_acpi_pdata(struct i2c_client *client,
 		struct i2c_hid_platform_data *pdata)
 {
 	static u8 i2c_hid_guid[] = {
 		0xF7, 0xF6, 0xDF, 0x3C, 0x67, 0x42, 0x55, 0x45,
 		0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE,
 	};
 	union acpi_object *obj;
 	struct acpi_device *adev;
 	acpi_handle handle;
 	handle = ACPI_HANDLE(&client->dev);
 	if (!handle || acpi_bus_get_device(handle, &adev))
 		return -ENODEV;
 	obj = acpi_evaluate_dsm_typed(handle, i2c_hid_guid, 1, 1, NULL,
 				      ACPI_TYPE_INTEGER);
 	if (!obj) {
 		dev_err(&client->dev, "device _DSM execution failed\n");
 		return -ENODEV;
 	}
 	pdata->hid_descriptor_address = obj->integer.value;
 	ACPI_FREE(obj);
 	return 0;
 }
 static const struct acpi_device_id i2c_hid_acpi_match[] = {
 	{"ACPI0C50", 0 },
 	{"PNP0C50", 0 },
 	{ },
 };
 MODULE_DEVICE_TABLE(acpi, i2c_hid_acpi_match);
 #else
 static inline int i2c_hid_acpi_pdata(struct i2c_client *client,
 		struct i2c_hid_platform_data *pdata)
 {
 	return -ENODEV;
 }
 #endif
 #ifdef CONFIG_OF
 static int i2c_hid_of_probe(struct i2c_client *client,
 		struct i2c_hid_platform_data *pdata)
 {
 	struct device *dev = &client->dev;
 	u32 val;
 	int ret;
 	ret = of_property_read_u32(dev->of_node, "hid-descr-addr", &val);
 	if (ret) {
 		dev_err(&client->dev, "HID register address not provided\n");
 		return -ENODEV;
 	}
 	if (val >> 16) {
 		dev_err(&client->dev, "Bad HID register address: 0x%08x\n",
 			val);
 		return -EINVAL;
 	}
 	pdata->hid_descriptor_address = val;
 	return 0;
 }
 static const struct of_device_id i2c_hid_of_match[] = {
 	{ .compatible = "hid-over-i2c" },
 	{},
 };
 MODULE_DEVICE_TABLE(of, i2c_hid_of_match);
 #else
 static inline int i2c_hid_of_probe(struct i2c_client *client,
 		struct i2c_hid_platform_data *pdata)
 {
 	return -ENODEV;
 }
 #endif
 static int i2c_hid_probe(struct i2c_client *client,
 			 const struct i2c_device_id *dev_id)
 {
 	int ret;
 	struct i2c_hid *ihid;
 	struct hid_device *hid;
 	__u16 hidRegister;
 	struct i2c_hid_platform_data *platform_data = client->dev.platform_data;
 	dbg_hid("HID probe called for i2c 0x%02x\n", client->addr);
 	if (!client->irq) {
 		dev_err(&client->dev,
 			"HID over i2c has not been provided an Int IRQ\n");
 		return -EINVAL;
 	}
 	ihid = kzalloc(sizeof(struct i2c_hid), GFP_KERNEL);
 	if (!ihid)
 		return -ENOMEM;
 	if (client->dev.of_node) {
 		ret = i2c_hid_of_probe(client, &ihid->pdata);
 		if (ret)
 			goto err;
 	} else if (!platform_data) {
 		ret = i2c_hid_acpi_pdata(client, &ihid->pdata);
 		if (ret) {
 			dev_err(&client->dev,
 				"HID register address not provided\n");
 			goto err;
 		}
 	} else {
 		ihid->pdata = *platform_data;
 	}
 	i2c_set_clientdata(client, ihid);
 	ihid->client = client;
 	hidRegister = ihid->pdata.hid_descriptor_address;
 	ihid->wHIDDescRegister = cpu_to_le16(hidRegister);
 	init_waitqueue_head(&ihid->wait);
 	/* we need to allocate the command buffer without knowing the maximum
 	 * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the
 	 * real computation later. */
 	ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE);
 	if (ret < 0)
 		goto err;
 	pm_runtime_get_noresume(&client->dev);
 	pm_runtime_set_active(&client->dev);
 	pm_runtime_enable(&client->dev);
 	ret = i2c_hid_fetch_hid_descriptor(ihid);
 	if (ret < 0)
 		goto err_pm;
 	ret = i2c_hid_init_irq(client);
 	if (ret < 0)
 		goto err_pm;
 	hid = hid_allocate_device();
 	if (IS_ERR(hid)) {
 		ret = PTR_ERR(hid);
 		goto err_irq;
 	}
 	ihid->hid = hid;
 	hid->driver_data = client;
 	hid->ll_driver = &i2c_hid_ll_driver;
 	hid->dev.parent = &client->dev;
 	ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev));
 	hid->bus = BUS_I2C;
 	hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
 	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
 	hid->product = le16_to_cpu(ihid->hdesc.wProductID);
 	snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
 		 client->name, hid->vendor, hid->product);
 	ret = hid_add_device(hid);
 	if (ret) {
 		if (ret != -ENODEV)
 			hid_err(client, "can't add hid device: %d\n", ret);
 		goto err_mem_free;
 	}
 	pm_runtime_put(&client->dev);
 	return 0;
 err_mem_free:
 	hid_destroy_device(hid);
 err_irq:
 	free_irq(client->irq, ihid);
 err_pm:
 	pm_runtime_put_noidle(&client->dev);
 	pm_runtime_disable(&client->dev);
 err:
 	i2c_hid_free_buffers(ihid);
 	kfree(ihid);
 	return ret;
 }
 static int i2c_hid_remove(struct i2c_client *client)
 {
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct hid_device *hid;
 	pm_runtime_get_sync(&client->dev);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
 	pm_runtime_put_noidle(&client->dev);
 	hid = ihid->hid;
 	hid_destroy_device(hid);
 	free_irq(client->irq, ihid);
 	if (ihid->bufsize)
 		i2c_hid_free_buffers(ihid);
 	kfree(ihid);
 	return 0;
 }
 #ifdef CONFIG_PM_SLEEP
 static int i2c_hid_suspend(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct hid_device *hid = ihid->hid;
 	int ret = 0;
 	disable_irq(client->irq);
 	if (device_may_wakeup(&client->dev))
 		enable_irq_wake(client->irq);
 	if (hid->driver && hid->driver->suspend)
 		ret = hid->driver->suspend(hid, PMSG_SUSPEND);
 	/* Save some power */
 	i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
 	return ret;
 }
 static int i2c_hid_resume(struct device *dev)
 {
 	int ret;
 	struct i2c_client *client = to_i2c_client(dev);
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct hid_device *hid = ihid->hid;
 	enable_irq(client->irq);
 	ret = i2c_hid_hwreset(client);
 	if (ret)
 		return ret;
 	if (device_may_wakeup(&client->dev))
 		disable_irq_wake(client->irq);
 	if (hid->driver && hid->driver->reset_resume) {
 		ret = hid->driver->reset_resume(hid);
 		return ret;
 	}
 	return 0;
 }
 #endif
 #ifdef CONFIG_PM
 static int i2c_hid_runtime_suspend(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
 	disable_irq(client->irq);
 	return 0;
 }
 static int i2c_hid_runtime_resume(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	enable_irq(client->irq);
 	i2c_hid_set_power(client, I2C_HID_PWR_ON);
 	return 0;
 }
 #endif
 static const struct dev_pm_ops i2c_hid_pm = {
 	SET_SYSTEM_SLEEP_PM_OPS(i2c_hid_suspend, i2c_hid_resume)
 	SET_RUNTIME_PM_OPS(i2c_hid_runtime_suspend, i2c_hid_runtime_resume,
 			   NULL)
 };
 static const struct i2c_device_id i2c_hid_id_table[] = {
 	{ "hid", 0 },
 	{ },
 };
 MODULE_DEVICE_TABLE(i2c, i2c_hid_id_table);
 static struct i2c_driver i2c_hid_driver = {
 	.driver = {
 		.name	= "i2c_hid",
 		.owner	= THIS_MODULE,
 		.pm	= &i2c_hid_pm,
 		.acpi_match_table = ACPI_PTR(i2c_hid_acpi_match),
 		.of_match_table = of_match_ptr(i2c_hid_of_match),
 	},
 	.probe		= i2c_hid_probe,
 	.remove		= i2c_hid_remove,
 	.id_table	= i2c_hid_id_table,
 };
 module_i2c_driver(i2c_hid_driver);
 MODULE_DESCRIPTION("HID over I2C core driver");
 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
 MODULE_LICENSE("GPL");

drivers/hid/usbhid/hid-quirks.c

Diff comments View file @ 28023d2

 /*
  *  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.
  */
 #include <linux/hid.h>
 #include <linux/export.h>
 #include <linux/slab.h>
 #include "../hid-ids.h"
 /*
  * Alphabetically sorted blacklist by quirk type.
  */
 static const struct hid_blacklist {
 	__u16 idVendor;
 	__u16 idProduct;
 	__u32 quirks;
 } hid_blacklist[] = {
 	{ 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_DWAV, USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER, HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_MOJO, USB_DEVICE_ID_RETRO_ADAPTER, 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 },
 	{ USB_VENDOR_ID_NATSU, USB_DEVICE_ID_NATSU_GAMEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_NEC, USB_DEVICE_ID_NEC_USB_GAME_PAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_NEXTWINDOW, USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN, HID_QUIRK_MULTI_INPUT},
 	{ 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_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 	{ USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH_2968, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
 	{ 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_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_AIREN, USB_DEVICE_ID_AIREN_SLIMPLUS, HID_QUIRK_NOGET },
 	{ 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 },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FIGHTERSTICK, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_COMBATSTICK, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_PRO_THROTTLE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_PRO_PEDALS, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_AXIS_295, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ELAN_TOUCHSCREEN, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ELAN_TOUCHSCREEN_009B, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ELAN_TOUCHSCREEN_0103, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ELAN_TOUCHSCREEN_010c, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ELAN_TOUCHSCREEN_016F, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_FORMOSA, USB_DEVICE_ID_FORMOSA_IR_RECEIVER, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_FREESCALE, USB_DEVICE_ID_FREESCALE_MX28, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_NEXIO, USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_NOVATEK, USB_DEVICE_ID_NOVATEK_MOUSE, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_1610, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_1640, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_KYE, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE_ID2, HID_QUIRK_ALWAYS_POLL },
 	{ USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_REALTEK, USB_DEVICE_ID_REALTEK_READER, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SENNHEISER, USB_DEVICE_ID_SENNHEISER_BTD500USB, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SIGMATEL, USB_DEVICE_ID_SIGMATEL_STMP3780, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS9200_TOUCH, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS817_TOUCH, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS_TS, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SIS_TOUCH, USB_DEVICE_ID_SIS1030_TOUCH, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_1, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_2, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_TPV, USB_DEVICE_ID_TPV_OPTICAL_TOUCHSCREEN, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_KNA5, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWA60, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_PI_ENGINEERING, USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL, HID_QUIRK_HIDINPUT_FORCE },
 	{ USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_SIGMA_MICRO, USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X, HID_QUIRK_MULTI_INPUT },
+	{ USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_DUOSENSE, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS1, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_HD, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103, HID_QUIRK_NO_INIT_REPORTS },
 	{ USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD_A096, HID_QUIRK_NO_INIT_INPUT_REPORTS },
 	{ 0, 0 }
 };
 /* Dynamic HID quirks list - specified at runtime */
 struct quirks_list_struct {
 	struct hid_blacklist hid_bl_item;
 	struct list_head node;
 };
 static LIST_HEAD(dquirks_list);
 static DECLARE_RWSEM(dquirks_rwsem);
 /* Runtime ("dynamic") quirks manipulation functions */
 /**
  * usbhid_exists_dquirk: find any dynamic quirks for a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *         Scans dquirks_list for a matching dynamic quirk and returns
  *         the pointer to the relevant struct hid_blacklist if found.
  *         Must be called with a read lock held on dquirks_rwsem.
  *
  * Returns: NULL if no quirk found, struct hid_blacklist * if found.
  */
 static struct hid_blacklist *usbhid_exists_dquirk(const u16 idVendor,
 		const u16 idProduct)
 {
 	struct quirks_list_struct *q;
 	struct hid_blacklist *bl_entry = NULL;
 	list_for_each_entry(q, &dquirks_list, node) {
 		if (q->hid_bl_item.idVendor == idVendor &&
 				q->hid_bl_item.idProduct == idProduct) {
 			bl_entry = &q->hid_bl_item;
 			break;
 		}
 	}
 	if (bl_entry != NULL)
 		dbg_hid("Found dynamic quirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
 				bl_entry->quirks, bl_entry->idVendor,
 				bl_entry->idProduct);
 	return bl_entry;
 }
 /**
  * usbhid_modify_dquirk: add/replace a HID quirk
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  * @quirks: the u32 quirks value to add/replace
  *
  * Description:
  *         If an dynamic quirk exists in memory for this (idVendor,
  *         idProduct) pair, replace its quirks value with what was
  *         provided.  Otherwise, add the quirk to the dynamic quirks list.
  *
  * Returns: 0 OK, -error on failure.
  */
 static int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct,
 				const u32 quirks)
 {
 	struct quirks_list_struct *q_new, *q;
 	int list_edited = 0;
 	if (!idVendor) {
 		dbg_hid("Cannot add a quirk with idVendor = 0\n");
 		return -EINVAL;
 	}
 	q_new = kmalloc(sizeof(struct quirks_list_struct), GFP_KERNEL);
 	if (!q_new) {
 		dbg_hid("Could not allocate quirks_list_struct\n");
 		return -ENOMEM;
 	}
 	q_new->hid_bl_item.idVendor = idVendor;
 	q_new->hid_bl_item.idProduct = idProduct;
 	q_new->hid_bl_item.quirks = quirks;
 	down_write(&dquirks_rwsem);
 	list_for_each_entry(q, &dquirks_list, node) {
 		if (q->hid_bl_item.idVendor == idVendor &&
 				q->hid_bl_item.idProduct == idProduct) {
 			list_replace(&q->node, &q_new->node);
 			kfree(q);
 			list_edited = 1;
 			break;
 		}
 	}
 	if (!list_edited)
 		list_add_tail(&q_new->node, &dquirks_list);
 	up_write(&dquirks_rwsem);
 	return 0;
 }
 /**
  * usbhid_remove_all_dquirks: remove all runtime HID quirks from memory
  *
  * Description:
  *         Free all memory associated with dynamic quirks - called before
  *         module unload.
  *
  */
 static void usbhid_remove_all_dquirks(void)
 {
 	struct quirks_list_struct *q, *temp;
 	down_write(&dquirks_rwsem);
 	list_for_each_entry_safe(q, temp, &dquirks_list, node) {
 		list_del(&q->node);
 		kfree(q);
 	}
 	up_write(&dquirks_rwsem);
 }
 /**
  * usbhid_quirks_init: apply USB HID quirks specified at module load time
  */
 int usbhid_quirks_init(char **quirks_param)
 {
 	u16 idVendor, idProduct;
 	u32 quirks;
 	int n = 0, m;
 	for (; n < MAX_USBHID_BOOT_QUIRKS && quirks_param[n]; n++) {
 		m = sscanf(quirks_param[n], "0x%hx:0x%hx:0x%x",
 				&idVendor, &idProduct, &quirks);
 		if (m != 3 ||
 				usbhid_modify_dquirk(idVendor, idProduct, quirks) != 0) {
 			printk(KERN_WARNING
 					"Could not parse HID quirk module param %s\n",
 					quirks_param[n]);
 		}
 	}
 	return 0;
 }
 /**
  * usbhid_quirks_exit: release memory associated with dynamic_quirks
  *
  * Description:
  *     Release all memory associated with dynamic quirks.  Called upon
  *     module unload.
  *
  * Returns: nothing
  */
 void usbhid_quirks_exit(void)
 {
 	usbhid_remove_all_dquirks();
 }
 /**
  * usbhid_exists_squirk: return any static quirks for a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *     Given a USB vendor ID and product ID, return a pointer to
  *     the hid_blacklist entry associated with that device.
  *
  * Returns: pointer if quirk found, or NULL if no quirks found.
  */
 static const struct hid_blacklist *usbhid_exists_squirk(const u16 idVendor,
 		const u16 idProduct)
 {
 	const struct hid_blacklist *bl_entry = NULL;
 	int n = 0;
 	for (; hid_blacklist[n].idVendor; n++)
 		if (hid_blacklist[n].idVendor == idVendor &&
 				hid_blacklist[n].idProduct == idProduct)
 			bl_entry = &hid_blacklist[n];
 	if (bl_entry != NULL)
 		dbg_hid("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
 				bl_entry->quirks, bl_entry->idVendor,
 				bl_entry->idProduct);
 	return bl_entry;
 }
 /**
  * usbhid_lookup_quirk: return any quirks associated with a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *     Given a USB vendor ID and product ID, return any quirks associated
  *     with that device.
  *
  * Returns: a u32 quirks value.
  */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
 {
 	u32 quirks = 0;
 	const struct hid_blacklist *bl_entry = NULL;
 	/* NCR devices must not be queried for reports */
 	if (idVendor == USB_VENDOR_ID_NCR &&
 			idProduct >= USB_DEVICE_ID_NCR_FIRST &&
 			idProduct <= USB_DEVICE_ID_NCR_LAST)
 			return HID_QUIRK_NO_INIT_REPORTS;
 	down_read(&dquirks_rwsem);
 	bl_entry = usbhid_exists_dquirk(idVendor, idProduct);
 	if (!bl_entry)
 		bl_entry = usbhid_exists_squirk(idVendor, idProduct);
 	if (bl_entry)
 		quirks = bl_entry->quirks;
 	up_read(&dquirks_rwsem);
 	return quirks;
 }
 EXPORT_SYMBOL_GPL(usbhid_lookup_quirk);