drivers/hid/hid-logitech-hidpp.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  HIDPP protocol for Logitech receivers
   4  *
   5  *  Copyright (c) 2011 Logitech (c)
   6  *  Copyright (c) 2012-2013 Google (c)
   7  *  Copyright (c) 2013-2014 Red Hat Inc.
   8  */
   9
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/device.h>
  14 #include <linux/input.h>
  15 #include <linux/usb.h>
  16 #include <linux/hid.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/sched.h>
  20 #include <linux/sched/clock.h>
  21 #include <linux/kfifo.h>
  22 #include <linux/input/mt.h>
  23 #include <linux/workqueue.h>
  24 #include <linux/atomic.h>
  25 #include <linux/fixp-arith.h>
  26 #include <asm/unaligned.h>
  27 #include "usbhid/usbhid.h"
  28 #include "hid-ids.h"
  29
  30 MODULE_LICENSE("GPL");
  31 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
  32 MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
  33 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
  34
  35 static bool disable_tap_to_click;
  36 module_param(disable_tap_to_click, bool, 0644);
  37 MODULE_PARM_DESC(disable_tap_to_click,
  38         "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently).");
  39
  40 /* Define a non-zero software ID to identify our own requests */
  41 #define LINUX_KERNEL_SW_ID                      0x01
  42
  43 #define REPORT_ID_HIDPP_SHORT                   0x10
  44 #define REPORT_ID_HIDPP_LONG                    0x11
  45 #define REPORT_ID_HIDPP_VERY_LONG               0x12
  46
  47 #define HIDPP_REPORT_SHORT_LENGTH               7
  48 #define HIDPP_REPORT_LONG_LENGTH                20
  49 #define HIDPP_REPORT_VERY_LONG_MAX_LENGTH       64
  50
  51 #define HIDPP_REPORT_SHORT_SUPPORTED            BIT(0)
  52 #define HIDPP_REPORT_LONG_SUPPORTED             BIT(1)
  53 #define HIDPP_REPORT_VERY_LONG_SUPPORTED        BIT(2)
  54
  55 #define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS       0x03
  56 #define HIDPP_SUB_ID_ROLLER                     0x05
  57 #define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS           0x06
  58 #define HIDPP_SUB_ID_USER_IFACE_EVENT           0x08
  59 #define HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST      BIT(5)
  60
  61 #define HIDPP_QUIRK_CLASS_WTP                   BIT(0)
  62 #define HIDPP_QUIRK_CLASS_M560                  BIT(1)
  63 #define HIDPP_QUIRK_CLASS_K400                  BIT(2)
  64 #define HIDPP_QUIRK_CLASS_G920                  BIT(3)
  65 #define HIDPP_QUIRK_CLASS_K750                  BIT(4)
  66
  67 /* bits 2..20 are reserved for classes */
  68 /* #define HIDPP_QUIRK_CONNECT_EVENTS           BIT(21) disabled */
  69 #define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS        BIT(22)
  70 #define HIDPP_QUIRK_DELAYED_INIT                BIT(23)
  71 #define HIDPP_QUIRK_FORCE_OUTPUT_REPORTS        BIT(24)
  72 #define HIDPP_QUIRK_UNIFYING                    BIT(25)
  73 #define HIDPP_QUIRK_HIDPP_WHEELS                BIT(26)
  74 #define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS      BIT(27)
  75 #define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS  BIT(28)
  76 #define HIDPP_QUIRK_HI_RES_SCROLL_1P0           BIT(29)
  77 #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
 124 struct fap {
 125         u8 feature_index;
 126         u8 funcindex_clientid;
 127         u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
 128 };
 129
 130 struct rap {
 131         u8 sub_id;
 132         u8 reg_address;
 133         u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
 134 };
 135
 136 struct 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
 146 struct 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  */
 174 struct hidpp_scroll_counter {
 175         int wheel_multiplier;
 176         int remainder;
 177         int direction;
 178         unsigned long long last_time;
 179 };
 180
 181 struct 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
 238 static void hidpp_connect_event(struct hidpp_device *hidpp_dev);
 239
 240 static 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  */
 287 static 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  */
 343 static 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  */
 372 static 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  */
 411 static 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
 453 static 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
 460 static 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
 467 static 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
 476 static 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  */
 488 static 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  */
 516 static 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  */
 547 static 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  */
 613 static 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
 647 static 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". */
 658 static 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
 666 static 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
 690 static 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
 724 static 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
 750 static 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
 776 static 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
 799 static 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
 845 static 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
 881 static 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
 903 static 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
 938 static 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
 961 static 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
