[thirdparty/kernel/stable.git] / drivers / media / rc / igorplugusb.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * IgorPlug-USB IR Receiver
 *
 * Copyright (C) 2014 Sean Young <sean@mess.org>
 *
 * Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
 * See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
 *
 * Based on the lirc_igorplugusb.c driver:
 *	Copyright (C) 2004 Jan M. Hochstein
 *	<hochstein@algo.informatik.tu-darmstadt.de>
 */
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/input.h>
#include <media/rc-core.h>

#define DRIVER_DESC		"IgorPlug-USB IR Receiver"
#define DRIVER_NAME		"igorplugusb"

#define HEADERLEN		3
#define BUFLEN			36
#define MAX_PACKET		(HEADERLEN + BUFLEN)

#define SET_INFRABUFFER_EMPTY	1
#define GET_INFRACODE		2


struct igorplugusb {
	struct rc_dev *rc;
	struct device *dev;

	struct urb *urb;
	struct usb_ctrlrequest request;

	struct timer_list timer;

	uint8_t buf_in[MAX_PACKET];

	char phys[64];
};

static void igorplugusb_cmd(struct igorplugusb *ir, int cmd);

static void igorplugusb_irdata(struct igorplugusb *ir, unsigned len)
{
	struct ir_raw_event rawir = {};
	unsigned i, start, overflow;

	dev_dbg(ir->dev, "irdata: %*ph (len=%u)", len, ir->buf_in, len);

	/*
	 * If more than 36 pulses and spaces follow each other, the igorplugusb
	 * overwrites its buffer from the beginning. The overflow value is the
	 * last offset which was not overwritten. Everything from this offset
	 * onwards occurred before everything until this offset.
	 */
	overflow = ir->buf_in[2];
	i = start = overflow + HEADERLEN;

	if (start >= len) {
		dev_err(ir->dev, "receive overflow invalid: %u", overflow);
	} else {
		if (overflow > 0)
			dev_warn(ir->dev, "receive overflow, at least %u lost",
								overflow);

		do {
			rawir.duration = ir->buf_in[i] * 85333;
			rawir.pulse = i & 1;

			ir_raw_event_store_with_filter(ir->rc, &rawir);

			if (++i == len)
				i = HEADERLEN;
		} while (i != start);

		/* add a trailing space */
		rawir.duration = ir->rc->timeout;
		rawir.pulse = false;
		ir_raw_event_store_with_filter(ir->rc, &rawir);

		ir_raw_event_handle(ir->rc);
	}

	igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
}

static void igorplugusb_callback(struct urb *urb)
{
	struct usb_ctrlrequest *req;
	struct igorplugusb *ir = urb->context;

	req = (struct usb_ctrlrequest *)urb->setup_packet;

	switch (urb->status) {
	case 0:
		if (req->bRequest == GET_INFRACODE &&
					urb->actual_length > HEADERLEN)
			igorplugusb_irdata(ir, urb->actual_length);
		else /* request IR */
			mod_timer(&ir->timer, jiffies + msecs_to_jiffies(50));
		break;
	case -EPROTO:
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		usb_unlink_urb(urb);
		return;
	default:
		dev_warn(ir->dev, "Error: urb status = %d\n", urb->status);
		igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
		break;
	}
}

static void igorplugusb_cmd(struct igorplugusb *ir, int cmd)
{
	int ret;

	ir->request.bRequest = cmd;
	ir->urb->transfer_flags = 0;
	ret = usb_submit_urb(ir->urb, GFP_ATOMIC);
	if (ret)
		dev_err(ir->dev, "submit urb failed: %d", ret);
}

static void igorplugusb_timer(struct timer_list *t)
{
	struct igorplugusb *ir = from_timer(ir, t, timer);

	igorplugusb_cmd(ir, GET_INFRACODE);
}

