[deliverable/linux.git] / drivers / hid / hid-wiimote.c

/*
 * HID driver for Nintendo Wiimote devices
 * Copyright (c) 2011 David Herrmann
 */

/*
 * 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/input.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include "hid-ids.h"

#define WIIMOTE_VERSION "0.1"
#define WIIMOTE_NAME "Nintendo Wii Remote"
#define WIIMOTE_BUFSIZE 32

struct wiimote_buf {
	__u8 data[HID_MAX_BUFFER_SIZE];
	size_t size;
};

struct wiimote_state {
	spinlock_t lock;
	__u8 flags;
};

struct wiimote_data {
	struct hid_device *hdev;
	struct input_dev *input;
	struct led_classdev *leds[4];

	spinlock_t qlock;
	__u8 head;
	__u8 tail;
	struct wiimote_buf outq[WIIMOTE_BUFSIZE];
	struct work_struct worker;

	struct wiimote_state state;
};

#define WIIPROTO_FLAG_LED1 0x01
#define WIIPROTO_FLAG_LED2 0x02
#define WIIPROTO_FLAG_LED3 0x04
#define WIIPROTO_FLAG_LED4 0x08
#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
					WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)

/* return flag for led \num */
#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))

enum wiiproto_reqs {
	WIIPROTO_REQ_NULL = 0x0,
	WIIPROTO_REQ_LED = 0x11,
	WIIPROTO_REQ_DRM = 0x12,
	WIIPROTO_REQ_STATUS = 0x20,
	WIIPROTO_REQ_RETURN = 0x22,
	WIIPROTO_REQ_DRM_K = 0x30,
};

enum wiiproto_keys {
	WIIPROTO_KEY_LEFT,
	WIIPROTO_KEY_RIGHT,
	WIIPROTO_KEY_UP,
	WIIPROTO_KEY_DOWN,
	WIIPROTO_KEY_PLUS,
	WIIPROTO_KEY_MINUS,
	WIIPROTO_KEY_ONE,
	WIIPROTO_KEY_TWO,
	WIIPROTO_KEY_A,
	WIIPROTO_KEY_B,
	WIIPROTO_KEY_HOME,
	WIIPROTO_KEY_COUNT
};

static __u16 wiiproto_keymap[] = {
	KEY_LEFT,	/* WIIPROTO_KEY_LEFT */
	KEY_RIGHT,	/* WIIPROTO_KEY_RIGHT */
	KEY_UP,		/* WIIPROTO_KEY_UP */
	KEY_DOWN,	/* WIIPROTO_KEY_DOWN */
	KEY_NEXT,	/* WIIPROTO_KEY_PLUS */
	KEY_PREVIOUS,	/* WIIPROTO_KEY_MINUS */
	BTN_1,		/* WIIPROTO_KEY_ONE */
	BTN_2,		/* WIIPROTO_KEY_TWO */
	BTN_A,		/* WIIPROTO_KEY_A */
	BTN_B,		/* WIIPROTO_KEY_B */
	BTN_MODE,	/* WIIPROTO_KEY_HOME */
};

static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
								size_t count)
{
	__u8 *buf;
	ssize_t ret;

	if (!hdev->hid_output_raw_report)
		return -ENODEV;

	buf = kmemdup(buffer, count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);

	kfree(buf);
	return ret;
}

static void wiimote_worker(struct work_struct *work)
{
	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
									worker);
	unsigned long flags;

	spin_lock_irqsave(&wdata->qlock, flags);

	while (wdata->head != wdata->tail) {
		spin_unlock_irqrestore(&wdata->qlock, flags);
		wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
						wdata->outq[wdata->tail].size);
		spin_lock_irqsave(&wdata->qlock, flags);

		wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
	}

	spin_unlock_irqrestore(&wdata->qlock, flags);
}

static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
								size_t count)
{
	unsigned long flags;
	__u8 newhead;

	if (count > HID_MAX_BUFFER_SIZE) {
		hid_warn(wdata->hdev, "Sending too large output report\n");
		return;
	}

	/*
	 * Copy new request into our output queue and check whether the
	 * queue is full. If it is full, discard this request.
	 * If it is empty we need to start a new worker that will
	 * send out the buffer to the hid device.
	 * If the queue is not empty, then there must be a worker
	 * that is currently sending out our buffer and this worker
	 * will reschedule itself until the queue is empty.
	 */

	spin_lock_irqsave(&wdata->qlock, flags);

	memcpy(wdata->outq[wdata->head].data, buffer, count);
	wdata->outq[wdata->head].size = count;
	newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;

	if (wdata->head == wdata->tail) {
		wdata->head = newhead;
		schedule_work(&wdata->worker);
	} else if (newhead != wdata->tail) {
		wdata->head = newhead;
	} else {
		hid_warn(wdata->hdev, "Output queue is full");
	}

	spin_unlock_irqrestore(&wdata->qlock, flags);
}

