2 * lirc_igorplugusb - USB remote support for LIRC
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
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?)
11 * Version 0.1 [beta status]
13 * Copyright (C) 2004 Jan M. Hochstein
14 * <hochstein@algo.informatik.tu-darmstadt.de>
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
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.
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.
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
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>
49 #include <linux/usb.h>
50 #include <linux/time.h>
52 #include <media/lirc.h>
53 #include <media/lirc_dev.h>
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"
63 /* debugging support */
64 #ifdef CONFIG_USB_DEBUG
70 #define dprintk(fmt, args...) \
73 printk(KERN_DEBUG fmt, ## args); \
76 /* One mode2 pulse/space has 4 bytes. */
77 #define CODE_LENGTH sizeof(int)
79 /* Igor's firmware cannot record bursts longer than 36. */
80 #define DEVICE_BUFLEN 36
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)
88 #define DEVICE_HEADERLEN 3
90 /* This is for the gap */
91 #define ADDITIONAL_LIRC_BYTES 2
93 /* times to poll per second */
94 #define SAMPLE_RATE 100
95 static int sample_rate
= SAMPLE_RATE
;
98 /**** Igor's USB Request Codes */
100 #define SET_INFRABUFFER_EMPTY 1
106 #define GET_INFRACODE 2
109 * wValue: offset to begin reading infra buffer
114 #define SET_DATAPORT_DIRECTION 3
117 * wValue: (byte) 1 bit for each data port pin (0=in, 1=out)
122 #define GET_DATAPORT_DIRECTION 4
126 * Answer: (byte) 1 bit for each data port pin (0=in, 1=out)
129 #define SET_OUT_DATAPORT 5
132 * wValue: byte to write to output data port
137 #define GET_OUT_DATAPORT 6
141 * Answer: least significant 3 bits read from output data port
144 #define GET_IN_DATAPORT 7
148 * Answer: least significant 3 bits read from input data port
151 #define READ_EEPROM 8
154 * wValue: offset to begin reading EEPROM
156 * Answer: EEPROM bytes
159 #define WRITE_EEPROM 9
162 * wValue: offset to EEPROM byte
163 * wIndex: byte to write
168 #define SEND_RS232 10
171 * wValue: byte to send
176 #define RECV_RS232 11
180 * Answer: byte received
183 #define SET_RS232_BAUD 12
186 * wValue: byte to write to UART bit rate register (UBRR)
191 #define GET_RS232_BAUD 13
195 * Answer: byte read from UART bit rate register (UBRR)
199 /* data structure for each usb remote */
203 struct usb_device
*usbdev
;
206 unsigned char *buf_in
;
209 struct timeval last_time
;
214 struct lirc_driver
*d
;
216 /* handle sending (init strings) */
220 static int unregister_from_lirc(struct igorplug
*ir
)
222 struct lirc_driver
*d
;
226 printk(KERN_ERR
"%s: called with NULL device struct!\n",
235 printk(KERN_ERR
"%s: called with NULL lirc driver struct!\n",
240 dprintk(DRIVER_NAME
"[%d]: calling lirc_unregister_driver\n", devnum
);
241 lirc_unregister_driver(d
->minor
);
250 static int set_use_inc(void *data
)
252 struct igorplug
*ir
= data
;
255 printk(DRIVER_NAME
"[?]: set_use_inc called with no context\n");
259 dprintk(DRIVER_NAME
"[%d]: set use inc\n", ir
->devnum
);
267 static void set_use_dec(void *data
)
269 struct igorplug
*ir
= data
;
272 printk(DRIVER_NAME
"[?]: set_use_dec called with no context\n");
276 dprintk(DRIVER_NAME
"[%d]: set use dec\n", ir
->devnum
);
279 static void send_fragment(struct igorplug
*ir
, struct lirc_buffer
*buf
,
284 /* MODE2: pulse/space (PULSE_BIT) in 1us units */
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
;
292 lirc_buffer_write(buf
, (unsigned char *)&code
);
293 /* 1 chunk = CODE_LENGTH bytes */
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
305 static int igorplugusb_remote_poll(void *data
, struct lirc_buffer
*buf
)
308 struct igorplug
*ir
= (struct igorplug
*)data
;
310 if (!ir
|| !ir
->usbdev
) /* Has the device been removed? */
313 memset(ir
->buf_in
, 0, ir
->len_in
);
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
);
324 /* ACK packet has 1 byte --> ignore */
325 if (ret
< DEVICE_HEADERLEN
)
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]);
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
;
337 timediff
+= now
.tv_usec
- ir
->last_time
.tv_usec
;
339 ir
->last_time
.tv_sec
= now
.tv_sec
;
340 ir
->last_time
.tv_usec
= now
.tv_usec
;
342 /* create leading gap */
344 lirc_buffer_write(buf
, (unsigned char *)&code
);
345 ir
->in_space
= 1; /* next comes a pulse */
347 if (ir
->buf_in
[2] == 0)
348 send_fragment(ir
, buf
, DEVICE_HEADERLEN
, ret
);
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]);
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
);
370 printk(DRIVER_NAME
"[%d]: SET_INFRABUFFER_EMPTY: "
371 "error %d\n", ir
->devnum
, ret
);
374 printk(DRIVER_NAME
"[%d]: GET_INFRACODE: error %d\n",
382 static int igorplugusb_remote_probe(struct usb_interface
*intf
,
383 const struct usb_device_id
*id
)
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
;
392 char buf
[63], name
[128] = "";
396 dprintk(DRIVER_NAME
": usb probe called.\n");
398 dev
= interface_to_usbdev(intf
);
400 idesc
= intf
->cur_altsetting
;
402 if (idesc
->desc
.bNumEndpoints
!= 1)
405 ep
= &idesc
->endpoint
->desc
;
406 if (((ep
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
408 || (ep
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
409 != USB_ENDPOINT_XFER_CONTROL
)
412 pipe
= usb_rcvctrlpipe(dev
, ep
->bEndpointAddress
);
413 devnum
= dev
->devnum
;
414 maxp
= usb_maxpacket(dev
, pipe
, usb_pipeout(pipe
));
416 dprintk(DRIVER_NAME
"[%d]: bytes_in_key=%zu maxp=%d\n",
417 devnum
, CODE_LENGTH
, maxp
);
420 ir
= kzalloc(sizeof(struct igorplug
), GFP_KERNEL
);
423 goto mem_failure_switch
;
425 driver
= kzalloc(sizeof(struct lirc_driver
), GFP_KERNEL
);
428 goto mem_failure_switch
;
431 ir
->buf_in
= usb_alloc_coherent(dev
, DEVICE_BUFLEN
+ DEVICE_HEADERLEN
,
432 GFP_ATOMIC
, &ir
->dma_in
);
435 goto mem_failure_switch
;
438 strcpy(driver
->name
, DRIVER_NAME
" ");
440 driver
->code_length
= CODE_LENGTH
* 8; /* in bits */
441 driver
->features
= LIRC_CAN_REC_MODE2
;
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
;
452 minor
= lirc_register_driver(driver
);
458 switch (mem_failure
) {
460 usb_free_coherent(dev
, DEVICE_BUFLEN
+ DEVICE_HEADERLEN
,
461 ir
->buf_in
, ir
->dma_in
);
467 printk(DRIVER_NAME
"[%d]: out of memory (code=%d)\n",
468 devnum
, mem_failure
);
472 driver
->minor
= minor
;
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
);
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
),
488 printk(DRIVER_NAME
"[%d]: %s on usb%d:%d\n", devnum
, name
,
489 dev
->bus
->busnum
, devnum
);
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
);
498 printk(DRIVER_NAME
"[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
501 usb_set_intfdata(intf
, ir
);
506 static void igorplugusb_remote_disconnect(struct usb_interface
*intf
)
508 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
509 struct igorplug
*ir
= usb_get_intfdata(intf
);
510 struct device
*dev
= &intf
->dev
;
513 usb_set_intfdata(intf
, NULL
);
520 usb_free_coherent(usbdev
, ir
->len_in
, ir
->buf_in
, ir
->dma_in
);
522 devnum
= unregister_from_lirc(ir
);
524 dev_info(dev
, DRIVER_NAME
"[%d]: %s done\n", devnum
, __func__
);
527 static struct usb_device_id igorplugusb_remote_id_table
[] = {
528 /* Igor Plug USB (Atmel's Manufact. ID) */
529 { USB_DEVICE(0x03eb, 0x0002) },
531 /* Terminating entry */
535 static struct usb_driver igorplugusb_remote_driver
= {
537 .probe
= igorplugusb_remote_probe
,
538 .disconnect
= igorplugusb_remote_disconnect
,
539 .id_table
= igorplugusb_remote_id_table
542 static int __init
igorplugusb_remote_init(void)
546 dprintk(DRIVER_NAME
": loaded, debug mode enabled\n");
548 ret
= usb_register(&igorplugusb_remote_driver
);
550 printk(KERN_ERR DRIVER_NAME
": usb register failed!\n");
555 static void __exit
igorplugusb_remote_exit(void)
557 usb_deregister(&igorplugusb_remote_driver
);
560 module_init(igorplugusb_remote_init
);
561 module_exit(igorplugusb_remote_exit
);
563 #include <linux/vermagic.h>
564 MODULE_INFO(vermagic
, VERMAGIC_STRING
);
566 MODULE_DESCRIPTION(DRIVER_DESC
);
567 MODULE_AUTHOR(DRIVER_AUTHOR
);
568 MODULE_LICENSE("GPL");
569 MODULE_DEVICE_TABLE(usb
, igorplugusb_remote_id_table
);
571 module_param(sample_rate
, int, S_IRUGO
| S_IWUSR
);
572 MODULE_PARM_DESC(sample_rate
, "Sampling rate in Hz (default: 100)");
574 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
575 MODULE_PARM_DESC(debug
, "Debug enabled or not");