[mirror_ubuntu-hirsute-kernel.git] / drivers / media / rc / streamzap.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Streamzap Remote Control driver
 *
 * Copyright (c) 2005 Christoph Bartelmus <lirc@bartelmus.de>
 * Copyright (c) 2010 Jarod Wilson <jarod@wilsonet.com>
 *
 * This driver was based on the work of Greg Wickham and Adrian
 * Dewhurst. It was substantially rewritten to support correct signal
 * gaps and now maintains a delay buffer, which is used to present
 * consistent timing behaviour to user space applications. Without the
 * delay buffer an ugly hack would be required in lircd, which can
 * cause sluggish signal decoding in certain situations.
 *
 * Ported to in-kernel ir-core interface by Jarod Wilson
 *
 * This driver is based on the USB skeleton driver packaged with the
 * kernel; copyright (C) 2001-2003 Greg Kroah-Hartman (greg@kroah.com)
 */

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

#define DRIVER_VERSION	"1.61"
#define DRIVER_NAME	"streamzap"
#define DRIVER_DESC	"Streamzap Remote Control driver"

#define USB_STREAMZAP_VENDOR_ID		0x0e9c
#define USB_STREAMZAP_PRODUCT_ID	0x0000

/* table of devices that work with this driver */
static const struct usb_device_id streamzap_table[] = {
	/* Streamzap Remote Control */
	{ USB_DEVICE(USB_STREAMZAP_VENDOR_ID, USB_STREAMZAP_PRODUCT_ID) },
	/* Terminating entry */
	{ }
};

MODULE_DEVICE_TABLE(usb, streamzap_table);

#define SZ_PULSE_MASK 0xf0
#define SZ_SPACE_MASK 0x0f
#define SZ_TIMEOUT    0xff
#define SZ_RESOLUTION 256

/* number of samples buffered */
#define SZ_BUF_LEN 128

enum StreamzapDecoderState {
	PulseSpace,
	FullPulse,
	FullSpace,
	IgnorePulse
};

/* structure to hold our device specific stuff */
struct streamzap_ir {
	/* ir-core */
	struct rc_dev *rdev;

	/* core device info */
	struct device *dev;

	/* usb */
	struct usb_device	*usbdev;
	struct usb_interface	*interface;
	struct usb_endpoint_descriptor *endpoint;
	struct urb		*urb_in;

	/* buffer & dma */
	unsigned char		*buf_in;
	dma_addr_t		dma_in;
	unsigned int		buf_in_len;

	/* track what state we're in */
	enum StreamzapDecoderState decoder_state;
	/* tracks whether we are currently receiving some signal */
	bool			idle;
	/* sum of signal lengths received since signal start */
	unsigned long		sum;
	/* start time of signal; necessary for gap tracking */
	ktime_t			signal_last;
	ktime_t			signal_start;
	bool			timeout_enabled;

	char			name[128];
	char			phys[64];
};


/* local function prototypes */
static int streamzap_probe(struct usb_interface *interface,
			   const struct usb_device_id *id);
static void streamzap_disconnect(struct usb_interface *interface);
static void streamzap_callback(struct urb *urb);
static int streamzap_suspend(struct usb_interface *intf, pm_message_t message);
static int streamzap_resume(struct usb_interface *intf);

/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver streamzap_driver = {
	.name =		DRIVER_NAME,
	.probe =	streamzap_probe,
	.disconnect =	streamzap_disconnect,
	.suspend =	streamzap_suspend,
	.resume =	streamzap_resume,
	.id_table =	streamzap_table,
};

static void sz_push(struct streamzap_ir *sz, struct ir_raw_event rawir)
{
	dev_dbg(sz->dev, "Storing %s with duration %u us\n",
		(rawir.pulse ? "pulse" : "space"), rawir.duration);
	ir_raw_event_store_with_filter(sz->rdev, &rawir);
}

static void sz_push_full_pulse(struct streamzap_ir *sz,
			       unsigned char value)
{
	struct ir_raw_event rawir = {};

	if (sz->idle) {
		int delta;

		sz->signal_last = sz->signal_start;
		sz->signal_start = ktime_get_real();

		delta = ktime_us_delta(sz->signal_start, sz->signal_last);
		rawir.pulse = false;
		if (delta > (15 * USEC_PER_SEC)) {
			/* really long time */
			rawir.duration = IR_MAX_DURATION;
		} else {
			rawir.duration = delta;
			rawir.duration -= sz->sum;
			rawir.duration = (rawir.duration > IR_MAX_DURATION) ?
					 IR_MAX_DURATION : rawir.duration;
		}
		sz_push(sz, rawir);

		sz->idle = false;
		sz->sum = 0;
	}

	rawir.pulse = true;
	rawir.duration = ((int) value) * SZ_RESOLUTION;
	rawir.duration += SZ_RESOLUTION / 2;
	sz->sum += rawir.duration;
	rawir.duration = (rawir.duration > IR_MAX_DURATION) ?
			 IR_MAX_DURATION : rawir.duration;
	sz_push(sz, rawir);
}

