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.1"
58 #define DRIVER_AUTHOR \
59 "Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>"
60 #define DRIVER_DESC "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
;
207 unsigned char *buf_in
;
210 struct timeval last_time
;
215 struct lirc_driver
*d
;
217 /* handle sending (init strings) */
219 wait_queue_head_t wait_out
;
222 static int unregister_from_lirc(struct igorplug
*ir
)
224 struct lirc_driver
*d
= ir
->d
;
231 dprintk(DRIVER_NAME
"[%d]: unregister from lirc called\n", devnum
);
233 lirc_unregister_driver(d
->minor
);
235 printk(DRIVER_NAME
"[%d]: usb remote disconnected\n", devnum
);
243 static int set_use_inc(void *data
)
245 struct igorplug
*ir
= data
;
248 printk(DRIVER_NAME
"[?]: set_use_inc called with no context\n");
251 dprintk(DRIVER_NAME
"[%d]: set use inc\n", ir
->devnum
);
259 static void set_use_dec(void *data
)
261 struct igorplug
*ir
= data
;
264 printk(DRIVER_NAME
"[?]: set_use_dec called with no context\n");
267 dprintk(DRIVER_NAME
"[%d]: set use dec\n", ir
->devnum
);
272 * Called in user context.
273 * return 0 if data was added to the buffer and
274 * -ENODATA if none was available. This should add some number of bits
275 * evenly divisible by code_length to the buffer
277 static int usb_remote_poll(void *data
, struct lirc_buffer
*buf
)
280 struct igorplug
*ir
= (struct igorplug
*)data
;
282 if (!ir
->usbdev
) /* Has the device been removed? */
285 memset(ir
->buf_in
, 0, ir
->len_in
);
287 ret
= usb_control_msg(
288 ir
->usbdev
, usb_rcvctrlpipe(ir
->usbdev
, 0),
289 GET_INFRACODE
, USB_TYPE_VENDOR
|USB_DIR_IN
,
290 0/* offset */, /*unused*/0,
291 ir
->buf_in
, ir
->len_in
,
292 /*timeout*/HZ
* USB_CTRL_GET_TIMEOUT
);
294 int i
= DEVICE_HEADERLEN
;
298 if (ret
<= 1) /* ACK packet has 1 byte --> ignore */
301 dprintk(DRIVER_NAME
": Got %d bytes. Header: %02x %02x %02x\n",
302 ret
, ir
->buf_in
[0], ir
->buf_in
[1], ir
->buf_in
[2]);
304 if (ir
->buf_in
[2] != 0) {
305 printk(DRIVER_NAME
"[%d]: Device buffer overrun.\n",
307 /* start at earliest byte */
308 i
= DEVICE_HEADERLEN
+ ir
->buf_in
[2];
309 /* where are we now? space, gap or pulse? */
312 do_gettimeofday(&now
);
313 timediff
= now
.tv_sec
- ir
->last_time
.tv_sec
;
314 if (timediff
+ 1 > PULSE_MASK
/ 1000000)
315 timediff
= PULSE_MASK
;
318 timediff
+= now
.tv_usec
- ir
->last_time
.tv_usec
;
320 ir
->last_time
.tv_sec
= now
.tv_sec
;
321 ir
->last_time
.tv_usec
= now
.tv_usec
;
323 /* create leading gap */
325 lirc_buffer_write(buf
, (unsigned char *)&code
);
326 ir
->in_space
= 1; /* next comes a pulse */
328 /* MODE2: pulse/space (PULSE_BIT) in 1us units */
331 /* 1 Igor-tick = 85.333333 us */
332 code
= (unsigned int)ir
->buf_in
[i
] * 85
333 + (unsigned int)ir
->buf_in
[i
] / 3;
336 lirc_buffer_write(buf
, (unsigned char *)&code
);
337 /* 1 chunk = CODE_LENGTH bytes */
342 ret
= usb_control_msg(
343 ir
->usbdev
, usb_rcvctrlpipe(ir
->usbdev
, 0),
344 SET_INFRABUFFER_EMPTY
, USB_TYPE_VENDOR
|USB_DIR_IN
,
345 /*unused*/0, /*unused*/0,
346 /*dummy*/ir
->buf_in
, /*dummy*/ir
->len_in
,
347 /*timeout*/HZ
* USB_CTRL_GET_TIMEOUT
);
349 printk(DRIVER_NAME
"[%d]: SET_INFRABUFFER_EMPTY: "
350 "error %d\n", ir
->devnum
, ret
);
353 printk(DRIVER_NAME
"[%d]: GET_INFRACODE: error %d\n",
361 static int usb_remote_probe(struct usb_interface
*intf
,
362 const struct usb_device_id
*id
)
364 struct usb_device
*dev
= NULL
;
365 struct usb_host_interface
*idesc
= NULL
;
366 struct usb_host_endpoint
*ep_ctl2
;
367 struct igorplug
*ir
= NULL
;
368 struct lirc_driver
*driver
= NULL
;
369 int devnum
, pipe
, maxp
;
371 char buf
[63], name
[128] = "";
375 dprintk(DRIVER_NAME
": usb probe called.\n");
377 dev
= interface_to_usbdev(intf
);
379 idesc
= intf
->cur_altsetting
;
381 if (idesc
->desc
.bNumEndpoints
!= 1)
383 ep_ctl2
= idesc
->endpoint
;
384 if (((ep_ctl2
->desc
.bEndpointAddress
& USB_ENDPOINT_DIR_MASK
)
386 || (ep_ctl2
->desc
.bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
387 != USB_ENDPOINT_XFER_CONTROL
)
389 pipe
= usb_rcvctrlpipe(dev
, ep_ctl2
->desc
.bEndpointAddress
);
390 devnum
= dev
->devnum
;
391 maxp
= usb_maxpacket(dev
, pipe
, usb_pipeout(pipe
));
393 dprintk(DRIVER_NAME
"[%d]: bytes_in_key=%lu maxp=%d\n",
394 devnum
, CODE_LENGTH
, maxp
);
398 ir
= kzalloc(sizeof(struct igorplug
), GFP_KERNEL
);
401 goto mem_failure_switch
;
403 driver
= kzalloc(sizeof(struct lirc_driver
), GFP_KERNEL
);
406 goto mem_failure_switch
;
409 ir
->buf_in
= usb_alloc_coherent(dev
,
410 DEVICE_BUFLEN
+DEVICE_HEADERLEN
,
411 GFP_ATOMIC
, &ir
->dma_in
);
414 goto mem_failure_switch
;
417 strcpy(driver
->name
, DRIVER_NAME
" ");
419 driver
->code_length
= CODE_LENGTH
* 8; /* in bits */
420 driver
->features
= LIRC_CAN_REC_MODE2
;
422 driver
->chunk_size
= CODE_LENGTH
;
423 driver
->buffer_size
= DEVICE_BUFLEN
+ ADDITIONAL_LIRC_BYTES
;
424 driver
->set_use_inc
= &set_use_inc
;
425 driver
->set_use_dec
= &set_use_dec
;
426 driver
->sample_rate
= sample_rate
; /* per second */
427 driver
->add_to_buf
= &usb_remote_poll
;
428 driver
->dev
= &intf
->dev
;
429 driver
->owner
= THIS_MODULE
;
431 init_waitqueue_head(&ir
->wait_out
);
433 minor
= lirc_register_driver(driver
);
439 switch (mem_failure
) {
441 usb_free_coherent(dev
, DEVICE_BUFLEN
+DEVICE_HEADERLEN
,
442 ir
->buf_in
, ir
->dma_in
);
448 printk(DRIVER_NAME
"[%d]: out of memory (code=%d)\n",
449 devnum
, mem_failure
);
453 driver
->minor
= minor
;
457 ir
->len_in
= DEVICE_BUFLEN
+DEVICE_HEADERLEN
;
458 ir
->in_space
= 1; /* First mode2 event is a space. */
459 do_gettimeofday(&ir
->last_time
);
461 if (dev
->descriptor
.iManufacturer
462 && usb_string(dev
, dev
->descriptor
.iManufacturer
,
463 buf
, sizeof(buf
)) > 0)
464 strlcpy(name
, buf
, sizeof(name
));
465 if (dev
->descriptor
.iProduct
466 && usb_string(dev
, dev
->descriptor
.iProduct
, buf
, sizeof(buf
)) > 0)
467 snprintf(name
+ strlen(name
), sizeof(name
) - strlen(name
),
469 printk(DRIVER_NAME
"[%d]: %s on usb%d:%d\n", devnum
, name
,
470 dev
->bus
->busnum
, devnum
);
472 /* clear device buffer */
473 ret
= usb_control_msg(ir
->usbdev
, usb_rcvctrlpipe(ir
->usbdev
, 0),
474 SET_INFRABUFFER_EMPTY
, USB_TYPE_VENDOR
|USB_DIR_IN
,
475 /*unused*/0, /*unused*/0,
476 /*dummy*/ir
->buf_in
, /*dummy*/ir
->len_in
,
477 /*timeout*/HZ
* USB_CTRL_GET_TIMEOUT
);
479 printk(DRIVER_NAME
"[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
482 usb_set_intfdata(intf
, ir
);
487 static void usb_remote_disconnect(struct usb_interface
*intf
)
489 struct usb_device
*dev
= interface_to_usbdev(intf
);
490 struct igorplug
*ir
= usb_get_intfdata(intf
);
491 usb_set_intfdata(intf
, NULL
);
497 wake_up_all(&ir
->wait_out
);
499 usb_free_coherent(dev
, ir
->len_in
, ir
->buf_in
, ir
->dma_in
);
501 unregister_from_lirc(ir
);
504 static struct usb_device_id usb_remote_id_table
[] = {
505 /* Igor Plug USB (Atmel's Manufact. ID) */
506 { USB_DEVICE(0x03eb, 0x0002) },
508 /* Terminating entry */
512 static struct usb_driver usb_remote_driver
= {
514 .probe
= usb_remote_probe
,
515 .disconnect
= usb_remote_disconnect
,
516 .id_table
= usb_remote_id_table
519 static int __init
usb_remote_init(void)
523 printk(KERN_INFO
"\n"
524 DRIVER_NAME
": " DRIVER_DESC
" v" DRIVER_VERSION
"\n");
525 printk(DRIVER_NAME
": " DRIVER_AUTHOR
"\n");
526 dprintk(DRIVER_NAME
": debug mode enabled\n");
528 i
= usb_register(&usb_remote_driver
);
530 printk(DRIVER_NAME
": usb register failed, result = %d\n", i
);
537 static void __exit
usb_remote_exit(void)
539 usb_deregister(&usb_remote_driver
);
542 module_init(usb_remote_init
);
543 module_exit(usb_remote_exit
);
545 #include <linux/vermagic.h>
546 MODULE_INFO(vermagic
, VERMAGIC_STRING
);
548 MODULE_DESCRIPTION(DRIVER_DESC
);
549 MODULE_AUTHOR(DRIVER_AUTHOR
);
550 MODULE_LICENSE("GPL");
551 MODULE_DEVICE_TABLE(usb
, usb_remote_id_table
);
553 module_param(sample_rate
, int, S_IRUGO
| S_IWUSR
);
554 MODULE_PARM_DESC(sample_rate
, "Sampling rate in Hz (default: 100)");