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