[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hid / hid-magicmouse.c

/*
 *   Apple "Magic" Wireless Mouse driver
 *
 *   Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
 *   Copyright (c) 2010 Chase Douglas <chase.douglas@canonical.com>
 */

/*
 * 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.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>

#include "hid-ids.h"

static bool emulate_3button = true;
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;

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

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)");

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

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

static bool report_undeciphered;
module_param(report_undeciphered, bool, 0644);
MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");

#define TRACKPAD_REPORT_ID 0x28
#define MOUSE_REPORT_ID    0x29
#define DOUBLE_REPORT_ID   0xf7
/* 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

#define SCROLL_ACCEL_DEFAULT 7

/* Single touch emulation should only begin when no touches are currently down.
 * This is true when single_touch_id is equal to NO_TOUCHES. If multiple touches
 * are down and the touch providing for single touch emulation is lifted,
 * single_touch_id is equal to SINGLE_TOUCH_UP. While single touch emulation is
 * occurring, single_touch_id corresponds with the tracking id of the touch used.
 */
#define NO_TOUCHES -1
#define SINGLE_TOUCH_UP -2

/* Touch surface information. Dimension is in hundredths of a mm, min and max
 * are in units. */
#define MOUSE_DIMENSION_X (float)9056
#define MOUSE_MIN_X -1100
#define MOUSE_MAX_X 1258
#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
#define MOUSE_DIMENSION_Y (float)5152
#define MOUSE_MIN_Y -1589
#define MOUSE_MAX_Y 2047
#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))

#define TRACKPAD_DIMENSION_X (float)13000
#define TRACKPAD_MIN_X -2909
#define TRACKPAD_MAX_X 3167
#define TRACKPAD_RES_X \
	((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
#define TRACKPAD_DIMENSION_Y (float)11000
#define TRACKPAD_MIN_Y -2456
#define TRACKPAD_MAX_Y 2565
#define TRACKPAD_RES_Y \
	((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))

/**
 * 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;
		short scroll_x;
		short scroll_y;
		u8 size;
	} touches[16];
	int tracking_ids[16];
	int single_touch_id;
};

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)
{
	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;

	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)
		msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
}

static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
{
	struct input_dev *input = msc->input;
	int id, x, y, size, orientation, touch_major, touch_minor, state, down;

	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
		id = (tdata[6] << 2 | tdata[5] >> 6) & 0xf;
		x = (tdata[1] << 28 | tdata[0] << 20) >> 20;
		y = -((tdata[2] << 24 | tdata[1] << 16) >> 20);
		size = tdata[5] & 0x3f;
		orientation = (tdata[6] >> 2) - 32;
		touch_major = tdata[3];
		touch_minor = tdata[4];
		state = tdata[7] & TOUCH_STATE_MASK;
		down = state != TOUCH_STATE_NONE;
	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
		id = (tdata[7] << 2 | tdata[6] >> 6) & 0xf;
		x = (tdata[1] << 27 | tdata[0] << 19) >> 19;
		y = -((tdata[3] << 30 | tdata[2] << 22 | tdata[1] << 14) >> 19);
		size = tdata[6] & 0x3f;
		orientation = (tdata[7] >> 2) - 32;
		touch_major = tdata[4];
		touch_minor = tdata[5];
		state = tdata[8] & TOUCH_STATE_MASK;
		down = state != TOUCH_STATE_NONE;
	}

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

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

		/* Calculate and apply the scroll motion. */
		switch (state) {
		case TOUCH_STATE_START:
			msc->touches[id].scroll_x = x;
			msc->touches[id].scroll_y = y;

			/* 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;

			break;
		case TOUCH_STATE_DRAG:
			step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
			if (step_x != 0) {
				msc->touches[id].scroll_x -= step_x *
					(64 - scroll_speed) * msc->scroll_accel;
				msc->scroll_jiffies = now;
				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);
			}
			break;
		}
	}

	if (down) {
		msc->ntouches++;
		if (msc->single_touch_id == NO_TOUCHES)
			msc->single_touch_id = id;
	} else if (msc->single_touch_id == id)
		msc->single_touch_id = SINGLE_TOUCH_UP;

	/* Generate the input events for this touch. */
	if (report_touches && down) {
		input_report_abs(input, ABS_MT_TRACKING_ID, id);
		input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2);
		input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2);
		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);

		if (report_undeciphered) {
			if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
				input_event(input, EV_MSC, MSC_RAW, tdata[7]);
			else /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
				input_event(input, EV_MSC, MSC_RAW, tdata[8]);
		}

		input_mt_sync(input);
	}
}

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;
	int x = 0, y = 0, ii, clicks = 0, npoints;

	switch (data[0]) {
	case TRACKPAD_REPORT_ID:
		/* Expect four bytes of prefix, and N*9 bytes of touch data. */
		if (size < 4 || ((size - 4) % 9) != 0)
			return 0;
		npoints = (size - 4) / 9;
		msc->ntouches = 0;
		for (ii = 0; ii < npoints; ii++)
			magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);

		/* We don't need an MT sync here because trackpad emits a
		 * BTN_TOUCH event in a new frame when all touches are released.
		 */
		if (msc->ntouches == 0)
			msc->single_touch_id = NO_TOUCHES;

		clicks = data[1];

		/* The following bits provide a device specific timestamp. They
		 * are unused here.
		 *
		 * ts = data[1] >> 6 | data[2] << 2 | data[3] << 10;
		 */
		break;
	case MOUSE_REPORT_ID:
		/* Expect six bytes of prefix, and N*8 bytes of touch data. */
		if (size < 6 || ((size - 6) % 8) != 0)
			return 0;
		npoints = (size - 6) / 8;
		msc->ntouches = 0;
		for (ii = 0; ii < npoints; ii++)
			magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);

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

		/* When emulating three-button mode, it is important
		 * to have the current touch information before
		 * generating a click event.
		 */
		x = (int)(((data[3] & 0x0c) << 28) | (data[1] << 22)) >> 22;
		y = (int)(((data[3] & 0x30) << 26) | (data[2] << 22)) >> 22;
		clicks = data[3];

		/* The following bits provide a device specific timestamp. They
		 * are unused here.
		 *
		 * ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
		 */
		break;
	case DOUBLE_REPORT_ID:
		/* Sometimes the trackpad sends two touch reports in one
		 * packet.
		 */
		magicmouse_raw_event(hdev, report, data + 2, data[1]);
		magicmouse_raw_event(hdev, report, data + 2 + data[1],
			size - 2 - data[1]);
		break;
	default:
		return 0;
	}

	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
		magicmouse_emit_buttons(msc, clicks & 3);
		input_report_rel(input, REL_X, x);
		input_report_rel(input, REL_Y, y);
	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
		input_report_key(input, BTN_MOUSE, clicks & 1);
		input_report_key(input, BTN_TOUCH, msc->ntouches > 0);
		input_report_key(input, BTN_TOOL_FINGER, msc->ntouches == 1);
		input_report_key(input, BTN_TOOL_DOUBLETAP, msc->ntouches == 2);
		input_report_key(input, BTN_TOOL_TRIPLETAP, msc->ntouches == 3);
		input_report_key(input, BTN_TOOL_QUADTAP, msc->ntouches == 4);
		if (msc->single_touch_id >= 0) {
			input_report_abs(input, ABS_X,
				msc->touches[msc->single_touch_id].x);
			input_report_abs(input, ABS_Y,
				msc->touches[msc->single_touch_id].y);
		}
	}

	input_sync(input);
	return 1;
}

