1/*
2 * Apple "Magic" Wireless Mouse driver
3 *
4 * Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
5 * Copyright (c) 2010 Chase Douglas <chase.douglas@canonical.com>
6 */
7
8/*
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 */
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <linux/device.h>
18#include <linux/hid.h>
19#include <linux/input/mt.h>
20#include <linux/module.h>
21#include <linux/slab.h>
22
23#include "hid-ids.h"
24
25static bool emulate_3button = true;
26module_param(emulate_3button, bool, 0644);
27MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");
28
29static int middle_button_start = -350;
30static int middle_button_stop = +350;
31
32static bool emulate_scroll_wheel = true;
33module_param(emulate_scroll_wheel, bool, 0644);
34MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");
35
36static unsigned int scroll_speed = 32;
37static int param_set_scroll_speed(const char *val,
38 const struct kernel_param *kp) {
39 unsigned long speed;
40 if (!val || kstrtoul(val, 0, &speed) || speed > 63)
41 return -EINVAL;
42 scroll_speed = speed;
43 return 0;
44}
45module_param_call(scroll_speed, param_set_scroll_speed, param_get_uint, &scroll_speed, 0644);
46MODULE_PARM_DESC(scroll_speed, "Scroll speed, value from 0 (slow) to 63 (fast)");
47
48static bool scroll_acceleration = false;
49module_param(scroll_acceleration, bool, 0644);
50MODULE_PARM_DESC(scroll_acceleration, "Accelerate sequential scroll events");
51
52static bool report_undeciphered;
53module_param(report_undeciphered, bool, 0644);
54MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");
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 DOUBLE_REPORT_ID 0xf7
61/* These definitions are not precise, but they're close enough. (Bits
62 * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
63 * to be some kind of bit mask -- 0x20 may be a near-field reading,
64 * and 0x40 is actual contact, and 0x10 may be a start/stop or change
65 * indication.)
66 */
67#define TOUCH_STATE_MASK 0xf0
68#define TOUCH_STATE_NONE 0x00
69#define TOUCH_STATE_START 0x30
70#define TOUCH_STATE_DRAG 0x40
71
72#define SCROLL_ACCEL_DEFAULT 7
73
74/* Touch surface information. Dimension is in hundredths of a mm, min and max
75 * are in units. */
76#define MOUSE_DIMENSION_X (float)9056
77#define MOUSE_MIN_X -1100
78#define MOUSE_MAX_X 1258
79#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
80#define MOUSE_DIMENSION_Y (float)5152
81#define MOUSE_MIN_Y -1589
82#define MOUSE_MAX_Y 2047
83#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
84
85#define TRACKPAD_DIMENSION_X (float)13000
86#define TRACKPAD_MIN_X -2909
87#define TRACKPAD_MAX_X 3167
88#define TRACKPAD_RES_X \
89 ((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
90#define TRACKPAD_DIMENSION_Y (float)11000
91#define TRACKPAD_MIN_Y -2456
92#define TRACKPAD_MAX_Y 2565
93#define TRACKPAD_RES_Y \
94 ((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
95
96#define TRACKPAD2_DIMENSION_X (float)16000
97#define TRACKPAD2_MIN_X -3678
98#define TRACKPAD2_MAX_X 3934
99#define TRACKPAD2_RES_X \
100 ((TRACKPAD2_MAX_X - TRACKPAD2_MIN_X) / (TRACKPAD2_DIMENSION_X / 100))
101#define TRACKPAD2_DIMENSION_Y (float)11490
102#define TRACKPAD2_MIN_Y -2478
103#define TRACKPAD2_MAX_Y 2587
104#define TRACKPAD2_RES_Y \
105 ((TRACKPAD2_MAX_Y - TRACKPAD2_MIN_Y) / (TRACKPAD2_DIMENSION_Y / 100))
106
107/**
108 * struct magicmouse_sc - Tracks Magic Mouse-specific data.
109 * @input: Input device through which we report events.
110 * @quirks: Currently unused.
111 * @ntouches: Number of touches in most recent touch report.
112 * @scroll_accel: Number of consecutive scroll motions.
113 * @scroll_jiffies: Time of last scroll motion.
114 * @touches: Most recent data for a touch, indexed by tracking ID.
115 * @tracking_ids: Mapping of current touch input data to @touches.
116 */
117struct magicmouse_sc {
118 struct input_dev *input;
119 unsigned long quirks;
120
121 int ntouches;
122 int scroll_accel;
123 unsigned long scroll_jiffies;
124
125 struct {
126 short x;
127 short y;
128 short scroll_x;
129 short scroll_y;
130 u8 size;
131 } touches[16];
132 int tracking_ids[16];
133};
134
135static int magicmouse_firm_touch(struct magicmouse_sc *msc)
136{
137 int touch = -1;
138 int ii;
139
140 /* If there is only one "firm" touch, set touch to its
141 * tracking ID.
142 */
143 for (ii = 0; ii < msc->ntouches; ii++) {
144 int idx = msc->tracking_ids[ii];
145 if (msc->touches[idx].size < 8) {
146 /* Ignore this touch. */
147 } else if (touch >= 0) {
148 touch = -1;
149 break;
150 } else {
151 touch = idx;
152 }
153 }
154
155 return touch;
156}
157
158static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
159{
160 int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |
161 test_bit(BTN_RIGHT, msc->input->key) << 1 |
162 test_bit(BTN_MIDDLE, msc->input->key) << 2;
163
164 if (emulate_3button) {
165 int id;
166
167 /* If some button was pressed before, keep it held
168 * down. Otherwise, if there's exactly one firm
169 * touch, use that to override the mouse's guess.
170 */
171 if (state == 0) {
172 /* The button was released. */
173 } else if (last_state != 0) {
174 state = last_state;
175 } else if ((id = magicmouse_firm_touch(msc)) >= 0) {
176 int x = msc->touches[id].x;
177 if (x < middle_button_start)
178 state = 1;
179 else if (x > middle_button_stop)
180 state = 2;
181 else
182 state = 4;
183 } /* else: we keep the mouse's guess */
184
185 input_report_key(msc->input, BTN_MIDDLE, state & 4);
186 }
187
188 input_report_key(msc->input, BTN_LEFT, state & 1);
189 input_report_key(msc->input, BTN_RIGHT, state & 2);
190
191 if (state != last_state)
192 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
193}
194
195static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
196{
197 struct input_dev *input = msc->input;
198 int id, x, y, size, orientation, touch_major, touch_minor, state, down;
199 int pressure = 0;
200
201 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
202 id = (tdata[6] << 2 | tdata[5] >> 6) & 0xf;
203 x = (tdata[1] << 28 | tdata[0] << 20) >> 20;
204 y = -((tdata[2] << 24 | tdata[1] << 16) >> 20);
205 size = tdata[5] & 0x3f;
206 orientation = (tdata[6] >> 2) - 32;
207 touch_major = tdata[3];
208 touch_minor = tdata[4];
209 state = tdata[7] & TOUCH_STATE_MASK;
210 down = state != TOUCH_STATE_NONE;
211 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
212 id = tdata[8] & 0xf;
213 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
214 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
215 size = tdata[6];
216 orientation = (tdata[8] >> 5) - 4;
217 touch_major = tdata[4];
218 touch_minor = tdata[5];
219 pressure = tdata[7];
220 state = tdata[3] & 0xC0;
221 down = state == 0x80;
222 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
223 id = (tdata[7] << 2 | tdata[6] >> 6) & 0xf;
224 x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
225 y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
226 size = tdata[6] & 0x3f;
227 orientation = (tdata[7] >> 2) - 32;
228 touch_major = tdata[4];
229 touch_minor = tdata[5];
230 state = tdata[8] & TOUCH_STATE_MASK;
231 down = state != TOUCH_STATE_NONE;
232 }
233
234 /* Store tracking ID and other fields. */
235 msc->tracking_ids[raw_id] = id;
236 msc->touches[id].x = x;
237 msc->touches[id].y = y;
238 msc->touches[id].size = size;
239
240 /* If requested, emulate a scroll wheel by detecting small
241 * vertical touch motions.
242 */
243 if (emulate_scroll_wheel && (input->id.product !=
244 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)) {
245 unsigned long now = jiffies;
246 int step_x = msc->touches[id].scroll_x - x;
247 int step_y = msc->touches[id].scroll_y - y;
248
249 /* Calculate and apply the scroll motion. */
250 switch (state) {
251 case TOUCH_STATE_START:
252 msc->touches[id].scroll_x = x;
253 msc->touches[id].scroll_y = y;
254
255 /* Reset acceleration after half a second. */
256 if (scroll_acceleration && time_before(now,
257 msc->scroll_jiffies + HZ / 2))
258 msc->scroll_accel = max_t(int,
259 msc->scroll_accel - 1, 1);
260 else
261 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
262
263 break;
264 case TOUCH_STATE_DRAG:
265 step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
266 if (step_x != 0) {
267 msc->touches[id].scroll_x -= step_x *
268 (64 - scroll_speed) * msc->scroll_accel;
269 msc->scroll_jiffies = now;
270 input_report_rel(input, REL_HWHEEL, -step_x);
271 }
272
273 step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;
274 if (step_y != 0) {
275 msc->touches[id].scroll_y -= step_y *
276 (64 - scroll_speed) * msc->scroll_accel;
277 msc->scroll_jiffies = now;
278 input_report_rel(input, REL_WHEEL, step_y);
279 }
280 break;
281 }
282 }
283
284 if (down)
285 msc->ntouches++;
286
287 input_mt_slot(input, id);
288 input_mt_report_slot_state(input, MT_TOOL_FINGER, down);
289
290 /* Generate the input events for this touch. */
291 if (down) {
292 input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2);
293 input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2);
294 input_report_abs(input, ABS_MT_ORIENTATION, -orientation);
295 input_report_abs(input, ABS_MT_POSITION_X, x);
296 input_report_abs(input, ABS_MT_POSITION_Y, y);
297
298 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
299 input_report_abs(input, ABS_MT_PRESSURE, pressure);
300
301 if (report_undeciphered) {
302 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
303 input_event(input, EV_MSC, MSC_RAW, tdata[7]);
304 else if (input->id.product !=
305 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2)
306 input_event(input, EV_MSC, MSC_RAW, tdata[8]);
307 }
308 }
309}
310
311static int magicmouse_raw_event(struct hid_device *hdev,
312 struct hid_report *report, u8 *data, int size)
313{
314 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
315 struct input_dev *input = msc->input;
316 int x = 0, y = 0, ii, clicks = 0, npoints;
317
318 switch (data[0]) {
319 case TRACKPAD_REPORT_ID:
320 case TRACKPAD2_BT_REPORT_ID:
321 /* Expect four bytes of prefix, and N*9 bytes of touch data. */
322 if (size < 4 || ((size - 4) % 9) != 0)
323 return 0;
324 npoints = (size - 4) / 9;
325 if (npoints > 15) {
326 hid_warn(hdev, "invalid size value (%d) for TRACKPAD_REPORT_ID\n",
327 size);
328 return 0;
329 }
330 msc->ntouches = 0;
331 for (ii = 0; ii < npoints; ii++)
332 magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);
333
334 clicks = data[1];
335
336 /* The following bits provide a device specific timestamp. They
337 * are unused here.
338 *
339 * ts = data[1] >> 6 | data[2] << 2 | data[3] << 10;
340 */
341 break;
342 case TRACKPAD2_USB_REPORT_ID:
343 /* Expect twelve bytes of prefix and N*9 bytes of touch data. */
344 if (size < 12 || ((size - 12) % 9) != 0)
345 return 0;
346 npoints = (size - 12) / 9;
347 if (npoints > 15) {
348 hid_warn(hdev, "invalid size value (%d) for TRACKPAD2_USB_REPORT_ID\n",
349 size);
350 return 0;
351 }
352 msc->ntouches = 0;
353 for (ii = 0; ii < npoints; ii++)
354 magicmouse_emit_touch(msc, ii, data + ii * 9 + 12);
355
356 clicks = data[1];
357 break;
358 case MOUSE_REPORT_ID:
359 /* Expect six bytes of prefix, and N*8 bytes of touch data. */
360 if (size < 6 || ((size - 6) % 8) != 0)
361 return 0;
362 npoints = (size - 6) / 8;
363 if (npoints > 15) {
364 hid_warn(hdev, "invalid size value (%d) for MOUSE_REPORT_ID\n",
365 size);
366 return 0;
367 }
368 msc->ntouches = 0;
369 for (ii = 0; ii < npoints; ii++)
370 magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
371
372 /* When emulating three-button mode, it is important
373 * to have the current touch information before
374 * generating a click event.
375 */
376 x = (int)(((data[3] & 0x0c) << 28) | (data[1] << 22)) >> 22;
377 y = (int)(((data[3] & 0x30) << 26) | (data[2] << 22)) >> 22;
378 clicks = data[3];
379
380 /* The following bits provide a device specific timestamp. They
381 * are unused here.
382 *
383 * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
384 */
385 break;
386 case DOUBLE_REPORT_ID:
387 /* Sometimes the trackpad sends two touch reports in one
388 * packet.
389 */
390 magicmouse_raw_event(hdev, report, data + 2, data[1]);
391 magicmouse_raw_event(hdev, report, data + 2 + data[1],
392 size - 2 - data[1]);
393 break;
394 default:
395 return 0;
396 }
397
398 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
399 magicmouse_emit_buttons(msc, clicks & 3);
400 input_report_rel(input, REL_X, x);
401 input_report_rel(input, REL_Y, y);
402 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
403 input_mt_sync_frame(input);
404 input_report_key(input, BTN_MOUSE, clicks & 1);
405 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
406 input_report_key(input, BTN_MOUSE, clicks & 1);
407 input_mt_report_pointer_emulation(input, true);
408 }
409
410 input_sync(input);
411 return 1;
412}
413
414static int magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
415{
416 int error;
417 int mt_flags = 0;
418
419 __set_bit(EV_KEY, input->evbit);
420
421 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
422 __set_bit(BTN_LEFT, input->keybit);
423 __set_bit(BTN_RIGHT, input->keybit);
424 if (emulate_3button)
425 __set_bit(BTN_MIDDLE, input->keybit);
426
427 __set_bit(EV_REL, input->evbit);
428 __set_bit(REL_X, input->relbit);
429 __set_bit(REL_Y, input->relbit);
430 if (emulate_scroll_wheel) {
431 __set_bit(REL_WHEEL, input->relbit);
432 __set_bit(REL_HWHEEL, input->relbit);
433 }
434 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
435 /* setting the device name to ensure the same driver settings
436 * get loaded, whether connected through bluetooth or USB
437 */
438 input->name = "Apple Inc. Magic Trackpad 2";
439
440 __clear_bit(EV_MSC, input->evbit);
441 __clear_bit(BTN_0, input->keybit);
442 __clear_bit(BTN_RIGHT, input->keybit);
443 __clear_bit(BTN_MIDDLE, input->keybit);
444 __set_bit(BTN_MOUSE, input->keybit);
445 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
446 __set_bit(BTN_TOOL_FINGER, input->keybit);
447
448 mt_flags = INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
449 INPUT_MT_TRACK;
450 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
451 /* input->keybit is initialized with incorrect button info
452 * for Magic Trackpad. There really is only one physical
453 * button (BTN_LEFT == BTN_MOUSE). Make sure we don't
454 * advertise buttons that don't exist...
455 */
456 __clear_bit(BTN_RIGHT, input->keybit);
457 __clear_bit(BTN_MIDDLE, input->keybit);
458 __set_bit(BTN_MOUSE, input->keybit);
459 __set_bit(BTN_TOOL_FINGER, input->keybit);
460 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
461 __set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
462 __set_bit(BTN_TOOL_QUADTAP, input->keybit);
463 __set_bit(BTN_TOOL_QUINTTAP, input->keybit);
464 __set_bit(BTN_TOUCH, input->keybit);
465 __set_bit(INPUT_PROP_POINTER, input->propbit);
466 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
467 }
468
469
470 __set_bit(EV_ABS, input->evbit);
471
472 error = input_mt_init_slots(input, 16, mt_flags);
473 if (error)
474 return error;
475 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255 << 2,
476 4, 0);
477 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255 << 2,
478 4, 0);
479
480 /* Note: Touch Y position from the device is inverted relative
481 * to how pointer motion is reported (and relative to how USB
482 * HID recommends the coordinates work). This driver keeps
483 * the origin at the same position, and just uses the additive
484 * inverse of the reported Y.
485 */
486 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
487 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
488 input_set_abs_params(input, ABS_MT_POSITION_X,
489 MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
490 input_set_abs_params(input, ABS_MT_POSITION_Y,
491 MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
492
493 input_abs_set_res(input, ABS_MT_POSITION_X,
494 MOUSE_RES_X);
495 input_abs_set_res(input, ABS_MT_POSITION_Y,
496 MOUSE_RES_Y);
497 } else if (input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
498 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 253, 0, 0);
499 input_set_abs_params(input, ABS_PRESSURE, 0, 253, 0, 0);
500 input_set_abs_params(input, ABS_MT_ORIENTATION, -3, 4, 0, 0);
501 input_set_abs_params(input, ABS_X, TRACKPAD2_MIN_X,
502 TRACKPAD2_MAX_X, 0, 0);
503 input_set_abs_params(input, ABS_Y, TRACKPAD2_MIN_Y,
504 TRACKPAD2_MAX_Y, 0, 0);
505 input_set_abs_params(input, ABS_MT_POSITION_X,
506 TRACKPAD2_MIN_X, TRACKPAD2_MAX_X, 0, 0);
507 input_set_abs_params(input, ABS_MT_POSITION_Y,
508 TRACKPAD2_MIN_Y, TRACKPAD2_MAX_Y, 0, 0);
509
510 input_abs_set_res(input, ABS_X, TRACKPAD2_RES_X);
511 input_abs_set_res(input, ABS_Y, TRACKPAD2_RES_Y);
512 input_abs_set_res(input, ABS_MT_POSITION_X, TRACKPAD2_RES_X);
513 input_abs_set_res(input, ABS_MT_POSITION_Y, TRACKPAD2_RES_Y);
514 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
515 input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
516 input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
517 TRACKPAD_MAX_X, 4, 0);
518 input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
519 TRACKPAD_MAX_Y, 4, 0);
520 input_set_abs_params(input, ABS_MT_POSITION_X,
521 TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
522 input_set_abs_params(input, ABS_MT_POSITION_Y,
523 TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
524
525 input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
526 input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
527 input_abs_set_res(input, ABS_MT_POSITION_X,
528 TRACKPAD_RES_X);
529 input_abs_set_res(input, ABS_MT_POSITION_Y,
530 TRACKPAD_RES_Y);
531 }
532
533 input_set_events_per_packet(input, 60);
534
535 if (report_undeciphered &&
536 input->id.product != USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
537 __set_bit(EV_MSC, input->evbit);
538 __set_bit(MSC_RAW, input->mscbit);
539 }
540
541 return 0;
542}
543
544static int magicmouse_input_mapping(struct hid_device *hdev,
545 struct hid_input *hi, struct hid_field *field,
546 struct hid_usage *usage, unsigned long **bit, int *max)
547{
548 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
549
550 if (!msc->input)
551 msc->input = hi->input;
552
553 /* Magic Trackpad does not give relative data after switching to MT */
554 if ((hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD ||
555 hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) &&
556 field->flags & HID_MAIN_ITEM_RELATIVE)
557 return -1;
558
559 return 0;
560}
561
562static int magicmouse_input_configured(struct hid_device *hdev,
563 struct hid_input *hi)
564
565{
566 struct magicmouse_sc *msc = hid_get_drvdata(hdev);
567 int ret;
568
569 ret = magicmouse_setup_input(msc->input, hdev);
570 if (ret) {
571 hid_err(hdev, "magicmouse setup input failed (%d)\n", ret);
572 /* clean msc->input to notify probe() of the failure */
573 msc->input = NULL;
574 return ret;
575 }
576
577 return 0;
578}
579
580
581static int magicmouse_probe(struct hid_device *hdev,
582 const struct hid_device_id *id)
583{
584 const u8 *feature;
585 const u8 feature_mt[] = { 0xD7, 0x01 };
586 const u8 feature_mt_trackpad2_usb[] = { 0x02, 0x01 };
587 const u8 feature_mt_trackpad2_bt[] = { 0xF1, 0x02, 0x01 };
588 u8 *buf;
589 struct magicmouse_sc *msc;
590 struct hid_report *report;
591 int ret;
592 int feature_size;
593
594 if (id->vendor == USB_VENDOR_ID_APPLE &&
595 id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2 &&
596 hdev->type != HID_TYPE_USBMOUSE)
597 return 0;
598
599 msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);
600 if (msc == NULL) {
601 hid_err(hdev, "can't alloc magicmouse descriptor\n");
602 return -ENOMEM;
603 }
604
605 msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
606
607 msc->quirks = id->driver_data;
608 hid_set_drvdata(hdev, msc);
609
610 ret = hid_parse(hdev);
611 if (ret) {
612 hid_err(hdev, "magicmouse hid parse failed\n");
613 return ret;
614 }
615
616 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
617 if (ret) {
618 hid_err(hdev, "magicmouse hw start failed\n");
619 return ret;
620 }
621
622 if (!msc->input) {
623 hid_err(hdev, "magicmouse input not registered\n");
624 ret = -ENOMEM;
625 goto err_stop_hw;
626 }
627
628 if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
629 report = hid_register_report(hdev, HID_INPUT_REPORT,
630 MOUSE_REPORT_ID, 0);
631 else if (id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
632 if (id->vendor == BT_VENDOR_ID_APPLE)
633 report = hid_register_report(hdev, HID_INPUT_REPORT,
634 TRACKPAD2_BT_REPORT_ID, 0);
635 else /* USB_VENDOR_ID_APPLE */
636 report = hid_register_report(hdev, HID_INPUT_REPORT,
637 TRACKPAD2_USB_REPORT_ID, 0);
638 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
639 report = hid_register_report(hdev, HID_INPUT_REPORT,
640 TRACKPAD_REPORT_ID, 0);
641 report = hid_register_report(hdev, HID_INPUT_REPORT,
642 DOUBLE_REPORT_ID, 0);
643 }
644
645 if (!report) {
646 hid_err(hdev, "unable to register touch report\n");
647 ret = -ENOMEM;
648 goto err_stop_hw;
649 }
650 report->size = 6;
651
652 if (id->product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD2) {
653 if (id->vendor == BT_VENDOR_ID_APPLE) {
654 feature_size = sizeof(feature_mt_trackpad2_bt);
655 feature = feature_mt_trackpad2_bt;
656 } else { /* USB_VENDOR_ID_APPLE */
657 feature_size = sizeof(feature_mt_trackpad2_usb);
658 feature = feature_mt_trackpad2_usb;
659 }
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 ret = -ENOMEM;
668 goto err_stop_hw;
669 }
670
671 /*
672 * Some devices repond with 'invalid report id' when feature
673 * report switching it into multitouch mode is sent to it.
674 *
675 * This results in -EIO from the _raw low-level transport callback,
676 * but there seems to be no other way of switching the mode.
677 * Thus the super-ugly hacky success check below.
678 */
679 ret = hid_hw_raw_request(hdev, buf[0], buf, feature_size,
680 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
681 kfree(buf);
682 if (ret != -EIO && ret != feature_size) {
683 hid_err(hdev, "unable to request touch data (%d)\n", ret);
684 goto err_stop_hw;
685 }
686
687 return 0;
688err_stop_hw:
689 hid_hw_stop(hdev);
690 return ret;
691}
692
693static const struct hid_device_id magic_mice[] = {
694 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
695 USB_DEVICE_ID_APPLE_MAGICMOUSE), .driver_data = 0 },
696 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
697 USB_DEVICE_ID_APPLE_MAGICTRACKPAD), .driver_data = 0 },
698 { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE,
699 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
700 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE,
701 USB_DEVICE_ID_APPLE_MAGICTRACKPAD2), .driver_data = 0 },
702 { }
703};
704MODULE_DEVICE_TABLE(hid, magic_mice);
705
706static struct hid_driver magicmouse_driver = {
707 .name = "magicmouse",
708 .id_table = magic_mice,
709 .probe = magicmouse_probe,
710 .raw_event = magicmouse_raw_event,
711 .input_mapping = magicmouse_input_mapping,
712 .input_configured = magicmouse_input_configured,
713};
714module_hid_driver(magicmouse_driver);
715
716MODULE_LICENSE("GPL");
717