~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,16 +1,12 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2		- * HIDPP protocol for Logitech Unifying receivers
	3	+ * HIDPP protocol for Logitech receivers
3	4	*
4	5	* Copyright (c) 2011 Logitech (c)
5	6	* Copyright (c) 2012-2013 Google (c)
6	7	* Copyright (c) 2013-2014 Red Hat Inc.
7	8	*/
8	9
9		-/*
10		- * This program is free software; you can redistribute it and/or modify it
11		- * under the terms of the GNU General Public License as published by the Free
12		- * Software Foundation; version 2 of the License.
13		- */
14	10
15	11	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16	12
..	..	@@ -21,6 +17,7 @@
21	17	#include <linux/module.h>
22	18	#include <linux/slab.h>
23	19	#include <linux/sched.h>
	20	+#include <linux/sched/clock.h>
24	21	#include <linux/kfifo.h>
25	22	#include <linux/input/mt.h>
26	23	#include <linux/workqueue.h>
..	..	@@ -50,7 +47,15 @@
50	47
51	48	#define HIDPP_REPORT_SHORT_LENGTH 7
52	49	#define HIDPP_REPORT_LONG_LENGTH 20
53		-#define HIDPP_REPORT_VERY_LONG_LENGTH 64
	50	+#define HIDPP_REPORT_VERY_LONG_MAX_LENGTH 64
	51	+
	52	+#define HIDPP_REPORT_SHORT_SUPPORTED BIT(0)
	53	+#define HIDPP_REPORT_LONG_SUPPORTED BIT(1)
	54	+#define HIDPP_REPORT_VERY_LONG_SUPPORTED BIT(2)
	55	+
	56	+#define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS 0x03
	57	+#define HIDPP_SUB_ID_ROLLER 0x05
	58	+#define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS 0x06
54	59
55	60	#define HIDPP_QUIRK_CLASS_WTP BIT(0)
56	61	#define HIDPP_QUIRK_CLASS_M560 BIT(1)
..	..	@@ -64,6 +69,21 @@
64	69	#define HIDPP_QUIRK_NO_HIDINPUT BIT(23)
65	70	#define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS BIT(24)
66	71	#define HIDPP_QUIRK_UNIFYING BIT(25)
	72	+#define HIDPP_QUIRK_HI_RES_SCROLL_1P0 BIT(26)
	73	+#define HIDPP_QUIRK_HI_RES_SCROLL_X2120 BIT(27)
	74	+#define HIDPP_QUIRK_HI_RES_SCROLL_X2121 BIT(28)
	75	+#define HIDPP_QUIRK_HIDPP_WHEELS BIT(29)
	76	+#define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS BIT(30)
	77	+#define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS BIT(31)
	78	+
	79	+/* These are just aliases for now */
	80	+#define HIDPP_QUIRK_KBD_SCROLL_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
	81	+#define HIDPP_QUIRK_KBD_ZOOM_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
	82	+
	83	+/* Convenience constant to check for any high-res support. */
	84	+#define HIDPP_QUIRK_HI_RES_SCROLL (HIDPP_QUIRK_HI_RES_SCROLL_1P0 \| \
	85	+ HIDPP_QUIRK_HI_RES_SCROLL_X2120 \| \
	86	+ HIDPP_QUIRK_HI_RES_SCROLL_X2121)
67	87
68	88	#define HIDPP_QUIRK_DELAYED_INIT HIDPP_QUIRK_NO_HIDINPUT
69	89
..	..	@@ -71,6 +91,9 @@
71	91	#define HIDPP_CAPABILITY_HIDPP20_BATTERY BIT(1)
72	92	#define HIDPP_CAPABILITY_BATTERY_MILEAGE BIT(2)
73	93	#define HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS BIT(3)
	94	+#define HIDPP_CAPABILITY_BATTERY_VOLTAGE BIT(4)
	95	+
	96	+#define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
74	97
75	98	/*
76	99	* There are two hidpp protocols in use, the first version hidpp10 is known
..	..	@@ -97,13 +120,13 @@
97	120	struct fap {
98	121	u8 feature_index;
99	122	u8 funcindex_clientid;
100		- u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
	123	+ u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
101	124	};
102	125
103	126	struct rap {
104	127	u8 sub_id;
105	128	u8 reg_address;
106		- u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
	129	+ u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
107	130	};
108	131
109	132	struct hidpp_report {
..	..	@@ -119,21 +142,44 @@
119	142	struct hidpp_battery {
120	143	u8 feature_index;
121	144	u8 solar_feature_index;
	145	+ u8 voltage_feature_index;
122	146	struct power_supply_desc desc;
123	147	struct power_supply *ps;
124	148	char name[64];
125	149	int status;
126	150	int capacity;
127	151	int level;
	152	+ int voltage;
	153	+ int charge_type;
128	154	bool online;
	155	+};
	156	+
	157	+/**
	158	+ * struct hidpp_scroll_counter - Utility class for processing high-resolution
	159	+ * scroll events.
	160	+ * @dev: the input device for which events should be reported.
	161	+ * @wheel_multiplier: the scalar multiplier to be applied to each wheel event
	162	+ * @remainder: counts the number of high-resolution units moved since the last
	163	+ * low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
	164	+ * only be used by class methods.
	165	+ * @direction: direction of last movement (1 or -1)
	166	+ * @last_time: last event time, used to reset remainder after inactivity
	167	+ */
	168	+struct hidpp_scroll_counter {
	169	+ int wheel_multiplier;
	170	+ int remainder;
	171	+ int direction;
	172	+ unsigned long long last_time;
129	173	};
130	174
131	175	struct hidpp_device {
132	176	struct hid_device *hid_dev;
	177	+ struct input_dev *input;
133	178	struct mutex send_mutex;
134	179	void *send_receive_buf;
135	180	char name; / will never be NULL and should not be freed */
136	181	wait_queue_head_t wait;
	182	+ int very_long_report_length;
137	183	bool answer_available;
138	184	u8 protocol_major;
139	185	u8 protocol_minor;
..	..	@@ -147,8 +193,12 @@
147	193
148	194	unsigned long quirks;
149	195	unsigned long capabilities;
	196	+ u8 supported_reports;
150	197
151	198	struct hidpp_battery battery;
	199	+ struct hidpp_scroll_counter vertical_wheel_counter;
	200	+
	201	+ u8 wireless_feature_index;
152	202	};
153	203
154	204	/* HID++ 1.0 error codes */
..	..	@@ -177,8 +227,6 @@
177	227	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
178	228	int fields_count, ret;
179	229
180		- hidpp = hid_get_drvdata(hdev);
181		-
182	230	switch (hidpp_report->report_id) {
183	231	case REPORT_ID_HIDPP_SHORT:
184	232	fields_count = HIDPP_REPORT_SHORT_LENGTH;
..	..	@@ -187,7 +235,7 @@
187	235	fields_count = HIDPP_REPORT_LONG_LENGTH;
188	236	break;
189	237	case REPORT_ID_HIDPP_VERY_LONG:
190		- fields_count = HIDPP_REPORT_VERY_LONG_LENGTH;
	238	+ fields_count = hidpp->very_long_report_length;
191	239	break;
192	240	default:
193	241	return -ENODEV;
..	..	@@ -305,6 +353,11 @@
305	353	struct hidpp_report *message;
306	354	int ret, max_count;
307	355
	356	+ /* Send as long report if short reports are not supported. */
	357	+ if (report_id == REPORT_ID_HIDPP_SHORT &&
	358	+ !(hidpp_dev->supported_reports & HIDPP_REPORT_SHORT_SUPPORTED))
	359	+ report_id = REPORT_ID_HIDPP_LONG;
	360	+
308	361	switch (report_id) {
309	362	case REPORT_ID_HIDPP_SHORT:
310	363	max_count = HIDPP_REPORT_SHORT_LENGTH - 4;
..	..	@@ -313,7 +366,7 @@
313	366	max_count = HIDPP_REPORT_LONG_LENGTH - 4;
314	367	break;
315	368	case REPORT_ID_HIDPP_VERY_LONG:
316		- max_count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
	369	+ max_count = hidpp_dev->very_long_report_length - 4;
317	370	break;
318	371	default:
319	372	return -EINVAL;
..	..	@@ -358,10 +411,13 @@
358	411	(answer->fap.params[0] == question->fap.funcindex_clientid);
359	412	}
360	413
361		-static inline bool hidpp_report_is_connect_event(struct hidpp_report *report)
	414	+static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
	415	+ struct hidpp_report *report)
362	416	{
363		- return (report->report_id == REPORT_ID_HIDPP_SHORT) &&
364		- (report->rap.sub_id == 0x41);
	417	+ return (hidpp->wireless_feature_index &&
	418	+ (report->fap.feature_index == hidpp->wireless_feature_index)) \|\|
	419	+ ((report->report_id == REPORT_ID_HIDPP_SHORT) &&
	420	+ (report->rap.sub_id == 0x41));
365	421	}
366	422
367	423	/**
..	..	@@ -391,6 +447,68 @@
391	447	*name = new_name;
392	448	}
393	449
	450	+/**
	451	+ * hidpp_scroll_counter_handle_scroll() - Send high- and low-resolution scroll
	452	+ * events given a high-resolution wheel
	453	+ * movement.
	454	+ * @counter: a hid_scroll_counter struct describing the wheel.
	455	+ * @hi_res_value: the movement of the wheel, in the mouse's high-resolution
	456	+ * units.
	457	+ *
	458	+ * Given a high-resolution movement, this function converts the movement into
	459	+ * fractions of 120 and emits high-resolution scroll events for the input
	460	+ * device. It also uses the multiplier from &struct hid_scroll_counter to
	461	+ * emit low-resolution scroll events when appropriate for
	462	+ * backwards-compatibility with userspace input libraries.
	463	+ */
	464	+static void hidpp_scroll_counter_handle_scroll(struct input_dev *input_dev,
	465	+ struct hidpp_scroll_counter *counter,
	466	+ int hi_res_value)
	467	+{
	468	+ int low_res_value, remainder, direction;
	469	+ unsigned long long now, previous;
	470	+
	471	+ hi_res_value = hi_res_value * 120/counter->wheel_multiplier;
	472	+ input_report_rel(input_dev, REL_WHEEL_HI_RES, hi_res_value);
	473	+
	474	+ remainder = counter->remainder;
	475	+ direction = hi_res_value > 0 ? 1 : -1;
	476	+
	477	+ now = sched_clock();
	478	+ previous = counter->last_time;
	479	+ counter->last_time = now;
	480	+ /*
	481	+ * Reset the remainder after a period of inactivity or when the
	482	+ * direction changes. This prevents the REL_WHEEL emulation point
	483	+ * from sliding for devices that don't always provide the same
	484	+ * number of movements per detent.
	485	+ */
	486	+ if (now - previous > 1000000000 \|\| direction != counter->direction)
	487	+ remainder = 0;
	488	+
	489	+ counter->direction = direction;
	490	+ remainder += hi_res_value;
	491	+
	492	+ /* Some wheels will rest 7/8ths of a detent from the previous detent
	493	+ * after slow movement, so we want the threshold for low-res events to
	494	+ * be in the middle between two detents (e.g. after 4/8ths) as
	495	+ * opposed to on the detents themselves (8/8ths).
	496	+ */
	497	+ if (abs(remainder) >= 60) {
	498	+ /* Add (or subtract) 1 because we want to trigger when the wheel
	499	+ * is half-way to the next detent (i.e. scroll 1 detent after a
	500	+ * 1/2 detent movement, 2 detents after a 1 1/2 detent movement,
	501	+ * etc.).
	502	+ */
	503	+ low_res_value = remainder / 120;
	504	+ if (low_res_value == 0)
	505	+ low_res_value = (hi_res_value > 0 ? 1 : -1);
	506	+ input_report_rel(input_dev, REL_WHEEL, low_res_value);
	507	+ remainder -= low_res_value * 120;
	508	+ }
	509	+ counter->remainder = remainder;
	510	+}
	511	+
