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