static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
{
	__u8 cmd[2];

	leds &= WIIPROTO_FLAGS_LEDS;
	if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
		return;
	wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;

	cmd[0] = WIIPROTO_REQ_LED;
	cmd[1] = 0;

	if (leds & WIIPROTO_FLAG_LED1)
		cmd[1] |= 0x10;
	if (leds & WIIPROTO_FLAG_LED2)
		cmd[1] |= 0x20;
	if (leds & WIIPROTO_FLAG_LED3)
		cmd[1] |= 0x40;
	if (leds & WIIPROTO_FLAG_LED4)
		cmd[1] |= 0x80;

	wiimote_queue(wdata, cmd, sizeof(cmd));
}

/*
 * Check what peripherals of the wiimote are currently
 * active and select a proper DRM that supports all of
 * the requested data inputs.
 */
static __u8 select_drm(struct wiimote_data *wdata)
{
	return WIIPROTO_REQ_DRM_K;
}

static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
{
	__u8 cmd[3];

	if (drm == WIIPROTO_REQ_NULL)
		drm = select_drm(wdata);

	cmd[0] = WIIPROTO_REQ_DRM;
	cmd[1] = 0;
	cmd[2] = drm;

	wiimote_queue(wdata, cmd, sizeof(cmd));
}

static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
{
	struct wiimote_data *wdata;
	struct device *dev = led_dev->dev->parent;
	int i;
	unsigned long flags;
	bool value = false;

	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));

	for (i = 0; i < 4; ++i) {
		if (wdata->leds[i] == led_dev) {
			spin_lock_irqsave(&wdata->state.lock, flags);
			value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
			spin_unlock_irqrestore(&wdata->state.lock, flags);
			break;
		}
	}

	return value ? LED_FULL : LED_OFF;
}

static void wiimote_leds_set(struct led_classdev *led_dev,
						enum led_brightness value)
{
	struct wiimote_data *wdata;
	struct device *dev = led_dev->dev->parent;
	int i;
	unsigned long flags;
	__u8 state, flag;

	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));

	for (i = 0; i < 4; ++i) {
		if (wdata->leds[i] == led_dev) {
			flag = WIIPROTO_FLAG_LED(i + 1);
			spin_lock_irqsave(&wdata->state.lock, flags);
			state = wdata->state.flags;
			if (value == LED_OFF)
				wiiproto_req_leds(wdata, state & ~flag);
			else
				wiiproto_req_leds(wdata, state | flag);
			spin_unlock_irqrestore(&wdata->state.lock, flags);
			break;
		}
	}
}

static int wiimote_input_event(struct input_dev *dev, unsigned int type,
						unsigned int code, int value)
{
	return 0;
}

static int wiimote_input_open(struct input_dev *dev)
{
	struct wiimote_data *wdata = input_get_drvdata(dev);

	return hid_hw_open(wdata->hdev);
}

static void wiimote_input_close(struct input_dev *dev)
{
	struct wiimote_data *wdata = input_get_drvdata(dev);

	hid_hw_close(wdata->hdev);
}

static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
{
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
							!!(payload[0] & 0x01));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
							!!(payload[0] & 0x02));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
							!!(payload[0] & 0x04));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
							!!(payload[0] & 0x08));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
							!!(payload[0] & 0x10));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
							!!(payload[1] & 0x01));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
							!!(payload[1] & 0x02));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
							!!(payload[1] & 0x04));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
							!!(payload[1] & 0x08));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
							!!(payload[1] & 0x10));
	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
							!!(payload[1] & 0x80));
	input_sync(wdata->input);
}

static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
{
	handler_keys(wdata, payload);

	/* on status reports the drm is reset so we need to resend the drm */
	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
}

static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
{
	__u8 err = payload[3];
	__u8 cmd = payload[2];

	handler_keys(wdata, payload);

	if (err)
		hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
									cmd);
}

struct wiiproto_handler {
	__u8 id;
	size_t size;
	void (*func)(struct wiimote_data *wdata, const __u8 *payload);
};

