[linux-2.6-block.git] / drivers / media / rc / xbox_remote.c

// SPDX-License-Identifier: GPL-2.0+
// Driver for Xbox DVD Movie Playback Kit
// Copyright (c) 2018 by Benjamin Valentin <benpicco@googlemail.com>

/*
 *  Xbox DVD Movie Playback Kit USB IR dongle support
 *
 *  The driver was derived from the ati_remote driver 2.2.1
 *          and used information from lirc_xbox.c
 *
 *          Copyright (c) 2011, 2012 Anssi Hannula <anssi.hannula@iki.fi>
 *          Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net>
 *          Copyright (c) 2002 Vladimir Dergachev
 *          Copyright (c) 2003-2004 Paul Miller <pmiller9@users.sourceforge.net>
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <linux/usb/input.h>
#include <media/rc-core.h>

/*
 * Module and Version Information
 */
#define DRIVER_VERSION	"1.0.0"
#define DRIVER_AUTHOR	"Benjamin Valentin <benpicco@googlemail.com>"
#define DRIVER_DESC		"Xbox DVD USB Remote Control"

#define NAME_BUFSIZE      80    /* size of product name, path buffers */
#define DATA_BUFSIZE      8     /* size of URB data buffers */

/*
 * USB vendor ids for XBOX DVD Dongles
 */
#define VENDOR_GAMESTER     0x040b
#define VENDOR_MICROSOFT    0x045e

static const struct usb_device_id xbox_remote_table[] = {
	/* Gamester Xbox DVD Movie Playback Kit IR */
	{
		USB_DEVICE(VENDOR_GAMESTER, 0x6521),
	},
	/* Microsoft Xbox DVD Movie Playback Kit IR */
	{
		USB_DEVICE(VENDOR_MICROSOFT, 0x0284),
	},
	{}	/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, xbox_remote_table);

struct xbox_remote {
	struct rc_dev *rdev;
	struct usb_device *udev;
	struct usb_interface *interface;

	struct urb *irq_urb;
	unsigned char inbuf[DATA_BUFSIZE] __aligned(sizeof(u16));

	char rc_name[NAME_BUFSIZE];
	char rc_phys[NAME_BUFSIZE];
};

static int xbox_remote_rc_open(struct rc_dev *rdev)
{
	struct xbox_remote *xbox_remote = rdev->priv;

	/* On first open, submit the read urb which was set up previously. */
	xbox_remote->irq_urb->dev = xbox_remote->udev;
	if (usb_submit_urb(xbox_remote->irq_urb, GFP_KERNEL)) {
		dev_err(&xbox_remote->interface->dev,
			"%s: usb_submit_urb failed!\n", __func__);
		return -EIO;
	}

	return 0;
}

static void xbox_remote_rc_close(struct rc_dev *rdev)
{
	struct xbox_remote *xbox_remote = rdev->priv;

	usb_kill_urb(xbox_remote->irq_urb);
}

/*
 * xbox_remote_report_input
 */
static void xbox_remote_input_report(struct urb *urb)
{
	struct xbox_remote *xbox_remote = urb->context;
	unsigned char *data = xbox_remote->inbuf;

	/*
	 * data[0] = 0x00
	 * data[1] = length - always 0x06
	 * data[2] = the key code
	 * data[3] = high part of key code
	 * data[4] = last_press_ms (low)
	 * data[5] = last_press_ms (high)
	 */

	/* Deal with strange looking inputs */
	if (urb->actual_length != 6 || urb->actual_length != data[1]) {
		dev_warn(&urb->dev->dev, "Weird data, len=%d: %*ph\n",
			 urb->actual_length, urb->actual_length, data);
		return;
	}

	rc_keydown(xbox_remote->rdev, RC_PROTO_XBOX_DVD,
		   le16_to_cpup((__le16 *)(data + 2)), 0);
}

/*
 * xbox_remote_irq_in
 */
static void xbox_remote_irq_in(struct urb *urb)
{
	struct xbox_remote *xbox_remote = urb->context;
	int retval;

	switch (urb->status) {
	case 0:			/* success */
		xbox_remote_input_report(urb);
		break;
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
	case -ESHUTDOWN:
		dev_dbg(&xbox_remote->interface->dev,
			"%s: urb error status, unlink?\n",
			__func__);
		return;
	default:		/* error */
		dev_dbg(&xbox_remote->interface->dev,
			"%s: Nonzero urb status %d\n",
			__func__, urb->status);
	}

	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		dev_err(&xbox_remote->interface->dev,
			"%s: usb_submit_urb()=%d\n",
			__func__, retval);
}