static void sz_push_half_pulse(struct streamzap_ir *sz,
			       unsigned char value)
{
	sz_push_full_pulse(sz, (value & SZ_PULSE_MASK) >> 4);
}

static void sz_push_full_space(struct streamzap_ir *sz,
			       unsigned char value)
{
	struct ir_raw_event rawir = {};

	rawir.pulse = false;
	rawir.duration = ((int) value) * SZ_RESOLUTION;
	rawir.duration += SZ_RESOLUTION / 2;
	sz->sum += rawir.duration;
	sz_push(sz, rawir);
}

static void sz_push_half_space(struct streamzap_ir *sz,
			       unsigned long value)
{
	sz_push_full_space(sz, value & SZ_SPACE_MASK);
}

/*
 * streamzap_callback - usb IRQ handler callback
 *
 * This procedure is invoked on reception of data from
 * the usb remote.
 */
static void streamzap_callback(struct urb *urb)
{
	struct streamzap_ir *sz;
	unsigned int i;
	int len;

	if (!urb)
		return;

	sz = urb->context;
	len = urb->actual_length;

	switch (urb->status) {
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/*
		 * this urb is terminated, clean up.
		 * sz might already be invalid at this point
		 */
		dev_err(sz->dev, "urb terminated, status: %d\n", urb->status);
		return;
	default:
		break;
	}

	dev_dbg(sz->dev, "%s: received urb, len %d\n", __func__, len);
	for (i = 0; i < len; i++) {
		dev_dbg(sz->dev, "sz->buf_in[%d]: %x\n",
			i, (unsigned char)sz->buf_in[i]);
		switch (sz->decoder_state) {
		case PulseSpace:
			if ((sz->buf_in[i] & SZ_PULSE_MASK) ==
				SZ_PULSE_MASK) {
				sz->decoder_state = FullPulse;
				continue;
			} else if ((sz->buf_in[i] & SZ_SPACE_MASK)
					== SZ_SPACE_MASK) {
				sz_push_half_pulse(sz, sz->buf_in[i]);
				sz->decoder_state = FullSpace;
				continue;
			} else {
				sz_push_half_pulse(sz, sz->buf_in[i]);
				sz_push_half_space(sz, sz->buf_in[i]);
			}
			break;
		case FullPulse:
			sz_push_full_pulse(sz, sz->buf_in[i]);
			sz->decoder_state = IgnorePulse;
			break;
		case FullSpace:
			if (sz->buf_in[i] == SZ_TIMEOUT) {
				struct ir_raw_event rawir = {
					.pulse = false,
					.duration = sz->rdev->timeout
				};
				sz->idle = true;
				if (sz->timeout_enabled)
					sz_push(sz, rawir);
				ir_raw_event_handle(sz->rdev);
				ir_raw_event_reset(sz->rdev);
			} else {
				sz_push_full_space(sz, sz->buf_in[i]);
			}
			sz->decoder_state = PulseSpace;
			break;
		case IgnorePulse:
			if ((sz->buf_in[i] & SZ_SPACE_MASK) ==
				SZ_SPACE_MASK) {
				sz->decoder_state = FullSpace;
				continue;
			}
			sz_push_half_space(sz, sz->buf_in[i]);
			sz->decoder_state = PulseSpace;
			break;
		}
	}

	ir_raw_event_handle(sz->rdev);
	usb_submit_urb(urb, GFP_ATOMIC);

	return;
}

static struct rc_dev *streamzap_init_rc_dev(struct streamzap_ir *sz)
{
	struct rc_dev *rdev;
	struct device *dev = sz->dev;
	int ret;

	rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
	if (!rdev) {
		dev_err(dev, "remote dev allocation failed\n");
		goto out;
	}

	snprintf(sz->name, sizeof(sz->name), "Streamzap PC Remote Infrared Receiver (%04x:%04x)",
		 le16_to_cpu(sz->usbdev->descriptor.idVendor),
		 le16_to_cpu(sz->usbdev->descriptor.idProduct));
	usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys));
	strlcat(sz->phys, "/input0", sizeof(sz->phys));

	rdev->device_name = sz->name;
	rdev->input_phys = sz->phys;
	usb_to_input_id(sz->usbdev, &rdev->input_id);
	rdev->dev.parent = dev;
	rdev->priv = sz;
	rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
	rdev->driver_name = DRIVER_NAME;
	rdev->map_name = RC_MAP_STREAMZAP;

	ret = rc_register_device(rdev);
	if (ret < 0) {
		dev_err(dev, "remote input device register failed\n");
		goto out;
	}

	return rdev;

out:
	rc_free_device(rdev);
	return NULL;
}

/*
 *	streamzap_probe
 *
 *	Called by usb-core to associated with a candidate device
 *	On any failure the return value is the ERROR
 *	On success return 0
 */
