hid-magicmouse.c 13.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *   Apple "Magic" Wireless Mouse driver
 *
 *   Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
17
#include <linux/slab.h>
18 19 20 21
#include <linux/usb.h>

#include "hid-ids.h"

22
static bool emulate_3button = true;
23 24 25 26 27 28
module_param(emulate_3button, bool, 0644);
MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");

static int middle_button_start = -350;
static int middle_button_stop = +350;

29
static bool emulate_scroll_wheel = true;
30 31 32
module_param(emulate_scroll_wheel, bool, 0644);
MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");

33 34 35 36 37 38 39 40 41 42 43
static unsigned int scroll_speed = 32;
static int param_set_scroll_speed(const char *val, struct kernel_param *kp) {
	unsigned long speed;
	if (!val || strict_strtoul(val, 0, &speed) || speed > 63)
		return -EINVAL;
	scroll_speed = speed;
	return 0;
}
module_param_call(scroll_speed, param_set_scroll_speed, param_get_uint, &scroll_speed, 0644);
MODULE_PARM_DESC(scroll_speed, "Scroll speed, value from 0 (slow) to 63 (fast)");

44 45 46 47
static bool scroll_acceleration = false;
module_param(scroll_acceleration, bool, 0644);
MODULE_PARM_DESC(scroll_acceleration, "Accelerate sequential scroll events");

48
static bool report_touches = true;
49 50 51
module_param(report_touches, bool, 0644);
MODULE_PARM_DESC(report_touches, "Emit touch records (otherwise, only use them for emulation)");

52
static bool report_undeciphered;
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
module_param(report_undeciphered, bool, 0644);
MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");

#define TOUCH_REPORT_ID   0x29
/* These definitions are not precise, but they're close enough.  (Bits
 * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
 * to be some kind of bit mask -- 0x20 may be a near-field reading,
 * and 0x40 is actual contact, and 0x10 may be a start/stop or change
 * indication.)
 */
#define TOUCH_STATE_MASK  0xf0
#define TOUCH_STATE_NONE  0x00
#define TOUCH_STATE_START 0x30
#define TOUCH_STATE_DRAG  0x40

68 69
#define SCROLL_ACCEL_DEFAULT 7

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
/**
 * struct magicmouse_sc - Tracks Magic Mouse-specific data.
 * @input: Input device through which we report events.
 * @quirks: Currently unused.
 * @ntouches: Number of touches in most recent touch report.
 * @scroll_accel: Number of consecutive scroll motions.
 * @scroll_jiffies: Time of last scroll motion.
 * @touches: Most recent data for a touch, indexed by tracking ID.
 * @tracking_ids: Mapping of current touch input data to @touches.
 */
struct magicmouse_sc {
	struct input_dev *input;
	unsigned long quirks;

	int ntouches;
	int scroll_accel;
	unsigned long scroll_jiffies;

	struct {
		short x;
		short y;
91
		short scroll_x;
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
		short scroll_y;
		u8 size;
	} touches[16];
	int tracking_ids[16];
};

static int magicmouse_firm_touch(struct magicmouse_sc *msc)
{
	int touch = -1;
	int ii;

	/* If there is only one "firm" touch, set touch to its
	 * tracking ID.
	 */
	for (ii = 0; ii < msc->ntouches; ii++) {
		int idx = msc->tracking_ids[ii];
		if (msc->touches[idx].size < 8) {
			/* Ignore this touch. */
		} else if (touch >= 0) {
			touch = -1;
			break;
		} else {
			touch = idx;
		}
	}

	return touch;
}

