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