drivers/media/IR/streamzap.c

   1 /*
   2  * Streamzap Remote Control driver
   3  *
   4  * Copyright (c) 2005 Christoph Bartelmus <lirc@bartelmus.de>
   5  * Copyright (c) 2010 Jarod Wilson <jarod@wilsonet.com>
   6  *
   7  * This driver was based on the work of Greg Wickham and Adrian
   8  * Dewhurst. It was substantially rewritten to support correct signal
   9  * gaps and now maintains a delay buffer, which is used to present
  10  * consistent timing behaviour to user space applications. Without the
  11  * delay buffer an ugly hack would be required in lircd, which can
  12  * cause sluggish signal decoding in certain situations.
  13  *
  14  * Ported to in-kernel ir-core interface by Jarod Wilson
  15  *
  16  * This driver is based on the USB skeleton driver packaged with the
  17  * kernel; copyright (C) 2001-2003 Greg Kroah-Hartman (greg@kroah.com)
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation; either version 2 of the License, or
  22  *  (at your option) any later version.
  23  *
  24  *  This program is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  32  */
  33
  34 #include <linux/device.h>
  35 #include <linux/module.h>
  36 #include <linux/slab.h>
  37 #include <linux/input.h>
  38 #include <linux/usb.h>
  39 #include <linux/usb/input.h>
  40 #include <media/ir-core.h>
  41
  42 #define DRIVER_VERSION  "1.61"
  43 #define DRIVER_NAME     "streamzap"
  44 #define DRIVER_DESC     "Streamzap Remote Control driver"
  45
  46 #ifdef CONFIG_USB_DEBUG
  47 static int debug = 1;
  48 #else
  49 static int debug;
  50 #endif
  51
  52 #define USB_STREAMZAP_VENDOR_ID         0x0e9c
  53 #define USB_STREAMZAP_PRODUCT_ID        0x0000
  54
  55 /* table of devices that work with this driver */
  56 static struct usb_device_id streamzap_table[] = {
  57         /* Streamzap Remote Control */
  58         { USB_DEVICE(USB_STREAMZAP_VENDOR_ID, USB_STREAMZAP_PRODUCT_ID) },
  59         /* Terminating entry */
  60         { }
  61 };
  62
  63 MODULE_DEVICE_TABLE(usb, streamzap_table);
  64
  65 #define SZ_PULSE_MASK 0xf0
  66 #define SZ_SPACE_MASK 0x0f
  67 #define SZ_TIMEOUT    0xff
  68 #define SZ_RESOLUTION 256
  69
  70 /* number of samples buffered */
  71 #define SZ_BUF_LEN 128
  72
  73 /* from ir-rc5-sz-decoder.c */
  74 #ifdef CONFIG_IR_RC5_SZ_DECODER_MODULE
  75 #define load_rc5_sz_decode()    request_module("ir-rc5-sz-decoder")
  76 #else
  77 #define load_rc5_sz_decode()    0
  78 #endif
  79
  80 enum StreamzapDecoderState {
  81         PulseSpace,
  82         FullPulse,
  83         FullSpace,
  84         IgnorePulse
  85 };
  86
  87 /* structure to hold our device specific stuff */
  88 struct streamzap_ir {
  89
  90         /* ir-core */
  91         struct ir_dev_props *props;
  92
  93         /* core device info */
  94         struct device *dev;
  95         struct input_dev *idev;
  96
  97         /* usb */
  98         struct usb_device       *usbdev;
  99         struct usb_interface    *interface;
 100         struct usb_endpoint_descriptor *endpoint;
 101         struct urb              *urb_in;
 102
 103         /* buffer & dma */
 104         unsigned char           *buf_in;
 105         dma_addr_t              dma_in;
 106         unsigned int            buf_in_len;
 107
 108         /* track what state we're in */
 109         enum StreamzapDecoderState decoder_state;
 110         /* tracks whether we are currently receiving some signal */
 111         bool                    idle;
 112         /* sum of signal lengths received since signal start */
 113         unsigned long           sum;
 114         /* start time of signal; necessary for gap tracking */
 115         struct timeval          signal_last;
 116         struct timeval          signal_start;
 117         bool                    timeout_enabled;
 118
 119         char                    name[128];
 120         char                    phys[64];
 121 };
 122
 123
 124 /* local function prototypes */
 125 static int streamzap_probe(struct usb_interface *interface,
 126                            const struct usb_device_id *id);
 127 static void streamzap_disconnect(struct usb_interface *interface);
 128 static void streamzap_callback(struct urb *urb);
 129 static int streamzap_suspend(struct usb_interface *intf, pm_message_t message);
 130 static int streamzap_resume(struct usb_interface *intf);
 131
 132 /* usb specific object needed to register this driver with the usb subsystem */
 133 static struct usb_driver streamzap_driver = {
 134         .name =         DRIVER_NAME,
 135         .probe =        streamzap_probe,
 136         .disconnect =   streamzap_disconnect,
 137         .suspend =      streamzap_suspend,
 138         .resume =       streamzap_resume,
 139         .id_table =     streamzap_table,
 140 };
 141
 142 static void sz_push(struct streamzap_ir *sz, struct ir_raw_event rawir)
 143 {
 144         dev_dbg(sz->dev, "Storing %s with duration %u us\n",
 145                 (rawir.pulse ? "pulse" : "space"), rawir.duration);
 146         ir_raw_event_store_with_filter(sz->idev, &rawir);
 147 }
 148
 149 static void sz_push_full_pulse(struct streamzap_ir *sz,
 150                                unsigned char value)
 151 {
 152         DEFINE_IR_RAW_EVENT(rawir);
 153
 154         if (sz->idle) {
 155                 long deltv;
 156
 157                 sz->signal_last = sz->signal_start;
 158                 do_gettimeofday(&sz->signal_start);
 159
 160                 deltv = sz->signal_start.tv_sec - sz->signal_last.tv_sec;
 161                 rawir.pulse = false;
 162                 if (deltv > 15) {
 163                         /* really long time */
 164                         rawir.duration = IR_MAX_DURATION;
 165                 } else {
 166                         rawir.duration = (int)(deltv * 1000000 +
 167                                 sz->signal_start.tv_usec -
 168                                 sz->signal_last.tv_usec);
 169                         rawir.duration -= sz->sum;
 170                         rawir.duration *= 1000;
 171                         rawir.duration &= IR_MAX_DURATION;
 172                 }
 173                 sz_push(sz, rawir);
 174
 175                 sz->idle = false;
 176                 sz->sum = 0;
 177         }
 178
 179         rawir.pulse = true;
 180         rawir.duration = ((int) value) * SZ_RESOLUTION;
 181         rawir.duration += SZ_RESOLUTION / 2;
 182         sz->sum += rawir.duration;
 183         rawir.duration *= 1000;
 184         rawir.duration &= IR_MAX_DURATION;
 185         sz_push(sz, rawir);
 186 }
 187
 188 static void sz_push_half_pulse(struct streamzap_ir *sz,
 189                                unsigned char value)
 190 {
 191         sz_push_full_pulse(sz, (value & SZ_PULSE_MASK) >> 4);
 192 }
 193
 194 static void sz_push_full_space(struct streamzap_ir *sz,
 195                                unsigned char value)
 196 {
 197         DEFINE_IR_RAW_EVENT(rawir);
 198
 199         rawir.pulse = false;
 200         rawir.duration = ((int) value) * SZ_RESOLUTION;
 201         rawir.duration += SZ_RESOLUTION / 2;
 202         sz->sum += rawir.duration;
 203         rawir.duration *= 1000;
 204         sz_push(sz, rawir);
 205 }
 206
 207 static void sz_push_half_space(struct streamzap_ir *sz,
 208                                unsigned long value)
 209 {
 210         sz_push_full_space(sz, value & SZ_SPACE_MASK);
 211 }
 212
 213 /**
 214  * streamzap_callback - usb IRQ handler callback
 215  *
 216  * This procedure is invoked on reception of data from
 217  * the usb remote.
 218  */
 219 static void streamzap_callback(struct urb *urb)
 220 {
 221         struct streamzap_ir *sz;
 222         unsigned int i;
 223         int len;
 224
 225         if (!urb)
 226                 return;
 227
 228         sz = urb->context;
 229         len = urb->actual_length;
 230
 231         switch (urb->status) {
 232         case -ECONNRESET:
 233         case -ENOENT:
 234         case -ESHUTDOWN:
 235                 /*
 236                  * this urb is terminated, clean up.
 237                  * sz might already be invalid at this point
 238                  */
 239                 dev_err(sz->dev, "urb terminated, status: %d\n", urb->status);
 240                 return;
 241         default:
 242                 break;
 243         }
 244
 245         dev_dbg(sz->dev, "%s: received urb, len %d\n", __func__, len);
 246         for (i = 0; i < len; i++) {
 247                 dev_dbg(sz->dev, "sz->buf_in[%d]: %x\n",
 248                         i, (unsigned char)sz->buf_in[i]);
 249                 switch (sz->decoder_state) {
 250                 case PulseSpace:
 251                         if ((sz->buf_in[i] & SZ_PULSE_MASK) ==
 252                                 SZ_PULSE_MASK) {
 253                                 sz->decoder_state = FullPulse;
 254                                 continue;
 255                         } else if ((sz->buf_in[i] & SZ_SPACE_MASK)
 256                                         == SZ_SPACE_MASK) {
 257                                 sz_push_half_pulse(sz, sz->buf_in[i]);
 258                                 sz->decoder_state = FullSpace;
 259                                 continue;
 260                         } else {
 261                                 sz_push_half_pulse(sz, sz->buf_in[i]);
 262                                 sz_push_half_space(sz, sz->buf_in[i]);
 263                         }
 264                         break;
 265                 case FullPulse:
 266                         sz_push_full_pulse(sz, sz->buf_in[i]);
 267                         sz->decoder_state = IgnorePulse;
 268                         break;
 269                 case FullSpace:
 270                         if (sz->buf_in[i] == SZ_TIMEOUT) {
 271                                 DEFINE_IR_RAW_EVENT(rawir);
 272
 273                                 rawir.pulse = false;
 274                                 rawir.duration = sz->props->timeout;
 275                                 sz->idle = true;
 276                                 if (sz->timeout_enabled)
 277                                         sz_push(sz, rawir);
 278                                 ir_raw_event_handle(sz->idev);
 279                         } else {
 280                                 sz_push_full_space(sz, sz->buf_in[i]);
 281                         }
 282                         sz->decoder_state = PulseSpace;
 283                         break;
 284                 case IgnorePulse:
 285                         if ((sz->buf_in[i] & SZ_SPACE_MASK) ==
 286                                 SZ_SPACE_MASK) {
 287                                 sz->decoder_state = FullSpace;
 288                                 continue;
 289                         }
 290                         sz_push_half_space(sz, sz->buf_in[i]);
 291                         sz->decoder_state = PulseSpace;
 292                         break;
 293                 }
 294         }
 295
 296         usb_submit_urb(urb, GFP_ATOMIC);
 297
 298         return;
 299 }
 300
 301 static struct input_dev *streamzap_init_input_dev(struct streamzap_ir *sz)
 302 {
 303         struct input_dev *idev;
 304         struct ir_dev_props *props;
 305         struct device *dev = sz->dev;
 306         int ret;
 307
 308         idev = input_allocate_device();
 309         if (!idev) {
 310                 dev_err(dev, "remote input dev allocation failed\n");
 311                 goto idev_alloc_failed;
 312         }
 313
 314         props = kzalloc(sizeof(struct ir_dev_props), GFP_KERNEL);
 315         if (!props) {
 316                 dev_err(dev, "remote ir dev props allocation failed\n");
 317                 goto props_alloc_failed;
 318         }
 319
 320         snprintf(sz->name, sizeof(sz->name), "Streamzap PC Remote Infrared "
 321                  "Receiver (%04x:%04x)",
 322                  le16_to_cpu(sz->usbdev->descriptor.idVendor),
 323                  le16_to_cpu(sz->usbdev->descriptor.idProduct));
 324
 325         idev->name = sz->name;
 326         usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys));
 327         strlcat(sz->phys, "/input0", sizeof(sz->phys));
 328         idev->phys = sz->phys;
 329
 330         props->priv = sz;
 331         props->driver_type = RC_DRIVER_IR_RAW;
 332         props->allowed_protos = IR_TYPE_ALL;
 333
 334         sz->props = props;
 335
 336         usb_to_input_id(sz->usbdev, &idev->id);
 337         idev->dev.parent = sz->dev;
 338
 339         ret = ir_input_register(idev, RC_MAP_STREAMZAP, props, DRIVER_NAME);
 340         if (ret < 0) {
 341                 dev_err(dev, "remote input device register failed\n");
 342                 goto irdev_failed;
 343         }
 344
 345         return idev;
 346
 347 irdev_failed:
 348         kfree(props);
 349 props_alloc_failed:
 350         input_free_device(idev);
 351 idev_alloc_failed:
 352         return NULL;
 353 }
 354
 355 /**
 356  *      streamzap_probe
 357  *
 358  *      Called by usb-core to associated with a candidate device
 359  *      On any failure the return value is the ERROR
 360  *      On success return 0
 361  */
 362 static int __devinit streamzap_probe(struct usb_interface *intf,
 363                                      const struct usb_device_id *id)
 364 {
 365         struct usb_device *usbdev = interface_to_usbdev(intf);
 366         struct usb_host_interface *iface_host;
 367         struct streamzap_ir *sz = NULL;
 368         char buf[63], name[128] = "";
 369         int retval = -ENOMEM;
 370         int pipe, maxp;
 371
 372         /* Allocate space for device driver specific data */
 373         sz = kzalloc(sizeof(struct streamzap_ir), GFP_KERNEL);
 374         if (!sz)
 375                 return -ENOMEM;
 376
 377         sz->usbdev = usbdev;
 378         sz->interface = intf;
 379
 380         /* Check to ensure endpoint information matches requirements */
 381         iface_host = intf->cur_altsetting;
 382
 383         if (iface_host->desc.bNumEndpoints != 1) {
 384                 dev_err(&intf->dev, "%s: Unexpected desc.bNumEndpoints (%d)\n",
 385                         __func__, iface_host->desc.bNumEndpoints);
 386                 retval = -ENODEV;
 387                 goto free_sz;
 388         }
 389
 390         sz->endpoint = &(iface_host->endpoint[0].desc);
 391         if ((sz->endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
 392             != USB_DIR_IN) {
 393                 dev_err(&intf->dev, "%s: endpoint doesn't match input device "
 394                         "02%02x\n", __func__, sz->endpoint->bEndpointAddress);
 395                 retval = -ENODEV;
 396                 goto free_sz;
 397         }
 398
 399         if ((sz->endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 400             != USB_ENDPOINT_XFER_INT) {
 401                 dev_err(&intf->dev, "%s: endpoint attributes don't match xfer "
 402                         "02%02x\n", __func__, sz->endpoint->bmAttributes);
 403                 retval = -ENODEV;
 404                 goto free_sz;
 405         }
 406
 407         pipe = usb_rcvintpipe(usbdev, sz->endpoint->bEndpointAddress);
 408         maxp = usb_maxpacket(usbdev, pipe, usb_pipeout(pipe));
 409
 410         if (maxp == 0) {
 411                 dev_err(&intf->dev, "%s: endpoint Max Packet Size is 0!?!\n",
 412                         __func__);
 413                 retval = -ENODEV;
 414                 goto free_sz;
 415         }
 416
 417         /* Allocate the USB buffer and IRQ URB */
 418         sz->buf_in = usb_alloc_coherent(usbdev, maxp, GFP_ATOMIC, &sz->dma_in);
 419         if (!sz->buf_in)
 420                 goto free_sz;
 421
 422         sz->urb_in = usb_alloc_urb(0, GFP_KERNEL);
 423         if (!sz->urb_in)
 424                 goto free_buf_in;
 425
 426         sz->dev = &intf->dev;
 427         sz->buf_in_len = maxp;
 428
 429         if (usbdev->descriptor.iManufacturer
 430             && usb_string(usbdev, usbdev->descriptor.iManufacturer,
 431                           buf, sizeof(buf)) > 0)
 432                 strlcpy(name, buf, sizeof(name));
 433
 434         if (usbdev->descriptor.iProduct
 435             && usb_string(usbdev, usbdev->descriptor.iProduct,
 436                           buf, sizeof(buf)) > 0)
 437                 snprintf(name + strlen(name), sizeof(name) - strlen(name),
 438                          " %s", buf);
 439
 440         sz->idev = streamzap_init_input_dev(sz);
 441         if (!sz->idev)
 442                 goto input_dev_fail;
 443
 444         sz->idle = true;
 445         sz->decoder_state = PulseSpace;
 446         /* FIXME: don't yet have a way to set this */
 447         sz->timeout_enabled = true;
 448         sz->props->timeout = (((SZ_TIMEOUT * SZ_RESOLUTION * 1000) &
 449                                 IR_MAX_DURATION) | 0x03000000);
 450         #if 0
 451         /* not yet supported, depends on patches from maxim */
 452         /* see also: LIRC_GET_REC_RESOLUTION and LIRC_SET_REC_TIMEOUT */
 453         sz->min_timeout = SZ_TIMEOUT * SZ_RESOLUTION * 1000;
 454         sz->max_timeout = SZ_TIMEOUT * SZ_RESOLUTION * 1000;
 455         #endif
 456
 457         do_gettimeofday(&sz->signal_start);
 458
 459         /* Complete final initialisations */
 460         usb_fill_int_urb(sz->urb_in, usbdev, pipe, sz->buf_in,
 461                          maxp, (usb_complete_t)streamzap_callback,
 462                          sz, sz->endpoint->bInterval);
 463         sz->urb_in->transfer_dma = sz->dma_in;
 464         sz->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 465
 466         usb_set_intfdata(intf, sz);
 467
 468         if (usb_submit_urb(sz->urb_in, GFP_ATOMIC))
 469                 dev_err(sz->dev, "urb submit failed\n");
 470
 471         dev_info(sz->dev, "Registered %s on usb%d:%d\n", name,
 472                  usbdev->bus->busnum, usbdev->devnum);
 473
 474         /* Load the streamzap not-quite-rc5 decoder too */
 475         load_rc5_sz_decode();
 476
 477         return 0;
 478
 479 input_dev_fail:
 480         usb_free_urb(sz->urb_in);
 481 free_buf_in:
 482         usb_free_coherent(usbdev, maxp, sz->buf_in, sz->dma_in);
 483 free_sz:
 484         kfree(sz);
 485
 486         return retval;
 487 }
 488
 489 /**
 490  * streamzap_disconnect
 491  *
 492  * Called by the usb core when the device is removed from the system.
 493  *
 494  * This routine guarantees that the driver will not submit any more urbs
 495  * by clearing dev->usbdev.  It is also supposed to terminate any currently
 496  * active urbs.  Unfortunately, usb_bulk_msg(), used in streamzap_read(),
 497  * does not provide any way to do this.
 498  */
 499 static void streamzap_disconnect(struct usb_interface *interface)
 500 {
 501         struct streamzap_ir *sz = usb_get_intfdata(interface);
 502         struct usb_device *usbdev = interface_to_usbdev(interface);
 503
 504         usb_set_intfdata(interface, NULL);
 505
 506         if (!sz)
 507                 return;
 508
 509         sz->usbdev = NULL;
 510         ir_input_unregister(sz->idev);
 511         usb_kill_urb(sz->urb_in);
 512         usb_free_urb(sz->urb_in);
 513         usb_free_coherent(usbdev, sz->buf_in_len, sz->buf_in, sz->dma_in);
 514
 515         kfree(sz);
 516 }
 517
 518 static int streamzap_suspend(struct usb_interface *intf, pm_message_t message)
 519 {
 520         struct streamzap_ir *sz = usb_get_intfdata(intf);
 521
 522         usb_kill_urb(sz->urb_in);
 523
 524         return 0;
 525 }
 526
 527 static int streamzap_resume(struct usb_interface *intf)
 528 {
 529         struct streamzap_ir *sz = usb_get_intfdata(intf);
 530
 531         if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) {
 532                 dev_err(sz->dev, "Error sumbiting urb\n");
 533                 return -EIO;
 534         }
 535
 536         return 0;
 537 }
 538
 539 /**
 540  *      streamzap_init
 541  */
 542 static int __init streamzap_init(void)
 543 {
 544         int ret;
 545
 546         /* register this driver with the USB subsystem */
 547         ret = usb_register(&streamzap_driver);
 548         if (ret < 0)
 549                 printk(KERN_ERR DRIVER_NAME ": usb register failed, "
 550                        "result = %d\n", ret);
 551
 552         return ret;
 553 }
 554
 555 /**
 556  *      streamzap_exit
 557  */
 558 static void __exit streamzap_exit(void)
 559 {
 560         usb_deregister(&streamzap_driver);
 561 }
 562
 563
 564 module_init(streamzap_init);
 565 module_exit(streamzap_exit);
 566
 567 MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>");
 568 MODULE_DESCRIPTION(DRIVER_DESC);
 569 MODULE_LICENSE("GPL");
 570
 571 module_param(debug, bool, S_IRUGO | S_IWUSR);
 572 MODULE_PARM_DESC(debug, "Enable debugging messages");