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