Denis at 15:39, 16 July 2009

2009-07-16T15:39:36Z

New page

This is a driver module for '''Infrared Receiver IgprPlug-USB (AVR)''':

<pre>
/* lirc_igorplugusb - USB remote support for LIRC
*
* Supports the standard homebrew IgorPlugUSB receiver with Igor's firmware.
*
* The device can only record bursts of up to 36 pulses/spaces.
* Works fine with RC5.
* (Maybe a better firmware or a microcontroller with more ram can help?)
*
*
* Changelog:
* Denis Turischev <denis@compulab.co.il>
* 23.06.09 - Added circular buffer reading
*
* 2004 Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>
*
* This driver was derived from:
* Paul Miller <pmiller9@users.sourceforge.net>
* "lirc_atiusb" module
* Vladimir Dergachev <volodya@minspring.com>'s 2002
* "USB ATI Remote support" (input device)
* Adrian Dewhurst <sailor-lk@sailorfrag.net>'s 2002
* "USB StreamZap remote driver" (LIRC)
* Artur Lipowski <alipowski@kki.net.pl>'s 2002
* "lirc_dev" and "lirc_gpio" LIRC modules
*
*/

/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/

#include <linux/version.h>
#include <linux/autoconf.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kmod.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux/fs.h>
#include <linux/usb.h>
#include <linux/poll.h>
#include <linux/smp_lock.h>
#include <linux/time.h>

#include "kcompat.h"
#include "lirc.h"
#include "lirc_dev/lirc_dev.h"

/* lock irctl structure */
#define IRLOCK down_interruptible(&ir->lock)
#define IRUNLOCK up(&ir->lock)

/* module identification */
#define DRIVER_VERSION "0.1"
#define DRIVER_AUTHOR \
"Jan M. Hochstein <hochstein@algo.informatik.tu-darmstadt.de>"
#define DRIVER_DESC "USB remote driver for LIRC"
#define DRIVER_NAME "lirc_igorplugusb"

/* debugging support */
#ifdef CONFIG_USB_DEBUG
static int debug = 1;
#else
static int debug;
#endif

#define dprintk(fmt, args...) \
do { \
if (debug) \
printk(KERN_DEBUG fmt, ## args); \
} while (0)

/* general constants */
#define SUCCESS 0

/* One mode2 pulse/space has 4 bytes. */
#define CODE_LENGTH sizeof(lirc_t)

/* Igor's firmware cannot record bursts longer than 36. */
#define DEVICE_BUFLEN 36

/** Header at the beginning of the device's buffer:
unsigned char data_length
unsigned char data_start (!=0 means ring-buffer overrun)
unsigned char counter (incremented by each burst)
**/
#define DEVICE_HEADERLEN 3

/* This is for the gap */
#define ADDITIONAL_LIRC_BYTES 2

/* times to poll per second */
#define SAMPLE_RATE 100

static int sample_rate = SAMPLE_RATE;

/**** Igor's USB Request Codes */

#define SET_INFRABUFFER_EMPTY 1
/**
* Params: none
* Answer: empty
*
**/

#define GET_INFRACODE 2
/**
* Params:
* wValue: offset to begin reading infra buffer
*
* Answer: infra data
*
**/

/* data structure for each usb remote */
struct irctl {

/* usb */
struct usb_device *usbdev;
int devnum;

unsigned char *buf_in;
unsigned int len_in;
int in_space;
struct timeval last_time;

dma_addr_t dma_in;

/* lirc */
struct lirc_plugin *p;

/* handle sending (init strings) */
wait_queue_head_t wait_out;

struct semaphore lock;
};

static int unregister_from_lirc(struct irctl *ir)
{
struct lirc_plugin *p = ir->p;
int devnum;

if (!ir->p)
return -EINVAL;

devnum = ir->devnum;
dprintk(DRIVER_NAME "[%d]: unregister from lirc called\n", devnum);

lirc_unregister_plugin(p->minor);

printk(DRIVER_NAME "[%d]: usb remote disconnected\n", devnum);

lirc_buffer_free(p->rbuf);
kfree(p->rbuf);
kfree(p);
kfree(ir);
ir->p = NULL;
return SUCCESS;
}

static int set_use_inc(void *data)
{
struct irctl *ir = data;

if (!ir) {
printk(DRIVER_NAME "[?]: set_use_inc called with no context\n");
return -EIO;
}
dprintk(DRIVER_NAME "[%d]: set use inc\n", ir->devnum);

MOD_INC_USE_COUNT;

if (!ir->usbdev)
return -ENODEV;

return SUCCESS;
}

static void set_use_dec(void *data)
{
struct irctl *ir = data;

if (!ir) {
printk(DRIVER_NAME "[?]: set_use_dec called with no context\n");
return;
}
dprintk(DRIVER_NAME "[%d]: set use dec\n", ir->devnum);

MOD_DEC_USE_COUNT;
}

static void set_infrabuffer_empty(struct irctl *ir){
int ret;
ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR | USB_DIR_IN,
0, 0, ir->buf_in, ir->len_in, HZ * USB_CTRL_GET_TIMEOUT);
if (ret < 0)
printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n", ir->devnum, ret);
}

