2 * Apple "Magic" Wireless Mouse driver
4 * Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
5 * Copyright (c) 2010 Chase Douglas <chase.douglas@canonical.com>
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)
15 #include <linux/device.h>
16 #include <linux/hid.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/usb.h>
23 static bool emulate_3button
= true;
24 module_param(emulate_3button
, bool, 0644);
25 MODULE_PARM_DESC(emulate_3button
, "Emulate a middle button");
27 static int middle_button_start
= -350;
28 static int middle_button_stop
= +350;
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");
34 static unsigned int scroll_speed
= 32;
35 static int param_set_scroll_speed(const char *val
, struct kernel_param
*kp
) {
37 if (!val
|| strict_strtoul(val
, 0, &speed
) || speed
> 63)
42 module_param_call(scroll_speed
, param_set_scroll_speed
, param_get_uint
, &scroll_speed
, 0644);
43 MODULE_PARM_DESC(scroll_speed
, "Scroll speed, value from 0 (slow) to 63 (fast)");
45 static bool scroll_acceleration
= false;
46 module_param(scroll_acceleration
, bool, 0644);
47 MODULE_PARM_DESC(scroll_acceleration
, "Accelerate sequential scroll events");
49 static bool report_touches
= true;
50 module_param(report_touches
, bool, 0644);
51 MODULE_PARM_DESC(report_touches
, "Emit touch records (otherwise, only use them for emulation)");
53 static bool report_undeciphered
;
54 module_param(report_undeciphered
, bool, 0644);
55 MODULE_PARM_DESC(report_undeciphered
, "Report undeciphered multi-touch state field using a MSC_RAW event");
57 #define TRACKPAD_REPORT_ID 0x28
58 #define MOUSE_REPORT_ID 0x29
59 #define DOUBLE_REPORT_ID 0xf7
60 /* These definitions are not precise, but they're close enough. (Bits
61 * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
62 * to be some kind of bit mask -- 0x20 may be a near-field reading,
63 * and 0x40 is actual contact, and 0x10 may be a start/stop or change
66 #define TOUCH_STATE_MASK 0xf0
67 #define TOUCH_STATE_NONE 0x00
68 #define TOUCH_STATE_START 0x30
69 #define TOUCH_STATE_DRAG 0x40
71 #define SCROLL_ACCEL_DEFAULT 7
73 /* Single touch emulation should only begin when no touches are currently down.
74 * This is true when single_touch_id is equal to NO_TOUCHES. If multiple touches
75 * are down and the touch providing for single touch emulation is lifted,
76 * single_touch_id is equal to SINGLE_TOUCH_UP. While single touch emulation is
77 * occuring, single_touch_id corresponds with the tracking id of the touch used.
80 #define SINGLE_TOUCH_UP -2
83 * struct magicmouse_sc - Tracks Magic Mouse-specific data.
84 * @input: Input device through which we report events.
85 * @quirks: Currently unused.
86 * @ntouches: Number of touches in most recent touch report.
87 * @scroll_accel: Number of consecutive scroll motions.
88 * @scroll_jiffies: Time of last scroll motion.
89 * @touches: Most recent data for a touch, indexed by tracking ID.
90 * @tracking_ids: Mapping of current touch input data to @touches.
92 struct magicmouse_sc
{
93 struct input_dev
*input
;
98 unsigned long scroll_jiffies
;
107 int tracking_ids
[16];
111 static int magicmouse_firm_touch(struct magicmouse_sc
*msc
)
116 /* If there is only one "firm" touch, set touch to its
119 for (ii
= 0; ii
< msc
->ntouches
; ii
++) {
120 int idx
= msc
->tracking_ids
[ii
];
121 if (msc
->touches
[idx
].size
< 8) {
122 /* Ignore this touch. */
123 } else if (touch
>= 0) {
134 static void magicmouse_emit_buttons(struct magicmouse_sc
*msc
, int state
)
136 int last_state
= test_bit(BTN_LEFT
, msc
->input
->key
) << 0 |
137 test_bit(BTN_RIGHT
, msc
->input
->key
) << 1 |
138 test_bit(BTN_MIDDLE
, msc
->input
->key
) << 2;
140 if (emulate_3button
) {
143 /* If some button was pressed before, keep it held
144 * down. Otherwise, if there's exactly one firm
145 * touch, use that to override the mouse's guess.
148 /* The button was released. */
149 } else if (last_state
!= 0) {
151 } else if ((id
= magicmouse_firm_touch(msc
)) >= 0) {
152 int x
= msc
->touches
[id
].x
;
153 if (x
< middle_button_start
)
155 else if (x
> middle_button_stop
)
159 } /* else: we keep the mouse's guess */
161 input_report_key(msc
->input
, BTN_MIDDLE
, state
& 4);
164 input_report_key(msc
->input
, BTN_LEFT
, state
& 1);
165 input_report_key(msc
->input
, BTN_RIGHT
, state
& 2);
167 if (state
!= last_state
)
168 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
171 static void magicmouse_emit_touch(struct magicmouse_sc
*msc
, int raw_id
, u8
*tdata
)
173 struct input_dev
*input
= msc
->input
;
174 int id
, x
, y
, size
, orientation
, touch_major
, touch_minor
, state
, down
;
176 if (input
->id
.product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
) {
177 id
= (tdata
[6] << 2 | tdata
[5] >> 6) & 0xf;
178 x
= (tdata
[1] << 28 | tdata
[0] << 20) >> 20;
179 y
= -((tdata
[2] << 24 | tdata
[1] << 16) >> 20);
180 size
= tdata
[5] & 0x3f;
181 orientation
= (tdata
[6] >> 2) - 32;
182 touch_major
= tdata
[3];
183 touch_minor
= tdata
[4];
184 state
= tdata
[7] & TOUCH_STATE_MASK
;
185 down
= state
!= TOUCH_STATE_NONE
;
186 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
187 id
= (tdata
[7] << 2 | tdata
[6] >> 6) & 0xf;
188 x
= (tdata
[1] << 27 | tdata
[0] << 19) >> 19;
189 y
= -((tdata
[3] << 30 | tdata
[2] << 22 | tdata
[1] << 14) >> 19);
190 size
= tdata
[6] & 0x3f;
191 orientation
= (tdata
[7] >> 2) - 32;
192 touch_major
= tdata
[4];
193 touch_minor
= tdata
[5];
194 state
= tdata
[8] & TOUCH_STATE_MASK
;
195 down
= state
!= TOUCH_STATE_NONE
;
198 /* Store tracking ID and other fields. */
199 msc
->tracking_ids
[raw_id
] = id
;
200 msc
->touches
[id
].x
= x
;
201 msc
->touches
[id
].y
= y
;
202 msc
->touches
[id
].size
= size
;
204 /* If requested, emulate a scroll wheel by detecting small
205 * vertical touch motions.
207 if (emulate_scroll_wheel
) {
208 unsigned long now
= jiffies
;
209 int step_x
= msc
->touches
[id
].scroll_x
- x
;
210 int step_y
= msc
->touches
[id
].scroll_y
- y
;
212 /* Calculate and apply the scroll motion. */
214 case TOUCH_STATE_START
:
215 msc
->touches
[id
].scroll_x
= x
;
216 msc
->touches
[id
].scroll_y
= y
;
218 /* Reset acceleration after half a second. */
219 if (scroll_acceleration
&& time_before(now
,
220 msc
->scroll_jiffies
+ HZ
/ 2))
221 msc
->scroll_accel
= max_t(int,
222 msc
->scroll_accel
- 1, 1);
224 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
227 case TOUCH_STATE_DRAG
:
228 step_x
/= (64 - (int)scroll_speed
) * msc
->scroll_accel
;
230 msc
->touches
[id
].scroll_x
-= step_x
*
231 (64 - scroll_speed
) * msc
->scroll_accel
;
232 msc
->scroll_jiffies
= now
;
233 input_report_rel(input
, REL_HWHEEL
, -step_x
);
236 step_y
/= (64 - (int)scroll_speed
) * msc
->scroll_accel
;
238 msc
->touches
[id
].scroll_y
-= step_y
*
239 (64 - scroll_speed
) * msc
->scroll_accel
;
240 msc
->scroll_jiffies
= now
;
241 input_report_rel(input
, REL_WHEEL
, step_y
);
249 if (msc
->single_touch_id
== NO_TOUCHES
)
250 msc
->single_touch_id
= id
;
251 } else if (msc
->single_touch_id
== id
)
252 msc
->single_touch_id
= SINGLE_TOUCH_UP
;
254 /* Generate the input events for this touch. */
255 if (report_touches
&& down
) {
256 input_report_abs(input
, ABS_MT_TRACKING_ID
, id
);
257 input_report_abs(input
, ABS_MT_TOUCH_MAJOR
, touch_major
<< 2);
258 input_report_abs(input
, ABS_MT_TOUCH_MINOR
, touch_minor
<< 2);
259 input_report_abs(input
, ABS_MT_ORIENTATION
, orientation
);
260 input_report_abs(input
, ABS_MT_POSITION_X
, x
);
261 input_report_abs(input
, ABS_MT_POSITION_Y
, y
);
263 if (report_undeciphered
) {
264 if (input
->id
.product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
)
265 input_event(input
, EV_MSC
, MSC_RAW
, tdata
[7]);
266 else /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
267 input_event(input
, EV_MSC
, MSC_RAW
, tdata
[8]);
270 input_mt_sync(input
);
274 static int magicmouse_raw_event(struct hid_device
*hdev
,
275 struct hid_report
*report
, u8
*data
, int size
)
277 struct magicmouse_sc
*msc
= hid_get_drvdata(hdev
);
278 struct input_dev
*input
= msc
->input
;
279 int x
= 0, y
= 0, ii
, clicks
= 0, npoints
;
282 case TRACKPAD_REPORT_ID
:
283 /* Expect four bytes of prefix, and N*9 bytes of touch data. */
284 if (size
< 4 || ((size
- 4) % 9) != 0)
286 npoints
= (size
- 4) / 9;
288 for (ii
= 0; ii
< npoints
; ii
++)
289 magicmouse_emit_touch(msc
, ii
, data
+ ii
* 9 + 4);
291 /* We don't need an MT sync here because trackpad emits a
292 * BTN_TOUCH event in a new frame when all touches are released.
294 if (msc
->ntouches
== 0)
295 msc
->single_touch_id
= NO_TOUCHES
;
299 /* The following bits provide a device specific timestamp. They
302 * ts = data[1] >> 6 | data[2] << 2 | data[3] << 10;
305 case MOUSE_REPORT_ID
:
306 /* Expect six bytes of prefix, and N*8 bytes of touch data. */
307 if (size
< 6 || ((size
- 6) % 8) != 0)
309 npoints
= (size
- 6) / 8;
311 for (ii
= 0; ii
< npoints
; ii
++)
312 magicmouse_emit_touch(msc
, ii
, data
+ ii
* 8 + 6);
314 if (report_touches
&& msc
->ntouches
== 0)
315 input_mt_sync(input
);
317 /* When emulating three-button mode, it is important
318 * to have the current touch information before
319 * generating a click event.
321 x
= (int)(((data
[3] & 0x0c) << 28) | (data
[1] << 22)) >> 22;
322 y
= (int)(((data
[3] & 0x30) << 26) | (data
[2] << 22)) >> 22;
325 /* The following bits provide a device specific timestamp. They
328 * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
331 case DOUBLE_REPORT_ID
:
332 /* Sometimes the trackpad sends two touch reports in one
335 magicmouse_raw_event(hdev
, report
, data
+ 2, data
[1]);
336 magicmouse_raw_event(hdev
, report
, data
+ 2 + data
[1],
343 if (input
->id
.product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
) {
344 magicmouse_emit_buttons(msc
, clicks
& 3);
345 input_report_rel(input
, REL_X
, x
);
346 input_report_rel(input
, REL_Y
, y
);
347 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
348 input_report_key(input
, BTN_MOUSE
, clicks
& 1);
349 input_report_key(input
, BTN_TOUCH
, msc
->ntouches
> 0);
350 input_report_key(input
, BTN_TOOL_FINGER
, msc
->ntouches
== 1);
351 input_report_key(input
, BTN_TOOL_DOUBLETAP
, msc
->ntouches
== 2);
352 input_report_key(input
, BTN_TOOL_TRIPLETAP
, msc
->ntouches
== 3);
353 input_report_key(input
, BTN_TOOL_QUADTAP
, msc
->ntouches
== 4);
354 if (msc
->single_touch_id
>= 0) {
355 input_report_abs(input
, ABS_X
,
356 msc
->touches
[msc
->single_touch_id
].x
);
357 input_report_abs(input
, ABS_Y
,
358 msc
->touches
[msc
->single_touch_id
].y
);
366 static void magicmouse_setup_input(struct input_dev
*input
, struct hid_device
*hdev
)
368 __set_bit(EV_KEY
, input
->evbit
);
370 if (input
->id
.product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
) {
371 __set_bit(BTN_LEFT
, input
->keybit
);
372 __set_bit(BTN_RIGHT
, input
->keybit
);
374 __set_bit(BTN_MIDDLE
, input
->keybit
);
376 __set_bit(EV_REL
, input
->evbit
);
377 __set_bit(REL_X
, input
->relbit
);
378 __set_bit(REL_Y
, input
->relbit
);
379 if (emulate_scroll_wheel
) {
380 __set_bit(REL_WHEEL
, input
->relbit
);
381 __set_bit(REL_HWHEEL
, input
->relbit
);
383 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
384 __set_bit(BTN_MOUSE
, input
->keybit
);
385 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
386 __set_bit(BTN_TOOL_DOUBLETAP
, input
->keybit
);
387 __set_bit(BTN_TOOL_TRIPLETAP
, input
->keybit
);
388 __set_bit(BTN_TOOL_QUADTAP
, input
->keybit
);
389 __set_bit(BTN_TOUCH
, input
->keybit
);
392 if (report_touches
) {
393 __set_bit(EV_ABS
, input
->evbit
);
395 input_set_abs_params(input
, ABS_MT_TRACKING_ID
, 0, 15, 0, 0);
396 input_set_abs_params(input
, ABS_MT_TOUCH_MAJOR
, 0, 255, 4, 0);
397 input_set_abs_params(input
, ABS_MT_TOUCH_MINOR
, 0, 255, 4, 0);
398 input_set_abs_params(input
, ABS_MT_ORIENTATION
, -32, 31, 1, 0);
400 /* Note: Touch Y position from the device is inverted relative
401 * to how pointer motion is reported (and relative to how USB
402 * HID recommends the coordinates work). This driver keeps
403 * the origin at the same position, and just uses the additive
404 * inverse of the reported Y.
406 if (input
->id
.product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
) {
407 input_set_abs_params(input
, ABS_MT_POSITION_X
, -1100,
409 input_set_abs_params(input
, ABS_MT_POSITION_Y
, -1589,
411 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
412 input_set_abs_params(input
, ABS_X
, -2909, 3167, 4, 0);
413 input_set_abs_params(input
, ABS_Y
, -2456, 2565, 4, 0);
414 input_set_abs_params(input
, ABS_MT_POSITION_X
, -2909,
416 input_set_abs_params(input
, ABS_MT_POSITION_Y
, -2456,
421 if (report_undeciphered
) {
422 __set_bit(EV_MSC
, input
->evbit
);
423 __set_bit(MSC_RAW
, input
->mscbit
);
427 static int magicmouse_input_mapping(struct hid_device
*hdev
,
428 struct hid_input
*hi
, struct hid_field
*field
,
429 struct hid_usage
*usage
, unsigned long **bit
, int *max
)
431 struct magicmouse_sc
*msc
= hid_get_drvdata(hdev
);
434 msc
->input
= hi
->input
;
439 static int magicmouse_probe(struct hid_device
*hdev
,
440 const struct hid_device_id
*id
)
442 __u8 feature
[] = { 0xd7, 0x01 };
443 struct magicmouse_sc
*msc
;
444 struct hid_report
*report
;
447 msc
= kzalloc(sizeof(*msc
), GFP_KERNEL
);
449 dev_err(&hdev
->dev
, "can't alloc magicmouse descriptor\n");
453 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
455 msc
->quirks
= id
->driver_data
;
456 hid_set_drvdata(hdev
, msc
);
458 msc
->single_touch_id
= NO_TOUCHES
;
460 ret
= hid_parse(hdev
);
462 dev_err(&hdev
->dev
, "magicmouse hid parse failed\n");
466 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
468 dev_err(&hdev
->dev
, "magicmouse hw start failed\n");
472 /* We do this after hid-input is done parsing reports so that
473 * hid-input uses the most natural button and axis IDs.
476 magicmouse_setup_input(msc
->input
, hdev
);
478 if (id
->product
== USB_DEVICE_ID_APPLE_MAGICMOUSE
)
479 report
= hid_register_report(hdev
, HID_INPUT_REPORT
,
481 else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
482 report
= hid_register_report(hdev
, HID_INPUT_REPORT
,
484 report
= hid_register_report(hdev
, HID_INPUT_REPORT
,
489 dev_err(&hdev
->dev
, "unable to register touch report\n");
495 ret
= hdev
->hid_output_raw_report(hdev
, feature
, sizeof(feature
),
497 if (ret
!= sizeof(feature
)) {
498 dev_err(&hdev
->dev
, "unable to request touch data (%d)\n",
511 static void magicmouse_remove(struct hid_device
*hdev
)
513 struct magicmouse_sc
*msc
= hid_get_drvdata(hdev
);
519 static const struct hid_device_id magic_mice
[] = {
520 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE
,
521 USB_DEVICE_ID_APPLE_MAGICMOUSE
), .driver_data
= 0 },
522 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE
,
523 USB_DEVICE_ID_APPLE_MAGICTRACKPAD
), .driver_data
= 0 },
526 MODULE_DEVICE_TABLE(hid
, magic_mice
);
528 static struct hid_driver magicmouse_driver
= {
529 .name
= "magicmouse",
530 .id_table
= magic_mice
,
531 .probe
= magicmouse_probe
,
532 .remove
= magicmouse_remove
,
533 .raw_event
= magicmouse_raw_event
,
534 .input_mapping
= magicmouse_input_mapping
,
537 static int __init
magicmouse_init(void)
541 ret
= hid_register_driver(&magicmouse_driver
);
543 printk(KERN_ERR
"can't register magicmouse driver\n");
548 static void __exit
magicmouse_exit(void)
550 hid_unregister_driver(&magicmouse_driver
);
553 module_init(magicmouse_init
);
554 module_exit(magicmouse_exit
);
555 MODULE_LICENSE("GPL");