static int streamzap_probe(struct usb_interface *intf,
			   const struct usb_device_id *id)
{
	struct usb_device *usbdev = interface_to_usbdev(intf);
	struct usb_host_interface *iface_host;
	struct streamzap_ir *sz = NULL;
	char buf[63], name[128] = "";
	int retval = -ENOMEM;
	int pipe, maxp;

	/* Allocate space for device driver specific data */
	sz = kzalloc(sizeof(struct streamzap_ir), GFP_KERNEL);
	if (!sz)
		return -ENOMEM;

	sz->usbdev = usbdev;
	sz->interface = intf;

	/* Check to ensure endpoint information matches requirements */
	iface_host = intf->cur_altsetting;

	if (iface_host->desc.bNumEndpoints != 1) {
		dev_err(&intf->dev, "%s: Unexpected desc.bNumEndpoints (%d)\n",
			__func__, iface_host->desc.bNumEndpoints);
		retval = -ENODEV;
		goto free_sz;
	}

	sz->endpoint = &(iface_host->endpoint[0].desc);
	if (!usb_endpoint_dir_in(sz->endpoint)) {
		dev_err(&intf->dev, "%s: endpoint doesn't match input device 02%02x\n",
			__func__, sz->endpoint->bEndpointAddress);
		retval = -ENODEV;
		goto free_sz;
	}

	if (!usb_endpoint_xfer_int(sz->endpoint)) {
		dev_err(&intf->dev, "%s: endpoint attributes don't match xfer 02%02x\n",
			__func__, sz->endpoint->bmAttributes);
		retval = -ENODEV;
		goto free_sz;
	}

	pipe = usb_rcvintpipe(usbdev, sz->endpoint->bEndpointAddress);
	maxp = usb_maxpacket(usbdev, pipe, usb_pipeout(pipe));

	if (maxp == 0) {
		dev_err(&intf->dev, "%s: endpoint Max Packet Size is 0!?!\n",
			__func__);
		retval = -ENODEV;
		goto free_sz;
	}

	/* Allocate the USB buffer and IRQ URB */
	sz->buf_in = usb_alloc_coherent(usbdev, maxp, GFP_ATOMIC, &sz->dma_in);
	if (!sz->buf_in)
		goto free_sz;

	sz->urb_in = usb_alloc_urb(0, GFP_KERNEL);
	if (!sz->urb_in)
		goto free_buf_in;

	sz->dev = &intf->dev;
	sz->buf_in_len = maxp;

	if (usbdev->descriptor.iManufacturer
	    && usb_string(usbdev, usbdev->descriptor.iManufacturer,
			  buf, sizeof(buf)) > 0)
		strscpy(name, buf, sizeof(name));

	if (usbdev->descriptor.iProduct
	    && usb_string(usbdev, usbdev->descriptor.iProduct,
			  buf, sizeof(buf)) > 0)
		snprintf(name + strlen(name), sizeof(name) - strlen(name),
			 " %s", buf);

	sz->rdev = streamzap_init_rc_dev(sz);
	if (!sz->rdev)
		goto rc_dev_fail;

	sz->idle = true;
	sz->decoder_state = PulseSpace;
	/* FIXME: don't yet have a way to set this */
	sz->timeout_enabled = true;
	sz->rdev->timeout = SZ_TIMEOUT * SZ_RESOLUTION;
	#if 0
	/* not yet supported, depends on patches from maxim */
	/* see also: LIRC_GET_REC_RESOLUTION and LIRC_SET_REC_TIMEOUT */
	sz->min_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
	sz->max_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
	#endif

	sz->signal_start = ktime_get_real();

	/* Complete final initialisations */
	usb_fill_int_urb(sz->urb_in, usbdev, pipe, sz->buf_in,
			 maxp, (usb_complete_t)streamzap_callback,
			 sz, sz->endpoint->bInterval);
	sz->urb_in->transfer_dma = sz->dma_in;
	sz->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	usb_set_intfdata(intf, sz);

	if (usb_submit_urb(sz->urb_in, GFP_ATOMIC))
		dev_err(sz->dev, "urb submit failed\n");

	dev_info(sz->dev, "Registered %s on usb%d:%d\n", name,
		 usbdev->bus->busnum, usbdev->devnum);

	return 0;

rc_dev_fail:
	usb_free_urb(sz->urb_in);
free_buf_in:
	usb_free_coherent(usbdev, maxp, sz->buf_in, sz->dma_in);
free_sz:
	kfree(sz);

	return retval;
}

/*
 * streamzap_disconnect
 *
 * Called by the usb core when the device is removed from the system.
 *
 * This routine guarantees that the driver will not submit any more urbs
 * by clearing dev->usbdev.  It is also supposed to terminate any currently
 * active urbs.  Unfortunately, usb_bulk_msg(), used in streamzap_read(),
 * does not provide any way to do this.
 */
