lael-labs/linux

Documentation/ABI/testing/sysfs-driver-hid-roccat-isku+11−1

 Contact:	Stefan Achatz <erazor_de@users.sourceforge.net>
 Description:	When written, this file lets one set the backlight intensity for
 		a specific profile. Profile number is included in written data.
-		The data has to be 10 bytes long.
+		The data has to be 10 bytes long for Isku, IskuFX needs	16 bytes
+		of data.
 		Before reading this file, control has to be written to select
 		which profile to read.
 Users:		http://roccat.sourceforge.net
 		The data has to be 16 bytes long.
 		This file is writeonly.
 Users:		http://roccat.sourceforge.net
+What:		/sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/isku/roccatisku<minor>/talkfx
+Date:		February 2013
+Contact:	Stefan Achatz <erazor_de@users.sourceforge.net>
+Description:	When written, this file lets one trigger temporary color schemes
+		from the host.
+		The data has to be 16 bytes long.
+		This file is writeonly.
+Users:		http://roccat.sourceforge.net

Documentation/ABI/testing/sysfs-driver-hid-roccat-konepure+105−0

@@ -0,0 +1,105 @@
	1	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/actual_profile
	2	Date: December 2012
	3	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	4	Description: The mouse can store 5 profiles which can be switched by the
	5	press of a button. actual_profile holds number of actual profile.
	6	This value is persistent, so its value determines the profile
	7	that's active when the mouse is powered on next time.
	8	When written, the mouse activates the set profile immediately.
	9	The data has to be 3 bytes long.
	10	The mouse will reject invalid data.
	11	Users: http://roccat.sourceforge.net
	12
	13	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/control
	14	Date: December 2012
	15	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	16	Description: When written, this file lets one select which data from which
	17	profile will be read next. The data has to be 3 bytes long.
	18	This file is writeonly.
	19	Users: http://roccat.sourceforge.net
	20
	21	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/info
	22	Date: December 2012
	23	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	24	Description: When read, this file returns general data like firmware version.
	25	When written, the device can be reset.
	26	The data is 6 bytes long.
	27	Users: http://roccat.sourceforge.net
	28
	29	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/macro
	30	Date: December 2012
	31	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	32	Description: The mouse can store a macro with max 500 key/button strokes
	33	internally.
	34	When written, this file lets one set the sequence for a specific
	35	button for a specific profile. Button and profile numbers are
	36	included in written data. The data has to be 2082 bytes long.
	37	This file is writeonly.
	38	Users: http://roccat.sourceforge.net
	39
	40	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/profile_buttons
	41	Date: December 2012
	42	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	43	Description: The mouse can store 5 profiles which can be switched by the
	44	press of a button. A profile is split in settings and buttons.
	45	profile_buttons holds information about button layout.
	46	When written, this file lets one write the respective profile
	47	buttons back to the mouse. The data has to be 59 bytes long.
	48	The mouse will reject invalid data.
	49	Which profile to write is determined by the profile number
	50	contained in the data.
	51	Before reading this file, control has to be written to select
	52	which profile to read.
	53	Users: http://roccat.sourceforge.net
	54
	55	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/profile_settings
	56	Date: December 2012
	57	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	58	Description: The mouse can store 5 profiles which can be switched by the
	59	press of a button. A profile is split in settings and buttons.
	60	profile_settings holds information like resolution, sensitivity
	61	and light effects.
	62	When written, this file lets one write the respective profile
	63	settings back to the mouse. The data has to be 31 bytes long.
	64	The mouse will reject invalid data.
	65	Which profile to write is determined by the profile number
	66	contained in the data.
	67	Before reading this file, control has to be written to select
	68	which profile to read.
	69	Users: http://roccat.sourceforge.net
	70
	71	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/sensor
	72	Date: December 2012
	73	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	74	Description: The mouse has a tracking- and a distance-control-unit. These
	75	can be activated/deactivated and the lift-off distance can be
	76	set. The data has to be 6 bytes long.
	77	This file is writeonly.
	78	Users: http://roccat.sourceforge.net
	79
	80	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/talk
	81	Date: December 2012
	82	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	83	Description: Used to active some easy* functions of the mouse from outside.
	84	The data has to be 16 bytes long.
	85	This file is writeonly.
	86	Users: http://roccat.sourceforge.net
	87
	88	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/tcu
	89	Date: December 2012
	90	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	91	Description: When written a calibration process for the tracking control unit
	92	can be initiated/cancelled. Also lets one read/write sensor
	93	registers.
	94	The data has to be 4 bytes long.
	95	Users: http://roccat.sourceforge.net
	96
	97	What: /sys/bus/usb/devices/<busnum>-<devnum>:<config num>.<interface num>/<hid-bus>:<vendor-id>:<product-id>.<num>/konepure/roccatkonepure<minor>/tcu_image
	98	Date: December 2012
	99	Contact: Stefan Achatz <erazor_de@users.sourceforge.net>
	100	Description: When read the mouse returns a 30x30 pixel image of the
	101	sampled underground. This works only in the course of a
	102	calibration process initiated with tcu.
	103	The returned data is 1028 bytes in size.
	104	This file is readonly.
	105	Users: http://roccat.sourceforge.net

drivers/hid/Kconfig+64−53

 config HID_A4TECH
 	tristate "A4 tech mice" if EXPERT
-	depends on USB_HID
+	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 USB_HID
+	depends on HID
 	---help---
 	Say Y here if you want to enable support for ACRUX game controllers.
 config HID_APPLE
 	tristate "Apple {i,Power,Mac}Books" if EXPERT
-	depends on (USB_HID || BT_HIDP)
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for some Apple devices which less or more break
 	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 USB_HID
+	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 USB_HID
+	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 USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Cherry Cymotion keyboard.
 config HID_CHICONY
 	tristate "Chicony Tactical pad" if EXPERT
-	depends on USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Chicony Tactical pad.
 config HID_PRODIKEYS
 	tristate "Prodikeys PC-MIDI Keyboard support"
-	depends on USB_HID && SND
+	depends on HID && SND
 	select SND_RAWMIDI
 	---help---
 	Support for Prodikeys PC-MIDI Keyboard device support.
 config HID_CYPRESS
 	tristate "Cypress mouse and barcode readers" if EXPERT
-	depends on USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for cypress mouse and barcode readers.
 config HID_DRAGONRISE
 	tristate "DragonRise Inc. game controller"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Say Y here if you have DragonRise Inc. game controllers.
 	These might be branded as:
 config HID_EMS_FF
 	tristate "EMS Production Inc. force feedback support"
-	depends on USB_HID
+	depends on HID
 	select INPUT_FF_MEMLESS
 	---help---
 	Say Y here if you want to enable force feedback support for devices by
 config HID_ELECOM
 	tristate "ELECOM BM084 bluetooth mouse"
-	depends on BT_HIDP
+	depends on HID
 	---help---
 	Support for the ELECOM BM084 (bluetooth mouse).
 config HID_EZKEY
 	tristate "Ezkey BTC 8193 keyboard" if EXPERT
-	depends on USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Ezkey BTC 8193 keyboard.
 config HID_KEYTOUCH
 	tristate "Keytouch HID devices"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Keytouch HID devices not fully compliant with
 	the specification. Currently supported:
 config HID_KYE
 	tristate "KYE/Genius devices"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for KYE/Genius devices not fully compliant with HID standard:
 	- Ergo Mouse
 config HID_UCLOGIC
 	tristate "UC-Logic"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for UC-Logic tablets.
 config HID_WALTOP
 	tristate "Waltop"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Waltop tablets.
 config HID_GYRATION
 	tristate "Gyration remote control"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Gyration remote control.
 config HID_ICADE
 	tristate "ION iCade arcade controller"
-	depends on BT_HIDP
+	depends on HID
 	---help---
 	Support for the ION iCade arcade controller to work as a joystick.
 config HID_TWINHAN
 	tristate "Twinhan IR remote control"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Twinhan IR remote control.
 config HID_KENSINGTON
 	tristate "Kensington Slimblade Trackball" if EXPERT
-	depends on USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Kensington Slimblade Trackball.
 config HID_LCPOWER
 	tristate "LC-Power"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for LC-Power RC1000MCE RF remote control.
 config HID_LOGITECH
 	tristate "Logitech devices" if EXPERT
-	depends on USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Logitech devices that are not fully compliant with HID standard.
 	  - Logitech Formula Force EX
 config HID_MAGICMOUSE
-	tristate "Apple MagicMouse multi-touch support"
+	tristate "Apple Magic Mouse/Trackpad multi-touch support"
-	depends on BT_HIDP
+	depends on HID
 	---help---
-	Support for the Apple Magic Mouse multi-touch.
+	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.
+	Apple Wireless "Magic" Mouse and the Apple Wireless "Magic" Trackpad.
 config HID_MICROSOFT
 	tristate "Microsoft non-fully HID-compliant devices" if EXPERT
-	depends on USB_HID
+	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 USB_HID
+	depends on HID
 	default !EXPERT
 	---help---
 	Support for Monterey Genius KB29E.
 config HID_MULTITOUCH
 	tristate "HID Multitouch panels"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  Generic support for HID multitouch panels.
 config HID_ORTEK
 	tristate "Ortek PKB-1700/WKB-2000/Skycable wireless keyboard and mouse trackpad"
-	depends on USB_HID
+	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
 config HID_PANTHERLORD
 	tristate "Pantherlord/GreenAsia game controller"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  Say Y here if you have a PantherLord/GreenAsia based game controller
 	  or adapter.
 config HID_PETALYNX
 	tristate "Petalynx Maxter remote control"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Petalynx Maxter remote control.
 config HID_PICOLCD
 	tristate "PicoLCD (graphic version)"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  This provides support for Minibox PicoLCD devices, currently
 	  only the graphical ones are supported.
 config HID_PRIMAX
 	tristate "Primax non-fully HID-compliant devices"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Primax devices that are not fully compliant with the
 	HID standard.
 config HID_PS3REMOTE
 	tristate "Sony PS3 BD Remote Control"
-	depends on BT_HIDP
+	depends on HID
 	---help---
 	Support for the Sony PS3 Blue-ray Disk Remote Control and Logitech
 	Harmony Adapter for PS3, which connect over Bluetooth.
 config HID_SAITEK
 	tristate "Saitek non-fully HID-compliant devices"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Saitek devices that are not fully compliant with the
 	HID standard.
 config HID_SAMSUNG
 	tristate "Samsung InfraRed remote control or keyboards"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Samsung InfraRed remote control or keyboards.
 config HID_SPEEDLINK
 	tristate "Speedlink VAD Cezanne mouse support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Speedlink Vicious and Divine Cezanne mouse.
 config HID_STEELSERIES
 	tristate "Steelseries SRW-S1 steering wheel support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Steelseries SRW-S1 steering wheel
 config HID_SUNPLUS
 	tristate "Sunplus wireless desktop"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Sunplus wireless desktop.
 config HID_GREENASIA
 	tristate "GreenAsia (Product ID 0x12) game controller support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  Say Y here if you have a GreenAsia (Product ID 0x12) based game
 	  controller or adapter.
 config HID_SMARTJOYPLUS
 	tristate "SmartJoy PLUS PS2/USB adapter support"
-	depends on USB_HID
+	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.
 config HID_TIVO
 	tristate "TiVo Slide Bluetooth remote control support"
-	depends on (USB_HID || BT_HIDP)
+	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 USB_HID
+	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 USB_HID
+	depends on HID
 	depends on LEDS_CLASS
 	---help---
 	Support for the ThingM blink(1) USB RGB LED. This driver registers a
 config HID_THRUSTMASTER
 	tristate "ThrustMaster devices support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
 	  a THRUSTMASTER Ferrari GT Rumble Wheel.
 config HID_WACOM
 	tristate "Wacom Bluetooth devices support"
-	depends on BT_HIDP
+	depends on HID
 	depends on LEDS_CLASS
 	select POWER_SUPPLY
 	---help---
 config HID_WIIMOTE
 	tristate "Nintendo Wii Remote support"
-	depends on BT_HIDP
+	depends on HID
 	depends on LEDS_CLASS
 	select POWER_SUPPLY
 	select INPUT_FF_MEMLESS
 config HID_ZEROPLUS
 	tristate "Zeroplus based game controller support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  Say Y here if you have a Zeroplus based game controller.
 config HID_ZYDACRON
 	tristate "Zydacron remote control support"
-	depends on USB_HID
+	depends on HID
 	---help---
 	Support for Zydacron remote control.
 config HID_SENSOR_HUB
 	tristate "HID Sensors framework support"
-	depends on USB_HID && GENERIC_HARDIRQS
+	depends on HID && GENERIC_HARDIRQS
 	select MFD_CORE
 	default n
-	-- help---
+	---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

drivers/hid/Makefile+3−2

 obj-$(CONFIG_HID_A4TECH)	+= hid-a4tech.o
 obj-$(CONFIG_HID_ACRUX)		+= hid-axff.o
 obj-$(CONFIG_HID_APPLE)		+= hid-apple.o
+obj-$(CONFIG_HID_APPLEIR)	+= hid-appleir.o
 obj-$(CONFIG_HID_AUREAL)        += hid-aureal.o
 obj-$(CONFIG_HID_BELKIN)	+= hid-belkin.o
 obj-$(CONFIG_HID_CHERRY)	+= hid-cherry.o
 obj-$(CONFIG_HID_PS3REMOTE)	+= hid-ps3remote.o
 obj-$(CONFIG_HID_ROCCAT)	+= hid-roccat.o hid-roccat-common.o \
 	hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
-	hid-roccat-koneplus.o hid-roccat-kovaplus.o hid-roccat-lua.o \
+	hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
-	hid-roccat-pyra.o hid-roccat-savu.o
+	hid-roccat-lua.o hid-roccat-pyra.o hid-roccat-savu.o
 obj-$(CONFIG_HID_SAITEK)	+= hid-saitek.o
 obj-$(CONFIG_HID_SAMSUNG)	+= hid-samsung.o
 obj-$(CONFIG_HID_SMARTJOYPLUS)	+= hid-sjoy.o

drivers/hid/hid-apple.c+0−5

 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include "hid-ids.h"
 }
 static const struct hid_device_id apple_devices[] = {
-	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL),
-		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
-	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
-		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
 		.driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },

drivers/hid/hid-appleir.c+352−0

