2 * HIDPP protocol for Logitech Unifying receivers
4 * Copyright (c) 2011 Logitech (c)
5 * Copyright (c) 2012-2013 Google (c)
6 * Copyright (c) 2013-2014 Red Hat Inc.
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; version 2 of the License.
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/device.h>
18 #include <linux/hid.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/sched.h>
22 #include <linux/kfifo.h>
23 #include <linux/input/mt.h>
24 #include <asm/unaligned.h>
27 MODULE_LICENSE("GPL");
28 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
29 MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
31 static bool disable_raw_mode;
32 module_param(disable_raw_mode, bool, 0644);
33 MODULE_PARM_DESC(disable_raw_mode,
34 "Disable Raw mode reporting for touchpads and keep firmware gestures.");
36 static bool disable_tap_to_click;
37 module_param(disable_tap_to_click, bool, 0644);
38 MODULE_PARM_DESC(disable_tap_to_click,
39 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
41 #define REPORT_ID_HIDPP_SHORT 0x10
42 #define REPORT_ID_HIDPP_LONG 0x11
44 #define HIDPP_REPORT_SHORT_LENGTH 7
45 #define HIDPP_REPORT_LONG_LENGTH 20
47 #define HIDPP_QUIRK_CLASS_WTP BIT(0)
48 #define HIDPP_QUIRK_CLASS_M560 BIT(1)
49 #define HIDPP_QUIRK_CLASS_K400 BIT(2)
51 /* bits 2..20 are reserved for classes */
52 #define HIDPP_QUIRK_CONNECT_EVENTS BIT(21)
53 #define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22)
54 #define HIDPP_QUIRK_NO_HIDINPUT BIT(23)
56 #define HIDPP_QUIRK_DELAYED_INIT (HIDPP_QUIRK_NO_HIDINPUT | \
57 HIDPP_QUIRK_CONNECT_EVENTS)
60 * There are two hidpp protocols in use, the first version hidpp10 is known
61 * as register access protocol or RAP, the second version hidpp20 is known as
62 * feature access protocol or FAP
64 * Most older devices (including the Unifying usb receiver) use the RAP protocol
65 * where as most newer devices use the FAP protocol. Both protocols are
66 * compatible with the underlying transport, which could be usb, Unifiying, or
67 * bluetooth. The message lengths are defined by the hid vendor specific report
68 * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and
69 * the HIDPP_LONG report type (total message length 20 bytes)
71 * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG
72 * messages. The Unifying receiver itself responds to RAP messages (device index
73 * is 0xFF for the receiver), and all messages (short or long) with a device
74 * index between 1 and 6 are passed untouched to the corresponding paired
77 * The paired device can be RAP or FAP, it will receive the message untouched
78 * from the Unifiying receiver.
83 u8 funcindex_clientid;
84 u8 params[HIDPP_REPORT_LONG_LENGTH - 4U];
90 u8 params[HIDPP_REPORT_LONG_LENGTH - 4U];
99 u8 rawbytes[sizeof(struct fap)];
103 struct hidpp_device {
104 struct hid_device *hid_dev;
105 struct mutex send_mutex;
106 void *send_receive_buf;
107 char *name; /* will never be NULL and should not be freed */
108 wait_queue_head_t wait;
109 bool answer_available;
115 struct work_struct work;
116 struct kfifo delayed_work_fifo;
118 struct input_dev *delayed_input;
120 unsigned long quirks;
124 /* HID++ 1.0 error codes */
125 #define HIDPP_ERROR 0x8f
126 #define HIDPP_ERROR_SUCCESS 0x00
127 #define HIDPP_ERROR_INVALID_SUBID 0x01
128 #define HIDPP_ERROR_INVALID_ADRESS 0x02
129 #define HIDPP_ERROR_INVALID_VALUE 0x03
130 #define HIDPP_ERROR_CONNECT_FAIL 0x04
131 #define HIDPP_ERROR_TOO_MANY_DEVICES 0x05
132 #define HIDPP_ERROR_ALREADY_EXISTS 0x06
133 #define HIDPP_ERROR_BUSY 0x07
134 #define HIDPP_ERROR_UNKNOWN_DEVICE 0x08
135 #define HIDPP_ERROR_RESOURCE_ERROR 0x09
136 #define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a
137 #define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b
138 #define HIDPP_ERROR_WRONG_PIN_CODE 0x0c
139 /* HID++ 2.0 error codes */
140 #define HIDPP20_ERROR 0xff
142 static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
144 static int __hidpp_send_report(struct hid_device *hdev,
145 struct hidpp_report *hidpp_report)
147 int fields_count, ret;
149 switch (hidpp_report->report_id) {
150 case REPORT_ID_HIDPP_SHORT:
151 fields_count = HIDPP_REPORT_SHORT_LENGTH;
153 case REPORT_ID_HIDPP_LONG:
154 fields_count = HIDPP_REPORT_LONG_LENGTH;
161 * set the device_index as the receiver, it will be overwritten by
162 * hid_hw_request if needed
164 hidpp_report->device_index = 0xff;
166 ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
167 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
170 return ret == fields_count ? 0 : -1;
174 * hidpp_send_message_sync() returns 0 in case of success, and something else
175 * in case of a failure.
176 * - If ' something else' is positive, that means that an error has been raised
177 * by the protocol itself.
178 * - If ' something else' is negative, that means that we had a classic error
179 * (-ENOMEM, -EPIPE, etc...)
181 static int hidpp_send_message_sync(struct hidpp_device *hidpp,
182 struct hidpp_report *message,
183 struct hidpp_report *response)
187 mutex_lock(&hidpp->send_mutex);
189 hidpp->send_receive_buf = response;
190 hidpp->answer_available = false;
193 * So that we can later validate the answer when it arrives
196 *response = *message;
198 ret = __hidpp_send_report(hidpp->hid_dev, message);
201 dbg_hid("__hidpp_send_report returned err: %d\n", ret);
202 memset(response, 0, sizeof(struct hidpp_report));
206 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
208 dbg_hid("%s:timeout waiting for response\n", __func__);
209 memset(response, 0, sizeof(struct hidpp_report));
213 if (response->report_id == REPORT_ID_HIDPP_SHORT &&
214 response->rap.sub_id == HIDPP_ERROR) {
215 ret = response->rap.params[1];
216 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
220 if (response->report_id == REPORT_ID_HIDPP_LONG &&
221 response->fap.feature_index == HIDPP20_ERROR) {
222 ret = response->fap.params[1];
223 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
228 mutex_unlock(&hidpp->send_mutex);
233 static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
234 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
235 struct hidpp_report *response)
237 struct hidpp_report *message;
240 if (param_count > sizeof(message->fap.params))
243 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
246 message->report_id = REPORT_ID_HIDPP_LONG;
247 message->fap.feature_index = feat_index;
248 message->fap.funcindex_clientid = funcindex_clientid;
249 memcpy(&message->fap.params, params, param_count);
251 ret = hidpp_send_message_sync(hidpp, message, response);
256 static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
257 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
258 struct hidpp_report *response)
260 struct hidpp_report *message;
263 if ((report_id != REPORT_ID_HIDPP_SHORT) &&
264 (report_id != REPORT_ID_HIDPP_LONG))
267 if (param_count > sizeof(message->rap.params))
270 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
273 message->report_id = report_id;
274 message->rap.sub_id = sub_id;
275 message->rap.reg_address = reg_address;
276 memcpy(&message->rap.params, params, param_count);
278 ret = hidpp_send_message_sync(hidpp_dev, message, response);
283 static void delayed_work_cb(struct work_struct *work)
285 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
287 hidpp_connect_event(hidpp);
290 static inline bool hidpp_match_answer(struct hidpp_report *question,
291 struct hidpp_report *answer)
293 return (answer->fap.feature_index == question->fap.feature_index) &&
294 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
297 static inline bool hidpp_match_error(struct hidpp_report *question,
298 struct hidpp_report *answer)
300 return ((answer->rap.sub_id == HIDPP_ERROR) ||
301 (answer->fap.feature_index == HIDPP20_ERROR)) &&
302 (answer->fap.funcindex_clientid == question->fap.feature_index) &&
303 (answer->fap.params[0] == question->fap.funcindex_clientid);
306 static inline bool hidpp_report_is_connect_event(struct hidpp_report *report)
308 return (report->report_id == REPORT_ID_HIDPP_SHORT) &&
309 (report->rap.sub_id == 0x41);
313 * hidpp_prefix_name() prefixes the current given name with "Logitech ".
315 static void hidpp_prefix_name(char **name, int name_length)
317 #define PREFIX_LENGTH 9 /* "Logitech " */
322 if (name_length > PREFIX_LENGTH &&
323 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
324 /* The prefix has is already in the name */
327 new_length = PREFIX_LENGTH + name_length;
328 new_name = kzalloc(new_length, GFP_KERNEL);
332 snprintf(new_name, new_length, "Logitech %s", *name);
339 /* -------------------------------------------------------------------------- */
340 /* HIDP++ 1.0 commands */
341 /* -------------------------------------------------------------------------- */
343 #define HIDPP_SET_REGISTER 0x80
344 #define HIDPP_GET_REGISTER 0x81
345 #define HIDPP_SET_LONG_REGISTER 0x82
346 #define HIDPP_GET_LONG_REGISTER 0x83
348 #define HIDPP_REG_PAIRING_INFORMATION 0xB5
349 #define DEVICE_NAME 0x40
351 static char *hidpp_get_unifying_name(struct hidpp_device *hidpp_dev)
353 struct hidpp_report response;
355 /* hid-logitech-dj is in charge of setting the right device index */
356 u8 params[1] = { DEVICE_NAME };
360 ret = hidpp_send_rap_command_sync(hidpp_dev,
361 REPORT_ID_HIDPP_SHORT,
362 HIDPP_GET_LONG_REGISTER,
363 HIDPP_REG_PAIRING_INFORMATION,
364 params, 1, &response);
368 len = response.rap.params[1];
370 if (2 + len > sizeof(response.rap.params))
373 name = kzalloc(len + 1, GFP_KERNEL);
377 memcpy(name, &response.rap.params[2], len);
379 /* include the terminating '\0' */
380 hidpp_prefix_name(&name, len + 1);
385 /* -------------------------------------------------------------------------- */
387 /* -------------------------------------------------------------------------- */
389 #define HIDPP_PAGE_ROOT 0x0000
390 #define HIDPP_PAGE_ROOT_IDX 0x00
392 #define CMD_ROOT_GET_FEATURE 0x01
393 #define CMD_ROOT_GET_PROTOCOL_VERSION 0x11
395 static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
396 u8 *feature_index, u8 *feature_type)
398 struct hidpp_report response;
400 u8 params[2] = { feature >> 8, feature & 0x00FF };
402 ret = hidpp_send_fap_command_sync(hidpp,
404 CMD_ROOT_GET_FEATURE,
405 params, 2, &response);
409 *feature_index = response.fap.params[0];
410 *feature_type = response.fap.params[1];
415 static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
417 const u8 ping_byte = 0x5a;
418 u8 ping_data[3] = { 0, 0, ping_byte };
419 struct hidpp_report response;
422 ret = hidpp_send_rap_command_sync(hidpp,
423 REPORT_ID_HIDPP_SHORT,
425 CMD_ROOT_GET_PROTOCOL_VERSION,
426 ping_data, sizeof(ping_data), &response);
428 if (ret == HIDPP_ERROR_INVALID_SUBID) {
429 hidpp->protocol_major = 1;
430 hidpp->protocol_minor = 0;
434 /* the device might not be connected */
435 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
439 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
446 if (response.rap.params[2] != ping_byte) {
447 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
448 __func__, response.rap.params[2], ping_byte);
452 hidpp->protocol_major = response.rap.params[0];
453 hidpp->protocol_minor = response.rap.params[1];
458 static bool hidpp_is_connected(struct hidpp_device *hidpp)
462 ret = hidpp_root_get_protocol_version(hidpp);
464 hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
465 hidpp->protocol_major, hidpp->protocol_minor);
469 /* -------------------------------------------------------------------------- */
470 /* 0x0005: GetDeviceNameType */
471 /* -------------------------------------------------------------------------- */
473 #define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005
475 #define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x01
476 #define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x11
477 #define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x21
479 static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
480 u8 feature_index, u8 *nameLength)
482 struct hidpp_report response;
485 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
486 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
489 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
496 *nameLength = response.fap.params[0];
501 static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
502 u8 feature_index, u8 char_index, char *device_name, int len_buf)
504 struct hidpp_report response;
508 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
509 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
513 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
520 if (response.report_id == REPORT_ID_HIDPP_LONG)
521 count = HIDPP_REPORT_LONG_LENGTH - 4;
523 count = HIDPP_REPORT_SHORT_LENGTH - 4;
528 for (i = 0; i < count; i++)
529 device_name[i] = response.fap.params[i];
534 static char *hidpp_get_device_name(struct hidpp_device *hidpp)
543 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
544 &feature_index, &feature_type);
548 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
553 name = kzalloc(__name_length + 1, GFP_KERNEL);
557 while (index < __name_length) {
558 ret = hidpp_devicenametype_get_device_name(hidpp,
559 feature_index, index, name + index,
560 __name_length - index);
568 /* include the terminating '\0' */
569 hidpp_prefix_name(&name, __name_length + 1);
574 /* -------------------------------------------------------------------------- */
575 /* 0x6010: Touchpad FW items */
576 /* -------------------------------------------------------------------------- */
578 #define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010
580 #define CMD_TOUCHPAD_FW_ITEMS_SET 0x10
582 struct hidpp_touchpad_fw_items {
584 uint8_t desired_state;
590 * send a set state command to the device by reading the current items->state
591 * field. items is then filled with the current state.
593 static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
595 struct hidpp_touchpad_fw_items *items)
597 struct hidpp_report response;
599 u8 *params = (u8 *)response.fap.params;
601 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
602 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
605 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
612 items->presence = params[0];
613 items->desired_state = params[1];
614 items->state = params[2];
615 items->persistent = params[3];
620 /* -------------------------------------------------------------------------- */
621 /* 0x6100: TouchPadRawXY */
622 /* -------------------------------------------------------------------------- */
624 #define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100
626 #define CMD_TOUCHPAD_GET_RAW_INFO 0x01
627 #define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x21
629 #define EVENT_TOUCHPAD_RAW_XY 0x00
631 #define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01
632 #define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03
634 struct hidpp_touchpad_raw_info {
645 struct hidpp_touchpad_raw_xy_finger {
655 struct hidpp_touchpad_raw_xy {
657 struct hidpp_touchpad_raw_xy_finger fingers[2];
664 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
665 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
667 struct hidpp_report response;
669 u8 *params = (u8 *)response.fap.params;
671 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
672 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
675 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
682 raw_info->x_size = get_unaligned_be16(¶ms[0]);
683 raw_info->y_size = get_unaligned_be16(¶ms[2]);
684 raw_info->z_range = params[4];
685 raw_info->area_range = params[5];
686 raw_info->maxcontacts = params[7];
687 raw_info->origin = params[8];
688 /* res is given in unit per inch */
689 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51;
694 static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
695 u8 feature_index, bool send_raw_reports,
696 bool sensor_enhanced_settings)
698 struct hidpp_report response;
703 * bit 1 - 16bit Z, no area
704 * bit 2 - enhanced sensitivity
705 * bit 3 - width, height (4 bits each) instead of area
706 * bit 4 - send raw + gestures (degrades smoothness)
707 * remaining bits - reserved
709 u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
711 return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
712 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response);
715 static void hidpp_touchpad_touch_event(u8 *data,
716 struct hidpp_touchpad_raw_xy_finger *finger)
718 u8 x_m = data[0] << 2;
719 u8 y_m = data[2] << 2;
721 finger->x = x_m << 6 | data[1];
722 finger->y = y_m << 6 | data[3];
724 finger->contact_type = data[0] >> 6;
725 finger->contact_status = data[2] >> 6;
728 finger->area = data[5];
729 finger->finger_id = data[6] >> 4;
732 static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
733 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
735 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
736 raw_xy->end_of_frame = data[8] & 0x01;
737 raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
738 raw_xy->finger_count = data[15] & 0x0f;
739 raw_xy->button = (data[8] >> 2) & 0x01;
741 if (raw_xy->finger_count) {
742 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
743 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
747 /* ************************************************************************** */
751 /* ************************************************************************** */
753 /* -------------------------------------------------------------------------- */
754 /* Touchpad HID++ devices */
755 /* -------------------------------------------------------------------------- */
757 #define WTP_MANUAL_RESOLUTION 39
760 struct input_dev *input;
764 u8 button_feature_index;
767 unsigned int resolution;
770 static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
771 struct hid_field *field, struct hid_usage *usage,
772 unsigned long **bit, int *max)
777 static void wtp_populate_input(struct hidpp_device *hidpp,
778 struct input_dev *input_dev, bool origin_is_hid_core)
780 struct wtp_data *wd = hidpp->private_data;
782 __set_bit(EV_ABS, input_dev->evbit);
783 __set_bit(EV_KEY, input_dev->evbit);
784 __clear_bit(EV_REL, input_dev->evbit);
785 __clear_bit(EV_LED, input_dev->evbit);
787 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
788 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
789 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
790 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
792 /* Max pressure is not given by the devices, pick one */
793 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
795 input_set_capability(input_dev, EV_KEY, BTN_LEFT);
797 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
798 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
800 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
802 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
803 INPUT_MT_DROP_UNUSED);
805 wd->input = input_dev;
808 static void wtp_touch_event(struct wtp_data *wd,
809 struct hidpp_touchpad_raw_xy_finger *touch_report)
813 if (!touch_report->finger_id || touch_report->contact_type)
817 slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id);
819 input_mt_slot(wd->input, slot);
820 input_mt_report_slot_state(wd->input, MT_TOOL_FINGER,
821 touch_report->contact_status);
822 if (touch_report->contact_status) {
823 input_event(wd->input, EV_ABS, ABS_MT_POSITION_X,
825 input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y,
826 wd->flip_y ? wd->y_size - touch_report->y :
828 input_event(wd->input, EV_ABS, ABS_MT_PRESSURE,
833 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
834 struct hidpp_touchpad_raw_xy *raw)
836 struct wtp_data *wd = hidpp->private_data;
839 for (i = 0; i < 2; i++)
840 wtp_touch_event(wd, &(raw->fingers[i]));
842 if (raw->end_of_frame &&
843 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
844 input_event(wd->input, EV_KEY, BTN_LEFT, raw->button);
846 if (raw->end_of_frame || raw->finger_count <= 2) {
847 input_mt_sync_frame(wd->input);
848 input_sync(wd->input);
852 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
854 struct wtp_data *wd = hidpp->private_data;
855 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
856 (data[7] >> 4) * (data[7] >> 4)) / 2;
857 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
858 (data[13] >> 4) * (data[13] >> 4)) / 2;
859 struct hidpp_touchpad_raw_xy raw = {
860 .timestamp = data[1],
864 .contact_status = !!data[7],
865 .x = get_unaligned_le16(&data[3]),
866 .y = get_unaligned_le16(&data[5]),
869 .finger_id = data[2],
872 .contact_status = !!data[13],
873 .x = get_unaligned_le16(&data[9]),
874 .y = get_unaligned_le16(&data[11]),
877 .finger_id = data[8],
880 .finger_count = wd->maxcontacts,
882 .end_of_frame = (data[0] >> 7) == 0,
883 .button = data[0] & 0x01,
886 wtp_send_raw_xy_event(hidpp, &raw);
891 static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
893 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
894 struct wtp_data *wd = hidpp->private_data;
895 struct hidpp_report *report = (struct hidpp_report *)data;
896 struct hidpp_touchpad_raw_xy raw;
898 if (!wd || !wd->input)
904 hid_err(hdev, "Received HID report of bad size (%d)",
908 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
909 input_event(wd->input, EV_KEY, BTN_LEFT,
911 input_event(wd->input, EV_KEY, BTN_RIGHT,
913 input_sync(wd->input);
918 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
920 case REPORT_ID_HIDPP_LONG:
921 /* size is already checked in hidpp_raw_event. */
922 if ((report->fap.feature_index != wd->mt_feature_index) ||
923 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
925 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
927 wtp_send_raw_xy_event(hidpp, &raw);
934 static int wtp_get_config(struct hidpp_device *hidpp)
936 struct wtp_data *wd = hidpp->private_data;
937 struct hidpp_touchpad_raw_info raw_info = {0};
941 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
942 &wd->mt_feature_index, &feature_type);
944 /* means that the device is not powered up */
947 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
952 wd->x_size = raw_info.x_size;
953 wd->y_size = raw_info.y_size;
954 wd->maxcontacts = raw_info.maxcontacts;
955 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
956 wd->resolution = raw_info.res;
958 wd->resolution = WTP_MANUAL_RESOLUTION;
963 static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
965 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
968 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
973 hidpp->private_data = wd;
978 static int wtp_connect(struct hid_device *hdev, bool connected)
980 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
981 struct wtp_data *wd = hidpp->private_data;
988 ret = wtp_get_config(hidpp);
990 hid_err(hdev, "Can not get wtp config: %d\n", ret);
995 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
999 /* ------------------------------------------------------------------------- */
1000 /* Logitech M560 devices */
1001 /* ------------------------------------------------------------------------- */
1004 * Logitech M560 protocol overview
1006 * The Logitech M560 mouse, is designed for windows 8. When the middle and/or
1007 * the sides buttons are pressed, it sends some keyboard keys events
1008 * instead of buttons ones.
1009 * To complicate things further, the middle button keys sequence
1010 * is different from the odd press and the even press.
1012 * forward button -> Super_R
1013 * backward button -> Super_L+'d' (press only)
1014 * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only)
1015 * 2nd time: left-click (press only)
1016 * NB: press-only means that when the button is pressed, the
1017 * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated
1018 * together sequentially; instead when the button is released, no event is
1022 * 10<xx>0a 3500af03 (where <xx> is the mouse id),
1023 * the mouse reacts differently:
1024 * - it never sends a keyboard key event
1025 * - for the three mouse button it sends:
1026 * middle button press 11<xx>0a 3500af00...
1027 * side 1 button (forward) press 11<xx>0a 3500b000...
1028 * side 2 button (backward) press 11<xx>0a 3500ae00...
1029 * middle/side1/side2 button release 11<xx>0a 35000000...
1032 static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
1034 struct m560_private_data {
1035 struct input_dev *input;
1038 /* how buttons are mapped in the report */
1039 #define M560_MOUSE_BTN_LEFT 0x01
1040 #define M560_MOUSE_BTN_RIGHT 0x02
1041 #define M560_MOUSE_BTN_WHEEL_LEFT 0x08
1042 #define M560_MOUSE_BTN_WHEEL_RIGHT 0x10
1044 #define M560_SUB_ID 0x0a
1045 #define M560_BUTTON_MODE_REGISTER 0x35
1047 static int m560_send_config_command(struct hid_device *hdev, bool connected)
1049 struct hidpp_report response;
1050 struct hidpp_device *hidpp_dev;
1052 hidpp_dev = hid_get_drvdata(hdev);
1057 return hidpp_send_rap_command_sync(
1059 REPORT_ID_HIDPP_SHORT,
1061 M560_BUTTON_MODE_REGISTER,
1062 (u8 *)m560_config_parameter,
1063 sizeof(m560_config_parameter),
1068 static int m560_allocate(struct hid_device *hdev)
1070 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1071 struct m560_private_data *d;
1073 d = devm_kzalloc(&hdev->dev, sizeof(struct m560_private_data),
1078 hidpp->private_data = d;
1083 static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
1085 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1086 struct m560_private_data *mydata = hidpp->private_data;
1089 if (!mydata || !mydata->input) {
1090 hid_err(hdev, "error in parameter\n");
1095 hid_err(hdev, "error in report\n");
1099 if (data[0] == REPORT_ID_HIDPP_LONG &&
1100 data[2] == M560_SUB_ID && data[6] == 0x00) {
1102 * m560 mouse report for middle, forward and backward button
1105 * data[1] = device-id
1107 * data[5] = 0xaf -> middle
1110 * 0x00 -> release all
1116 input_report_key(mydata->input, BTN_MIDDLE, 1);
1119 input_report_key(mydata->input, BTN_FORWARD, 1);
1122 input_report_key(mydata->input, BTN_BACK, 1);
1125 input_report_key(mydata->input, BTN_BACK, 0);
1126 input_report_key(mydata->input, BTN_FORWARD, 0);
1127 input_report_key(mydata->input, BTN_MIDDLE, 0);
1130 hid_err(hdev, "error in report\n");
1133 input_sync(mydata->input);
1135 } else if (data[0] == 0x02) {
1137 * Logitech M560 mouse report
1139 * data[0] = type (0x02)
1140 * data[1..2] = buttons
1147 input_report_key(mydata->input, BTN_LEFT,
1148 !!(data[1] & M560_MOUSE_BTN_LEFT));
1149 input_report_key(mydata->input, BTN_RIGHT,
1150 !!(data[1] & M560_MOUSE_BTN_RIGHT));
1152 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT)
1153 input_report_rel(mydata->input, REL_HWHEEL, -1);
1154 else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT)
1155 input_report_rel(mydata->input, REL_HWHEEL, 1);
1157 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
1158 input_report_rel(mydata->input, REL_X, v);
1160 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
1161 input_report_rel(mydata->input, REL_Y, v);
1163 v = hid_snto32(data[6], 8);
1164 input_report_rel(mydata->input, REL_WHEEL, v);
1166 input_sync(mydata->input);
1172 static void m560_populate_input(struct hidpp_device *hidpp,
1173 struct input_dev *input_dev, bool origin_is_hid_core)
1175 struct m560_private_data *mydata = hidpp->private_data;
1177 mydata->input = input_dev;
1179 __set_bit(EV_KEY, mydata->input->evbit);
1180 __set_bit(BTN_MIDDLE, mydata->input->keybit);
1181 __set_bit(BTN_RIGHT, mydata->input->keybit);
1182 __set_bit(BTN_LEFT, mydata->input->keybit);
1183 __set_bit(BTN_BACK, mydata->input->keybit);
1184 __set_bit(BTN_FORWARD, mydata->input->keybit);
1186 __set_bit(EV_REL, mydata->input->evbit);
1187 __set_bit(REL_X, mydata->input->relbit);
1188 __set_bit(REL_Y, mydata->input->relbit);
1189 __set_bit(REL_WHEEL, mydata->input->relbit);
1190 __set_bit(REL_HWHEEL, mydata->input->relbit);
1193 static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
1194 struct hid_field *field, struct hid_usage *usage,
1195 unsigned long **bit, int *max)
1200 /* ------------------------------------------------------------------------- */
1201 /* Logitech K400 devices */
1202 /* ------------------------------------------------------------------------- */
1205 * The Logitech K400 keyboard has an embedded touchpad which is seen
1206 * as a mouse from the OS point of view. There is a hardware shortcut to disable
1207 * tap-to-click but the setting is not remembered accross reset, annoying some
1210 * We can toggle this feature from the host by using the feature 0x6010:
1214 struct k400_private_data {
1218 static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
1220 struct k400_private_data *k400 = hidpp->private_data;
1221 struct hidpp_touchpad_fw_items items = {};
1225 if (!k400->feature_index) {
1226 ret = hidpp_root_get_feature(hidpp,
1227 HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
1228 &k400->feature_index, &feature_type);
1230 /* means that the device is not powered up */
1234 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
1241 static int k400_allocate(struct hid_device *hdev)
1243 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1244 struct k400_private_data *k400;
1246 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
1251 hidpp->private_data = k400;
1256 static int k400_connect(struct hid_device *hdev, bool connected)
1258 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1263 if (!disable_tap_to_click)
1266 return k400_disable_tap_to_click(hidpp);
1269 /* -------------------------------------------------------------------------- */
1270 /* Generic HID++ devices */
1271 /* -------------------------------------------------------------------------- */
1273 static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
1274 struct hid_field *field, struct hid_usage *usage,
1275 unsigned long **bit, int *max)
1277 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1279 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
1280 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
1281 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
1282 field->application != HID_GD_MOUSE)
1283 return m560_input_mapping(hdev, hi, field, usage, bit, max);
1288 static void hidpp_populate_input(struct hidpp_device *hidpp,
1289 struct input_dev *input, bool origin_is_hid_core)
1291 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
1292 wtp_populate_input(hidpp, input, origin_is_hid_core);
1293 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
1294 m560_populate_input(hidpp, input, origin_is_hid_core);
1297 static int hidpp_input_configured(struct hid_device *hdev,
1298 struct hid_input *hidinput)
1300 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1301 struct input_dev *input = hidinput->input;
1303 hidpp_populate_input(hidpp, input, true);
1308 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
1311 struct hidpp_report *question = hidpp->send_receive_buf;
1312 struct hidpp_report *answer = hidpp->send_receive_buf;
1313 struct hidpp_report *report = (struct hidpp_report *)data;
1316 * If the mutex is locked then we have a pending answer from a
1317 * previously sent command.
1319 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
1321 * Check for a correct hidpp20 answer or the corresponding
1324 if (hidpp_match_answer(question, report) ||
1325 hidpp_match_error(question, report)) {
1327 hidpp->answer_available = true;
1328 wake_up(&hidpp->wait);
1330 * This was an answer to a command that this driver sent
1331 * We return 1 to hid-core to avoid forwarding the
1332 * command upstream as it has been treated by the driver
1339 if (unlikely(hidpp_report_is_connect_event(report))) {
1340 atomic_set(&hidpp->connected,
1341 !(report->rap.params[0] & (1 << 6)));
1342 if ((hidpp->quirks & HIDPP_QUIRK_CONNECT_EVENTS) &&
1343 (schedule_work(&hidpp->work) == 0))
1344 dbg_hid("%s: connect event already queued\n", __func__);
1351 static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
1354 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1357 /* Generic HID++ processing. */
1359 case REPORT_ID_HIDPP_LONG:
1360 if (size != HIDPP_REPORT_LONG_LENGTH) {
1361 hid_err(hdev, "received hid++ report of bad size (%d)",
1365 ret = hidpp_raw_hidpp_event(hidpp, data, size);
1367 case REPORT_ID_HIDPP_SHORT:
1368 if (size != HIDPP_REPORT_SHORT_LENGTH) {
1369 hid_err(hdev, "received hid++ report of bad size (%d)",
1373 ret = hidpp_raw_hidpp_event(hidpp, data, size);
1377 /* If no report is available for further processing, skip calling
1378 * raw_event of subclasses. */
1382 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
1383 return wtp_raw_event(hdev, data, size);
1384 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
1385 return m560_raw_event(hdev, data, size);
1390 static void hidpp_overwrite_name(struct hid_device *hdev, bool use_unifying)
1392 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1397 * the device is connected through an Unifying receiver, and
1398 * might not be already connected.
1399 * Ask the receiver for its name.
1401 name = hidpp_get_unifying_name(hidpp);
1403 name = hidpp_get_device_name(hidpp);
1406 hid_err(hdev, "unable to retrieve the name of the device");
1408 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
1413 static int hidpp_input_open(struct input_dev *dev)
1415 struct hid_device *hid = input_get_drvdata(dev);
1417 return hid_hw_open(hid);
1420 static void hidpp_input_close(struct input_dev *dev)
1422 struct hid_device *hid = input_get_drvdata(dev);
1427 static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
1429 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
1430 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1435 input_set_drvdata(input_dev, hdev);
1436 input_dev->open = hidpp_input_open;
1437 input_dev->close = hidpp_input_close;
1439 input_dev->name = hidpp->name;
1440 input_dev->phys = hdev->phys;
1441 input_dev->uniq = hdev->uniq;
1442 input_dev->id.bustype = hdev->bus;
1443 input_dev->id.vendor = hdev->vendor;
1444 input_dev->id.product = hdev->product;
1445 input_dev->id.version = hdev->version;
1446 input_dev->dev.parent = &hdev->dev;
1451 static void hidpp_connect_event(struct hidpp_device *hidpp)
1453 struct hid_device *hdev = hidpp->hid_dev;
1455 bool connected = atomic_read(&hidpp->connected);
1456 struct input_dev *input;
1457 char *name, *devm_name;
1459 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
1460 ret = wtp_connect(hdev, connected);
1463 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
1464 ret = m560_send_config_command(hdev, connected);
1467 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
1468 ret = k400_connect(hdev, connected);
1473 if (!connected || hidpp->delayed_input)
1476 /* the device is already connected, we can ask for its name and
1478 if (!hidpp->protocol_major) {
1479 ret = !hidpp_is_connected(hidpp);
1481 hid_err(hdev, "Can not get the protocol version.\n");
1484 hid_info(hdev, "HID++ %u.%u device connected.\n",
1485 hidpp->protocol_major, hidpp->protocol_minor);
1488 if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT))
1489 /* if HID created the input nodes for us, we can stop now */
1492 if (!hidpp->name || hidpp->name == hdev->name) {
1493 name = hidpp_get_device_name(hidpp);
1496 "unable to retrieve the name of the device");
1500 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name);
1505 hidpp->name = devm_name;
1508 input = hidpp_allocate_input(hdev);
1510 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
1514 hidpp_populate_input(hidpp, input, false);
1516 ret = input_register_device(input);
1518 input_free_device(input);
1520 hidpp->delayed_input = input;
1523 static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
1525 struct hidpp_device *hidpp;
1528 unsigned int connect_mask = HID_CONNECT_DEFAULT;
1530 hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device),
1535 hidpp->hid_dev = hdev;
1536 hidpp->name = hdev->name;
1537 hid_set_drvdata(hdev, hidpp);
1539 hidpp->quirks = id->driver_data;
1541 if (disable_raw_mode) {
1542 hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
1543 hidpp->quirks &= ~HIDPP_QUIRK_CONNECT_EVENTS;
1544 hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT;
1547 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
1548 ret = wtp_allocate(hdev, id);
1551 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
1552 ret = m560_allocate(hdev);
1555 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
1556 ret = k400_allocate(hdev);
1561 INIT_WORK(&hidpp->work, delayed_work_cb);
1562 mutex_init(&hidpp->send_mutex);
1563 init_waitqueue_head(&hidpp->wait);
1565 ret = hid_parse(hdev);
1567 hid_err(hdev, "%s:parse failed\n", __func__);
1568 goto hid_parse_fail;
1571 /* Allow incoming packets */
1572 hid_device_io_start(hdev);
1574 connected = hidpp_is_connected(hidpp);
1575 if (id->group != HID_GROUP_LOGITECH_DJ_DEVICE) {
1578 hid_err(hdev, "Device not connected");
1579 hid_device_io_stop(hdev);
1580 goto hid_parse_fail;
1583 hid_info(hdev, "HID++ %u.%u device connected.\n",
1584 hidpp->protocol_major, hidpp->protocol_minor);
1587 hidpp_overwrite_name(hdev, id->group == HID_GROUP_LOGITECH_DJ_DEVICE);
1588 atomic_set(&hidpp->connected, connected);
1590 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
1591 ret = wtp_get_config(hidpp);
1593 goto hid_parse_fail;
1596 /* Block incoming packets */
1597 hid_device_io_stop(hdev);
1599 if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
1600 connect_mask &= ~HID_CONNECT_HIDINPUT;
1602 ret = hid_hw_start(hdev, connect_mask);
1604 hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
1605 goto hid_hw_start_fail;
1608 if (hidpp->quirks & HIDPP_QUIRK_CONNECT_EVENTS) {
1609 /* Allow incoming packets */
1610 hid_device_io_start(hdev);
1612 hidpp_connect_event(hidpp);
1619 cancel_work_sync(&hidpp->work);
1620 mutex_destroy(&hidpp->send_mutex);
1622 hid_set_drvdata(hdev, NULL);
1626 static void hidpp_remove(struct hid_device *hdev)
1628 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
1630 cancel_work_sync(&hidpp->work);
1631 mutex_destroy(&hidpp->send_mutex);
1635 static const struct hid_device_id hidpp_devices[] = {
1636 { /* wireless touchpad */
1637 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
1638 USB_VENDOR_ID_LOGITECH, 0x4011),
1639 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
1640 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
1641 { /* wireless touchpad T650 */
1642 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
1643 USB_VENDOR_ID_LOGITECH, 0x4101),
1644 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
1645 { /* wireless touchpad T651 */
1646 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
1647 USB_DEVICE_ID_LOGITECH_T651),
1648 .driver_data = HIDPP_QUIRK_CLASS_WTP },
1649 { /* Mouse logitech M560 */
1650 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
1651 USB_VENDOR_ID_LOGITECH, 0x402d),
1652 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 },
1653 { /* Keyboard logitech K400 */
1654 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
1655 USB_VENDOR_ID_LOGITECH, 0x4024),
1656 .driver_data = HIDPP_QUIRK_CONNECT_EVENTS | HIDPP_QUIRK_CLASS_K400 },
1658 { HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE,
1659 USB_VENDOR_ID_LOGITECH, HID_ANY_ID)},
1663 MODULE_DEVICE_TABLE(hid, hidpp_devices);
1665 static struct hid_driver hidpp_driver = {
1666 .name = "logitech-hidpp-device",
1667 .id_table = hidpp_devices,
1668 .probe = hidpp_probe,
1669 .remove = hidpp_remove,
1670 .raw_event = hidpp_raw_event,
1671 .input_configured = hidpp_input_configured,
1672 .input_mapping = hidpp_input_mapping,
1675 module_hid_driver(hidpp_driver);