394	512	/* -------------------------------------------------------------------------- */
395	513	/* HIDP++ 1.0 commands */
396	514	/* -------------------------------------------------------------------------- */
..	..	@@ -400,32 +518,64 @@
400	518	#define HIDPP_SET_LONG_REGISTER 0x82
401	519	#define HIDPP_GET_LONG_REGISTER 0x83
402	520
403		-#define HIDPP_REG_GENERAL 0x00
404		-
405		-static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
	521	+/**
	522	+ * hidpp10_set_register - Modify a HID++ 1.0 register.
	523	+ * @hidpp_dev: the device to set the register on.
	524	+ * @register_address: the address of the register to modify.
	525	+ * @byte: the byte of the register to modify. Should be less than 3.
	526	+ * @mask: mask of the bits to modify
	527	+ * @value: new values for the bits in mask
	528	+ * Return: 0 if successful, otherwise a negative error code.
	529	+ */
	530	+static int hidpp10_set_register(struct hidpp_device *hidpp_dev,
	531	+ u8 register_address, u8 byte, u8 mask, u8 value)
406	532	{
407	533	struct hidpp_report response;
408	534	int ret;
409	535	u8 params[3] = { 0 };
410	536
411	537	ret = hidpp_send_rap_command_sync(hidpp_dev,
412		- REPORT_ID_HIDPP_SHORT,
413		- HIDPP_GET_REGISTER,
414		- HIDPP_REG_GENERAL,
415		- NULL, 0, &response);
	538	+ REPORT_ID_HIDPP_SHORT,
	539	+ HIDPP_GET_REGISTER,
	540	+ register_address,
	541	+ NULL, 0, &response);
416	542	if (ret)
417	543	return ret;
418	544
419	545	memcpy(params, response.rap.params, 3);
420	546
421		- /* Set the battery bit */
422		- params[0] \|= BIT(4);
	547	+ params[byte] &= ~mask;
	548	+ params[byte] \|= value & mask;
423	549
424	550	return hidpp_send_rap_command_sync(hidpp_dev,
425		- REPORT_ID_HIDPP_SHORT,
426		- HIDPP_SET_REGISTER,
427		- HIDPP_REG_GENERAL,
428		- params, 3, &response);
	551	+ REPORT_ID_HIDPP_SHORT,
	552	+ HIDPP_SET_REGISTER,
	553	+ register_address,
	554	+ params, 3, &response);
	555	+}
	556	+
	557	+#define HIDPP_REG_ENABLE_REPORTS 0x00
	558	+#define HIDPP_ENABLE_CONSUMER_REPORT BIT(0)
	559	+#define HIDPP_ENABLE_WHEEL_REPORT BIT(2)
	560	+#define HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT BIT(3)
	561	+#define HIDPP_ENABLE_BAT_REPORT BIT(4)
	562	+#define HIDPP_ENABLE_HWHEEL_REPORT BIT(5)
	563	+
	564	+static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
	565	+{
	566	+ return hidpp10_set_register(hidpp_dev, HIDPP_REG_ENABLE_REPORTS, 0,
	567	+ HIDPP_ENABLE_BAT_REPORT, HIDPP_ENABLE_BAT_REPORT);
	568	+}
	569	+
	570	+#define HIDPP_REG_FEATURES 0x01
	571	+#define HIDPP_ENABLE_SPECIAL_BUTTON_FUNC BIT(1)
	572	+#define HIDPP_ENABLE_FAST_SCROLL BIT(6)
	573	+
	574	+/* On HID++ 1.0 devices, high-res scroll was called "scrolling acceleration". */
	575	+static int hidpp10_enable_scrolling_acceleration(struct hidpp_device *hidpp_dev)
	576	+{
	577	+ return hidpp10_set_register(hidpp_dev, HIDPP_REG_FEATURES, 0,
	578	+ HIDPP_ENABLE_FAST_SCROLL, HIDPP_ENABLE_FAST_SCROLL);
429	579	}
430	580
431	581	#define HIDPP_REG_BATTERY_STATUS 0x07
..	..	@@ -630,6 +780,9 @@
630	780	if (2 + len > sizeof(response.rap.params))
631	781	return NULL;
632	782
	783	+ if (len < 4) /* logitech devices are usually at least Xddd */
	784	+ return NULL;
	785	+
633	786	name = kzalloc(len + 1, GFP_KERNEL);
634	787	if (!name)
635	788	return NULL;
..	..	@@ -739,7 +892,7 @@
739	892	if (ret == HIDPP_ERROR_INVALID_SUBID) {
740	893	hidpp->protocol_major = 1;
741	894	hidpp->protocol_minor = 0;
742		- return 0;
	895	+ goto print_version;
743	896	}
744	897
745	898	/* the device might not be connected */
..	..	@@ -763,18 +916,10 @@
763	916	hidpp->protocol_major = response.rap.params[0];
764	917	hidpp->protocol_minor = response.rap.params[1];
765	918
766		- return ret;
767		-}
768		-
769		-static bool hidpp_is_connected(struct hidpp_device *hidpp)
770		-{
771		- int ret;
772		-
773		- ret = hidpp_root_get_protocol_version(hidpp);
774		- if (!ret)
775		- hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
776		- hidpp->protocol_major, hidpp->protocol_minor);
777		- return ret == 0;
	919	+print_version:
	920	+ hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
	921	+ hidpp->protocol_major, hidpp->protocol_minor);
	922	+ return 0;
778	923	}
779	924
780	925	/* -------------------------------------------------------------------------- */
..	..	@@ -830,7 +975,7 @@
830	975
831	976	switch (response.report_id) {
832	977	case REPORT_ID_HIDPP_VERY_LONG:
833		- count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
	978	+ count = hidpp->very_long_report_length - 4;
834	979	break;
835	980	case REPORT_ID_HIDPP_LONG:
836	981	count = HIDPP_REPORT_LONG_LENGTH - 4;
..	..	@@ -1098,6 +1243,144 @@
1098	1243	return 0;
1099	1244	}
1100	1245
	1246	+/* -------------------------------------------------------------------------- */
	1247	+/* 0x1001: Battery voltage */
	1248	+/* -------------------------------------------------------------------------- */
	1249	+
	1250	+#define HIDPP_PAGE_BATTERY_VOLTAGE 0x1001
	1251	+
	1252	+#define CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE 0x00
	1253	+
	1254	+#define EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST 0x00
	1255	+
	1256	+static int hidpp20_battery_map_status_voltage(u8 data[3], int *voltage,
	1257	+ int level, int charge_type)
	1258	+{
	1259	+ int status;
	1260	+
	1261	+ long flags = (long) data[2];
	1262	+ *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
	1263	+
	1264	+ if (flags & 0x80)
	1265	+ switch (flags & 0x07) {
	1266	+ case 0:
	1267	+ status = POWER_SUPPLY_STATUS_CHARGING;
	1268	+ break;
	1269	+ case 1:
	1270	+ status = POWER_SUPPLY_STATUS_FULL;
	1271	+ *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
	1272	+ break;
	1273	+ case 2:
	1274	+ status = POWER_SUPPLY_STATUS_NOT_CHARGING;
	1275	+ break;
	1276	+ default:
	1277	+ status = POWER_SUPPLY_STATUS_UNKNOWN;
	1278	+ break;
	1279	+ }
	1280	+ else
	1281	+ status = POWER_SUPPLY_STATUS_DISCHARGING;
	1282	+
	1283	+ *charge_type = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
	1284	+ if (test_bit(3, &flags)) {
	1285	+ *charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
	1286	+ }
	1287	+ if (test_bit(4, &flags)) {
	1288	+ *charge_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	1289	+ }
	1290	+ if (test_bit(5, &flags)) {
	1291	+ *level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
	1292	+ }
	1293	+
	1294	+ *voltage = get_unaligned_be16(data);
	1295	+
	1296	+ return status;
	1297	+}
	1298	+
	1299	+static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
	1300	+ u8 feature_index,
	1301	+ int status, int voltage,
	1302	+ int level, int charge_type)
	1303	+{
	1304	+ struct hidpp_report response;
	1305	+ int ret;
	1306	+ u8 params = (u8 )response.fap.params;
	1307	+
	1308	+ ret = hidpp_send_fap_command_sync(hidpp, feature_index,
	1309	+ CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE,
	1310	+ NULL, 0, &response);
	1311	+
	1312	+ if (ret > 0) {
	1313	+ hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
	1314	+ __func__, ret);
	1315	+ return -EPROTO;
	1316	+ }
	1317	+ if (ret)
	1318	+ return ret;
	1319	+
	1320	+ hidpp->capabilities \|= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
	1321	+
	1322	+ *status = hidpp20_battery_map_status_voltage(params, voltage,
	1323	+ level, charge_type);
	1324	+
	1325	+ return 0;
	1326	+}
	1327	+
	1328	+static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
	1329	+{
	1330	+ u8 feature_type;
	1331	+ int ret;
	1332	+ int status, voltage, level, charge_type;
	1333	+
	1334	+ if (hidpp->battery.voltage_feature_index == 0xff) {
	1335	+ ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
	1336	+ &hidpp->battery.voltage_feature_index,
	1337	+ &feature_type);
	1338	+ if (ret)
	1339	+ return ret;
	1340	+ }
	1341	+
	1342	+ ret = hidpp20_battery_get_battery_voltage(hidpp,
	1343	+ hidpp->battery.voltage_feature_index,
	1344	+ &status, &voltage, &level, &charge_type);
	1345	+
	1346	+ if (ret)
	1347	+ return ret;
	1348	+
	1349	+ hidpp->battery.status = status;
	1350	+ hidpp->battery.voltage = voltage;
	1351	+ hidpp->battery.level = level;
	1352	+ hidpp->battery.charge_type = charge_type;
	1353	+ hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
	1354	+
	1355	+ return 0;
	1356	+}
	1357	+
	1358	+static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
	1359	+ u8 *data, int size)
	1360	+{
	1361	+ struct hidpp_report report = (struct hidpp_report )data;
	1362	+ int status, voltage, level, charge_type;
	1363	+
	1364	+ if (report->fap.feature_index != hidpp->battery.voltage_feature_index \|\|
	1365	+ report->fap.funcindex_clientid != EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST)
	1366	+ return 0;
	1367	+
	1368	+ status = hidpp20_battery_map_status_voltage(report->fap.params, &voltage,
	1369	+ &level, &charge_type);
	1370	+
	1371	+ hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
	1372	+
	1373	+ if (voltage != hidpp->battery.voltage \|\| status != hidpp->battery.status) {
	1374	+ hidpp->battery.voltage = voltage;
	1375	+ hidpp->battery.status = status;
	1376	+ hidpp->battery.level = level;
	1377	+ hidpp->battery.charge_type = charge_type;
	1378	+ if (hidpp->battery.ps)
	1379	+ power_supply_changed(hidpp->battery.ps);
	1380	+ }
	1381	+ return 0;
	1382	+}
	1383	+