static void magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
{
	__set_bit(EV_KEY, input->evbit);

	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
		__set_bit(BTN_LEFT, input->keybit);
		__set_bit(BTN_RIGHT, input->keybit);
		if (emulate_3button)
			__set_bit(BTN_MIDDLE, input->keybit);

		__set_bit(EV_REL, input->evbit);
		__set_bit(REL_X, input->relbit);
		__set_bit(REL_Y, input->relbit);
		if (emulate_scroll_wheel) {
			__set_bit(REL_WHEEL, input->relbit);
			__set_bit(REL_HWHEEL, input->relbit);
		}
	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
		__set_bit(BTN_MOUSE, input->keybit);
		__set_bit(BTN_TOOL_FINGER, input->keybit);
		__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
		__set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
		__set_bit(BTN_TOOL_QUADTAP, input->keybit);
		__set_bit(BTN_TOUCH, input->keybit);
	}

	if (report_touches) {
		__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, -31, 32, 1, 0);

		/* 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.
		 */
		if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
			input_set_abs_params(input, ABS_MT_POSITION_X,
				MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
			input_set_abs_params(input, ABS_MT_POSITION_Y,
				MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);

			input_abs_set_res(input, ABS_MT_POSITION_X,
				MOUSE_RES_X);
			input_abs_set_res(input, ABS_MT_POSITION_Y,
				MOUSE_RES_Y);
		} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
			input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
				TRACKPAD_MAX_X, 4, 0);
			input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
				TRACKPAD_MAX_Y, 4, 0);
			input_set_abs_params(input, ABS_MT_POSITION_X,
				TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
			input_set_abs_params(input, ABS_MT_POSITION_Y,
				TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);

			input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
			input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
			input_abs_set_res(input, ABS_MT_POSITION_X,
				TRACKPAD_RES_X);
			input_abs_set_res(input, ABS_MT_POSITION_Y,
				TRACKPAD_RES_Y);
		}

		input_set_events_per_packet(input, 60);
	}

	if (report_undeciphered) {
		__set_bit(EV_MSC, input->evbit);
		__set_bit(MSC_RAW, input->mscbit);
	}
}