1001 print_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
1015 static 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
1039 static 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
1065 static 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
1087 static 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
1129 static 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
1184 static 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
1199 static 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
1242 static 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
1274 static 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
1304 static 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
1341 static 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
1386 static 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
1429 static 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
1458 static 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
1493 static 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
1525 static 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
1572 static 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
1617 static 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
1647 static 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
1665 static 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
1696 static 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
1734 static 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
1771 static 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
1783 static 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
1838 static 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
1860 static 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
1900 static 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 */
1932 static 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
1956 static 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
1983 static 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
2016 static 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
2051 static 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;
2072 return_default:
2073         hid_warn(hidpp->hid_dev,
2074                  "Couldn't get wheel multiplier (error %d)\n", ret);
2075         return ret;
2076 }
2077
2078 static 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
2113 static 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
2146 static 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
2204 struct 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  */
2215 static 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
2256 struct 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
2267 struct 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
2277 struct 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
2286 static 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(&params[0]);
2305         raw_info->y_size = get_unaligned_be16(&params[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(&params[13]) * 2 / 51;
2312
2313         return ret;
2314 }
2315
2316 static 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, &params, 1, &response);
2335 }
2336
2337 static 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
2354 static 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
2409 struct 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
2422 struct 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
2431 static 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
2446 static const signed short hidpp_ff_effects_v2[] = {
2447         FF_RAMP,
2448         FF_FRICTION,
2449         FF_INERTIA,
2450         -1
2451 };
2452
2453 static 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
2460 static const char *HIDPP_FF_CONDITION_NAMES[] = {
2461         "spring",
2462         "friction",
2463         "damper",
2464         "inertia"
2465 };
2466
2467
2468 static 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
2479 static 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
2542 out:
2543         atomic_dec(&data->workqueue_size);
2544         kfree(wd);
2545 }
2546
2547 static 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
2573 static 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
2719 static 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
2731 static 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
2741 static 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
2763 static 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
2778 static 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
2788 static 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
2807 static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
2808
2809 static 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
2821 static 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
2928 struct 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
2938 static 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
2945 static 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
2974 static 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
3000 static 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
3018 static 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
3057 static 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
3100 static 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
3129 static 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
3144 static 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
3195 static 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
3206 static 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
3224 static 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
3319 static 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
3338 static 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
3359 struct k400_private_data {
3360         u8 feature_index;
3361 };
3362
3363 static 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
3386 static 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
3401 static 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
3417 static 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
3441 static 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
3511 static 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 /* -------------------------------------------------------------------------- */
3529 static 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
3536 static 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
3562 static 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 /* -------------------------------------------------------------------------- */
3575 static 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
3582 static 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
3616 static 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 */
3635 static 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
3663 static 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
3670 static 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
3699 static 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
3732 static 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
3773 static 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
3789 static 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
3810 static 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
3832 static 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
3849 static 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
3863 static 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
3958 static 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
4008 static 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
4035 static 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
4133 static 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
4153 static 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
4160 static 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
4167 static 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
4191 static 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
4319 static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
4320
4321 static struct attribute *sysfs_attrs[] = {
4322         &dev_attr_builtin_power_supply.attr,
4323         NULL
4324 };
4325
4326 static const struct attribute_group ps_attribute_group = {
4327         .attrs = sysfs_attrs
4328 };
4329
4330 static 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
4343 static 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
4380 bad_device:
4381         hid_warn(hdev, "not enough values in hidpp report %d\n", id);
4382         return false;
4383 }
4384
4385 static 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
4396 static 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
4540 hid_hw_init_fail:
4541         hid_hw_close(hdev);
4542 hid_hw_open_fail:
4543         hid_hw_stop(hdev);
4544 hid_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
4551 static 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
4573 static 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
4654         { /* G935 Gaming Headset */
4655           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0x0a87),
4656                 .driver_data = HIDPP_QUIRK_WIRELESS_STATUS },
4657
4658         { /* MX5000 keyboard over Bluetooth */
4659           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
4660           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4661         { /* Dinovo Edge keyboard over Bluetooth */
4662           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb309),
4663           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4664         { /* MX5500 keyboard over Bluetooth */
4665           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
4666           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4667         { /* Logitech G915 TKL keyboard over Bluetooth */
4668           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb35f) },
4669         { /* M-RCQ142 V470 Cordless Laser Mouse over Bluetooth */
4670           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb008) },
4671         { /* MX Master mouse over Bluetooth */
4672           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012) },
4673         { /* M720 Triathlon mouse over Bluetooth */
4674           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb015) },
4675         { /* MX Ergo trackball over Bluetooth */
4676           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
4677         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e) },
4678         { /* Signature M650 over Bluetooth */
4679           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb02a) },
4680         { /* MX Master 3 mouse over Bluetooth */
4681           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023) },
4682         { /* MX Anywhere 3 mouse over Bluetooth */
4683           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb025) },
4684         { /* MX Master 3S mouse over Bluetooth */
4685           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb034) },
4686         {}
4687 };
4688
4689 MODULE_DEVICE_TABLE(hid, hidpp_devices);
4690
4691 static const struct hid_usage_id hidpp_usages[] = {
4692         { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
4693         { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
4694 };
4695
4696 static struct hid_driver hidpp_driver = {
4697         .name = "logitech-hidpp-device",
4698         .id_table = hidpp_devices,
4699         .report_fixup = hidpp_report_fixup,
4700         .probe = hidpp_probe,
4701         .remove = hidpp_remove,
4702         .raw_event = hidpp_raw_event,
4703         .usage_table = hidpp_usages,
4704         .event = hidpp_event,
4705         .input_configured = hidpp_input_configured,
4706         .input_mapping = hidpp_input_mapping,
4707         .input_mapped = hidpp_input_mapped,
4708 };
4709
4710 module_hid_driver(hidpp_driver);