1 /* 2 * Apple "Magic" Wireless Mouse driver 3 * 4 * Copyright (c) 2010 Michael Poole <mdpoole@troilus.org> 5 */ 6 7 /* 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) 11 * any later version. 12 */ 13 14 #include <linux/device.h> 15 #include <linux/hid.h> 16 #include <linux/module.h> 17 #include <linux/usb.h> 18 19 #include "hid-ids.h" 20 21 static bool emulate_3button = true; 22 module_param(emulate_3button, bool, 0644); 23 MODULE_PARM_DESC(emulate_3button, "Emulate a middle button"); 24 25 static int middle_button_start = -350; 26 static int middle_button_stop = +350; 27 28 static bool emulate_scroll_wheel = true; 29 module_param(emulate_scroll_wheel, bool, 0644); 30 MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel"); 31 32 static bool report_touches = true; 33 module_param(report_touches, bool, 0644); 34 MODULE_PARM_DESC(report_touches, "Emit touch records (otherwise, only use them for emulation)"); 35 36 static bool report_undeciphered; 37 module_param(report_undeciphered, bool, 0644); 38 MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event"); 39 40 #define TOUCH_REPORT_ID 0x29 41 /* These definitions are not precise, but they're close enough. (Bits 42 * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem 43 * to be some kind of bit mask -- 0x20 may be a near-field reading, 44 * and 0x40 is actual contact, and 0x10 may be a start/stop or change 45 * indication.) 46 */ 47 #define TOUCH_STATE_MASK 0xf0 48 #define TOUCH_STATE_NONE 0x00 49 #define TOUCH_STATE_START 0x30 50 #define TOUCH_STATE_DRAG 0x40 51 52 /** 53 * struct magicmouse_sc - Tracks Magic Mouse-specific data. 54 * @input: Input device through which we report events. 55 * @quirks: Currently unused. 56 * @last_timestamp: Timestamp from most recent (18-bit) touch report 57 * (units of milliseconds over short windows, but seems to 58 * increase faster when there are no touches). 59 * @delta_time: 18-bit difference between the two most recent touch 60 * reports from the mouse. 61 * @ntouches: Number of touches in most recent touch report. 62 * @scroll_accel: Number of consecutive scroll motions. 63 * @scroll_jiffies: Time of last scroll motion. 64 * @touches: Most recent data for a touch, indexed by tracking ID. 65 * @tracking_ids: Mapping of current touch input data to @touches. 66 */ 67 struct magicmouse_sc { 68 struct input_dev *input; 69 unsigned long quirks; 70 71 int last_timestamp; 72 int delta_time; 73 int ntouches; 74 int scroll_accel; 75 unsigned long scroll_jiffies; 76 77 struct { 78 short x; 79 short y; 80 short scroll_y; 81 u8 size; 82 } touches[16]; 83 int tracking_ids[16]; 84 }; 85 86 static int magicmouse_firm_touch(struct magicmouse_sc *msc) 87 { 88 int touch = -1; 89 int ii; 90 91 /* If there is only one "firm" touch, set touch to its 92 * tracking ID. 93 */ 94 for (ii = 0; ii < msc->ntouches; ii++) { 95 int idx = msc->tracking_ids[ii]; 96 if (msc->touches[idx].size < 8) { 97 /* Ignore this touch. */ 98 } else if (touch >= 0) { 99 touch = -1; 100 break; 101 } else { 102 touch = idx; 103 } 104 } 105 106 return touch; 107 } 108 109 static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state) 110 { 111 int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 | 112 test_bit(BTN_RIGHT, msc->input->key) << 1 | 113 test_bit(BTN_MIDDLE, msc->input->key) << 2; 114 115 if (emulate_3button) { 116 int id; 117 118 /* If some button was pressed before, keep it held 119 * down. Otherwise, if there's exactly one firm 120 * touch, use that to override the mouse's guess. 121 */ 122 if (state == 0) { 123 /* The button was released. */ 124 } else if (last_state != 0) { 125 state = last_state; 126 } else if ((id = magicmouse_firm_touch(msc)) >= 0) { 127 int x = msc->touches[id].x; 128 if (x < middle_button_start) 129 state = 1; 130 else if (x > middle_button_stop) 131 state = 2; 132 else 133 state = 4; 134 } /* else: we keep the mouse's guess */ 135 136 input_report_key(msc->input, BTN_MIDDLE, state & 4); 137 } 138 139 input_report_key(msc->input, BTN_LEFT, state & 1); 140 input_report_key(msc->input, BTN_RIGHT, state & 2); 141 142 if (state != last_state) 143 msc->scroll_accel = 0; 144 } 145 146 static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata) 147 { 148 struct input_dev *input = msc->input; 149 __s32 x_y = tdata[0] << 8 | tdata[1] << 16 | tdata[2] << 24; 150 int misc = tdata[5] | tdata[6] << 8; 151 int id = (misc >> 6) & 15; 152 int x = x_y << 12 >> 20; 153 int y = -(x_y >> 20); 154 155 /* Store tracking ID and other fields. */ 156 msc->tracking_ids[raw_id] = id; 157 msc->touches[id].x = x; 158 msc->touches[id].y = y; 159 msc->touches[id].size = misc & 63; 160 161 /* If requested, emulate a scroll wheel by detecting small 162 * vertical touch motions along the middle of the mouse. 163 */ 164 if (emulate_scroll_wheel && 165 middle_button_start < x && x < middle_button_stop) { 166 static const int accel_profile[] = { 167 256, 228, 192, 160, 128, 96, 64, 32, 168 }; 169 unsigned long now = jiffies; 170 int step = msc->touches[id].scroll_y - y; 171 172 /* Reset acceleration after half a second. */ 173 if (time_after(now, msc->scroll_jiffies + HZ / 2)) 174 msc->scroll_accel = 0; 175 176 /* Calculate and apply the scroll motion. */ 177 switch (tdata[7] & TOUCH_STATE_MASK) { 178 case TOUCH_STATE_START: 179 msc->touches[id].scroll_y = y; 180 msc->scroll_accel = min_t(int, msc->scroll_accel + 1, 181 ARRAY_SIZE(accel_profile) - 1); 182 break; 183 case TOUCH_STATE_DRAG: 184 step = step / accel_profile[msc->scroll_accel]; 185 if (step != 0) { 186 msc->touches[id].scroll_y = y; 187 msc->scroll_jiffies = now; 188 input_report_rel(input, REL_WHEEL, step); 189 } 190 break; 191 } 192 } 193 194 /* Generate the input events for this touch. */ 195 if (report_touches) { 196 int orientation = (misc >> 10) - 32; 197 198 input_report_abs(input, ABS_MT_TRACKING_ID, id); 199 input_report_abs(input, ABS_MT_TOUCH_MAJOR, tdata[3]); 200 input_report_abs(input, ABS_MT_TOUCH_MINOR, tdata[4]); 201 input_report_abs(input, ABS_MT_ORIENTATION, orientation); 202 input_report_abs(input, ABS_MT_POSITION_X, x); 203 input_report_abs(input, ABS_MT_POSITION_Y, y); 204 205 if (report_undeciphered) 206 input_event(input, EV_MSC, MSC_RAW, tdata[7]); 207 208 input_mt_sync(input); 209 } 210 } 211 212 static int magicmouse_raw_event(struct hid_device *hdev, 213 struct hid_report *report, u8 *data, int size) 214 { 215 struct magicmouse_sc *msc = hid_get_drvdata(hdev); 216 struct input_dev *input = msc->input; 217 int x, y, ts, ii, clicks; 218 219 switch (data[0]) { 220 case 0x10: 221 if (size != 6) 222 return 0; 223 x = (__s16)(data[2] | data[3] << 8); 224 y = (__s16)(data[4] | data[5] << 8); 225 clicks = data[1]; 226 break; 227 case TOUCH_REPORT_ID: 228 /* Expect six bytes of prefix, and N*8 bytes of touch data. */ 229 if (size < 6 || ((size - 6) % 8) != 0) 230 return 0; 231 ts = data[3] >> 6 | data[4] << 2 | data[5] << 10; 232 msc->delta_time = (ts - msc->last_timestamp) & 0x3ffff; 233 msc->last_timestamp = ts; 234 msc->ntouches = (size - 6) / 8; 235 for (ii = 0; ii < msc->ntouches; ii++) 236 magicmouse_emit_touch(msc, ii, data + ii * 8 + 6); 237 /* When emulating three-button mode, it is important 238 * to have the current touch information before 239 * generating a click event. 240 */ 241 x = (signed char)data[1]; 242 y = (signed char)data[2]; 243 clicks = data[3]; 244 break; 245 case 0x20: /* Theoretically battery status (0-100), but I have 246 * never seen it -- maybe it is only upon request. 247 */ 248 case 0x60: /* Unknown, maybe laser on/off. */ 249 case 0x61: /* Laser reflection status change. 250 * data[1]: 0 = spotted, 1 = lost 251 */ 252 default: 253 return 0; 254 } 255 256 magicmouse_emit_buttons(msc, clicks & 3); 257 input_report_rel(input, REL_X, x); 258 input_report_rel(input, REL_Y, y); 259 input_sync(input); 260 return 1; 261 } 262 263 static int magicmouse_input_open(struct input_dev *dev) 264 { 265 struct hid_device *hid = input_get_drvdata(dev); 266 267 return hid->ll_driver->open(hid); 268 } 269 270 static void magicmouse_input_close(struct input_dev *dev) 271 { 272 struct hid_device *hid = input_get_drvdata(dev); 273 274 hid->ll_driver->close(hid); 275 } 276 277 static void magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev) 278 { 279 input_set_drvdata(input, hdev); 280 input->event = hdev->ll_driver->hidinput_input_event; 281 input->open = magicmouse_input_open; 282 input->close = magicmouse_input_close; 283 284 input->name = hdev->name; 285 input->phys = hdev->phys; 286 input->uniq = hdev->uniq; 287 input->id.bustype = hdev->bus; 288 input->id.vendor = hdev->vendor; 289 input->id.product = hdev->product; 290 input->id.version = hdev->version; 291 input->dev.parent = hdev->dev.parent; 292 293 __set_bit(EV_KEY, input->evbit); 294 __set_bit(BTN_LEFT, input->keybit); 295 __set_bit(BTN_RIGHT, input->keybit); 296 if (emulate_3button) 297 __set_bit(BTN_MIDDLE, input->keybit); 298 __set_bit(BTN_TOOL_FINGER, input->keybit); 299 300 __set_bit(EV_REL, input->evbit); 301 __set_bit(REL_X, input->relbit); 302 __set_bit(REL_Y, input->relbit); 303 if (emulate_scroll_wheel) 304 __set_bit(REL_WHEEL, input->relbit); 305 306 if (report_touches) { 307 __set_bit(EV_ABS, input->evbit); 308 309 input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, 15, 0, 0); 310 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 4, 0); 311 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 4, 0); 312 input_set_abs_params(input, ABS_MT_ORIENTATION, -32, 31, 1, 0); 313 input_set_abs_params(input, ABS_MT_POSITION_X, -1100, 1358, 314 4, 0); 315 /* Note: Touch Y position from the device is inverted relative 316 * to how pointer motion is reported (and relative to how USB 317 * HID recommends the coordinates work). This driver keeps 318 * the origin at the same position, and just uses the additive 319 * inverse of the reported Y. 320 */ 321 input_set_abs_params(input, ABS_MT_POSITION_Y, -1589, 2047, 322 4, 0); 323 } 324 325 if (report_undeciphered) { 326 __set_bit(EV_MSC, input->evbit); 327 __set_bit(MSC_RAW, input->mscbit); 328 } 329 } 330 331 static int magicmouse_probe(struct hid_device *hdev, 332 const struct hid_device_id *id) 333 { 334 __u8 feature_1[] = { 0xd7, 0x01 }; 335 __u8 feature_2[] = { 0xf8, 0x01, 0x32 }; 336 struct input_dev *input; 337 struct magicmouse_sc *msc; 338 struct hid_report *report; 339 int ret; 340 341 msc = kzalloc(sizeof(*msc), GFP_KERNEL); 342 if (msc == NULL) { 343 dev_err(&hdev->dev, "can't alloc magicmouse descriptor\n"); 344 return -ENOMEM; 345 } 346 347 msc->quirks = id->driver_data; 348 hid_set_drvdata(hdev, msc); 349 350 ret = hid_parse(hdev); 351 if (ret) { 352 dev_err(&hdev->dev, "magicmouse hid parse failed\n"); 353 goto err_free; 354 } 355 356 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 357 if (ret) { 358 dev_err(&hdev->dev, "magicmouse hw start failed\n"); 359 goto err_free; 360 } 361 362 report = hid_register_report(hdev, HID_INPUT_REPORT, TOUCH_REPORT_ID); 363 if (!report) { 364 dev_err(&hdev->dev, "unable to register touch report\n"); 365 ret = -ENOMEM; 366 goto err_stop_hw; 367 } 368 report->size = 6; 369 370 ret = hdev->hid_output_raw_report(hdev, feature_1, sizeof(feature_1), 371 HID_FEATURE_REPORT); 372 if (ret != sizeof(feature_1)) { 373 dev_err(&hdev->dev, "unable to request touch data (1:%d)\n", 374 ret); 375 goto err_stop_hw; 376 } 377 ret = hdev->hid_output_raw_report(hdev, feature_2, 378 sizeof(feature_2), HID_FEATURE_REPORT); 379 if (ret != sizeof(feature_2)) { 380 dev_err(&hdev->dev, "unable to request touch data (2:%d)\n", 381 ret); 382 goto err_stop_hw; 383 } 384 385 input = input_allocate_device(); 386 if (!input) { 387 dev_err(&hdev->dev, "can't alloc input device\n"); 388 ret = -ENOMEM; 389 goto err_stop_hw; 390 } 391 magicmouse_setup_input(input, hdev); 392 393 ret = input_register_device(input); 394 if (ret) { 395 dev_err(&hdev->dev, "input device registration failed\n"); 396 goto err_input; 397 } 398 msc->input = input; 399 400 return 0; 401 err_input: 402 input_free_device(input); 403 err_stop_hw: 404 hid_hw_stop(hdev); 405 err_free: 406 kfree(msc); 407 return ret; 408 } 409 410 static void magicmouse_remove(struct hid_device *hdev) 411 { 412 hid_hw_stop(hdev); 413 kfree(hid_get_drvdata(hdev)); 414 } 415 416 static const struct hid_device_id magic_mice[] = { 417 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE), 418 .driver_data = 0 }, 419 { } 420 }; 421 MODULE_DEVICE_TABLE(hid, magic_mice); 422 423 static struct hid_driver magicmouse_driver = { 424 .name = "magicmouse", 425 .id_table = magic_mice, 426 .probe = magicmouse_probe, 427 .remove = magicmouse_remove, 428 .raw_event = magicmouse_raw_event, 429 }; 430 431 static int __init magicmouse_init(void) 432 { 433 int ret; 434 435 ret = hid_register_driver(&magicmouse_driver); 436 if (ret) 437 printk(KERN_ERR "can't register magicmouse driver\n"); 438 439 return ret; 440 } 441 442 static void __exit magicmouse_exit(void) 443 { 444 hid_unregister_driver(&magicmouse_driver); 445 } 446 447 module_init(magicmouse_init); 448 module_exit(magicmouse_exit); 449 MODULE_LICENSE("GPL"); 450