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/usb.h> 38 #include <linux/usb/input.h> 39 #include <media/rc-core.h> 40 41 #define DRIVER_VERSION "1.61" 42 #define DRIVER_NAME "streamzap" 43 #define DRIVER_DESC "Streamzap Remote Control driver" 44 45 #ifdef CONFIG_USB_DEBUG 46 static bool debug = 1; 47 #else 48 static bool debug; 49 #endif 50 51 #define USB_STREAMZAP_VENDOR_ID 0x0e9c 52 #define USB_STREAMZAP_PRODUCT_ID 0x0000 53 54 /* table of devices that work with this driver */ 55 static struct usb_device_id streamzap_table[] = { 56 /* Streamzap Remote Control */ 57 { USB_DEVICE(USB_STREAMZAP_VENDOR_ID, USB_STREAMZAP_PRODUCT_ID) }, 58 /* Terminating entry */ 59 { } 60 }; 61 62 MODULE_DEVICE_TABLE(usb, streamzap_table); 63 64 #define SZ_PULSE_MASK 0xf0 65 #define SZ_SPACE_MASK 0x0f 66 #define SZ_TIMEOUT 0xff 67 #define SZ_RESOLUTION 256 68 69 /* number of samples buffered */ 70 #define SZ_BUF_LEN 128 71 72 /* from ir-rc5-sz-decoder.c */ 73 #ifdef CONFIG_IR_RC5_SZ_DECODER_MODULE 74 #define load_rc5_sz_decode() request_module("ir-rc5-sz-decoder") 75 #else 76 #define load_rc5_sz_decode() {} 77 #endif 78 79 enum StreamzapDecoderState { 80 PulseSpace, 81 FullPulse, 82 FullSpace, 83 IgnorePulse 84 }; 85 86 /* structure to hold our device specific stuff */ 87 struct streamzap_ir { 88 /* ir-core */ 89 struct rc_dev *rdev; 90 91 /* core device info */ 92 struct device *dev; 93 94 /* usb */ 95 struct usb_device *usbdev; 96 struct usb_interface *interface; 97 struct usb_endpoint_descriptor *endpoint; 98 struct urb *urb_in; 99 100 /* buffer & dma */ 101 unsigned char *buf_in; 102 dma_addr_t dma_in; 103 unsigned int buf_in_len; 104 105 /* track what state we're in */ 106 enum StreamzapDecoderState decoder_state; 107 /* tracks whether we are currently receiving some signal */ 108 bool idle; 109 /* sum of signal lengths received since signal start */ 110 unsigned long sum; 111 /* start time of signal; necessary for gap tracking */ 112 struct timeval signal_last; 113 struct timeval signal_start; 114 bool timeout_enabled; 115 116 char name[128]; 117 char phys[64]; 118 }; 119 120 121 /* local function prototypes */ 122 static int streamzap_probe(struct usb_interface *interface, 123 const struct usb_device_id *id); 124 static void streamzap_disconnect(struct usb_interface *interface); 125 static void streamzap_callback(struct urb *urb); 126 static int streamzap_suspend(struct usb_interface *intf, pm_message_t message); 127 static int streamzap_resume(struct usb_interface *intf); 128 129 /* usb specific object needed to register this driver with the usb subsystem */ 130 static struct usb_driver streamzap_driver = { 131 .name = DRIVER_NAME, 132 .probe = streamzap_probe, 133 .disconnect = streamzap_disconnect, 134 .suspend = streamzap_suspend, 135 .resume = streamzap_resume, 136 .id_table = streamzap_table, 137 }; 138 139 static void sz_push(struct streamzap_ir *sz, struct ir_raw_event rawir) 140 { 141 dev_dbg(sz->dev, "Storing %s with duration %u us\n", 142 (rawir.pulse ? "pulse" : "space"), rawir.duration); 143 ir_raw_event_store_with_filter(sz->rdev, &rawir); 144 } 145 146 static void sz_push_full_pulse(struct streamzap_ir *sz, 147 unsigned char value) 148 { 149 DEFINE_IR_RAW_EVENT(rawir); 150 151 if (sz->idle) { 152 long deltv; 153 154 sz->signal_last = sz->signal_start; 155 do_gettimeofday(&sz->signal_start); 156 157 deltv = sz->signal_start.tv_sec - sz->signal_last.tv_sec; 158 rawir.pulse = false; 159 if (deltv > 15) { 160 /* really long time */ 161 rawir.duration = IR_MAX_DURATION; 162 } else { 163 rawir.duration = (int)(deltv * 1000000 + 164 sz->signal_start.tv_usec - 165 sz->signal_last.tv_usec); 166 rawir.duration -= sz->sum; 167 rawir.duration = US_TO_NS(rawir.duration); 168 rawir.duration &= IR_MAX_DURATION; 169 } 170 sz_push(sz, rawir); 171 172 sz->idle = false; 173 sz->sum = 0; 174 } 175 176 rawir.pulse = true; 177 rawir.duration = ((int) value) * SZ_RESOLUTION; 178 rawir.duration += SZ_RESOLUTION / 2; 179 sz->sum += rawir.duration; 180 rawir.duration = US_TO_NS(rawir.duration); 181 rawir.duration &= IR_MAX_DURATION; 182 sz_push(sz, rawir); 183 } 184 185 static void sz_push_half_pulse(struct streamzap_ir *sz, 186 unsigned char value) 187 { 188 sz_push_full_pulse(sz, (value & SZ_PULSE_MASK) >> 4); 189 } 190 191 static void sz_push_full_space(struct streamzap_ir *sz, 192 unsigned char value) 193 { 194 DEFINE_IR_RAW_EVENT(rawir); 195 196 rawir.pulse = false; 197 rawir.duration = ((int) value) * SZ_RESOLUTION; 198 rawir.duration += SZ_RESOLUTION / 2; 199 sz->sum += rawir.duration; 200 rawir.duration = US_TO_NS(rawir.duration); 201 sz_push(sz, rawir); 202 } 203 204 static void sz_push_half_space(struct streamzap_ir *sz, 205 unsigned long value) 206 { 207 sz_push_full_space(sz, value & SZ_SPACE_MASK); 208 } 209 210 /** 211 * streamzap_callback - usb IRQ handler callback 212 * 213 * This procedure is invoked on reception of data from 214 * the usb remote. 215 */ 216 static void streamzap_callback(struct urb *urb) 217 { 218 struct streamzap_ir *sz; 219 unsigned int i; 220 int len; 221 222 if (!urb) 223 return; 224 225 sz = urb->context; 226 len = urb->actual_length; 227 228 switch (urb->status) { 229 case -ECONNRESET: 230 case -ENOENT: 231 case -ESHUTDOWN: 232 /* 233 * this urb is terminated, clean up. 234 * sz might already be invalid at this point 235 */ 236 dev_err(sz->dev, "urb terminated, status: %d\n", urb->status); 237 return; 238 default: 239 break; 240 } 241 242 dev_dbg(sz->dev, "%s: received urb, len %d\n", __func__, len); 243 for (i = 0; i < len; i++) { 244 dev_dbg(sz->dev, "sz->buf_in[%d]: %x\n", 245 i, (unsigned char)sz->buf_in[i]); 246 switch (sz->decoder_state) { 247 case PulseSpace: 248 if ((sz->buf_in[i] & SZ_PULSE_MASK) == 249 SZ_PULSE_MASK) { 250 sz->decoder_state = FullPulse; 251 continue; 252 } else if ((sz->buf_in[i] & SZ_SPACE_MASK) 253 == SZ_SPACE_MASK) { 254 sz_push_half_pulse(sz, sz->buf_in[i]); 255 sz->decoder_state = FullSpace; 256 continue; 257 } else { 258 sz_push_half_pulse(sz, sz->buf_in[i]); 259 sz_push_half_space(sz, sz->buf_in[i]); 260 } 261 break; 262 case FullPulse: 263 sz_push_full_pulse(sz, sz->buf_in[i]); 264 sz->decoder_state = IgnorePulse; 265 break; 266 case FullSpace: 267 if (sz->buf_in[i] == SZ_TIMEOUT) { 268 DEFINE_IR_RAW_EVENT(rawir); 269 270 rawir.pulse = false; 271 rawir.duration = sz->rdev->timeout; 272 sz->idle = true; 273 if (sz->timeout_enabled) 274 sz_push(sz, rawir); 275 ir_raw_event_handle(sz->rdev); 276 ir_raw_event_reset(sz->rdev); 277 } else { 278 sz_push_full_space(sz, sz->buf_in[i]); 279 } 280 sz->decoder_state = PulseSpace; 281 break; 282 case IgnorePulse: 283 if ((sz->buf_in[i] & SZ_SPACE_MASK) == 284 SZ_SPACE_MASK) { 285 sz->decoder_state = FullSpace; 286 continue; 287 } 288 sz_push_half_space(sz, sz->buf_in[i]); 289 sz->decoder_state = PulseSpace; 290 break; 291 } 292 } 293 294 ir_raw_event_handle(sz->rdev); 295 usb_submit_urb(urb, GFP_ATOMIC); 296 297 return; 298 } 299 300 static struct rc_dev *streamzap_init_rc_dev(struct streamzap_ir *sz) 301 { 302 struct rc_dev *rdev; 303 struct device *dev = sz->dev; 304 int ret; 305 306 rdev = rc_allocate_device(); 307 if (!rdev) { 308 dev_err(dev, "remote dev allocation failed\n"); 309 goto out; 310 } 311 312 snprintf(sz->name, sizeof(sz->name), "Streamzap PC Remote Infrared " 313 "Receiver (%04x:%04x)", 314 le16_to_cpu(sz->usbdev->descriptor.idVendor), 315 le16_to_cpu(sz->usbdev->descriptor.idProduct)); 316 usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys)); 317 strlcat(sz->phys, "/input0", sizeof(sz->phys)); 318 319 rdev->input_name = sz->name; 320 rdev->input_phys = sz->phys; 321 usb_to_input_id(sz->usbdev, &rdev->input_id); 322 rdev->dev.parent = dev; 323 rdev->priv = sz; 324 rdev->driver_type = RC_DRIVER_IR_RAW; 325 rdev->allowed_protos = RC_BIT_ALL; 326 rdev->driver_name = DRIVER_NAME; 327 rdev->map_name = RC_MAP_STREAMZAP; 328 329 ret = rc_register_device(rdev); 330 if (ret < 0) { 331 dev_err(dev, "remote input device register failed\n"); 332 goto out; 333 } 334 335 return rdev; 336 337 out: 338 rc_free_device(rdev); 339 return NULL; 340 } 341 342 /** 343 * streamzap_probe 344 * 345 * Called by usb-core to associated with a candidate device 346 * On any failure the return value is the ERROR 347 * On success return 0 348 */ 349 static int streamzap_probe(struct usb_interface *intf, 350 const struct usb_device_id *id) 351 { 352 struct usb_device *usbdev = interface_to_usbdev(intf); 353 struct usb_host_interface *iface_host; 354 struct streamzap_ir *sz = NULL; 355 char buf[63], name[128] = ""; 356 int retval = -ENOMEM; 357 int pipe, maxp; 358 359 /* Allocate space for device driver specific data */ 360 sz = kzalloc(sizeof(struct streamzap_ir), GFP_KERNEL); 361 if (!sz) 362 return -ENOMEM; 363 364 sz->usbdev = usbdev; 365 sz->interface = intf; 366 367 /* Check to ensure endpoint information matches requirements */ 368 iface_host = intf->cur_altsetting; 369 370 if (iface_host->desc.bNumEndpoints != 1) { 371 dev_err(&intf->dev, "%s: Unexpected desc.bNumEndpoints (%d)\n", 372 __func__, iface_host->desc.bNumEndpoints); 373 retval = -ENODEV; 374 goto free_sz; 375 } 376 377 sz->endpoint = &(iface_host->endpoint[0].desc); 378 if ((sz->endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) 379 != USB_DIR_IN) { 380 dev_err(&intf->dev, "%s: endpoint doesn't match input device " 381 "02%02x\n", __func__, sz->endpoint->bEndpointAddress); 382 retval = -ENODEV; 383 goto free_sz; 384 } 385 386 if ((sz->endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 387 != USB_ENDPOINT_XFER_INT) { 388 dev_err(&intf->dev, "%s: endpoint attributes don't match xfer " 389 "02%02x\n", __func__, sz->endpoint->bmAttributes); 390 retval = -ENODEV; 391 goto free_sz; 392 } 393 394 pipe = usb_rcvintpipe(usbdev, sz->endpoint->bEndpointAddress); 395 maxp = usb_maxpacket(usbdev, pipe, usb_pipeout(pipe)); 396 397 if (maxp == 0) { 398 dev_err(&intf->dev, "%s: endpoint Max Packet Size is 0!?!\n", 399 __func__); 400 retval = -ENODEV; 401 goto free_sz; 402 } 403 404 /* Allocate the USB buffer and IRQ URB */ 405 sz->buf_in = usb_alloc_coherent(usbdev, maxp, GFP_ATOMIC, &sz->dma_in); 406 if (!sz->buf_in) 407 goto free_sz; 408 409 sz->urb_in = usb_alloc_urb(0, GFP_KERNEL); 410 if (!sz->urb_in) 411 goto free_buf_in; 412 413 sz->dev = &intf->dev; 414 sz->buf_in_len = maxp; 415 416 if (usbdev->descriptor.iManufacturer 417 && usb_string(usbdev, usbdev->descriptor.iManufacturer, 418 buf, sizeof(buf)) > 0) 419 strlcpy(name, buf, sizeof(name)); 420 421 if (usbdev->descriptor.iProduct 422 && usb_string(usbdev, usbdev->descriptor.iProduct, 423 buf, sizeof(buf)) > 0) 424 snprintf(name + strlen(name), sizeof(name) - strlen(name), 425 " %s", buf); 426 427 sz->rdev = streamzap_init_rc_dev(sz); 428 if (!sz->rdev) 429 goto rc_dev_fail; 430 431 sz->idle = true; 432 sz->decoder_state = PulseSpace; 433 /* FIXME: don't yet have a way to set this */ 434 sz->timeout_enabled = true; 435 sz->rdev->timeout = ((US_TO_NS(SZ_TIMEOUT * SZ_RESOLUTION) & 436 IR_MAX_DURATION) | 0x03000000); 437 #if 0 438 /* not yet supported, depends on patches from maxim */ 439 /* see also: LIRC_GET_REC_RESOLUTION and LIRC_SET_REC_TIMEOUT */ 440 sz->min_timeout = US_TO_NS(SZ_TIMEOUT * SZ_RESOLUTION); 441 sz->max_timeout = US_TO_NS(SZ_TIMEOUT * SZ_RESOLUTION); 442 #endif 443 444 do_gettimeofday(&sz->signal_start); 445 446 /* Complete final initialisations */ 447 usb_fill_int_urb(sz->urb_in, usbdev, pipe, sz->buf_in, 448 maxp, (usb_complete_t)streamzap_callback, 449 sz, sz->endpoint->bInterval); 450 sz->urb_in->transfer_dma = sz->dma_in; 451 sz->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 452 453 usb_set_intfdata(intf, sz); 454 455 if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) 456 dev_err(sz->dev, "urb submit failed\n"); 457 458 dev_info(sz->dev, "Registered %s on usb%d:%d\n", name, 459 usbdev->bus->busnum, usbdev->devnum); 460 461 /* Load the streamzap not-quite-rc5 decoder too */ 462 load_rc5_sz_decode(); 463 464 return 0; 465 466 rc_dev_fail: 467 usb_free_urb(sz->urb_in); 468 free_buf_in: 469 usb_free_coherent(usbdev, maxp, sz->buf_in, sz->dma_in); 470 free_sz: 471 kfree(sz); 472 473 return retval; 474 } 475 476 /** 477 * streamzap_disconnect 478 * 479 * Called by the usb core when the device is removed from the system. 480 * 481 * This routine guarantees that the driver will not submit any more urbs 482 * by clearing dev->usbdev. It is also supposed to terminate any currently 483 * active urbs. Unfortunately, usb_bulk_msg(), used in streamzap_read(), 484 * does not provide any way to do this. 485 */ 486 static void streamzap_disconnect(struct usb_interface *interface) 487 { 488 struct streamzap_ir *sz = usb_get_intfdata(interface); 489 struct usb_device *usbdev = interface_to_usbdev(interface); 490 491 usb_set_intfdata(interface, NULL); 492 493 if (!sz) 494 return; 495 496 sz->usbdev = NULL; 497 rc_unregister_device(sz->rdev); 498 usb_kill_urb(sz->urb_in); 499 usb_free_urb(sz->urb_in); 500 usb_free_coherent(usbdev, sz->buf_in_len, sz->buf_in, sz->dma_in); 501 502 kfree(sz); 503 } 504 505 static int streamzap_suspend(struct usb_interface *intf, pm_message_t message) 506 { 507 struct streamzap_ir *sz = usb_get_intfdata(intf); 508 509 usb_kill_urb(sz->urb_in); 510 511 return 0; 512 } 513 514 static int streamzap_resume(struct usb_interface *intf) 515 { 516 struct streamzap_ir *sz = usb_get_intfdata(intf); 517 518 if (usb_submit_urb(sz->urb_in, GFP_ATOMIC)) { 519 dev_err(sz->dev, "Error sumbiting urb\n"); 520 return -EIO; 521 } 522 523 return 0; 524 } 525 526 module_usb_driver(streamzap_driver); 527 528 MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>"); 529 MODULE_DESCRIPTION(DRIVER_DESC); 530 MODULE_LICENSE("GPL"); 531 532 module_param(debug, bool, S_IRUGO | S_IWUSR); 533 MODULE_PARM_DESC(debug, "Enable debugging messages"); 534