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 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 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 /* Needed by serial_ir_probe() */
 491 static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
 492                         unsigned int count);
 493 static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle);
 494 static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier);
 495 static int serial_ir_open(struct rc_dev *rcdev);
 496 static void serial_ir_close(struct rc_dev *rcdev);
 497
 498 static int serial_ir_probe(struct platform_device *dev)
 499 {
 500         struct rc_dev *rcdev;
 501         int i, nlow, nhigh, result;
 502
 503         rcdev = devm_rc_allocate_device(&dev->dev, RC_DRIVER_IR_RAW);
 504         if (!rcdev)
 505                 return -ENOMEM;
 506
 507         if (hardware[type].send_pulse && hardware[type].send_space)
 508                 rcdev->tx_ir = serial_ir_tx;
 509         if (hardware[type].set_send_carrier)
 510                 rcdev->s_tx_carrier = serial_ir_tx_carrier;
 511         if (hardware[type].set_duty_cycle)
 512                 rcdev->s_tx_duty_cycle = serial_ir_tx_duty_cycle;
 513
 514         switch (type) {
 515         case IR_HOMEBREW:
 516                 rcdev->input_name = "Serial IR type home-brew";
 517                 break;
 518         case IR_IRDEO:
 519                 rcdev->input_name = "Serial IR type IRdeo";
 520                 break;
 521         case IR_IRDEO_REMOTE:
 522                 rcdev->input_name = "Serial IR type IRdeo remote";
 523                 break;
 524         case IR_ANIMAX:
 525                 rcdev->input_name = "Serial IR type AnimaX";
 526                 break;
 527         case IR_IGOR:
 528                 rcdev->input_name = "Serial IR type IgorPlug";
 529                 break;
 530         }
 531
 532         rcdev->input_phys = KBUILD_MODNAME "/input0";
 533         rcdev->input_id.bustype = BUS_HOST;
 534         rcdev->input_id.vendor = 0x0001;
 535         rcdev->input_id.product = 0x0001;
 536         rcdev->input_id.version = 0x0100;
 537         rcdev->open = serial_ir_open;
 538         rcdev->close = serial_ir_close;
 539         rcdev->dev.parent = &serial_ir.pdev->dev;
 540         rcdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
 541         rcdev->driver_name = KBUILD_MODNAME;
 542         rcdev->map_name = RC_MAP_RC6_MCE;
 543         rcdev->min_timeout = 1;
 544         rcdev->timeout = IR_DEFAULT_TIMEOUT;
 545         rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
 546         rcdev->rx_resolution = 250000;
 547
 548         serial_ir.rcdev = rcdev;
 549
 550         setup_timer(&serial_ir.timeout_timer, serial_ir_timeout,
 551                     (unsigned long)&serial_ir);
 552
 553         result = devm_request_irq(&dev->dev, irq, serial_ir_irq_handler,
 554                                   share_irq ? IRQF_SHARED : 0,
 555                                   KBUILD_MODNAME, &hardware);
 556         if (result < 0) {
 557                 if (result == -EBUSY)
 558                         dev_err(&dev->dev, "IRQ %d busy\n", irq);
 559                 else if (result == -EINVAL)
 560                         dev_err(&dev->dev, "Bad irq number or handler\n");
 561                 return result;
 562         }
 563
 564         /* Reserve io region. */
 565         if ((iommap &&
 566              (devm_request_mem_region(&dev->dev, iommap, 8 << ioshift,
 567                                       KBUILD_MODNAME) == NULL)) ||
 568              (!iommap && (devm_request_region(&dev->dev, io, 8,
 569                           KBUILD_MODNAME) == NULL))) {
 570                 dev_err(&dev->dev, "port %04x already in use\n", io);
 571                 dev_warn(&dev->dev, "use 'setserial /dev/ttySX uart none'\n");
 572                 dev_warn(&dev->dev,
 573                          "or compile the serial port driver as module and\n");
 574                 dev_warn(&dev->dev, "make sure this module is loaded first\n");
 575                 return -EBUSY;
 576         }
 577
 578         result = hardware_init_port();
 579         if (result < 0)
 580                 return result;
 581
 582         /* Initialize pulse/space widths */
 583         init_timing_params(50, 38000);
 584
 585         /* If pin is high, then this must be an active low receiver. */
 586         if (sense == -1) {
 587                 /* wait 1/2 sec for the power supply */
 588                 msleep(500);
 589
 590                 /*
 591                  * probe 9 times every 0.04s, collect "votes" for
 592                  * active high/low
 593                  */
 594                 nlow = 0;
 595                 nhigh = 0;
 596                 for (i = 0; i < 9; i++) {
 597                         if (sinp(UART_MSR) & hardware[type].signal_pin)
 598                                 nlow++;
 599                         else
 600                                 nhigh++;
 601                         msleep(40);
 602                 }
 603                 sense = nlow >= nhigh ? 1 : 0;
 604                 dev_info(&dev->dev, "auto-detected active %s receiver\n",
 605                          sense ? "low" : "high");
 606         } else
 607                 dev_info(&dev->dev, "Manually using active %s receiver\n",
 608                          sense ? "low" : "high");
 609
 610         dev_dbg(&dev->dev, "Interrupt %d, port %04x obtained\n", irq, io);
 611
 612         return devm_rc_register_device(&dev->dev, rcdev);
 613 }
 614
 615 static int serial_ir_open(struct rc_dev *rcdev)
 616 {
 617         unsigned long flags;
 618
 619         /* initialize timestamp */
 620         serial_ir.lastkt = ktime_get();
 621
 622         spin_lock_irqsave(&hardware[type].lock, flags);
 623
 624         /* Set DLAB 0. */
 625         soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
 626
 627         soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
 628
 629         spin_unlock_irqrestore(&hardware[type].lock, flags);
 630
 631         return 0;
 632 }
 633
 634 static void serial_ir_close(struct rc_dev *rcdev)
 635 {
 636         unsigned long flags;
 637
 638         spin_lock_irqsave(&hardware[type].lock, flags);
 639
 640         /* Set DLAB 0. */
 641         soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
 642
 643         /* First of all, disable all interrupts */
 644         soutp(UART_IER, sinp(UART_IER) &
 645               (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
 646         spin_unlock_irqrestore(&hardware[type].lock, flags);
 647 }
 648
 649 static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
 650                         unsigned int count)
 651 {
 652         unsigned long flags;
 653         ktime_t edge;
 654         s64 delta;
 655         int i;
 656
 657         spin_lock_irqsave(&hardware[type].lock, flags);
 658         if (type == IR_IRDEO) {
 659                 /* DTR, RTS down */
 660                 on();
 661         }
 662
 663         edge = ktime_get();
 664         for (i = 0; i < count; i++) {
 665                 if (i % 2)
 666                         hardware[type].send_space();
 667                 else
 668                         hardware[type].send_pulse(txbuf[i], edge);
 669
 670                 edge = ktime_add_us(edge, txbuf[i]);
 671                 delta = ktime_us_delta(edge, ktime_get());
 672                 if (delta > 25) {
 673                         spin_unlock_irqrestore(&hardware[type].lock, flags);
 674                         usleep_range(delta - 25, delta + 25);
 675                         spin_lock_irqsave(&hardware[type].lock, flags);
 676                 } else if (delta > 0) {
 677                         udelay(delta);
 678                 }
 679         }
 680         off();
 681         spin_unlock_irqrestore(&hardware[type].lock, flags);
 682         return count;
 683 }
 684
 685 static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle)
 686 {
 687         init_timing_params(cycle, serial_ir.freq);
 688         return 0;
 689 }
 690
 691 static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier)
 692 {
 693         if (carrier > 500000 || carrier < 20000)
 694                 return -EINVAL;
 695
 696         init_timing_params(serial_ir.duty_cycle, carrier);
 697         return 0;
 698 }
 699
 700 static int serial_ir_suspend(struct platform_device *dev,
 701                              pm_message_t state)
 702 {
 703         /* Set DLAB 0. */
 704         soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
 705
 706         /* Disable all interrupts */
 707         soutp(UART_IER, sinp(UART_IER) &
 708               (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
 709
 710         /* Clear registers. */
 711         sinp(UART_LSR);
 712         sinp(UART_RX);
 713         sinp(UART_IIR);
 714         sinp(UART_MSR);
 715
 716         return 0;
 717 }
 718
 719 static int serial_ir_resume(struct platform_device *dev)
 720 {
 721         unsigned long flags;
 722         int result;
 723
 724         result = hardware_init_port();
 725         if (result < 0)
 726                 return result;
 727
 728         spin_lock_irqsave(&hardware[type].lock, flags);
 729         /* Enable Interrupt */
 730         serial_ir.lastkt = ktime_get();
 731         soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
 732         off();
 733
 734         spin_unlock_irqrestore(&hardware[type].lock, flags);
 735
 736         return 0;
 737 }
 738
 739 static struct platform_driver serial_ir_driver = {
 740         .probe          = serial_ir_probe,
 741         .suspend        = serial_ir_suspend,
 742         .resume         = serial_ir_resume,
 743         .driver         = {
 744                 .name   = "serial_ir",
 745         },
 746 };
 747
 748 static int __init serial_ir_init(void)
 749 {
 750         int result;
 751
 752         result = platform_driver_register(&serial_ir_driver);
 753         if (result)
 754                 return result;
 755
 756         serial_ir.pdev = platform_device_alloc("serial_ir", 0);
 757         if (!serial_ir.pdev) {
 758                 result = -ENOMEM;
 759                 goto exit_driver_unregister;
 760         }
 761
 762         result = platform_device_add(serial_ir.pdev);
 763         if (result)
 764                 goto exit_device_put;
 765
 766         return 0;
 767
 768 exit_device_put:
 769         platform_device_put(serial_ir.pdev);
 770 exit_driver_unregister:
 771         platform_driver_unregister(&serial_ir_driver);
 772         return result;
 773 }
 774
 775 static void serial_ir_exit(void)
 776 {
 777         platform_device_unregister(serial_ir.pdev);
 778         platform_driver_unregister(&serial_ir_driver);
 779 }
 780
 781 static int __init serial_ir_init_module(void)
 782 {
 783         int result;
 784
 785         switch (type) {
 786         case IR_HOMEBREW:
 787         case IR_IRDEO:
 788         case IR_IRDEO_REMOTE:
 789         case IR_ANIMAX:
 790         case IR_IGOR:
 791                 /* if nothing specified, use ttyS0/com1 and irq 4 */
 792                 io = io ? io : 0x3f8;
 793                 irq = irq ? irq : 4;
 794                 break;
 795         default:
 796                 return -EINVAL;
 797         }
 798         if (!softcarrier) {
 799                 switch (type) {
 800                 case IR_HOMEBREW:
 801                 case IR_IGOR:
 802                         hardware[type].set_send_carrier = false;
 803                         hardware[type].set_duty_cycle = false;
 804                         break;
 805                 }
 806         }
 807
 808         /* make sure sense is either -1, 0, or 1 */
 809         if (sense != -1)
 810                 sense = !!sense;
 811
 812         result = serial_ir_init();
 813         if (!result)
 814                 return 0;
 815
 816         serial_ir_exit();
 817         return result;
 818 }
 819
 820 static void __exit serial_ir_exit_module(void)
 821 {
 822         del_timer_sync(&serial_ir.timeout_timer);
 823         serial_ir_exit();
 824 }
 825
 826 module_init(serial_ir_init_module);
 827 module_exit(serial_ir_exit_module);
 828
 829 MODULE_DESCRIPTION("Infra-red receiver driver for serial ports.");
 830 MODULE_AUTHOR("Ralph Metzler, Trent Piepho, Ben Pfaff, Christoph Bartelmus, Andrei Tanas");
 831 MODULE_LICENSE("GPL");
 832
 833 module_param(type, int, 0444);
 834 MODULE_PARM_DESC(type, "Hardware type (0 = home-brew, 1 = IRdeo, 2 = IRdeo Remote, 3 = AnimaX, 4 = IgorPlug");
 835
 836 module_param_hw(io, int, ioport, 0444);
 837 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");
 838
 839 /* some architectures (e.g. intel xscale) have memory mapped registers */
 840 module_param_hw(iommap, ulong, other, 0444);
 841 MODULE_PARM_DESC(iommap, "physical base for memory mapped I/O (0 = no memory mapped io)");
 842
 843 /*
 844  * some architectures (e.g. intel xscale) align the 8bit serial registers
 845  * on 32bit word boundaries.
 846  * See linux-kernel/drivers/tty/serial/8250/8250.c serial_in()/out()
 847  */
 848 module_param_hw(ioshift, int, other, 0444);
 849 MODULE_PARM_DESC(ioshift, "shift I/O register offset (0 = no shift)");
 850
 851 module_param_hw(irq, int, irq, 0444);
 852 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");
 853
 854 module_param_hw(share_irq, bool, other, 0444);
 855 MODULE_PARM_DESC(share_irq, "Share interrupts (0 = off, 1 = on)");
 856
 857 module_param(sense, int, 0444);
 858 MODULE_PARM_DESC(sense, "Override autodetection of IR receiver circuit (0 = active high, 1 = active low )");
 859
 860 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
 861 module_param(txsense, bool, 0444);
 862 MODULE_PARM_DESC(txsense, "Sense of transmitter circuit (0 = active high, 1 = active low )");
 863 #endif
 864
 865 module_param(softcarrier, bool, 0444);
 866 MODULE_PARM_DESC(softcarrier, "Software carrier (0 = off, 1 = on, default on)");