static void xbox_remote_rc_init(struct xbox_remote *xbox_remote)
{
	struct rc_dev *rdev = xbox_remote->rdev;

	rdev->priv = xbox_remote;
	rdev->allowed_protocols = RC_PROTO_BIT_XBOX_DVD;
	rdev->driver_name = "xbox_remote";

	rdev->open = xbox_remote_rc_open;
	rdev->close = xbox_remote_rc_close;

	rdev->device_name = xbox_remote->rc_name;
	rdev->input_phys = xbox_remote->rc_phys;

	rdev->timeout = MS_TO_NS(10);

	usb_to_input_id(xbox_remote->udev, &rdev->input_id);
	rdev->dev.parent = &xbox_remote->interface->dev;
}

static int xbox_remote_initialize(struct xbox_remote *xbox_remote,
				  struct usb_endpoint_descriptor *endpoint_in)
{
	struct usb_device *udev = xbox_remote->udev;
	int pipe, maxp;

	/* Set up irq_urb */
	pipe = usb_rcvintpipe(udev, endpoint_in->bEndpointAddress);
	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
	maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;

	usb_fill_int_urb(xbox_remote->irq_urb, udev, pipe, xbox_remote->inbuf,
			 maxp, xbox_remote_irq_in, xbox_remote,
			 endpoint_in->bInterval);

	return 0;
}

/*
 * xbox_remote_probe
 */
static int xbox_remote_probe(struct usb_interface *interface,
			     const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(interface);
	struct usb_host_interface *iface_host = interface->cur_altsetting;
	struct usb_endpoint_descriptor *endpoint_in;
	struct xbox_remote *xbox_remote;
	struct rc_dev *rc_dev;
	int err = -ENOMEM;

	// why is there also a device with no endpoints?
	if (iface_host->desc.bNumEndpoints == 0)
		return -ENODEV;

	if (iface_host->desc.bNumEndpoints != 1) {
		pr_err("%s: Unexpected desc.bNumEndpoints: %d\n",
		       __func__, iface_host->desc.bNumEndpoints);
		return -ENODEV;
	}

	endpoint_in = &iface_host->endpoint[0].desc;

	if (!usb_endpoint_is_int_in(endpoint_in)) {
		pr_err("%s: Unexpected endpoint_in\n", __func__);
		return -ENODEV;
	}
	if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
		pr_err("%s: endpoint_in message size==0?\n", __func__);
		return -ENODEV;
	}

	xbox_remote = kzalloc(sizeof(*xbox_remote), GFP_KERNEL);
	rc_dev = rc_allocate_device(RC_DRIVER_SCANCODE);
	if (!xbox_remote || !rc_dev)
		goto exit_free_dev_rdev;

	/* Allocate URB buffer */
	xbox_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!xbox_remote->irq_urb)
		goto exit_free_buffers;

	xbox_remote->udev = udev;
	xbox_remote->rdev = rc_dev;
	xbox_remote->interface = interface;

	usb_make_path(udev, xbox_remote->rc_phys, sizeof(xbox_remote->rc_phys));

	strlcat(xbox_remote->rc_phys, "/input0", sizeof(xbox_remote->rc_phys));

	snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name), "%s%s%s",
		 udev->manufacturer ?: "",
		 udev->manufacturer && udev->product ? " " : "",
		 udev->product ?: "");

	if (!strlen(xbox_remote->rc_name))
		snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name),
			 DRIVER_DESC "(%04x,%04x)",
			 le16_to_cpu(xbox_remote->udev->descriptor.idVendor),
			 le16_to_cpu(xbox_remote->udev->descriptor.idProduct));

	rc_dev->map_name = RC_MAP_XBOX_DVD; /* default map */

	xbox_remote_rc_init(xbox_remote);

	/* Device Hardware Initialization */
	err = xbox_remote_initialize(xbox_remote, endpoint_in);
	if (err)
		goto exit_kill_urbs;

	/* Set up and register rc device */
	err = rc_register_device(xbox_remote->rdev);
	if (err)
		goto exit_kill_urbs;

	usb_set_intfdata(interface, xbox_remote);

	return 0;

exit_kill_urbs:
	usb_kill_urb(xbox_remote->irq_urb);
exit_free_buffers:
	usb_free_urb(xbox_remote->irq_urb);
