History

staging: Move media drivers to staging/media

In practice, it is being hard to distinguish when a patch should go to staging tree or to the media tree. Better to distinguish it, by putting the media drivers at a separate staging directory. Newer staging drivers that include anything with "dvb*.h", "v4l2*.h" or "videodev2.h" should go to the drivers/staging/media tree.

Mauro Carvalho Chehab committed 15 years ago

Commit 4860c731 parent d6ce55d83 files · +48 −22Browse files

Showing the changes to drivers/staging/media/lirc/lirc_igorplugusb.c (1 of 83 files). Show all

Unified · Split

drivers/staging/media/lirc/lirc_igorplugusb.c+577−0
@@ -0,0 +1,577 @@
1+/*
2+ * lirc_igorplugusb - USB remote support for LIRC
3+ *
4+ * Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
5+ * See http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm
6+ *
7+ * The device can only record bursts of up to 36 pulses/spaces.
8+ * Works fine with RC5. Longer commands lead to device buffer overrun.
9+ * (Maybe a better firmware or a microcontroller with more ram can help?)
10+ *
11+ * Version 0.1 [beta status]
12+ *
13+ * Copyright (C) 2004 Jan M. Hochstein
14+ * <hochstein@algo.informatik.tu-darmstadt.de>
15+ *
16+ * This driver was derived from:
17+ * Paul Miller <pmiller9@users.sourceforge.net>
18+ * "lirc_atiusb" module
19+ * Vladimir Dergachev <volodya@minspring.com>'s 2002
20+ * "USB ATI Remote support" (input device)
21+ * Adrian Dewhurst <sailor-lk@sailorfrag.net>'s 2002
22+ * "USB StreamZap remote driver" (LIRC)
23+ * Artur Lipowski <alipowski@kki.net.pl>'s 2002
24+ * "lirc_dev" and "lirc_gpio" LIRC modules
25+ */
26+
27+/*
28+ * This program is free software; you can redistribute it and/or modify
29+ * it under the terms of the GNU General Public License as published by
30+ * the Free Software Foundation; either version 2 of the License, or
31+ * (at your option) any later version.
32+ *
33+ * This program is distributed in the hope that it will be useful,
34+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
35+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36+ * GNU General Public License for more details.
37+ *
38+ * You should have received a copy of the GNU General Public License
39+ * along with this program; if not, write to the Free Software
40+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
41+ */
42+
43+#include <linux/module.h>
44+#include <linux/kernel.h>
45+#include <linux/kmod.h>
46+#include <linux/sched.h>
47+#include <linux/errno.h>
48+#include <linux/fs.h>
49+#include <linux/usb.h>
50+#include <linux/time.h>
51+
52+#include <media/lirc.h>
53+#include <media/lirc_dev.h>
54+
55+
56+/* module identification */
57+#define DRIVER_VERSION "0.2"
58+#define DRIVER_AUTHOR \
59+ "Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>"
60+#define DRIVER_DESC "Igorplug USB remote driver for LIRC"
61+#define DRIVER_NAME "lirc_igorplugusb"
62+
63+/* debugging support */
64+#ifdef CONFIG_USB_DEBUG
65+static int debug = 1;
66+#else
67+static int debug;
68+#endif
69+
70+#define dprintk(fmt, args...) \
71+ do { \
72+ if (debug) \
73+ printk(KERN_DEBUG fmt, ## args); \
74+ } while (0)
75+
76+/* One mode2 pulse/space has 4 bytes. */
77+#define CODE_LENGTH sizeof(int)
78+
79+/* Igor's firmware cannot record bursts longer than 36. */
80+#define DEVICE_BUFLEN 36
81+
82+/*
83+ * Header at the beginning of the device's buffer:
84+ * unsigned char data_length
85+ * unsigned char data_start (!=0 means ring-buffer overrun)
86+ * unsigned char counter (incremented by each burst)
87+ */
88+#define DEVICE_HEADERLEN 3
89+
90+/* This is for the gap */
91+#define ADDITIONAL_LIRC_BYTES 2
92+
93+/* times to poll per second */
94+#define SAMPLE_RATE 100
95+static int sample_rate = SAMPLE_RATE;
96+
97+
98+/**** Igor's USB Request Codes */
99+
100+#define SET_INFRABUFFER_EMPTY 1
101+/**
102+ * Params: none
103+ * Answer: empty
104+ */
105+
106+#define GET_INFRACODE 2
107+/**
108+ * Params:
109+ * wValue: offset to begin reading infra buffer
110+ *
111+ * Answer: infra data
112+ */
113+
114+#define SET_DATAPORT_DIRECTION 3
115+/**
116+ * Params:
117+ * wValue: (byte) 1 bit for each data port pin (0=in, 1=out)
118+ *
119+ * Answer: empty
120+ */
121+
122+#define GET_DATAPORT_DIRECTION 4
123+/**
124+ * Params: none
125+ *
126+ * Answer: (byte) 1 bit for each data port pin (0=in, 1=out)
127+ */
128+
129+#define SET_OUT_DATAPORT 5
130+/**
131+ * Params:
132+ * wValue: byte to write to output data port
133+ *
134+ * Answer: empty
135+ */
136+
137+#define GET_OUT_DATAPORT 6
138+/**
139+ * Params: none
140+ *
141+ * Answer: least significant 3 bits read from output data port
142+ */
143+
144+#define GET_IN_DATAPORT 7
145+/**
146+ * Params: none
147+ *
148+ * Answer: least significant 3 bits read from input data port
149+ */
150+
151+#define READ_EEPROM 8
152+/**
153+ * Params:
154+ * wValue: offset to begin reading EEPROM
155+ *
156+ * Answer: EEPROM bytes
157+ */
158+
159+#define WRITE_EEPROM 9
160+/**
161+ * Params:
162+ * wValue: offset to EEPROM byte
163+ * wIndex: byte to write
164+ *
165+ * Answer: empty
166+ */
167+
168+#define SEND_RS232 10
169+/**
170+ * Params:
171+ * wValue: byte to send
172+ *
173+ * Answer: empty
174+ */
175+
176+#define RECV_RS232 11
177+/**
178+ * Params: none
179+ *
180+ * Answer: byte received
181+ */
182+
183+#define SET_RS232_BAUD 12
184+/**
185+ * Params:
186+ * wValue: byte to write to UART bit rate register (UBRR)
187+ *
188+ * Answer: empty
189+ */
190+
191+#define GET_RS232_BAUD 13
192+/**
193+ * Params: none
194+ *
195+ * Answer: byte read from UART bit rate register (UBRR)
196+ */
197+
198+
199+/* data structure for each usb remote */
200+struct igorplug {
201+
202+ /* usb */
203+ struct usb_device *usbdev;
204+ int devnum;
205+
206+ unsigned char *buf_in;
207+ unsigned int len_in;
208+ int in_space;
209+ struct timeval last_time;
210+
211+ dma_addr_t dma_in;
212+
213+ /* lirc */
214+ struct lirc_driver *d;
215+
216+ /* handle sending (init strings) */
217+ int send_flags;
218+};
219+
220+static int unregister_from_lirc(struct igorplug *ir)
221+{
222+ struct lirc_driver *d;
223+ int devnum;
224+
225+ if (!ir) {
226+ printk(KERN_ERR "%s: called with NULL device struct!\n",
227+ __func__);
228+ return -EINVAL;
229+ }
230+
231+ devnum = ir->devnum;
232+ d = ir->d;
233+
234+ if (!d) {
235+ printk(KERN_ERR "%s: called with NULL lirc driver struct!\n",
236+ __func__);
237+ return -EINVAL;
238+ }
239+
240+ dprintk(DRIVER_NAME "[%d]: calling lirc_unregister_driver\n", devnum);
241+ lirc_unregister_driver(d->minor);
242+
243+ kfree(d);
244+ ir->d = NULL;
245+ kfree(ir);
246+
247+ return devnum;
248+}
249+
250+static int set_use_inc(void *data)
251+{
252+ struct igorplug *ir = data;
253+
254+ if (!ir) {
255+ printk(DRIVER_NAME "[?]: set_use_inc called with no context\n");
256+ return -EIO;
257+ }
258+
259+ dprintk(DRIVER_NAME "[%d]: set use inc\n", ir->devnum);
260+
261+ if (!ir->usbdev)
262+ return -ENODEV;
263+
264+ return 0;
265+}
266+
267+static void set_use_dec(void *data)
268+{
269+ struct igorplug *ir = data;
270+
271+ if (!ir) {
272+ printk(DRIVER_NAME "[?]: set_use_dec called with no context\n");
273+ return;
274+ }
275+
276+ dprintk(DRIVER_NAME "[%d]: set use dec\n", ir->devnum);
277+}
278+
279+static void send_fragment(struct igorplug *ir, struct lirc_buffer *buf,
280+ int i, int max)
281+{
282+ int code;
283+
284+ /* MODE2: pulse/space (PULSE_BIT) in 1us units */
285+ while (i < max) {
286+ /* 1 Igor-tick = 85.333333 us */
287+ code = (unsigned int)ir->buf_in[i] * 85 +
288+ (unsigned int)ir->buf_in[i] / 3;
289+ ir->last_time.tv_usec += code;
290+ if (ir->in_space)
291+ code |= PULSE_BIT;
292+ lirc_buffer_write(buf, (unsigned char *)&code);
293+ /* 1 chunk = CODE_LENGTH bytes */
294+ ir->in_space ^= 1;
295+ ++i;
296+ }
297+}
298+
299+/**
300+ * Called in user context.
301+ * return 0 if data was added to the buffer and
302+ * -ENODATA if none was available. This should add some number of bits
303+ * evenly divisible by code_length to the buffer
304+ */
305+static int igorplugusb_remote_poll(void *data, struct lirc_buffer *buf)
306+{
307+ int ret;
308+ struct igorplug *ir = (struct igorplug *)data;
309+
310+ if (!ir || !ir->usbdev) /* Has the device been removed? */
311+ return -ENODEV;
312+
313+ memset(ir->buf_in, 0, ir->len_in);
314+
315+ ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
316+ GET_INFRACODE, USB_TYPE_VENDOR | USB_DIR_IN,
317+ 0/* offset */, /*unused*/0,
318+ ir->buf_in, ir->len_in,
319+ /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
320+ if (ret > 0) {
321+ int code, timediff;
322+ struct timeval now;
323+
324+ /* ACK packet has 1 byte --> ignore */
325+ if (ret < DEVICE_HEADERLEN)
326+ return -ENODATA;
327+
328+ dprintk(DRIVER_NAME ": Got %d bytes. Header: %02x %02x %02x\n",
329+ ret, ir->buf_in[0], ir->buf_in[1], ir->buf_in[2]);
330+
331+ do_gettimeofday(&now);
332+ timediff = now.tv_sec - ir->last_time.tv_sec;
333+ if (timediff + 1 > PULSE_MASK / 1000000)
334+ timediff = PULSE_MASK;
335+ else {
336+ timediff *= 1000000;
337+ timediff += now.tv_usec - ir->last_time.tv_usec;
338+ }
339+ ir->last_time.tv_sec = now.tv_sec;
340+ ir->last_time.tv_usec = now.tv_usec;
341+
342+ /* create leading gap */
343+ code = timediff;
344+ lirc_buffer_write(buf, (unsigned char *)&code);
345+ ir->in_space = 1; /* next comes a pulse */
346+
347+ if (ir->buf_in[2] == 0)
348+ send_fragment(ir, buf, DEVICE_HEADERLEN, ret);
349+ else {
350+ printk(KERN_WARNING DRIVER_NAME
351+ "[%d]: Device buffer overrun.\n", ir->devnum);
352+ /* HHHNNNNNNNNNNNOOOOOOOO H = header
353+ <---[2]---> N = newer
354+ <---------ret--------> O = older */
355+ ir->buf_in[2] %= ret - DEVICE_HEADERLEN; /* sanitize */
356+ /* keep even-ness to not desync pulse/pause */
357+ send_fragment(ir, buf, DEVICE_HEADERLEN +
358+ ir->buf_in[2] - (ir->buf_in[2] & 1), ret);
359+ send_fragment(ir, buf, DEVICE_HEADERLEN,
360+ DEVICE_HEADERLEN + ir->buf_in[2]);
361+ }
362+
363+ ret = usb_control_msg(
364+ ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
365+ SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
366+ /*unused*/0, /*unused*/0,
367+ /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
368+ /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
369+ if (ret < 0)
370+ printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: "
371+ "error %d\n", ir->devnum, ret);
372+ return 0;
373+ } else if (ret < 0)
374+ printk(DRIVER_NAME "[%d]: GET_INFRACODE: error %d\n",
375+ ir->devnum, ret);
376+
377+ return -ENODATA;
378+}
379+
380+
381+
382+static int igorplugusb_remote_probe(struct usb_interface *intf,
383+ const struct usb_device_id *id)
384+{
385+ struct usb_device *dev = NULL;
386+ struct usb_host_interface *idesc = NULL;
387+ struct usb_endpoint_descriptor *ep;
388+ struct igorplug *ir = NULL;
389+ struct lirc_driver *driver = NULL;
390+ int devnum, pipe, maxp;
391+ int minor = 0;
392+ char buf[63], name[128] = "";
393+ int mem_failure = 0;
394+ int ret;
395+
396+ dprintk(DRIVER_NAME ": usb probe called.\n");
397+
398+ dev = interface_to_usbdev(intf);
399+
400+ idesc = intf->cur_altsetting;
401+
402+ if (idesc->desc.bNumEndpoints != 1)
403+ return -ENODEV;
404+
405+ ep = &idesc->endpoint->desc;
406+ if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
407+ != USB_DIR_IN)
408+ || (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
409+ != USB_ENDPOINT_XFER_CONTROL)
410+ return -ENODEV;
411+
412+ pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);
413+ devnum = dev->devnum;
414+ maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
415+
416+ dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d\n",
417+ devnum, CODE_LENGTH, maxp);
418+
419+ mem_failure = 0;
420+ ir = kzalloc(sizeof(struct igorplug), GFP_KERNEL);
421+ if (!ir) {
422+ mem_failure = 1;
423+ goto mem_failure_switch;
424+ }
425+ driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
426+ if (!driver) {
427+ mem_failure = 2;
428+ goto mem_failure_switch;
429+ }
430+
431+ ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
432+ GFP_ATOMIC, &ir->dma_in);
433+ if (!ir->buf_in) {
434+ mem_failure = 3;
435+ goto mem_failure_switch;
436+ }
437+
438+ strcpy(driver->name, DRIVER_NAME " ");
439+ driver->minor = -1;
440+ driver->code_length = CODE_LENGTH * 8; /* in bits */
441+ driver->features = LIRC_CAN_REC_MODE2;
442+ driver->data = ir;
443+ driver->chunk_size = CODE_LENGTH;
444+ driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
445+ driver->set_use_inc = &set_use_inc;
446+ driver->set_use_dec = &set_use_dec;
447+ driver->sample_rate = sample_rate; /* per second */
448+ driver->add_to_buf = &igorplugusb_remote_poll;
449+ driver->dev = &intf->dev;
450+ driver->owner = THIS_MODULE;
451+
452+ minor = lirc_register_driver(driver);
453+ if (minor < 0)
454+ mem_failure = 9;
455+
456+mem_failure_switch:
457+
458+ switch (mem_failure) {
459+ case 9:
460+ usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
461+ ir->buf_in, ir->dma_in);
462+ case 3:
463+ kfree(driver);
464+ case 2:
465+ kfree(ir);
466+ case 1:
467+ printk(DRIVER_NAME "[%d]: out of memory (code=%d)\n",
468+ devnum, mem_failure);
469+ return -ENOMEM;
470+ }
471+
472+ driver->minor = minor;
473+ ir->d = driver;
474+ ir->devnum = devnum;
475+ ir->usbdev = dev;
476+ ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;
477+ ir->in_space = 1; /* First mode2 event is a space. */
478+ do_gettimeofday(&ir->last_time);
479+
480+ if (dev->descriptor.iManufacturer
481+ && usb_string(dev, dev->descriptor.iManufacturer,
482+ buf, sizeof(buf)) > 0)
483+ strlcpy(name, buf, sizeof(name));
484+ if (dev->descriptor.iProduct
485+ && usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
486+ snprintf(name + strlen(name), sizeof(name) - strlen(name),
487+ " %s", buf);
488+ printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
489+ dev->bus->busnum, devnum);
490+
491+ /* clear device buffer */
492+ ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
493+ SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
494+ /*unused*/0, /*unused*/0,
495+ /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
496+ /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
497+ if (ret < 0)
498+ printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
499+ devnum, ret);
500+
501+ usb_set_intfdata(intf, ir);
502+ return 0;
503+}
504+
505+
506+static void igorplugusb_remote_disconnect(struct usb_interface *intf)
507+{
508+ struct usb_device *usbdev = interface_to_usbdev(intf);
509+ struct igorplug *ir = usb_get_intfdata(intf);
510+ struct device *dev = &intf->dev;
511+ int devnum;
512+
513+ usb_set_intfdata(intf, NULL);
514+
515+ if (!ir || !ir->d)
516+ return;
517+
518+ ir->usbdev = NULL;
519+
520+ usb_free_coherent(usbdev, ir->len_in, ir->buf_in, ir->dma_in);
521+
522+ devnum = unregister_from_lirc(ir);
523+
524+ dev_info(dev, DRIVER_NAME "[%d]: %s done\n", devnum, __func__);
525+}
526+
527+static struct usb_device_id igorplugusb_remote_id_table[] = {
528+ /* Igor Plug USB (Atmel's Manufact. ID) */
529+ { USB_DEVICE(0x03eb, 0x0002) },
530+ /* Fit PC2 Infrared Adapter */
531+ { USB_DEVICE(0x03eb, 0x21fe) },
532+
533+ /* Terminating entry */
534+ { }
535+};
536+
537+static struct usb_driver igorplugusb_remote_driver = {
538+ .name = DRIVER_NAME,
539+ .probe = igorplugusb_remote_probe,
540+ .disconnect = igorplugusb_remote_disconnect,
541+ .id_table = igorplugusb_remote_id_table
542+};
543+
544+static int __init igorplugusb_remote_init(void)
545+{
546+ int ret = 0;
547+
548+ dprintk(DRIVER_NAME ": loaded, debug mode enabled\n");
549+
550+ ret = usb_register(&igorplugusb_remote_driver);
551+ if (ret)
552+ printk(KERN_ERR DRIVER_NAME ": usb register failed!\n");
553+
554+ return ret;
555+}
556+
557+static void __exit igorplugusb_remote_exit(void)
558+{
559+ usb_deregister(&igorplugusb_remote_driver);
560+}
561+
562+module_init(igorplugusb_remote_init);
563+module_exit(igorplugusb_remote_exit);
564+
565+#include <linux/vermagic.h>
566+MODULE_INFO(vermagic, VERMAGIC_STRING);
567+
568+MODULE_DESCRIPTION(DRIVER_DESC);
569+MODULE_AUTHOR(DRIVER_AUTHOR);
570+MODULE_LICENSE("GPL");
571+MODULE_DEVICE_TABLE(usb, igorplugusb_remote_id_table);
572+
573+module_param(sample_rate, int, S_IRUGO | S_IWUSR);
574+MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");
575+
576+module_param(debug, bool, S_IRUGO | S_IWUSR);
577+MODULE_PARM_DESC(debug, "Debug enabled or not");