1 // SPDX-License-Identifier: GPL-2.0-only
3 * HIDPP protocol for Logitech receivers
5 * Copyright (c) 2011 Logitech (c)
6 * Copyright (c) 2012-2013 Google (c)
7 * Copyright (c) 2013-2014 Red Hat Inc.
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/device.h>
14 #include <linux/input.h>
15 #include <linux/usb.h>
16 #include <linux/hid.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/sched.h>
20 #include <linux/sched/clock.h>
21 #include <linux/kfifo.h>
22 #include <linux/input/mt.h>
23 #include <linux/workqueue.h>
24 #include <linux/atomic.h>
25 #include <linux/fixp-arith.h>
26 #include <asm/unaligned.h>
27 #include "usbhid/usbhid.h"
30 MODULE_LICENSE("GPL");
31 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
32 MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
33 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
35 static bool disable_tap_to_click;
36 module_param(disable_tap_to_click, bool, 0644);
37 MODULE_PARM_DESC(disable_tap_to_click,
38 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
40 /* Define a non-zero software ID to identify our own requests */
41 #define LINUX_KERNEL_SW_ID 0x01
43 #define REPORT_ID_HIDPP_SHORT 0x10
44 #define REPORT_ID_HIDPP_LONG 0x11
45 #define REPORT_ID_HIDPP_VERY_LONG 0x12
47 #define HIDPP_REPORT_SHORT_LENGTH 7
48 #define HIDPP_REPORT_LONG_LENGTH 20
49 #define HIDPP_REPORT_VERY_LONG_MAX_LENGTH 64
51 #define HIDPP_REPORT_SHORT_SUPPORTED BIT(0)
52 #define HIDPP_REPORT_LONG_SUPPORTED BIT(1)
53 #define HIDPP_REPORT_VERY_LONG_SUPPORTED BIT(2)
55 #define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS 0x03
56 #define HIDPP_SUB_ID_ROLLER 0x05
57 #define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS 0x06
58 #define HIDPP_SUB_ID_USER_IFACE_EVENT 0x08
59 #define HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST BIT(5)
61 #define HIDPP_QUIRK_CLASS_WTP BIT(0)
62 #define HIDPP_QUIRK_CLASS_M560 BIT(1)
63 #define HIDPP_QUIRK_CLASS_K400 BIT(2)
64 #define HIDPP_QUIRK_CLASS_G920 BIT(3)
65 #define HIDPP_QUIRK_CLASS_K750 BIT(4)
67 /* bits 2..20 are reserved for classes */
68 /* #define HIDPP_QUIRK_CONNECT_EVENTS BIT(21) disabled */
69 #define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22)
70 #define HIDPP_QUIRK_DELAYED_INIT BIT(23)
71 #define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS BIT(24)
72 #define HIDPP_QUIRK_UNIFYING BIT(25)
73 #define HIDPP_QUIRK_HIDPP_WHEELS BIT(26)
74 #define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS BIT(27)
75 #define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS BIT(28)
76 #define HIDPP_QUIRK_HI_RES_SCROLL_1P0 BIT(29)
77 #define HIDPP_QUIRK_WIRELESS_STATUS BIT(30)
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
83 /* Convenience constant to check for any high-res support. */
84 #define HIDPP_CAPABILITY_HI_RES_SCROLL (HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL | \
85 HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL | \
86 HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL)
88 #define HIDPP_CAPABILITY_HIDPP10_BATTERY BIT(0)
89 #define HIDPP_CAPABILITY_HIDPP20_BATTERY BIT(1)
90 #define HIDPP_CAPABILITY_BATTERY_MILEAGE BIT(2)
91 #define HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS BIT(3)
92 #define HIDPP_CAPABILITY_BATTERY_VOLTAGE BIT(4)
93 #define HIDPP_CAPABILITY_BATTERY_PERCENTAGE BIT(5)
94 #define HIDPP_CAPABILITY_UNIFIED_BATTERY BIT(6)
95 #define HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL BIT(7)
96 #define HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL BIT(8)
97 #define HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL BIT(9)
98 #define HIDPP_CAPABILITY_ADC_MEASUREMENT BIT(10)
100 #define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
103 * There are two hidpp protocols in use, the first version hidpp10 is known
104 * as register access protocol or RAP, the second version hidpp20 is known as
105 * feature access protocol or FAP
107 * Most older devices (including the Unifying usb receiver) use the RAP protocol
108 * where as most newer devices use the FAP protocol. Both protocols are
109 * compatible with the underlying transport, which could be usb, Unifiying, or
110 * bluetooth. The message lengths are defined by the hid vendor specific report
111 * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and
112 * the HIDPP_LONG report type (total message length 20 bytes)
114 * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG
115 * messages. The Unifying receiver itself responds to RAP messages (device index
116 * is 0xFF for the receiver), and all messages (short or long) with a device
117 * index between 1 and 6 are passed untouched to the corresponding paired
120 * The paired device can be RAP or FAP, it will receive the message untouched
121 * from the Unifiying receiver.
126 u8 funcindex_clientid;
127 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
133 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
136 struct hidpp_report {
142 u8 rawbytes[sizeof(struct fap)];
146 struct hidpp_battery {
148 u8 solar_feature_index;
149 u8 voltage_feature_index;
150 u8 adc_measurement_feature_index;
151 struct power_supply_desc desc;
152 struct power_supply *ps;
160 u8 supported_levels_1004;
164 * struct hidpp_scroll_counter - Utility class for processing high-resolution
166 * @dev: the input device for which events should be reported.
167 * @wheel_multiplier: the scalar multiplier to be applied to each wheel event
168 * @remainder: counts the number of high-resolution units moved since the last
169 * low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
170 * only be used by class methods.
171 * @direction: direction of last movement (1 or -1)
172 * @last_time: last event time, used to reset remainder after inactivity
174 struct hidpp_scroll_counter {
175 int wheel_multiplier;
178 unsigned long long last_time;
181 struct hidpp_device {
182 struct hid_device *hid_dev;
183 struct input_dev *input;
184 struct mutex send_mutex;
185 void *send_receive_buf;
186 char *name; /* will never be NULL and should not be freed */
187 wait_queue_head_t wait;
188 int very_long_report_length;
189 bool answer_available;
195 struct work_struct work;
196 struct kfifo delayed_work_fifo;
198 struct input_dev *delayed_input;
200 unsigned long quirks;
201 unsigned long capabilities;
202 u8 supported_reports;
204 struct hidpp_battery battery;
205 struct hidpp_scroll_counter vertical_wheel_counter;
207 u8 wireless_feature_index;
210 /* HID++ 1.0 error codes */
211 #define HIDPP_ERROR 0x8f
212 #define HIDPP_ERROR_SUCCESS 0x00
213 #define HIDPP_ERROR_INVALID_SUBID 0x01
214 #define HIDPP_ERROR_INVALID_ADRESS 0x02
215 #define HIDPP_ERROR_INVALID_VALUE 0x03
216 #define HIDPP_ERROR_CONNECT_FAIL 0x04
217 #define HIDPP_ERROR_TOO_MANY_DEVICES 0x05
218 #define HIDPP_ERROR_ALREADY_EXISTS 0x06
219 #define HIDPP_ERROR_BUSY 0x07
220 #define HIDPP_ERROR_UNKNOWN_DEVICE 0x08
221 #define HIDPP_ERROR_RESOURCE_ERROR 0x09
222 #define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a
223 #define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b
224 #define HIDPP_ERROR_WRONG_PIN_CODE 0x0c
225 /* HID++ 2.0 error codes */
226 #define HIDPP20_ERROR_NO_ERROR 0x00
227 #define HIDPP20_ERROR_UNKNOWN 0x01
228 #define HIDPP20_ERROR_INVALID_ARGS 0x02
229 #define HIDPP20_ERROR_OUT_OF_RANGE 0x03
230 #define HIDPP20_ERROR_HW_ERROR 0x04
231 #define HIDPP20_ERROR_NOT_ALLOWED 0x05
232 #define HIDPP20_ERROR_INVALID_FEATURE_INDEX 0x06
233 #define HIDPP20_ERROR_INVALID_FUNCTION_ID 0x07
234 #define HIDPP20_ERROR_BUSY 0x08
235 #define HIDPP20_ERROR_UNSUPPORTED 0x09
236 #define HIDPP20_ERROR 0xff
238 static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
240 static int __hidpp_send_report(struct hid_device *hdev,
241 struct hidpp_report *hidpp_report)
243 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
244 int fields_count, ret;
246 switch (hidpp_report->report_id) {
247 case REPORT_ID_HIDPP_SHORT:
248 fields_count = HIDPP_REPORT_SHORT_LENGTH;
250 case REPORT_ID_HIDPP_LONG:
251 fields_count = HIDPP_REPORT_LONG_LENGTH;
253 case REPORT_ID_HIDPP_VERY_LONG:
254 fields_count = hidpp->very_long_report_length;
261 * set the device_index as the receiver, it will be overwritten by
262 * hid_hw_request if needed
264 hidpp_report->device_index = 0xff;
266 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
267 ret = hid_hw_output_report(hdev, (u8 *)hidpp_report, fields_count);
269 ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
270 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
274 return ret == fields_count ? 0 : -1;
278 * Effectively send the message to the device, waiting for its answer.
280 * Must be called with hidpp->send_mutex locked
282 * Same return protocol than hidpp_send_message_sync():
284 * - negative error means transport error
285 * - positive value means protocol error
287 static int __do_hidpp_send_message_sync(struct hidpp_device *hidpp,
288 struct hidpp_report *message,
289 struct hidpp_report *response)
293 __must_hold(&hidpp->send_mutex);
295 hidpp->send_receive_buf = response;
296 hidpp->answer_available = false;
299 * So that we can later validate the answer when it arrives
302 *response = *message;
304 ret = __hidpp_send_report(hidpp->hid_dev, message);
306 dbg_hid("__hidpp_send_report returned err: %d\n", ret);
307 memset(response, 0, sizeof(struct hidpp_report));
311 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
313 dbg_hid("%s:timeout waiting for response\n", __func__);
314 memset(response, 0, sizeof(struct hidpp_report));
318 if (response->report_id == REPORT_ID_HIDPP_SHORT &&
319 response->rap.sub_id == HIDPP_ERROR) {
320 ret = response->rap.params[1];
321 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
325 if ((response->report_id == REPORT_ID_HIDPP_LONG ||
326 response->report_id == REPORT_ID_HIDPP_VERY_LONG) &&
327 response->fap.feature_index == HIDPP20_ERROR) {
328 ret = response->fap.params[1];
329 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
337 * hidpp_send_message_sync() returns 0 in case of success, and something else
338 * in case of a failure.
340 * See __do_hidpp_send_message_sync() for a detailed explanation of the returned
343 static int hidpp_send_message_sync(struct hidpp_device *hidpp,
344 struct hidpp_report *message,
345 struct hidpp_report *response)
350 mutex_lock(&hidpp->send_mutex);
353 ret = __do_hidpp_send_message_sync(hidpp, message, response);
354 if (ret != HIDPP20_ERROR_BUSY)
357 dbg_hid("%s:got busy hidpp 2.0 error %02X, retrying\n", __func__, ret);
358 } while (--max_retries);
360 mutex_unlock(&hidpp->send_mutex);
366 * hidpp_send_fap_command_sync() returns 0 in case of success, and something else
367 * in case of a failure.
369 * See __do_hidpp_send_message_sync() for a detailed explanation of the returned
372 static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
373 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
374 struct hidpp_report *response)
376 struct hidpp_report *message;
379 if (param_count > sizeof(message->fap.params)) {
380 hid_dbg(hidpp->hid_dev,
381 "Invalid number of parameters passed to command (%d != %llu)\n",
383 (unsigned long long) sizeof(message->fap.params));
387 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
391 if (param_count > (HIDPP_REPORT_LONG_LENGTH - 4))
392 message->report_id = REPORT_ID_HIDPP_VERY_LONG;
394 message->report_id = REPORT_ID_HIDPP_LONG;
395 message->fap.feature_index = feat_index;
396 message->fap.funcindex_clientid = funcindex_clientid | LINUX_KERNEL_SW_ID;
397 memcpy(&message->fap.params, params, param_count);
399 ret = hidpp_send_message_sync(hidpp, message, response);
405 * hidpp_send_rap_command_sync() returns 0 in case of success, and something else
406 * in case of a failure.
408 * See __do_hidpp_send_message_sync() for a detailed explanation of the returned
411 static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
412 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
413 struct hidpp_report *response)
415 struct hidpp_report *message;
418 /* Send as long report if short reports are not supported. */
419 if (report_id == REPORT_ID_HIDPP_SHORT &&
420 !(hidpp_dev->supported_reports & HIDPP_REPORT_SHORT_SUPPORTED))
421 report_id = REPORT_ID_HIDPP_LONG;
424 case REPORT_ID_HIDPP_SHORT:
425 max_count = HIDPP_REPORT_SHORT_LENGTH - 4;
427 case REPORT_ID_HIDPP_LONG:
428 max_count = HIDPP_REPORT_LONG_LENGTH - 4;
430 case REPORT_ID_HIDPP_VERY_LONG:
431 max_count = hidpp_dev->very_long_report_length - 4;
437 if (param_count > max_count)
440 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
443 message->report_id = report_id;
444 message->rap.sub_id = sub_id;
445 message->rap.reg_address = reg_address;
446 memcpy(&message->rap.params, params, param_count);
448 ret = hidpp_send_message_sync(hidpp_dev, message, response);
453 static void delayed_work_cb(struct work_struct *work)
455 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
457 hidpp_connect_event(hidpp);
460 static inline bool hidpp_match_answer(struct hidpp_report *question,
461 struct hidpp_report *answer)
463 return (answer->fap.feature_index == question->fap.feature_index) &&
464 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
467 static inline bool hidpp_match_error(struct hidpp_report *question,
468 struct hidpp_report *answer)
470 return ((answer->rap.sub_id == HIDPP_ERROR) ||
471 (answer->fap.feature_index == HIDPP20_ERROR)) &&
472 (answer->fap.funcindex_clientid == question->fap.feature_index) &&
473 (answer->fap.params[0] == question->fap.funcindex_clientid);
476 static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
477 struct hidpp_report *report)
479 return (hidpp->wireless_feature_index &&
480 (report->fap.feature_index == hidpp->wireless_feature_index)) ||
481 ((report->report_id == REPORT_ID_HIDPP_SHORT) &&
482 (report->rap.sub_id == 0x41));
486 * hidpp_prefix_name() prefixes the current given name with "Logitech ".
488 static void hidpp_prefix_name(char **name, int name_length)
490 #define PREFIX_LENGTH 9 /* "Logitech " */
495 if (name_length > PREFIX_LENGTH &&
496 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
497 /* The prefix has is already in the name */
500 new_length = PREFIX_LENGTH + name_length;
501 new_name = kzalloc(new_length, GFP_KERNEL);
505 snprintf(new_name, new_length, "Logitech %s", *name);
513 * Updates the USB wireless_status based on whether the headset
514 * is turned on and reachable.
516 static void hidpp_update_usb_wireless_status(struct hidpp_device *hidpp)
518 struct hid_device *hdev = hidpp->hid_dev;
519 struct usb_interface *intf;
521 if (!(hidpp->quirks & HIDPP_QUIRK_WIRELESS_STATUS))
523 if (!hid_is_usb(hdev))
526 intf = to_usb_interface(hdev->dev.parent);
527 usb_set_wireless_status(intf, hidpp->battery.online ?
528 USB_WIRELESS_STATUS_CONNECTED :
529 USB_WIRELESS_STATUS_DISCONNECTED);
533 * hidpp_scroll_counter_handle_scroll() - Send high- and low-resolution scroll
534 * events given a high-resolution wheel
536 * @input_dev: Pointer to the input device
537 * @counter: a hid_scroll_counter struct describing the wheel.
538 * @hi_res_value: the movement of the wheel, in the mouse's high-resolution
541 * Given a high-resolution movement, this function converts the movement into
542 * fractions of 120 and emits high-resolution scroll events for the input
543 * device. It also uses the multiplier from &struct hid_scroll_counter to
544 * emit low-resolution scroll events when appropriate for
545 * backwards-compatibility with userspace input libraries.
547 static void hidpp_scroll_counter_handle_scroll(struct input_dev *input_dev,
548 struct hidpp_scroll_counter *counter,
551 int low_res_value, remainder, direction;
552 unsigned long long now, previous;
554 hi_res_value = hi_res_value * 120/counter->wheel_multiplier;
555 input_report_rel(input_dev, REL_WHEEL_HI_RES, hi_res_value);
557 remainder = counter->remainder;
558 direction = hi_res_value > 0 ? 1 : -1;
561 previous = counter->last_time;
562 counter->last_time = now;
564 * Reset the remainder after a period of inactivity or when the
565 * direction changes. This prevents the REL_WHEEL emulation point
566 * from sliding for devices that don't always provide the same
567 * number of movements per detent.
569 if (now - previous > 1000000000 || direction != counter->direction)
572 counter->direction = direction;
573 remainder += hi_res_value;
575 /* Some wheels will rest 7/8ths of a detent from the previous detent
576 * after slow movement, so we want the threshold for low-res events to
577 * be in the middle between two detents (e.g. after 4/8ths) as
578 * opposed to on the detents themselves (8/8ths).
580 if (abs(remainder) >= 60) {
581 /* Add (or subtract) 1 because we want to trigger when the wheel
582 * is half-way to the next detent (i.e. scroll 1 detent after a
583 * 1/2 detent movement, 2 detents after a 1 1/2 detent movement,
586 low_res_value = remainder / 120;
587 if (low_res_value == 0)
588 low_res_value = (hi_res_value > 0 ? 1 : -1);
589 input_report_rel(input_dev, REL_WHEEL, low_res_value);
590 remainder -= low_res_value * 120;
592 counter->remainder = remainder;
595 /* -------------------------------------------------------------------------- */
596 /* HIDP++ 1.0 commands */
597 /* -------------------------------------------------------------------------- */
599 #define HIDPP_SET_REGISTER 0x80
600 #define HIDPP_GET_REGISTER 0x81
601 #define HIDPP_SET_LONG_REGISTER 0x82
602 #define HIDPP_GET_LONG_REGISTER 0x83
605 * hidpp10_set_register - Modify a HID++ 1.0 register.
606 * @hidpp_dev: the device to set the register on.
607 * @register_address: the address of the register to modify.
608 * @byte: the byte of the register to modify. Should be less than 3.
609 * @mask: mask of the bits to modify
610 * @value: new values for the bits in mask
611 * Return: 0 if successful, otherwise a negative error code.
613 static int hidpp10_set_register(struct hidpp_device *hidpp_dev,
614 u8 register_address, u8 byte, u8 mask, u8 value)
616 struct hidpp_report response;
618 u8 params[3] = { 0 };
620 ret = hidpp_send_rap_command_sync(hidpp_dev,
621 REPORT_ID_HIDPP_SHORT,
628 memcpy(params, response.rap.params, 3);
630 params[byte] &= ~mask;
631 params[byte] |= value & mask;
633 return hidpp_send_rap_command_sync(hidpp_dev,
634 REPORT_ID_HIDPP_SHORT,
637 params, 3, &response);
640 #define HIDPP_REG_ENABLE_REPORTS 0x00
641 #define HIDPP_ENABLE_CONSUMER_REPORT BIT(0)
642 #define HIDPP_ENABLE_WHEEL_REPORT BIT(2)
643 #define HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT BIT(3)
644 #define HIDPP_ENABLE_BAT_REPORT BIT(4)
645 #define HIDPP_ENABLE_HWHEEL_REPORT BIT(5)
647 static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
649 return hidpp10_set_register(hidpp_dev, HIDPP_REG_ENABLE_REPORTS, 0,
650 HIDPP_ENABLE_BAT_REPORT, HIDPP_ENABLE_BAT_REPORT);
653 #define HIDPP_REG_FEATURES 0x01
654 #define HIDPP_ENABLE_SPECIAL_BUTTON_FUNC BIT(1)
655 #define HIDPP_ENABLE_FAST_SCROLL BIT(6)
657 /* On HID++ 1.0 devices, high-res scroll was called "scrolling acceleration". */
658 static int hidpp10_enable_scrolling_acceleration(struct hidpp_device *hidpp_dev)
660 return hidpp10_set_register(hidpp_dev, HIDPP_REG_FEATURES, 0,
661 HIDPP_ENABLE_FAST_SCROLL, HIDPP_ENABLE_FAST_SCROLL);
664 #define HIDPP_REG_BATTERY_STATUS 0x07
666 static int hidpp10_battery_status_map_level(u8 param)
672 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
675 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
678 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
681 level = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
684 level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
690 static int hidpp10_battery_status_map_status(u8 param)
696 /* discharging (in use) */
697 status = POWER_SUPPLY_STATUS_DISCHARGING;
699 case 0x21: /* (standard) charging */
700 case 0x24: /* fast charging */
701 case 0x25: /* slow charging */
702 status = POWER_SUPPLY_STATUS_CHARGING;
704 case 0x26: /* topping charge */
705 case 0x22: /* charge complete */
706 status = POWER_SUPPLY_STATUS_FULL;
708 case 0x20: /* unknown */
709 status = POWER_SUPPLY_STATUS_UNKNOWN;
712 * 0x01...0x1F = reserved (not charging)
713 * 0x23 = charging error
714 * 0x27..0xff = reserved
717 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
724 static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
726 struct hidpp_report response;
729 ret = hidpp_send_rap_command_sync(hidpp,
730 REPORT_ID_HIDPP_SHORT,
732 HIDPP_REG_BATTERY_STATUS,
737 hidpp->battery.level =
738 hidpp10_battery_status_map_level(response.rap.params[0]);
739 status = hidpp10_battery_status_map_status(response.rap.params[1]);
740 hidpp->battery.status = status;
741 /* the capacity is only available when discharging or full */
742 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
743 status == POWER_SUPPLY_STATUS_FULL;
748 #define HIDPP_REG_BATTERY_MILEAGE 0x0D
750 static int hidpp10_battery_mileage_map_status(u8 param)
754 switch (param >> 6) {
756 /* discharging (in use) */
757 status = POWER_SUPPLY_STATUS_DISCHARGING;
759 case 0x01: /* charging */
760 status = POWER_SUPPLY_STATUS_CHARGING;
762 case 0x02: /* charge complete */
763 status = POWER_SUPPLY_STATUS_FULL;
766 * 0x03 = charging error
769 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
776 static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
778 struct hidpp_report response;
781 ret = hidpp_send_rap_command_sync(hidpp,
782 REPORT_ID_HIDPP_SHORT,
784 HIDPP_REG_BATTERY_MILEAGE,
789 hidpp->battery.capacity = response.rap.params[0];
790 status = hidpp10_battery_mileage_map_status(response.rap.params[2]);
791 hidpp->battery.status = status;
792 /* the capacity is only available when discharging or full */
793 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
794 status == POWER_SUPPLY_STATUS_FULL;
799 static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
801 struct hidpp_report *report = (struct hidpp_report *)data;
802 int status, capacity, level;
805 if (report->report_id != REPORT_ID_HIDPP_SHORT)
808 switch (report->rap.sub_id) {
809 case HIDPP_REG_BATTERY_STATUS:
810 capacity = hidpp->battery.capacity;
811 level = hidpp10_battery_status_map_level(report->rawbytes[1]);
812 status = hidpp10_battery_status_map_status(report->rawbytes[2]);
814 case HIDPP_REG_BATTERY_MILEAGE:
815 capacity = report->rap.params[0];
816 level = hidpp->battery.level;
817 status = hidpp10_battery_mileage_map_status(report->rawbytes[3]);
823 changed = capacity != hidpp->battery.capacity ||
824 level != hidpp->battery.level ||
825 status != hidpp->battery.status;
827 /* the capacity is only available when discharging or full */
828 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
829 status == POWER_SUPPLY_STATUS_FULL;
832 hidpp->battery.level = level;
833 hidpp->battery.status = status;
834 if (hidpp->battery.ps)
835 power_supply_changed(hidpp->battery.ps);
841 #define HIDPP_REG_PAIRING_INFORMATION 0xB5
842 #define HIDPP_EXTENDED_PAIRING 0x30
843 #define HIDPP_DEVICE_NAME 0x40
845 static char *hidpp_unifying_get_name(struct hidpp_device *hidpp_dev)
847 struct hidpp_report response;
849 u8 params[1] = { HIDPP_DEVICE_NAME };
853 ret = hidpp_send_rap_command_sync(hidpp_dev,
854 REPORT_ID_HIDPP_SHORT,
855 HIDPP_GET_LONG_REGISTER,
856 HIDPP_REG_PAIRING_INFORMATION,
857 params, 1, &response);
861 len = response.rap.params[1];
863 if (2 + len > sizeof(response.rap.params))
866 if (len < 4) /* logitech devices are usually at least Xddd */
869 name = kzalloc(len + 1, GFP_KERNEL);
873 memcpy(name, &response.rap.params[2], len);
875 /* include the terminating '\0' */
876 hidpp_prefix_name(&name, len + 1);
881 static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
883 struct hidpp_report response;
885 u8 params[1] = { HIDPP_EXTENDED_PAIRING };
887 ret = hidpp_send_rap_command_sync(hidpp,
888 REPORT_ID_HIDPP_SHORT,
889 HIDPP_GET_LONG_REGISTER,
890 HIDPP_REG_PAIRING_INFORMATION,
891 params, 1, &response);
896 * We don't care about LE or BE, we will output it as a string
897 * with %4phD, so we need to keep the order.
899 *serial = *((u32 *)&response.rap.params[1]);
903 static int hidpp_unifying_init(struct hidpp_device *hidpp)
905 struct hid_device *hdev = hidpp->hid_dev;
910 ret = hidpp_unifying_get_serial(hidpp, &serial);
914 snprintf(hdev->uniq, sizeof(hdev->uniq), "%4phD", &serial);
915 dbg_hid("HID++ Unifying: Got serial: %s\n", hdev->uniq);
917 name = hidpp_unifying_get_name(hidpp);
921 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
922 dbg_hid("HID++ Unifying: Got name: %s\n", name);
928 /* -------------------------------------------------------------------------- */
930 /* -------------------------------------------------------------------------- */
932 #define HIDPP_PAGE_ROOT 0x0000
933 #define HIDPP_PAGE_ROOT_IDX 0x00
935 #define CMD_ROOT_GET_FEATURE 0x00
936 #define CMD_ROOT_GET_PROTOCOL_VERSION 0x10
938 static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
939 u8 *feature_index, u8 *feature_type)
941 struct hidpp_report response;
943 u8 params[2] = { feature >> 8, feature & 0x00FF };
945 ret = hidpp_send_fap_command_sync(hidpp,
947 CMD_ROOT_GET_FEATURE,
948 params, 2, &response);
952 if (response.fap.params[0] == 0)
955 *feature_index = response.fap.params[0];
956 *feature_type = response.fap.params[1];
961 static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
963 const u8 ping_byte = 0x5a;
964 u8 ping_data[3] = { 0, 0, ping_byte };
965 struct hidpp_report response;
968 ret = hidpp_send_rap_command_sync(hidpp,
969 REPORT_ID_HIDPP_SHORT,
971 CMD_ROOT_GET_PROTOCOL_VERSION | LINUX_KERNEL_SW_ID,
972 ping_data, sizeof(ping_data), &response);
974 if (ret == HIDPP_ERROR_INVALID_SUBID) {
975 hidpp->protocol_major = 1;
976 hidpp->protocol_minor = 0;
980 /* the device might not be connected */
981 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
985 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
992 if (response.rap.params[2] != ping_byte) {
993 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
994 __func__, response.rap.params[2], ping_byte);
998 hidpp->protocol_major = response.rap.params[0];
999 hidpp->protocol_minor = response.rap.params[1];
1002 hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
1003 hidpp->protocol_major, hidpp->protocol_minor);
1007 /* -------------------------------------------------------------------------- */
1008 /* 0x0003: Device Information */
1009 /* -------------------------------------------------------------------------- */
1011 #define HIDPP_PAGE_DEVICE_INFORMATION 0x0003
1013 #define CMD_GET_DEVICE_INFO 0x00
1015 static int hidpp_get_serial(struct hidpp_device *hidpp, u32 *serial)
1017 struct hidpp_report response;
1022 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_DEVICE_INFORMATION,
1028 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1029 CMD_GET_DEVICE_INFO,
1030 NULL, 0, &response);
1034 /* See hidpp_unifying_get_serial() */
1035 *serial = *((u32 *)&response.rap.params[1]);
1039 static int hidpp_serial_init(struct hidpp_device *hidpp)
1041 struct hid_device *hdev = hidpp->hid_dev;
1045 ret = hidpp_get_serial(hidpp, &serial);
1049 snprintf(hdev->uniq, sizeof(hdev->uniq), "%4phD", &serial);
1050 dbg_hid("HID++ DeviceInformation: Got serial: %s\n", hdev->uniq);
1055 /* -------------------------------------------------------------------------- */
1056 /* 0x0005: GetDeviceNameType */
1057 /* -------------------------------------------------------------------------- */
1059 #define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005
1061 #define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x00
1062 #define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x10
1063 #define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x20
1065 static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
1066 u8 feature_index, u8 *nameLength)
1068 struct hidpp_report response;
1071 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1072 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
1075 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1082 *nameLength = response.fap.params[0];
1087 static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
1088 u8 feature_index, u8 char_index, char *device_name, int len_buf)
1090 struct hidpp_report response;
1094 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1095 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
1099 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1106 switch (response.report_id) {
1107 case REPORT_ID_HIDPP_VERY_LONG:
1108 count = hidpp->very_long_report_length - 4;
1110 case REPORT_ID_HIDPP_LONG:
1111 count = HIDPP_REPORT_LONG_LENGTH - 4;
1113 case REPORT_ID_HIDPP_SHORT:
1114 count = HIDPP_REPORT_SHORT_LENGTH - 4;
1120 if (len_buf < count)
1123 for (i = 0; i < count; i++)
1124 device_name[i] = response.fap.params[i];
1129 static char *hidpp_get_device_name(struct hidpp_device *hidpp)
1138 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
1139 &feature_index, &feature_type);
1143 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
1148 name = kzalloc(__name_length + 1, GFP_KERNEL);
1152 while (index < __name_length) {
1153 ret = hidpp_devicenametype_get_device_name(hidpp,
1154 feature_index, index, name + index,
1155 __name_length - index);
1163 /* include the terminating '\0' */
1164 hidpp_prefix_name(&name, __name_length + 1);
1169 /* -------------------------------------------------------------------------- */
1170 /* 0x1000: Battery level status */
1171 /* -------------------------------------------------------------------------- */
1173 #define HIDPP_PAGE_BATTERY_LEVEL_STATUS 0x1000
1175 #define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS 0x00
1176 #define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY 0x10
1178 #define EVENT_BATTERY_LEVEL_STATUS_BROADCAST 0x00
1180 #define FLAG_BATTERY_LEVEL_DISABLE_OSD BIT(0)
1181 #define FLAG_BATTERY_LEVEL_MILEAGE BIT(1)
1182 #define FLAG_BATTERY_LEVEL_RECHARGEABLE BIT(2)
1184 static int hidpp_map_battery_level(int capacity)
1187 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1189 * The spec says this should be < 31 but some devices report 30
1190 * with brand new batteries and Windows reports 30 as "Good".
1192 else if (capacity < 30)
1193 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1194 else if (capacity < 81)
1195 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1196 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1199 static int hidpp20_batterylevel_map_status_capacity(u8 data[3], int *capacity,
1205 *capacity = data[0];
1206 *next_capacity = data[1];
1207 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1209 /* When discharging, we can rely on the device reported capacity.
1210 * For all other states the device reports 0 (unknown).
1213 case 0: /* discharging (in use) */
1214 status = POWER_SUPPLY_STATUS_DISCHARGING;
1215 *level = hidpp_map_battery_level(*capacity);
1217 case 1: /* recharging */
1218 status = POWER_SUPPLY_STATUS_CHARGING;
1220 case 2: /* charge in final stage */
1221 status = POWER_SUPPLY_STATUS_CHARGING;
1223 case 3: /* charge complete */
1224 status = POWER_SUPPLY_STATUS_FULL;
1225 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1228 case 4: /* recharging below optimal speed */
1229 status = POWER_SUPPLY_STATUS_CHARGING;
1231 /* 5 = invalid battery type
1233 7 = other charging error */
1235 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1242 static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
1249 struct hidpp_report response;
1251 u8 *params = (u8 *)response.fap.params;
1253 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1254 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS,
1255 NULL, 0, &response);
1256 /* Ignore these intermittent errors */
1257 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1260 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1267 *status = hidpp20_batterylevel_map_status_capacity(params, capacity,
1274 static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
1277 struct hidpp_report response;
1279 u8 *params = (u8 *)response.fap.params;
1280 unsigned int level_count, flags;
1282 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1283 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY,
1284 NULL, 0, &response);
1286 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1293 level_count = params[0];
1296 if (level_count < 10 || !(flags & FLAG_BATTERY_LEVEL_MILEAGE))
1297 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1299 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1304 static int hidpp20_query_battery_info_1000(struct hidpp_device *hidpp)
1308 int status, capacity, next_capacity, level;
1310 if (hidpp->battery.feature_index == 0xff) {
1311 ret = hidpp_root_get_feature(hidpp,
1312 HIDPP_PAGE_BATTERY_LEVEL_STATUS,
1313 &hidpp->battery.feature_index,
1319 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1320 hidpp->battery.feature_index,
1322 &next_capacity, &level);
1326 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1327 hidpp->battery.feature_index);
1331 hidpp->battery.status = status;
1332 hidpp->battery.capacity = capacity;
1333 hidpp->battery.level = level;
1334 /* the capacity is only available when discharging or full */
1335 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1336 status == POWER_SUPPLY_STATUS_FULL;
1341 static int hidpp20_battery_event_1000(struct hidpp_device *hidpp,
1344 struct hidpp_report *report = (struct hidpp_report *)data;
1345 int status, capacity, next_capacity, level;
1348 if (report->fap.feature_index != hidpp->battery.feature_index ||
1349 report->fap.funcindex_clientid != EVENT_BATTERY_LEVEL_STATUS_BROADCAST)
1352 status = hidpp20_batterylevel_map_status_capacity(report->fap.params,
1357 /* the capacity is only available when discharging or full */
1358 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1359 status == POWER_SUPPLY_STATUS_FULL;
1361 changed = capacity != hidpp->battery.capacity ||
1362 level != hidpp->battery.level ||
1363 status != hidpp->battery.status;
1366 hidpp->battery.level = level;
1367 hidpp->battery.capacity = capacity;
1368 hidpp->battery.status = status;
1369 if (hidpp->battery.ps)
1370 power_supply_changed(hidpp->battery.ps);
1376 /* -------------------------------------------------------------------------- */
1377 /* 0x1001: Battery voltage */
1378 /* -------------------------------------------------------------------------- */
1380 #define HIDPP_PAGE_BATTERY_VOLTAGE 0x1001
1382 #define CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE 0x00
1384 #define EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST 0x00
1386 static int hidpp20_battery_map_status_voltage(u8 data[3], int *voltage,
1387 int *level, int *charge_type)
1391 long flags = (long) data[2];
1392 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1395 switch (flags & 0x07) {
1397 status = POWER_SUPPLY_STATUS_CHARGING;
1400 status = POWER_SUPPLY_STATUS_FULL;
1401 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1404 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1407 status = POWER_SUPPLY_STATUS_UNKNOWN;
1411 status = POWER_SUPPLY_STATUS_DISCHARGING;
1413 *charge_type = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
1414 if (test_bit(3, &flags)) {
1415 *charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
1417 if (test_bit(4, &flags)) {
1418 *charge_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1420 if (test_bit(5, &flags)) {
1421 *level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1424 *voltage = get_unaligned_be16(data);
1429 static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
1431 int *status, int *voltage,
1432 int *level, int *charge_type)
1434 struct hidpp_report response;
1436 u8 *params = (u8 *)response.fap.params;
1438 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1439 CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE,
1440 NULL, 0, &response);
1443 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1450 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
1452 *status = hidpp20_battery_map_status_voltage(params, voltage,
1453 level, charge_type);
1458 static int hidpp20_map_battery_capacity(struct hid_device *hid_dev, int voltage)
1460 /* NB: This voltage curve doesn't necessarily map perfectly to all
1461 * devices that implement the BATTERY_VOLTAGE feature. This is because
1462 * there are a few devices that use different battery technology.
1465 static const int voltages[100] = {
1466 4186, 4156, 4143, 4133, 4122, 4113, 4103, 4094, 4086, 4075,
1467 4067, 4059, 4051, 4043, 4035, 4027, 4019, 4011, 4003, 3997,
1468 3989, 3983, 3976, 3969, 3961, 3955, 3949, 3942, 3935, 3929,
1469 3922, 3916, 3909, 3902, 3896, 3890, 3883, 3877, 3870, 3865,
1470 3859, 3853, 3848, 3842, 3837, 3833, 3828, 3824, 3819, 3815,
1471 3811, 3808, 3804, 3800, 3797, 3793, 3790, 3787, 3784, 3781,
1472 3778, 3775, 3772, 3770, 3767, 3764, 3762, 3759, 3757, 3754,
1473 3751, 3748, 3744, 3741, 3737, 3734, 3730, 3726, 3724, 3720,
1474 3717, 3714, 3710, 3706, 3702, 3697, 3693, 3688, 3683, 3677,
1475 3671, 3666, 3662, 3658, 3654, 3646, 3633, 3612, 3579, 3537
1480 if (unlikely(voltage < 3500 || voltage >= 5000))
1481 hid_warn_once(hid_dev,
1482 "%s: possibly using the wrong voltage curve\n",
1485 for (i = 0; i < ARRAY_SIZE(voltages); i++) {
1486 if (voltage >= voltages[i])
1487 return ARRAY_SIZE(voltages) - i;
1493 static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
1497 int status, voltage, level, charge_type;
1499 if (hidpp->battery.voltage_feature_index == 0xff) {
1500 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
1501 &hidpp->battery.voltage_feature_index,
1507 ret = hidpp20_battery_get_battery_voltage(hidpp,
1508 hidpp->battery.voltage_feature_index,
1509 &status, &voltage, &level, &charge_type);
1514 hidpp->battery.status = status;
1515 hidpp->battery.voltage = voltage;
1516 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1518 hidpp->battery.level = level;
1519 hidpp->battery.charge_type = charge_type;
1520 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1525 static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
1528 struct hidpp_report *report = (struct hidpp_report *)data;
1529 int status, voltage, level, charge_type;
1531 if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||
1532 report->fap.funcindex_clientid != EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST)
1535 status = hidpp20_battery_map_status_voltage(report->fap.params, &voltage,
1536 &level, &charge_type);
1538 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1540 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1541 hidpp->battery.voltage = voltage;
1542 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1544 hidpp->battery.status = status;
1545 hidpp->battery.level = level;
1546 hidpp->battery.charge_type = charge_type;
1547 if (hidpp->battery.ps)
1548 power_supply_changed(hidpp->battery.ps);
1553 /* -------------------------------------------------------------------------- */
1554 /* 0x1004: Unified battery */
1555 /* -------------------------------------------------------------------------- */
1557 #define HIDPP_PAGE_UNIFIED_BATTERY 0x1004
1559 #define CMD_UNIFIED_BATTERY_GET_CAPABILITIES 0x00
1560 #define CMD_UNIFIED_BATTERY_GET_STATUS 0x10
1562 #define EVENT_UNIFIED_BATTERY_STATUS_EVENT 0x00
1564 #define FLAG_UNIFIED_BATTERY_LEVEL_CRITICAL BIT(0)
1565 #define FLAG_UNIFIED_BATTERY_LEVEL_LOW BIT(1)
1566 #define FLAG_UNIFIED_BATTERY_LEVEL_GOOD BIT(2)
1567 #define FLAG_UNIFIED_BATTERY_LEVEL_FULL BIT(3)
1569 #define FLAG_UNIFIED_BATTERY_FLAGS_RECHARGEABLE BIT(0)
1570 #define FLAG_UNIFIED_BATTERY_FLAGS_STATE_OF_CHARGE BIT(1)
1572 static int hidpp20_unifiedbattery_get_capabilities(struct hidpp_device *hidpp,
1575 struct hidpp_report response;
1577 u8 *params = (u8 *)response.fap.params;
1579 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS ||
1580 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) {
1581 /* we have already set the device capabilities, so let's skip */
1585 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1586 CMD_UNIFIED_BATTERY_GET_CAPABILITIES,
1587 NULL, 0, &response);
1588 /* Ignore these intermittent errors */
1589 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1592 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1600 * If the device supports state of charge (battery percentage) we won't
1601 * export the battery level information. there are 4 possible battery
1602 * levels and they all are optional, this means that the device might
1603 * not support any of them, we are just better off with the battery
1606 if (params[1] & FLAG_UNIFIED_BATTERY_FLAGS_STATE_OF_CHARGE) {
1607 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_PERCENTAGE;
1608 hidpp->battery.supported_levels_1004 = 0;
1610 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1611 hidpp->battery.supported_levels_1004 = params[0];
1617 static int hidpp20_unifiedbattery_map_status(struct hidpp_device *hidpp,
1619 u8 external_power_status)
1623 switch (charging_status) {
1624 case 0: /* discharging */
1625 status = POWER_SUPPLY_STATUS_DISCHARGING;
1627 case 1: /* charging */
1628 case 2: /* charging slow */
1629 status = POWER_SUPPLY_STATUS_CHARGING;
1631 case 3: /* complete */
1632 status = POWER_SUPPLY_STATUS_FULL;
1635 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1636 hid_info(hidpp->hid_dev, "%s: charging error",
1640 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1647 static int hidpp20_unifiedbattery_map_level(struct hidpp_device *hidpp,
1650 /* cler unsupported level bits */
1651 battery_level &= hidpp->battery.supported_levels_1004;
1653 if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_FULL)
1654 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1655 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_GOOD)
1656 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1657 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_LOW)
1658 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1659 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_CRITICAL)
1660 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1662 return POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1665 static int hidpp20_unifiedbattery_get_status(struct hidpp_device *hidpp,
1667 u8 *state_of_charge,
1671 struct hidpp_report response;
1673 u8 *params = (u8 *)response.fap.params;
1675 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1676 CMD_UNIFIED_BATTERY_GET_STATUS,
1677 NULL, 0, &response);
1678 /* Ignore these intermittent errors */
1679 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1682 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1689 *state_of_charge = params[0];
1690 *status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1691 *level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1696 static int hidpp20_query_battery_info_1004(struct hidpp_device *hidpp)
1703 if (hidpp->battery.feature_index == 0xff) {
1704 ret = hidpp_root_get_feature(hidpp,
1705 HIDPP_PAGE_UNIFIED_BATTERY,
1706 &hidpp->battery.feature_index,
1712 ret = hidpp20_unifiedbattery_get_capabilities(hidpp,
1713 hidpp->battery.feature_index);
1717 ret = hidpp20_unifiedbattery_get_status(hidpp,
1718 hidpp->battery.feature_index,
1725 hidpp->capabilities |= HIDPP_CAPABILITY_UNIFIED_BATTERY;
1726 hidpp->battery.capacity = state_of_charge;
1727 hidpp->battery.status = status;
1728 hidpp->battery.level = level;
1729 hidpp->battery.online = true;
1734 static int hidpp20_battery_event_1004(struct hidpp_device *hidpp,
1737 struct hidpp_report *report = (struct hidpp_report *)data;
1738 u8 *params = (u8 *)report->fap.params;
1739 int state_of_charge, status, level;
1742 if (report->fap.feature_index != hidpp->battery.feature_index ||
1743 report->fap.funcindex_clientid != EVENT_UNIFIED_BATTERY_STATUS_EVENT)
1746 state_of_charge = params[0];
1747 status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1748 level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1750 changed = status != hidpp->battery.status ||
1751 (state_of_charge != hidpp->battery.capacity &&
1752 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) ||
1753 (level != hidpp->battery.level &&
1754 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS);
1757 hidpp->battery.capacity = state_of_charge;
1758 hidpp->battery.status = status;
1759 hidpp->battery.level = level;
1760 if (hidpp->battery.ps)
1761 power_supply_changed(hidpp->battery.ps);
1767 /* -------------------------------------------------------------------------- */
1768 /* Battery feature helpers */
1769 /* -------------------------------------------------------------------------- */
1771 static enum power_supply_property hidpp_battery_props[] = {
1772 POWER_SUPPLY_PROP_ONLINE,
1773 POWER_SUPPLY_PROP_STATUS,
1774 POWER_SUPPLY_PROP_SCOPE,
1775 POWER_SUPPLY_PROP_MODEL_NAME,
1776 POWER_SUPPLY_PROP_MANUFACTURER,
1777 POWER_SUPPLY_PROP_SERIAL_NUMBER,
1778 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY, */
1779 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY_LEVEL, */
1780 0, /* placeholder for POWER_SUPPLY_PROP_VOLTAGE_NOW, */
1783 static int hidpp_battery_get_property(struct power_supply *psy,
1784 enum power_supply_property psp,
1785 union power_supply_propval *val)
1787 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1791 case POWER_SUPPLY_PROP_STATUS:
1792 val->intval = hidpp->battery.status;
1794 case POWER_SUPPLY_PROP_CAPACITY:
1795 val->intval = hidpp->battery.capacity;
1797 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1798 val->intval = hidpp->battery.level;
1800 case POWER_SUPPLY_PROP_SCOPE:
1801 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1803 case POWER_SUPPLY_PROP_ONLINE:
1804 val->intval = hidpp->battery.online;
1806 case POWER_SUPPLY_PROP_MODEL_NAME:
1807 if (!strncmp(hidpp->name, "Logitech ", 9))
1808 val->strval = hidpp->name + 9;
1810 val->strval = hidpp->name;
1812 case POWER_SUPPLY_PROP_MANUFACTURER:
1813 val->strval = "Logitech";
1815 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
1816 val->strval = hidpp->hid_dev->uniq;
1818 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1819 /* hardware reports voltage in mV. sysfs expects uV */
1820 val->intval = hidpp->battery.voltage * 1000;
1822 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1823 val->intval = hidpp->battery.charge_type;
1833 /* -------------------------------------------------------------------------- */
1834 /* 0x1d4b: Wireless device status */
1835 /* -------------------------------------------------------------------------- */
1836 #define HIDPP_PAGE_WIRELESS_DEVICE_STATUS 0x1d4b
1838 static int hidpp_get_wireless_feature_index(struct hidpp_device *hidpp, u8 *feature_index)
1843 ret = hidpp_root_get_feature(hidpp,
1844 HIDPP_PAGE_WIRELESS_DEVICE_STATUS,
1845 feature_index, &feature_type);
1850 /* -------------------------------------------------------------------------- */
1851 /* 0x1f20: ADC measurement */
1852 /* -------------------------------------------------------------------------- */
1854 #define HIDPP_PAGE_ADC_MEASUREMENT 0x1f20
1856 #define CMD_ADC_MEASUREMENT_GET_ADC_MEASUREMENT 0x00
1858 #define EVENT_ADC_MEASUREMENT_STATUS_BROADCAST 0x00
1860 static int hidpp20_map_adc_measurement_1f20_capacity(struct hid_device *hid_dev, int voltage)
1862 /* NB: This voltage curve doesn't necessarily map perfectly to all
1863 * devices that implement the ADC_MEASUREMENT feature. This is because
1864 * there are a few devices that use different battery technology.
1867 * https://github.com/Sapd/HeadsetControl/blob/acd972be0468e039b93aae81221f20a54d2d60f7/src/devices/logitech_g633_g933_935.c#L44-L52
1869 static const int voltages[100] = {
1870 4030, 4024, 4018, 4011, 4003, 3994, 3985, 3975, 3963, 3951,
1871 3937, 3922, 3907, 3893, 3880, 3868, 3857, 3846, 3837, 3828,
1872 3820, 3812, 3805, 3798, 3791, 3785, 3779, 3773, 3768, 3762,
1873 3757, 3752, 3747, 3742, 3738, 3733, 3729, 3724, 3720, 3716,
1874 3712, 3708, 3704, 3700, 3696, 3692, 3688, 3685, 3681, 3677,
1875 3674, 3670, 3667, 3663, 3660, 3657, 3653, 3650, 3646, 3643,
1876 3640, 3637, 3633, 3630, 3627, 3624, 3620, 3617, 3614, 3611,
1877 3608, 3604, 3601, 3598, 3595, 3592, 3589, 3585, 3582, 3579,
1878 3576, 3573, 3569, 3566, 3563, 3560, 3556, 3553, 3550, 3546,
1879 3543, 3539, 3536, 3532, 3529, 3525, 3499, 3466, 3433, 3399,
1887 if (unlikely(voltage < 3400 || voltage >= 5000))
1888 hid_warn_once(hid_dev,
1889 "%s: possibly using the wrong voltage curve\n",
1892 for (i = 0; i < ARRAY_SIZE(voltages); i++) {
1893 if (voltage >= voltages[i])
1894 return ARRAY_SIZE(voltages) - i;
1900 static int hidpp20_map_adc_measurement_1f20(u8 data[3], int *voltage)
1909 status = POWER_SUPPLY_STATUS_DISCHARGING;
1912 status = POWER_SUPPLY_STATUS_CHARGING;
1915 status = POWER_SUPPLY_STATUS_FULL;
1919 status = POWER_SUPPLY_STATUS_UNKNOWN;
1923 *voltage = get_unaligned_be16(data);
1925 dbg_hid("Parsed 1f20 data as flag 0x%02x voltage %dmV\n",
1931 /* Return value is whether the device is online */
1932 static bool hidpp20_get_adc_measurement_1f20(struct hidpp_device *hidpp,
1934 int *status, int *voltage)
1936 struct hidpp_report response;
1938 u8 *params = (u8 *)response.fap.params;
1940 *status = POWER_SUPPLY_STATUS_UNKNOWN;
1942 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1943 CMD_ADC_MEASUREMENT_GET_ADC_MEASUREMENT,
1944 NULL, 0, &response);
1947 hid_dbg(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1952 *status = hidpp20_map_adc_measurement_1f20(params, voltage);
1956 static int hidpp20_query_adc_measurement_info_1f20(struct hidpp_device *hidpp)
1960 if (hidpp->battery.adc_measurement_feature_index == 0xff) {
1963 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_ADC_MEASUREMENT,
1964 &hidpp->battery.adc_measurement_feature_index,
1969 hidpp->capabilities |= HIDPP_CAPABILITY_ADC_MEASUREMENT;
1972 hidpp->battery.online = hidpp20_get_adc_measurement_1f20(hidpp,
1973 hidpp->battery.adc_measurement_feature_index,
1974 &hidpp->battery.status,
1975 &hidpp->battery.voltage);
1976 hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev,
1977 hidpp->battery.voltage);
1978 hidpp_update_usb_wireless_status(hidpp);
1983 static int hidpp20_adc_measurement_event_1f20(struct hidpp_device *hidpp,
1986 struct hidpp_report *report = (struct hidpp_report *)data;
1987 int status, voltage;
1989 if (report->fap.feature_index != hidpp->battery.adc_measurement_feature_index ||
1990 report->fap.funcindex_clientid != EVENT_ADC_MEASUREMENT_STATUS_BROADCAST)
1993 status = hidpp20_map_adc_measurement_1f20(report->fap.params, &voltage);
1995 hidpp->battery.online = status != POWER_SUPPLY_STATUS_UNKNOWN;
1997 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1998 hidpp->battery.status = status;
1999 hidpp->battery.voltage = voltage;
2000 hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev, voltage);
2001 if (hidpp->battery.ps)
2002 power_supply_changed(hidpp->battery.ps);
2003 hidpp_update_usb_wireless_status(hidpp);
2008 /* -------------------------------------------------------------------------- */
2009 /* 0x2120: Hi-resolution scrolling */
2010 /* -------------------------------------------------------------------------- */
2012 #define HIDPP_PAGE_HI_RESOLUTION_SCROLLING 0x2120
2014 #define CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE 0x10
2016 static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
2017 bool enabled, u8 *multiplier)
2023 struct hidpp_report response;
2025 ret = hidpp_root_get_feature(hidpp,
2026 HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
2032 params[0] = enabled ? BIT(0) : 0;
2033 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2034 CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE,
2035 params, sizeof(params), &response);
2038 *multiplier = response.fap.params[1];
2042 /* -------------------------------------------------------------------------- */
2043 /* 0x2121: HiRes Wheel */
2044 /* -------------------------------------------------------------------------- */
2046 #define HIDPP_PAGE_HIRES_WHEEL 0x2121
2048 #define CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY 0x00
2049 #define CMD_HIRES_WHEEL_SET_WHEEL_MODE 0x20
2051 static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
2057 struct hidpp_report response;
2059 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2060 &feature_index, &feature_type);
2062 goto return_default;
2064 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2065 CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY,
2066 NULL, 0, &response);
2068 goto return_default;
2070 *multiplier = response.fap.params[0];
2073 hid_warn(hidpp->hid_dev,
2074 "Couldn't get wheel multiplier (error %d)\n", ret);
2078 static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
2079 bool high_resolution, bool use_hidpp)
2085 struct hidpp_report response;
2087 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2088 &feature_index, &feature_type);
2092 params[0] = (invert ? BIT(2) : 0) |
2093 (high_resolution ? BIT(1) : 0) |
2094 (use_hidpp ? BIT(0) : 0);
2096 return hidpp_send_fap_command_sync(hidpp, feature_index,
2097 CMD_HIRES_WHEEL_SET_WHEEL_MODE,
2098 params, sizeof(params), &response);
2101 /* -------------------------------------------------------------------------- */
2102 /* 0x4301: Solar Keyboard */
2103 /* -------------------------------------------------------------------------- */
2105 #define HIDPP_PAGE_SOLAR_KEYBOARD 0x4301
2107 #define CMD_SOLAR_SET_LIGHT_MEASURE 0x00
2109 #define EVENT_SOLAR_BATTERY_BROADCAST 0x00
2110 #define EVENT_SOLAR_BATTERY_LIGHT_MEASURE 0x10
2111 #define EVENT_SOLAR_CHECK_LIGHT_BUTTON 0x20
2113 static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
2115 struct hidpp_report response;
2116 u8 params[2] = { 1, 1 };
2120 if (hidpp->battery.feature_index == 0xff) {
2121 ret = hidpp_root_get_feature(hidpp,
2122 HIDPP_PAGE_SOLAR_KEYBOARD,
2123 &hidpp->battery.solar_feature_index,
2129 ret = hidpp_send_fap_command_sync(hidpp,
2130 hidpp->battery.solar_feature_index,
2131 CMD_SOLAR_SET_LIGHT_MEASURE,
2132 params, 2, &response);
2134 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2141 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
2146 static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
2149 struct hidpp_report *report = (struct hidpp_report *)data;
2150 int capacity, lux, status;
2153 function = report->fap.funcindex_clientid;
2156 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
2157 !(function == EVENT_SOLAR_BATTERY_BROADCAST ||
2158 function == EVENT_SOLAR_BATTERY_LIGHT_MEASURE ||
2159 function == EVENT_SOLAR_CHECK_LIGHT_BUTTON))
2162 capacity = report->fap.params[0];
2165 case EVENT_SOLAR_BATTERY_LIGHT_MEASURE:
2166 lux = (report->fap.params[1] << 8) | report->fap.params[2];
2168 status = POWER_SUPPLY_STATUS_CHARGING;
2170 status = POWER_SUPPLY_STATUS_DISCHARGING;
2172 case EVENT_SOLAR_CHECK_LIGHT_BUTTON:
2174 if (capacity < hidpp->battery.capacity)
2175 status = POWER_SUPPLY_STATUS_DISCHARGING;
2177 status = POWER_SUPPLY_STATUS_CHARGING;
2181 if (capacity == 100)
2182 status = POWER_SUPPLY_STATUS_FULL;
2184 hidpp->battery.online = true;
2185 if (capacity != hidpp->battery.capacity ||
2186 status != hidpp->battery.status) {
2187 hidpp->battery.capacity = capacity;
2188 hidpp->battery.status = status;
2189 if (hidpp->battery.ps)
2190 power_supply_changed(hidpp->battery.ps);
2196 /* -------------------------------------------------------------------------- */
2197 /* 0x6010: Touchpad FW items */
2198 /* -------------------------------------------------------------------------- */
2200 #define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010
2202 #define CMD_TOUCHPAD_FW_ITEMS_SET 0x10
2204 struct hidpp_touchpad_fw_items {
2206 uint8_t desired_state;
2212 * send a set state command to the device by reading the current items->state
2213 * field. items is then filled with the current state.
2215 static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
2217 struct hidpp_touchpad_fw_items *items)
2219 struct hidpp_report response;
2221 u8 *params = (u8 *)response.fap.params;
2223 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2224 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
2227 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2234 items->presence = params[0];
2235 items->desired_state = params[1];
2236 items->state = params[2];
2237 items->persistent = params[3];
2242 /* -------------------------------------------------------------------------- */
2243 /* 0x6100: TouchPadRawXY */
2244 /* -------------------------------------------------------------------------- */
2246 #define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100
2248 #define CMD_TOUCHPAD_GET_RAW_INFO 0x00
2249 #define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x20
2251 #define EVENT_TOUCHPAD_RAW_XY 0x00
2253 #define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01
2254 #define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03
2256 struct hidpp_touchpad_raw_info {
2267 struct hidpp_touchpad_raw_xy_finger {
2277 struct hidpp_touchpad_raw_xy {
2279 struct hidpp_touchpad_raw_xy_finger fingers[2];
2286 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
2287 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
2289 struct hidpp_report response;
2291 u8 *params = (u8 *)response.fap.params;
2293 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2294 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
2297 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2304 raw_info->x_size = get_unaligned_be16(¶ms[0]);
2305 raw_info->y_size = get_unaligned_be16(¶ms[2]);
2306 raw_info->z_range = params[4];
2307 raw_info->area_range = params[5];
2308 raw_info->maxcontacts = params[7];
2309 raw_info->origin = params[8];
2310 /* res is given in unit per inch */
2311 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51;
2316 static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
2317 u8 feature_index, bool send_raw_reports,
2318 bool sensor_enhanced_settings)
2320 struct hidpp_report response;
2324 * bit 0 - enable raw
2325 * bit 1 - 16bit Z, no area
2326 * bit 2 - enhanced sensitivity
2327 * bit 3 - width, height (4 bits each) instead of area
2328 * bit 4 - send raw + gestures (degrades smoothness)
2329 * remaining bits - reserved
2331 u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
2333 return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
2334 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response);
2337 static void hidpp_touchpad_touch_event(u8 *data,
2338 struct hidpp_touchpad_raw_xy_finger *finger)
2340 u8 x_m = data[0] << 2;
2341 u8 y_m = data[2] << 2;
2343 finger->x = x_m << 6 | data[1];
2344 finger->y = y_m << 6 | data[3];
2346 finger->contact_type = data[0] >> 6;
2347 finger->contact_status = data[2] >> 6;
2349 finger->z = data[4];
2350 finger->area = data[5];
2351 finger->finger_id = data[6] >> 4;
2354 static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
2355 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
2357 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
2358 raw_xy->end_of_frame = data[8] & 0x01;
2359 raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
2360 raw_xy->finger_count = data[15] & 0x0f;
2361 raw_xy->button = (data[8] >> 2) & 0x01;
2363 if (raw_xy->finger_count) {
2364 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
2365 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
2369 /* -------------------------------------------------------------------------- */
2370 /* 0x8123: Force feedback support */
2371 /* -------------------------------------------------------------------------- */
2373 #define HIDPP_FF_GET_INFO 0x01
2374 #define HIDPP_FF_RESET_ALL 0x11
2375 #define HIDPP_FF_DOWNLOAD_EFFECT 0x21
2376 #define HIDPP_FF_SET_EFFECT_STATE 0x31
2377 #define HIDPP_FF_DESTROY_EFFECT 0x41
2378 #define HIDPP_FF_GET_APERTURE 0x51
2379 #define HIDPP_FF_SET_APERTURE 0x61
2380 #define HIDPP_FF_GET_GLOBAL_GAINS 0x71
2381 #define HIDPP_FF_SET_GLOBAL_GAINS 0x81
2383 #define HIDPP_FF_EFFECT_STATE_GET 0x00
2384 #define HIDPP_FF_EFFECT_STATE_STOP 0x01
2385 #define HIDPP_FF_EFFECT_STATE_PLAY 0x02
2386 #define HIDPP_FF_EFFECT_STATE_PAUSE 0x03
2388 #define HIDPP_FF_EFFECT_CONSTANT 0x00
2389 #define HIDPP_FF_EFFECT_PERIODIC_SINE 0x01
2390 #define HIDPP_FF_EFFECT_PERIODIC_SQUARE 0x02
2391 #define HIDPP_FF_EFFECT_PERIODIC_TRIANGLE 0x03
2392 #define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP 0x04
2393 #define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN 0x05
2394 #define HIDPP_FF_EFFECT_SPRING 0x06
2395 #define HIDPP_FF_EFFECT_DAMPER 0x07
2396 #define HIDPP_FF_EFFECT_FRICTION 0x08
2397 #define HIDPP_FF_EFFECT_INERTIA 0x09
2398 #define HIDPP_FF_EFFECT_RAMP 0x0A
2400 #define HIDPP_FF_EFFECT_AUTOSTART 0x80
2402 #define HIDPP_FF_EFFECTID_NONE -1
2403 #define HIDPP_FF_EFFECTID_AUTOCENTER -2
2404 #define HIDPP_AUTOCENTER_PARAMS_LENGTH 18
2406 #define HIDPP_FF_MAX_PARAMS 20
2407 #define HIDPP_FF_RESERVED_SLOTS 1
2409 struct hidpp_ff_private_data {
2410 struct hidpp_device *hidpp;
2418 struct workqueue_struct *wq;
2419 atomic_t workqueue_size;
2422 struct hidpp_ff_work_data {
2423 struct work_struct work;
2424 struct hidpp_ff_private_data *data;
2427 u8 params[HIDPP_FF_MAX_PARAMS];
2431 static const signed short hidpp_ff_effects[] = {
2446 static const signed short hidpp_ff_effects_v2[] = {
2453 static const u8 HIDPP_FF_CONDITION_CMDS[] = {
2454 HIDPP_FF_EFFECT_SPRING,
2455 HIDPP_FF_EFFECT_FRICTION,
2456 HIDPP_FF_EFFECT_DAMPER,
2457 HIDPP_FF_EFFECT_INERTIA
2460 static const char *HIDPP_FF_CONDITION_NAMES[] = {
2468 static u8 hidpp_ff_find_effect(struct hidpp_ff_private_data *data, int effect_id)
2472 for (i = 0; i < data->num_effects; i++)
2473 if (data->effect_ids[i] == effect_id)
2479 static void hidpp_ff_work_handler(struct work_struct *w)
2481 struct hidpp_ff_work_data *wd = container_of(w, struct hidpp_ff_work_data, work);
2482 struct hidpp_ff_private_data *data = wd->data;
2483 struct hidpp_report response;
2487 /* add slot number if needed */
2488 switch (wd->effect_id) {
2489 case HIDPP_FF_EFFECTID_AUTOCENTER:
2490 wd->params[0] = data->slot_autocenter;
2492 case HIDPP_FF_EFFECTID_NONE:
2493 /* leave slot as zero */
2496 /* find current slot for effect */
2497 wd->params[0] = hidpp_ff_find_effect(data, wd->effect_id);
2501 /* send command and wait for reply */
2502 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
2503 wd->command, wd->params, wd->size, &response);
2506 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
2510 /* parse return data */
2511 switch (wd->command) {
2512 case HIDPP_FF_DOWNLOAD_EFFECT:
2513 slot = response.fap.params[0];
2514 if (slot > 0 && slot <= data->num_effects) {
2515 if (wd->effect_id >= 0)
2516 /* regular effect uploaded */
2517 data->effect_ids[slot-1] = wd->effect_id;
2518 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2519 /* autocenter spring uploaded */
2520 data->slot_autocenter = slot;
2523 case HIDPP_FF_DESTROY_EFFECT:
2524 if (wd->effect_id >= 0)
2525 /* regular effect destroyed */
2526 data->effect_ids[wd->params[0]-1] = -1;
2527 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2528 /* autocenter spring destoyed */
2529 data->slot_autocenter = 0;
2531 case HIDPP_FF_SET_GLOBAL_GAINS:
2532 data->gain = (wd->params[0] << 8) + wd->params[1];
2534 case HIDPP_FF_SET_APERTURE:
2535 data->range = (wd->params[0] << 8) + wd->params[1];
2538 /* no action needed */
2543 atomic_dec(&data->workqueue_size);
2547 static int hidpp_ff_queue_work(struct hidpp_ff_private_data *data, int effect_id, u8 command, u8 *params, u8 size)
2549 struct hidpp_ff_work_data *wd = kzalloc(sizeof(*wd), GFP_KERNEL);
2555 INIT_WORK(&wd->work, hidpp_ff_work_handler);
2558 wd->effect_id = effect_id;
2559 wd->command = command;
2561 memcpy(wd->params, params, size);
2563 s = atomic_inc_return(&data->workqueue_size);
2564 queue_work(data->wq, &wd->work);
2566 /* warn about excessive queue size */
2567 if (s >= 20 && s % 20 == 0)
2568 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2573 static int hidpp_ff_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
2575 struct hidpp_ff_private_data *data = dev->ff->private;
2580 /* set common parameters */
2581 params[2] = effect->replay.length >> 8;
2582 params[3] = effect->replay.length & 255;
2583 params[4] = effect->replay.delay >> 8;
2584 params[5] = effect->replay.delay & 255;
2586 switch (effect->type) {
2588 force = (effect->u.constant.level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2589 params[1] = HIDPP_FF_EFFECT_CONSTANT;
2590 params[6] = force >> 8;
2591 params[7] = force & 255;
2592 params[8] = effect->u.constant.envelope.attack_level >> 7;
2593 params[9] = effect->u.constant.envelope.attack_length >> 8;
2594 params[10] = effect->u.constant.envelope.attack_length & 255;
2595 params[11] = effect->u.constant.envelope.fade_level >> 7;
2596 params[12] = effect->u.constant.envelope.fade_length >> 8;
2597 params[13] = effect->u.constant.envelope.fade_length & 255;
2599 dbg_hid("Uploading constant force level=%d in dir %d = %d\n",
2600 effect->u.constant.level,
2601 effect->direction, force);
2602 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2603 effect->u.constant.envelope.attack_level,
2604 effect->u.constant.envelope.attack_length,
2605 effect->u.constant.envelope.fade_level,
2606 effect->u.constant.envelope.fade_length);
2610 switch (effect->u.periodic.waveform) {
2612 params[1] = HIDPP_FF_EFFECT_PERIODIC_SINE;
2615 params[1] = HIDPP_FF_EFFECT_PERIODIC_SQUARE;
2618 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP;
2621 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN;
2624 params[1] = HIDPP_FF_EFFECT_PERIODIC_TRIANGLE;
2627 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2630 force = (effect->u.periodic.magnitude * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2631 params[6] = effect->u.periodic.magnitude >> 8;
2632 params[7] = effect->u.periodic.magnitude & 255;
2633 params[8] = effect->u.periodic.offset >> 8;
2634 params[9] = effect->u.periodic.offset & 255;
2635 params[10] = effect->u.periodic.period >> 8;
2636 params[11] = effect->u.periodic.period & 255;
2637 params[12] = effect->u.periodic.phase >> 8;
2638 params[13] = effect->u.periodic.phase & 255;
2639 params[14] = effect->u.periodic.envelope.attack_level >> 7;
2640 params[15] = effect->u.periodic.envelope.attack_length >> 8;
2641 params[16] = effect->u.periodic.envelope.attack_length & 255;
2642 params[17] = effect->u.periodic.envelope.fade_level >> 7;
2643 params[18] = effect->u.periodic.envelope.fade_length >> 8;
2644 params[19] = effect->u.periodic.envelope.fade_length & 255;
2646 dbg_hid("Uploading periodic force mag=%d/dir=%d, offset=%d, period=%d ms, phase=%d\n",
2647 effect->u.periodic.magnitude, effect->direction,
2648 effect->u.periodic.offset,
2649 effect->u.periodic.period,
2650 effect->u.periodic.phase);
2651 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2652 effect->u.periodic.envelope.attack_level,
2653 effect->u.periodic.envelope.attack_length,
2654 effect->u.periodic.envelope.fade_level,
2655 effect->u.periodic.envelope.fade_length);
2659 params[1] = HIDPP_FF_EFFECT_RAMP;
2660 force = (effect->u.ramp.start_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2661 params[6] = force >> 8;
2662 params[7] = force & 255;
2663 force = (effect->u.ramp.end_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2664 params[8] = force >> 8;
2665 params[9] = force & 255;
2666 params[10] = effect->u.ramp.envelope.attack_level >> 7;
2667 params[11] = effect->u.ramp.envelope.attack_length >> 8;
2668 params[12] = effect->u.ramp.envelope.attack_length & 255;
2669 params[13] = effect->u.ramp.envelope.fade_level >> 7;
2670 params[14] = effect->u.ramp.envelope.fade_length >> 8;
2671 params[15] = effect->u.ramp.envelope.fade_length & 255;
2673 dbg_hid("Uploading ramp force level=%d -> %d in dir %d = %d\n",
2674 effect->u.ramp.start_level,
2675 effect->u.ramp.end_level,
2676 effect->direction, force);
2677 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2678 effect->u.ramp.envelope.attack_level,
2679 effect->u.ramp.envelope.attack_length,
2680 effect->u.ramp.envelope.fade_level,
2681 effect->u.ramp.envelope.fade_length);
2687 params[1] = HIDPP_FF_CONDITION_CMDS[effect->type - FF_SPRING];
2688 params[6] = effect->u.condition[0].left_saturation >> 9;
2689 params[7] = (effect->u.condition[0].left_saturation >> 1) & 255;
2690 params[8] = effect->u.condition[0].left_coeff >> 8;
2691 params[9] = effect->u.condition[0].left_coeff & 255;
2692 params[10] = effect->u.condition[0].deadband >> 9;
2693 params[11] = (effect->u.condition[0].deadband >> 1) & 255;
2694 params[12] = effect->u.condition[0].center >> 8;
2695 params[13] = effect->u.condition[0].center & 255;
2696 params[14] = effect->u.condition[0].right_coeff >> 8;
2697 params[15] = effect->u.condition[0].right_coeff & 255;
2698 params[16] = effect->u.condition[0].right_saturation >> 9;
2699 params[17] = (effect->u.condition[0].right_saturation >> 1) & 255;
2701 dbg_hid("Uploading %s force left coeff=%d, left sat=%d, right coeff=%d, right sat=%d\n",
2702 HIDPP_FF_CONDITION_NAMES[effect->type - FF_SPRING],
2703 effect->u.condition[0].left_coeff,
2704 effect->u.condition[0].left_saturation,
2705 effect->u.condition[0].right_coeff,
2706 effect->u.condition[0].right_saturation);
2707 dbg_hid(" deadband=%d, center=%d\n",
2708 effect->u.condition[0].deadband,
2709 effect->u.condition[0].center);
2712 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2716 return hidpp_ff_queue_work(data, effect->id, HIDPP_FF_DOWNLOAD_EFFECT, params, size);
2719 static int hidpp_ff_playback(struct input_dev *dev, int effect_id, int value)
2721 struct hidpp_ff_private_data *data = dev->ff->private;
2724 params[1] = value ? HIDPP_FF_EFFECT_STATE_PLAY : HIDPP_FF_EFFECT_STATE_STOP;
2726 dbg_hid("St%sing playback of effect %d.\n", value?"art":"opp", effect_id);
2728 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_SET_EFFECT_STATE, params, ARRAY_SIZE(params));
2731 static int hidpp_ff_erase_effect(struct input_dev *dev, int effect_id)
2733 struct hidpp_ff_private_data *data = dev->ff->private;
2736 dbg_hid("Erasing effect %d.\n", effect_id);
2738 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_DESTROY_EFFECT, &slot, 1);
2741 static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
2743 struct hidpp_ff_private_data *data = dev->ff->private;
2744 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH];
2746 dbg_hid("Setting autocenter to %d.\n", magnitude);
2748 /* start a standard spring effect */
2749 params[1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART;
2750 /* zero delay and duration */
2751 params[2] = params[3] = params[4] = params[5] = 0;
2752 /* set coeff to 25% of saturation */
2753 params[8] = params[14] = magnitude >> 11;
2754 params[9] = params[15] = (magnitude >> 3) & 255;
2755 params[6] = params[16] = magnitude >> 9;
2756 params[7] = params[17] = (magnitude >> 1) & 255;
2757 /* zero deadband and center */
2758 params[10] = params[11] = params[12] = params[13] = 0;
2760 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_AUTOCENTER, HIDPP_FF_DOWNLOAD_EFFECT, params, ARRAY_SIZE(params));
2763 static void hidpp_ff_set_gain(struct input_dev *dev, u16 gain)
2765 struct hidpp_ff_private_data *data = dev->ff->private;
2768 dbg_hid("Setting gain to %d.\n", gain);
2770 params[0] = gain >> 8;
2771 params[1] = gain & 255;
2772 params[2] = 0; /* no boost */
2775 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_NONE, HIDPP_FF_SET_GLOBAL_GAINS, params, ARRAY_SIZE(params));
2778 static ssize_t hidpp_ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
2780 struct hid_device *hid = to_hid_device(dev);
2781 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2782 struct input_dev *idev = hidinput->input;
2783 struct hidpp_ff_private_data *data = idev->ff->private;
2785 return scnprintf(buf, PAGE_SIZE, "%u\n", data->range);
2788 static ssize_t hidpp_ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2790 struct hid_device *hid = to_hid_device(dev);
2791 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2792 struct input_dev *idev = hidinput->input;
2793 struct hidpp_ff_private_data *data = idev->ff->private;
2795 int range = simple_strtoul(buf, NULL, 10);
2797 range = clamp(range, 180, 900);
2799 params[0] = range >> 8;
2800 params[1] = range & 0x00FF;
2802 hidpp_ff_queue_work(data, -1, HIDPP_FF_SET_APERTURE, params, ARRAY_SIZE(params));
2807 static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
2809 static void hidpp_ff_destroy(struct ff_device *ff)
2811 struct hidpp_ff_private_data *data = ff->private;
2812 struct hid_device *hid = data->hidpp->hid_dev;
2814 hid_info(hid, "Unloading HID++ force feedback.\n");
2816 device_remove_file(&hid->dev, &dev_attr_range);
2817 destroy_workqueue(data->wq);
2818 kfree(data->effect_ids);
2821 static int hidpp_ff_init(struct hidpp_device *hidpp,
2822 struct hidpp_ff_private_data *data)
2824 struct hid_device *hid = hidpp->hid_dev;
2825 struct hid_input *hidinput;
2826 struct input_dev *dev;
2827 struct usb_device_descriptor *udesc;
2829 struct ff_device *ff;
2830 int error, j, num_slots = data->num_effects;
2833 if (!hid_is_usb(hid)) {
2834 hid_err(hid, "device is not USB\n");
2838 if (list_empty(&hid->inputs)) {
2839 hid_err(hid, "no inputs found\n");
2842 hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2843 dev = hidinput->input;
2846 hid_err(hid, "Struct input_dev not set!\n");
2850 /* Get firmware release */
2851 udesc = &(hid_to_usb_dev(hid)->descriptor);
2852 bcdDevice = le16_to_cpu(udesc->bcdDevice);
2853 version = bcdDevice & 255;
2855 /* Set supported force feedback capabilities */
2856 for (j = 0; hidpp_ff_effects[j] >= 0; j++)
2857 set_bit(hidpp_ff_effects[j], dev->ffbit);
2859 for (j = 0; hidpp_ff_effects_v2[j] >= 0; j++)
2860 set_bit(hidpp_ff_effects_v2[j], dev->ffbit);
2862 error = input_ff_create(dev, num_slots);
2865 hid_err(dev, "Failed to create FF device!\n");
2869 * Create a copy of passed data, so we can transfer memory
2870 * ownership to FF core
2872 data = kmemdup(data, sizeof(*data), GFP_KERNEL);
2875 data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
2876 if (!data->effect_ids) {
2880 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2882 kfree(data->effect_ids);
2887 data->hidpp = hidpp;
2888 data->version = version;
2889 for (j = 0; j < num_slots; j++)
2890 data->effect_ids[j] = -1;
2895 ff->upload = hidpp_ff_upload_effect;
2896 ff->erase = hidpp_ff_erase_effect;
2897 ff->playback = hidpp_ff_playback;
2898 ff->set_gain = hidpp_ff_set_gain;
2899 ff->set_autocenter = hidpp_ff_set_autocenter;
2900 ff->destroy = hidpp_ff_destroy;
2902 /* Create sysfs interface */
2903 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2905 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2907 /* init the hardware command queue */
2908 atomic_set(&data->workqueue_size, 0);
2910 hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
2916 /* ************************************************************************** */
2918 /* Device Support */
2920 /* ************************************************************************** */
2922 /* -------------------------------------------------------------------------- */
2923 /* Touchpad HID++ devices */
2924 /* -------------------------------------------------------------------------- */
2926 #define WTP_MANUAL_RESOLUTION 39
2931 u8 mt_feature_index;
2932 u8 button_feature_index;
2935 unsigned int resolution;
2938 static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2939 struct hid_field *field, struct hid_usage *usage,
2940 unsigned long **bit, int *max)
2945 static void wtp_populate_input(struct hidpp_device *hidpp,
2946 struct input_dev *input_dev)
2948 struct wtp_data *wd = hidpp->private_data;
2950 __set_bit(EV_ABS, input_dev->evbit);
2951 __set_bit(EV_KEY, input_dev->evbit);
2952 __clear_bit(EV_REL, input_dev->evbit);
2953 __clear_bit(EV_LED, input_dev->evbit);
2955 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
2956 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
2957 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
2958 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
2960 /* Max pressure is not given by the devices, pick one */
2961 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
2963 input_set_capability(input_dev, EV_KEY, BTN_LEFT);
2965 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2966 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
2968 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2970 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
2971 INPUT_MT_DROP_UNUSED);
2974 static void wtp_touch_event(struct hidpp_device *hidpp,
2975 struct hidpp_touchpad_raw_xy_finger *touch_report)
2977 struct wtp_data *wd = hidpp->private_data;
2980 if (!touch_report->finger_id || touch_report->contact_type)
2981 /* no actual data */
2984 slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2986 input_mt_slot(hidpp->input, slot);
2987 input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2988 touch_report->contact_status);
2989 if (touch_report->contact_status) {
2990 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2992 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2993 wd->flip_y ? wd->y_size - touch_report->y :
2995 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2996 touch_report->area);
3000 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
3001 struct hidpp_touchpad_raw_xy *raw)
3005 for (i = 0; i < 2; i++)
3006 wtp_touch_event(hidpp, &(raw->fingers[i]));
3008 if (raw->end_of_frame &&
3009 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
3010 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
3012 if (raw->end_of_frame || raw->finger_count <= 2) {
3013 input_mt_sync_frame(hidpp->input);
3014 input_sync(hidpp->input);
3018 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
3020 struct wtp_data *wd = hidpp->private_data;
3021 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
3022 (data[7] >> 4) * (data[7] >> 4)) / 2;
3023 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
3024 (data[13] >> 4) * (data[13] >> 4)) / 2;
3025 struct hidpp_touchpad_raw_xy raw = {
3026 .timestamp = data[1],
3030 .contact_status = !!data[7],
3031 .x = get_unaligned_le16(&data[3]),
3032 .y = get_unaligned_le16(&data[5]),
3035 .finger_id = data[2],
3038 .contact_status = !!data[13],
3039 .x = get_unaligned_le16(&data[9]),
3040 .y = get_unaligned_le16(&data[11]),
3043 .finger_id = data[8],
3046 .finger_count = wd->maxcontacts,
3048 .end_of_frame = (data[0] >> 7) == 0,
3049 .button = data[0] & 0x01,
3052 wtp_send_raw_xy_event(hidpp, &raw);
3057 static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
3059 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3060 struct wtp_data *wd = hidpp->private_data;
3061 struct hidpp_report *report = (struct hidpp_report *)data;
3062 struct hidpp_touchpad_raw_xy raw;
3064 if (!wd || !hidpp->input)
3070 hid_err(hdev, "Received HID report of bad size (%d)",
3074 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
3075 input_event(hidpp->input, EV_KEY, BTN_LEFT,
3076 !!(data[1] & 0x01));
3077 input_event(hidpp->input, EV_KEY, BTN_RIGHT,
3078 !!(data[1] & 0x02));
3079 input_sync(hidpp->input);
3084 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
3086 case REPORT_ID_HIDPP_LONG:
3087 /* size is already checked in hidpp_raw_event. */
3088 if ((report->fap.feature_index != wd->mt_feature_index) ||
3089 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
3091 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
3093 wtp_send_raw_xy_event(hidpp, &raw);
3100 static int wtp_get_config(struct hidpp_device *hidpp)
3102 struct wtp_data *wd = hidpp->private_data;
3103 struct hidpp_touchpad_raw_info raw_info = {0};
3107 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
3108 &wd->mt_feature_index, &feature_type);
3110 /* means that the device is not powered up */
3113 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
3118 wd->x_size = raw_info.x_size;
3119 wd->y_size = raw_info.y_size;
3120 wd->maxcontacts = raw_info.maxcontacts;
3121 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
3122 wd->resolution = raw_info.res;
3123 if (!wd->resolution)
3124 wd->resolution = WTP_MANUAL_RESOLUTION;
3129 static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
3131 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3132 struct wtp_data *wd;
3134 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
3139 hidpp->private_data = wd;
3144 static int wtp_connect(struct hid_device *hdev, bool connected)
3146 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3147 struct wtp_data *wd = hidpp->private_data;
3151 ret = wtp_get_config(hidpp);
3153 hid_err(hdev, "Can not get wtp config: %d\n", ret);
3158 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
3162 /* ------------------------------------------------------------------------- */
3163 /* Logitech M560 devices */
3164 /* ------------------------------------------------------------------------- */
3167 * Logitech M560 protocol overview
3169 * The Logitech M560 mouse, is designed for windows 8. When the middle and/or
3170 * the sides buttons are pressed, it sends some keyboard keys events
3171 * instead of buttons ones.
3172 * To complicate things further, the middle button keys sequence
3173 * is different from the odd press and the even press.
3175 * forward button -> Super_R
3176 * backward button -> Super_L+'d' (press only)
3177 * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only)
3178 * 2nd time: left-click (press only)
3179 * NB: press-only means that when the button is pressed, the
3180 * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated
3181 * together sequentially; instead when the button is released, no event is
3185 * 10<xx>0a 3500af03 (where <xx> is the mouse id),
3186 * the mouse reacts differently:
3187 * - it never sends a keyboard key event
3188 * - for the three mouse button it sends:
3189 * middle button press 11<xx>0a 3500af00...
3190 * side 1 button (forward) press 11<xx>0a 3500b000...
3191 * side 2 button (backward) press 11<xx>0a 3500ae00...
3192 * middle/side1/side2 button release 11<xx>0a 35000000...
3195 static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
3197 /* how buttons are mapped in the report */
3198 #define M560_MOUSE_BTN_LEFT 0x01
3199 #define M560_MOUSE_BTN_RIGHT 0x02
3200 #define M560_MOUSE_BTN_WHEEL_LEFT 0x08
3201 #define M560_MOUSE_BTN_WHEEL_RIGHT 0x10
3203 #define M560_SUB_ID 0x0a
3204 #define M560_BUTTON_MODE_REGISTER 0x35
3206 static int m560_send_config_command(struct hid_device *hdev, bool connected)
3208 struct hidpp_report response;
3209 struct hidpp_device *hidpp_dev;
3211 hidpp_dev = hid_get_drvdata(hdev);
3213 return hidpp_send_rap_command_sync(
3215 REPORT_ID_HIDPP_SHORT,
3217 M560_BUTTON_MODE_REGISTER,
3218 (u8 *)m560_config_parameter,
3219 sizeof(m560_config_parameter),
3224 static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
3226 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3229 if (!hidpp->input) {
3230 hid_err(hdev, "error in parameter\n");
3235 hid_err(hdev, "error in report\n");
3239 if (data[0] == REPORT_ID_HIDPP_LONG &&
3240 data[2] == M560_SUB_ID && data[6] == 0x00) {
3242 * m560 mouse report for middle, forward and backward button
3245 * data[1] = device-id
3247 * data[5] = 0xaf -> middle
3250 * 0x00 -> release all
3256 input_report_key(hidpp->input, BTN_MIDDLE, 1);
3259 input_report_key(hidpp->input, BTN_FORWARD, 1);
3262 input_report_key(hidpp->input, BTN_BACK, 1);
3265 input_report_key(hidpp->input, BTN_BACK, 0);
3266 input_report_key(hidpp->input, BTN_FORWARD, 0);
3267 input_report_key(hidpp->input, BTN_MIDDLE, 0);
3270 hid_err(hdev, "error in report\n");
3273 input_sync(hidpp->input);
3275 } else if (data[0] == 0x02) {
3277 * Logitech M560 mouse report
3279 * data[0] = type (0x02)
3280 * data[1..2] = buttons
3287 input_report_key(hidpp->input, BTN_LEFT,
3288 !!(data[1] & M560_MOUSE_BTN_LEFT));
3289 input_report_key(hidpp->input, BTN_RIGHT,
3290 !!(data[1] & M560_MOUSE_BTN_RIGHT));
3292 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
3293 input_report_rel(hidpp->input, REL_HWHEEL, -1);
3294 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3296 } else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
3297 input_report_rel(hidpp->input, REL_HWHEEL, 1);
3298 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3302 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
3303 input_report_rel(hidpp->input, REL_X, v);
3305 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
3306 input_report_rel(hidpp->input, REL_Y, v);
3308 v = hid_snto32(data[6], 8);
3310 hidpp_scroll_counter_handle_scroll(hidpp->input,
3311 &hidpp->vertical_wheel_counter, v);
3313 input_sync(hidpp->input);
3319 static void m560_populate_input(struct hidpp_device *hidpp,
3320 struct input_dev *input_dev)
3322 __set_bit(EV_KEY, input_dev->evbit);
3323 __set_bit(BTN_MIDDLE, input_dev->keybit);
3324 __set_bit(BTN_RIGHT, input_dev->keybit);
3325 __set_bit(BTN_LEFT, input_dev->keybit);
3326 __set_bit(BTN_BACK, input_dev->keybit);
3327 __set_bit(BTN_FORWARD, input_dev->keybit);
3329 __set_bit(EV_REL, input_dev->evbit);
3330 __set_bit(REL_X, input_dev->relbit);
3331 __set_bit(REL_Y, input_dev->relbit);
3332 __set_bit(REL_WHEEL, input_dev->relbit);
3333 __set_bit(REL_HWHEEL, input_dev->relbit);
3334 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3335 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3338 static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3339 struct hid_field *field, struct hid_usage *usage,
3340 unsigned long **bit, int *max)
3345 /* ------------------------------------------------------------------------- */
3346 /* Logitech K400 devices */
3347 /* ------------------------------------------------------------------------- */
3350 * The Logitech K400 keyboard has an embedded touchpad which is seen
3351 * as a mouse from the OS point of view. There is a hardware shortcut to disable
3352 * tap-to-click but the setting is not remembered accross reset, annoying some
3355 * We can toggle this feature from the host by using the feature 0x6010:
3359 struct k400_private_data {
3363 static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
3365 struct k400_private_data *k400 = hidpp->private_data;
3366 struct hidpp_touchpad_fw_items items = {};
3370 if (!k400->feature_index) {
3371 ret = hidpp_root_get_feature(hidpp,
3372 HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
3373 &k400->feature_index, &feature_type);
3375 /* means that the device is not powered up */
3379 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
3386 static int k400_allocate(struct hid_device *hdev)
3388 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3389 struct k400_private_data *k400;
3391 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
3396 hidpp->private_data = k400;
3401 static int k400_connect(struct hid_device *hdev, bool connected)
3403 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3405 if (!disable_tap_to_click)
3408 return k400_disable_tap_to_click(hidpp);
3411 /* ------------------------------------------------------------------------- */
3412 /* Logitech G920 Driving Force Racing Wheel for Xbox One */
3413 /* ------------------------------------------------------------------------- */
3415 #define HIDPP_PAGE_G920_FORCE_FEEDBACK 0x8123
3417 static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
3418 struct hidpp_ff_private_data *data)
3420 struct hidpp_report response;
3421 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH] = {
3422 [1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART,
3426 /* initialize with zero autocenter to get wheel in usable state */
3428 dbg_hid("Setting autocenter to 0.\n");
3429 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3430 HIDPP_FF_DOWNLOAD_EFFECT,
3431 params, ARRAY_SIZE(params),
3434 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
3436 data->slot_autocenter = response.fap.params[0];
3441 static int g920_get_config(struct hidpp_device *hidpp,
3442 struct hidpp_ff_private_data *data)
3444 struct hidpp_report response;
3448 memset(data, 0, sizeof(*data));
3450 /* Find feature and store for later use */
3451 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
3452 &data->feature_index, &feature_type);
3456 /* Read number of slots available in device */
3457 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3464 hid_err(hidpp->hid_dev,
3465 "%s: received protocol error 0x%02x\n", __func__, ret);
3469 data->num_effects = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
3471 /* reset all forces */
3472 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3477 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
3479 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3480 HIDPP_FF_GET_APERTURE,
3484 hid_warn(hidpp->hid_dev,
3485 "Failed to read range from device!\n");
3488 900 : get_unaligned_be16(&response.fap.params[0]);
3490 /* Read the current gain values */
3491 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3492 HIDPP_FF_GET_GLOBAL_GAINS,
3496 hid_warn(hidpp->hid_dev,
3497 "Failed to read gain values from device!\n");
3499 0xffff : get_unaligned_be16(&response.fap.params[0]);
3501 /* ignore boost value at response.fap.params[2] */
3503 return g920_ff_set_autocenter(hidpp, data);
3506 /* -------------------------------------------------------------------------- */
3507 /* Logitech Dinovo Mini keyboard with builtin touchpad */
3508 /* -------------------------------------------------------------------------- */
3509 #define DINOVO_MINI_PRODUCT_ID 0xb30c
3511 static int lg_dinovo_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3512 struct hid_field *field, struct hid_usage *usage,
3513 unsigned long **bit, int *max)
3515 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
3518 switch (usage->hid & HID_USAGE) {
3519 case 0x00d: lg_map_key_clear(KEY_MEDIA); break;
3526 /* -------------------------------------------------------------------------- */
3527 /* HID++1.0 devices which use HID++ reports for their wheels */
3528 /* -------------------------------------------------------------------------- */
3529 static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
3531 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3532 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT,
3533 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT);
3536 static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
3547 if (data[0] != REPORT_ID_HIDPP_SHORT || data[2] != HIDPP_SUB_ID_ROLLER)
3553 input_report_rel(hidpp->input, REL_WHEEL, value);
3554 input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
3555 input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
3556 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
3557 input_sync(hidpp->input);
3562 static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
3563 struct input_dev *input_dev)
3565 __set_bit(EV_REL, input_dev->evbit);
3566 __set_bit(REL_WHEEL, input_dev->relbit);
3567 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3568 __set_bit(REL_HWHEEL, input_dev->relbit);
3569 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3572 /* -------------------------------------------------------------------------- */
3573 /* HID++1.0 mice which use HID++ reports for extra mouse buttons */
3574 /* -------------------------------------------------------------------------- */
3575 static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3577 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3578 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
3579 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
3582 static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3593 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3594 data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
3598 * Buttons are either delivered through the regular mouse report *or*
3599 * through the extra buttons report. At least for button 6 how it is
3600 * delivered differs per receiver firmware version. Even receivers with
3601 * the same usb-id show different behavior, so we handle both cases.
3603 for (i = 0; i < 8; i++)
3604 input_report_key(hidpp->input, BTN_MOUSE + i,
3605 (data[3] & (1 << i)));
3607 /* Some mice report events on button 9+, use BTN_MISC */
3608 for (i = 0; i < 8; i++)
3609 input_report_key(hidpp->input, BTN_MISC + i,
3610 (data[4] & (1 << i)));
3612 input_sync(hidpp->input);
3616 static void hidpp10_extra_mouse_buttons_populate_input(
3617 struct hidpp_device *hidpp, struct input_dev *input_dev)
3619 /* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
3620 __set_bit(BTN_0, input_dev->keybit);
3621 __set_bit(BTN_1, input_dev->keybit);
3622 __set_bit(BTN_2, input_dev->keybit);
3623 __set_bit(BTN_3, input_dev->keybit);
3624 __set_bit(BTN_4, input_dev->keybit);
3625 __set_bit(BTN_5, input_dev->keybit);
3626 __set_bit(BTN_6, input_dev->keybit);
3627 __set_bit(BTN_7, input_dev->keybit);
3630 /* -------------------------------------------------------------------------- */
3631 /* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
3632 /* -------------------------------------------------------------------------- */
3634 /* Find the consumer-page input report desc and change Maximums to 0x107f */
3635 static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3636 u8 *_rdesc, unsigned int *rsize)
3638 /* Note 0 terminated so we can use strnstr to search for this. */
3639 static const char consumer_rdesc_start[] = {
3640 0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
3641 0x09, 0x01, /* USAGE (Consumer Control) */
3642 0xA1, 0x01, /* COLLECTION (Application) */
3643 0x85, 0x03, /* REPORT_ID = 3 */
3644 0x75, 0x10, /* REPORT_SIZE (16) */
3645 0x95, 0x02, /* REPORT_COUNT (2) */
3646 0x15, 0x01, /* LOGICAL_MIN (1) */
3647 0x26, 0x00 /* LOGICAL_MAX (... */
3649 char *consumer_rdesc, *rdesc = (char *)_rdesc;
3652 consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
3653 size = *rsize - (consumer_rdesc - rdesc);
3654 if (consumer_rdesc && size >= 25) {
3655 consumer_rdesc[15] = 0x7f;
3656 consumer_rdesc[16] = 0x10;
3657 consumer_rdesc[20] = 0x7f;
3658 consumer_rdesc[21] = 0x10;
3663 static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3665 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3666 HIDPP_ENABLE_CONSUMER_REPORT,
3667 HIDPP_ENABLE_CONSUMER_REPORT);
3670 static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3673 u8 consumer_report[5];
3678 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3679 data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
3683 * Build a normal consumer report (3) out of the data, this detour
3684 * is necessary to get some keyboards to report their 0x10xx usages.
3686 consumer_report[0] = 0x03;
3687 memcpy(&consumer_report[1], &data[3], 4);
3688 /* We are called from atomic context */
3689 hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3690 consumer_report, 5, 1);
3695 /* -------------------------------------------------------------------------- */
3696 /* High-resolution scroll wheels */
3697 /* -------------------------------------------------------------------------- */
3699 static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3704 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL) {
3705 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3707 ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3708 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL) {
3709 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3711 } else /* if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL) */ {
3712 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3716 hid_dbg(hidpp->hid_dev,
3717 "Could not enable hi-res scrolling: %d\n", ret);
3721 if (multiplier == 0) {
3722 hid_dbg(hidpp->hid_dev,
3723 "Invalid multiplier 0 from device, setting it to 1\n");
3727 hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3728 hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3732 static int hidpp_initialize_hires_scroll(struct hidpp_device *hidpp)
3735 unsigned long capabilities;
3737 capabilities = hidpp->capabilities;
3739 if (hidpp->protocol_major >= 2) {
3743 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
3744 &feature_index, &feature_type);
3746 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL;
3747 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scroll wheel\n");
3750 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
3751 &feature_index, &feature_type);
3753 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL;
3754 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scrolling\n");
3757 /* We cannot detect fast scrolling support on HID++ 1.0 devices */
3758 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) {
3759 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL;
3760 hid_dbg(hidpp->hid_dev, "Detected HID++ 1.0 fast scroll\n");
3764 if (hidpp->capabilities == capabilities)
3765 hid_dbg(hidpp->hid_dev, "Did not detect HID++ hi-res scrolling hardware support\n");
3769 /* -------------------------------------------------------------------------- */
3770 /* Generic HID++ devices */
3771 /* -------------------------------------------------------------------------- */
3773 static u8 *hidpp_report_fixup(struct hid_device *hdev, u8 *rdesc,
3774 unsigned int *rsize)
3776 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3781 /* For 27 MHz keyboards the quirk gets set after hid_parse. */
3782 if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE ||
3783 (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3784 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3789 static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3790 struct hid_field *field, struct hid_usage *usage,
3791 unsigned long **bit, int *max)
3793 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3798 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3799 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
3800 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3801 field->application != HID_GD_MOUSE)
3802 return m560_input_mapping(hdev, hi, field, usage, bit, max);
3804 if (hdev->product == DINOVO_MINI_PRODUCT_ID)
3805 return lg_dinovo_input_mapping(hdev, hi, field, usage, bit, max);
3810 static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
3811 struct hid_field *field, struct hid_usage *usage,
3812 unsigned long **bit, int *max)
3814 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3819 /* Ensure that Logitech G920 is not given a default fuzz/flat value */
3820 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3821 if (usage->type == EV_ABS && (usage->code == ABS_X ||
3822 usage->code == ABS_Y || usage->code == ABS_Z ||
3823 usage->code == ABS_RZ)) {
3824 field->application = HID_GD_MULTIAXIS;
3832 static void hidpp_populate_input(struct hidpp_device *hidpp,
3833 struct input_dev *input)
3835 hidpp->input = input;
3837 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3838 wtp_populate_input(hidpp, input);
3839 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3840 m560_populate_input(hidpp, input);
3842 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3843 hidpp10_wheel_populate_input(hidpp, input);
3845 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3846 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3849 static int hidpp_input_configured(struct hid_device *hdev,
3850 struct hid_input *hidinput)
3852 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3853 struct input_dev *input = hidinput->input;
3858 hidpp_populate_input(hidpp, input);
3863 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3866 struct hidpp_report *question = hidpp->send_receive_buf;
3867 struct hidpp_report *answer = hidpp->send_receive_buf;
3868 struct hidpp_report *report = (struct hidpp_report *)data;
3872 * If the mutex is locked then we have a pending answer from a
3873 * previously sent command.
3875 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3877 * Check for a correct hidpp20 answer or the corresponding
3880 if (hidpp_match_answer(question, report) ||
3881 hidpp_match_error(question, report)) {
3883 hidpp->answer_available = true;
3884 wake_up(&hidpp->wait);
3886 * This was an answer to a command that this driver sent
3887 * We return 1 to hid-core to avoid forwarding the
3888 * command upstream as it has been treated by the driver
3895 if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3896 atomic_set(&hidpp->connected,
3897 !(report->rap.params[0] & (1 << 6)));
3898 if (schedule_work(&hidpp->work) == 0)
3899 dbg_hid("%s: connect event already queued\n", __func__);
3903 if (hidpp->hid_dev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3904 data[0] == REPORT_ID_HIDPP_SHORT &&
3905 data[2] == HIDPP_SUB_ID_USER_IFACE_EVENT &&
3906 (data[3] & HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST)) {
3907 dev_err_ratelimited(&hidpp->hid_dev->dev,
3908 "Error the keyboard's wireless encryption key has been lost, your keyboard will not work unless you re-configure encryption.\n");
3909 dev_err_ratelimited(&hidpp->hid_dev->dev,
3910 "See: https://gitlab.freedesktop.org/jwrdegoede/logitech-27mhz-keyboard-encryption-setup/\n");
3913 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3914 ret = hidpp20_battery_event_1000(hidpp, data, size);
3917 ret = hidpp20_battery_event_1004(hidpp, data, size);
3920 ret = hidpp_solar_battery_event(hidpp, data, size);
3923 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3926 ret = hidpp20_adc_measurement_event_1f20(hidpp, data, size);
3931 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3932 ret = hidpp10_battery_event(hidpp, data, size);
3937 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3938 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3943 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3944 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3949 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3950 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3958 static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
3961 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3967 /* Generic HID++ processing. */
3969 case REPORT_ID_HIDPP_VERY_LONG:
3970 if (size != hidpp->very_long_report_length) {
3971 hid_err(hdev, "received hid++ report of bad size (%d)",
3975 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3977 case REPORT_ID_HIDPP_LONG:
3978 if (size != HIDPP_REPORT_LONG_LENGTH) {
3979 hid_err(hdev, "received hid++ report of bad size (%d)",
3983 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3985 case REPORT_ID_HIDPP_SHORT:
3986 if (size != HIDPP_REPORT_SHORT_LENGTH) {
3987 hid_err(hdev, "received hid++ report of bad size (%d)",
3991 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3995 /* If no report is available for further processing, skip calling
3996 * raw_event of subclasses. */
4000 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
4001 return wtp_raw_event(hdev, data, size);
4002 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
4003 return m560_raw_event(hdev, data, size);
4008 static int hidpp_event(struct hid_device *hdev, struct hid_field *field,
4009 struct hid_usage *usage, __s32 value)
4011 /* This function will only be called for scroll events, due to the
4012 * restriction imposed in hidpp_usages.
4014 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4015 struct hidpp_scroll_counter *counter;
4020 counter = &hidpp->vertical_wheel_counter;
4021 /* A scroll event may occur before the multiplier has been retrieved or
4022 * the input device set, or high-res scroll enabling may fail. In such
4023 * cases we must return early (falling back to default behaviour) to
4024 * avoid a crash in hidpp_scroll_counter_handle_scroll.
4026 if (!(hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4027 || value == 0 || hidpp->input == NULL
4028 || counter->wheel_multiplier == 0)
4031 hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
4035 static int hidpp_initialize_battery(struct hidpp_device *hidpp)
4037 static atomic_t battery_no = ATOMIC_INIT(0);
4038 struct power_supply_config cfg = { .drv_data = hidpp };
4039 struct power_supply_desc *desc = &hidpp->battery.desc;
4040 enum power_supply_property *battery_props;
4041 struct hidpp_battery *battery;
4042 unsigned int num_battery_props;
4046 if (hidpp->battery.ps)
4049 hidpp->battery.feature_index = 0xff;
4050 hidpp->battery.solar_feature_index = 0xff;
4051 hidpp->battery.voltage_feature_index = 0xff;
4052 hidpp->battery.adc_measurement_feature_index = 0xff;
4054 if (hidpp->protocol_major >= 2) {
4055 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
4056 ret = hidpp_solar_request_battery_event(hidpp);
4058 /* we only support one battery feature right now, so let's
4059 first check the ones that support battery level first
4060 and leave voltage for last */
4061 ret = hidpp20_query_battery_info_1000(hidpp);
4063 ret = hidpp20_query_battery_info_1004(hidpp);
4065 ret = hidpp20_query_battery_voltage_info(hidpp);
4067 ret = hidpp20_query_adc_measurement_info_1f20(hidpp);
4072 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
4074 ret = hidpp10_query_battery_status(hidpp);
4076 ret = hidpp10_query_battery_mileage(hidpp);
4079 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
4081 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
4083 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
4086 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
4087 hidpp_battery_props,
4088 sizeof(hidpp_battery_props),
4093 num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 3;
4095 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE ||
4096 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE ||
4097 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4098 hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4099 battery_props[num_battery_props++] =
4100 POWER_SUPPLY_PROP_CAPACITY;
4102 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
4103 battery_props[num_battery_props++] =
4104 POWER_SUPPLY_PROP_CAPACITY_LEVEL;
4106 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4107 hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4108 battery_props[num_battery_props++] =
4109 POWER_SUPPLY_PROP_VOLTAGE_NOW;
4111 battery = &hidpp->battery;
4113 n = atomic_inc_return(&battery_no) - 1;
4114 desc->properties = battery_props;
4115 desc->num_properties = num_battery_props;
4116 desc->get_property = hidpp_battery_get_property;
4117 sprintf(battery->name, "hidpp_battery_%ld", n);
4118 desc->name = battery->name;
4119 desc->type = POWER_SUPPLY_TYPE_BATTERY;
4120 desc->use_for_apm = 0;
4122 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
4125 if (IS_ERR(battery->ps))
4126 return PTR_ERR(battery->ps);
4128 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
4133 static void hidpp_overwrite_name(struct hid_device *hdev)
4135 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4138 if (hidpp->protocol_major < 2)
4141 name = hidpp_get_device_name(hidpp);
4144 hid_err(hdev, "unable to retrieve the name of the device");
4146 dbg_hid("HID++: Got name: %s\n", name);
4147 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
4153 static int hidpp_input_open(struct input_dev *dev)
4155 struct hid_device *hid = input_get_drvdata(dev);
4157 return hid_hw_open(hid);
4160 static void hidpp_input_close(struct input_dev *dev)
4162 struct hid_device *hid = input_get_drvdata(dev);
4167 static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
4169 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
4170 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4175 input_set_drvdata(input_dev, hdev);
4176 input_dev->open = hidpp_input_open;
4177 input_dev->close = hidpp_input_close;
4179 input_dev->name = hidpp->name;
4180 input_dev->phys = hdev->phys;
4181 input_dev->uniq = hdev->uniq;
4182 input_dev->id.bustype = hdev->bus;
4183 input_dev->id.vendor = hdev->vendor;
4184 input_dev->id.product = hdev->product;
4185 input_dev->id.version = hdev->version;
4186 input_dev->dev.parent = &hdev->dev;
4191 static void hidpp_connect_event(struct hidpp_device *hidpp)
4193 struct hid_device *hdev = hidpp->hid_dev;
4195 bool connected = atomic_read(&hidpp->connected);
4196 struct input_dev *input;
4197 char *name, *devm_name;
4200 if (hidpp->battery.ps) {
4201 hidpp->battery.online = false;
4202 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
4203 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
4204 power_supply_changed(hidpp->battery.ps);
4209 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4210 ret = wtp_connect(hdev, connected);
4213 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
4214 ret = m560_send_config_command(hdev, connected);
4217 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4218 ret = k400_connect(hdev, connected);
4223 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
4224 ret = hidpp10_wheel_connect(hidpp);
4229 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
4230 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
4235 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
4236 ret = hidpp10_consumer_keys_connect(hidpp);
4241 /* the device is already connected, we can ask for its name and
4243 if (!hidpp->protocol_major) {
4244 ret = hidpp_root_get_protocol_version(hidpp);
4246 hid_err(hdev, "Can not get the protocol version.\n");
4251 if (hidpp->protocol_major >= 2) {
4254 if (!hidpp_get_wireless_feature_index(hidpp, &feature_index))
4255 hidpp->wireless_feature_index = feature_index;
4258 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
4259 name = hidpp_get_device_name(hidpp);
4261 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
4267 hidpp->name = devm_name;
4271 hidpp_initialize_battery(hidpp);
4272 if (!hid_is_usb(hidpp->hid_dev))
4273 hidpp_initialize_hires_scroll(hidpp);
4275 /* forward current battery state */
4276 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
4277 hidpp10_enable_battery_reporting(hidpp);
4278 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
4279 hidpp10_query_battery_mileage(hidpp);
4281 hidpp10_query_battery_status(hidpp);
4282 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
4283 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
4284 hidpp20_query_battery_voltage_info(hidpp);
4285 else if (hidpp->capabilities & HIDPP_CAPABILITY_UNIFIED_BATTERY)
4286 hidpp20_query_battery_info_1004(hidpp);
4287 else if (hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4288 hidpp20_query_adc_measurement_info_1f20(hidpp);
4290 hidpp20_query_battery_info_1000(hidpp);
4292 if (hidpp->battery.ps)
4293 power_supply_changed(hidpp->battery.ps);
4295 if (hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4296 hi_res_scroll_enable(hidpp);
4298 if (!(hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) || hidpp->delayed_input)
4299 /* if the input nodes are already created, we can stop now */
4302 input = hidpp_allocate_input(hdev);
4304 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
4308 hidpp_populate_input(hidpp, input);
4310 ret = input_register_device(input);
4312 input_free_device(input);
4316 hidpp->delayed_input = input;
4319 static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
4321 static struct attribute *sysfs_attrs[] = {
4322 &dev_attr_builtin_power_supply.attr,
4326 static const struct attribute_group ps_attribute_group = {
4327 .attrs = sysfs_attrs
4330 static int hidpp_get_report_length(struct hid_device *hdev, int id)
4332 struct hid_report_enum *re;
4333 struct hid_report *report;
4335 re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
4336 report = re->report_id_hash[id];
4340 return report->field[0]->report_count + 1;
4343 static u8 hidpp_validate_device(struct hid_device *hdev)
4345 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4346 int id, report_length;
4347 u8 supported_reports = 0;
4349 id = REPORT_ID_HIDPP_SHORT;
4350 report_length = hidpp_get_report_length(hdev, id);
4351 if (report_length) {
4352 if (report_length < HIDPP_REPORT_SHORT_LENGTH)
4355 supported_reports |= HIDPP_REPORT_SHORT_SUPPORTED;
4358 id = REPORT_ID_HIDPP_LONG;
4359 report_length = hidpp_get_report_length(hdev, id);
4360 if (report_length) {
4361 if (report_length < HIDPP_REPORT_LONG_LENGTH)
4364 supported_reports |= HIDPP_REPORT_LONG_SUPPORTED;
4367 id = REPORT_ID_HIDPP_VERY_LONG;
4368 report_length = hidpp_get_report_length(hdev, id);
4369 if (report_length) {
4370 if (report_length < HIDPP_REPORT_LONG_LENGTH ||
4371 report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
4374 supported_reports |= HIDPP_REPORT_VERY_LONG_SUPPORTED;
4375 hidpp->very_long_report_length = report_length;
4378 return supported_reports;
4381 hid_warn(hdev, "not enough values in hidpp report %d\n", id);
4385 static bool hidpp_application_equals(struct hid_device *hdev,
4386 unsigned int application)
4388 struct list_head *report_list;
4389 struct hid_report *report;
4391 report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
4392 report = list_first_entry_or_null(report_list, struct hid_report, list);
4393 return report && report->application == application;
4396 static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
4398 struct hidpp_device *hidpp;
4401 unsigned int connect_mask = HID_CONNECT_DEFAULT;
4402 struct hidpp_ff_private_data data;
4404 /* report_fixup needs drvdata to be set before we call hid_parse */
4405 hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
4409 hidpp->hid_dev = hdev;
4410 hidpp->name = hdev->name;
4411 hidpp->quirks = id->driver_data;
4412 hid_set_drvdata(hdev, hidpp);
4414 ret = hid_parse(hdev);
4416 hid_err(hdev, "%s:parse failed\n", __func__);
4421 * Make sure the device is HID++ capable, otherwise treat as generic HID
4423 hidpp->supported_reports = hidpp_validate_device(hdev);
4425 if (!hidpp->supported_reports) {
4426 hid_set_drvdata(hdev, NULL);
4427 devm_kfree(&hdev->dev, hidpp);
4428 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
4431 if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
4432 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
4434 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4435 hidpp_application_equals(hdev, HID_GD_MOUSE))
4436 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
4437 HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
4439 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4440 hidpp_application_equals(hdev, HID_GD_KEYBOARD))
4441 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
4443 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4444 ret = wtp_allocate(hdev, id);
4447 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4448 ret = k400_allocate(hdev);
4453 INIT_WORK(&hidpp->work, delayed_work_cb);
4454 mutex_init(&hidpp->send_mutex);
4455 init_waitqueue_head(&hidpp->wait);
4457 /* indicates we are handling the battery properties in the kernel */
4458 ret = sysfs_create_group(&hdev->dev.kobj, &ps_attribute_group);
4460 hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
4464 * First call hid_hw_start(hdev, 0) to allow IO without connecting any
4465 * hid subdrivers (hid-input, hidraw). This allows retrieving the dev's
4466 * name and serial number and store these in hdev->name and hdev->uniq,
4467 * before the hid-input and hidraw drivers expose these to userspace.
4469 ret = hid_hw_start(hdev, 0);
4471 hid_err(hdev, "hw start failed\n");
4472 goto hid_hw_start_fail;
4475 ret = hid_hw_open(hdev);
4477 dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
4479 goto hid_hw_open_fail;
4482 /* Allow incoming packets */
4483 hid_device_io_start(hdev);
4485 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
4486 hidpp_unifying_init(hidpp);
4487 else if (hid_is_usb(hidpp->hid_dev))
4488 hidpp_serial_init(hidpp);
4490 connected = hidpp_root_get_protocol_version(hidpp) == 0;
4491 atomic_set(&hidpp->connected, connected);
4492 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
4495 hid_err(hdev, "Device not connected");
4496 goto hid_hw_init_fail;
4499 hidpp_overwrite_name(hdev);
4502 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
4503 ret = wtp_get_config(hidpp);
4505 goto hid_hw_init_fail;
4506 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
4507 ret = g920_get_config(hidpp, &data);
4509 goto hid_hw_init_fail;
4512 schedule_work(&hidpp->work);
4513 flush_work(&hidpp->work);
4515 if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT)
4516 connect_mask &= ~HID_CONNECT_HIDINPUT;
4518 /* Now export the actual inputs and hidraw nodes to the world */
4519 ret = hid_connect(hdev, connect_mask);
4521 hid_err(hdev, "%s:hid_connect returned error %d\n", __func__, ret);
4522 goto hid_hw_init_fail;
4525 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
4526 ret = hidpp_ff_init(hidpp, &data);
4528 hid_warn(hidpp->hid_dev,
4529 "Unable to initialize force feedback support, errno %d\n",
4534 * This relies on logi_dj_ll_close() being a no-op so that DJ connection
4535 * events will still be received.
4545 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4546 cancel_work_sync(&hidpp->work);
4547 mutex_destroy(&hidpp->send_mutex);
4551 static void hidpp_remove(struct hid_device *hdev)
4553 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4556 return hid_hw_stop(hdev);
4558 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4561 cancel_work_sync(&hidpp->work);
4562 mutex_destroy(&hidpp->send_mutex);
4565 #define LDJ_DEVICE(product) \
4566 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
4567 USB_VENDOR_ID_LOGITECH, (product))
4569 #define L27MHZ_DEVICE(product) \
4570 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
4571 USB_VENDOR_ID_LOGITECH, (product))
4573 static const struct hid_device_id hidpp_devices[] = {
4574 { /* wireless touchpad */
4576 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
4577 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
4578 { /* wireless touchpad T650 */
4580 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
4581 { /* wireless touchpad T651 */
4582 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
4583 USB_DEVICE_ID_LOGITECH_T651),
4584 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
4585 { /* Mouse Logitech Anywhere MX */
4586 LDJ_DEVICE(0x1017), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4587 { /* Mouse logitech M560 */
4589 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 },
4590 { /* Mouse Logitech M705 (firmware RQM17) */
4591 LDJ_DEVICE(0x101b), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4592 { /* Mouse Logitech Performance MX */
4593 LDJ_DEVICE(0x101a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4594 { /* Keyboard logitech K400 */
4596 .driver_data = HIDPP_QUIRK_CLASS_K400 },
4597 { /* Solar Keyboard Logitech K750 */
4599 .driver_data = HIDPP_QUIRK_CLASS_K750 },
4600 { /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
4602 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4603 { /* Dinovo Edge (Bluetooth-receiver in HID proxy mode) */
4605 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4606 { /* Keyboard MX5500 (Bluetooth-receiver in HID proxy mode) */
4608 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4610 { LDJ_DEVICE(HID_ANY_ID) },
4612 { /* Keyboard LX501 (Y-RR53) */
4613 L27MHZ_DEVICE(0x0049),
4614 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4615 { /* Keyboard MX3000 (Y-RAM74) */
4616 L27MHZ_DEVICE(0x0057),
4617 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4618 { /* Keyboard MX3200 (Y-RAV80) */
4619 L27MHZ_DEVICE(0x005c),
4620 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4621 { /* S510 Media Remote */
4622 L27MHZ_DEVICE(0x00fe),
4623 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4625 { L27MHZ_DEVICE(HID_ANY_ID) },
4627 { /* Logitech G403 Wireless Gaming Mouse over USB */
4628 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
4629 { /* Logitech G502 Lightspeed Wireless Gaming Mouse over USB */
4630 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC08D) },
4631 { /* Logitech G703 Gaming Mouse over USB */
4632 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC087) },
4633 { /* Logitech G703 Hero Gaming Mouse over USB */
4634 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC090) },
4635 { /* Logitech G900 Gaming Mouse over USB */
4636 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
4637 { /* Logitech G903 Gaming Mouse over USB */
4638 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC086) },
4639 { /* Logitech G903 Hero Gaming Mouse over USB */
4640 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC091) },
4641 { /* Logitech G915 TKL Keyboard over USB */
4642 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC343) },
4643 { /* Logitech G920 Wheel over USB */
4644 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
4645 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
4646 { /* Logitech G923 Wheel (Xbox version) over USB */
4647 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G923_XBOX_WHEEL),
4648 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS },
4649 { /* Logitech G Pro Gaming Mouse over USB */
4650 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC088) },
4651 { /* Logitech G Pro X Superlight Gaming Mouse over USB */
4652 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC094) },
4654 { /* G935 Gaming Headset */
4655 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0x0a87),
4656 .driver_data = HIDPP_QUIRK_WIRELESS_STATUS },
4658 { /* MX5000 keyboard over Bluetooth */
4659 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
4660 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4661 { /* Dinovo Edge keyboard over Bluetooth */
4662 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb309),
4663 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4664 { /* MX5500 keyboard over Bluetooth */
4665 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
4666 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4667 { /* Logitech G915 TKL keyboard over Bluetooth */
4668 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb35f) },
4669 { /* M-RCQ142 V470 Cordless Laser Mouse over Bluetooth */
4670 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb008) },
4671 { /* MX Master mouse over Bluetooth */
4672 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012) },
4673 { /* M720 Triathlon mouse over Bluetooth */
4674 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb015) },
4675 { /* MX Ergo trackball over Bluetooth */
4676 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
4677 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e) },
4678 { /* Signature M650 over Bluetooth */
4679 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb02a) },
4680 { /* MX Master 3 mouse over Bluetooth */
4681 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023) },
4682 { /* MX Anywhere 3 mouse over Bluetooth */
4683 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb025) },
4684 { /* MX Master 3S mouse over Bluetooth */
4685 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb034) },
4689 MODULE_DEVICE_TABLE(hid, hidpp_devices);
4691 static const struct hid_usage_id hidpp_usages[] = {
4692 { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
4693 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
4696 static struct hid_driver hidpp_driver = {
4697 .name = "logitech-hidpp-device",
4698 .id_table = hidpp_devices,
4699 .report_fixup = hidpp_report_fixup,
4700 .probe = hidpp_probe,
4701 .remove = hidpp_remove,
4702 .raw_event = hidpp_raw_event,
4703 .usage_table = hidpp_usages,
4704 .event = hidpp_event,
4705 .input_configured = hidpp_input_configured,
4706 .input_mapping = hidpp_input_mapping,
4707 .input_mapped = hidpp_input_mapped,
4710 module_hid_driver(hidpp_driver);