static int magicmouse_input_mapping(struct hid_device *hdev,
		struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
	struct magicmouse_sc *msc = hid_get_drvdata(hdev);

	if (!msc->input)
		msc->input = hi->input;

	/* Magic Trackpad does not give relative data after switching to MT */
	if (hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD &&
	    field->flags & HID_MAIN_ITEM_RELATIVE)
		return -1;

	return 0;
}

static int magicmouse_probe(struct hid_device *hdev,
	const struct hid_device_id *id)
{
	__u8 feature[] = { 0xd7, 0x01 };
	struct magicmouse_sc *msc;
	struct hid_report *report;
	int ret;

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

	msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

	msc->quirks = id->driver_data;
	hid_set_drvdata(hdev, msc);

	msc->single_touch_id = NO_TOUCHES;

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "magicmouse hid parse failed\n");
		goto err_free;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret) {
		hid_err(hdev, "magicmouse hw start failed\n");
		goto err_free;
	}

	/* We do this after hid-input is done parsing reports so that
	 * hid-input uses the most natural button and axis IDs.
	 */
	if (msc->input)
		magicmouse_setup_input(msc->input, hdev);

	if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
		report = hid_register_report(hdev, HID_INPUT_REPORT,
			MOUSE_REPORT_ID);
	else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
		report = hid_register_report(hdev, HID_INPUT_REPORT,
			TRACKPAD_REPORT_ID);
		report = hid_register_report(hdev, HID_INPUT_REPORT,
			DOUBLE_REPORT_ID);
	}

	if (!report) {
		hid_err(hdev, "unable to register touch report\n");
		ret = -ENOMEM;
		goto err_stop_hw;
	}
	report->size = 6;

	ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature),
			HID_FEATURE_REPORT);
	if (ret != sizeof(feature)) {
		hid_err(hdev, "unable to request touch data (%d)\n", ret);
		goto err_stop_hw;
	}

	return 0;
err_stop_hw:
	hid_hw_stop(hdev);
err_free:
	kfree(msc);
	return ret;
}

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

	hid_hw_stop(hdev);
	kfree(msc);
}

static const struct hid_device_id magic_mice[] = {
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
		USB_DEVICE_ID_APPLE_MAGICMOUSE), .driver_data = 0 },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
		USB_DEVICE_ID_APPLE_MAGICTRACKPAD), .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,
	.input_mapping = magicmouse_input_mapping,
};

