Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * HIDPP protocol for Logitech receivers
4 *
5 * Copyright (c) 2011 Logitech (c)
6 * Copyright (c) 2012-2013 Google (c)
7 * Copyright (c) 2013-2014 Red Hat Inc.
8 */
9
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
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"
28#include "hid-ids.h"
29
30MODULE_LICENSE("GPL");
31MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
32MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
33
34static bool disable_raw_mode;
35module_param(disable_raw_mode, bool, 0644);
36MODULE_PARM_DESC(disable_raw_mode,
37 "Disable Raw mode reporting for touchpads and keep firmware gestures.");
38
39static bool disable_tap_to_click;
40module_param(disable_tap_to_click, bool, 0644);
41MODULE_PARM_DESC(disable_tap_to_click,
42 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
43
44/* Define a non-zero software ID to identify our own requests */
45#define LINUX_KERNEL_SW_ID 0x01
46
47#define REPORT_ID_HIDPP_SHORT 0x10
48#define REPORT_ID_HIDPP_LONG 0x11
49#define REPORT_ID_HIDPP_VERY_LONG 0x12
50
51#define HIDPP_REPORT_SHORT_LENGTH 7
52#define HIDPP_REPORT_LONG_LENGTH 20
53#define HIDPP_REPORT_VERY_LONG_MAX_LENGTH 64
54
55#define HIDPP_REPORT_SHORT_SUPPORTED BIT(0)
56#define HIDPP_REPORT_LONG_SUPPORTED BIT(1)
57#define HIDPP_REPORT_VERY_LONG_SUPPORTED BIT(2)
58
59#define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS 0x03
60#define HIDPP_SUB_ID_ROLLER 0x05
61#define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS 0x06
62#define HIDPP_SUB_ID_USER_IFACE_EVENT 0x08
63#define HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST BIT(5)
64
65#define HIDPP_QUIRK_CLASS_WTP BIT(0)
66#define HIDPP_QUIRK_CLASS_M560 BIT(1)
67#define HIDPP_QUIRK_CLASS_K400 BIT(2)
68#define HIDPP_QUIRK_CLASS_G920 BIT(3)
69#define HIDPP_QUIRK_CLASS_K750 BIT(4)
70
71/* bits 2..20 are reserved for classes */
72/* #define HIDPP_QUIRK_CONNECT_EVENTS BIT(21) disabled */
73#define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22)
74#define HIDPP_QUIRK_NO_HIDINPUT BIT(23)
75#define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS BIT(24)
76#define HIDPP_QUIRK_UNIFYING BIT(25)
77#define HIDPP_QUIRK_HIDPP_WHEELS BIT(26)
78#define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS BIT(27)
79#define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS BIT(28)
80
81/* These are just aliases for now */
82#define HIDPP_QUIRK_KBD_SCROLL_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
83#define HIDPP_QUIRK_KBD_ZOOM_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
84
85/* Convenience constant to check for any high-res support. */
86#define HIDPP_CAPABILITY_HI_RES_SCROLL (HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL | \
87 HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL | \
88 HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL)
89
90#define HIDPP_QUIRK_DELAYED_INIT HIDPP_QUIRK_NO_HIDINPUT
91
92#define HIDPP_CAPABILITY_HIDPP10_BATTERY BIT(0)
93#define HIDPP_CAPABILITY_HIDPP20_BATTERY BIT(1)
94#define HIDPP_CAPABILITY_BATTERY_MILEAGE BIT(2)
95#define HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS BIT(3)
96#define HIDPP_CAPABILITY_BATTERY_VOLTAGE BIT(4)
97#define HIDPP_CAPABILITY_BATTERY_PERCENTAGE BIT(5)
98#define HIDPP_CAPABILITY_UNIFIED_BATTERY BIT(6)
99#define HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL BIT(7)
100#define HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL BIT(8)
101#define HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL BIT(9)
102
103#define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
104
105/*
106 * There are two hidpp protocols in use, the first version hidpp10 is known
107 * as register access protocol or RAP, the second version hidpp20 is known as
108 * feature access protocol or FAP
109 *
110 * Most older devices (including the Unifying usb receiver) use the RAP protocol
111 * where as most newer devices use the FAP protocol. Both protocols are
112 * compatible with the underlying transport, which could be usb, Unifiying, or
113 * bluetooth. The message lengths are defined by the hid vendor specific report
114 * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and
115 * the HIDPP_LONG report type (total message length 20 bytes)
116 *
117 * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG
118 * messages. The Unifying receiver itself responds to RAP messages (device index
119 * is 0xFF for the receiver), and all messages (short or long) with a device
120 * index between 1 and 6 are passed untouched to the corresponding paired
121 * Unifying device.
122 *
123 * The paired device can be RAP or FAP, it will receive the message untouched
124 * from the Unifiying receiver.
125 */
126
127struct fap {
128 u8 feature_index;
129 u8 funcindex_clientid;
130 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
131};
132
133struct rap {
134 u8 sub_id;
135 u8 reg_address;
136 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
137};
138
139struct hidpp_report {
140 u8 report_id;
141 u8 device_index;
142 union {
143 struct fap fap;
144 struct rap rap;
145 u8 rawbytes[sizeof(struct fap)];
146 };
147} __packed;
148
149struct hidpp_battery {
150 u8 feature_index;
151 u8 solar_feature_index;
152 u8 voltage_feature_index;
153 struct power_supply_desc desc;
154 struct power_supply *ps;
155 char name[64];
156 int status;
157 int capacity;
158 int level;
159 int voltage;
160 int charge_type;
161 bool online;
162 u8 supported_levels_1004;
163};
164
165/**
166 * struct hidpp_scroll_counter - Utility class for processing high-resolution
167 * scroll events.
168 * @dev: the input device for which events should be reported.
169 * @wheel_multiplier: the scalar multiplier to be applied to each wheel event
170 * @remainder: counts the number of high-resolution units moved since the last
171 * low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
172 * only be used by class methods.
173 * @direction: direction of last movement (1 or -1)
174 * @last_time: last event time, used to reset remainder after inactivity
175 */
176struct hidpp_scroll_counter {
177 int wheel_multiplier;
178 int remainder;
179 int direction;
180 unsigned long long last_time;
181};
182
183struct hidpp_device {
184 struct hid_device *hid_dev;
185 struct input_dev *input;
186 struct mutex send_mutex;
187 void *send_receive_buf;
188 char *name; /* will never be NULL and should not be freed */
189 wait_queue_head_t wait;
190 int very_long_report_length;
191 bool answer_available;
192 u8 protocol_major;
193 u8 protocol_minor;
194
195 void *private_data;
196
197 struct work_struct work;
198 struct kfifo delayed_work_fifo;
199 atomic_t connected;
200 struct input_dev *delayed_input;
201
202 unsigned long quirks;
203 unsigned long capabilities;
204 u8 supported_reports;
205
206 struct hidpp_battery battery;
207 struct hidpp_scroll_counter vertical_wheel_counter;
208
209 u8 wireless_feature_index;
210};
211
212/* HID++ 1.0 error codes */
213#define HIDPP_ERROR 0x8f
214#define HIDPP_ERROR_SUCCESS 0x00
215#define HIDPP_ERROR_INVALID_SUBID 0x01
216#define HIDPP_ERROR_INVALID_ADRESS 0x02
217#define HIDPP_ERROR_INVALID_VALUE 0x03
218#define HIDPP_ERROR_CONNECT_FAIL 0x04
219#define HIDPP_ERROR_TOO_MANY_DEVICES 0x05
220#define HIDPP_ERROR_ALREADY_EXISTS 0x06
221#define HIDPP_ERROR_BUSY 0x07
222#define HIDPP_ERROR_UNKNOWN_DEVICE 0x08
223#define HIDPP_ERROR_RESOURCE_ERROR 0x09
224#define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a
225#define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b
226#define HIDPP_ERROR_WRONG_PIN_CODE 0x0c
227/* HID++ 2.0 error codes */
228#define HIDPP20_ERROR 0xff
229
230static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
231
232static int __hidpp_send_report(struct hid_device *hdev,
233 struct hidpp_report *hidpp_report)
234{
235 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
236 int fields_count, ret;
237
238 switch (hidpp_report->report_id) {
239 case REPORT_ID_HIDPP_SHORT:
240 fields_count = HIDPP_REPORT_SHORT_LENGTH;
241 break;
242 case REPORT_ID_HIDPP_LONG:
243 fields_count = HIDPP_REPORT_LONG_LENGTH;
244 break;
245 case REPORT_ID_HIDPP_VERY_LONG:
246 fields_count = hidpp->very_long_report_length;
247 break;
248 default:
249 return -ENODEV;
250 }
251
252 /*
253 * set the device_index as the receiver, it will be overwritten by
254 * hid_hw_request if needed
255 */
256 hidpp_report->device_index = 0xff;
257
258 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
259 ret = hid_hw_output_report(hdev, (u8 *)hidpp_report, fields_count);
260 } else {
261 ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
262 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
263 HID_REQ_SET_REPORT);
264 }
265
266 return ret == fields_count ? 0 : -1;
267}
268
269/*
270 * hidpp_send_message_sync() returns 0 in case of success, and something else
271 * in case of a failure.
272 * - If ' something else' is positive, that means that an error has been raised
273 * by the protocol itself.
274 * - If ' something else' is negative, that means that we had a classic error
275 * (-ENOMEM, -EPIPE, etc...)
276 */
277static int hidpp_send_message_sync(struct hidpp_device *hidpp,
278 struct hidpp_report *message,
279 struct hidpp_report *response)
280{
281 int ret;
282
283 mutex_lock(&hidpp->send_mutex);
284
285 hidpp->send_receive_buf = response;
286 hidpp->answer_available = false;
287
288 /*
289 * So that we can later validate the answer when it arrives
290 * in hidpp_raw_event
291 */
292 *response = *message;
293
294 ret = __hidpp_send_report(hidpp->hid_dev, message);
295
296 if (ret) {
297 dbg_hid("__hidpp_send_report returned err: %d\n", ret);
298 memset(response, 0, sizeof(struct hidpp_report));
299 goto exit;
300 }
301
302 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
303 5*HZ)) {
304 dbg_hid("%s:timeout waiting for response\n", __func__);
305 memset(response, 0, sizeof(struct hidpp_report));
306 ret = -ETIMEDOUT;
307 }
308
309 if (response->report_id == REPORT_ID_HIDPP_SHORT &&
310 response->rap.sub_id == HIDPP_ERROR) {
311 ret = response->rap.params[1];
312 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
313 goto exit;
314 }
315
316 if ((response->report_id == REPORT_ID_HIDPP_LONG ||
317 response->report_id == REPORT_ID_HIDPP_VERY_LONG) &&
318 response->fap.feature_index == HIDPP20_ERROR) {
319 ret = response->fap.params[1];
320 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
321 goto exit;
322 }
323
324exit:
325 mutex_unlock(&hidpp->send_mutex);
326 return ret;
327
328}
329
330static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
331 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
332 struct hidpp_report *response)
333{
334 struct hidpp_report *message;
335 int ret;
336
337 if (param_count > sizeof(message->fap.params))
338 return -EINVAL;
339
340 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
341 if (!message)
342 return -ENOMEM;
343
344 if (param_count > (HIDPP_REPORT_LONG_LENGTH - 4))
345 message->report_id = REPORT_ID_HIDPP_VERY_LONG;
346 else
347 message->report_id = REPORT_ID_HIDPP_LONG;
348 message->fap.feature_index = feat_index;
349 message->fap.funcindex_clientid = funcindex_clientid | LINUX_KERNEL_SW_ID;
350 memcpy(&message->fap.params, params, param_count);
351
352 ret = hidpp_send_message_sync(hidpp, message, response);
353 kfree(message);
354 return ret;
355}
356
357static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
358 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
359 struct hidpp_report *response)
360{
361 struct hidpp_report *message;
362 int ret, max_count;
363
364 /* Send as long report if short reports are not supported. */
365 if (report_id == REPORT_ID_HIDPP_SHORT &&
366 !(hidpp_dev->supported_reports & HIDPP_REPORT_SHORT_SUPPORTED))
367 report_id = REPORT_ID_HIDPP_LONG;
368
369 switch (report_id) {
370 case REPORT_ID_HIDPP_SHORT:
371 max_count = HIDPP_REPORT_SHORT_LENGTH - 4;
372 break;
373 case REPORT_ID_HIDPP_LONG:
374 max_count = HIDPP_REPORT_LONG_LENGTH - 4;
375 break;
376 case REPORT_ID_HIDPP_VERY_LONG:
377 max_count = hidpp_dev->very_long_report_length - 4;
378 break;
379 default:
380 return -EINVAL;
381 }
382
383 if (param_count > max_count)
384 return -EINVAL;
385
386 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
387 if (!message)
388 return -ENOMEM;
389 message->report_id = report_id;
390 message->rap.sub_id = sub_id;
391 message->rap.reg_address = reg_address;
392 memcpy(&message->rap.params, params, param_count);
393
394 ret = hidpp_send_message_sync(hidpp_dev, message, response);
395 kfree(message);
396 return ret;
397}
398
399static void delayed_work_cb(struct work_struct *work)
400{
401 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
402 work);
403 hidpp_connect_event(hidpp);
404}
405
406static inline bool hidpp_match_answer(struct hidpp_report *question,
407 struct hidpp_report *answer)
408{
409 return (answer->fap.feature_index == question->fap.feature_index) &&
410 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
411}
412
413static inline bool hidpp_match_error(struct hidpp_report *question,
414 struct hidpp_report *answer)
415{
416 return ((answer->rap.sub_id == HIDPP_ERROR) ||
417 (answer->fap.feature_index == HIDPP20_ERROR)) &&
418 (answer->fap.funcindex_clientid == question->fap.feature_index) &&
419 (answer->fap.params[0] == question->fap.funcindex_clientid);
420}
421
422static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
423 struct hidpp_report *report)
424{
425 return (hidpp->wireless_feature_index &&
426 (report->fap.feature_index == hidpp->wireless_feature_index)) ||
427 ((report->report_id == REPORT_ID_HIDPP_SHORT) &&
428 (report->rap.sub_id == 0x41));
429}
430
431/*
432 * hidpp_prefix_name() prefixes the current given name with "Logitech ".
433 */
434static void hidpp_prefix_name(char **name, int name_length)
435{
436#define PREFIX_LENGTH 9 /* "Logitech " */
437
438 int new_length;
439 char *new_name;
440
441 if (name_length > PREFIX_LENGTH &&
442 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
443 /* The prefix has is already in the name */
444 return;
445
446 new_length = PREFIX_LENGTH + name_length;
447 new_name = kzalloc(new_length, GFP_KERNEL);
448 if (!new_name)
449 return;
450
451 snprintf(new_name, new_length, "Logitech %s", *name);
452
453 kfree(*name);
454
455 *name = new_name;
456}
457
458/**
459 * hidpp_scroll_counter_handle_scroll() - Send high- and low-resolution scroll
460 * events given a high-resolution wheel
461 * movement.
462 * @input_dev: Pointer to the input device
463 * @counter: a hid_scroll_counter struct describing the wheel.
464 * @hi_res_value: the movement of the wheel, in the mouse's high-resolution
465 * units.
466 *
467 * Given a high-resolution movement, this function converts the movement into
468 * fractions of 120 and emits high-resolution scroll events for the input
469 * device. It also uses the multiplier from &struct hid_scroll_counter to
470 * emit low-resolution scroll events when appropriate for
471 * backwards-compatibility with userspace input libraries.
472 */
473static void hidpp_scroll_counter_handle_scroll(struct input_dev *input_dev,
474 struct hidpp_scroll_counter *counter,
475 int hi_res_value)
476{
477 int low_res_value, remainder, direction;
478 unsigned long long now, previous;
479
480 hi_res_value = hi_res_value * 120/counter->wheel_multiplier;
481 input_report_rel(input_dev, REL_WHEEL_HI_RES, hi_res_value);
482
483 remainder = counter->remainder;
484 direction = hi_res_value > 0 ? 1 : -1;
485
486 now = sched_clock();
487 previous = counter->last_time;
488 counter->last_time = now;
489 /*
490 * Reset the remainder after a period of inactivity or when the
491 * direction changes. This prevents the REL_WHEEL emulation point
492 * from sliding for devices that don't always provide the same
493 * number of movements per detent.
494 */
495 if (now - previous > 1000000000 || direction != counter->direction)
496 remainder = 0;
497
498 counter->direction = direction;
499 remainder += hi_res_value;
500
501 /* Some wheels will rest 7/8ths of a detent from the previous detent
502 * after slow movement, so we want the threshold for low-res events to
503 * be in the middle between two detents (e.g. after 4/8ths) as
504 * opposed to on the detents themselves (8/8ths).
505 */
506 if (abs(remainder) >= 60) {
507 /* Add (or subtract) 1 because we want to trigger when the wheel
508 * is half-way to the next detent (i.e. scroll 1 detent after a
509 * 1/2 detent movement, 2 detents after a 1 1/2 detent movement,
510 * etc.).
511 */
512 low_res_value = remainder / 120;
513 if (low_res_value == 0)
514 low_res_value = (hi_res_value > 0 ? 1 : -1);
515 input_report_rel(input_dev, REL_WHEEL, low_res_value);
516 remainder -= low_res_value * 120;
517 }
518 counter->remainder = remainder;
519}
520
521/* -------------------------------------------------------------------------- */
522/* HIDP++ 1.0 commands */
523/* -------------------------------------------------------------------------- */
524
525#define HIDPP_SET_REGISTER 0x80
526#define HIDPP_GET_REGISTER 0x81
527#define HIDPP_SET_LONG_REGISTER 0x82
528#define HIDPP_GET_LONG_REGISTER 0x83
529
530/**
531 * hidpp10_set_register - Modify a HID++ 1.0 register.
532 * @hidpp_dev: the device to set the register on.
533 * @register_address: the address of the register to modify.
534 * @byte: the byte of the register to modify. Should be less than 3.
535 * @mask: mask of the bits to modify
536 * @value: new values for the bits in mask
537 * Return: 0 if successful, otherwise a negative error code.
538 */
539static int hidpp10_set_register(struct hidpp_device *hidpp_dev,
540 u8 register_address, u8 byte, u8 mask, u8 value)
541{
542 struct hidpp_report response;
543 int ret;
544 u8 params[3] = { 0 };
545
546 ret = hidpp_send_rap_command_sync(hidpp_dev,
547 REPORT_ID_HIDPP_SHORT,
548 HIDPP_GET_REGISTER,
549 register_address,
550 NULL, 0, &response);
551 if (ret)
552 return ret;
553
554 memcpy(params, response.rap.params, 3);
555
556 params[byte] &= ~mask;
557 params[byte] |= value & mask;
558
559 return hidpp_send_rap_command_sync(hidpp_dev,
560 REPORT_ID_HIDPP_SHORT,
561 HIDPP_SET_REGISTER,
562 register_address,
563 params, 3, &response);
564}
565
566#define HIDPP_REG_ENABLE_REPORTS 0x00
567#define HIDPP_ENABLE_CONSUMER_REPORT BIT(0)
568#define HIDPP_ENABLE_WHEEL_REPORT BIT(2)
569#define HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT BIT(3)
570#define HIDPP_ENABLE_BAT_REPORT BIT(4)
571#define HIDPP_ENABLE_HWHEEL_REPORT BIT(5)
572
573static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
574{
575 return hidpp10_set_register(hidpp_dev, HIDPP_REG_ENABLE_REPORTS, 0,
576 HIDPP_ENABLE_BAT_REPORT, HIDPP_ENABLE_BAT_REPORT);
577}
578
579#define HIDPP_REG_FEATURES 0x01
580#define HIDPP_ENABLE_SPECIAL_BUTTON_FUNC BIT(1)
581#define HIDPP_ENABLE_FAST_SCROLL BIT(6)
582
583/* On HID++ 1.0 devices, high-res scroll was called "scrolling acceleration". */
584static int hidpp10_enable_scrolling_acceleration(struct hidpp_device *hidpp_dev)
585{
586 return hidpp10_set_register(hidpp_dev, HIDPP_REG_FEATURES, 0,
587 HIDPP_ENABLE_FAST_SCROLL, HIDPP_ENABLE_FAST_SCROLL);
588}
589
590#define HIDPP_REG_BATTERY_STATUS 0x07
591
592static int hidpp10_battery_status_map_level(u8 param)
593{
594 int level;
595
596 switch (param) {
597 case 1 ... 2:
598 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
599 break;
600 case 3 ... 4:
601 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
602 break;
603 case 5 ... 6:
604 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
605 break;
606 case 7:
607 level = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
608 break;
609 default:
610 level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
611 }
612
613 return level;
614}
615
616static int hidpp10_battery_status_map_status(u8 param)
617{
618 int status;
619
620 switch (param) {
621 case 0x00:
622 /* discharging (in use) */
623 status = POWER_SUPPLY_STATUS_DISCHARGING;
624 break;
625 case 0x21: /* (standard) charging */
626 case 0x24: /* fast charging */
627 case 0x25: /* slow charging */
628 status = POWER_SUPPLY_STATUS_CHARGING;
629 break;
630 case 0x26: /* topping charge */
631 case 0x22: /* charge complete */
632 status = POWER_SUPPLY_STATUS_FULL;
633 break;
634 case 0x20: /* unknown */
635 status = POWER_SUPPLY_STATUS_UNKNOWN;
636 break;
637 /*
638 * 0x01...0x1F = reserved (not charging)
639 * 0x23 = charging error
640 * 0x27..0xff = reserved
641 */
642 default:
643 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
644 break;
645 }
646
647 return status;
648}
649
650static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
651{
652 struct hidpp_report response;
653 int ret, status;
654
655 ret = hidpp_send_rap_command_sync(hidpp,
656 REPORT_ID_HIDPP_SHORT,
657 HIDPP_GET_REGISTER,
658 HIDPP_REG_BATTERY_STATUS,
659 NULL, 0, &response);
660 if (ret)
661 return ret;
662
663 hidpp->battery.level =
664 hidpp10_battery_status_map_level(response.rap.params[0]);
665 status = hidpp10_battery_status_map_status(response.rap.params[1]);
666 hidpp->battery.status = status;
667 /* the capacity is only available when discharging or full */
668 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
669 status == POWER_SUPPLY_STATUS_FULL;
670
671 return 0;
672}
673
674#define HIDPP_REG_BATTERY_MILEAGE 0x0D
675
676static int hidpp10_battery_mileage_map_status(u8 param)
677{
678 int status;
679
680 switch (param >> 6) {
681 case 0x00:
682 /* discharging (in use) */
683 status = POWER_SUPPLY_STATUS_DISCHARGING;
684 break;
685 case 0x01: /* charging */
686 status = POWER_SUPPLY_STATUS_CHARGING;
687 break;
688 case 0x02: /* charge complete */
689 status = POWER_SUPPLY_STATUS_FULL;
690 break;
691 /*
692 * 0x03 = charging error
693 */
694 default:
695 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
696 break;
697 }
698
699 return status;
700}
701
702static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
703{
704 struct hidpp_report response;
705 int ret, status;
706
707 ret = hidpp_send_rap_command_sync(hidpp,
708 REPORT_ID_HIDPP_SHORT,
709 HIDPP_GET_REGISTER,
710 HIDPP_REG_BATTERY_MILEAGE,
711 NULL, 0, &response);
712 if (ret)
713 return ret;
714
715 hidpp->battery.capacity = response.rap.params[0];
716 status = hidpp10_battery_mileage_map_status(response.rap.params[2]);
717 hidpp->battery.status = status;
718 /* the capacity is only available when discharging or full */
719 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
720 status == POWER_SUPPLY_STATUS_FULL;
721
722 return 0;
723}
724
725static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
726{
727 struct hidpp_report *report = (struct hidpp_report *)data;
728 int status, capacity, level;
729 bool changed;
730
731 if (report->report_id != REPORT_ID_HIDPP_SHORT)
732 return 0;
733
734 switch (report->rap.sub_id) {
735 case HIDPP_REG_BATTERY_STATUS:
736 capacity = hidpp->battery.capacity;
737 level = hidpp10_battery_status_map_level(report->rawbytes[1]);
738 status = hidpp10_battery_status_map_status(report->rawbytes[2]);
739 break;
740 case HIDPP_REG_BATTERY_MILEAGE:
741 capacity = report->rap.params[0];
742 level = hidpp->battery.level;
743 status = hidpp10_battery_mileage_map_status(report->rawbytes[3]);
744 break;
745 default:
746 return 0;
747 }
748
749 changed = capacity != hidpp->battery.capacity ||
750 level != hidpp->battery.level ||
751 status != hidpp->battery.status;
752
753 /* the capacity is only available when discharging or full */
754 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
755 status == POWER_SUPPLY_STATUS_FULL;
756
757 if (changed) {
758 hidpp->battery.level = level;
759 hidpp->battery.status = status;
760 if (hidpp->battery.ps)
761 power_supply_changed(hidpp->battery.ps);
762 }
763
764 return 0;
765}
766
767#define HIDPP_REG_PAIRING_INFORMATION 0xB5
768#define HIDPP_EXTENDED_PAIRING 0x30
769#define HIDPP_DEVICE_NAME 0x40
770
771static char *hidpp_unifying_get_name(struct hidpp_device *hidpp_dev)
772{
773 struct hidpp_report response;
774 int ret;
775 u8 params[1] = { HIDPP_DEVICE_NAME };
776 char *name;
777 int len;
778
779 ret = hidpp_send_rap_command_sync(hidpp_dev,
780 REPORT_ID_HIDPP_SHORT,
781 HIDPP_GET_LONG_REGISTER,
782 HIDPP_REG_PAIRING_INFORMATION,
783 params, 1, &response);
784 if (ret)
785 return NULL;
786
787 len = response.rap.params[1];
788
789 if (2 + len > sizeof(response.rap.params))
790 return NULL;
791
792 if (len < 4) /* logitech devices are usually at least Xddd */
793 return NULL;
794
795 name = kzalloc(len + 1, GFP_KERNEL);
796 if (!name)
797 return NULL;
798
799 memcpy(name, &response.rap.params[2], len);
800
801 /* include the terminating '\0' */
802 hidpp_prefix_name(&name, len + 1);
803
804 return name;
805}
806
807static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
808{
809 struct hidpp_report response;
810 int ret;
811 u8 params[1] = { HIDPP_EXTENDED_PAIRING };
812
813 ret = hidpp_send_rap_command_sync(hidpp,
814 REPORT_ID_HIDPP_SHORT,
815 HIDPP_GET_LONG_REGISTER,
816 HIDPP_REG_PAIRING_INFORMATION,
817 params, 1, &response);
818 if (ret)
819 return ret;
820
821 /*
822 * We don't care about LE or BE, we will output it as a string
823 * with %4phD, so we need to keep the order.
824 */
825 *serial = *((u32 *)&response.rap.params[1]);
826 return 0;
827}
828
829static int hidpp_unifying_init(struct hidpp_device *hidpp)
830{
831 struct hid_device *hdev = hidpp->hid_dev;
832 const char *name;
833 u32 serial;
834 int ret;
835
836 ret = hidpp_unifying_get_serial(hidpp, &serial);
837 if (ret)
838 return ret;
839
840 snprintf(hdev->uniq, sizeof(hdev->uniq), "%04x-%4phD",
841 hdev->product, &serial);
842 dbg_hid("HID++ Unifying: Got serial: %s\n", hdev->uniq);
843
844 name = hidpp_unifying_get_name(hidpp);
845 if (!name)
846 return -EIO;
847
848 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
849 dbg_hid("HID++ Unifying: Got name: %s\n", name);
850
851 kfree(name);
852 return 0;
853}
854
855/* -------------------------------------------------------------------------- */
856/* 0x0000: Root */
857/* -------------------------------------------------------------------------- */
858
859#define HIDPP_PAGE_ROOT 0x0000
860#define HIDPP_PAGE_ROOT_IDX 0x00
861
862#define CMD_ROOT_GET_FEATURE 0x00
863#define CMD_ROOT_GET_PROTOCOL_VERSION 0x10
864
865static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
866 u8 *feature_index, u8 *feature_type)
867{
868 struct hidpp_report response;
869 int ret;
870 u8 params[2] = { feature >> 8, feature & 0x00FF };
871
872 ret = hidpp_send_fap_command_sync(hidpp,
873 HIDPP_PAGE_ROOT_IDX,
874 CMD_ROOT_GET_FEATURE,
875 params, 2, &response);
876 if (ret)
877 return ret;
878
879 if (response.fap.params[0] == 0)
880 return -ENOENT;
881
882 *feature_index = response.fap.params[0];
883 *feature_type = response.fap.params[1];
884
885 return ret;
886}
887
888static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
889{
890 const u8 ping_byte = 0x5a;
891 u8 ping_data[3] = { 0, 0, ping_byte };
892 struct hidpp_report response;
893 int ret;
894
895 ret = hidpp_send_rap_command_sync(hidpp,
896 REPORT_ID_HIDPP_SHORT,
897 HIDPP_PAGE_ROOT_IDX,
898 CMD_ROOT_GET_PROTOCOL_VERSION | LINUX_KERNEL_SW_ID,
899 ping_data, sizeof(ping_data), &response);
900
901 if (ret == HIDPP_ERROR_INVALID_SUBID) {
902 hidpp->protocol_major = 1;
903 hidpp->protocol_minor = 0;
904 goto print_version;
905 }
906
907 /* the device might not be connected */
908 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
909 return -EIO;
910
911 if (ret > 0) {
912 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
913 __func__, ret);
914 return -EPROTO;
915 }
916 if (ret)
917 return ret;
918
919 if (response.rap.params[2] != ping_byte) {
920 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
921 __func__, response.rap.params[2], ping_byte);
922 return -EPROTO;
923 }
924
925 hidpp->protocol_major = response.rap.params[0];
926 hidpp->protocol_minor = response.rap.params[1];
927
928print_version:
929 hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
930 hidpp->protocol_major, hidpp->protocol_minor);
931 return 0;
932}
933
934/* -------------------------------------------------------------------------- */
935/* 0x0005: GetDeviceNameType */
936/* -------------------------------------------------------------------------- */
937
938#define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005
939
940#define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x00
941#define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x10
942#define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x20
943
944static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
945 u8 feature_index, u8 *nameLength)
946{
947 struct hidpp_report response;
948 int ret;
949
950 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
951 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
952
953 if (ret > 0) {
954 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
955 __func__, ret);
956 return -EPROTO;
957 }
958 if (ret)
959 return ret;
960
961 *nameLength = response.fap.params[0];
962
963 return ret;
964}
965
966static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
967 u8 feature_index, u8 char_index, char *device_name, int len_buf)
968{
969 struct hidpp_report response;
970 int ret, i;
971 int count;
972
973 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
974 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
975 &response);
976
977 if (ret > 0) {
978 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
979 __func__, ret);
980 return -EPROTO;
981 }
982 if (ret)
983 return ret;
984
985 switch (response.report_id) {
986 case REPORT_ID_HIDPP_VERY_LONG:
987 count = hidpp->very_long_report_length - 4;
988 break;
989 case REPORT_ID_HIDPP_LONG:
990 count = HIDPP_REPORT_LONG_LENGTH - 4;
991 break;
992 case REPORT_ID_HIDPP_SHORT:
993 count = HIDPP_REPORT_SHORT_LENGTH - 4;
994 break;
995 default:
996 return -EPROTO;
997 }
998
999 if (len_buf < count)
1000 count = len_buf;
1001
1002 for (i = 0; i < count; i++)
1003 device_name[i] = response.fap.params[i];
1004
1005 return count;
1006}
1007
1008static char *hidpp_get_device_name(struct hidpp_device *hidpp)
1009{
1010 u8 feature_type;
1011 u8 feature_index;
1012 u8 __name_length;
1013 char *name;
1014 unsigned index = 0;
1015 int ret;
1016
1017 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
1018 &feature_index, &feature_type);
1019 if (ret)
1020 return NULL;
1021
1022 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
1023 &__name_length);
1024 if (ret)
1025 return NULL;
1026
1027 name = kzalloc(__name_length + 1, GFP_KERNEL);
1028 if (!name)
1029 return NULL;
1030
1031 while (index < __name_length) {
1032 ret = hidpp_devicenametype_get_device_name(hidpp,
1033 feature_index, index, name + index,
1034 __name_length - index);
1035 if (ret <= 0) {
1036 kfree(name);
1037 return NULL;
1038 }
1039 index += ret;
1040 }
1041
1042 /* include the terminating '\0' */
1043 hidpp_prefix_name(&name, __name_length + 1);
1044
1045 return name;
1046}
1047
1048/* -------------------------------------------------------------------------- */
1049/* 0x1000: Battery level status */
1050/* -------------------------------------------------------------------------- */
1051
1052#define HIDPP_PAGE_BATTERY_LEVEL_STATUS 0x1000
1053
1054#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS 0x00
1055#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY 0x10
1056
1057#define EVENT_BATTERY_LEVEL_STATUS_BROADCAST 0x00
1058
1059#define FLAG_BATTERY_LEVEL_DISABLE_OSD BIT(0)
1060#define FLAG_BATTERY_LEVEL_MILEAGE BIT(1)
1061#define FLAG_BATTERY_LEVEL_RECHARGEABLE BIT(2)
1062
1063static int hidpp_map_battery_level(int capacity)
1064{
1065 if (capacity < 11)
1066 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1067 /*
1068 * The spec says this should be < 31 but some devices report 30
1069 * with brand new batteries and Windows reports 30 as "Good".
1070 */
1071 else if (capacity < 30)
1072 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1073 else if (capacity < 81)
1074 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1075 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1076}
1077
1078static int hidpp20_batterylevel_map_status_capacity(u8 data[3], int *capacity,
1079 int *next_capacity,
1080 int *level)
1081{
1082 int status;
1083
1084 *capacity = data[0];
1085 *next_capacity = data[1];
1086 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1087
1088 /* When discharging, we can rely on the device reported capacity.
1089 * For all other states the device reports 0 (unknown).
1090 */
1091 switch (data[2]) {
1092 case 0: /* discharging (in use) */
1093 status = POWER_SUPPLY_STATUS_DISCHARGING;
1094 *level = hidpp_map_battery_level(*capacity);
1095 break;
1096 case 1: /* recharging */
1097 status = POWER_SUPPLY_STATUS_CHARGING;
1098 break;
1099 case 2: /* charge in final stage */
1100 status = POWER_SUPPLY_STATUS_CHARGING;
1101 break;
1102 case 3: /* charge complete */
1103 status = POWER_SUPPLY_STATUS_FULL;
1104 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1105 *capacity = 100;
1106 break;
1107 case 4: /* recharging below optimal speed */
1108 status = POWER_SUPPLY_STATUS_CHARGING;
1109 break;
1110 /* 5 = invalid battery type
1111 6 = thermal error
1112 7 = other charging error */
1113 default:
1114 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1115 break;
1116 }
1117
1118 return status;
1119}
1120
1121static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
1122 u8 feature_index,
1123 int *status,
1124 int *capacity,
1125 int *next_capacity,
1126 int *level)
1127{
1128 struct hidpp_report response;
1129 int ret;
1130 u8 *params = (u8 *)response.fap.params;
1131
1132 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1133 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS,
1134 NULL, 0, &response);
1135 /* Ignore these intermittent errors */
1136 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1137 return -EIO;
1138 if (ret > 0) {
1139 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1140 __func__, ret);
1141 return -EPROTO;
1142 }
1143 if (ret)
1144 return ret;
1145
1146 *status = hidpp20_batterylevel_map_status_capacity(params, capacity,
1147 next_capacity,
1148 level);
1149
1150 return 0;
1151}
1152
1153static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
1154 u8 feature_index)
1155{
1156 struct hidpp_report response;
1157 int ret;
1158 u8 *params = (u8 *)response.fap.params;
1159 unsigned int level_count, flags;
1160
1161 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1162 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY,
1163 NULL, 0, &response);
1164 if (ret > 0) {
1165 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1166 __func__, ret);
1167 return -EPROTO;
1168 }
1169 if (ret)
1170 return ret;
1171
1172 level_count = params[0];
1173 flags = params[1];
1174
1175 if (level_count < 10 || !(flags & FLAG_BATTERY_LEVEL_MILEAGE))
1176 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1177 else
1178 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1179
1180 return 0;
1181}
1182
1183static int hidpp20_query_battery_info_1000(struct hidpp_device *hidpp)
1184{
1185 u8 feature_type;
1186 int ret;
1187 int status, capacity, next_capacity, level;
1188
1189 if (hidpp->battery.feature_index == 0xff) {
1190 ret = hidpp_root_get_feature(hidpp,
1191 HIDPP_PAGE_BATTERY_LEVEL_STATUS,
1192 &hidpp->battery.feature_index,
1193 &feature_type);
1194 if (ret)
1195 return ret;
1196 }
1197
1198 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1199 hidpp->battery.feature_index,
1200 &status, &capacity,
1201 &next_capacity, &level);
1202 if (ret)
1203 return ret;
1204
1205 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1206 hidpp->battery.feature_index);
1207 if (ret)
1208 return ret;
1209
1210 hidpp->battery.status = status;
1211 hidpp->battery.capacity = capacity;
1212 hidpp->battery.level = level;
1213 /* the capacity is only available when discharging or full */
1214 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1215 status == POWER_SUPPLY_STATUS_FULL;
1216
1217 return 0;
1218}
1219
1220static int hidpp20_battery_event_1000(struct hidpp_device *hidpp,
1221 u8 *data, int size)
1222{
1223 struct hidpp_report *report = (struct hidpp_report *)data;
1224 int status, capacity, next_capacity, level;
1225 bool changed;
1226
1227 if (report->fap.feature_index != hidpp->battery.feature_index ||
1228 report->fap.funcindex_clientid != EVENT_BATTERY_LEVEL_STATUS_BROADCAST)
1229 return 0;
1230
1231 status = hidpp20_batterylevel_map_status_capacity(report->fap.params,
1232 &capacity,
1233 &next_capacity,
1234 &level);
1235
1236 /* the capacity is only available when discharging or full */
1237 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1238 status == POWER_SUPPLY_STATUS_FULL;
1239
1240 changed = capacity != hidpp->battery.capacity ||
1241 level != hidpp->battery.level ||
1242 status != hidpp->battery.status;
1243
1244 if (changed) {
1245 hidpp->battery.level = level;
1246 hidpp->battery.capacity = capacity;
1247 hidpp->battery.status = status;
1248 if (hidpp->battery.ps)
1249 power_supply_changed(hidpp->battery.ps);
1250 }
1251
1252 return 0;
1253}
1254
1255/* -------------------------------------------------------------------------- */
1256/* 0x1001: Battery voltage */
1257/* -------------------------------------------------------------------------- */
1258
1259#define HIDPP_PAGE_BATTERY_VOLTAGE 0x1001
1260
1261#define CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE 0x00
1262
1263#define EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST 0x00
1264
1265static int hidpp20_battery_map_status_voltage(u8 data[3], int *voltage,
1266 int *level, int *charge_type)
1267{
1268 int status;
1269
1270 long flags = (long) data[2];
1271 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1272
1273 if (flags & 0x80)
1274 switch (flags & 0x07) {
1275 case 0:
1276 status = POWER_SUPPLY_STATUS_CHARGING;
1277 break;
1278 case 1:
1279 status = POWER_SUPPLY_STATUS_FULL;
1280 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1281 break;
1282 case 2:
1283 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1284 break;
1285 default:
1286 status = POWER_SUPPLY_STATUS_UNKNOWN;
1287 break;
1288 }
1289 else
1290 status = POWER_SUPPLY_STATUS_DISCHARGING;
1291
1292 *charge_type = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
1293 if (test_bit(3, &flags)) {
1294 *charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
1295 }
1296 if (test_bit(4, &flags)) {
1297 *charge_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1298 }
1299 if (test_bit(5, &flags)) {
1300 *level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1301 }
1302
1303 *voltage = get_unaligned_be16(data);
1304
1305 return status;
1306}
1307
1308static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
1309 u8 feature_index,
1310 int *status, int *voltage,
1311 int *level, int *charge_type)
1312{
1313 struct hidpp_report response;
1314 int ret;
1315 u8 *params = (u8 *)response.fap.params;
1316
1317 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1318 CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE,
1319 NULL, 0, &response);
1320
1321 if (ret > 0) {
1322 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1323 __func__, ret);
1324 return -EPROTO;
1325 }
1326 if (ret)
1327 return ret;
1328
1329 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
1330
1331 *status = hidpp20_battery_map_status_voltage(params, voltage,
1332 level, charge_type);
1333
1334 return 0;
1335}
1336
1337static int hidpp20_map_battery_capacity(struct hid_device *hid_dev, int voltage)
1338{
1339 /* NB: This voltage curve doesn't necessarily map perfectly to all
1340 * devices that implement the BATTERY_VOLTAGE feature. This is because
1341 * there are a few devices that use different battery technology.
1342 */
1343
1344 static const int voltages[] = {
1345 4186, 4156, 4143, 4133, 4122, 4113, 4103, 4094, 4086, 4075,
1346 4067, 4059, 4051, 4043, 4035, 4027, 4019, 4011, 4003, 3997,
1347 3989, 3983, 3976, 3969, 3961, 3955, 3949, 3942, 3935, 3929,
1348 3922, 3916, 3909, 3902, 3896, 3890, 3883, 3877, 3870, 3865,
1349 3859, 3853, 3848, 3842, 3837, 3833, 3828, 3824, 3819, 3815,
1350 3811, 3808, 3804, 3800, 3797, 3793, 3790, 3787, 3784, 3781,
1351 3778, 3775, 3772, 3770, 3767, 3764, 3762, 3759, 3757, 3754,
1352 3751, 3748, 3744, 3741, 3737, 3734, 3730, 3726, 3724, 3720,
1353 3717, 3714, 3710, 3706, 3702, 3697, 3693, 3688, 3683, 3677,
1354 3671, 3666, 3662, 3658, 3654, 3646, 3633, 3612, 3579, 3537
1355 };
1356
1357 int i;
1358
1359 BUILD_BUG_ON(ARRAY_SIZE(voltages) != 100);
1360
1361 if (unlikely(voltage < 3500 || voltage >= 5000))
1362 hid_warn_once(hid_dev,
1363 "%s: possibly using the wrong voltage curve\n",
1364 __func__);
1365
1366 for (i = 0; i < ARRAY_SIZE(voltages); i++) {
1367 if (voltage >= voltages[i])
1368 return ARRAY_SIZE(voltages) - i;
1369 }
1370
1371 return 0;
1372}
1373
1374static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
1375{
1376 u8 feature_type;
1377 int ret;
1378 int status, voltage, level, charge_type;
1379
1380 if (hidpp->battery.voltage_feature_index == 0xff) {
1381 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
1382 &hidpp->battery.voltage_feature_index,
1383 &feature_type);
1384 if (ret)
1385 return ret;
1386 }
1387
1388 ret = hidpp20_battery_get_battery_voltage(hidpp,
1389 hidpp->battery.voltage_feature_index,
1390 &status, &voltage, &level, &charge_type);
1391
1392 if (ret)
1393 return ret;
1394
1395 hidpp->battery.status = status;
1396 hidpp->battery.voltage = voltage;
1397 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1398 voltage);
1399 hidpp->battery.level = level;
1400 hidpp->battery.charge_type = charge_type;
1401 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1402
1403 return 0;
1404}
1405
1406static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
1407 u8 *data, int size)
1408{
1409 struct hidpp_report *report = (struct hidpp_report *)data;
1410 int status, voltage, level, charge_type;
1411
1412 if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||
1413 report->fap.funcindex_clientid != EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST)
1414 return 0;
1415
1416 status = hidpp20_battery_map_status_voltage(report->fap.params, &voltage,
1417 &level, &charge_type);
1418
1419 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1420
1421 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1422 hidpp->battery.voltage = voltage;
1423 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1424 voltage);
1425 hidpp->battery.status = status;
1426 hidpp->battery.level = level;
1427 hidpp->battery.charge_type = charge_type;
1428 if (hidpp->battery.ps)
1429 power_supply_changed(hidpp->battery.ps);
1430 }
1431 return 0;
1432}
1433
1434/* -------------------------------------------------------------------------- */
1435/* 0x1004: Unified battery */
1436/* -------------------------------------------------------------------------- */
1437
1438#define HIDPP_PAGE_UNIFIED_BATTERY 0x1004
1439
1440#define CMD_UNIFIED_BATTERY_GET_CAPABILITIES 0x00
1441#define CMD_UNIFIED_BATTERY_GET_STATUS 0x10
1442
1443#define EVENT_UNIFIED_BATTERY_STATUS_EVENT 0x00
1444
1445#define FLAG_UNIFIED_BATTERY_LEVEL_CRITICAL BIT(0)
1446#define FLAG_UNIFIED_BATTERY_LEVEL_LOW BIT(1)
1447#define FLAG_UNIFIED_BATTERY_LEVEL_GOOD BIT(2)
1448#define FLAG_UNIFIED_BATTERY_LEVEL_FULL BIT(3)
1449
1450#define FLAG_UNIFIED_BATTERY_FLAGS_RECHARGEABLE BIT(0)
1451#define FLAG_UNIFIED_BATTERY_FLAGS_STATE_OF_CHARGE BIT(1)
1452
1453static int hidpp20_unifiedbattery_get_capabilities(struct hidpp_device *hidpp,
1454 u8 feature_index)
1455{
1456 struct hidpp_report response;
1457 int ret;
1458 u8 *params = (u8 *)response.fap.params;
1459
1460 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS ||
1461 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) {
1462 /* we have already set the device capabilities, so let's skip */
1463 return 0;
1464 }
1465
1466 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1467 CMD_UNIFIED_BATTERY_GET_CAPABILITIES,
1468 NULL, 0, &response);
1469 /* Ignore these intermittent errors */
1470 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1471 return -EIO;
1472 if (ret > 0) {
1473 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1474 __func__, ret);
1475 return -EPROTO;
1476 }
1477 if (ret)
1478 return ret;
1479
1480 /*
1481 * If the device supports state of charge (battery percentage) we won't
1482 * export the battery level information. there are 4 possible battery
1483 * levels and they all are optional, this means that the device might
1484 * not support any of them, we are just better off with the battery
1485 * percentage.
1486 */
1487 if (params[1] & FLAG_UNIFIED_BATTERY_FLAGS_STATE_OF_CHARGE) {
1488 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_PERCENTAGE;
1489 hidpp->battery.supported_levels_1004 = 0;
1490 } else {
1491 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1492 hidpp->battery.supported_levels_1004 = params[0];
1493 }
1494
1495 return 0;
1496}
1497
1498static int hidpp20_unifiedbattery_map_status(struct hidpp_device *hidpp,
1499 u8 charging_status,
1500 u8 external_power_status)
1501{
1502 int status;
1503
1504 switch (charging_status) {
1505 case 0: /* discharging */
1506 status = POWER_SUPPLY_STATUS_DISCHARGING;
1507 break;
1508 case 1: /* charging */
1509 case 2: /* charging slow */
1510 status = POWER_SUPPLY_STATUS_CHARGING;
1511 break;
1512 case 3: /* complete */
1513 status = POWER_SUPPLY_STATUS_FULL;
1514 break;
1515 case 4: /* error */
1516 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1517 hid_info(hidpp->hid_dev, "%s: charging error",
1518 hidpp->name);
1519 break;
1520 default:
1521 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1522 break;
1523 }
1524
1525 return status;
1526}
1527
1528static int hidpp20_unifiedbattery_map_level(struct hidpp_device *hidpp,
1529 u8 battery_level)
1530{
1531 /* cler unsupported level bits */
1532 battery_level &= hidpp->battery.supported_levels_1004;
1533
1534 if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_FULL)
1535 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1536 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_GOOD)
1537 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1538 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_LOW)
1539 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1540 else if (battery_level & FLAG_UNIFIED_BATTERY_LEVEL_CRITICAL)
1541 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1542
1543 return POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1544}
1545
1546static int hidpp20_unifiedbattery_get_status(struct hidpp_device *hidpp,
1547 u8 feature_index,
1548 u8 *state_of_charge,
1549 int *status,
1550 int *level)
1551{
1552 struct hidpp_report response;
1553 int ret;
1554 u8 *params = (u8 *)response.fap.params;
1555
1556 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1557 CMD_UNIFIED_BATTERY_GET_STATUS,
1558 NULL, 0, &response);
1559 /* Ignore these intermittent errors */
1560 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1561 return -EIO;
1562 if (ret > 0) {
1563 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1564 __func__, ret);
1565 return -EPROTO;
1566 }
1567 if (ret)
1568 return ret;
1569
1570 *state_of_charge = params[0];
1571 *status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1572 *level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1573
1574 return 0;
1575}
1576
1577static int hidpp20_query_battery_info_1004(struct hidpp_device *hidpp)
1578{
1579 u8 feature_type;
1580 int ret;
1581 u8 state_of_charge;
1582 int status, level;
1583
1584 if (hidpp->battery.feature_index == 0xff) {
1585 ret = hidpp_root_get_feature(hidpp,
1586 HIDPP_PAGE_UNIFIED_BATTERY,
1587 &hidpp->battery.feature_index,
1588 &feature_type);
1589 if (ret)
1590 return ret;
1591 }
1592
1593 ret = hidpp20_unifiedbattery_get_capabilities(hidpp,
1594 hidpp->battery.feature_index);
1595 if (ret)
1596 return ret;
1597
1598 ret = hidpp20_unifiedbattery_get_status(hidpp,
1599 hidpp->battery.feature_index,
1600 &state_of_charge,
1601 &status,
1602 &level);
1603 if (ret)
1604 return ret;
1605
1606 hidpp->capabilities |= HIDPP_CAPABILITY_UNIFIED_BATTERY;
1607 hidpp->battery.capacity = state_of_charge;
1608 hidpp->battery.status = status;
1609 hidpp->battery.level = level;
1610 hidpp->battery.online = true;
1611
1612 return 0;
1613}
1614
1615static int hidpp20_battery_event_1004(struct hidpp_device *hidpp,
1616 u8 *data, int size)
1617{
1618 struct hidpp_report *report = (struct hidpp_report *)data;
1619 u8 *params = (u8 *)report->fap.params;
1620 int state_of_charge, status, level;
1621 bool changed;
1622
1623 if (report->fap.feature_index != hidpp->battery.feature_index ||
1624 report->fap.funcindex_clientid != EVENT_UNIFIED_BATTERY_STATUS_EVENT)
1625 return 0;
1626
1627 state_of_charge = params[0];
1628 status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1629 level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1630
1631 changed = status != hidpp->battery.status ||
1632 (state_of_charge != hidpp->battery.capacity &&
1633 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) ||
1634 (level != hidpp->battery.level &&
1635 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS);
1636
1637 if (changed) {
1638 hidpp->battery.capacity = state_of_charge;
1639 hidpp->battery.status = status;
1640 hidpp->battery.level = level;
1641 if (hidpp->battery.ps)
1642 power_supply_changed(hidpp->battery.ps);
1643 }
1644
1645 return 0;
1646}
1647
1648/* -------------------------------------------------------------------------- */
1649/* Battery feature helpers */
1650/* -------------------------------------------------------------------------- */
1651
1652static enum power_supply_property hidpp_battery_props[] = {
1653 POWER_SUPPLY_PROP_ONLINE,
1654 POWER_SUPPLY_PROP_STATUS,
1655 POWER_SUPPLY_PROP_SCOPE,
1656 POWER_SUPPLY_PROP_MODEL_NAME,
1657 POWER_SUPPLY_PROP_MANUFACTURER,
1658 POWER_SUPPLY_PROP_SERIAL_NUMBER,
1659 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY, */
1660 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY_LEVEL, */
1661 0, /* placeholder for POWER_SUPPLY_PROP_VOLTAGE_NOW, */
1662};
1663
1664static int hidpp_battery_get_property(struct power_supply *psy,
1665 enum power_supply_property psp,
1666 union power_supply_propval *val)
1667{
1668 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1669 int ret = 0;
1670
1671 switch(psp) {
1672 case POWER_SUPPLY_PROP_STATUS:
1673 val->intval = hidpp->battery.status;
1674 break;
1675 case POWER_SUPPLY_PROP_CAPACITY:
1676 val->intval = hidpp->battery.capacity;
1677 break;
1678 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1679 val->intval = hidpp->battery.level;
1680 break;
1681 case POWER_SUPPLY_PROP_SCOPE:
1682 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1683 break;
1684 case POWER_SUPPLY_PROP_ONLINE:
1685 val->intval = hidpp->battery.online;
1686 break;
1687 case POWER_SUPPLY_PROP_MODEL_NAME:
1688 if (!strncmp(hidpp->name, "Logitech ", 9))
1689 val->strval = hidpp->name + 9;
1690 else
1691 val->strval = hidpp->name;
1692 break;
1693 case POWER_SUPPLY_PROP_MANUFACTURER:
1694 val->strval = "Logitech";
1695 break;
1696 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
1697 val->strval = hidpp->hid_dev->uniq;
1698 break;
1699 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1700 /* hardware reports voltage in mV. sysfs expects uV */
1701 val->intval = hidpp->battery.voltage * 1000;
1702 break;
1703 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1704 val->intval = hidpp->battery.charge_type;
1705 break;
1706 default:
1707 ret = -EINVAL;
1708 break;
1709 }
1710
1711 return ret;
1712}
1713
1714/* -------------------------------------------------------------------------- */
1715/* 0x1d4b: Wireless device status */
1716/* -------------------------------------------------------------------------- */
1717#define HIDPP_PAGE_WIRELESS_DEVICE_STATUS 0x1d4b
1718
1719static int hidpp_set_wireless_feature_index(struct hidpp_device *hidpp)
1720{
1721 u8 feature_type;
1722 int ret;
1723
1724 ret = hidpp_root_get_feature(hidpp,
1725 HIDPP_PAGE_WIRELESS_DEVICE_STATUS,
1726 &hidpp->wireless_feature_index,
1727 &feature_type);
1728
1729 return ret;
1730}
1731
1732/* -------------------------------------------------------------------------- */
1733/* 0x2120: Hi-resolution scrolling */
1734/* -------------------------------------------------------------------------- */
1735
1736#define HIDPP_PAGE_HI_RESOLUTION_SCROLLING 0x2120
1737
1738#define CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE 0x10
1739
1740static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
1741 bool enabled, u8 *multiplier)
1742{
1743 u8 feature_index;
1744 u8 feature_type;
1745 int ret;
1746 u8 params[1];
1747 struct hidpp_report response;
1748
1749 ret = hidpp_root_get_feature(hidpp,
1750 HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
1751 &feature_index,
1752 &feature_type);
1753 if (ret)
1754 return ret;
1755
1756 params[0] = enabled ? BIT(0) : 0;
1757 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1758 CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE,
1759 params, sizeof(params), &response);
1760 if (ret)
1761 return ret;
1762 *multiplier = response.fap.params[1];
1763 return 0;
1764}
1765
1766/* -------------------------------------------------------------------------- */
1767/* 0x2121: HiRes Wheel */
1768/* -------------------------------------------------------------------------- */
1769
1770#define HIDPP_PAGE_HIRES_WHEEL 0x2121
1771
1772#define CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY 0x00
1773#define CMD_HIRES_WHEEL_SET_WHEEL_MODE 0x20
1774
1775static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
1776 u8 *multiplier)
1777{
1778 u8 feature_index;
1779 u8 feature_type;
1780 int ret;
1781 struct hidpp_report response;
1782
1783 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1784 &feature_index, &feature_type);
1785 if (ret)
1786 goto return_default;
1787
1788 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1789 CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY,
1790 NULL, 0, &response);
1791 if (ret)
1792 goto return_default;
1793
1794 *multiplier = response.fap.params[0];
1795 return 0;
1796return_default:
1797 hid_warn(hidpp->hid_dev,
1798 "Couldn't get wheel multiplier (error %d)\n", ret);
1799 return ret;
1800}
1801
1802static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
1803 bool high_resolution, bool use_hidpp)
1804{
1805 u8 feature_index;
1806 u8 feature_type;
1807 int ret;
1808 u8 params[1];
1809 struct hidpp_report response;
1810
1811 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1812 &feature_index, &feature_type);
1813 if (ret)
1814 return ret;
1815
1816 params[0] = (invert ? BIT(2) : 0) |
1817 (high_resolution ? BIT(1) : 0) |
1818 (use_hidpp ? BIT(0) : 0);
1819
1820 return hidpp_send_fap_command_sync(hidpp, feature_index,
1821 CMD_HIRES_WHEEL_SET_WHEEL_MODE,
1822 params, sizeof(params), &response);
1823}
1824
1825/* -------------------------------------------------------------------------- */
1826/* 0x4301: Solar Keyboard */
1827/* -------------------------------------------------------------------------- */
1828
1829#define HIDPP_PAGE_SOLAR_KEYBOARD 0x4301
1830
1831#define CMD_SOLAR_SET_LIGHT_MEASURE 0x00
1832
1833#define EVENT_SOLAR_BATTERY_BROADCAST 0x00
1834#define EVENT_SOLAR_BATTERY_LIGHT_MEASURE 0x10
1835#define EVENT_SOLAR_CHECK_LIGHT_BUTTON 0x20
1836
1837static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
1838{
1839 struct hidpp_report response;
1840 u8 params[2] = { 1, 1 };
1841 u8 feature_type;
1842 int ret;
1843
1844 if (hidpp->battery.feature_index == 0xff) {
1845 ret = hidpp_root_get_feature(hidpp,
1846 HIDPP_PAGE_SOLAR_KEYBOARD,
1847 &hidpp->battery.solar_feature_index,
1848 &feature_type);
1849 if (ret)
1850 return ret;
1851 }
1852
1853 ret = hidpp_send_fap_command_sync(hidpp,
1854 hidpp->battery.solar_feature_index,
1855 CMD_SOLAR_SET_LIGHT_MEASURE,
1856 params, 2, &response);
1857 if (ret > 0) {
1858 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1859 __func__, ret);
1860 return -EPROTO;
1861 }
1862 if (ret)
1863 return ret;
1864
1865 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1866
1867 return 0;
1868}
1869
1870static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
1871 u8 *data, int size)
1872{
1873 struct hidpp_report *report = (struct hidpp_report *)data;
1874 int capacity, lux, status;
1875 u8 function;
1876
1877 function = report->fap.funcindex_clientid;
1878
1879
1880 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
1881 !(function == EVENT_SOLAR_BATTERY_BROADCAST ||
1882 function == EVENT_SOLAR_BATTERY_LIGHT_MEASURE ||
1883 function == EVENT_SOLAR_CHECK_LIGHT_BUTTON))
1884 return 0;
1885
1886 capacity = report->fap.params[0];
1887
1888 switch (function) {
1889 case EVENT_SOLAR_BATTERY_LIGHT_MEASURE:
1890 lux = (report->fap.params[1] << 8) | report->fap.params[2];
1891 if (lux > 200)
1892 status = POWER_SUPPLY_STATUS_CHARGING;
1893 else
1894 status = POWER_SUPPLY_STATUS_DISCHARGING;
1895 break;
1896 case EVENT_SOLAR_CHECK_LIGHT_BUTTON:
1897 default:
1898 if (capacity < hidpp->battery.capacity)
1899 status = POWER_SUPPLY_STATUS_DISCHARGING;
1900 else
1901 status = POWER_SUPPLY_STATUS_CHARGING;
1902
1903 }
1904
1905 if (capacity == 100)
1906 status = POWER_SUPPLY_STATUS_FULL;
1907
1908 hidpp->battery.online = true;
1909 if (capacity != hidpp->battery.capacity ||
1910 status != hidpp->battery.status) {
1911 hidpp->battery.capacity = capacity;
1912 hidpp->battery.status = status;
1913 if (hidpp->battery.ps)
1914 power_supply_changed(hidpp->battery.ps);
1915 }
1916
1917 return 0;
1918}
1919
1920/* -------------------------------------------------------------------------- */
1921/* 0x6010: Touchpad FW items */
1922/* -------------------------------------------------------------------------- */
1923
1924#define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010
1925
1926#define CMD_TOUCHPAD_FW_ITEMS_SET 0x10
1927
1928struct hidpp_touchpad_fw_items {
1929 uint8_t presence;
1930 uint8_t desired_state;
1931 uint8_t state;
1932 uint8_t persistent;
1933};
1934
1935/*
1936 * send a set state command to the device by reading the current items->state
1937 * field. items is then filled with the current state.
1938 */
1939static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
1940 u8 feature_index,
1941 struct hidpp_touchpad_fw_items *items)
1942{
1943 struct hidpp_report response;
1944 int ret;
1945 u8 *params = (u8 *)response.fap.params;
1946
1947 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1948 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
1949
1950 if (ret > 0) {
1951 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1952 __func__, ret);
1953 return -EPROTO;
1954 }
1955 if (ret)
1956 return ret;
1957
1958 items->presence = params[0];
1959 items->desired_state = params[1];
1960 items->state = params[2];
1961 items->persistent = params[3];
1962
1963 return 0;
1964}
1965
1966/* -------------------------------------------------------------------------- */
1967/* 0x6100: TouchPadRawXY */
1968/* -------------------------------------------------------------------------- */
1969
1970#define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100
1971
1972#define CMD_TOUCHPAD_GET_RAW_INFO 0x00
1973#define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x20
1974
1975#define EVENT_TOUCHPAD_RAW_XY 0x00
1976
1977#define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01
1978#define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03
1979
1980struct hidpp_touchpad_raw_info {
1981 u16 x_size;
1982 u16 y_size;
1983 u8 z_range;
1984 u8 area_range;
1985 u8 timestamp_unit;
1986 u8 maxcontacts;
1987 u8 origin;
1988 u16 res;
1989};
1990
1991struct hidpp_touchpad_raw_xy_finger {
1992 u8 contact_type;
1993 u8 contact_status;
1994 u16 x;
1995 u16 y;
1996 u8 z;
1997 u8 area;
1998 u8 finger_id;
1999};
2000
2001struct hidpp_touchpad_raw_xy {
2002 u16 timestamp;
2003 struct hidpp_touchpad_raw_xy_finger fingers[2];
2004 u8 spurious_flag;
2005 u8 end_of_frame;
2006 u8 finger_count;
2007 u8 button;
2008};
2009
2010static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
2011 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
2012{
2013 struct hidpp_report response;
2014 int ret;
2015 u8 *params = (u8 *)response.fap.params;
2016
2017 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2018 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
2019
2020 if (ret > 0) {
2021 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2022 __func__, ret);
2023 return -EPROTO;
2024 }
2025 if (ret)
2026 return ret;
2027
2028 raw_info->x_size = get_unaligned_be16(¶ms[0]);
2029 raw_info->y_size = get_unaligned_be16(¶ms[2]);
2030 raw_info->z_range = params[4];
2031 raw_info->area_range = params[5];
2032 raw_info->maxcontacts = params[7];
2033 raw_info->origin = params[8];
2034 /* res is given in unit per inch */
2035 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51;
2036
2037 return ret;
2038}
2039
2040static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
2041 u8 feature_index, bool send_raw_reports,
2042 bool sensor_enhanced_settings)
2043{
2044 struct hidpp_report response;
2045
2046 /*
2047 * Params:
2048 * bit 0 - enable raw
2049 * bit 1 - 16bit Z, no area
2050 * bit 2 - enhanced sensitivity
2051 * bit 3 - width, height (4 bits each) instead of area
2052 * bit 4 - send raw + gestures (degrades smoothness)
2053 * remaining bits - reserved
2054 */
2055 u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
2056
2057 return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
2058 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response);
2059}
2060
2061static void hidpp_touchpad_touch_event(u8 *data,
2062 struct hidpp_touchpad_raw_xy_finger *finger)
2063{
2064 u8 x_m = data[0] << 2;
2065 u8 y_m = data[2] << 2;
2066
2067 finger->x = x_m << 6 | data[1];
2068 finger->y = y_m << 6 | data[3];
2069
2070 finger->contact_type = data[0] >> 6;
2071 finger->contact_status = data[2] >> 6;
2072
2073 finger->z = data[4];
2074 finger->area = data[5];
2075 finger->finger_id = data[6] >> 4;
2076}
2077
2078static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
2079 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
2080{
2081 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
2082 raw_xy->end_of_frame = data[8] & 0x01;
2083 raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
2084 raw_xy->finger_count = data[15] & 0x0f;
2085 raw_xy->button = (data[8] >> 2) & 0x01;
2086
2087 if (raw_xy->finger_count) {
2088 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
2089 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
2090 }
2091}
2092
2093/* -------------------------------------------------------------------------- */
2094/* 0x8123: Force feedback support */
2095/* -------------------------------------------------------------------------- */
2096
2097#define HIDPP_FF_GET_INFO 0x01
2098#define HIDPP_FF_RESET_ALL 0x11
2099#define HIDPP_FF_DOWNLOAD_EFFECT 0x21
2100#define HIDPP_FF_SET_EFFECT_STATE 0x31
2101#define HIDPP_FF_DESTROY_EFFECT 0x41
2102#define HIDPP_FF_GET_APERTURE 0x51
2103#define HIDPP_FF_SET_APERTURE 0x61
2104#define HIDPP_FF_GET_GLOBAL_GAINS 0x71
2105#define HIDPP_FF_SET_GLOBAL_GAINS 0x81
2106
2107#define HIDPP_FF_EFFECT_STATE_GET 0x00
2108#define HIDPP_FF_EFFECT_STATE_STOP 0x01
2109#define HIDPP_FF_EFFECT_STATE_PLAY 0x02
2110#define HIDPP_FF_EFFECT_STATE_PAUSE 0x03
2111
2112#define HIDPP_FF_EFFECT_CONSTANT 0x00
2113#define HIDPP_FF_EFFECT_PERIODIC_SINE 0x01
2114#define HIDPP_FF_EFFECT_PERIODIC_SQUARE 0x02
2115#define HIDPP_FF_EFFECT_PERIODIC_TRIANGLE 0x03
2116#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP 0x04
2117#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN 0x05
2118#define HIDPP_FF_EFFECT_SPRING 0x06
2119#define HIDPP_FF_EFFECT_DAMPER 0x07
2120#define HIDPP_FF_EFFECT_FRICTION 0x08
2121#define HIDPP_FF_EFFECT_INERTIA 0x09
2122#define HIDPP_FF_EFFECT_RAMP 0x0A
2123
2124#define HIDPP_FF_EFFECT_AUTOSTART 0x80
2125
2126#define HIDPP_FF_EFFECTID_NONE -1
2127#define HIDPP_FF_EFFECTID_AUTOCENTER -2
2128#define HIDPP_AUTOCENTER_PARAMS_LENGTH 18
2129
2130#define HIDPP_FF_MAX_PARAMS 20
2131#define HIDPP_FF_RESERVED_SLOTS 1
2132
2133struct hidpp_ff_private_data {
2134 struct hidpp_device *hidpp;
2135 u8 feature_index;
2136 u8 version;
2137 u16 gain;
2138 s16 range;
2139 u8 slot_autocenter;
2140 u8 num_effects;
2141 int *effect_ids;
2142 struct workqueue_struct *wq;
2143 atomic_t workqueue_size;
2144};
2145
2146struct hidpp_ff_work_data {
2147 struct work_struct work;
2148 struct hidpp_ff_private_data *data;
2149 int effect_id;
2150 u8 command;
2151 u8 params[HIDPP_FF_MAX_PARAMS];
2152 u8 size;
2153};
2154
2155static const signed short hidpp_ff_effects[] = {
2156 FF_CONSTANT,
2157 FF_PERIODIC,
2158 FF_SINE,
2159 FF_SQUARE,
2160 FF_SAW_UP,
2161 FF_SAW_DOWN,
2162 FF_TRIANGLE,
2163 FF_SPRING,
2164 FF_DAMPER,
2165 FF_AUTOCENTER,
2166 FF_GAIN,
2167 -1
2168};
2169
2170static const signed short hidpp_ff_effects_v2[] = {
2171 FF_RAMP,
2172 FF_FRICTION,
2173 FF_INERTIA,
2174 -1
2175};
2176
2177static const u8 HIDPP_FF_CONDITION_CMDS[] = {
2178 HIDPP_FF_EFFECT_SPRING,
2179 HIDPP_FF_EFFECT_FRICTION,
2180 HIDPP_FF_EFFECT_DAMPER,
2181 HIDPP_FF_EFFECT_INERTIA
2182};
2183
2184static const char *HIDPP_FF_CONDITION_NAMES[] = {
2185 "spring",
2186 "friction",
2187 "damper",
2188 "inertia"
2189};
2190
2191
2192static u8 hidpp_ff_find_effect(struct hidpp_ff_private_data *data, int effect_id)
2193{
2194 int i;
2195
2196 for (i = 0; i < data->num_effects; i++)
2197 if (data->effect_ids[i] == effect_id)
2198 return i+1;
2199
2200 return 0;
2201}
2202
2203static void hidpp_ff_work_handler(struct work_struct *w)
2204{
2205 struct hidpp_ff_work_data *wd = container_of(w, struct hidpp_ff_work_data, work);
2206 struct hidpp_ff_private_data *data = wd->data;
2207 struct hidpp_report response;
2208 u8 slot;
2209 int ret;
2210
2211 /* add slot number if needed */
2212 switch (wd->effect_id) {
2213 case HIDPP_FF_EFFECTID_AUTOCENTER:
2214 wd->params[0] = data->slot_autocenter;
2215 break;
2216 case HIDPP_FF_EFFECTID_NONE:
2217 /* leave slot as zero */
2218 break;
2219 default:
2220 /* find current slot for effect */
2221 wd->params[0] = hidpp_ff_find_effect(data, wd->effect_id);
2222 break;
2223 }
2224
2225 /* send command and wait for reply */
2226 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
2227 wd->command, wd->params, wd->size, &response);
2228
2229 if (ret) {
2230 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
2231 goto out;
2232 }
2233
2234 /* parse return data */
2235 switch (wd->command) {
2236 case HIDPP_FF_DOWNLOAD_EFFECT:
2237 slot = response.fap.params[0];
2238 if (slot > 0 && slot <= data->num_effects) {
2239 if (wd->effect_id >= 0)
2240 /* regular effect uploaded */
2241 data->effect_ids[slot-1] = wd->effect_id;
2242 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2243 /* autocenter spring uploaded */
2244 data->slot_autocenter = slot;
2245 }
2246 break;
2247 case HIDPP_FF_DESTROY_EFFECT:
2248 if (wd->effect_id >= 0)
2249 /* regular effect destroyed */
2250 data->effect_ids[wd->params[0]-1] = -1;
2251 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2252 /* autocenter spring destoyed */
2253 data->slot_autocenter = 0;
2254 break;
2255 case HIDPP_FF_SET_GLOBAL_GAINS:
2256 data->gain = (wd->params[0] << 8) + wd->params[1];
2257 break;
2258 case HIDPP_FF_SET_APERTURE:
2259 data->range = (wd->params[0] << 8) + wd->params[1];
2260 break;
2261 default:
2262 /* no action needed */
2263 break;
2264 }
2265
2266out:
2267 atomic_dec(&data->workqueue_size);
2268 kfree(wd);
2269}
2270
2271static int hidpp_ff_queue_work(struct hidpp_ff_private_data *data, int effect_id, u8 command, u8 *params, u8 size)
2272{
2273 struct hidpp_ff_work_data *wd = kzalloc(sizeof(*wd), GFP_KERNEL);
2274 int s;
2275
2276 if (!wd)
2277 return -ENOMEM;
2278
2279 INIT_WORK(&wd->work, hidpp_ff_work_handler);
2280
2281 wd->data = data;
2282 wd->effect_id = effect_id;
2283 wd->command = command;
2284 wd->size = size;
2285 memcpy(wd->params, params, size);
2286
2287 s = atomic_inc_return(&data->workqueue_size);
2288 queue_work(data->wq, &wd->work);
2289
2290 /* warn about excessive queue size */
2291 if (s >= 20 && s % 20 == 0)
2292 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2293
2294 return 0;
2295}
2296
2297static int hidpp_ff_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
2298{
2299 struct hidpp_ff_private_data *data = dev->ff->private;
2300 u8 params[20];
2301 u8 size;
2302 int force;
2303
2304 /* set common parameters */
2305 params[2] = effect->replay.length >> 8;
2306 params[3] = effect->replay.length & 255;
2307 params[4] = effect->replay.delay >> 8;
2308 params[5] = effect->replay.delay & 255;
2309
2310 switch (effect->type) {
2311 case FF_CONSTANT:
2312 force = (effect->u.constant.level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2313 params[1] = HIDPP_FF_EFFECT_CONSTANT;
2314 params[6] = force >> 8;
2315 params[7] = force & 255;
2316 params[8] = effect->u.constant.envelope.attack_level >> 7;
2317 params[9] = effect->u.constant.envelope.attack_length >> 8;
2318 params[10] = effect->u.constant.envelope.attack_length & 255;
2319 params[11] = effect->u.constant.envelope.fade_level >> 7;
2320 params[12] = effect->u.constant.envelope.fade_length >> 8;
2321 params[13] = effect->u.constant.envelope.fade_length & 255;
2322 size = 14;
2323 dbg_hid("Uploading constant force level=%d in dir %d = %d\n",
2324 effect->u.constant.level,
2325 effect->direction, force);
2326 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2327 effect->u.constant.envelope.attack_level,
2328 effect->u.constant.envelope.attack_length,
2329 effect->u.constant.envelope.fade_level,
2330 effect->u.constant.envelope.fade_length);
2331 break;
2332 case FF_PERIODIC:
2333 {
2334 switch (effect->u.periodic.waveform) {
2335 case FF_SINE:
2336 params[1] = HIDPP_FF_EFFECT_PERIODIC_SINE;
2337 break;
2338 case FF_SQUARE:
2339 params[1] = HIDPP_FF_EFFECT_PERIODIC_SQUARE;
2340 break;
2341 case FF_SAW_UP:
2342 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP;
2343 break;
2344 case FF_SAW_DOWN:
2345 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN;
2346 break;
2347 case FF_TRIANGLE:
2348 params[1] = HIDPP_FF_EFFECT_PERIODIC_TRIANGLE;
2349 break;
2350 default:
2351 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2352 return -EINVAL;
2353 }
2354 force = (effect->u.periodic.magnitude * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2355 params[6] = effect->u.periodic.magnitude >> 8;
2356 params[7] = effect->u.periodic.magnitude & 255;
2357 params[8] = effect->u.periodic.offset >> 8;
2358 params[9] = effect->u.periodic.offset & 255;
2359 params[10] = effect->u.periodic.period >> 8;
2360 params[11] = effect->u.periodic.period & 255;
2361 params[12] = effect->u.periodic.phase >> 8;
2362 params[13] = effect->u.periodic.phase & 255;
2363 params[14] = effect->u.periodic.envelope.attack_level >> 7;
2364 params[15] = effect->u.periodic.envelope.attack_length >> 8;
2365 params[16] = effect->u.periodic.envelope.attack_length & 255;
2366 params[17] = effect->u.periodic.envelope.fade_level >> 7;
2367 params[18] = effect->u.periodic.envelope.fade_length >> 8;
2368 params[19] = effect->u.periodic.envelope.fade_length & 255;
2369 size = 20;
2370 dbg_hid("Uploading periodic force mag=%d/dir=%d, offset=%d, period=%d ms, phase=%d\n",
2371 effect->u.periodic.magnitude, effect->direction,
2372 effect->u.periodic.offset,
2373 effect->u.periodic.period,
2374 effect->u.periodic.phase);
2375 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2376 effect->u.periodic.envelope.attack_level,
2377 effect->u.periodic.envelope.attack_length,
2378 effect->u.periodic.envelope.fade_level,
2379 effect->u.periodic.envelope.fade_length);
2380 break;
2381 }
2382 case FF_RAMP:
2383 params[1] = HIDPP_FF_EFFECT_RAMP;
2384 force = (effect->u.ramp.start_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2385 params[6] = force >> 8;
2386 params[7] = force & 255;
2387 force = (effect->u.ramp.end_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2388 params[8] = force >> 8;
2389 params[9] = force & 255;
2390 params[10] = effect->u.ramp.envelope.attack_level >> 7;
2391 params[11] = effect->u.ramp.envelope.attack_length >> 8;
2392 params[12] = effect->u.ramp.envelope.attack_length & 255;
2393 params[13] = effect->u.ramp.envelope.fade_level >> 7;
2394 params[14] = effect->u.ramp.envelope.fade_length >> 8;
2395 params[15] = effect->u.ramp.envelope.fade_length & 255;
2396 size = 16;
2397 dbg_hid("Uploading ramp force level=%d -> %d in dir %d = %d\n",
2398 effect->u.ramp.start_level,
2399 effect->u.ramp.end_level,
2400 effect->direction, force);
2401 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2402 effect->u.ramp.envelope.attack_level,
2403 effect->u.ramp.envelope.attack_length,
2404 effect->u.ramp.envelope.fade_level,
2405 effect->u.ramp.envelope.fade_length);
2406 break;
2407 case FF_FRICTION:
2408 case FF_INERTIA:
2409 case FF_SPRING:
2410 case FF_DAMPER:
2411 params[1] = HIDPP_FF_CONDITION_CMDS[effect->type - FF_SPRING];
2412 params[6] = effect->u.condition[0].left_saturation >> 9;
2413 params[7] = (effect->u.condition[0].left_saturation >> 1) & 255;
2414 params[8] = effect->u.condition[0].left_coeff >> 8;
2415 params[9] = effect->u.condition[0].left_coeff & 255;
2416 params[10] = effect->u.condition[0].deadband >> 9;
2417 params[11] = (effect->u.condition[0].deadband >> 1) & 255;
2418 params[12] = effect->u.condition[0].center >> 8;
2419 params[13] = effect->u.condition[0].center & 255;
2420 params[14] = effect->u.condition[0].right_coeff >> 8;
2421 params[15] = effect->u.condition[0].right_coeff & 255;
2422 params[16] = effect->u.condition[0].right_saturation >> 9;
2423 params[17] = (effect->u.condition[0].right_saturation >> 1) & 255;
2424 size = 18;
2425 dbg_hid("Uploading %s force left coeff=%d, left sat=%d, right coeff=%d, right sat=%d\n",
2426 HIDPP_FF_CONDITION_NAMES[effect->type - FF_SPRING],
2427 effect->u.condition[0].left_coeff,
2428 effect->u.condition[0].left_saturation,
2429 effect->u.condition[0].right_coeff,
2430 effect->u.condition[0].right_saturation);
2431 dbg_hid(" deadband=%d, center=%d\n",
2432 effect->u.condition[0].deadband,
2433 effect->u.condition[0].center);
2434 break;
2435 default:
2436 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2437 return -EINVAL;
2438 }
2439
2440 return hidpp_ff_queue_work(data, effect->id, HIDPP_FF_DOWNLOAD_EFFECT, params, size);
2441}
2442
2443static int hidpp_ff_playback(struct input_dev *dev, int effect_id, int value)
2444{
2445 struct hidpp_ff_private_data *data = dev->ff->private;
2446 u8 params[2];
2447
2448 params[1] = value ? HIDPP_FF_EFFECT_STATE_PLAY : HIDPP_FF_EFFECT_STATE_STOP;
2449
2450 dbg_hid("St%sing playback of effect %d.\n", value?"art":"opp", effect_id);
2451
2452 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_SET_EFFECT_STATE, params, ARRAY_SIZE(params));
2453}
2454
2455static int hidpp_ff_erase_effect(struct input_dev *dev, int effect_id)
2456{
2457 struct hidpp_ff_private_data *data = dev->ff->private;
2458 u8 slot = 0;
2459
2460 dbg_hid("Erasing effect %d.\n", effect_id);
2461
2462 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_DESTROY_EFFECT, &slot, 1);
2463}
2464
2465static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
2466{
2467 struct hidpp_ff_private_data *data = dev->ff->private;
2468 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH];
2469
2470 dbg_hid("Setting autocenter to %d.\n", magnitude);
2471
2472 /* start a standard spring effect */
2473 params[1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART;
2474 /* zero delay and duration */
2475 params[2] = params[3] = params[4] = params[5] = 0;
2476 /* set coeff to 25% of saturation */
2477 params[8] = params[14] = magnitude >> 11;
2478 params[9] = params[15] = (magnitude >> 3) & 255;
2479 params[6] = params[16] = magnitude >> 9;
2480 params[7] = params[17] = (magnitude >> 1) & 255;
2481 /* zero deadband and center */
2482 params[10] = params[11] = params[12] = params[13] = 0;
2483
2484 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_AUTOCENTER, HIDPP_FF_DOWNLOAD_EFFECT, params, ARRAY_SIZE(params));
2485}
2486
2487static void hidpp_ff_set_gain(struct input_dev *dev, u16 gain)
2488{
2489 struct hidpp_ff_private_data *data = dev->ff->private;
2490 u8 params[4];
2491
2492 dbg_hid("Setting gain to %d.\n", gain);
2493
2494 params[0] = gain >> 8;
2495 params[1] = gain & 255;
2496 params[2] = 0; /* no boost */
2497 params[3] = 0;
2498
2499 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_NONE, HIDPP_FF_SET_GLOBAL_GAINS, params, ARRAY_SIZE(params));
2500}
2501
2502static ssize_t hidpp_ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
2503{
2504 struct hid_device *hid = to_hid_device(dev);
2505 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2506 struct input_dev *idev = hidinput->input;
2507 struct hidpp_ff_private_data *data = idev->ff->private;
2508
2509 return scnprintf(buf, PAGE_SIZE, "%u\n", data->range);
2510}
2511
2512static ssize_t hidpp_ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2513{
2514 struct hid_device *hid = to_hid_device(dev);
2515 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2516 struct input_dev *idev = hidinput->input;
2517 struct hidpp_ff_private_data *data = idev->ff->private;
2518 u8 params[2];
2519 int range = simple_strtoul(buf, NULL, 10);
2520
2521 range = clamp(range, 180, 900);
2522
2523 params[0] = range >> 8;
2524 params[1] = range & 0x00FF;
2525
2526 hidpp_ff_queue_work(data, -1, HIDPP_FF_SET_APERTURE, params, ARRAY_SIZE(params));
2527
2528 return count;
2529}
2530
2531static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
2532
2533static void hidpp_ff_destroy(struct ff_device *ff)
2534{
2535 struct hidpp_ff_private_data *data = ff->private;
2536 struct hid_device *hid = data->hidpp->hid_dev;
2537
2538 hid_info(hid, "Unloading HID++ force feedback.\n");
2539
2540 device_remove_file(&hid->dev, &dev_attr_range);
2541 destroy_workqueue(data->wq);
2542 kfree(data->effect_ids);
2543}
2544
2545static int hidpp_ff_init(struct hidpp_device *hidpp,
2546 struct hidpp_ff_private_data *data)
2547{
2548 struct hid_device *hid = hidpp->hid_dev;
2549 struct hid_input *hidinput;
2550 struct input_dev *dev;
2551 struct usb_device_descriptor *udesc;
2552 u16 bcdDevice;
2553 struct ff_device *ff;
2554 int error, j, num_slots = data->num_effects;
2555 u8 version;
2556
2557 if (!hid_is_usb(hid)) {
2558 hid_err(hid, "device is not USB\n");
2559 return -ENODEV;
2560 }
2561
2562 if (list_empty(&hid->inputs)) {
2563 hid_err(hid, "no inputs found\n");
2564 return -ENODEV;
2565 }
2566 hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2567 dev = hidinput->input;
2568
2569 if (!dev) {
2570 hid_err(hid, "Struct input_dev not set!\n");
2571 return -EINVAL;
2572 }
2573
2574 /* Get firmware release */
2575 udesc = &(hid_to_usb_dev(hid)->descriptor);
2576 bcdDevice = le16_to_cpu(udesc->bcdDevice);
2577 version = bcdDevice & 255;
2578
2579 /* Set supported force feedback capabilities */
2580 for (j = 0; hidpp_ff_effects[j] >= 0; j++)
2581 set_bit(hidpp_ff_effects[j], dev->ffbit);
2582 if (version > 1)
2583 for (j = 0; hidpp_ff_effects_v2[j] >= 0; j++)
2584 set_bit(hidpp_ff_effects_v2[j], dev->ffbit);
2585
2586 error = input_ff_create(dev, num_slots);
2587
2588 if (error) {
2589 hid_err(dev, "Failed to create FF device!\n");
2590 return error;
2591 }
2592 /*
2593 * Create a copy of passed data, so we can transfer memory
2594 * ownership to FF core
2595 */
2596 data = kmemdup(data, sizeof(*data), GFP_KERNEL);
2597 if (!data)
2598 return -ENOMEM;
2599 data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
2600 if (!data->effect_ids) {
2601 kfree(data);
2602 return -ENOMEM;
2603 }
2604 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2605 if (!data->wq) {
2606 kfree(data->effect_ids);
2607 kfree(data);
2608 return -ENOMEM;
2609 }
2610
2611 data->hidpp = hidpp;
2612 data->version = version;
2613 for (j = 0; j < num_slots; j++)
2614 data->effect_ids[j] = -1;
2615
2616 ff = dev->ff;
2617 ff->private = data;
2618
2619 ff->upload = hidpp_ff_upload_effect;
2620 ff->erase = hidpp_ff_erase_effect;
2621 ff->playback = hidpp_ff_playback;
2622 ff->set_gain = hidpp_ff_set_gain;
2623 ff->set_autocenter = hidpp_ff_set_autocenter;
2624 ff->destroy = hidpp_ff_destroy;
2625
2626 /* Create sysfs interface */
2627 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2628 if (error)
2629 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2630
2631 /* init the hardware command queue */
2632 atomic_set(&data->workqueue_size, 0);
2633
2634 hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
2635 version);
2636
2637 return 0;
2638}
2639
2640/* ************************************************************************** */
2641/* */
2642/* Device Support */
2643/* */
2644/* ************************************************************************** */
2645
2646/* -------------------------------------------------------------------------- */
2647/* Touchpad HID++ devices */
2648/* -------------------------------------------------------------------------- */
2649
2650#define WTP_MANUAL_RESOLUTION 39
2651
2652struct wtp_data {
2653 u16 x_size, y_size;
2654 u8 finger_count;
2655 u8 mt_feature_index;
2656 u8 button_feature_index;
2657 u8 maxcontacts;
2658 bool flip_y;
2659 unsigned int resolution;
2660};
2661
2662static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2663 struct hid_field *field, struct hid_usage *usage,
2664 unsigned long **bit, int *max)
2665{
2666 return -1;
2667}
2668
2669static void wtp_populate_input(struct hidpp_device *hidpp,
2670 struct input_dev *input_dev)
2671{
2672 struct wtp_data *wd = hidpp->private_data;
2673
2674 __set_bit(EV_ABS, input_dev->evbit);
2675 __set_bit(EV_KEY, input_dev->evbit);
2676 __clear_bit(EV_REL, input_dev->evbit);
2677 __clear_bit(EV_LED, input_dev->evbit);
2678
2679 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
2680 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
2681 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
2682 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
2683
2684 /* Max pressure is not given by the devices, pick one */
2685 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
2686
2687 input_set_capability(input_dev, EV_KEY, BTN_LEFT);
2688
2689 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2690 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
2691 else
2692 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2693
2694 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
2695 INPUT_MT_DROP_UNUSED);
2696}
2697
2698static void wtp_touch_event(struct hidpp_device *hidpp,
2699 struct hidpp_touchpad_raw_xy_finger *touch_report)
2700{
2701 struct wtp_data *wd = hidpp->private_data;
2702 int slot;
2703
2704 if (!touch_report->finger_id || touch_report->contact_type)
2705 /* no actual data */
2706 return;
2707
2708 slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2709
2710 input_mt_slot(hidpp->input, slot);
2711 input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2712 touch_report->contact_status);
2713 if (touch_report->contact_status) {
2714 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2715 touch_report->x);
2716 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2717 wd->flip_y ? wd->y_size - touch_report->y :
2718 touch_report->y);
2719 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2720 touch_report->area);
2721 }
2722}
2723
2724static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
2725 struct hidpp_touchpad_raw_xy *raw)
2726{
2727 int i;
2728
2729 for (i = 0; i < 2; i++)
2730 wtp_touch_event(hidpp, &(raw->fingers[i]));
2731
2732 if (raw->end_of_frame &&
2733 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
2734 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
2735
2736 if (raw->end_of_frame || raw->finger_count <= 2) {
2737 input_mt_sync_frame(hidpp->input);
2738 input_sync(hidpp->input);
2739 }
2740}
2741
2742static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
2743{
2744 struct wtp_data *wd = hidpp->private_data;
2745 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
2746 (data[7] >> 4) * (data[7] >> 4)) / 2;
2747 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
2748 (data[13] >> 4) * (data[13] >> 4)) / 2;
2749 struct hidpp_touchpad_raw_xy raw = {
2750 .timestamp = data[1],
2751 .fingers = {
2752 {
2753 .contact_type = 0,
2754 .contact_status = !!data[7],
2755 .x = get_unaligned_le16(&data[3]),
2756 .y = get_unaligned_le16(&data[5]),
2757 .z = c1_area,
2758 .area = c1_area,
2759 .finger_id = data[2],
2760 }, {
2761 .contact_type = 0,
2762 .contact_status = !!data[13],
2763 .x = get_unaligned_le16(&data[9]),
2764 .y = get_unaligned_le16(&data[11]),
2765 .z = c2_area,
2766 .area = c2_area,
2767 .finger_id = data[8],
2768 }
2769 },
2770 .finger_count = wd->maxcontacts,
2771 .spurious_flag = 0,
2772 .end_of_frame = (data[0] >> 7) == 0,
2773 .button = data[0] & 0x01,
2774 };
2775
2776 wtp_send_raw_xy_event(hidpp, &raw);
2777
2778 return 1;
2779}
2780
2781static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
2782{
2783 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2784 struct wtp_data *wd = hidpp->private_data;
2785 struct hidpp_report *report = (struct hidpp_report *)data;
2786 struct hidpp_touchpad_raw_xy raw;
2787
2788 if (!wd || !hidpp->input)
2789 return 1;
2790
2791 switch (data[0]) {
2792 case 0x02:
2793 if (size < 2) {
2794 hid_err(hdev, "Received HID report of bad size (%d)",
2795 size);
2796 return 1;
2797 }
2798 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
2799 input_event(hidpp->input, EV_KEY, BTN_LEFT,
2800 !!(data[1] & 0x01));
2801 input_event(hidpp->input, EV_KEY, BTN_RIGHT,
2802 !!(data[1] & 0x02));
2803 input_sync(hidpp->input);
2804 return 0;
2805 } else {
2806 if (size < 21)
2807 return 1;
2808 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
2809 }
2810 case REPORT_ID_HIDPP_LONG:
2811 /* size is already checked in hidpp_raw_event. */
2812 if ((report->fap.feature_index != wd->mt_feature_index) ||
2813 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
2814 return 1;
2815 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
2816
2817 wtp_send_raw_xy_event(hidpp, &raw);
2818 return 0;
2819 }
2820
2821 return 0;
2822}
2823
2824static int wtp_get_config(struct hidpp_device *hidpp)
2825{
2826 struct wtp_data *wd = hidpp->private_data;
2827 struct hidpp_touchpad_raw_info raw_info = {0};
2828 u8 feature_type;
2829 int ret;
2830
2831 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
2832 &wd->mt_feature_index, &feature_type);
2833 if (ret)
2834 /* means that the device is not powered up */
2835 return ret;
2836
2837 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
2838 &raw_info);
2839 if (ret)
2840 return ret;
2841
2842 wd->x_size = raw_info.x_size;
2843 wd->y_size = raw_info.y_size;
2844 wd->maxcontacts = raw_info.maxcontacts;
2845 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
2846 wd->resolution = raw_info.res;
2847 if (!wd->resolution)
2848 wd->resolution = WTP_MANUAL_RESOLUTION;
2849
2850 return 0;
2851}
2852
2853static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
2854{
2855 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2856 struct wtp_data *wd;
2857
2858 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
2859 GFP_KERNEL);
2860 if (!wd)
2861 return -ENOMEM;
2862
2863 hidpp->private_data = wd;
2864
2865 return 0;
2866};
2867
2868static int wtp_connect(struct hid_device *hdev, bool connected)
2869{
2870 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2871 struct wtp_data *wd = hidpp->private_data;
2872 int ret;
2873
2874 if (!wd->x_size) {
2875 ret = wtp_get_config(hidpp);
2876 if (ret) {
2877 hid_err(hdev, "Can not get wtp config: %d\n", ret);
2878 return ret;
2879 }
2880 }
2881
2882 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
2883 true, true);
2884}
2885
2886/* ------------------------------------------------------------------------- */
2887/* Logitech M560 devices */
2888/* ------------------------------------------------------------------------- */
2889
2890/*
2891 * Logitech M560 protocol overview
2892 *
2893 * The Logitech M560 mouse, is designed for windows 8. When the middle and/or
2894 * the sides buttons are pressed, it sends some keyboard keys events
2895 * instead of buttons ones.
2896 * To complicate things further, the middle button keys sequence
2897 * is different from the odd press and the even press.
2898 *
2899 * forward button -> Super_R
2900 * backward button -> Super_L+'d' (press only)
2901 * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only)
2902 * 2nd time: left-click (press only)
2903 * NB: press-only means that when the button is pressed, the
2904 * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated
2905 * together sequentially; instead when the button is released, no event is
2906 * generated !
2907 *
2908 * With the command
2909 * 10<xx>0a 3500af03 (where <xx> is the mouse id),
2910 * the mouse reacts differently:
2911 * - it never sends a keyboard key event
2912 * - for the three mouse button it sends:
2913 * middle button press 11<xx>0a 3500af00...
2914 * side 1 button (forward) press 11<xx>0a 3500b000...
2915 * side 2 button (backward) press 11<xx>0a 3500ae00...
2916 * middle/side1/side2 button release 11<xx>0a 35000000...
2917 */
2918
2919static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
2920
2921/* how buttons are mapped in the report */
2922#define M560_MOUSE_BTN_LEFT 0x01
2923#define M560_MOUSE_BTN_RIGHT 0x02
2924#define M560_MOUSE_BTN_WHEEL_LEFT 0x08
2925#define M560_MOUSE_BTN_WHEEL_RIGHT 0x10
2926
2927#define M560_SUB_ID 0x0a
2928#define M560_BUTTON_MODE_REGISTER 0x35
2929
2930static int m560_send_config_command(struct hid_device *hdev, bool connected)
2931{
2932 struct hidpp_report response;
2933 struct hidpp_device *hidpp_dev;
2934
2935 hidpp_dev = hid_get_drvdata(hdev);
2936
2937 return hidpp_send_rap_command_sync(
2938 hidpp_dev,
2939 REPORT_ID_HIDPP_SHORT,
2940 M560_SUB_ID,
2941 M560_BUTTON_MODE_REGISTER,
2942 (u8 *)m560_config_parameter,
2943 sizeof(m560_config_parameter),
2944 &response
2945 );
2946}
2947
2948static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
2949{
2950 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2951
2952 /* sanity check */
2953 if (!hidpp->input) {
2954 hid_err(hdev, "error in parameter\n");
2955 return -EINVAL;
2956 }
2957
2958 if (size < 7) {
2959 hid_err(hdev, "error in report\n");
2960 return 0;
2961 }
2962
2963 if (data[0] == REPORT_ID_HIDPP_LONG &&
2964 data[2] == M560_SUB_ID && data[6] == 0x00) {
2965 /*
2966 * m560 mouse report for middle, forward and backward button
2967 *
2968 * data[0] = 0x11
2969 * data[1] = device-id
2970 * data[2] = 0x0a
2971 * data[5] = 0xaf -> middle
2972 * 0xb0 -> forward
2973 * 0xae -> backward
2974 * 0x00 -> release all
2975 * data[6] = 0x00
2976 */
2977
2978 switch (data[5]) {
2979 case 0xaf:
2980 input_report_key(hidpp->input, BTN_MIDDLE, 1);
2981 break;
2982 case 0xb0:
2983 input_report_key(hidpp->input, BTN_FORWARD, 1);
2984 break;
2985 case 0xae:
2986 input_report_key(hidpp->input, BTN_BACK, 1);
2987 break;
2988 case 0x00:
2989 input_report_key(hidpp->input, BTN_BACK, 0);
2990 input_report_key(hidpp->input, BTN_FORWARD, 0);
2991 input_report_key(hidpp->input, BTN_MIDDLE, 0);
2992 break;
2993 default:
2994 hid_err(hdev, "error in report\n");
2995 return 0;
2996 }
2997 input_sync(hidpp->input);
2998
2999 } else if (data[0] == 0x02) {
3000 /*
3001 * Logitech M560 mouse report
3002 *
3003 * data[0] = type (0x02)
3004 * data[1..2] = buttons
3005 * data[3..5] = xy
3006 * data[6] = wheel
3007 */
3008
3009 int v;
3010
3011 input_report_key(hidpp->input, BTN_LEFT,
3012 !!(data[1] & M560_MOUSE_BTN_LEFT));
3013 input_report_key(hidpp->input, BTN_RIGHT,
3014 !!(data[1] & M560_MOUSE_BTN_RIGHT));
3015
3016 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
3017 input_report_rel(hidpp->input, REL_HWHEEL, -1);
3018 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3019 -120);
3020 } else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
3021 input_report_rel(hidpp->input, REL_HWHEEL, 1);
3022 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3023 120);
3024 }
3025
3026 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
3027 input_report_rel(hidpp->input, REL_X, v);
3028
3029 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
3030 input_report_rel(hidpp->input, REL_Y, v);
3031
3032 v = hid_snto32(data[6], 8);
3033 if (v != 0)
3034 hidpp_scroll_counter_handle_scroll(hidpp->input,
3035 &hidpp->vertical_wheel_counter, v);
3036
3037 input_sync(hidpp->input);
3038 }
3039
3040 return 1;
3041}
3042
3043static void m560_populate_input(struct hidpp_device *hidpp,
3044 struct input_dev *input_dev)
3045{
3046 __set_bit(EV_KEY, input_dev->evbit);
3047 __set_bit(BTN_MIDDLE, input_dev->keybit);
3048 __set_bit(BTN_RIGHT, input_dev->keybit);
3049 __set_bit(BTN_LEFT, input_dev->keybit);
3050 __set_bit(BTN_BACK, input_dev->keybit);
3051 __set_bit(BTN_FORWARD, input_dev->keybit);
3052
3053 __set_bit(EV_REL, input_dev->evbit);
3054 __set_bit(REL_X, input_dev->relbit);
3055 __set_bit(REL_Y, input_dev->relbit);
3056 __set_bit(REL_WHEEL, input_dev->relbit);
3057 __set_bit(REL_HWHEEL, input_dev->relbit);
3058 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3059 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3060}
3061
3062static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3063 struct hid_field *field, struct hid_usage *usage,
3064 unsigned long **bit, int *max)
3065{
3066 return -1;
3067}
3068
3069/* ------------------------------------------------------------------------- */
3070/* Logitech K400 devices */
3071/* ------------------------------------------------------------------------- */
3072
3073/*
3074 * The Logitech K400 keyboard has an embedded touchpad which is seen
3075 * as a mouse from the OS point of view. There is a hardware shortcut to disable
3076 * tap-to-click but the setting is not remembered accross reset, annoying some
3077 * users.
3078 *
3079 * We can toggle this feature from the host by using the feature 0x6010:
3080 * Touchpad FW items
3081 */
3082
3083struct k400_private_data {
3084 u8 feature_index;
3085};
3086
3087static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
3088{
3089 struct k400_private_data *k400 = hidpp->private_data;
3090 struct hidpp_touchpad_fw_items items = {};
3091 int ret;
3092 u8 feature_type;
3093
3094 if (!k400->feature_index) {
3095 ret = hidpp_root_get_feature(hidpp,
3096 HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
3097 &k400->feature_index, &feature_type);
3098 if (ret)
3099 /* means that the device is not powered up */
3100 return ret;
3101 }
3102
3103 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
3104 if (ret)
3105 return ret;
3106
3107 return 0;
3108}
3109
3110static int k400_allocate(struct hid_device *hdev)
3111{
3112 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3113 struct k400_private_data *k400;
3114
3115 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
3116 GFP_KERNEL);
3117 if (!k400)
3118 return -ENOMEM;
3119
3120 hidpp->private_data = k400;
3121
3122 return 0;
3123};
3124
3125static int k400_connect(struct hid_device *hdev, bool connected)
3126{
3127 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3128
3129 if (!disable_tap_to_click)
3130 return 0;
3131
3132 return k400_disable_tap_to_click(hidpp);
3133}
3134
3135/* ------------------------------------------------------------------------- */
3136/* Logitech G920 Driving Force Racing Wheel for Xbox One */
3137/* ------------------------------------------------------------------------- */
3138
3139#define HIDPP_PAGE_G920_FORCE_FEEDBACK 0x8123
3140
3141static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
3142 struct hidpp_ff_private_data *data)
3143{
3144 struct hidpp_report response;
3145 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH] = {
3146 [1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART,
3147 };
3148 int ret;
3149
3150 /* initialize with zero autocenter to get wheel in usable state */
3151
3152 dbg_hid("Setting autocenter to 0.\n");
3153 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3154 HIDPP_FF_DOWNLOAD_EFFECT,
3155 params, ARRAY_SIZE(params),
3156 &response);
3157 if (ret)
3158 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
3159 else
3160 data->slot_autocenter = response.fap.params[0];
3161
3162 return ret;
3163}
3164
3165static int g920_get_config(struct hidpp_device *hidpp,
3166 struct hidpp_ff_private_data *data)
3167{
3168 struct hidpp_report response;
3169 u8 feature_type;
3170 int ret;
3171
3172 memset(data, 0, sizeof(*data));
3173
3174 /* Find feature and store for later use */
3175 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
3176 &data->feature_index, &feature_type);
3177 if (ret)
3178 return ret;
3179
3180 /* Read number of slots available in device */
3181 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3182 HIDPP_FF_GET_INFO,
3183 NULL, 0,
3184 &response);
3185 if (ret) {
3186 if (ret < 0)
3187 return ret;
3188 hid_err(hidpp->hid_dev,
3189 "%s: received protocol error 0x%02x\n", __func__, ret);
3190 return -EPROTO;
3191 }
3192
3193 data->num_effects = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
3194
3195 /* reset all forces */
3196 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3197 HIDPP_FF_RESET_ALL,
3198 NULL, 0,
3199 &response);
3200 if (ret)
3201 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
3202
3203 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3204 HIDPP_FF_GET_APERTURE,
3205 NULL, 0,
3206 &response);
3207 if (ret) {
3208 hid_warn(hidpp->hid_dev,
3209 "Failed to read range from device!\n");
3210 }
3211 data->range = ret ?
3212 900 : get_unaligned_be16(&response.fap.params[0]);
3213
3214 /* Read the current gain values */
3215 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3216 HIDPP_FF_GET_GLOBAL_GAINS,
3217 NULL, 0,
3218 &response);
3219 if (ret)
3220 hid_warn(hidpp->hid_dev,
3221 "Failed to read gain values from device!\n");
3222 data->gain = ret ?
3223 0xffff : get_unaligned_be16(&response.fap.params[0]);
3224
3225 /* ignore boost value at response.fap.params[2] */
3226
3227 return g920_ff_set_autocenter(hidpp, data);
3228}
3229
3230/* -------------------------------------------------------------------------- */
3231/* Logitech Dinovo Mini keyboard with builtin touchpad */
3232/* -------------------------------------------------------------------------- */
3233#define DINOVO_MINI_PRODUCT_ID 0xb30c
3234
3235static int lg_dinovo_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3236 struct hid_field *field, struct hid_usage *usage,
3237 unsigned long **bit, int *max)
3238{
3239 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
3240 return 0;
3241
3242 switch (usage->hid & HID_USAGE) {
3243 case 0x00d: lg_map_key_clear(KEY_MEDIA); break;
3244 default:
3245 return 0;
3246 }
3247 return 1;
3248}
3249
3250/* -------------------------------------------------------------------------- */
3251/* HID++1.0 devices which use HID++ reports for their wheels */
3252/* -------------------------------------------------------------------------- */
3253static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
3254{
3255 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3256 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT,
3257 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT);
3258}
3259
3260static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
3261 u8 *data, int size)
3262{
3263 s8 value, hvalue;
3264
3265 if (!hidpp->input)
3266 return -EINVAL;
3267
3268 if (size < 7)
3269 return 0;
3270
3271 if (data[0] != REPORT_ID_HIDPP_SHORT || data[2] != HIDPP_SUB_ID_ROLLER)
3272 return 0;
3273
3274 value = data[3];
3275 hvalue = data[4];
3276
3277 input_report_rel(hidpp->input, REL_WHEEL, value);
3278 input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
3279 input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
3280 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
3281 input_sync(hidpp->input);
3282
3283 return 1;
3284}
3285
3286static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
3287 struct input_dev *input_dev)
3288{
3289 __set_bit(EV_REL, input_dev->evbit);
3290 __set_bit(REL_WHEEL, input_dev->relbit);
3291 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3292 __set_bit(REL_HWHEEL, input_dev->relbit);
3293 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3294}
3295
3296/* -------------------------------------------------------------------------- */
3297/* HID++1.0 mice which use HID++ reports for extra mouse buttons */
3298/* -------------------------------------------------------------------------- */
3299static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3300{
3301 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3302 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
3303 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
3304}
3305
3306static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3307 u8 *data, int size)
3308{
3309 int i;
3310
3311 if (!hidpp->input)
3312 return -EINVAL;
3313
3314 if (size < 7)
3315 return 0;
3316
3317 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3318 data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
3319 return 0;
3320
3321 /*
3322 * Buttons are either delivered through the regular mouse report *or*
3323 * through the extra buttons report. At least for button 6 how it is
3324 * delivered differs per receiver firmware version. Even receivers with
3325 * the same usb-id show different behavior, so we handle both cases.
3326 */
3327 for (i = 0; i < 8; i++)
3328 input_report_key(hidpp->input, BTN_MOUSE + i,
3329 (data[3] & (1 << i)));
3330
3331 /* Some mice report events on button 9+, use BTN_MISC */
3332 for (i = 0; i < 8; i++)
3333 input_report_key(hidpp->input, BTN_MISC + i,
3334 (data[4] & (1 << i)));
3335
3336 input_sync(hidpp->input);
3337 return 1;
3338}
3339
3340static void hidpp10_extra_mouse_buttons_populate_input(
3341 struct hidpp_device *hidpp, struct input_dev *input_dev)
3342{
3343 /* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
3344 __set_bit(BTN_0, input_dev->keybit);
3345 __set_bit(BTN_1, input_dev->keybit);
3346 __set_bit(BTN_2, input_dev->keybit);
3347 __set_bit(BTN_3, input_dev->keybit);
3348 __set_bit(BTN_4, input_dev->keybit);
3349 __set_bit(BTN_5, input_dev->keybit);
3350 __set_bit(BTN_6, input_dev->keybit);
3351 __set_bit(BTN_7, input_dev->keybit);
3352}
3353
3354/* -------------------------------------------------------------------------- */
3355/* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
3356/* -------------------------------------------------------------------------- */
3357
3358/* Find the consumer-page input report desc and change Maximums to 0x107f */
3359static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3360 u8 *_rdesc, unsigned int *rsize)
3361{
3362 /* Note 0 terminated so we can use strnstr to search for this. */
3363 static const char consumer_rdesc_start[] = {
3364 0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
3365 0x09, 0x01, /* USAGE (Consumer Control) */
3366 0xA1, 0x01, /* COLLECTION (Application) */
3367 0x85, 0x03, /* REPORT_ID = 3 */
3368 0x75, 0x10, /* REPORT_SIZE (16) */
3369 0x95, 0x02, /* REPORT_COUNT (2) */
3370 0x15, 0x01, /* LOGICAL_MIN (1) */
3371 0x26, 0x00 /* LOGICAL_MAX (... */
3372 };
3373 char *consumer_rdesc, *rdesc = (char *)_rdesc;
3374 unsigned int size;
3375
3376 consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
3377 size = *rsize - (consumer_rdesc - rdesc);
3378 if (consumer_rdesc && size >= 25) {
3379 consumer_rdesc[15] = 0x7f;
3380 consumer_rdesc[16] = 0x10;
3381 consumer_rdesc[20] = 0x7f;
3382 consumer_rdesc[21] = 0x10;
3383 }
3384 return _rdesc;
3385}
3386
3387static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3388{
3389 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3390 HIDPP_ENABLE_CONSUMER_REPORT,
3391 HIDPP_ENABLE_CONSUMER_REPORT);
3392}
3393
3394static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3395 u8 *data, int size)
3396{
3397 u8 consumer_report[5];
3398
3399 if (size < 7)
3400 return 0;
3401
3402 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3403 data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
3404 return 0;
3405
3406 /*
3407 * Build a normal consumer report (3) out of the data, this detour
3408 * is necessary to get some keyboards to report their 0x10xx usages.
3409 */
3410 consumer_report[0] = 0x03;
3411 memcpy(&consumer_report[1], &data[3], 4);
3412 /* We are called from atomic context */
3413 hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3414 consumer_report, 5, 1);
3415
3416 return 1;
3417}
3418
3419/* -------------------------------------------------------------------------- */
3420/* High-resolution scroll wheels */
3421/* -------------------------------------------------------------------------- */
3422
3423static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3424{
3425 int ret;
3426 u8 multiplier = 1;
3427
3428 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL) {
3429 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3430 if (ret == 0)
3431 ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3432 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL) {
3433 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3434 &multiplier);
3435 } else /* if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL) */ {
3436 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3437 multiplier = 8;
3438 }
3439 if (ret)
3440 return ret;
3441
3442 if (multiplier == 0)
3443 multiplier = 1;
3444
3445 hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3446 hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3447 return 0;
3448}
3449
3450static int hidpp_initialize_hires_scroll(struct hidpp_device *hidpp)
3451{
3452 int ret;
3453 unsigned long capabilities;
3454
3455 capabilities = hidpp->capabilities;
3456
3457 if (hidpp->protocol_major >= 2) {
3458 u8 feature_index;
3459 u8 feature_type;
3460
3461 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
3462 &feature_index, &feature_type);
3463 if (!ret) {
3464 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL;
3465 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scroll wheel\n");
3466 return 0;
3467 }
3468 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
3469 &feature_index, &feature_type);
3470 if (!ret) {
3471 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL;
3472 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scrolling\n");
3473 }
3474 } else {
3475 struct hidpp_report response;
3476
3477 ret = hidpp_send_rap_command_sync(hidpp,
3478 REPORT_ID_HIDPP_SHORT,
3479 HIDPP_GET_REGISTER,
3480 HIDPP_ENABLE_FAST_SCROLL,
3481 NULL, 0, &response);
3482 if (!ret) {
3483 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL;
3484 hid_dbg(hidpp->hid_dev, "Detected HID++ 1.0 fast scroll\n");
3485 }
3486 }
3487
3488 if (hidpp->capabilities == capabilities)
3489 hid_dbg(hidpp->hid_dev, "Did not detect HID++ hi-res scrolling hardware support\n");
3490 return 0;
3491}
3492
3493/* -------------------------------------------------------------------------- */
3494/* Generic HID++ devices */
3495/* -------------------------------------------------------------------------- */
3496
3497static u8 *hidpp_report_fixup(struct hid_device *hdev, u8 *rdesc,
3498 unsigned int *rsize)
3499{
3500 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3501
3502 if (!hidpp)
3503 return rdesc;
3504
3505 /* For 27 MHz keyboards the quirk gets set after hid_parse. */
3506 if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE ||
3507 (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3508 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3509
3510 return rdesc;
3511}
3512
3513static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3514 struct hid_field *field, struct hid_usage *usage,
3515 unsigned long **bit, int *max)
3516{
3517 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3518
3519 if (!hidpp)
3520 return 0;
3521
3522 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3523 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
3524 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3525 field->application != HID_GD_MOUSE)
3526 return m560_input_mapping(hdev, hi, field, usage, bit, max);
3527
3528 if (hdev->product == DINOVO_MINI_PRODUCT_ID)
3529 return lg_dinovo_input_mapping(hdev, hi, field, usage, bit, max);
3530
3531 return 0;
3532}
3533
3534static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
3535 struct hid_field *field, struct hid_usage *usage,
3536 unsigned long **bit, int *max)
3537{
3538 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3539
3540 if (!hidpp)
3541 return 0;
3542
3543 /* Ensure that Logitech G920 is not given a default fuzz/flat value */
3544 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3545 if (usage->type == EV_ABS && (usage->code == ABS_X ||
3546 usage->code == ABS_Y || usage->code == ABS_Z ||
3547 usage->code == ABS_RZ)) {
3548 field->application = HID_GD_MULTIAXIS;
3549 }
3550 }
3551
3552 return 0;
3553}
3554
3555
3556static void hidpp_populate_input(struct hidpp_device *hidpp,
3557 struct input_dev *input)
3558{
3559 hidpp->input = input;
3560
3561 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3562 wtp_populate_input(hidpp, input);
3563 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3564 m560_populate_input(hidpp, input);
3565
3566 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3567 hidpp10_wheel_populate_input(hidpp, input);
3568
3569 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3570 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3571}
3572
3573static int hidpp_input_configured(struct hid_device *hdev,
3574 struct hid_input *hidinput)
3575{
3576 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3577 struct input_dev *input = hidinput->input;
3578
3579 if (!hidpp)
3580 return 0;
3581
3582 hidpp_populate_input(hidpp, input);
3583
3584 return 0;
3585}
3586
3587static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3588 int size)
3589{
3590 struct hidpp_report *question = hidpp->send_receive_buf;
3591 struct hidpp_report *answer = hidpp->send_receive_buf;
3592 struct hidpp_report *report = (struct hidpp_report *)data;
3593 int ret;
3594
3595 /*
3596 * If the mutex is locked then we have a pending answer from a
3597 * previously sent command.
3598 */
3599 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3600 /*
3601 * Check for a correct hidpp20 answer or the corresponding
3602 * error
3603 */
3604 if (hidpp_match_answer(question, report) ||
3605 hidpp_match_error(question, report)) {
3606 *answer = *report;
3607 hidpp->answer_available = true;
3608 wake_up(&hidpp->wait);
3609 /*
3610 * This was an answer to a command that this driver sent
3611 * We return 1 to hid-core to avoid forwarding the
3612 * command upstream as it has been treated by the driver
3613 */
3614
3615 return 1;
3616 }
3617 }
3618
3619 if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3620 atomic_set(&hidpp->connected,
3621 !(report->rap.params[0] & (1 << 6)));
3622 if (schedule_work(&hidpp->work) == 0)
3623 dbg_hid("%s: connect event already queued\n", __func__);
3624 return 1;
3625 }
3626
3627 if (hidpp->hid_dev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3628 data[0] == REPORT_ID_HIDPP_SHORT &&
3629 data[2] == HIDPP_SUB_ID_USER_IFACE_EVENT &&
3630 (data[3] & HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST)) {
3631 dev_err_ratelimited(&hidpp->hid_dev->dev,
3632 "Error the keyboard's wireless encryption key has been lost, your keyboard will not work unless you re-configure encryption.\n");
3633 dev_err_ratelimited(&hidpp->hid_dev->dev,
3634 "See: https://gitlab.freedesktop.org/jwrdegoede/logitech-27mhz-keyboard-encryption-setup/\n");
3635 }
3636
3637 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3638 ret = hidpp20_battery_event_1000(hidpp, data, size);
3639 if (ret != 0)
3640 return ret;
3641 ret = hidpp20_battery_event_1004(hidpp, data, size);
3642 if (ret != 0)
3643 return ret;
3644 ret = hidpp_solar_battery_event(hidpp, data, size);
3645 if (ret != 0)
3646 return ret;
3647 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3648 if (ret != 0)
3649 return ret;
3650 }
3651
3652 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3653 ret = hidpp10_battery_event(hidpp, data, size);
3654 if (ret != 0)
3655 return ret;
3656 }
3657
3658 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3659 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3660 if (ret != 0)
3661 return ret;
3662 }
3663
3664 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3665 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3666 if (ret != 0)
3667 return ret;
3668 }
3669
3670 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3671 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3672 if (ret != 0)
3673 return ret;
3674 }
3675
3676 return 0;
3677}
3678
3679static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
3680 u8 *data, int size)
3681{
3682 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3683 int ret = 0;
3684
3685 if (!hidpp)
3686 return 0;
3687
3688 /* Generic HID++ processing. */
3689 switch (data[0]) {
3690 case REPORT_ID_HIDPP_VERY_LONG:
3691 if (size != hidpp->very_long_report_length) {
3692 hid_err(hdev, "received hid++ report of bad size (%d)",
3693 size);
3694 return 1;
3695 }
3696 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3697 break;
3698 case REPORT_ID_HIDPP_LONG:
3699 if (size != HIDPP_REPORT_LONG_LENGTH) {
3700 hid_err(hdev, "received hid++ report of bad size (%d)",
3701 size);
3702 return 1;
3703 }
3704 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3705 break;
3706 case REPORT_ID_HIDPP_SHORT:
3707 if (size != HIDPP_REPORT_SHORT_LENGTH) {
3708 hid_err(hdev, "received hid++ report of bad size (%d)",
3709 size);
3710 return 1;
3711 }
3712 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3713 break;
3714 }
3715
3716 /* If no report is available for further processing, skip calling
3717 * raw_event of subclasses. */
3718 if (ret != 0)
3719 return ret;
3720
3721 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3722 return wtp_raw_event(hdev, data, size);
3723 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3724 return m560_raw_event(hdev, data, size);
3725
3726 return 0;
3727}
3728
3729static int hidpp_event(struct hid_device *hdev, struct hid_field *field,
3730 struct hid_usage *usage, __s32 value)
3731{
3732 /* This function will only be called for scroll events, due to the
3733 * restriction imposed in hidpp_usages.
3734 */
3735 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3736 struct hidpp_scroll_counter *counter;
3737
3738 if (!hidpp)
3739 return 0;
3740
3741 counter = &hidpp->vertical_wheel_counter;
3742 /* A scroll event may occur before the multiplier has been retrieved or
3743 * the input device set, or high-res scroll enabling may fail. In such
3744 * cases we must return early (falling back to default behaviour) to
3745 * avoid a crash in hidpp_scroll_counter_handle_scroll.
3746 */
3747 if (!(hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
3748 || value == 0 || hidpp->input == NULL
3749 || counter->wheel_multiplier == 0)
3750 return 0;
3751
3752 hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
3753 return 1;
3754}
3755
3756static int hidpp_initialize_battery(struct hidpp_device *hidpp)
3757{
3758 static atomic_t battery_no = ATOMIC_INIT(0);
3759 struct power_supply_config cfg = { .drv_data = hidpp };
3760 struct power_supply_desc *desc = &hidpp->battery.desc;
3761 enum power_supply_property *battery_props;
3762 struct hidpp_battery *battery;
3763 unsigned int num_battery_props;
3764 unsigned long n;
3765 int ret;
3766
3767 if (hidpp->battery.ps)
3768 return 0;
3769
3770 hidpp->battery.feature_index = 0xff;
3771 hidpp->battery.solar_feature_index = 0xff;
3772 hidpp->battery.voltage_feature_index = 0xff;
3773
3774 if (hidpp->protocol_major >= 2) {
3775 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
3776 ret = hidpp_solar_request_battery_event(hidpp);
3777 else {
3778 /* we only support one battery feature right now, so let's
3779 first check the ones that support battery level first
3780 and leave voltage for last */
3781 ret = hidpp20_query_battery_info_1000(hidpp);
3782 if (ret)
3783 ret = hidpp20_query_battery_info_1004(hidpp);
3784 if (ret)
3785 ret = hidpp20_query_battery_voltage_info(hidpp);
3786 }
3787
3788 if (ret)
3789 return ret;
3790 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
3791 } else {
3792 ret = hidpp10_query_battery_status(hidpp);
3793 if (ret) {
3794 ret = hidpp10_query_battery_mileage(hidpp);
3795 if (ret)
3796 return -ENOENT;
3797 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
3798 } else {
3799 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
3800 }
3801 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
3802 }
3803
3804 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
3805 hidpp_battery_props,
3806 sizeof(hidpp_battery_props),
3807 GFP_KERNEL);
3808 if (!battery_props)
3809 return -ENOMEM;
3810
3811 num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 3;
3812
3813 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE ||
3814 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE ||
3815 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3816 battery_props[num_battery_props++] =
3817 POWER_SUPPLY_PROP_CAPACITY;
3818
3819 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
3820 battery_props[num_battery_props++] =
3821 POWER_SUPPLY_PROP_CAPACITY_LEVEL;
3822
3823 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3824 battery_props[num_battery_props++] =
3825 POWER_SUPPLY_PROP_VOLTAGE_NOW;
3826
3827 battery = &hidpp->battery;
3828
3829 n = atomic_inc_return(&battery_no) - 1;
3830 desc->properties = battery_props;
3831 desc->num_properties = num_battery_props;
3832 desc->get_property = hidpp_battery_get_property;
3833 sprintf(battery->name, "hidpp_battery_%ld", n);
3834 desc->name = battery->name;
3835 desc->type = POWER_SUPPLY_TYPE_BATTERY;
3836 desc->use_for_apm = 0;
3837
3838 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
3839 &battery->desc,
3840 &cfg);
3841 if (IS_ERR(battery->ps))
3842 return PTR_ERR(battery->ps);
3843
3844 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
3845
3846 return ret;
3847}
3848
3849static void hidpp_overwrite_name(struct hid_device *hdev)
3850{
3851 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3852 char *name;
3853
3854 if (hidpp->protocol_major < 2)
3855 return;
3856
3857 name = hidpp_get_device_name(hidpp);
3858
3859 if (!name) {
3860 hid_err(hdev, "unable to retrieve the name of the device");
3861 } else {
3862 dbg_hid("HID++: Got name: %s\n", name);
3863 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
3864 }
3865
3866 kfree(name);
3867}
3868
3869static int hidpp_input_open(struct input_dev *dev)
3870{
3871 struct hid_device *hid = input_get_drvdata(dev);
3872
3873 return hid_hw_open(hid);
3874}
3875
3876static void hidpp_input_close(struct input_dev *dev)
3877{
3878 struct hid_device *hid = input_get_drvdata(dev);
3879
3880 hid_hw_close(hid);
3881}
3882
3883static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
3884{
3885 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
3886 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3887
3888 if (!input_dev)
3889 return NULL;
3890
3891 input_set_drvdata(input_dev, hdev);
3892 input_dev->open = hidpp_input_open;
3893 input_dev->close = hidpp_input_close;
3894
3895 input_dev->name = hidpp->name;
3896 input_dev->phys = hdev->phys;
3897 input_dev->uniq = hdev->uniq;
3898 input_dev->id.bustype = hdev->bus;
3899 input_dev->id.vendor = hdev->vendor;
3900 input_dev->id.product = hdev->product;
3901 input_dev->id.version = hdev->version;
3902 input_dev->dev.parent = &hdev->dev;
3903
3904 return input_dev;
3905}
3906
3907static void hidpp_connect_event(struct hidpp_device *hidpp)
3908{
3909 struct hid_device *hdev = hidpp->hid_dev;
3910 int ret = 0;
3911 bool connected = atomic_read(&hidpp->connected);
3912 struct input_dev *input;
3913 char *name, *devm_name;
3914
3915 if (!connected) {
3916 if (hidpp->battery.ps) {
3917 hidpp->battery.online = false;
3918 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
3919 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
3920 power_supply_changed(hidpp->battery.ps);
3921 }
3922 return;
3923 }
3924
3925 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
3926 ret = wtp_connect(hdev, connected);
3927 if (ret)
3928 return;
3929 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
3930 ret = m560_send_config_command(hdev, connected);
3931 if (ret)
3932 return;
3933 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
3934 ret = k400_connect(hdev, connected);
3935 if (ret)
3936 return;
3937 }
3938
3939 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3940 ret = hidpp10_wheel_connect(hidpp);
3941 if (ret)
3942 return;
3943 }
3944
3945 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3946 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
3947 if (ret)
3948 return;
3949 }
3950
3951 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3952 ret = hidpp10_consumer_keys_connect(hidpp);
3953 if (ret)
3954 return;
3955 }
3956
3957 /* the device is already connected, we can ask for its name and
3958 * protocol */
3959 if (!hidpp->protocol_major) {
3960 ret = hidpp_root_get_protocol_version(hidpp);
3961 if (ret) {
3962 hid_err(hdev, "Can not get the protocol version.\n");
3963 return;
3964 }
3965 }
3966
3967 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
3968 name = hidpp_get_device_name(hidpp);
3969 if (name) {
3970 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
3971 "%s", name);
3972 kfree(name);
3973 if (!devm_name)
3974 return;
3975
3976 hidpp->name = devm_name;
3977 }
3978 }
3979
3980 hidpp_initialize_battery(hidpp);
3981 if (!hid_is_usb(hidpp->hid_dev))
3982 hidpp_initialize_hires_scroll(hidpp);
3983
3984 /* forward current battery state */
3985 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3986 hidpp10_enable_battery_reporting(hidpp);
3987 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
3988 hidpp10_query_battery_mileage(hidpp);
3989 else
3990 hidpp10_query_battery_status(hidpp);
3991 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3992 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3993 hidpp20_query_battery_voltage_info(hidpp);
3994 else if (hidpp->capabilities & HIDPP_CAPABILITY_UNIFIED_BATTERY)
3995 hidpp20_query_battery_info_1004(hidpp);
3996 else
3997 hidpp20_query_battery_info_1000(hidpp);
3998 }
3999 if (hidpp->battery.ps)
4000 power_supply_changed(hidpp->battery.ps);
4001
4002 if (hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4003 hi_res_scroll_enable(hidpp);
4004
4005 if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT) || hidpp->delayed_input)
4006 /* if the input nodes are already created, we can stop now */
4007 return;
4008
4009 input = hidpp_allocate_input(hdev);
4010 if (!input) {
4011 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
4012 return;
4013 }
4014
4015 hidpp_populate_input(hidpp, input);
4016
4017 ret = input_register_device(input);
4018 if (ret) {
4019 input_free_device(input);
4020 return;
4021 }
4022
4023 hidpp->delayed_input = input;
4024}
4025
4026static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
4027
4028static struct attribute *sysfs_attrs[] = {
4029 &dev_attr_builtin_power_supply.attr,
4030 NULL
4031};
4032
4033static const struct attribute_group ps_attribute_group = {
4034 .attrs = sysfs_attrs
4035};
4036
4037static int hidpp_get_report_length(struct hid_device *hdev, int id)
4038{
4039 struct hid_report_enum *re;
4040 struct hid_report *report;
4041
4042 re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
4043 report = re->report_id_hash[id];
4044 if (!report)
4045 return 0;
4046
4047 return report->field[0]->report_count + 1;
4048}
4049
4050static u8 hidpp_validate_device(struct hid_device *hdev)
4051{
4052 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4053 int id, report_length;
4054 u8 supported_reports = 0;
4055
4056 id = REPORT_ID_HIDPP_SHORT;
4057 report_length = hidpp_get_report_length(hdev, id);
4058 if (report_length) {
4059 if (report_length < HIDPP_REPORT_SHORT_LENGTH)
4060 goto bad_device;
4061
4062 supported_reports |= HIDPP_REPORT_SHORT_SUPPORTED;
4063 }
4064
4065 id = REPORT_ID_HIDPP_LONG;
4066 report_length = hidpp_get_report_length(hdev, id);
4067 if (report_length) {
4068 if (report_length < HIDPP_REPORT_LONG_LENGTH)
4069 goto bad_device;
4070
4071 supported_reports |= HIDPP_REPORT_LONG_SUPPORTED;
4072 }
4073
4074 id = REPORT_ID_HIDPP_VERY_LONG;
4075 report_length = hidpp_get_report_length(hdev, id);
4076 if (report_length) {
4077 if (report_length < HIDPP_REPORT_LONG_LENGTH ||
4078 report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
4079 goto bad_device;
4080
4081 supported_reports |= HIDPP_REPORT_VERY_LONG_SUPPORTED;
4082 hidpp->very_long_report_length = report_length;
4083 }
4084
4085 return supported_reports;
4086
4087bad_device:
4088 hid_warn(hdev, "not enough values in hidpp report %d\n", id);
4089 return false;
4090}
4091
4092static bool hidpp_application_equals(struct hid_device *hdev,
4093 unsigned int application)
4094{
4095 struct list_head *report_list;
4096 struct hid_report *report;
4097
4098 report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
4099 report = list_first_entry_or_null(report_list, struct hid_report, list);
4100 return report && report->application == application;
4101}
4102
4103static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
4104{
4105 struct hidpp_device *hidpp;
4106 int ret;
4107 bool connected;
4108 unsigned int connect_mask = HID_CONNECT_DEFAULT;
4109 struct hidpp_ff_private_data data;
4110
4111 /* report_fixup needs drvdata to be set before we call hid_parse */
4112 hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
4113 if (!hidpp)
4114 return -ENOMEM;
4115
4116 hidpp->hid_dev = hdev;
4117 hidpp->name = hdev->name;
4118 hidpp->quirks = id->driver_data;
4119 hid_set_drvdata(hdev, hidpp);
4120
4121 ret = hid_parse(hdev);
4122 if (ret) {
4123 hid_err(hdev, "%s:parse failed\n", __func__);
4124 return ret;
4125 }
4126
4127 /*
4128 * Make sure the device is HID++ capable, otherwise treat as generic HID
4129 */
4130 hidpp->supported_reports = hidpp_validate_device(hdev);
4131
4132 if (!hidpp->supported_reports) {
4133 hid_set_drvdata(hdev, NULL);
4134 devm_kfree(&hdev->dev, hidpp);
4135 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
4136 }
4137
4138 if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
4139 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
4140
4141 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4142 hidpp_application_equals(hdev, HID_GD_MOUSE))
4143 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
4144 HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
4145
4146 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4147 hidpp_application_equals(hdev, HID_GD_KEYBOARD))
4148 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
4149
4150 if (disable_raw_mode) {
4151 hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
4152 hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT;
4153 }
4154
4155 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4156 ret = wtp_allocate(hdev, id);
4157 if (ret)
4158 return ret;
4159 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4160 ret = k400_allocate(hdev);
4161 if (ret)
4162 return ret;
4163 }
4164
4165 INIT_WORK(&hidpp->work, delayed_work_cb);
4166 mutex_init(&hidpp->send_mutex);
4167 init_waitqueue_head(&hidpp->wait);
4168
4169 /* indicates we are handling the battery properties in the kernel */
4170 ret = sysfs_create_group(&hdev->dev.kobj, &ps_attribute_group);
4171 if (ret)
4172 hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
4173 hdev->name);
4174
4175 /*
4176 * Plain USB connections need to actually call start and open
4177 * on the transport driver to allow incoming data.
4178 */
4179 ret = hid_hw_start(hdev, 0);
4180 if (ret) {
4181 hid_err(hdev, "hw start failed\n");
4182 goto hid_hw_start_fail;
4183 }
4184
4185 ret = hid_hw_open(hdev);
4186 if (ret < 0) {
4187 dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
4188 __func__, ret);
4189 goto hid_hw_open_fail;
4190 }
4191
4192 /* Allow incoming packets */
4193 hid_device_io_start(hdev);
4194
4195 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
4196 hidpp_unifying_init(hidpp);
4197
4198 connected = hidpp_root_get_protocol_version(hidpp) == 0;
4199 atomic_set(&hidpp->connected, connected);
4200 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
4201 if (!connected) {
4202 ret = -ENODEV;
4203 hid_err(hdev, "Device not connected");
4204 goto hid_hw_init_fail;
4205 }
4206
4207 hidpp_overwrite_name(hdev);
4208 }
4209
4210 if (connected && hidpp->protocol_major >= 2) {
4211 ret = hidpp_set_wireless_feature_index(hidpp);
4212 if (ret == -ENOENT)
4213 hidpp->wireless_feature_index = 0;
4214 else if (ret)
4215 goto hid_hw_init_fail;
4216 }
4217
4218 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
4219 ret = wtp_get_config(hidpp);
4220 if (ret)
4221 goto hid_hw_init_fail;
4222 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
4223 ret = g920_get_config(hidpp, &data);
4224 if (ret)
4225 goto hid_hw_init_fail;
4226 }
4227
4228 hidpp_connect_event(hidpp);
4229
4230 /* Reset the HID node state */
4231 hid_device_io_stop(hdev);
4232 hid_hw_close(hdev);
4233 hid_hw_stop(hdev);
4234
4235 if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
4236 connect_mask &= ~HID_CONNECT_HIDINPUT;
4237
4238 /* Now export the actual inputs and hidraw nodes to the world */
4239 ret = hid_hw_start(hdev, connect_mask);
4240 if (ret) {
4241 hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
4242 goto hid_hw_start_fail;
4243 }
4244
4245 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
4246 ret = hidpp_ff_init(hidpp, &data);
4247 if (ret)
4248 hid_warn(hidpp->hid_dev,
4249 "Unable to initialize force feedback support, errno %d\n",
4250 ret);
4251 }
4252
4253 return ret;
4254
4255hid_hw_init_fail:
4256 hid_hw_close(hdev);
4257hid_hw_open_fail:
4258 hid_hw_stop(hdev);
4259hid_hw_start_fail:
4260 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4261 cancel_work_sync(&hidpp->work);
4262 mutex_destroy(&hidpp->send_mutex);
4263 return ret;
4264}
4265
4266static void hidpp_remove(struct hid_device *hdev)
4267{
4268 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4269
4270 if (!hidpp)
4271 return hid_hw_stop(hdev);
4272
4273 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4274
4275 hid_hw_stop(hdev);
4276 cancel_work_sync(&hidpp->work);
4277 mutex_destroy(&hidpp->send_mutex);
4278}
4279
4280#define LDJ_DEVICE(product) \
4281 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
4282 USB_VENDOR_ID_LOGITECH, (product))
4283
4284#define L27MHZ_DEVICE(product) \
4285 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
4286 USB_VENDOR_ID_LOGITECH, (product))
4287
4288static const struct hid_device_id hidpp_devices[] = {
4289 { /* wireless touchpad */
4290 LDJ_DEVICE(0x4011),
4291 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
4292 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
4293 { /* wireless touchpad T650 */
4294 LDJ_DEVICE(0x4101),
4295 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
4296 { /* wireless touchpad T651 */
4297 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
4298 USB_DEVICE_ID_LOGITECH_T651),
4299 .driver_data = HIDPP_QUIRK_CLASS_WTP },
4300 { /* Mouse logitech M560 */
4301 LDJ_DEVICE(0x402d),
4302 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 },
4303 { /* Keyboard logitech K400 */
4304 LDJ_DEVICE(0x4024),
4305 .driver_data = HIDPP_QUIRK_CLASS_K400 },
4306 { /* Solar Keyboard Logitech K750 */
4307 LDJ_DEVICE(0x4002),
4308 .driver_data = HIDPP_QUIRK_CLASS_K750 },
4309 { /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
4310 LDJ_DEVICE(0xb305),
4311 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4312 { /* Dinovo Edge (Bluetooth-receiver in HID proxy mode) */
4313 LDJ_DEVICE(0xb309),
4314 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4315 { /* Keyboard MX5500 (Bluetooth-receiver in HID proxy mode) */
4316 LDJ_DEVICE(0xb30b),
4317 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4318
4319 { LDJ_DEVICE(HID_ANY_ID) },
4320
4321 { /* Keyboard LX501 (Y-RR53) */
4322 L27MHZ_DEVICE(0x0049),
4323 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4324 { /* Keyboard MX3000 (Y-RAM74) */
4325 L27MHZ_DEVICE(0x0057),
4326 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4327 { /* Keyboard MX3200 (Y-RAV80) */
4328 L27MHZ_DEVICE(0x005c),
4329 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4330 { /* S510 Media Remote */
4331 L27MHZ_DEVICE(0x00fe),
4332 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4333
4334 { L27MHZ_DEVICE(HID_ANY_ID) },
4335
4336 { /* Logitech G403 Wireless Gaming Mouse over USB */
4337 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
4338 { /* Logitech G703 Gaming Mouse over USB */
4339 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC087) },
4340 { /* Logitech G703 Hero Gaming Mouse over USB */
4341 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC090) },
4342 { /* Logitech G900 Gaming Mouse over USB */
4343 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
4344 { /* Logitech G903 Gaming Mouse over USB */
4345 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC086) },
4346 { /* Logitech G903 Hero Gaming Mouse over USB */
4347 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC091) },
4348 { /* Logitech G920 Wheel over USB */
4349 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
4350 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
4351 { /* Logitech G Pro Gaming Mouse over USB */
4352 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC088) },
4353
4354 { /* MX5000 keyboard over Bluetooth */
4355 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
4356 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4357 { /* Dinovo Edge keyboard over Bluetooth */
4358 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb309),
4359 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4360 { /* MX5500 keyboard over Bluetooth */
4361 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
4362 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4363 { /* M-RCQ142 V470 Cordless Laser Mouse over Bluetooth */
4364 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb008) },
4365 { /* MX Master mouse over Bluetooth */
4366 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012) },
4367 { /* MX Ergo trackball over Bluetooth */
4368 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
4369 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e) },
4370 { /* MX Master 3 mouse over Bluetooth */
4371 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023) },
4372 {}
4373};
4374
4375MODULE_DEVICE_TABLE(hid, hidpp_devices);
4376
4377static const struct hid_usage_id hidpp_usages[] = {
4378 { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
4379 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
4380};
4381
4382static struct hid_driver hidpp_driver = {
4383 .name = "logitech-hidpp-device",
4384 .id_table = hidpp_devices,
4385 .report_fixup = hidpp_report_fixup,
4386 .probe = hidpp_probe,
4387 .remove = hidpp_remove,
4388 .raw_event = hidpp_raw_event,
4389 .usage_table = hidpp_usages,
4390 .event = hidpp_event,
4391 .input_configured = hidpp_input_configured,
4392 .input_mapping = hidpp_input_mapping,
4393 .input_mapped = hidpp_input_mapped,
4394};
4395
4396module_hid_driver(hidpp_driver);
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * HIDPP protocol for Logitech receivers
4 *
5 * Copyright (c) 2011 Logitech (c)
6 * Copyright (c) 2012-2013 Google (c)
7 * Copyright (c) 2013-2014 Red Hat Inc.
8 */
9
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
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"
28#include "hid-ids.h"
29
30MODULE_LICENSE("GPL");
31MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
32MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
33
34static bool disable_raw_mode;
35module_param(disable_raw_mode, bool, 0644);
36MODULE_PARM_DESC(disable_raw_mode,
37 "Disable Raw mode reporting for touchpads and keep firmware gestures.");
38
39static bool disable_tap_to_click;
40module_param(disable_tap_to_click, bool, 0644);
41MODULE_PARM_DESC(disable_tap_to_click,
42 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
43
44#define REPORT_ID_HIDPP_SHORT 0x10
45#define REPORT_ID_HIDPP_LONG 0x11
46#define REPORT_ID_HIDPP_VERY_LONG 0x12
47
48#define HIDPP_REPORT_SHORT_LENGTH 7
49#define HIDPP_REPORT_LONG_LENGTH 20
50#define HIDPP_REPORT_VERY_LONG_MAX_LENGTH 64
51
52#define HIDPP_REPORT_SHORT_SUPPORTED BIT(0)
53#define HIDPP_REPORT_LONG_SUPPORTED BIT(1)
54#define HIDPP_REPORT_VERY_LONG_SUPPORTED BIT(2)
55
56#define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS 0x03
57#define HIDPP_SUB_ID_ROLLER 0x05
58#define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS 0x06
59
60#define HIDPP_QUIRK_CLASS_WTP BIT(0)
61#define HIDPP_QUIRK_CLASS_M560 BIT(1)
62#define HIDPP_QUIRK_CLASS_K400 BIT(2)
63#define HIDPP_QUIRK_CLASS_G920 BIT(3)
64#define HIDPP_QUIRK_CLASS_K750 BIT(4)
65
66/* bits 2..20 are reserved for classes */
67/* #define HIDPP_QUIRK_CONNECT_EVENTS BIT(21) disabled */
68#define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22)
69#define HIDPP_QUIRK_NO_HIDINPUT BIT(23)
70#define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS BIT(24)
71#define HIDPP_QUIRK_UNIFYING BIT(25)
72#define HIDPP_QUIRK_HI_RES_SCROLL_1P0 BIT(26)
73#define HIDPP_QUIRK_HI_RES_SCROLL_X2120 BIT(27)
74#define HIDPP_QUIRK_HI_RES_SCROLL_X2121 BIT(28)
75#define HIDPP_QUIRK_HIDPP_WHEELS BIT(29)
76#define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS BIT(30)
77#define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS BIT(31)
78
79/* These are just aliases for now */
80#define HIDPP_QUIRK_KBD_SCROLL_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
81#define HIDPP_QUIRK_KBD_ZOOM_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
82
83/* Convenience constant to check for any high-res support. */
84#define HIDPP_QUIRK_HI_RES_SCROLL (HIDPP_QUIRK_HI_RES_SCROLL_1P0 | \
85 HIDPP_QUIRK_HI_RES_SCROLL_X2120 | \
86 HIDPP_QUIRK_HI_RES_SCROLL_X2121)
87
88#define HIDPP_QUIRK_DELAYED_INIT HIDPP_QUIRK_NO_HIDINPUT
89
90#define HIDPP_CAPABILITY_HIDPP10_BATTERY BIT(0)
91#define HIDPP_CAPABILITY_HIDPP20_BATTERY BIT(1)
92#define HIDPP_CAPABILITY_BATTERY_MILEAGE BIT(2)
93#define HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS BIT(3)
94#define HIDPP_CAPABILITY_BATTERY_VOLTAGE BIT(4)
95
96/*
97 * There are two hidpp protocols in use, the first version hidpp10 is known
98 * as register access protocol or RAP, the second version hidpp20 is known as
99 * feature access protocol or FAP
100 *
101 * Most older devices (including the Unifying usb receiver) use the RAP protocol
102 * where as most newer devices use the FAP protocol. Both protocols are
103 * compatible with the underlying transport, which could be usb, Unifiying, or
104 * bluetooth. The message lengths are defined by the hid vendor specific report
105 * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and
106 * the HIDPP_LONG report type (total message length 20 bytes)
107 *
108 * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG
109 * messages. The Unifying receiver itself responds to RAP messages (device index
110 * is 0xFF for the receiver), and all messages (short or long) with a device
111 * index between 1 and 6 are passed untouched to the corresponding paired
112 * Unifying device.
113 *
114 * The paired device can be RAP or FAP, it will receive the message untouched
115 * from the Unifiying receiver.
116 */
117
118struct fap {
119 u8 feature_index;
120 u8 funcindex_clientid;
121 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
122};
123
124struct rap {
125 u8 sub_id;
126 u8 reg_address;
127 u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
128};
129
130struct hidpp_report {
131 u8 report_id;
132 u8 device_index;
133 union {
134 struct fap fap;
135 struct rap rap;
136 u8 rawbytes[sizeof(struct fap)];
137 };
138} __packed;
139
140struct hidpp_battery {
141 u8 feature_index;
142 u8 solar_feature_index;
143 u8 voltage_feature_index;
144 struct power_supply_desc desc;
145 struct power_supply *ps;
146 char name[64];
147 int status;
148 int capacity;
149 int level;
150 int voltage;
151 int charge_type;
152 bool online;
153};
154
155/**
156 * struct hidpp_scroll_counter - Utility class for processing high-resolution
157 * scroll events.
158 * @dev: the input device for which events should be reported.
159 * @wheel_multiplier: the scalar multiplier to be applied to each wheel event
160 * @remainder: counts the number of high-resolution units moved since the last
161 * low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
162 * only be used by class methods.
163 * @direction: direction of last movement (1 or -1)
164 * @last_time: last event time, used to reset remainder after inactivity
165 */
166struct hidpp_scroll_counter {
167 int wheel_multiplier;
168 int remainder;
169 int direction;
170 unsigned long long last_time;
171};
172
173struct hidpp_device {
174 struct hid_device *hid_dev;
175 struct input_dev *input;
176 struct mutex send_mutex;
177 void *send_receive_buf;
178 char *name; /* will never be NULL and should not be freed */
179 wait_queue_head_t wait;
180 int very_long_report_length;
181 bool answer_available;
182 u8 protocol_major;
183 u8 protocol_minor;
184
185 void *private_data;
186
187 struct work_struct work;
188 struct kfifo delayed_work_fifo;
189 atomic_t connected;
190 struct input_dev *delayed_input;
191
192 unsigned long quirks;
193 unsigned long capabilities;
194 u8 supported_reports;
195
196 struct hidpp_battery battery;
197 struct hidpp_scroll_counter vertical_wheel_counter;
198
199 u8 wireless_feature_index;
200};
201
202/* HID++ 1.0 error codes */
203#define HIDPP_ERROR 0x8f
204#define HIDPP_ERROR_SUCCESS 0x00
205#define HIDPP_ERROR_INVALID_SUBID 0x01
206#define HIDPP_ERROR_INVALID_ADRESS 0x02
207#define HIDPP_ERROR_INVALID_VALUE 0x03
208#define HIDPP_ERROR_CONNECT_FAIL 0x04
209#define HIDPP_ERROR_TOO_MANY_DEVICES 0x05
210#define HIDPP_ERROR_ALREADY_EXISTS 0x06
211#define HIDPP_ERROR_BUSY 0x07
212#define HIDPP_ERROR_UNKNOWN_DEVICE 0x08
213#define HIDPP_ERROR_RESOURCE_ERROR 0x09
214#define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a
215#define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b
216#define HIDPP_ERROR_WRONG_PIN_CODE 0x0c
217/* HID++ 2.0 error codes */
218#define HIDPP20_ERROR 0xff
219
220static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
221
222static int __hidpp_send_report(struct hid_device *hdev,
223 struct hidpp_report *hidpp_report)
224{
225 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
226 int fields_count, ret;
227
228 switch (hidpp_report->report_id) {
229 case REPORT_ID_HIDPP_SHORT:
230 fields_count = HIDPP_REPORT_SHORT_LENGTH;
231 break;
232 case REPORT_ID_HIDPP_LONG:
233 fields_count = HIDPP_REPORT_LONG_LENGTH;
234 break;
235 case REPORT_ID_HIDPP_VERY_LONG:
236 fields_count = hidpp->very_long_report_length;
237 break;
238 default:
239 return -ENODEV;
240 }
241
242 /*
243 * set the device_index as the receiver, it will be overwritten by
244 * hid_hw_request if needed
245 */
246 hidpp_report->device_index = 0xff;
247
248 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
249 ret = hid_hw_output_report(hdev, (u8 *)hidpp_report, fields_count);
250 } else {
251 ret = hid_hw_raw_request(hdev, hidpp_report->report_id,
252 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT,
253 HID_REQ_SET_REPORT);
254 }
255
256 return ret == fields_count ? 0 : -1;
257}
258
259/**
260 * hidpp_send_message_sync() returns 0 in case of success, and something else
261 * in case of a failure.
262 * - If ' something else' is positive, that means that an error has been raised
263 * by the protocol itself.
264 * - If ' something else' is negative, that means that we had a classic error
265 * (-ENOMEM, -EPIPE, etc...)
266 */
267static int hidpp_send_message_sync(struct hidpp_device *hidpp,
268 struct hidpp_report *message,
269 struct hidpp_report *response)
270{
271 int ret;
272
273 mutex_lock(&hidpp->send_mutex);
274
275 hidpp->send_receive_buf = response;
276 hidpp->answer_available = false;
277
278 /*
279 * So that we can later validate the answer when it arrives
280 * in hidpp_raw_event
281 */
282 *response = *message;
283
284 ret = __hidpp_send_report(hidpp->hid_dev, message);
285
286 if (ret) {
287 dbg_hid("__hidpp_send_report returned err: %d\n", ret);
288 memset(response, 0, sizeof(struct hidpp_report));
289 goto exit;
290 }
291
292 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
293 5*HZ)) {
294 dbg_hid("%s:timeout waiting for response\n", __func__);
295 memset(response, 0, sizeof(struct hidpp_report));
296 ret = -ETIMEDOUT;
297 }
298
299 if (response->report_id == REPORT_ID_HIDPP_SHORT &&
300 response->rap.sub_id == HIDPP_ERROR) {
301 ret = response->rap.params[1];
302 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
303 goto exit;
304 }
305
306 if ((response->report_id == REPORT_ID_HIDPP_LONG ||
307 response->report_id == REPORT_ID_HIDPP_VERY_LONG) &&
308 response->fap.feature_index == HIDPP20_ERROR) {
309 ret = response->fap.params[1];
310 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
311 goto exit;
312 }
313
314exit:
315 mutex_unlock(&hidpp->send_mutex);
316 return ret;
317
318}
319
320static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
321 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count,
322 struct hidpp_report *response)
323{
324 struct hidpp_report *message;
325 int ret;
326
327 if (param_count > sizeof(message->fap.params))
328 return -EINVAL;
329
330 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
331 if (!message)
332 return -ENOMEM;
333
334 if (param_count > (HIDPP_REPORT_LONG_LENGTH - 4))
335 message->report_id = REPORT_ID_HIDPP_VERY_LONG;
336 else
337 message->report_id = REPORT_ID_HIDPP_LONG;
338 message->fap.feature_index = feat_index;
339 message->fap.funcindex_clientid = funcindex_clientid;
340 memcpy(&message->fap.params, params, param_count);
341
342 ret = hidpp_send_message_sync(hidpp, message, response);
343 kfree(message);
344 return ret;
345}
346
347static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
348 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count,
349 struct hidpp_report *response)
350{
351 struct hidpp_report *message;
352 int ret, max_count;
353
354 /* Send as long report if short reports are not supported. */
355 if (report_id == REPORT_ID_HIDPP_SHORT &&
356 !(hidpp_dev->supported_reports & HIDPP_REPORT_SHORT_SUPPORTED))
357 report_id = REPORT_ID_HIDPP_LONG;
358
359 switch (report_id) {
360 case REPORT_ID_HIDPP_SHORT:
361 max_count = HIDPP_REPORT_SHORT_LENGTH - 4;
362 break;
363 case REPORT_ID_HIDPP_LONG:
364 max_count = HIDPP_REPORT_LONG_LENGTH - 4;
365 break;
366 case REPORT_ID_HIDPP_VERY_LONG:
367 max_count = hidpp_dev->very_long_report_length - 4;
368 break;
369 default:
370 return -EINVAL;
371 }
372
373 if (param_count > max_count)
374 return -EINVAL;
375
376 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL);
377 if (!message)
378 return -ENOMEM;
379 message->report_id = report_id;
380 message->rap.sub_id = sub_id;
381 message->rap.reg_address = reg_address;
382 memcpy(&message->rap.params, params, param_count);
383
384 ret = hidpp_send_message_sync(hidpp_dev, message, response);
385 kfree(message);
386 return ret;
387}
388
389static void delayed_work_cb(struct work_struct *work)
390{
391 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
392 work);
393 hidpp_connect_event(hidpp);
394}
395
396static inline bool hidpp_match_answer(struct hidpp_report *question,
397 struct hidpp_report *answer)
398{
399 return (answer->fap.feature_index == question->fap.feature_index) &&
400 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid);
401}
402
403static inline bool hidpp_match_error(struct hidpp_report *question,
404 struct hidpp_report *answer)
405{
406 return ((answer->rap.sub_id == HIDPP_ERROR) ||
407 (answer->fap.feature_index == HIDPP20_ERROR)) &&
408 (answer->fap.funcindex_clientid == question->fap.feature_index) &&
409 (answer->fap.params[0] == question->fap.funcindex_clientid);
410}
411
412static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
413 struct hidpp_report *report)
414{
415 return (hidpp->wireless_feature_index &&
416 (report->fap.feature_index == hidpp->wireless_feature_index)) ||
417 ((report->report_id == REPORT_ID_HIDPP_SHORT) &&
418 (report->rap.sub_id == 0x41));
419}
420
421/**
422 * hidpp_prefix_name() prefixes the current given name with "Logitech ".
423 */
424static void hidpp_prefix_name(char **name, int name_length)
425{
426#define PREFIX_LENGTH 9 /* "Logitech " */
427
428 int new_length;
429 char *new_name;
430
431 if (name_length > PREFIX_LENGTH &&
432 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0)
433 /* The prefix has is already in the name */
434 return;
435
436 new_length = PREFIX_LENGTH + name_length;
437 new_name = kzalloc(new_length, GFP_KERNEL);
438 if (!new_name)
439 return;
440
441 snprintf(new_name, new_length, "Logitech %s", *name);
442
443 kfree(*name);
444
445 *name = new_name;
446}
447
448/**
449 * hidpp_scroll_counter_handle_scroll() - Send high- and low-resolution scroll
450 * events given a high-resolution wheel
451 * movement.
452 * @counter: a hid_scroll_counter struct describing the wheel.
453 * @hi_res_value: the movement of the wheel, in the mouse's high-resolution
454 * units.
455 *
456 * Given a high-resolution movement, this function converts the movement into
457 * fractions of 120 and emits high-resolution scroll events for the input
458 * device. It also uses the multiplier from &struct hid_scroll_counter to
459 * emit low-resolution scroll events when appropriate for
460 * backwards-compatibility with userspace input libraries.
461 */
462static void hidpp_scroll_counter_handle_scroll(struct input_dev *input_dev,
463 struct hidpp_scroll_counter *counter,
464 int hi_res_value)
465{
466 int low_res_value, remainder, direction;
467 unsigned long long now, previous;
468
469 hi_res_value = hi_res_value * 120/counter->wheel_multiplier;
470 input_report_rel(input_dev, REL_WHEEL_HI_RES, hi_res_value);
471
472 remainder = counter->remainder;
473 direction = hi_res_value > 0 ? 1 : -1;
474
475 now = sched_clock();
476 previous = counter->last_time;
477 counter->last_time = now;
478 /*
479 * Reset the remainder after a period of inactivity or when the
480 * direction changes. This prevents the REL_WHEEL emulation point
481 * from sliding for devices that don't always provide the same
482 * number of movements per detent.
483 */
484 if (now - previous > 1000000000 || direction != counter->direction)
485 remainder = 0;
486
487 counter->direction = direction;
488 remainder += hi_res_value;
489
490 /* Some wheels will rest 7/8ths of a detent from the previous detent
491 * after slow movement, so we want the threshold for low-res events to
492 * be in the middle between two detents (e.g. after 4/8ths) as
493 * opposed to on the detents themselves (8/8ths).
494 */
495 if (abs(remainder) >= 60) {
496 /* Add (or subtract) 1 because we want to trigger when the wheel
497 * is half-way to the next detent (i.e. scroll 1 detent after a
498 * 1/2 detent movement, 2 detents after a 1 1/2 detent movement,
499 * etc.).
500 */
501 low_res_value = remainder / 120;
502 if (low_res_value == 0)
503 low_res_value = (hi_res_value > 0 ? 1 : -1);
504 input_report_rel(input_dev, REL_WHEEL, low_res_value);
505 remainder -= low_res_value * 120;
506 }
507 counter->remainder = remainder;
508}
509
510/* -------------------------------------------------------------------------- */
511/* HIDP++ 1.0 commands */
512/* -------------------------------------------------------------------------- */
513
514#define HIDPP_SET_REGISTER 0x80
515#define HIDPP_GET_REGISTER 0x81
516#define HIDPP_SET_LONG_REGISTER 0x82
517#define HIDPP_GET_LONG_REGISTER 0x83
518
519/**
520 * hidpp10_set_register - Modify a HID++ 1.0 register.
521 * @hidpp_dev: the device to set the register on.
522 * @register_address: the address of the register to modify.
523 * @byte: the byte of the register to modify. Should be less than 3.
524 * @mask: mask of the bits to modify
525 * @value: new values for the bits in mask
526 * Return: 0 if successful, otherwise a negative error code.
527 */
528static int hidpp10_set_register(struct hidpp_device *hidpp_dev,
529 u8 register_address, u8 byte, u8 mask, u8 value)
530{
531 struct hidpp_report response;
532 int ret;
533 u8 params[3] = { 0 };
534
535 ret = hidpp_send_rap_command_sync(hidpp_dev,
536 REPORT_ID_HIDPP_SHORT,
537 HIDPP_GET_REGISTER,
538 register_address,
539 NULL, 0, &response);
540 if (ret)
541 return ret;
542
543 memcpy(params, response.rap.params, 3);
544
545 params[byte] &= ~mask;
546 params[byte] |= value & mask;
547
548 return hidpp_send_rap_command_sync(hidpp_dev,
549 REPORT_ID_HIDPP_SHORT,
550 HIDPP_SET_REGISTER,
551 register_address,
552 params, 3, &response);
553}
554
555#define HIDPP_REG_ENABLE_REPORTS 0x00
556#define HIDPP_ENABLE_CONSUMER_REPORT BIT(0)
557#define HIDPP_ENABLE_WHEEL_REPORT BIT(2)
558#define HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT BIT(3)
559#define HIDPP_ENABLE_BAT_REPORT BIT(4)
560#define HIDPP_ENABLE_HWHEEL_REPORT BIT(5)
561
562static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
563{
564 return hidpp10_set_register(hidpp_dev, HIDPP_REG_ENABLE_REPORTS, 0,
565 HIDPP_ENABLE_BAT_REPORT, HIDPP_ENABLE_BAT_REPORT);
566}
567
568#define HIDPP_REG_FEATURES 0x01
569#define HIDPP_ENABLE_SPECIAL_BUTTON_FUNC BIT(1)
570#define HIDPP_ENABLE_FAST_SCROLL BIT(6)
571
572/* On HID++ 1.0 devices, high-res scroll was called "scrolling acceleration". */
573static int hidpp10_enable_scrolling_acceleration(struct hidpp_device *hidpp_dev)
574{
575 return hidpp10_set_register(hidpp_dev, HIDPP_REG_FEATURES, 0,
576 HIDPP_ENABLE_FAST_SCROLL, HIDPP_ENABLE_FAST_SCROLL);
577}
578
579#define HIDPP_REG_BATTERY_STATUS 0x07
580
581static int hidpp10_battery_status_map_level(u8 param)
582{
583 int level;
584
585 switch (param) {
586 case 1 ... 2:
587 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
588 break;
589 case 3 ... 4:
590 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
591 break;
592 case 5 ... 6:
593 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
594 break;
595 case 7:
596 level = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
597 break;
598 default:
599 level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
600 }
601
602 return level;
603}
604
605static int hidpp10_battery_status_map_status(u8 param)
606{
607 int status;
608
609 switch (param) {
610 case 0x00:
611 /* discharging (in use) */
612 status = POWER_SUPPLY_STATUS_DISCHARGING;
613 break;
614 case 0x21: /* (standard) charging */
615 case 0x24: /* fast charging */
616 case 0x25: /* slow charging */
617 status = POWER_SUPPLY_STATUS_CHARGING;
618 break;
619 case 0x26: /* topping charge */
620 case 0x22: /* charge complete */
621 status = POWER_SUPPLY_STATUS_FULL;
622 break;
623 case 0x20: /* unknown */
624 status = POWER_SUPPLY_STATUS_UNKNOWN;
625 break;
626 /*
627 * 0x01...0x1F = reserved (not charging)
628 * 0x23 = charging error
629 * 0x27..0xff = reserved
630 */
631 default:
632 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
633 break;
634 }
635
636 return status;
637}
638
639static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
640{
641 struct hidpp_report response;
642 int ret, status;
643
644 ret = hidpp_send_rap_command_sync(hidpp,
645 REPORT_ID_HIDPP_SHORT,
646 HIDPP_GET_REGISTER,
647 HIDPP_REG_BATTERY_STATUS,
648 NULL, 0, &response);
649 if (ret)
650 return ret;
651
652 hidpp->battery.level =
653 hidpp10_battery_status_map_level(response.rap.params[0]);
654 status = hidpp10_battery_status_map_status(response.rap.params[1]);
655 hidpp->battery.status = status;
656 /* the capacity is only available when discharging or full */
657 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
658 status == POWER_SUPPLY_STATUS_FULL;
659
660 return 0;
661}
662
663#define HIDPP_REG_BATTERY_MILEAGE 0x0D
664
665static int hidpp10_battery_mileage_map_status(u8 param)
666{
667 int status;
668
669 switch (param >> 6) {
670 case 0x00:
671 /* discharging (in use) */
672 status = POWER_SUPPLY_STATUS_DISCHARGING;
673 break;
674 case 0x01: /* charging */
675 status = POWER_SUPPLY_STATUS_CHARGING;
676 break;
677 case 0x02: /* charge complete */
678 status = POWER_SUPPLY_STATUS_FULL;
679 break;
680 /*
681 * 0x03 = charging error
682 */
683 default:
684 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
685 break;
686 }
687
688 return status;
689}
690
691static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
692{
693 struct hidpp_report response;
694 int ret, status;
695
696 ret = hidpp_send_rap_command_sync(hidpp,
697 REPORT_ID_HIDPP_SHORT,
698 HIDPP_GET_REGISTER,
699 HIDPP_REG_BATTERY_MILEAGE,
700 NULL, 0, &response);
701 if (ret)
702 return ret;
703
704 hidpp->battery.capacity = response.rap.params[0];
705 status = hidpp10_battery_mileage_map_status(response.rap.params[2]);
706 hidpp->battery.status = status;
707 /* the capacity is only available when discharging or full */
708 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
709 status == POWER_SUPPLY_STATUS_FULL;
710
711 return 0;
712}
713
714static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
715{
716 struct hidpp_report *report = (struct hidpp_report *)data;
717 int status, capacity, level;
718 bool changed;
719
720 if (report->report_id != REPORT_ID_HIDPP_SHORT)
721 return 0;
722
723 switch (report->rap.sub_id) {
724 case HIDPP_REG_BATTERY_STATUS:
725 capacity = hidpp->battery.capacity;
726 level = hidpp10_battery_status_map_level(report->rawbytes[1]);
727 status = hidpp10_battery_status_map_status(report->rawbytes[2]);
728 break;
729 case HIDPP_REG_BATTERY_MILEAGE:
730 capacity = report->rap.params[0];
731 level = hidpp->battery.level;
732 status = hidpp10_battery_mileage_map_status(report->rawbytes[3]);
733 break;
734 default:
735 return 0;
736 }
737
738 changed = capacity != hidpp->battery.capacity ||
739 level != hidpp->battery.level ||
740 status != hidpp->battery.status;
741
742 /* the capacity is only available when discharging or full */
743 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
744 status == POWER_SUPPLY_STATUS_FULL;
745
746 if (changed) {
747 hidpp->battery.level = level;
748 hidpp->battery.status = status;
749 if (hidpp->battery.ps)
750 power_supply_changed(hidpp->battery.ps);
751 }
752
753 return 0;
754}
755
756#define HIDPP_REG_PAIRING_INFORMATION 0xB5
757#define HIDPP_EXTENDED_PAIRING 0x30
758#define HIDPP_DEVICE_NAME 0x40
759
760static char *hidpp_unifying_get_name(struct hidpp_device *hidpp_dev)
761{
762 struct hidpp_report response;
763 int ret;
764 u8 params[1] = { HIDPP_DEVICE_NAME };
765 char *name;
766 int len;
767
768 ret = hidpp_send_rap_command_sync(hidpp_dev,
769 REPORT_ID_HIDPP_SHORT,
770 HIDPP_GET_LONG_REGISTER,
771 HIDPP_REG_PAIRING_INFORMATION,
772 params, 1, &response);
773 if (ret)
774 return NULL;
775
776 len = response.rap.params[1];
777
778 if (2 + len > sizeof(response.rap.params))
779 return NULL;
780
781 if (len < 4) /* logitech devices are usually at least Xddd */
782 return NULL;
783
784 name = kzalloc(len + 1, GFP_KERNEL);
785 if (!name)
786 return NULL;
787
788 memcpy(name, &response.rap.params[2], len);
789
790 /* include the terminating '\0' */
791 hidpp_prefix_name(&name, len + 1);
792
793 return name;
794}
795
796static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
797{
798 struct hidpp_report response;
799 int ret;
800 u8 params[1] = { HIDPP_EXTENDED_PAIRING };
801
802 ret = hidpp_send_rap_command_sync(hidpp,
803 REPORT_ID_HIDPP_SHORT,
804 HIDPP_GET_LONG_REGISTER,
805 HIDPP_REG_PAIRING_INFORMATION,
806 params, 1, &response);
807 if (ret)
808 return ret;
809
810 /*
811 * We don't care about LE or BE, we will output it as a string
812 * with %4phD, so we need to keep the order.
813 */
814 *serial = *((u32 *)&response.rap.params[1]);
815 return 0;
816}
817
818static int hidpp_unifying_init(struct hidpp_device *hidpp)
819{
820 struct hid_device *hdev = hidpp->hid_dev;
821 const char *name;
822 u32 serial;
823 int ret;
824
825 ret = hidpp_unifying_get_serial(hidpp, &serial);
826 if (ret)
827 return ret;
828
829 snprintf(hdev->uniq, sizeof(hdev->uniq), "%04x-%4phD",
830 hdev->product, &serial);
831 dbg_hid("HID++ Unifying: Got serial: %s\n", hdev->uniq);
832
833 name = hidpp_unifying_get_name(hidpp);
834 if (!name)
835 return -EIO;
836
837 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
838 dbg_hid("HID++ Unifying: Got name: %s\n", name);
839
840 kfree(name);
841 return 0;
842}
843
844/* -------------------------------------------------------------------------- */
845/* 0x0000: Root */
846/* -------------------------------------------------------------------------- */
847
848#define HIDPP_PAGE_ROOT 0x0000
849#define HIDPP_PAGE_ROOT_IDX 0x00
850
851#define CMD_ROOT_GET_FEATURE 0x01
852#define CMD_ROOT_GET_PROTOCOL_VERSION 0x11
853
854static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
855 u8 *feature_index, u8 *feature_type)
856{
857 struct hidpp_report response;
858 int ret;
859 u8 params[2] = { feature >> 8, feature & 0x00FF };
860
861 ret = hidpp_send_fap_command_sync(hidpp,
862 HIDPP_PAGE_ROOT_IDX,
863 CMD_ROOT_GET_FEATURE,
864 params, 2, &response);
865 if (ret)
866 return ret;
867
868 if (response.fap.params[0] == 0)
869 return -ENOENT;
870
871 *feature_index = response.fap.params[0];
872 *feature_type = response.fap.params[1];
873
874 return ret;
875}
876
877static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
878{
879 const u8 ping_byte = 0x5a;
880 u8 ping_data[3] = { 0, 0, ping_byte };
881 struct hidpp_report response;
882 int ret;
883
884 ret = hidpp_send_rap_command_sync(hidpp,
885 REPORT_ID_HIDPP_SHORT,
886 HIDPP_PAGE_ROOT_IDX,
887 CMD_ROOT_GET_PROTOCOL_VERSION,
888 ping_data, sizeof(ping_data), &response);
889
890 if (ret == HIDPP_ERROR_INVALID_SUBID) {
891 hidpp->protocol_major = 1;
892 hidpp->protocol_minor = 0;
893 goto print_version;
894 }
895
896 /* the device might not be connected */
897 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
898 return -EIO;
899
900 if (ret > 0) {
901 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
902 __func__, ret);
903 return -EPROTO;
904 }
905 if (ret)
906 return ret;
907
908 if (response.rap.params[2] != ping_byte) {
909 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
910 __func__, response.rap.params[2], ping_byte);
911 return -EPROTO;
912 }
913
914 hidpp->protocol_major = response.rap.params[0];
915 hidpp->protocol_minor = response.rap.params[1];
916
917print_version:
918 hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
919 hidpp->protocol_major, hidpp->protocol_minor);
920 return 0;
921}
922
923/* -------------------------------------------------------------------------- */
924/* 0x0005: GetDeviceNameType */
925/* -------------------------------------------------------------------------- */
926
927#define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005
928
929#define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x01
930#define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x11
931#define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x21
932
933static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
934 u8 feature_index, u8 *nameLength)
935{
936 struct hidpp_report response;
937 int ret;
938
939 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
940 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response);
941
942 if (ret > 0) {
943 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
944 __func__, ret);
945 return -EPROTO;
946 }
947 if (ret)
948 return ret;
949
950 *nameLength = response.fap.params[0];
951
952 return ret;
953}
954
955static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
956 u8 feature_index, u8 char_index, char *device_name, int len_buf)
957{
958 struct hidpp_report response;
959 int ret, i;
960 int count;
961
962 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
963 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1,
964 &response);
965
966 if (ret > 0) {
967 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
968 __func__, ret);
969 return -EPROTO;
970 }
971 if (ret)
972 return ret;
973
974 switch (response.report_id) {
975 case REPORT_ID_HIDPP_VERY_LONG:
976 count = hidpp->very_long_report_length - 4;
977 break;
978 case REPORT_ID_HIDPP_LONG:
979 count = HIDPP_REPORT_LONG_LENGTH - 4;
980 break;
981 case REPORT_ID_HIDPP_SHORT:
982 count = HIDPP_REPORT_SHORT_LENGTH - 4;
983 break;
984 default:
985 return -EPROTO;
986 }
987
988 if (len_buf < count)
989 count = len_buf;
990
991 for (i = 0; i < count; i++)
992 device_name[i] = response.fap.params[i];
993
994 return count;
995}
996
997static char *hidpp_get_device_name(struct hidpp_device *hidpp)
998{
999 u8 feature_type;
1000 u8 feature_index;
1001 u8 __name_length;
1002 char *name;
1003 unsigned index = 0;
1004 int ret;
1005
1006 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
1007 &feature_index, &feature_type);
1008 if (ret)
1009 return NULL;
1010
1011 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
1012 &__name_length);
1013 if (ret)
1014 return NULL;
1015
1016 name = kzalloc(__name_length + 1, GFP_KERNEL);
1017 if (!name)
1018 return NULL;
1019
1020 while (index < __name_length) {
1021 ret = hidpp_devicenametype_get_device_name(hidpp,
1022 feature_index, index, name + index,
1023 __name_length - index);
1024 if (ret <= 0) {
1025 kfree(name);
1026 return NULL;
1027 }
1028 index += ret;
1029 }
1030
1031 /* include the terminating '\0' */
1032 hidpp_prefix_name(&name, __name_length + 1);
1033
1034 return name;
1035}
1036
1037/* -------------------------------------------------------------------------- */
1038/* 0x1000: Battery level status */
1039/* -------------------------------------------------------------------------- */
1040
1041#define HIDPP_PAGE_BATTERY_LEVEL_STATUS 0x1000
1042
1043#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS 0x00
1044#define CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY 0x10
1045
1046#define EVENT_BATTERY_LEVEL_STATUS_BROADCAST 0x00
1047
1048#define FLAG_BATTERY_LEVEL_DISABLE_OSD BIT(0)
1049#define FLAG_BATTERY_LEVEL_MILEAGE BIT(1)
1050#define FLAG_BATTERY_LEVEL_RECHARGEABLE BIT(2)
1051
1052static int hidpp_map_battery_level(int capacity)
1053{
1054 if (capacity < 11)
1055 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1056 /*
1057 * The spec says this should be < 31 but some devices report 30
1058 * with brand new batteries and Windows reports 30 as "Good".
1059 */
1060 else if (capacity < 30)
1061 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1062 else if (capacity < 81)
1063 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1064 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1065}
1066
1067static int hidpp20_batterylevel_map_status_capacity(u8 data[3], int *capacity,
1068 int *next_capacity,
1069 int *level)
1070{
1071 int status;
1072
1073 *capacity = data[0];
1074 *next_capacity = data[1];
1075 *level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1076
1077 /* When discharging, we can rely on the device reported capacity.
1078 * For all other states the device reports 0 (unknown).
1079 */
1080 switch (data[2]) {
1081 case 0: /* discharging (in use) */
1082 status = POWER_SUPPLY_STATUS_DISCHARGING;
1083 *level = hidpp_map_battery_level(*capacity);
1084 break;
1085 case 1: /* recharging */
1086 status = POWER_SUPPLY_STATUS_CHARGING;
1087 break;
1088 case 2: /* charge in final stage */
1089 status = POWER_SUPPLY_STATUS_CHARGING;
1090 break;
1091 case 3: /* charge complete */
1092 status = POWER_SUPPLY_STATUS_FULL;
1093 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1094 *capacity = 100;
1095 break;
1096 case 4: /* recharging below optimal speed */
1097 status = POWER_SUPPLY_STATUS_CHARGING;
1098 break;
1099 /* 5 = invalid battery type
1100 6 = thermal error
1101 7 = other charging error */
1102 default:
1103 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1104 break;
1105 }
1106
1107 return status;
1108}
1109
1110static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
1111 u8 feature_index,
1112 int *status,
1113 int *capacity,
1114 int *next_capacity,
1115 int *level)
1116{
1117 struct hidpp_report response;
1118 int ret;
1119 u8 *params = (u8 *)response.fap.params;
1120
1121 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1122 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_LEVEL_STATUS,
1123 NULL, 0, &response);
1124 /* Ignore these intermittent errors */
1125 if (ret == HIDPP_ERROR_RESOURCE_ERROR)
1126 return -EIO;
1127 if (ret > 0) {
1128 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1129 __func__, ret);
1130 return -EPROTO;
1131 }
1132 if (ret)
1133 return ret;
1134
1135 *status = hidpp20_batterylevel_map_status_capacity(params, capacity,
1136 next_capacity,
1137 level);
1138
1139 return 0;
1140}
1141
1142static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
1143 u8 feature_index)
1144{
1145 struct hidpp_report response;
1146 int ret;
1147 u8 *params = (u8 *)response.fap.params;
1148 unsigned int level_count, flags;
1149
1150 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1151 CMD_BATTERY_LEVEL_STATUS_GET_BATTERY_CAPABILITY,
1152 NULL, 0, &response);
1153 if (ret > 0) {
1154 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1155 __func__, ret);
1156 return -EPROTO;
1157 }
1158 if (ret)
1159 return ret;
1160
1161 level_count = params[0];
1162 flags = params[1];
1163
1164 if (level_count < 10 || !(flags & FLAG_BATTERY_LEVEL_MILEAGE))
1165 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1166 else
1167 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1168
1169 return 0;
1170}
1171
1172static int hidpp20_query_battery_info(struct hidpp_device *hidpp)
1173{
1174 u8 feature_type;
1175 int ret;
1176 int status, capacity, next_capacity, level;
1177
1178 if (hidpp->battery.feature_index == 0xff) {
1179 ret = hidpp_root_get_feature(hidpp,
1180 HIDPP_PAGE_BATTERY_LEVEL_STATUS,
1181 &hidpp->battery.feature_index,
1182 &feature_type);
1183 if (ret)
1184 return ret;
1185 }
1186
1187 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1188 hidpp->battery.feature_index,
1189 &status, &capacity,
1190 &next_capacity, &level);
1191 if (ret)
1192 return ret;
1193
1194 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1195 hidpp->battery.feature_index);
1196 if (ret)
1197 return ret;
1198
1199 hidpp->battery.status = status;
1200 hidpp->battery.capacity = capacity;
1201 hidpp->battery.level = level;
1202 /* the capacity is only available when discharging or full */
1203 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1204 status == POWER_SUPPLY_STATUS_FULL;
1205
1206 return 0;
1207}
1208
1209static int hidpp20_battery_event(struct hidpp_device *hidpp,
1210 u8 *data, int size)
1211{
1212 struct hidpp_report *report = (struct hidpp_report *)data;
1213 int status, capacity, next_capacity, level;
1214 bool changed;
1215
1216 if (report->fap.feature_index != hidpp->battery.feature_index ||
1217 report->fap.funcindex_clientid != EVENT_BATTERY_LEVEL_STATUS_BROADCAST)
1218 return 0;
1219
1220 status = hidpp20_batterylevel_map_status_capacity(report->fap.params,
1221 &capacity,
1222 &next_capacity,
1223 &level);
1224
1225 /* the capacity is only available when discharging or full */
1226 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1227 status == POWER_SUPPLY_STATUS_FULL;
1228
1229 changed = capacity != hidpp->battery.capacity ||
1230 level != hidpp->battery.level ||
1231 status != hidpp->battery.status;
1232
1233 if (changed) {
1234 hidpp->battery.level = level;
1235 hidpp->battery.capacity = capacity;
1236 hidpp->battery.status = status;
1237 if (hidpp->battery.ps)
1238 power_supply_changed(hidpp->battery.ps);
1239 }
1240
1241 return 0;
1242}
1243
1244/* -------------------------------------------------------------------------- */
1245/* 0x1001: Battery voltage */
1246/* -------------------------------------------------------------------------- */
1247
1248#define HIDPP_PAGE_BATTERY_VOLTAGE 0x1001
1249
1250#define CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE 0x00
1251
1252#define EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST 0x00
1253
1254static int hidpp20_battery_map_status_voltage(u8 data[3], int *voltage,
1255 int *level, int *charge_type)
1256{
1257 int status;
1258
1259 long flags = (long) data[2];
1260
1261 if (flags & 0x80)
1262 switch (flags & 0x07) {
1263 case 0:
1264 status = POWER_SUPPLY_STATUS_CHARGING;
1265 break;
1266 case 1:
1267 status = POWER_SUPPLY_STATUS_FULL;
1268 *level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1269 break;
1270 case 2:
1271 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1272 break;
1273 default:
1274 status = POWER_SUPPLY_STATUS_UNKNOWN;
1275 break;
1276 }
1277 else
1278 status = POWER_SUPPLY_STATUS_DISCHARGING;
1279
1280 *charge_type = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
1281 if (test_bit(3, &flags)) {
1282 *charge_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
1283 }
1284 if (test_bit(4, &flags)) {
1285 *charge_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1286 }
1287 if (test_bit(5, &flags)) {
1288 *level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1289 }
1290
1291 *voltage = get_unaligned_be16(data);
1292
1293 return status;
1294}
1295
1296static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
1297 u8 feature_index,
1298 int *status, int *voltage,
1299 int *level, int *charge_type)
1300{
1301 struct hidpp_report response;
1302 int ret;
1303 u8 *params = (u8 *)response.fap.params;
1304
1305 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1306 CMD_BATTERY_VOLTAGE_GET_BATTERY_VOLTAGE,
1307 NULL, 0, &response);
1308
1309 if (ret > 0) {
1310 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1311 __func__, ret);
1312 return -EPROTO;
1313 }
1314 if (ret)
1315 return ret;
1316
1317 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
1318
1319 *status = hidpp20_battery_map_status_voltage(params, voltage,
1320 level, charge_type);
1321
1322 return 0;
1323}
1324
1325static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
1326{
1327 u8 feature_type;
1328 int ret;
1329 int status, voltage, level, charge_type;
1330
1331 if (hidpp->battery.voltage_feature_index == 0xff) {
1332 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
1333 &hidpp->battery.voltage_feature_index,
1334 &feature_type);
1335 if (ret)
1336 return ret;
1337 }
1338
1339 ret = hidpp20_battery_get_battery_voltage(hidpp,
1340 hidpp->battery.voltage_feature_index,
1341 &status, &voltage, &level, &charge_type);
1342
1343 if (ret)
1344 return ret;
1345
1346 hidpp->battery.status = status;
1347 hidpp->battery.voltage = voltage;
1348 hidpp->battery.level = level;
1349 hidpp->battery.charge_type = charge_type;
1350 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1351
1352 return 0;
1353}
1354
1355static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
1356 u8 *data, int size)
1357{
1358 struct hidpp_report *report = (struct hidpp_report *)data;
1359 int status, voltage, level, charge_type;
1360
1361 if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||
1362 report->fap.funcindex_clientid != EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST)
1363 return 0;
1364
1365 status = hidpp20_battery_map_status_voltage(report->fap.params, &voltage,
1366 &level, &charge_type);
1367
1368 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1369
1370 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1371 hidpp->battery.voltage = voltage;
1372 hidpp->battery.status = status;
1373 hidpp->battery.level = level;
1374 hidpp->battery.charge_type = charge_type;
1375 if (hidpp->battery.ps)
1376 power_supply_changed(hidpp->battery.ps);
1377 }
1378 return 0;
1379}
1380
1381static enum power_supply_property hidpp_battery_props[] = {
1382 POWER_SUPPLY_PROP_ONLINE,
1383 POWER_SUPPLY_PROP_STATUS,
1384 POWER_SUPPLY_PROP_SCOPE,
1385 POWER_SUPPLY_PROP_MODEL_NAME,
1386 POWER_SUPPLY_PROP_MANUFACTURER,
1387 POWER_SUPPLY_PROP_SERIAL_NUMBER,
1388 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY, */
1389 0, /* placeholder for POWER_SUPPLY_PROP_CAPACITY_LEVEL, */
1390 0, /* placeholder for POWER_SUPPLY_PROP_VOLTAGE_NOW, */
1391};
1392
1393static int hidpp_battery_get_property(struct power_supply *psy,
1394 enum power_supply_property psp,
1395 union power_supply_propval *val)
1396{
1397 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1398 int ret = 0;
1399
1400 switch(psp) {
1401 case POWER_SUPPLY_PROP_STATUS:
1402 val->intval = hidpp->battery.status;
1403 break;
1404 case POWER_SUPPLY_PROP_CAPACITY:
1405 val->intval = hidpp->battery.capacity;
1406 break;
1407 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1408 val->intval = hidpp->battery.level;
1409 break;
1410 case POWER_SUPPLY_PROP_SCOPE:
1411 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1412 break;
1413 case POWER_SUPPLY_PROP_ONLINE:
1414 val->intval = hidpp->battery.online;
1415 break;
1416 case POWER_SUPPLY_PROP_MODEL_NAME:
1417 if (!strncmp(hidpp->name, "Logitech ", 9))
1418 val->strval = hidpp->name + 9;
1419 else
1420 val->strval = hidpp->name;
1421 break;
1422 case POWER_SUPPLY_PROP_MANUFACTURER:
1423 val->strval = "Logitech";
1424 break;
1425 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
1426 val->strval = hidpp->hid_dev->uniq;
1427 break;
1428 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1429 /* hardware reports voltage in in mV. sysfs expects uV */
1430 val->intval = hidpp->battery.voltage * 1000;
1431 break;
1432 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1433 val->intval = hidpp->battery.charge_type;
1434 break;
1435 default:
1436 ret = -EINVAL;
1437 break;
1438 }
1439
1440 return ret;
1441}
1442
1443/* -------------------------------------------------------------------------- */
1444/* 0x1d4b: Wireless device status */
1445/* -------------------------------------------------------------------------- */
1446#define HIDPP_PAGE_WIRELESS_DEVICE_STATUS 0x1d4b
1447
1448static int hidpp_set_wireless_feature_index(struct hidpp_device *hidpp)
1449{
1450 u8 feature_type;
1451 int ret;
1452
1453 ret = hidpp_root_get_feature(hidpp,
1454 HIDPP_PAGE_WIRELESS_DEVICE_STATUS,
1455 &hidpp->wireless_feature_index,
1456 &feature_type);
1457
1458 return ret;
1459}
1460
1461/* -------------------------------------------------------------------------- */
1462/* 0x2120: Hi-resolution scrolling */
1463/* -------------------------------------------------------------------------- */
1464
1465#define HIDPP_PAGE_HI_RESOLUTION_SCROLLING 0x2120
1466
1467#define CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE 0x10
1468
1469static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
1470 bool enabled, u8 *multiplier)
1471{
1472 u8 feature_index;
1473 u8 feature_type;
1474 int ret;
1475 u8 params[1];
1476 struct hidpp_report response;
1477
1478 ret = hidpp_root_get_feature(hidpp,
1479 HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
1480 &feature_index,
1481 &feature_type);
1482 if (ret)
1483 return ret;
1484
1485 params[0] = enabled ? BIT(0) : 0;
1486 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1487 CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE,
1488 params, sizeof(params), &response);
1489 if (ret)
1490 return ret;
1491 *multiplier = response.fap.params[1];
1492 return 0;
1493}
1494
1495/* -------------------------------------------------------------------------- */
1496/* 0x2121: HiRes Wheel */
1497/* -------------------------------------------------------------------------- */
1498
1499#define HIDPP_PAGE_HIRES_WHEEL 0x2121
1500
1501#define CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY 0x00
1502#define CMD_HIRES_WHEEL_SET_WHEEL_MODE 0x20
1503
1504static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
1505 u8 *multiplier)
1506{
1507 u8 feature_index;
1508 u8 feature_type;
1509 int ret;
1510 struct hidpp_report response;
1511
1512 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1513 &feature_index, &feature_type);
1514 if (ret)
1515 goto return_default;
1516
1517 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1518 CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY,
1519 NULL, 0, &response);
1520 if (ret)
1521 goto return_default;
1522
1523 *multiplier = response.fap.params[0];
1524 return 0;
1525return_default:
1526 hid_warn(hidpp->hid_dev,
1527 "Couldn't get wheel multiplier (error %d)\n", ret);
1528 return ret;
1529}
1530
1531static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
1532 bool high_resolution, bool use_hidpp)
1533{
1534 u8 feature_index;
1535 u8 feature_type;
1536 int ret;
1537 u8 params[1];
1538 struct hidpp_report response;
1539
1540 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1541 &feature_index, &feature_type);
1542 if (ret)
1543 return ret;
1544
1545 params[0] = (invert ? BIT(2) : 0) |
1546 (high_resolution ? BIT(1) : 0) |
1547 (use_hidpp ? BIT(0) : 0);
1548
1549 return hidpp_send_fap_command_sync(hidpp, feature_index,
1550 CMD_HIRES_WHEEL_SET_WHEEL_MODE,
1551 params, sizeof(params), &response);
1552}
1553
1554/* -------------------------------------------------------------------------- */
1555/* 0x4301: Solar Keyboard */
1556/* -------------------------------------------------------------------------- */
1557
1558#define HIDPP_PAGE_SOLAR_KEYBOARD 0x4301
1559
1560#define CMD_SOLAR_SET_LIGHT_MEASURE 0x00
1561
1562#define EVENT_SOLAR_BATTERY_BROADCAST 0x00
1563#define EVENT_SOLAR_BATTERY_LIGHT_MEASURE 0x10
1564#define EVENT_SOLAR_CHECK_LIGHT_BUTTON 0x20
1565
1566static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
1567{
1568 struct hidpp_report response;
1569 u8 params[2] = { 1, 1 };
1570 u8 feature_type;
1571 int ret;
1572
1573 if (hidpp->battery.feature_index == 0xff) {
1574 ret = hidpp_root_get_feature(hidpp,
1575 HIDPP_PAGE_SOLAR_KEYBOARD,
1576 &hidpp->battery.solar_feature_index,
1577 &feature_type);
1578 if (ret)
1579 return ret;
1580 }
1581
1582 ret = hidpp_send_fap_command_sync(hidpp,
1583 hidpp->battery.solar_feature_index,
1584 CMD_SOLAR_SET_LIGHT_MEASURE,
1585 params, 2, &response);
1586 if (ret > 0) {
1587 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1588 __func__, ret);
1589 return -EPROTO;
1590 }
1591 if (ret)
1592 return ret;
1593
1594 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1595
1596 return 0;
1597}
1598
1599static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
1600 u8 *data, int size)
1601{
1602 struct hidpp_report *report = (struct hidpp_report *)data;
1603 int capacity, lux, status;
1604 u8 function;
1605
1606 function = report->fap.funcindex_clientid;
1607
1608
1609 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
1610 !(function == EVENT_SOLAR_BATTERY_BROADCAST ||
1611 function == EVENT_SOLAR_BATTERY_LIGHT_MEASURE ||
1612 function == EVENT_SOLAR_CHECK_LIGHT_BUTTON))
1613 return 0;
1614
1615 capacity = report->fap.params[0];
1616
1617 switch (function) {
1618 case EVENT_SOLAR_BATTERY_LIGHT_MEASURE:
1619 lux = (report->fap.params[1] << 8) | report->fap.params[2];
1620 if (lux > 200)
1621 status = POWER_SUPPLY_STATUS_CHARGING;
1622 else
1623 status = POWER_SUPPLY_STATUS_DISCHARGING;
1624 break;
1625 case EVENT_SOLAR_CHECK_LIGHT_BUTTON:
1626 default:
1627 if (capacity < hidpp->battery.capacity)
1628 status = POWER_SUPPLY_STATUS_DISCHARGING;
1629 else
1630 status = POWER_SUPPLY_STATUS_CHARGING;
1631
1632 }
1633
1634 if (capacity == 100)
1635 status = POWER_SUPPLY_STATUS_FULL;
1636
1637 hidpp->battery.online = true;
1638 if (capacity != hidpp->battery.capacity ||
1639 status != hidpp->battery.status) {
1640 hidpp->battery.capacity = capacity;
1641 hidpp->battery.status = status;
1642 if (hidpp->battery.ps)
1643 power_supply_changed(hidpp->battery.ps);
1644 }
1645
1646 return 0;
1647}
1648
1649/* -------------------------------------------------------------------------- */
1650/* 0x6010: Touchpad FW items */
1651/* -------------------------------------------------------------------------- */
1652
1653#define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010
1654
1655#define CMD_TOUCHPAD_FW_ITEMS_SET 0x10
1656
1657struct hidpp_touchpad_fw_items {
1658 uint8_t presence;
1659 uint8_t desired_state;
1660 uint8_t state;
1661 uint8_t persistent;
1662};
1663
1664/**
1665 * send a set state command to the device by reading the current items->state
1666 * field. items is then filled with the current state.
1667 */
1668static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
1669 u8 feature_index,
1670 struct hidpp_touchpad_fw_items *items)
1671{
1672 struct hidpp_report response;
1673 int ret;
1674 u8 *params = (u8 *)response.fap.params;
1675
1676 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1677 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
1678
1679 if (ret > 0) {
1680 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1681 __func__, ret);
1682 return -EPROTO;
1683 }
1684 if (ret)
1685 return ret;
1686
1687 items->presence = params[0];
1688 items->desired_state = params[1];
1689 items->state = params[2];
1690 items->persistent = params[3];
1691
1692 return 0;
1693}
1694
1695/* -------------------------------------------------------------------------- */
1696/* 0x6100: TouchPadRawXY */
1697/* -------------------------------------------------------------------------- */
1698
1699#define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100
1700
1701#define CMD_TOUCHPAD_GET_RAW_INFO 0x01
1702#define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x21
1703
1704#define EVENT_TOUCHPAD_RAW_XY 0x00
1705
1706#define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01
1707#define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03
1708
1709struct hidpp_touchpad_raw_info {
1710 u16 x_size;
1711 u16 y_size;
1712 u8 z_range;
1713 u8 area_range;
1714 u8 timestamp_unit;
1715 u8 maxcontacts;
1716 u8 origin;
1717 u16 res;
1718};
1719
1720struct hidpp_touchpad_raw_xy_finger {
1721 u8 contact_type;
1722 u8 contact_status;
1723 u16 x;
1724 u16 y;
1725 u8 z;
1726 u8 area;
1727 u8 finger_id;
1728};
1729
1730struct hidpp_touchpad_raw_xy {
1731 u16 timestamp;
1732 struct hidpp_touchpad_raw_xy_finger fingers[2];
1733 u8 spurious_flag;
1734 u8 end_of_frame;
1735 u8 finger_count;
1736 u8 button;
1737};
1738
1739static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
1740 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
1741{
1742 struct hidpp_report response;
1743 int ret;
1744 u8 *params = (u8 *)response.fap.params;
1745
1746 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1747 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
1748
1749 if (ret > 0) {
1750 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1751 __func__, ret);
1752 return -EPROTO;
1753 }
1754 if (ret)
1755 return ret;
1756
1757 raw_info->x_size = get_unaligned_be16(¶ms[0]);
1758 raw_info->y_size = get_unaligned_be16(¶ms[2]);
1759 raw_info->z_range = params[4];
1760 raw_info->area_range = params[5];
1761 raw_info->maxcontacts = params[7];
1762 raw_info->origin = params[8];
1763 /* res is given in unit per inch */
1764 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51;
1765
1766 return ret;
1767}
1768
1769static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
1770 u8 feature_index, bool send_raw_reports,
1771 bool sensor_enhanced_settings)
1772{
1773 struct hidpp_report response;
1774
1775 /*
1776 * Params:
1777 * bit 0 - enable raw
1778 * bit 1 - 16bit Z, no area
1779 * bit 2 - enhanced sensitivity
1780 * bit 3 - width, height (4 bits each) instead of area
1781 * bit 4 - send raw + gestures (degrades smoothness)
1782 * remaining bits - reserved
1783 */
1784 u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
1785
1786 return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
1787 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response);
1788}
1789
1790static void hidpp_touchpad_touch_event(u8 *data,
1791 struct hidpp_touchpad_raw_xy_finger *finger)
1792{
1793 u8 x_m = data[0] << 2;
1794 u8 y_m = data[2] << 2;
1795
1796 finger->x = x_m << 6 | data[1];
1797 finger->y = y_m << 6 | data[3];
1798
1799 finger->contact_type = data[0] >> 6;
1800 finger->contact_status = data[2] >> 6;
1801
1802 finger->z = data[4];
1803 finger->area = data[5];
1804 finger->finger_id = data[6] >> 4;
1805}
1806
1807static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
1808 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
1809{
1810 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
1811 raw_xy->end_of_frame = data[8] & 0x01;
1812 raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
1813 raw_xy->finger_count = data[15] & 0x0f;
1814 raw_xy->button = (data[8] >> 2) & 0x01;
1815
1816 if (raw_xy->finger_count) {
1817 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
1818 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
1819 }
1820}
1821
1822/* -------------------------------------------------------------------------- */
1823/* 0x8123: Force feedback support */
1824/* -------------------------------------------------------------------------- */
1825
1826#define HIDPP_FF_GET_INFO 0x01
1827#define HIDPP_FF_RESET_ALL 0x11
1828#define HIDPP_FF_DOWNLOAD_EFFECT 0x21
1829#define HIDPP_FF_SET_EFFECT_STATE 0x31
1830#define HIDPP_FF_DESTROY_EFFECT 0x41
1831#define HIDPP_FF_GET_APERTURE 0x51
1832#define HIDPP_FF_SET_APERTURE 0x61
1833#define HIDPP_FF_GET_GLOBAL_GAINS 0x71
1834#define HIDPP_FF_SET_GLOBAL_GAINS 0x81
1835
1836#define HIDPP_FF_EFFECT_STATE_GET 0x00
1837#define HIDPP_FF_EFFECT_STATE_STOP 0x01
1838#define HIDPP_FF_EFFECT_STATE_PLAY 0x02
1839#define HIDPP_FF_EFFECT_STATE_PAUSE 0x03
1840
1841#define HIDPP_FF_EFFECT_CONSTANT 0x00
1842#define HIDPP_FF_EFFECT_PERIODIC_SINE 0x01
1843#define HIDPP_FF_EFFECT_PERIODIC_SQUARE 0x02
1844#define HIDPP_FF_EFFECT_PERIODIC_TRIANGLE 0x03
1845#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP 0x04
1846#define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN 0x05
1847#define HIDPP_FF_EFFECT_SPRING 0x06
1848#define HIDPP_FF_EFFECT_DAMPER 0x07
1849#define HIDPP_FF_EFFECT_FRICTION 0x08
1850#define HIDPP_FF_EFFECT_INERTIA 0x09
1851#define HIDPP_FF_EFFECT_RAMP 0x0A
1852
1853#define HIDPP_FF_EFFECT_AUTOSTART 0x80
1854
1855#define HIDPP_FF_EFFECTID_NONE -1
1856#define HIDPP_FF_EFFECTID_AUTOCENTER -2
1857#define HIDPP_AUTOCENTER_PARAMS_LENGTH 18
1858
1859#define HIDPP_FF_MAX_PARAMS 20
1860#define HIDPP_FF_RESERVED_SLOTS 1
1861
1862struct hidpp_ff_private_data {
1863 struct hidpp_device *hidpp;
1864 u8 feature_index;
1865 u8 version;
1866 u16 gain;
1867 s16 range;
1868 u8 slot_autocenter;
1869 u8 num_effects;
1870 int *effect_ids;
1871 struct workqueue_struct *wq;
1872 atomic_t workqueue_size;
1873};
1874
1875struct hidpp_ff_work_data {
1876 struct work_struct work;
1877 struct hidpp_ff_private_data *data;
1878 int effect_id;
1879 u8 command;
1880 u8 params[HIDPP_FF_MAX_PARAMS];
1881 u8 size;
1882};
1883
1884static const signed short hidpp_ff_effects[] = {
1885 FF_CONSTANT,
1886 FF_PERIODIC,
1887 FF_SINE,
1888 FF_SQUARE,
1889 FF_SAW_UP,
1890 FF_SAW_DOWN,
1891 FF_TRIANGLE,
1892 FF_SPRING,
1893 FF_DAMPER,
1894 FF_AUTOCENTER,
1895 FF_GAIN,
1896 -1
1897};
1898
1899static const signed short hidpp_ff_effects_v2[] = {
1900 FF_RAMP,
1901 FF_FRICTION,
1902 FF_INERTIA,
1903 -1
1904};
1905
1906static const u8 HIDPP_FF_CONDITION_CMDS[] = {
1907 HIDPP_FF_EFFECT_SPRING,
1908 HIDPP_FF_EFFECT_FRICTION,
1909 HIDPP_FF_EFFECT_DAMPER,
1910 HIDPP_FF_EFFECT_INERTIA
1911};
1912
1913static const char *HIDPP_FF_CONDITION_NAMES[] = {
1914 "spring",
1915 "friction",
1916 "damper",
1917 "inertia"
1918};
1919
1920
1921static u8 hidpp_ff_find_effect(struct hidpp_ff_private_data *data, int effect_id)
1922{
1923 int i;
1924
1925 for (i = 0; i < data->num_effects; i++)
1926 if (data->effect_ids[i] == effect_id)
1927 return i+1;
1928
1929 return 0;
1930}
1931
1932static void hidpp_ff_work_handler(struct work_struct *w)
1933{
1934 struct hidpp_ff_work_data *wd = container_of(w, struct hidpp_ff_work_data, work);
1935 struct hidpp_ff_private_data *data = wd->data;
1936 struct hidpp_report response;
1937 u8 slot;
1938 int ret;
1939
1940 /* add slot number if needed */
1941 switch (wd->effect_id) {
1942 case HIDPP_FF_EFFECTID_AUTOCENTER:
1943 wd->params[0] = data->slot_autocenter;
1944 break;
1945 case HIDPP_FF_EFFECTID_NONE:
1946 /* leave slot as zero */
1947 break;
1948 default:
1949 /* find current slot for effect */
1950 wd->params[0] = hidpp_ff_find_effect(data, wd->effect_id);
1951 break;
1952 }
1953
1954 /* send command and wait for reply */
1955 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
1956 wd->command, wd->params, wd->size, &response);
1957
1958 if (ret) {
1959 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
1960 goto out;
1961 }
1962
1963 /* parse return data */
1964 switch (wd->command) {
1965 case HIDPP_FF_DOWNLOAD_EFFECT:
1966 slot = response.fap.params[0];
1967 if (slot > 0 && slot <= data->num_effects) {
1968 if (wd->effect_id >= 0)
1969 /* regular effect uploaded */
1970 data->effect_ids[slot-1] = wd->effect_id;
1971 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
1972 /* autocenter spring uploaded */
1973 data->slot_autocenter = slot;
1974 }
1975 break;
1976 case HIDPP_FF_DESTROY_EFFECT:
1977 if (wd->effect_id >= 0)
1978 /* regular effect destroyed */
1979 data->effect_ids[wd->params[0]-1] = -1;
1980 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
1981 /* autocenter spring destoyed */
1982 data->slot_autocenter = 0;
1983 break;
1984 case HIDPP_FF_SET_GLOBAL_GAINS:
1985 data->gain = (wd->params[0] << 8) + wd->params[1];
1986 break;
1987 case HIDPP_FF_SET_APERTURE:
1988 data->range = (wd->params[0] << 8) + wd->params[1];
1989 break;
1990 default:
1991 /* no action needed */
1992 break;
1993 }
1994
1995out:
1996 atomic_dec(&data->workqueue_size);
1997 kfree(wd);
1998}
1999
2000static int hidpp_ff_queue_work(struct hidpp_ff_private_data *data, int effect_id, u8 command, u8 *params, u8 size)
2001{
2002 struct hidpp_ff_work_data *wd = kzalloc(sizeof(*wd), GFP_KERNEL);
2003 int s;
2004
2005 if (!wd)
2006 return -ENOMEM;
2007
2008 INIT_WORK(&wd->work, hidpp_ff_work_handler);
2009
2010 wd->data = data;
2011 wd->effect_id = effect_id;
2012 wd->command = command;
2013 wd->size = size;
2014 memcpy(wd->params, params, size);
2015
2016 atomic_inc(&data->workqueue_size);
2017 queue_work(data->wq, &wd->work);
2018
2019 /* warn about excessive queue size */
2020 s = atomic_read(&data->workqueue_size);
2021 if (s >= 20 && s % 20 == 0)
2022 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2023
2024 return 0;
2025}
2026
2027static int hidpp_ff_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
2028{
2029 struct hidpp_ff_private_data *data = dev->ff->private;
2030 u8 params[20];
2031 u8 size;
2032 int force;
2033
2034 /* set common parameters */
2035 params[2] = effect->replay.length >> 8;
2036 params[3] = effect->replay.length & 255;
2037 params[4] = effect->replay.delay >> 8;
2038 params[5] = effect->replay.delay & 255;
2039
2040 switch (effect->type) {
2041 case FF_CONSTANT:
2042 force = (effect->u.constant.level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2043 params[1] = HIDPP_FF_EFFECT_CONSTANT;
2044 params[6] = force >> 8;
2045 params[7] = force & 255;
2046 params[8] = effect->u.constant.envelope.attack_level >> 7;
2047 params[9] = effect->u.constant.envelope.attack_length >> 8;
2048 params[10] = effect->u.constant.envelope.attack_length & 255;
2049 params[11] = effect->u.constant.envelope.fade_level >> 7;
2050 params[12] = effect->u.constant.envelope.fade_length >> 8;
2051 params[13] = effect->u.constant.envelope.fade_length & 255;
2052 size = 14;
2053 dbg_hid("Uploading constant force level=%d in dir %d = %d\n",
2054 effect->u.constant.level,
2055 effect->direction, force);
2056 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2057 effect->u.constant.envelope.attack_level,
2058 effect->u.constant.envelope.attack_length,
2059 effect->u.constant.envelope.fade_level,
2060 effect->u.constant.envelope.fade_length);
2061 break;
2062 case FF_PERIODIC:
2063 {
2064 switch (effect->u.periodic.waveform) {
2065 case FF_SINE:
2066 params[1] = HIDPP_FF_EFFECT_PERIODIC_SINE;
2067 break;
2068 case FF_SQUARE:
2069 params[1] = HIDPP_FF_EFFECT_PERIODIC_SQUARE;
2070 break;
2071 case FF_SAW_UP:
2072 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP;
2073 break;
2074 case FF_SAW_DOWN:
2075 params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN;
2076 break;
2077 case FF_TRIANGLE:
2078 params[1] = HIDPP_FF_EFFECT_PERIODIC_TRIANGLE;
2079 break;
2080 default:
2081 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2082 return -EINVAL;
2083 }
2084 force = (effect->u.periodic.magnitude * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2085 params[6] = effect->u.periodic.magnitude >> 8;
2086 params[7] = effect->u.periodic.magnitude & 255;
2087 params[8] = effect->u.periodic.offset >> 8;
2088 params[9] = effect->u.periodic.offset & 255;
2089 params[10] = effect->u.periodic.period >> 8;
2090 params[11] = effect->u.periodic.period & 255;
2091 params[12] = effect->u.periodic.phase >> 8;
2092 params[13] = effect->u.periodic.phase & 255;
2093 params[14] = effect->u.periodic.envelope.attack_level >> 7;
2094 params[15] = effect->u.periodic.envelope.attack_length >> 8;
2095 params[16] = effect->u.periodic.envelope.attack_length & 255;
2096 params[17] = effect->u.periodic.envelope.fade_level >> 7;
2097 params[18] = effect->u.periodic.envelope.fade_length >> 8;
2098 params[19] = effect->u.periodic.envelope.fade_length & 255;
2099 size = 20;
2100 dbg_hid("Uploading periodic force mag=%d/dir=%d, offset=%d, period=%d ms, phase=%d\n",
2101 effect->u.periodic.magnitude, effect->direction,
2102 effect->u.periodic.offset,
2103 effect->u.periodic.period,
2104 effect->u.periodic.phase);
2105 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2106 effect->u.periodic.envelope.attack_level,
2107 effect->u.periodic.envelope.attack_length,
2108 effect->u.periodic.envelope.fade_level,
2109 effect->u.periodic.envelope.fade_length);
2110 break;
2111 }
2112 case FF_RAMP:
2113 params[1] = HIDPP_FF_EFFECT_RAMP;
2114 force = (effect->u.ramp.start_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2115 params[6] = force >> 8;
2116 params[7] = force & 255;
2117 force = (effect->u.ramp.end_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2118 params[8] = force >> 8;
2119 params[9] = force & 255;
2120 params[10] = effect->u.ramp.envelope.attack_level >> 7;
2121 params[11] = effect->u.ramp.envelope.attack_length >> 8;
2122 params[12] = effect->u.ramp.envelope.attack_length & 255;
2123 params[13] = effect->u.ramp.envelope.fade_level >> 7;
2124 params[14] = effect->u.ramp.envelope.fade_length >> 8;
2125 params[15] = effect->u.ramp.envelope.fade_length & 255;
2126 size = 16;
2127 dbg_hid("Uploading ramp force level=%d -> %d in dir %d = %d\n",
2128 effect->u.ramp.start_level,
2129 effect->u.ramp.end_level,
2130 effect->direction, force);
2131 dbg_hid(" envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2132 effect->u.ramp.envelope.attack_level,
2133 effect->u.ramp.envelope.attack_length,
2134 effect->u.ramp.envelope.fade_level,
2135 effect->u.ramp.envelope.fade_length);
2136 break;
2137 case FF_FRICTION:
2138 case FF_INERTIA:
2139 case FF_SPRING:
2140 case FF_DAMPER:
2141 params[1] = HIDPP_FF_CONDITION_CMDS[effect->type - FF_SPRING];
2142 params[6] = effect->u.condition[0].left_saturation >> 9;
2143 params[7] = (effect->u.condition[0].left_saturation >> 1) & 255;
2144 params[8] = effect->u.condition[0].left_coeff >> 8;
2145 params[9] = effect->u.condition[0].left_coeff & 255;
2146 params[10] = effect->u.condition[0].deadband >> 9;
2147 params[11] = (effect->u.condition[0].deadband >> 1) & 255;
2148 params[12] = effect->u.condition[0].center >> 8;
2149 params[13] = effect->u.condition[0].center & 255;
2150 params[14] = effect->u.condition[0].right_coeff >> 8;
2151 params[15] = effect->u.condition[0].right_coeff & 255;
2152 params[16] = effect->u.condition[0].right_saturation >> 9;
2153 params[17] = (effect->u.condition[0].right_saturation >> 1) & 255;
2154 size = 18;
2155 dbg_hid("Uploading %s force left coeff=%d, left sat=%d, right coeff=%d, right sat=%d\n",
2156 HIDPP_FF_CONDITION_NAMES[effect->type - FF_SPRING],
2157 effect->u.condition[0].left_coeff,
2158 effect->u.condition[0].left_saturation,
2159 effect->u.condition[0].right_coeff,
2160 effect->u.condition[0].right_saturation);
2161 dbg_hid(" deadband=%d, center=%d\n",
2162 effect->u.condition[0].deadband,
2163 effect->u.condition[0].center);
2164 break;
2165 default:
2166 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2167 return -EINVAL;
2168 }
2169
2170 return hidpp_ff_queue_work(data, effect->id, HIDPP_FF_DOWNLOAD_EFFECT, params, size);
2171}
2172
2173static int hidpp_ff_playback(struct input_dev *dev, int effect_id, int value)
2174{
2175 struct hidpp_ff_private_data *data = dev->ff->private;
2176 u8 params[2];
2177
2178 params[1] = value ? HIDPP_FF_EFFECT_STATE_PLAY : HIDPP_FF_EFFECT_STATE_STOP;
2179
2180 dbg_hid("St%sing playback of effect %d.\n", value?"art":"opp", effect_id);
2181
2182 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_SET_EFFECT_STATE, params, ARRAY_SIZE(params));
2183}
2184
2185static int hidpp_ff_erase_effect(struct input_dev *dev, int effect_id)
2186{
2187 struct hidpp_ff_private_data *data = dev->ff->private;
2188 u8 slot = 0;
2189
2190 dbg_hid("Erasing effect %d.\n", effect_id);
2191
2192 return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_DESTROY_EFFECT, &slot, 1);
2193}
2194
2195static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
2196{
2197 struct hidpp_ff_private_data *data = dev->ff->private;
2198 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH];
2199
2200 dbg_hid("Setting autocenter to %d.\n", magnitude);
2201
2202 /* start a standard spring effect */
2203 params[1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART;
2204 /* zero delay and duration */
2205 params[2] = params[3] = params[4] = params[5] = 0;
2206 /* set coeff to 25% of saturation */
2207 params[8] = params[14] = magnitude >> 11;
2208 params[9] = params[15] = (magnitude >> 3) & 255;
2209 params[6] = params[16] = magnitude >> 9;
2210 params[7] = params[17] = (magnitude >> 1) & 255;
2211 /* zero deadband and center */
2212 params[10] = params[11] = params[12] = params[13] = 0;
2213
2214 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_AUTOCENTER, HIDPP_FF_DOWNLOAD_EFFECT, params, ARRAY_SIZE(params));
2215}
2216
2217static void hidpp_ff_set_gain(struct input_dev *dev, u16 gain)
2218{
2219 struct hidpp_ff_private_data *data = dev->ff->private;
2220 u8 params[4];
2221
2222 dbg_hid("Setting gain to %d.\n", gain);
2223
2224 params[0] = gain >> 8;
2225 params[1] = gain & 255;
2226 params[2] = 0; /* no boost */
2227 params[3] = 0;
2228
2229 hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_NONE, HIDPP_FF_SET_GLOBAL_GAINS, params, ARRAY_SIZE(params));
2230}
2231
2232static ssize_t hidpp_ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
2233{
2234 struct hid_device *hid = to_hid_device(dev);
2235 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2236 struct input_dev *idev = hidinput->input;
2237 struct hidpp_ff_private_data *data = idev->ff->private;
2238
2239 return scnprintf(buf, PAGE_SIZE, "%u\n", data->range);
2240}
2241
2242static ssize_t hidpp_ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2243{
2244 struct hid_device *hid = to_hid_device(dev);
2245 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2246 struct input_dev *idev = hidinput->input;
2247 struct hidpp_ff_private_data *data = idev->ff->private;
2248 u8 params[2];
2249 int range = simple_strtoul(buf, NULL, 10);
2250
2251 range = clamp(range, 180, 900);
2252
2253 params[0] = range >> 8;
2254 params[1] = range & 0x00FF;
2255
2256 hidpp_ff_queue_work(data, -1, HIDPP_FF_SET_APERTURE, params, ARRAY_SIZE(params));
2257
2258 return count;
2259}
2260
2261static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
2262
2263static void hidpp_ff_destroy(struct ff_device *ff)
2264{
2265 struct hidpp_ff_private_data *data = ff->private;
2266 struct hid_device *hid = data->hidpp->hid_dev;
2267
2268 hid_info(hid, "Unloading HID++ force feedback.\n");
2269
2270 device_remove_file(&hid->dev, &dev_attr_range);
2271 destroy_workqueue(data->wq);
2272 kfree(data->effect_ids);
2273}
2274
2275static int hidpp_ff_init(struct hidpp_device *hidpp,
2276 struct hidpp_ff_private_data *data)
2277{
2278 struct hid_device *hid = hidpp->hid_dev;
2279 struct hid_input *hidinput;
2280 struct input_dev *dev;
2281 const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor);
2282 const u16 bcdDevice = le16_to_cpu(udesc->bcdDevice);
2283 struct ff_device *ff;
2284 int error, j, num_slots = data->num_effects;
2285 u8 version;
2286
2287 if (list_empty(&hid->inputs)) {
2288 hid_err(hid, "no inputs found\n");
2289 return -ENODEV;
2290 }
2291 hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2292 dev = hidinput->input;
2293
2294 if (!dev) {
2295 hid_err(hid, "Struct input_dev not set!\n");
2296 return -EINVAL;
2297 }
2298
2299 /* Get firmware release */
2300 version = bcdDevice & 255;
2301
2302 /* Set supported force feedback capabilities */
2303 for (j = 0; hidpp_ff_effects[j] >= 0; j++)
2304 set_bit(hidpp_ff_effects[j], dev->ffbit);
2305 if (version > 1)
2306 for (j = 0; hidpp_ff_effects_v2[j] >= 0; j++)
2307 set_bit(hidpp_ff_effects_v2[j], dev->ffbit);
2308
2309 error = input_ff_create(dev, num_slots);
2310
2311 if (error) {
2312 hid_err(dev, "Failed to create FF device!\n");
2313 return error;
2314 }
2315 /*
2316 * Create a copy of passed data, so we can transfer memory
2317 * ownership to FF core
2318 */
2319 data = kmemdup(data, sizeof(*data), GFP_KERNEL);
2320 if (!data)
2321 return -ENOMEM;
2322 data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
2323 if (!data->effect_ids) {
2324 kfree(data);
2325 return -ENOMEM;
2326 }
2327 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2328 if (!data->wq) {
2329 kfree(data->effect_ids);
2330 kfree(data);
2331 return -ENOMEM;
2332 }
2333
2334 data->hidpp = hidpp;
2335 data->version = version;
2336 for (j = 0; j < num_slots; j++)
2337 data->effect_ids[j] = -1;
2338
2339 ff = dev->ff;
2340 ff->private = data;
2341
2342 ff->upload = hidpp_ff_upload_effect;
2343 ff->erase = hidpp_ff_erase_effect;
2344 ff->playback = hidpp_ff_playback;
2345 ff->set_gain = hidpp_ff_set_gain;
2346 ff->set_autocenter = hidpp_ff_set_autocenter;
2347 ff->destroy = hidpp_ff_destroy;
2348
2349 /* Create sysfs interface */
2350 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2351 if (error)
2352 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2353
2354 /* init the hardware command queue */
2355 atomic_set(&data->workqueue_size, 0);
2356
2357 hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
2358 version);
2359
2360 return 0;
2361}
2362
2363/* ************************************************************************** */
2364/* */
2365/* Device Support */
2366/* */
2367/* ************************************************************************** */
2368
2369/* -------------------------------------------------------------------------- */
2370/* Touchpad HID++ devices */
2371/* -------------------------------------------------------------------------- */
2372
2373#define WTP_MANUAL_RESOLUTION 39
2374
2375struct wtp_data {
2376 u16 x_size, y_size;
2377 u8 finger_count;
2378 u8 mt_feature_index;
2379 u8 button_feature_index;
2380 u8 maxcontacts;
2381 bool flip_y;
2382 unsigned int resolution;
2383};
2384
2385static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2386 struct hid_field *field, struct hid_usage *usage,
2387 unsigned long **bit, int *max)
2388{
2389 return -1;
2390}
2391
2392static void wtp_populate_input(struct hidpp_device *hidpp,
2393 struct input_dev *input_dev)
2394{
2395 struct wtp_data *wd = hidpp->private_data;
2396
2397 __set_bit(EV_ABS, input_dev->evbit);
2398 __set_bit(EV_KEY, input_dev->evbit);
2399 __clear_bit(EV_REL, input_dev->evbit);
2400 __clear_bit(EV_LED, input_dev->evbit);
2401
2402 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
2403 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
2404 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
2405 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
2406
2407 /* Max pressure is not given by the devices, pick one */
2408 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
2409
2410 input_set_capability(input_dev, EV_KEY, BTN_LEFT);
2411
2412 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2413 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
2414 else
2415 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2416
2417 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
2418 INPUT_MT_DROP_UNUSED);
2419}
2420
2421static void wtp_touch_event(struct hidpp_device *hidpp,
2422 struct hidpp_touchpad_raw_xy_finger *touch_report)
2423{
2424 struct wtp_data *wd = hidpp->private_data;
2425 int slot;
2426
2427 if (!touch_report->finger_id || touch_report->contact_type)
2428 /* no actual data */
2429 return;
2430
2431 slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2432
2433 input_mt_slot(hidpp->input, slot);
2434 input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2435 touch_report->contact_status);
2436 if (touch_report->contact_status) {
2437 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2438 touch_report->x);
2439 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2440 wd->flip_y ? wd->y_size - touch_report->y :
2441 touch_report->y);
2442 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2443 touch_report->area);
2444 }
2445}
2446
2447static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
2448 struct hidpp_touchpad_raw_xy *raw)
2449{
2450 int i;
2451
2452 for (i = 0; i < 2; i++)
2453 wtp_touch_event(hidpp, &(raw->fingers[i]));
2454
2455 if (raw->end_of_frame &&
2456 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
2457 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
2458
2459 if (raw->end_of_frame || raw->finger_count <= 2) {
2460 input_mt_sync_frame(hidpp->input);
2461 input_sync(hidpp->input);
2462 }
2463}
2464
2465static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
2466{
2467 struct wtp_data *wd = hidpp->private_data;
2468 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
2469 (data[7] >> 4) * (data[7] >> 4)) / 2;
2470 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
2471 (data[13] >> 4) * (data[13] >> 4)) / 2;
2472 struct hidpp_touchpad_raw_xy raw = {
2473 .timestamp = data[1],
2474 .fingers = {
2475 {
2476 .contact_type = 0,
2477 .contact_status = !!data[7],
2478 .x = get_unaligned_le16(&data[3]),
2479 .y = get_unaligned_le16(&data[5]),
2480 .z = c1_area,
2481 .area = c1_area,
2482 .finger_id = data[2],
2483 }, {
2484 .contact_type = 0,
2485 .contact_status = !!data[13],
2486 .x = get_unaligned_le16(&data[9]),
2487 .y = get_unaligned_le16(&data[11]),
2488 .z = c2_area,
2489 .area = c2_area,
2490 .finger_id = data[8],
2491 }
2492 },
2493 .finger_count = wd->maxcontacts,
2494 .spurious_flag = 0,
2495 .end_of_frame = (data[0] >> 7) == 0,
2496 .button = data[0] & 0x01,
2497 };
2498
2499 wtp_send_raw_xy_event(hidpp, &raw);
2500
2501 return 1;
2502}
2503
2504static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
2505{
2506 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2507 struct wtp_data *wd = hidpp->private_data;
2508 struct hidpp_report *report = (struct hidpp_report *)data;
2509 struct hidpp_touchpad_raw_xy raw;
2510
2511 if (!wd || !hidpp->input)
2512 return 1;
2513
2514 switch (data[0]) {
2515 case 0x02:
2516 if (size < 2) {
2517 hid_err(hdev, "Received HID report of bad size (%d)",
2518 size);
2519 return 1;
2520 }
2521 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
2522 input_event(hidpp->input, EV_KEY, BTN_LEFT,
2523 !!(data[1] & 0x01));
2524 input_event(hidpp->input, EV_KEY, BTN_RIGHT,
2525 !!(data[1] & 0x02));
2526 input_sync(hidpp->input);
2527 return 0;
2528 } else {
2529 if (size < 21)
2530 return 1;
2531 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
2532 }
2533 case REPORT_ID_HIDPP_LONG:
2534 /* size is already checked in hidpp_raw_event. */
2535 if ((report->fap.feature_index != wd->mt_feature_index) ||
2536 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
2537 return 1;
2538 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
2539
2540 wtp_send_raw_xy_event(hidpp, &raw);
2541 return 0;
2542 }
2543
2544 return 0;
2545}
2546
2547static int wtp_get_config(struct hidpp_device *hidpp)
2548{
2549 struct wtp_data *wd = hidpp->private_data;
2550 struct hidpp_touchpad_raw_info raw_info = {0};
2551 u8 feature_type;
2552 int ret;
2553
2554 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
2555 &wd->mt_feature_index, &feature_type);
2556 if (ret)
2557 /* means that the device is not powered up */
2558 return ret;
2559
2560 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
2561 &raw_info);
2562 if (ret)
2563 return ret;
2564
2565 wd->x_size = raw_info.x_size;
2566 wd->y_size = raw_info.y_size;
2567 wd->maxcontacts = raw_info.maxcontacts;
2568 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
2569 wd->resolution = raw_info.res;
2570 if (!wd->resolution)
2571 wd->resolution = WTP_MANUAL_RESOLUTION;
2572
2573 return 0;
2574}
2575
2576static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
2577{
2578 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2579 struct wtp_data *wd;
2580
2581 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
2582 GFP_KERNEL);
2583 if (!wd)
2584 return -ENOMEM;
2585
2586 hidpp->private_data = wd;
2587
2588 return 0;
2589};
2590
2591static int wtp_connect(struct hid_device *hdev, bool connected)
2592{
2593 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2594 struct wtp_data *wd = hidpp->private_data;
2595 int ret;
2596
2597 if (!wd->x_size) {
2598 ret = wtp_get_config(hidpp);
2599 if (ret) {
2600 hid_err(hdev, "Can not get wtp config: %d\n", ret);
2601 return ret;
2602 }
2603 }
2604
2605 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
2606 true, true);
2607}
2608
2609/* ------------------------------------------------------------------------- */
2610/* Logitech M560 devices */
2611/* ------------------------------------------------------------------------- */
2612
2613/*
2614 * Logitech M560 protocol overview
2615 *
2616 * The Logitech M560 mouse, is designed for windows 8. When the middle and/or
2617 * the sides buttons are pressed, it sends some keyboard keys events
2618 * instead of buttons ones.
2619 * To complicate things further, the middle button keys sequence
2620 * is different from the odd press and the even press.
2621 *
2622 * forward button -> Super_R
2623 * backward button -> Super_L+'d' (press only)
2624 * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only)
2625 * 2nd time: left-click (press only)
2626 * NB: press-only means that when the button is pressed, the
2627 * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated
2628 * together sequentially; instead when the button is released, no event is
2629 * generated !
2630 *
2631 * With the command
2632 * 10<xx>0a 3500af03 (where <xx> is the mouse id),
2633 * the mouse reacts differently:
2634 * - it never sends a keyboard key event
2635 * - for the three mouse button it sends:
2636 * middle button press 11<xx>0a 3500af00...
2637 * side 1 button (forward) press 11<xx>0a 3500b000...
2638 * side 2 button (backward) press 11<xx>0a 3500ae00...
2639 * middle/side1/side2 button release 11<xx>0a 35000000...
2640 */
2641
2642static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
2643
2644/* how buttons are mapped in the report */
2645#define M560_MOUSE_BTN_LEFT 0x01
2646#define M560_MOUSE_BTN_RIGHT 0x02
2647#define M560_MOUSE_BTN_WHEEL_LEFT 0x08
2648#define M560_MOUSE_BTN_WHEEL_RIGHT 0x10
2649
2650#define M560_SUB_ID 0x0a
2651#define M560_BUTTON_MODE_REGISTER 0x35
2652
2653static int m560_send_config_command(struct hid_device *hdev, bool connected)
2654{
2655 struct hidpp_report response;
2656 struct hidpp_device *hidpp_dev;
2657
2658 hidpp_dev = hid_get_drvdata(hdev);
2659
2660 return hidpp_send_rap_command_sync(
2661 hidpp_dev,
2662 REPORT_ID_HIDPP_SHORT,
2663 M560_SUB_ID,
2664 M560_BUTTON_MODE_REGISTER,
2665 (u8 *)m560_config_parameter,
2666 sizeof(m560_config_parameter),
2667 &response
2668 );
2669}
2670
2671static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
2672{
2673 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2674
2675 /* sanity check */
2676 if (!hidpp->input) {
2677 hid_err(hdev, "error in parameter\n");
2678 return -EINVAL;
2679 }
2680
2681 if (size < 7) {
2682 hid_err(hdev, "error in report\n");
2683 return 0;
2684 }
2685
2686 if (data[0] == REPORT_ID_HIDPP_LONG &&
2687 data[2] == M560_SUB_ID && data[6] == 0x00) {
2688 /*
2689 * m560 mouse report for middle, forward and backward button
2690 *
2691 * data[0] = 0x11
2692 * data[1] = device-id
2693 * data[2] = 0x0a
2694 * data[5] = 0xaf -> middle
2695 * 0xb0 -> forward
2696 * 0xae -> backward
2697 * 0x00 -> release all
2698 * data[6] = 0x00
2699 */
2700
2701 switch (data[5]) {
2702 case 0xaf:
2703 input_report_key(hidpp->input, BTN_MIDDLE, 1);
2704 break;
2705 case 0xb0:
2706 input_report_key(hidpp->input, BTN_FORWARD, 1);
2707 break;
2708 case 0xae:
2709 input_report_key(hidpp->input, BTN_BACK, 1);
2710 break;
2711 case 0x00:
2712 input_report_key(hidpp->input, BTN_BACK, 0);
2713 input_report_key(hidpp->input, BTN_FORWARD, 0);
2714 input_report_key(hidpp->input, BTN_MIDDLE, 0);
2715 break;
2716 default:
2717 hid_err(hdev, "error in report\n");
2718 return 0;
2719 }
2720 input_sync(hidpp->input);
2721
2722 } else if (data[0] == 0x02) {
2723 /*
2724 * Logitech M560 mouse report
2725 *
2726 * data[0] = type (0x02)
2727 * data[1..2] = buttons
2728 * data[3..5] = xy
2729 * data[6] = wheel
2730 */
2731
2732 int v;
2733
2734 input_report_key(hidpp->input, BTN_LEFT,
2735 !!(data[1] & M560_MOUSE_BTN_LEFT));
2736 input_report_key(hidpp->input, BTN_RIGHT,
2737 !!(data[1] & M560_MOUSE_BTN_RIGHT));
2738
2739 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
2740 input_report_rel(hidpp->input, REL_HWHEEL, -1);
2741 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
2742 -120);
2743 } else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
2744 input_report_rel(hidpp->input, REL_HWHEEL, 1);
2745 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
2746 120);
2747 }
2748
2749 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
2750 input_report_rel(hidpp->input, REL_X, v);
2751
2752 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
2753 input_report_rel(hidpp->input, REL_Y, v);
2754
2755 v = hid_snto32(data[6], 8);
2756 if (v != 0)
2757 hidpp_scroll_counter_handle_scroll(hidpp->input,
2758 &hidpp->vertical_wheel_counter, v);
2759
2760 input_sync(hidpp->input);
2761 }
2762
2763 return 1;
2764}
2765
2766static void m560_populate_input(struct hidpp_device *hidpp,
2767 struct input_dev *input_dev)
2768{
2769 __set_bit(EV_KEY, input_dev->evbit);
2770 __set_bit(BTN_MIDDLE, input_dev->keybit);
2771 __set_bit(BTN_RIGHT, input_dev->keybit);
2772 __set_bit(BTN_LEFT, input_dev->keybit);
2773 __set_bit(BTN_BACK, input_dev->keybit);
2774 __set_bit(BTN_FORWARD, input_dev->keybit);
2775
2776 __set_bit(EV_REL, input_dev->evbit);
2777 __set_bit(REL_X, input_dev->relbit);
2778 __set_bit(REL_Y, input_dev->relbit);
2779 __set_bit(REL_WHEEL, input_dev->relbit);
2780 __set_bit(REL_HWHEEL, input_dev->relbit);
2781 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
2782 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
2783}
2784
2785static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2786 struct hid_field *field, struct hid_usage *usage,
2787 unsigned long **bit, int *max)
2788{
2789 return -1;
2790}
2791
2792/* ------------------------------------------------------------------------- */
2793/* Logitech K400 devices */
2794/* ------------------------------------------------------------------------- */
2795
2796/*
2797 * The Logitech K400 keyboard has an embedded touchpad which is seen
2798 * as a mouse from the OS point of view. There is a hardware shortcut to disable
2799 * tap-to-click but the setting is not remembered accross reset, annoying some
2800 * users.
2801 *
2802 * We can toggle this feature from the host by using the feature 0x6010:
2803 * Touchpad FW items
2804 */
2805
2806struct k400_private_data {
2807 u8 feature_index;
2808};
2809
2810static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
2811{
2812 struct k400_private_data *k400 = hidpp->private_data;
2813 struct hidpp_touchpad_fw_items items = {};
2814 int ret;
2815 u8 feature_type;
2816
2817 if (!k400->feature_index) {
2818 ret = hidpp_root_get_feature(hidpp,
2819 HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
2820 &k400->feature_index, &feature_type);
2821 if (ret)
2822 /* means that the device is not powered up */
2823 return ret;
2824 }
2825
2826 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
2827 if (ret)
2828 return ret;
2829
2830 return 0;
2831}
2832
2833static int k400_allocate(struct hid_device *hdev)
2834{
2835 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2836 struct k400_private_data *k400;
2837
2838 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
2839 GFP_KERNEL);
2840 if (!k400)
2841 return -ENOMEM;
2842
2843 hidpp->private_data = k400;
2844
2845 return 0;
2846};
2847
2848static int k400_connect(struct hid_device *hdev, bool connected)
2849{
2850 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2851
2852 if (!disable_tap_to_click)
2853 return 0;
2854
2855 return k400_disable_tap_to_click(hidpp);
2856}
2857
2858/* ------------------------------------------------------------------------- */
2859/* Logitech G920 Driving Force Racing Wheel for Xbox One */
2860/* ------------------------------------------------------------------------- */
2861
2862#define HIDPP_PAGE_G920_FORCE_FEEDBACK 0x8123
2863
2864static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
2865 struct hidpp_ff_private_data *data)
2866{
2867 struct hidpp_report response;
2868 u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH] = {
2869 [1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART,
2870 };
2871 int ret;
2872
2873 /* initialize with zero autocenter to get wheel in usable state */
2874
2875 dbg_hid("Setting autocenter to 0.\n");
2876 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2877 HIDPP_FF_DOWNLOAD_EFFECT,
2878 params, ARRAY_SIZE(params),
2879 &response);
2880 if (ret)
2881 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
2882 else
2883 data->slot_autocenter = response.fap.params[0];
2884
2885 return ret;
2886}
2887
2888static int g920_get_config(struct hidpp_device *hidpp,
2889 struct hidpp_ff_private_data *data)
2890{
2891 struct hidpp_report response;
2892 u8 feature_type;
2893 int ret;
2894
2895 memset(data, 0, sizeof(*data));
2896
2897 /* Find feature and store for later use */
2898 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
2899 &data->feature_index, &feature_type);
2900 if (ret)
2901 return ret;
2902
2903 /* Read number of slots available in device */
2904 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2905 HIDPP_FF_GET_INFO,
2906 NULL, 0,
2907 &response);
2908 if (ret) {
2909 if (ret < 0)
2910 return ret;
2911 hid_err(hidpp->hid_dev,
2912 "%s: received protocol error 0x%02x\n", __func__, ret);
2913 return -EPROTO;
2914 }
2915
2916 data->num_effects = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
2917
2918 /* reset all forces */
2919 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2920 HIDPP_FF_RESET_ALL,
2921 NULL, 0,
2922 &response);
2923 if (ret)
2924 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
2925
2926 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2927 HIDPP_FF_GET_APERTURE,
2928 NULL, 0,
2929 &response);
2930 if (ret) {
2931 hid_warn(hidpp->hid_dev,
2932 "Failed to read range from device!\n");
2933 }
2934 data->range = ret ?
2935 900 : get_unaligned_be16(&response.fap.params[0]);
2936
2937 /* Read the current gain values */
2938 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2939 HIDPP_FF_GET_GLOBAL_GAINS,
2940 NULL, 0,
2941 &response);
2942 if (ret)
2943 hid_warn(hidpp->hid_dev,
2944 "Failed to read gain values from device!\n");
2945 data->gain = ret ?
2946 0xffff : get_unaligned_be16(&response.fap.params[0]);
2947
2948 /* ignore boost value at response.fap.params[2] */
2949
2950 return g920_ff_set_autocenter(hidpp, data);
2951}
2952
2953/* -------------------------------------------------------------------------- */
2954/* HID++1.0 devices which use HID++ reports for their wheels */
2955/* -------------------------------------------------------------------------- */
2956static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
2957{
2958 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
2959 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT,
2960 HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT);
2961}
2962
2963static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
2964 u8 *data, int size)
2965{
2966 s8 value, hvalue;
2967
2968 if (!hidpp->input)
2969 return -EINVAL;
2970
2971 if (size < 7)
2972 return 0;
2973
2974 if (data[0] != REPORT_ID_HIDPP_SHORT || data[2] != HIDPP_SUB_ID_ROLLER)
2975 return 0;
2976
2977 value = data[3];
2978 hvalue = data[4];
2979
2980 input_report_rel(hidpp->input, REL_WHEEL, value);
2981 input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
2982 input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
2983 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
2984 input_sync(hidpp->input);
2985
2986 return 1;
2987}
2988
2989static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
2990 struct input_dev *input_dev)
2991{
2992 __set_bit(EV_REL, input_dev->evbit);
2993 __set_bit(REL_WHEEL, input_dev->relbit);
2994 __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
2995 __set_bit(REL_HWHEEL, input_dev->relbit);
2996 __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
2997}
2998
2999/* -------------------------------------------------------------------------- */
3000/* HID++1.0 mice which use HID++ reports for extra mouse buttons */
3001/* -------------------------------------------------------------------------- */
3002static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3003{
3004 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3005 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
3006 HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
3007}
3008
3009static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3010 u8 *data, int size)
3011{
3012 int i;
3013
3014 if (!hidpp->input)
3015 return -EINVAL;
3016
3017 if (size < 7)
3018 return 0;
3019
3020 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3021 data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
3022 return 0;
3023
3024 /*
3025 * Buttons are either delivered through the regular mouse report *or*
3026 * through the extra buttons report. At least for button 6 how it is
3027 * delivered differs per receiver firmware version. Even receivers with
3028 * the same usb-id show different behavior, so we handle both cases.
3029 */
3030 for (i = 0; i < 8; i++)
3031 input_report_key(hidpp->input, BTN_MOUSE + i,
3032 (data[3] & (1 << i)));
3033
3034 /* Some mice report events on button 9+, use BTN_MISC */
3035 for (i = 0; i < 8; i++)
3036 input_report_key(hidpp->input, BTN_MISC + i,
3037 (data[4] & (1 << i)));
3038
3039 input_sync(hidpp->input);
3040 return 1;
3041}
3042
3043static void hidpp10_extra_mouse_buttons_populate_input(
3044 struct hidpp_device *hidpp, struct input_dev *input_dev)
3045{
3046 /* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
3047 __set_bit(BTN_0, input_dev->keybit);
3048 __set_bit(BTN_1, input_dev->keybit);
3049 __set_bit(BTN_2, input_dev->keybit);
3050 __set_bit(BTN_3, input_dev->keybit);
3051 __set_bit(BTN_4, input_dev->keybit);
3052 __set_bit(BTN_5, input_dev->keybit);
3053 __set_bit(BTN_6, input_dev->keybit);
3054 __set_bit(BTN_7, input_dev->keybit);
3055}
3056
3057/* -------------------------------------------------------------------------- */
3058/* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
3059/* -------------------------------------------------------------------------- */
3060
3061/* Find the consumer-page input report desc and change Maximums to 0x107f */
3062static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3063 u8 *_rdesc, unsigned int *rsize)
3064{
3065 /* Note 0 terminated so we can use strnstr to search for this. */
3066 static const char consumer_rdesc_start[] = {
3067 0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
3068 0x09, 0x01, /* USAGE (Consumer Control) */
3069 0xA1, 0x01, /* COLLECTION (Application) */
3070 0x85, 0x03, /* REPORT_ID = 3 */
3071 0x75, 0x10, /* REPORT_SIZE (16) */
3072 0x95, 0x02, /* REPORT_COUNT (2) */
3073 0x15, 0x01, /* LOGICAL_MIN (1) */
3074 0x26, 0x00 /* LOGICAL_MAX (... */
3075 };
3076 char *consumer_rdesc, *rdesc = (char *)_rdesc;
3077 unsigned int size;
3078
3079 consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
3080 size = *rsize - (consumer_rdesc - rdesc);
3081 if (consumer_rdesc && size >= 25) {
3082 consumer_rdesc[15] = 0x7f;
3083 consumer_rdesc[16] = 0x10;
3084 consumer_rdesc[20] = 0x7f;
3085 consumer_rdesc[21] = 0x10;
3086 }
3087 return _rdesc;
3088}
3089
3090static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3091{
3092 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3093 HIDPP_ENABLE_CONSUMER_REPORT,
3094 HIDPP_ENABLE_CONSUMER_REPORT);
3095}
3096
3097static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3098 u8 *data, int size)
3099{
3100 u8 consumer_report[5];
3101
3102 if (size < 7)
3103 return 0;
3104
3105 if (data[0] != REPORT_ID_HIDPP_SHORT ||
3106 data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
3107 return 0;
3108
3109 /*
3110 * Build a normal consumer report (3) out of the data, this detour
3111 * is necessary to get some keyboards to report their 0x10xx usages.
3112 */
3113 consumer_report[0] = 0x03;
3114 memcpy(&consumer_report[1], &data[3], 4);
3115 /* We are called from atomic context */
3116 hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3117 consumer_report, 5, 1);
3118
3119 return 1;
3120}
3121
3122/* -------------------------------------------------------------------------- */
3123/* High-resolution scroll wheels */
3124/* -------------------------------------------------------------------------- */
3125
3126static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3127{
3128 int ret;
3129 u8 multiplier = 1;
3130
3131 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2121) {
3132 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3133 if (ret == 0)
3134 ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3135 } else if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2120) {
3136 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3137 &multiplier);
3138 } else /* if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) */ {
3139 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3140 multiplier = 8;
3141 }
3142 if (ret)
3143 return ret;
3144
3145 if (multiplier == 0)
3146 multiplier = 1;
3147
3148 hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3149 hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3150 return 0;
3151}
3152
3153/* -------------------------------------------------------------------------- */
3154/* Generic HID++ devices */
3155/* -------------------------------------------------------------------------- */
3156
3157static u8 *hidpp_report_fixup(struct hid_device *hdev, u8 *rdesc,
3158 unsigned int *rsize)
3159{
3160 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3161
3162 if (!hidpp)
3163 return rdesc;
3164
3165 /* For 27 MHz keyboards the quirk gets set after hid_parse. */
3166 if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE ||
3167 (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3168 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3169
3170 return rdesc;
3171}
3172
3173static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3174 struct hid_field *field, struct hid_usage *usage,
3175 unsigned long **bit, int *max)
3176{
3177 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3178
3179 if (!hidpp)
3180 return 0;
3181
3182 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3183 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
3184 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3185 field->application != HID_GD_MOUSE)
3186 return m560_input_mapping(hdev, hi, field, usage, bit, max);
3187
3188 return 0;
3189}
3190
3191static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
3192 struct hid_field *field, struct hid_usage *usage,
3193 unsigned long **bit, int *max)
3194{
3195 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3196
3197 if (!hidpp)
3198 return 0;
3199
3200 /* Ensure that Logitech G920 is not given a default fuzz/flat value */
3201 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3202 if (usage->type == EV_ABS && (usage->code == ABS_X ||
3203 usage->code == ABS_Y || usage->code == ABS_Z ||
3204 usage->code == ABS_RZ)) {
3205 field->application = HID_GD_MULTIAXIS;
3206 }
3207 }
3208
3209 return 0;
3210}
3211
3212
3213static void hidpp_populate_input(struct hidpp_device *hidpp,
3214 struct input_dev *input)
3215{
3216 hidpp->input = input;
3217
3218 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3219 wtp_populate_input(hidpp, input);
3220 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3221 m560_populate_input(hidpp, input);
3222
3223 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3224 hidpp10_wheel_populate_input(hidpp, input);
3225
3226 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3227 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3228}
3229
3230static int hidpp_input_configured(struct hid_device *hdev,
3231 struct hid_input *hidinput)
3232{
3233 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3234 struct input_dev *input = hidinput->input;
3235
3236 if (!hidpp)
3237 return 0;
3238
3239 hidpp_populate_input(hidpp, input);
3240
3241 return 0;
3242}
3243
3244static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3245 int size)
3246{
3247 struct hidpp_report *question = hidpp->send_receive_buf;
3248 struct hidpp_report *answer = hidpp->send_receive_buf;
3249 struct hidpp_report *report = (struct hidpp_report *)data;
3250 int ret;
3251
3252 /*
3253 * If the mutex is locked then we have a pending answer from a
3254 * previously sent command.
3255 */
3256 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3257 /*
3258 * Check for a correct hidpp20 answer or the corresponding
3259 * error
3260 */
3261 if (hidpp_match_answer(question, report) ||
3262 hidpp_match_error(question, report)) {
3263 *answer = *report;
3264 hidpp->answer_available = true;
3265 wake_up(&hidpp->wait);
3266 /*
3267 * This was an answer to a command that this driver sent
3268 * We return 1 to hid-core to avoid forwarding the
3269 * command upstream as it has been treated by the driver
3270 */
3271
3272 return 1;
3273 }
3274 }
3275
3276 if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3277 atomic_set(&hidpp->connected,
3278 !(report->rap.params[0] & (1 << 6)));
3279 if (schedule_work(&hidpp->work) == 0)
3280 dbg_hid("%s: connect event already queued\n", __func__);
3281 return 1;
3282 }
3283
3284 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3285 ret = hidpp20_battery_event(hidpp, data, size);
3286 if (ret != 0)
3287 return ret;
3288 ret = hidpp_solar_battery_event(hidpp, data, size);
3289 if (ret != 0)
3290 return ret;
3291 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3292 if (ret != 0)
3293 return ret;
3294 }
3295
3296 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3297 ret = hidpp10_battery_event(hidpp, data, size);
3298 if (ret != 0)
3299 return ret;
3300 }
3301
3302 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3303 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3304 if (ret != 0)
3305 return ret;
3306 }
3307
3308 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3309 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3310 if (ret != 0)
3311 return ret;
3312 }
3313
3314 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3315 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3316 if (ret != 0)
3317 return ret;
3318 }
3319
3320 return 0;
3321}
3322
3323static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
3324 u8 *data, int size)
3325{
3326 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3327 int ret = 0;
3328
3329 if (!hidpp)
3330 return 0;
3331
3332 /* Generic HID++ processing. */
3333 switch (data[0]) {
3334 case REPORT_ID_HIDPP_VERY_LONG:
3335 if (size != hidpp->very_long_report_length) {
3336 hid_err(hdev, "received hid++ report of bad size (%d)",
3337 size);
3338 return 1;
3339 }
3340 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3341 break;
3342 case REPORT_ID_HIDPP_LONG:
3343 if (size != HIDPP_REPORT_LONG_LENGTH) {
3344 hid_err(hdev, "received hid++ report of bad size (%d)",
3345 size);
3346 return 1;
3347 }
3348 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3349 break;
3350 case REPORT_ID_HIDPP_SHORT:
3351 if (size != HIDPP_REPORT_SHORT_LENGTH) {
3352 hid_err(hdev, "received hid++ report of bad size (%d)",
3353 size);
3354 return 1;
3355 }
3356 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3357 break;
3358 }
3359
3360 /* If no report is available for further processing, skip calling
3361 * raw_event of subclasses. */
3362 if (ret != 0)
3363 return ret;
3364
3365 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3366 return wtp_raw_event(hdev, data, size);
3367 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3368 return m560_raw_event(hdev, data, size);
3369
3370 return 0;
3371}
3372
3373static int hidpp_event(struct hid_device *hdev, struct hid_field *field,
3374 struct hid_usage *usage, __s32 value)
3375{
3376 /* This function will only be called for scroll events, due to the
3377 * restriction imposed in hidpp_usages.
3378 */
3379 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3380 struct hidpp_scroll_counter *counter;
3381
3382 if (!hidpp)
3383 return 0;
3384
3385 counter = &hidpp->vertical_wheel_counter;
3386 /* A scroll event may occur before the multiplier has been retrieved or
3387 * the input device set, or high-res scroll enabling may fail. In such
3388 * cases we must return early (falling back to default behaviour) to
3389 * avoid a crash in hidpp_scroll_counter_handle_scroll.
3390 */
3391 if (!(hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL) || value == 0
3392 || hidpp->input == NULL || counter->wheel_multiplier == 0)
3393 return 0;
3394
3395 hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
3396 return 1;
3397}
3398
3399static int hidpp_initialize_battery(struct hidpp_device *hidpp)
3400{
3401 static atomic_t battery_no = ATOMIC_INIT(0);
3402 struct power_supply_config cfg = { .drv_data = hidpp };
3403 struct power_supply_desc *desc = &hidpp->battery.desc;
3404 enum power_supply_property *battery_props;
3405 struct hidpp_battery *battery;
3406 unsigned int num_battery_props;
3407 unsigned long n;
3408 int ret;
3409
3410 if (hidpp->battery.ps)
3411 return 0;
3412
3413 hidpp->battery.feature_index = 0xff;
3414 hidpp->battery.solar_feature_index = 0xff;
3415 hidpp->battery.voltage_feature_index = 0xff;
3416
3417 if (hidpp->protocol_major >= 2) {
3418 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
3419 ret = hidpp_solar_request_battery_event(hidpp);
3420 else {
3421 ret = hidpp20_query_battery_voltage_info(hidpp);
3422 if (ret)
3423 ret = hidpp20_query_battery_info(hidpp);
3424 }
3425
3426 if (ret)
3427 return ret;
3428 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
3429 } else {
3430 ret = hidpp10_query_battery_status(hidpp);
3431 if (ret) {
3432 ret = hidpp10_query_battery_mileage(hidpp);
3433 if (ret)
3434 return -ENOENT;
3435 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
3436 } else {
3437 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
3438 }
3439 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
3440 }
3441
3442 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
3443 hidpp_battery_props,
3444 sizeof(hidpp_battery_props),
3445 GFP_KERNEL);
3446 if (!battery_props)
3447 return -ENOMEM;
3448
3449 num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 3;
3450
3451 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
3452 battery_props[num_battery_props++] =
3453 POWER_SUPPLY_PROP_CAPACITY;
3454
3455 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
3456 battery_props[num_battery_props++] =
3457 POWER_SUPPLY_PROP_CAPACITY_LEVEL;
3458
3459 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3460 battery_props[num_battery_props++] =
3461 POWER_SUPPLY_PROP_VOLTAGE_NOW;
3462
3463 battery = &hidpp->battery;
3464
3465 n = atomic_inc_return(&battery_no) - 1;
3466 desc->properties = battery_props;
3467 desc->num_properties = num_battery_props;
3468 desc->get_property = hidpp_battery_get_property;
3469 sprintf(battery->name, "hidpp_battery_%ld", n);
3470 desc->name = battery->name;
3471 desc->type = POWER_SUPPLY_TYPE_BATTERY;
3472 desc->use_for_apm = 0;
3473
3474 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
3475 &battery->desc,
3476 &cfg);
3477 if (IS_ERR(battery->ps))
3478 return PTR_ERR(battery->ps);
3479
3480 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
3481
3482 return ret;
3483}
3484
3485static void hidpp_overwrite_name(struct hid_device *hdev)
3486{
3487 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3488 char *name;
3489
3490 if (hidpp->protocol_major < 2)
3491 return;
3492
3493 name = hidpp_get_device_name(hidpp);
3494
3495 if (!name) {
3496 hid_err(hdev, "unable to retrieve the name of the device");
3497 } else {
3498 dbg_hid("HID++: Got name: %s\n", name);
3499 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
3500 }
3501
3502 kfree(name);
3503}
3504
3505static int hidpp_input_open(struct input_dev *dev)
3506{
3507 struct hid_device *hid = input_get_drvdata(dev);
3508
3509 return hid_hw_open(hid);
3510}
3511
3512static void hidpp_input_close(struct input_dev *dev)
3513{
3514 struct hid_device *hid = input_get_drvdata(dev);
3515
3516 hid_hw_close(hid);
3517}
3518
3519static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
3520{
3521 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
3522 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3523
3524 if (!input_dev)
3525 return NULL;
3526
3527 input_set_drvdata(input_dev, hdev);
3528 input_dev->open = hidpp_input_open;
3529 input_dev->close = hidpp_input_close;
3530
3531 input_dev->name = hidpp->name;
3532 input_dev->phys = hdev->phys;
3533 input_dev->uniq = hdev->uniq;
3534 input_dev->id.bustype = hdev->bus;
3535 input_dev->id.vendor = hdev->vendor;
3536 input_dev->id.product = hdev->product;
3537 input_dev->id.version = hdev->version;
3538 input_dev->dev.parent = &hdev->dev;
3539
3540 return input_dev;
3541}
3542
3543static void hidpp_connect_event(struct hidpp_device *hidpp)
3544{
3545 struct hid_device *hdev = hidpp->hid_dev;
3546 int ret = 0;
3547 bool connected = atomic_read(&hidpp->connected);
3548 struct input_dev *input;
3549 char *name, *devm_name;
3550
3551 if (!connected) {
3552 if (hidpp->battery.ps) {
3553 hidpp->battery.online = false;
3554 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
3555 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
3556 power_supply_changed(hidpp->battery.ps);
3557 }
3558 return;
3559 }
3560
3561 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
3562 ret = wtp_connect(hdev, connected);
3563 if (ret)
3564 return;
3565 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
3566 ret = m560_send_config_command(hdev, connected);
3567 if (ret)
3568 return;
3569 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
3570 ret = k400_connect(hdev, connected);
3571 if (ret)
3572 return;
3573 }
3574
3575 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3576 ret = hidpp10_wheel_connect(hidpp);
3577 if (ret)
3578 return;
3579 }
3580
3581 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3582 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
3583 if (ret)
3584 return;
3585 }
3586
3587 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3588 ret = hidpp10_consumer_keys_connect(hidpp);
3589 if (ret)
3590 return;
3591 }
3592
3593 /* the device is already connected, we can ask for its name and
3594 * protocol */
3595 if (!hidpp->protocol_major) {
3596 ret = hidpp_root_get_protocol_version(hidpp);
3597 if (ret) {
3598 hid_err(hdev, "Can not get the protocol version.\n");
3599 return;
3600 }
3601 }
3602
3603 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
3604 name = hidpp_get_device_name(hidpp);
3605 if (name) {
3606 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
3607 "%s", name);
3608 kfree(name);
3609 if (!devm_name)
3610 return;
3611
3612 hidpp->name = devm_name;
3613 }
3614 }
3615
3616 hidpp_initialize_battery(hidpp);
3617
3618 /* forward current battery state */
3619 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3620 hidpp10_enable_battery_reporting(hidpp);
3621 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
3622 hidpp10_query_battery_mileage(hidpp);
3623 else
3624 hidpp10_query_battery_status(hidpp);
3625 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3626 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3627 hidpp20_query_battery_voltage_info(hidpp);
3628 else
3629 hidpp20_query_battery_info(hidpp);
3630 }
3631 if (hidpp->battery.ps)
3632 power_supply_changed(hidpp->battery.ps);
3633
3634 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL)
3635 hi_res_scroll_enable(hidpp);
3636
3637 if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT) || hidpp->delayed_input)
3638 /* if the input nodes are already created, we can stop now */
3639 return;
3640
3641 input = hidpp_allocate_input(hdev);
3642 if (!input) {
3643 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
3644 return;
3645 }
3646
3647 hidpp_populate_input(hidpp, input);
3648
3649 ret = input_register_device(input);
3650 if (ret)
3651 input_free_device(input);
3652
3653 hidpp->delayed_input = input;
3654}
3655
3656static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
3657
3658static struct attribute *sysfs_attrs[] = {
3659 &dev_attr_builtin_power_supply.attr,
3660 NULL
3661};
3662
3663static const struct attribute_group ps_attribute_group = {
3664 .attrs = sysfs_attrs
3665};
3666
3667static int hidpp_get_report_length(struct hid_device *hdev, int id)
3668{
3669 struct hid_report_enum *re;
3670 struct hid_report *report;
3671
3672 re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
3673 report = re->report_id_hash[id];
3674 if (!report)
3675 return 0;
3676
3677 return report->field[0]->report_count + 1;
3678}
3679
3680static u8 hidpp_validate_device(struct hid_device *hdev)
3681{
3682 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3683 int id, report_length;
3684 u8 supported_reports = 0;
3685
3686 id = REPORT_ID_HIDPP_SHORT;
3687 report_length = hidpp_get_report_length(hdev, id);
3688 if (report_length) {
3689 if (report_length < HIDPP_REPORT_SHORT_LENGTH)
3690 goto bad_device;
3691
3692 supported_reports |= HIDPP_REPORT_SHORT_SUPPORTED;
3693 }
3694
3695 id = REPORT_ID_HIDPP_LONG;
3696 report_length = hidpp_get_report_length(hdev, id);
3697 if (report_length) {
3698 if (report_length < HIDPP_REPORT_LONG_LENGTH)
3699 goto bad_device;
3700
3701 supported_reports |= HIDPP_REPORT_LONG_SUPPORTED;
3702 }
3703
3704 id = REPORT_ID_HIDPP_VERY_LONG;
3705 report_length = hidpp_get_report_length(hdev, id);
3706 if (report_length) {
3707 if (report_length < HIDPP_REPORT_LONG_LENGTH ||
3708 report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
3709 goto bad_device;
3710
3711 supported_reports |= HIDPP_REPORT_VERY_LONG_SUPPORTED;
3712 hidpp->very_long_report_length = report_length;
3713 }
3714
3715 return supported_reports;
3716
3717bad_device:
3718 hid_warn(hdev, "not enough values in hidpp report %d\n", id);
3719 return false;
3720}
3721
3722static bool hidpp_application_equals(struct hid_device *hdev,
3723 unsigned int application)
3724{
3725 struct list_head *report_list;
3726 struct hid_report *report;
3727
3728 report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
3729 report = list_first_entry_or_null(report_list, struct hid_report, list);
3730 return report && report->application == application;
3731}
3732
3733static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
3734{
3735 struct hidpp_device *hidpp;
3736 int ret;
3737 bool connected;
3738 unsigned int connect_mask = HID_CONNECT_DEFAULT;
3739 struct hidpp_ff_private_data data;
3740
3741 /* report_fixup needs drvdata to be set before we call hid_parse */
3742 hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
3743 if (!hidpp)
3744 return -ENOMEM;
3745
3746 hidpp->hid_dev = hdev;
3747 hidpp->name = hdev->name;
3748 hidpp->quirks = id->driver_data;
3749 hid_set_drvdata(hdev, hidpp);
3750
3751 ret = hid_parse(hdev);
3752 if (ret) {
3753 hid_err(hdev, "%s:parse failed\n", __func__);
3754 return ret;
3755 }
3756
3757 /*
3758 * Make sure the device is HID++ capable, otherwise treat as generic HID
3759 */
3760 hidpp->supported_reports = hidpp_validate_device(hdev);
3761
3762 if (!hidpp->supported_reports) {
3763 hid_set_drvdata(hdev, NULL);
3764 devm_kfree(&hdev->dev, hidpp);
3765 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
3766 }
3767
3768 if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
3769 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
3770
3771 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3772 hidpp_application_equals(hdev, HID_GD_MOUSE))
3773 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
3774 HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
3775
3776 if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3777 hidpp_application_equals(hdev, HID_GD_KEYBOARD))
3778 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
3779
3780 if (disable_raw_mode) {
3781 hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
3782 hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT;
3783 }
3784
3785 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
3786 ret = wtp_allocate(hdev, id);
3787 if (ret)
3788 return ret;
3789 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
3790 ret = k400_allocate(hdev);
3791 if (ret)
3792 return ret;
3793 }
3794
3795 INIT_WORK(&hidpp->work, delayed_work_cb);
3796 mutex_init(&hidpp->send_mutex);
3797 init_waitqueue_head(&hidpp->wait);
3798
3799 /* indicates we are handling the battery properties in the kernel */
3800 ret = sysfs_create_group(&hdev->dev.kobj, &ps_attribute_group);
3801 if (ret)
3802 hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
3803 hdev->name);
3804
3805 /*
3806 * Plain USB connections need to actually call start and open
3807 * on the transport driver to allow incoming data.
3808 */
3809 ret = hid_hw_start(hdev, 0);
3810 if (ret) {
3811 hid_err(hdev, "hw start failed\n");
3812 goto hid_hw_start_fail;
3813 }
3814
3815 ret = hid_hw_open(hdev);
3816 if (ret < 0) {
3817 dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
3818 __func__, ret);
3819 goto hid_hw_open_fail;
3820 }
3821
3822 /* Allow incoming packets */
3823 hid_device_io_start(hdev);
3824
3825 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
3826 hidpp_unifying_init(hidpp);
3827
3828 connected = hidpp_root_get_protocol_version(hidpp) == 0;
3829 atomic_set(&hidpp->connected, connected);
3830 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
3831 if (!connected) {
3832 ret = -ENODEV;
3833 hid_err(hdev, "Device not connected");
3834 goto hid_hw_init_fail;
3835 }
3836
3837 hidpp_overwrite_name(hdev);
3838 }
3839
3840 if (connected && hidpp->protocol_major >= 2) {
3841 ret = hidpp_set_wireless_feature_index(hidpp);
3842 if (ret == -ENOENT)
3843 hidpp->wireless_feature_index = 0;
3844 else if (ret)
3845 goto hid_hw_init_fail;
3846 }
3847
3848 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
3849 ret = wtp_get_config(hidpp);
3850 if (ret)
3851 goto hid_hw_init_fail;
3852 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3853 ret = g920_get_config(hidpp, &data);
3854 if (ret)
3855 goto hid_hw_init_fail;
3856 }
3857
3858 hidpp_connect_event(hidpp);
3859
3860 /* Reset the HID node state */
3861 hid_device_io_stop(hdev);
3862 hid_hw_close(hdev);
3863 hid_hw_stop(hdev);
3864
3865 if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
3866 connect_mask &= ~HID_CONNECT_HIDINPUT;
3867
3868 /* Now export the actual inputs and hidraw nodes to the world */
3869 ret = hid_hw_start(hdev, connect_mask);
3870 if (ret) {
3871 hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
3872 goto hid_hw_start_fail;
3873 }
3874
3875 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3876 ret = hidpp_ff_init(hidpp, &data);
3877 if (ret)
3878 hid_warn(hidpp->hid_dev,
3879 "Unable to initialize force feedback support, errno %d\n",
3880 ret);
3881 }
3882
3883 return ret;
3884
3885hid_hw_init_fail:
3886 hid_hw_close(hdev);
3887hid_hw_open_fail:
3888 hid_hw_stop(hdev);
3889hid_hw_start_fail:
3890 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3891 cancel_work_sync(&hidpp->work);
3892 mutex_destroy(&hidpp->send_mutex);
3893 return ret;
3894}
3895
3896static void hidpp_remove(struct hid_device *hdev)
3897{
3898 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3899
3900 if (!hidpp)
3901 return hid_hw_stop(hdev);
3902
3903 sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
3904
3905 hid_hw_stop(hdev);
3906 cancel_work_sync(&hidpp->work);
3907 mutex_destroy(&hidpp->send_mutex);
3908}
3909
3910#define LDJ_DEVICE(product) \
3911 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
3912 USB_VENDOR_ID_LOGITECH, (product))
3913
3914#define L27MHZ_DEVICE(product) \
3915 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
3916 USB_VENDOR_ID_LOGITECH, (product))
3917
3918static const struct hid_device_id hidpp_devices[] = {
3919 { /* wireless touchpad */
3920 LDJ_DEVICE(0x4011),
3921 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
3922 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
3923 { /* wireless touchpad T650 */
3924 LDJ_DEVICE(0x4101),
3925 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
3926 { /* wireless touchpad T651 */
3927 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
3928 USB_DEVICE_ID_LOGITECH_T651),
3929 .driver_data = HIDPP_QUIRK_CLASS_WTP },
3930 { /* Mouse Logitech Anywhere MX */
3931 LDJ_DEVICE(0x1017), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
3932 { /* Mouse Logitech Cube */
3933 LDJ_DEVICE(0x4010), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
3934 { /* Mouse Logitech M335 */
3935 LDJ_DEVICE(0x4050), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3936 { /* Mouse Logitech M515 */
3937 LDJ_DEVICE(0x4007), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
3938 { /* Mouse logitech M560 */
3939 LDJ_DEVICE(0x402d),
3940 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560
3941 | HIDPP_QUIRK_HI_RES_SCROLL_X2120 },
3942 { /* Mouse Logitech M705 (firmware RQM17) */
3943 LDJ_DEVICE(0x101b), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
3944 { /* Mouse Logitech M705 (firmware RQM67) */
3945 LDJ_DEVICE(0x406d), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3946 { /* Mouse Logitech M720 */
3947 LDJ_DEVICE(0x405e), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3948 { /* Mouse Logitech MX Anywhere 2 */
3949 LDJ_DEVICE(0x404a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3950 { LDJ_DEVICE(0xb013), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3951 { LDJ_DEVICE(0xb018), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3952 { LDJ_DEVICE(0xb01f), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3953 { /* Mouse Logitech MX Anywhere 2S */
3954 LDJ_DEVICE(0x406a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3955 { /* Mouse Logitech MX Master */
3956 LDJ_DEVICE(0x4041), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3957 { LDJ_DEVICE(0x4060), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3958 { LDJ_DEVICE(0x4071), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3959 { /* Mouse Logitech MX Master 2S */
3960 LDJ_DEVICE(0x4069), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3961 { /* Mouse Logitech MX Master 3 */
3962 LDJ_DEVICE(0x4082), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
3963 { /* Mouse Logitech Performance MX */
3964 LDJ_DEVICE(0x101a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
3965 { /* Keyboard logitech K400 */
3966 LDJ_DEVICE(0x4024),
3967 .driver_data = HIDPP_QUIRK_CLASS_K400 },
3968 { /* Solar Keyboard Logitech K750 */
3969 LDJ_DEVICE(0x4002),
3970 .driver_data = HIDPP_QUIRK_CLASS_K750 },
3971 { /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
3972 LDJ_DEVICE(0xb305),
3973 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
3974 { /* Keyboard MX5500 (Bluetooth-receiver in HID proxy mode) */
3975 LDJ_DEVICE(0xb30b),
3976 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
3977
3978 { LDJ_DEVICE(HID_ANY_ID) },
3979
3980 { /* Keyboard LX501 (Y-RR53) */
3981 L27MHZ_DEVICE(0x0049),
3982 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
3983 { /* Keyboard MX3000 (Y-RAM74) */
3984 L27MHZ_DEVICE(0x0057),
3985 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
3986 { /* Keyboard MX3200 (Y-RAV80) */
3987 L27MHZ_DEVICE(0x005c),
3988 .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
3989 { /* S510 Media Remote */
3990 L27MHZ_DEVICE(0x00fe),
3991 .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
3992
3993 { L27MHZ_DEVICE(HID_ANY_ID) },
3994
3995 { /* Logitech G403 Wireless Gaming Mouse over USB */
3996 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
3997 { /* Logitech G703 Gaming Mouse over USB */
3998 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC087) },
3999 { /* Logitech G703 Hero Gaming Mouse over USB */
4000 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC090) },
4001 { /* Logitech G900 Gaming Mouse over USB */
4002 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
4003 { /* Logitech G903 Gaming Mouse over USB */
4004 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC086) },
4005 { /* Logitech G903 Hero Gaming Mouse over USB */
4006 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC091) },
4007 { /* Logitech G920 Wheel over USB */
4008 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
4009 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
4010 { /* Logitech G Pro Gaming Mouse over USB */
4011 HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC088) },
4012
4013 { /* MX5000 keyboard over Bluetooth */
4014 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
4015 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4016 { /* MX5500 keyboard over Bluetooth */
4017 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
4018 .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4019 { /* MX Master mouse over Bluetooth */
4020 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012),
4021 .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
4022 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e),
4023 .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
4024 { /* MX Master 3 mouse over Bluetooth */
4025 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023),
4026 .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_X2121 },
4027 {}
4028};
4029
4030MODULE_DEVICE_TABLE(hid, hidpp_devices);
4031
4032static const struct hid_usage_id hidpp_usages[] = {
4033 { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
4034 { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
4035};
4036
4037static struct hid_driver hidpp_driver = {
4038 .name = "logitech-hidpp-device",
4039 .id_table = hidpp_devices,
4040 .report_fixup = hidpp_report_fixup,
4041 .probe = hidpp_probe,
4042 .remove = hidpp_remove,
4043 .raw_event = hidpp_raw_event,
4044 .usage_table = hidpp_usages,
4045 .event = hidpp_event,
4046 .input_configured = hidpp_input_configured,
4047 .input_mapping = hidpp_input_mapping,
4048 .input_mapped = hidpp_input_mapped,
4049};
4050
4051module_hid_driver(hidpp_driver);