/**
* Called in user context.
* return 0 if data was added to the buffer and
* -ENODATA if none was available. This should add some number of bits
* evenly divisible by code_length to the buffer
**/
static int usb_remote_poll(void *data, struct lirc_buffer *buf)
{
int ret, bytes_to_read, sequence_number, last_readed_index, i;
struct irctl *ir = (struct irctl *)data;

if (!ir->usbdev) /* Has the device been removed? */
return -ENODEV;

memset(ir->buf_in, 0, DEVICE_HEADERLEN);

ret = usb_control_msg(
ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
GET_INFRACODE, USB_TYPE_VENDOR|USB_DIR_IN,
0/* offset */, /*unused*/0,
ir->buf_in, DEVICE_HEADERLEN,
/*timeout*/HZ * USB_CTRL_GET_TIMEOUT);

if (ret == 1) {
/* ACK packet has 1 byte --> ignore */
return -ENODATA;
}

if (ret != DEVICE_HEADERLEN) {
printk(DRIVER_NAME "[%d]: CORRUPTED HEADER: length = %d\n", ir->devnum, ret);

/* Try to recover from unexpected error */
set_infrabuffer_empty(ir);
ir->in_space = 1;

return -ENODATA;
}

bytes_to_read = ir->buf_in[0];
sequence_number = ir->buf_in[1];
last_readed_index = ir->buf_in[2];

memset(ir->buf_in, 0, ir->len_in);

ret = usb_control_msg( ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
GET_INFRACODE, USB_TYPE_VENDOR | USB_DIR_IN,
DEVICE_HEADERLEN, 0, ir->buf_in, bytes_to_read,HZ * USB_CTRL_GET_TIMEOUT);

if ((ret == bytes_to_read) && (sequence_number != -1)) {
lirc_t code, timediff;
struct timeval now;

do_gettimeofday(&now);
timediff = now.tv_sec - ir->last_time.tv_sec;
if (timediff + 1 > PULSE_MASK / 1000000)
timediff = PULSE_MASK;
else {
timediff *= 1000000;
timediff += now.tv_usec - ir->last_time.tv_usec;
}
ir->last_time.tv_sec = now.tv_sec;
ir->last_time.tv_usec = now.tv_usec;

/* create leading gap */
code = timediff;

lirc_buffer_write_n(buf, (unsigned char *)&code, 1);
ir->in_space = 1; /* next comes a pulse */

/* MODE2: pulse/space (PULSE_BIT) in 1us units */

for(i = last_readed_index; i < bytes_to_read; i++){
/* 1 Igor-tick = 85.333333 us */
code = (unsigned int)ir->buf_in[i] * 85 + (unsigned int)ir->buf_in[i] / 3;
ir->last_time.tv_usec += code;
if (ir->in_space)
code |= PULSE_BIT;
lirc_buffer_write_n(buf, (unsigned char *)&code, 1);
/* 1 chunk = CODE_LENGTH bytes */
ir->in_space ^= 1;
}
for(i = 0; i < last_readed_index - 1; i++){
/* 1 Igor-tick = 85.333333 us */
code = (unsigned int)ir->buf_in[i] * 85 + (unsigned int)ir->buf_in[i] / 3;
ir->last_time.tv_usec += code;
if (ir->in_space)
code |= PULSE_BIT;
lirc_buffer_write_n(buf, (unsigned char *)&code, 1);
/* 1 chunk = CODE_LENGTH bytes */
ir->in_space ^= 1;
}

set_infrabuffer_empty(ir);

return SUCCESS;
} else
printk(DRIVER_NAME "[%d]: GET_INFRACODE: error %d\n", ir->devnum, ret);

return -ENODATA;
}

static int usb_remote_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev = NULL;
struct usb_host_interface *idesc = NULL;
struct usb_host_endpoint *ep_ctl2;

struct irctl *ir = NULL;
struct lirc_plugin *plugin = NULL;
struct lirc_buffer *rbuf = NULL;
int devnum, pipe, maxp, bytes_in_key;
int minor = 0;
char buf[63], name[128] = "";
int mem_failure = 0;

dprintk(DRIVER_NAME ": usb probe called.\n");

dev = interface_to_usbdev(intf);

idesc = intf->cur_altsetting;

