1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Streamzap Remote Control driver
4 *
5 * Copyright (c) 2005 Christoph Bartelmus <lirc@bartelmus.de>
6 * Copyright (c) 2010 Jarod Wilson <jarod@wilsonet.com>
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 *
15 * Ported to in-kernel ir-core interface by Jarod Wilson
16 *
17 * This driver is based on the USB skeleton driver packaged with the
18 * kernel; copyright (C) 2001-2003 Greg Kroah-Hartman (greg@kroah.com)
19 */
20
21#include <linux/device.h>
22#include <linux/module.h>
23#include <linux/slab.h>
24#include <linux/usb.h>
25#include <linux/usb/input.h>
26#include <media/rc-core.h>
27
28#define DRIVER_NAME "streamzap"
29#define DRIVER_DESC "Streamzap Remote Control driver"
30
31#define USB_STREAMZAP_VENDOR_ID 0x0e9c
32#define USB_STREAMZAP_PRODUCT_ID 0x0000
33
34/* table of devices that work with this driver */
35static const struct usb_device_id streamzap_table[] = {
36 /* Streamzap Remote Control */
37 { USB_DEVICE(USB_STREAMZAP_VENDOR_ID, USB_STREAMZAP_PRODUCT_ID) },
38 /* Terminating entry */
39 { }
40};
41
42MODULE_DEVICE_TABLE(usb, streamzap_table);
43
44#define SZ_PULSE_MASK 0xf0
45#define SZ_SPACE_MASK 0x0f
46#define SZ_TIMEOUT 0xff
47#define SZ_RESOLUTION 256
48
49/* number of samples buffered */
50#define SZ_BUF_LEN 128
51
52enum StreamzapDecoderState {
53 PulseSpace,
54 FullPulse,
55 FullSpace,
56 IgnorePulse
57};
58
59/* structure to hold our device specific stuff */
60struct streamzap_ir {
61 /* ir-core */
62 struct rc_dev *rdev;
63
64 /* core device info */
65 struct device *dev;
66
67 /* usb */
68 struct urb *urb_in;
69
70 /* buffer & dma */
71 unsigned char *buf_in;
72 dma_addr_t dma_in;
73 unsigned int buf_in_len;
74
75 /* track what state we're in */
76 enum StreamzapDecoderState decoder_state;
77
78 char phys[64];
79};
80
81
82/* local function prototypes */
83static int streamzap_probe(struct usb_interface *interface,
84 const struct usb_device_id *id);
85static void streamzap_disconnect(struct usb_interface *interface);
86static void streamzap_callback(struct urb *urb);
87static int streamzap_suspend(struct usb_interface *intf, pm_message_t message);
88static int streamzap_resume(struct usb_interface *intf);
89
90/* usb specific object needed to register this driver with the usb subsystem */
91static struct usb_driver streamzap_driver = {
92 .name = DRIVER_NAME,
93 .probe = streamzap_probe,
94 .disconnect = streamzap_disconnect,
95 .suspend = streamzap_suspend,
96 .resume = streamzap_resume,
97 .id_table = streamzap_table,
98};
99
100static void sz_push(struct streamzap_ir *sz, struct ir_raw_event rawir)
101{
102 dev_dbg(sz->dev, "Storing %s with duration %u us\n",
103 (rawir.pulse ? "pulse" : "space"), rawir.duration);
104 ir_raw_event_store_with_filter(dev: sz->rdev, ev: &rawir);
105}
106
107static void sz_push_full_pulse(struct streamzap_ir *sz,
108 unsigned char value)
109{
110 struct ir_raw_event rawir = {
111 .pulse = true,
112 .duration = value * SZ_RESOLUTION + SZ_RESOLUTION / 2,
113 };
114
115 sz_push(sz, rawir);
116}
117
118static void sz_push_half_pulse(struct streamzap_ir *sz,
119 unsigned char value)
120{
121 sz_push_full_pulse(sz, value: (value & SZ_PULSE_MASK) >> 4);
122}
123
124static void sz_push_full_space(struct streamzap_ir *sz,
125 unsigned char value)
126{
127 struct ir_raw_event rawir = {
128 .pulse = false,
129 .duration = value * SZ_RESOLUTION + SZ_RESOLUTION / 2,
130 };
131
132 sz_push(sz, rawir);
133}
134
135static void sz_push_half_space(struct streamzap_ir *sz,
136 unsigned long value)
137{
138 sz_push_full_space(sz, value: value & SZ_SPACE_MASK);
139}
140
141static void sz_process_ir_data(struct streamzap_ir *sz, int len)
142{
143 unsigned int i;
144
145 for (i = 0; i < len; i++) {
146 dev_dbg(sz->dev, "sz->buf_in[%d]: %x\n",
147 i, (unsigned char)sz->buf_in[i]);
148 switch (sz->decoder_state) {
149 case PulseSpace:
150 if ((sz->buf_in[i] & SZ_PULSE_MASK) ==
151 SZ_PULSE_MASK) {
152 sz->decoder_state = FullPulse;
153 continue;
154 } else if ((sz->buf_in[i] & SZ_SPACE_MASK)
155 == SZ_SPACE_MASK) {
156 sz_push_half_pulse(sz, value: sz->buf_in[i]);
157 sz->decoder_state = FullSpace;
158 continue;
159 } else {
160 sz_push_half_pulse(sz, value: sz->buf_in[i]);
161 sz_push_half_space(sz, value: sz->buf_in[i]);
162 }
163 break;
164 case FullPulse:
165 sz_push_full_pulse(sz, value: sz->buf_in[i]);
166 sz->decoder_state = IgnorePulse;
167 break;
168 case FullSpace:
169 if (sz->buf_in[i] == SZ_TIMEOUT) {
170 struct ir_raw_event rawir = {
171 .pulse = false,
172 .duration = sz->rdev->timeout
173 };
174 sz_push(sz, rawir);
175 } else {
176 sz_push_full_space(sz, value: sz->buf_in[i]);
177 }
178 sz->decoder_state = PulseSpace;
179 break;
180 case IgnorePulse:
181 if ((sz->buf_in[i] & SZ_SPACE_MASK) ==
182 SZ_SPACE_MASK) {
183 sz->decoder_state = FullSpace;
184 continue;
185 }
186 sz_push_half_space(sz, value: sz->buf_in[i]);
187 sz->decoder_state = PulseSpace;
188 break;
189 }
190 }
191
192 ir_raw_event_handle(dev: sz->rdev);
193}
194
195/*
196 * streamzap_callback - usb IRQ handler callback
197 *
198 * This procedure is invoked on reception of data from
199 * the usb remote.
200 */
201static void streamzap_callback(struct urb *urb)
202{
203 struct streamzap_ir *sz;
204 int len;
205
206 if (!urb)
207 return;
208
209 sz = urb->context;
210 len = urb->actual_length;
211
212 switch (urb->status) {
213 case 0:
214 dev_dbg(sz->dev, "%s: received urb, len %d\n", __func__, len);
215 sz_process_ir_data(sz, len);
216 break;
217 case -ECONNRESET:
218 case -ENOENT:
219 case -ESHUTDOWN:
220 /*
221 * this urb is terminated, clean up.
222 * sz might already be invalid at this point
223 */
224 dev_err(sz->dev, "urb terminated, status: %d\n", urb->status);
225 return;
226 default:
227 break;
228 }
229
230 usb_submit_urb(urb, GFP_ATOMIC);
231}
232
233static struct rc_dev *streamzap_init_rc_dev(struct streamzap_ir *sz,
234 struct usb_device *usbdev)
235{
236 struct rc_dev *rdev;
237 struct device *dev = sz->dev;
238 int ret;
239
240 rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
241 if (!rdev)
242 goto out;
243
244 usb_make_path(dev: usbdev, buf: sz->phys, size: sizeof(sz->phys));
245 strlcat(p: sz->phys, q: "/input0", avail: sizeof(sz->phys));
246
247 rdev->device_name = "Streamzap PC Remote Infrared Receiver";
248 rdev->input_phys = sz->phys;
249 usb_to_input_id(dev: usbdev, id: &rdev->input_id);
250 rdev->dev.parent = dev;
251 rdev->priv = sz;
252 rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
253 rdev->driver_name = DRIVER_NAME;
254 rdev->map_name = RC_MAP_STREAMZAP;
255 rdev->rx_resolution = SZ_RESOLUTION;
256
257 ret = rc_register_device(dev: rdev);
258 if (ret < 0) {
259 dev_err(dev, "remote input device register failed\n");
260 goto out;
261 }
262
263 return rdev;
264
265out:
266 rc_free_device(dev: rdev);
267 return NULL;
268}
269
270/*
271 * streamzap_probe
272 *
273 * Called by usb-core to associated with a candidate device
274 * On any failure the return value is the ERROR
275 * On success return 0
276 */
277static int streamzap_probe(struct usb_interface *intf,
278 const struct usb_device_id *id)
279{
280 struct usb_device *usbdev = interface_to_usbdev(intf);
281 struct usb_endpoint_descriptor *endpoint;
282 struct usb_host_interface *iface_host;
283 struct streamzap_ir *sz = NULL;
284 int retval = -ENOMEM;
285 int pipe, maxp;
286
287 /* Allocate space for device driver specific data */
288 sz = kzalloc(sizeof(struct streamzap_ir), GFP_KERNEL);
289 if (!sz)
290 return -ENOMEM;
291
292 /* Check to ensure endpoint information matches requirements */
293 iface_host = intf->cur_altsetting;
294
295 if (iface_host->desc.bNumEndpoints != 1) {
296 dev_err(&intf->dev, "%s: Unexpected desc.bNumEndpoints (%d)\n",
297 __func__, iface_host->desc.bNumEndpoints);
298 retval = -ENODEV;
299 goto free_sz;
300 }
301
302 endpoint = &iface_host->endpoint[0].desc;
303 if (!usb_endpoint_dir_in(epd: endpoint)) {
304 dev_err(&intf->dev, "%s: endpoint doesn't match input device 02%02x\n",
305 __func__, endpoint->bEndpointAddress);
306 retval = -ENODEV;
307 goto free_sz;
308 }
309
310 if (!usb_endpoint_xfer_int(epd: endpoint)) {
311 dev_err(&intf->dev, "%s: endpoint attributes don't match xfer 02%02x\n",
312 __func__, endpoint->bmAttributes);
313 retval = -ENODEV;
314 goto free_sz;
315 }
316
317 pipe = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress);
318 maxp = usb_maxpacket(udev: usbdev, pipe);
319
320 if (maxp == 0) {
321 dev_err(&intf->dev, "%s: endpoint Max Packet Size is 0!?!\n",
322 __func__);
323 retval = -ENODEV;
324 goto free_sz;
325 }
326
327 /* Allocate the USB buffer and IRQ URB */
328 sz->buf_in = usb_alloc_coherent(dev: usbdev, size: maxp, GFP_ATOMIC, dma: &sz->dma_in);
329 if (!sz->buf_in)
330 goto free_sz;
331
332 sz->urb_in = usb_alloc_urb(iso_packets: 0, GFP_KERNEL);
333 if (!sz->urb_in)
334 goto free_buf_in;
335
336 sz->dev = &intf->dev;
337 sz->buf_in_len = maxp;
338
339 sz->rdev = streamzap_init_rc_dev(sz, usbdev);
340 if (!sz->rdev)
341 goto rc_dev_fail;
342
343 sz->decoder_state = PulseSpace;
344 /* FIXME: don't yet have a way to set this */
345 sz->rdev->timeout = SZ_TIMEOUT * SZ_RESOLUTION;
346 #if 0
347 /* not yet supported, depends on patches from maxim */
348 /* see also: LIRC_GET_REC_RESOLUTION and LIRC_SET_REC_TIMEOUT */
349 sz->min_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
350 sz->max_timeout = SZ_TIMEOUT * SZ_RESOLUTION;
351 #endif
352
353 /* Complete final initialisations */
354 usb_fill_int_urb(urb: sz->urb_in, dev: usbdev, pipe, transfer_buffer: sz->buf_in,
355 buffer_length: maxp, complete_fn: streamzap_callback, context: sz, interval: endpoint->bInterval);
356 sz->urb_in->transfer_dma = sz->dma_in;
357 sz->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
358
359 usb_set_intfdata(intf, data: sz);
360
361 if (usb_submit_urb(urb: sz->urb_in, GFP_ATOMIC))
362 dev_err(sz->dev, "urb submit failed\n");
363
364 return 0;
365
366rc_dev_fail:
367 usb_free_urb(urb: sz->urb_in);
368free_buf_in:
369 usb_free_coherent(dev: usbdev, size: maxp, addr: sz->buf_in, dma: sz->dma_in);
370free_sz:
371 kfree(objp: sz);
372
373 return retval;
374}
375
376/*
377 * streamzap_disconnect
378 *
379 * Called by the usb core when the device is removed from the system.
380 *
381 * This routine guarantees that the driver will not submit any more urbs
382 * by clearing dev->usbdev. It is also supposed to terminate any currently
383 * active urbs. Unfortunately, usb_bulk_msg(), used in streamzap_read(),
384 * does not provide any way to do this.
385 */
386static void streamzap_disconnect(struct usb_interface *interface)
387{
388 struct streamzap_ir *sz = usb_get_intfdata(intf: interface);
389 struct usb_device *usbdev = interface_to_usbdev(interface);
390
391 usb_set_intfdata(intf: interface, NULL);
392
393 if (!sz)
394 return;
395
396 usb_kill_urb(urb: sz->urb_in);
397 rc_unregister_device(dev: sz->rdev);
398 usb_free_urb(urb: sz->urb_in);
399 usb_free_coherent(dev: usbdev, size: sz->buf_in_len, addr: sz->buf_in, dma: sz->dma_in);
400
401 kfree(objp: sz);
402}
403
404static int streamzap_suspend(struct usb_interface *intf, pm_message_t message)
405{
406 struct streamzap_ir *sz = usb_get_intfdata(intf);
407
408 usb_kill_urb(urb: sz->urb_in);
409
410 return 0;
411}
412
413static int streamzap_resume(struct usb_interface *intf)
414{
415 struct streamzap_ir *sz = usb_get_intfdata(intf);
416
417 if (usb_submit_urb(urb: sz->urb_in, GFP_NOIO)) {
418 dev_err(sz->dev, "Error submitting urb\n");
419 return -EIO;
420 }
421
422 return 0;
423}
424
425module_usb_driver(streamzap_driver);
426
427MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>");
428MODULE_DESCRIPTION(DRIVER_DESC);
429MODULE_LICENSE("GPL");
430

source code of linux/drivers/media/rc/streamzap.c