static int igorplugusb_probe(struct usb_interface *intf,
					const struct usb_device_id *id)
{
	struct usb_device *udev;
	struct usb_host_interface *idesc;
	struct usb_endpoint_descriptor *ep;
	struct igorplugusb *ir;
	struct rc_dev *rc;
	int ret = -ENOMEM;

	udev = interface_to_usbdev(intf);
	idesc = intf->cur_altsetting;

	if (idesc->desc.bNumEndpoints != 1) {
		dev_err(&intf->dev, "incorrect number of endpoints");
		return -ENODEV;
	}

	ep = &idesc->endpoint[0].desc;
	if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_control(ep)) {
		dev_err(&intf->dev, "endpoint incorrect");
		return -ENODEV;
	}

	ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
	if (!ir)
		return -ENOMEM;

	ir->dev = &intf->dev;

	timer_setup(&ir->timer, igorplugusb_timer, 0);

	ir->request.bRequest = GET_INFRACODE;
	ir->request.bRequestType = USB_TYPE_VENDOR | USB_DIR_IN;
	ir->request.wLength = cpu_to_le16(sizeof(ir->buf_in));

	ir->urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!ir->urb)
		goto fail;

	usb_fill_control_urb(ir->urb, udev,
		usb_rcvctrlpipe(udev, 0), (uint8_t *)&ir->request,
		ir->buf_in, sizeof(ir->buf_in), igorplugusb_callback, ir);

	usb_make_path(udev, ir->phys, sizeof(ir->phys));

	rc = rc_allocate_device(RC_DRIVER_IR_RAW);
	if (!rc)
		goto fail;

	rc->device_name = DRIVER_DESC;
	rc->input_phys = ir->phys;
	usb_to_input_id(udev, &rc->input_id);
	rc->dev.parent = &intf->dev;
	/*
	 * This device can only store 36 pulses + spaces, which is not enough
	 * for the NEC protocol and many others.
	 */
	rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER &
		~(RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX | RC_PROTO_BIT_NEC32 |
		  RC_PROTO_BIT_RC6_6A_20 | RC_PROTO_BIT_RC6_6A_24 |
		  RC_PROTO_BIT_RC6_6A_32 | RC_PROTO_BIT_RC6_MCE |
		  RC_PROTO_BIT_SONY20 | RC_PROTO_BIT_SANYO);

	rc->priv = ir;
	rc->driver_name = DRIVER_NAME;
	rc->map_name = RC_MAP_HAUPPAUGE;
	rc->timeout = MS_TO_NS(100);
	rc->rx_resolution = 85333;

	ir->rc = rc;
	ret = rc_register_device(rc);
	if (ret) {
		dev_err(&intf->dev, "failed to register rc device: %d", ret);
		goto fail;
	}

	usb_set_intfdata(intf, ir);

	igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);

	return 0;
fail:
	rc_free_device(ir->rc);
	usb_free_urb(ir->urb);
	del_timer(&ir->timer);

	return ret;
}

static void igorplugusb_disconnect(struct usb_interface *intf)
{
	struct igorplugusb *ir = usb_get_intfdata(intf);

	rc_unregister_device(ir->rc);
	del_timer_sync(&ir->timer);
	usb_set_intfdata(intf, NULL);
	usb_kill_urb(ir->urb);
	usb_free_urb(ir->urb);
}

static const struct usb_device_id igorplugusb_table[] = {
	/* Igor Plug USB (Atmel's Manufact. ID) */
	{ USB_DEVICE(0x03eb, 0x0002) },
	/* Fit PC2 Infrared Adapter */
	{ USB_DEVICE(0x03eb, 0x21fe) },
	/* Terminating entry */
	{ }
};

static struct usb_driver igorplugusb_driver = {
	.name =	DRIVER_NAME,
	.probe = igorplugusb_probe,
	.disconnect = igorplugusb_disconnect,
	.id_table = igorplugusb_table
};