@@ -0,0 +1,352 @@
	1	/*
	2	* HID driver for the apple ir device
	3	*
	4	* Original driver written by James McKenzie
	5	* Ported to recent 2.6 kernel versions by Greg Kroah-Hartman <gregkh@suse.de>
	6	* Updated to support newer remotes by Bastien Nocera <hadess@hadess.net>
	7	* Ported to HID subsystem by Benjamin Tissoires <benjamin.tissoires@gmail.com>
	8	*
	9	* Copyright (C) 2006 James McKenzie
	10	* Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com>
	11	* Copyright (C) 2008 Novell Inc.
	12	* Copyright (C) 2010, 2012 Bastien Nocera <hadess@hadess.net>
	13	* Copyright (C) 2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
	14	* Copyright (C) 2013 Red Hat Inc. All Rights Reserved
	15	*
	16	* This software is licensed under the terms of the GNU General Public
	17	* License version 2, as published by the Free Software Foundation, and
	18	* may be copied, distributed, and modified under those terms.
	19	*
	20	* This program is distributed in the hope that it will be useful,
	21	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	23	* GNU General Public License for more details.
	24	*/
	25
	26	#include <linux/device.h>
	27	#include <linux/hid.h>
	28	#include <linux/module.h>
	29	#include "hid-ids.h"
	30
	31	MODULE_AUTHOR("James McKenzie");
	32	MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
	33	MODULE_DESCRIPTION("HID Apple IR remote controls");
	34	MODULE_LICENSE("GPL");
	35
	36	#define KEY_MASK 0x0F
	37	#define TWO_PACKETS_MASK 0x40
	38
	39	/*
	40	* James McKenzie has two devices both of which report the following
	41	* 25 87 ee 83 0a +
	42	* 25 87 ee 83 0c -
	43	* 25 87 ee 83 09 <<
	44	* 25 87 ee 83 06 >>
	45	* 25 87 ee 83 05 >"
	46	* 25 87 ee 83 03 menu
	47	* 26 00 00 00 00 for key repeat
	48	*/
	49
	50	/*
	51	* Thomas Glanzmann reports the following responses
	52	* 25 87 ee ca 0b +
	53	* 25 87 ee ca 0d -
	54	* 25 87 ee ca 08 <<
	55	* 25 87 ee ca 07 >>
	56	* 25 87 ee ca 04 >"
	57	* 25 87 ee ca 02 menu
	58	* 26 00 00 00 00 for key repeat
	59	*
	60	* He also observes the following event sometimes
	61	* sent after a key is release, which I interpret
	62	* as a flat battery message
	63	* 25 87 e0 ca 06 flat battery
	64	*/
	65
	66	/*
	67	* Alexandre Karpenko reports the following responses for Device ID 0x8242
	68	* 25 87 ee 47 0b +
	69	* 25 87 ee 47 0d -
	70	* 25 87 ee 47 08 <<
	71	* 25 87 ee 47 07 >>
	72	* 25 87 ee 47 04 >"
	73	* 25 87 ee 47 02 menu
	74	* 26 87 ee 47 for key repeat ( is the code of the key being held)
	75	*/
	76
	77	/*
	78	* Bastien Nocera's remote
	79	* 25 87 ee 91 5f followed by
	80	* 25 87 ee 91 05 gives you >"
	81	*
	82	* 25 87 ee 91 5c followed by
	83	* 25 87 ee 91 05 gives you the middle button
	84	*/
	85
	86	/*
	87	* Fabien Andre's remote
	88	* 25 87 ee a3 5e followed by
	89	* 25 87 ee a3 04 gives you >"
	90	*
	91	* 25 87 ee a3 5d followed by
	92	* 25 87 ee a3 04 gives you the middle button
	93	*/
	94
	95	static const unsigned short appleir_key_table[] = {
	96	KEY_RESERVED,
	97	KEY_MENU,
	98	KEY_PLAYPAUSE,
	99	KEY_FORWARD,
	100	KEY_BACK,
	101	KEY_VOLUMEUP,
	102	KEY_VOLUMEDOWN,
	103	KEY_RESERVED,
	104	KEY_RESERVED,
	105	KEY_RESERVED,
	106	KEY_RESERVED,
	107	KEY_RESERVED,
	108	KEY_RESERVED,
	109	KEY_RESERVED,
	110	KEY_ENTER,
	111	KEY_PLAYPAUSE,
	112	KEY_RESERVED,
	113	};
	114
	115	struct appleir {
	116	struct input_dev *input_dev;
	117	struct hid_device *hid;
	118	unsigned short keymap[ARRAY_SIZE(appleir_key_table)];
	119	struct timer_list key_up_timer; /* timer for key up */
	120	spinlock_t lock; /* protects .current_key */
	121	int current_key; /* the currently pressed key */
	122	int prev_key_idx; /* key index in a 2 packets message */
	123	};
	124
	125	static int get_key(int data)
	126	{
	127	/*
	128	* The key is coded accross bits 2..9:
	129	*
	130	* 0x00 or 0x01 ( ) key: 0 -> KEY_RESERVED
	131	* 0x02 or 0x03 ( menu ) key: 1 -> KEY_MENU
	132	* 0x04 or 0x05 ( >" ) key: 2 -> KEY_PLAYPAUSE
	133	* 0x06 or 0x07 ( >> ) key: 3 -> KEY_FORWARD
	134	* 0x08 or 0x09 ( << ) key: 4 -> KEY_BACK
	135	* 0x0a or 0x0b ( + ) key: 5 -> KEY_VOLUMEUP
	136	* 0x0c or 0x0d ( - ) key: 6 -> KEY_VOLUMEDOWN
	137	* 0x0e or 0x0f ( ) key: 7 -> KEY_RESERVED
	138	* 0x50 or 0x51 ( ) key: 8 -> KEY_RESERVED
	139	* 0x52 or 0x53 ( ) key: 9 -> KEY_RESERVED
	140	* 0x54 or 0x55 ( ) key: 10 -> KEY_RESERVED
	141	* 0x56 or 0x57 ( ) key: 11 -> KEY_RESERVED
	142	* 0x58 or 0x59 ( ) key: 12 -> KEY_RESERVED
	143	* 0x5a or 0x5b ( ) key: 13 -> KEY_RESERVED
	144	* 0x5c or 0x5d ( middle ) key: 14 -> KEY_ENTER
	145	* 0x5e or 0x5f ( >" ) key: 15 -> KEY_PLAYPAUSE
	146	*
	147	* Packets starting with 0x5 are part of a two-packets message,
	148	* we notify the caller by sending a negative value.
	149	*/
	150	int key = (data >> 1) & KEY_MASK;
	151
	152	if ((data & TWO_PACKETS_MASK))
	153	/* Part of a 2 packets-command */
	154	key = -key;
	155
	156	return key;
	157	}
	158
	159	static void key_up(struct hid_device hid, struct appleir appleir, int key)
	160	{
	161	input_report_key(appleir->input_dev, key, 0);
	162	input_sync(appleir->input_dev);
	163	}
	164
	165	static void key_down(struct hid_device hid, struct appleir appleir, int key)
	166	{
	167	input_report_key(appleir->input_dev, key, 1);
	168	input_sync(appleir->input_dev);
	169	}
	170
	171	static void battery_flat(struct appleir *appleir)
	172	{
	173	dev_err(&appleir->input_dev->dev, "possible flat battery?\n");
	174	}
	175
	176	static void key_up_tick(unsigned long data)
	177	{
	178	struct appleir appleir = (struct appleir )data;
	179	struct hid_device *hid = appleir->hid;
	180	unsigned long flags;
	181
	182	spin_lock_irqsave(&appleir->lock, flags);
	183	if (appleir->current_key) {
	184	key_up(hid, appleir, appleir->current_key);
	185	appleir->current_key = 0;
	186	}
	187	spin_unlock_irqrestore(&appleir->lock, flags);
	188	}
	189
	190	static int appleir_raw_event(struct hid_device hid, struct hid_report report,
	191	u8 *data, int len)
	192	{
	193	struct appleir *appleir = hid_get_drvdata(hid);
	194	static const u8 keydown[] = { 0x25, 0x87, 0xee };
	195	static const u8 keyrepeat[] = { 0x26, };
	196	static const u8 flatbattery[] = { 0x25, 0x87, 0xe0 };
	197	unsigned long flags;
	198
	199	if (len != 5)
	200	goto out;
	201
	202	if (!memcmp(data, keydown, sizeof(keydown))) {
	203	int index;
	204
	205	spin_lock_irqsave(&appleir->lock, flags);
	206	/*
	207	* If we already have a key down, take it up before marking
	208	* this one down
	209	*/
	210	if (appleir->current_key)
	211	key_up(hid, appleir, appleir->current_key);
	212
	213	/* Handle dual packet commands */
	214	if (appleir->prev_key_idx > 0)
	215	index = appleir->prev_key_idx;
	216	else
	217	index = get_key(data[4]);
	218
	219	if (index >= 0) {
	220	appleir->current_key = appleir->keymap[index];
	221
	222	key_down(hid, appleir, appleir->current_key);
	223	/*
	224	* Remote doesn't do key up, either pull them up, in
	225	* the test above, or here set a timer which pulls
	226	* them up after 1/8 s
	227	*/
	228	mod_timer(&appleir->key_up_timer, jiffies + HZ / 8);
	229	appleir->prev_key_idx = 0;
	230	} else
	231	/* Remember key for next packet */
	232	appleir->prev_key_idx = -index;
	233	spin_unlock_irqrestore(&appleir->lock, flags);
	234	goto out;
	235	}
	236
	237	appleir->prev_key_idx = 0;
	238
	239	if (!memcmp(data, keyrepeat, sizeof(keyrepeat))) {
	240	key_down(hid, appleir, appleir->current_key);
	241	/*
	242	* Remote doesn't do key up, either pull them up, in the test
	243	* above, or here set a timer which pulls them up after 1/8 s
	244	*/
	245	mod_timer(&appleir->key_up_timer, jiffies + HZ / 8);
	246	goto out;
	247	}
	248
	249	if (!memcmp(data, flatbattery, sizeof(flatbattery))) {
	250	battery_flat(appleir);
	251	/* Fall through */
	252	}
	253
	254	out:
	255	/* let hidraw and hiddev handle the report */
	256	return 0;
	257	}
	258
	259	static void appleir_input_configured(struct hid_device *hid,
	260	struct hid_input *hidinput)
	261	{
	262	struct input_dev *input_dev = hidinput->input;
	263	struct appleir *appleir = hid_get_drvdata(hid);
	264	int i;
	265
	266	appleir->input_dev = input_dev;
	267
	268	input_dev->keycode = appleir->keymap;
	269	input_dev->keycodesize = sizeof(unsigned short);
	270	input_dev->keycodemax = ARRAY_SIZE(appleir->keymap);
	271
	272	input_dev->evbit[0] = BIT(EV_KEY) \| BIT(EV_REP);
	273
	274	memcpy(appleir->keymap, appleir_key_table, sizeof(appleir->keymap));
	275	for (i = 0; i < ARRAY_SIZE(appleir_key_table); i++)
	276	set_bit(appleir->keymap[i], input_dev->keybit);
	277	clear_bit(KEY_RESERVED, input_dev->keybit);
	278	}
	279
	280	static int appleir_input_mapping(struct hid_device *hid,
	281	struct hid_input hi, struct hid_field field,
	282	struct hid_usage usage, unsigned long bit, int max)
	283	{
	284	return -1;
	285	}
	286
	287	static int appleir_probe(struct hid_device hid, const struct hid_device_id id)
	288	{
	289	int ret;
	290	struct appleir *appleir;
	291
	292	appleir = kzalloc(sizeof(struct appleir), GFP_KERNEL);
	293	if (!appleir) {
	294	ret = -ENOMEM;
	295	goto allocfail;
	296	}
	297
	298	appleir->hid = hid;
	299
	300	spin_lock_init(&appleir->lock);
	301	setup_timer(&appleir->key_up_timer,
	302	key_up_tick, (unsigned long) appleir);
	303
	304	hid_set_drvdata(hid, appleir);
	305
	306	ret = hid_parse(hid);
	307	if (ret) {
	308	hid_err(hid, "parse failed\n");
	309	goto fail;
	310	}
	311
	312	ret = hid_hw_start(hid, HID_CONNECT_DEFAULT \| HID_CONNECT_HIDDEV_FORCE);
	313	if (ret) {
	314	hid_err(hid, "hw start failed\n");
	315	goto fail;
	316	}
	317
	318	return 0;
	319	fail:
	320	kfree(appleir);
	321	allocfail:
	322	return ret;
	323	}
	324
	325	static void appleir_remove(struct hid_device *hid)
	326	{
	327	struct appleir *appleir = hid_get_drvdata(hid);
	328	hid_hw_stop(hid);
	329	del_timer_sync(&appleir->key_up_timer);
	330	kfree(appleir);
	331	}
	332
	333	static const struct hid_device_id appleir_devices[] = {
	334	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },
	335	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
	336	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
	337	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
	338	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
	339	{ }
	340	};
	341	MODULE_DEVICE_TABLE(hid, appleir_devices);
	342
	343	static struct hid_driver appleir_driver = {
	344	.name = "appleir",
	345	.id_table = appleir_devices,
	346	.raw_event = appleir_raw_event,
	347	.input_configured = appleir_input_configured,
	348	.probe = appleir_probe,
	349	.remove = appleir_remove,
	350	.input_mapping = appleir_input_mapping,
	351	};
	352	module_hid_driver(appleir_driver);

drivers/hid/hid-axff.c+2−4

 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 #ifdef CONFIG_HID_ACRUX_FF
-#include "usbhid/usbhid.h"
 struct axff_device {
 	struct hid_report *report;
 	}
 	dbg_hid("running with 0x%02x 0x%02x", left, right);
-	usbhid_submit_report(hid, axff->report, USB_DIR_OUT);
+	hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 		goto err_free_mem;
 	axff->report = report;
-	usbhid_submit_report(hid, axff->report, USB_DIR_OUT);
+	hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);
 	hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun <x0r@dv-life.ru>\n");

drivers/hid/hid-core.c+33−30

 		} else if (page == HID_UP_SENSOR &&
 			item.type == HID_ITEM_TYPE_MAIN &&
 			item.tag == HID_MAIN_ITEM_TAG_BEGIN_COLLECTION &&
-			(item_udata(&item) & 0xff) == HID_COLLECTION_PHYSICAL &&
+			(item_udata(&item) & 0xff) == HID_COLLECTION_PHYSICAL)
-			(hid->bus == BUS_USB || hid->bus == BUS_I2C))
 			hid->group = HID_GROUP_SENSOR_HUB;
 	}
 	struct hid_report_enum *report_enum;
 	struct hid_driver *hdrv;
 	struct hid_report *report;
-	char *buf;
-	unsigned int i;
 	int ret = 0;
 	if (!hid)
 		return -ENODEV;
-	if (down_trylock(&hid->driver_lock))
+	if (down_trylock(&hid->driver_input_lock))
 		return -EBUSY;
 	if (!hid->driver) {
 	}
 	/* Avoid unnecessary overhead if debugfs is disabled */
-	if (list_empty(&hid->debug_list))
+	if (!list_empty(&hid->debug_list))
-		goto nomem;
+		hid_dump_report(hid, type, data, size);
-	buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
-	if (!buf)
-		goto nomem;
-	/* dump the report */
-	snprintf(buf, HID_DEBUG_BUFSIZE - 1,
-			"\nreport (size %u) (%snumbered) = ", size, report_enum->numbered ? "" : "un");
-	hid_debug_event(hid, buf);
-	for (i = 0; i < size; i++) {
-		snprintf(buf, HID_DEBUG_BUFSIZE - 1,
-				" %02x", data[i]);
-		hid_debug_event(hid, buf);
-	}
-	hid_debug_event(hid, "\n");
-	kfree(buf);
-nomem:
 	report = hid_get_report(report_enum, data);
 	if (!report) {
 	ret = hid_report_raw_event(hid, type, data, size, interrupt);
 unlock:
-	up(&hid->driver_lock);
+	up(&hid->driver_input_lock);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
 	{ 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_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
-	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
 	{ HID_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_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_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_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_KONEPLUS) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
 	{ 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_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) },
 	{ }
 };
 	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);
 		}
 	}
 unlock:
+	if (!hdev->io_started)
+		up(&hdev->driver_input_lock);
+unlock_driver_lock:
 	up(&hdev->driver_lock);
 	return ret;
 }
 {
 	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) {
 		hdev->driver = NULL;
 	}
+	if (!hdev->io_started)
+		up(&hdev->driver_input_lock);
+unlock_driver_lock:
 	up(&hdev->driver_lock);
-	return 0;
+	return ret;
 }
 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 	init_waitqueue_head(&hdev->debug_wait);
 	INIT_LIST_HEAD(&hdev->debug_list);
+	mutex_init(&hdev->debug_list_lock);
 	sema_init(&hdev->driver_lock, 1);
+	sema_init(&hdev->driver_input_lock, 1);
 	return hdev;
 }

drivers/hid/hid-debug.c+36−0

@@ -580,17 +580,49 @@ void hid_debug_event(struct hid_device hdev, char buf) · 579 unmodified lines
580	int i;	580	int i;
581	struct hid_debug_list *list;	581	struct hid_debug_list *list;
582		582
		583	mutex_lock(&hdev->debug_list_lock);