static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
{
123 124 125
	int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |
		test_bit(BTN_RIGHT, msc->input->key) << 1 |
		test_bit(BTN_MIDDLE, msc->input->key) << 2;
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154

	if (emulate_3button) {
		int id;

		/* If some button was pressed before, keep it held
		 * down.  Otherwise, if there's exactly one firm
		 * touch, use that to override the mouse's guess.
		 */
		if (state == 0) {
			/* The button was released. */
		} else if (last_state != 0) {
			state = last_state;
		} else if ((id = magicmouse_firm_touch(msc)) >= 0) {
			int x = msc->touches[id].x;
			if (x < middle_button_start)
				state = 1;
			else if (x > middle_button_stop)
				state = 2;
			else
				state = 4;
		} /* else: we keep the mouse's guess */

		input_report_key(msc->input, BTN_MIDDLE, state & 4);
	}

	input_report_key(msc->input, BTN_LEFT, state & 1);
	input_report_key(msc->input, BTN_RIGHT, state & 2);

	if (state != last_state)
155
		msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
156 157 158 159 160
}

static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
{
	struct input_dev *input = msc->input;
161 162 163 164 165 166 167 168 169
	int id = (tdata[6] << 2 | tdata[5] >> 6) & 0xf;
	int x = (tdata[1] << 28 | tdata[0] << 20) >> 20;
	int y = -((tdata[2] << 24 | tdata[1] << 16) >> 20);
	int size = tdata[5] & 0x3f;
	int orientation = (tdata[6] >> 2) - 32;
	int touch_major = tdata[3];
	int touch_minor = tdata[4];
	int state = tdata[7] & TOUCH_STATE_MASK;
	int down = state != TOUCH_STATE_NONE;
170 171 172 173 174

	/* Store tracking ID and other fields. */
	msc->tracking_ids[raw_id] = id;
	msc->touches[id].x = x;
	msc->touches[id].y = y;
175
	msc->touches[id].size = size;
176 177

	/* If requested, emulate a scroll wheel by detecting small
178
	 * vertical touch motions.
179
	 */
180
	if (emulate_scroll_wheel) {
181
		unsigned long now = jiffies;
182 183
		int step_x = msc->touches[id].scroll_x - x;
		int step_y = msc->touches[id].scroll_y - y;
184 185

		/* Calculate and apply the scroll motion. */
186
		switch (state) {
187
		case TOUCH_STATE_START:
188
			msc->touches[id].scroll_x = x;
189
			msc->touches[id].scroll_y = y;
190 191 192 193 194 195 196 197 198

			/* Reset acceleration after half a second. */
			if (scroll_acceleration && time_before(now,
						msc->scroll_jiffies + HZ / 2))
				msc->scroll_accel = max_t(int,
						msc->scroll_accel - 1, 1);
			else
				msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

199 200
			break;
		case TOUCH_STATE_DRAG:
201 202 203
			step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
			if (step_x != 0) {
				msc->touches[id].scroll_x -= step_x *
204
					(64 - scroll_speed) * msc->scroll_accel;
205
				msc->scroll_jiffies = now;
206 207 208 209 210 211 212 213 214
				input_report_rel(input, REL_HWHEEL, -step_x);
			}

			step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;
			if (step_y != 0) {
				msc->touches[id].scroll_y -= step_y *
					(64 - scroll_speed) * msc->scroll_accel;
				msc->scroll_jiffies = now;
				input_report_rel(input, REL_WHEEL, step_y);
215 216 217 218 219 220
			}
			break;
		}
	}

	/* Generate the input events for this touch. */
221
	if (report_touches && down) {
222
		input_report_abs(input, ABS_MT_TRACKING_ID, id);
223 224
		input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major);
		input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor);
225 226 227 228
		input_report_abs(input, ABS_MT_ORIENTATION, orientation);
		input_report_abs(input, ABS_MT_POSITION_X, x);
		input_report_abs(input, ABS_MT_POSITION_Y, y);

229
		if (report_undeciphered)
230 231 232 233
			input_event(input, EV_MSC, MSC_RAW, tdata[7]);

		input_mt_sync(input);
	}
234 235 236

	if (down)
		msc->ntouches++;
237 238 239 240 241 242 243
}

static int magicmouse_raw_event(struct hid_device *hdev,
		struct hid_report *report, u8 *data, int size)
{
	struct magicmouse_sc *msc = hid_get_drvdata(hdev);
	struct input_dev *input = msc->input;
244
	int x, y, ii, clicks, npoints;
245 246 247 248 249 250 251 252 253 254 255 256 257