static int __init magicmouse_init(void)
{
	int ret;

	ret = hid_register_driver(&magicmouse_driver);
	if (ret)
		pr_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");
Commit	Line	Data
128537ce MP	1	/*
	2	* Apple "Magic" Wireless Mouse driver
	3	*
	4	* Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
a462230e	5	* Copyright (c) 2010 Chase Douglas <chase.douglas@canonical.com>
128537ce MP	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
4291ee30 JP	15	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
4291ee30 JP	16
128537ce MP	17	#include <linux/device.h>
	18	#include <linux/hid.h>
	19	#include <linux/module.h>
5a0e3ad6	20	#include <linux/slab.h>
128537ce MP	21	#include <linux/usb.h>
	22
	23	#include "hid-ids.h"
	24
71b38bd4	25	static bool emulate_3button = true;
128537ce MP	26	module_param(emulate_3button, bool, 0644);
	27	MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");
	28
	29	static int middle_button_start = -350;
	30	static int middle_button_stop = +350;
	31
71b38bd4	32	static bool emulate_scroll_wheel = true;
128537ce MP	33	module_param(emulate_scroll_wheel, bool, 0644);
	34	MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");
	35
0b778e76 CD	36	static unsigned int scroll_speed = 32;
	37	static int param_set_scroll_speed(const char val, struct kernel_param kp) {
	38	unsigned long speed;
	39	if (!val \|\| strict_strtoul(val, 0, &speed) \|\| speed > 63)
	40	return -EINVAL;
	41	scroll_speed = speed;
	42	return 0;
	43	}
	44	module_param_call(scroll_speed, param_set_scroll_speed, param_get_uint, &scroll_speed, 0644);
	45	MODULE_PARM_DESC(scroll_speed, "Scroll speed, value from 0 (slow) to 63 (fast)");
	46
9846f350 CD	47	static bool scroll_acceleration = false;
	48	module_param(scroll_acceleration, bool, 0644);
	49	MODULE_PARM_DESC(scroll_acceleration, "Accelerate sequential scroll events");
	50
71b38bd4	51	static bool report_touches = true;
128537ce MP	52	module_param(report_touches, bool, 0644);
	53	MODULE_PARM_DESC(report_touches, "Emit touch records (otherwise, only use them for emulation)");
	54
71b38bd4	55	static bool report_undeciphered;
128537ce MP	56	module_param(report_undeciphered, bool, 0644);
	57	MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");
	58
a462230e CD	59	#define TRACKPAD_REPORT_ID 0x28
	60	#define MOUSE_REPORT_ID 0x29
	61	#define DOUBLE_REPORT_ID 0xf7
128537ce MP	62	/* These definitions are not precise, but they're close enough. (Bits
	63	* 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
	64	* to be some kind of bit mask -- 0x20 may be a near-field reading,
	65	* and 0x40 is actual contact, and 0x10 may be a start/stop or change
	66	* indication.)
	67	*/
	68	#define TOUCH_STATE_MASK 0xf0
	69	#define TOUCH_STATE_NONE 0x00
	70	#define TOUCH_STATE_START 0x30
	71	#define TOUCH_STATE_DRAG 0x40
	72
0b778e76 CD	73	#define SCROLL_ACCEL_DEFAULT 7
0b778e76 CD	74
a462230e CD	75	/* Single touch emulation should only begin when no touches are currently down.
	76	* This is true when single_touch_id is equal to NO_TOUCHES. If multiple touches
	77	* are down and the touch providing for single touch emulation is lifted,
	78	* single_touch_id is equal to SINGLE_TOUCH_UP. While single touch emulation is
25985edc	79	* occurring, single_touch_id corresponds with the tracking id of the touch used.
a462230e CD	80	*/
	81	#define NO_TOUCHES -1
	82	#define SINGLE_TOUCH_UP -2
	83
4f6fdf08 CD	84	/* Touch surface information. Dimension is in hundredths of a mm, min and max
	85	* are in units. */
	86	#define MOUSE_DIMENSION_X (float)9056
	87	#define MOUSE_MIN_X -1100
	88	#define MOUSE_MAX_X 1258
	89	#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
	90	#define MOUSE_DIMENSION_Y (float)5152
	91	#define MOUSE_MIN_Y -1589
	92	#define MOUSE_MAX_Y 2047
	93	#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
	94
	95	#define TRACKPAD_DIMENSION_X (float)13000
	96	#define TRACKPAD_MIN_X -2909
	97	#define TRACKPAD_MAX_X 3167
	98	#define TRACKPAD_RES_X \
	99	((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
	100	#define TRACKPAD_DIMENSION_Y (float)11000
	101	#define TRACKPAD_MIN_Y -2456
	102	#define TRACKPAD_MAX_Y 2565
	103	#define TRACKPAD_RES_Y \
	104	((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
	105
128537ce MP	106	/**
	107	* struct magicmouse_sc - Tracks Magic Mouse-specific data.
	108	* @input: Input device through which we report events.
	109	* @quirks: Currently unused.
128537ce MP	110	* @ntouches: Number of touches in most recent touch report.
	111	* @scroll_accel: Number of consecutive scroll motions.
	112	* @scroll_jiffies: Time of last scroll motion.
	113	* @touches: Most recent data for a touch, indexed by tracking ID.
	114	* @tracking_ids: Mapping of current touch input data to @touches.
	115	*/
	116	struct magicmouse_sc {
	117	struct input_dev *input;
	118	unsigned long quirks;
	119
128537ce MP	120	int ntouches;
	121	int scroll_accel;
	122	unsigned long scroll_jiffies;
	123
	124	struct {
	125	short x;
	126	short y;
c0426688	127	short scroll_x;
128537ce MP	128	short scroll_y;
	129	u8 size;
	130	} touches[16];
	131	int tracking_ids[16];
a462230e	132	int single_touch_id;
128537ce MP	133	};
	134
	135	static 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
	158	static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
	159	{
71b38bd4 MP	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;
128537ce MP	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)
0b778e76	192	msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
128537ce MP	193	}
	194
	195	static void magicmouse_emit_touch(struct magicmouse_sc msc, int raw_id, u8 tdata)
	196	{
	197	struct input_dev *input = msc->input;
a462230e CD	198	int id, x, y, size, orientation, touch_major, touch_minor, state, down;
	199
	200	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
	201	id = (tdata[6] << 2 \| tdata[5] >> 6) & 0xf;
	202	x = (tdata[1] << 28 \| tdata[0] << 20) >> 20;
	203	y = -((tdata[2] << 24 \| tdata[1] << 16) >> 20);
	204	size = tdata[5] & 0x3f;
	205	orientation = (tdata[6] >> 2) - 32;
	206	touch_major = tdata[3];
	207	touch_minor = tdata[4];
	208	state = tdata[7] & TOUCH_STATE_MASK;
	209	down = state != TOUCH_STATE_NONE;
	210	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
	211	id = (tdata[7] << 2 \| tdata[6] >> 6) & 0xf;
	212	x = (tdata[1] << 27 \| tdata[0] << 19) >> 19;
	213	y = -((tdata[3] << 30 \| tdata[2] << 22 \| tdata[1] << 14) >> 19);
	214	size = tdata[6] & 0x3f;
	215	orientation = (tdata[7] >> 2) - 32;
	216	touch_major = tdata[4];
	217	touch_minor = tdata[5];
	218	state = tdata[8] & TOUCH_STATE_MASK;
	219	down = state != TOUCH_STATE_NONE;
	220	}
128537ce MP	221
	222	/* Store tracking ID and other fields. */
	223	msc->tracking_ids[raw_id] = id;
	224	msc->touches[id].x = x;
	225	msc->touches[id].y = y;
6de048bf	226	msc->touches[id].size = size;
128537ce MP	227
128537ce MP	228	/* If requested, emulate a scroll wheel by detecting small
ef566d30	229	* vertical touch motions.
128537ce	230	*/
ef566d30	231	if (emulate_scroll_wheel) {
128537ce	232	unsigned long now = jiffies;
c0426688 CD	233	int step_x = msc->touches[id].scroll_x - x;
c0426688 CD	234	int step_y = msc->touches[id].scroll_y - y;
128537ce	235
128537ce	236	/* Calculate and apply the scroll motion. */
6de048bf	237	switch (state) {
128537ce	238	case TOUCH_STATE_START:
c0426688	239	msc->touches[id].scroll_x = x;
128537ce	240	msc->touches[id].scroll_y = y;
0b778e76 CD	241
	242	/* Reset acceleration after half a second. */
	243	if (scroll_acceleration && time_before(now,
	244	msc->scroll_jiffies + HZ / 2))
	245	msc->scroll_accel = max_t(int,
	246	msc->scroll_accel - 1, 1);
	247	else
	248	msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
	249
128537ce MP	250	break;
128537ce MP	251	case TOUCH_STATE_DRAG:
c0426688 CD	252	step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;
	253	if (step_x != 0) {
	254	msc->touches[id].scroll_x -= step_x *
0b778e76	255	(64 - scroll_speed) * msc->scroll_accel;
128537ce	256	msc->scroll_jiffies = now;
c0426688 CD	257	input_report_rel(input, REL_HWHEEL, -step_x);
	258	}
	259
	260	step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;
	261	if (step_y != 0) {
	262	msc->touches[id].scroll_y -= step_y *
	263	(64 - scroll_speed) * msc->scroll_accel;
	264	msc->scroll_jiffies = now;
	265	input_report_rel(input, REL_WHEEL, step_y);
128537ce MP	266	}
	267	break;
	268	}
	269	}
	270
a462230e CD	271	if (down) {
	272	msc->ntouches++;
	273	if (msc->single_touch_id == NO_TOUCHES)
	274	msc->single_touch_id = id;
	275	} else if (msc->single_touch_id == id)
	276	msc->single_touch_id = SINGLE_TOUCH_UP;
	277
128537ce	278	/* Generate the input events for this touch. */
e3612e86	279	if (report_touches && down) {
128537ce	280	input_report_abs(input, ABS_MT_TRACKING_ID, id);
921990b7 HR	281	input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major << 2);
921990b7 HR	282	input_report_abs(input, ABS_MT_TOUCH_MINOR, touch_minor << 2);
2d9ca4e9	283	input_report_abs(input, ABS_MT_ORIENTATION, -orientation);
128537ce MP	284	input_report_abs(input, ABS_MT_POSITION_X, x);
	285	input_report_abs(input, ABS_MT_POSITION_Y, y);
	286
a462230e CD	287	if (report_undeciphered) {
	288	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
	289	input_event(input, EV_MSC, MSC_RAW, tdata[7]);
	290	else /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
	291	input_event(input, EV_MSC, MSC_RAW, tdata[8]);
	292	}
128537ce MP	293
	294	input_mt_sync(input);
	295	}
	296	}
	297
	298	static int magicmouse_raw_event(struct hid_device *hdev,
	299	struct hid_report report, u8 data, int size)
	300	{
	301	struct magicmouse_sc *msc = hid_get_drvdata(hdev);
	302	struct input_dev *input = msc->input;
a462230e	303	int x = 0, y = 0, ii, clicks = 0, npoints;
128537ce MP	304
128537ce MP	305	switch (data[0]) {
a462230e CD	306	case TRACKPAD_REPORT_ID:
	307	/* Expect four bytes of prefix, and N9 bytes of touch data. /
	308	if (size < 4 \|\| ((size - 4) % 9) != 0)
	309	return 0;
	310	npoints = (size - 4) / 9;
	311	msc->ntouches = 0;
	312	for (ii = 0; ii < npoints; ii++)
	313	magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);
	314
	315	/* We don't need an MT sync here because trackpad emits a
	316	* BTN_TOUCH event in a new frame when all touches are released.
	317	*/
	318	if (msc->ntouches == 0)
	319	msc->single_touch_id = NO_TOUCHES;
	320
	321	clicks = data[1];
	322
	323	/* The following bits provide a device specific timestamp. They
	324	* are unused here.
	325	*
	326	* ts = data[1] >> 6 \| data[2] << 2 \| data[3] << 10;
	327	*/
	328	break;
	329	case MOUSE_REPORT_ID:
128537ce MP	330	/* Expect six bytes of prefix, and N8 bytes of touch data. /
	331	if (size < 6 \|\| ((size - 6) % 8) != 0)
	332	return 0;
0228db70 CD	333	npoints = (size - 6) / 8;
	334	msc->ntouches = 0;
	335	for (ii = 0; ii < npoints; ii++)
128537ce	336	magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
e3612e86	337
0228db70 CD	338	if (report_touches && msc->ntouches == 0)
0228db70 CD	339	input_mt_sync(input);
e3612e86	340
128537ce MP	341	/* When emulating three-button mode, it is important
	342	* to have the current touch information before
	343	* generating a click event.
	344	*/
7d876c05 MP	345	x = (int)(((data[3] & 0x0c) << 28) \| (data[1] << 22)) >> 22;
7d876c05 MP	346	y = (int)(((data[3] & 0x30) << 26) \| (data[2] << 22)) >> 22;
128537ce	347	clicks = data[3];
c61b7cee CD	348
	349	/* The following bits provide a device specific timestamp. They
	350	* are unused here.
	351	*
	352	* ts = data[3] >> 6 \| data[4] << 2 \| data[5] << 10;
	353	*/
128537ce	354	break;
a462230e CD	355	case DOUBLE_REPORT_ID:
	356	/* Sometimes the trackpad sends two touch reports in one
	357	* packet.
	358	*/
	359	magicmouse_raw_event(hdev, report, data + 2, data[1]);
	360	magicmouse_raw_event(hdev, report, data + 2 + data[1],
	361	size - 2 - data[1]);
	362	break;
128537ce MP	363	default:
	364	return 0;
	365	}
	366
a462230e CD	367	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
	368	magicmouse_emit_buttons(msc, clicks & 3);
	369	input_report_rel(input, REL_X, x);
	370	input_report_rel(input, REL_Y, y);
	371	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
	372	input_report_key(input, BTN_MOUSE, clicks & 1);
	373	input_report_key(input, BTN_TOUCH, msc->ntouches > 0);
	374	input_report_key(input, BTN_TOOL_FINGER, msc->ntouches == 1);
	375	input_report_key(input, BTN_TOOL_DOUBLETAP, msc->ntouches == 2);
	376	input_report_key(input, BTN_TOOL_TRIPLETAP, msc->ntouches == 3);
	377	input_report_key(input, BTN_TOOL_QUADTAP, msc->ntouches == 4);
	378	if (msc->single_touch_id >= 0) {
	379	input_report_abs(input, ABS_X,
	380	msc->touches[msc->single_touch_id].x);
	381	input_report_abs(input, ABS_Y,
	382	msc->touches[msc->single_touch_id].y);
	383	}
	384	}
	385
128537ce MP	386	input_sync(input);
	387	return 1;
	388	}
	389
128537ce MP	390	static void magicmouse_setup_input(struct input_dev input, struct hid_device hdev)
128537ce MP	391	{
71b38bd4	392	__set_bit(EV_KEY, input->evbit);
a462230e CD	393
	394	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
	395	__set_bit(BTN_LEFT, input->keybit);
	396	__set_bit(BTN_RIGHT, input->keybit);
	397	if (emulate_3button)
	398	__set_bit(BTN_MIDDLE, input->keybit);
	399
	400	__set_bit(EV_REL, input->evbit);
	401	__set_bit(REL_X, input->relbit);
	402	__set_bit(REL_Y, input->relbit);
	403	if (emulate_scroll_wheel) {
	404	__set_bit(REL_WHEEL, input->relbit);
	405	__set_bit(REL_HWHEEL, input->relbit);
	406	}
	407	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
	408	__set_bit(BTN_MOUSE, input->keybit);
	409	__set_bit(BTN_TOOL_FINGER, input->keybit);
	410	__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
	411	__set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
	412	__set_bit(BTN_TOOL_QUADTAP, input->keybit);
	413	__set_bit(BTN_TOUCH, input->keybit);
c0426688	414	}
128537ce MP	415
128537ce MP	416	if (report_touches) {
71b38bd4 MP	417	__set_bit(EV_ABS, input->evbit);
	418
	419	input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, 15, 0, 0);
	420	input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 4, 0);
	421	input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 4, 0);