static void streamzap_disconnect(struct usb_interface *interface)
{
	struct streamzap_ir *sz = usb_get_intfdata(interface);
	struct usb_device *usbdev = interface_to_usbdev(interface);

	usb_set_intfdata(interface, NULL);

	if (!sz)
		return;

	sz->usbdev = NULL;
	rc_unregister_device(sz->rdev);
	usb_kill_urb(sz->urb_in);
	usb_free_urb(sz->urb_in);
	usb_free_coherent(usbdev, sz->buf_in_len, sz->buf_in, sz->dma_in);

	kfree(sz);
}

static int streamzap_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct streamzap_ir *sz = usb_get_intfdata(intf);

	usb_kill_urb(sz->urb_in);

	return 0;
}

static int streamzap_resume(struct usb_interface *intf)
{
	struct streamzap_ir *sz = usb_get_intfdata(intf);

	if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) {
		dev_err(sz->dev, "Error submitting urb\n");
		return -EIO;
	}

	return 0;
}

module_usb_driver(streamzap_driver);

MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
19770693 JW	2	/*
	3	* Streamzap Remote Control driver
	4	*
	5	* Copyright (c) 2005 Christoph Bartelmus <lirc@bartelmus.de>
8e9e6064	6	* Copyright (c) 2010 Jarod Wilson <jarod@wilsonet.com>
19770693 JW	7	*
	8	* This driver was based on the work of Greg Wickham and Adrian
	9	* Dewhurst. It was substantially rewritten to support correct signal
	10	* gaps and now maintains a delay buffer, which is used to present
	11	* consistent timing behaviour to user space applications. Without the
	12	* delay buffer an ugly hack would be required in lircd, which can
	13	* cause sluggish signal decoding in certain situations.
	14	*
8e9e6064 JW	15	* Ported to in-kernel ir-core interface by Jarod Wilson
8e9e6064 JW	16	*
19770693 JW	17	* This driver is based on the USB skeleton driver packaged with the
19770693 JW	18	* kernel; copyright (C) 2001-2003 Greg Kroah-Hartman (greg@kroah.com)
19770693 JW	19	*/
19770693 JW	20
8e9e6064	21	#include <linux/device.h>
19770693	22	#include <linux/module.h>
8e9e6064	23	#include <linux/slab.h>
dd4c22a6	24	#include <linux/ktime.h>
635f76b2 PB	25	#include <linux/usb.h>
635f76b2 PB	26	#include <linux/usb/input.h>
6bda9644	27	#include <media/rc-core.h>
19770693	28
7a569f52	29	#define DRIVER_VERSION "1.61"
8e9e6064	30	#define DRIVER_NAME "streamzap"
19770693 JW	31	#define DRIVER_DESC "Streamzap Remote Control driver"
19770693 JW	32
19770693 JW	33	#define USB_STREAMZAP_VENDOR_ID 0x0e9c
	34	#define USB_STREAMZAP_PRODUCT_ID 0x0000
	35
19770693	36	/* table of devices that work with this driver */
5fad16b5	37	static const struct usb_device_id streamzap_table[] = {
19770693 JW	38	/* Streamzap Remote Control */
	39	{ USB_DEVICE(USB_STREAMZAP_VENDOR_ID, USB_STREAMZAP_PRODUCT_ID) },
	40	/* Terminating entry */
	41	{ }
	42	};
	43
	44	MODULE_DEVICE_TABLE(usb, streamzap_table);
	45
b768d47e JW	46	#define SZ_PULSE_MASK 0xf0
	47	#define SZ_SPACE_MASK 0x0f
	48	#define SZ_TIMEOUT 0xff
	49	#define SZ_RESOLUTION 256
19770693 JW	50
19770693 JW	51	/* number of samples buffered */
8e9e6064	52	#define SZ_BUF_LEN 128
19770693 JW	53
	54	enum StreamzapDecoderState {
	55	PulseSpace,
	56	FullPulse,
	57	FullSpace,
	58	IgnorePulse
	59	};
	60
8e9e6064 JW	61	/* structure to hold our device specific stuff */
8e9e6064 JW	62	struct streamzap_ir {
8e9e6064	63	/* ir-core */
d8b4b582	64	struct rc_dev *rdev;
8e9e6064 JW	65
	66	/* core device info */
	67	struct device *dev;
19770693 JW	68
19770693 JW	69	/* usb */
8e9e6064	70	struct usb_device *usbdev;
19770693	71	struct usb_interface *interface;
8e9e6064 JW	72	struct usb_endpoint_descriptor *endpoint;
8e9e6064 JW	73	struct urb *urb_in;
19770693 JW	74
	75	/* buffer & dma */
	76	unsigned char *buf_in;
	77	dma_addr_t dma_in;
	78	unsigned int buf_in_len;
	79
8e9e6064 JW	80	/* track what state we're in */
8e9e6064 JW	81	enum StreamzapDecoderState decoder_state;
19770693	82	/* tracks whether we are currently receiving some signal */
8e9e6064	83	bool idle;
19770693 JW	84	/* sum of signal lengths received since signal start */
	85	unsigned long sum;
	86	/* start time of signal; necessary for gap tracking */
dd4c22a6 TR	87	ktime_t signal_last;
dd4c22a6 TR	88	ktime_t signal_start;
7a569f52	89	bool timeout_enabled;
8e9e6064 JW	90
	91	char name[128];
	92	char phys[64];
19770693 JW	93	};
	94
	95
	96	/* local function prototypes */
	97	static int streamzap_probe(struct usb_interface *interface,
	98	const struct usb_device_id *id);
	99	static void streamzap_disconnect(struct usb_interface *interface);