	switch (data[0]) {
	case 0x10:
		if (size != 6)
			return 0;
		x = (__s16)(data[2] | data[3] << 8);
		y = (__s16)(data[4] | data[5] << 8);
		clicks = data[1];
		break;
	case TOUCH_REPORT_ID:
		/* Expect six bytes of prefix, and N*8 bytes of touch data. */
		if (size < 6 || ((size - 6) % 8) != 0)
			return 0;
258 259 260
		npoints = (size - 6) / 8;
		msc->ntouches = 0;
		for (ii = 0; ii < npoints; ii++)
261
			magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
262

263 264
		if (report_touches && msc->ntouches == 0)
			input_mt_sync(input);
265

266 267 268 269
		/* When emulating three-button mode, it is important
		 * to have the current touch information before
		 * generating a click event.
		 */
270 271
		x = (int)(((data[3] & 0x0c) << 28) | (data[1] << 22)) >> 22;
		y = (int)(((data[3] & 0x30) << 26) | (data[2] << 22)) >> 22;
272
		clicks = data[3];
273 274 275 276 277 278

		/* The following bits provide a device specific timestamp. They
		 * are unused here.
		 *
		 * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
		 */
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
		break;
	case 0x20: /* Theoretically battery status (0-100), but I have
		    * never seen it -- maybe it is only upon request.
		    */
	case 0x60: /* Unknown, maybe laser on/off. */
	case 0x61: /* Laser reflection status change.
		    * data[1]: 0 = spotted, 1 = lost
		    */
	default:
		return 0;
	}

	magicmouse_emit_buttons(msc, clicks & 3);
	input_report_rel(input, REL_X, x);
	input_report_rel(input, REL_Y, y);
	input_sync(input);
	return 1;
}

static int magicmouse_input_open(struct input_dev *dev)
{
	struct hid_device *hid = input_get_drvdata(dev);

	return hid->ll_driver->open(hid);
}

static void magicmouse_input_close(struct input_dev *dev)
{
	struct hid_device *hid = input_get_drvdata(dev);

	hid->ll_driver->close(hid);
}

static void magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
{
	input_set_drvdata(input, hdev);
	input->event = hdev->ll_driver->hidinput_input_event;
	input->open = magicmouse_input_open;
	input->close = magicmouse_input_close;

	input->name = hdev->name;
	input->phys = hdev->phys;
	input->uniq = hdev->uniq;
	input->id.bustype = hdev->bus;
	input->id.vendor = hdev->vendor;
	input->id.product = hdev->product;
	input->id.version = hdev->version;
	input->dev.parent = hdev->dev.parent;

328 329 330
	__set_bit(EV_KEY, input->evbit);
	__set_bit(BTN_LEFT, input->keybit);
	__set_bit(BTN_RIGHT, input->keybit);
331
	if (emulate_3button)
332 333
		__set_bit(BTN_MIDDLE, input->keybit);
	__set_bit(BTN_TOOL_FINGER, input->keybit);
334

335 336 337
	__set_bit(EV_REL, input->evbit);
	__set_bit(REL_X, input->relbit);
	__set_bit(REL_Y, input->relbit);
338
	if (emulate_scroll_wheel) {
339
		__set_bit(REL_WHEEL, input->relbit);
340 341
		__set_bit(REL_HWHEEL, input->relbit);
	}
342 343

	if (report_touches) {
344 345 346 347 348 349 350 351
		__set_bit(EV_ABS, input->evbit);

		input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, 15, 0, 0);
		input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 4, 0);
		input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 4, 0);
		input_set_abs_params(input, ABS_MT_ORIENTATION, -32, 31, 1, 0);
		input_set_abs_params(input, ABS_MT_POSITION_X, -1100, 1358,
				4, 0);
352 353 354 355 356 357
		/* Note: Touch Y position from the device is inverted relative
		 * to how pointer motion is reported (and relative to how USB
		 * HID recommends the coordinates work).  This driver keeps
		 * the origin at the same position, and just uses the additive
		 * inverse of the reported Y.
		 */