static struct wiiproto_handler handlers[] = {
	{ .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
	{ .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
	{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
	{ .id = 0 }
};

static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
							u8 *raw_data, int size)
{
	struct wiimote_data *wdata = hid_get_drvdata(hdev);
	struct wiiproto_handler *h;
	int i;
	unsigned long flags;

	if (size < 1)
		return -EINVAL;

	spin_lock_irqsave(&wdata->state.lock, flags);

	for (i = 0; handlers[i].id; ++i) {
		h = &handlers[i];
		if (h->id == raw_data[0] && h->size < size)
			h->func(wdata, &raw_data[1]);
	}

	spin_unlock_irqrestore(&wdata->state.lock, flags);

	return 0;
}

static void wiimote_leds_destroy(struct wiimote_data *wdata)
{
	int i;
	struct led_classdev *led;

	for (i = 0; i < 4; ++i) {
		if (wdata->leds[i]) {
			led = wdata->leds[i];
			wdata->leds[i] = NULL;
			led_classdev_unregister(led);
			kfree(led);
		}
	}
}

static int wiimote_leds_create(struct wiimote_data *wdata)
{
	int i, ret;
	struct device *dev = &wdata->hdev->dev;
	size_t namesz = strlen(dev_name(dev)) + 9;
	struct led_classdev *led;
	char *name;

	for (i = 0; i < 4; ++i) {
		led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
		if (!led) {
			ret = -ENOMEM;
			goto err;
		}
		name = (void*)&led[1];
		snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
		led->name = name;
		led->brightness = 0;
		led->max_brightness = 1;
		led->brightness_get = wiimote_leds_get;
		led->brightness_set = wiimote_leds_set;

		ret = led_classdev_register(dev, led);
		if (ret) {
			kfree(led);
			goto err;
		}
		wdata->leds[i] = led;
	}

	return 0;

err:
	wiimote_leds_destroy(wdata);
	return ret;
}

static struct wiimote_data *wiimote_create(struct hid_device *hdev)
{
	struct wiimote_data *wdata;
	int i;

	wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
	if (!wdata)
		return NULL;

	wdata->input = input_allocate_device();
	if (!wdata->input) {
		kfree(wdata);
		return NULL;
	}

	wdata->hdev = hdev;
	hid_set_drvdata(hdev, wdata);

	input_set_drvdata(wdata->input, wdata);
	wdata->input->event = wiimote_input_event;
	wdata->input->open = wiimote_input_open;
	wdata->input->close = wiimote_input_close;
	wdata->input->dev.parent = &wdata->hdev->dev;
	wdata->input->id.bustype = wdata->hdev->bus;
	wdata->input->id.vendor = wdata->hdev->vendor;
	wdata->input->id.product = wdata->hdev->product;
	wdata->input->id.version = wdata->hdev->version;
	wdata->input->name = WIIMOTE_NAME;

	set_bit(EV_KEY, wdata->input->evbit);
	for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
		set_bit(wiiproto_keymap[i], wdata->input->keybit);

	spin_lock_init(&wdata->qlock);
	INIT_WORK(&wdata->worker, wiimote_worker);

	spin_lock_init(&wdata->state.lock);

	return wdata;
}

static void wiimote_destroy(struct wiimote_data *wdata)
{
	wiimote_leds_destroy(wdata);

	input_unregister_device(wdata->input);
	cancel_work_sync(&wdata->worker);
	hid_hw_stop(wdata->hdev);

	kfree(wdata);
}

static int wiimote_hid_probe(struct hid_device *hdev,
				const struct hid_device_id *id)
{
	struct wiimote_data *wdata;
	int ret;

	wdata = wiimote_create(hdev);
	if (!wdata) {
		hid_err(hdev, "Can't alloc device\n");
		return -ENOMEM;
	}

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "HID parse failed\n");
		goto err;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (ret) {
		hid_err(hdev, "HW start failed\n");
		goto err;
	}

	ret = input_register_device(wdata->input);
	if (ret) {
		hid_err(hdev, "Cannot register input device\n");
		goto err_stop;
	}

	ret = wiimote_leds_create(wdata);
	if (ret)
		goto err_free;

	hid_info(hdev, "New device registered\n");

	/* by default set led1 after device initialization */
	spin_lock_irq(&wdata->state.lock);
	wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
	spin_unlock_irq(&wdata->state.lock);

