drivers/media/rc/serial_ir.c

   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)");