drivers/media/rc/serial

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

DEFINITIONS
