drivers/hid/hid-magicmouse.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Apple "Magic" Wireless Mouse driver
   4  *
   5  *   Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
   6  *   Copyright (c) 2010 Chase Douglas <chase.douglas@canonical.com>
   7  */
   8
   9 /*
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/device.h>
  15 #include <linux/hid.h>
  16 #include <linux/input/mt.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/workqueue.h>
  20
  21 #include "hid-ids.h"
  22
  23 static bool emulate_3button = true;
  24 module_param(emulate_3button, bool, 0644);
  25 MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");
  26
  27 static int middle_button_start = -350;
  28 static int middle_button_stop = +350;
  29
  30 static bool emulate_scroll_wheel = true;
  31 module_param(emulate_scroll_wheel, bool, 0644);
  32 MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");
  33
  34 static unsigned int scroll_speed = 32;
  35 static int param_set_scroll_speed(const char *val,
  36                                   const struct kernel_param *kp) {
  37         unsigned long speed;
  38         if (!val || kstrtoul(val, 0, &speed) || speed > 63)
  39                 return -EINVAL;
  40         scroll_speed = speed;
  41         return 0;
  42 }
  43 module_param_call(scroll_speed, param_set_scroll_speed, param_get_uint, &scroll_speed, 0644);
  44 MODULE_PARM_DESC(scroll_speed, "Scroll speed, value from 0 (slow) to 63 (fast)");
  45
  46 static bool scroll_acceleration = false;
  47 module_param(scroll_acceleration, bool, 0644);
  48 MODULE_PARM_DESC(scroll_acceleration, "Accelerate sequential scroll events");
  49
  50 static bool report_undeciphered;
  51 module_param(report_undeciphered, bool, 0644);
  52 MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");
  53
  54 #define TRACKPAD2_2021_BT_VERSION 0x110
  55
  56 #define TRACKPAD_REPORT_ID 0x28
  57 #define TRACKPAD2_USB_REPORT_ID 0x02
  58 #define TRACKPAD2_BT_REPORT_ID 0x31
  59 #define MOUSE_REPORT_ID    0x29
  60 #define MOUSE2_REPORT_ID   0x12
  61 #define DOUBLE_REPORT_ID   0xf7
  62 #define USB_BATTERY_TIMEOUT_MS 60000
  63
  64 /* These definitions are not precise, but they're close enough.  (Bits
  65  * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
  66  * to be some kind of bit mask -- 0x20 may be a near-field reading,
  67  * and 0x40 is actual contact, and 0x10 may be a start/stop or change
  68  * indication.)
  69  */
  70 #define TOUCH_STATE_MASK  0xf0
  71 #define TOUCH_STATE_NONE  0x00
  72 #define TOUCH_STATE_START 0x30
  73 #define TOUCH_STATE_DRAG  0x40
  74
  75 /* Number of high-resolution events for each low-resolution detent. */
  76 #define SCROLL_HR_STEPS 10
  77 #define SCROLL_HR_MULT (120 / SCROLL_HR_STEPS)
  78 #define SCROLL_HR_THRESHOLD 90 /* units */
  79 #define SCROLL_ACCEL_DEFAULT 7
  80
  81 /* Touch surface information. Dimension is in hundredths of a mm, min and max
  82  * are in units. */
  83 #define MOUSE_DIMENSION_X (float)9056
  84 #define MOUSE_MIN_X -1100
  85 #define MOUSE_MAX_X 1258
  86 #define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
  87 #define MOUSE_DIMENSION_Y (float)5152
  88 #define MOUSE_MIN_Y -1589
  89 #define MOUSE_MAX_Y 2047
  90 #define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
  91
  92 #define TRACKPAD_DIMENSION_X (float)13000
  93 #define TRACKPAD_MIN_X -2909
  94 #define TRACKPAD_MAX_X 3167
  95 #define TRACKPAD_RES_X \
  96         ((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
  97 #define TRACKPAD_DIMENSION_Y (float)11000
  98 #define TRACKPAD_MIN_Y -2456
  99 #define TRACKPAD_MAX_Y 2565
 100 #define TRACKPAD_RES_Y \
 101         ((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
 102
 103 #define TRACKPAD2_DIMENSION_X (float)16000
 104 #define TRACKPAD2_MIN_X -3678
 105 #define TRACKPAD2_MAX_X 3934
 106 #define TRACKPAD2_RES_X \
 107         ((TRACKPAD2_MAX_X - TRACKPAD2_MIN_X) / (TRACKPAD2_DIMENSION_X / 100))
 108 #define TRACKPAD2_DIMENSION_Y (float)11490
 109 #define TRACKPAD2_MIN_Y -2478
 110 #define TRACKPAD2_MAX_Y 2587
 111 #define TRACKPAD2_RES_Y \
 112         ((TRACKPAD2_MAX_Y - TRACKPAD2_MIN_Y) / (TRACKPAD2_DIMENSION_Y / 100))
 113
 114 /**
 115  * struct magicmouse_sc - Tracks Magic Mouse-specific data.
 116  * @input: Input device through which we report events.
 117  * @quirks: Currently unused.
 118  * @ntouches: Number of touches in most recent touch report.
 119  * @scroll_accel: Number of consecutive scroll motions.
 120  * @scroll_jiffies: Time of last scroll motion.
 121  * @touches: Most recent data for a touch, indexed by tracking ID.
 122  * @tracking_ids: Mapping of current touch input data to @touches.
 123  * @hdev: Pointer to the underlying HID device.
 124  * @work: Workqueue to handle initialization retry for quirky devices.
 125  * @battery_timer: Timer for obtaining battery level information.
 126  */
 127 struct magicmouse_sc {
 128         struct input_dev *input;
 129         unsigned long quirks;
 130
 131         int ntouches;
 132         int scroll_accel;
 133         unsigned long scroll_jiffies;
 134
 135         struct {
 136                 short x;
 137                 short y;
 138                 short scroll_x;
 139                 short scroll_y;
 140                 short scroll_x_hr;
 141                 short scroll_y_hr;
 142                 u8 size;
 143                 bool scroll_x_active;
 144                 bool scroll_y_active;
 145         } touches[16];
 146         int tracking_ids[16];
 147
 148         struct hid_device *hdev;
 149         struct delayed_work work;
 150         struct timer_list battery_timer;
 151 };
 152
 153 static int magicmouse_firm_touch(struct magicmouse_sc *msc)
 154 {
 155         int touch = -1;
 156         int ii;
 157
 158         /* If there is only one "firm" touch, set touch to its
 159          * tracking ID.
 160          */
 161         for (ii = 0; ii < msc->ntouches; ii++) {
 162                 int idx = msc->tracking_ids[ii];
 163                 if (msc->touches[idx].size < 8) {
 164                         /* Ignore this touch. */
 165                 } else if (touch >= 0) {
 166                         touch = -1;
 167                         break;
 168                 } else {
 169                         touch = idx;
 170                 }
 171         }
 172
 173         return touch;
 174 }
 175
 176 static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
 177 {
 178         int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |
 179                 test_bit(BTN_RIGHT, msc->input->key) << 1 |
 180                 test_bit(BTN_MIDDLE, msc->input->key) << 2;
 181
 182         if (emulate_3button) {
 183                 int id;
 184
 185                 /* If some button was pressed before, keep it held
 186                  * down.  Otherwise, if there's exactly one firm
 187                  * touch, use that to override the mouse's guess.
 188                  */
 189                 if (state == 0) {
 190                         /* The button was released. */
 191                 } else if (last_state != 0) {
 192                         state = last_state;
 193                 } else if ((id = magicmouse_firm_touch(msc)) >= 0) {
 194                         int x = msc->touches[id].x;
 195                         if (x < middle_button_start)
 196                                 state = 1;
 197                         else if (x > middle_button_stop)
 198                                 state = 2;
 199                         else
 200                                 state = 4;
 201                 } /* else: we keep the mouse's guess */
 202
 203                 input_report_key(msc->input, BTN_MIDDLE, state & 4);
 204         }
 205
 206         input_report_key(msc->input, BTN_LEFT, state & 1);
 207         input_report_key(msc->input, BTN_RIGHT, state & 2);
 208
 209         if (state != last_state)
 210                 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
 211 }
 212
 213 static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
 214 {
 215         struct input_dev *input = msc->input;
 216         int id, x, y, size, orientation, touch_major, touch_minor, state, down;
 217         int pressure = 0;
 218
 219         if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
 220             input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 221                 id = (tdata[6] << 2 | tdata[5] >> 6) & 0xf;
 222                 x = (tdata[1] << 28 | tdata[0] << 20) >> 20;
 223                 y = -((tdata[2] << 24 | tdata[1] << 16) >> 20);
 224                 size = tdata[5] & 0x3f;
 225                 orientation = (tdata[6] >> 2) - 32;
 226                 touch_major = tdata[3];
 227                 touch_minor = tdata[4];
 228                 state = tdata[7] & TOUCH_STATE_MASK;
 229                 down = state != TOUCH_STATE_NONE;
 230         } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 231                 id = tdata[8] & 0xf;
 232                 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
 233                 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
 234                 size = tdata[6];
 235                 orientation = (tdata[8] >> 5) - 4;
 236                 touch_major = tdata[4];
 237                 touch_minor = tdata[5];
 238                 pressure = tdata[7];
 239                 state = tdata[3] & 0xC0;
 240                 down = state == 0x80;
 241         } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 242                 id = (tdata[7] << 2 | tdata[6] >> 6) & 0xf;
 243                 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
 244                 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
 245                 size = tdata[6] & 0x3f;
 246                 orientation = (tdata[7] >> 2) - 32;
 247                 touch_major = tdata[4];
 248                 touch_minor = tdata[5];
 249                 state = tdata[8] & TOUCH_STATE_MASK;
 250                 down = state != TOUCH_STATE_NONE;
 251         }
 252
 253         /* Store tracking ID and other fields. */
 254         msc->tracking_ids[raw_id] = id;
 255         msc->touches[id].x = x;
 256         msc->touches[id].y = y;
 257         msc->touches[id].size = size;
 258
 259         /* If requested, emulate a scroll wheel by detecting small
 260          * vertical touch motions.
 261          */
 262         if (emulate_scroll_wheel && (input->id.product !=
 263                         USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)) {
 264                 unsigned long now = jiffies;
 265                 int step_x = msc->touches[id].scroll_x - x;
 266                 int step_y = msc->touches[id].scroll_y - y;
 267                 int step_hr =
 268                         max_t(int,
 269                               ((64 - (int)scroll_speed) * msc->scroll_accel) /
 270                                         SCROLL_HR_STEPS,
 271                               1);
 272                 int step_x_hr = msc->touches[id].scroll_x_hr - x;
 273                 int step_y_hr = msc->touches[id].scroll_y_hr - y;
 274
 275                 /* Calculate and apply the scroll motion. */
 276                 switch (state) {
 277                 case TOUCH_STATE_START:
 278                         msc->touches[id].scroll_x = x;
 279                         msc->touches[id].scroll_y = y;
 280                         msc->touches[id].scroll_x_hr = x;
 281                         msc->touches[id].scroll_y_hr = y;
 282                         msc->touches[id].scroll_x_active = false;
 283                         msc->touches[id].scroll_y_active = false;
 284
 285                         /* Reset acceleration after half a second. */
 286                         if (scroll_acceleration && time_before(now,
 287                                                 msc->scroll_jiffies + HZ / 2))
 288                                 msc->scroll_accel = max_t(int,
 289                                                 msc->scroll_accel - 1, 1);
 290                         else
 291                                 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
 292
 293                         break;
 294                 case TOUCH_STATE_DRAG:
 295                         step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
 296                         if (step_x != 0) {
 297                                 msc->touches[id].scroll_x -= step_x *
 298                                         (64 - scroll_speed) * msc->scroll_accel;
 299                                 msc->scroll_jiffies = now;
 300                                 input_report_rel(input, REL_HWHEEL, -step_x);
 301                         }
 302
 303                         step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;
 304                         if (step_y != 0) {
 305                                 msc->touches[id].scroll_y -= step_y *
 306                                         (64 - scroll_speed) * msc->scroll_accel;
 307                                 msc->scroll_jiffies = now;
 308                                 input_report_rel(input, REL_WHEEL, step_y);
 309                         }
 310
 311                         if (!msc->touches[id].scroll_x_active &&
 312                             abs(step_x_hr) > SCROLL_HR_THRESHOLD) {
 313                                 msc->touches[id].scroll_x_active = true;
 314                                 msc->touches[id].scroll_x_hr = x;
 315                                 step_x_hr = 0;
 316                         }
 317
 318                         step_x_hr /= step_hr;
 319                         if (step_x_hr != 0 &&
 320                             msc->touches[id].scroll_x_active) {
 321                                 msc->touches[id].scroll_x_hr -= step_x_hr *
 322                                         step_hr;
 323                                 input_report_rel(input,
 324                                                  REL_HWHEEL_HI_RES,
 325                                                  -step_x_hr * SCROLL_HR_MULT);
 326                         }
 327
 328                         if (!msc->touches[id].scroll_y_active &&
 329                             abs(step_y_hr) > SCROLL_HR_THRESHOLD) {
 330                                 msc->touches[id].scroll_y_active = true;
 331                                 msc->touches[id].scroll_y_hr = y;
 332                                 step_y_hr = 0;
 333                         }
 334
 335                         step_y_hr /= step_hr;
 336                         if (step_y_hr != 0 &&
 337                             msc->touches[id].scroll_y_active) {
 338                                 msc->touches[id].scroll_y_hr -= step_y_hr *
 339                                         step_hr;
 340                                 input_report_rel(input,
 341                                                  REL_WHEEL_HI_RES,
 342                                                  step_y_hr * SCROLL_HR_MULT);
 343                         }
 344                         break;
 345                 }
 346         }
 347
 348         if (down)
 349                 msc->ntouches++;
 350
 351         input_mt_slot(input, id);
 352         input_mt_report_slot_state(input, MT_TOOL_FINGER, down);
 353
 354         /* Generate the input events for this touch. */
 355         if (down) {
 356                 input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2);
 357                 input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2);
 358                 input_report_abs(input, ABS_MT_ORIENTATION, -orientation);
 359                 input_report_abs(input, ABS_MT_POSITION_X, x);
 360                 input_report_abs(input, ABS_MT_POSITION_Y, y);
 361
 362                 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
 363                         input_report_abs(input, ABS_MT_PRESSURE, pressure);
 364
 365                 if (report_undeciphered) {
 366                         if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
 367                             input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2)
 368                                 input_event(input, EV_MSC, MSC_RAW, tdata[7]);
 369                         else if (input->id.product !=
 370                                         USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
 371                                 input_event(input, EV_MSC, MSC_RAW, tdata[8]);
 372                 }
 373         }
 374 }
 375
 376 static int magicmouse_raw_event(struct hid_device *hdev,
 377                 struct hid_report *report, u8 *data, int size)
 378 {
 379         struct magicmouse_sc *msc = hid_get_drvdata(hdev);
 380         struct input_dev *input = msc->input;
 381         int x = 0, y = 0, ii, clicks = 0, npoints;
 382
 383         switch (data[0]) {
 384         case TRACKPAD_REPORT_ID:
 385         case TRACKPAD2_BT_REPORT_ID:
 386                 /* Expect four bytes of prefix, and N*9 bytes of touch data. */
 387                 if (size < 4 || ((size - 4) % 9) != 0)
 388                         return 0;
 389                 npoints = (size - 4) / 9;
 390                 if (npoints > 15) {
 391                         hid_warn(hdev, "invalid size value (%d) for TRACKPAD_REPORT_ID\n",
 392                                         size);
 393                         return 0;
 394                 }
 395                 msc->ntouches = 0;
 396                 for (ii = 0; ii < npoints; ii++)
 397                         magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);
 398
 399                 clicks = data[1];
 400
 401                 /* The following bits provide a device specific timestamp. They
 402                  * are unused here.
 403                  *
 404                  * ts = data[1] >> 6 | data[2] << 2 | data[3] << 10;
 405                  */
 406                 break;
 407         case TRACKPAD2_USB_REPORT_ID:
 408                 /* Expect twelve bytes of prefix and N*9 bytes of touch data. */
 409                 if (size < 12 || ((size - 12) % 9) != 0)
 410                         return 0;
 411                 npoints = (size - 12) / 9;
 412                 if (npoints > 15) {
 413                         hid_warn(hdev, "invalid size value (%d) for TRACKPAD2_USB_REPORT_ID\n",
 414                                         size);
 415                         return 0;
 416                 }
 417                 msc->ntouches = 0;
 418                 for (ii = 0; ii < npoints; ii++)
 419                         magicmouse_emit_touch(msc, ii, data + ii * 9 + 12);
 420
 421                 clicks = data[1];
 422                 break;
 423         case MOUSE_REPORT_ID:
 424                 /* Expect six bytes of prefix, and N*8 bytes of touch data. */
 425                 if (size < 6 || ((size - 6) % 8) != 0)
 426                         return 0;
 427                 npoints = (size - 6) / 8;
 428                 if (npoints > 15) {
 429                         hid_warn(hdev, "invalid size value (%d) for MOUSE_REPORT_ID\n",
 430                                         size);
 431                         return 0;
 432                 }
 433                 msc->ntouches = 0;
 434                 for (ii = 0; ii < npoints; ii++)
 435                         magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
 436
 437                 /* When emulating three-button mode, it is important
 438                  * to have the current touch information before
 439                  * generating a click event.
 440                  */
 441                 x = (int)(((data[3] & 0x0c) << 28) | (data[1] << 22)) >> 22;
 442                 y = (int)(((data[3] & 0x30) << 26) | (data[2] << 22)) >> 22;
 443                 clicks = data[3];
 444
 445                 /* The following bits provide a device specific timestamp. They
 446                  * are unused here.
 447                  *
 448                  * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
 449                  */
 450                 break;
 451         case MOUSE2_REPORT_ID:
 452                 /* Size is either 8 or (14 + 8 * N) */
 453                 if (size != 8 && (size < 14 || (size - 14) % 8 != 0))
 454                         return 0;
 455                 npoints = (size - 14) / 8;
 456                 if (npoints > 15) {
 457                         hid_warn(hdev, "invalid size value (%d) for MOUSE2_REPORT_ID\n",
 458                                         size);
 459                         return 0;
 460                 }
 461                 msc->ntouches = 0;
 462                 for (ii = 0; ii < npoints; ii++)
 463                         magicmouse_emit_touch(msc, ii, data + ii * 8 + 14);
 464
 465                 /* When emulating three-button mode, it is important
 466                  * to have the current touch information before
 467                  * generating a click event.
 468                  */
 469                 x = (int)((data[3] << 24) | (data[2] << 16)) >> 16;
 470                 y = (int)((data[5] << 24) | (data[4] << 16)) >> 16;
 471                 clicks = data[1];
 472
 473                 /* The following bits provide a device specific timestamp. They
 474                  * are unused here.
 475                  *
 476                  * ts = data[11] >> 6 | data[12] << 2 | data[13] << 10;
 477                  */
 478                 break;
 479         case DOUBLE_REPORT_ID:
 480                 /* Sometimes the trackpad sends two touch reports in one
 481                  * packet.
 482                  */
 483                 magicmouse_raw_event(hdev, report, data + 2, data[1]);
 484                 magicmouse_raw_event(hdev, report, data + 2 + data[1],
 485                         size - 2 - data[1]);
 486                 return 0;
 487         default:
 488                 return 0;
 489         }
 490
 491         if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
 492             input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 493                 magicmouse_emit_buttons(msc, clicks & 3);
 494                 input_report_rel(input, REL_X, x);
 495                 input_report_rel(input, REL_Y, y);
 496         } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 497                 input_mt_sync_frame(input);
 498                 input_report_key(input, BTN_MOUSE, clicks & 1);
 499         } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 500                 input_report_key(input, BTN_MOUSE, clicks & 1);
 501                 input_mt_report_pointer_emulation(input, true);
 502         }
 503
 504         input_sync(input);
 505         return 1;
 506 }
 507
 508 static int magicmouse_event(struct hid_device *hdev, struct hid_field *field,
 509                 struct hid_usage *usage, __s32 value)
 510 {
 511         struct magicmouse_sc *msc = hid_get_drvdata(hdev);
 512         if (msc->input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2 &&
 513             field->report->id == MOUSE2_REPORT_ID) {
 514                 /*
 515                  * magic_mouse_raw_event has done all the work. Skip hidinput.
 516                  *
 517                  * Specifically, hidinput may modify BTN_LEFT and BTN_RIGHT,
 518                  * breaking emulate_3button.
 519                  */
 520                 return 1;
 521         }
 522         return 0;
 523 }
 524
 525 static int magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
 526 {
 527         int error;
 528         int mt_flags = 0;
 529
 530         __set_bit(EV_KEY, input->evbit);
 531
 532         if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
 533             input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 534                 __set_bit(BTN_LEFT, input->keybit);
 535                 __set_bit(BTN_RIGHT, input->keybit);
 536                 if (emulate_3button)
 537                         __set_bit(BTN_MIDDLE, input->keybit);
 538
 539                 __set_bit(EV_REL, input->evbit);
 540                 __set_bit(REL_X, input->relbit);
 541                 __set_bit(REL_Y, input->relbit);
 542                 if (emulate_scroll_wheel) {
 543                         __set_bit(REL_WHEEL, input->relbit);
 544                         __set_bit(REL_HWHEEL, input->relbit);
 545                         __set_bit(REL_WHEEL_HI_RES, input->relbit);
 546                         __set_bit(REL_HWHEEL_HI_RES, input->relbit);
 547                 }
 548         } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 549                 /* If the trackpad has been connected to a Mac, the name is
 550                  * automatically personalized, e.g., "José Expósito's Trackpad".
 551                  * When connected through Bluetooth, the personalized name is
 552                  * reported, however, when connected through USB the generic
 553                  * name is reported.
 554                  * Set the device name to ensure the same driver settings get
 555                  * loaded, whether connected through bluetooth or USB.
 556                  */
 557                 if (hdev->vendor == BT_VENDOR_ID_APPLE) {
 558                         if (input->id.version == TRACKPAD2_2021_BT_VERSION)
 559                                 input->name = "Apple Inc. Magic Trackpad";
 560                         else
 561                                 input->name = "Apple Inc. Magic Trackpad 2";
 562                 } else { /* USB_VENDOR_ID_APPLE */
 563                         input->name = hdev->name;
 564                 }
 565
 566                 __clear_bit(EV_MSC, input->evbit);
 567                 __clear_bit(BTN_0, input->keybit);
 568                 __clear_bit(BTN_RIGHT, input->keybit);
 569                 __clear_bit(BTN_MIDDLE, input->keybit);
 570                 __set_bit(BTN_MOUSE, input->keybit);
 571                 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 572                 __set_bit(BTN_TOOL_FINGER, input->keybit);
 573
 574                 mt_flags = INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
 575                                 INPUT_MT_TRACK;
 576         } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 577                 /* input->keybit is initialized with incorrect button info
 578                  * for Magic Trackpad. There really is only one physical
 579                  * button (BTN_LEFT == BTN_MOUSE). Make sure we don't
 580                  * advertise buttons that don't exist...
 581                  */
 582                 __clear_bit(BTN_RIGHT, input->keybit);
 583                 __clear_bit(BTN_MIDDLE, input->keybit);
 584                 __set_bit(BTN_MOUSE, input->keybit);
 585                 __set_bit(BTN_TOOL_FINGER, input->keybit);
 586                 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
 587                 __set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
 588                 __set_bit(BTN_TOOL_QUADTAP, input->keybit);
 589                 __set_bit(BTN_TOOL_QUINTTAP, input->keybit);
 590                 __set_bit(BTN_TOUCH, input->keybit);
 591                 __set_bit(INPUT_PROP_POINTER, input->propbit);
 592                 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 593         }
 594
 595
 596         __set_bit(EV_ABS, input->evbit);
 597
 598         error = input_mt_init_slots(input, 16, mt_flags);
 599         if (error)
 600                 return error;
 601         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255 << 2,
 602                              4, 0);
 603         input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255 << 2,
 604                              4, 0);
 605
 606         /* Note: Touch Y position from the device is inverted relative
 607          * to how pointer motion is reported (and relative to how USB
 608          * HID recommends the coordinates work).  This driver keeps
 609          * the origin at the same position, and just uses the additive
 610          * inverse of the reported Y.
 611          */
 612         if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
 613             input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 614                 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
 615                 input_set_abs_params(input, ABS_MT_POSITION_X,
 616                                      MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
 617                 input_set_abs_params(input, ABS_MT_POSITION_Y,
 618                                      MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
 619
 620                 input_abs_set_res(input, ABS_MT_POSITION_X,
 621                                   MOUSE_RES_X);
 622                 input_abs_set_res(input, ABS_MT_POSITION_Y,
 623                                   MOUSE_RES_Y);
 624         } else if (input->id.product ==  USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 625                 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 253, 0, 0);
 626                 input_set_abs_params(input, ABS_PRESSURE, 0, 253, 0, 0);
 627                 input_set_abs_params(input, ABS_MT_ORIENTATION, -3, 4, 0, 0);
 628                 input_set_abs_params(input, ABS_X, TRACKPAD2_MIN_X,
 629                                      TRACKPAD2_MAX_X, 0, 0);
 630                 input_set_abs_params(input, ABS_Y, TRACKPAD2_MIN_Y,
 631                                      TRACKPAD2_MAX_Y, 0, 0);
 632                 input_set_abs_params(input, ABS_MT_POSITION_X,
 633                                      TRACKPAD2_MIN_X, TRACKPAD2_MAX_X, 0, 0);
 634                 input_set_abs_params(input, ABS_MT_POSITION_Y,
 635                                      TRACKPAD2_MIN_Y, TRACKPAD2_MAX_Y, 0, 0);
 636
 637                 input_abs_set_res(input, ABS_X, TRACKPAD2_RES_X);
 638                 input_abs_set_res(input, ABS_Y, TRACKPAD2_RES_Y);
 639                 input_abs_set_res(input, ABS_MT_POSITION_X, TRACKPAD2_RES_X);
 640                 input_abs_set_res(input, ABS_MT_POSITION_Y, TRACKPAD2_RES_Y);
 641         } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 642                 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
 643                 input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
 644                                      TRACKPAD_MAX_X, 4, 0);
 645                 input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
 646                                      TRACKPAD_MAX_Y, 4, 0);
 647                 input_set_abs_params(input, ABS_MT_POSITION_X,
 648                                      TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
 649                 input_set_abs_params(input, ABS_MT_POSITION_Y,
 650                                      TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
 651
 652                 input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
 653                 input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
 654                 input_abs_set_res(input, ABS_MT_POSITION_X,
 655                                   TRACKPAD_RES_X);
 656                 input_abs_set_res(input, ABS_MT_POSITION_Y,
 657                                   TRACKPAD_RES_Y);
 658         }
 659
 660         input_set_events_per_packet(input, 60);
 661
 662         if (report_undeciphered &&
 663             input->id.product != USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 664                 __set_bit(EV_MSC, input->evbit);
 665                 __set_bit(MSC_RAW, input->mscbit);
 666         }
 667
 668         /*
 669          * hid-input may mark device as using autorepeat, but neither
 670          * the trackpad, nor the mouse actually want it.
 671          */
 672         __clear_bit(EV_REP, input->evbit);
 673
 674         return 0;
 675 }
 676
 677 static int magicmouse_input_mapping(struct hid_device *hdev,
 678                 struct hid_input *hi, struct hid_field *field,
 679                 struct hid_usage *usage, unsigned long **bit, int *max)
 680 {
 681         struct magicmouse_sc *msc = hid_get_drvdata(hdev);
 682
 683         if (!msc->input)
 684                 msc->input = hi->input;
 685
 686         /* Magic Trackpad does not give relative data after switching to MT */
 687         if ((hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD ||
 688              hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) &&
 689             field->flags & HID_MAIN_ITEM_RELATIVE)
 690                 return -1;
 691
 692         return 0;
 693 }
 694
 695 static int magicmouse_input_configured(struct hid_device *hdev,
 696                 struct hid_input *hi)
 697
 698 {
 699         struct magicmouse_sc *msc = hid_get_drvdata(hdev);
 700         int ret;
 701
 702         ret = magicmouse_setup_input(msc->input, hdev);
 703         if (ret) {
 704                 hid_err(hdev, "magicmouse setup input failed (%d)\n", ret);
 705                 /* clean msc->input to notify probe() of the failure */
 706                 msc->input = NULL;
 707                 return ret;
 708         }
 709
 710         return 0;
 711 }
 712
 713 static int magicmouse_enable_multitouch(struct hid_device *hdev)
 714 {
 715         const u8 *feature;
 716         const u8 feature_mt[] = { 0xD7, 0x01 };
 717         const u8 feature_mt_mouse2[] = { 0xF1, 0x02, 0x01 };
 718         const u8 feature_mt_trackpad2_usb[] = { 0x02, 0x01 };
 719         const u8 feature_mt_trackpad2_bt[] = { 0xF1, 0x02, 0x01 };
 720         u8 *buf;
 721         int ret;
 722         int feature_size;
 723
 724         if (hdev->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 725                 if (hdev->vendor == BT_VENDOR_ID_APPLE) {
 726                         feature_size = sizeof(feature_mt_trackpad2_bt);
 727                         feature = feature_mt_trackpad2_bt;
 728                 } else { /* USB_VENDOR_ID_APPLE */
 729                         feature_size = sizeof(feature_mt_trackpad2_usb);
 730                         feature = feature_mt_trackpad2_usb;
 731                 }
 732         } else if (hdev->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 733                 feature_size = sizeof(feature_mt_mouse2);
 734                 feature = feature_mt_mouse2;
 735         } else {
 736                 feature_size = sizeof(feature_mt);
 737                 feature = feature_mt;
 738         }
 739
 740         buf = kmemdup(feature, feature_size, GFP_KERNEL);
 741         if (!buf)
 742                 return -ENOMEM;
 743
 744         ret = hid_hw_raw_request(hdev, buf[0], buf, feature_size,
 745                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 746         kfree(buf);
 747         return ret;
 748 }
 749
 750 static void magicmouse_enable_mt_work(struct work_struct *work)
 751 {
 752         struct magicmouse_sc *msc =
 753                 container_of(work, struct magicmouse_sc, work.work);
 754         int ret;
 755
 756         ret = magicmouse_enable_multitouch(msc->hdev);
 757         if (ret < 0)
 758                 hid_err(msc->hdev, "unable to request touch data (%d)\n", ret);
 759 }
 760
 761 static int magicmouse_fetch_battery(struct hid_device *hdev)
 762 {
 763 #ifdef CONFIG_HID_BATTERY_STRENGTH
 764         struct hid_report_enum *report_enum;
 765         struct hid_report *report;
 766
 767         if (!hdev->battery || hdev->vendor != USB_VENDOR_ID_APPLE ||
 768             (hdev->product != USB_DEVICE_ID_APPLE_MAGICMOUSE2 &&
 769              hdev->product != USB_DEVICE_ID_APPLE_MAGICTRACKPAD2))
 770                 return -1;
 771
 772         report_enum = &hdev->report_enum[hdev->battery_report_type];
 773         report = report_enum->report_id_hash[hdev->battery_report_id];
 774
 775         if (!report || report->maxfield < 1)
 776                 return -1;
 777
 778         if (hdev->battery_capacity == hdev->battery_max)
 779                 return -1;
 780
 781         hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
 782         return 0;
 783 #else
 784         return -1;
 785 #endif
 786 }
 787
 788 static void magicmouse_battery_timer_tick(struct timer_list *t)
 789 {
 790         struct magicmouse_sc *msc = from_timer(msc, t, battery_timer);
 791         struct hid_device *hdev = msc->hdev;
 792
 793         if (magicmouse_fetch_battery(hdev) == 0) {
 794                 mod_timer(&msc->battery_timer,
 795                           jiffies + msecs_to_jiffies(USB_BATTERY_TIMEOUT_MS));
 796         }
 797 }
 798
 799 static int magicmouse_probe(struct hid_device *hdev,
 800         const struct hid_device_id *id)
 801 {
 802         struct magicmouse_sc *msc;
 803         struct hid_report *report;
 804         int ret;
 805
 806         msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);
 807         if (msc == NULL) {
 808                 hid_err(hdev, "can't alloc magicmouse descriptor\n");
 809                 return -ENOMEM;
 810         }
 811
 812         msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
 813         msc->hdev = hdev;
 814         INIT_DEFERRABLE_WORK(&msc->work, magicmouse_enable_mt_work);
 815
 816         msc->quirks = id->driver_data;
 817         hid_set_drvdata(hdev, msc);
 818
 819         ret = hid_parse(hdev);
 820         if (ret) {
 821                 hid_err(hdev, "magicmouse hid parse failed\n");
 822                 return ret;
 823         }
 824
 825         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 826         if (ret) {
 827                 hid_err(hdev, "magicmouse hw start failed\n");
 828                 return ret;
 829         }
 830
 831         timer_setup(&msc->battery_timer, magicmouse_battery_timer_tick, 0);
 832         mod_timer(&msc->battery_timer,
 833                   jiffies + msecs_to_jiffies(USB_BATTERY_TIMEOUT_MS));
 834         magicmouse_fetch_battery(hdev);
 835
 836         if (id->vendor == USB_VENDOR_ID_APPLE &&
 837             (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2 ||
 838              (id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2 && hdev->type != HID_TYPE_USBMOUSE)))
 839                 return 0;
 840
 841         if (!msc->input) {
 842                 hid_err(hdev, "magicmouse input not registered\n");
 843                 ret = -ENOMEM;
 844                 goto err_stop_hw;
 845         }
 846
 847         if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
 848                 report = hid_register_report(hdev, HID_INPUT_REPORT,
 849                         MOUSE_REPORT_ID, 0);
 850         else if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2)
 851                 report = hid_register_report(hdev, HID_INPUT_REPORT,
 852                         MOUSE2_REPORT_ID, 0);
 853         else if (id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
 854                 if (id->vendor == BT_VENDOR_ID_APPLE)
 855                         report = hid_register_report(hdev, HID_INPUT_REPORT,
 856                                 TRACKPAD2_BT_REPORT_ID, 0);
 857                 else /* USB_VENDOR_ID_APPLE */
 858                         report = hid_register_report(hdev, HID_INPUT_REPORT,
 859                                 TRACKPAD2_USB_REPORT_ID, 0);
 860         } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
 861                 report = hid_register_report(hdev, HID_INPUT_REPORT,
 862                         TRACKPAD_REPORT_ID, 0);
 863                 report = hid_register_report(hdev, HID_INPUT_REPORT,
 864                         DOUBLE_REPORT_ID, 0);
 865         }
 866
 867         if (!report) {
 868                 hid_err(hdev, "unable to register touch report\n");
 869                 ret = -ENOMEM;
 870                 goto err_stop_hw;
 871         }
 872         report->size = 6;
 873
 874         /*
 875          * Some devices repond with 'invalid report id' when feature
 876          * report switching it into multitouch mode is sent to it.
 877          *
 878          * This results in -EIO from the _raw low-level transport callback,
 879          * but there seems to be no other way of switching the mode.
 880          * Thus the super-ugly hacky success check below.
 881          */
 882         ret = magicmouse_enable_multitouch(hdev);
 883         if (ret != -EIO && ret < 0) {
 884                 hid_err(hdev, "unable to request touch data (%d)\n", ret);
 885                 goto err_stop_hw;
 886         }
 887         if (ret == -EIO && id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
 888                 schedule_delayed_work(&msc->work, msecs_to_jiffies(500));
 889         }
 890
 891         return 0;
 892 err_stop_hw:
 893         del_timer_sync(&msc->battery_timer);
 894         hid_hw_stop(hdev);
 895         return ret;
 896 }
 897
 898 static void magicmouse_remove(struct hid_device *hdev)
 899 {
 900         struct magicmouse_sc *msc = hid_get_drvdata(hdev);
 901
 902         if (msc) {
 903                 cancel_delayed_work_sync(&msc->work);
 904                 del_timer_sync(&msc->battery_timer);
 905         }
 906
 907         hid_hw_stop(hdev);
 908 }
 909
 910 static __u8 *magicmouse_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 911                                      unsigned int *rsize)
 912 {
 913         /*
 914          * Change the usage from:
 915          *   0x06, 0x00, 0xff, // Usage Page (Vendor Defined Page 1)  0
 916          *   0x09, 0x0b,       // Usage (Vendor Usage 0x0b)           3
 917          * To:
 918          *   0x05, 0x01,       // Usage Page (Generic Desktop)        0
 919          *   0x09, 0x02,       // Usage (Mouse)                       2
 920          */
 921         if (hdev->vendor == USB_VENDOR_ID_APPLE &&
 922             (hdev->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2 ||
 923              hdev->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) &&
 924             *rsize == 83 && rdesc[46] == 0x84 && rdesc[58] == 0x85) {
 925                 hid_info(hdev,
 926                          "fixing up magicmouse battery report descriptor\n");
 927                 *rsize = *rsize - 1;
 928                 rdesc = kmemdup(rdesc + 1, *rsize, GFP_KERNEL);
 929                 if (!rdesc)
 930                         return NULL;
 931
 932                 rdesc[0] = 0x05;
 933                 rdesc[1] = 0x01;
 934                 rdesc[2] = 0x09;
 935                 rdesc[3] = 0x02;
 936         }
 937
 938         return rdesc;
 939 }
 940
 941 static const struct hid_device_id magic_mice[] = {
 942         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 943                 USB_DEVICE_ID_APPLE_MAGICMOUSE), .driver_data = 0 },
 944         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE,
 945                 USB_DEVICE_ID_APPLE_MAGICMOUSE2), .driver_data = 0 },
 946         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE,
 947                 USB_DEVICE_ID_APPLE_MAGICMOUSE2), .driver_data = 0 },
 948         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
 949                 USB_DEVICE_ID_APPLE_MAGICTRACKPAD), .driver_data = 0 },
 950         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE,
 951                 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
 952         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE,
 953                 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
 954         { }
 955 };
 956 MODULE_DEVICE_TABLE(hid, magic_mice);
 957
 958 static struct hid_driver magicmouse_driver = {
 959         .name = "magicmouse",
 960         .id_table = magic_mice,
 961         .probe = magicmouse_probe,
 962         .remove = magicmouse_remove,
 963         .report_fixup = magicmouse_report_fixup,
 964         .raw_event = magicmouse_raw_event,
 965         .event = magicmouse_event,
 966         .input_mapping = magicmouse_input_mapping,
 967         .input_configured = magicmouse_input_configured,
 968 };
 969 module_hid_driver(magicmouse_driver);
 970
 971 MODULE_LICENSE("GPL");