2d9ca4e9	422	input_set_abs_params(input, ABS_MT_ORIENTATION, -31, 32, 1, 0);
a462230e	423
128537ce MP	424	/* Note: Touch Y position from the device is inverted relative
	425	* to how pointer motion is reported (and relative to how USB
	426	* HID recommends the coordinates work). This driver keeps
	427	* the origin at the same position, and just uses the additive
	428	* inverse of the reported Y.
	429	*/
a462230e	430	if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
4f6fdf08 CD	431	input_set_abs_params(input, ABS_MT_POSITION_X,
	432	MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
	433	input_set_abs_params(input, ABS_MT_POSITION_Y,
	434	MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
	435
	436	input_abs_set_res(input, ABS_MT_POSITION_X,
	437	MOUSE_RES_X);
	438	input_abs_set_res(input, ABS_MT_POSITION_Y,
	439	MOUSE_RES_Y);
a462230e	440	} else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
4f6fdf08 CD	441	input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
	442	TRACKPAD_MAX_X, 4, 0);
	443	input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
	444	TRACKPAD_MAX_Y, 4, 0);
	445	input_set_abs_params(input, ABS_MT_POSITION_X,
	446	TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
	447	input_set_abs_params(input, ABS_MT_POSITION_Y,
	448	TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
	449
	450	input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
	451	input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
	452	input_abs_set_res(input, ABS_MT_POSITION_X,
	453	TRACKPAD_RES_X);
	454	input_abs_set_res(input, ABS_MT_POSITION_Y,
	455	TRACKPAD_RES_Y);
a462230e	456	}
cc5e0f08 CD	457
cc5e0f08 CD	458	input_set_events_per_packet(input, 60);
128537ce MP	459	}
	460
	461	if (report_undeciphered) {
71b38bd4 MP	462	__set_bit(EV_MSC, input->evbit);
71b38bd4 MP	463	__set_bit(MSC_RAW, input->mscbit);
128537ce MP	464	}
	465	}
	466