583	list_for_each_entry(list, &hdev->debug_list, node) {	584	list_for_each_entry(list, &hdev->debug_list, node) {
584	for (i = 0; i < strlen(buf); i++)	585	for (i = 0; i < strlen(buf); i++)
585	list->hid_debug_buf[(list->tail + i) % HID_DEBUG_BUFSIZE] =	586	list->hid_debug_buf[(list->tail + i) % HID_DEBUG_BUFSIZE] =
586	buf[i];	587	buf[i];
587	list->tail = (list->tail + i) % HID_DEBUG_BUFSIZE;	588	list->tail = (list->tail + i) % HID_DEBUG_BUFSIZE;
588	}	589	}
		590	mutex_unlock(&hdev->debug_list_lock);
589		591
590	wake_up_interruptible(&hdev->debug_wait);	592	wake_up_interruptible(&hdev->debug_wait);
591	}	593	}
592	EXPORT_SYMBOL_GPL(hid_debug_event);	594	EXPORT_SYMBOL_GPL(hid_debug_event);
593		595
		596	void hid_dump_report(struct hid_device hid, int type, u8 data,
		597	int size)
		598	{
		599	struct hid_report_enum *report_enum;
		600	char *buf;
		601	unsigned int i;
		602
		603	buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
		604
		605	if (!buf)
		606	return;
		607
		608	report_enum = hid->report_enum + type;
		609
		610	/* dump the report */
		611	snprintf(buf, HID_DEBUG_BUFSIZE - 1,
		612	"\nreport (size %u) (%snumbered) = ", size,
		613	report_enum->numbered ? "" : "un");
		614	hid_debug_event(hid, buf);
		615
		616	for (i = 0; i < size; i++) {
		617	snprintf(buf, HID_DEBUG_BUFSIZE - 1,
		618	" %02x", data[i]);
		619	hid_debug_event(hid, buf);
		620	}
		621	hid_debug_event(hid, "\n");
		622	kfree(buf);
		623	}
		624	EXPORT_SYMBOL_GPL(hid_dump_report);
		625
594	void hid_dump_input(struct hid_device hdev, struct hid_usage usage, __s32 value)	626	void hid_dump_input(struct hid_device hdev, struct hid_usage usage, __s32 value)
595	{	627	{
596	char *buf;	628	char *buf;
@@ -960,7 +992,9 @@ static int hid_debug_events_open(struct inode inode, struct file file) · 363 unmodified lines
960	file->private_data = list;	992	file->private_data = list;
961	mutex_init(&list->read_mutex);	993	mutex_init(&list->read_mutex);
962		994
		995	mutex_lock(&list->hdev->debug_list_lock);
963	list_add_tail(&list->node, &list->hdev->debug_list);	996	list_add_tail(&list->node, &list->hdev->debug_list);
		997	mutex_unlock(&list->hdev->debug_list_lock);
964		998
965	out:	999	out:
966	return err;	1000	return err;
@@ -1055,7 +1089,9 @@ static int hid_debug_events_release(struct inode inode, struct file file) · 88 unmodified lines
1055	{	1089	{
1056	struct hid_debug_list *list = file->private_data;	1090	struct hid_debug_list *list = file->private_data;
1057		1091
		1092	mutex_lock(&list->hdev->debug_list_lock);
1058	list_del(&list->node);	1093	list_del(&list->node);
		1094	mutex_unlock(&list->hdev->debug_list_lock);
1059	kfree(list->hid_debug_buf);	1095	kfree(list->hid_debug_buf);
1060	kfree(list);	1096	kfree(list);
1061		1097

drivers/hid/hid-dr.c+3−5

 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 #ifdef CONFIG_DRAGONRISE_FF
-#include "usbhid/usbhid.h"
 struct drff_device {
 	struct hid_report *report;
 		drff->report->field[0]->value[1] = 0x00;
 		drff->report->field[0]->value[2] = weak;
 		drff->report->field[0]->value[4] = strong;
-		usbhid_submit_report(hid, drff->report, USB_DIR_OUT);
+		hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
 		drff->report->field[0]->value[0] = 0xfa;
 		drff->report->field[0]->value[1] = 0xfe;
 	drff->report->field[0]->value[2] = 0x00;
 	drff->report->field[0]->value[4] = 0x00;
 	dbg_hid("running with 0x%02x 0x%02x", strong, weak);
-	usbhid_submit_report(hid, drff->report, USB_DIR_OUT);
+	hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	drff->report->field[0]->value[4] = 0x00;
 	drff->report->field[0]->value[5] = 0x00;
 	drff->report->field[0]->value[6] = 0x00;
-	usbhid_submit_report(hid, drff->report, USB_DIR_OUT);
+	hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
 	hid_info(hid, "Force Feedback for DragonRise Inc. "
 		 "game controllers by Richard Walmsley <richwalm@gmail.com>\n");

drivers/hid/hid-emsff.c+2−4

 #include <linux/hid.h>
 #include <linux/input.h>
-#include <linux/usb.h>
 #include <linux/module.h>
 #include "hid-ids.h"
-#include "usbhid/usbhid.h"
 struct emsff_device {
 	struct hid_report *report;
 	emsff->report->field[0]->value[2] = strong;
 	dbg_hid("running with 0x%02x 0x%02x\n", strong, weak);
-	usbhid_submit_report(hid, emsff->report, USB_DIR_OUT);
+	hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	emsff->report->field[0]->value[4] = 0x00;
 	emsff->report->field[0]->value[5] = 0x00;
 	emsff->report->field[0]->value[6] = 0x00;
-	usbhid_submit_report(hid, emsff->report, USB_DIR_OUT);
+	hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
 	hid_info(hid, "force feedback for EMS based devices by Ignaz Forster <ignaz.forster@gmx.de>\n");

drivers/hid/hid-gaff.c+4−6

 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 #ifdef CONFIG_GREENASIA_FF
-#include "usbhid/usbhid.h"
 struct gaff_device {
 	struct hid_report *report;
 	gaff->report->field[0]->value[4] = left;
 	gaff->report->field[0]->value[5] = 0;
 	dbg_hid("running with 0x%02x 0x%02x", left, right);
-	usbhid_submit_report(hid, gaff->report, USB_DIR_OUT);
+	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
 	gaff->report->field[0]->value[0] = 0xfa;
 	gaff->report->field[0]->value[1] = 0xfe;
 	gaff->report->field[0]->value[2] = 0x0;
 	gaff->report->field[0]->value[4] = 0x0;
-	usbhid_submit_report(hid, gaff->report, USB_DIR_OUT);
+	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	gaff->report->field[0]->value[1] = 0x00;
 	gaff->report->field[0]->value[2] = 0x00;
 	gaff->report->field[0]->value[3] = 0x00;
-	usbhid_submit_report(hid, gaff->report, USB_DIR_OUT);
+	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
 	gaff->report->field[0]->value[0] = 0xfa;
 	gaff->report->field[0]->value[1] = 0xfe;
-	usbhid_submit_report(hid, gaff->report, USB_DIR_OUT);
+	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
 	hid_info(hid, "Force Feedback for GreenAsia 0x12 devices by Lukasz Lubojanski <lukasz@lubojanski.info>\n");

drivers/hid/hid-holtekff.c+1−3

 #include <linux/input.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include "hid-ids.h"
 #ifdef CONFIG_HOLTEK_FF
-#include "usbhid/usbhid.h"
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Anssi Hannula <anssi.hannula@iki.fi>");
 	dbg_hid("sending %*ph\n", 7, data);
-	usbhid_submit_report(hid, holtekff->field->report, USB_DIR_OUT);
+	hid_hw_request(hid, holtekff->field->report, HID_REQ_SET_REPORT);
 }
 static int holtekff_play(struct input_dev *dev, void *data,

drivers/hid/hid-icade.c+1−1

@@ -159,7 +159,7 @@ static const struct icade_key icade_usage_table[30] = { · 158 unmodified lines
159		159
160	static const struct icade_key *icade_find_translation(u16 from)	160	static const struct icade_key *icade_find_translation(u16 from)
161	{	161	{
162	if (from < 0 \|\| from > ICADE_MAX_USAGE)	162	if (from > ICADE_MAX_USAGE)
163	return NULL;	163	return NULL;
164	return &icade_usage_table[from];	164	return &icade_usage_table[from];
165	}	165	}

drivers/hid/hid-ids.h+8−1

 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO   0x0256
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY	0x030a
 #define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY	0x030b
-#define USB_DEVICE_ID_APPLE_ATV_IRCONTROL	0x8241
+#define USB_DEVICE_ID_APPLE_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_SIDEWINDER_GV	0x003b
 #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
 #define USB_DEVICE_ID_MS_NE4K		0x00db
+#define USB_DEVICE_ID_MS_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_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_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_KONEXTD	0x2e22
 #define USB_DEVICE_ID_ROCCAT_KOVAPLUS	0x2d50
 #define USB_DEVICE_ID_ROCCAT_LUA	0x2c2e

drivers/hid/hid-input.c+77−0

@@ -1198,6 +1198,67 @@ static struct hid_input hidinput_allocate(struct hid_device hid) · 1197 unmodified lines
1198	return hidinput;	1198	return hidinput;
1199	}	1199	}
1200		1200
		1201	static bool hidinput_has_been_populated(struct hid_input *hidinput)
		1202	{
		1203	int i;
		1204	unsigned long r = 0;
		1205
		1206	for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
		1207	r \|= hidinput->input->evbit[i];
		1208
		1209	for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
		1210	r \|= hidinput->input->keybit[i];
		1211
		1212	for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
		1213	r \|= hidinput->input->relbit[i];
		1214
		1215	for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
		1216	r \|= hidinput->input->absbit[i];
		1217
		1218	for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
		1219	r \|= hidinput->input->mscbit[i];
		1220
		1221	for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
		1222	r \|= hidinput->input->ledbit[i];
		1223
		1224	for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
		1225	r \|= hidinput->input->sndbit[i];
		1226
		1227	for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
		1228	r \|= hidinput->input->ffbit[i];
		1229
		1230	for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
		1231	r \|= hidinput->input->swbit[i];
		1232
		1233	return !!r;
		1234	}
		1235
		1236	static void hidinput_cleanup_hidinput(struct hid_device *hid,
		1237	struct hid_input *hidinput)
		1238	{
		1239	struct hid_report *report;
		1240	int i, k;
		1241
		1242	list_del(&hidinput->list);
		1243	input_free_device(hidinput->input);
		1244
		1245	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
		1246	if (k == HID_OUTPUT_REPORT &&
		1247	hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
		1248	continue;
		1249
		1250	list_for_each_entry(report, &hid->report_enum[k].report_list,
		1251	list) {
		1252
		1253	for (i = 0; i < report->maxfield; i++)
		1254	if (report->field[i]->hidinput == hidinput)
		1255	report->field[i]->hidinput = NULL;
		1256	}
		1257	}
		1258
		1259	kfree(hidinput);
		1260	}
		1261
1201	/*	1262	/*
1202	* Register the input device; print a message.	1263	* Register the input device; print a message.
1203	* Configure the input layer interface	1264	* Configure the input layer interface
@@ -1249,6 +1310,10 @@ int hidinput_connect(struct hid_device *hid, unsigned int force) · 45 unmodified lines
1249	hidinput_configure_usage(hidinput, report->field[i],	1310	hidinput_configure_usage(hidinput, report->field[i],
1250	report->field[i]->usage + j);	1311	report->field[i]->usage + j);
1251		1312
		1313	if ((hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) &&
		1314	!hidinput_has_been_populated(hidinput))
		1315	continue;
		1316
1252	if (hid->quirks & HID_QUIRK_MULTI_INPUT) {	1317	if (hid->quirks & HID_QUIRK_MULTI_INPUT) {
1253	/* This will leave hidinput NULL, so that it	1318	/* This will leave hidinput NULL, so that it
1254	* allocates another one if we have more inputs on	1319	* allocates another one if we have more inputs on
@@ -1265,6 +1330,18 @@ int hidinput_connect(struct hid_device *hid, unsigned int force) · 10 unmodified lines
1265	}	1330	}
1266	}	1331	}
1267		1332
		1333	if (hidinput && (hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) &&
		1334	!hidinput_has_been_populated(hidinput)) {
		1335	/* no need to register an input device not populated */
		1336	hidinput_cleanup_hidinput(hid, hidinput);
		1337	hidinput = NULL;
		1338	}
		1339
		1340	if (list_empty(&hid->inputs)) {
		1341	hid_err(hid, "No inputs registered, leaving\n");
		1342	goto out_unwind;
		1343	}
		1344
1268	if (hidinput) {	1345	if (hidinput) {
1269	if (drv->input_configured)	1346	if (drv->input_configured)
1270	drv->input_configured(hid, hidinput);	1347	drv->input_configured(hid, hidinput);

drivers/hid/hid-kye.c+1−3

 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
-#include <linux/usb.h>
-#include "usbhid/usbhid.h"
 #include "hid-ids.h"
 	value[4] = 0x00;
 	value[5] = 0x00;
 	value[6] = 0x00;
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	return 0;
 }

drivers/hid/hid-lenovo-tpkbd.c+2−4

 	report->field[2]->value[0] = data_pointer->sensitivity;
 	report->field[3]->value[0] = data_pointer->press_speed;
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev);
-	data_pointer = hid_get_drvdata(hdev);
 	return snprintf(buf, PAGE_SIZE, "%u\n",
 		data_pointer->press_speed);
 }
 	report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3];
 	report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1;
 	report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1;
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 }
 static int tpkbd_probe_tp(struct hid_device *hdev)

drivers/hid/hid-lg2ff.c+2−4

 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
 #include "hid-lg.h"
 struct lg2ff_device {
 		lg2ff->report->field[0]->value[4] = 0x00;
 	}
-	usbhid_submit_report(hid, lg2ff->report, USB_DIR_OUT);
+	hid_hw_request(hid, lg2ff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	report->field[0]->value[5] = 0x00;
 	report->field[0]->value[6] = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 	hid_info(hid, "Force feedback for Logitech RumblePad/Rumblepad 2 by Anssi Hannula <anssi.hannula@gmail.com>\n");

drivers/hid/hid-lg3ff.c+2−4

 #include <linux/input.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
 #include "hid-lg.h"
 /*
 		report->field[0]->value[1] = (unsigned char)(-x);
 		report->field[0]->value[31] = (unsigned char)(-y);
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 		break;
 	}
 	return 0;
 	report->field[0]->value[33] = 0x7F;
 	report->field[0]->value[34] = 0x7F;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }

drivers/hid/hid-lg4ff.c+11−9

 #define DFGT_REV_MAJ 0x13
 #define DFGT_REV_MIN 0x22
+#define DFGT2_REV_MIN 0x26
 #define DFP_REV_MAJ 0x11
 #define DFP_REV_MIN 0x06
 #define FFEX_REV_MAJ 0x21
 static const struct lg4ff_usb_revision lg4ff_revs[] = {
 	{DFGT_REV_MAJ, DFGT_REV_MIN, &native_dfgt},	/* Driving Force GT */
+	{DFGT_REV_MAJ, DFGT2_REV_MIN, &native_dfgt},	/* Driving Force GT v2 */
 	{DFP_REV_MAJ,  DFP_REV_MIN,  &native_dfp},	/* Driving Force Pro */
 	{G25_REV_MAJ,  G25_REV_MIN,  &native_g25},	/* G25 */
 	{G27_REV_MAJ,  G27_REV_MIN,  &native_g27},	/* G27 */
 		value[5] = 0x00;
 		value[6] = 0x00;
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 		break;
 	}
 	return 0;
 	value[5] = 0x00;
 	value[6] = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 /* Sends autocentering command compatible with Formula Force EX */
 	value[5] = 0x00;
 	value[6] = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 /* Sends command to set range compatible with G25/G27/Driving Force GT */
 	value[5] = 0x00;
 	value[6] = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 /* Sends commands to set range compatible with Driving Force Pro wheel */
 		report->field[0]->value[1] = 0x02;
 		full_range = 200;
 	}
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 	/* Prepare "fine" limit command */
 	value[0] = 0x81;
 	value[6] = 0x00;
 	if (range == 200 || range == 900) {	/* Do not apply any fine limit */
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 		return;
 	}
 	value[5] = (start_right & 0xe) << 4 | (start_left & 0xe);
 	value[6] = 0xff;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 static void hid_lg4ff_switch_native(struct hid_device *hid, const struct lg4ff_native_cmd *cmd)
 		for (i = 0; i < 7; i++)
 			report->field[0]->value[i] = cmd->cmd[j++];
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 	}
 }
 	value[4] = 0x00;
 	value[5] = 0x00;
 	value[6] = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 static void lg4ff_led_set_brightness(struct led_classdev *led_cdev,

drivers/hid/hid-lgff.c+3−5

 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/input.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
 #include "hid-lg.h"
 struct dev_type {
 		report->field[0]->value[2] = x;
 		report->field[0]->value[3] = y;
 		dbg_hid("(x, y)=(%04x, %04x)\n", x, y);
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 		break;
 	case FF_RUMBLE:
 		report->field[0]->value[2] = left;
 		report->field[0]->value[3] = right;
 		dbg_hid("(left, right)=(%04x, %04x)\n", left, right);
-		usbhid_submit_report(hid, report, USB_DIR_OUT);
+		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 		break;
 	}
 	return 0;
 	*value++ = 0x80;
 	*value++ = 0x00;
 	*value = 0x00;
-	usbhid_submit_report(hid, report, USB_DIR_OUT);
+	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
 }
 int lgff_init(struct hid_device* hid)

