static int __init lirc_rpi_init_module(void)
{
int result;
result = lirc_rpi_init();
if (result)
return result;
result = init_port();
if (result < 0)
goto exit_rpi;
driver.features = LIRC_CAN_SET_SEND_DUTY_CYCLE |
LIRC_CAN_SET_SEND_CARRIER |
LIRC_CAN_SEND_PULSE;
driver.dev = &lirc_rpi_dev->dev;
driver.minor = lirc_register_driver(&driver);
if (driver.minor < 0) {
printk(KERN_ERR LIRC_DRIVER_NAME
": device registration failed with %d\n", result);
result = -EIO;
goto exit_rpi;
}
printk(KERN_INFO LIRC_DRIVER_NAME ": driver registered!\n");
return 0;
exit_rpi:
lirc_rpi_exit();
return result;
}
static int __init lirc_bbb_init_module(void)
{
int result, i;
result = lirc_bbb_init();
if (result)
return result;
driver.features = LIRC_CAN_SET_SEND_DUTY_CYCLE |
LIRC_CAN_SET_SEND_CARRIER |
LIRC_CAN_SEND_PULSE |
LIRC_CAN_REC_MODE2;
driver.dev = &lirc_bbb_dev->dev;
driver.minor = lirc_register_driver(&driver);
if (driver.minor < 0) {
printk(KERN_ERR LIRC_DRIVER_NAME
": device registration failed with %d\n", result);
result = -EIO;
goto exit;
}
result = init_port();
if (result < 0)
goto unregister;
return 0;
unregister:
lirc_unregister_driver(driver.minor);
exit:
lirc_bbb_exit();
return result;
}
static int __init lirc_parallel_init(void)
{
pport = parport_find_base(io);
if (pport == NULL) {
printk(KERN_NOTICE "%s: no port at %x found\n",
LIRC_DRIVER_NAME, io);
return -ENXIO;
}
ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
pf, kf, irq_handler, 0, NULL);
parport_put_port(pport);
if (ppdevice == NULL) {
printk(KERN_NOTICE "%s: parport_register_device() failed\n",
LIRC_DRIVER_NAME);
return -ENXIO;
}
if (parport_claim(ppdevice) != 0)
goto skip_init;
is_claimed = 1;
out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);
#ifdef LIRC_TIMER
if (debug)
out(LIRC_PORT_DATA, tx_mask);
timer = init_lirc_timer();
#if 0 /* continue even if device is offline */
if (timer == 0) {
is_claimed = 0;
parport_release(pport);
parport_unregister_device(ppdevice);
return -EIO;
}
#endif
if (debug)
out(LIRC_PORT_DATA, 0);
#endif
is_claimed = 0;
parport_release(ppdevice);
skip_init:
driver.minor = lirc_register_driver(&driver);
if (driver.minor < 0) {
printk(KERN_NOTICE "%s: register_chrdev() failed\n",
LIRC_DRIVER_NAME);
parport_unregister_device(ppdevice);
return -EIO;
}
printk(KERN_INFO "%s: installed using port 0x%04x irq %d\n",
LIRC_DRIVER_NAME, io, irq);
return 0;
}
static int __init lirc_dove_init_module(void)
{
int result;
result = lirc_dove_init();
if (result)
return result;
#if 0
if (!softcarrier) {
switch (type) {
case LIRC_HOMEBREW:
case LIRC_IGOR:
#ifdef CONFIG_LIRC_SERIAL_NSLU2
case LIRC_NSLU2:
#endif
hardware[type].features &=
~(LIRC_CAN_SET_SEND_DUTY_CYCLE|
LIRC_CAN_SET_SEND_CARRIER);
break;
}
}
#endif
result = init_port();
if (result < 0)
goto exit_dove_exit;
driver.features = LIRC_CAN_REC_MODE2;//LIRC_CAN_REC_RAW | LIRC_CAN_REC_PULSE;// FIXME hardware[type].features;
driver.dev = &lirc_dove_dev->dev;
driver.minor = lirc_register_driver(&driver);
if (driver.minor < 0) {
printk(KERN_ERR LIRC_DRIVER_NAME
": register_chrdev failed!\n");
result = -EIO;
goto exit_release;
}
return 0;
exit_release:
//release_region(io, 8);
exit_dove_exit:
lirc_dove_exit();
return result;
}
static int lirc_rx51_probe(struct platform_device *dev)
{
lirc_rx51_driver.features = LIRC_RX51_DRIVER_FEATURES;
lirc_rx51.pdata = dev->dev.platform_data;
lirc_rx51.pwm_timer_num = lirc_rx51.pdata->pwm_timer;
lirc_rx51.dev = &dev->dev;
lirc_rx51_driver.dev = &dev->dev;
lirc_rx51_driver.minor = lirc_register_driver(&lirc_rx51_driver);
init_waitqueue_head(&lirc_rx51.wqueue);
if (lirc_rx51_driver.minor < 0) {
dev_err(lirc_rx51.dev, ": lirc_register_driver failed: %d\n",
lirc_rx51_driver.minor);
return lirc_rx51_driver.minor;
}
dev_info(lirc_rx51.dev, "registration ok, minor: %d, pwm: %d\n",
lirc_rx51_driver.minor, lirc_rx51.pwm_timer_num);
return 0;
}
static int __init lirc_parallel_init(void)
{
int result;
result = platform_driver_register(&lirc_parallel_driver);
if (result) {
pr_notice("platform_driver_register returned %d\n", result);
return result;
}
lirc_parallel_dev = platform_device_alloc(LIRC_DRIVER_NAME, 0);
if (!lirc_parallel_dev) {
result = -ENOMEM;
goto exit_driver_unregister;
}
result = platform_device_add(lirc_parallel_dev);
if (result)
goto exit_device_put;
pport = parport_find_base(io);
if (pport == NULL) {
pr_notice("no port at %x found\n", io);
result = -ENXIO;
goto exit_device_put;
}
ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME,
pf, kf, lirc_lirc_irq_handler, 0,
NULL);
parport_put_port(pport);
if (ppdevice == NULL) {
pr_notice("parport_register_device() failed\n");
result = -ENXIO;
goto exit_device_put;
}
if (parport_claim(ppdevice) != 0)
goto skip_init;
is_claimed = 1;
out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP);
#ifdef LIRC_TIMER
if (debug)
out(LIRC_PORT_DATA, tx_mask);
timer = init_lirc_timer();
#if 0 /* continue even if device is offline */
if (timer == 0) {
is_claimed = 0;
parport_release(pport);
parport_unregister_device(ppdevice);
result = -EIO;
goto exit_device_put;
}
#endif
if (debug)
out(LIRC_PORT_DATA, 0);
#endif
is_claimed = 0;
parport_release(ppdevice);
skip_init:
driver.dev = &lirc_parallel_dev->dev;
driver.minor = lirc_register_driver(&driver);
if (driver.minor < 0) {
pr_notice("register_chrdev() failed\n");
parport_unregister_device(ppdevice);
result = -EIO;
goto exit_device_put;
}
pr_info("installed using port 0x%04x irq %d\n", io, irq);
return 0;
exit_device_put:
platform_device_put(lirc_parallel_dev);
exit_driver_unregister:
platform_driver_unregister(&lirc_parallel_driver);
return result;
}
static int ir_lirc_register(struct rc_dev *dev)
{
struct lirc_driver *drv;
struct lirc_buffer *rbuf;
int rc = -ENOMEM;
unsigned long features;
drv = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
if (!drv)
return rc;
rbuf = kzalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
if (!rbuf)
goto rbuf_alloc_failed;
rc = lirc_buffer_init(rbuf, sizeof(int), LIRCBUF_SIZE);
if (rc)
goto rbuf_init_failed;
features = LIRC_CAN_REC_MODE2;
if (dev->tx_ir) {
features |= LIRC_CAN_SEND_PULSE;
if (dev->s_tx_mask)
features |= LIRC_CAN_SET_TRANSMITTER_MASK;
if (dev->s_tx_carrier)
features |= LIRC_CAN_SET_SEND_CARRIER;
if (dev->s_tx_duty_cycle)
features |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
}
if (dev->s_rx_carrier_range)
features |= LIRC_CAN_SET_REC_CARRIER |
LIRC_CAN_SET_REC_CARRIER_RANGE;
if (dev->s_learning_mode)
features |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
if (dev->s_carrier_report)
features |= LIRC_CAN_MEASURE_CARRIER;
if (dev->max_timeout)
features |= LIRC_CAN_SET_REC_TIMEOUT;
snprintf(drv->name, sizeof(drv->name), "ir-lirc-codec (%s)",
dev->driver_name);
drv->minor = -1;
drv->features = features;
drv->data = &dev->raw->lirc;
drv->rbuf = rbuf;
drv->set_use_inc = &ir_lirc_open;
drv->set_use_dec = &ir_lirc_close;
drv->code_length = sizeof(struct ir_raw_event) * 8;
drv->fops = &lirc_fops;
drv->dev = &dev->dev;
drv->owner = THIS_MODULE;
drv->minor = lirc_register_driver(drv);
if (drv->minor < 0) {
rc = -ENODEV;
goto lirc_register_failed;
}
dev->raw->lirc.drv = drv;
dev->raw->lirc.dev = dev;
return 0;
lirc_register_failed:
rbuf_init_failed:
kfree(rbuf);
rbuf_alloc_failed:
kfree(drv);
return rc;
}
static int igorplugusb_remote_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev;
struct usb_host_interface *idesc = NULL;
struct usb_endpoint_descriptor *ep;
struct igorplug *ir = NULL;
struct lirc_driver *driver = NULL;
int devnum, pipe, maxp;
char buf[63], name[128] = "";
int ret;
dprintk(DRIVER_NAME ": usb probe called.\n");
dev = interface_to_usbdev(intf);
idesc = intf->cur_altsetting;
if (idesc->desc.bNumEndpoints != 1)
return -ENODEV;
ep = &idesc->endpoint->desc;
if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
!= USB_DIR_IN)
|| (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
!= USB_ENDPOINT_XFER_CONTROL)
return -ENODEV;
pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);
devnum = dev->devnum;
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d\n",
devnum, CODE_LENGTH, maxp);
ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
if (!ir)
return -ENOMEM;
driver = devm_kzalloc(&intf->dev, sizeof(*driver), GFP_KERNEL);
if (!driver)
return -ENOMEM;
ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
GFP_ATOMIC, &ir->dma_in);
if (!ir->buf_in)
return -ENOMEM;
strcpy(driver->name, DRIVER_NAME " ");
driver->minor = -1;
driver->code_length = CODE_LENGTH * 8; /* in bits */
driver->features = LIRC_CAN_REC_MODE2;
driver->data = ir;
driver->chunk_size = CODE_LENGTH;
driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
driver->set_use_inc = &set_use_inc;
driver->set_use_dec = &set_use_dec;
driver->sample_rate = sample_rate; /* per second */
driver->add_to_buf = &igorplugusb_remote_poll;
driver->dev = &intf->dev;
driver->owner = THIS_MODULE;
ret = lirc_register_driver(driver);
if (ret < 0) {
usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
ir->buf_in, ir->dma_in);
return ret;
}
driver->minor = ret;
ir->d = driver;
ir->devnum = devnum;
ir->usbdev = dev;
ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;
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, sizeof(buf)) > 0)
strlcpy(name, buf, sizeof(name));
if (dev->descriptor.iProduct
&& usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
snprintf(name + strlen(name), sizeof(name) - strlen(name),
" %s", buf);
printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
dev->bus->busnum, devnum);
/* clear device buffer */
ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
/*unused*/0, /*unused*/0,
/*dummy*/ir->buf_in, /*dummy*/ir->len_in,
/*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
if (ret < 0)
printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
devnum, ret);
usb_set_intfdata(intf, ir);
return 0;
}
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;
#else
static void *usb_remote_probe(struct usb_device *dev, unsigned int ifnum,
const struct usb_device_id *id)
{
struct usb_interface *intf;
struct usb_interface_descriptor *idesc;
struct usb_endpoint_descriptor *ep_ctl2;
#endif
struct igorplug *ir = NULL;
struct lirc_driver *driver = NULL;
int devnum, pipe, maxp;
int minor = 0;
char buf[63], name[128] = "";
int mem_failure = 0;
int ret;
dprintk(": usb probe called.\n");
#if defined(KERNEL_2_5)
dev = interface_to_usbdev(intf);
# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 5)
idesc = &intf->altsetting[intf->act_altsetting]; /* in 2.6.4 */
# else
idesc = intf->cur_altsetting; /* in 2.6.6 */
# endif
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);
#else
intf = &dev->actconfig->interface[ifnum];
idesc = &intf->altsetting[intf->act_altsetting];
if (idesc->bNumEndpoints != 1)
return NULL;
ep_ctl2 = idesc->endpoint;
if (((ep_ctl2->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
!= USB_DIR_IN)
|| (ep_ctl2->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
!= USB_ENDPOINT_XFER_CONTROL)
return NULL;
pipe = usb_rcvctrlpipe(dev, ep_ctl2->bEndpointAddress);
#endif
devnum = dev->devnum;
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
dprintk(DRIVER_NAME "[%d]: bytes_in_key=%d maxp=%d\n",
devnum, CODE_LENGTH, maxp);
mem_failure = 0;
ir = kzalloc(sizeof(struct igorplug), GFP_KERNEL);
if (!ir) {
mem_failure = 1;
goto mem_failure_switch;
}
driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
if (!driver) {
mem_failure = 2;
goto mem_failure_switch;
}
#if defined(KERNEL_2_5)
ir->buf_in = usb_buffer_alloc(dev,
DEVICE_BUFLEN+DEVICE_HEADERLEN,
GFP_ATOMIC, &ir->dma_in);
#else
ir->buf_in = kmalloc(DEVICE_BUFLEN+DEVICE_HEADERLEN,
GFP_KERNEL);
#endif
if (!ir->buf_in) {
mem_failure = 3;
goto mem_failure_switch;
}
strcpy(driver->name, DRIVER_NAME " ");
driver->minor = -1;
driver->code_length = CODE_LENGTH * 8; /* in bits */
driver->features = LIRC_CAN_REC_MODE2;
driver->data = ir;
driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
driver->set_use_inc = &set_use_inc;
driver->set_use_dec = &set_use_dec;
driver->sample_rate = sample_rate; /* per second */
driver->add_to_buf = &usb_remote_poll;
#ifdef LIRC_HAVE_SYSFS
driver->dev = &intf->dev;
#endif
driver->owner = THIS_MODULE;
minor = lirc_register_driver(driver);
if (minor < 0)
mem_failure = 9;
mem_failure_switch:
switch (mem_failure) {
case 9:
#if defined(KERNEL_2_5)
usb_buffer_free(dev, DEVICE_BUFLEN+DEVICE_HEADERLEN,
ir->buf_in, ir->dma_in);
#else
kfree(ir->buf_in);
#endif
case 3:
kfree(driver);
case 2:
kfree(ir);
case 1:
printk(KERN_ERR DRIVER_NAME "[%d]: out of memory (code=%d)\n",
devnum, mem_failure);
#if defined(KERNEL_2_5)
return -ENOMEM;
#else
return NULL;
#endif
}
driver->minor = minor;
ir->d = driver;
ir->devnum = devnum;
ir->usbdev = dev;
ir->len_in = DEVICE_BUFLEN+DEVICE_HEADERLEN;
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, sizeof(buf)) > 0)
strlcpy(name, buf, sizeof(name));
if (dev->descriptor.iProduct
&& usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
snprintf(name + strlen(name), sizeof(name) - strlen(name),
" %s", buf);
printk(KERN_INFO DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
dev->bus->busnum, devnum);
/* clear device buffer */
ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
/*unused*/0, /*unused*/0,
/*dummy*/ir->buf_in, /*dummy*/ir->len_in,
/*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
if (ret < 0)
printk(KERN_WARNING DRIVER_NAME
"[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
devnum, ret);
#if defined(KERNEL_2_5)
usb_set_intfdata(intf, ir);
return 0;
#else
return ir;
#endif
}
#if defined(KERNEL_2_5)
static void usb_remote_disconnect(struct usb_interface *intf)
{
struct usb_device *dev = interface_to_usbdev(intf);
struct igorplug *ir = usb_get_intfdata(intf);
#else
static void usb_remote_disconnect(struct usb_device *dev, void *ptr)
{
struct igorplug *ir = ptr;
#endif
if (!ir || !ir->d)
return;
printk(KERN_INFO DRIVER_NAME
"[%d]: usb remote disconnected\n", ir->devnum);
lirc_unregister_driver(ir->d->minor);
lirc_buffer_free(ir->d->rbuf);
kfree(ir->d->rbuf);
kfree(ir->d);
#if defined(KERNEL_2_5)
usb_buffer_free(dev, ir->len_in, ir->buf_in, ir->dma_in);
#else
kfree(ir->buf_in);
#endif
kfree(ir);
}
static struct usb_device_id usb_remote_id_table [] = {
/* Igor Plug USB (Atmel's Manufact. ID) */
{ USB_DEVICE(0x03eb, 0x0002) },
/* Fit PC2 Infrared Adapter */
{ 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 DRIVER_NAME ": " DRIVER_DESC " v" DRIVER_VERSION "\n");
printk(KERN_INFO DRIVER_NAME ": " DRIVER_AUTHOR "\n");
dprintk(": debug mode enabled\n");
i = usb_register(&usb_remote_driver);
if (i < 0) {
printk(KERN_ERR DRIVER_NAME
": usb register failed, result = %d\n", i);
return -ENODEV;
}
return 0;
}
/*
* Called whenever the USB subsystem thinks we could be the right driver
* to handle this device
*/
static int probe(struct usb_interface *intf, const struct usb_device_id *id)
{
int alt_set, endp;
int found = 0;
int i, j;
int struct_size;
struct usb_host_interface *host_interf;
struct usb_interface_descriptor *interf_desc;
struct usb_host_endpoint *host_endpoint;
struct ttusbir_device *ttusbir;
DPRINTK("Module ttusbir probe\n");
/* To reduce memory fragmentation we use only one allocation */
struct_size = sizeof(struct ttusbir_device) +
(sizeof(struct urb *) * num_urbs) +
(sizeof(char *) * num_urbs) +
(num_urbs * 128);
ttusbir = kzalloc(struct_size, GFP_KERNEL);
if (!ttusbir)
return -ENOMEM;
ttusbir->urb = (struct urb **)((char *)ttusbir +
sizeof(struct ttusbir_device));
ttusbir->buffer = (char **)((char *)ttusbir->urb +
(sizeof(struct urb *) * num_urbs));
for (i = 0; i < num_urbs; i++)
ttusbir->buffer[i] = (char *)ttusbir->buffer +
(sizeof(char *)*num_urbs) + (i * 128);
ttusbir->usb_driver = &usb_driver;
ttusbir->alt_setting = -1;
/* @TODO check if error can be returned */
ttusbir->udev = usb_get_dev(interface_to_usbdev(intf));
ttusbir->interf = intf;
ttusbir->last_pulse = 0x00;
ttusbir->last_num = 0;
/*
* Now look for interface setting we can handle
* We are searching for the alt setting where end point
* 0x82 has max packet size 16
*/
for (alt_set = 0; alt_set < intf->num_altsetting && !found; alt_set++) {
host_interf = &intf->altsetting[alt_set];
interf_desc = &host_interf->desc;
for (endp = 0; endp < interf_desc->bNumEndpoints; endp++) {
host_endpoint = &host_interf->endpoint[endp];
if ((host_endpoint->desc.bEndpointAddress == 0x82) &&
(host_endpoint->desc.wMaxPacketSize == 0x10)) {
ttusbir->alt_setting = alt_set;
ttusbir->endpoint = endp;
found = 1;
break;
}
}
}
if (ttusbir->alt_setting != -1)
DPRINTK("alt setting: %d\n", ttusbir->alt_setting);
else {
err("Could not find alternate setting\n");
kfree(ttusbir);
return -EINVAL;
}
/* OK lets setup this interface setting */
usb_set_interface(ttusbir->udev, 0, ttusbir->alt_setting);
/* Store device info in interface structure */
usb_set_intfdata(intf, ttusbir);
/* Register as a LIRC driver */
if (lirc_buffer_init(&ttusbir->rbuf, sizeof(lirc_t), 256) < 0) {
err("Could not get memory for LIRC data buffer\n");
usb_set_intfdata(intf, NULL);
kfree(ttusbir);
return -ENOMEM;
}
strcpy(ttusbir->driver.name, "TTUSBIR");
ttusbir->driver.minor = -1;
ttusbir->driver.code_length = 1;
ttusbir->driver.sample_rate = 0;
ttusbir->driver.data = ttusbir;
ttusbir->driver.add_to_buf = NULL;
ttusbir->driver.rbuf = &ttusbir->rbuf;
ttusbir->driver.set_use_inc = set_use_inc;
ttusbir->driver.set_use_dec = set_use_dec;
ttusbir->driver.fops = NULL;
ttusbir->driver.dev = &intf->dev;
ttusbir->driver.owner = THIS_MODULE;
ttusbir->driver.features = LIRC_CAN_REC_MODE2;
ttusbir->minor = lirc_register_driver(&ttusbir->driver);
if (ttusbir->minor < 0) {
err("Error registering as LIRC driver\n");
usb_set_intfdata(intf, NULL);
lirc_buffer_free(&ttusbir->rbuf);
kfree(ttusbir);
return -EIO;
}
/* Allocate and setup the URB that we will use to talk to the device */
for (i = 0; i < num_urbs; i++) {
ttusbir->urb[i] = usb_alloc_urb(8, GFP_KERNEL);
if (!ttusbir->urb[i]) {
err("Could not allocate memory for the URB\n");
for (j = i - 1; j >= 0; j--)
kfree(ttusbir->urb[j]);
lirc_buffer_free(&ttusbir->rbuf);
lirc_unregister_driver(ttusbir->minor);
kfree(ttusbir);
usb_set_intfdata(intf, NULL);
return -ENOMEM;
}
ttusbir->urb[i]->dev = ttusbir->udev;
ttusbir->urb[i]->context = ttusbir;
ttusbir->urb[i]->pipe = usb_rcvisocpipe(ttusbir->udev,
ttusbir->endpoint);
ttusbir->urb[i]->interval = 1;
ttusbir->urb[i]->transfer_flags = URB_ISO_ASAP;
ttusbir->urb[i]->transfer_buffer = &ttusbir->buffer[i][0];
ttusbir->urb[i]->complete = urb_complete;
ttusbir->urb[i]->number_of_packets = 8;
ttusbir->urb[i]->transfer_buffer_length = 128;
for (j = 0; j < 8; j++) {
ttusbir->urb[i]->iso_frame_desc[j].offset = j*16;
ttusbir->urb[i]->iso_frame_desc[j].length = 16;
}
}
return 0;
}