exit_free_dev_rdev:
	rc_free_device(rc_dev);
	kfree(xbox_remote);

	return err;
}

/*
 * xbox_remote_disconnect
 */
static void xbox_remote_disconnect(struct usb_interface *interface)
{
	struct xbox_remote *xbox_remote;

	xbox_remote = usb_get_intfdata(interface);
	usb_set_intfdata(interface, NULL);
	if (!xbox_remote) {
		dev_warn(&interface->dev, "%s - null device?\n", __func__);
		return;
	}

	usb_kill_urb(xbox_remote->irq_urb);
	rc_unregister_device(xbox_remote->rdev);
	usb_free_urb(xbox_remote->irq_urb);
	kfree(xbox_remote);
}

/* usb specific object to register with the usb subsystem */
static struct usb_driver xbox_remote_driver = {
	.name         = "xbox_remote",
	.probe        = xbox_remote_probe,
	.disconnect   = xbox_remote_disconnect,
	.id_table     = xbox_remote_table,
};

module_usb_driver(xbox_remote_driver);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
Commit	Line	Data
02d32bda BV	1	// SPDX-License-Identifier: GPL-2.0+
	2	// Driver for Xbox DVD Movie Playback Kit
	3	// Copyright (c) 2018 by Benjamin Valentin <benpicco@googlemail.com>
	4
	5	/*
	6	* Xbox DVD Movie Playback Kit USB IR dongle support
	7	*
	8	* The driver was derived from the ati_remote driver 2.2.1
	9	* and used information from lirc_xbox.c
	10	*
	11	* Copyright (c) 2011, 2012 Anssi Hannula <anssi.hannula@iki.fi>
	12	* Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net>
	13	* Copyright (c) 2002 Vladimir Dergachev
	14	* Copyright (c) 2003-2004 Paul Miller <pmiller9@users.sourceforge.net>
	15	*/
	16
	17	#include <linux/slab.h>
	18	#include <linux/module.h>
	19	#include <linux/usb/input.h>
	20	#include <media/rc-core.h>
	21
	22	/*
	23	* Module and Version Information
	24	*/
	25	#define DRIVER_VERSION "1.0.0"
	26	#define DRIVER_AUTHOR "Benjamin Valentin <benpicco@googlemail.com>"
	27	#define DRIVER_DESC "Xbox DVD USB Remote Control"
	28
	29	#define NAME_BUFSIZE 80 /* size of product name, path buffers */
	30	#define DATA_BUFSIZE 8 /* size of URB data buffers */
	31
	32	/*
	33	* USB vendor ids for XBOX DVD Dongles
	34	*/
	35	#define VENDOR_GAMESTER 0x040b
	36	#define VENDOR_MICROSOFT 0x045e
	37
	38	static const struct usb_device_id xbox_remote_table[] = {
	39	/* Gamester Xbox DVD Movie Playback Kit IR */
	40	{
	41	USB_DEVICE(VENDOR_GAMESTER, 0x6521),
	42	},
	43	/* Microsoft Xbox DVD Movie Playback Kit IR */
	44	{
	45	USB_DEVICE(VENDOR_MICROSOFT, 0x0284),
	46	},
	47	{} /* Terminating entry */
	48	};
	49
	50	MODULE_DEVICE_TABLE(usb, xbox_remote_table);
	51
	52	struct xbox_remote {
	53	struct rc_dev *rdev;
	54	struct usb_device *udev;
	55	struct usb_interface *interface;
	56
	57	struct urb *irq_urb;
cea1c41d	58	unsigned char inbuf[DATA_BUFSIZE] __aligned(sizeof(u16));
02d32bda BV	59
	60	char rc_name[NAME_BUFSIZE];
	61	char rc_phys[NAME_BUFSIZE];
	62	};
	63
	64	static int xbox_remote_rc_open(struct rc_dev *rdev)
	65	{
	66	struct xbox_remote *xbox_remote = rdev->priv;
	67
	68	/* On first open, submit the read urb which was set up previously. */
	69	xbox_remote->irq_urb->dev = xbox_remote->udev;
	70	if (usb_submit_urb(xbox_remote->irq_urb, GFP_KERNEL)) {
	71	dev_err(&xbox_remote->interface->dev,
	72	"%s: usb_submit_urb failed!\n", __func__);
	73	return -EIO;
	74	}
	75
	76	return 0;
	77	}
	78
	79	static void xbox_remote_rc_close(struct rc_dev *rdev)
	80	{
	81	struct xbox_remote *xbox_remote = rdev->priv;
	82
	83	usb_kill_urb(xbox_remote->irq_urb);
	84	}
	85
	86	/*
	87	* xbox_remote_report_input
	88	*/
	89	static void xbox_remote_input_report(struct urb *urb)
	90	{
	91	struct xbox_remote *xbox_remote = urb->context;
	92	unsigned char *data = xbox_remote->inbuf;
	93
	94	/*
	95	* data[0] = 0x00
	96	* data[1] = length - always 0x06
	97	* data[2] = the key code
cea1c41d	98	* data[3] = high part of key code
02d32bda BV	99	* data[4] = last_press_ms (low)
	100	* data[5] = last_press_ms (high)
	101	*/
	102
	103	/* Deal with strange looking inputs */
	104	if (urb->actual_length != 6 \|\| urb->actual_length != data[1]) {
	105	dev_warn(&urb->dev->dev, "Weird data, len=%d: %*ph\n",
	106	urb->actual_length, urb->actual_length, data);
	107	return;
	108	}
	109
17287692	110	rc_keydown(xbox_remote->rdev, RC_PROTO_XBOX_DVD,
cea1c41d	111	le16_to_cpup((__le16 *)(data + 2)), 0);
02d32bda BV	112	}
	113
	114	/*
	115	* xbox_remote_irq_in
	116	*/
	117	static void xbox_remote_irq_in(struct urb *urb)
	118	{
	119	struct xbox_remote *xbox_remote = urb->context;
	120	int retval;
	121
	122	switch (urb->status) {
	123	case 0: /* success */
	124	xbox_remote_input_report(urb);
	125	break;
	126	case -ECONNRESET: /* unlink */
	127	case -ENOENT:
	128	case -ESHUTDOWN:
	129	dev_dbg(&xbox_remote->interface->dev,
	130	"%s: urb error status, unlink?\n",
	131	__func__);
	132	return;
	133	default: /* error */
	134	dev_dbg(&xbox_remote->interface->dev,
	135	"%s: Nonzero urb status %d\n",
	136	__func__, urb->status);
	137	}
	138
	139	retval = usb_submit_urb(urb, GFP_ATOMIC);
	140	if (retval)
	141	dev_err(&xbox_remote->interface->dev,
	142	"%s: usb_submit_urb()=%d\n",
	143	__func__, retval);
	144	}
	145
	146	static void xbox_remote_rc_init(struct xbox_remote *xbox_remote)
	147	{
	148	struct rc_dev *rdev = xbox_remote->rdev;
	149
	150	rdev->priv = xbox_remote;
17287692	151	rdev->allowed_protocols = RC_PROTO_BIT_XBOX_DVD;
02d32bda BV	152	rdev->driver_name = "xbox_remote";
	153
	154	rdev->open = xbox_remote_rc_open;
	155	rdev->close = xbox_remote_rc_close;
	156
	157	rdev->device_name = xbox_remote->rc_name;
	158	rdev->input_phys = xbox_remote->rc_phys;
	159
17287692 MR	160	rdev->timeout = MS_TO_NS(10);
17287692 MR	161
02d32bda BV	162	usb_to_input_id(xbox_remote->udev, &rdev->input_id);
	163	rdev->dev.parent = &xbox_remote->interface->dev;
	164	}
	165
	166	static int xbox_remote_initialize(struct xbox_remote *xbox_remote,
	167	struct usb_endpoint_descriptor *endpoint_in)
	168	{
	169	struct usb_device *udev = xbox_remote->udev;
	170	int pipe, maxp;
	171
	172	/* Set up irq_urb */
	173	pipe = usb_rcvintpipe(udev, endpoint_in->bEndpointAddress);
	174	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
	175	maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
	176
	177	usb_fill_int_urb(xbox_remote->irq_urb, udev, pipe, xbox_remote->inbuf,
	178	maxp, xbox_remote_irq_in, xbox_remote,
	179	endpoint_in->bInterval);
	180
	181	return 0;
	182	}
	183
	184	/*
	185	* xbox_remote_probe
	186	*/
	187	static int xbox_remote_probe(struct usb_interface *interface,
	188	const struct usb_device_id *id)
	189	{
	190	struct usb_device *udev = interface_to_usbdev(interface);
	191	struct usb_host_interface *iface_host = interface->cur_altsetting;
	192	struct usb_endpoint_descriptor *endpoint_in;
	193	struct xbox_remote *xbox_remote;
	194	struct rc_dev *rc_dev;
	195	int err = -ENOMEM;
	196
	197	// why is there also a device with no endpoints?
	198	if (iface_host->desc.bNumEndpoints == 0)
	199	return -ENODEV;
	200
	201	if (iface_host->desc.bNumEndpoints != 1) {
	202	pr_err("%s: Unexpected desc.bNumEndpoints: %d\n",
	203	__func__, iface_host->desc.bNumEndpoints);
	204	return -ENODEV;
	205	}
	206
	207	endpoint_in = &iface_host->endpoint[0].desc;
	208
	209	if (!usb_endpoint_is_int_in(endpoint_in)) {
	210	pr_err("%s: Unexpected endpoint_in\n", __func__);
	211	return -ENODEV;
	212	}
	213	if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
	214	pr_err("%s: endpoint_in message size==0?\n", __func__);
	215	return -ENODEV;
	216	}
	217
	218	xbox_remote = kzalloc(sizeof(*xbox_remote), GFP_KERNEL);
	219	rc_dev = rc_allocate_device(RC_DRIVER_SCANCODE);
	220	if (!xbox_remote \|\| !rc_dev)
	221	goto exit_free_dev_rdev;
	222
	223	/* Allocate URB buffer */
	224	xbox_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
	225	if (!xbox_remote->irq_urb)