drivers/hid/hid-logitech-dj.c+5−48

 #include <linux/module.h>
 #include <linux/usb.h>
 #include <asm/unaligned.h>
-#include "usbhid/usbhid.h"
 #include "hid-ids.h"
 #include "hid-logitech-dj.h"
 static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
 					size_t count,
 					unsigned char report_type);
-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)
 	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;
 	}
 		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",
 	struct dj_report dj_report;
 	unsigned long flags;
 	int count;
-	int retval;
 	dbg_hid("%s\n", __func__);
 		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__);
 	}
 }
 	if (!djdev) {
 		dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
 			" is NULL, index %d\n", dj_report->device_index);
-		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__);
-		}
 		return;
 	}
 	if (dj_device == NULL) {
 		dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
 			" is NULL, index %d\n", dj_report->device_index);
-		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__);
-		}
 		return;
 	}
 	for (i = 0; i < report->field[0]->report_count; i++)
 		report->field[0]->value[i] = data[i];
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	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;
 	return retval;
 }
 static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
 					  unsigned timeout)
 {
 	hid_set_field(report->field[0], 1, REPORT_TYPE_LEDS);
 	hid_set_field(report->field[0], 2, data[1]);
-	usbhid_submit_report(dj_rcv_hiddev, report, USB_DIR_OUT);
+	hid_hw_request(dj_rcv_hiddev, report, HID_REQ_SET_REPORT);
 	return 0;
 		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 "

drivers/hid/hid-logitech-dj.h+0−1

@@ -101,7 +101,6 @@ struct dj_receiver_dev { · 100 unmodified lines
101	struct work_struct work;	101	struct work_struct work;
102	struct kfifo notif_fifo;	102	struct kfifo notif_fifo;
103	spinlock_t lock;	103	spinlock_t lock;
104	bool querying_devices;
105	};	104	};
106		105
107	struct dj_device {	106	struct dj_device {

drivers/hid/hid-magicmouse.c+0−1

@@ -19,7 +19,6 @@ · 18 unmodified lines
19	#include <linux/input/mt.h>	19	#include <linux/input/mt.h>
20	#include <linux/module.h>	20	#include <linux/module.h>
21	#include <linux/slab.h>	21	#include <linux/slab.h>
22	#include <linux/usb.h>
23		22
24	#include "hid-ids.h"	23	#include "hid-ids.h"
25		24

drivers/hid/hid-microsoft.c+2−0

 		.driver_data = MS_HIDINPUT },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
 		.driver_data = MS_ERGONOMY },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
+		.driver_data = MS_ERGONOMY },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
 		.driver_data = MS_ERGONOMY | MS_RDESC },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),

drivers/hid/hid-multitouch.c+193−80

  *  HID driver for multitouch panels
  *
  *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
- *  Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
+ *  Copyright (c) 2010-2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>
  *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
+ *  Copyright (c) 2012-2013 Red Hat, Inc
  *
  *  This code is partly based on hid-egalax.c:
  *
  * any later version.
  */
+/*
+ * This driver is regularly tested thanks to the tool hid-test[1].
+ * This tool relies on hid-replay[2] and a database of hid devices[3].
+ * Please run these regression tests before patching this module so that
+ * your patch won't break existing known devices.
+ *
+ * [1] https://github.com/bentiss/hid-test
+ * [2] https://github.com/bentiss/hid-replay
+ * [3] https://github.com/bentiss/hid-devices
+ */
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/usb.h>
 #include <linux/input/mt.h>
-#include "usbhid/usbhid.h"
+#include <linux/string.h>
 MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
 					   multitouch fields */
 	int cc_index;	/* contact count field index in the report */
 	int cc_value_index;	/* contact count value index in the field */
-	unsigned last_field_index;	/* last field index of the report */
 	unsigned last_slot_field;	/* the last field of a slot */
 	unsigned mt_report_id;	/* the report ID of the multitouch device */
+	unsigned pen_report_id;	/* the report ID of the pen device */
 	__s8 inputmode;		/* InputMode HID feature, -1 if non-existent */
 	__s8 inputmode_index;	/* InputMode HID feature index in the report */
 	__s8 maxcontact_report_id;	/* Maximum Contact Number HID feature,
 	unsigned mt_flags;	/* flags to pass to input-mt */
 };
+static void mt_post_parse_default_settings(struct mt_device *td);
+static void mt_post_parse(struct mt_device *td);
 /* classes of device behavior */
 #define MT_CLS_DEFAULT				0x0001
 	{ }
 };
+static void mt_free_input_name(struct hid_input *hi)
+{
+	struct hid_device *hdev = hi->report->device;
+	if (hi->input->name != hdev->name)
+		kfree(hi->input->name);
+}
 static ssize_t mt_show_quirks(struct device *dev,
 			   struct device_attribute *attr,
 			   char *buf)
 	f->usages[f->length++] = usage->hid;
 }
-static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+static int mt_pen_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+		struct hid_field *field, struct hid_usage *usage,
+		unsigned long **bit, int *max)
+{
+	struct mt_device *td = hid_get_drvdata(hdev);
+	td->pen_report_id = field->report->id;
+	return 0;
+}
+static int mt_pen_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+		struct hid_field *field, struct hid_usage *usage,
+		unsigned long **bit, int *max)
+{
+	return 0;
+}
+static int mt_pen_event(struct hid_device *hid, struct hid_field *field,
+				struct hid_usage *usage, __s32 value)
+{
+	/* let hid-input handle it */
+	return 0;
+}
+static void mt_pen_report(struct hid_device *hid, struct hid_report *report)
+{
+	struct hid_field *field = report->field[0];
+	input_sync(field->hidinput->input);
+}
+static void mt_pen_input_configured(struct hid_device *hdev,
+					struct hid_input *hi)
+{
+	char *name = kzalloc(strlen(hi->input->name) + 5, GFP_KERNEL);
+	if (name) {
+		sprintf(name, "%s Pen", hi->input->name);
+		mt_free_input_name(hi);
+		hi->input->name = name;
+	}
+	/* force BTN_STYLUS to allow tablet matching in udev */
+	__set_bit(BTN_STYLUS, hi->input->keybit);
+}
+static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 		struct hid_field *field, struct hid_usage *usage,
 		unsigned long **bit, int *max)
 {
 	int code;
 	struct hid_usage *prev_usage = NULL;
-	/* Only map fields from TouchScreen or TouchPad collections.
-	* We need to ignore fields that belong to other collections
-	* such as Mouse that might have the same GenericDesktop usages. */
 	if (field->application == HID_DG_TOUCHSCREEN)
 		td->mt_flags |= INPUT_MT_DIRECT;
-	else if (field->application != HID_DG_TOUCHPAD)
-		return 0;
 	/*
 	 * Model touchscreens providing buttons as touchpads.
 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
 		td->mt_flags |= INPUT_MT_POINTER;
-	/* eGalax devices provide a Digitizer.Stylus input which overrides
-	 * the correct Digitizers.Finger X/Y ranges.
-	 * Let's just ignore this input. */
-	if (field->physical == HID_DG_STYLUS)
-		return -1;
 	if (usage->usage_index)
 		prev_usage = &field->usage[usage->usage_index - 1];
 			}
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_GD_Y:
 			if (prev_usage && (prev_usage->hid == usage->hid)) {
 			}
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		}
 		return 0;
 					ABS_MT_DISTANCE, 0, 1, 0, 0);
 			}
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_CONFIDENCE:
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_TIPSWITCH:
 			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
 			input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_CONTACTID:
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			td->touches_by_report++;
 			td->mt_report_id = field->report->id;
 			return 1;
 				set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
 					cls->sn_width);
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_HEIGHT:
 			hid_map_usage(hi, usage, bit, max,
 					ABS_MT_ORIENTATION, 0, 1, 0, 0);
 			}
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_TIPPRESSURE:
 			hid_map_usage(hi, usage, bit, max,
 			set_abs(hi->input, ABS_MT_PRESSURE, field,
 				cls->sn_pressure);
 			mt_store_field(usage, td, hi);
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_CONTACTCOUNT:
 			td->cc_index = field->index;
 			td->cc_value_index = usage->usage_index;
-			td->last_field_index = field->index;
 			return 1;
 		case HID_DG_CONTACTMAX:
 			/* we don't set td->last_slot_field as contactcount and
 			 * contact max are global to the report */
-			td->last_field_index = field->index;
 			return -1;
 		case HID_DG_TOUCH:
 			/* Legacy devices use TIPSWITCH and not TOUCH.
 	return 0;
 }
-static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+static int mt_touch_input_mapped(struct hid_device *hdev, struct hid_input *hi,
 		struct hid_field *field, struct hid_usage *usage,
 		unsigned long **bit, int *max)
 {
 	td->num_received = 0;
 }
-static int mt_event(struct hid_device *hid, struct hid_field *field,
+static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
 				struct hid_usage *usage, __s32 value)
 {
 	/* we will handle the hidinput part later, now remains hiddev */
 		if (usage->usage_index + 1 == field->report_count) {
 			/* we only take into account the last report. */
 			if (usage->hid == td->last_slot_field)
-				mt_complete_slot(td, input);
+				mt_complete_slot(td, field->hidinput->input);
-			if (field->index == td->last_field_index
-				&& td->num_received >= td->num_expected)
-				mt_sync_frame(td, field->hidinput->input);
 		}
 	}
 }