	return 0;

err_free:
	wiimote_destroy(wdata);
	return ret;

err_stop:
	hid_hw_stop(hdev);
err:
	input_free_device(wdata->input);
	kfree(wdata);
	return ret;
}

static void wiimote_hid_remove(struct hid_device *hdev)
{
	struct wiimote_data *wdata = hid_get_drvdata(hdev);

	hid_info(hdev, "Device removed\n");
	wiimote_destroy(wdata);
}

static const struct hid_device_id wiimote_hid_devices[] = {
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
				USB_DEVICE_ID_NINTENDO_WIIMOTE) },
	{ }
};
MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);

static struct hid_driver wiimote_hid_driver = {
	.name = "wiimote",
	.id_table = wiimote_hid_devices,
	.probe = wiimote_hid_probe,
	.remove = wiimote_hid_remove,
	.raw_event = wiimote_hid_event,
};

static int __init wiimote_init(void)
{
	int ret;

	ret = hid_register_driver(&wiimote_hid_driver);
	if (ret)
		pr_err("Can't register wiimote hid driver\n");

	return ret;
}

static void __exit wiimote_exit(void)
{
	hid_unregister_driver(&wiimote_hid_driver);
}

module_init(wiimote_init);
module_exit(wiimote_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
MODULE_VERSION(WIIMOTE_VERSION);
Commit	Line	Data
fb51b443 DH	1	/*
	2	* HID driver for Nintendo Wiimote devices
	3	* Copyright (c) 2011 David Herrmann
	4	*/
	5
	6	/*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the Free
	9	* Software Foundation; either version 2 of the License, or (at your option)
	10	* any later version.
	11	*/
	12
672bc4e0	13	#include <linux/device.h>
02fb72a0	14	#include <linux/hid.h>
672bc4e0	15	#include <linux/input.h>
23a5a4a3	16	#include <linux/leds.h>
fb51b443	17	#include <linux/module.h>
23c063cb	18	#include <linux/spinlock.h>
02fb72a0	19	#include "hid-ids.h"
fb51b443 DH	20
	21	#define WIIMOTE_VERSION "0.1"
	22	#define WIIMOTE_NAME "Nintendo Wii Remote"
23c063cb DH	23	#define WIIMOTE_BUFSIZE 32
	24
	25	struct wiimote_buf {
	26	__u8 data[HID_MAX_BUFFER_SIZE];
	27	size_t size;
	28	};
fb51b443	29
32a0d9a5 DH	30	struct wiimote_state {
	31	spinlock_t lock;
	32	__u8 flags;
	33	};
	34
e894d0e3 DH	35	struct wiimote_data {
e894d0e3 DH	36	struct hid_device *hdev;
672bc4e0	37	struct input_dev *input;
23a5a4a3	38	struct led_classdev *leds[4];
23c063cb DH	39
	40	spinlock_t qlock;
	41	__u8 head;
	42	__u8 tail;
	43	struct wiimote_buf outq[WIIMOTE_BUFSIZE];
	44	struct work_struct worker;
32a0d9a5 DH	45
32a0d9a5 DH	46	struct wiimote_state state;
e894d0e3 DH	47	};
e894d0e3 DH	48
db308346 DH	49	#define WIIPROTO_FLAG_LED1 0x01
	50	#define WIIPROTO_FLAG_LED2 0x02
	51	#define WIIPROTO_FLAG_LED3 0x04
	52	#define WIIPROTO_FLAG_LED4 0x08
32a0d9a5 DH	53	#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 \| WIIPROTO_FLAG_LED2 \| \
32a0d9a5 DH	54	WIIPROTO_FLAG_LED3 \| WIIPROTO_FLAG_LED4)
db308346	55
23a5a4a3 DH	56	/* return flag for led \num */
	57	#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
	58