1101	1384	static enum power_supply_property hidpp_battery_props[] = {
1102	1385	POWER_SUPPLY_PROP_ONLINE,
1103	1386	POWER_SUPPLY_PROP_STATUS,
..	..	@@ -1107,6 +1390,7 @@
1107	1390	POWER_SUPPLY_PROP_SERIAL_NUMBER,
1108	1391	0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY, */
1109	1392	0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY_LEVEL, */
	1393	+ 0, /* placeholder for POWER_SUPPLY_PROP_VOLTAGE_NOW, */
1110	1394	};
1111	1395
1112	1396	static int hidpp_battery_get_property(struct power_supply *psy,
..	..	@@ -1144,12 +1428,130 @@
1144	1428	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
1145	1429	val->strval = hidpp->hid_dev->uniq;
1146	1430	break;
	1431	+ case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	1432	+ /* hardware reports voltage in in mV. sysfs expects uV */
	1433	+ val->intval = hidpp->battery.voltage * 1000;
	1434	+ break;
	1435	+ case POWER_SUPPLY_PROP_CHARGE_TYPE:
	1436	+ val->intval = hidpp->battery.charge_type;
	1437	+ break;
1147	1438	default:
1148	1439	ret = -EINVAL;
1149	1440	break;
1150	1441	}
1151	1442
1152	1443	return ret;
	1444	+}
	1445	+
	1446	+/* -------------------------------------------------------------------------- */
	1447	+/* 0x1d4b: Wireless device status */
	1448	+/* -------------------------------------------------------------------------- */
	1449	+#define HIDPP_PAGE_WIRELESS_DEVICE_STATUS 0x1d4b
	1450	+
	1451	+static int hidpp_set_wireless_feature_index(struct hidpp_device *hidpp)
	1452	+{
	1453	+ u8 feature_type;
	1454	+ int ret;
	1455	+
	1456	+ ret = hidpp_root_get_feature(hidpp,
	1457	+ HIDPP_PAGE_WIRELESS_DEVICE_STATUS,
	1458	+ &hidpp->wireless_feature_index,
	1459	+ &feature_type);
	1460	+
	1461	+ return ret;
	1462	+}
	1463	+
	1464	+/* -------------------------------------------------------------------------- */
	1465	+/* 0x2120: Hi-resolution scrolling */
	1466	+/* -------------------------------------------------------------------------- */
	1467	+
	1468	+#define HIDPP_PAGE_HI_RESOLUTION_SCROLLING 0x2120
	1469	+
	1470	+#define CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE 0x10
	1471	+
	1472	+static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
	1473	+ bool enabled, u8 *multiplier)
	1474	+{
	1475	+ u8 feature_index;
	1476	+ u8 feature_type;
	1477	+ int ret;
	1478	+ u8 params[1];
	1479	+ struct hidpp_report response;
	1480	+
	1481	+ ret = hidpp_root_get_feature(hidpp,
	1482	+ HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
	1483	+ &feature_index,
	1484	+ &feature_type);
	1485	+ if (ret)
	1486	+ return ret;
	1487	+
	1488	+ params[0] = enabled ? BIT(0) : 0;
	1489	+ ret = hidpp_send_fap_command_sync(hidpp, feature_index,
	1490	+ CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE,
	1491	+ params, sizeof(params), &response);
	1492	+ if (ret)
	1493	+ return ret;
	1494	+ *multiplier = response.fap.params[1];
	1495	+ return 0;
	1496	+}
	1497	+
	1498	+/* -------------------------------------------------------------------------- */
	1499	+/* 0x2121: HiRes Wheel */
	1500	+/* -------------------------------------------------------------------------- */
	1501	+
	1502	+#define HIDPP_PAGE_HIRES_WHEEL 0x2121
	1503	+
	1504	+#define CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY 0x00
	1505	+#define CMD_HIRES_WHEEL_SET_WHEEL_MODE 0x20
	1506	+
	1507	+static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
	1508	+ u8 *multiplier)
	1509	+{
	1510	+ u8 feature_index;
	1511	+ u8 feature_type;
	1512	+ int ret;
	1513	+ struct hidpp_report response;
	1514	+
	1515	+ ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
	1516	+ &feature_index, &feature_type);
	1517	+ if (ret)
	1518	+ goto return_default;
	1519	+
	1520	+ ret = hidpp_send_fap_command_sync(hidpp, feature_index,
	1521	+ CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY,
	1522	+ NULL, 0, &response);
	1523	+ if (ret)
	1524	+ goto return_default;
	1525	+
	1526	+ *multiplier = response.fap.params[0];
	1527	+ return 0;
	1528	+return_default:
	1529	+ hid_warn(hidpp->hid_dev,
	1530	+ "Couldn't get wheel multiplier (error %d)\n", ret);
	1531	+ return ret;
	1532	+}
	1533	+
	1534	+static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
	1535	+ bool high_resolution, bool use_hidpp)
	1536	+{
	1537	+ u8 feature_index;
	1538	+ u8 feature_type;
	1539	+ int ret;
	1540	+ u8 params[1];
	1541	+ struct hidpp_report response;
	1542	+
	1543	+ ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
	1544	+ &feature_index, &feature_type);
	1545	+ if (ret)
	1546	+ return ret;
	1547	+
	1548	+ params[0] = (invert ? BIT(2) : 0) \|
	1549	+ (high_resolution ? BIT(1) : 0) \|
	1550	+ (use_hidpp ? BIT(0) : 0);
	1551	+
	1552	+ return hidpp_send_fap_command_sync(hidpp, feature_index,
	1553	+ CMD_HIRES_WHEEL_SET_WHEEL_MODE,
	1554	+ params, sizeof(params), &response);
1153	1555	}
1154	1556
1155	1557	/* -------------------------------------------------------------------------- */
..	..	@@ -1455,6 +1857,7 @@
1455	1857
1456	1858	#define HIDPP_FF_EFFECTID_NONE -1
1457	1859	#define HIDPP_FF_EFFECTID_AUTOCENTER -2
	1860	+#define HIDPP_AUTOCENTER_PARAMS_LENGTH 18
1458	1861
1459	1862	#define HIDPP_FF_MAX_PARAMS 20
1460	1863	#define HIDPP_FF_RESERVED_SLOTS 1
..	..	@@ -1481,7 +1884,7 @@
1481	1884	u8 size;
1482	1885	};
1483	1886
1484		-static const signed short hiddpp_ff_effects[] = {
	1887	+static const signed short hidpp_ff_effects[] = {
1485	1888	FF_CONSTANT,
1486	1889	FF_PERIODIC,
1487	1890	FF_SINE,
..	..	@@ -1496,7 +1899,7 @@
1496	1899	-1
1497	1900	};
1498	1901
1499		-static const signed short hiddpp_ff_effects_v2[] = {
	1902	+static const signed short hidpp_ff_effects_v2[] = {
1500	1903	FF_RAMP,
1501	1904	FF_FRICTION,
1502	1905	FF_INERTIA,
..	..	@@ -1795,7 +2198,7 @@
1795	2198	static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
1796	2199	{
1797	2200	struct hidpp_ff_private_data *data = dev->ff->private;
1798		- u8 params[18];
	2201	+ u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH];
1799	2202
1800	2203	dbg_hid("Setting autocenter to %d.\n", magnitude);
1801	2204
..	..	@@ -1863,11 +2266,17 @@
1863	2266	static void hidpp_ff_destroy(struct ff_device *ff)
1864	2267	{
1865	2268	struct hidpp_ff_private_data *data = ff->private;
	2269	+ struct hid_device *hid = data->hidpp->hid_dev;
1866	2270
	2271	+ hid_info(hid, "Unloading HID++ force feedback.\n");
	2272	+
	2273	+ device_remove_file(&hid->dev, &dev_attr_range);
	2274	+ destroy_workqueue(data->wq);
1867	2275	kfree(data->effect_ids);
1868	2276	}
1869	2277
1870		-static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index)
	2278	+static int hidpp_ff_init(struct hidpp_device *hidpp,
	2279	+ struct hidpp_ff_private_data *data)
1871	2280	{
1872	2281	struct hid_device *hid = hidpp->hid_dev;
1873	2282	struct hid_input *hidinput;
..	..	@@ -1875,9 +2284,7 @@
1875	2284	const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor);
1876	2285	const u16 bcdDevice = le16_to_cpu(udesc->bcdDevice);
1877	2286	struct ff_device *ff;
1878		- struct hidpp_report response;
1879		- struct hidpp_ff_private_data *data;
1880		- int error, j, num_slots;
	2287	+ int error, j, num_slots = data->num_effects;
1881	2288	u8 version;
1882	2289
1883	2290	if (list_empty(&hid->inputs)) {
..	..	@@ -1896,24 +2303,11 @@
1896	2303	version = bcdDevice & 255;
1897	2304
1898	2305	/* Set supported force feedback capabilities */
1899		- for (j = 0; hiddpp_ff_effects[j] >= 0; j++)
1900		- set_bit(hiddpp_ff_effects[j], dev->ffbit);
	2306	+ for (j = 0; hidpp_ff_effects[j] >= 0; j++)
	2307	+ set_bit(hidpp_ff_effects[j], dev->ffbit);
1901	2308	if (version > 1)
1902		- for (j = 0; hiddpp_ff_effects_v2[j] >= 0; j++)
1903		- set_bit(hiddpp_ff_effects_v2[j], dev->ffbit);
1904		-
1905		- /* Read number of slots available in device */
1906		- error = hidpp_send_fap_command_sync(hidpp, feature_index,
1907		- HIDPP_FF_GET_INFO, NULL, 0, &response);
1908		- if (error) {
1909		- if (error < 0)
1910		- return error;
1911		- hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1912		- __func__, error);
1913		- return -EPROTO;
1914		- }
1915		-
1916		- num_slots = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
	2309	+ for (j = 0; hidpp_ff_effects_v2[j] >= 0; j++)
	2310	+ set_bit(hidpp_ff_effects_v2[j], dev->ffbit);
1917	2311
1918	2312	error = input_ff_create(dev, num_slots);
1919	2313
..	..	@@ -1921,8 +2315,11 @@
1921	2315	hid_err(dev, "Failed to create FF device!\n");
1922	2316	return error;
1923	2317	}
1924		-
1925		- data = kzalloc(sizeof(*data), GFP_KERNEL);
	2318	+ /*
	2319	+ * Create a copy of passed data, so we can transfer memory
	2320	+ * ownership to FF core
	2321	+ */
	2322	+ data = kmemdup(data, sizeof(*data), GFP_KERNEL);
1926	2323	if (!data)
1927	2324	return -ENOMEM;
1928	2325	data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
..	..	@@ -1938,10 +2335,7 @@
1938	2335	}
1939	2336
1940	2337	data->hidpp = hidpp;
1941		- data->feature_index = feature_index;
1942	2338	data->version = version;
1943		- data->slot_autocenter = 0;
1944		- data->num_effects = num_slots;
1945	2339	for (j = 0; j < num_slots; j++)
1946	2340	data->effect_ids[j] = -1;
1947	2341
..	..	@@ -1955,67 +2349,19 @@
1955	2349	ff->set_autocenter = hidpp_ff_set_autocenter;
1956	2350	ff->destroy = hidpp_ff_destroy;
1957	2351
1958		-
1959		- /* reset all forces */
1960		- error = hidpp_send_fap_command_sync(hidpp, feature_index,
1961		- HIDPP_FF_RESET_ALL, NULL, 0, &response);
1962		-
1963		- /* Read current Range */
1964		- error = hidpp_send_fap_command_sync(hidpp, feature_index,
1965		- HIDPP_FF_GET_APERTURE, NULL, 0, &response);
1966		- if (error)
1967		- hid_warn(hidpp->hid_dev, "Failed to read range from device!\n");
1968		- data->range = error ? 900 : get_unaligned_be16(&response.fap.params[0]);
1969		-
1970	2352	/* Create sysfs interface */
1971	2353	error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
1972	2354	if (error)
1973	2355	hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
1974	2356
1975		- /* Read the current gain values */
1976		- error = hidpp_send_fap_command_sync(hidpp, feature_index,
1977		- HIDPP_FF_GET_GLOBAL_GAINS, NULL, 0, &response);
1978		- if (error)
1979		- hid_warn(hidpp->hid_dev, "Failed to read gain values from device!\n");
1980		- data->gain = error ? 0xffff : get_unaligned_be16(&response.fap.params[0]);
1981		- /* ignore boost value at response.fap.params[2] */
1982		-
1983	2357	/* init the hardware command queue */
1984	2358	atomic_set(&data->workqueue_size, 0);
1985		-
1986		- /* initialize with zero autocenter to get wheel in usable state */
1987		- hidpp_ff_set_autocenter(dev, 0);
1988	2359
1989	2360	hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
1990	2361	version);
1991	2362
1992	2363	return 0;
1993	2364	}
1994		-
1995		-static int hidpp_ff_deinit(struct hid_device *hid)
1996		-{
1997		- struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
1998		- struct input_dev *dev = hidinput->input;
1999		- struct hidpp_ff_private_data *data;
2000		-
2001		- if (!dev) {
2002		- hid_err(hid, "Struct input_dev not found!\n");
2003		- return -EINVAL;
2004		- }
2005		-
2006		- hid_info(hid, "Unloading HID++ force feedback.\n");
2007		- data = dev->ff->private;
2008		- if (!data) {
2009		- hid_err(hid, "Private data not found!\n");
2010		- return -EINVAL;
2011		- }
2012		-
2013		- destroy_workqueue(data->wq);
2014		- device_remove_file(&hid->dev, &dev_attr_range);
2015		-
2016		- return 0;
2017		-}
2018		-
2019	2365
2020	2366	/* ************************************************************************** */
2021	2367	/* */
..	..	@@ -2030,7 +2376,6 @@
2030	2376	#define WTP_MANUAL_RESOLUTION 39
2031	2377
2032	2378	struct wtp_data {
2033		- struct input_dev *input;
2034	2379	u16 x_size, y_size;
2035	2380	u8 finger_count;
2036	2381	u8 mt_feature_index;
..	..	@@ -2048,7 +2393,7 @@
2048	2393	}
2049	2394
2050	2395	static void wtp_populate_input(struct hidpp_device *hidpp,
2051		- struct input_dev *input_dev, bool origin_is_hid_core)
	2396	+ struct input_dev *input_dev)
