drivers/staging/media/lirc/lirc_igorplugusb.c

   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 bool debug = 1;
  66 #else
  67 static bool 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                 dev_err(&ir->usbdev->dev,
 227                         "%s: called with NULL device struct!\n", __func__);
 228                 return -EINVAL;
 229         }
 230
 231         devnum = ir->devnum;
 232         d = ir->d;
 233
 234         if (!d) {
 235                 dev_err(&ir->usbdev->dev,
 236                         "%s: called with NULL lirc driver struct!\n", __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         return devnum;
 244 }
 245
 246 static int set_use_inc(void *data)
 247 {
 248         struct igorplug *ir = data;
 249
 250         if (!ir) {
 251                 printk(DRIVER_NAME "[?]: set_use_inc called with no context\n");
 252                 return -EIO;
 253         }
 254
 255         dprintk(DRIVER_NAME "[%d]: set use inc\n", ir->devnum);
 256
 257         if (!ir->usbdev)
 258                 return -ENODEV;
 259
 260         return 0;
 261 }
 262
 263 static void set_use_dec(void *data)
 264 {
 265         struct igorplug *ir = data;
 266
 267         if (!ir) {
 268                 printk(DRIVER_NAME "[?]: set_use_dec called with no context\n");
 269                 return;
 270         }
 271
 272         dprintk(DRIVER_NAME "[%d]: set use dec\n", ir->devnum);
 273 }
 274
 275 static void send_fragment(struct igorplug *ir, struct lirc_buffer *buf,
 276                            int i, int max)
 277 {
 278         int code;
 279
 280         /* MODE2: pulse/space (PULSE_BIT) in 1us units */
 281         while (i < max) {
 282                 /* 1 Igor-tick = 85.333333 us */
 283                 code = (unsigned int)ir->buf_in[i] * 85 +
 284                         (unsigned int)ir->buf_in[i] / 3;
 285                 ir->last_time.tv_usec += code;
 286                 if (ir->in_space)
 287                         code |= PULSE_BIT;
 288                 lirc_buffer_write(buf, (unsigned char *)&code);
 289                 /* 1 chunk = CODE_LENGTH bytes */
 290                 ir->in_space ^= 1;
 291                 ++i;
 292         }
 293 }
 294
 295 /**
 296  * Called in user context.
 297  * return 0 if data was added to the buffer and
 298  * -ENODATA if none was available. This should add some number of bits
 299  * evenly divisible by code_length to the buffer
 300  */
 301 static int igorplugusb_remote_poll(void *data, struct lirc_buffer *buf)
 302 {
 303         int ret;
 304         struct igorplug *ir = (struct igorplug *)data;
 305
 306         if (!ir || !ir->usbdev)  /* Has the device been removed? */
 307                 return -ENODEV;
 308
 309         memset(ir->buf_in, 0, ir->len_in);
 310
 311         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
 312                               GET_INFRACODE, USB_TYPE_VENDOR | USB_DIR_IN,
 313                               0/* offset */, /*unused*/0,
 314                               ir->buf_in, ir->len_in,
 315                               /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
 316         if (ret > 0) {
 317                 int code, timediff;
 318                 struct timeval now;
 319
 320                 /* ACK packet has 1 byte --> ignore */
 321                 if (ret < DEVICE_HEADERLEN)
 322                         return -ENODATA;
 323
 324                 dprintk(DRIVER_NAME ": Got %d bytes. Header: %*ph\n",
 325                         ret, 3, ir->buf_in);
 326
 327                 do_gettimeofday(&now);
 328                 timediff = now.tv_sec - ir->last_time.tv_sec;
 329                 if (timediff + 1 > PULSE_MASK / 1000000)
 330                         timediff = PULSE_MASK;
 331                 else {
 332                         timediff *= 1000000;
 333                         timediff += now.tv_usec - ir->last_time.tv_usec;
 334                 }
 335                 ir->last_time.tv_sec = now.tv_sec;
 336                 ir->last_time.tv_usec = now.tv_usec;
 337
 338                 /* create leading gap  */
 339                 code = timediff;
 340                 lirc_buffer_write(buf, (unsigned char *)&code);
 341                 ir->in_space = 1;   /* next comes a pulse */
 342
 343                 if (ir->buf_in[2] == 0)
 344                         send_fragment(ir, buf, DEVICE_HEADERLEN, ret);
 345                 else {
 346                         dev_warn(&ir->usbdev->dev,
 347                                  "[%d]: Device buffer overrun.\n", ir->devnum);
 348                         /* HHHNNNNNNNNNNNOOOOOOOO H = header
 349                               <---[2]--->         N = newer
 350                            <---------ret--------> O = older */
 351                         ir->buf_in[2] %= ret - DEVICE_HEADERLEN; /* sanitize */
 352                         /* keep even-ness to not desync pulse/pause */
 353                         send_fragment(ir, buf, DEVICE_HEADERLEN +
 354                                       ir->buf_in[2] - (ir->buf_in[2] & 1), ret);
 355                         send_fragment(ir, buf, DEVICE_HEADERLEN,
 356                                       DEVICE_HEADERLEN + ir->buf_in[2]);
 357                 }
 358
 359                 ret = usb_control_msg(
 360                       ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
 361                       SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
 362                       /*unused*/0, /*unused*/0,
 363                       /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
 364                       /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
 365                 if (ret < 0)
 366                         printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: "
 367                                "error %d\n", ir->devnum, ret);
 368                 return 0;
 369         } else if (ret < 0)
 370                 printk(DRIVER_NAME "[%d]: GET_INFRACODE: error %d\n",
 371                         ir->devnum, ret);
 372
 373         return -ENODATA;
 374 }
 375
 376 static int igorplugusb_remote_probe(struct usb_interface *intf,
 377                                     const struct usb_device_id *id)
 378 {
 379         struct usb_device *dev;
 380         struct usb_host_interface *idesc = NULL;
 381         struct usb_endpoint_descriptor *ep;
 382         struct igorplug *ir = NULL;
 383         struct lirc_driver *driver = NULL;
 384         int devnum, pipe, maxp;
 385         char buf[63], name[128] = "";
 386         int ret;
 387
 388         dprintk(DRIVER_NAME ": usb probe called.\n");
 389
 390         dev = interface_to_usbdev(intf);
 391
 392         idesc = intf->cur_altsetting;
 393
 394         if (idesc->desc.bNumEndpoints != 1)
 395                 return -ENODEV;
 396
 397         ep = &idesc->endpoint->desc;
 398         if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
 399             != USB_DIR_IN)
 400             || (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 401             != USB_ENDPOINT_XFER_CONTROL)
 402                 return -ENODEV;
 403
 404         pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);
 405         devnum = dev->devnum;
 406         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
 407
 408         dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d\n",
 409                 devnum, CODE_LENGTH, maxp);
 410
 411         ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
 412         if (!ir)
 413                 return -ENOMEM;
 414
 415         driver = devm_kzalloc(&intf->dev, sizeof(*driver), GFP_KERNEL);
 416         if (!driver)
 417                 return -ENOMEM;
 418
 419         ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
 420                                         GFP_ATOMIC, &ir->dma_in);
 421         if (!ir->buf_in)
 422                 return -ENOMEM;
 423
 424         strcpy(driver->name, DRIVER_NAME " ");
 425         driver->minor = -1;
 426         driver->code_length = CODE_LENGTH * 8; /* in bits */
 427         driver->features = LIRC_CAN_REC_MODE2;
 428         driver->data = ir;
 429         driver->chunk_size = CODE_LENGTH;
 430         driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;
 431         driver->set_use_inc = &set_use_inc;
 432         driver->set_use_dec = &set_use_dec;
 433         driver->sample_rate = sample_rate;    /* per second */
 434         driver->add_to_buf = &igorplugusb_remote_poll;
 435         driver->dev = &intf->dev;
 436         driver->owner = THIS_MODULE;
 437
 438         ret = lirc_register_driver(driver);
 439         if (ret < 0) {
 440                 usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,
 441                         ir->buf_in, ir->dma_in);
 442                 return ret;
 443         }
 444
 445         driver->minor = ret;
 446         ir->d = driver;
 447         ir->devnum = devnum;
 448         ir->usbdev = dev;
 449         ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;
 450         ir->in_space = 1; /* First mode2 event is a space. */
 451         do_gettimeofday(&ir->last_time);
 452
 453         if (dev->descriptor.iManufacturer
 454             && usb_string(dev, dev->descriptor.iManufacturer,
 455                           buf, sizeof(buf)) > 0)
 456                 strlcpy(name, buf, sizeof(name));
 457         if (dev->descriptor.iProduct
 458             && usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)
 459                 snprintf(name + strlen(name), sizeof(name) - strlen(name),
 460                          " %s", buf);
 461         printk(DRIVER_NAME "[%d]: %s on usb%d:%d\n", devnum, name,
 462                dev->bus->busnum, devnum);
 463
 464         /* clear device buffer */
 465         ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),
 466                 SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,
 467                 /*unused*/0, /*unused*/0,
 468                 /*dummy*/ir->buf_in, /*dummy*/ir->len_in,
 469                 /*timeout*/HZ * USB_CTRL_GET_TIMEOUT);
 470         if (ret < 0)
 471                 printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d\n",
 472                         devnum, ret);
 473
 474         usb_set_intfdata(intf, ir);
 475         return 0;
 476 }
 477
 478 static void igorplugusb_remote_disconnect(struct usb_interface *intf)
 479 {
 480         struct usb_device *usbdev = interface_to_usbdev(intf);
 481         struct igorplug *ir = usb_get_intfdata(intf);
 482         struct device *dev = &intf->dev;
 483         int devnum;
 484
 485         usb_set_intfdata(intf, NULL);
 486
 487         if (!ir || !ir->d)
 488                 return;
 489
 490         ir->usbdev = NULL;
 491
 492         usb_free_coherent(usbdev, ir->len_in, ir->buf_in, ir->dma_in);
 493
 494         devnum = unregister_from_lirc(ir);
 495
 496         dev_info(dev, DRIVER_NAME "[%d]: %s done\n", devnum, __func__);
 497 }
 498
 499 static struct usb_device_id igorplugusb_remote_id_table[] = {
 500         /* Igor Plug USB (Atmel's Manufact. ID) */
 501         { USB_DEVICE(0x03eb, 0x0002) },
 502         /* Fit PC2 Infrared Adapter */
 503         { USB_DEVICE(0x03eb, 0x21fe) },
 504
 505         /* Terminating entry */
 506         { }
 507 };
 508
 509 static struct usb_driver igorplugusb_remote_driver = {
 510         .name =         DRIVER_NAME,
 511         .probe =        igorplugusb_remote_probe,
 512         .disconnect =   igorplugusb_remote_disconnect,
 513         .id_table =     igorplugusb_remote_id_table
 514 };
 515
 516 module_usb_driver(igorplugusb_remote_driver);
 517
 518 #include <linux/vermagic.h>
 519 MODULE_INFO(vermagic, VERMAGIC_STRING);
 520
 521 MODULE_DESCRIPTION(DRIVER_DESC);
 522 MODULE_AUTHOR(DRIVER_AUTHOR);
 523 MODULE_LICENSE("GPL");
 524 MODULE_DEVICE_TABLE(usb, igorplugusb_remote_id_table);
 525
 526 module_param(sample_rate, int, S_IRUGO | S_IWUSR);
 527 MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");
 528
 529 module_param(debug, bool, S_IRUGO | S_IWUSR);
 530 MODULE_PARM_DESC(debug, "Debug enabled or not");