2 * Apple "Magic" Wireless Mouse driver
4 * Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
14 #include <linux/device.h>
15 #include <linux/hid.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/usb.h>
22 static bool emulate_3button
= true;
23 module_param(emulate_3button
, bool, 0644);
24 MODULE_PARM_DESC(emulate_3button
, "Emulate a middle button");
26 static int middle_button_start
= -350;
27 static int middle_button_stop
= +350;
29 static bool emulate_scroll_wheel
= true;
30 module_param(emulate_scroll_wheel
, bool, 0644);
31 MODULE_PARM_DESC(emulate_scroll_wheel
, "Emulate a scroll wheel");
33 static unsigned int scroll_speed
= 32;
34 static int param_set_scroll_speed(const char *val
, struct kernel_param
*kp
) {
36 if (!val
|| strict_strtoul(val
, 0, &speed
) || speed
> 63)
41 module_param_call(scroll_speed
, param_set_scroll_speed
, param_get_uint
, &scroll_speed
, 0644);
42 MODULE_PARM_DESC(scroll_speed
, "Scroll speed, value from 0 (slow) to 63 (fast)");
44 static bool scroll_acceleration
= false;
45 module_param(scroll_acceleration
, bool, 0644);
46 MODULE_PARM_DESC(scroll_acceleration
, "Accelerate sequential scroll events");
48 static bool report_touches
= true;
49 module_param(report_touches
, bool, 0644);
50 MODULE_PARM_DESC(report_touches
, "Emit touch records (otherwise, only use them for emulation)");
52 static bool report_undeciphered
;
53 module_param(report_undeciphered
, bool, 0644);
54 MODULE_PARM_DESC(report_undeciphered
, "Report undeciphered multi-touch state field using a MSC_RAW event");
56 #define TOUCH_REPORT_ID 0x29
57 /* These definitions are not precise, but they're close enough. (Bits
58 * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
59 * to be some kind of bit mask -- 0x20 may be a near-field reading,
60 * and 0x40 is actual contact, and 0x10 may be a start/stop or change
63 #define TOUCH_STATE_MASK 0xf0
64 #define TOUCH_STATE_NONE 0x00
65 #define TOUCH_STATE_START 0x30
66 #define TOUCH_STATE_DRAG 0x40
68 #define SCROLL_ACCEL_DEFAULT 7
71 * struct magicmouse_sc - Tracks Magic Mouse-specific data.
72 * @input: Input device through which we report events.
73 * @quirks: Currently unused.
74 * @ntouches: Number of touches in most recent touch report.
75 * @scroll_accel: Number of consecutive scroll motions.
76 * @scroll_jiffies: Time of last scroll motion.
77 * @touches: Most recent data for a touch, indexed by tracking ID.
78 * @tracking_ids: Mapping of current touch input data to @touches.
80 struct magicmouse_sc
{
81 struct input_dev
*input
;
86 unsigned long scroll_jiffies
;
98 static int magicmouse_firm_touch(struct magicmouse_sc
*msc
)
103 /* If there is only one "firm" touch, set touch to its
106 for (ii
= 0; ii
< msc
->ntouches
; ii
++) {
107 int idx
= msc
->tracking_ids
[ii
];
108 if (msc
->touches
[idx
].size
< 8) {
109 /* Ignore this touch. */
110 } else if (touch
>= 0) {
121 static void magicmouse_emit_buttons(struct magicmouse_sc
*msc
, int state
)
123 int last_state
= test_bit(BTN_LEFT
, msc
->input
->key
) << 0 |
124 test_bit(BTN_RIGHT
, msc
->input
->key
) << 1 |
125 test_bit(BTN_MIDDLE
, msc
->input
->key
) << 2;
127 if (emulate_3button
) {
130 /* If some button was pressed before, keep it held
131 * down. Otherwise, if there's exactly one firm
132 * touch, use that to override the mouse's guess.
135 /* The button was released. */
136 } else if (last_state
!= 0) {
138 } else if ((id
= magicmouse_firm_touch(msc
)) >= 0) {
139 int x
= msc
->touches
[id
].x
;
140 if (x
< middle_button_start
)
142 else if (x
> middle_button_stop
)
146 } /* else: we keep the mouse's guess */
148 input_report_key(msc
->input
, BTN_MIDDLE
, state
& 4);
151 input_report_key(msc
->input
, BTN_LEFT
, state
& 1);
152 input_report_key(msc
->input
, BTN_RIGHT
, state
& 2);
154 if (state
!= last_state
)
155 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
158 static void magicmouse_emit_touch(struct magicmouse_sc
*msc
, int raw_id
, u8
*tdata
)
160 struct input_dev
*input
= msc
->input
;
161 __s32 x_y
= tdata
[0] << 8 | tdata
[1] << 16 | tdata
[2] << 24;
162 int misc
= tdata
[5] | tdata
[6] << 8;
163 int id
= (misc
>> 6) & 15;
164 int x
= x_y
<< 12 >> 20;
165 int y
= -(x_y
>> 20);
166 int down
= (tdata
[7] & TOUCH_STATE_MASK
) != TOUCH_STATE_NONE
;
168 /* Store tracking ID and other fields. */
169 msc
->tracking_ids
[raw_id
] = id
;
170 msc
->touches
[id
].x
= x
;
171 msc
->touches
[id
].y
= y
;
172 msc
->touches
[id
].size
= misc
& 63;
174 /* If requested, emulate a scroll wheel by detecting small
175 * vertical touch motions.
177 if (emulate_scroll_wheel
) {
178 unsigned long now
= jiffies
;
179 int step_x
= msc
->touches
[id
].scroll_x
- x
;
180 int step_y
= msc
->touches
[id
].scroll_y
- y
;
182 /* Calculate and apply the scroll motion. */
183 switch (tdata
[7] & TOUCH_STATE_MASK
) {
184 case TOUCH_STATE_START
:
185 msc
->touches
[id
].scroll_x
= x
;
186 msc
->touches
[id
].scroll_y
= y
;
188 /* Reset acceleration after half a second. */
189 if (scroll_acceleration
&& time_before(now
,
190 msc
->scroll_jiffies
+ HZ
/ 2))
191 msc
->scroll_accel
= max_t(int,
192 msc
->scroll_accel
- 1, 1);
194 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
197 case TOUCH_STATE_DRAG
:
198 step_x
/= (64 - (int)scroll_speed
) * msc
->scroll_accel
;
200 msc
->touches
[id
].scroll_x
-= step_x
*
201 (64 - scroll_speed
) * msc
->scroll_accel
;
202 msc
->scroll_jiffies
= now
;
203 input_report_rel(input
, REL_HWHEEL
, -step_x
);
206 step_y
/= (64 - (int)scroll_speed
) * msc
->scroll_accel
;
208 msc
->touches
[id
].scroll_y
-= step_y
*
209 (64 - scroll_speed
) * msc
->scroll_accel
;
210 msc
->scroll_jiffies
= now
;
211 input_report_rel(input
, REL_WHEEL
, step_y
);
217 /* Generate the input events for this touch. */
218 if (report_touches
&& down
) {
219 int orientation
= (misc
>> 10) - 32;
221 input_report_abs(input
, ABS_MT_TRACKING_ID
, id
);
222 input_report_abs(input
, ABS_MT_TOUCH_MAJOR
, tdata
[3]);
223 input_report_abs(input
, ABS_MT_TOUCH_MINOR
, tdata
[4]);
224 input_report_abs(input
, ABS_MT_ORIENTATION
, orientation
);
225 input_report_abs(input
, ABS_MT_POSITION_X
, x
);
226 input_report_abs(input
, ABS_MT_POSITION_Y
, y
);
228 if (report_undeciphered
)
229 input_event(input
, EV_MSC
, MSC_RAW
, tdata
[7]);
231 input_mt_sync(input
);
238 static int magicmouse_raw_event(struct hid_device
*hdev
,
239 struct hid_report
*report
, u8
*data
, int size
)
241 struct magicmouse_sc
*msc
= hid_get_drvdata(hdev
);
242 struct input_dev
*input
= msc
->input
;
243 int x
, y
, ii
, clicks
, npoints
;
249 x
= (__s16
)(data
[2] | data
[3] << 8);
250 y
= (__s16
)(data
[4] | data
[5] << 8);
253 case TOUCH_REPORT_ID
:
254 /* Expect six bytes of prefix, and N*8 bytes of touch data. */
255 if (size
< 6 || ((size
- 6) % 8) != 0)
257 npoints
= (size
- 6) / 8;
259 for (ii
= 0; ii
< npoints
; ii
++)
260 magicmouse_emit_touch(msc
, ii
, data
+ ii
* 8 + 6);
262 if (report_touches
&& msc
->ntouches
== 0)
263 input_mt_sync(input
);
265 /* When emulating three-button mode, it is important
266 * to have the current touch information before
267 * generating a click event.
269 x
= (int)(((data
[3] & 0x0c) << 28) | (data
[1] << 22)) >> 22;
270 y
= (int)(((data
[3] & 0x30) << 26) | (data
[2] << 22)) >> 22;
273 /* The following bits provide a device specific timestamp. They
276 * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
279 case 0x20: /* Theoretically battery status (0-100), but I have
280 * never seen it -- maybe it is only upon request.
282 case 0x60: /* Unknown, maybe laser on/off. */
283 case 0x61: /* Laser reflection status change.
284 * data[1]: 0 = spotted, 1 = lost
290 magicmouse_emit_buttons(msc
, clicks
& 3);
291 input_report_rel(input
, REL_X
, x
);
292 input_report_rel(input
, REL_Y
, y
);
297 static int magicmouse_input_open(struct input_dev
*dev
)
299 struct hid_device
*hid
= input_get_drvdata(dev
);
301 return hid
->ll_driver
->open(hid
);
304 static void magicmouse_input_close(struct input_dev
*dev
)
306 struct hid_device
*hid
= input_get_drvdata(dev
);
308 hid
->ll_driver
->close(hid
);
311 static void magicmouse_setup_input(struct input_dev
*input
, struct hid_device
*hdev
)
313 input_set_drvdata(input
, hdev
);
314 input
->event
= hdev
->ll_driver
->hidinput_input_event
;
315 input
->open
= magicmouse_input_open
;
316 input
->close
= magicmouse_input_close
;
318 input
->name
= hdev
->name
;
319 input
->phys
= hdev
->phys
;
320 input
->uniq
= hdev
->uniq
;
321 input
->id
.bustype
= hdev
->bus
;
322 input
->id
.vendor
= hdev
->vendor
;
323 input
->id
.product
= hdev
->product
;
324 input
->id
.version
= hdev
->version
;
325 input
->dev
.parent
= hdev
->dev
.parent
;
327 __set_bit(EV_KEY
, input
->evbit
);
328 __set_bit(BTN_LEFT
, input
->keybit
);
329 __set_bit(BTN_RIGHT
, input
->keybit
);
331 __set_bit(BTN_MIDDLE
, input
->keybit
);
332 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
334 __set_bit(EV_REL
, input
->evbit
);
335 __set_bit(REL_X
, input
->relbit
);
336 __set_bit(REL_Y
, input
->relbit
);
337 if (emulate_scroll_wheel
) {
338 __set_bit(REL_WHEEL
, input
->relbit
);
339 __set_bit(REL_HWHEEL
, input
->relbit
);
342 if (report_touches
) {
343 __set_bit(EV_ABS
, input
->evbit
);
345 input_set_abs_params(input
, ABS_MT_TRACKING_ID
, 0, 15, 0, 0);
346 input_set_abs_params(input
, ABS_MT_TOUCH_MAJOR
, 0, 255, 4, 0);
347 input_set_abs_params(input
, ABS_MT_TOUCH_MINOR
, 0, 255, 4, 0);
348 input_set_abs_params(input
, ABS_MT_ORIENTATION
, -32, 31, 1, 0);
349 input_set_abs_params(input
, ABS_MT_POSITION_X
, -1100, 1358,
351 /* Note: Touch Y position from the device is inverted relative
352 * to how pointer motion is reported (and relative to how USB
353 * HID recommends the coordinates work). This driver keeps
354 * the origin at the same position, and just uses the additive
355 * inverse of the reported Y.
357 input_set_abs_params(input
, ABS_MT_POSITION_Y
, -1589, 2047,
361 if (report_undeciphered
) {
362 __set_bit(EV_MSC
, input
->evbit
);
363 __set_bit(MSC_RAW
, input
->mscbit
);
367 static int magicmouse_probe(struct hid_device
*hdev
,
368 const struct hid_device_id
*id
)
370 __u8 feature_1
[] = { 0xd7, 0x01 };
371 __u8 feature_2
[] = { 0xf8, 0x01, 0x32 };
372 struct input_dev
*input
;
373 struct magicmouse_sc
*msc
;
374 struct hid_report
*report
;
377 msc
= kzalloc(sizeof(*msc
), GFP_KERNEL
);
379 dev_err(&hdev
->dev
, "can't alloc magicmouse descriptor\n");
383 msc
->scroll_accel
= SCROLL_ACCEL_DEFAULT
;
385 msc
->quirks
= id
->driver_data
;
386 hid_set_drvdata(hdev
, msc
);
388 ret
= hid_parse(hdev
);
390 dev_err(&hdev
->dev
, "magicmouse hid parse failed\n");
394 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
396 dev_err(&hdev
->dev
, "magicmouse hw start failed\n");
400 /* we are handling the input ourselves */
401 hidinput_disconnect(hdev
);
403 report
= hid_register_report(hdev
, HID_INPUT_REPORT
, TOUCH_REPORT_ID
);
405 dev_err(&hdev
->dev
, "unable to register touch report\n");
411 ret
= hdev
->hid_output_raw_report(hdev
, feature_1
, sizeof(feature_1
),
413 if (ret
!= sizeof(feature_1
)) {
414 dev_err(&hdev
->dev
, "unable to request touch data (1:%d)\n",
418 ret
= hdev
->hid_output_raw_report(hdev
, feature_2
,
419 sizeof(feature_2
), HID_FEATURE_REPORT
);
420 if (ret
!= sizeof(feature_2
)) {
421 dev_err(&hdev
->dev
, "unable to request touch data (2:%d)\n",
426 input
= input_allocate_device();
428 dev_err(&hdev
->dev
, "can't alloc input device\n");
432 magicmouse_setup_input(input
, hdev
);
434 ret
= input_register_device(input
);
436 dev_err(&hdev
->dev
, "input device registration failed\n");
443 input_free_device(input
);
451 static void magicmouse_remove(struct hid_device
*hdev
)
453 struct magicmouse_sc
*msc
= hid_get_drvdata(hdev
);
456 input_unregister_device(msc
->input
);
460 static const struct hid_device_id magic_mice
[] = {
461 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE
, USB_DEVICE_ID_APPLE_MAGICMOUSE
),
465 MODULE_DEVICE_TABLE(hid
, magic_mice
);
467 static struct hid_driver magicmouse_driver
= {
468 .name
= "magicmouse",
469 .id_table
= magic_mice
,
470 .probe
= magicmouse_probe
,
471 .remove
= magicmouse_remove
,
472 .raw_event
= magicmouse_raw_event
,
475 static int __init
magicmouse_init(void)
479 ret
= hid_register_driver(&magicmouse_driver
);
481 printk(KERN_ERR
"can't register magicmouse driver\n");
486 static void __exit
magicmouse_exit(void)
488 hid_unregister_driver(&magicmouse_driver
);
491 module_init(magicmouse_init
);
492 module_exit(magicmouse_exit
);
493 MODULE_LICENSE("GPL");