2052	2397	{
2053	2398	struct wtp_data *wd = hidpp->private_data;
2054	2399
..	..	@@ -2074,31 +2419,30 @@
2074	2419
2075	2420	input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER \|
2076	2421	INPUT_MT_DROP_UNUSED);
2077		-
2078		- wd->input = input_dev;
2079	2422	}
2080	2423
2081		-static void wtp_touch_event(struct wtp_data *wd,
	2424	+static void wtp_touch_event(struct hidpp_device *hidpp,
2082	2425	struct hidpp_touchpad_raw_xy_finger *touch_report)
2083	2426	{
	2427	+ struct wtp_data *wd = hidpp->private_data;
2084	2428	int slot;
2085	2429
2086	2430	if (!touch_report->finger_id \|\| touch_report->contact_type)
2087	2431	/* no actual data */
2088	2432	return;
2089	2433
2090		- slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id);
	2434	+ slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2091	2435
2092		- input_mt_slot(wd->input, slot);
2093		- input_mt_report_slot_state(wd->input, MT_TOOL_FINGER,
	2436	+ input_mt_slot(hidpp->input, slot);
	2437	+ input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2094	2438	touch_report->contact_status);
2095	2439	if (touch_report->contact_status) {
2096		- input_event(wd->input, EV_ABS, ABS_MT_POSITION_X,
	2440	+ input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2097	2441	touch_report->x);
2098		- input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y,
	2442	+ input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2099	2443	wd->flip_y ? wd->y_size - touch_report->y :
2100	2444	touch_report->y);
2101		- input_event(wd->input, EV_ABS, ABS_MT_PRESSURE,
	2445	+ input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2102	2446	touch_report->area);
2103	2447	}
2104	2448	}
..	..	@@ -2106,19 +2450,18 @@
2106	2450	static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
2107	2451	struct hidpp_touchpad_raw_xy *raw)
2108	2452	{
2109		- struct wtp_data *wd = hidpp->private_data;
2110	2453	int i;
2111	2454
2112	2455	for (i = 0; i < 2; i++)
2113		- wtp_touch_event(wd, &(raw->fingers[i]));
	2456	+ wtp_touch_event(hidpp, &(raw->fingers[i]));
2114	2457
2115	2458	if (raw->end_of_frame &&
2116	2459	!(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
2117		- input_event(wd->input, EV_KEY, BTN_LEFT, raw->button);
	2460	+ input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
2118	2461
2119	2462	if (raw->end_of_frame \|\| raw->finger_count <= 2) {
2120		- input_mt_sync_frame(wd->input);
2121		- input_sync(wd->input);
	2463	+ input_mt_sync_frame(hidpp->input);
	2464	+ input_sync(hidpp->input);
2122	2465	}
2123	2466	}
2124	2467
..	..	@@ -2168,7 +2511,7 @@
2168	2511	struct hidpp_report report = (struct hidpp_report )data;
2169	2512	struct hidpp_touchpad_raw_xy raw;
2170	2513
2171		- if (!wd \|\| !wd->input)
	2514	+ if (!wd \|\| !hidpp->input)
2172	2515	return 1;
2173	2516
2174	2517	switch (data[0]) {
..	..	@@ -2179,11 +2522,11 @@
2179	2522	return 1;
2180	2523	}
2181	2524	if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
2182		- input_event(wd->input, EV_KEY, BTN_LEFT,
	2525	+ input_event(hidpp->input, EV_KEY, BTN_LEFT,
2183	2526	!!(data[1] & 0x01));
2184		- input_event(wd->input, EV_KEY, BTN_RIGHT,
	2527	+ input_event(hidpp->input, EV_KEY, BTN_RIGHT,
2185	2528	!!(data[1] & 0x02));
2186		- input_sync(wd->input);
	2529	+ input_sync(hidpp->input);
2187	2530	return 0;
2188	2531	} else {
2189	2532	if (size < 21)
..	..	@@ -2301,10 +2644,6 @@
2301	2644
2302	2645	static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
2303	2646
2304		-struct m560_private_data {
2305		- struct input_dev *input;
2306		-};
2307		-
2308	2647	/* how buttons are mapped in the report */
2309	2648	#define M560_MOUSE_BTN_LEFT 0x01
2310	2649	#define M560_MOUSE_BTN_RIGHT 0x02
..	..	@@ -2332,28 +2671,12 @@
2332	2671	);
2333	2672	}
2334	2673
2335		-static int m560_allocate(struct hid_device *hdev)
2336		-{
2337		- struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2338		- struct m560_private_data *d;
2339		-
2340		- d = devm_kzalloc(&hdev->dev, sizeof(struct m560_private_data),
2341		- GFP_KERNEL);
2342		- if (!d)
2343		- return -ENOMEM;
2344		-
2345		- hidpp->private_data = d;
2346		-
2347		- return 0;
2348		-};
2349		-
2350	2674	static int m560_raw_event(struct hid_device hdev, u8 data, int size)
2351	2675	{
2352	2676	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2353		- struct m560_private_data *mydata = hidpp->private_data;
2354	2677
2355	2678	/* sanity check */
2356		- if (!mydata \|\| !mydata->input) {
	2679	+ if (!hidpp->input) {
2357	2680	hid_err(hdev, "error in parameter\n");
2358	2681	return -EINVAL;
2359	2682	}
..	..	@@ -2380,24 +2703,24 @@
2380	2703
2381	2704	switch (data[5]) {
2382	2705	case 0xaf:
2383		- input_report_key(mydata->input, BTN_MIDDLE, 1);
	2706	+ input_report_key(hidpp->input, BTN_MIDDLE, 1);
2384	2707	break;
2385	2708	case 0xb0:
2386		- input_report_key(mydata->input, BTN_FORWARD, 1);
	2709	+ input_report_key(hidpp->input, BTN_FORWARD, 1);
2387	2710	break;
2388	2711	case 0xae:
2389		- input_report_key(mydata->input, BTN_BACK, 1);
	2712	+ input_report_key(hidpp->input, BTN_BACK, 1);
2390	2713	break;
2391	2714	case 0x00:
2392		- input_report_key(mydata->input, BTN_BACK, 0);
2393		- input_report_key(mydata->input, BTN_FORWARD, 0);
2394		- input_report_key(mydata->input, BTN_MIDDLE, 0);
	2715	+ input_report_key(hidpp->input, BTN_BACK, 0);
	2716	+ input_report_key(hidpp->input, BTN_FORWARD, 0);
	2717	+ input_report_key(hidpp->input, BTN_MIDDLE, 0);
2395	2718	break;
2396	2719	default:
2397	2720	hid_err(hdev, "error in report\n");
2398	2721	return 0;
2399	2722	}
2400		- input_sync(mydata->input);
	2723	+ input_sync(hidpp->input);
2401	2724
2402	2725	} else if (data[0] == 0x02) {
2403	2726	/*
..	..	@@ -2411,50 +2734,55 @@
2411	2734
2412	2735	int v;
2413	2736
2414		- input_report_key(mydata->input, BTN_LEFT,
	2737	+ input_report_key(hidpp->input, BTN_LEFT,
2415	2738	!!(data[1] & M560_MOUSE_BTN_LEFT));
2416		- input_report_key(mydata->input, BTN_RIGHT,
	2739	+ input_report_key(hidpp->input, BTN_RIGHT,
2417	2740	!!(data[1] & M560_MOUSE_BTN_RIGHT));
2418	2741
2419		- if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT)
2420		- input_report_rel(mydata->input, REL_HWHEEL, -1);
2421		- else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT)
2422		- input_report_rel(mydata->input, REL_HWHEEL, 1);
	2742	+ if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
	2743	+ input_report_rel(hidpp->input, REL_HWHEEL, -1);
	2744	+ input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
	2745	+ -120);
	2746	+ } else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
	2747	+ input_report_rel(hidpp->input, REL_HWHEEL, 1);
	2748	+ input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
	2749	+ 120);
	2750	+ }
2423	2751
2424	2752	v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
2425		- input_report_rel(mydata->input, REL_X, v);
	2753	+ input_report_rel(hidpp->input, REL_X, v);
2426	2754
2427	2755	v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
2428		- input_report_rel(mydata->input, REL_Y, v);
	2756	+ input_report_rel(hidpp->input, REL_Y, v);
2429	2757
2430	2758	v = hid_snto32(data[6], 8);
2431		- input_report_rel(mydata->input, REL_WHEEL, v);
	2759	+ if (v != 0)
	2760	+ hidpp_scroll_counter_handle_scroll(hidpp->input,
	2761	+ &hidpp->vertical_wheel_counter, v);
2432	2762
2433		- input_sync(mydata->input);
	2763	+ input_sync(hidpp->input);
2434	2764	}
2435	2765
2436	2766	return 1;
2437	2767	}
2438	2768
2439	2769	static void m560_populate_input(struct hidpp_device *hidpp,
2440		- struct input_dev *input_dev, bool origin_is_hid_core)
	2770	+ struct input_dev *input_dev)
2441	2771	{
2442		- struct m560_private_data *mydata = hidpp->private_data;
	2772	+ __set_bit(EV_KEY, input_dev->evbit);
	2773	+ __set_bit(BTN_MIDDLE, input_dev->keybit);
	2774	+ __set_bit(BTN_RIGHT, input_dev->keybit);
	2775	+ __set_bit(BTN_LEFT, input_dev->keybit);
	2776	+ __set_bit(BTN_BACK, input_dev->keybit);
	2777	+ __set_bit(BTN_FORWARD, input_dev->keybit);
2443	2778
2444		- mydata->input = input_dev;
2445		-
2446		- __set_bit(EV_KEY, mydata->input->evbit);
2447		- __set_bit(BTN_MIDDLE, mydata->input->keybit);
2448		- __set_bit(BTN_RIGHT, mydata->input->keybit);
2449		- __set_bit(BTN_LEFT, mydata->input->keybit);
2450		- __set_bit(BTN_BACK, mydata->input->keybit);
2451		- __set_bit(BTN_FORWARD, mydata->input->keybit);
2452		-
2453		- __set_bit(EV_REL, mydata->input->evbit);
2454		- __set_bit(REL_X, mydata->input->relbit);
2455		- __set_bit(REL_Y, mydata->input->relbit);
2456		- __set_bit(REL_WHEEL, mydata->input->relbit);
2457		- __set_bit(REL_HWHEEL, mydata->input->relbit);
	2779	+ __set_bit(EV_REL, input_dev->evbit);
	2780	+ __set_bit(REL_X, input_dev->relbit);
	2781	+ __set_bit(REL_Y, input_dev->relbit);
	2782	+ __set_bit(REL_WHEEL, input_dev->relbit);
	2783	+ __set_bit(REL_HWHEEL, input_dev->relbit);
	2784	+ __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
	2785	+ __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
2458	2786	}
2459	2787
2460	2788	static int m560_input_mapping(struct hid_device hdev, struct hid_input hi,
..	..	@@ -2536,23 +2864,312 @@
2536	2864
2537	2865	#define HIDPP_PAGE_G920_FORCE_FEEDBACK 0x8123
2538	2866
2539		-static int g920_get_config(struct hidpp_device *hidpp)
	2867	+static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
	2868	+ struct hidpp_ff_private_data *data)
2540	2869	{
2541		- u8 feature_type;
2542		- u8 feature_index;
	2870	+ struct hidpp_report response;
	2871	+ u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH] = {
	2872	+ [1] = HIDPP_FF_EFFECT_SPRING \| HIDPP_FF_EFFECT_AUTOSTART,
	2873	+ };
2543	2874	int ret;
	2875	+
	2876	+ /* initialize with zero autocenter to get wheel in usable state */
	2877	+
	2878	+ dbg_hid("Setting autocenter to 0.\n");
	2879	+ ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
	2880	+ HIDPP_FF_DOWNLOAD_EFFECT,
	2881	+ params, ARRAY_SIZE(params),
	2882	+ &response);
	2883	+ if (ret)
	2884	+ hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
	2885	+ else
	2886	+ data->slot_autocenter = response.fap.params[0];
	2887	+
	2888	+ return ret;
	2889	+}
	2890	+
	2891	+static int g920_get_config(struct hidpp_device *hidpp,
	2892	+ struct hidpp_ff_private_data *data)
	2893	+{
	2894	+ struct hidpp_report response;
	2895	+ u8 feature_type;
	2896	+ int ret;
	2897	+
	2898	+ memset(data, 0, sizeof(*data));
2544	2899
2545	2900	/* Find feature and store for later use */
2546	2901	ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
2547		- &feature_index, &feature_type);
	2902	+ &data->feature_index, &feature_type);
2548	2903	if (ret)
2549	2904	return ret;
2550	2905
2551		- ret = hidpp_ff_init(hidpp, feature_index);
2552		- if (ret)
2553		- hid_warn(hidpp->hid_dev, "Unable to initialize force feedback support, errno %d\n",
2554		- ret);
	2906	+ /* Read number of slots available in device */
	2907	+ ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
	2908	+ HIDPP_FF_GET_INFO,
	2909	+ NULL, 0,
	2910	+ &response);
	2911	+ if (ret) {
	2912	+ if (ret < 0)
	2913	+ return ret;
	2914	+ hid_err(hidpp->hid_dev,
	2915	+ "%s: received protocol error 0x%02x\n", __func__, ret);
	2916	+ return -EPROTO;
	2917	+ }