module_usb_driver(igorplugusb_driver);

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Sean Young <sean@mess.org>");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(usb, igorplugusb_table);
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
b1c97193 SY	2	/*
	3	* IgorPlug-USB IR Receiver
	4	*
	5	* Copyright (C) 2014 Sean Young <sean@mess.org>
	6	*
	7	* Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
	8	* See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
	9	*
	10	* Based on the lirc_igorplugusb.c driver:
	11	* Copyright (C) 2004 Jan M. Hochstein
	12	* <hochstein@algo.informatik.tu-darmstadt.de>
b1c97193 SY	13	*/
	14	#include <linux/device.h>
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/usb.h>
	18	#include <linux/usb/input.h>
	19	#include <media/rc-core.h>
	20
	21	#define DRIVER_DESC "IgorPlug-USB IR Receiver"
	22	#define DRIVER_NAME "igorplugusb"
	23
	24	#define HEADERLEN 3
	25	#define BUFLEN 36
	26	#define MAX_PACKET (HEADERLEN + BUFLEN)
	27
	28	#define SET_INFRABUFFER_EMPTY 1
	29	#define GET_INFRACODE 2
	30
	31
	32	struct igorplugusb {
	33	struct rc_dev *rc;
	34	struct device *dev;
	35
	36	struct urb *urb;
	37	struct usb_ctrlrequest request;
	38
	39	struct timer_list timer;
	40
	41	uint8_t buf_in[MAX_PACKET];
	42
	43	char phys[64];
	44	};
	45
	46	static void igorplugusb_cmd(struct igorplugusb *ir, int cmd);
	47
	48	static void igorplugusb_irdata(struct igorplugusb *ir, unsigned len)
	49	{
183e19f5	50	struct ir_raw_event rawir = {};
b1c97193 SY	51	unsigned i, start, overflow;
	52
	53	dev_dbg(ir->dev, "irdata: %*ph (len=%u)", len, ir->buf_in, len);
	54
	55	/*
	56	* If more than 36 pulses and spaces follow each other, the igorplugusb
	57	* overwrites its buffer from the beginning. The overflow value is the
	58	* last offset which was not overwritten. Everything from this offset
	59	* onwards occurred before everything until this offset.
	60	*/
	61	overflow = ir->buf_in[2];
	62	i = start = overflow + HEADERLEN;
	63
	64	if (start >= len) {
	65	dev_err(ir->dev, "receive overflow invalid: %u", overflow);
	66	} else {
	67	if (overflow > 0)
	68	dev_warn(ir->dev, "receive overflow, at least %u lost",
	69	overflow);
	70
	71	do {
	72	rawir.duration = ir->buf_in[i] * 85333;
	73	rawir.pulse = i & 1;
	74
	75	ir_raw_event_store_with_filter(ir->rc, &rawir);
	76
	77	if (++i == len)
	78	i = HEADERLEN;
	79	} while (i != start);
	80
	81	/* add a trailing space */
	82	rawir.duration = ir->rc->timeout;
	83	rawir.pulse = false;
	84	ir_raw_event_store_with_filter(ir->rc, &rawir);
	85
	86	ir_raw_event_handle(ir->rc);
	87	}
	88
	89	igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
	90	}
	91
	92	static void igorplugusb_callback(struct urb *urb)
	93	{
	94	struct usb_ctrlrequest *req;
	95	struct igorplugusb *ir = urb->context;
	96
	97	req = (struct usb_ctrlrequest *)urb->setup_packet;
	98
	99	switch (urb->status) {
	100	case 0:
	101	if (req->bRequest == GET_INFRACODE &&
	102	urb->actual_length > HEADERLEN)
	103	igorplugusb_irdata(ir, urb->actual_length);
	104	else /* request IR */
	105	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(50));
	106	break;
	107	case -EPROTO:
	108	case -ECONNRESET:
	109	case -ENOENT:
	110	case -ESHUTDOWN:
	111	usb_unlink_urb(urb);
	112	return;
	113	default:
	114	dev_warn(ir->dev, "Error: urb status = %d\n", urb->status);
115	igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
116	break;
117	}
118	}
119
120	static void igorplugusb_cmd(struct igorplugusb *ir, int cmd)
121	{
122	int ret;
123
124	ir->request.bRequest = cmd;
125	ir->urb->transfer_flags = 0;
126	ret = usb_submit_urb(ir->urb, GFP_ATOMIC);
127	if (ret)
128	dev_err(ir->dev, "submit urb failed: %d", ret);
129	}
130
b17ec78a	131	static void igorplugusb_timer(struct timer_list *t)
b1c97193	132	{
b17ec78a	133	struct igorplugusb *ir = from_timer(ir, t, timer);
b1c97193 SY	134
	135	igorplugusb_cmd(ir, GET_INFRACODE);
	136	}
	137
	138	static int igorplugusb_probe(struct usb_interface *intf,
	139	const struct usb_device_id *id)
	140	{
	141	struct usb_device *udev;
	142	struct usb_host_interface *idesc;
	143	struct usb_endpoint_descriptor *ep;
	144	struct igorplugusb *ir;
	145	struct rc_dev *rc;
a40973ff	146	int ret = -ENOMEM;
b1c97193 SY	147
	148	udev = interface_to_usbdev(intf);
	149	idesc = intf->cur_altsetting;
	150
	151	if (idesc->desc.bNumEndpoints != 1) {
	152	dev_err(&intf->dev, "incorrect number of endpoints");
	153	return -ENODEV;
	154	}
	155
	156	ep = &idesc->endpoint[0].desc;
	157	if (!usb_endpoint_dir_in(ep) \|\| !usb_endpoint_xfer_control(ep)) {
	158	dev_err(&intf->dev, "endpoint incorrect");
	159	return -ENODEV;
	160	}
	161
	162	ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
	163	if (!ir)
	164	return -ENOMEM;
	165
	166	ir->dev = &intf->dev;
	167
b17ec78a	168	timer_setup(&ir->timer, igorplugusb_timer, 0);
b1c97193 SY	169
	170	ir->request.bRequest = GET_INFRACODE;
	171	ir->request.bRequestType = USB_TYPE_VENDOR \| USB_DIR_IN;
	172	ir->request.wLength = cpu_to_le16(sizeof(ir->buf_in));
	173
	174	ir->urb = usb_alloc_urb(0, GFP_KERNEL);
	175	if (!ir->urb)
a40973ff	176	goto fail;
b1c97193 SY	177
	178	usb_fill_control_urb(ir->urb, udev,
	179	usb_rcvctrlpipe(udev, 0), (uint8_t *)&ir->request,
	180	ir->buf_in, sizeof(ir->buf_in), igorplugusb_callback, ir);
	181
	182	usb_make_path(udev, ir->phys, sizeof(ir->phys));
	183
0f7499fd	184	rc = rc_allocate_device(RC_DRIVER_IR_RAW);
a40973ff SY	185	if (!rc)
	186	goto fail;
	187
518f4b26	188	rc->device_name = DRIVER_DESC;
b1c97193 SY	189	rc->input_phys = ir->phys;
	190	usb_to_input_id(udev, &rc->input_id);
	191	rc->dev.parent = &intf->dev;
b1c97193 SY	192	/*
	193	* This device can only store 36 pulses + spaces, which is not enough
	194	* for the NEC protocol and many others.
	195	*/
6d741bfe SY	196	rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER &
	197	~(RC_PROTO_BIT_NEC \| RC_PROTO_BIT_NECX \| RC_PROTO_BIT_NEC32 \|
	198	RC_PROTO_BIT_RC6_6A_20 \| RC_PROTO_BIT_RC6_6A_24 \|
	199	RC_PROTO_BIT_RC6_6A_32 \| RC_PROTO_BIT_RC6_MCE \|
	200	RC_PROTO_BIT_SONY20 \| RC_PROTO_BIT_SANYO);
b1c97193 SY	201
	202	rc->priv = ir;
	203	rc->driver_name = DRIVER_NAME;
	204	rc->map_name = RC_MAP_HAUPPAUGE;
	205	rc->timeout = MS_TO_NS(100);
	206	rc->rx_resolution = 85333;
	207
	208	ir->rc = rc;
	209	ret = rc_register_device(rc);
	210	if (ret) {
	211	dev_err(&intf->dev, "failed to register rc device: %d", ret);
a40973ff	212	goto fail;
b1c97193 SY	213	}
	214
	215	usb_set_intfdata(intf, ir);
	216
	217	igorplugusb_cmd(ir, SET_INFRABUFFER_EMPTY);
	218
	219	return 0;
a40973ff SY	220	fail:
	221	rc_free_device(ir->rc);
	222	usb_free_urb(ir->urb);
	223	del_timer(&ir->timer);
	224
	225	return ret;
b1c97193 SY	226	}
	227
	228	static void igorplugusb_disconnect(struct usb_interface *intf)
	229	{
	230	struct igorplugusb *ir = usb_get_intfdata(intf);
	231
	232	rc_unregister_device(ir->rc);
	233	del_timer_sync(&ir->timer);
	234	usb_set_intfdata(intf, NULL);
	235	usb_kill_urb(ir->urb);
	236	usb_free_urb(ir->urb);
	237	}
	238
5fad16b5	239	static const struct usb_device_id igorplugusb_table[] = {
b1c97193 SY	240	/* Igor Plug USB (Atmel's Manufact. ID) */
	241	{ USB_DEVICE(0x03eb, 0x0002) },
	242	/* Fit PC2 Infrared Adapter */
	243	{ USB_DEVICE(0x03eb, 0x21fe) },
	244	/* Terminating entry */
	245	{ }
	246	};
	247
	248	static struct usb_driver igorplugusb_driver = {
	249	.name = DRIVER_NAME,
	250	.probe = igorplugusb_probe,
	251	.disconnect = igorplugusb_disconnect,
	252	.id_table = igorplugusb_table
	253	};
	254
	255	module_usb_driver(igorplugusb_driver);
	256
	257	MODULE_DESCRIPTION(DRIVER_DESC);
	258	MODULE_AUTHOR("Sean Young <sean@mess.org>");
	259	MODULE_LICENSE("GPL");
	260	MODULE_DEVICE_TABLE(usb, igorplugusb_table);