1 /* 2 * serial_ir.c 3 * 4 * serial_ir - Device driver that records pulse- and pause-lengths 5 * (space-lengths) between DDCD event on a serial port. 6 * 7 * Copyright (C) 1996,97 Ralph Metzler <rjkm@thp.uni-koeln.de> 8 * Copyright (C) 1998 Trent Piepho <xyzzy@u.washington.edu> 9 * Copyright (C) 1998 Ben Pfaff <blp@gnu.org> 10 * Copyright (C) 1999 Christoph Bartelmus <lirc@bartelmus.de> 11 * Copyright (C) 2007 Andrei Tanas <andrei@tanas.ca> (suspend/resume support) 12 * Copyright (C) 2016 Sean Young <sean@mess.org> (port to rc-core) 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 */ 23 24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 25 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/interrupt.h> 29 #include <linux/kernel.h> 30 #include <linux/serial_reg.h> 31 #include <linux/types.h> 32 #include <linux/delay.h> 33 #include <linux/platform_device.h> 34 #include <linux/spinlock.h> 35 #include <media/rc-core.h> 36 37 struct serial_ir_hw { 38 int signal_pin; 39 int signal_pin_change; 40 u8 on; 41 u8 off; 42 unsigned set_send_carrier:1; 43 unsigned set_duty_cycle:1; 44 void (*send_pulse)(unsigned int length, ktime_t edge); 45 void (*send_space)(void); 46 spinlock_t lock; 47 }; 48 49 #define IR_HOMEBREW 0 50 #define IR_IRDEO 1 51 #define IR_IRDEO_REMOTE 2 52 #define IR_ANIMAX 3 53 #define IR_IGOR 4 54 55 /* module parameters */ 56 static int type; 57 static int io; 58 static int irq; 59 static bool iommap; 60 static int ioshift; 61 static bool softcarrier = true; 62 static bool share_irq; 63 static int sense = -1; /* -1 = auto, 0 = active high, 1 = active low */ 64 static bool txsense; /* 0 = active high, 1 = active low */ 65 66 /* forward declarations */ 67 static void send_pulse_irdeo(unsigned int length, ktime_t edge); 68 static void send_space_irdeo(void); 69 #ifdef CONFIG_IR_SERIAL_TRANSMITTER 70 static void send_pulse_homebrew(unsigned int length, ktime_t edge); 71 static void send_space_homebrew(void); 72 #endif 73 74 static struct serial_ir_hw hardware[] = { 75 [IR_HOMEBREW] = { 76 .lock = __SPIN_LOCK_UNLOCKED(hardware[IR_HOMEBREW].lock), 77 .signal_pin = UART_MSR_DCD, 78 .signal_pin_change = UART_MSR_DDCD, 79 .on = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR), 80 .off = (UART_MCR_RTS | UART_MCR_OUT2), 81 #ifdef CONFIG_IR_SERIAL_TRANSMITTER 82 .send_pulse = send_pulse_homebrew, 83 .send_space = send_space_homebrew, 84 .set_send_carrier = true, 85 .set_duty_cycle = true, 86 #endif 87 }, 88 89 [IR_IRDEO] = { 90 .lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO].lock), 91 .signal_pin = UART_MSR_DSR, 92 .signal_pin_change = UART_MSR_DDSR, 93 .on = UART_MCR_OUT2, 94 .off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2), 95 .send_pulse = send_pulse_irdeo, 96 .send_space = send_space_irdeo, 97 .set_duty_cycle = true, 98 }, 99 100 [IR_IRDEO_REMOTE] = { 101 .lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO_REMOTE].lock), 102 .signal_pin = UART_MSR_DSR, 103 .signal_pin_change = UART_MSR_DDSR, 104 .on = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2), 105 .off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2), 106 .send_pulse = send_pulse_irdeo, 107 .send_space = send_space_irdeo, 108 .set_duty_cycle = true, 109 }, 110 111 [IR_ANIMAX] = { 112 .lock = __SPIN_LOCK_UNLOCKED(hardware[IR_ANIMAX].lock), 113 .signal_pin = UART_MSR_DCD, 114 .signal_pin_change = UART_MSR_DDCD, 115 .on = 0, 116 .off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2), 117 }, 118 119 [IR_IGOR] = { 120 .lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IGOR].lock), 121 .signal_pin = UART_MSR_DSR, 122 .signal_pin_change = UART_MSR_DDSR, 123 .on = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR), 124 .off = (UART_MCR_RTS | UART_MCR_OUT2), 125 #ifdef CONFIG_IR_SERIAL_TRANSMITTER 126 .send_pulse = send_pulse_homebrew, 127 .send_space = send_space_homebrew, 128 .set_send_carrier = true, 129 .set_duty_cycle = true, 130 #endif 131 }, 132 }; 133 134 #define RS_ISR_PASS_LIMIT 256 135 136 struct serial_ir { 137 ktime_t lastkt; 138 struct rc_dev *rcdev; 139 struct platform_device *pdev; 140 struct timer_list timeout_timer; 141 142 unsigned int freq; 143 unsigned int duty_cycle; 144 145 unsigned int pulse_width, space_width; 146 }; 147 148 static struct serial_ir serial_ir; 149 150 /* fetch serial input packet (1 byte) from register offset */ 151 static u8 sinp(int offset) 152 { 153 if (iommap) 154 /* the register is memory-mapped */ 155 offset <<= ioshift; 156 157 return inb(io + offset); 158 } 159 160 /* write serial output packet (1 byte) of value to register offset */ 161 static void soutp(int offset, u8 value) 162 { 163 if (iommap) 164 /* the register is memory-mapped */ 165 offset <<= ioshift; 166 167 outb(value, io + offset); 168 } 169 170 static void on(void) 171 { 172 if (txsense) 173 soutp(UART_MCR, hardware[type].off); 174 else 175 soutp(UART_MCR, hardware[type].on); 176 } 177 178 static void off(void) 179 { 180 if (txsense) 181 soutp(UART_MCR, hardware[type].on); 182 else 183 soutp(UART_MCR, hardware[type].off); 184 } 185 186 static void init_timing_params(unsigned int new_duty_cycle, 187 unsigned int new_freq) 188 { 189 serial_ir.duty_cycle = new_duty_cycle; 190 serial_ir.freq = new_freq; 191 192 serial_ir.pulse_width = DIV_ROUND_CLOSEST( 193 new_duty_cycle * NSEC_PER_SEC, new_freq * 100l); 194 serial_ir.space_width = DIV_ROUND_CLOSEST( 195 (100l - new_duty_cycle) * NSEC_PER_SEC, new_freq * 100l); 196 } 197 198 static void send_pulse_irdeo(unsigned int length, ktime_t target) 199 { 200 long rawbits; 201 int i; 202 unsigned char output; 203 unsigned char chunk, shifted; 204 205 /* how many bits have to be sent ? */ 206 rawbits = length * 1152 / 10000; 207 if (serial_ir.duty_cycle > 50) 208 chunk = 3; 209 else 210 chunk = 1; 211 for (i = 0, output = 0x7f; rawbits > 0; rawbits -= 3) { 212 shifted = chunk << (i * 3); 213 shifted >>= 1; 214 output &= (~shifted); 215 i++; 216 if (i == 3) { 217 soutp(UART_TX, output); 218 while (!(sinp(UART_LSR) & UART_LSR_THRE)) 219 ; 220 output = 0x7f; 221 i = 0; 222 } 223 } 224 if (i != 0) { 225 soutp(UART_TX, output); 226 while (!(sinp(UART_LSR) & UART_LSR_TEMT)) 227 ; 228 } 229 } 230 231 static void send_space_irdeo(void) 232 { 233 } 234 235 #ifdef CONFIG_IR_SERIAL_TRANSMITTER 236 static void send_pulse_homebrew_softcarrier(unsigned int length, ktime_t edge) 237 { 238 ktime_t now, target = ktime_add_us(edge, length); 239 /* 240 * delta should never exceed 4 seconds and on m68k 241 * ndelay(s64) does not compile; so use s32 rather than s64. 242 */ 243 s32 delta; 244 245 for (;;) { 246 now = ktime_get(); 247 if (ktime_compare(now, target) >= 0) 248 break; 249 on(); 250 edge = ktime_add_ns(edge, serial_ir.pulse_width); 251 delta = ktime_to_ns(ktime_sub(edge, now)); 252 if (delta > 0) 253 ndelay(delta); 254 now = ktime_get(); 255 off(); 256 if (ktime_compare(now, target) >= 0) 257 break; 258 edge = ktime_add_ns(edge, serial_ir.space_width); 259 delta = ktime_to_ns(ktime_sub(edge, now)); 260 if (delta > 0) 261 ndelay(delta); 262 } 263 } 264 265 static void send_pulse_homebrew(unsigned int length, ktime_t edge) 266 { 267 if (softcarrier) 268 send_pulse_homebrew_softcarrier(length, edge); 269 else 270 on(); 271 } 272 273 static void send_space_homebrew(void) 274 { 275 off(); 276 } 277 #endif 278 279 static void frbwrite(unsigned int l, bool is_pulse) 280 { 281 /* simple noise filter */ 282 static unsigned int ptr, pulse, space; 283 DEFINE_IR_RAW_EVENT(ev); 284 285 if (ptr > 0 && is_pulse) { 286 pulse += l; 287 if (pulse > 250000) { 288 ev.duration = space; 289 ev.pulse = false; 290 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 291 ev.duration = pulse; 292 ev.pulse = true; 293 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 294 ptr = 0; 295 pulse = 0; 296 } 297 return; 298 } 299 if (!is_pulse) { 300 if (ptr == 0) { 301 if (l > 20000000) { 302 space = l; 303 ptr++; 304 return; 305 } 306 } else { 307 if (l > 20000000) { 308 space += pulse; 309 if (space > IR_MAX_DURATION) 310 space = IR_MAX_DURATION; 311 space += l; 312 if (space > IR_MAX_DURATION) 313 space = IR_MAX_DURATION; 314 pulse = 0; 315 return; 316 } 317 318 ev.duration = space; 319 ev.pulse = false; 320 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 321 ev.duration = pulse; 322 ev.pulse = true; 323 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 324 ptr = 0; 325 pulse = 0; 326 } 327 } 328 329 ev.duration = l; 330 ev.pulse = is_pulse; 331 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 332 } 333 334 static irqreturn_t serial_ir_irq_handler(int i, void *blah) 335 { 336 ktime_t kt; 337 int counter, dcd; 338 u8 status; 339 ktime_t delkt; 340 unsigned int data; 341 static int last_dcd = -1; 342 343 if ((sinp(UART_IIR) & UART_IIR_NO_INT)) { 344 /* not our interrupt */ 345 return IRQ_NONE; 346 } 347 348 counter = 0; 349 do { 350 counter++; 351 status = sinp(UART_MSR); 352 if (counter > RS_ISR_PASS_LIMIT) { 353 dev_err(&serial_ir.pdev->dev, "Trapped in interrupt"); 354 break; 355 } 356 if ((status & hardware[type].signal_pin_change) && 357 sense != -1) { 358 /* get current time */ 359 kt = ktime_get(); 360 361 /* 362 * The driver needs to know if your receiver is 363 * active high or active low, or the space/pulse 364 * sense could be inverted. 365 */ 366 367 /* calc time since last interrupt in nanoseconds */ 368 dcd = (status & hardware[type].signal_pin) ? 1 : 0; 369 370 if (dcd == last_dcd) { 371 dev_err(&serial_ir.pdev->dev, 372 "ignoring spike: %d %d %lldns %lldns\n", 373 dcd, sense, ktime_to_ns(kt), 374 ktime_to_ns(serial_ir.lastkt)); 375 continue; 376 } 377 378 delkt = ktime_sub(kt, serial_ir.lastkt); 379 if (ktime_compare(delkt, ktime_set(15, 0)) > 0) { 380 data = IR_MAX_DURATION; /* really long time */ 381 if (!(dcd ^ sense)) { 382 /* sanity check */ 383 dev_err(&serial_ir.pdev->dev, 384 "dcd unexpected: %d %d %lldns %lldns\n", 385 dcd, sense, ktime_to_ns(kt), 386 ktime_to_ns(serial_ir.lastkt)); 387 /* 388 * detecting pulse while this 389 * MUST be a space! 390 */ 391 sense = sense ? 0 : 1; 392 } 393 } else { 394 data = ktime_to_ns(delkt); 395 } 396 frbwrite(data, !(dcd ^ sense)); 397 serial_ir.lastkt = kt; 398 last_dcd = dcd; 399 } 400 } while (!(sinp(UART_IIR) & UART_IIR_NO_INT)); /* still pending ? */ 401 402 mod_timer(&serial_ir.timeout_timer, 403 jiffies + nsecs_to_jiffies(serial_ir.rcdev->timeout)); 404 405 ir_raw_event_handle(serial_ir.rcdev); 406 407 return IRQ_HANDLED; 408 } 409 410 static int hardware_init_port(void) 411 { 412 u8 scratch, scratch2, scratch3; 413 414 /* 415 * This is a simple port existence test, borrowed from the autoconfig 416 * function in drivers/tty/serial/8250/8250_port.c 417 */ 418 scratch = sinp(UART_IER); 419 soutp(UART_IER, 0); 420 #ifdef __i386__ 421 outb(0xff, 0x080); 422 #endif 423 scratch2 = sinp(UART_IER) & 0x0f; 424 soutp(UART_IER, 0x0f); 425 #ifdef __i386__ 426 outb(0x00, 0x080); 427 #endif 428 scratch3 = sinp(UART_IER) & 0x0f; 429 soutp(UART_IER, scratch); 430 if (scratch2 != 0 || scratch3 != 0x0f) { 431 /* we fail, there's nothing here */ 432 pr_err("port existence test failed, cannot continue\n"); 433 return -ENODEV; 434 } 435 436 /* Set DLAB 0. */ 437 soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB)); 438 439 /* First of all, disable all interrupts */ 440 soutp(UART_IER, sinp(UART_IER) & 441 (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI))); 442 443 /* Clear registers. */ 444 sinp(UART_LSR); 445 sinp(UART_RX); 446 sinp(UART_IIR); 447 sinp(UART_MSR); 448 449 /* Set line for power source */ 450 off(); 451 452 /* Clear registers again to be sure. */ 453 sinp(UART_LSR); 454 sinp(UART_RX); 455 sinp(UART_IIR); 456 sinp(UART_MSR); 457 458 switch (type) { 459 case IR_IRDEO: 460 case IR_IRDEO_REMOTE: 461 /* setup port to 7N1 @ 115200 Baud */ 462 /* 7N1+start = 9 bits at 115200 ~ 3 bits at 38kHz */ 463 464 /* Set DLAB 1. */ 465 soutp(UART_LCR, sinp(UART_LCR) | UART_LCR_DLAB); 466 /* Set divisor to 1 => 115200 Baud */ 467 soutp(UART_DLM, 0); 468 soutp(UART_DLL, 1); 469 /* Set DLAB 0 + 7N1 */ 470 soutp(UART_LCR, UART_LCR_WLEN7); 471 /* THR interrupt already disabled at this point */ 472 break; 473 default: 474 break; 475 } 476 477 return 0; 478 } 479 480 static void serial_ir_timeout(unsigned long arg) 481 { 482 DEFINE_IR_RAW_EVENT(ev); 483 484 ev.timeout = true; 485 ev.duration = serial_ir.rcdev->timeout; 486 ir_raw_event_store_with_filter(serial_ir.rcdev, &ev); 487 ir_raw_event_handle(serial_ir.rcdev); 488 } 489 490 static int serial_ir_probe(struct platform_device *dev) 491 { 492 int i, nlow, nhigh, result; 493 494 result = devm_request_irq(&dev->dev, irq, serial_ir_irq_handler, 495 share_irq ? IRQF_SHARED : 0, 496 KBUILD_MODNAME, &hardware); 497 if (result < 0) { 498 if (result == -EBUSY) 499 dev_err(&dev->dev, "IRQ %d busy\n", irq); 500 else if (result == -EINVAL) 501 dev_err(&dev->dev, "Bad irq number or handler\n"); 502 return result; 503 } 504 505 /* Reserve io region. */ 506 if ((iommap && 507 (devm_request_mem_region(&dev->dev, iommap, 8 << ioshift, 508 KBUILD_MODNAME) == NULL)) || 509 (!iommap && (devm_request_region(&dev->dev, io, 8, 510 KBUILD_MODNAME) == NULL))) { 511 dev_err(&dev->dev, "port %04x already in use\n", io); 512 dev_warn(&dev->dev, "use 'setserial /dev/ttySX uart none'\n"); 513 dev_warn(&dev->dev, 514 "or compile the serial port driver as module and\n"); 515 dev_warn(&dev->dev, "make sure this module is loaded first\n"); 516 return -EBUSY; 517 } 518 519 setup_timer(&serial_ir.timeout_timer, serial_ir_timeout, 520 (unsigned long)&serial_ir); 521 522 result = hardware_init_port(); 523 if (result < 0) 524 return result; 525 526 /* Initialize pulse/space widths */ 527 init_timing_params(50, 38000); 528 529 /* If pin is high, then this must be an active low receiver. */ 530 if (sense == -1) { 531 /* wait 1/2 sec for the power supply */ 532 msleep(500); 533 534 /* 535 * probe 9 times every 0.04s, collect "votes" for 536 * active high/low 537 */ 538 nlow = 0; 539 nhigh = 0; 540 for (i = 0; i < 9; i++) { 541 if (sinp(UART_MSR) & hardware[type].signal_pin) 542 nlow++; 543 else 544 nhigh++; 545 msleep(40); 546 } 547 sense = nlow >= nhigh ? 1 : 0; 548 dev_info(&dev->dev, "auto-detected active %s receiver\n", 549 sense ? "low" : "high"); 550 } else 551 dev_info(&dev->dev, "Manually using active %s receiver\n", 552 sense ? "low" : "high"); 553 554 dev_dbg(&dev->dev, "Interrupt %d, port %04x obtained\n", irq, io); 555 return 0; 556 } 557 558 static int serial_ir_open(struct rc_dev *rcdev) 559 { 560 unsigned long flags; 561 562 /* initialize timestamp */ 563 serial_ir.lastkt = ktime_get(); 564 565 spin_lock_irqsave(&hardware[type].lock, flags); 566 567 /* Set DLAB 0. */ 568 soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB)); 569 570 soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI); 571 572 spin_unlock_irqrestore(&hardware[type].lock, flags); 573 574 return 0; 575 } 576 577 static void serial_ir_close(struct rc_dev *rcdev) 578 { 579 unsigned long flags; 580 581 spin_lock_irqsave(&hardware[type].lock, flags); 582 583 /* Set DLAB 0. */ 584 soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB)); 585 586 /* First of all, disable all interrupts */ 587 soutp(UART_IER, sinp(UART_IER) & 588 (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI))); 589 spin_unlock_irqrestore(&hardware[type].lock, flags); 590 } 591 592 static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf, 593 unsigned int count) 594 { 595 unsigned long flags; 596 ktime_t edge; 597 s64 delta; 598 int i; 599 600 spin_lock_irqsave(&hardware[type].lock, flags); 601 if (type == IR_IRDEO) { 602 /* DTR, RTS down */ 603 on(); 604 } 605 606 edge = ktime_get(); 607 for (i = 0; i < count; i++) { 608 if (i % 2) 609 hardware[type].send_space(); 610 else 611 hardware[type].send_pulse(txbuf[i], edge); 612 613 edge = ktime_add_us(edge, txbuf[i]); 614 delta = ktime_us_delta(edge, ktime_get()); 615 if (delta > 25) { 616 spin_unlock_irqrestore(&hardware[type].lock, flags); 617 usleep_range(delta - 25, delta + 25); 618 spin_lock_irqsave(&hardware[type].lock, flags); 619 } else if (delta > 0) { 620 udelay(delta); 621 } 622 } 623 off(); 624 spin_unlock_irqrestore(&hardware[type].lock, flags); 625 return count; 626 } 627 628 static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle) 629 { 630 init_timing_params(cycle, serial_ir.freq); 631 return 0; 632 } 633 634 static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier) 635 { 636 if (carrier > 500000 || carrier < 20000) 637 return -EINVAL; 638 639 init_timing_params(serial_ir.duty_cycle, carrier); 640 return 0; 641 } 642 643 static int serial_ir_suspend(struct platform_device *dev, 644 pm_message_t state) 645 { 646 /* Set DLAB 0. */ 647 soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB)); 648 649 /* Disable all interrupts */ 650 soutp(UART_IER, sinp(UART_IER) & 651 (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI))); 652 653 /* Clear registers. */ 654 sinp(UART_LSR); 655 sinp(UART_RX); 656 sinp(UART_IIR); 657 sinp(UART_MSR); 658 659 return 0; 660 } 661 662 static int serial_ir_resume(struct platform_device *dev) 663 { 664 unsigned long flags; 665 int result; 666 667 result = hardware_init_port(); 668 if (result < 0) 669 return result; 670 671 spin_lock_irqsave(&hardware[type].lock, flags); 672 /* Enable Interrupt */ 673 serial_ir.lastkt = ktime_get(); 674 soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI); 675 off(); 676 677 spin_unlock_irqrestore(&hardware[type].lock, flags); 678 679 return 0; 680 } 681 682 static struct platform_driver serial_ir_driver = { 683 .probe = serial_ir_probe, 684 .suspend = serial_ir_suspend, 685 .resume = serial_ir_resume, 686 .driver = { 687 .name = "serial_ir", 688 }, 689 }; 690 691 static int __init serial_ir_init(void) 692 { 693 int result; 694 695 result = platform_driver_register(&serial_ir_driver); 696 if (result) 697 return result; 698 699 serial_ir.pdev = platform_device_alloc("serial_ir", 0); 700 if (!serial_ir.pdev) { 701 result = -ENOMEM; 702 goto exit_driver_unregister; 703 } 704 705 result = platform_device_add(serial_ir.pdev); 706 if (result) 707 goto exit_device_put; 708 709 return 0; 710 711 exit_device_put: 712 platform_device_put(serial_ir.pdev); 713 exit_driver_unregister: 714 platform_driver_unregister(&serial_ir_driver); 715 return result; 716 } 717 718 static void serial_ir_exit(void) 719 { 720 platform_device_unregister(serial_ir.pdev); 721 platform_driver_unregister(&serial_ir_driver); 722 } 723 724 static int __init serial_ir_init_module(void) 725 { 726 struct rc_dev *rcdev; 727 int result; 728 729 switch (type) { 730 case IR_HOMEBREW: 731 case IR_IRDEO: 732 case IR_IRDEO_REMOTE: 733 case IR_ANIMAX: 734 case IR_IGOR: 735 /* if nothing specified, use ttyS0/com1 and irq 4 */ 736 io = io ? io : 0x3f8; 737 irq = irq ? irq : 4; 738 break; 739 default: 740 return -EINVAL; 741 } 742 if (!softcarrier) { 743 switch (type) { 744 case IR_HOMEBREW: 745 case IR_IGOR: 746 hardware[type].set_send_carrier = false; 747 hardware[type].set_duty_cycle = false; 748 break; 749 } 750 } 751 752 /* make sure sense is either -1, 0, or 1 */ 753 if (sense != -1) 754 sense = !!sense; 755 756 result = serial_ir_init(); 757 if (result) 758 return result; 759 760 rcdev = devm_rc_allocate_device(&serial_ir.pdev->dev, RC_DRIVER_IR_RAW); 761 if (!rcdev) { 762 result = -ENOMEM; 763 goto serial_cleanup; 764 } 765 766 if (hardware[type].send_pulse && hardware[type].send_space) 767 rcdev->tx_ir = serial_ir_tx; 768 if (hardware[type].set_send_carrier) 769 rcdev->s_tx_carrier = serial_ir_tx_carrier; 770 if (hardware[type].set_duty_cycle) 771 rcdev->s_tx_duty_cycle = serial_ir_tx_duty_cycle; 772 773 switch (type) { 774 case IR_HOMEBREW: 775 rcdev->input_name = "Serial IR type home-brew"; 776 break; 777 case IR_IRDEO: 778 rcdev->input_name = "Serial IR type IRdeo"; 779 break; 780 case IR_IRDEO_REMOTE: 781 rcdev->input_name = "Serial IR type IRdeo remote"; 782 break; 783 case IR_ANIMAX: 784 rcdev->input_name = "Serial IR type AnimaX"; 785 break; 786 case IR_IGOR: 787 rcdev->input_name = "Serial IR type IgorPlug"; 788 break; 789 } 790 791 rcdev->input_phys = KBUILD_MODNAME "/input0"; 792 rcdev->input_id.bustype = BUS_HOST; 793 rcdev->input_id.vendor = 0x0001; 794 rcdev->input_id.product = 0x0001; 795 rcdev->input_id.version = 0x0100; 796 rcdev->open = serial_ir_open; 797 rcdev->close = serial_ir_close; 798 rcdev->dev.parent = &serial_ir.pdev->dev; 799 rcdev->allowed_protocols = RC_BIT_ALL_IR_DECODER; 800 rcdev->driver_name = KBUILD_MODNAME; 801 rcdev->map_name = RC_MAP_RC6_MCE; 802 rcdev->min_timeout = 1; 803 rcdev->timeout = IR_DEFAULT_TIMEOUT; 804 rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT; 805 rcdev->rx_resolution = 250000; 806 807 serial_ir.rcdev = rcdev; 808 809 result = rc_register_device(rcdev); 810 811 if (!result) 812 return 0; 813 serial_cleanup: 814 serial_ir_exit(); 815 return result; 816 } 817 818 static void __exit serial_ir_exit_module(void) 819 { 820 del_timer_sync(&serial_ir.timeout_timer); 821 rc_unregister_device(serial_ir.rcdev); 822 serial_ir_exit(); 823 } 824 825 module_init(serial_ir_init_module); 826 module_exit(serial_ir_exit_module); 827 828 MODULE_DESCRIPTION("Infra-red receiver driver for serial ports."); 829 MODULE_AUTHOR("Ralph Metzler, Trent Piepho, Ben Pfaff, Christoph Bartelmus, Andrei Tanas"); 830 MODULE_LICENSE("GPL"); 831 832 module_param(type, int, 0444); 833 MODULE_PARM_DESC(type, "Hardware type (0 = home-brew, 1 = IRdeo, 2 = IRdeo Remote, 3 = AnimaX, 4 = IgorPlug"); 834 835 module_param(io, int, 0444); 836 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)"); 837 838 /* some architectures (e.g. intel xscale) have memory mapped registers */ 839 module_param(iommap, bool, 0444); 840 MODULE_PARM_DESC(iommap, "physical base for memory mapped I/O (0 = no memory mapped io)"); 841 842 /* 843 * some architectures (e.g. intel xscale) align the 8bit serial registers 844 * on 32bit word boundaries. 845 * See linux-kernel/drivers/tty/serial/8250/8250.c serial_in()/out() 846 */ 847 module_param(ioshift, int, 0444); 848 MODULE_PARM_DESC(ioshift, "shift I/O register offset (0 = no shift)"); 849 850 module_param(irq, int, 0444); 851 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)"); 852 853 module_param(share_irq, bool, 0444); 854 MODULE_PARM_DESC(share_irq, "Share interrupts (0 = off, 1 = on)"); 855 856 module_param(sense, int, 0444); 857 MODULE_PARM_DESC(sense, "Override autodetection of IR receiver circuit (0 = active high, 1 = active low )"); 858 859 #ifdef CONFIG_IR_SERIAL_TRANSMITTER 860 module_param(txsense, bool, 0444); 861 MODULE_PARM_DESC(txsense, "Sense of transmitter circuit (0 = active high, 1 = active low )"); 862 #endif 863 864 module_param(softcarrier, bool, 0444); 865 MODULE_PARM_DESC(softcarrier, "Software carrier (0 = off, 1 = on, default on)"); 866