2555	2918
	2919	+ data->num_effects = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
	2920	+
	2921	+ /* reset all forces */
	2922	+ ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
	2923	+ HIDPP_FF_RESET_ALL,
	2924	+ NULL, 0,
	2925	+ &response);
	2926	+ if (ret)
	2927	+ hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
	2928	+
	2929	+ ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
	2930	+ HIDPP_FF_GET_APERTURE,
	2931	+ NULL, 0,
	2932	+ &response);
	2933	+ if (ret) {
	2934	+ hid_warn(hidpp->hid_dev,
	2935	+ "Failed to read range from device!\n");
	2936	+ }
	2937	+ data->range = ret ?
	2938	+ 900 : get_unaligned_be16(&response.fap.params[0]);
	2939	+
	2940	+ /* Read the current gain values */
	2941	+ ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
	2942	+ HIDPP_FF_GET_GLOBAL_GAINS,
	2943	+ NULL, 0,
	2944	+ &response);
	2945	+ if (ret)
	2946	+ hid_warn(hidpp->hid_dev,
	2947	+ "Failed to read gain values from device!\n");
	2948	+ data->gain = ret ?
	2949	+ 0xffff : get_unaligned_be16(&response.fap.params[0]);
	2950	+
	2951	+ /* ignore boost value at response.fap.params[2] */
	2952	+
	2953	+ return g920_ff_set_autocenter(hidpp, data);
	2954	+}
	2955	+
	2956	+/* -------------------------------------------------------------------------- */
	2957	+/* Logitech Dinovo Mini keyboard with builtin touchpad */
	2958	+/* -------------------------------------------------------------------------- */
	2959	+#define DINOVO_MINI_PRODUCT_ID 0xb30c
	2960	+
	2961	+static int lg_dinovo_input_mapping(struct hid_device hdev, struct hid_input hi,
	2962	+ struct hid_field field, struct hid_usage usage,
	2963	+ unsigned long *bit, int max)
	2964	+{
	2965	+ if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
	2966	+ return 0;
	2967	+
	2968	+ switch (usage->hid & HID_USAGE) {
	2969	+ case 0x00d: lg_map_key_clear(KEY_MEDIA); break;
	2970	+ default:
	2971	+ return 0;
	2972	+ }
	2973	+ return 1;
	2974	+}
	2975	+
	2976	+/* -------------------------------------------------------------------------- */
	2977	+/* HID++1.0 devices which use HID++ reports for their wheels */
	2978	+/* -------------------------------------------------------------------------- */
	2979	+static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
	2980	+{
	2981	+ return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
	2982	+ HIDPP_ENABLE_WHEEL_REPORT \| HIDPP_ENABLE_HWHEEL_REPORT,
	2983	+ HIDPP_ENABLE_WHEEL_REPORT \| HIDPP_ENABLE_HWHEEL_REPORT);
	2984	+}
	2985	+
	2986	+static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
	2987	+ u8 *data, int size)
	2988	+{
	2989	+ s8 value, hvalue;
	2990	+
	2991	+ if (!hidpp->input)
	2992	+ return -EINVAL;
	2993	+
	2994	+ if (size < 7)
	2995	+ return 0;
	2996	+
	2997	+ if (data[0] != REPORT_ID_HIDPP_SHORT \|\| data[2] != HIDPP_SUB_ID_ROLLER)
	2998	+ return 0;
	2999	+
	3000	+ value = data[3];
	3001	+ hvalue = data[4];
	3002	+
	3003	+ input_report_rel(hidpp->input, REL_WHEEL, value);
	3004	+ input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
	3005	+ input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
	3006	+ input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
	3007	+ input_sync(hidpp->input);
	3008	+
	3009	+ return 1;
	3010	+}
	3011	+
	3012	+static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
	3013	+ struct input_dev *input_dev)
	3014	+{
	3015	+ __set_bit(EV_REL, input_dev->evbit);
	3016	+ __set_bit(REL_WHEEL, input_dev->relbit);
	3017	+ __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
	3018	+ __set_bit(REL_HWHEEL, input_dev->relbit);
	3019	+ __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
	3020	+}
	3021	+
	3022	+/* -------------------------------------------------------------------------- */
	3023	+/* HID++1.0 mice which use HID++ reports for extra mouse buttons */
	3024	+/* -------------------------------------------------------------------------- */
	3025	+static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
	3026	+{
	3027	+ return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
	3028	+ HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
	3029	+ HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
	3030	+}
	3031	+
	3032	+static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
	3033	+ u8 *data, int size)
	3034	+{
	3035	+ int i;
	3036	+
	3037	+ if (!hidpp->input)
	3038	+ return -EINVAL;
	3039	+
	3040	+ if (size < 7)
	3041	+ return 0;
	3042	+
	3043	+ if (data[0] != REPORT_ID_HIDPP_SHORT \|\|
	3044	+ data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
	3045	+ return 0;
	3046	+
	3047	+ /*
	3048	+ * Buttons are either delivered through the regular mouse report or
	3049	+ * through the extra buttons report. At least for button 6 how it is
	3050	+ * delivered differs per receiver firmware version. Even receivers with
	3051	+ * the same usb-id show different behavior, so we handle both cases.
	3052	+ */
	3053	+ for (i = 0; i < 8; i++)
	3054	+ input_report_key(hidpp->input, BTN_MOUSE + i,
	3055	+ (data[3] & (1 << i)));
	3056	+
	3057	+ /* Some mice report events on button 9+, use BTN_MISC */
	3058	+ for (i = 0; i < 8; i++)
	3059	+ input_report_key(hidpp->input, BTN_MISC + i,
	3060	+ (data[4] & (1 << i)));
	3061	+
	3062	+ input_sync(hidpp->input);
	3063	+ return 1;
	3064	+}
	3065	+
	3066	+static void hidpp10_extra_mouse_buttons_populate_input(
	3067	+ struct hidpp_device hidpp, struct input_dev input_dev)
	3068	+{
	3069	+ /* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
	3070	+ __set_bit(BTN_0, input_dev->keybit);
	3071	+ __set_bit(BTN_1, input_dev->keybit);
	3072	+ __set_bit(BTN_2, input_dev->keybit);
	3073	+ __set_bit(BTN_3, input_dev->keybit);
	3074	+ __set_bit(BTN_4, input_dev->keybit);
	3075	+ __set_bit(BTN_5, input_dev->keybit);
	3076	+ __set_bit(BTN_6, input_dev->keybit);
	3077	+ __set_bit(BTN_7, input_dev->keybit);
	3078	+}
	3079	+
	3080	+/* -------------------------------------------------------------------------- */
	3081	+/* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
	3082	+/* -------------------------------------------------------------------------- */
	3083	+
	3084	+/* Find the consumer-page input report desc and change Maximums to 0x107f */
	3085	+static u8 hidpp10_consumer_keys_report_fixup(struct hidpp_device hidpp,
	3086	+ u8 _rdesc, unsigned int rsize)
	3087	+{
	3088	+ /* Note 0 terminated so we can use strnstr to search for this. */
	3089	+ static const char consumer_rdesc_start[] = {
	3090	+ 0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
	3091	+ 0x09, 0x01, /* USAGE (Consumer Control) */
	3092	+ 0xA1, 0x01, /* COLLECTION (Application) */
	3093	+ 0x85, 0x03, /* REPORT_ID = 3 */
	3094	+ 0x75, 0x10, /* REPORT_SIZE (16) */
	3095	+ 0x95, 0x02, /* REPORT_COUNT (2) */
	3096	+ 0x15, 0x01, /* LOGICAL_MIN (1) */
	3097	+ 0x26, 0x00 /* LOGICAL_MAX (... */
	3098	+ };
	3099	+ char consumer_rdesc, rdesc = (char *)_rdesc;
	3100	+ unsigned int size;
	3101	+
	3102	+ consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
	3103	+ size = *rsize - (consumer_rdesc - rdesc);
	3104	+ if (consumer_rdesc && size >= 25) {
	3105	+ consumer_rdesc[15] = 0x7f;
	3106	+ consumer_rdesc[16] = 0x10;
	3107	+ consumer_rdesc[20] = 0x7f;
	3108	+ consumer_rdesc[21] = 0x10;
	3109	+ }
	3110	+ return _rdesc;
	3111	+}
	3112	+
	3113	+static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
	3114	+{
	3115	+ return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
	3116	+ HIDPP_ENABLE_CONSUMER_REPORT,
	3117	+ HIDPP_ENABLE_CONSUMER_REPORT);
	3118	+}
	3119	+
	3120	+static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
	3121	+ u8 *data, int size)
	3122	+{
	3123	+ u8 consumer_report[5];
	3124	+
	3125	+ if (size < 7)
	3126	+ return 0;
	3127	+
	3128	+ if (data[0] != REPORT_ID_HIDPP_SHORT \|\|
	3129	+ data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
	3130	+ return 0;
	3131	+
	3132	+ /*
	3133	+ * Build a normal consumer report (3) out of the data, this detour
	3134	+ * is necessary to get some keyboards to report their 0x10xx usages.
	3135	+ */
	3136	+ consumer_report[0] = 0x03;
	3137	+ memcpy(&consumer_report[1], &data[3], 4);
	3138	+ /* We are called from atomic context */
	3139	+ hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
	3140	+ consumer_report, 5, 1);
	3141	+
	3142	+ return 1;
	3143	+}
	3144	+
	3145	+/* -------------------------------------------------------------------------- */
	3146	+/* High-resolution scroll wheels */
	3147	+/* -------------------------------------------------------------------------- */
	3148	+
	3149	+static int hi_res_scroll_enable(struct hidpp_device *hidpp)
	3150	+{
	3151	+ int ret;
	3152	+ u8 multiplier = 1;
	3153	+
	3154	+ if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2121) {
	3155	+ ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
	3156	+ if (ret == 0)
	3157	+ ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
	3158	+ } else if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2120) {
	3159	+ ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
	3160	+ &multiplier);
	3161	+ } else /* if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) */ {
	3162	+ ret = hidpp10_enable_scrolling_acceleration(hidpp);
	3163	+ multiplier = 8;
	3164	+ }
	3165	+ if (ret)
	3166	+ return ret;
	3167	+
	3168	+ if (multiplier == 0)
	3169	+ multiplier = 1;
	3170	+
	3171	+ hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
	3172	+ hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