64eb105d MP	467	static int magicmouse_input_mapping(struct hid_device *hdev,
	468	struct hid_input hi, struct hid_field field,
	469	struct hid_usage usage, unsigned long bit, int max)
	470	{
	471	struct magicmouse_sc *msc = hid_get_drvdata(hdev);
	472
	473	if (!msc->input)
	474	msc->input = hi->input;
	475
6a66bbd6 CD	476	/* Magic Trackpad does not give relative data after switching to MT */
	477	if (hi->input->id.product == USB_DEVICE_ID_APPLE_MAGICTRACKPAD &&
	478	field->flags & HID_MAIN_ITEM_RELATIVE)
	479	return -1;
	480
64eb105d MP	481	return 0;
	482	}
	483
128537ce MP	484	static int magicmouse_probe(struct hid_device *hdev,
	485	const struct hid_device_id *id)
	486	{
0773590c	487	__u8 feature[] = { 0xd7, 0x01 };
128537ce MP	488	struct magicmouse_sc *msc;
	489	struct hid_report *report;
	490	int ret;
	491
	492	msc = kzalloc(sizeof(*msc), GFP_KERNEL);
	493	if (msc == NULL) {
4291ee30	494	hid_err(hdev, "can't alloc magicmouse descriptor\n");
128537ce MP	495	return -ENOMEM;
	496	}
	497
0b778e76 CD	498	msc->scroll_accel = SCROLL_ACCEL_DEFAULT;
0b778e76 CD	499
128537ce MP	500	msc->quirks = id->driver_data;
	501	hid_set_drvdata(hdev, msc);
	502
a462230e CD	503	msc->single_touch_id = NO_TOUCHES;
a462230e CD	504
128537ce MP	505	ret = hid_parse(hdev);
128537ce MP	506	if (ret) {
4291ee30	507	hid_err(hdev, "magicmouse hid parse failed\n");
128537ce MP	508	goto err_free;
	509	}
	510
23d02116	511	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
128537ce	512	if (ret) {
4291ee30	513	hid_err(hdev, "magicmouse hw start failed\n");
128537ce MP	514	goto err_free;
	515	}
	516
64eb105d MP	517	/* We do this after hid-input is done parsing reports so that
	518	* hid-input uses the most natural button and axis IDs.
	519	*/
	520	if (msc->input)
	521	magicmouse_setup_input(msc->input, hdev);
23d02116	522
a462230e CD	523	if (id->product == USB_DEVICE_ID_APPLE_MAGICMOUSE)
	524	report = hid_register_report(hdev, HID_INPUT_REPORT,
	525	MOUSE_REPORT_ID);
	526	else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
	527	report = hid_register_report(hdev, HID_INPUT_REPORT,
	528	TRACKPAD_REPORT_ID);
	529	report = hid_register_report(hdev, HID_INPUT_REPORT,
	530	DOUBLE_REPORT_ID);
	531	}
	532
