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