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