-static void mt_report(struct hid_device *hid, struct hid_report *report)
+static void mt_touch_report(struct hid_device *hid, struct hid_report *report)
 {
 	struct mt_device *td = hid_get_drvdata(hid);
 	struct hid_field *field;
 	unsigned count;
 	int r, n;
-	if (report->id != td->mt_report_id)
-		return;
-	if (!(hid->claimed & HID_CLAIMED_INPUT))
-		return;
 	/*
 	 * Includes multi-packet support where subsequent
 	 * packets are sent with zero contactcount.
 			mt_process_mt_event(hid, field, &field->usage[n],
 					field->value[n]);
 	}
+	if (td->num_received >= td->num_expected)
+		mt_sync_frame(td, report->field[0]->hidinput->input);
+}
+static void mt_touch_input_configured(struct hid_device *hdev,
+					struct hid_input *hi)
+{
+	struct mt_device *td = hid_get_drvdata(hdev);
+	struct mt_class *cls = &td->mtclass;
+	struct input_dev *input = hi->input;
+	if (!td->maxcontacts)
+		td->maxcontacts = MT_DEFAULT_MAXCONTACT;
+	mt_post_parse(td);
+	if (td->serial_maybe)
+		mt_post_parse_default_settings(td);
+	if (cls->is_indirect)
+		td->mt_flags |= INPUT_MT_POINTER;
+	if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
+		td->mt_flags |= INPUT_MT_DROP_UNUSED;
+	input_mt_init_slots(input, td->maxcontacts, td->mt_flags);
+	td->mt_flags = 0;
+}
+static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+		struct hid_field *field, struct hid_usage *usage,
+		unsigned long **bit, int *max)
+{
+	/* Only map fields from TouchScreen or TouchPad collections.
+	* We need to ignore fields that belong to other collections
+	* such as Mouse that might have the same GenericDesktop usages. */
+	if (field->application != HID_DG_TOUCHSCREEN &&
+	    field->application != HID_DG_PEN &&
+	    field->application != HID_DG_TOUCHPAD)
+		return -1;
+	if (field->physical == HID_DG_STYLUS)
+		return mt_pen_input_mapping(hdev, hi, field, usage, bit, max);
+	return mt_touch_input_mapping(hdev, hi, field, usage, bit, max);
+}
+static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+		struct hid_field *field, struct hid_usage *usage,
+		unsigned long **bit, int *max)
+{
+	if (field->physical == HID_DG_STYLUS)
+		return mt_pen_input_mapped(hdev, hi, field, usage, bit, max);
+	return mt_touch_input_mapped(hdev, hi, field, usage, bit, max);
+}
+static int mt_event(struct hid_device *hid, struct hid_field *field,
+				struct hid_usage *usage, __s32 value)
+{
+	struct mt_device *td = hid_get_drvdata(hid);
+	if (field->report->id == td->mt_report_id)
+		return mt_touch_event(hid, field, usage, value);
+	if (field->report->id == td->pen_report_id)
+		return mt_pen_event(hid, field, usage, value);
+	/* ignore other reports */
+	return 1;
+}
+static void mt_report(struct hid_device *hid, struct hid_report *report)
+{
+	struct mt_device *td = hid_get_drvdata(hid);
+	if (!(hid->claimed & HID_CLAIMED_INPUT))
+		return;
+	if (report->id == td->mt_report_id)
+		mt_touch_report(hid, report);
+	if (report->id == td->pen_report_id)
+		mt_pen_report(hid, report);
 }
 static void mt_set_input_mode(struct hid_device *hdev)
 	r = re->report_id_hash[td->inputmode];
 	if (r) {
 		r->field[0]->value[td->inputmode_index] = 0x02;
-		usbhid_submit_report(hdev, r, USB_DIR_OUT);
+		hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
 	}
 }
 		max = min(fieldmax, max);
 		if (r->field[0]->value[0] != max) {
 			r->field[0]->value[0] = max;
-			usbhid_submit_report(hdev, r, USB_DIR_OUT);
+			hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
 		}
 	}
 }
 }
 static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
 {
 	struct mt_device *td = hid_get_drvdata(hdev);
-	struct mt_class *cls = &td->mtclass;
+	char *name = kstrdup(hdev->name, GFP_KERNEL);
-	struct input_dev *input = hi->input;
-	/* Only initialize slots for MT input devices */
+	if (name)
-	if (!test_bit(ABS_MT_POSITION_X, input->absbit))
+		hi->input->name = name;
-		return;
-	if (!td->maxcontacts)
+	if (hi->report->id == td->mt_report_id)
-		td->maxcontacts = MT_DEFAULT_MAXCONTACT;
+		mt_touch_input_configured(hdev, hi);
-	mt_post_parse(td);
+	if (hi->report->id == td->pen_report_id)
-	if (td->serial_maybe)
+		mt_pen_input_configured(hdev, hi);
-		mt_post_parse_default_settings(td);
-	if (cls->is_indirect)
-		td->mt_flags |= INPUT_MT_POINTER;
-	if (cls->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
-		td->mt_flags |= INPUT_MT_DROP_UNUSED;
-	input_mt_init_slots(input, td->maxcontacts, td->mt_flags);
-	td->mt_flags = 0;
 }
 static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
 	int ret, i;
 	struct mt_device *td;
 	struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
+	struct hid_input *hi;
 	for (i = 0; mt_classes[i].name ; i++) {
 		if (id->driver_data == mt_classes[i].name) {
 	 */
 	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
+	/*
+	 * This allows the driver to handle different input sensors
+	 * that emits events through different reports on the same HID
+	 * device.
+	 */
+	hdev->quirks |= HID_QUIRK_MULTI_INPUT;
+	hdev->quirks |= HID_QUIRK_NO_EMPTY_INPUT;
 	td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
 	if (!td) {
 		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
 	td->inputmode = -1;
 	td->maxcontact_report_id = -1;
 	td->cc_index = -1;
+	td->mt_report_id = -1;
+	td->pen_report_id = -1;
 	hid_set_drvdata(hdev, td);
 	td->fields = kzalloc(sizeof(struct mt_fields), GFP_KERNEL);
 	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 	if (ret)
-		goto fail;
+		goto hid_fail;
 	ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
 	return 0;
+hid_fail:
+	list_for_each_entry(hi, &hdev->inputs, list)
+		mt_free_input_name(hi);
 fail:
 	kfree(td->fields);
 	kfree(td);
 static int mt_resume(struct hid_device *hdev)
 {
-	struct usb_interface *intf;
-	struct usb_host_interface *interface;
-	struct usb_device *dev;
-	if (hdev->bus != BUS_USB)
-		return 0;
-	intf = to_usb_interface(hdev->dev.parent);
-	interface = intf->cur_altsetting;
-	dev = hid_to_usb_dev(hdev);
 	/* Some Elan legacy devices require SET_IDLE to be set on resume.
 	 * It should be safe to send it to other devices too.
 	 * Tested on 3M, Stantum, Cypress, Zytronic, eGalax, and Elan panels. */
-	usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+	hid_hw_idle(hdev, 0, 0, HID_REQ_SET_IDLE);
-			HID_REQ_SET_IDLE,
-			USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-			0, interface->desc.bInterfaceNumber,
-			NULL, 0, USB_CTRL_SET_TIMEOUT);
 	return 0;
 }
 static void mt_remove(struct hid_device *hdev)
 {
 	struct mt_device *td = hid_get_drvdata(hdev);
+	struct hid_input *hi;
 	sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
 	hid_hw_stop(hdev);
+	list_for_each_entry(hi, &hdev->inputs, list)
+		mt_free_input_name(hi);
 	kfree(td);
 	hid_set_drvdata(hdev, NULL);
 }

drivers/hid/hid-ntrig.c+5−5

@@ -118,8 +118,8 @@ static inline int ntrig_get_mode(struct hid_device *hdev) · 117 unmodified lines
118	if (!report)	118	if (!report)
119	return -EINVAL;	119	return -EINVAL;
120		120
121	usbhid_submit_report(hdev, report, USB_DIR_IN);	121	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
122	usbhid_wait_io(hdev);	122	hid_hw_wait(hdev);
123	return (int)report->field[0]->value[0];	123	return (int)report->field[0]->value[0];
124	}	124	}
125		125
@@ -137,7 +137,7 @@ static inline void ntrig_set_mode(struct hid_device *hdev, const int mode) · 11 unmodified lines
137	if (!report)	137	if (!report)
138	return;	138	return;
139		139
140	usbhid_submit_report(hdev, report, USB_DIR_IN);	140	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
141	}	141	}
142		142
143	static void ntrig_report_version(struct hid_device *hdev)	143	static void ntrig_report_version(struct hid_device *hdev)
@@ -937,8 +937,8 @@ static int ntrig_probe(struct hid_device hdev, const struct hid_device_id id) · 793 unmodified lines
937	if (report) {	937	if (report) {
938	/* Let the device settle to ensure the wakeup message gets	938	/* Let the device settle to ensure the wakeup message gets
939	* through */	939	* through */
940	usbhid_wait_io(hdev);	940	hid_hw_wait(hdev);
941	usbhid_submit_report(hdev, report, USB_DIR_IN);	941	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
942		942
943	/*	943	/*
944	* Sanity check: if the current mode is invalid reset it to	944	* Sanity check: if the current mode is invalid reset it to

drivers/hid/hid-picolcd.h+3−3

@@ -142,10 +142,10 @@ struct hid_report picolcd_report(int id, struct hid_device hdev, int dir); · 141 unmodified lines
142	#ifdef CONFIG_DEBUG_FS	142	#ifdef CONFIG_DEBUG_FS
143	void picolcd_debug_out_report(struct picolcd_data *data,	143	void picolcd_debug_out_report(struct picolcd_data *data,
144	struct hid_device hdev, struct hid_report report);	144	struct hid_device hdev, struct hid_report report);
145	#define usbhid_submit_report(a, b, c) \	145	#define hid_hw_request(a, b, c) \
146	do { \	146	do { \
147	picolcd_debug_out_report(hid_get_drvdata(a), a, b); \	147	picolcd_debug_out_report(hid_get_drvdata(a), a, b); \
148	usbhid_submit_report(a, b, c); \	148	hid_hw_request(a, b, c); \
149	} while (0)	149	} while (0)
150		150
151	void picolcd_debug_raw_event(struct picolcd_data *data,	151	void picolcd_debug_raw_event(struct picolcd_data *data,
@@ -302,7 +302,7 @@ static inline int picolcd_init_cir(struct picolcd_data *data, struct hid_report · 150 unmodified lines
302	static inline void picolcd_exit_cir(struct picolcd_data *data)	302	static inline void picolcd_exit_cir(struct picolcd_data *data)
303	{	303	{
304	}	304	}
305	#endif /* CONFIG_HID_PICOLCD_LIRC */	305	#endif /* CONFIG_HID_PICOLCD_CIR */
306		306
307	int picolcd_reset(struct hid_device *hdev);	307	int picolcd_reset(struct hid_device *hdev);
308	struct picolcd_pending picolcd_send_and_wait(struct hid_device hdev,	308	struct picolcd_pending picolcd_send_and_wait(struct hid_device hdev,

drivers/hid/hid-picolcd_backlight.c+1−3

  ***************************************************************************/
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
-#include <linux/usb.h>
 #include <linux/fb.h>
 #include <linux/backlight.h>
 	spin_lock_irqsave(&data->lock, flags);
 	hid_set_field(report->field[0], 0, data->lcd_power == FB_BLANK_UNBLANK ? data->lcd_brightness : 0);
 	if (!(data->status & PICOLCD_FAILED))
-		usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+		hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	return 0;
 }

drivers/hid/hid-picolcd_cir.c+0−2

@@ -21,8 +21,6 @@ · 20 unmodified lines
21	#include <linux/hid-debug.h>	21	#include <linux/hid-debug.h>
22	#include <linux/input.h>	22	#include <linux/input.h>
23	#include "hid-ids.h"	23	#include "hid-ids.h"
24	#include "usbhid/usbhid.h"
25	#include <linux/usb.h>
26		24
27	#include <linux/fb.h>	25	#include <linux/fb.h>
28	#include <linux/vmalloc.h>	26	#include <linux/vmalloc.h>

drivers/hid/hid-picolcd_core.c+3−5

 #include <linux/hid-debug.h>
 #include <linux/input.h>
 #include "hid-ids.h"
-#include "usbhid/usbhid.h"
-#include <linux/usb.h>
 #include <linux/fb.h>
 #include <linux/vmalloc.h>
 		work = NULL;
 	} else {
 		data->pending = work;
-		usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+		hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 		spin_unlock_irqrestore(&data->lock, flags);
 		wait_for_completion_interruptible_timeout(&work->ready, HZ*2);
 		spin_lock_irqsave(&data->lock, flags);
 		spin_unlock_irqrestore(&data->lock, flags);
 		return -ENODEV;
 	}
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	error = picolcd_check_version(hdev);
 	spin_lock_irqsave(&data->lock, flags);
 	hid_set_field(report->field[0], 0, timeout & 0xff);
 	hid_set_field(report->field[0], 1, (timeout >> 8) & 0xff);
-	usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+	hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	return count;
 }

drivers/hid/hid-picolcd_debugfs.c+0−2

@@ -19,8 +19,6 @@ · 18 unmodified lines
19		19
20	#include <linux/hid.h>	20	#include <linux/hid.h>
21	#include <linux/hid-debug.h>	21	#include <linux/hid-debug.h>
22	#include "usbhid/usbhid.h"
23	#include <linux/usb.h>
24		22
25	#include <linux/fb.h>	23	#include <linux/fb.h>
26	#include <linux/seq_file.h>	24	#include <linux/seq_file.h>

drivers/hid/hid-picolcd_fb.c+5−7

 #include <linux/hid.h>
 #include <linux/vmalloc.h>
-#include "usbhid/usbhid.h"
-#include <linux/usb.h>
 #include <linux/fb.h>
 #include <linux/module.h>
 		else
 			hid_set_field(report2->field[0], 4 + i - 32, tdata[i]);
-	usbhid_submit_report(data->hdev, report1, USB_DIR_OUT);
+	hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT);
-	usbhid_submit_report(data->hdev, report2, USB_DIR_OUT);
+	hid_hw_request(data->hdev, report2, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	return 0;
 }
 				hid_set_field(report->field[0], j, mapcmd[j]);
 			else
 				hid_set_field(report->field[0], j, 0);
-		usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+		hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 	}
 	spin_unlock_irqrestore(&data->lock, flags);
 				mutex_unlock(&info->lock);
 				if (!data)
 					return;
-				usbhid_wait_io(data->hdev);
+				hid_hw_wait(data->hdev);
 				mutex_lock(&info->lock);
 				n = 0;
 			}
 		spin_unlock_irqrestore(&fbdata->lock, flags);
 		mutex_unlock(&info->lock);
 		if (data)
-			usbhid_wait_io(data->hdev);
+			hid_hw_wait(data->hdev);
 		return;
 	}
 out:

drivers/hid/hid-picolcd_lcd.c+1−3

  ***************************************************************************/
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
-#include <linux/usb.h>
 #include <linux/fb.h>
 #include <linux/lcd.h>
 	spin_lock_irqsave(&data->lock, flags);
 	hid_set_field(report->field[0], 0, data->lcd_contrast);
 	if (!(data->status & PICOLCD_FAILED))
-		usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+		hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	return 0;
 }

drivers/hid/hid-picolcd_leds.c+1−3

 #include <linux/hid-debug.h>
 #include <linux/input.h>
 #include "hid-ids.h"
-#include "usbhid/usbhid.h"
-#include <linux/usb.h>
 #include <linux/fb.h>
 #include <linux/vmalloc.h>
 	spin_lock_irqsave(&data->lock, flags);
 	hid_set_field(report->field[0], 0, data->led_state);
 	if (!(data->status & PICOLCD_FAILED))
-		usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
+		hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 }

drivers/hid/hid-pl.c+2−4

 #include <linux/input.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
 #include "hid-ids.h"
 #ifdef CONFIG_PANTHERLORD_FF
-#include "usbhid/usbhid.h"
 struct plff_device {
 	struct hid_report *report;
 	*plff->strong = left;
 	*plff->weak = right;
 	debug("running with 0x%02x 0x%02x", left, right);
-	usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
+	hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 		*strong = 0x00;
 		*weak = 0x00;
-		usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
+		hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);
 	}
 	hid_info(hid, "Force feedback for PantherLord/GreenAsia devices by Anssi Hannula <anssi.hannula@gmail.com>\n");

drivers/hid/hid-prodikeys.c+1−2

 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include "usbhid/usbhid.h"
 #include "hid-ids.h"
 	report->field[0]->value[0] = 0x01;
 	report->field[0]->value[1] = state;
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 }
 static int pcmidi_handle_report1(struct pcmidi_snd *pm, u8 *data)

drivers/hid/hid-roccat-isku.c+10−7

 	if (off >= real_size)
 		return 0;
-	if (off != 0 || count != real_size)
+	if (off != 0 || count > real_size)
 		return -EINVAL;
 	mutex_lock(&isku->isku_lock);
-	retval = isku_receive(usb_dev, command, buf, real_size);
+	retval = isku_receive(usb_dev, command, buf, count);
 	mutex_unlock(&isku->isku_lock);
-	return retval ? retval : real_size;
+	return retval ? retval : count;
 }
 static ssize_t isku_sysfs_write(struct file *fp, struct kobject *kobj,
 	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 	int retval;
-	if (off != 0 || count != real_size)
+	if (off != 0 || count > real_size)
 		return -EINVAL;
 	mutex_lock(&isku->isku_lock);
 	retval = roccat_common2_send_with_status(usb_dev, command,
-			(void *)buf, real_size);
+			(void *)buf, count);
 	mutex_unlock(&isku->isku_lock);
-	return retval ? retval : real_size;
+	return retval ? retval : count;
 }
 #define ISKU_SYSFS_W(thingy, THINGY) \
 ISKU_SYSFS_RW(key_mask, KEY_MASK)
 ISKU_SYSFS_RW(last_set, LAST_SET)
 ISKU_SYSFS_W(talk, TALK)
+ISKU_SYSFS_W(talkfx, TALKFX)
 ISKU_SYSFS_R(info, INFO)
 ISKU_SYSFS_W(control, CONTROL)
 ISKU_SYSFS_W(reset, RESET)
 	ISKU_BIN_ATTR_RW(key_mask, KEY_MASK),
 	ISKU_BIN_ATTR_RW(last_set, LAST_SET),
 	ISKU_BIN_ATTR_W(talk, TALK),
+	ISKU_BIN_ATTR_W(talkfx, TALKFX),
 	ISKU_BIN_ATTR_R(info, INFO),
 	ISKU_BIN_ATTR_W(control, CONTROL),
 	ISKU_BIN_ATTR_W(reset, RESET),
 static const struct hid_device_id isku_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) },
 	{ }
 };
 module_exit(isku_exit);
 MODULE_AUTHOR("Stefan Achatz");
-MODULE_DESCRIPTION("USB Roccat Isku driver");
+MODULE_DESCRIPTION("USB Roccat Isku/FX driver");
 MODULE_LICENSE("GPL v2");

drivers/hid/hid-roccat-isku.h+3−1

 	ISKU_SIZE_KEYS_MACRO = 0x23,
 	ISKU_SIZE_KEYS_CAPSLOCK = 0x06,
 	ISKU_SIZE_LAST_SET = 0x14,
-	ISKU_SIZE_LIGHT = 0x0a,
+	ISKU_SIZE_LIGHT = 0x10,
 	ISKU_SIZE_MACRO = 0x823,
 	ISKU_SIZE_RESET = 0x03,
 	ISKU_SIZE_TALK = 0x10,
+	ISKU_SIZE_TALKFX = 0x10,
 };
 enum {
 	ISKU_COMMAND_LAST_SET = 0x14,
 	ISKU_COMMAND_15 = 0x15,
 	ISKU_COMMAND_TALK = 0x16,
+	ISKU_COMMAND_TALKFX = 0x17,
 	ISKU_COMMAND_FIRMWARE_WRITE = 0x1b,
 	ISKU_COMMAND_FIRMWARE_WRITE_CONTROL = 0x1c,
 };

drivers/hid/hid-roccat-kone.c+2−1

 				(uint8_t *)&roccat_report);
 		break;
 	case kone_mouse_event_call_overlong_macro:
+	case kone_mouse_event_multimedia:
 		if (event->value == kone_keystroke_action_press) {
-			roccat_report.event = kone_mouse_event_call_overlong_macro;
+			roccat_report.event = event->event;
 			roccat_report.value = kone->actual_profile;
 			roccat_report.key = event->macro_key;
 			roccat_report_event(kone->chrdev_minor,

drivers/hid/hid-roccat-kone.h+1−0

@@ -169,6 +169,7 @@ enum kone_mouse_events { · 168 unmodified lines
169	/* TODO clarify meaning and occurence of kone_mouse_event_calibration */	169	/* TODO clarify meaning and occurence of kone_mouse_event_calibration */
170	kone_mouse_event_calibration = 0xc0,	170	kone_mouse_event_calibration = 0xc0,
171	kone_mouse_event_call_overlong_macro = 0xe0,	171	kone_mouse_event_call_overlong_macro = 0xe0,
		172	kone_mouse_event_multimedia = 0xe1,
172	/* switch events notify if user changed values with mousebutton click */	173	/* switch events notify if user changed values with mousebutton click */
173	kone_mouse_event_switch_dpi = 0xf0,	174	kone_mouse_event_switch_dpi = 0xf0,
174	kone_mouse_event_switch_profile = 0xf1	175	kone_mouse_event_switch_profile = 0xf1

drivers/hid/hid-roccat-konepure.c+304−0

@@ -0,0 +1,304 @@
	1	/*
	2	* Roccat KonePure driver for Linux
	3	*
	4	* Copyright (c) 2012 Stefan Achatz <erazor_de@users.sourceforge.net>
	5	*/
	6
	7	/*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
	11	* any later version.
	12	*/
	13
	14	/*
	15	* Roccat KonePure is a smaller version of KoneXTD with less buttons and lights.
	16	*/
	17
	18	#include <linux/device.h>
	19	#include <linux/input.h>
	20	#include <linux/hid.h>
	21	#include <linux/module.h>
	22	#include <linux/slab.h>
	23	#include <linux/hid-roccat.h>
	24	#include "hid-ids.h"
	25	#include "hid-roccat-common.h"
	26	#include "hid-roccat-konepure.h"
	27
	28	static struct class *konepure_class;
	29
	30	static ssize_t konepure_sysfs_read(struct file fp, struct kobject kobj,
	31	char *buf, loff_t off, size_t count,
	32	size_t real_size, uint command)
	33	{
	34	struct device *dev =
	35	container_of(kobj, struct device, kobj)->parent->parent;
	36	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	37	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	38	int retval;
	39
	40	if (off >= real_size)
	41	return 0;
	42
	43	if (off != 0 \|\| count != real_size)
	44	return -EINVAL;
	45
	46	mutex_lock(&konepure->konepure_lock);
	47	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
	48	mutex_unlock(&konepure->konepure_lock);
	49
	50	return retval ? retval : real_size;
	51	}
	52
	53	static ssize_t konepure_sysfs_write(struct file fp, struct kobject kobj,
	54	void const *buf, loff_t off, size_t count,
	55	size_t real_size, uint command)
	56	{
	57	struct device *dev =
	58	container_of(kobj, struct device, kobj)->parent->parent;
	59	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	60	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	61	int retval;
	62
	63	if (off != 0 \|\| count != real_size)
	64	return -EINVAL;
	65
	66	mutex_lock(&konepure->konepure_lock);
	67	retval = roccat_common2_send_with_status(usb_dev, command,
	68	(void *)buf, real_size);
	69	mutex_unlock(&konepure->konepure_lock);
	70
	71	return retval ? retval : real_size;
	72	}
	73
	74	#define KONEPURE_SYSFS_W(thingy, THINGY) \
	75	static ssize_t konepure_sysfs_write_ ## thingy(struct file *fp, \
	76	struct kobject kobj, struct bin_attribute attr, char *buf, \
	77	loff_t off, size_t count) \
	78	{ \
	79	return konepure_sysfs_write(fp, kobj, buf, off, count, \
	80	KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
	81	}
	82
	83	#define KONEPURE_SYSFS_R(thingy, THINGY) \
	84	static ssize_t konepure_sysfs_read_ ## thingy(struct file *fp, \
	85	struct kobject kobj, struct bin_attribute attr, char *buf, \
	86	loff_t off, size_t count) \
	87	{ \
	88	return konepure_sysfs_read(fp, kobj, buf, off, count, \
	89	KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
	90	}
	91
	92	#define KONEPURE_SYSFS_RW(thingy, THINGY) \
	93	KONEPURE_SYSFS_W(thingy, THINGY) \
	94	KONEPURE_SYSFS_R(thingy, THINGY)
	95
	96	#define KONEPURE_BIN_ATTRIBUTE_RW(thingy, THINGY) \
	97	{ \
	98	.attr = { .name = #thingy, .mode = 0660 }, \
	99	.size = KONEPURE_SIZE_ ## THINGY, \
	100	.read = konepure_sysfs_read_ ## thingy, \
	101	.write = konepure_sysfs_write_ ## thingy \
	102	}
	103
	104	#define KONEPURE_BIN_ATTRIBUTE_R(thingy, THINGY) \
	105	{ \
	106	.attr = { .name = #thingy, .mode = 0440 }, \
	107	.size = KONEPURE_SIZE_ ## THINGY, \
	108	.read = konepure_sysfs_read_ ## thingy, \
	109	}
	110
	111	#define KONEPURE_BIN_ATTRIBUTE_W(thingy, THINGY) \
	112	{ \
	113	.attr = { .name = #thingy, .mode = 0220 }, \
	114	.size = KONEPURE_SIZE_ ## THINGY, \
	115	.write = konepure_sysfs_write_ ## thingy \
	116	}
	117
	118	KONEPURE_SYSFS_RW(actual_profile, ACTUAL_PROFILE)
	119	KONEPURE_SYSFS_W(control, CONTROL)
	120	KONEPURE_SYSFS_RW(info, INFO)
	121	KONEPURE_SYSFS_W(talk, TALK)
	122	KONEPURE_SYSFS_W(macro, MACRO)
	123	KONEPURE_SYSFS_RW(sensor, SENSOR)
	124	KONEPURE_SYSFS_RW(tcu, TCU)
	125	KONEPURE_SYSFS_R(tcu_image, TCU_IMAGE)
	126	KONEPURE_SYSFS_RW(profile_settings, PROFILE_SETTINGS)
	127	KONEPURE_SYSFS_RW(profile_buttons, PROFILE_BUTTONS)
	128
	129	static struct bin_attribute konepure_bin_attributes[] = {
	130	KONEPURE_BIN_ATTRIBUTE_RW(actual_profile, ACTUAL_PROFILE),
	131	KONEPURE_BIN_ATTRIBUTE_W(control, CONTROL),
	132	KONEPURE_BIN_ATTRIBUTE_RW(info, INFO),
	133	KONEPURE_BIN_ATTRIBUTE_W(talk, TALK),
	134	KONEPURE_BIN_ATTRIBUTE_W(macro, MACRO),
	135	KONEPURE_BIN_ATTRIBUTE_RW(sensor, SENSOR),
	136	KONEPURE_BIN_ATTRIBUTE_RW(tcu, TCU),
	137	KONEPURE_BIN_ATTRIBUTE_R(tcu_image, TCU_IMAGE),
	138	KONEPURE_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS),
	139	KONEPURE_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS),
	140	__ATTR_NULL
	141	};
	142
	143	static int konepure_init_konepure_device_struct(struct usb_device *usb_dev,
	144	struct konepure_device *konepure)
	145	{
	146	mutex_init(&konepure->konepure_lock);
	147
	148	return 0;
	149	}
	150
	151	static int konepure_init_specials(struct hid_device *hdev)
	152	{
	153	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	154	struct usb_device *usb_dev = interface_to_usbdev(intf);
	155	struct konepure_device *konepure;
	156	int retval;
	157
	158	if (intf->cur_altsetting->desc.bInterfaceProtocol
	159	!= USB_INTERFACE_PROTOCOL_MOUSE) {
	160	hid_set_drvdata(hdev, NULL);
	161	return 0;
	162	}
	163
	164	konepure = kzalloc(sizeof(*konepure), GFP_KERNEL);
	165	if (!konepure) {
	166	hid_err(hdev, "can't alloc device descriptor\n");
	167	return -ENOMEM;
	168	}
	169	hid_set_drvdata(hdev, konepure);
	170
	171	retval = konepure_init_konepure_device_struct(usb_dev, konepure);
	172	if (retval) {
	173	hid_err(hdev, "couldn't init struct konepure_device\n");
	174	goto exit_free;
	175	}
	176
	177	retval = roccat_connect(konepure_class, hdev,
	178	sizeof(struct konepure_mouse_report_button));
	179	if (retval < 0) {
	180	hid_err(hdev, "couldn't init char dev\n");
	181	} else {
	182	konepure->chrdev_minor = retval;
	183	konepure->roccat_claimed = 1;
	184	}
	185
	186	return 0;
	187	exit_free:
	188	kfree(konepure);
	189	return retval;
	190	}
	191
	192	static void konepure_remove_specials(struct hid_device *hdev)
	193	{
	194	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	195	struct konepure_device *konepure;
	196
	197	if (intf->cur_altsetting->desc.bInterfaceProtocol
	198	!= USB_INTERFACE_PROTOCOL_MOUSE)
	199	return;
	200
	201	konepure = hid_get_drvdata(hdev);
	202	if (konepure->roccat_claimed)
	203	roccat_disconnect(konepure->chrdev_minor);
	204	kfree(konepure);
	205	}
	206
	207	static int konepure_probe(struct hid_device *hdev,
	208	const struct hid_device_id *id)
	209	{
	210	int retval;
	211
	212	retval = hid_parse(hdev);
	213	if (retval) {
	214	hid_err(hdev, "parse failed\n");
	215	goto exit;
	216	}
	217
	218	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	219	if (retval) {
	220	hid_err(hdev, "hw start failed\n");
	221	goto exit;
	222	}
	223
	224	retval = konepure_init_specials(hdev);
	225	if (retval) {
	226	hid_err(hdev, "couldn't install mouse\n");
	227	goto exit_stop;
	228	}
	229
	230	return 0;
	231
	232	exit_stop:
	233	hid_hw_stop(hdev);
	234	exit:
	235	return retval;
	236	}
	237
	238	static void konepure_remove(struct hid_device *hdev)
	239	{
	240	konepure_remove_specials(hdev);
	241	hid_hw_stop(hdev);
	242	}
	243
	244	static int konepure_raw_event(struct hid_device *hdev,
	245	struct hid_report report, u8 data, int size)
	246	{
	247	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	248	struct konepure_device *konepure = hid_get_drvdata(hdev);
	249
	250	if (intf->cur_altsetting->desc.bInterfaceProtocol
	251	!= USB_INTERFACE_PROTOCOL_MOUSE)
	252	return 0;
	253
	254	if (data[0] != KONEPURE_MOUSE_REPORT_NUMBER_BUTTON)
	255	return 0;
	256
	257	if (konepure != NULL && konepure->roccat_claimed)
	258	roccat_report_event(konepure->chrdev_minor, data);
	259
	260	return 0;
	261	}
	262
	263	static const struct hid_device_id konepure_devices[] = {
	264	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
	265	{ }
	266	};
	267
	268	MODULE_DEVICE_TABLE(hid, konepure_devices);
	269
	270	static struct hid_driver konepure_driver = {
	271	.name = "konepure",
	272	.id_table = konepure_devices,
	273	.probe = konepure_probe,
	274	.remove = konepure_remove,
	275	.raw_event = konepure_raw_event
	276	};
	277
	278	static int __init konepure_init(void)
	279	{
	280	int retval;
	281
	282	konepure_class = class_create(THIS_MODULE, "konepure");
	283	if (IS_ERR(konepure_class))
	284	return PTR_ERR(konepure_class);
	285	konepure_class->dev_bin_attrs = konepure_bin_attributes;
	286
	287	retval = hid_register_driver(&konepure_driver);
	288	if (retval)
	289	class_destroy(konepure_class);
	290	return retval;
	291	}
	292
	293	static void __exit konepure_exit(void)
	294	{
	295	hid_unregister_driver(&konepure_driver);
	296	class_destroy(konepure_class);
	297	}
	298
	299	module_init(konepure_init);
	300	module_exit(konepure_exit);
	301
	302	MODULE_AUTHOR("Stefan Achatz");
	303	MODULE_DESCRIPTION("USB Roccat KonePure driver");
	304	MODULE_LICENSE("GPL v2");

drivers/hid/hid-roccat-konepure.h+72−0

@@ -0,0 +1,72 @@
	1	#ifndef __HID_ROCCAT_KONEPURE_H
	2	#define __HID_ROCCAT_KONEPURE_H
	3
	4	/*
	5	* Copyright (c) 2012 Stefan Achatz <erazor_de@users.sourceforge.net>
	6	*/
	7
	8	/*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the Free
	11	* Software Foundation; either version 2 of the License, or (at your option)
	12	* any later version.
	13	*/
	14
	15	#include <linux/types.h>
	16
	17	enum {
	18	KONEPURE_SIZE_ACTUAL_PROFILE = 0x03,
	19	KONEPURE_SIZE_CONTROL = 0x03,
	20	KONEPURE_SIZE_FIRMWARE_WRITE = 0x0402,
	21	KONEPURE_SIZE_INFO = 0x06,
	22	KONEPURE_SIZE_MACRO = 0x0822,
	23	KONEPURE_SIZE_PROFILE_SETTINGS = 0x1f,
	24	KONEPURE_SIZE_PROFILE_BUTTONS = 0x3b,
	25	KONEPURE_SIZE_SENSOR = 0x06,
	26	KONEPURE_SIZE_TALK = 0x10,
	27	KONEPURE_SIZE_TCU = 0x04,
	28	KONEPURE_SIZE_TCU_IMAGE = 0x0404,
	29	};
	30
	31	enum konepure_control_requests {
	32	KONEPURE_CONTROL_REQUEST_GENERAL = 0x80,
	33	KONEPURE_CONTROL_REQUEST_BUTTONS = 0x90,
	34	};
	35
	36	enum konepure_commands {
	37	KONEPURE_COMMAND_CONTROL = 0x04,
	38	KONEPURE_COMMAND_ACTUAL_PROFILE = 0x05,
	39	KONEPURE_COMMAND_PROFILE_SETTINGS = 0x06,
	40	KONEPURE_COMMAND_PROFILE_BUTTONS = 0x07,
	41	KONEPURE_COMMAND_MACRO = 0x08,
	42	KONEPURE_COMMAND_INFO = 0x09,
	43	KONEPURE_COMMAND_TCU = 0x0c,
	44	KONEPURE_COMMAND_TCU_IMAGE = 0x0c,
	45	KONEPURE_COMMAND_E = 0x0e,
	46	KONEPURE_COMMAND_SENSOR = 0x0f,
	47	KONEPURE_COMMAND_TALK = 0x10,
	48	KONEPURE_COMMAND_FIRMWARE_WRITE = 0x1b,
	49	KONEPURE_COMMAND_FIRMWARE_WRITE_CONTROL = 0x1c,
	50	};
	51
	52	enum {
	53	KONEPURE_MOUSE_REPORT_NUMBER_BUTTON = 3,
	54	};
	55
	56	struct konepure_mouse_report_button {
	57	uint8_t report_number; /* always KONEPURE_MOUSE_REPORT_NUMBER_BUTTON */
	58	uint8_t zero;
	59	uint8_t type;
	60	uint8_t data1;
	61	uint8_t data2;
	62	uint8_t zero2;
	63	uint8_t unknown[2];
	64	} __packed;
	65
	66	struct konepure_device {
	67	int roccat_claimed;
	68	int chrdev_minor;
	69	struct mutex konepure_lock;
	70	};
	71
	72	#endif

drivers/hid/hid-roccat.c+1−1

  * roccat_report_event() - output data to readers
  * @minor: minor device number returned by roccat_connect()
  * @data: pointer to data
- * @len: size of data
  *
  * Return value is zero on success, a negative error code on failure.
  *
  * @class: the class thats used to create the device. Meant to hold device
  * specific sysfs attributes.
  * @hid: the hid device the char device should be connected to.
+ * @report_size: size of reports
  *
  * Return value is minor device number in Range [0, ROCCAT_MAX_DEVICES] on
  * success, a negative error code on failure.

drivers/hid/hid-sensor-hub.c+5−7

  */
 #include <linux/device.h>
 #include <linux/hid.h>
-#include <linux/usb.h>
-#include "usbhid/usbhid.h"
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mfd/core.h>
 		goto done_proc;
 	}
 	hid_set_field(report->field[field_index], 0, value);
-	usbhid_submit_report(hsdev->hdev, report, USB_DIR_OUT);
+	hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
-	usbhid_wait_io(hsdev->hdev);
+	hid_hw_wait(hsdev->hdev);
 done_proc:
 	mutex_unlock(&data->mutex);
 		ret = -EINVAL;
 		goto done_proc;
 	}
-	usbhid_submit_report(hsdev->hdev, report, USB_DIR_IN);
+	hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
-	usbhid_wait_io(hsdev->hdev);
+	hid_hw_wait(hsdev->hdev);
 	*value = report->field[field_index]->value[0];
 done_proc:
 		spin_unlock_irqrestore(&data->lock, flags);
 		goto err_free;
 	}
-	usbhid_submit_report(hsdev->hdev, report, USB_DIR_IN);
+	hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
 	spin_unlock_irqrestore(&data->lock, flags);
 	wait_for_completion_interruptible_timeout(&data->pending.ready, HZ*5);
 	switch (data->pending.raw_size) {

drivers/hid/hid-sjoy.c+2−4

 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 #ifdef CONFIG_SMARTJOYPLUS_FF
-#include "usbhid/usbhid.h"
 struct sjoyff_device {
 	struct hid_report *report;
 	sjoyff->report->field[0]->value[1] = right;
 	sjoyff->report->field[0]->value[2] = left;
 	dev_dbg(&dev->dev, "running with 0x%02x 0x%02x\n", left, right);
-	usbhid_submit_report(hid, sjoyff->report, USB_DIR_OUT);
+	hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 		sjoyff->report->field[0]->value[0] = 0x01;
 		sjoyff->report->field[0]->value[1] = 0x00;
 		sjoyff->report->field[0]->value[2] = 0x00;
-		usbhid_submit_report(hid, sjoyff->report, USB_DIR_OUT);
+		hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);
 	}
 	hid_info(hid, "Force feedback for SmartJoy PLUS PS2/USB adapter\n");

drivers/hid/hid-speedlink.c+0−2

 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
-#include <linux/usb.h>
 #include "hid-ids.h"
-#include "usbhid/usbhid.h"
 static const struct hid_device_id speedlink_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE)},

