drivers/media/rc/serial_ir.c

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