8e9e6064	100	static void streamzap_callback(struct urb *urb);
19770693 JW	101	static int streamzap_suspend(struct usb_interface *intf, pm_message_t message);
	102	static int streamzap_resume(struct usb_interface *intf);
	103
	104	/* usb specific object needed to register this driver with the usb subsystem */
19770693 JW	105	static struct usb_driver streamzap_driver = {
	106	.name = DRIVER_NAME,
	107	.probe = streamzap_probe,
	108	.disconnect = streamzap_disconnect,
	109	.suspend = streamzap_suspend,
	110	.resume = streamzap_resume,
	111	.id_table = streamzap_table,
	112	};
	113
7a569f52	114	static void sz_push(struct streamzap_ir *sz, struct ir_raw_event rawir)
19770693	115	{
1338c925 JW	116	dev_dbg(sz->dev, "Storing %s with duration %u us\n",
1338c925 JW	117	(rawir.pulse ? "pulse" : "space"), rawir.duration);
d8b4b582	118	ir_raw_event_store_with_filter(sz->rdev, &rawir);
19770693 JW	119	}
19770693 JW	120
8e9e6064 JW	121	static void sz_push_full_pulse(struct streamzap_ir *sz,
8e9e6064 JW	122	unsigned char value)
19770693	123	{
183e19f5	124	struct ir_raw_event rawir = {};
7a569f52	125
19770693	126	if (sz->idle) {
dd4c22a6	127	int delta;
19770693 JW	128
19770693 JW	129	sz->signal_last = sz->signal_start;
dd4c22a6	130	sz->signal_start = ktime_get_real();
19770693	131
dd4c22a6	132	delta = ktime_us_delta(sz->signal_start, sz->signal_last);
7a569f52	133	rawir.pulse = false;
dd4c22a6	134	if (delta > (15 * USEC_PER_SEC)) {
19770693	135	/* really long time */
7a569f52	136	rawir.duration = IR_MAX_DURATION;
19770693	137	} else {
dd4c22a6	138	rawir.duration = delta;
7a569f52	139	rawir.duration -= sz->sum;
95cf60aa MCC	140	rawir.duration = (rawir.duration > IR_MAX_DURATION) ?
95cf60aa MCC	141	IR_MAX_DURATION : rawir.duration;
19770693	142	}
7a569f52	143	sz_push(sz, rawir);
19770693	144
7a569f52	145	sz->idle = false;
19770693 JW	146	sz->sum = 0;
	147	}
	148
7a569f52	149	rawir.pulse = true;
b768d47e JW	150	rawir.duration = ((int) value) * SZ_RESOLUTION;
b768d47e JW	151	rawir.duration += SZ_RESOLUTION / 2;
7a569f52	152	sz->sum += rawir.duration;
95cf60aa MCC	153	rawir.duration = (rawir.duration > IR_MAX_DURATION) ?
95cf60aa MCC	154	IR_MAX_DURATION : rawir.duration;
7a569f52	155	sz_push(sz, rawir);
19770693 JW	156	}
19770693 JW	157
8e9e6064 JW	158	static void sz_push_half_pulse(struct streamzap_ir *sz,
8e9e6064 JW	159	unsigned char value)
19770693	160	{
b768d47e	161	sz_push_full_pulse(sz, (value & SZ_PULSE_MASK) >> 4);
19770693 JW	162	}
19770693 JW	163
8e9e6064 JW	164	static void sz_push_full_space(struct streamzap_ir *sz,
8e9e6064 JW	165	unsigned char value)
19770693	166	{
183e19f5	167	struct ir_raw_event rawir = {};
7a569f52 JW	168
7a569f52 JW	169	rawir.pulse = false;
b768d47e JW	170	rawir.duration = ((int) value) * SZ_RESOLUTION;
b768d47e JW	171	rawir.duration += SZ_RESOLUTION / 2;
7a569f52	172	sz->sum += rawir.duration;
7a569f52	173	sz_push(sz, rawir);
19770693 JW	174	}
19770693 JW	175
8e9e6064 JW	176	static void sz_push_half_space(struct streamzap_ir *sz,
8e9e6064 JW	177	unsigned long value)
19770693	178	{
b768d47e	179	sz_push_full_space(sz, value & SZ_SPACE_MASK);
19770693 JW	180	}
19770693 JW	181
cba862dc	182	/*
8e9e6064	183	* streamzap_callback - usb IRQ handler callback
19770693 JW	184	*
	185	* This procedure is invoked on reception of data from
	186	* the usb remote.
	187	*/
