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