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