Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid (a53e77fa) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/hid/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -589,6 +589,7 @@ config HID_WACOM_POWER_SUPPLY
	config HID_WIIMOTE		config HID_WIIMOTE
	tristate "Nintendo Wii Remote support"		tristate "Nintendo Wii Remote support"
	depends on BT_HIDP		depends on BT_HIDP
			depends on LEDS_CLASS
	---help---		---help---
	Support for the Nintendo Wii Remote bluetooth device.		Support for the Nintendo Wii Remote bluetooth device.

drivers/hid/hid-apple.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -444,6 +444,12 @@ static const struct hid_device_id apple_devices[] = {
	{ 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_GEYSER4_HF_JIS),
	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|		.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
	APPLE_RDESC_JIS },		APPLE_RDESC_JIS },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
			.driver_data = APPLE_HAS_FN },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
			.driver_data = APPLE_HAS_FN \| APPLE_ISO_KEYBOARD },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
			.driver_data = APPLE_HAS_FN },
	{ 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_ANSI),
	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN },		.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN },
	{ 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_ISO),

drivers/hid/hid-core.c

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1340,6 +1340,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },		{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },		{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },		{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
			{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },		{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },		{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },		{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },

drivers/hid/hid-ids.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -109,6 +109,9 @@
	#define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI 0x0245		#define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI 0x0245
	#define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO 0x0246		#define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO 0x0246
	#define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS 0x0247		#define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS 0x0247
			#define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI 0x024f
			#define USB_DEVICE_ID_APPLE_ALU_REVB_ISO 0x0250
			#define USB_DEVICE_ID_APPLE_ALU_REVB_JIS 0x0251
	#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI 0x0239		#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI 0x0239
	#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO 0x023a		#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO 0x023a
	#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS 0x023b		#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS 0x023b
	@@ -576,6 +579,9 @@
	#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001		#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
	#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE 0x0600		#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE 0x0600

			#define USB_VENDOR_ID_SIGMA_MICRO 0x1c4f
			#define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD 0x0002

	#define USB_VENDOR_ID_SKYCABLE 0x1223		#define USB_VENDOR_ID_SKYCABLE 0x1223
	#define USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER 0x3F07		#define USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER 0x3F07

drivers/hid/hid-wiimote.c

+183 −94

Original line number	Original line	Diff line number	Diff line
	@@ -10,10 +10,10 @@
	* any later version.		* any later version.
	*/		*/

	#include <linux/atomic.h>
	#include <linux/device.h>		#include <linux/device.h>
	#include <linux/hid.h>		#include <linux/hid.h>
	#include <linux/input.h>		#include <linux/input.h>
			#include <linux/leds.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
	#include "hid-ids.h"		#include "hid-ids.h"
	@@ -33,9 +33,9 @@ struct wiimote_state {
	};		};

	struct wiimote_data {		struct wiimote_data {
	atomic_t ready;
	struct hid_device *hdev;		struct hid_device *hdev;
	struct input_dev *input;		struct input_dev *input;
			struct led_classdev *leds[4];

	spinlock_t qlock;		spinlock_t qlock;
	__u8 head;		__u8 head;
	@@ -53,8 +53,15 @@ struct wiimote_data {
	#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 \| WIIPROTO_FLAG_LED2 \| \		#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 \| WIIPROTO_FLAG_LED2 \| \
	WIIPROTO_FLAG_LED3 \| WIIPROTO_FLAG_LED4)		WIIPROTO_FLAG_LED3 \| WIIPROTO_FLAG_LED4)

			/* return flag for led \num */
			#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))

	enum wiiproto_reqs {		enum wiiproto_reqs {
			WIIPROTO_REQ_NULL = 0x0,
	WIIPROTO_REQ_LED = 0x11,		WIIPROTO_REQ_LED = 0x11,
			WIIPROTO_REQ_DRM = 0x12,
			WIIPROTO_REQ_STATUS = 0x20,
			WIIPROTO_REQ_RETURN = 0x22,
	WIIPROTO_REQ_DRM_K = 0x30,		WIIPROTO_REQ_DRM_K = 0x30,
	};		};

	@@ -87,9 +94,6 @@ static __u16 wiiproto_keymap[] = {
	BTN_MODE, /* WIIPROTO_KEY_HOME */		BTN_MODE, /* WIIPROTO_KEY_HOME */
	};		};

	#define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
	dev))

	static ssize_t wiimote_hid_send(struct hid_device hdev, __u8 buffer,		static ssize_t wiimote_hid_send(struct hid_device hdev, __u8 buffer,
	size_t count)		size_t count)
	{		{
	@@ -192,66 +196,96 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
	wiimote_queue(wdata, cmd, sizeof(cmd));		wiimote_queue(wdata, cmd, sizeof(cmd));
	}		}

	#define wiifs_led_show_set(num) \		/*
	static ssize_t wiifs_led_show_##num(struct device *dev, \		* Check what peripherals of the wiimote are currently
	struct device_attribute attr, char buf) \		* active and select a proper DRM that supports all of
	{ \		* the requested data inputs.
	struct wiimote_data *wdata = dev_to_wii(dev); \		*/
	unsigned long flags; \		static __u8 select_drm(struct wiimote_data *wdata)
	int state; \		{
	\		return WIIPROTO_REQ_DRM_K;
	if (!atomic_read(&wdata->ready)) \		}
	return -EBUSY; \
	\		static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
	spin_lock_irqsave(&wdata->state.lock, flags); \		{
	state = !!(wdata->state.flags & WIIPROTO_FLAG_LED##num); \		__u8 cmd[3];
	spin_unlock_irqrestore(&wdata->state.lock, flags); \
	\		if (drm == WIIPROTO_REQ_NULL)
	return sprintf(buf, "%d\n", state); \		drm = select_drm(wdata);
	} \
	static ssize_t wiifs_led_set_##num(struct device *dev, \		cmd[0] = WIIPROTO_REQ_DRM;
	struct device_attribute attr, const char buf, size_t count) \		cmd[1] = 0;
	{ \		cmd[2] = drm;
	struct wiimote_data *wdata = dev_to_wii(dev); \
	int tmp = simple_strtoul(buf, NULL, 10); \		wiimote_queue(wdata, cmd, sizeof(cmd));
	unsigned long flags; \		}
	__u8 state; \
	\		static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
	if (!atomic_read(&wdata->ready)) \		{
	return -EBUSY; \		struct wiimote_data *wdata;
	\		struct device *dev = led_dev->dev->parent;
	spin_lock_irqsave(&wdata->state.lock, flags); \		int i;
	\		unsigned long flags;
	state = wdata->state.flags; \		bool value = false;
	\
	if (tmp) \		wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
	wiiproto_req_leds(wdata, state \| WIIPROTO_FLAG_LED##num);\
	else \		for (i = 0; i < 4; ++i) {
	wiiproto_req_leds(wdata, state & ~WIIPROTO_FLAG_LED##num);\		if (wdata->leds[i] == led_dev) {
	\		spin_lock_irqsave(&wdata->state.lock, flags);
	spin_unlock_irqrestore(&wdata->state.lock, flags); \		value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
	\		spin_unlock_irqrestore(&wdata->state.lock, flags);
	return count; \		break;
	} \		}
	static DEVICE_ATTR(led##num, S_IRUGO \| S_IWUSR, wiifs_led_show_##num, \		}
	wiifs_led_set_##num)
			return value ? LED_FULL : LED_OFF;
	wiifs_led_show_set(1);		}
	wiifs_led_show_set(2);
	wiifs_led_show_set(3);		static void wiimote_leds_set(struct led_classdev *led_dev,
	wiifs_led_show_set(4);		enum led_brightness value)
			{
			struct wiimote_data *wdata;
			struct device *dev = led_dev->dev->parent;
			int i;
			unsigned long flags;
			__u8 state, flag;

			wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));

			for (i = 0; i < 4; ++i) {
			if (wdata->leds[i] == led_dev) {
			flag = WIIPROTO_FLAG_LED(i + 1);
			spin_lock_irqsave(&wdata->state.lock, flags);
			state = wdata->state.flags;
			if (value == LED_OFF)
			wiiproto_req_leds(wdata, state & ~flag);
			else
			wiiproto_req_leds(wdata, state \| flag);
			spin_unlock_irqrestore(&wdata->state.lock, flags);
			break;
			}
			}
			}

	static int wiimote_input_event(struct input_dev *dev, unsigned int type,		static int wiimote_input_event(struct input_dev *dev, unsigned int type,
	unsigned int code, int value)		unsigned int code, int value)
			{
			return 0;
			}

			static int wiimote_input_open(struct input_dev *dev)
	{		{
	struct wiimote_data *wdata = input_get_drvdata(dev);		struct wiimote_data *wdata = input_get_drvdata(dev);

	if (!atomic_read(&wdata->ready))		return hid_hw_open(wdata->hdev);
	return -EBUSY;		}
	/* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
	smp_rmb();

	return 0;		static void wiimote_input_close(struct input_dev *dev)
			{
			struct wiimote_data *wdata = input_get_drvdata(dev);

			hid_hw_close(wdata->hdev);
	}		}

	static void handler_keys(struct wiimote_data wdata, const __u8 payload)		static void handler_keys(struct wiimote_data wdata, const __u8 payload)
	@@ -281,6 +315,26 @@ static void handler_keys(struct wiimote_data wdata, const __u8 payload)
	input_sync(wdata->input);		input_sync(wdata->input);
	}		}

			static void handler_status(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);
			}

			static void handler_return(struct wiimote_data wdata, const __u8 payload)
			{
			__u8 err = payload[3];
			__u8 cmd = payload[2];

			handler_keys(wdata, payload);

			if (err)
			hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
			cmd);
			}

	struct wiiproto_handler {		struct wiiproto_handler {
	__u8 id;		__u8 id;
	size_t size;		size_t size;
	@@ -288,6 +342,8 @@ struct wiiproto_handler {
	};		};

	static struct wiiproto_handler handlers[] = {		static struct wiiproto_handler handlers[] = {
			{ .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
			{ .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
	{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },		{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
	{ .id = 0 }		{ .id = 0 }
	};		};
	@@ -300,11 +356,6 @@ static int wiimote_hid_event(struct hid_device hdev, struct hid_report report,
	int i;		int i;
	unsigned long flags;		unsigned long flags;

	if (!atomic_read(&wdata->ready))
	return -EBUSY;
	/* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
	smp_rmb();

	if (size < 1)		if (size < 1)
	return -EINVAL;		return -EINVAL;

	@@ -321,6 +372,58 @@ static int wiimote_hid_event(struct hid_device hdev, struct hid_report report,
	return 0;		return 0;
	}		}

			static void wiimote_leds_destroy(struct wiimote_data *wdata)
			{
			int i;
			struct led_classdev *led;

			for (i = 0; i < 4; ++i) {
			if (wdata->leds[i]) {
			led = wdata->leds[i];
			wdata->leds[i] = NULL;
			led_classdev_unregister(led);
			kfree(led);
			}
			}
			}

			static int wiimote_leds_create(struct wiimote_data *wdata)
			{
			int i, ret;
			struct device *dev = &wdata->hdev->dev;
			size_t namesz = strlen(dev_name(dev)) + 9;
			struct led_classdev *led;
			char *name;

			for (i = 0; i < 4; ++i) {
			led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
			if (!led) {
			ret = -ENOMEM;
			goto err;
			}
			name = (void*)&led[1];
			snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
			led->name = name;
			led->brightness = 0;
			led->max_brightness = 1;
			led->brightness_get = wiimote_leds_get;
			led->brightness_set = wiimote_leds_set;

			ret = led_classdev_register(dev, led);
			if (ret) {
			kfree(led);
			goto err;
			}
			wdata->leds[i] = led;
			}

			return 0;

			err:
			wiimote_leds_destroy(wdata);
			return ret;
			}

	static struct wiimote_data wiimote_create(struct hid_device hdev)		static struct wiimote_data wiimote_create(struct hid_device hdev)
	{		{
	struct wiimote_data *wdata;		struct wiimote_data *wdata;
	@@ -341,6 +444,8 @@ static struct wiimote_data wiimote_create(struct hid_device hdev)

	input_set_drvdata(wdata->input, wdata);		input_set_drvdata(wdata->input, wdata);
	wdata->input->event = wiimote_input_event;		wdata->input->event = wiimote_input_event;
			wdata->input->open = wiimote_input_open;
			wdata->input->close = wiimote_input_close;
	wdata->input->dev.parent = &wdata->hdev->dev;		wdata->input->dev.parent = &wdata->hdev->dev;
	wdata->input->id.bustype = wdata->hdev->bus;		wdata->input->id.bustype = wdata->hdev->bus;
	wdata->input->id.vendor = wdata->hdev->vendor;		wdata->input->id.vendor = wdata->hdev->vendor;
	@@ -362,6 +467,12 @@ static struct wiimote_data wiimote_create(struct hid_device hdev)

	static void wiimote_destroy(struct wiimote_data *wdata)		static void wiimote_destroy(struct wiimote_data *wdata)
	{		{
			wiimote_leds_destroy(wdata);

			input_unregister_device(wdata->input);
			cancel_work_sync(&wdata->worker);
			hid_hw_stop(wdata->hdev);

	kfree(wdata);		kfree(wdata);
	}		}

	@@ -377,19 +488,6 @@ static int wiimote_hid_probe(struct hid_device *hdev,
	return -ENOMEM;		return -ENOMEM;
	}		}

	ret = device_create_file(&hdev->dev, &dev_attr_led1);
	if (ret)
	goto err;
	ret = device_create_file(&hdev->dev, &dev_attr_led2);
	if (ret)
	goto err;
	ret = device_create_file(&hdev->dev, &dev_attr_led3);
	if (ret)
	goto err;
	ret = device_create_file(&hdev->dev, &dev_attr_led4);
	if (ret)
	goto err;

	ret = hid_parse(hdev);		ret = hid_parse(hdev);
	if (ret) {		if (ret) {
	hid_err(hdev, "HID parse failed\n");		hid_err(hdev, "HID parse failed\n");
	@@ -408,9 +506,10 @@ static int wiimote_hid_probe(struct hid_device *hdev,
	goto err_stop;		goto err_stop;
	}		}

	/* smp_wmb: Write wdata->xy first before wdata->ready is set to 1 */		ret = wiimote_leds_create(wdata);
	smp_wmb();		if (ret)
	atomic_set(&wdata->ready, 1);		goto err_free;

	hid_info(hdev, "New device registered\n");		hid_info(hdev, "New device registered\n");

	/* by default set led1 after device initialization */		/* by default set led1 after device initialization */
	@@ -420,15 +519,15 @@ static int wiimote_hid_probe(struct hid_device *hdev,

	return 0;		return 0;

			err_free:
			wiimote_destroy(wdata);
			return ret;

	err_stop:		err_stop:
	hid_hw_stop(hdev);		hid_hw_stop(hdev);
	err:		err:
	input_free_device(wdata->input);		input_free_device(wdata->input);
	device_remove_file(&hdev->dev, &dev_attr_led1);		kfree(wdata);
	device_remove_file(&hdev->dev, &dev_attr_led2);
	device_remove_file(&hdev->dev, &dev_attr_led3);
	device_remove_file(&hdev->dev, &dev_attr_led4);
	wiimote_destroy(wdata);
	return ret;		return ret;
	}		}

	@@ -437,16 +536,6 @@ static void wiimote_hid_remove(struct hid_device *hdev)
	struct wiimote_data *wdata = hid_get_drvdata(hdev);		struct wiimote_data *wdata = hid_get_drvdata(hdev);

	hid_info(hdev, "Device removed\n");		hid_info(hdev, "Device removed\n");

	device_remove_file(&hdev->dev, &dev_attr_led1);
	device_remove_file(&hdev->dev, &dev_attr_led2);
	device_remove_file(&hdev->dev, &dev_attr_led3);
	device_remove_file(&hdev->dev, &dev_attr_led4);

	hid_hw_stop(hdev);
	input_unregister_device(wdata->input);

	cancel_work_sync(&wdata->worker);
	wiimote_destroy(wdata);		wiimote_destroy(wdata);
	}		}