8e9e6064	188	static void streamzap_callback(struct urb *urb)
19770693	189	{
8e9e6064 JW	190	struct streamzap_ir *sz;
	191	unsigned int i;
	192	int len;
19770693 JW	193
	194	if (!urb)
	195	return;
	196
	197	sz = urb->context;
	198	len = urb->actual_length;
	199
	200	switch (urb->status) {
	201	case -ECONNRESET:
	202	case -ENOENT:
	203	case -ESHUTDOWN:
	204	/*
	205	* this urb is terminated, clean up.
	206	* sz might already be invalid at this point
	207	*/
8e9e6064	208	dev_err(sz->dev, "urb terminated, status: %d\n", urb->status);
19770693 JW	209	return;
	210	default:
	211	break;
	212	}
	213
8e9e6064	214	dev_dbg(sz->dev, "%s: received urb, len %d\n", __func__, len);
7a569f52	215	for (i = 0; i < len; i++) {
1338c925	216	dev_dbg(sz->dev, "sz->buf_in[%d]: %x\n",
7a569f52 JW	217	i, (unsigned char)sz->buf_in[i]);
	218	switch (sz->decoder_state) {
	219	case PulseSpace:
b768d47e JW	220	if ((sz->buf_in[i] & SZ_PULSE_MASK) ==
b768d47e JW	221	SZ_PULSE_MASK) {
7a569f52 JW	222	sz->decoder_state = FullPulse;
7a569f52 JW	223	continue;
b768d47e JW	224	} else if ((sz->buf_in[i] & SZ_SPACE_MASK)
b768d47e JW	225	== SZ_SPACE_MASK) {
7a569f52 JW	226	sz_push_half_pulse(sz, sz->buf_in[i]);
	227	sz->decoder_state = FullSpace;
	228	continue;
	229	} else {
	230	sz_push_half_pulse(sz, sz->buf_in[i]);
8e9e6064	231	sz_push_half_space(sz, sz->buf_in[i]);
19770693	232	}
7a569f52 JW	233	break;
	234	case FullPulse:
	235	sz_push_full_pulse(sz, sz->buf_in[i]);
	236	sz->decoder_state = IgnorePulse;
	237	break;
	238	case FullSpace:
b768d47e	239	if (sz->buf_in[i] == SZ_TIMEOUT) {
183e19f5 SY	240	struct ir_raw_event rawir = {
	241	.pulse = false,
	242	.duration = sz->rdev->timeout
	243	};
7a569f52 JW	244	sz->idle = true;
	245	if (sz->timeout_enabled)
	246	sz_push(sz, rawir);
d8b4b582	247	ir_raw_event_handle(sz->rdev);
56b0ec30	248	ir_raw_event_reset(sz->rdev);
7a569f52 JW	249	} else {
	250	sz_push_full_space(sz, sz->buf_in[i]);
	251	}
	252	sz->decoder_state = PulseSpace;
	253	break;
	254	case IgnorePulse:
b768d47e JW	255	if ((sz->buf_in[i] & SZ_SPACE_MASK) ==
b768d47e JW	256	SZ_SPACE_MASK) {
7a569f52 JW	257	sz->decoder_state = FullSpace;
	258	continue;
	259	}
	260	sz_push_half_space(sz, sz->buf_in[i]);
	261	sz->decoder_state = PulseSpace;
	262	break;
19770693 JW	263	}
	264	}
	265
56b0ec30	266	ir_raw_event_handle(sz->rdev);
19770693 JW	267	usb_submit_urb(urb, GFP_ATOMIC);
	268
	269	return;
	270	}
	271
d8b4b582	272	static struct rc_dev streamzap_init_rc_dev(struct streamzap_ir sz)
8e9e6064	273	{
d8b4b582	274	struct rc_dev *rdev;
8e9e6064 JW	275	struct device *dev = sz->dev;
	276	int ret;
	277
0f7499fd	278	rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
d8b4b582 DH	279	if (!rdev) {
	280	dev_err(dev, "remote dev allocation failed\n");
	281	goto out;
8e9e6064 JW	282	}
8e9e6064 JW	283
25ec587c	284	snprintf(sz->name, sizeof(sz->name), "Streamzap PC Remote Infrared Receiver (%04x:%04x)",
8e9e6064 JW	285	le16_to_cpu(sz->usbdev->descriptor.idVendor),
8e9e6064 JW	286	le16_to_cpu(sz->usbdev->descriptor.idProduct));
8e9e6064 JW	287	usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys));
8e9e6064 JW	288	strlcat(sz->phys, "/input0", sizeof(sz->phys));
8e9e6064	289
518f4b26	290	rdev->device_name = sz->name;
d8b4b582	291	rdev->input_phys = sz->phys;
5ad1a555 PB	292	usb_to_input_id(sz->usbdev, &rdev->input_id);
5ad1a555 PB	293	rdev->dev.parent = dev;
d8b4b582	294	rdev->priv = sz;
6d741bfe	295	rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
d8b4b582 DH	296	rdev->driver_name = DRIVER_NAME;
d8b4b582 DH	297	rdev->map_name = RC_MAP_STREAMZAP;
635f76b2	298
d8b4b582	299	ret = rc_register_device(rdev);
8e9e6064 JW	300	if (ret < 0) {
8e9e6064 JW	301	dev_err(dev, "remote input device register failed\n");
d8b4b582	302	goto out;
8e9e6064 JW	303	}
8e9e6064 JW	304
d8b4b582	305	return rdev;
8e9e6064	306
d8b4b582 DH	307	out:
d8b4b582 DH	308	rc_free_device(rdev);
8e9e6064 JW	309	return NULL;
	310	}
	311