if (idesc->desc.bNumEndpoints != 1)
return -ENODEV;
ep_ctl2 = idesc->endpoint;
if (((ep_ctl2->desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK)
!= USB_DIR_IN)
|| (ep_ctl2->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
!= USB_ENDPOINT_XFER_CONTROL)
return -ENODEV;
pipe = usb_rcvctrlpipe(dev, ep_ctl2->desc.bEndpointAddress);

devnum = dev->devnum;
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

bytes_in_key = CODE_LENGTH;

dprintk(DRIVER_NAME "[%d]: bytes_in_key=%d maxp=%d\n",
devnum, bytes_in_key, maxp);

/* allocate kernel memory */
mem_failure = 0;
ir = kmalloc(sizeof(struct irctl), GFP_KERNEL);
if (!ir) {
mem_failure = 1;
goto mem_failure_switch;
}

memset(ir, 0, sizeof(struct irctl));

plugin = kmalloc(sizeof(struct lirc_plugin), GFP_KERNEL);
if (!plugin) {
mem_failure = 2;
goto mem_failure_switch;
}

rbuf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
if (!rbuf) {
mem_failure = 3;
goto mem_failure_switch;
}

if (lirc_buffer_init(rbuf, bytes_in_key,
DEVICE_BUFLEN+ADDITIONAL_LIRC_BYTES)) {
mem_failure = 4;
goto mem_failure_switch;
}

ir->buf_in = usb_buffer_alloc(dev,
DEVICE_BUFLEN,
GFP_ATOMIC, &ir->dma_in);

if (!ir->buf_in) {
mem_failure = 5;
goto mem_failure_switch;
}

memset(plugin, 0, sizeof(struct lirc_plugin));

strcpy(plugin->name, DRIVER_NAME " ");
plugin->minor = -1;
plugin->code_length = bytes_in_key*8; /* in bits */
plugin->features = LIRC_CAN_REC_MODE2;
plugin->data = ir;
plugin->rbuf = rbuf;
plugin->set_use_inc = &set_use_inc;
plugin->set_use_dec = &set_use_dec;
plugin->sample_rate = sample_rate; /* per second */
plugin->add_to_buf = &usb_remote_poll;
#ifdef LIRC_HAVE_SYSFS
plugin->dev = &dev->dev;
#endif
plugin->owner = THIS_MODULE;

init_MUTEX(&ir->lock);
init_waitqueue_head(&ir->wait_out);

minor = lirc_register_plugin(plugin);
if (minor < 0)
mem_failure = 9;

mem_failure_switch:

/* free allocated memory in case of failure */
switch (mem_failure) {
case 9:
usb_buffer_free(dev, DEVICE_BUFLEN,
ir->buf_in, ir->dma_in);

case 5:
lirc_buffer_free(rbuf);
case 4:
kfree(rbuf);
case 3:
kfree(plugin);
case 2:
kfree(ir);
case 1:
printk(DRIVER_NAME "[%d]: out of memory (code=%d)\n",devnum, mem_failure);
return -ENOMEM;
}

plugin->minor = minor;
ir->p = plugin;
ir->devnum = devnum;
ir->usbdev = dev;
ir->len_in = DEVICE_BUFLEN;
ir->in_space = 1; /* First mode2 event is a space. */
do_gettimeofday(&ir->last_time);

if (dev->descriptor.iManufacturer
&& usb_string(dev, dev->descriptor.iManufacturer, buf, 63) > 0)
strncpy(name, buf, 128);
if (dev->descriptor.iProduct
&& usb_string(dev, dev->descriptor.iProduct, buf, 63) > 0)
snprintf(name, 128, "%s %s", name, buf);
printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
dev->bus->busnum, devnum);

set_infrabuffer_empty(ir);

usb_set_intfdata(intf, ir);
return SUCCESS;
}

static void usb_remote_disconnect(struct usb_interface *intf)
{
struct usb_device *dev = interface_to_usbdev(intf);
struct irctl *ir = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);

if (!ir || !ir->p)
return;

ir->usbdev = NULL;
wake_up_all(&ir->wait_out);

IRLOCK;
usb_buffer_free(dev, ir->len_in, ir->buf_in, ir->dma_in);
IRUNLOCK;

unregister_from_lirc(ir);
}

static struct usb_device_id usb_remote_id_table [] = {
/* Igor Plug USB (Atmel's Manufact. ID) */
{ USB_DEVICE(0x03eb, 0x0002) },
{ USB_DEVICE(0x03eb, 0x21fe) },
/* Terminating entry */
{ }
};

static struct usb_driver usb_remote_driver = {
LIRC_THIS_MODULE(.owner = THIS_MODULE)
.name = DRIVER_NAME,
.probe = usb_remote_probe,
.disconnect = usb_remote_disconnect,
.id_table = usb_remote_id_table
};

static int __init usb_remote_init(void)
{
int i;

printk(KERN_INFO "\n"
DRIVER_NAME ": " DRIVER_DESC " v" DRIVER_VERSION "\n");
printk(DRIVER_NAME ": " DRIVER_AUTHOR "\n");
dprintk(DRIVER_NAME ": debug mode enabled\n");

request_module("lirc_dev");

i = usb_register(&usb_remote_driver);
if (i < 0) {
printk(DRIVER_NAME ": usb register failed, result = %d\n", i);
return -ENODEV;
}

return SUCCESS;
}

static void __exit usb_remote_exit(void)
{
usb_deregister(&usb_remote_driver);
}

module_init(usb_remote_init);
module_exit(usb_remote_exit);

#include <linux/vermagic.h>
MODULE_INFO(vermagic, VERMAGIC_STRING);

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(usb, usb_remote_id_table);

module_param(sample_rate, int, 0644);
MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");

EXPORT_NO_SYMBOLS;

</pre>

Lirc igorplugusb.c - Revision history

Denis at 15:39, 16 July 2009