358 359
		input_set_abs_params(input, ABS_MT_POSITION_Y, -1589, 2047,
				4, 0);
360 361 362
	}

	if (report_undeciphered) {
363 364
		__set_bit(EV_MSC, input->evbit);
		__set_bit(MSC_RAW, input->mscbit);
365 366 367 368 369 370
	}
}

static int magicmouse_probe(struct hid_device *hdev,
	const struct hid_device_id *id)
{
371
	__u8 feature[] = { 0xd7, 0x01 };
372 373 374 375 376 377 378 379 380 381 382
	struct input_dev *input;
	struct magicmouse_sc *msc;
	struct hid_report *report;
	int ret;

	msc = kzalloc(sizeof(*msc), GFP_KERNEL);
	if (msc == NULL) {
		dev_err(&hdev->dev, "can't alloc magicmouse descriptor\n");
		return -ENOMEM;
	}

383 384
	msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

385 386 387 388 389 390 391 392 393
	msc->quirks = id->driver_data;
	hid_set_drvdata(hdev, msc);

	ret = hid_parse(hdev);
	if (ret) {
		dev_err(&hdev->dev, "magicmouse hid parse failed\n");
		goto err_free;
	}

394
	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
395 396 397 398 399
	if (ret) {
		dev_err(&hdev->dev, "magicmouse hw start failed\n");
		goto err_free;
	}

400 401 402
	/* we are handling the input ourselves */
	hidinput_disconnect(hdev);

403 404 405 406
	report = hid_register_report(hdev, HID_INPUT_REPORT, TOUCH_REPORT_ID);
	if (!report) {
		dev_err(&hdev->dev, "unable to register touch report\n");
		ret = -ENOMEM;
407
		goto err_stop_hw;
408 409 410
	}
	report->size = 6;

411
	ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature),
412
			HID_FEATURE_REPORT);
413 414
	if (ret != sizeof(feature)) {
		dev_err(&hdev->dev, "unable to request touch data (%d)\n",
415
				ret);
416
		goto err_stop_hw;
417 418 419 420 421 422
	}

	input = input_allocate_device();
	if (!input) {
		dev_err(&hdev->dev, "can't alloc input device\n");
		ret = -ENOMEM;
423
		goto err_stop_hw;
424 425 426 427 428 429
	}
	magicmouse_setup_input(input, hdev);

	ret = input_register_device(input);
	if (ret) {
		dev_err(&hdev->dev, "input device registration failed\n");
430
		goto err_input;
431 432 433 434
	}
	msc->input = input;

	return 0;
435
err_input:
436
	input_free_device(input);
437 438 439
err_stop_hw:
	hid_hw_stop(hdev);
err_free:
440 441 442 443 444 445
	kfree(msc);
	return ret;
}

static void magicmouse_remove(struct hid_device *hdev)
{
446 447
	struct magicmouse_sc *msc = hid_get_drvdata(hdev);

448
	hid_hw_stop(hdev);
449 450
	input_unregister_device(msc->input);
	kfree(msc);
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
}

static const struct hid_device_id magic_mice[] = {
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE),
		.driver_data = 0 },
	{ }
};
MODULE_DEVICE_TABLE(hid, magic_mice);

static struct hid_driver magicmouse_driver = {
	.name = "magicmouse",
	.id_table = magic_mice,
	.probe = magicmouse_probe,
	.remove = magicmouse_remove,
	.raw_event = magicmouse_raw_event,
};

static int __init magicmouse_init(void)
{
	int ret;

	ret = hid_register_driver(&magicmouse_driver);
	if (ret)
		printk(KERN_ERR "can't register magicmouse driver\n");

	return ret;
}

static void __exit magicmouse_exit(void)
{
	hid_unregister_driver(&magicmouse_driver);
}

module_init(magicmouse_init);
module_exit(magicmouse_exit);
MODULE_LICENSE("GPL");