cba862dc	312	/*
19770693 JW	313	* streamzap_probe
	314	*
	315	* Called by usb-core to associated with a candidate device
	316	* On any failure the return value is the ERROR
	317	* On success return 0
	318	*/
4c62e976 GKH	319	static int streamzap_probe(struct usb_interface *intf,
4c62e976 GKH	320	const struct usb_device_id *id)
19770693	321	{
8e9e6064	322	struct usb_device *usbdev = interface_to_usbdev(intf);
19770693	323	struct usb_host_interface *iface_host;
8e9e6064	324	struct streamzap_ir *sz = NULL;
19770693 JW	325	char buf[63], name[128] = "";
19770693 JW	326	int retval = -ENOMEM;
8e9e6064	327	int pipe, maxp;
19770693 JW	328
19770693 JW	329	/* Allocate space for device driver specific data */
8e9e6064 JW	330	sz = kzalloc(sizeof(struct streamzap_ir), GFP_KERNEL);
8e9e6064 JW	331	if (!sz)
19770693 JW	332	return -ENOMEM;
19770693 JW	333
8e9e6064 JW	334	sz->usbdev = usbdev;
8e9e6064 JW	335	sz->interface = intf;
19770693 JW	336
19770693 JW	337	/* Check to ensure endpoint information matches requirements */
8e9e6064	338	iface_host = intf->cur_altsetting;
19770693 JW	339
19770693 JW	340	if (iface_host->desc.bNumEndpoints != 1) {
8e9e6064 JW	341	dev_err(&intf->dev, "%s: Unexpected desc.bNumEndpoints (%d)\n",
8e9e6064 JW	342	__func__, iface_host->desc.bNumEndpoints);
19770693 JW	343	retval = -ENODEV;
	344	goto free_sz;
	345	}
	346
	347	sz->endpoint = &(iface_host->endpoint[0].desc);
5611588b	348	if (!usb_endpoint_dir_in(sz->endpoint)) {
25ec587c MCC	349	dev_err(&intf->dev, "%s: endpoint doesn't match input device 02%02x\n",
25ec587c MCC	350	__func__, sz->endpoint->bEndpointAddress);
19770693 JW	351	retval = -ENODEV;
	352	goto free_sz;
	353	}
	354
5611588b	355	if (!usb_endpoint_xfer_int(sz->endpoint)) {
25ec587c MCC	356	dev_err(&intf->dev, "%s: endpoint attributes don't match xfer 02%02x\n",
25ec587c MCC	357	__func__, sz->endpoint->bmAttributes);
19770693 JW	358	retval = -ENODEV;
	359	goto free_sz;
	360	}
	361
8e9e6064 JW	362	pipe = usb_rcvintpipe(usbdev, sz->endpoint->bEndpointAddress);
	363	maxp = usb_maxpacket(usbdev, pipe, usb_pipeout(pipe));
	364
	365	if (maxp == 0) {
	366	dev_err(&intf->dev, "%s: endpoint Max Packet Size is 0!?!\n",
	367	__func__);
19770693 JW	368	retval = -ENODEV;
	369	goto free_sz;
	370	}
	371
	372	/* Allocate the USB buffer and IRQ URB */
8e9e6064 JW	373	sz->buf_in = usb_alloc_coherent(usbdev, maxp, GFP_ATOMIC, &sz->dma_in);
8e9e6064 JW	374	if (!sz->buf_in)
19770693 JW	375	goto free_sz;
	376
	377	sz->urb_in = usb_alloc_urb(0, GFP_KERNEL);
8e9e6064 JW	378	if (!sz->urb_in)
8e9e6064 JW	379	goto free_buf_in;
19770693	380
8e9e6064 JW	381	sz->dev = &intf->dev;
8e9e6064 JW	382	sz->buf_in_len = maxp;
19770693	383
8e9e6064 JW	384	if (usbdev->descriptor.iManufacturer
8e9e6064 JW	385	&& usb_string(usbdev, usbdev->descriptor.iManufacturer,
19770693	386	buf, sizeof(buf)) > 0)
c0decac1	387	strscpy(name, buf, sizeof(name));
19770693	388
8e9e6064 JW	389	if (usbdev->descriptor.iProduct
8e9e6064 JW	390	&& usb_string(usbdev, usbdev->descriptor.iProduct,
19770693 JW	391	buf, sizeof(buf)) > 0)
	392	snprintf(name + strlen(name), sizeof(name) - strlen(name),
	393	" %s", buf);
	394
d8b4b582 DH	395	sz->rdev = streamzap_init_rc_dev(sz);
	396	if (!sz->rdev)
	397	goto rc_dev_fail;
19770693	398
8e9e6064 JW	399	sz->idle = true;
8e9e6064 JW	400	sz->decoder_state = PulseSpace;
7a569f52 JW	401	/* FIXME: don't yet have a way to set this */
7a569f52 JW	402	sz->timeout_enabled = true;
528222d8	403	sz->rdev->timeout = SZ_TIMEOUT * SZ_RESOLUTION;
8e9e6064 JW	404	#if 0
	405	/* not yet supported, depends on patches from maxim */
	406	/* see also: LIRC_GET_REC_RESOLUTION and LIRC_SET_REC_TIMEOUT */
528222d8 SY	407	sz->min_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
528222d8 SY	408	sz->max_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
8e9e6064	409	#endif
19770693	410
dd4c22a6	411	sz->signal_start = ktime_get_real();
19770693	412
8e9e6064 JW	413	/* Complete final initialisations */
	414	usb_fill_int_urb(sz->urb_in, usbdev, pipe, sz->buf_in,
	415	maxp, (usb_complete_t)streamzap_callback,
	416	sz, sz->endpoint->bInterval);
	417	sz->urb_in->transfer_dma = sz->dma_in;
	418	sz->urb_in->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
19770693	419
8e9e6064	420	usb_set_intfdata(intf, sz);
19770693	421
7a569f52 JW	422	if (usb_submit_urb(sz->urb_in, GFP_ATOMIC))
7a569f52 JW	423	dev_err(sz->dev, "urb submit failed\n");
19770693	424
8e9e6064 JW	425	dev_info(sz->dev, "Registered %s on usb%d:%d\n", name,
8e9e6064 JW	426	usbdev->bus->busnum, usbdev->devnum);
19770693	427
8e9e6064	428	return 0;
19770693	429
d8b4b582	430	rc_dev_fail:
8e9e6064 JW	431	usb_free_urb(sz->urb_in);
	432	free_buf_in:
	433	usb_free_coherent(usbdev, maxp, sz->buf_in, sz->dma_in);
	434	free_sz:
	435	kfree(sz);
19770693	436
8e9e6064	437	return retval;
19770693 JW	438	}
19770693 JW	439
cba862dc	440	/*
19770693 JW	441	* streamzap_disconnect
	442	*
	443	* Called by the usb core when the device is removed from the system.
	444	*
	445	* This routine guarantees that the driver will not submit any more urbs
8e9e6064	446	* by clearing dev->usbdev. It is also supposed to terminate any currently
19770693 JW	447	* active urbs. Unfortunately, usb_bulk_msg(), used in streamzap_read(),
	448	* does not provide any way to do this.
	449	*/
	450	static void streamzap_disconnect(struct usb_interface *interface)
	451	{
8e9e6064 JW	452	struct streamzap_ir *sz = usb_get_intfdata(interface);
8e9e6064 JW	453	struct usb_device *usbdev = interface_to_usbdev(interface);
19770693	454
8e9e6064	455	usb_set_intfdata(interface, NULL);
19770693	456
8e9e6064 JW	457	if (!sz)
8e9e6064 JW	458	return;
19770693	459
8e9e6064	460	sz->usbdev = NULL;
d8b4b582	461	rc_unregister_device(sz->rdev);
8e9e6064	462	usb_kill_urb(sz->urb_in);
19770693	463	usb_free_urb(sz->urb_in);
8e9e6064	464	usb_free_coherent(usbdev, sz->buf_in_len, sz->buf_in, sz->dma_in);
19770693	465
19770693	466	kfree(sz);
19770693 JW	467	}
	468
	469	static int streamzap_suspend(struct usb_interface *intf, pm_message_t message)
	470	{
8e9e6064	471	struct streamzap_ir *sz = usb_get_intfdata(intf);
19770693	472
8e9e6064	473	usb_kill_urb(sz->urb_in);
19770693	474
19770693 JW	475	return 0;
	476	}
	477
	478	static int streamzap_resume(struct usb_interface *intf)
	479	{
8e9e6064	480	struct streamzap_ir *sz = usb_get_intfdata(intf);
19770693	481
8e9e6064	482	if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) {
1c195cb1	483	dev_err(sz->dev, "Error submitting urb\n");
8e9e6064	484	return -EIO;
19770693	485	}
8e9e6064	486
19770693 JW	487	return 0;
	488	}
	489
ecb3b2b3	490	module_usb_driver(streamzap_driver);
19770693	491
8e9e6064	492	MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>");
19770693 JW	493	MODULE_DESCRIPTION(DRIVER_DESC);
19770693 JW	494	MODULE_LICENSE("GPL");