drivers/hid/hid-steelseries.c+2−14

 #include <linux/hid.h>
 #include <linux/module.h>
-#include "usbhid/usbhid.h"
 #include "hid-ids.h"
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
 	value[14] = 0x00;
 	value[15] = 0x00;
-	usbhid_submit_report(hdev, report, USB_DIR_OUT);
+	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 	/* Note: LED change does not show on device until the device is read/polled */
 }
 	.report_fixup = steelseries_srws1_report_fixup
 };
-static int __init steelseries_srws1_init(void)
+module_hid_driver(steelseries_srws1_driver);
-{
-	return hid_register_driver(&steelseries_srws1_driver);
-}
-static void __exit steelseries_srws1_exit(void)
-{
-	hid_unregister_driver(&steelseries_srws1_driver);
-}
-module_init(steelseries_srws1_init);
-module_exit(steelseries_srws1_exit);
 MODULE_LICENSE("GPL");

drivers/hid/hid-thingm.c+0−1

@@ -12,7 +12,6 @@ · 11 unmodified lines
12	#include <linux/hid.h>	12	#include <linux/hid.h>
13	#include <linux/leds.h>	13	#include <linux/leds.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/usb.h>
16		15
17	#include "hid-ids.h"	16	#include "hid-ids.h"
18		17

drivers/hid/hid-tmff.c+2−4

 #include <linux/hid.h>
 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 };
 #ifdef CONFIG_THRUSTMASTER_FF
-#include "usbhid/usbhid.h"
 /* Usages for thrustmaster devices I know about */
 #define THRUSTMASTER_USAGE_FF	(HID_UP_GENDESK | 0xbb)
 		dbg_hid("(x, y)=(%04x, %04x)\n", x, y);
 		ff_field->value[0] = x;
 		ff_field->value[1] = y;
-		usbhid_submit_report(hid, tmff->report, USB_DIR_OUT);
+		hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);
 		break;
 	case FF_RUMBLE:
 		dbg_hid("(left,right)=(%08x, %08x)\n", left, right);
 		ff_field->value[0] = left;
 		ff_field->value[1] = right;
-		usbhid_submit_report(hid, tmff->report, USB_DIR_OUT);
+		hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);
 		break;
 	}
 	return 0;

drivers/hid/hid-wiimote-core.c+38−5

 	input_report_abs(wdata->ir, yid, y);
 }
-static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
+/* reduced status report with "BB BB" key data only */
+static void handler_status_K(struct wiimote_data *wdata,
+			     const __u8 *payload)
 {
 	handler_keys(wdata, payload);
 	/* on status reports the drm is reset so we need to resend the drm */
 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+}
+/* extended status report with "BB BB LF 00 00 VV" data */
+static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
+{
+	handler_status_K(wdata, payload);
 	wiiext_event(wdata, payload[2] & 0x02);
 	}
 }
+/* reduced generic report with "BB BB" key data only */
+static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
+{
+	handler_keys(wdata, payload);
+}
 static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
 {
 	__u16 offset = payload[3] << 8 | payload[4];
 static struct wiiproto_handler handlers[] = {
 	{ .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
+	{ .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
 	{ .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
+	{ .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
+	{ .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
 	{ .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
+	{ .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
+	{ .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
+	{ .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
+	{ .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
+	{ .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
+	{ .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
+	{ .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
 	{ .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
 	{ .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
 	struct wiiproto_handler *h;
 	int i;
 	unsigned long flags;
-	bool handled = false;
 	if (size < 1)
 		return -EINVAL;
 		h = &handlers[i];
 		if (h->id == raw_data[0] && h->size < size) {
 			h->func(wdata, &raw_data[1]);
-			handled = true;
+			break;
 		}
 	}
-	if (!handled)
+	if (!handlers[i].id)
 		hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
 									size);
 	wiimote_leds_destroy(wdata);
 	power_supply_unregister(&wdata->battery);
+	kfree(wdata->battery.name);
 	input_unregister_device(wdata->accel);
 	input_unregister_device(wdata->ir);
 	input_unregister_device(wdata->input);
 	wdata->battery.properties = wiimote_battery_props;
 	wdata->battery.num_properties = ARRAY_SIZE(wiimote_battery_props);
 	wdata->battery.get_property = wiimote_battery_get_property;
-	wdata->battery.name = "wiimote_battery";
 	wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
 	wdata->battery.use_for_apm = 0;
+	wdata->battery.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
+					wdata->hdev->uniq);
+	if (!wdata->battery.name) {
+		ret = -ENOMEM;
+		goto err_battery_name;
+	}
 	ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
 	if (ret) {
 	return ret;
 err_battery:
+	kfree(wdata->battery.name);
+err_battery_name:
 	input_unregister_device(wdata->input);
 	wdata->input = NULL;
 err_input:
 static const struct hid_device_id wiimote_hid_devices[] = {
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
 				USB_DEVICE_ID_NINTENDO_WIIMOTE) },
+	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
+				USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);

drivers/hid/hid-zpff.c+2−4

 #include <linux/hid.h>
 #include <linux/input.h>
 #include <linux/slab.h>
-#include <linux/usb.h>
 #include <linux/module.h>
 #include "hid-ids.h"
 #ifdef CONFIG_ZEROPLUS_FF
-#include "usbhid/usbhid.h"
 struct zpff_device {
 	struct hid_report *report;
 	zpff->report->field[2]->value[0] = left;
 	zpff->report->field[3]->value[0] = right;
 	dbg_hid("running with 0x%02x 0x%02x\n", left, right);
-	usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
+	hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
 	return 0;
 }
 	zpff->report->field[1]->value[0] = 0x02;
 	zpff->report->field[2]->value[0] = 0x00;
 	zpff->report->field[3]->value[0] = 0x00;
-	usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
+	hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
 	hid_info(hid, "force feedback for Zeroplus based devices by Anssi Hannula <anssi.hannula@gmail.com>\n");

drivers/hid/i2c-hid/i2c-hid.c+31−0

@@ -563,6 +563,36 @@ static int i2c_hid_output_raw_report(struct hid_device hid, __u8 buf, · 562 unmodified lines
563	return ret;	563	return ret;
564	}	564	}
565		565
		566	static void i2c_hid_request(struct hid_device hid, struct hid_report rep,
		567	int reqtype)
		568	{
		569	struct i2c_client *client = hid->driver_data;
		570	char *buf;
		571	int ret;
		572	int len = i2c_hid_get_report_length(rep) - 2;
		573
		574	buf = kzalloc(len, GFP_KERNEL);
		575	if (!buf)
		576	return;
		577
		578	switch (reqtype) {
		579	case HID_REQ_GET_REPORT:
		580	ret = i2c_hid_get_raw_report(hid, rep->id, buf, len, rep->type);
		581	if (ret < 0)
		582	dev_err(&client->dev, "%s: unable to get report: %d\n",
		583	__func__, ret);
		584	else
		585	hid_input_report(hid, rep->type, buf, ret, 0);
		586	break;
		587	case HID_REQ_SET_REPORT:
		588	hid_output_report(rep, buf);
		589	i2c_hid_output_raw_report(hid, buf, len, rep->type);
		590	break;
		591	}
		592
		593	kfree(buf);
		594	}
		595
566	static int i2c_hid_parse(struct hid_device *hid)	596	static int i2c_hid_parse(struct hid_device *hid)
567	{	597	{
568	struct i2c_client *client = hid->driver_data;	598	struct i2c_client *client = hid->driver_data;
@@ -742,6 +772,7 @@ static struct hid_ll_driver i2c_hid_ll_driver = { · 173 unmodified lines
742	.open = i2c_hid_open,	772	.open = i2c_hid_open,
743	.close = i2c_hid_close,	773	.close = i2c_hid_close,
744	.power = i2c_hid_power,	774	.power = i2c_hid_power,
		775	.request = i2c_hid_request,
745	.hidinput_input_event = i2c_hid_hidinput_input_event,	776	.hidinput_input_event = i2c_hid_hidinput_input_event,
746	};	777	};
747		778

drivers/hid/usbhid/hid-core.c+31−4

 	}
 }
-void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
+static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
 {
 	struct usbhid_device *usbhid = hid->driver_data;
 	unsigned long flags;
 	__usbhid_submit_report(hid, report, dir);
 	spin_unlock_irqrestore(&usbhid->lock, flags);
 }
-EXPORT_SYMBOL_GPL(usbhid_submit_report);
 /* Workqueue routine to send requests to change LEDs */
 static void hid_led(struct work_struct *work)
 	return 0;
 }
-int usbhid_wait_io(struct hid_device *hid)
+static int usbhid_wait_io(struct hid_device *hid)
 {
 	struct usbhid_device *usbhid = hid->driver_data;
 	return 0;
 }
-EXPORT_SYMBOL_GPL(usbhid_wait_io);
 static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
 {
 	return r;
 }
+static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype)
+{
+	switch (reqtype) {
+	case HID_REQ_GET_REPORT:
+		usbhid_submit_report(hid, rep, USB_DIR_IN);
+		break;
+	case HID_REQ_SET_REPORT:
+		usbhid_submit_report(hid, rep, USB_DIR_OUT);
+		break;
+	}
+}
+static int usbhid_idle(struct hid_device *hid, int report, int idle,
+		int reqtype)
+{
+	struct usb_device *dev = hid_to_usb_dev(hid);
+	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
+	struct usb_host_interface *interface = intf->cur_altsetting;
+	int ifnum = interface->desc.bInterfaceNumber;
+	if (reqtype != HID_REQ_SET_IDLE)
+		return -EINVAL;
+	return hid_set_idle(dev, ifnum, report, idle);
+}
 static struct hid_ll_driver usb_hid_driver = {
 	.parse = usbhid_parse,
 	.start = usbhid_start,
 	.close = usbhid_close,
 	.power = usbhid_power,
 	.hidinput_input_event = usb_hidinput_input_event,
+	.request = usbhid_request,
+	.wait = usbhid_wait_io,
+	.idle = usbhid_idle,
 };
 static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id)

drivers/hid/usbhid/hid-pidff.c+40−40

@@ -263,8 +263,8 @@ static void pidff_set_envelope_report(struct pidff_device *pidff, · 262 unmodified lines
263	envelope->attack_level,	263	envelope->attack_level,
264	pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);	264	pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
265		265
266	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE],	266	hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
267	USB_DIR_OUT);	267	HID_REQ_SET_REPORT);
268	}	268	}
269		269
270	/*	270	/*
@@ -290,8 +290,8 @@ static void pidff_set_constant_force_report(struct pidff_device *pidff, · 19 unmodified lines
290	pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],	290	pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],
291	effect->u.constant.level);	291	effect->u.constant.level);
292		292
293	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONSTANT],	293	hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT],
294	USB_DIR_OUT);	294	HID_REQ_SET_REPORT);
295	}	295	}
296		296
297	/*	297	/*
@@ -325,8 +325,8 @@ static void pidff_set_effect_report(struct pidff_device *pidff, · 27 unmodified lines
325	pidff->effect_direction);	325	pidff->effect_direction);
326	pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;	326	pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;
327		327
328	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],	328	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
329	USB_DIR_OUT);	329	HID_REQ_SET_REPORT);
330	}	330	}
331		331
332	/*	332	/*
@@ -357,8 +357,8 @@ static void pidff_set_periodic_report(struct pidff_device *pidff, · 24 unmodified lines
357	pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);	357	pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);
358	pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;	358	pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;
359		359
360	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_PERIODIC],	360	hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],
361	USB_DIR_OUT);	361	HID_REQ_SET_REPORT);
362		362
363	}	363	}
364		364
@@ -399,8 +399,8 @@ static void pidff_set_condition_report(struct pidff_device *pidff, · 34 unmodified lines
399	effect->u.condition[i].left_saturation);	399	effect->u.condition[i].left_saturation);
400	pidff_set(&pidff->set_condition[PID_DEAD_BAND],	400	pidff_set(&pidff->set_condition[PID_DEAD_BAND],
401	effect->u.condition[i].deadband);	401	effect->u.condition[i].deadband);
402	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],	402	hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],
403	USB_DIR_OUT);	403	HID_REQ_SET_REPORT);
404	}	404	}
405	}	405	}
406		406
@@ -440,8 +440,8 @@ static void pidff_set_ramp_force_report(struct pidff_device *pidff, · 33 unmodified lines
440	effect->u.ramp.start_level);	440	effect->u.ramp.start_level);
441	pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],	441	pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],
442	effect->u.ramp.end_level);	442	effect->u.ramp.end_level);
443	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_RAMP],	443	hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP],
444	USB_DIR_OUT);	444	HID_REQ_SET_REPORT);
445	}	445	}
446		446
447	/*	447	/*
@@ -465,19 +465,19 @@ static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum) · 17 unmodified lines
465	int j;	465	int j;
466		466
467	pidff->create_new_effect_type->value[0] = efnum;	467	pidff->create_new_effect_type->value[0] = efnum;
468	usbhid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],	468	hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
469	USB_DIR_OUT);	469	HID_REQ_SET_REPORT);
470	hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);	470	hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);
471		471
472	pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;	472	pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
473	pidff->block_load_status->value[0] = 0;	473	pidff->block_load_status->value[0] = 0;
474	usbhid_wait_io(pidff->hid);	474	hid_hw_wait(pidff->hid);
475		475
476	for (j = 0; j < 60; j++) {	476	for (j = 0; j < 60; j++) {
477	hid_dbg(pidff->hid, "pid_block_load requested\n");	477	hid_dbg(pidff->hid, "pid_block_load requested\n");
478	usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD],	478	hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
479	USB_DIR_IN);	479	HID_REQ_GET_REPORT);
480	usbhid_wait_io(pidff->hid);	480	hid_hw_wait(pidff->hid);
481	if (pidff->block_load_status->value[0] ==	481	if (pidff->block_load_status->value[0] ==
482	pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {	482	pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
483	hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",	483	hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",
@@ -513,8 +513,8 @@ static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n) · 29 unmodified lines
513	pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;	513	pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
514	}	514	}
515		515
516	usbhid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],	516	hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
517	USB_DIR_OUT);	517	HID_REQ_SET_REPORT);
518	}	518	}
519		519
520	/**	520	/**
@@ -535,8 +535,8 @@ static int pidff_playback(struct input_dev *dev, int effect_id, int value) · 14 unmodified lines
535	static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)	535	static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)
536	{	536	{
537	pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;	537	pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;
538	usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_FREE],	538	hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE],
539	USB_DIR_OUT);	539	HID_REQ_SET_REPORT);
540	}	540	}
541		541
542	/*	542	/*
@@ -551,7 +551,7 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id) · 8 unmodified lines
551	effect_id, pidff->pid_id[effect_id]);	551	effect_id, pidff->pid_id[effect_id]);
552	/* Wait for the queue to clear. We do not want a full fifo to	552	/* Wait for the queue to clear. We do not want a full fifo to
553	prevent the effect removal. */	553	prevent the effect removal. */
554	usbhid_wait_io(pidff->hid);	554	hid_hw_wait(pidff->hid);
555	pidff_playback_pid(pidff, pid_id, 0);	555	pidff_playback_pid(pidff, pid_id, 0);
556	pidff_erase_pid(pidff, pid_id);	556	pidff_erase_pid(pidff, pid_id);
557		557
@@ -718,8 +718,8 @@ static void pidff_set_gain(struct input_dev *dev, u16 gain) · 160 unmodified lines
718	struct pidff_device *pidff = dev->ff->private;	718	struct pidff_device *pidff = dev->ff->private;
719		719
720	pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);	720	pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);
721	usbhid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],	721	hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
722	USB_DIR_OUT);	722	HID_REQ_SET_REPORT);
723	}	723	}
724		724
725	static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)	725	static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
@@ -744,8 +744,8 @@ static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude) · 18 unmodified lines
744	pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;	744	pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;
745	pidff->set_effect[PID_START_DELAY].value[0] = 0;	745	pidff->set_effect[PID_START_DELAY].value[0] = 0;
746		746
747	usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],	747	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
748	USB_DIR_OUT);	748	HID_REQ_SET_REPORT);
749	}	749	}
750		750
751	/*	751	/*
@@ -1158,19 +1158,19 @@ static void pidff_reset(struct pidff_device *pidff) · 406 unmodified lines
1158		1158
1159	pidff->device_control->value[0] = pidff->control_id[PID_RESET];	1159	pidff->device_control->value[0] = pidff->control_id[PID_RESET];
1160	/* We reset twice as sometimes hid_wait_io isn't waiting long enough */	1160	/* We reset twice as sometimes hid_wait_io isn't waiting long enough */
1161	usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);	1161	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
1162	usbhid_wait_io(hid);	1162	hid_hw_wait(hid);
1163	usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);	1163	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
1164	usbhid_wait_io(hid);	1164	hid_hw_wait(hid);
1165		1165
1166	pidff->device_control->value[0] =	1166	pidff->device_control->value[0] =
1167	pidff->control_id[PID_ENABLE_ACTUATORS];	1167	pidff->control_id[PID_ENABLE_ACTUATORS];
1168	usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);	1168	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
1169	usbhid_wait_io(hid);	1169	hid_hw_wait(hid);
1170		1170
1171	/* pool report is sometimes messed up, refetch it */	1171	/* pool report is sometimes messed up, refetch it */
1172	usbhid_submit_report(hid, pidff->reports[PID_POOL], USB_DIR_IN);	1172	hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);
1173	usbhid_wait_io(hid);	1173	hid_hw_wait(hid);
1174		1174
1175	if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {	1175	if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
1176	while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {	1176	while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {
@@ -1181,9 +1181,9 @@ static void pidff_reset(struct pidff_device *pidff) · 4 unmodified lines
1181	break;	1181	break;
1182	}	1182	}
1183	hid_dbg(pidff->hid, "pid_pool requested again\n");	1183	hid_dbg(pidff->hid, "pid_pool requested again\n");
1184	usbhid_submit_report(hid, pidff->reports[PID_POOL],	1184	hid_hw_request(hid, pidff->reports[PID_POOL],
1185	USB_DIR_IN);	1185	HID_REQ_GET_REPORT);
1186	usbhid_wait_io(hid);	1186	hid_hw_wait(hid);
1187	}	1187	}
1188	}	1188	}
1189	}	1189	}
@@ -1269,8 +1269,8 @@ int hid_pidff_init(struct hid_device *hid) · 79 unmodified lines
1269		1269
1270	if (test_bit(FF_GAIN, dev->ffbit)) {	1270	if (test_bit(FF_GAIN, dev->ffbit)) {
1271	pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);	1271	pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);
1272	usbhid_submit_report(hid, pidff->reports[PID_DEVICE_GAIN],	1272	hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN],
1273	USB_DIR_OUT);	1273	HID_REQ_SET_REPORT);
1274	}	1274	}
1275		1275
1276	error = pidff_check_autocenter(pidff, dev);	1276	error = pidff_check_autocenter(pidff, dev);