1abb9ad3	59	enum wiiproto_reqs {
2cb5e4bc	60	WIIPROTO_REQ_NULL = 0x0,
db308346	61	WIIPROTO_REQ_LED = 0x11,
2cb5e4bc	62	WIIPROTO_REQ_DRM = 0x12,
c87019e4 DH	63	WIIPROTO_REQ_STATUS = 0x20,
c87019e4 DH	64	WIIPROTO_REQ_RETURN = 0x22,
1abb9ad3 DH	65	WIIPROTO_REQ_DRM_K = 0x30,
	66	};
	67
	68	enum wiiproto_keys {
	69	WIIPROTO_KEY_LEFT,
	70	WIIPROTO_KEY_RIGHT,
	71	WIIPROTO_KEY_UP,
	72	WIIPROTO_KEY_DOWN,
	73	WIIPROTO_KEY_PLUS,
	74	WIIPROTO_KEY_MINUS,
	75	WIIPROTO_KEY_ONE,
	76	WIIPROTO_KEY_TWO,
	77	WIIPROTO_KEY_A,
	78	WIIPROTO_KEY_B,
	79	WIIPROTO_KEY_HOME,
	80	WIIPROTO_KEY_COUNT
	81	};
	82
	83	static __u16 wiiproto_keymap[] = {
	84	KEY_LEFT, /* WIIPROTO_KEY_LEFT */
	85	KEY_RIGHT, /* WIIPROTO_KEY_RIGHT */
	86	KEY_UP, /* WIIPROTO_KEY_UP */
	87	KEY_DOWN, /* WIIPROTO_KEY_DOWN */
	88	KEY_NEXT, /* WIIPROTO_KEY_PLUS */
	89	KEY_PREVIOUS, /* WIIPROTO_KEY_MINUS */
	90	BTN_1, /* WIIPROTO_KEY_ONE */
	91	BTN_2, /* WIIPROTO_KEY_TWO */
	92	BTN_A, /* WIIPROTO_KEY_A */
	93	BTN_B, /* WIIPROTO_KEY_B */
	94	BTN_MODE, /* WIIPROTO_KEY_HOME */
	95	};
	96
0c218f14 DH	97	static ssize_t wiimote_hid_send(struct hid_device hdev, __u8 buffer,
	98	size_t count)
	99	{
	100	__u8 *buf;
	101	ssize_t ret;
	102
	103	if (!hdev->hid_output_raw_report)
	104	return -ENODEV;
	105
	106	buf = kmemdup(buffer, count, GFP_KERNEL);
	107	if (!buf)
	108	return -ENOMEM;
	109
	110	ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
	111
	112	kfree(buf);
	113	return ret;
	114	}
	115
23c063cb DH	116	static void wiimote_worker(struct work_struct *work)
	117	{
	118	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
	119	worker);
	120	unsigned long flags;
	121
	122	spin_lock_irqsave(&wdata->qlock, flags);
	123
	124	while (wdata->head != wdata->tail) {
	125	spin_unlock_irqrestore(&wdata->qlock, flags);
	126	wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
	127	wdata->outq[wdata->tail].size);
	128	spin_lock_irqsave(&wdata->qlock, flags);
	129
	130	wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
	131	}
	132
	133	spin_unlock_irqrestore(&wdata->qlock, flags);
	134	}
	135
	136	static void wiimote_queue(struct wiimote_data wdata, const __u8 buffer,
	137	size_t count)
	138	{
	139	unsigned long flags;
	140	__u8 newhead;
	141
	142	if (count > HID_MAX_BUFFER_SIZE) {
	143	hid_warn(wdata->hdev, "Sending too large output report\n");
	144	return;
	145	}
	146
	147	/*
	148	* Copy new request into our output queue and check whether the
	149	* queue is full. If it is full, discard this request.
	150	* If it is empty we need to start a new worker that will
	151	* send out the buffer to the hid device.
	152	* If the queue is not empty, then there must be a worker
	153	* that is currently sending out our buffer and this worker
	154	* will reschedule itself until the queue is empty.
	155	*/
	156
	157	spin_lock_irqsave(&wdata->qlock, flags);
	158
	159	memcpy(wdata->outq[wdata->head].data, buffer, count);
	160	wdata->outq[wdata->head].size = count;
	161	newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
	162
	163	if (wdata->head == wdata->tail) {
	164	wdata->head = newhead;
	165	schedule_work(&wdata->worker);
	166	} else if (newhead != wdata->tail) {
	167	wdata->head = newhead;
	168	} else {
	169	hid_warn(wdata->hdev, "Output queue is full");
	170	}
	171
	172	spin_unlock_irqrestore(&wdata->qlock, flags);
	173	}
	174
db308346 DH	175	static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
	176	{
	177	__u8 cmd[2];
	178
32a0d9a5 DH	179	leds &= WIIPROTO_FLAGS_LEDS;
	180	if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
	181	return;
	182	wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) \| leds;
	183
db308346 DH	184	cmd[0] = WIIPROTO_REQ_LED;
	185	cmd[1] = 0;
	186
	187	if (leds & WIIPROTO_FLAG_LED1)
	188	cmd[1] \|= 0x10;
	189	if (leds & WIIPROTO_FLAG_LED2)
	190	cmd[1] \|= 0x20;
	191	if (leds & WIIPROTO_FLAG_LED3)
	192	cmd[1] \|= 0x40;
	193	if (leds & WIIPROTO_FLAG_LED4)
	194	cmd[1] \|= 0x80;
	195
	196	wiimote_queue(wdata, cmd, sizeof(cmd));
	197	}
	198