226	goto exit_free_buffers;
227
228	xbox_remote->udev = udev;
229	xbox_remote->rdev = rc_dev;
230	xbox_remote->interface = interface;
231
232	usb_make_path(udev, xbox_remote->rc_phys, sizeof(xbox_remote->rc_phys));
233
234	strlcat(xbox_remote->rc_phys, "/input0", sizeof(xbox_remote->rc_phys));
235
236	snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name), "%s%s%s",
237	udev->manufacturer ?: "",
238	udev->manufacturer && udev->product ? " " : "",
239	udev->product ?: "");
240
241	if (!strlen(xbox_remote->rc_name))
242	snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name),
243	DRIVER_DESC "(%04x,%04x)",
244	le16_to_cpu(xbox_remote->udev->descriptor.idVendor),
245	le16_to_cpu(xbox_remote->udev->descriptor.idProduct));
246
247	rc_dev->map_name = RC_MAP_XBOX_DVD; /* default map */
248
249	xbox_remote_rc_init(xbox_remote);
250
251	/* Device Hardware Initialization */
252	err = xbox_remote_initialize(xbox_remote, endpoint_in);
253	if (err)
254	goto exit_kill_urbs;
255
256	/* Set up and register rc device */
257	err = rc_register_device(xbox_remote->rdev);
258	if (err)
259	goto exit_kill_urbs;
260
261	usb_set_intfdata(interface, xbox_remote);
262
263	return 0;
264
265	exit_kill_urbs:
266	usb_kill_urb(xbox_remote->irq_urb);
267	exit_free_buffers:
268	usb_free_urb(xbox_remote->irq_urb);
269	exit_free_dev_rdev:
270	rc_free_device(rc_dev);
271	kfree(xbox_remote);
272
273	return err;
274	}
275
276	/*
277	* xbox_remote_disconnect
278	*/
279	static void xbox_remote_disconnect(struct usb_interface *interface)
280	{
281	struct xbox_remote *xbox_remote;
282
283	xbox_remote = usb_get_intfdata(interface);
284	usb_set_intfdata(interface, NULL);
285	if (!xbox_remote) {
286	dev_warn(&interface->dev, "%s - null device?\n", __func__);
287	return;
288	}
289
290	usb_kill_urb(xbox_remote->irq_urb);
291	rc_unregister_device(xbox_remote->rdev);
292	usb_free_urb(xbox_remote->irq_urb);
293	kfree(xbox_remote);
294	}
295
296	/* usb specific object to register with the usb subsystem */
297	static struct usb_driver xbox_remote_driver = {
298	.name = "xbox_remote",
299	.probe = xbox_remote_probe,
300	.disconnect = xbox_remote_disconnect,
301	.id_table = xbox_remote_table,
302	};
303
304	module_usb_driver(xbox_remote_driver);
305
306	MODULE_AUTHOR(DRIVER_AUTHOR);
307	MODULE_DESCRIPTION(DRIVER_DESC);
308	MODULE_LICENSE("GPL");