128537ce	533	if (!report) {
4291ee30	534	hid_err(hdev, "unable to register touch report\n");
128537ce	535	ret = -ENOMEM;
71b38bd4	536	goto err_stop_hw;
128537ce MP	537	}
	538	report->size = 6;
	539
0773590c	540	ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature),
128537ce	541	HID_FEATURE_REPORT);
c3a49245	542	if (ret != sizeof(feature)) {
4291ee30	543	hid_err(hdev, "unable to request touch data (%d)\n", ret);
71b38bd4	544	goto err_stop_hw;
128537ce MP	545	}
128537ce MP	546
128537ce	547	return 0;
71b38bd4 MP	548	err_stop_hw:
	549	hid_hw_stop(hdev);
	550	err_free:
128537ce MP	551	kfree(msc);
	552	return ret;
	553	}
	554
	555	static void magicmouse_remove(struct hid_device *hdev)
	556	{
28918c21 MP	557	struct magicmouse_sc *msc = hid_get_drvdata(hdev);
28918c21 MP	558
128537ce	559	hid_hw_stop(hdev);
28918c21	560	kfree(msc);
128537ce MP	561	}
	562
	563	static const struct hid_device_id magic_mice[] = {
a462230e CD	564	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
	565	USB_DEVICE_ID_APPLE_MAGICMOUSE), .driver_data = 0 },
	566	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
	567	USB_DEVICE_ID_APPLE_MAGICTRACKPAD), .driver_data = 0 },
128537ce MP	568	{ }
	569	};
	570	MODULE_DEVICE_TABLE(hid, magic_mice);
	571
	572	static struct hid_driver magicmouse_driver = {
	573	.name = "magicmouse",
	574	.id_table = magic_mice,
	575	.probe = magicmouse_probe,
	576	.remove = magicmouse_remove,
	577	.raw_event = magicmouse_raw_event,
64eb105d	578	.input_mapping = magicmouse_input_mapping,
128537ce MP	579	};
	580
	581	static int __init magicmouse_init(void)
	582	{
	583	int ret;
	584
	585	ret = hid_register_driver(&magicmouse_driver);
	586	if (ret)
4291ee30	587	pr_err("can't register magicmouse driver\n");
128537ce MP	588
	589	return ret;
	590	}
	591
	592	static void __exit magicmouse_exit(void)
	593	{
	594	hid_unregister_driver(&magicmouse_driver);
	595	}
	596
	597	module_init(magicmouse_init);
	598	module_exit(magicmouse_exit);
	599	MODULE_LICENSE("GPL");