2cb5e4bc DH	199	/*
	200	* Check what peripherals of the wiimote are currently
	201	* active and select a proper DRM that supports all of
	202	* the requested data inputs.
	203	*/
	204	static __u8 select_drm(struct wiimote_data *wdata)
	205	{
	206	return WIIPROTO_REQ_DRM_K;
	207	}
	208
	209	static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
	210	{
	211	__u8 cmd[3];
	212
	213	if (drm == WIIPROTO_REQ_NULL)
	214	drm = select_drm(wdata);
	215
	216	cmd[0] = WIIPROTO_REQ_DRM;
	217	cmd[1] = 0;
	218	cmd[2] = drm;
	219
	220	wiimote_queue(wdata, cmd, sizeof(cmd));
	221	}
	222
23a5a4a3 DH	223	static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
	224	{
	225	struct wiimote_data *wdata;
	226	struct device *dev = led_dev->dev->parent;
	227	int i;
	228	unsigned long flags;
	229	bool value = false;
	230
	231	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
	232
	233	for (i = 0; i < 4; ++i) {
	234	if (wdata->leds[i] == led_dev) {
	235	spin_lock_irqsave(&wdata->state.lock, flags);
	236	value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
	237	spin_unlock_irqrestore(&wdata->state.lock, flags);
	238	break;
	239	}
	240	}
	241
	242	return value ? LED_FULL : LED_OFF;
	243	}
	244
	245	static void wiimote_leds_set(struct led_classdev *led_dev,
	246	enum led_brightness value)
	247	{
	248	struct wiimote_data *wdata;
	249	struct device *dev = led_dev->dev->parent;
	250	int i;
	251	unsigned long flags;
	252	__u8 state, flag;
	253
	254	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
	255
	256	for (i = 0; i < 4; ++i) {
	257	if (wdata->leds[i] == led_dev) {
	258	flag = WIIPROTO_FLAG_LED(i + 1);
	259	spin_lock_irqsave(&wdata->state.lock, flags);
	260	state = wdata->state.flags;
	261	if (value == LED_OFF)
	262	wiiproto_req_leds(wdata, state & ~flag);
	263	else
	264	wiiproto_req_leds(wdata, state \| flag);
	265	spin_unlock_irqrestore(&wdata->state.lock, flags);
	266	break;
	267	}
	268	}
	269	}
3c1c2fce	270
672bc4e0 DH	271	static int wiimote_input_event(struct input_dev *dev, unsigned int type,
	272	unsigned int code, int value)
	273	{
	274	return 0;
	275	}
	276
26af1748 DH	277	static int wiimote_input_open(struct input_dev *dev)
	278	{
	279	struct wiimote_data *wdata = input_get_drvdata(dev);
	280
	281	return hid_hw_open(wdata->hdev);
	282	}
	283
	284	static void wiimote_input_close(struct input_dev *dev)
	285	{
	286	struct wiimote_data *wdata = input_get_drvdata(dev);
	287
	288	hid_hw_close(wdata->hdev);
	289	}
	290
1abb9ad3 DH	291	static void handler_keys(struct wiimote_data wdata, const __u8 payload)
	292	{
	293	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
	294	!!(payload[0] & 0x01));
	295	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
	296	!!(payload[0] & 0x02));
	297	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
	298	!!(payload[0] & 0x04));
	299	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
	300	!!(payload[0] & 0x08));
	301	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
	302	!!(payload[0] & 0x10));
	303	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
	304	!!(payload[1] & 0x01));
	305	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
	306	!!(payload[1] & 0x02));
	307	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
	308	!!(payload[1] & 0x04));
	309	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
	310	!!(payload[1] & 0x08));
	311	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
	312	!!(payload[1] & 0x10));
	313	input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
	314	!!(payload[1] & 0x80));
	315	input_sync(wdata->input);
	316	}
	317
c87019e4 DH	318	static void handler_status(struct wiimote_data wdata, const __u8 payload)
	319	{
	320	handler_keys(wdata, payload);
	321
	322	/* on status reports the drm is reset so we need to resend the drm */
	323	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
	324	}
	325
	326	static void handler_return(struct wiimote_data wdata, const __u8 payload)
	327	{
	328	__u8 err = payload[3];
	329	__u8 cmd = payload[2];
	330
	331	handler_keys(wdata, payload);
	332
	333	if (err)
	334	hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
	335	cmd);
	336	}
	337