2556	3173	return 0;
2557	3174	}
2558	3175
..	..	@@ -2560,17 +3177,39 @@
2560	3177	/* Generic HID++ devices */
2561	3178	/* -------------------------------------------------------------------------- */
2562	3179
	3180	+static u8 hidpp_report_fixup(struct hid_device hdev, u8 *rdesc,
	3181	+ unsigned int *rsize)
	3182	+{
	3183	+ struct hidpp_device *hidpp = hid_get_drvdata(hdev);
	3184	+
	3185	+ if (!hidpp)
	3186	+ return rdesc;
	3187	+
	3188	+ /* For 27 MHz keyboards the quirk gets set after hid_parse. */
	3189	+ if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE \|\|
	3190	+ (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
	3191	+ rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
	3192	+
	3193	+ return rdesc;
	3194	+}
	3195	+
2563	3196	static int hidpp_input_mapping(struct hid_device hdev, struct hid_input hi,
2564	3197	struct hid_field field, struct hid_usage usage,
2565	3198	unsigned long *bit, int max)
2566	3199	{
2567	3200	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2568	3201
	3202	+ if (!hidpp)
	3203	+ return 0;
	3204	+
2569	3205	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
2570	3206	return wtp_input_mapping(hdev, hi, field, usage, bit, max);
2571	3207	else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
2572	3208	field->application != HID_GD_MOUSE)
2573	3209	return m560_input_mapping(hdev, hi, field, usage, bit, max);
	3210	+
	3211	+ if (hdev->product == DINOVO_MINI_PRODUCT_ID)
	3212	+ return lg_dinovo_input_mapping(hdev, hi, field, usage, bit, max);
2574	3213
2575	3214	return 0;
2576	3215	}
..	..	@@ -2580,6 +3219,9 @@
2580	3219	unsigned long *bit, int max)
2581	3220	{
2582	3221	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
	3222	+
	3223	+ if (!hidpp)
	3224	+ return 0;
2583	3225
2584	3226	/* Ensure that Logitech G920 is not given a default fuzz/flat value */
2585	3227	if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
..	..	@@ -2595,12 +3237,20 @@
2595	3237
2596	3238
2597	3239	static void hidpp_populate_input(struct hidpp_device *hidpp,
2598		- struct input_dev *input, bool origin_is_hid_core)
	3240	+ struct input_dev *input)
2599	3241	{
	3242	+ hidpp->input = input;
	3243	+
2600	3244	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
2601		- wtp_populate_input(hidpp, input, origin_is_hid_core);
	3245	+ wtp_populate_input(hidpp, input);
2602	3246	else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
2603		- m560_populate_input(hidpp, input, origin_is_hid_core);
	3247	+ m560_populate_input(hidpp, input);
	3248	+
	3249	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
	3250	+ hidpp10_wheel_populate_input(hidpp, input);
	3251	+
	3252	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
	3253	+ hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
2604	3254	}
2605	3255
2606	3256	static int hidpp_input_configured(struct hid_device *hdev,
..	..	@@ -2609,7 +3259,10 @@
2609	3259	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2610	3260	struct input_dev *input = hidinput->input;
2611	3261
2612		- hidpp_populate_input(hidpp, input, true);
	3262	+ if (!hidpp)
	3263	+ return 0;
	3264	+
	3265	+ hidpp_populate_input(hidpp, input);
2613	3266
2614	3267	return 0;
2615	3268	}
..	..	@@ -2646,7 +3299,7 @@
2646	3299	}
2647	3300	}
2648	3301
2649		- if (unlikely(hidpp_report_is_connect_event(report))) {
	3302	+ if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
2650	3303	atomic_set(&hidpp->connected,
2651	3304	!(report->rap.params[0] & (1 << 6)));
2652	3305	if (schedule_work(&hidpp->work) == 0)
..	..	@@ -2661,10 +3314,31 @@
2661	3314	ret = hidpp_solar_battery_event(hidpp, data, size);
2662	3315	if (ret != 0)
2663	3316	return ret;
	3317	+ ret = hidpp20_battery_voltage_event(hidpp, data, size);
	3318	+ if (ret != 0)
	3319	+ return ret;
2664	3320	}
2665	3321
2666	3322	if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
2667	3323	ret = hidpp10_battery_event(hidpp, data, size);
	3324	+ if (ret != 0)
	3325	+ return ret;
	3326	+ }
	3327	+
	3328	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
	3329	+ ret = hidpp10_wheel_raw_event(hidpp, data, size);
	3330	+ if (ret != 0)
	3331	+ return ret;
	3332	+ }
	3333	+
	3334	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
	3335	+ ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
	3336	+ if (ret != 0)
	3337	+ return ret;
	3338	+ }
	3339	+
	3340	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
	3341	+ ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
2668	3342	if (ret != 0)
2669	3343	return ret;
2670	3344	}
..	..	@@ -2678,10 +3352,13 @@
2678	3352	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2679	3353	int ret = 0;
2680	3354
	3355	+ if (!hidpp)
	3356	+ return 0;
	3357	+
2681	3358	/* Generic HID++ processing. */
2682	3359	switch (data[0]) {
2683	3360	case REPORT_ID_HIDPP_VERY_LONG:
2684		- if (size != HIDPP_REPORT_VERY_LONG_LENGTH) {
	3361	+ if (size != hidpp->very_long_report_length) {
2685	3362	hid_err(hdev, "received hid++ report of bad size (%d)",
2686	3363	size);
2687	3364	return 1;
..	..	@@ -2719,6 +3396,32 @@
2719	3396	return 0;
2720	3397	}
2721	3398
	3399	+static int hidpp_event(struct hid_device hdev, struct hid_field field,
	3400	+ struct hid_usage *usage, __s32 value)
	3401	+{
	3402	+ /* This function will only be called for scroll events, due to the
	3403	+ * restriction imposed in hidpp_usages.
	3404	+ */
	3405	+ struct hidpp_device *hidpp = hid_get_drvdata(hdev);
	3406	+ struct hidpp_scroll_counter *counter;
	3407	+
	3408	+ if (!hidpp)
	3409	+ return 0;
	3410	+
	3411	+ counter = &hidpp->vertical_wheel_counter;
	3412	+ /* A scroll event may occur before the multiplier has been retrieved or
	3413	+ * the input device set, or high-res scroll enabling may fail. In such
	3414	+ * cases we must return early (falling back to default behaviour) to
	3415	+ * avoid a crash in hidpp_scroll_counter_handle_scroll.
	3416	+ */
	3417	+ if (!(hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL) \|\| value == 0
	3418	+ \|\| hidpp->input == NULL \|\| counter->wheel_multiplier == 0)
	3419	+ return 0;
	3420	+
	3421	+ hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
	3422	+ return 1;
	3423	+}
	3424	+
2722	3425	static int hidpp_initialize_battery(struct hidpp_device *hidpp)
2723	3426	{
2724	3427	static atomic_t battery_no = ATOMIC_INIT(0);
..	..	@@ -2735,12 +3438,16 @@
2735	3438
2736	3439	hidpp->battery.feature_index = 0xff;
2737	3440	hidpp->battery.solar_feature_index = 0xff;
	3441	+ hidpp->battery.voltage_feature_index = 0xff;
2738	3442
2739	3443	if (hidpp->protocol_major >= 2) {
2740	3444	if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
2741	3445	ret = hidpp_solar_request_battery_event(hidpp);
2742		- else
2743		- ret = hidpp20_query_battery_info(hidpp);
	3446	+ else {
	3447	+ ret = hidpp20_query_battery_voltage_info(hidpp);
	3448	+ if (ret)
	3449	+ ret = hidpp20_query_battery_info(hidpp);
	3450	+ }
2744	3451
2745	3452	if (ret)
2746	3453	return ret;
..	..	@@ -2765,7 +3472,7 @@
2765	3472	if (!battery_props)
2766	3473	return -ENOMEM;
2767	3474
2768		- num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 2;
	3475	+ num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 3;
2769	3476
2770	3477	if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
2771	3478	battery_props[num_battery_props++] =
..	..	@@ -2774,6 +3481,10 @@
2774	3481	if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
2775	3482	battery_props[num_battery_props++] =
2776	3483	POWER_SUPPLY_PROP_CAPACITY_LEVEL;
	3484	+
	3485	+ if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
	3486	+ battery_props[num_battery_props++] =
	3487	+ POWER_SUPPLY_PROP_VOLTAGE_NOW;
2777	3488
2778	3489	battery = &hidpp->battery;
2779	3490
..	..	@@ -2887,32 +3598,45 @@
2887	3598	return;
2888	3599	}
2889	3600
	3601	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
	3602	+ ret = hidpp10_wheel_connect(hidpp);
	3603	+ if (ret)
	3604	+ return;
	3605	+ }
	3606	+
	3607	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
	3608	+ ret = hidpp10_extra_mouse_buttons_connect(hidpp);
	3609	+ if (ret)
	3610	+ return;
	3611	+ }
	3612	+
	3613	+ if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
	3614	+ ret = hidpp10_consumer_keys_connect(hidpp);
	3615	+ if (ret)
	3616	+ return;
	3617	+ }
	3618	+