drivers/hid/usbhid/hiddev.c+4−4

@@ -705,8 +705,8 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 704 unmodified lines
705	if (report == NULL)	705	if (report == NULL)
706	break;	706	break;
707		707
708	usbhid_submit_report(hid, report, USB_DIR_IN);	708	hid_hw_request(hid, report, HID_REQ_GET_REPORT);
709	usbhid_wait_io(hid);	709	hid_hw_wait(hid);
710		710
711	r = 0;	711	r = 0;
712	break;	712	break;
@@ -724,8 +724,8 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 11 unmodified lines
724	if (report == NULL)	724	if (report == NULL)
725	break;	725	break;
726		726
727	usbhid_submit_report(hid, report, USB_DIR_OUT);	727	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
728	usbhid_wait_io(hid);	728	hid_hw_wait(hid);
729		729
730	r = 0;	730	r = 0;
731	break;	731	break;

drivers/hid/usbhid/usbhid.h+0−3

 #include <linux/input.h>
 /*  API provided by hid-core.c for USB HID drivers */
-int usbhid_wait_io(struct hid_device* hid);
 void usbhid_close(struct hid_device *hid);
 int usbhid_open(struct hid_device *hid);
 void usbhid_init_reports(struct hid_device *hid);
-void usbhid_submit_report
-(struct hid_device *hid, struct hid_report *report, unsigned char dir);
 int usbhid_get_power(struct hid_device *hid);
 void usbhid_put_power(struct hid_device *hid);
 struct usb_interface *usbhid_find_interface(int minor);

include/linux/hid-debug.h+4−2

  *
  */
-#define HID_DEBUG_BUFSIZE 512
 #ifdef CONFIG_DEBUG_FS
+#define HID_DEBUG_BUFSIZE 512
 void hid_dump_input(struct hid_device *, struct hid_usage *, __s32);
+void hid_dump_report(struct hid_device *, int , u8 *, int);
 void hid_dump_device(struct hid_device *, struct seq_file *);
 void hid_dump_field(struct hid_field *, int, struct seq_file *);
 char *hid_resolv_usage(unsigned, struct seq_file *);
 #else
 #define hid_dump_input(a,b,c)		do { } while (0)
+#define hid_dump_report(a,b,c,d)	do { } while (0)
 #define hid_dump_device(a,b)		do { } while (0)
 #define hid_dump_field(a,b,c)		do { } while (0)
 #define hid_resolv_usage(a,b)		do { } while (0)

include/linux/hid.h+100−1

@@ -282,6 +282,7 @@ struct hid_item { · 281 unmodified lines
282	#define HID_QUIRK_BADPAD 0x00000020	282	#define HID_QUIRK_BADPAD 0x00000020
283	#define HID_QUIRK_MULTI_INPUT 0x00000040	283	#define HID_QUIRK_MULTI_INPUT 0x00000040
284	#define HID_QUIRK_HIDINPUT_FORCE 0x00000080	284	#define HID_QUIRK_HIDINPUT_FORCE 0x00000080
		285	#define HID_QUIRK_NO_EMPTY_INPUT 0x00000100
285	#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000	286	#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000
286	#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000	287	#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000
287	#define HID_QUIRK_NO_INIT_REPORTS 0x20000000	288	#define HID_QUIRK_NO_INIT_REPORTS 0x20000000
@@ -456,7 +457,8 @@ struct hid_device { /* device report descriptor */ · 168 unmodified lines
456	unsigned country; /* HID country */	457	unsigned country; /* HID country */
457	struct hid_report_enum report_enum[HID_REPORT_TYPES];	458	struct hid_report_enum report_enum[HID_REPORT_TYPES];
458		459
459	struct semaphore driver_lock; /* protects the current driver */	460	struct semaphore driver_lock; /* protects the current driver, except during input */
		461	struct semaphore driver_input_lock; /* protects the current driver */
460	struct device dev; /* device */	462	struct device dev; /* device */
461	struct hid_driver *driver;	463	struct hid_driver *driver;
462	struct hid_ll_driver *ll_driver;	464	struct hid_ll_driver *ll_driver;
@@ -477,6 +479,7 @@ struct hid_device { /* device report descriptor */ · 14 unmodified lines
477	unsigned int status; /* see STAT flags above */	479	unsigned int status; /* see STAT flags above */
478	unsigned claimed; /* Claimed by hidinput, hiddev? */	480	unsigned claimed; /* Claimed by hidinput, hiddev? */
479	unsigned quirks; /* Various quirks the device can pull on us */	481	unsigned quirks; /* Various quirks the device can pull on us */
		482	bool io_started; /* Protected by driver_lock. If IO has started */
480		483
481	struct list_head inputs; /* The list of inputs */	484	struct list_head inputs; /* The list of inputs */
482	void hiddev; / The hiddev structure */	485	void hiddev; / The hiddev structure */
@@ -512,6 +515,7 @@ struct hid_device { /* device report descriptor */ · 29 unmodified lines
512	struct dentry *debug_rdesc;	515	struct dentry *debug_rdesc;
513	struct dentry *debug_events;	516	struct dentry *debug_events;
514	struct list_head debug_list;	517	struct list_head debug_list;
		518	struct mutex debug_list_lock;
515	wait_queue_head_t debug_wait;	519	wait_queue_head_t debug_wait;
516	};	520	};
517		521
@@ -599,6 +603,10 @@ struct hid_usage_id { · 81 unmodified lines
599	* @resume: invoked on resume if device was not reset (NULL means nop)	603	* @resume: invoked on resume if device was not reset (NULL means nop)
600	* @reset_resume: invoked on resume if device was reset (NULL means nop)	604	* @reset_resume: invoked on resume if device was reset (NULL means nop)
601	*	605	*
		606	* probe should return -errno on error, or 0 on success. During probe,
		607	* input will not be passed to raw_event unless hid_device_io_start is
		608	* called.
		609	*
602	* raw_event and event should return 0 on no action performed, 1 when no	610	* raw_event and event should return 0 on no action performed, 1 when no
603	* further processing should be done and negative on error	611	* further processing should be done and negative on error
604	*	612	*
@@ -662,6 +670,9 @@ struct hid_driver { · 57 unmodified lines
662	* @hidinput_input_event: event input event (e.g. ff or leds)	670	* @hidinput_input_event: event input event (e.g. ff or leds)
663	* @parse: this method is called only once to parse the device data,	671	* @parse: this method is called only once to parse the device data,
664	* shouldn't allocate anything to not leak memory	672	* shouldn't allocate anything to not leak memory
		673	* @request: send report request to device (e.g. feature report)
		674	* @wait: wait for buffered io to complete (send/recv reports)
		675	* @idle: send idle request to device
665	*/	676	*/
666	struct hid_ll_driver {	677	struct hid_ll_driver {
667	int (start)(struct hid_device hdev);	678	int (start)(struct hid_device hdev);
@@ -676,6 +687,13 @@ struct hid_ll_driver { · 8 unmodified lines
676	unsigned int code, int value);	687	unsigned int code, int value);
677		688
678	int (parse)(struct hid_device hdev);	689	int (parse)(struct hid_device hdev);
		690
		691	void (request)(struct hid_device hdev,
		692	struct hid_report *report, int reqtype);
		693
		694	int (wait)(struct hid_device hdev);
		695	int (idle)(struct hid_device hdev, int report, int idle, int reqtype);
		696
679	};	697	};
680		698
681	#define PM_HINT_FULLON 1<<5	699	#define PM_HINT_FULLON 1<<5
@@ -737,6 +755,44 @@ const struct hid_device_id hid_match_id(struct hid_device hdev, · 55 unmodified lines
737	const struct hid_device_id *id);	755	const struct hid_device_id *id);
738	s32 hid_snto32(__u32 value, unsigned n);	756	s32 hid_snto32(__u32 value, unsigned n);
739		757
		758	/**
		759	* hid_device_io_start - enable HID input during probe, remove
		760	*
		761	* @hid - the device
		762	*
		763	* This should only be called during probe or remove and only be
		764	* called by the thread calling probe or remove. It will allow
		765	* incoming packets to be delivered to the driver.
		766	*/
		767	static inline void hid_device_io_start(struct hid_device *hid) {
		768	if (hid->io_started) {
		769	dev_warn(&hid->dev, "io already started");
		770	return;
		771	}
		772	hid->io_started = true;
		773	up(&hid->driver_input_lock);
		774	}
		775
		776	/**
		777	* hid_device_io_stop - disable HID input during probe, remove
		778	*
		779	* @hid - the device
		780	*
		781	* Should only be called after hid_device_io_start. It will prevent
		782	* incoming packets from going to the driver for the duration of
		783	* probe, remove. If called during probe, packets will still go to the
		784	* driver after probe is complete. This function should only be called
		785	* by the thread calling probe or remove.
		786	*/
		787	static inline void hid_device_io_stop(struct hid_device *hid) {
		788	if (!hid->io_started) {
		789	dev_warn(&hid->dev, "io already stopped");
		790	return;
		791	}
		792	hid->io_started = false;
		793	down(&hid->driver_input_lock);
		794	}
		795
740	/**	796	/**
741	* hid_map_usage - map usage input bits	797	* hid_map_usage - map usage input bits
742	*	798	*
@@ -883,6 +939,49 @@ static inline int hid_hw_power(struct hid_device *hdev, int level) · 140 unmodified lines
883	return hdev->ll_driver->power ? hdev->ll_driver->power(hdev, level) : 0;	939	return hdev->ll_driver->power ? hdev->ll_driver->power(hdev, level) : 0;
884	}	940	}
885		941
		942
		943	/**
		944	* hid_hw_request - send report request to device
		945	*
		946	* @hdev: hid device
		947	* @report: report to send
		948	* @reqtype: hid request type
		949	*/
		950	static inline void hid_hw_request(struct hid_device *hdev,
		951	struct hid_report *report, int reqtype)
		952	{
		953	if (hdev->ll_driver->request)
		954	hdev->ll_driver->request(hdev, report, reqtype);
		955	}
		956
		957	/**
		958	* hid_hw_idle - send idle request to device
		959	*
		960	* @hdev: hid device
		961	* @report: report to control
		962	* @idle: idle state
		963	* @reqtype: hid request type
		964	*/
		965	static inline int hid_hw_idle(struct hid_device *hdev, int report, int idle,
		966	int reqtype)
		967	{
		968	if (hdev->ll_driver->idle)
		969	return hdev->ll_driver->idle(hdev, report, idle, reqtype);
		970
		971	return 0;
		972	}
		973
		974	/**
		975	* hid_hw_wait - wait for buffered io to complete
		976	*
		977	* @hdev: hid device
		978	*/
		979	static inline void hid_hw_wait(struct hid_device *hdev)
		980	{
		981	if (hdev->ll_driver->wait)
		982	hdev->ll_driver->wait(hdev);
		983	}
		984
886	int hid_report_raw_event(struct hid_device hid, int type, u8 data, int size,	985	int hid_report_raw_event(struct hid_device hid, int type, u8 data, int size,
887	int interrupt);	986	int interrupt);
888		987

samples/hidraw/hid-example.c+1−2

 /*
  * Ugly hack to work around failing compilation on systems that don't
  * yet populate new version of hidraw.h to userspace.
- *
- * If you need this, please have your distro update the kernel headers.
  */
 #ifndef HIDIOCSFEATURE
+#warning Please have your distro update the userspace kernel headers
 #define HIDIOCSFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
 #define HIDIOCGFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
 #endif

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code