a4d19197 DH	338	struct wiiproto_handler {
	339	__u8 id;
	340	size_t size;
	341	void (func)(struct wiimote_data wdata, const __u8 *payload);
	342	};
	343
	344	static struct wiiproto_handler handlers[] = {
c87019e4 DH	345	{ .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
c87019e4 DH	346	{ .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
1abb9ad3	347	{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
a4d19197 DH	348	{ .id = 0 }
	349	};
	350
02fb72a0 DH	351	static int wiimote_hid_event(struct hid_device hdev, struct hid_report report,
	352	u8 *raw_data, int size)
	353	{
4d36e975	354	struct wiimote_data *wdata = hid_get_drvdata(hdev);
a4d19197 DH	355	struct wiiproto_handler *h;
a4d19197 DH	356	int i;
32a0d9a5	357	unsigned long flags;
4d36e975	358
02fb72a0 DH	359	if (size < 1)
	360	return -EINVAL;
	361
32a0d9a5 DH	362	spin_lock_irqsave(&wdata->state.lock, flags);
32a0d9a5 DH	363
a4d19197 DH	364	for (i = 0; handlers[i].id; ++i) {
	365	h = &handlers[i];
	366	if (h->id == raw_data[0] && h->size < size)
	367	h->func(wdata, &raw_data[1]);
	368	}
	369
32a0d9a5 DH	370	spin_unlock_irqrestore(&wdata->state.lock, flags);
32a0d9a5 DH	371
02fb72a0 DH	372	return 0;
	373	}
	374
23a5a4a3 DH	375	static void wiimote_leds_destroy(struct wiimote_data *wdata)
	376	{
	377	int i;
	378	struct led_classdev *led;
	379
	380	for (i = 0; i < 4; ++i) {
	381	if (wdata->leds[i]) {
	382	led = wdata->leds[i];
	383	wdata->leds[i] = NULL;
	384	led_classdev_unregister(led);
	385	kfree(led);
	386	}
	387	}
	388	}
	389
	390	static int wiimote_leds_create(struct wiimote_data *wdata)
	391	{
	392	int i, ret;
	393	struct device *dev = &wdata->hdev->dev;
	394	size_t namesz = strlen(dev_name(dev)) + 9;
	395	struct led_classdev *led;
	396	char *name;
	397
	398	for (i = 0; i < 4; ++i) {
	399	led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
	400	if (!led) {
	401	ret = -ENOMEM;
	402	goto err;
	403	}
	404	name = (void*)&led[1];
	405	snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
	406	led->name = name;
	407	led->brightness = 0;
	408	led->max_brightness = 1;
	409	led->brightness_get = wiimote_leds_get;
	410	led->brightness_set = wiimote_leds_set;
	411
	412	ret = led_classdev_register(dev, led);
	413	if (ret) {
	414	kfree(led);
	415	goto err;
	416	}
	417	wdata->leds[i] = led;
	418	}
	419
	420	return 0;
	421
	422	err:
	423	wiimote_leds_destroy(wdata);
	424	return ret;
	425	}
	426
e894d0e3 DH	427	static struct wiimote_data wiimote_create(struct hid_device hdev)
	428	{
	429	struct wiimote_data *wdata;
1abb9ad3	430	int i;
e894d0e3 DH	431
	432	wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
	433	if (!wdata)
	434	return NULL;
	435
672bc4e0 DH	436	wdata->input = input_allocate_device();
	437	if (!wdata->input) {
	438	kfree(wdata);
	439	return NULL;
	440	}
	441
e894d0e3 DH	442	wdata->hdev = hdev;
	443	hid_set_drvdata(hdev, wdata);
	444
672bc4e0 DH	445	input_set_drvdata(wdata->input, wdata);
672bc4e0 DH	446	wdata->input->event = wiimote_input_event;
26af1748 DH	447	wdata->input->open = wiimote_input_open;
26af1748 DH	448	wdata->input->close = wiimote_input_close;
672bc4e0 DH	449	wdata->input->dev.parent = &wdata->hdev->dev;
	450	wdata->input->id.bustype = wdata->hdev->bus;
	451	wdata->input->id.vendor = wdata->hdev->vendor;
	452	wdata->input->id.product = wdata->hdev->product;
	453	wdata->input->id.version = wdata->hdev->version;
	454	wdata->input->name = WIIMOTE_NAME;
	455
1abb9ad3 DH	456	set_bit(EV_KEY, wdata->input->evbit);
	457	for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
	458	set_bit(wiiproto_keymap[i], wdata->input->keybit);
	459
23c063cb DH	460	spin_lock_init(&wdata->qlock);
	461	INIT_WORK(&wdata->worker, wiimote_worker);
	462
32a0d9a5 DH	463	spin_lock_init(&wdata->state.lock);
32a0d9a5 DH	464
e894d0e3 DH	465	return wdata;
	466	}
	467
	468	static void wiimote_destroy(struct wiimote_data *wdata)
	469	{
23a5a4a3	470	wiimote_leds_destroy(wdata);
3989ef6c DH	471
	472	input_unregister_device(wdata->input);
	473	cancel_work_sync(&wdata->worker);
	474	hid_hw_stop(wdata->hdev);
	475
e894d0e3 DH	476	kfree(wdata);
	477	}
	478
02fb72a0 DH	479	static int wiimote_hid_probe(struct hid_device *hdev,
02fb72a0 DH	480	const struct hid_device_id *id)
fb51b443	481	{
e894d0e3	482	struct wiimote_data *wdata;
02fb72a0 DH	483	int ret;
02fb72a0 DH	484
e894d0e3 DH	485	wdata = wiimote_create(hdev);
	486	if (!wdata) {
	487	hid_err(hdev, "Can't alloc device\n");
	488	return -ENOMEM;
	489	}
	490
02fb72a0 DH	491	ret = hid_parse(hdev);
	492	if (ret) {
	493	hid_err(hdev, "HID parse failed\n");
e894d0e3	494	goto err;
02fb72a0 DH	495	}
	496
	497	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	498	if (ret) {
	499	hid_err(hdev, "HW start failed\n");
e894d0e3	500	goto err;
02fb72a0 DH	501	}
02fb72a0 DH	502
672bc4e0 DH	503	ret = input_register_device(wdata->input);
	504	if (ret) {
	505	hid_err(hdev, "Cannot register input device\n");
	506	goto err_stop;
	507	}
	508
23a5a4a3	509	ret = wiimote_leds_create(wdata);
3989ef6c DH	510	if (ret)
	511	goto err_free;
	512
02fb72a0	513	hid_info(hdev, "New device registered\n");
32a0d9a5 DH	514
	515	/* by default set led1 after device initialization */
	516	spin_lock_irq(&wdata->state.lock);
db308346	517	wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
32a0d9a5 DH	518	spin_unlock_irq(&wdata->state.lock);
32a0d9a5 DH	519
fb51b443	520	return 0;
e894d0e3	521
3989ef6c DH	522	err_free:
	523	wiimote_destroy(wdata);
	524	return ret;
	525
672bc4e0 DH	526	err_stop:
672bc4e0 DH	527	hid_hw_stop(hdev);
e894d0e3	528	err:
672bc4e0	529	input_free_device(wdata->input);
3989ef6c	530	kfree(wdata);
e894d0e3	531	return ret;
fb51b443 DH	532	}
fb51b443 DH	533
02fb72a0 DH	534	static void wiimote_hid_remove(struct hid_device *hdev)
02fb72a0 DH	535	{
e894d0e3 DH	536	struct wiimote_data *wdata = hid_get_drvdata(hdev);
e894d0e3 DH	537
02fb72a0	538	hid_info(hdev, "Device removed\n");
e894d0e3	539	wiimote_destroy(wdata);
02fb72a0 DH	540	}
	541
	542	static const struct hid_device_id wiimote_hid_devices[] = {
	543	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
	544	USB_DEVICE_ID_NINTENDO_WIIMOTE) },
	545	{ }
	546	};
	547	MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
	548
	549	static struct hid_driver wiimote_hid_driver = {
	550	.name = "wiimote",
	551	.id_table = wiimote_hid_devices,
	552	.probe = wiimote_hid_probe,
	553	.remove = wiimote_hid_remove,
	554	.raw_event = wiimote_hid_event,
	555	};
	556
	557	static int __init wiimote_init(void)
	558	{
	559	int ret;
	560
	561	ret = hid_register_driver(&wiimote_hid_driver);
	562	if (ret)
	563	pr_err("Can't register wiimote hid driver\n");
	564
	565	return ret;
	566	}
	567
fb51b443 DH	568	static void __exit wiimote_exit(void)
fb51b443 DH	569	{
02fb72a0	570	hid_unregister_driver(&wiimote_hid_driver);
fb51b443 DH	571	}
	572
	573	module_init(wiimote_init);
	574	module_exit(wiimote_exit);
	575	MODULE_LICENSE("GPL");
	576	MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
	577	MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
	578	MODULE_VERSION(WIIMOTE_VERSION);