2890	3619	/* the device is already connected, we can ask for its name and
2891	3620	* protocol */
2892	3621	if (!hidpp->protocol_major) {
2893		- ret = !hidpp_is_connected(hidpp);
	3622	+ ret = hidpp_root_get_protocol_version(hidpp);
2894	3623	if (ret) {
2895	3624	hid_err(hdev, "Can not get the protocol version.\n");
2896	3625	return;
2897	3626	}
2898		- hid_info(hdev, "HID++ %u.%u device connected.\n",
2899		- hidpp->protocol_major, hidpp->protocol_minor);
2900	3627	}
2901	3628
2902	3629	if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
2903	3630	name = hidpp_get_device_name(hidpp);
2904		- if (!name) {
2905		- hid_err(hdev,
2906		- "unable to retrieve the name of the device");
2907		- return;
	3631	+ if (name) {
	3632	+ devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
	3633	+ "%s", name);
	3634	+ kfree(name);
	3635	+ if (!devm_name)
	3636	+ return;
	3637	+
	3638	+ hidpp->name = devm_name;
2908	3639	}
2909		-
2910		- devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name);
2911		- kfree(name);
2912		- if (!devm_name)
2913		- return;
2914		-
2915		- hidpp->name = devm_name;
2916	3640	}
2917	3641
2918	3642	hidpp_initialize_battery(hidpp);
..	..	@@ -2925,10 +3649,16 @@
2925	3649	else
2926	3650	hidpp10_query_battery_status(hidpp);
2927	3651	} else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
2928		- hidpp20_query_battery_info(hidpp);
	3652	+ if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
	3653	+ hidpp20_query_battery_voltage_info(hidpp);
	3654	+ else
	3655	+ hidpp20_query_battery_info(hidpp);
2929	3656	}
2930	3657	if (hidpp->battery.ps)
2931	3658	power_supply_changed(hidpp->battery.ps);
	3659	+
	3660	+ if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL)
	3661	+ hi_res_scroll_enable(hidpp);
2932	3662
2933	3663	if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT) \|\| hidpp->delayed_input)
2934	3664	/* if the input nodes are already created, we can stop now */
..	..	@@ -2940,7 +3670,7 @@
2940	3670	return;
2941	3671	}
2942	3672
2943		- hidpp_populate_input(hidpp, input, false);
	3673	+ hidpp_populate_input(hidpp, input);
2944	3674
2945	3675	ret = input_register_device(input);
2946	3676	if (ret)
..	..	@@ -2960,26 +3690,118 @@
2960	3690	.attrs = sysfs_attrs
2961	3691	};
2962	3692
	3693	+static int hidpp_get_report_length(struct hid_device *hdev, int id)
	3694	+{
	3695	+ struct hid_report_enum *re;
	3696	+ struct hid_report *report;
	3697	+
	3698	+ re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
	3699	+ report = re->report_id_hash[id];
	3700	+ if (!report)
	3701	+ return 0;
	3702	+
	3703	+ return report->field[0]->report_count + 1;
	3704	+}
	3705	+
	3706	+static u8 hidpp_validate_device(struct hid_device *hdev)
	3707	+{
	3708	+ struct hidpp_device *hidpp = hid_get_drvdata(hdev);
	3709	+ int id, report_length;
	3710	+ u8 supported_reports = 0;
	3711	+
	3712	+ id = REPORT_ID_HIDPP_SHORT;
	3713	+ report_length = hidpp_get_report_length(hdev, id);
	3714	+ if (report_length) {
	3715	+ if (report_length < HIDPP_REPORT_SHORT_LENGTH)
	3716	+ goto bad_device;
	3717	+
	3718	+ supported_reports \|= HIDPP_REPORT_SHORT_SUPPORTED;
	3719	+ }
	3720	+
	3721	+ id = REPORT_ID_HIDPP_LONG;
	3722	+ report_length = hidpp_get_report_length(hdev, id);
	3723	+ if (report_length) {
	3724	+ if (report_length < HIDPP_REPORT_LONG_LENGTH)
	3725	+ goto bad_device;
	3726	+
	3727	+ supported_reports \|= HIDPP_REPORT_LONG_SUPPORTED;
	3728	+ }
	3729	+
	3730	+ id = REPORT_ID_HIDPP_VERY_LONG;
	3731	+ report_length = hidpp_get_report_length(hdev, id);
	3732	+ if (report_length) {
	3733	+ if (report_length < HIDPP_REPORT_LONG_LENGTH \|\|
	3734	+ report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
	3735	+ goto bad_device;
	3736	+
	3737	+ supported_reports \|= HIDPP_REPORT_VERY_LONG_SUPPORTED;
	3738	+ hidpp->very_long_report_length = report_length;
	3739	+ }
	3740	+
	3741	+ return supported_reports;
	3742	+
	3743	+bad_device:
	3744	+ hid_warn(hdev, "not enough values in hidpp report %d\n", id);
	3745	+ return false;
	3746	+}
	3747	+
	3748	+static bool hidpp_application_equals(struct hid_device *hdev,
	3749	+ unsigned int application)
	3750	+{
	3751	+ struct list_head *report_list;
	3752	+ struct hid_report *report;
	3753	+
	3754	+ report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
	3755	+ report = list_first_entry_or_null(report_list, struct hid_report, list);
	3756	+ return report && report->application == application;
	3757	+}
	3758	+
2963	3759	static int hidpp_probe(struct hid_device hdev, const struct hid_device_id id)
2964	3760	{
2965	3761	struct hidpp_device *hidpp;
2966	3762	int ret;
2967	3763	bool connected;
2968	3764	unsigned int connect_mask = HID_CONNECT_DEFAULT;
	3765	+ struct hidpp_ff_private_data data;
2969	3766
2970		- hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device),
2971		- GFP_KERNEL);
	3767	+ /* report_fixup needs drvdata to be set before we call hid_parse */
	3768	+ hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
2972	3769	if (!hidpp)
2973	3770	return -ENOMEM;
2974	3771
2975	3772	hidpp->hid_dev = hdev;
2976	3773	hidpp->name = hdev->name;
	3774	+ hidpp->quirks = id->driver_data;
2977	3775	hid_set_drvdata(hdev, hidpp);
2978	3776
2979		- hidpp->quirks = id->driver_data;
	3777	+ ret = hid_parse(hdev);
	3778	+ if (ret) {
	3779	+ hid_err(hdev, "%s:parse failed\n", __func__);
	3780	+ return ret;
	3781	+ }
	3782	+
	3783	+ /*
	3784	+ * Make sure the device is HID++ capable, otherwise treat as generic HID
	3785	+ */
	3786	+ hidpp->supported_reports = hidpp_validate_device(hdev);
	3787	+
	3788	+ if (!hidpp->supported_reports) {
	3789	+ hid_set_drvdata(hdev, NULL);
	3790	+ devm_kfree(&hdev->dev, hidpp);
	3791	+ return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	3792	+ }
2980	3793
2981	3794	if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
2982	3795	hidpp->quirks \|= HIDPP_QUIRK_UNIFYING;
	3796	+
	3797	+ if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
	3798	+ hidpp_application_equals(hdev, HID_GD_MOUSE))
	3799	+ hidpp->quirks \|= HIDPP_QUIRK_HIDPP_WHEELS \|
	3800	+ HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
	3801	+
	3802	+ if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
	3803	+ hidpp_application_equals(hdev, HID_GD_KEYBOARD))
	3804	+ hidpp->quirks \|= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
2983	3805
2984	3806	if (disable_raw_mode) {
2985	3807	hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
..	..	@@ -2989,15 +3811,11 @@
2989	3811	if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
2990	3812	ret = wtp_allocate(hdev, id);
2991	3813	if (ret)
2992		- goto allocate_fail;
2993		- } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
2994		- ret = m560_allocate(hdev);
2995		- if (ret)
2996		- goto allocate_fail;
	3814	+ return ret;
2997	3815	} else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
2998	3816	ret = k400_allocate(hdev);
2999	3817	if (ret)
3000		- goto allocate_fail;
	3818	+ return ret;
3001	3819	}
3002	3820
3003	3821	INIT_WORK(&hidpp->work, delayed_work_cb);
..	..	@@ -3010,30 +3828,22 @@
3010	3828	hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
3011	3829	hdev->name);
3012	3830
3013		- ret = hid_parse(hdev);
	3831	+ /*
	3832	+ * Plain USB connections need to actually call start and open
	3833	+ * on the transport driver to allow incoming data.
	3834	+ */
	3835	+ ret = hid_hw_start(hdev, 0);
3014	3836	if (ret) {
3015		- hid_err(hdev, "%s:parse failed\n", __func__);
3016		- goto hid_parse_fail;
	3837	+ hid_err(hdev, "hw start failed\n");
	3838	+ goto hid_hw_start_fail;
3017	3839	}
3018	3840
3019		- if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
3020		- connect_mask &= ~HID_CONNECT_HIDINPUT;
3021		-
3022		- if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3023		- ret = hid_hw_start(hdev, connect_mask);
3024		- if (ret) {
3025		- hid_err(hdev, "hw start failed\n");
3026		- goto hid_hw_start_fail;
3027		- }
3028		- ret = hid_hw_open(hdev);
3029		- if (ret < 0) {
3030		- dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
3031		- __func__, ret);
3032		- hid_hw_stop(hdev);
3033		- goto hid_hw_start_fail;
3034		- }
	3841	+ ret = hid_hw_open(hdev);
	3842	+ if (ret < 0) {
	3843	+ dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
	3844	+ __func__, ret);
	3845	+ goto hid_hw_open_fail;
3035	3846	}
3036		-
3037	3847
3038	3848	/* Allow incoming packets */
3039	3849	hid_device_io_start(hdev);
..	..	@@ -3041,62 +3851,71 @@
3041	3851	if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
3042	3852	hidpp_unifying_init(hidpp);
3043	3853
3044		- connected = hidpp_is_connected(hidpp);
	3854	+ connected = hidpp_root_get_protocol_version(hidpp) == 0;
3045	3855	atomic_set(&hidpp->connected, connected);
3046	3856	if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
3047	3857	if (!connected) {
3048	3858	ret = -ENODEV;
3049	3859	hid_err(hdev, "Device not connected");
3050		- goto hid_hw_open_failed;
	3860	+ goto hid_hw_init_fail;
3051	3861	}
3052	3862
3053		- hid_info(hdev, "HID++ %u.%u device connected.\n",
3054		- hidpp->protocol_major, hidpp->protocol_minor);
3055		-
3056	3863	hidpp_overwrite_name(hdev);
	3864	+ }
	3865	+
	3866	+ if (connected && hidpp->protocol_major >= 2) {
	3867	+ ret = hidpp_set_wireless_feature_index(hidpp);
	3868	+ if (ret == -ENOENT)
	3869	+ hidpp->wireless_feature_index = 0;
	3870	+ else if (ret)
	3871	+ goto hid_hw_init_fail;
3057	3872	}
3058	3873
3059	3874	if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
3060	3875	ret = wtp_get_config(hidpp);
3061	3876	if (ret)
3062		- goto hid_hw_open_failed;
	3877	+ goto hid_hw_init_fail;
