1 /* 2 * USB RedRat3 IR Transceiver rc-core driver 3 * 4 * Copyright (c) 2011 by Jarod Wilson <jarod@redhat.com> 5 * based heavily on the work of Stephen Cox, with additional 6 * help from RedRat Ltd. 7 * 8 * This driver began life based an an old version of the first-generation 9 * lirc_mceusb driver from the lirc 0.7.2 distribution. It was then 10 * significantly rewritten by Stephen Cox with the aid of RedRat Ltd's 11 * Chris Dodge. 12 * 13 * The driver was then ported to rc-core and significantly rewritten again, 14 * by Jarod, using the in-kernel mceusb driver as a guide, after an initial 15 * port effort was started by Stephen. 16 * 17 * TODO LIST: 18 * - fix lirc not showing repeats properly 19 * -- 20 * 21 * The RedRat3 is a USB transceiver with both send & receive, 22 * with 2 separate sensors available for receive to enable 23 * both good long range reception for general use, and good 24 * short range reception when required for learning a signal. 25 * 26 * http://www.redrat.co.uk/ 27 * 28 * It uses its own little protocol to communicate, the required 29 * parts of which are embedded within this driver. 30 * -- 31 * 32 * This program is free software; you can redistribute it and/or modify 33 * it under the terms of the GNU General Public License as published by 34 * the Free Software Foundation; either version 2 of the License, or 35 * (at your option) any later version. 36 * 37 * This program is distributed in the hope that it will be useful, 38 * but WITHOUT ANY WARRANTY; without even the implied warranty of 39 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 40 * GNU General Public License for more details. 41 * 42 * You should have received a copy of the GNU General Public License 43 * along with this program; if not, write to the Free Software 44 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 45 * 46 */ 47 48 #include <asm/unaligned.h> 49 #include <linux/device.h> 50 #include <linux/leds.h> 51 #include <linux/module.h> 52 #include <linux/slab.h> 53 #include <linux/usb.h> 54 #include <linux/usb/input.h> 55 #include <media/rc-core.h> 56 57 /* Driver Information */ 58 #define DRIVER_AUTHOR "Jarod Wilson <jarod@redhat.com>" 59 #define DRIVER_AUTHOR2 "The Dweller, Stephen Cox" 60 #define DRIVER_DESC "RedRat3 USB IR Transceiver Driver" 61 #define DRIVER_NAME "redrat3" 62 63 /* bulk data transfer types */ 64 #define RR3_ERROR 0x01 65 #define RR3_MOD_SIGNAL_IN 0x20 66 #define RR3_MOD_SIGNAL_OUT 0x21 67 68 /* Get the RR firmware version */ 69 #define RR3_FW_VERSION 0xb1 70 #define RR3_FW_VERSION_LEN 64 71 /* Send encoded signal bulk-sent earlier*/ 72 #define RR3_TX_SEND_SIGNAL 0xb3 73 #define RR3_SET_IR_PARAM 0xb7 74 #define RR3_GET_IR_PARAM 0xb8 75 /* Blink the red LED on the device */ 76 #define RR3_BLINK_LED 0xb9 77 /* Read serial number of device */ 78 #define RR3_READ_SER_NO 0xba 79 #define RR3_SER_NO_LEN 4 80 /* Start capture with the RC receiver */ 81 #define RR3_RC_DET_ENABLE 0xbb 82 /* Stop capture with the RC receiver */ 83 #define RR3_RC_DET_DISABLE 0xbc 84 /* Return the status of RC detector capture */ 85 #define RR3_RC_DET_STATUS 0xbd 86 /* Reset redrat */ 87 #define RR3_RESET 0xa0 88 89 /* Max number of lengths in the signal. */ 90 #define RR3_IR_IO_MAX_LENGTHS 0x01 91 /* Periods to measure mod. freq. */ 92 #define RR3_IR_IO_PERIODS_MF 0x02 93 /* Size of memory for main signal data */ 94 #define RR3_IR_IO_SIG_MEM_SIZE 0x03 95 /* Delta value when measuring lengths */ 96 #define RR3_IR_IO_LENGTH_FUZZ 0x04 97 /* Timeout for end of signal detection */ 98 #define RR3_IR_IO_SIG_TIMEOUT 0x05 99 /* Minimum value for pause recognition. */ 100 #define RR3_IR_IO_MIN_PAUSE 0x06 101 102 /* Clock freq. of EZ-USB chip */ 103 #define RR3_CLK 24000000 104 /* Clock periods per timer count */ 105 #define RR3_CLK_PER_COUNT 12 106 /* (RR3_CLK / RR3_CLK_PER_COUNT) */ 107 #define RR3_CLK_CONV_FACTOR 2000000 108 /* USB bulk-in IR data endpoint address */ 109 #define RR3_BULK_IN_EP_ADDR 0x82 110 111 /* Size of the fixed-length portion of the signal */ 112 #define RR3_DRIVER_MAXLENS 128 113 #define RR3_MAX_SIG_SIZE 512 114 #define RR3_TIME_UNIT 50 115 #define RR3_END_OF_SIGNAL 0x7f 116 #define RR3_TX_TRAILER_LEN 2 117 #define RR3_RX_MIN_TIMEOUT 5 118 #define RR3_RX_MAX_TIMEOUT 2000 119 120 /* The 8051's CPUCS Register address */ 121 #define RR3_CPUCS_REG_ADDR 0x7f92 122 123 #define USB_RR3USB_VENDOR_ID 0x112a 124 #define USB_RR3USB_PRODUCT_ID 0x0001 125 #define USB_RR3IIUSB_PRODUCT_ID 0x0005 126 127 128 /* 129 * The redrat3 encodes an IR signal as set of different lengths and a set 130 * of indices into those lengths. This sets how much two lengths must 131 * differ before they are considered distinct, the value is specified 132 * in microseconds. 133 * Default 5, value 0 to 127. 134 */ 135 static int length_fuzz = 5; 136 module_param(length_fuzz, uint, 0644); 137 MODULE_PARM_DESC(length_fuzz, "Length Fuzz (0-127)"); 138 139 /* 140 * When receiving a continuous ir stream (for example when a user is 141 * holding a button down on a remote), this specifies the minimum size 142 * of a space when the redrat3 sends a irdata packet to the host. Specified 143 * in miliseconds. Default value 18ms. 144 * The value can be between 2 and 30 inclusive. 145 */ 146 static int minimum_pause = 18; 147 module_param(minimum_pause, uint, 0644); 148 MODULE_PARM_DESC(minimum_pause, "Minimum Pause in ms (2-30)"); 149 150 /* 151 * The carrier frequency is measured during the first pulse of the IR 152 * signal. The larger the number of periods used To measure, the more 153 * accurate the result is likely to be, however some signals have short 154 * initial pulses, so in some case it may be necessary to reduce this value. 155 * Default 8, value 1 to 255. 156 */ 157 static int periods_measure_carrier = 8; 158 module_param(periods_measure_carrier, uint, 0644); 159 MODULE_PARM_DESC(periods_measure_carrier, "Number of Periods to Measure Carrier (1-255)"); 160 161 162 struct redrat3_header { 163 __be16 length; 164 __be16 transfer_type; 165 } __packed; 166 167 /* sending and receiving irdata */ 168 struct redrat3_irdata { 169 struct redrat3_header header; 170 __be32 pause; 171 __be16 mod_freq_count; 172 __be16 num_periods; 173 __u8 max_lengths; 174 __u8 no_lengths; 175 __be16 max_sig_size; 176 __be16 sig_size; 177 __u8 no_repeats; 178 __be16 lens[RR3_DRIVER_MAXLENS]; /* not aligned */ 179 __u8 sigdata[RR3_MAX_SIG_SIZE]; 180 } __packed; 181 182 /* firmware errors */ 183 struct redrat3_error { 184 struct redrat3_header header; 185 __be16 fw_error; 186 } __packed; 187 188 /* table of devices that work with this driver */ 189 static struct usb_device_id redrat3_dev_table[] = { 190 /* Original version of the RedRat3 */ 191 {USB_DEVICE(USB_RR3USB_VENDOR_ID, USB_RR3USB_PRODUCT_ID)}, 192 /* Second Version/release of the RedRat3 - RetRat3-II */ 193 {USB_DEVICE(USB_RR3USB_VENDOR_ID, USB_RR3IIUSB_PRODUCT_ID)}, 194 {} /* Terminating entry */ 195 }; 196 197 /* Structure to hold all of our device specific stuff */ 198 struct redrat3_dev { 199 /* core device bits */ 200 struct rc_dev *rc; 201 struct device *dev; 202 203 /* led control */ 204 struct led_classdev led; 205 atomic_t flash; 206 struct usb_ctrlrequest flash_control; 207 struct urb *flash_urb; 208 u8 flash_in_buf; 209 210 /* save off the usb device pointer */ 211 struct usb_device *udev; 212 213 /* the receive endpoint */ 214 struct usb_endpoint_descriptor *ep_in; 215 /* the buffer to receive data */ 216 void *bulk_in_buf; 217 /* urb used to read ir data */ 218 struct urb *read_urb; 219 220 /* the send endpoint */ 221 struct usb_endpoint_descriptor *ep_out; 222 223 /* usb dma */ 224 dma_addr_t dma_in; 225 226 /* Is the device currently transmitting?*/ 227 bool transmitting; 228 229 /* store for current packet */ 230 struct redrat3_irdata irdata; 231 u16 bytes_read; 232 233 u32 carrier; 234 235 char name[64]; 236 char phys[64]; 237 }; 238 239 /* 240 * redrat3_issue_async 241 * 242 * Issues an async read to the ir data in port.. 243 * sets the callback to be redrat3_handle_async 244 */ 245 static void redrat3_issue_async(struct redrat3_dev *rr3) 246 { 247 int res; 248 249 res = usb_submit_urb(rr3->read_urb, GFP_ATOMIC); 250 if (res) 251 dev_dbg(rr3->dev, 252 "%s: receive request FAILED! (res %d, len %d)\n", 253 __func__, res, rr3->read_urb->transfer_buffer_length); 254 } 255 256 static void redrat3_dump_fw_error(struct redrat3_dev *rr3, int code) 257 { 258 if (!rr3->transmitting && (code != 0x40)) 259 dev_info(rr3->dev, "fw error code 0x%02x: ", code); 260 261 switch (code) { 262 case 0x00: 263 pr_cont("No Error\n"); 264 break; 265 266 /* Codes 0x20 through 0x2f are IR Firmware Errors */ 267 case 0x20: 268 pr_cont("Initial signal pulse not long enough to measure carrier frequency\n"); 269 break; 270 case 0x21: 271 pr_cont("Not enough length values allocated for signal\n"); 272 break; 273 case 0x22: 274 pr_cont("Not enough memory allocated for signal data\n"); 275 break; 276 case 0x23: 277 pr_cont("Too many signal repeats\n"); 278 break; 279 case 0x28: 280 pr_cont("Insufficient memory available for IR signal data memory allocation\n"); 281 break; 282 case 0x29: 283 pr_cont("Insufficient memory available for IrDa signal data memory allocation\n"); 284 break; 285 286 /* Codes 0x30 through 0x3f are USB Firmware Errors */ 287 case 0x30: 288 pr_cont("Insufficient memory available for bulk transfer structure\n"); 289 break; 290 291 /* 292 * Other error codes... These are primarily errors that can occur in 293 * the control messages sent to the redrat 294 */ 295 case 0x40: 296 if (!rr3->transmitting) 297 pr_cont("Signal capture has been terminated\n"); 298 break; 299 case 0x41: 300 pr_cont("Attempt to set/get and unknown signal I/O algorithm parameter\n"); 301 break; 302 case 0x42: 303 pr_cont("Signal capture already started\n"); 304 break; 305 306 default: 307 pr_cont("Unknown Error\n"); 308 break; 309 } 310 } 311 312 static u32 redrat3_val_to_mod_freq(struct redrat3_irdata *irdata) 313 { 314 u32 mod_freq = 0; 315 u16 mod_freq_count = be16_to_cpu(irdata->mod_freq_count); 316 317 if (mod_freq_count != 0) 318 mod_freq = (RR3_CLK * be16_to_cpu(irdata->num_periods)) / 319 (mod_freq_count * RR3_CLK_PER_COUNT); 320 321 return mod_freq; 322 } 323 324 /* this function scales down the figures for the same result... */ 325 static u32 redrat3_len_to_us(u32 length) 326 { 327 u32 biglen = length * 1000; 328 u32 divisor = (RR3_CLK_CONV_FACTOR) / 1000; 329 u32 result = (u32) (biglen / divisor); 330 331 /* don't allow zero lengths to go back, breaks lirc */ 332 return result ? result : 1; 333 } 334 335 /* 336 * convert us back into redrat3 lengths 337 * 338 * length * 1000 length * 1000000 339 * ------------- = ---------------- = micro 340 * rr3clk / 1000 rr3clk 341 342 * 6 * 2 4 * 3 micro * rr3clk micro * rr3clk / 1000 343 * ----- = 4 ----- = 6 -------------- = len --------------------- 344 * 3 2 1000000 1000 345 */ 346 static u32 redrat3_us_to_len(u32 microsec) 347 { 348 u32 result; 349 u32 divisor; 350 351 microsec = (microsec > IR_MAX_DURATION) ? IR_MAX_DURATION : microsec; 352 divisor = (RR3_CLK_CONV_FACTOR / 1000); 353 result = (u32)(microsec * divisor) / 1000; 354 355 /* don't allow zero lengths to go back, breaks lirc */ 356 return result ? result : 1; 357 } 358 359 static void redrat3_process_ir_data(struct redrat3_dev *rr3) 360 { 361 DEFINE_IR_RAW_EVENT(rawir); 362 struct device *dev; 363 unsigned int i, sig_size, single_len, offset, val; 364 u32 mod_freq; 365 366 if (!rr3) { 367 pr_err("%s called with no context!\n", __func__); 368 return; 369 } 370 371 dev = rr3->dev; 372 373 mod_freq = redrat3_val_to_mod_freq(&rr3->irdata); 374 dev_dbg(dev, "Got mod_freq of %u\n", mod_freq); 375 376 /* process each rr3 encoded byte into an int */ 377 sig_size = be16_to_cpu(rr3->irdata.sig_size); 378 for (i = 0; i < sig_size; i++) { 379 offset = rr3->irdata.sigdata[i]; 380 val = get_unaligned_be16(&rr3->irdata.lens[offset]); 381 single_len = redrat3_len_to_us(val); 382 383 /* we should always get pulse/space/pulse/space samples */ 384 if (i % 2) 385 rawir.pulse = false; 386 else 387 rawir.pulse = true; 388 389 rawir.duration = US_TO_NS(single_len); 390 /* cap the value to IR_MAX_DURATION */ 391 rawir.duration = (rawir.duration > IR_MAX_DURATION) ? 392 IR_MAX_DURATION : rawir.duration; 393 394 dev_dbg(dev, "storing %s with duration %d (i: %d)\n", 395 rawir.pulse ? "pulse" : "space", rawir.duration, i); 396 ir_raw_event_store_with_filter(rr3->rc, &rawir); 397 } 398 399 /* add a trailing space */ 400 rawir.pulse = false; 401 rawir.timeout = true; 402 rawir.duration = rr3->rc->timeout; 403 dev_dbg(dev, "storing trailing timeout with duration %d\n", 404 rawir.duration); 405 ir_raw_event_store_with_filter(rr3->rc, &rawir); 406 407 dev_dbg(dev, "calling ir_raw_event_handle\n"); 408 ir_raw_event_handle(rr3->rc); 409 } 410 411 /* Util fn to send rr3 cmds */ 412 static int redrat3_send_cmd(int cmd, struct redrat3_dev *rr3) 413 { 414 struct usb_device *udev; 415 u8 *data; 416 int res; 417 418 data = kzalloc(sizeof(u8), GFP_KERNEL); 419 if (!data) 420 return -ENOMEM; 421 422 udev = rr3->udev; 423 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), cmd, 424 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 425 0x0000, 0x0000, data, sizeof(u8), HZ * 10); 426 427 if (res < 0) { 428 dev_err(rr3->dev, "%s: Error sending rr3 cmd res %d, data %d", 429 __func__, res, *data); 430 res = -EIO; 431 } else 432 res = data[0]; 433 434 kfree(data); 435 436 return res; 437 } 438 439 /* Enables the long range detector and starts async receive */ 440 static int redrat3_enable_detector(struct redrat3_dev *rr3) 441 { 442 struct device *dev = rr3->dev; 443 u8 ret; 444 445 ret = redrat3_send_cmd(RR3_RC_DET_ENABLE, rr3); 446 if (ret != 0) 447 dev_dbg(dev, "%s: unexpected ret of %d\n", 448 __func__, ret); 449 450 ret = redrat3_send_cmd(RR3_RC_DET_STATUS, rr3); 451 if (ret != 1) { 452 dev_err(dev, "%s: detector status: %d, should be 1\n", 453 __func__, ret); 454 return -EIO; 455 } 456 457 redrat3_issue_async(rr3); 458 459 return 0; 460 } 461 462 static inline void redrat3_delete(struct redrat3_dev *rr3, 463 struct usb_device *udev) 464 { 465 usb_kill_urb(rr3->read_urb); 466 usb_kill_urb(rr3->flash_urb); 467 usb_free_urb(rr3->read_urb); 468 usb_free_urb(rr3->flash_urb); 469 usb_free_coherent(udev, le16_to_cpu(rr3->ep_in->wMaxPacketSize), 470 rr3->bulk_in_buf, rr3->dma_in); 471 472 kfree(rr3); 473 } 474 475 static u32 redrat3_get_timeout(struct redrat3_dev *rr3) 476 { 477 __be32 *tmp; 478 u32 timeout = MS_TO_US(150); /* a sane default, if things go haywire */ 479 int len, ret, pipe; 480 481 len = sizeof(*tmp); 482 tmp = kzalloc(len, GFP_KERNEL); 483 if (!tmp) { 484 dev_warn(rr3->dev, "Memory allocation faillure\n"); 485 return timeout; 486 } 487 488 pipe = usb_rcvctrlpipe(rr3->udev, 0); 489 ret = usb_control_msg(rr3->udev, pipe, RR3_GET_IR_PARAM, 490 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 491 RR3_IR_IO_SIG_TIMEOUT, 0, tmp, len, HZ * 5); 492 if (ret != len) 493 dev_warn(rr3->dev, "Failed to read timeout from hardware\n"); 494 else { 495 timeout = redrat3_len_to_us(be32_to_cpup(tmp)); 496 497 dev_dbg(rr3->dev, "Got timeout of %d ms\n", timeout / 1000); 498 } 499 500 kfree(tmp); 501 502 return timeout; 503 } 504 505 static int redrat3_set_timeout(struct rc_dev *rc_dev, unsigned int timeoutns) 506 { 507 struct redrat3_dev *rr3 = rc_dev->priv; 508 struct usb_device *udev = rr3->udev; 509 struct device *dev = rr3->dev; 510 __be32 *timeout; 511 int ret; 512 513 timeout = kmalloc(sizeof(*timeout), GFP_KERNEL); 514 if (!timeout) 515 return -ENOMEM; 516 517 *timeout = cpu_to_be32(redrat3_us_to_len(timeoutns / 1000)); 518 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), RR3_SET_IR_PARAM, 519 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 520 RR3_IR_IO_SIG_TIMEOUT, 0, timeout, sizeof(*timeout), 521 HZ * 25); 522 dev_dbg(dev, "set ir parm timeout %d ret 0x%02x\n", 523 be32_to_cpu(*timeout), ret); 524 525 if (ret == sizeof(*timeout)) 526 ret = 0; 527 else if (ret >= 0) 528 ret = -EIO; 529 530 kfree(timeout); 531 532 return ret; 533 } 534 535 static void redrat3_reset(struct redrat3_dev *rr3) 536 { 537 struct usb_device *udev = rr3->udev; 538 struct device *dev = rr3->dev; 539 int rc, rxpipe, txpipe; 540 u8 *val; 541 int len = sizeof(u8); 542 543 rxpipe = usb_rcvctrlpipe(udev, 0); 544 txpipe = usb_sndctrlpipe(udev, 0); 545 546 val = kmalloc(len, GFP_KERNEL); 547 if (!val) { 548 dev_err(dev, "Memory allocation failure\n"); 549 return; 550 } 551 552 *val = 0x01; 553 rc = usb_control_msg(udev, rxpipe, RR3_RESET, 554 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 555 RR3_CPUCS_REG_ADDR, 0, val, len, HZ * 25); 556 dev_dbg(dev, "reset returned 0x%02x\n", rc); 557 558 *val = length_fuzz; 559 rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM, 560 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 561 RR3_IR_IO_LENGTH_FUZZ, 0, val, len, HZ * 25); 562 dev_dbg(dev, "set ir parm len fuzz %d rc 0x%02x\n", *val, rc); 563 564 *val = (65536 - (minimum_pause * 2000)) / 256; 565 rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM, 566 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 567 RR3_IR_IO_MIN_PAUSE, 0, val, len, HZ * 25); 568 dev_dbg(dev, "set ir parm min pause %d rc 0x%02x\n", *val, rc); 569 570 *val = periods_measure_carrier; 571 rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM, 572 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 573 RR3_IR_IO_PERIODS_MF, 0, val, len, HZ * 25); 574 dev_dbg(dev, "set ir parm periods measure carrier %d rc 0x%02x", *val, 575 rc); 576 577 *val = RR3_DRIVER_MAXLENS; 578 rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM, 579 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 580 RR3_IR_IO_MAX_LENGTHS, 0, val, len, HZ * 25); 581 dev_dbg(dev, "set ir parm max lens %d rc 0x%02x\n", *val, rc); 582 583 kfree(val); 584 } 585 586 static void redrat3_get_firmware_rev(struct redrat3_dev *rr3) 587 { 588 int rc = 0; 589 char *buffer; 590 591 buffer = kzalloc(sizeof(char) * (RR3_FW_VERSION_LEN + 1), GFP_KERNEL); 592 if (!buffer) { 593 dev_err(rr3->dev, "Memory allocation failure\n"); 594 return; 595 } 596 597 rc = usb_control_msg(rr3->udev, usb_rcvctrlpipe(rr3->udev, 0), 598 RR3_FW_VERSION, 599 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 600 0, 0, buffer, RR3_FW_VERSION_LEN, HZ * 5); 601 602 if (rc >= 0) 603 dev_info(rr3->dev, "Firmware rev: %s", buffer); 604 else 605 dev_err(rr3->dev, "Problem fetching firmware ID\n"); 606 607 kfree(buffer); 608 } 609 610 static void redrat3_read_packet_start(struct redrat3_dev *rr3, unsigned len) 611 { 612 struct redrat3_header *header = rr3->bulk_in_buf; 613 unsigned pktlen, pkttype; 614 615 /* grab the Length and type of transfer */ 616 pktlen = be16_to_cpu(header->length); 617 pkttype = be16_to_cpu(header->transfer_type); 618 619 if (pktlen > sizeof(rr3->irdata)) { 620 dev_warn(rr3->dev, "packet length %u too large\n", pktlen); 621 return; 622 } 623 624 switch (pkttype) { 625 case RR3_ERROR: 626 if (len >= sizeof(struct redrat3_error)) { 627 struct redrat3_error *error = rr3->bulk_in_buf; 628 unsigned fw_error = be16_to_cpu(error->fw_error); 629 redrat3_dump_fw_error(rr3, fw_error); 630 } 631 break; 632 633 case RR3_MOD_SIGNAL_IN: 634 memcpy(&rr3->irdata, rr3->bulk_in_buf, len); 635 rr3->bytes_read = len; 636 dev_dbg(rr3->dev, "bytes_read %d, pktlen %d\n", 637 rr3->bytes_read, pktlen); 638 break; 639 640 default: 641 dev_dbg(rr3->dev, "ignoring packet with type 0x%02x, len of %d, 0x%02x\n", 642 pkttype, len, pktlen); 643 break; 644 } 645 } 646 647 static void redrat3_read_packet_continue(struct redrat3_dev *rr3, unsigned len) 648 { 649 void *irdata = &rr3->irdata; 650 651 if (len + rr3->bytes_read > sizeof(rr3->irdata)) { 652 dev_warn(rr3->dev, "too much data for packet\n"); 653 rr3->bytes_read = 0; 654 return; 655 } 656 657 memcpy(irdata + rr3->bytes_read, rr3->bulk_in_buf, len); 658 659 rr3->bytes_read += len; 660 dev_dbg(rr3->dev, "bytes_read %d, pktlen %d\n", rr3->bytes_read, 661 be16_to_cpu(rr3->irdata.header.length)); 662 } 663 664 /* gather IR data from incoming urb, process it when we have enough */ 665 static int redrat3_get_ir_data(struct redrat3_dev *rr3, unsigned len) 666 { 667 struct device *dev = rr3->dev; 668 unsigned pkttype; 669 int ret = 0; 670 671 if (rr3->bytes_read == 0 && len >= sizeof(struct redrat3_header)) { 672 redrat3_read_packet_start(rr3, len); 673 } else if (rr3->bytes_read != 0) { 674 redrat3_read_packet_continue(rr3, len); 675 } else if (rr3->bytes_read == 0) { 676 dev_err(dev, "error: no packet data read\n"); 677 ret = -ENODATA; 678 goto out; 679 } 680 681 if (rr3->bytes_read < be16_to_cpu(rr3->irdata.header.length) + 682 sizeof(struct redrat3_header)) 683 /* we're still accumulating data */ 684 return 0; 685 686 /* if we get here, we've got IR data to decode */ 687 pkttype = be16_to_cpu(rr3->irdata.header.transfer_type); 688 if (pkttype == RR3_MOD_SIGNAL_IN) 689 redrat3_process_ir_data(rr3); 690 else 691 dev_dbg(dev, "discarding non-signal data packet (type 0x%02x)\n", 692 pkttype); 693 694 out: 695 rr3->bytes_read = 0; 696 return ret; 697 } 698 699 /* callback function from USB when async USB request has completed */ 700 static void redrat3_handle_async(struct urb *urb) 701 { 702 struct redrat3_dev *rr3; 703 int ret; 704 705 if (!urb) 706 return; 707 708 rr3 = urb->context; 709 if (!rr3) { 710 pr_err("%s called with invalid context!\n", __func__); 711 usb_unlink_urb(urb); 712 return; 713 } 714 715 switch (urb->status) { 716 case 0: 717 ret = redrat3_get_ir_data(rr3, urb->actual_length); 718 if (!ret) { 719 /* no error, prepare to read more */ 720 redrat3_issue_async(rr3); 721 } 722 break; 723 724 case -ECONNRESET: 725 case -ENOENT: 726 case -ESHUTDOWN: 727 usb_unlink_urb(urb); 728 return; 729 730 case -EPIPE: 731 default: 732 dev_warn(rr3->dev, "Error: urb status = %d\n", urb->status); 733 rr3->bytes_read = 0; 734 break; 735 } 736 } 737 738 static u16 mod_freq_to_val(unsigned int mod_freq) 739 { 740 int mult = 6000000; 741 742 /* Clk used in mod. freq. generation is CLK24/4. */ 743 return 65536 - (mult / mod_freq); 744 } 745 746 static int redrat3_set_tx_carrier(struct rc_dev *rcdev, u32 carrier) 747 { 748 struct redrat3_dev *rr3 = rcdev->priv; 749 struct device *dev = rr3->dev; 750 751 dev_dbg(dev, "Setting modulation frequency to %u", carrier); 752 if (carrier == 0) 753 return -EINVAL; 754 755 rr3->carrier = carrier; 756 757 return 0; 758 } 759 760 static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf, 761 unsigned count) 762 { 763 struct redrat3_dev *rr3 = rcdev->priv; 764 struct device *dev = rr3->dev; 765 struct redrat3_irdata *irdata = NULL; 766 int ret, ret_len; 767 int lencheck, cur_sample_len, pipe; 768 int *sample_lens = NULL; 769 u8 curlencheck = 0; 770 unsigned i, sendbuf_len; 771 772 if (rr3->transmitting) { 773 dev_warn(dev, "%s: transmitter already in use\n", __func__); 774 return -EAGAIN; 775 } 776 777 if (count > RR3_MAX_SIG_SIZE - RR3_TX_TRAILER_LEN) 778 return -EINVAL; 779 780 /* rr3 will disable rc detector on transmit */ 781 rr3->transmitting = true; 782 783 sample_lens = kzalloc(sizeof(int) * RR3_DRIVER_MAXLENS, GFP_KERNEL); 784 if (!sample_lens) { 785 ret = -ENOMEM; 786 goto out; 787 } 788 789 irdata = kzalloc(sizeof(*irdata), GFP_KERNEL); 790 if (!irdata) { 791 ret = -ENOMEM; 792 goto out; 793 } 794 795 for (i = 0; i < count; i++) { 796 cur_sample_len = redrat3_us_to_len(txbuf[i]); 797 if (cur_sample_len > 0xffff) { 798 dev_warn(dev, "transmit period of %uus truncated to %uus\n", 799 txbuf[i], redrat3_len_to_us(0xffff)); 800 cur_sample_len = 0xffff; 801 } 802 for (lencheck = 0; lencheck < curlencheck; lencheck++) { 803 if (sample_lens[lencheck] == cur_sample_len) 804 break; 805 } 806 if (lencheck == curlencheck) { 807 dev_dbg(dev, "txbuf[%d]=%u, pos %d, enc %u\n", 808 i, txbuf[i], curlencheck, cur_sample_len); 809 if (curlencheck < RR3_DRIVER_MAXLENS) { 810 /* now convert the value to a proper 811 * rr3 value.. */ 812 sample_lens[curlencheck] = cur_sample_len; 813 put_unaligned_be16(cur_sample_len, 814 &irdata->lens[curlencheck]); 815 curlencheck++; 816 } else { 817 ret = -EINVAL; 818 goto out; 819 } 820 } 821 irdata->sigdata[i] = lencheck; 822 } 823 824 irdata->sigdata[count] = RR3_END_OF_SIGNAL; 825 irdata->sigdata[count + 1] = RR3_END_OF_SIGNAL; 826 827 sendbuf_len = offsetof(struct redrat3_irdata, 828 sigdata[count + RR3_TX_TRAILER_LEN]); 829 /* fill in our packet header */ 830 irdata->header.length = cpu_to_be16(sendbuf_len - 831 sizeof(struct redrat3_header)); 832 irdata->header.transfer_type = cpu_to_be16(RR3_MOD_SIGNAL_OUT); 833 irdata->pause = cpu_to_be32(redrat3_len_to_us(100)); 834 irdata->mod_freq_count = cpu_to_be16(mod_freq_to_val(rr3->carrier)); 835 irdata->no_lengths = curlencheck; 836 irdata->sig_size = cpu_to_be16(count + RR3_TX_TRAILER_LEN); 837 838 pipe = usb_sndbulkpipe(rr3->udev, rr3->ep_out->bEndpointAddress); 839 ret = usb_bulk_msg(rr3->udev, pipe, irdata, 840 sendbuf_len, &ret_len, 10 * HZ); 841 dev_dbg(dev, "sent %d bytes, (ret %d)\n", ret_len, ret); 842 843 /* now tell the hardware to transmit what we sent it */ 844 pipe = usb_rcvctrlpipe(rr3->udev, 0); 845 ret = usb_control_msg(rr3->udev, pipe, RR3_TX_SEND_SIGNAL, 846 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 847 0, 0, irdata, 2, HZ * 10); 848 849 if (ret < 0) 850 dev_err(dev, "Error: control msg send failed, rc %d\n", ret); 851 else 852 ret = count; 853 854 out: 855 kfree(sample_lens); 856 kfree(irdata); 857 858 rr3->transmitting = false; 859 /* rr3 re-enables rc detector because it was enabled before */ 860 861 return ret; 862 } 863 864 static void redrat3_brightness_set(struct led_classdev *led_dev, enum 865 led_brightness brightness) 866 { 867 struct redrat3_dev *rr3 = container_of(led_dev, struct redrat3_dev, 868 led); 869 870 if (brightness != LED_OFF && atomic_cmpxchg(&rr3->flash, 0, 1) == 0) { 871 int ret = usb_submit_urb(rr3->flash_urb, GFP_ATOMIC); 872 if (ret != 0) { 873 dev_dbg(rr3->dev, "%s: unexpected ret of %d\n", 874 __func__, ret); 875 atomic_set(&rr3->flash, 0); 876 } 877 } 878 } 879 880 static void redrat3_led_complete(struct urb *urb) 881 { 882 struct redrat3_dev *rr3 = urb->context; 883 884 switch (urb->status) { 885 case 0: 886 break; 887 case -ECONNRESET: 888 case -ENOENT: 889 case -ESHUTDOWN: 890 usb_unlink_urb(urb); 891 return; 892 case -EPIPE: 893 default: 894 dev_dbg(rr3->dev, "Error: urb status = %d\n", urb->status); 895 break; 896 } 897 898 rr3->led.brightness = LED_OFF; 899 atomic_dec(&rr3->flash); 900 } 901 902 static struct rc_dev *redrat3_init_rc_dev(struct redrat3_dev *rr3) 903 { 904 struct device *dev = rr3->dev; 905 struct rc_dev *rc; 906 int ret = -ENODEV; 907 u16 prod = le16_to_cpu(rr3->udev->descriptor.idProduct); 908 909 rc = rc_allocate_device(); 910 if (!rc) { 911 dev_err(dev, "remote input dev allocation failed\n"); 912 goto out; 913 } 914 915 snprintf(rr3->name, sizeof(rr3->name), "RedRat3%s Infrared Remote Transceiver (%04x:%04x)", 916 prod == USB_RR3IIUSB_PRODUCT_ID ? "-II" : "", 917 le16_to_cpu(rr3->udev->descriptor.idVendor), prod); 918 919 usb_make_path(rr3->udev, rr3->phys, sizeof(rr3->phys)); 920 921 rc->input_name = rr3->name; 922 rc->input_phys = rr3->phys; 923 usb_to_input_id(rr3->udev, &rc->input_id); 924 rc->dev.parent = dev; 925 rc->priv = rr3; 926 rc->driver_type = RC_DRIVER_IR_RAW; 927 rc->allowed_protocols = RC_BIT_ALL; 928 rc->min_timeout = MS_TO_NS(RR3_RX_MIN_TIMEOUT); 929 rc->max_timeout = MS_TO_NS(RR3_RX_MAX_TIMEOUT); 930 rc->timeout = US_TO_NS(redrat3_get_timeout(rr3)); 931 rc->s_timeout = redrat3_set_timeout; 932 rc->tx_ir = redrat3_transmit_ir; 933 rc->s_tx_carrier = redrat3_set_tx_carrier; 934 rc->driver_name = DRIVER_NAME; 935 rc->rx_resolution = US_TO_NS(2); 936 rc->map_name = RC_MAP_HAUPPAUGE; 937 938 ret = rc_register_device(rc); 939 if (ret < 0) { 940 dev_err(dev, "remote dev registration failed\n"); 941 goto out; 942 } 943 944 return rc; 945 946 out: 947 rc_free_device(rc); 948 return NULL; 949 } 950 951 static int redrat3_dev_probe(struct usb_interface *intf, 952 const struct usb_device_id *id) 953 { 954 struct usb_device *udev = interface_to_usbdev(intf); 955 struct device *dev = &intf->dev; 956 struct usb_host_interface *uhi; 957 struct redrat3_dev *rr3; 958 struct usb_endpoint_descriptor *ep; 959 struct usb_endpoint_descriptor *ep_in = NULL; 960 struct usb_endpoint_descriptor *ep_out = NULL; 961 u8 addr, attrs; 962 int pipe, i; 963 int retval = -ENOMEM; 964 965 uhi = intf->cur_altsetting; 966 967 /* find our bulk-in and bulk-out endpoints */ 968 for (i = 0; i < uhi->desc.bNumEndpoints; ++i) { 969 ep = &uhi->endpoint[i].desc; 970 addr = ep->bEndpointAddress; 971 attrs = ep->bmAttributes; 972 973 if ((ep_in == NULL) && 974 ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) && 975 ((attrs & USB_ENDPOINT_XFERTYPE_MASK) == 976 USB_ENDPOINT_XFER_BULK)) { 977 dev_dbg(dev, "found bulk-in endpoint at 0x%02x\n", 978 ep->bEndpointAddress); 979 /* data comes in on 0x82, 0x81 is for other data... */ 980 if (ep->bEndpointAddress == RR3_BULK_IN_EP_ADDR) 981 ep_in = ep; 982 } 983 984 if ((ep_out == NULL) && 985 ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) && 986 ((attrs & USB_ENDPOINT_XFERTYPE_MASK) == 987 USB_ENDPOINT_XFER_BULK)) { 988 dev_dbg(dev, "found bulk-out endpoint at 0x%02x\n", 989 ep->bEndpointAddress); 990 ep_out = ep; 991 } 992 } 993 994 if (!ep_in || !ep_out) { 995 dev_err(dev, "Couldn't find both in and out endpoints\n"); 996 retval = -ENODEV; 997 goto no_endpoints; 998 } 999 1000 /* allocate memory for our device state and initialize it */ 1001 rr3 = kzalloc(sizeof(*rr3), GFP_KERNEL); 1002 if (rr3 == NULL) { 1003 dev_err(dev, "Memory allocation failure\n"); 1004 goto no_endpoints; 1005 } 1006 1007 rr3->dev = &intf->dev; 1008 1009 /* set up bulk-in endpoint */ 1010 rr3->read_urb = usb_alloc_urb(0, GFP_KERNEL); 1011 if (!rr3->read_urb) 1012 goto error; 1013 1014 rr3->ep_in = ep_in; 1015 rr3->bulk_in_buf = usb_alloc_coherent(udev, 1016 le16_to_cpu(ep_in->wMaxPacketSize), GFP_KERNEL, &rr3->dma_in); 1017 if (!rr3->bulk_in_buf) { 1018 dev_err(dev, "Read buffer allocation failure\n"); 1019 goto error; 1020 } 1021 1022 pipe = usb_rcvbulkpipe(udev, ep_in->bEndpointAddress); 1023 usb_fill_bulk_urb(rr3->read_urb, udev, pipe, rr3->bulk_in_buf, 1024 le16_to_cpu(ep_in->wMaxPacketSize), redrat3_handle_async, rr3); 1025 rr3->read_urb->transfer_dma = rr3->dma_in; 1026 rr3->read_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1027 1028 rr3->ep_out = ep_out; 1029 rr3->udev = udev; 1030 1031 redrat3_reset(rr3); 1032 redrat3_get_firmware_rev(rr3); 1033 1034 /* might be all we need to do? */ 1035 retval = redrat3_enable_detector(rr3); 1036 if (retval < 0) 1037 goto error; 1038 1039 /* default.. will get overridden by any sends with a freq defined */ 1040 rr3->carrier = 38000; 1041 1042 /* led control */ 1043 rr3->led.name = "redrat3:red:feedback"; 1044 rr3->led.default_trigger = "rc-feedback"; 1045 rr3->led.brightness_set = redrat3_brightness_set; 1046 retval = led_classdev_register(&intf->dev, &rr3->led); 1047 if (retval) 1048 goto error; 1049 1050 atomic_set(&rr3->flash, 0); 1051 rr3->flash_urb = usb_alloc_urb(0, GFP_KERNEL); 1052 if (!rr3->flash_urb) { 1053 retval = -ENOMEM; 1054 goto led_free_error; 1055 } 1056 1057 /* setup packet is 'c0 b9 0000 0000 0001' */ 1058 rr3->flash_control.bRequestType = 0xc0; 1059 rr3->flash_control.bRequest = RR3_BLINK_LED; 1060 rr3->flash_control.wLength = cpu_to_le16(1); 1061 1062 usb_fill_control_urb(rr3->flash_urb, udev, usb_rcvctrlpipe(udev, 0), 1063 (unsigned char *)&rr3->flash_control, 1064 &rr3->flash_in_buf, sizeof(rr3->flash_in_buf), 1065 redrat3_led_complete, rr3); 1066 1067 rr3->rc = redrat3_init_rc_dev(rr3); 1068 if (!rr3->rc) { 1069 retval = -ENOMEM; 1070 goto led_free_error; 1071 } 1072 1073 /* we can register the device now, as it is ready */ 1074 usb_set_intfdata(intf, rr3); 1075 1076 return 0; 1077 1078 led_free_error: 1079 led_classdev_unregister(&rr3->led); 1080 error: 1081 redrat3_delete(rr3, rr3->udev); 1082 1083 no_endpoints: 1084 dev_err(dev, "%s: retval = %x", __func__, retval); 1085 1086 return retval; 1087 } 1088 1089 static void redrat3_dev_disconnect(struct usb_interface *intf) 1090 { 1091 struct usb_device *udev = interface_to_usbdev(intf); 1092 struct redrat3_dev *rr3 = usb_get_intfdata(intf); 1093 1094 if (!rr3) 1095 return; 1096 1097 usb_set_intfdata(intf, NULL); 1098 rc_unregister_device(rr3->rc); 1099 led_classdev_unregister(&rr3->led); 1100 redrat3_delete(rr3, udev); 1101 } 1102 1103 static int redrat3_dev_suspend(struct usb_interface *intf, pm_message_t message) 1104 { 1105 struct redrat3_dev *rr3 = usb_get_intfdata(intf); 1106 1107 led_classdev_suspend(&rr3->led); 1108 usb_kill_urb(rr3->read_urb); 1109 usb_kill_urb(rr3->flash_urb); 1110 return 0; 1111 } 1112 1113 static int redrat3_dev_resume(struct usb_interface *intf) 1114 { 1115 struct redrat3_dev *rr3 = usb_get_intfdata(intf); 1116 1117 if (usb_submit_urb(rr3->read_urb, GFP_ATOMIC)) 1118 return -EIO; 1119 led_classdev_resume(&rr3->led); 1120 return 0; 1121 } 1122 1123 static struct usb_driver redrat3_dev_driver = { 1124 .name = DRIVER_NAME, 1125 .probe = redrat3_dev_probe, 1126 .disconnect = redrat3_dev_disconnect, 1127 .suspend = redrat3_dev_suspend, 1128 .resume = redrat3_dev_resume, 1129 .reset_resume = redrat3_dev_resume, 1130 .id_table = redrat3_dev_table 1131 }; 1132 1133 module_usb_driver(redrat3_dev_driver); 1134 1135 MODULE_DESCRIPTION(DRIVER_DESC); 1136 MODULE_AUTHOR(DRIVER_AUTHOR); 1137 MODULE_AUTHOR(DRIVER_AUTHOR2); 1138 MODULE_LICENSE("GPL"); 1139 MODULE_DEVICE_TABLE(usb, redrat3_dev_table); 1140