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