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_set_wireless_feature_index(struct hidpp_device *hidpp)
1839 {
1840         u8 feature_type;
1841         int ret;
1842
1843         ret = hidpp_root_get_feature(hidpp,
1844                                      HIDPP_PAGE_WIRELESS_DEVICE_STATUS,
1845                                      &hidpp->wireless_feature_index,
1846                                      &feature_type);
1847
1848         return ret;
1849 }
1850
1851 /* -------------------------------------------------------------------------- */
1852 /* 0x1f20: ADC measurement                                                    */
1853 /* -------------------------------------------------------------------------- */
1854
1855 #define HIDPP_PAGE_ADC_MEASUREMENT 0x1f20
1856
1857 #define CMD_ADC_MEASUREMENT_GET_ADC_MEASUREMENT 0x00
1858
1859 #define EVENT_ADC_MEASUREMENT_STATUS_BROADCAST 0x00
1860
1861 static int hidpp20_map_adc_measurement_1f20_capacity(struct hid_device *hid_dev, int voltage)
1862 {
1863         /* NB: This voltage curve doesn't necessarily map perfectly to all
1864          * devices that implement the ADC_MEASUREMENT feature. This is because
1865          * there are a few devices that use different battery technology.
1866          *
1867          * Adapted from:
1868          * https://github.com/Sapd/HeadsetControl/blob/acd972be0468e039b93aae81221f20a54d2d60f7/src/devices/logitech_g633_g933_935.c#L44-L52
1869          */
1870         static const int voltages[100] = {
1871                 4030, 4024, 4018, 4011, 4003, 3994, 3985, 3975, 3963, 3951,
1872                 3937, 3922, 3907, 3893, 3880, 3868, 3857, 3846, 3837, 3828,
1873                 3820, 3812, 3805, 3798, 3791, 3785, 3779, 3773, 3768, 3762,
1874                 3757, 3752, 3747, 3742, 3738, 3733, 3729, 3724, 3720, 3716,
1875                 3712, 3708, 3704, 3700, 3696, 3692, 3688, 3685, 3681, 3677,
1876                 3674, 3670, 3667, 3663, 3660, 3657, 3653, 3650, 3646, 3643,
1877                 3640, 3637, 3633, 3630, 3627, 3624, 3620, 3617, 3614, 3611,
1878                 3608, 3604, 3601, 3598, 3595, 3592, 3589, 3585, 3582, 3579,
1879                 3576, 3573, 3569, 3566, 3563, 3560, 3556, 3553, 3550, 3546,
1880                 3543, 3539, 3536, 3532, 3529, 3525, 3499, 3466, 3433, 3399,
1881         };
1882
1883         int i;
1884
1885         if (voltage == 0)
1886                 return 0;
1887
1888         if (unlikely(voltage < 3400 || voltage >= 5000))
1889                 hid_warn_once(hid_dev,
1890                               "%s: possibly using the wrong voltage curve\n",
1891                               __func__);
1892
1893         for (i = 0; i < ARRAY_SIZE(voltages); i++) {
1894                 if (voltage >= voltages[i])
1895                         return ARRAY_SIZE(voltages) - i;
1896         }
1897
1898         return 0;
1899 }
1900
1901 static int hidpp20_map_adc_measurement_1f20(u8 data[3], int *voltage)
1902 {
1903         int status;
1904         u8 flags;
1905
1906         flags = data[2];
1907
1908         switch (flags) {
1909         case 0x01:
1910                 status = POWER_SUPPLY_STATUS_DISCHARGING;
1911                 break;
1912         case 0x03:
1913                 status = POWER_SUPPLY_STATUS_CHARGING;
1914                 break;
1915         case 0x07:
1916                 status = POWER_SUPPLY_STATUS_FULL;
1917                 break;
1918         case 0x0F:
1919         default:
1920                 status = POWER_SUPPLY_STATUS_UNKNOWN;
1921                 break;
1922         }
1923
1924         *voltage = get_unaligned_be16(data);
1925
1926         dbg_hid("Parsed 1f20 data as flag 0x%02x voltage %dmV\n",
1927                 flags, *voltage);
1928
1929         return status;
1930 }
1931
1932 /* Return value is whether the device is online */
1933 static bool hidpp20_get_adc_measurement_1f20(struct hidpp_device *hidpp,
1934                                                  u8 feature_index,
1935                                                  int *status, int *voltage)
1936 {
1937         struct hidpp_report response;
1938         int ret;
1939         u8 *params = (u8 *)response.fap.params;
1940
1941         *status = POWER_SUPPLY_STATUS_UNKNOWN;
1942         *voltage = 0;
1943         ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1944                                           CMD_ADC_MEASUREMENT_GET_ADC_MEASUREMENT,
1945                                           NULL, 0, &response);
1946
1947         if (ret > 0) {
1948                 hid_dbg(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1949                         __func__, ret);
1950                 return false;
1951         }
1952
1953         *status = hidpp20_map_adc_measurement_1f20(params, voltage);
1954         return true;
1955 }
1956
1957 static int hidpp20_query_adc_measurement_info_1f20(struct hidpp_device *hidpp)
1958 {
1959         u8 feature_type;
1960
1961         if (hidpp->battery.adc_measurement_feature_index == 0xff) {
1962                 int ret;
1963
1964                 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_ADC_MEASUREMENT,
1965                                              &hidpp->battery.adc_measurement_feature_index,
1966                                              &feature_type);
1967                 if (ret)
1968                         return ret;
1969
1970                 hidpp->capabilities |= HIDPP_CAPABILITY_ADC_MEASUREMENT;
1971         }
1972
1973         hidpp->battery.online = hidpp20_get_adc_measurement_1f20(hidpp,
1974                                                                  hidpp->battery.adc_measurement_feature_index,
1975                                                                  &hidpp->battery.status,
1976                                                                  &hidpp->battery.voltage);
1977         hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev,
1978                                                                             hidpp->battery.voltage);
1979         hidpp_update_usb_wireless_status(hidpp);
1980
1981         return 0;
1982 }
1983
1984 static int hidpp20_adc_measurement_event_1f20(struct hidpp_device *hidpp,
1985                                             u8 *data, int size)
1986 {
1987         struct hidpp_report *report = (struct hidpp_report *)data;
1988         int status, voltage;
1989
1990         if (report->fap.feature_index != hidpp->battery.adc_measurement_feature_index ||
1991                 report->fap.funcindex_clientid != EVENT_ADC_MEASUREMENT_STATUS_BROADCAST)
1992                 return 0;
1993
1994         status = hidpp20_map_adc_measurement_1f20(report->fap.params, &voltage);
1995
1996         hidpp->battery.online = status != POWER_SUPPLY_STATUS_UNKNOWN;
1997
1998         if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1999                 hidpp->battery.status = status;
2000                 hidpp->battery.voltage = voltage;
2001                 hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev, voltage);
2002                 if (hidpp->battery.ps)
2003                         power_supply_changed(hidpp->battery.ps);
2004                 hidpp_update_usb_wireless_status(hidpp);
2005         }
2006         return 0;
2007 }
2008
2009 /* -------------------------------------------------------------------------- */
2010 /* 0x2120: Hi-resolution scrolling                                            */
2011 /* -------------------------------------------------------------------------- */
2012
2013 #define HIDPP_PAGE_HI_RESOLUTION_SCROLLING                      0x2120
2014
2015 #define CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE  0x10
2016
2017 static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
2018         bool enabled, u8 *multiplier)
2019 {
2020         u8 feature_index;
2021         u8 feature_type;
2022         int ret;
2023         u8 params[1];
2024         struct hidpp_report response;
2025
2026         ret = hidpp_root_get_feature(hidpp,
2027                                      HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
2028                                      &feature_index,
2029                                      &feature_type);
2030         if (ret)
2031                 return ret;
2032
2033         params[0] = enabled ? BIT(0) : 0;
2034         ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2035                                           CMD_HI_RESOLUTION_SCROLLING_SET_HIGHRES_SCROLLING_MODE,
2036                                           params, sizeof(params), &response);
2037         if (ret)
2038                 return ret;
2039         *multiplier = response.fap.params[1];
2040         return 0;
2041 }
2042
2043 /* -------------------------------------------------------------------------- */
2044 /* 0x2121: HiRes Wheel                                                        */
2045 /* -------------------------------------------------------------------------- */
2046
2047 #define HIDPP_PAGE_HIRES_WHEEL          0x2121
2048
2049 #define CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY    0x00
2050 #define CMD_HIRES_WHEEL_SET_WHEEL_MODE          0x20
2051
2052 static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
2053         u8 *multiplier)
2054 {
2055         u8 feature_index;
2056         u8 feature_type;
2057         int ret;
2058         struct hidpp_report response;
2059
2060         ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2061                                      &feature_index, &feature_type);
2062         if (ret)
2063                 goto return_default;
2064
2065         ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2066                                           CMD_HIRES_WHEEL_GET_WHEEL_CAPABILITY,
2067                                           NULL, 0, &response);
2068         if (ret)
2069                 goto return_default;
2070
2071         *multiplier = response.fap.params[0];
2072         return 0;
2073 return_default:
2074         hid_warn(hidpp->hid_dev,
2075                  "Couldn't get wheel multiplier (error %d)\n", ret);
2076         return ret;
2077 }
2078
2079 static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
2080         bool high_resolution, bool use_hidpp)
2081 {
2082         u8 feature_index;
2083         u8 feature_type;
2084         int ret;
2085         u8 params[1];
2086         struct hidpp_report response;
2087
2088         ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2089                                      &feature_index, &feature_type);
2090         if (ret)
2091                 return ret;
2092
2093         params[0] = (invert          ? BIT(2) : 0) |
2094                     (high_resolution ? BIT(1) : 0) |
2095                     (use_hidpp       ? BIT(0) : 0);
2096
2097         return hidpp_send_fap_command_sync(hidpp, feature_index,
2098                                            CMD_HIRES_WHEEL_SET_WHEEL_MODE,
2099                                            params, sizeof(params), &response);
2100 }
2101
2102 /* -------------------------------------------------------------------------- */
2103 /* 0x4301: Solar Keyboard                                                     */
2104 /* -------------------------------------------------------------------------- */
2105
2106 #define HIDPP_PAGE_SOLAR_KEYBOARD                       0x4301
2107
2108 #define CMD_SOLAR_SET_LIGHT_MEASURE                     0x00
2109
2110 #define EVENT_SOLAR_BATTERY_BROADCAST                   0x00
2111 #define EVENT_SOLAR_BATTERY_LIGHT_MEASURE               0x10
2112 #define EVENT_SOLAR_CHECK_LIGHT_BUTTON                  0x20
2113
2114 static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
2115 {
2116         struct hidpp_report response;
2117         u8 params[2] = { 1, 1 };
2118         u8 feature_type;
2119         int ret;
2120
2121         if (hidpp->battery.feature_index == 0xff) {
2122                 ret = hidpp_root_get_feature(hidpp,
2123                                              HIDPP_PAGE_SOLAR_KEYBOARD,
2124                                              &hidpp->battery.solar_feature_index,
2125                                              &feature_type);
2126                 if (ret)
2127                         return ret;
2128         }
2129
2130         ret = hidpp_send_fap_command_sync(hidpp,
2131                                           hidpp->battery.solar_feature_index,
2132                                           CMD_SOLAR_SET_LIGHT_MEASURE,
2133                                           params, 2, &response);
2134         if (ret > 0) {
2135                 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2136                         __func__, ret);
2137                 return -EPROTO;
2138         }
2139         if (ret)
2140                 return ret;
2141
2142         hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
2143
2144         return 0;
2145 }
2146
2147 static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
2148                                      u8 *data, int size)
2149 {
2150         struct hidpp_report *report = (struct hidpp_report *)data;
2151         int capacity, lux, status;
2152         u8 function;
2153
2154         function = report->fap.funcindex_clientid;
2155
2156
2157         if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
2158             !(function == EVENT_SOLAR_BATTERY_BROADCAST ||
2159               function == EVENT_SOLAR_BATTERY_LIGHT_MEASURE ||
2160               function == EVENT_SOLAR_CHECK_LIGHT_BUTTON))
2161                 return 0;
2162
2163         capacity = report->fap.params[0];
2164
2165         switch (function) {
2166         case EVENT_SOLAR_BATTERY_LIGHT_MEASURE:
2167                 lux = (report->fap.params[1] << 8) | report->fap.params[2];
2168                 if (lux > 200)
2169                         status = POWER_SUPPLY_STATUS_CHARGING;
2170                 else
2171                         status = POWER_SUPPLY_STATUS_DISCHARGING;
2172                 break;
2173         case EVENT_SOLAR_CHECK_LIGHT_BUTTON:
2174         default:
2175                 if (capacity < hidpp->battery.capacity)
2176                         status = POWER_SUPPLY_STATUS_DISCHARGING;
2177                 else
2178                         status = POWER_SUPPLY_STATUS_CHARGING;
2179
2180         }
2181
2182         if (capacity == 100)
2183                 status = POWER_SUPPLY_STATUS_FULL;
2184
2185         hidpp->battery.online = true;
2186         if (capacity != hidpp->battery.capacity ||
2187             status != hidpp->battery.status) {
2188                 hidpp->battery.capacity = capacity;
2189                 hidpp->battery.status = status;
2190                 if (hidpp->battery.ps)
2191                         power_supply_changed(hidpp->battery.ps);
2192         }
2193
2194         return 0;
2195 }
2196
2197 /* -------------------------------------------------------------------------- */
2198 /* 0x6010: Touchpad FW items                                                  */
2199 /* -------------------------------------------------------------------------- */
2200
2201 #define HIDPP_PAGE_TOUCHPAD_FW_ITEMS                    0x6010
2202
2203 #define CMD_TOUCHPAD_FW_ITEMS_SET                       0x10
2204
2205 struct hidpp_touchpad_fw_items {
2206         uint8_t presence;
2207         uint8_t desired_state;
2208         uint8_t state;
2209         uint8_t persistent;
2210 };
2211
2212 /*
2213  * send a set state command to the device by reading the current items->state
2214  * field. items is then filled with the current state.
2215  */
2216 static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
2217                                        u8 feature_index,
2218                                        struct hidpp_touchpad_fw_items *items)
2219 {
2220         struct hidpp_report response;
2221         int ret;
2222         u8 *params = (u8 *)response.fap.params;
2223
2224         ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2225                 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response);
2226
2227         if (ret > 0) {
2228                 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2229                         __func__, ret);
2230                 return -EPROTO;
2231         }
2232         if (ret)
2233                 return ret;
2234
2235         items->presence = params[0];
2236         items->desired_state = params[1];
2237         items->state = params[2];
2238         items->persistent = params[3];
2239
2240         return 0;
2241 }
2242
2243 /* -------------------------------------------------------------------------- */
2244 /* 0x6100: TouchPadRawXY                                                      */
2245 /* -------------------------------------------------------------------------- */
2246
2247 #define HIDPP_PAGE_TOUCHPAD_RAW_XY                      0x6100
2248
2249 #define CMD_TOUCHPAD_GET_RAW_INFO                       0x00
2250 #define CMD_TOUCHPAD_SET_RAW_REPORT_STATE               0x20
2251
2252 #define EVENT_TOUCHPAD_RAW_XY                           0x00
2253
2254 #define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT               0x01
2255 #define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT               0x03
2256
2257 struct hidpp_touchpad_raw_info {
2258         u16 x_size;
2259         u16 y_size;
2260         u8 z_range;
2261         u8 area_range;
2262         u8 timestamp_unit;
2263         u8 maxcontacts;
2264         u8 origin;
2265         u16 res;
2266 };
2267
2268 struct hidpp_touchpad_raw_xy_finger {
2269         u8 contact_type;
2270         u8 contact_status;
2271         u16 x;
2272         u16 y;
2273         u8 z;
2274         u8 area;
2275         u8 finger_id;
2276 };
2277
2278 struct hidpp_touchpad_raw_xy {
2279         u16 timestamp;
2280         struct hidpp_touchpad_raw_xy_finger fingers[2];
2281         u8 spurious_flag;
2282         u8 end_of_frame;
2283         u8 finger_count;
2284         u8 button;
2285 };
2286
2287 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
2288         u8 feature_index, struct hidpp_touchpad_raw_info *raw_info)
2289 {
2290         struct hidpp_report response;
2291         int ret;
2292         u8 *params = (u8 *)response.fap.params;
2293
2294         ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2295                 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response);
2296
2297         if (ret > 0) {
2298                 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2299                         __func__, ret);
2300                 return -EPROTO;
2301         }
2302         if (ret)
2303                 return ret;
2304
2305         raw_info->x_size = get_unaligned_be16(&params[0]);
2306         raw_info->y_size = get_unaligned_be16(&params[2]);
2307         raw_info->z_range = params[4];
2308         raw_info->area_range = params[5];
2309         raw_info->maxcontacts = params[7];
2310         raw_info->origin = params[8];
2311         /* res is given in unit per inch */
2312         raw_info->res = get_unaligned_be16(&params[13]) * 2 / 51;
2313
2314         return ret;
2315 }
2316
2317 static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev,
2318                 u8 feature_index, bool send_raw_reports,
2319                 bool sensor_enhanced_settings)
2320 {
2321         struct hidpp_report response;
2322
2323         /*
2324          * Params:
2325          *   bit 0 - enable raw
2326          *   bit 1 - 16bit Z, no area
2327          *   bit 2 - enhanced sensitivity
2328          *   bit 3 - width, height (4 bits each) instead of area
2329          *   bit 4 - send raw + gestures (degrades smoothness)
2330          *   remaining bits - reserved
2331          */
2332         u8 params = send_raw_reports | (sensor_enhanced_settings << 2);
2333
2334         return hidpp_send_fap_command_sync(hidpp_dev, feature_index,
2335                 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, &params, 1, &response);
2336 }
2337
2338 static void hidpp_touchpad_touch_event(u8 *data,
2339         struct hidpp_touchpad_raw_xy_finger *finger)
2340 {
2341         u8 x_m = data[0] << 2;
2342         u8 y_m = data[2] << 2;
2343
2344         finger->x = x_m << 6 | data[1];
2345         finger->y = y_m << 6 | data[3];
2346
2347         finger->contact_type = data[0] >> 6;
2348         finger->contact_status = data[2] >> 6;
2349
2350         finger->z = data[4];
2351         finger->area = data[5];
2352         finger->finger_id = data[6] >> 4;
2353 }
2354
2355 static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev,
2356                 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy)
2357 {
2358         memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy));
2359         raw_xy->end_of_frame = data[8] & 0x01;
2360         raw_xy->spurious_flag = (data[8] >> 1) & 0x01;
2361         raw_xy->finger_count = data[15] & 0x0f;
2362         raw_xy->button = (data[8] >> 2) & 0x01;
2363
2364         if (raw_xy->finger_count) {
2365                 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]);
2366                 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]);
2367         }
2368 }
2369
2370 /* -------------------------------------------------------------------------- */
2371 /* 0x8123: Force feedback support                                             */
2372 /* -------------------------------------------------------------------------- */
2373
2374 #define HIDPP_FF_GET_INFO               0x01
2375 #define HIDPP_FF_RESET_ALL              0x11
2376 #define HIDPP_FF_DOWNLOAD_EFFECT        0x21
2377 #define HIDPP_FF_SET_EFFECT_STATE       0x31
2378 #define HIDPP_FF_DESTROY_EFFECT         0x41
2379 #define HIDPP_FF_GET_APERTURE           0x51
2380 #define HIDPP_FF_SET_APERTURE           0x61
2381 #define HIDPP_FF_GET_GLOBAL_GAINS       0x71
2382 #define HIDPP_FF_SET_GLOBAL_GAINS       0x81
2383
2384 #define HIDPP_FF_EFFECT_STATE_GET       0x00
2385 #define HIDPP_FF_EFFECT_STATE_STOP      0x01
2386 #define HIDPP_FF_EFFECT_STATE_PLAY      0x02
2387 #define HIDPP_FF_EFFECT_STATE_PAUSE     0x03
2388
2389 #define HIDPP_FF_EFFECT_CONSTANT        0x00
2390 #define HIDPP_FF_EFFECT_PERIODIC_SINE           0x01
2391 #define HIDPP_FF_EFFECT_PERIODIC_SQUARE         0x02
2392 #define HIDPP_FF_EFFECT_PERIODIC_TRIANGLE       0x03
2393 #define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP     0x04
2394 #define HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN   0x05
2395 #define HIDPP_FF_EFFECT_SPRING          0x06
2396 #define HIDPP_FF_EFFECT_DAMPER          0x07
2397 #define HIDPP_FF_EFFECT_FRICTION        0x08
2398 #define HIDPP_FF_EFFECT_INERTIA         0x09
2399 #define HIDPP_FF_EFFECT_RAMP            0x0A
2400
2401 #define HIDPP_FF_EFFECT_AUTOSTART       0x80
2402
2403 #define HIDPP_FF_EFFECTID_NONE          -1
2404 #define HIDPP_FF_EFFECTID_AUTOCENTER    -2
2405 #define HIDPP_AUTOCENTER_PARAMS_LENGTH  18
2406
2407 #define HIDPP_FF_MAX_PARAMS     20
2408 #define HIDPP_FF_RESERVED_SLOTS 1
2409
2410 struct hidpp_ff_private_data {
2411         struct hidpp_device *hidpp;
2412         u8 feature_index;
2413         u8 version;
2414         u16 gain;
2415         s16 range;
2416         u8 slot_autocenter;
2417         u8 num_effects;
2418         int *effect_ids;
2419         struct workqueue_struct *wq;
2420         atomic_t workqueue_size;
2421 };
2422
2423 struct hidpp_ff_work_data {
2424         struct work_struct work;
2425         struct hidpp_ff_private_data *data;
2426         int effect_id;
2427         u8 command;
2428         u8 params[HIDPP_FF_MAX_PARAMS];
2429         u8 size;
2430 };
2431
2432 static const signed short hidpp_ff_effects[] = {
2433         FF_CONSTANT,
2434         FF_PERIODIC,
2435         FF_SINE,
2436         FF_SQUARE,
2437         FF_SAW_UP,
2438         FF_SAW_DOWN,
2439         FF_TRIANGLE,
2440         FF_SPRING,
2441         FF_DAMPER,
2442         FF_AUTOCENTER,
2443         FF_GAIN,
2444         -1
2445 };
2446
2447 static const signed short hidpp_ff_effects_v2[] = {
2448         FF_RAMP,
2449         FF_FRICTION,
2450         FF_INERTIA,
2451         -1
2452 };
2453
2454 static const u8 HIDPP_FF_CONDITION_CMDS[] = {
2455         HIDPP_FF_EFFECT_SPRING,
2456         HIDPP_FF_EFFECT_FRICTION,
2457         HIDPP_FF_EFFECT_DAMPER,
2458         HIDPP_FF_EFFECT_INERTIA
2459 };
2460
2461 static const char *HIDPP_FF_CONDITION_NAMES[] = {
2462         "spring",
2463         "friction",
2464         "damper",
2465         "inertia"
2466 };
2467
2468
2469 static u8 hidpp_ff_find_effect(struct hidpp_ff_private_data *data, int effect_id)
2470 {
2471         int i;
2472
2473         for (i = 0; i < data->num_effects; i++)
2474                 if (data->effect_ids[i] == effect_id)
2475                         return i+1;
2476
2477         return 0;
2478 }
2479
2480 static void hidpp_ff_work_handler(struct work_struct *w)
2481 {
2482         struct hidpp_ff_work_data *wd = container_of(w, struct hidpp_ff_work_data, work);
2483         struct hidpp_ff_private_data *data = wd->data;
2484         struct hidpp_report response;
2485         u8 slot;
2486         int ret;
2487
2488         /* add slot number if needed */
2489         switch (wd->effect_id) {
2490         case HIDPP_FF_EFFECTID_AUTOCENTER:
2491                 wd->params[0] = data->slot_autocenter;
2492                 break;
2493         case HIDPP_FF_EFFECTID_NONE:
2494                 /* leave slot as zero */
2495                 break;
2496         default:
2497                 /* find current slot for effect */
2498                 wd->params[0] = hidpp_ff_find_effect(data, wd->effect_id);
2499                 break;
2500         }
2501
2502         /* send command and wait for reply */
2503         ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
2504                 wd->command, wd->params, wd->size, &response);
2505
2506         if (ret) {
2507                 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
2508                 goto out;
2509         }
2510
2511         /* parse return data */
2512         switch (wd->command) {
2513         case HIDPP_FF_DOWNLOAD_EFFECT:
2514                 slot = response.fap.params[0];
2515                 if (slot > 0 && slot <= data->num_effects) {
2516                         if (wd->effect_id >= 0)
2517                                 /* regular effect uploaded */
2518                                 data->effect_ids[slot-1] = wd->effect_id;
2519                         else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2520                                 /* autocenter spring uploaded */
2521                                 data->slot_autocenter = slot;
2522                 }
2523                 break;
2524         case HIDPP_FF_DESTROY_EFFECT:
2525                 if (wd->effect_id >= 0)
2526                         /* regular effect destroyed */
2527                         data->effect_ids[wd->params[0]-1] = -1;
2528                 else if (wd->effect_id >= HIDPP_FF_EFFECTID_AUTOCENTER)
2529                         /* autocenter spring destoyed */
2530                         data->slot_autocenter = 0;
2531                 break;
2532         case HIDPP_FF_SET_GLOBAL_GAINS:
2533                 data->gain = (wd->params[0] << 8) + wd->params[1];
2534                 break;
2535         case HIDPP_FF_SET_APERTURE:
2536                 data->range = (wd->params[0] << 8) + wd->params[1];
2537                 break;
2538         default:
2539                 /* no action needed */
2540                 break;
2541         }
2542
2543 out:
2544         atomic_dec(&data->workqueue_size);
2545         kfree(wd);
2546 }
2547
2548 static int hidpp_ff_queue_work(struct hidpp_ff_private_data *data, int effect_id, u8 command, u8 *params, u8 size)
2549 {
2550         struct hidpp_ff_work_data *wd = kzalloc(sizeof(*wd), GFP_KERNEL);
2551         int s;
2552
2553         if (!wd)
2554                 return -ENOMEM;
2555
2556         INIT_WORK(&wd->work, hidpp_ff_work_handler);
2557
2558         wd->data = data;
2559         wd->effect_id = effect_id;
2560         wd->command = command;
2561         wd->size = size;
2562         memcpy(wd->params, params, size);
2563
2564         s = atomic_inc_return(&data->workqueue_size);
2565         queue_work(data->wq, &wd->work);
2566
2567         /* warn about excessive queue size */
2568         if (s >= 20 && s % 20 == 0)
2569                 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2570
2571         return 0;
2572 }
2573
2574 static int hidpp_ff_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
2575 {
2576         struct hidpp_ff_private_data *data = dev->ff->private;
2577         u8 params[20];
2578         u8 size;
2579         int force;
2580
2581         /* set common parameters */
2582         params[2] = effect->replay.length >> 8;
2583         params[3] = effect->replay.length & 255;
2584         params[4] = effect->replay.delay >> 8;
2585         params[5] = effect->replay.delay & 255;
2586
2587         switch (effect->type) {
2588         case FF_CONSTANT:
2589                 force = (effect->u.constant.level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2590                 params[1] = HIDPP_FF_EFFECT_CONSTANT;
2591                 params[6] = force >> 8;
2592                 params[7] = force & 255;
2593                 params[8] = effect->u.constant.envelope.attack_level >> 7;
2594                 params[9] = effect->u.constant.envelope.attack_length >> 8;
2595                 params[10] = effect->u.constant.envelope.attack_length & 255;
2596                 params[11] = effect->u.constant.envelope.fade_level >> 7;
2597                 params[12] = effect->u.constant.envelope.fade_length >> 8;
2598                 params[13] = effect->u.constant.envelope.fade_length & 255;
2599                 size = 14;
2600                 dbg_hid("Uploading constant force level=%d in dir %d = %d\n",
2601                                 effect->u.constant.level,
2602                                 effect->direction, force);
2603                 dbg_hid("          envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2604                                 effect->u.constant.envelope.attack_level,
2605                                 effect->u.constant.envelope.attack_length,
2606                                 effect->u.constant.envelope.fade_level,
2607                                 effect->u.constant.envelope.fade_length);
2608                 break;
2609         case FF_PERIODIC:
2610         {
2611                 switch (effect->u.periodic.waveform) {
2612                 case FF_SINE:
2613                         params[1] = HIDPP_FF_EFFECT_PERIODIC_SINE;
2614                         break;
2615                 case FF_SQUARE:
2616                         params[1] = HIDPP_FF_EFFECT_PERIODIC_SQUARE;
2617                         break;
2618                 case FF_SAW_UP:
2619                         params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHUP;
2620                         break;
2621                 case FF_SAW_DOWN:
2622                         params[1] = HIDPP_FF_EFFECT_PERIODIC_SAWTOOTHDOWN;
2623                         break;
2624                 case FF_TRIANGLE:
2625                         params[1] = HIDPP_FF_EFFECT_PERIODIC_TRIANGLE;
2626                         break;
2627                 default:
2628                         hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2629                         return -EINVAL;
2630                 }
2631                 force = (effect->u.periodic.magnitude * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2632                 params[6] = effect->u.periodic.magnitude >> 8;
2633                 params[7] = effect->u.periodic.magnitude & 255;
2634                 params[8] = effect->u.periodic.offset >> 8;
2635                 params[9] = effect->u.periodic.offset & 255;
2636                 params[10] = effect->u.periodic.period >> 8;
2637                 params[11] = effect->u.periodic.period & 255;
2638                 params[12] = effect->u.periodic.phase >> 8;
2639                 params[13] = effect->u.periodic.phase & 255;
2640                 params[14] = effect->u.periodic.envelope.attack_level >> 7;
2641                 params[15] = effect->u.periodic.envelope.attack_length >> 8;
2642                 params[16] = effect->u.periodic.envelope.attack_length & 255;
2643                 params[17] = effect->u.periodic.envelope.fade_level >> 7;
2644                 params[18] = effect->u.periodic.envelope.fade_length >> 8;
2645                 params[19] = effect->u.periodic.envelope.fade_length & 255;
2646                 size = 20;
2647                 dbg_hid("Uploading periodic force mag=%d/dir=%d, offset=%d, period=%d ms, phase=%d\n",
2648                                 effect->u.periodic.magnitude, effect->direction,
2649                                 effect->u.periodic.offset,
2650                                 effect->u.periodic.period,
2651                                 effect->u.periodic.phase);
2652                 dbg_hid("          envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2653                                 effect->u.periodic.envelope.attack_level,
2654                                 effect->u.periodic.envelope.attack_length,
2655                                 effect->u.periodic.envelope.fade_level,
2656                                 effect->u.periodic.envelope.fade_length);
2657                 break;
2658         }
2659         case FF_RAMP:
2660                 params[1] = HIDPP_FF_EFFECT_RAMP;
2661                 force = (effect->u.ramp.start_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2662                 params[6] = force >> 8;
2663                 params[7] = force & 255;
2664                 force = (effect->u.ramp.end_level * fixp_sin16((effect->direction * 360) >> 16)) >> 15;
2665                 params[8] = force >> 8;
2666                 params[9] = force & 255;
2667                 params[10] = effect->u.ramp.envelope.attack_level >> 7;
2668                 params[11] = effect->u.ramp.envelope.attack_length >> 8;
2669                 params[12] = effect->u.ramp.envelope.attack_length & 255;
2670                 params[13] = effect->u.ramp.envelope.fade_level >> 7;
2671                 params[14] = effect->u.ramp.envelope.fade_length >> 8;
2672                 params[15] = effect->u.ramp.envelope.fade_length & 255;
2673                 size = 16;
2674                 dbg_hid("Uploading ramp force level=%d -> %d in dir %d = %d\n",
2675                                 effect->u.ramp.start_level,
2676                                 effect->u.ramp.end_level,
2677                                 effect->direction, force);
2678                 dbg_hid("          envelope attack=(%d, %d ms) fade=(%d, %d ms)\n",
2679                                 effect->u.ramp.envelope.attack_level,
2680                                 effect->u.ramp.envelope.attack_length,
2681                                 effect->u.ramp.envelope.fade_level,
2682                                 effect->u.ramp.envelope.fade_length);
2683                 break;
2684         case FF_FRICTION:
2685         case FF_INERTIA:
2686         case FF_SPRING:
2687         case FF_DAMPER:
2688                 params[1] = HIDPP_FF_CONDITION_CMDS[effect->type - FF_SPRING];
2689                 params[6] = effect->u.condition[0].left_saturation >> 9;
2690                 params[7] = (effect->u.condition[0].left_saturation >> 1) & 255;
2691                 params[8] = effect->u.condition[0].left_coeff >> 8;
2692                 params[9] = effect->u.condition[0].left_coeff & 255;
2693                 params[10] = effect->u.condition[0].deadband >> 9;
2694                 params[11] = (effect->u.condition[0].deadband >> 1) & 255;
2695                 params[12] = effect->u.condition[0].center >> 8;
2696                 params[13] = effect->u.condition[0].center & 255;
2697                 params[14] = effect->u.condition[0].right_coeff >> 8;
2698                 params[15] = effect->u.condition[0].right_coeff & 255;
2699                 params[16] = effect->u.condition[0].right_saturation >> 9;
2700                 params[17] = (effect->u.condition[0].right_saturation >> 1) & 255;
2701                 size = 18;
2702                 dbg_hid("Uploading %s force left coeff=%d, left sat=%d, right coeff=%d, right sat=%d\n",
2703                                 HIDPP_FF_CONDITION_NAMES[effect->type - FF_SPRING],
2704                                 effect->u.condition[0].left_coeff,
2705                                 effect->u.condition[0].left_saturation,
2706                                 effect->u.condition[0].right_coeff,
2707                                 effect->u.condition[0].right_saturation);
2708                 dbg_hid("          deadband=%d, center=%d\n",
2709                                 effect->u.condition[0].deadband,
2710                                 effect->u.condition[0].center);
2711                 break;
2712         default:
2713                 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2714                 return -EINVAL;
2715         }
2716
2717         return hidpp_ff_queue_work(data, effect->id, HIDPP_FF_DOWNLOAD_EFFECT, params, size);
2718 }
2719
2720 static int hidpp_ff_playback(struct input_dev *dev, int effect_id, int value)
2721 {
2722         struct hidpp_ff_private_data *data = dev->ff->private;
2723         u8 params[2];
2724
2725         params[1] = value ? HIDPP_FF_EFFECT_STATE_PLAY : HIDPP_FF_EFFECT_STATE_STOP;
2726
2727         dbg_hid("St%sing playback of effect %d.\n", value?"art":"opp", effect_id);
2728
2729         return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_SET_EFFECT_STATE, params, ARRAY_SIZE(params));
2730 }
2731
2732 static int hidpp_ff_erase_effect(struct input_dev *dev, int effect_id)
2733 {
2734         struct hidpp_ff_private_data *data = dev->ff->private;
2735         u8 slot = 0;
2736
2737         dbg_hid("Erasing effect %d.\n", effect_id);
2738
2739         return hidpp_ff_queue_work(data, effect_id, HIDPP_FF_DESTROY_EFFECT, &slot, 1);
2740 }
2741
2742 static void hidpp_ff_set_autocenter(struct input_dev *dev, u16 magnitude)
2743 {
2744         struct hidpp_ff_private_data *data = dev->ff->private;
2745         u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH];
2746
2747         dbg_hid("Setting autocenter to %d.\n", magnitude);
2748
2749         /* start a standard spring effect */
2750         params[1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART;
2751         /* zero delay and duration */
2752         params[2] = params[3] = params[4] = params[5] = 0;
2753         /* set coeff to 25% of saturation */
2754         params[8] = params[14] = magnitude >> 11;
2755         params[9] = params[15] = (magnitude >> 3) & 255;
2756         params[6] = params[16] = magnitude >> 9;
2757         params[7] = params[17] = (magnitude >> 1) & 255;
2758         /* zero deadband and center */
2759         params[10] = params[11] = params[12] = params[13] = 0;
2760
2761         hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_AUTOCENTER, HIDPP_FF_DOWNLOAD_EFFECT, params, ARRAY_SIZE(params));
2762 }
2763
2764 static void hidpp_ff_set_gain(struct input_dev *dev, u16 gain)
2765 {
2766         struct hidpp_ff_private_data *data = dev->ff->private;
2767         u8 params[4];
2768
2769         dbg_hid("Setting gain to %d.\n", gain);
2770
2771         params[0] = gain >> 8;
2772         params[1] = gain & 255;
2773         params[2] = 0; /* no boost */
2774         params[3] = 0;
2775
2776         hidpp_ff_queue_work(data, HIDPP_FF_EFFECTID_NONE, HIDPP_FF_SET_GLOBAL_GAINS, params, ARRAY_SIZE(params));
2777 }
2778
2779 static ssize_t hidpp_ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
2780 {
2781         struct hid_device *hid = to_hid_device(dev);
2782         struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2783         struct input_dev *idev = hidinput->input;
2784         struct hidpp_ff_private_data *data = idev->ff->private;
2785
2786         return scnprintf(buf, PAGE_SIZE, "%u\n", data->range);
2787 }
2788
2789 static ssize_t hidpp_ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
2790 {
2791         struct hid_device *hid = to_hid_device(dev);
2792         struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2793         struct input_dev *idev = hidinput->input;
2794         struct hidpp_ff_private_data *data = idev->ff->private;
2795         u8 params[2];
2796         int range = simple_strtoul(buf, NULL, 10);
2797
2798         range = clamp(range, 180, 900);
2799
2800         params[0] = range >> 8;
2801         params[1] = range & 0x00FF;
2802
2803         hidpp_ff_queue_work(data, -1, HIDPP_FF_SET_APERTURE, params, ARRAY_SIZE(params));
2804
2805         return count;
2806 }
2807
2808 static DEVICE_ATTR(range, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, hidpp_ff_range_show, hidpp_ff_range_store);
2809
2810 static void hidpp_ff_destroy(struct ff_device *ff)
2811 {
2812         struct hidpp_ff_private_data *data = ff->private;
2813         struct hid_device *hid = data->hidpp->hid_dev;
2814
2815         hid_info(hid, "Unloading HID++ force feedback.\n");
2816
2817         device_remove_file(&hid->dev, &dev_attr_range);
2818         destroy_workqueue(data->wq);
2819         kfree(data->effect_ids);
2820 }
2821
2822 static int hidpp_ff_init(struct hidpp_device *hidpp,
2823                          struct hidpp_ff_private_data *data)
2824 {
2825         struct hid_device *hid = hidpp->hid_dev;
2826         struct hid_input *hidinput;
2827         struct input_dev *dev;
2828         struct usb_device_descriptor *udesc;
2829         u16 bcdDevice;
2830         struct ff_device *ff;
2831         int error, j, num_slots = data->num_effects;
2832         u8 version;
2833
2834         if (!hid_is_usb(hid)) {
2835                 hid_err(hid, "device is not USB\n");
2836                 return -ENODEV;
2837         }
2838
2839         if (list_empty(&hid->inputs)) {
2840                 hid_err(hid, "no inputs found\n");
2841                 return -ENODEV;
2842         }
2843         hidinput = list_entry(hid->inputs.next, struct hid_input, list);
2844         dev = hidinput->input;
2845
2846         if (!dev) {
2847                 hid_err(hid, "Struct input_dev not set!\n");
2848                 return -EINVAL;
2849         }
2850
2851         /* Get firmware release */
2852         udesc = &(hid_to_usb_dev(hid)->descriptor);
2853         bcdDevice = le16_to_cpu(udesc->bcdDevice);
2854         version = bcdDevice & 255;
2855
2856         /* Set supported force feedback capabilities */
2857         for (j = 0; hidpp_ff_effects[j] >= 0; j++)
2858                 set_bit(hidpp_ff_effects[j], dev->ffbit);
2859         if (version > 1)
2860                 for (j = 0; hidpp_ff_effects_v2[j] >= 0; j++)
2861                         set_bit(hidpp_ff_effects_v2[j], dev->ffbit);
2862
2863         error = input_ff_create(dev, num_slots);
2864
2865         if (error) {
2866                 hid_err(dev, "Failed to create FF device!\n");
2867                 return error;
2868         }
2869         /*
2870          * Create a copy of passed data, so we can transfer memory
2871          * ownership to FF core
2872          */
2873         data = kmemdup(data, sizeof(*data), GFP_KERNEL);
2874         if (!data)
2875                 return -ENOMEM;
2876         data->effect_ids = kcalloc(num_slots, sizeof(int), GFP_KERNEL);
2877         if (!data->effect_ids) {
2878                 kfree(data);
2879                 return -ENOMEM;
2880         }
2881         data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2882         if (!data->wq) {
2883                 kfree(data->effect_ids);
2884                 kfree(data);
2885                 return -ENOMEM;
2886         }
2887
2888         data->hidpp = hidpp;
2889         data->version = version;
2890         for (j = 0; j < num_slots; j++)
2891                 data->effect_ids[j] = -1;
2892
2893         ff = dev->ff;
2894         ff->private = data;
2895
2896         ff->upload = hidpp_ff_upload_effect;
2897         ff->erase = hidpp_ff_erase_effect;
2898         ff->playback = hidpp_ff_playback;
2899         ff->set_gain = hidpp_ff_set_gain;
2900         ff->set_autocenter = hidpp_ff_set_autocenter;
2901         ff->destroy = hidpp_ff_destroy;
2902
2903         /* Create sysfs interface */
2904         error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2905         if (error)
2906                 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2907
2908         /* init the hardware command queue */
2909         atomic_set(&data->workqueue_size, 0);
2910
2911         hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
2912                  version);
2913
2914         return 0;
2915 }
2916
2917 /* ************************************************************************** */
2918 /*                                                                            */
2919 /* Device Support                                                             */
2920 /*                                                                            */
2921 /* ************************************************************************** */
2922
2923 /* -------------------------------------------------------------------------- */
2924 /* Touchpad HID++ devices                                                     */
2925 /* -------------------------------------------------------------------------- */
2926
2927 #define WTP_MANUAL_RESOLUTION                           39
2928
2929 struct wtp_data {
2930         u16 x_size, y_size;
2931         u8 finger_count;
2932         u8 mt_feature_index;
2933         u8 button_feature_index;
2934         u8 maxcontacts;
2935         bool flip_y;
2936         unsigned int resolution;
2937 };
2938
2939 static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
2940                 struct hid_field *field, struct hid_usage *usage,
2941                 unsigned long **bit, int *max)
2942 {
2943         return -1;
2944 }
2945
2946 static void wtp_populate_input(struct hidpp_device *hidpp,
2947                                struct input_dev *input_dev)
2948 {
2949         struct wtp_data *wd = hidpp->private_data;
2950
2951         __set_bit(EV_ABS, input_dev->evbit);
2952         __set_bit(EV_KEY, input_dev->evbit);
2953         __clear_bit(EV_REL, input_dev->evbit);
2954         __clear_bit(EV_LED, input_dev->evbit);
2955
2956         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0);
2957         input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution);
2958         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0);
2959         input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution);
2960
2961         /* Max pressure is not given by the devices, pick one */
2962         input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0);
2963
2964         input_set_capability(input_dev, EV_KEY, BTN_LEFT);
2965
2966         if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2967                 input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
2968         else
2969                 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2970
2971         input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
2972                 INPUT_MT_DROP_UNUSED);
2973 }
2974
2975 static void wtp_touch_event(struct hidpp_device *hidpp,
2976         struct hidpp_touchpad_raw_xy_finger *touch_report)
2977 {
2978         struct wtp_data *wd = hidpp->private_data;
2979         int slot;
2980
2981         if (!touch_report->finger_id || touch_report->contact_type)
2982                 /* no actual data */
2983                 return;
2984
2985         slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2986
2987         input_mt_slot(hidpp->input, slot);
2988         input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2989                                         touch_report->contact_status);
2990         if (touch_report->contact_status) {
2991                 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2992                                 touch_report->x);
2993                 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2994                                 wd->flip_y ? wd->y_size - touch_report->y :
2995                                              touch_report->y);
2996                 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2997                                 touch_report->area);
2998         }
2999 }
3000
3001 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
3002                 struct hidpp_touchpad_raw_xy *raw)
3003 {
3004         int i;
3005
3006         for (i = 0; i < 2; i++)
3007                 wtp_touch_event(hidpp, &(raw->fingers[i]));
3008
3009         if (raw->end_of_frame &&
3010             !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
3011                 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
3012
3013         if (raw->end_of_frame || raw->finger_count <= 2) {
3014                 input_mt_sync_frame(hidpp->input);
3015                 input_sync(hidpp->input);
3016         }
3017 }
3018
3019 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
3020 {
3021         struct wtp_data *wd = hidpp->private_data;
3022         u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) +
3023                       (data[7] >> 4) * (data[7] >> 4)) / 2;
3024         u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) +
3025                       (data[13] >> 4) * (data[13] >> 4)) / 2;
3026         struct hidpp_touchpad_raw_xy raw = {
3027                 .timestamp = data[1],
3028                 .fingers = {
3029                         {
3030                                 .contact_type = 0,
3031                                 .contact_status = !!data[7],
3032                                 .x = get_unaligned_le16(&data[3]),
3033                                 .y = get_unaligned_le16(&data[5]),
3034                                 .z = c1_area,
3035                                 .area = c1_area,
3036                                 .finger_id = data[2],
3037                         }, {
3038                                 .contact_type = 0,
3039                                 .contact_status = !!data[13],
3040                                 .x = get_unaligned_le16(&data[9]),
3041                                 .y = get_unaligned_le16(&data[11]),
3042                                 .z = c2_area,
3043                                 .area = c2_area,
3044                                 .finger_id = data[8],
3045                         }
3046                 },
3047                 .finger_count = wd->maxcontacts,
3048                 .spurious_flag = 0,
3049                 .end_of_frame = (data[0] >> 7) == 0,
3050                 .button = data[0] & 0x01,
3051         };
3052
3053         wtp_send_raw_xy_event(hidpp, &raw);
3054
3055         return 1;
3056 }
3057
3058 static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
3059 {
3060         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3061         struct wtp_data *wd = hidpp->private_data;
3062         struct hidpp_report *report = (struct hidpp_report *)data;
3063         struct hidpp_touchpad_raw_xy raw;
3064
3065         if (!wd || !hidpp->input)
3066                 return 1;
3067
3068         switch (data[0]) {
3069         case 0x02:
3070                 if (size < 2) {
3071                         hid_err(hdev, "Received HID report of bad size (%d)",
3072                                 size);
3073                         return 1;
3074                 }
3075                 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
3076                         input_event(hidpp->input, EV_KEY, BTN_LEFT,
3077                                         !!(data[1] & 0x01));
3078                         input_event(hidpp->input, EV_KEY, BTN_RIGHT,
3079                                         !!(data[1] & 0x02));
3080                         input_sync(hidpp->input);
3081                         return 0;
3082                 } else {
3083                         if (size < 21)
3084                                 return 1;
3085                         return wtp_mouse_raw_xy_event(hidpp, &data[7]);
3086                 }
3087         case REPORT_ID_HIDPP_LONG:
3088                 /* size is already checked in hidpp_raw_event. */
3089                 if ((report->fap.feature_index != wd->mt_feature_index) ||
3090                     (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))
3091                         return 1;
3092                 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
3093
3094                 wtp_send_raw_xy_event(hidpp, &raw);
3095                 return 0;
3096         }
3097
3098         return 0;
3099 }
3100
3101 static int wtp_get_config(struct hidpp_device *hidpp)
3102 {
3103         struct wtp_data *wd = hidpp->private_data;
3104         struct hidpp_touchpad_raw_info raw_info = {0};
3105         u8 feature_type;
3106         int ret;
3107
3108         ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
3109                 &wd->mt_feature_index, &feature_type);
3110         if (ret)
3111                 /* means that the device is not powered up */
3112                 return ret;
3113
3114         ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
3115                 &raw_info);
3116         if (ret)
3117                 return ret;
3118
3119         wd->x_size = raw_info.x_size;
3120         wd->y_size = raw_info.y_size;
3121         wd->maxcontacts = raw_info.maxcontacts;
3122         wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT;
3123         wd->resolution = raw_info.res;
3124         if (!wd->resolution)
3125                 wd->resolution = WTP_MANUAL_RESOLUTION;
3126
3127         return 0;
3128 }
3129
3130 static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id)
3131 {
3132         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3133         struct wtp_data *wd;
3134
3135         wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data),
3136                         GFP_KERNEL);
3137         if (!wd)
3138                 return -ENOMEM;
3139
3140         hidpp->private_data = wd;
3141
3142         return 0;
3143 };
3144
3145 static int wtp_connect(struct hid_device *hdev, bool connected)
3146 {
3147         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3148         struct wtp_data *wd = hidpp->private_data;
3149         int ret;
3150
3151         if (!wd->x_size) {
3152                 ret = wtp_get_config(hidpp);
3153                 if (ret) {
3154                         hid_err(hdev, "Can not get wtp config: %d\n", ret);
3155                         return ret;
3156                 }
3157         }
3158
3159         return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
3160                         true, true);
3161 }
3162
3163 /* ------------------------------------------------------------------------- */
3164 /* Logitech M560 devices                                                     */
3165 /* ------------------------------------------------------------------------- */
3166
3167 /*
3168  * Logitech M560 protocol overview
3169  *
3170  * The Logitech M560 mouse, is designed for windows 8. When the middle and/or
3171  * the sides buttons are pressed, it sends some keyboard keys events
3172  * instead of buttons ones.
3173  * To complicate things further, the middle button keys sequence
3174  * is different from the odd press and the even press.
3175  *
3176  * forward button -> Super_R
3177  * backward button -> Super_L+'d' (press only)
3178  * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only)
3179  *                  2nd time: left-click (press only)
3180  * NB: press-only means that when the button is pressed, the
3181  * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated
3182  * together sequentially; instead when the button is released, no event is
3183  * generated !
3184  *
3185  * With the command
3186  *      10<xx>0a 3500af03 (where <xx> is the mouse id),
3187  * the mouse reacts differently:
3188  * - it never sends a keyboard key event
3189  * - for the three mouse button it sends:
3190  *      middle button               press   11<xx>0a 3500af00...
3191  *      side 1 button (forward)     press   11<xx>0a 3500b000...
3192  *      side 2 button (backward)    press   11<xx>0a 3500ae00...
3193  *      middle/side1/side2 button   release 11<xx>0a 35000000...
3194  */
3195
3196 static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
3197
3198 /* how buttons are mapped in the report */
3199 #define M560_MOUSE_BTN_LEFT             0x01
3200 #define M560_MOUSE_BTN_RIGHT            0x02
3201 #define M560_MOUSE_BTN_WHEEL_LEFT       0x08
3202 #define M560_MOUSE_BTN_WHEEL_RIGHT      0x10
3203
3204 #define M560_SUB_ID                     0x0a
3205 #define M560_BUTTON_MODE_REGISTER       0x35
3206
3207 static int m560_send_config_command(struct hid_device *hdev, bool connected)
3208 {
3209         struct hidpp_report response;
3210         struct hidpp_device *hidpp_dev;
3211
3212         hidpp_dev = hid_get_drvdata(hdev);
3213
3214         return hidpp_send_rap_command_sync(
3215                 hidpp_dev,
3216                 REPORT_ID_HIDPP_SHORT,
3217                 M560_SUB_ID,
3218                 M560_BUTTON_MODE_REGISTER,
3219                 (u8 *)m560_config_parameter,
3220                 sizeof(m560_config_parameter),
3221                 &response
3222         );
3223 }
3224
3225 static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
3226 {
3227         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3228
3229         /* sanity check */
3230         if (!hidpp->input) {
3231                 hid_err(hdev, "error in parameter\n");
3232                 return -EINVAL;
3233         }
3234
3235         if (size < 7) {
3236                 hid_err(hdev, "error in report\n");
3237                 return 0;
3238         }
3239
3240         if (data[0] == REPORT_ID_HIDPP_LONG &&
3241             data[2] == M560_SUB_ID && data[6] == 0x00) {
3242                 /*
3243                  * m560 mouse report for middle, forward and backward button
3244                  *
3245                  * data[0] = 0x11
3246                  * data[1] = device-id
3247                  * data[2] = 0x0a
3248                  * data[5] = 0xaf -> middle
3249                  *           0xb0 -> forward
3250                  *           0xae -> backward
3251                  *           0x00 -> release all
3252                  * data[6] = 0x00
3253                  */
3254
3255                 switch (data[5]) {
3256                 case 0xaf:
3257                         input_report_key(hidpp->input, BTN_MIDDLE, 1);
3258                         break;
3259                 case 0xb0:
3260                         input_report_key(hidpp->input, BTN_FORWARD, 1);
3261                         break;
3262                 case 0xae:
3263                         input_report_key(hidpp->input, BTN_BACK, 1);
3264                         break;
3265                 case 0x00:
3266                         input_report_key(hidpp->input, BTN_BACK, 0);
3267                         input_report_key(hidpp->input, BTN_FORWARD, 0);
3268                         input_report_key(hidpp->input, BTN_MIDDLE, 0);
3269                         break;
3270                 default:
3271                         hid_err(hdev, "error in report\n");
3272                         return 0;
3273                 }
3274                 input_sync(hidpp->input);
3275
3276         } else if (data[0] == 0x02) {
3277                 /*
3278                  * Logitech M560 mouse report
3279                  *
3280                  * data[0] = type (0x02)
3281                  * data[1..2] = buttons
3282                  * data[3..5] = xy
3283                  * data[6] = wheel
3284                  */
3285
3286                 int v;
3287
3288                 input_report_key(hidpp->input, BTN_LEFT,
3289                         !!(data[1] & M560_MOUSE_BTN_LEFT));
3290                 input_report_key(hidpp->input, BTN_RIGHT,
3291                         !!(data[1] & M560_MOUSE_BTN_RIGHT));
3292
3293                 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
3294                         input_report_rel(hidpp->input, REL_HWHEEL, -1);
3295                         input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3296                                          -120);
3297                 } else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
3298                         input_report_rel(hidpp->input, REL_HWHEEL, 1);
3299                         input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3300                                          120);
3301                 }
3302
3303                 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
3304                 input_report_rel(hidpp->input, REL_X, v);
3305
3306                 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
3307                 input_report_rel(hidpp->input, REL_Y, v);
3308
3309                 v = hid_snto32(data[6], 8);
3310                 if (v != 0)
3311                         hidpp_scroll_counter_handle_scroll(hidpp->input,
3312                                         &hidpp->vertical_wheel_counter, v);
3313
3314                 input_sync(hidpp->input);
3315         }
3316
3317         return 1;
3318 }
3319
3320 static void m560_populate_input(struct hidpp_device *hidpp,
3321                                 struct input_dev *input_dev)
3322 {
3323         __set_bit(EV_KEY, input_dev->evbit);
3324         __set_bit(BTN_MIDDLE, input_dev->keybit);
3325         __set_bit(BTN_RIGHT, input_dev->keybit);
3326         __set_bit(BTN_LEFT, input_dev->keybit);
3327         __set_bit(BTN_BACK, input_dev->keybit);
3328         __set_bit(BTN_FORWARD, input_dev->keybit);
3329
3330         __set_bit(EV_REL, input_dev->evbit);
3331         __set_bit(REL_X, input_dev->relbit);
3332         __set_bit(REL_Y, input_dev->relbit);
3333         __set_bit(REL_WHEEL, input_dev->relbit);
3334         __set_bit(REL_HWHEEL, input_dev->relbit);
3335         __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3336         __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3337 }
3338
3339 static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3340                 struct hid_field *field, struct hid_usage *usage,
3341                 unsigned long **bit, int *max)
3342 {
3343         return -1;
3344 }
3345
3346 /* ------------------------------------------------------------------------- */
3347 /* Logitech K400 devices                                                     */
3348 /* ------------------------------------------------------------------------- */
3349
3350 /*
3351  * The Logitech K400 keyboard has an embedded touchpad which is seen
3352  * as a mouse from the OS point of view. There is a hardware shortcut to disable
3353  * tap-to-click but the setting is not remembered accross reset, annoying some
3354  * users.
3355  *
3356  * We can toggle this feature from the host by using the feature 0x6010:
3357  * Touchpad FW items
3358  */
3359
3360 struct k400_private_data {
3361         u8 feature_index;
3362 };
3363
3364 static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
3365 {
3366         struct k400_private_data *k400 = hidpp->private_data;
3367         struct hidpp_touchpad_fw_items items = {};
3368         int ret;
3369         u8 feature_type;
3370
3371         if (!k400->feature_index) {
3372                 ret = hidpp_root_get_feature(hidpp,
3373                         HIDPP_PAGE_TOUCHPAD_FW_ITEMS,
3374                         &k400->feature_index, &feature_type);
3375                 if (ret)
3376                         /* means that the device is not powered up */
3377                         return ret;
3378         }
3379
3380         ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
3381         if (ret)
3382                 return ret;
3383
3384         return 0;
3385 }
3386
3387 static int k400_allocate(struct hid_device *hdev)
3388 {
3389         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3390         struct k400_private_data *k400;
3391
3392         k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data),
3393                             GFP_KERNEL);
3394         if (!k400)
3395                 return -ENOMEM;
3396
3397         hidpp->private_data = k400;
3398
3399         return 0;
3400 };
3401
3402 static int k400_connect(struct hid_device *hdev, bool connected)
3403 {
3404         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3405
3406         if (!disable_tap_to_click)
3407                 return 0;
3408
3409         return k400_disable_tap_to_click(hidpp);
3410 }
3411
3412 /* ------------------------------------------------------------------------- */
3413 /* Logitech G920 Driving Force Racing Wheel for Xbox One                     */
3414 /* ------------------------------------------------------------------------- */
3415
3416 #define HIDPP_PAGE_G920_FORCE_FEEDBACK                  0x8123
3417
3418 static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
3419                                   struct hidpp_ff_private_data *data)
3420 {
3421         struct hidpp_report response;
3422         u8 params[HIDPP_AUTOCENTER_PARAMS_LENGTH] = {
3423                 [1] = HIDPP_FF_EFFECT_SPRING | HIDPP_FF_EFFECT_AUTOSTART,
3424         };
3425         int ret;
3426
3427         /* initialize with zero autocenter to get wheel in usable state */
3428
3429         dbg_hid("Setting autocenter to 0.\n");
3430         ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3431                                           HIDPP_FF_DOWNLOAD_EFFECT,
3432                                           params, ARRAY_SIZE(params),
3433                                           &response);
3434         if (ret)
3435                 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
3436         else
3437                 data->slot_autocenter = response.fap.params[0];
3438
3439         return ret;
3440 }
3441
3442 static int g920_get_config(struct hidpp_device *hidpp,
3443                            struct hidpp_ff_private_data *data)
3444 {
3445         struct hidpp_report response;
3446         u8 feature_type;
3447         int ret;
3448
3449         memset(data, 0, sizeof(*data));
3450
3451         /* Find feature and store for later use */
3452         ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
3453                                      &data->feature_index, &feature_type);
3454         if (ret)
3455                 return ret;
3456
3457         /* Read number of slots available in device */
3458         ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3459                                           HIDPP_FF_GET_INFO,
3460                                           NULL, 0,
3461                                           &response);
3462         if (ret) {
3463                 if (ret < 0)
3464                         return ret;
3465                 hid_err(hidpp->hid_dev,
3466                         "%s: received protocol error 0x%02x\n", __func__, ret);
3467                 return -EPROTO;
3468         }
3469
3470         data->num_effects = response.fap.params[0] - HIDPP_FF_RESERVED_SLOTS;
3471
3472         /* reset all forces */
3473         ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3474                                           HIDPP_FF_RESET_ALL,
3475                                           NULL, 0,
3476                                           &response);
3477         if (ret)
3478                 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
3479
3480         ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3481                                           HIDPP_FF_GET_APERTURE,
3482                                           NULL, 0,
3483                                           &response);
3484         if (ret) {
3485                 hid_warn(hidpp->hid_dev,
3486                          "Failed to read range from device!\n");
3487         }
3488         data->range = ret ?
3489                 900 : get_unaligned_be16(&response.fap.params[0]);
3490
3491         /* Read the current gain values */
3492         ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3493                                           HIDPP_FF_GET_GLOBAL_GAINS,
3494                                           NULL, 0,
3495                                           &response);
3496         if (ret)
3497                 hid_warn(hidpp->hid_dev,
3498                          "Failed to read gain values from device!\n");
3499         data->gain = ret ?
3500                 0xffff : get_unaligned_be16(&response.fap.params[0]);
3501
3502         /* ignore boost value at response.fap.params[2] */
3503
3504         return g920_ff_set_autocenter(hidpp, data);
3505 }
3506
3507 /* -------------------------------------------------------------------------- */
3508 /* Logitech Dinovo Mini keyboard with builtin touchpad                        */
3509 /* -------------------------------------------------------------------------- */
3510 #define DINOVO_MINI_PRODUCT_ID          0xb30c
3511
3512 static int lg_dinovo_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3513                 struct hid_field *field, struct hid_usage *usage,
3514                 unsigned long **bit, int *max)
3515 {
3516         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
3517                 return 0;
3518
3519         switch (usage->hid & HID_USAGE) {
3520         case 0x00d: lg_map_key_clear(KEY_MEDIA);        break;
3521         default:
3522                 return 0;
3523         }
3524         return 1;
3525 }
3526
3527 /* -------------------------------------------------------------------------- */
3528 /* HID++1.0 devices which use HID++ reports for their wheels                  */
3529 /* -------------------------------------------------------------------------- */
3530 static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
3531 {
3532         return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3533                         HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT,
3534                         HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT);
3535 }
3536
3537 static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
3538                                    u8 *data, int size)
3539 {
3540         s8 value, hvalue;
3541
3542         if (!hidpp->input)
3543                 return -EINVAL;
3544
3545         if (size < 7)
3546                 return 0;
3547
3548         if (data[0] != REPORT_ID_HIDPP_SHORT || data[2] != HIDPP_SUB_ID_ROLLER)
3549                 return 0;
3550
3551         value = data[3];
3552         hvalue = data[4];
3553
3554         input_report_rel(hidpp->input, REL_WHEEL, value);
3555         input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
3556         input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
3557         input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
3558         input_sync(hidpp->input);
3559
3560         return 1;
3561 }
3562
3563 static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
3564                                          struct input_dev *input_dev)
3565 {
3566         __set_bit(EV_REL, input_dev->evbit);
3567         __set_bit(REL_WHEEL, input_dev->relbit);
3568         __set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
3569         __set_bit(REL_HWHEEL, input_dev->relbit);
3570         __set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
3571 }
3572
3573 /* -------------------------------------------------------------------------- */
3574 /* HID++1.0 mice which use HID++ reports for extra mouse buttons              */
3575 /* -------------------------------------------------------------------------- */
3576 static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3577 {
3578         return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3579                                     HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
3580                                     HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
3581 }
3582
3583 static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3584                                     u8 *data, int size)
3585 {
3586         int i;
3587
3588         if (!hidpp->input)
3589                 return -EINVAL;
3590
3591         if (size < 7)
3592                 return 0;
3593
3594         if (data[0] != REPORT_ID_HIDPP_SHORT ||
3595             data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
3596                 return 0;
3597
3598         /*
3599          * Buttons are either delivered through the regular mouse report *or*
3600          * through the extra buttons report. At least for button 6 how it is
3601          * delivered differs per receiver firmware version. Even receivers with
3602          * the same usb-id show different behavior, so we handle both cases.
3603          */
3604         for (i = 0; i < 8; i++)
3605                 input_report_key(hidpp->input, BTN_MOUSE + i,
3606                                  (data[3] & (1 << i)));
3607
3608         /* Some mice report events on button 9+, use BTN_MISC */
3609         for (i = 0; i < 8; i++)
3610                 input_report_key(hidpp->input, BTN_MISC + i,
3611                                  (data[4] & (1 << i)));
3612
3613         input_sync(hidpp->input);
3614         return 1;
3615 }
3616
3617 static void hidpp10_extra_mouse_buttons_populate_input(
3618                         struct hidpp_device *hidpp, struct input_dev *input_dev)
3619 {
3620         /* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
3621         __set_bit(BTN_0, input_dev->keybit);
3622         __set_bit(BTN_1, input_dev->keybit);
3623         __set_bit(BTN_2, input_dev->keybit);
3624         __set_bit(BTN_3, input_dev->keybit);
3625         __set_bit(BTN_4, input_dev->keybit);
3626         __set_bit(BTN_5, input_dev->keybit);
3627         __set_bit(BTN_6, input_dev->keybit);
3628         __set_bit(BTN_7, input_dev->keybit);
3629 }
3630
3631 /* -------------------------------------------------------------------------- */
3632 /* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
3633 /* -------------------------------------------------------------------------- */
3634
3635 /* Find the consumer-page input report desc and change Maximums to 0x107f */
3636 static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3637                                               u8 *_rdesc, unsigned int *rsize)
3638 {
3639         /* Note 0 terminated so we can use strnstr to search for this. */
3640         static const char consumer_rdesc_start[] = {
3641                 0x05, 0x0C,     /* USAGE_PAGE (Consumer Devices)       */
3642                 0x09, 0x01,     /* USAGE (Consumer Control)            */
3643                 0xA1, 0x01,     /* COLLECTION (Application)            */
3644                 0x85, 0x03,     /* REPORT_ID = 3                       */
3645                 0x75, 0x10,     /* REPORT_SIZE (16)                    */
3646                 0x95, 0x02,     /* REPORT_COUNT (2)                    */
3647                 0x15, 0x01,     /* LOGICAL_MIN (1)                     */
3648                 0x26, 0x00      /* LOGICAL_MAX (...                    */
3649         };
3650         char *consumer_rdesc, *rdesc = (char *)_rdesc;
3651         unsigned int size;
3652
3653         consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
3654         size = *rsize - (consumer_rdesc - rdesc);
3655         if (consumer_rdesc && size >= 25) {
3656                 consumer_rdesc[15] = 0x7f;
3657                 consumer_rdesc[16] = 0x10;
3658                 consumer_rdesc[20] = 0x7f;
3659                 consumer_rdesc[21] = 0x10;
3660         }
3661         return _rdesc;
3662 }
3663
3664 static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3665 {
3666         return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3667                                     HIDPP_ENABLE_CONSUMER_REPORT,
3668                                     HIDPP_ENABLE_CONSUMER_REPORT);
3669 }
3670
3671 static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3672                                            u8 *data, int size)
3673 {
3674         u8 consumer_report[5];
3675
3676         if (size < 7)
3677                 return 0;
3678
3679         if (data[0] != REPORT_ID_HIDPP_SHORT ||
3680             data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
3681                 return 0;
3682
3683         /*
3684          * Build a normal consumer report (3) out of the data, this detour
3685          * is necessary to get some keyboards to report their 0x10xx usages.
3686          */
3687         consumer_report[0] = 0x03;
3688         memcpy(&consumer_report[1], &data[3], 4);
3689         /* We are called from atomic context */
3690         hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3691                              consumer_report, 5, 1);
3692
3693         return 1;
3694 }
3695
3696 /* -------------------------------------------------------------------------- */
3697 /* High-resolution scroll wheels                                              */
3698 /* -------------------------------------------------------------------------- */
3699
3700 static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3701 {
3702         int ret;
3703         u8 multiplier = 1;
3704
3705         if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL) {
3706                 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3707                 if (ret == 0)
3708                         ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3709         } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL) {
3710                 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3711                                                            &multiplier);
3712         } else /* if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL) */ {
3713                 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3714                 multiplier = 8;
3715         }
3716         if (ret) {
3717                 hid_dbg(hidpp->hid_dev,
3718                         "Could not enable hi-res scrolling: %d\n", ret);
3719                 return ret;
3720         }
3721
3722         if (multiplier == 0) {
3723                 hid_dbg(hidpp->hid_dev,
3724                         "Invalid multiplier 0 from device, setting it to 1\n");
3725                 multiplier = 1;
3726         }
3727
3728         hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3729         hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3730         return 0;
3731 }
3732
3733 static int hidpp_initialize_hires_scroll(struct hidpp_device *hidpp)
3734 {
3735         int ret;
3736         unsigned long capabilities;
3737
3738         capabilities = hidpp->capabilities;
3739
3740         if (hidpp->protocol_major >= 2) {
3741                 u8 feature_index;
3742                 u8 feature_type;
3743
3744                 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
3745                                              &feature_index, &feature_type);
3746                 if (!ret) {
3747                         hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL;
3748                         hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scroll wheel\n");
3749                         return 0;
3750                 }
3751                 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
3752                                              &feature_index, &feature_type);
3753                 if (!ret) {
3754                         hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL;
3755                         hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scrolling\n");
3756                 }
3757         } else {
3758                 /* We cannot detect fast scrolling support on HID++ 1.0 devices */
3759                 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) {
3760                         hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL;
3761                         hid_dbg(hidpp->hid_dev, "Detected HID++ 1.0 fast scroll\n");
3762                 }
3763         }
3764
3765         if (hidpp->capabilities == capabilities)
3766                 hid_dbg(hidpp->hid_dev, "Did not detect HID++ hi-res scrolling hardware support\n");
3767         return 0;
3768 }
3769
3770 /* -------------------------------------------------------------------------- */
3771 /* Generic HID++ devices                                                      */
3772 /* -------------------------------------------------------------------------- */
3773
3774 static u8 *hidpp_report_fixup(struct hid_device *hdev, u8 *rdesc,
3775                               unsigned int *rsize)
3776 {
3777         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3778
3779         if (!hidpp)
3780                 return rdesc;
3781
3782         /* For 27 MHz keyboards the quirk gets set after hid_parse. */
3783         if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE ||
3784             (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3785                 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3786
3787         return rdesc;
3788 }
3789
3790 static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
3791                 struct hid_field *field, struct hid_usage *usage,
3792                 unsigned long **bit, int *max)
3793 {
3794         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3795
3796         if (!hidpp)
3797                 return 0;
3798
3799         if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3800                 return wtp_input_mapping(hdev, hi, field, usage, bit, max);
3801         else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3802                         field->application != HID_GD_MOUSE)
3803                 return m560_input_mapping(hdev, hi, field, usage, bit, max);
3804
3805         if (hdev->product == DINOVO_MINI_PRODUCT_ID)
3806                 return lg_dinovo_input_mapping(hdev, hi, field, usage, bit, max);
3807
3808         return 0;
3809 }
3810
3811 static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
3812                 struct hid_field *field, struct hid_usage *usage,
3813                 unsigned long **bit, int *max)
3814 {
3815         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3816
3817         if (!hidpp)
3818                 return 0;
3819
3820         /* Ensure that Logitech G920 is not given a default fuzz/flat value */
3821         if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3822                 if (usage->type == EV_ABS && (usage->code == ABS_X ||
3823                                 usage->code == ABS_Y || usage->code == ABS_Z ||
3824                                 usage->code == ABS_RZ)) {
3825                         field->application = HID_GD_MULTIAXIS;
3826                 }
3827         }
3828
3829         return 0;
3830 }
3831
3832
3833 static void hidpp_populate_input(struct hidpp_device *hidpp,
3834                                  struct input_dev *input)
3835 {
3836         hidpp->input = input;
3837
3838         if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3839                 wtp_populate_input(hidpp, input);
3840         else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3841                 m560_populate_input(hidpp, input);
3842
3843         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3844                 hidpp10_wheel_populate_input(hidpp, input);
3845
3846         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3847                 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3848 }
3849
3850 static int hidpp_input_configured(struct hid_device *hdev,
3851                                 struct hid_input *hidinput)
3852 {
3853         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3854         struct input_dev *input = hidinput->input;
3855
3856         if (!hidpp)
3857                 return 0;
3858
3859         hidpp_populate_input(hidpp, input);
3860
3861         return 0;
3862 }
3863
3864 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3865                 int size)
3866 {
3867         struct hidpp_report *question = hidpp->send_receive_buf;
3868         struct hidpp_report *answer = hidpp->send_receive_buf;
3869         struct hidpp_report *report = (struct hidpp_report *)data;
3870         int ret;
3871
3872         /*
3873          * If the mutex is locked then we have a pending answer from a
3874          * previously sent command.
3875          */
3876         if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3877                 /*
3878                  * Check for a correct hidpp20 answer or the corresponding
3879                  * error
3880                  */
3881                 if (hidpp_match_answer(question, report) ||
3882                                 hidpp_match_error(question, report)) {
3883                         *answer = *report;
3884                         hidpp->answer_available = true;
3885                         wake_up(&hidpp->wait);
3886                         /*
3887                          * This was an answer to a command that this driver sent
3888                          * We return 1 to hid-core to avoid forwarding the
3889                          * command upstream as it has been treated by the driver
3890                          */
3891
3892                         return 1;
3893                 }
3894         }
3895
3896         if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3897                 atomic_set(&hidpp->connected,
3898                                 !(report->rap.params[0] & (1 << 6)));
3899                 if (schedule_work(&hidpp->work) == 0)
3900                         dbg_hid("%s: connect event already queued\n", __func__);
3901                 return 1;
3902         }
3903
3904         if (hidpp->hid_dev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3905             data[0] == REPORT_ID_HIDPP_SHORT &&
3906             data[2] == HIDPP_SUB_ID_USER_IFACE_EVENT &&
3907             (data[3] & HIDPP_USER_IFACE_EVENT_ENCRYPTION_KEY_LOST)) {
3908                 dev_err_ratelimited(&hidpp->hid_dev->dev,
3909                         "Error the keyboard's wireless encryption key has been lost, your keyboard will not work unless you re-configure encryption.\n");
3910                 dev_err_ratelimited(&hidpp->hid_dev->dev,
3911                         "See: https://gitlab.freedesktop.org/jwrdegoede/logitech-27mhz-keyboard-encryption-setup/\n");
3912         }
3913
3914         if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3915                 ret = hidpp20_battery_event_1000(hidpp, data, size);
3916                 if (ret != 0)
3917                         return ret;
3918                 ret = hidpp20_battery_event_1004(hidpp, data, size);
3919                 if (ret != 0)
3920                         return ret;
3921                 ret = hidpp_solar_battery_event(hidpp, data, size);
3922                 if (ret != 0)
3923                         return ret;
3924                 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3925                 if (ret != 0)
3926                         return ret;
3927                 ret = hidpp20_adc_measurement_event_1f20(hidpp, data, size);
3928                 if (ret != 0)
3929                         return ret;
3930         }
3931
3932         if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3933                 ret = hidpp10_battery_event(hidpp, data, size);
3934                 if (ret != 0)
3935                         return ret;
3936         }
3937
3938         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3939                 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3940                 if (ret != 0)
3941                         return ret;
3942         }
3943
3944         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3945                 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3946                 if (ret != 0)
3947                         return ret;
3948         }
3949
3950         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3951                 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3952                 if (ret != 0)
3953                         return ret;
3954         }
3955
3956         return 0;
3957 }
3958
3959 static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
3960                 u8 *data, int size)
3961 {
3962         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3963         int ret = 0;
3964
3965         if (!hidpp)
3966                 return 0;
3967
3968         /* Generic HID++ processing. */
3969         switch (data[0]) {
3970         case REPORT_ID_HIDPP_VERY_LONG:
3971                 if (size != hidpp->very_long_report_length) {
3972                         hid_err(hdev, "received hid++ report of bad size (%d)",
3973                                 size);
3974                         return 1;
3975                 }
3976                 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3977                 break;
3978         case REPORT_ID_HIDPP_LONG:
3979                 if (size != HIDPP_REPORT_LONG_LENGTH) {
3980                         hid_err(hdev, "received hid++ report of bad size (%d)",
3981                                 size);
3982                         return 1;
3983                 }
3984                 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3985                 break;
3986         case REPORT_ID_HIDPP_SHORT:
3987                 if (size != HIDPP_REPORT_SHORT_LENGTH) {
3988                         hid_err(hdev, "received hid++ report of bad size (%d)",
3989                                 size);
3990                         return 1;
3991                 }
3992                 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3993                 break;
3994         }
3995
3996         /* If no report is available for further processing, skip calling
3997          * raw_event of subclasses. */
3998         if (ret != 0)
3999                 return ret;
4000
4001         if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
4002                 return wtp_raw_event(hdev, data, size);
4003         else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
4004                 return m560_raw_event(hdev, data, size);
4005
4006         return 0;
4007 }
4008
4009 static int hidpp_event(struct hid_device *hdev, struct hid_field *field,
4010         struct hid_usage *usage, __s32 value)
4011 {
4012         /* This function will only be called for scroll events, due to the
4013          * restriction imposed in hidpp_usages.
4014          */
4015         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4016         struct hidpp_scroll_counter *counter;
4017
4018         if (!hidpp)
4019                 return 0;
4020
4021         counter = &hidpp->vertical_wheel_counter;
4022         /* A scroll event may occur before the multiplier has been retrieved or
4023          * the input device set, or high-res scroll enabling may fail. In such
4024          * cases we must return early (falling back to default behaviour) to
4025          * avoid a crash in hidpp_scroll_counter_handle_scroll.
4026          */
4027         if (!(hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4028             || value == 0 || hidpp->input == NULL
4029             || counter->wheel_multiplier == 0)
4030                 return 0;
4031
4032         hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
4033         return 1;
4034 }
4035
4036 static int hidpp_initialize_battery(struct hidpp_device *hidpp)
4037 {
4038         static atomic_t battery_no = ATOMIC_INIT(0);
4039         struct power_supply_config cfg = { .drv_data = hidpp };
4040         struct power_supply_desc *desc = &hidpp->battery.desc;
4041         enum power_supply_property *battery_props;
4042         struct hidpp_battery *battery;
4043         unsigned int num_battery_props;
4044         unsigned long n;
4045         int ret;
4046
4047         if (hidpp->battery.ps)
4048                 return 0;
4049
4050         hidpp->battery.feature_index = 0xff;
4051         hidpp->battery.solar_feature_index = 0xff;
4052         hidpp->battery.voltage_feature_index = 0xff;
4053         hidpp->battery.adc_measurement_feature_index = 0xff;
4054
4055         if (hidpp->protocol_major >= 2) {
4056                 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
4057                         ret = hidpp_solar_request_battery_event(hidpp);
4058                 else {
4059                         /* we only support one battery feature right now, so let's
4060                            first check the ones that support battery level first
4061                            and leave voltage for last */
4062                         ret = hidpp20_query_battery_info_1000(hidpp);
4063                         if (ret)
4064                                 ret = hidpp20_query_battery_info_1004(hidpp);
4065                         if (ret)
4066                                 ret = hidpp20_query_battery_voltage_info(hidpp);
4067                         if (ret)
4068                                 ret = hidpp20_query_adc_measurement_info_1f20(hidpp);
4069                 }
4070
4071                 if (ret)
4072                         return ret;
4073                 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
4074         } else {
4075                 ret = hidpp10_query_battery_status(hidpp);
4076                 if (ret) {
4077                         ret = hidpp10_query_battery_mileage(hidpp);
4078                         if (ret)
4079                                 return -ENOENT;
4080                         hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
4081                 } else {
4082                         hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
4083                 }
4084                 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
4085         }
4086
4087         battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
4088                                      hidpp_battery_props,
4089                                      sizeof(hidpp_battery_props),
4090                                      GFP_KERNEL);
4091         if (!battery_props)
4092                 return -ENOMEM;
4093
4094         num_battery_props = ARRAY_SIZE(hidpp_battery_props) - 3;
4095
4096         if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE ||
4097             hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE ||
4098             hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4099             hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4100                 battery_props[num_battery_props++] =
4101                                 POWER_SUPPLY_PROP_CAPACITY;
4102
4103         if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
4104                 battery_props[num_battery_props++] =
4105                                 POWER_SUPPLY_PROP_CAPACITY_LEVEL;
4106
4107         if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4108             hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4109                 battery_props[num_battery_props++] =
4110                         POWER_SUPPLY_PROP_VOLTAGE_NOW;
4111
4112         battery = &hidpp->battery;
4113
4114         n = atomic_inc_return(&battery_no) - 1;
4115         desc->properties = battery_props;
4116         desc->num_properties = num_battery_props;
4117         desc->get_property = hidpp_battery_get_property;
4118         sprintf(battery->name, "hidpp_battery_%ld", n);
4119         desc->name = battery->name;
4120         desc->type = POWER_SUPPLY_TYPE_BATTERY;
4121         desc->use_for_apm = 0;
4122
4123         battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
4124                                                  &battery->desc,
4125                                                  &cfg);
4126         if (IS_ERR(battery->ps))
4127                 return PTR_ERR(battery->ps);
4128
4129         power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
4130
4131         return ret;
4132 }
4133
4134 static void hidpp_overwrite_name(struct hid_device *hdev)
4135 {
4136         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4137         char *name;
4138
4139         if (hidpp->protocol_major < 2)
4140                 return;
4141
4142         name = hidpp_get_device_name(hidpp);
4143
4144         if (!name) {
4145                 hid_err(hdev, "unable to retrieve the name of the device");
4146         } else {
4147                 dbg_hid("HID++: Got name: %s\n", name);
4148                 snprintf(hdev->name, sizeof(hdev->name), "%s", name);
4149         }
4150
4151         kfree(name);
4152 }
4153
4154 static int hidpp_input_open(struct input_dev *dev)
4155 {
4156         struct hid_device *hid = input_get_drvdata(dev);
4157
4158         return hid_hw_open(hid);
4159 }
4160
4161 static void hidpp_input_close(struct input_dev *dev)
4162 {
4163         struct hid_device *hid = input_get_drvdata(dev);
4164
4165         hid_hw_close(hid);
4166 }
4167
4168 static struct input_dev *hidpp_allocate_input(struct hid_device *hdev)
4169 {
4170         struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev);
4171         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4172
4173         if (!input_dev)
4174                 return NULL;
4175
4176         input_set_drvdata(input_dev, hdev);
4177         input_dev->open = hidpp_input_open;
4178         input_dev->close = hidpp_input_close;
4179
4180         input_dev->name = hidpp->name;
4181         input_dev->phys = hdev->phys;
4182         input_dev->uniq = hdev->uniq;
4183         input_dev->id.bustype = hdev->bus;
4184         input_dev->id.vendor  = hdev->vendor;
4185         input_dev->id.product = hdev->product;
4186         input_dev->id.version = hdev->version;
4187         input_dev->dev.parent = &hdev->dev;
4188
4189         return input_dev;
4190 }
4191
4192 static void hidpp_connect_event(struct hidpp_device *hidpp)
4193 {
4194         struct hid_device *hdev = hidpp->hid_dev;
4195         int ret = 0;
4196         bool connected = atomic_read(&hidpp->connected);
4197         struct input_dev *input;
4198         char *name, *devm_name;
4199
4200         if (!connected) {
4201                 if (hidpp->battery.ps) {
4202                         hidpp->battery.online = false;
4203                         hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
4204                         hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
4205                         power_supply_changed(hidpp->battery.ps);
4206                 }
4207                 return;
4208         }
4209
4210         if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4211                 ret = wtp_connect(hdev, connected);
4212                 if (ret)
4213                         return;
4214         } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
4215                 ret = m560_send_config_command(hdev, connected);
4216                 if (ret)
4217                         return;
4218         } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4219                 ret = k400_connect(hdev, connected);
4220                 if (ret)
4221                         return;
4222         }
4223
4224         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
4225                 ret = hidpp10_wheel_connect(hidpp);
4226                 if (ret)
4227                         return;
4228         }
4229
4230         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
4231                 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
4232                 if (ret)
4233                         return;
4234         }
4235
4236         if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
4237                 ret = hidpp10_consumer_keys_connect(hidpp);
4238                 if (ret)
4239                         return;
4240         }
4241
4242         /* the device is already connected, we can ask for its name and
4243          * protocol */
4244         if (!hidpp->protocol_major) {
4245                 ret = hidpp_root_get_protocol_version(hidpp);
4246                 if (ret) {
4247                         hid_err(hdev, "Can not get the protocol version.\n");
4248                         return;
4249                 }
4250         }
4251
4252         if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
4253                 name = hidpp_get_device_name(hidpp);
4254                 if (name) {
4255                         devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
4256                                                    "%s", name);
4257                         kfree(name);
4258                         if (!devm_name)
4259                                 return;
4260
4261                         hidpp->name = devm_name;
4262                 }
4263         }
4264
4265         hidpp_initialize_battery(hidpp);
4266         if (!hid_is_usb(hidpp->hid_dev))
4267                 hidpp_initialize_hires_scroll(hidpp);
4268
4269         /* forward current battery state */
4270         if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
4271                 hidpp10_enable_battery_reporting(hidpp);
4272                 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
4273                         hidpp10_query_battery_mileage(hidpp);
4274                 else
4275                         hidpp10_query_battery_status(hidpp);
4276         } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
4277                 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
4278                         hidpp20_query_battery_voltage_info(hidpp);
4279                 else if (hidpp->capabilities & HIDPP_CAPABILITY_UNIFIED_BATTERY)
4280                         hidpp20_query_battery_info_1004(hidpp);
4281                 else if (hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4282                         hidpp20_query_adc_measurement_info_1f20(hidpp);
4283                 else
4284                         hidpp20_query_battery_info_1000(hidpp);
4285         }
4286         if (hidpp->battery.ps)
4287                 power_supply_changed(hidpp->battery.ps);
4288
4289         if (hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4290                 hi_res_scroll_enable(hidpp);
4291
4292         if (!(hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) || hidpp->delayed_input)
4293                 /* if the input nodes are already created, we can stop now */
4294                 return;
4295
4296         input = hidpp_allocate_input(hdev);
4297         if (!input) {
4298                 hid_err(hdev, "cannot allocate new input device: %d\n", ret);
4299                 return;
4300         }
4301
4302         hidpp_populate_input(hidpp, input);
4303
4304         ret = input_register_device(input);
4305         if (ret) {
4306                 input_free_device(input);
4307                 return;
4308         }
4309
4310         hidpp->delayed_input = input;
4311 }
4312
4313 static DEVICE_ATTR(builtin_power_supply, 0000, NULL, NULL);
4314
4315 static struct attribute *sysfs_attrs[] = {
4316         &dev_attr_builtin_power_supply.attr,
4317         NULL
4318 };
4319
4320 static const struct attribute_group ps_attribute_group = {
4321         .attrs = sysfs_attrs
4322 };
4323
4324 static int hidpp_get_report_length(struct hid_device *hdev, int id)
4325 {
4326         struct hid_report_enum *re;
4327         struct hid_report *report;
4328
4329         re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
4330         report = re->report_id_hash[id];
4331         if (!report)
4332                 return 0;
4333
4334         return report->field[0]->report_count + 1;
4335 }
4336
4337 static u8 hidpp_validate_device(struct hid_device *hdev)
4338 {
4339         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4340         int id, report_length;
4341         u8 supported_reports = 0;
4342
4343         id = REPORT_ID_HIDPP_SHORT;
4344         report_length = hidpp_get_report_length(hdev, id);
4345         if (report_length) {
4346                 if (report_length < HIDPP_REPORT_SHORT_LENGTH)
4347                         goto bad_device;
4348
4349                 supported_reports |= HIDPP_REPORT_SHORT_SUPPORTED;
4350         }
4351
4352         id = REPORT_ID_HIDPP_LONG;
4353         report_length = hidpp_get_report_length(hdev, id);
4354         if (report_length) {
4355                 if (report_length < HIDPP_REPORT_LONG_LENGTH)
4356                         goto bad_device;
4357
4358                 supported_reports |= HIDPP_REPORT_LONG_SUPPORTED;
4359         }
4360
4361         id = REPORT_ID_HIDPP_VERY_LONG;
4362         report_length = hidpp_get_report_length(hdev, id);
4363         if (report_length) {
4364                 if (report_length < HIDPP_REPORT_LONG_LENGTH ||
4365                     report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
4366                         goto bad_device;
4367
4368                 supported_reports |= HIDPP_REPORT_VERY_LONG_SUPPORTED;
4369                 hidpp->very_long_report_length = report_length;
4370         }
4371
4372         return supported_reports;
4373
4374 bad_device:
4375         hid_warn(hdev, "not enough values in hidpp report %d\n", id);
4376         return false;
4377 }
4378
4379 static bool hidpp_application_equals(struct hid_device *hdev,
4380                                      unsigned int application)
4381 {
4382         struct list_head *report_list;
4383         struct hid_report *report;
4384
4385         report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
4386         report = list_first_entry_or_null(report_list, struct hid_report, list);
4387         return report && report->application == application;
4388 }
4389
4390 static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
4391 {
4392         struct hidpp_device *hidpp;
4393         int ret;
4394         bool connected;
4395         unsigned int connect_mask = HID_CONNECT_DEFAULT;
4396         struct hidpp_ff_private_data data;
4397         bool will_restart = false;
4398
4399         /* report_fixup needs drvdata to be set before we call hid_parse */
4400         hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
4401         if (!hidpp)
4402                 return -ENOMEM;
4403
4404         hidpp->hid_dev = hdev;
4405         hidpp->name = hdev->name;
4406         hidpp->quirks = id->driver_data;
4407         hid_set_drvdata(hdev, hidpp);
4408
4409         ret = hid_parse(hdev);
4410         if (ret) {
4411                 hid_err(hdev, "%s:parse failed\n", __func__);
4412                 return ret;
4413         }
4414
4415         /*
4416          * Make sure the device is HID++ capable, otherwise treat as generic HID
4417          */
4418         hidpp->supported_reports = hidpp_validate_device(hdev);
4419
4420         if (!hidpp->supported_reports) {
4421                 hid_set_drvdata(hdev, NULL);
4422                 devm_kfree(&hdev->dev, hidpp);
4423                 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
4424         }
4425
4426         if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
4427                 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
4428
4429         if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4430             hidpp_application_equals(hdev, HID_GD_MOUSE))
4431                 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
4432                                  HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
4433
4434         if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
4435             hidpp_application_equals(hdev, HID_GD_KEYBOARD))
4436                 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
4437
4438         if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4439                 ret = wtp_allocate(hdev, id);
4440                 if (ret)
4441                         return ret;
4442         } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4443                 ret = k400_allocate(hdev);
4444                 if (ret)
4445                         return ret;
4446         }
4447
4448         if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT ||
4449             hidpp->quirks & HIDPP_QUIRK_UNIFYING)
4450                 will_restart = true;
4451
4452         INIT_WORK(&hidpp->work, delayed_work_cb);
4453         mutex_init(&hidpp->send_mutex);
4454         init_waitqueue_head(&hidpp->wait);
4455
4456         /* indicates we are handling the battery properties in the kernel */
4457         ret = sysfs_create_group(&hdev->dev.kobj, &ps_attribute_group);
4458         if (ret)
4459                 hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
4460                          hdev->name);
4461
4462         /*
4463          * Plain USB connections need to actually call start and open
4464          * on the transport driver to allow incoming data.
4465          */
4466         ret = hid_hw_start(hdev, will_restart ? 0 : connect_mask);
4467         if (ret) {
4468                 hid_err(hdev, "hw start failed\n");
4469                 goto hid_hw_start_fail;
4470         }
4471
4472         ret = hid_hw_open(hdev);
4473         if (ret < 0) {
4474                 dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
4475                         __func__, ret);
4476                 goto hid_hw_open_fail;
4477         }
4478
4479         /* Allow incoming packets */
4480         hid_device_io_start(hdev);
4481
4482         if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
4483                 hidpp_unifying_init(hidpp);
4484         else if (hid_is_usb(hidpp->hid_dev))
4485                 hidpp_serial_init(hidpp);
4486
4487         connected = hidpp_root_get_protocol_version(hidpp) == 0;
4488         atomic_set(&hidpp->connected, connected);
4489         if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
4490                 if (!connected) {
4491                         ret = -ENODEV;
4492                         hid_err(hdev, "Device not connected");
4493                         goto hid_hw_init_fail;
4494                 }
4495
4496                 hidpp_overwrite_name(hdev);
4497         }
4498
4499         if (connected && hidpp->protocol_major >= 2) {
4500                 ret = hidpp_set_wireless_feature_index(hidpp);
4501                 if (ret == -ENOENT)
4502                         hidpp->wireless_feature_index = 0;
4503                 else if (ret)
4504                         goto hid_hw_init_fail;
4505                 ret = 0;
4506         }
4507
4508         if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
4509                 ret = wtp_get_config(hidpp);
4510                 if (ret)
4511                         goto hid_hw_init_fail;
4512         } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
4513                 ret = g920_get_config(hidpp, &data);
4514                 if (ret)
4515                         goto hid_hw_init_fail;
4516         }
4517
4518         schedule_work(&hidpp->work);
4519         flush_work(&hidpp->work);
4520
4521         if (will_restart) {
4522                 /* Reset the HID node state */
4523                 hid_device_io_stop(hdev);
4524                 hid_hw_close(hdev);
4525                 hid_hw_stop(hdev);
4526
4527                 if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT)
4528                         connect_mask &= ~HID_CONNECT_HIDINPUT;
4529
4530                 /* Now export the actual inputs and hidraw nodes to the world */
4531                 ret = hid_hw_start(hdev, connect_mask);
4532                 if (ret) {
4533                         hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
4534                         goto hid_hw_start_fail;
4535                 }
4536         }
4537
4538         if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
4539                 ret = hidpp_ff_init(hidpp, &data);
4540                 if (ret)
4541                         hid_warn(hidpp->hid_dev,
4542                      "Unable to initialize force feedback support, errno %d\n",
4543                                  ret);
4544         }
4545
4546         return ret;
4547
4548 hid_hw_init_fail:
4549         hid_hw_close(hdev);
4550 hid_hw_open_fail:
4551         hid_hw_stop(hdev);
4552 hid_hw_start_fail:
4553         sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4554         cancel_work_sync(&hidpp->work);
4555         mutex_destroy(&hidpp->send_mutex);
4556         return ret;
4557 }
4558
4559 static void hidpp_remove(struct hid_device *hdev)
4560 {
4561         struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4562
4563         if (!hidpp)
4564                 return hid_hw_stop(hdev);
4565
4566         sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
4567
4568         hid_hw_stop(hdev);
4569         cancel_work_sync(&hidpp->work);
4570         mutex_destroy(&hidpp->send_mutex);
4571 }
4572
4573 #define LDJ_DEVICE(product) \
4574         HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
4575                    USB_VENDOR_ID_LOGITECH, (product))
4576
4577 #define L27MHZ_DEVICE(product) \
4578         HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
4579                    USB_VENDOR_ID_LOGITECH, (product))
4580
4581 static const struct hid_device_id hidpp_devices[] = {
4582         { /* wireless touchpad */
4583           LDJ_DEVICE(0x4011),
4584           .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT |
4585                          HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS },
4586         { /* wireless touchpad T650 */
4587           LDJ_DEVICE(0x4101),
4588           .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
4589         { /* wireless touchpad T651 */
4590           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
4591                 USB_DEVICE_ID_LOGITECH_T651),
4592           .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT },
4593         { /* Mouse Logitech Anywhere MX */
4594           LDJ_DEVICE(0x1017), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4595         { /* Mouse logitech M560 */
4596           LDJ_DEVICE(0x402d),
4597           .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 },
4598         { /* Mouse Logitech M705 (firmware RQM17) */
4599           LDJ_DEVICE(0x101b), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4600         { /* Mouse Logitech Performance MX */
4601           LDJ_DEVICE(0x101a), .driver_data = HIDPP_QUIRK_HI_RES_SCROLL_1P0 },
4602         { /* Keyboard logitech K400 */
4603           LDJ_DEVICE(0x4024),
4604           .driver_data = HIDPP_QUIRK_CLASS_K400 },
4605         { /* Solar Keyboard Logitech K750 */
4606           LDJ_DEVICE(0x4002),
4607           .driver_data = HIDPP_QUIRK_CLASS_K750 },
4608         { /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
4609           LDJ_DEVICE(0xb305),
4610           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4611         { /* Dinovo Edge (Bluetooth-receiver in HID proxy mode) */
4612           LDJ_DEVICE(0xb309),
4613           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4614         { /* Keyboard MX5500 (Bluetooth-receiver in HID proxy mode) */
4615           LDJ_DEVICE(0xb30b),
4616           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4617
4618         { LDJ_DEVICE(HID_ANY_ID) },
4619
4620         { /* Keyboard LX501 (Y-RR53) */
4621           L27MHZ_DEVICE(0x0049),
4622           .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4623         { /* Keyboard MX3000 (Y-RAM74) */
4624           L27MHZ_DEVICE(0x0057),
4625           .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4626         { /* Keyboard MX3200 (Y-RAV80) */
4627           L27MHZ_DEVICE(0x005c),
4628           .driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
4629         { /* S510 Media Remote */
4630           L27MHZ_DEVICE(0x00fe),
4631           .driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
4632
4633         { L27MHZ_DEVICE(HID_ANY_ID) },
4634
4635         { /* Logitech G403 Wireless Gaming Mouse over USB */
4636           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
4637         { /* Logitech G502 Lightspeed Wireless Gaming Mouse over USB */
4638           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC08D) },
4639         { /* Logitech G703 Gaming Mouse over USB */
4640           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC087) },
4641         { /* Logitech G703 Hero Gaming Mouse over USB */
4642           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC090) },
4643         { /* Logitech G900 Gaming Mouse over USB */
4644           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
4645         { /* Logitech G903 Gaming Mouse over USB */
4646           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC086) },
4647         { /* Logitech G903 Hero Gaming Mouse over USB */
4648           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC091) },
4649         { /* Logitech G915 TKL Keyboard over USB */
4650           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC343) },
4651         { /* Logitech G920 Wheel over USB */
4652           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
4653                 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
4654         { /* Logitech G923 Wheel (Xbox version) over USB */
4655           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G923_XBOX_WHEEL),
4656                 .driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS },
4657         { /* Logitech G Pro Gaming Mouse over USB */
4658           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC088) },
4659         { /* Logitech G Pro X Superlight Gaming Mouse over USB */
4660           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC094) },
4661
4662         { /* G935 Gaming Headset */
4663           HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0x0a87),
4664                 .driver_data = HIDPP_QUIRK_WIRELESS_STATUS },
4665
4666         { /* MX5000 keyboard over Bluetooth */
4667           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
4668           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4669         { /* Dinovo Edge keyboard over Bluetooth */
4670           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb309),
4671           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4672         { /* MX5500 keyboard over Bluetooth */
4673           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb30b),
4674           .driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
4675         { /* Logitech G915 TKL keyboard over Bluetooth */
4676           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb35f) },
4677         { /* M-RCQ142 V470 Cordless Laser Mouse over Bluetooth */
4678           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb008) },
4679         { /* MX Master mouse over Bluetooth */
4680           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb012) },
4681         { /* M720 Triathlon mouse over Bluetooth */
4682           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb015) },
4683         { /* MX Ergo trackball over Bluetooth */
4684           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01d) },
4685         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb01e) },
4686         { /* Signature M650 over Bluetooth */
4687           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb02a) },
4688         { /* MX Master 3 mouse over Bluetooth */
4689           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb023) },
4690         { /* MX Anywhere 3 mouse over Bluetooth */
4691           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb025) },
4692         { /* MX Master 3S mouse over Bluetooth */
4693           HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb034) },
4694         {}
4695 };
4696
4697 MODULE_DEVICE_TABLE(hid, hidpp_devices);
4698
4699 static const struct hid_usage_id hidpp_usages[] = {
4700         { HID_GD_WHEEL, EV_REL, REL_WHEEL_HI_RES },
4701         { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
4702 };
4703
4704 static struct hid_driver hidpp_driver = {
4705         .name = "logitech-hidpp-device",
4706         .id_table = hidpp_devices,
4707         .report_fixup = hidpp_report_fixup,
4708         .probe = hidpp_probe,
4709         .remove = hidpp_remove,
4710         .raw_event = hidpp_raw_event,
4711         .usage_table = hidpp_usages,
4712         .event = hidpp_event,
4713         .input_configured = hidpp_input_configured,
4714         .input_mapping = hidpp_input_mapping,
4715         .input_mapped = hidpp_input_mapped,
4716 };
4717
4718 module_hid_driver(hidpp_driver);