1
2
3
4
5
6
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
23static bool emulate_3button = true;
24module_param(emulate_3button, bool, 0644);
25MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");
26
27static int middle_button_start = -350;
28static int middle_button_stop = +350;
29
30static bool emulate_scroll_wheel = true;
31module_param(emulate_scroll_wheel, bool, 0644);
32MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");
33
34static unsigned int scroll_speed = 32;
35static 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}
43module_param_call(scroll_speed, param_set_scroll_speed, param_get_uint, &scroll_speed, 0644);
44MODULE_PARM_DESC(scroll_speed, "Scroll speed, value from 0 (slow) to 63 (fast)");
45
46static bool scroll_acceleration = false;
47module_param(scroll_acceleration, bool, 0644);
48MODULE_PARM_DESC(scroll_acceleration, "Accelerate sequential scroll events");
49
50static bool report_undeciphered;
51module_param(report_undeciphered, bool, 0644);
52MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");
53
54#define TRACKPAD_REPORT_ID 0x28
55#define TRACKPAD2_USB_REPORT_ID 0x02
56#define TRACKPAD2_BT_REPORT_ID 0x31
57#define MOUSE_REPORT_ID 0x29
58#define MOUSE2_REPORT_ID 0x12
59#define DOUBLE_REPORT_ID 0xf7
60
61
62
63
64
65
66#define TOUCH_STATE_MASK 0xf0
67#define TOUCH_STATE_NONE 0x00
68#define TOUCH_STATE_START 0x30
69#define TOUCH_STATE_DRAG 0x40
70
71#define SCROLL_ACCEL_DEFAULT 7
72
73
74
75#define MOUSE_DIMENSION_X (float)9056
76#define MOUSE_MIN_X -1100
77#define MOUSE_MAX_X 1258
78#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
79#define MOUSE_DIMENSION_Y (float)5152
80#define MOUSE_MIN_Y -1589
81#define MOUSE_MAX_Y 2047
82#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
83
84#define TRACKPAD_DIMENSION_X (float)13000
85#define TRACKPAD_MIN_X -2909
86#define TRACKPAD_MAX_X 3167
87#define TRACKPAD_RES_X \
88 ((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
89#define TRACKPAD_DIMENSION_Y (float)11000
90#define TRACKPAD_MIN_Y -2456
91#define TRACKPAD_MAX_Y 2565
92#define TRACKPAD_RES_Y \
93 ((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
94
95#define TRACKPAD2_DIMENSION_X (float)16000
96#define TRACKPAD2_MIN_X -3678
97#define TRACKPAD2_MAX_X 3934
98#define TRACKPAD2_RES_X \
99 ((TRACKPAD2_MAX_X - TRACKPAD2_MIN_X) / (TRACKPAD2_DIMENSION_X / 100))
100#define TRACKPAD2_DIMENSION_Y (float)11490
101#define TRACKPAD2_MIN_Y -2478
102#define TRACKPAD2_MAX_Y 2587
103#define TRACKPAD2_RES_Y \
104 ((TRACKPAD2_MAX_Y - TRACKPAD2_MIN_Y) / (TRACKPAD2_DIMENSION_Y / 100))
105
106
107
108
109
110
111
112
113
114
115
116struct magicmouse_sc {
117 struct input_dev *input;
118 unsigned long quirks;
119
120 int ntouches;
121 int scroll_accel;
122 unsigned long scroll_jiffies;
123
124 struct {
125 short x;
126 short y;
127 short scroll_x;
128 short scroll_y;
129 u8 size;
130 } touches[16];
131 int tracking_ids[16];
132
133 struct hid_device *hdev;
134 struct delayed_work work;
135};
136
137static int magicmouse_firm_touch(struct magicmouse_sc *msc)
138{
139 int touch = -1;
140 int ii;
141
142
143
144
145 for (ii = 0; ii < msc->ntouches; ii++) {
146 int idx = msc->tracking_ids[ii];
147 if (msc->touches[idx].size < 8) {
148
149 } else if (touch >= 0) {
150 touch = -1;
151 break;
152 } else {
153 touch = idx;
154 }
155 }
156
157 return touch;
158}
159
160static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
161{
162 int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |
163 test_bit(BTN_RIGHT, msc->input->key) << 1 |
164 test_bit(BTN_MIDDLE, msc->input->key) << 2;
165
166 if (emulate_3button) {
167 int id;
168
169
170
171
172
173 if (state == 0) {
174
175 } else if (last_state != 0) {
176 state = last_state;
177 } else if ((id = magicmouse_firm_touch(msc)) >= 0) {
178 int x = msc->touches[id].x;
179 if (x < middle_button_start)
180 state = 1;
181 else if (x > middle_button_stop)
182 state = 2;
183 else
184 state = 4;
185 }
186
187 input_report_key(msc->input, BTN_MIDDLE, state & 4);
188 }
189
190 input_report_key(msc->input, BTN_LEFT, state & 1);
191 input_report_key(msc->input, BTN_RIGHT, state & 2);
192
193 if (state != last_state)
194 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
195}
196
197static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
198{
199 struct input_dev *input = msc->input;
200 int id, x, y, size, orientation, touch_major, touch_minor, state, down;
201 int pressure = 0;
202
203 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
204 input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
205 id = (tdata[6] << 2 | tdata[5] >> 6) & 0xf;
206 x = (tdata[1] << 28 | tdata[0] << 20) >> 20;
207 y = -((tdata[2] << 24 | tdata[1] << 16) >> 20);
208 size = tdata[5] & 0x3f;
209 orientation = (tdata[6] >> 2) - 32;
210 touch_major = tdata[3];
211 touch_minor = tdata[4];
212 state = tdata[7] & TOUCH_STATE_MASK;
213 down = state != TOUCH_STATE_NONE;
214 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
215 id = tdata[8] & 0xf;
216 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
217 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
218 size = tdata[6];
219 orientation = (tdata[8] >> 5) - 4;
220 touch_major = tdata[4];
221 touch_minor = tdata[5];
222 pressure = tdata[7];
223 state = tdata[3] & 0xC0;
224 down = state == 0x80;
225 } else {
226 id = (tdata[7] << 2 | tdata[6] >> 6) & 0xf;
227 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
228 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
229 size = tdata[6] & 0x3f;
230 orientation = (tdata[7] >> 2) - 32;
231 touch_major = tdata[4];
232 touch_minor = tdata[5];
233 state = tdata[8] & TOUCH_STATE_MASK;
234 down = state != TOUCH_STATE_NONE;
235 }
236
237
238 msc->tracking_ids[raw_id] = id;
239 msc->touches[id].x = x;
240 msc->touches[id].y = y;
241 msc->touches[id].size = size;
242
243
244
245
246 if (emulate_scroll_wheel && (input->id.product !=
247 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)) {
248 unsigned long now = jiffies;
249 int step_x = msc->touches[id].scroll_x - x;
250 int step_y = msc->touches[id].scroll_y - y;
251
252
253 switch (state) {
254 case TOUCH_STATE_START:
255 msc->touches[id].scroll_x = x;
256 msc->touches[id].scroll_y = y;
257
258
259 if (scroll_acceleration && time_before(now,
260 msc->scroll_jiffies + HZ / 2))
261 msc->scroll_accel = max_t(int,
262 msc->scroll_accel - 1, 1);
263 else
264 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
265
266 break;
267 case TOUCH_STATE_DRAG:
268 step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
269 if (step_x != 0) {
270 msc->touches[id].scroll_x -= step_x *
271 (64 - scroll_speed) * msc->scroll_accel;
272 msc->scroll_jiffies = now;
273 input_report_rel(input, REL_HWHEEL, -step_x);
274 }
275
276 step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;
277 if (step_y != 0) {
278 msc->touches[id].scroll_y -= step_y *
279 (64 - scroll_speed) * msc->scroll_accel;
280 msc->scroll_jiffies = now;
281 input_report_rel(input, REL_WHEEL, step_y);
282 }
283 break;
284 }
285 }
286
287 if (down)
288 msc->ntouches++;
289
290 input_mt_slot(input, id);
291 input_mt_report_slot_state(input, MT_TOOL_FINGER, down);
292
293
294 if (down) {
295 input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2);
296 input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2);
297 input_report_abs(input, ABS_MT_ORIENTATION, -orientation);
298 input_report_abs(input, ABS_MT_POSITION_X, x);
299 input_report_abs(input, ABS_MT_POSITION_Y, y);
300
301 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
302 input_report_abs(input, ABS_MT_PRESSURE, pressure);
303
304 if (report_undeciphered) {
305 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
306 input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2)
307 input_event(input, EV_MSC, MSC_RAW, tdata[7]);
308 else if (input->id.product !=
309 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
310 input_event(input, EV_MSC, MSC_RAW, tdata[8]);
311 }
312 }
313}
314
315static int magicmouse_raw_event(struct hid_device *hdev,
316 struct hid_report *report, u8 *data, int size)
317{
318 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
319 struct input_dev *input = msc->input;
320 int x = 0, y = 0, ii, clicks = 0, npoints;
321
322 switch (data[0]) {
323 case TRACKPAD_REPORT_ID:
324 case TRACKPAD2_BT_REPORT_ID:
325
326 if (size < 4 || ((size - 4) % 9) != 0)
327 return 0;
328 npoints = (size - 4) / 9;
329 if (npoints > 15) {
330 hid_warn(hdev, "invalid size value (%d) for TRACKPAD_REPORT_ID\n",
331 size);
332 return 0;
333 }
334 msc->ntouches = 0;
335 for (ii = 0; ii < npoints; ii++)
336 magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);
337
338 clicks = data[1];
339
340
341
342
343
344
345 break;
346 case TRACKPAD2_USB_REPORT_ID:
347
348 if (size < 12 || ((size - 12) % 9) != 0)
349 return 0;
350 npoints = (size - 12) / 9;
351 if (npoints > 15) {
352 hid_warn(hdev, "invalid size value (%d) for TRACKPAD2_USB_REPORT_ID\n",
353 size);
354 return 0;
355 }
356 msc->ntouches = 0;
357 for (ii = 0; ii < npoints; ii++)
358 magicmouse_emit_touch(msc, ii, data + ii * 9 + 12);
359
360 clicks = data[1];
361 break;
362 case MOUSE_REPORT_ID:
363
364 if (size < 6 || ((size - 6) % 8) != 0)
365 return 0;
366 npoints = (size - 6) / 8;
367 if (npoints > 15) {
368 hid_warn(hdev, "invalid size value (%d) for MOUSE_REPORT_ID\n",
369 size);
370 return 0;
371 }
372 msc->ntouches = 0;
373 for (ii = 0; ii < npoints; ii++)
374 magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
375
376
377
378
379
380 x = (int)(((data[3] & 0x0c) << 28) | (data[1] << 22)) >> 22;
381 y = (int)(((data[3] & 0x30) << 26) | (data[2] << 22)) >> 22;
382 clicks = data[3];
383
384
385
386
387
388
389 break;
390 case MOUSE2_REPORT_ID:
391
392 if (size != 8 && (size < 14 || (size - 14) % 8 != 0))
393 return 0;
394 npoints = (size - 14) / 8;
395 if (npoints > 15) {
396 hid_warn(hdev, "invalid size value (%d) for MOUSE2_REPORT_ID\n",
397 size);
398 return 0;
399 }
400 msc->ntouches = 0;
401 for (ii = 0; ii < npoints; ii++)
402 magicmouse_emit_touch(msc, ii, data + ii * 8 + 14);
403
404
405
406
407
408 x = (int)((data[3] << 24) | (data[2] << 16)) >> 16;
409 y = (int)((data[5] << 24) | (data[4] << 16)) >> 16;
410 clicks = data[1];
411
412
413
414
415
416
417 break;
418 case DOUBLE_REPORT_ID:
419
420
421
422 magicmouse_raw_event(hdev, report, data + 2, data[1]);
423 magicmouse_raw_event(hdev, report, data + 2 + data[1],
424 size - 2 - data[1]);
425 break;
426 default:
427 return 0;
428 }
429
430 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
431 input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
432 magicmouse_emit_buttons(msc, clicks & 3);
433 input_report_rel(input, REL_X, x);
434 input_report_rel(input, REL_Y, y);
435 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
436 input_mt_sync_frame(input);
437 input_report_key(input, BTN_MOUSE, clicks & 1);
438 } else {
439 input_report_key(input, BTN_MOUSE, clicks & 1);
440 input_mt_report_pointer_emulation(input, true);
441 }
442
443 input_sync(input);
444 return 1;
445}
446
447static int magicmouse_event(struct hid_device *hdev, struct hid_field *field,
448 struct hid_usage *usage, __s32 value)
449{
450 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
451 if (msc->input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2 &&
452 field->report->id == MOUSE2_REPORT_ID) {
453
454
455
456
457
458
459 return 1;
460 }
461 return 0;
462}
463
464static int magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
465{
466 int error;
467 int mt_flags = 0;
468
469 __set_bit(EV_KEY, input->evbit);
470
471 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
472 input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
473 __set_bit(BTN_LEFT, input->keybit);
474 __set_bit(BTN_RIGHT, input->keybit);
475 if (emulate_3button)
476 __set_bit(BTN_MIDDLE, input->keybit);
477
478 __set_bit(EV_REL, input->evbit);
479 __set_bit(REL_X, input->relbit);
480 __set_bit(REL_Y, input->relbit);
481 if (emulate_scroll_wheel) {
482 __set_bit(REL_WHEEL, input->relbit);
483 __set_bit(REL_HWHEEL, input->relbit);
484 }
485 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
486
487
488
489 input->name = "Apple Inc. Magic Trackpad 2";
490
491 __clear_bit(EV_MSC, input->evbit);
492 __clear_bit(BTN_0, input->keybit);
493 __clear_bit(BTN_RIGHT, input->keybit);
494 __clear_bit(BTN_MIDDLE, input->keybit);
495 __set_bit(BTN_MOUSE, input->keybit);
496 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
497 __set_bit(BTN_TOOL_FINGER, input->keybit);
498
499 mt_flags = INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
500 INPUT_MT_TRACK;
501 } else {
502
503
504
505
506
507 __clear_bit(BTN_RIGHT, input->keybit);
508 __clear_bit(BTN_MIDDLE, input->keybit);
509 __set_bit(BTN_MOUSE, input->keybit);
510 __set_bit(BTN_TOOL_FINGER, input->keybit);
511 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
512 __set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
513 __set_bit(BTN_TOOL_QUADTAP, input->keybit);
514 __set_bit(BTN_TOOL_QUINTTAP, input->keybit);
515 __set_bit(BTN_TOUCH, input->keybit);
516 __set_bit(INPUT_PROP_POINTER, input->propbit);
517 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
518 }
519
520
521 __set_bit(EV_ABS, input->evbit);
522
523 error = input_mt_init_slots(input, 16, mt_flags);
524 if (error)
525 return error;
526 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255 << 2,
527 4, 0);
528 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255 << 2,
529 4, 0);
530
531
532
533
534
535
536
537 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE ||
538 input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
539 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
540 input_set_abs_params(input, ABS_MT_POSITION_X,
541 MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
542 input_set_abs_params(input, ABS_MT_POSITION_Y,
543 MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
544
545 input_abs_set_res(input, ABS_MT_POSITION_X,
546 MOUSE_RES_X);
547 input_abs_set_res(input, ABS_MT_POSITION_Y,
548 MOUSE_RES_Y);
549 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
550 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 253, 0, 0);
551 input_set_abs_params(input, ABS_PRESSURE, 0, 253, 0, 0);
552 input_set_abs_params(input, ABS_MT_ORIENTATION, -3, 4, 0, 0);
553 input_set_abs_params(input, ABS_X, TRACKPAD2_MIN_X,
554 TRACKPAD2_MAX_X, 0, 0);
555 input_set_abs_params(input, ABS_Y, TRACKPAD2_MIN_Y,
556 TRACKPAD2_MAX_Y, 0, 0);
557 input_set_abs_params(input, ABS_MT_POSITION_X,
558 TRACKPAD2_MIN_X, TRACKPAD2_MAX_X, 0, 0);
559 input_set_abs_params(input, ABS_MT_POSITION_Y,
560 TRACKPAD2_MIN_Y, TRACKPAD2_MAX_Y, 0, 0);
561
562 input_abs_set_res(input, ABS_X, TRACKPAD2_RES_X);
563 input_abs_set_res(input, ABS_Y, TRACKPAD2_RES_Y);
564 input_abs_set_res(input, ABS_MT_POSITION_X, TRACKPAD2_RES_X);
565 input_abs_set_res(input, ABS_MT_POSITION_Y, TRACKPAD2_RES_Y);
566 } else {
567 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
568 input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
569 TRACKPAD_MAX_X, 4, 0);
570 input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
571 TRACKPAD_MAX_Y, 4, 0);
572 input_set_abs_params(input, ABS_MT_POSITION_X,
573 TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
574 input_set_abs_params(input, ABS_MT_POSITION_Y,
575 TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
576
577 input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
578 input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
579 input_abs_set_res(input, ABS_MT_POSITION_X,
580 TRACKPAD_RES_X);
581 input_abs_set_res(input, ABS_MT_POSITION_Y,
582 TRACKPAD_RES_Y);
583 }
584
585 input_set_events_per_packet(input, 60);
586
587 if (report_undeciphered &&
588 input->id.product != USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
589 __set_bit(EV_MSC, input->evbit);
590 __set_bit(MSC_RAW, input->mscbit);
591 }
592
593
594
595
596
597 __clear_bit(EV_REP, input->evbit);
598
599 return 0;
600}
601
602static int magicmouse_input_mapping(struct hid_device *hdev,
603 struct hid_input *hi, struct hid_field *field,
604 struct hid_usage *usage, unsigned long **bit, int *max)
605{
606 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
607
608 if (!msc->input)
609 msc->input = hi->input;
610
611
612 if ((hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD ||
613 hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) &&
614 field->flags & HID_MAIN_ITEM_RELATIVE)
615 return -1;
616
617 return 0;
618}
619
620static int magicmouse_input_configured(struct hid_device *hdev,
621 struct hid_input *hi)
622
623{
624 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
625 int ret;
626
627 ret = magicmouse_setup_input(msc->input, hdev);
628 if (ret) {
629 hid_err(hdev, "magicmouse setup input failed (%d)\n", ret);
630
631 msc->input = NULL;
632 return ret;
633 }
634
635 return 0;
636}
637
638static int magicmouse_enable_multitouch(struct hid_device *hdev)
639{
640 const u8 *feature;
641 const u8 feature_mt[] = { 0xD7, 0x01 };
642 const u8 feature_mt_mouse2[] = { 0xF1, 0x02, 0x01 };
643 const u8 feature_mt_trackpad2_usb[] = { 0x02, 0x01 };
644 const u8 feature_mt_trackpad2_bt[] = { 0xF1, 0x02, 0x01 };
645 u8 *buf;
646 int ret;
647 int feature_size;
648
649 if (hdev->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
650 if (hdev->vendor == BT_VENDOR_ID_APPLE) {
651 feature_size = sizeof(feature_mt_trackpad2_bt);
652 feature = feature_mt_trackpad2_bt;
653 } else {
654 feature_size = sizeof(feature_mt_trackpad2_usb);
655 feature = feature_mt_trackpad2_usb;
656 }
657 } else if (hdev->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
658 feature_size = sizeof(feature_mt_mouse2);
659 feature = feature_mt_mouse2;
660 } else {
661 feature_size = sizeof(feature_mt);
662 feature = feature_mt;
663 }
664
665 buf = kmemdup(feature, feature_size, GFP_KERNEL);
666 if (!buf)
667 return -ENOMEM;
668
669 ret = hid_hw_raw_request(hdev, buf[0], buf, feature_size,
670 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
671 kfree(buf);
672 return ret;
673}
674
675static void magicmouse_enable_mt_work(struct work_struct *work)
676{
677 struct magicmouse_sc *msc =
678 container_of(work, struct magicmouse_sc, work.work);
679 int ret;
680
681 ret = magicmouse_enable_multitouch(msc->hdev);
682 if (ret < 0)
683 hid_err(msc->hdev, "unable to request touch data (%d)\n", ret);
684}
685
686static int magicmouse_probe(struct hid_device *hdev,
687 const struct hid_device_id *id)
688{
689 struct magicmouse_sc *msc;
690 struct hid_report *report;
691 int ret;
692
693 if (id->vendor == USB_VENDOR_ID_APPLE &&
694 id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2 &&
695 hdev->type != HID_TYPE_USBMOUSE)
696 return -ENODEV;
697
698 msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);
699 if (msc == NULL) {
700 hid_err(hdev, "can't alloc magicmouse descriptor\n");
701 return -ENOMEM;
702 }
703
704 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
705 msc->hdev = hdev;
706 INIT_DEFERRABLE_WORK(&msc->work, magicmouse_enable_mt_work);
707
708 msc->quirks = id->driver_data;
709 hid_set_drvdata(hdev, msc);
710
711 ret = hid_parse(hdev);
712 if (ret) {
713 hid_err(hdev, "magicmouse hid parse failed\n");
714 return ret;
715 }
716
717 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
718 if (ret) {
719 hid_err(hdev, "magicmouse hw start failed\n");
720 return ret;
721 }
722
723 if (!msc->input) {
724 hid_err(hdev, "magicmouse input not registered\n");
725 ret = -ENOMEM;
726 goto err_stop_hw;
727 }
728
729 if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
730 report = hid_register_report(hdev, HID_INPUT_REPORT,
731 MOUSE_REPORT_ID, 0);
732 else if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2)
733 report = hid_register_report(hdev, HID_INPUT_REPORT,
734 MOUSE2_REPORT_ID, 0);
735 else if (id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
736 if (id->vendor == BT_VENDOR_ID_APPLE)
737 report = hid_register_report(hdev, HID_INPUT_REPORT,
738 TRACKPAD2_BT_REPORT_ID, 0);
739 else
740 report = hid_register_report(hdev, HID_INPUT_REPORT,
741 TRACKPAD2_USB_REPORT_ID, 0);
742 } else {
743 report = hid_register_report(hdev, HID_INPUT_REPORT,
744 TRACKPAD_REPORT_ID, 0);
745 report = hid_register_report(hdev, HID_INPUT_REPORT,
746 DOUBLE_REPORT_ID, 0);
747 }
748
749 if (!report) {
750 hid_err(hdev, "unable to register touch report\n");
751 ret = -ENOMEM;
752 goto err_stop_hw;
753 }
754 report->size = 6;
755
756
757
758
759
760
761
762
763
764 ret = magicmouse_enable_multitouch(hdev);
765 if (ret != -EIO && ret < 0) {
766 hid_err(hdev, "unable to request touch data (%d)\n", ret);
767 goto err_stop_hw;
768 }
769 if (ret == -EIO && id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE2) {
770 schedule_delayed_work(&msc->work, msecs_to_jiffies(500));
771 }
772
773 return 0;
774err_stop_hw:
775 hid_hw_stop(hdev);
776 return ret;
777}
778
779static void magicmouse_remove(struct hid_device *hdev)
780{
781 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
782
783 if (msc)
784 cancel_delayed_work_sync(&msc->work);
785
786 hid_hw_stop(hdev);
787}
788
789static const struct hid_device_id magic_mice[] = {
790 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
791 USB_DEVICE_ID_APPLE_MAGICMOUSE), .driver_data = 0 },
792 { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE,
793 USB_DEVICE_ID_APPLE_MAGICMOUSE2), .driver_data = 0 },
794 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
795 USB_DEVICE_ID_APPLE_MAGICTRACKPAD), .driver_data = 0 },
796 { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE,
797 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
798 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE,
799 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
800 { }
801};
802MODULE_DEVICE_TABLE(hid, magic_mice);
803
804static struct hid_driver magicmouse_driver = {
805 .name = "magicmouse",
806 .id_table = magic_mice,
807 .probe = magicmouse_probe,
808 .remove = magicmouse_remove,
809 .raw_event = magicmouse_raw_event,
810 .event = magicmouse_event,
811 .input_mapping = magicmouse_input_mapping,
812 .input_configured = magicmouse_input_configured,
813};
814module_hid_driver(magicmouse_driver);
815
816MODULE_LICENSE("GPL");
817