3063	3878	} else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3064		- ret = g920_get_config(hidpp);
	3879	+ ret = g920_get_config(hidpp, &data);
3065	3880	if (ret)
3066		- goto hid_hw_open_failed;
	3881	+ goto hid_hw_init_fail;
3067	3882	}
3068		-
3069		- /* Block incoming packets */
3070		- hid_device_io_stop(hdev);
3071		-
3072		- if (!(hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3073		- ret = hid_hw_start(hdev, connect_mask);
3074		- if (ret) {
3075		- hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
3076		- goto hid_hw_start_fail;
3077		- }
3078		- }
3079		-
3080		- /* Allow incoming packets */
3081		- hid_device_io_start(hdev);
3082	3883
3083	3884	hidpp_connect_event(hidpp);
3084	3885
	3886	+ /* Reset the HID node state */
	3887	+ hid_device_io_stop(hdev);
	3888	+ hid_hw_close(hdev);
	3889	+ hid_hw_stop(hdev);
	3890	+
	3891	+ if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
	3892	+ connect_mask &= ~HID_CONNECT_HIDINPUT;
	3893	+
	3894	+ /* Now export the actual inputs and hidraw nodes to the world */
	3895	+ ret = hid_hw_start(hdev, connect_mask);
	3896	+ if (ret) {
	3897	+ hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
	3898	+ goto hid_hw_start_fail;
	3899	+ }
	3900	+
	3901	+ if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
	3902	+ ret = hidpp_ff_init(hidpp, &data);
	3903	+ if (ret)
	3904	+ hid_warn(hidpp->hid_dev,
	3905	+ "Unable to initialize force feedback support, errno %d\n",
	3906	+ ret);
	3907	+ }
	3908	+
3085	3909	return ret;
3086	3910
3087		-hid_hw_open_failed:
3088		- hid_device_io_stop(hdev);
3089		- if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3090		- hid_hw_close(hdev);
3091		- hid_hw_stop(hdev);
3092		- }
	3911	+hid_hw_init_fail:
	3912	+ hid_hw_close(hdev);
	3913	+hid_hw_open_fail:
	3914	+ hid_hw_stop(hdev);
3093	3915	hid_hw_start_fail:
3094		-hid_parse_fail:
3095	3916	sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3096	3917	cancel_work_sync(&hidpp->work);
3097	3918	mutex_destroy(&hidpp->send_mutex);
3098		-allocate_fail:
3099		- hid_set_drvdata(hdev, NULL);
3100	3919	return ret;
3101	3920	}
3102	3921
..	..	@@ -3104,60 +3923,161 @@
3104	3923	{
3105	3924	struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3106	3925
	3926	+ if (!hidpp)
	3927	+ return hid_hw_stop(hdev);
	3928	+
3107	3929	sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3108	3930
3109		- if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3110		- hidpp_ff_deinit(hdev);
3111		- hid_hw_close(hdev);
3112		- }
3113	3931	hid_hw_stop(hdev);
3114	3932	cancel_work_sync(&hidpp->work);
3115	3933	mutex_destroy(&hidpp->send_mutex);
3116	3934	}
3117	3935
	3936	+#define LDJ_DEVICE(product) \
	3937	+ HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
	3938	+ USB_VENDOR_ID_LOGITECH, (product))
	3939	+
	3940	+#define L27MHZ_DEVICE(product) \
	3941	+ HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
	3942	+ USB_VENDOR_ID_LOGITECH, (product))
	3943	+
3118	3944	static const struct hid_device_id hidpp_devices[] = {
3119	3945	{ /* wireless touchpad */
3120		- HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3121		- USB_VENDOR_ID_LOGITECH, 0x4011),
	3946	+ LDJ_DEVICE(0x4011),
3122	3947	.driver_data = HIDPP_QUIRK_CLASS_WTP \| HIDPP_QUIRK_DELAYED_INIT \|
3123	3948	HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
3124	3949	{ /* wireless touchpad T650 */
3125		- HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3126		- USB_VENDOR_ID_LOGITECH, 0x4101),
	3950	+ LDJ_DEVICE(0x4101),
3127	3951	.driver_data = HIDPP_QUIRK_CLASS_WTP \| HIDPP_QUIRK_DELAYED_INIT },
3128	3952	{ /* wireless touchpad T651 */
3129	3953	HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
3130	3954	USB_DEVICE_ID_LOGITECH_T651),
3131	3955	.driver_data = HIDPP_QUIRK_CLASS_WTP },
	3956	+ { /* Mouse Logitech Anywhere MX */
	3957	+ LDJ_DEVICE(0x1017), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
	3958	+ { /* Mouse Logitech Cube */
	3959	+ LDJ_DEVICE(0x4010), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
	3960	+ { /* Mouse Logitech M335 */
	3961	+ LDJ_DEVICE(0x4050), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3962	+ { /* Mouse Logitech M515 */
	3963	+ LDJ_DEVICE(0x4007), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
3132	3964	{ /* Mouse logitech M560 */
3133		- HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3134		- USB_VENDOR_ID_LOGITECH, 0x402d),
3135		- .driver_data = HIDPP_QUIRK_DELAYED_INIT \| HIDPP_QUIRK_CLASS_M560 },
	3965	+ LDJ_DEVICE(0x402d),
	3966	+ .driver_data = HIDPP_QUIRK_DELAYED_INIT \| HIDPP_QUIRK_CLASS_M560
	3967	+ \| HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
	3968	+ { /* Mouse Logitech M705 (firmware RQM17) */
	3969	+ LDJ_DEVICE(0x101b), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
	3970	+ { /* Mouse Logitech M705 (firmware RQM67) */
	3971	+ LDJ_DEVICE(0x406d), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3972	+ { /* Mouse Logitech M720 */
	3973	+ LDJ_DEVICE(0x405e), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3974	+ { /* Mouse Logitech MX Anywhere 2 */
	3975	+ LDJ_DEVICE(0x404a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3976	+ { LDJ_DEVICE(0x4072), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3977	+ { LDJ_DEVICE(0xb013), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3978	+ { LDJ_DEVICE(0xb018), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3979	+ { LDJ_DEVICE(0xb01f), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3980	+ { /* Mouse Logitech MX Anywhere 2S */
	3981	+ LDJ_DEVICE(0x406a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3982	+ { /* Mouse Logitech MX Master */
	3983	+ LDJ_DEVICE(0x4041), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3984	+ { LDJ_DEVICE(0x4060), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3985	+ { LDJ_DEVICE(0x4071), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3986	+ { /* Mouse Logitech MX Master 2S */
	3987	+ LDJ_DEVICE(0x4069), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3988	+ { /* Mouse Logitech MX Master 3 */
	3989	+ LDJ_DEVICE(0x4082), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	3990	+ { /* Mouse Logitech Performance MX */
	3991	+ LDJ_DEVICE(0x101a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
3136	3992	{ /* Keyboard logitech K400 */
3137		- HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3138		- USB_VENDOR_ID_LOGITECH, 0x4024),
	3993	+ LDJ_DEVICE(0x4024),
3139	3994	.driver_data = HIDPP_QUIRK_CLASS_K400 },
3140	3995	{ /* Solar Keyboard Logitech K750 */
3141		- HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3142		- USB_VENDOR_ID_LOGITECH, 0x4002),
	3996	+ LDJ_DEVICE(0x4002),
3143	3997	.driver_data = HIDPP_QUIRK_CLASS_K750 },
	3998	+ { /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
	3999	+ LDJ_DEVICE(0xb305),
	4000	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
	4001	+ { /* Dinovo Edge (Bluetooth-receiver in HID proxy mode) */
	4002	+ LDJ_DEVICE(0xb309),
	4003	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
	4004	+ { /* Keyboard MX5500 (Bluetooth-receiver in HID proxy mode) */
	4005	+ LDJ_DEVICE(0xb30b),
	4006	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
3144	4007
3145		- { HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
3146		- USB_VENDOR_ID_LOGITECH, HID_ANY_ID)},
	4008	+ { LDJ_DEVICE(HID_ANY_ID) },
3147	4009
3148		- { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
	4010	+ { /* Keyboard LX501 (Y-RR53) */
	4011	+ L27MHZ_DEVICE(0x0049),
	4012	+ .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
	4013	+ { /* Keyboard MX3000 (Y-RAM74) */
	4014	+ L27MHZ_DEVICE(0x0057),
	4015	+ .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
	4016	+ { /* Keyboard MX3200 (Y-RAV80) */
	4017	+ L27MHZ_DEVICE(0x005c),
	4018	+ .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
	4019	+ { /* S510 Media Remote */
	4020	+ L27MHZ_DEVICE(0x00fe),
	4021	+ .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
	4022	+
	4023	+ { L27MHZ_DEVICE(HID_ANY_ID) },
	4024	+
	4025	+ { /* Logitech G403 Wireless Gaming Mouse over USB */
	4026	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
	4027	+ { /* Logitech G703 Gaming Mouse over USB */
	4028	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC087) },
	4029	+ { /* Logitech G703 Hero Gaming Mouse over USB */
	4030	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC090) },
	4031	+ { /* Logitech G900 Gaming Mouse over USB */
	4032	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
	4033	+ { /* Logitech G903 Gaming Mouse over USB */
	4034	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC086) },
	4035	+ { /* Logitech G903 Hero Gaming Mouse over USB */
	4036	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC091) },
	4037	+ { /* Logitech G920 Wheel over USB */
	4038	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
3149	4039	.driver_data = HIDPP_QUIRK_CLASS_G920 \| HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
	4040	+ { /* Logitech G Pro Gaming Mouse over USB */
	4041	+ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC088) },
	4042	+
	4043	+ { /* MX5000 keyboard over Bluetooth */
	4044	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
	4045	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
	4046	+ { /* Dinovo Edge keyboard over Bluetooth */
	4047	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb309),
	4048	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
	4049	+ { /* MX5500 keyboard over Bluetooth */
	4050	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
	4051	+ .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
	4052	+ { /* MX Master mouse over Bluetooth */
	4053	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012),
	4054	+ .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	4055	+ { /* MX Ergo trackball over Bluetooth */
	4056	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
	4057	+ { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e),
	4058	+ .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
	4059	+ { /* MX Master 3 mouse over Bluetooth */
	4060	+ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023),
	4061	+ .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3150	4062	{}
3151	4063	};
3152	4064
3153	4065	MODULE_DEVICE_TABLE(hid, hidpp_devices);
3154	4066
	4067	+static const struct hid_usage_id hidpp_usages[] = {
	4068	+ { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
	4069	+ { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
	4070	+};
	4071	+
3155	4072	static struct hid_driver hidpp_driver = {
3156	4073	.name = "logitech-hidpp-device",
3157	4074	.id_table = hidpp_devices,
	4075	+ .report_fixup = hidpp_report_fixup,
3158	4076	.probe = hidpp_probe,
3159	4077	.remove = hidpp_remove,
3160	4078	.raw_event = hidpp_raw_event,
	4079	+ .usage_table = hidpp_usages,
	4080	+ .event = hidpp_event,
3161	4081	.input_configured = hidpp_input_configured,
3162	4082	.input_mapping = hidpp_input_mapping,
3163	4083	.input_mapped = hidpp_input_mapped,